---
title: "フィジカルAI研究室を作る Log#37 | mechArm 270 のお手本、角度の抜けを11か所から3か所に"
slug: mecharm-270-demo-angle-gaps-11-to-3
date: 2026-11-15
day: 514
meta_description: "小型ロボットアーム mechArm 270 で π0.5 用のお手本を撮るとき、角度を1秒以上読めない抜けは11か所から3か所に減った。ただ、送った直後に角度を読む形では、送信が1回無視されてアームが19秒止まった。"
tags: [フィジカルAI研究室, mechArm 270, π0.5, Physical Intelligence, データの質, お手本, 手教示, Claude Code]
series: "フィジカルAI研究室"
---

**小型ロボットアーム mechArm 270 で Physical Intelligence の π0.5 に学ばせるお手本を撮るとき、関節の角度を1秒以上読めない抜けは、1本あたり11か所から3か所に減った。** 残った3か所は爪を動かしている間で、アームは止まっています。ただ、送った直後にも角度を読む形にしたら、実機の2本目で送信が1回無視され、アームが19秒止まりました。そのため、原因が分かるまでは、お手本を抜けの残る形で撮ることにしました。

この回の作業で、次のことが変わりました。

- お手本の角度の記録が細かくなった：角度を読めた間隔の中央値は、0.32秒から0.12秒になった（同じ教えた記録・同じ位置で比べた実機の本）。前の回で「動いた量の半分ほどが、測った値ではなく補った値」だった原因のうち、読み取りの粗さを埋めた
- 動いている最中の1秒も読めるようになった：送ったあとの1秒を Mac で待つ形（案2）にすると、1秒を超える抜けは11か所から3か所になった。アームの動きそのもの（送る角度・速さ・待つ長さ）は変えていない
- 引き換えに、送信が無視される危うさが見つかった：手で教えた記録の再生111本のうち、送ったあとにまったく動かなかった（0.00°）のは案2の1本だけ。ぶつかりはせず、もとからある再送の決まりで動き直した
- 費用はかかっていない：この回は実機とコードだけで、クラウドの GPU は使っていない

前の回（[LOG512](https://pixelstomotors.com/record/mecharm-270-demo-data-half-motion-interpolated)）で、手で教えたお手本は角度を0.32秒おきにしか読めておらず、アームが動いた量の56〜59%が、角度を読まない「送ったあとの1秒」の中にあると分かっていました。学習に入る角度の多くが、前後の実測を直線で結んだ値になっていた、ということです。直し方の案は2つありました。案1は、すでに読んでいるのに捨てていた角度を書き残すこと。案2は、送ったあとの1秒の待ちを Pi の中から Mac に移し、その間も読むことです。

| やったこと | なぜ | 結果 |
|---|---|---|
| 案1：電流の記録が読んでいた角度も、お手本の記録に書く（依頼202） | 待ちの間に読んでいた角度を捨てていた | 間隔の中央値 0.32 → 0.12秒。1秒を超える抜けは11のまま |
| 案1を実機で2本 | 動きが変わっていないかを確かめる | 送信の往復・静止の確かめ・再送は前と同じ |
| 案2：送ったあとの1秒を Mac で待ち、その間も読む（依頼213） | 動いている最中の1秒が抜けていた | 1秒を超える抜け 11 → 3 |
| 案2を実機で2本 | 動きが変わっていないかを確かめる | 1本目は問題なし。2本目は送信が無視され、19秒止まってから再送で動いた |
| 当面のお手本は案1の形で撮る。原因を調べる依頼を出した（依頼215） | 送信の無視は、案1の形では一度も起きていない | 案1の形で撮った1本は、つかんで箱に入れ、再送0 |

試しの記録と、この回に使った材料（依頼文・報告・差分・比べた表・ターミナルの全文・この回の終わりのコード）は KIOXIA の `lab/Log37/` に入れています。

GPU を買うか借りるかの判断は、Runpod で実際に借りて学習させた費用をもとに、別のページにまとめています。この回で直したお手本も、その借り方で学習させる予定です。

【バナー】gpu-buy-or-rent

【図解】LOG514_angle_read_timeline.html


## 作業ログ ― 角度の抜けを2つの案で埋め、案2で送信が無視されるまで

ここから下は作業の記録です。依頼文・報告・コードの差分・ターミナルの出力は全量で載せます。効果を書いた所のうち、数字で書いたものは実機で測った値、「見込み」と書いたものはまだ確かめていない値です。

この回で何度も出てくる言葉を先に言い換えておきます。

- π0.5：[Physical Intelligence](https://www.pi.website/blog/pi05) が公開しているロボット用の AI。上カメラの画像と関節の角度を見て、次の動きを出す
- お手本：π0.5 に学ばせるための、アームを動かした記録。この回で扱うのは、手で教えた要所の姿勢を再生して撮る「手教示」のお手本
- `states.csv`：お手本1本の、関節の角度を読めた時刻と値の記録。`actual` の行が、実際に読めた角度
- daemon：アームの中の Raspberry Pi で動いている、命令を受けてアームへ送る常駐のプログラム。Mac はこれに角度を送り、角度を読む
- 送ったあとの1秒：角度を送ったあと、daemon が1.0秒眠ってから返事をする決まり（`SENDWAIT 1.0`）。この間はほかの命令を受けないので、角度も読めない。「短くしない」と前から決めている
- 電流の記録：爪と肩のモーターの電流を、本体が眠っている間だけ読んで残す仕組み（`CurrentsRecorder`）。電流を読む命令 `read_servo` は、同時に角度も返す
- 再送：送ったのにアームが1°も動かなかったとき、5秒待って同じ角度をもう一度だけ送る決まり
- 依頼箱：Claude Code への依頼をファイルで置いておく Mac のフォルダ。置くと見張り係が順に Claude Code に渡し、結果を書き戻す
- [Claude Code](https://www.anthropic.com/claude-code)：Anthropic の、コードを書いて動かす AI。この回のコードはすべて依頼箱から Claude Code が書いた



## 依頼202（案1）：電流の記録が読んだ角度を、お手本の記録にも書く

前の回の調べで、手教示の記録は、到達の確かめのついでに角度を読んでいるだけでした。到達の確かめは「角度を1回読む → 0.3秒眠る」を繰り返すので、0.32秒おきになります。一方、電流の記録はその0.3秒の間に `read_servo` で角度も受け取っていましたが、電流だけを残して角度は捨てていました。案1は、捨てていた角度を書き残すだけで、アームへの命令は何も変えません。

読む命令を、角度だけの `get_angles` に替えるか、電流も読める今の `read_servo` のままにするかは、決まっていませんでした。π0.5 のお手本に電流を足す計画があるので、電流も残る `read_servo` のままにしました。

### 依頼202 の依頼文

```markdown
---
作業フォルダ: /Users/shimazueiichi/r2r2r-scripts
上限時間: 90
---
# 依頼202：手教示の記録（states.csv）に、電流の記録スレッドが読んだ角度も actual として書く（依頼197 の案1）

実機は動かさない（実装・テスト・レビューまで）。Pi にもつながない（テストは偽の daemon で）。Log37。

## なぜ
依頼197 の調べで、手教示の記録の実測角は到達の確かめに相乗りして 0.32 秒おきにしか読めていない。一方、電流の記録スレッド（pi05/policy_recorder.py の CurrentsRecorder）は寝ている間に read_servo で角度も読んでいる（11/9 の1本で中央値 0.16 秒おき）が、その角度は states.csv に書いていない。エイイチの決め（LOG512）：案1から作り、実機で1本→5本で確かめ、そのあとで案2を決める。

## やること
1. CurrentsRecorder が read_servo で読んだ角度を、手教示の記録（record_teach_demo.py の _Recorder）に actual 行として渡す口を足す。読む命令は read_servo のまま（電流の記録は今のまま残す）
2. 足した行は、本体の到達の確かめで読んだ行と区別できるようにする（例：列 source に current_thread / arrival_poll。列を足すなら、既存の読み手（学習データ作り・diag_fill_flags.py・依頼196 の state_source）が壊れないことを確かめる。壊れるなら列は足さず、別ファイルに分ける案を報告で止める）
3. 時刻は読んだ時刻（返ってきた時刻）で書き、行は時刻順に並ぶようにする
4. 本体の送信・到達の確かめ・静止の確かめ・爪の前後の止め方・待つ長さ（SENDWAIT 1.0・ARRIVAL_POLL_SLEEP 0.3・爪の待ち）は変えない。電流スレッドが読む時機（寝ている間だけ）も変えない
5. 実機での確かめ手順を報告に書く（HOME の近くで1本 → states.csv の actual の間隔の中央値・90%点、試行 JSON の segments の到達時間・still_check の回数が直す前の本と同じ形か）。比べるための数えるスクリプトも用意する（KIOXIA の diag/teach_state_rate_20261115/ のものを使い回してよい）
6. テストを足し、既存のテスト（pi05/ と test_lab_start.sh）も通す。codex で差分を見てもらい、直して通るまで
7. 変えたファイルだけを指定して git add・commit（git add . と git clean は使わない）

## 報告
変えた所、states.csv の行の例（直す前と後）、実機で確かめるコマンド、決めてほしいこと
```

### 依頼202 で Claude Code が返した報告

```markdown
# 結果：20261115_202_手教示の記録に電流スレッドの角度も書く

- 状態：完了
- 始めた時刻：2026-11-15 09:04
- 終わった時刻：2026-11-15 09:51（48分）
- 作業フォルダ：/Users/shimazueiichi/r2r2r-scripts
- この続きを Claude Code で話すとき：作業フォルダで `claude --resume 61867303-ae75-49d0-908d-2d3bbc2302e1`

## Claude Code の報告

やったこと／結果／変えたファイル／決めてほしいこと

**やったこと**
- 電流の記録スレッドが read_servo で読んだ角度を、states.csv の actual 行としても書くようにしました。読む命令と読む時機（本体が眠っている間だけ）は変えていません。
- 列は足していません。もとからある `note` 列に `source=current_thread` を入れて区別します。本体が読んだ行は `note` が空のままです。
  - 既存の読み手（build_demo_episodes の load_states、依頼196 の state_source を作る gap_fill_flags、diag_fill_flags、diag_joint_hold）は、actual 行の `note` を見ていないことを確かめました。
- 時刻は角度を読んだ時刻で、currents.csv の ts と同じです。
- 行が時刻順に並ぶように、stage・actual・gripper_cmd と電流スレッドの角度を 1 つの鍵の中で列に積み、専用の送り手スレッドが積んだ順に送ります。鍵の中では送らないので、本体も電流スレッドも送信を待ちません。
  - 先に積んだ行より前の時刻の角度は積まずに数えます。
  - 送り切れないまま閉じたときは、trial_end も列の最後に積むので、行が trial_end を追い越しません。
- 本体の送信・到達の確かめ・静止の確かめ・爪の前後の止め方・待つ長さは変えていません。
- 比べるためのスクリプト pi05/teach_state_rate.py を作りました（KIOXIA の measure_gaps.py の数え方を使い回し、読むだけ）。
- codex には 4 回見てもらい、4 回目で必須の指摘はなくなりました。
  - 1 回目：送信を鍵の中でしない形に直しました。
  - 2・3 回目：trial_end を追い越さない形に直しました。

**結果**
- 偽の daemon での actual の間隔：中央値 0.333 → 0.105 秒、ポーリングの間 0.332 → 0.104 秒。90% 点は 1.63 秒のままです（送信の待ちの間は今も読まないため）。
- 角度を渡さない再生と比べて、次は同じでした：関節と爪の命令の順と中身、get_angles の回数、到達と静止の確かめの結果、見込み超え 0。
- states.csv の行の例：
  - 直す前（11/9 の本）：`1794185321.152368,actual,HOME_START,-0.260,1.230,1.490,-0.260,0.000,-29.880,,,,,,,`
  - 直した後（偽の daemon）：
    - `…430.730318,actual,HOME_START,0.000,0.000,0.000,0.000,0.000,-30.000,,,,,,,`（本体の読み）
    - `…430.752837,actual,HOME_START,0.000,0.000,0.000,0.000,0.000,-30.000,,,,,,,source=current_thread`
- テスト：
  - 新しいテスト 22 件と test_teach_currents 27 件は OK、test_lab_start.sh は 237 件 OK です。
  - pi05/ では test_state_source だけが落ちます。git の HEAD と今のファイルを比べる作りで、依頼196 がコミット済みのため、今回の変更と関係なく必ず落ちます。今回そのファイルには触っていません。
- コミット：c68ba07

**実機で確かめる手順**
1. HOME の近くで、いつもの手教示を 1 本撮ります（`record_teach_demo.py run --teach … --execute`）。
2. 直す前の本と並べます：
   `python3 pi05/teach_state_rate.py --before run_0001_20261109_094839 run_0001_20261109_095308 --after <新しい run>`
3. 次を見ます：
   - actual の間隔の中央値・90% 点（全部と本体だけ）
   - 逆順が 0 か、見込み超えが 0 か
   - 区間ごとの送信の往復と区間の長さ、静止の確かめの reads
4. よければ 5 本撮って `--out` を付け、KIOXIA に CSV を残します。

**変えたファイル**
- pi05/policy_recorder.py（今回の 3 か所だけをコミットしました。依頼156 の未コミットの変更は作業ツリーにそのまま残っています）
- dynamic_tracking_limits/drag_teaching/record_teach_demo.py（これまでどおり git の外です。直す前の写しは record_teach_demo.py.bak_pre_req202_20261115）
- pi05/teach_state_rate.py（新規）
- pi05/test_teach_current_actuals.py（新規）
- pi05/test_teach_currents.py（cmd_run の書き方を文字列で確かめる 2 か所を、今の呼び方に合わせました）
- logs/20261115_0951.md（作業記録）

**決めてほしいこと**
1. 時刻の取り方：依頼文の「返ってきた時刻」ではなく、daemon の中で角度を読み終えた時刻にしました。番地を読む分の 60〜80 ms 前になり、currents.csv の ts と同じ値です。返事が届いた時刻にそろえたほうがよければ直します。
2. 実機で確かめる時機（1 本 → 5 本）と、その前に Pi の daemon が 11/5 版かを確かめるかどうか。
3. codex 4 回目の推奨で、見送ったもの：既存の `recorder_send_failures` を試行 JSON に写す時機を trial_end の後に動かすと、trial_end の失敗も数えるようになり、欄の意味が変わります。それでよければ直します。
4. test_state_source は今の作りでは必ず落ちます。比べる相手を直すかどうか（今回の範囲の外です）。
```

報告の「決めてほしいこと」には、次のように答えました。時刻は、電流の記録と同じ「daemon が角度を読み終えた時刻」のままにしました。見送った推奨の直し（失敗の数え方の意味が変わるもの）と、前から必ず落ちるテスト（`test_state_source`）は、今は触らないことにしました。

### 依頼202 のコードの差分（コミット c68ba07）

```diff
commit c68ba076d3f88772b68cbcb2f8a7e3876eb9f931
Author: Eiichi Shimazu <studio@adaptdesign.jp>
Date:   Sun Nov 15 09:51:18 2026 +0900

    手教示の記録 (states.csv) に, 電流の記録スレッドが read_servo で読んだ角度も actual 行として書く (依頼 202・依頼 197 の案 1・Log37)
    
    policy_recorder.CurrentsRecorder に angle_sink を足し, 読めた回だけ (角度, 角度を読んだ時刻 = currents.csv の ts) を渡す.
    読む命令 (read_servo)・読む時機 (本体が眠っている間だけ)・電流の記録は変えない. 渡す側の例外は loop_errors に数えて続ける.
    record_teach_demo.py (git の外) の _Recorder に start_current_actuals / actual_from_currents / close_current_actuals と送り手の
    スレッドを足した. 列は足さず note 列を source=current_thread にする (本体の読みは note が空のまま). 行を時刻順に保つため,
    stage・actual・gripper_cmd・電流スレッドの角度を 1 つの鍵の中で列に積み, 送り手が積んだ順に送る (鍵の中では送らない.
    本体も電流スレッドも送信を待たない). 先に積んだ行より前の時刻の電流スレッドの角度は積まずに数える. 送り切れないまま閉じても
    trial_end を列の最後に積んで追い越さない. 試行 JSON に送った数・積まなかった数・時計が戻った数などを残す.
    本体の送信・到達と静止の確かめ・爪の前後の止め方・待つ長さは変えない (偽の daemon で関節と爪の命令・get_angles の回数・
    到達と静止の確かめの結果が角度を渡さない再生と同じ). 偽の daemon で actual の間の中央値 0.333 → 0.105 秒.
    pi05/teach_state_rate.py: 直す前と後の本の actual の間隔 (全部・本体だけ・電流スレッドだけ・原因ごと) と試行 JSON の segments
    を並べる (読むだけ. --out で KIOXIA に CSV). テスト test_teach_current_actuals 22 件. test_teach_currents は cmd_run の
    書き方の確かめを今の呼び方に合わせた. pi05 のテストは test_state_source (HEAD と比べる作りで依頼 196 のコミット後は必ず落ちる.
    今回は触っていない) のほかは OK, test_lab_start.sh 237 OK. codex 4 回 (4 回目で必須なし)
    
    Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

diff --git a/pi05/policy_recorder.py b/pi05/policy_recorder.py
index b68ade9..02840a1 100644
--- a/pi05/policy_recorder.py
+++ b/pi05/policy_recorder.py
@@ -544,7 +544,9 @@ class CurrentsRecorder(_ServoCurrents):
       - pause() から resume() までは window があっても読まない (爪の命令と待ち・再送の前の待ち.
         「爪を動かした直後にシリアルを触らない」(2026-10-19))
       - states.csv・top.mp4 は今までどおり recorder.py (別のプロセス) が書く. ここは currents.csv と
-        currents_meta.json だけを書く (read_servo で読んだ角度は ts を決めるのに使い, どこにも書かない)
+        currents_meta.json だけを書く. read_servo で読んだ角度は ts を決めるのに使い, angle_sink があれば
+        angle_sink(角度, 読んだ時刻) で渡す (依頼 202: record_teach_demo が states.csv の actual 行にする.
+        渡すのは読めた回だけ. 読み方・読む時機は変えない. 渡す側の失敗は loop_errors に数えて続ける)
       - daemon に read_servo がなければ (unknown cmd) 読むのをやめる (currents.csv は列名だけ)
     記録の失敗で再生を止めない (例外は外へ出さない. stop()・pause() は書き込みで止まったスレッドを待ち続けない).
     daemon のソケットは本体と共用なので, 使う前に install_daemon_lock() を呼ぶこと.
@@ -558,6 +560,7 @@ class CurrentsRecorder(_ServoCurrents):
         self.read_servo_fn = read_servo_fn
         self.read_angles_fn = lambda: None
         self.angles_ok = None
+        self.angle_sink = None          # 依頼 202: 読めた角度を渡す先 (角度, 読んだ時刻). None なら渡さない
         self.currents_mode = "read_servo"
         self.n_reads = 0
         self.n_currents = 0
@@ -716,7 +719,9 @@ class CurrentsRecorder(_ServoCurrents):
                 self.next_at = t0 + ANGLE_INTERVAL
                 n_before = len(self.read_ms)
                 try:
-                    self._read_once()
+                    a, ts = self._read_once()
+                    if a is not None and self.angle_sink is not None:
+                        self.angle_sink(a, ts)      # 依頼 202: states.csv の actual 行へ
                 except Exception as e:      # 記録の失敗で再生を止めない
                     self.loop_errors += 1
                     if self.loop_errors <= 3:
diff --git a/pi05/teach_state_rate.py b/pi05/teach_state_rate.py
new file mode 100644
index 0000000..5020526
--- /dev/null
+++ b/pi05/teach_state_rate.py
@@ -0,0 +1,263 @@
+#!/usr/bin/env python3
+"""teach_state_rate.py — 手教示の記録 (record_teach_demo.py run --execute) の実測角の間隔を, 直す前と後の本で並べる
+(2026-11-15 依頼 202. 数え方は依頼 197 の KIOXIA diag/teach_state_rate_20261115/measure_gaps.py と同じ).
+
+依頼 202 で, 電流の記録スレッド (read_servo) が読んだ角度も states.csv の actual 行に書くようにした
+(note 列が source=current_thread. 本体の読み = 到達・静止の確かめなどは note が空のまま). 実機で 1 本 → 5 本撮って,
+  - states.csv の actual の間隔 (全部・本体の読みだけ・電流スレッドの読みだけ) の中央値・90% 点・1 秒超
+  - 間の原因ごと (poll = 到達・静止の確かめの間 / send = 送信の待ち / gripper = 爪の待ち / stage_change)
+  - 試行 JSON の segments: 動く区間ごとの送信の往復 (send_rtt_sec)・区間の長さ (segment_elapsed_sec)・再送・着いたか,
+    爪の前の静止の確かめ (still_check の reads・elapsed_sec・still)
+が直す前の本と同じ形かを見る. 合否の線は決めていない (表を出すだけ).
+
+入力: {runs_root}/{run}/{run}.json と {run}/recording/states.csv (runs_root の既定は KIOXIA の runs/run_pick_place)
+  python3 pi05/teach_state_rate.py --before run_0001_20261109_094839 run_0001_20261109_095308 --after run_0001_20261116_...
+  python3 pi05/teach_state_rate.py --after /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261116_...   # フォルダでも
+  python3 pi05/teach_state_rate.py --before ... --after ... --out    # CSV も残す
+--out のときだけ書く: /Volumes/KIOXIA/r2r2r-data/runs/experiments/teach_state_rate/{YYYYMMDD_HHMMSS}/
+  runs.csv (本ごと)・segments.csv (区間ごと). KIOXIA がなければ止まる. 出し先がもうあれば止まる. run の記録には何も書かない.
+"""
+import argparse
+import csv
+import json
+import os
+import statistics
+import sys
+from datetime import datetime
+from pathlib import Path
+
+KIOXIA_MOUNT = Path("/Volumes/KIOXIA")
+DATA_ROOT = KIOXIA_MOUNT / "r2r2r-data"
+RUNS_ROOT = DATA_ROOT / "runs" / "run_pick_place"
+OUT_ROOT = DATA_ROOT / "runs" / "experiments" / "teach_state_rate"
+CURRENT_THREAD_NOTE = "source=current_thread"   # record_teach_demo.CURRENT_THREAD_NOTE と同じ
+LONG = 1.0
+
+
+def ensure_ssd_mounted():
+    """KIOXIA がマウントされていて書けるか. だめなら止める (ローカルへは書かない)."""
+    if not os.path.ismount(str(KIOXIA_MOUNT)):
+        sys.exit(f"[ABORT] KIOXIA がマウントされていません: {KIOXIA_MOUNT}")
+    if not DATA_ROOT.is_dir():
+        sys.exit(f"[ABORT] {DATA_ROOT} がありません")
+
+
+def run_dir(arg, runs_root):
+    p = Path(arg)
+    return p if p.is_dir() else Path(runs_root) / arg
+
+
+def load_states(path):
+    rows = []
+    with Path(path).open(newline="") as f:
+        for r in csv.DictReader(f):
+            try:
+                r["ts"] = float(r["ts"])
+            except (KeyError, TypeError, ValueError):
+                continue
+            rows.append(r)
+    return rows
+
+
+def is_actual(r):
+    return r.get("event_type") == "actual" and (r.get("j0") or "") != ""
+
+
+def source_of(r):
+    return "current_thread" if CURRENT_THREAD_NOTE in (r.get("note") or "").split() else "main"
+
+
+def classify(rows):
+    """actual の間ごとに原因を決める (依頼 197 の measure_gaps.classify と同じ決め方. 手教示の形).
+    rows は states.csv の行 (stage・gripper_cmd も入ったまま)."""
+    acts = [i for i, r in enumerate(rows) if is_actual(r)]
+    out = []
+    for a, b in zip(acts, acts[1:]):
+        types = [m.get("event_type") for m in rows[a + 1:b]]
+        prev = rows[a - 1].get("event_type") if a > 0 else ""
+        if "gripper_cmd" in types or "gripper" in types:
+            cause = "gripper"
+        elif "commanded" in types or prev == "stage":
+            cause = "send"          # record_teach_demo: stage → 送信前の読み → 送信 (wait=1.0)
+        elif "stage" in types:
+            cause = "stage_change"
+        else:
+            cause = "poll"
+        out.append({"t0": rows[a]["ts"], "t1": rows[b]["ts"], "gap": rows[b]["ts"] - rows[a]["ts"],
+                    "stage": rows[a].get("stage"), "cause": cause})
+    return out
+
+
+def pct(v, p):
+    if not v:
+        return None
+    ys = sorted(v)
+    k = (len(ys) - 1) * p / 100.0
+    lo = int(k)
+    hi = min(lo + 1, len(ys) - 1)
+    return ys[lo] + (ys[hi] - ys[lo]) * (k - lo)
+
+
+def gap_stats(gaps):
+    v = [g["gap"] for g in gaps]
+    tot = sum(v)
+    lv = [x for x in v if x > LONG]
+    return {"n": len(v), "median": pct(v, 50), "p90": pct(v, 90), "max": max(v) if v else None,
+            "long_n": len(lv), "long_share": (sum(lv) / tot) if tot > 0 else None}
+
+
+def order_ok(rows):
+    """states.csv の行が時刻順に並んでいるか (依頼 202). 逆になった所の数."""
+    return sum(1 for a, b in zip(rows, rows[1:]) if b["ts"] < a["ts"])
+
+
+def measure(d):
+    """1 本の値 (dict) と区間ごとの行 (list)."""
+    d = Path(d)
+    name = d.name
+    rows = load_states(d / "recording" / "states.csv")
+    acts = [r for r in rows if is_actual(r)]
+    main_rows = [r for r in rows if not (is_actual(r) and source_of(r) == "current_thread")]
+    g_all = classify(rows)
+    g_main = classify(main_rows)
+    cur_ts = [r["ts"] for r in acts if source_of(r) == "current_thread"]
+    g_cur = [{"gap": b - a} for a, b in zip(cur_ts, cur_ts[1:])]
+    out = {"run": name, "n_actual": len(acts), "n_main": len(acts) - len(cur_ts), "n_current_thread": len(cur_ts),
+           "order_reversed": order_ok(rows)}
+    for key, g in (("all", g_all), ("main", g_main), ("cur", g_cur)):
+        s = gap_stats(g)
+        for k, v in s.items():
+            out[f"{key}_{k}"] = v
+    for cause in ("poll", "send", "gripper"):
+        s = gap_stats([g for g in g_all if g["cause"] == cause])
+        out[f"all_{cause}_median"], out[f"all_{cause}_max"] = s["median"], s["max"]
+    try:
+        j = json.loads((d / f"{name}.json").read_text())
+    except Exception as e:
+        j = {}
+        out["json_error"] = f"{type(e).__name__}"
+    cur = j.get("currents") or {}
+    out.update({"result": j.get("result"), "overruns": cur.get("overruns"),
+                "sent_current_thread": j.get("recorder_actual_events_sent_current_thread"),
+                "late_current_thread": j.get("recorder_actual_current_thread_late"),
+                "actual_sampling_reads_ok": (j.get("actual_sampling") or {}).get("reads_ok")})
+    segs = []
+    for g in j.get("segments") or []:
+        sc = g.get("still_check") or {}
+        segs.append({"run": name, "step": g.get("step"), "kind": g.get("kind"),
+                     "name": g.get("to_name") if g.get("kind") == "move" else g.get("action"),
+                     "send_rtt_sec": g.get("send_rtt_sec"), "segment_elapsed_sec": g.get("segment_elapsed_sec"),
+                     "retried": g.get("retried"), "arrival_ok": g.get("arrival_ok"),
+                     "still_reads": sc.get("reads"), "still_elapsed_sec": sc.get("elapsed_sec"),
+                     "still": sc.get("still")})
+    out["still_reads_total"] = sum(s["still_reads"] or 0 for s in segs)
+    out["retried_n"] = sum(1 for s in segs if s["retried"])
+    return out, segs
+
+
+def fmt(v, nd=3):
+    if v is None:
+        return "-"
+    if isinstance(v, float):
+        return f"{v:.{nd}f}"
+    return str(v)
+
+
+RUN_COLS = [("run", "run"), ("n_actual", "actual"), ("n_current_thread", "うち電流"), ("all_median", "間 中央"),
+            ("all_p90", "90%"), ("all_long_n", "1秒超"), ("all_poll_median", "poll中央"), ("all_send_median", "send中央"),
+            ("main_median", "本体だけ中央"), ("main_p90", "本体90%"), ("cur_median", "電流だけ中央"),
+            ("order_reversed", "逆順"), ("late_current_thread", "送らず"), ("overruns", "見込み超え"),
+            ("still_reads_total", "静止reads"), ("retried_n", "再送"), ("result", "結果")]
+
+
+def print_group(label, ms):
+    print(f"\n## {label} ({len(ms)} 本)")
+    print("  " + " | ".join(h for _, h in RUN_COLS))
+    for m in ms:
+        print("  " + " | ".join(fmt(m.get(k)) for k, _ in RUN_COLS))
+    if len(ms) > 1:
+        def med(k):
+            v = [m[k] for m in ms if isinstance(m.get(k), (int, float))]
+            return statistics.median(v) if v else None
+        print("  (本ごとの中央値) " + " | ".join(
+            f"{h} {fmt(med(k))}" for k, h in RUN_COLS[1:] if k not in ("result",)))
+
+
+def print_segments(groups):
+    """区間ごと (step 順) に, 群ごとの中央値を並べる. 区間の並びが群で違えば step の名前で分かる."""
+    print("\n## 区間ごと (群ごとの中央値: 送信の往復 / 区間の長さ / 静止の確かめの reads)")
+    keys = []
+    for _, segs in groups:
+        for s in segs:
+            k = (s["step"], s["kind"], s["name"])
+            if k not in keys:
+                keys.append(k)
+    for k in sorted(keys, key=lambda x: (x[0] is None, x[0] or 0)):
+        cells = []
+        for label, segs in groups:
+            ss = [s for s in segs if (s["step"], s["kind"], s["name"]) == k]
+
+            def med(f):
+                v = [s[f] for s in ss if isinstance(s.get(f), (int, float)) and not isinstance(s.get(f), bool)]
+                return statistics.median(v) if v else None
+            cells.append(f"{label}: n={len(ss)} rtt {fmt(med('send_rtt_sec'))} 長さ {fmt(med('segment_elapsed_sec'))}"
+                         f" reads {fmt(med('still_reads'))}")
+        print(f"  step {k[0]} {k[1]} {k[2]}  " + "  /  ".join(cells))
+
+
+def write_out(results, segs_all):
+    ensure_ssd_mounted()
+    out = OUT_ROOT / datetime.now().strftime("%Y%m%d_%H%M%S")
+    if out.exists():
+        sys.exit(f"[ABORT] 出し先がもうあります: {out}")
+    out.mkdir(parents=True)
+    cols = sorted({k for r in results for k in r})
+    cols = ["group"] + [c for c in cols if c != "group"]
+    with (out / "runs.csv").open("w", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=cols)
+        w.writeheader()
+        w.writerows(results)
+    if segs_all:
+        with (out / "segments.csv").open("w", newline="") as f:
+            w = csv.DictWriter(f, fieldnames=list(segs_all[0].keys()))
+            w.writeheader()
+            w.writerows(segs_all)
+    print(f"\n→ {out}")
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(description="手教示の記録の実測角の間隔を直す前と後で並べる (依頼 202)")
+    ap.add_argument("--before", nargs="*", default=[], help="直す前の run (名前かフォルダ)")
+    ap.add_argument("--after", nargs="*", default=[], help="直したあとの run (名前かフォルダ)")
+    ap.add_argument("--runs-root", default=str(RUNS_ROOT))
+    ap.add_argument("--out", action="store_true", help="KIOXIA の runs/experiments/teach_state_rate/ に CSV も残す")
+    a = ap.parse_args(argv)
+    if not a.before and not a.after:
+        ap.error("--before か --after に run を 1 本以上")
+    results, groups, segs_all = [], [], []
+    for label, names in (("before", a.before), ("after", a.after)):
+        if not names:
+            continue
+        ms, ss = [], []
+        for n in names:
+            d = run_dir(n, a.runs_root)
+            if not (d / "recording" / "states.csv").exists():
+                sys.exit(f"[ABORT] states.csv がありません: {d}")
+            m, segs = measure(d)
+            m["group"] = label
+            for s in segs:
+                s["group"] = label
+            ms.append(m)
+            ss += segs
+        print_group(label, ms)
+        results += ms
+        groups.append((label, ss))
+        segs_all += ss
+    print_segments(groups)
+    if a.out:
+        write_out(results, segs_all)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/pi05/test_teach_current_actuals.py b/pi05/test_teach_current_actuals.py
new file mode 100644
index 0000000..47540d1
--- /dev/null
+++ b/pi05/test_teach_current_actuals.py
@@ -0,0 +1,413 @@
+#!/usr/bin/env python3
+"""test_teach_current_actuals.py — 手教示の記録 (states.csv) に電流の記録スレッドが読んだ角度も actual 行として書く形
+(依頼 202. 依頼 197 の案 1) を偽の daemon で確かめる (アームなし・Pi なし. 2026-11-15).
+
+  python3 pi05/test_teach_current_actuals.py          # 全部 (再生を 2 回通すので 1 分ほど)
+  python3 pi05/test_teach_current_actuals.py -v
+
+偽の daemon は test_teach_currents.ArmDaemon (依頼 121) で, read_servo の角度だけ腕の今の角度にする (元は固定の値).
+再生は cmd_run と同じ順 (install_daemon_lock → start_current_actuals → _start_currents(angle_sink=
+recorder.actual_from_currents) → _replay → stop → close_current_actuals). recorder.py へ送る通知を集め, recorder.py の TrialWriter.write_state で states.csv にする.
+
+確かめること:
+  - 電流スレッドが読めた角度が actual 行 (note = source=current_thread) になり, 時刻は currents.csv の ts と同じ
+  - 本体の通知 (stage・本体の actual・gripper_cmd) と本体が daemon に送る命令は, 角度を渡さない再生と同じ
+    (到達・静止の確かめの結果と回数・関節と爪の命令の順と中身)
+  - states.csv の行は時刻順. 爪の命令から待ちの終わりまで電流スレッドの actual 行はない
+  - 既存の読み手が壊れない: build_demo_episodes.load_states・build_correction_episodes.gap_fill_flags
+    (依頼 196 の state_source)・teach_state_rate.py (数えるスクリプト)
+  - _Recorder: 先に積んだ行より前の時刻は積まずに数える・close_current_actuals のあとは積まない・壊れた値は数える.
+    送信が止まっても本体の通知と電流スレッドは待たない (codex R1)・送り切れない分は数える・時計が戻った行は数える (R2).
+    送り切れないまま閉じても積んだ行は trial_end を追い越さない (trial_end も列の最後に積む. codex 2・3 回目 R1)
+    start_current_actuals を呼ばなければ今までどおりその場で送る
+  - CurrentsRecorder: angle_sink が例外を出しても読み取りは続く (loop_errors に数える)・読めない角度は渡さない
+KIOXIA にもアームにも触らない (一時フォルダと 127.0.0.1 だけ).
+"""
+import csv
+import importlib.util
+import io
+import sys
+import tempfile
+import threading
+import time
+import unittest
+from pathlib import Path
+from unittest import mock
+
+_HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(_HERE))
+sys.path.insert(0, str(_HERE.parent / "dynamic_tracking_limits" / "drag_teaching"))
+
+import test_teach_currents as ttc  # noqa: E402  (ArmDaemon・WAYPOINTS. 偽の daemon と run_policy_client のスタブ)
+import test_recorder_currents as trc  # noqa: E402
+import policy_recorder as pr  # noqa: E402
+import visual_servo_pick as vsp  # noqa: E402
+import record_teach_demo as rtd  # noqa: E402
+import build_demo_episodes as bde  # noqa: E402
+import build_correction_episodes as bce  # noqa: E402
+import teach_state_rate as tsr  # noqa: E402
+
+_spec = importlib.util.spec_from_file_location(
+    "recorder_for_test", str(_HERE.parent / "dynamic_tracking_limits" / "place" / "place_modules" / "recorder.py"))
+reco = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(reco)
+
+NOTE = rtd.CURRENT_THREAD_NOTE
+
+
+class PoseDaemon(ttc.ArmDaemon):
+    """read_servo の角度を腕の今の角度にする (states.csv に書かれる角度が動きに沿うか見るため)."""
+
+    def _handle(self, c):
+        resp = super()._handle(c)
+        if c.get("cmd") == "read_servo" and isinstance(resp, dict) and "angles" in (resp.get("items") or {}):
+            resp["items"]["angles"]["value"] = self.pose()
+        return resp
+
+
+def replay(daemon, run_dir, sink=True):
+    """cmd_run と同じ順で再生を 1 回通す. 戻り値: (result, 通知, log_record, recorder)."""
+    sent = []
+    vsp.close_daemon_socket()
+    log_record = {"current_angles_before_replay": list(rtd.HOME_ANGLES)}
+    seq = rtd.wpsr._build_segments(ttc.WAYPOINTS)
+    with mock.patch.object(vsp, "DAEMON_HOST", "127.0.0.1"), mock.patch.object(vsp, "DAEMON_PORT", daemon.port), \
+            mock.patch.object(rtd.rpp, "recorder_notify", lambda p: sent.append(dict(p))), \
+            mock.patch("sys.stdout", new=io.StringIO()):
+        recorder = rtd._Recorder(True, run_dir.name)
+        if sink:
+            recorder.start_current_actuals()
+        recorder.currents = rtd._start_currents(
+            run_dir, angle_sink=recorder.actual_from_currents if sink else None)
+        result = rtd._replay(seq, recorder, log_record)
+        log_record["currents"] = recorder.currents.stop()
+        recorder.close_current_actuals()
+    vsp.close_daemon_socket()
+    return result, sent, log_record, recorder
+
+
+def write_states(runs_root, run_stem, sent):
+    """recorder.py の TrialWriter で states.csv を書く (本物の書き手. 届いた順に書く)."""
+    with mock.patch.object(reco, "RUNS_ROOT", runs_root), mock.patch("sys.stdout", new=io.StringIO()):
+        tw = reco.TrialWriter(run_stem, 64, 48)
+        for p in sent:
+            if p["type"] in ("stage", "commanded", "gripper", "actual", "gripper_cmd"):
+                tw.write_state(p["type"], p)
+        tw.close("ok")
+    return runs_root / run_stem / "recording" / "states.csv"
+
+
+def is_cur(p):
+    return p.get("type") == "actual" and p.get("note") == NOTE
+
+
+def main_kinds(sent):
+    return [(p["type"], p.get("stage"), p.get("state"), p.get("note")) for p in sent if not is_cur(p)]
+
+
+class TestReplayCurrentActuals(unittest.TestCase):
+    """再生を 2 回 (角度を渡す / 渡さない. どちらも電流は記録する) 通して比べる."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.td = Path(tempfile.mkdtemp())
+        pr.install_daemon_lock()
+        cls.d_on, cls.d_off = PoseDaemon(), PoseDaemon()
+        try:
+            cls.on = replay(cls.d_on, cls.td / "run_0001_20991115_000000", sink=True)
+            cls.off = replay(cls.d_off, cls.td / "run_0002_20991115_000000", sink=False)
+        finally:
+            cls.d_on.close()
+            cls.d_off.close()
+        cls.rec = cls.td / "run_0001_20991115_000000" / "recording"
+        cls.states_root = cls.td / "states"
+        cls.st_on = write_states(cls.states_root, "run_0001_20991115_000000", cls.on[1])
+        cls.st_off = write_states(cls.states_root, "run_0002_20991115_000000", cls.off[1])
+
+    def test_completed(self):
+        self.assertEqual((self.on[0], self.off[0]), ("completed", "completed"))
+
+    def test_current_rows_sent(self):
+        cur = [p for p in self.on[1] if is_cur(p)]
+        rec = self.on[3]
+        self.assertGreater(len(cur), 30)
+        self.assertEqual(len(cur), rec.actual_sent_current_thread)
+        self.assertEqual(rec.actual_current_thread_errors, 0)
+        self.assertFalse(any(is_cur(p) for p in self.off[1]))
+        # 時刻は currents.csv の ts (角度を読んだ時刻) と同じ. 送らなかった分だけ少ない
+        cts = [r[0] for r in ttc.read_csv(self.rec / "currents.csv")[1:]]
+        got = [f"{p['ts']:.6f}" for p in cur]
+        self.assertTrue(set(got) <= set(cts))
+        self.assertEqual(len(cts) - len(got), rec.actual_current_thread_late)
+        self.assertEqual(rec.actual_sent, self.off[3].actual_sent)      # 本体の actual の数 (試行 JSON) は今までの意味
+
+    def test_main_unchanged(self):
+        """本体の通知・本体の daemon への命令・到達と静止の確かめは角度を渡さない再生と同じ."""
+        self.assertEqual(main_kinds(self.on[1]), main_kinds(self.off[1]))
+        cmds = lambda d: [(s[0], s[3]) for s in d.spans if s[0] in  # noqa: E731
+                          ("send_angles", "set_gripper", "set_gripper_value", "set_fresh_mode")]
+        self.assertEqual(cmds(self.d_on), cmds(self.d_off))
+        n_get = lambda d: sum(1 for s in d.spans if s[0] == "get_angles")  # noqa: E731
+        self.assertEqual(n_get(self.d_on), n_get(self.d_off))         # 本体の読みの回数も同じ
+
+        def summary(lr):
+            return [(g.get("kind"), g.get("arrival_ok"), g.get("retried"), tuple(g.get("warnings") or ()),
+                     (g.get("still_check") or {}).get("still"), (g.get("still_check") or {}).get("reads"))
+                    for g in lr["segments"]]
+        self.assertEqual(summary(self.on[2]), summary(self.off[2]))
+        self.assertEqual(self.on[2]["currents"]["overruns"], 0)
+
+    def test_states_csv_order_and_note(self):
+        with self.st_on.open() as f:
+            rows = list(csv.DictReader(f))
+        self.assertEqual(list(rows[0].keys()), reco.STATES_COLS)         # 列は変えない
+        ts = [float(r["ts"]) for r in rows]
+        self.assertEqual(ts, sorted(ts))                                 # 時刻順
+        acts = [r for r in rows if r["event_type"] == "actual"]
+        notes = {r["note"] for r in acts}
+        self.assertEqual(notes, {"", NOTE})
+        self.assertTrue(all(r["j0"] != "" for r in acts))
+        # 電流スレッドの行の stage は, その時刻に recorder.py が見ていた区間 (前の stage 行) と同じ
+        cur_stage = ""
+        for r in rows:
+            if r["event_type"] == "stage":
+                cur_stage = r["stage"]
+            self.assertEqual(r["stage"], cur_stage)
+        print("\nstates.csv の行の例 (直したあと):")
+        for r in rows[:12]:
+            print("  " + ",".join(r[c] for c in reco.STATES_COLS))
+
+    def test_no_current_rows_during_gripper(self):
+        cur_ts = [p["ts"] for p in self.on[1] if is_cur(p)]
+        for cmd, g0, nxt in ttc.gripper_windows(self.d_on.spans):
+            inside = [t for t in cur_ts if g0 <= t < nxt - 0.03]
+            self.assertEqual(inside, [], f"{cmd} の待ちの間に電流スレッドの actual 行")
+
+    def test_angles_follow_arm(self):
+        """電流スレッドの角度は腕の動きに沿う (固定の値ではない)."""
+        cur = [p["angles"] for p in self.on[1] if is_cur(p)]
+        self.assertGreater(len({tuple(round(x, 1) for x in a) for a in cur}), 3)
+
+    def test_readers(self):
+        at_on, aq_on, gt_on, _ = bde.load_states(self.st_on)
+        at_off, _, gt_off, _ = bde.load_states(self.st_off)
+        n_cur = sum(1 for p in self.on[1] if is_cur(p))
+        self.assertEqual(len(at_on), len(at_off) + n_cur)
+        self.assertEqual(list(gt_on) == sorted(gt_on), True)
+        self.assertEqual(len(gt_on), len(gt_off))
+        # 依頼 196 の state_source: 実測の間が狭くなるので, 埋めたコマ (0.1 秒おきのコマで数える) の割合は増えない
+        def filled_share(st):
+            at, aq, _, _ = bde.load_states(st)
+            t = bde.np.arange(at[0], at[-1], 0.1)
+            return float((bce.gap_fill_flags(t, at, aq) != 0).mean())
+        self.assertLessEqual(filled_share(self.st_on), filled_share(self.st_off))
+
+    def test_rate_table(self):
+        """数えるスクリプト (teach_state_rate.py) で直す前・後を数える. ポーリングの間が狭くなる."""
+        m_on, _ = tsr.measure(self.st_on.parent.parent)
+        m_off, _ = tsr.measure(self.st_off.parent.parent)
+        self.assertEqual(m_on["order_reversed"], 0)
+        self.assertEqual(m_on["n_main"], m_off["n_actual"])
+        self.assertAlmostEqual(m_on["main_median"], m_off["all_median"], delta=0.03)   # 本体の読みだけなら今までと同じ形
+        self.assertLess(m_on["all_poll_median"], m_off["all_poll_median"])
+        print(f"\n偽の daemon での actual の間 (send_angles {ttc.SEND_SEC} 秒): 直す前 中央値 {m_off['all_median']:.3f}"
+              f" 90% {m_off['all_p90']:.3f} poll {m_off['all_poll_median']:.3f} / 直したあと 中央値 {m_on['all_median']:.3f}"
+              f" 90% {m_on['all_p90']:.3f} poll {m_on['all_poll_median']:.3f} (電流スレッドの行 {m_on['n_current_thread']})")
+
+
+class TestRecorderUnits(unittest.TestCase):
+    def setUp(self):
+        self.sent = []
+        self.p = mock.patch.object(rtd.rpp, "recorder_notify", lambda p: self.sent.append(dict(p)))
+        self.p.start()
+        self.rec = rtd._Recorder(True, "run_x")
+        self.rec.start_current_actuals()
+
+    def tearDown(self):
+        self.rec.close_current_actuals()
+        self.p.stop()
+
+    def test_late_dropped(self):
+        self.rec.actual([0] * 6)
+        self.rec.actual_from_currents([1] * 6, self.rec._last_state_ts - 0.01)   # 本体の行より前 → 積まない
+        self.rec.actual_from_currents([2] * 6, self.rec._last_state_ts + 0.01)
+        self.rec.close_current_actuals()
+        self.assertEqual([p.get("note") for p in self.sent], [None, NOTE])
+        self.assertEqual((self.rec.actual_current_thread_late, self.rec.actual_sent_current_thread), (1, 1))
+        self.assertEqual(self.rec.actual_sent, 1)
+
+    def test_stage_counts_as_previous_row(self):
+        self.rec.stage("PICK")
+        self.rec.actual_from_currents([1] * 6, self.rec._last_state_ts - 0.001)
+        self.rec.close_current_actuals()
+        self.assertEqual([p["type"] for p in self.sent], ["stage"])
+
+    def test_gripper_ts_kept(self):
+        self.rec.gripper_cmd(1, "close", ts=123.0)
+        self.rec.close_current_actuals()
+        self.assertEqual(self.sent[-1]["ts"], 123.0)               # 渡した時刻のまま (今までどおり)
+
+    def test_closed(self):
+        self.rec.close_current_actuals()
+        self.rec.actual_from_currents([1] * 6, time.time())
+        self.assertEqual(self.sent, [])
+        self.assertEqual(self.rec.actual_sent_current_thread, 0)
+        self.rec.stage("X")                                        # 閉じたあとは今までどおりその場で送る
+        self.assertEqual([p["type"] for p in self.sent], ["stage"])
+
+    def test_bad_values(self):
+        self.rec.actual_from_currents(["x"] * 6, time.time())
+        self.rec.actual_from_currents([float("nan")] * 6, time.time())
+        self.rec.actual_from_currents([1] * 5, time.time())
+        self.rec.close_current_actuals()
+        self.assertEqual((self.sent, self.rec.actual_current_thread_errors), ([], 3))
+
+    def test_disabled(self):
+        rec = rtd._Recorder(False, "run_x")
+        rec.start_current_actuals()
+        rec.actual_from_currents([1] * 6, time.time())
+        rec.actual([1] * 6)
+        rec.close_current_actuals()
+        self.assertEqual(self.sent, [])
+
+    def test_not_started_sends_inline(self):
+        """start_current_actuals を呼ばなければ今までどおりその場で送り, 電流スレッドの角度は受け付けない."""
+        rec = rtd._Recorder(True, "run_y")
+        rec.actual([1] * 6)
+        rec.actual_from_currents([2] * 6, time.time() + 1)
+        self.assertEqual([p.get("note") for p in self.sent], [None])
+        self.assertEqual(rec.actual_sent_current_thread, 0)
+
+    def test_order_across_threads(self):
+        """本体と電流スレッドが同時に積んでも, 届く順は時刻順."""
+        stop = time.time() + 0.5
+
+        def cur():
+            while time.time() < stop:
+                self.rec.actual_from_currents([1] * 6, time.time())
+        th = threading.Thread(target=cur)
+        th.start()
+        while time.time() < stop:
+            self.rec.actual([0] * 6)
+            self.rec.stage("S")
+        th.join()
+        self.rec.close_current_actuals()
+        ts = [p["ts"] for p in self.sent]
+        self.assertGreater(self.rec.actual_sent_current_thread, 10)
+        self.assertEqual(ts, sorted(ts))
+
+    def test_clock_backwards_counted(self):
+        self.rec.gripper_cmd(1, "close", ts=time.time() + 100)
+        self.rec.actual([0] * 6)                                   # 前の行より前の時刻 → 送るが数える
+        self.rec.close_current_actuals()
+        self.assertEqual(len(self.sent), 2)
+        self.assertEqual(self.rec.state_ts_backwards, 1)
+
+
+class TestSlowNotify(unittest.TestCase):
+    """codex R1 必須: 通知の送信が止まっても本体と電流スレッドは待たない. 閉じるのも上限まで.
+    codex 2・3 回目 R1 必須: 送り切れないまま閉じても, 積んだ行は trial_end を追い越さない (trial_end も列の最後に積む)."""
+
+    def _stuck(self):
+        self.gate = threading.Event()
+        self.sent = []
+
+        def slow(p):
+            if p.get("type") != "trial_end":
+                self.gate.wait(5.0)
+            self.sent.append(dict(p))
+        return mock.patch.object(rtd.rpp, "recorder_notify", slow)
+
+    def test_stuck_send(self):
+        with self._stuck():
+            rec = rtd._Recorder(True, "run_z")
+            rec.start_current_actuals()
+            t0 = time.time()
+            for _ in range(20):
+                rec.actual([0] * 6)
+                rec.stage("S")
+                rec.actual_from_currents([1] * 6, time.time())
+            self.assertLess(time.time() - t0, 0.2)                    # 送信が止まっていても積むだけで戻る
+            t1 = time.time()
+            rec.close_current_actuals(timeout=0.3)
+            rec.trial_end()
+            self.assertLess(time.time() - t1, 1.0)                   # 閉じるのも trial_end も上限まで (本体は待たない)
+            self.assertTrue(rec.current_actuals_flush_timeout)
+            self.assertEqual(rec.current_actuals_unsent, 60)         # 期限の時点でまだの数 (途中の 1 件を含む)
+            self.assertTrue(rec.trial_end_via_sender)
+            self.gate.set()                                          # 送信が戻ると, 積んだ順に送り切る
+            for _ in range(100):
+                if self.sent and self.sent[-1]["type"] == "trial_end":
+                    break
+                time.sleep(0.02)
+        types = [p["type"] for p in self.sent]
+        self.assertEqual(len(types), 61)
+        self.assertEqual(types[-1], "trial_end")                     # trial_end を追い越さない
+        ts = [p["ts"] for p in self.sent[:-1]]
+        self.assertEqual(ts, sorted(ts))
+        self.assertEqual(rec.state_rows_sent_by_sender, 61)
+
+    def test_normal_counts(self):
+        sent = []
+        with mock.patch.object(rtd.rpp, "recorder_notify", lambda p: sent.append(dict(p))):
+            rec = rtd._Recorder(True, "run_v")
+            rec.start_current_actuals()
+            rec.stage("S")
+            rec.actual_from_currents([1] * 6, time.time())
+            rec.close_current_actuals()
+            rec.trial_end()
+        self.assertEqual([p["type"] for p in sent], ["stage", "actual", "trial_end"])
+        self.assertEqual((rec.state_rows_sent_by_sender, rec.current_actuals_unsent,
+                          rec.current_actuals_flush_timeout, rec.trial_end_via_sender), (2, 0, False, False))
+
+
+class TestCurrentsRecorderSink(unittest.TestCase):
+    def _run(self, sink, daemon):
+        td = Path(tempfile.mkdtemp())
+        with mock.patch("sys.stdout", new=io.StringIO()):
+            cur = pr.CurrentsRecorder(td, lambda c: daemon._handle(c))
+            cur.angle_sink = sink
+            cur.start()
+            t_end = time.time() + 1.0
+            while time.time() < t_end:
+                cur.window(0.3)
+                time.sleep(0.3)
+            meta = cur.stop()
+        return cur, meta
+
+    def test_sink_error_keeps_reading(self):
+        d = trc.FakeDaemon()
+        calls = []
+
+        def bad(a, ts):
+            calls.append(ts)
+            raise RuntimeError("x")
+        cur, meta = self._run(bad, d)
+        try:
+            self.assertGreaterEqual(len(calls), 2)
+            self.assertEqual(meta["loop_errors"], len(calls))
+            self.assertEqual(meta["currents_rows"], len(calls))       # 電流の行は今までどおり書く
+        finally:
+            d.close()
+
+    def test_no_angles_not_sent(self):
+        d = trc.FakeDaemon()
+        orig = d._handle
+
+        def no_angles(c):
+            r = orig(c)
+            if c.get("cmd") == "read_servo":
+                r["items"] = {}
+            return r
+        d._handle = no_angles
+        calls = []
+        cur, meta = self._run(lambda a, ts: calls.append(ts), d)
+        try:
+            self.assertEqual(calls, [])
+            self.assertGreaterEqual(meta["currents_rows"], 2)
+        finally:
+            d.close()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/pi05/test_teach_currents.py b/pi05/test_teach_currents.py
index f639383..2793fd9 100644
--- a/pi05/test_teach_currents.py
+++ b/pi05/test_teach_currents.py
@@ -366,10 +366,16 @@ class TestPauseAndOldDaemon(unittest.TestCase):
         """cmd_run: settle のあとに始め, trial_end より先に止めて試行 JSON に残す (記録するときだけ)."""
         src = Path(rtd.__file__).read_text()
         i_settle = src.index("time.sleep(RECORDER_START_SETTLE_SEC)")
-        i_start = src.index("recorder.currents = _start_currents(run_dir)")
+        i_start = src.index("recorder.currents = _start_currents(\n                            run_dir, angle_sink=")   # 依頼 202
         i_replay = src.index("result = _replay(seq, recorder, log_record)")
         i_stop = src.index('log_record["currents"] = recorder.currents.stop()')
         i_end = src.index("recorder.trial_end()\n", i_stop)
+        i_open = src.index("recorder.start_current_actuals()")             # 依頼 202: 角度を受け付けてから始める
+        i_close = src.index("recorder.close_current_actuals()", i_stop)    # 依頼 202: 止めてから閉じ, trial_end の前
+        self.assertLess(i_settle, i_open)
+        self.assertLess(i_open, i_start)
+        self.assertLess(i_stop, i_close)
+        self.assertLess(i_close, i_end)
         self.assertLess(i_settle, i_start)
         self.assertLess(i_start, i_replay)
         self.assertLess(i_replay, i_stop)
@@ -525,8 +531,9 @@ class TestFailurePaths(unittest.TestCase):
     def test_no_currents_option(self):
         src = Path(rtd.__file__).read_text()
         self.assertIn('ap_r.add_argument("--no-currents"', src)
-        self.assertIn('if not getattr(args, "no_currents", False):\n                        recorder.currents = '
-                      '_start_currents(run_dir)', src)
+        self.assertIn('if not getattr(args, "no_currents", False):\n'
+                      '                        recorder.start_current_actuals()   # 依頼 202\n'
+                      '                        recorder.currents = _start_currents(', src)
 
     def test_stop_flush_hang(self):
         """スレッドが終わっていても, ファイルの flush が止まると stop() は CLOSE_LIMIT_SEC ほどで戻る (codex R2 必須 1)."""
```

### 依頼202 の record_teach_demo.py の差分（git の外のため、直す前の写しとの差）

`record_teach_demo.py` は git に入っていないので、Claude Code が残した直す前の写し（`.bak_pre_req202_20261115`）と、依頼213の前の写し（`.bak_pre_req213_20261115`）の差を載せます。


```diff
--- dynamic_tracking_limits/drag_teaching/record_teach_demo.py.bak_pre_req202_20261115	2026-11-12 02:44:38.376909959 +0000
+++ dynamic_tracking_limits/drag_teaching/record_teach_demo.py.bak_pre_req213_20261115	2026-11-15 00:26:31.699619895 +0000
@@ -49,6 +49,7 @@
 import subprocess
 import sys
 import tempfile
+import threading
 import time
 import traceback
 import types
@@ -343,6 +344,10 @@
 # 3 tick に 1 回 = 約 3.3Hz（これまでの 19 本と同程度の 3Hz 以上）。
 ACTUAL_READ_EVERY_N_TICKS = 3
 ACTUAL_READ_TARGET_HZ = 3.0
+# 依頼 202: 電流の記録スレッド（read_servo・本体が眠っている間だけ）が読んだ角度も states.csv の actual 行にする。
+# 列は足さず note 列に入れて、本体の読み（到達・静止の確かめなど。note は空のまま）と区別する。
+CURRENT_THREAD_NOTE = "source=current_thread"
+CURRENT_ACTUALS_FLUSH_SEC = 1.0   # trial_end の前に、積んだ通知を送り切るのを待つ上限（ふつうは数 ms で終わる）
 # 1 コマンドに許す時間。既定 DAEMON_TIMEOUT_SEC=35.0 のままだと 1 回の通信失敗で
 # ストリームが長時間止まる（codex R1 C6）。send / get の両方に override を付ける。
 # ---- LOG352: daemon の新 cmd を使う（段階C の実測を受けて）-------------------
@@ -1981,6 +1986,81 @@
         self.send_failures = 0
         self.last_send_error = None
         self.currents = None   # 依頼 121: policy_recorder.CurrentsRecorder（記録するときだけ）
+        # 依頼 202: 電流の記録スレッドが読んだ角度も actual 行にする。states.csv の行が時刻順に並ぶよう、
+        # start_current_actuals() から close_current_actuals() までは stage / actual / gripper_cmd の通知を
+        # 鍵の中で 1 本の列に積み（鍵の中では送らない）、送り手のスレッドが積んだ順に送る
+        # （codex R1 必須: 送信が遅れても本体と電流の記録スレッドは待たない）。
+        self._state_lock = threading.Lock()
+        self._state_cv = threading.Condition(self._state_lock)
+        self._last_state_ts = None
+        self._queue = None                        # 積んだ通知（列を使っている間だけ list）
+        self._sender = None
+        self._sender_stop = False
+        self._current_actuals_open = False        # start_current_actuals() で開き、trial_end の前に閉じる
+        self.actual_sent_current_thread = 0       # 電流の記録スレッドの角度で積んだ actual 行
+        self.actual_current_thread_late = 0       # 先に積んだ行より前の時刻だったので積まなかった数
+        self.actual_current_thread_errors = 0     # 角度・時刻が数にならず積まなかった数
+        self.state_ts_backwards = 0               # 本体の行の時刻が前の行より前だった数（時計が戻ったとき. codex R2）
+        self.current_actuals_unsent = 0           # close の期限の時点でまだ送り終えていなかった通知の数（途中の 1 件を含む）
+        self.current_actuals_flush_timeout = False
+        self.state_rows_sent_by_sender = 0        # 送り手のスレッドが送り終えた通知の数（試行 JSON は trial_end の直後の値）
+        self.trial_end_via_sender = False         # 送り手が止まっていたので trial_end も列の最後に積んだ
+        self._inflight = 0                        # 送り手が送っている途中の通知の数（0 か 1）
+        self._sender_exited = False               # 送り手が列を空にして終わった（鍵の中で立てる）
+
+    def start_current_actuals(self):
+        """依頼 202: 電流の記録スレッドの角度を受け付け、通知を送り手のスレッドから送る形にする."""
+        with self._state_lock:
+            if self._sender is not None:
+                return
+            self._queue = []
+            self._sender_stop = False
+            self._sender_exited = False
+            self._current_actuals_open = True
+            self._sender = threading.Thread(target=self._send_loop, args=(self._queue,), daemon=True,
+                                            name="record_state_sender")
+        self._sender.start()
+
+    def _send_loop(self, q):
+        """積んだ通知を 1 件ずつ取り出して送る（close の期限を過ぎても捨てずに、trial_end まで積んだ順に送り切る）."""
+        while True:
+            with self._state_cv:
+                while not q and not self._sender_stop:
+                    self._state_cv.wait()
+                if not q:
+                    self._sender_exited = True
+                    return
+                p = q.pop(0)
+                self._inflight = 1
+            self._send(p)        # 鍵の外で送る（_send は例外を外へ出さない）
+            with self._state_cv:
+                self._inflight = 0
+                self.state_rows_sent_by_sender += 1
+
+    def _send_state(self, payload, state_row=True):
+        """依頼 202: states.csv の行になる通知（stage / actual / gripper_cmd）.
+
+        ts が無ければ鍵の中で今の時刻を入れる（rpp.recorder_notify が入れるのと同じ時刻）。
+        列を使っている間は鍵の中で積むだけ（recorder.py は届いた順に書くので、積んだ順 = states.csv の順）。
+        列を使っていなければ今までどおりその場で送る。
+        """
+        with self._state_cv:
+            if state_row:
+                if "ts" not in payload:
+                    payload = dict(payload)
+                    payload["ts"] = time.time()
+                ts = float(payload["ts"])
+                if self._last_state_ts is not None and ts < self._last_state_ts:
+                    self.state_ts_backwards += 1      # 直さずに数えるだけ（codex R2）
+                else:
+                    self._last_state_ts = ts
+            if self._queue is not None and not self._sender_exited:
+                self._queue.append(payload)
+                if not state_row:
+                    self.trial_end_via_sender = True
+                self._state_cv.notify()
+                return
+        self._send(payload)
 
     def _send(self, payload):
         """通知は fire-and-forget。**例外を外に出さない**（codex U1）.
@@ -2009,10 +2089,12 @@
         self._send({"type": "trial_start", "run_stem": self.run_stem})
 
     def trial_end(self):
-        self._send({"type": "trial_end", "run_stem": self.run_stem})
+        # 依頼 202: 送り手がまだ送り終えていなければ（close の期限切れ）、trial_end も列の最後に積む。
+        # 送り手が積んだ順に送るので、states.csv の行が trial_end を追い越さない（本体は待たない）。
+        self._send_state({"type": "trial_end", "run_stem": self.run_stem}, state_row=False)
 
     def stage(self, name):
-        self._send({"type": "stage", "stage": name})
+        self._send_state({"type": "stage", "stage": name})
 
     def gripper_cmd(self, state, note, ts=None):
         """build_demo_episodes.py は gripper_cmd の gripper_state を 0/1 で読む.
@@ -2028,7 +2110,7 @@
         payload = {"type": "gripper_cmd", "state": int(state), "note": str(note)}
         if ts is not None:
             payload["ts"] = float(ts)
-        self._send(payload)
+        self._send_state(payload)
 
     def currents_window(self, sec):
         """依頼 121: これから sec 秒 daemon を使わない（眠る）と電流の記録に知らせる."""
@@ -2064,11 +2146,63 @@
                 type(e).__name__, e))
 
     def actual(self, angles):
-        self._send({"type": "actual",
-                    "angles": [float(x) for x in angles],
-                    "ts": time.time()})
+        self._send_state({"type": "actual",
+                          "angles": [float(x) for x in angles]})
         self.actual_sent += 1
 
+    def actual_from_currents(self, angles, ts):
+        """依頼 202: 電流の記録スレッド（read_servo）が読んだ角度を actual 行として送る.
+
+        時刻 ts は角度を読んだ時刻（currents.csv の ts と同じ）。本体の読み（到達・静止の確かめなど。
+        note は空のまま）と区別するため note に CURRENT_THREAD_NOTE を入れる。
+        先に積んだ行（本体の actual・stage・gripper_cmd）より前の時刻なら積まずに数える
+        （states.csv の行を時刻順に保つため。電流スレッドは本体が眠っている間だけ読むので、ふつうは起きない）。
+        電流スレッドから呼ばれる。鍵の中では積むだけで送らない（送るのは送り手のスレッド）。例外は外へ出さない。
+        start_current_actuals() の前と close_current_actuals() のあとは何もしない。
+        """
+        try:
+            vals = [float(x) for x in angles]
+            ts = float(ts)
+            if len(vals) != 6 or not all(math.isfinite(v) for v in vals) or not math.isfinite(ts):
+                raise ValueError("bad angles")
+            with self._state_cv:
+                if not self._current_actuals_open or self._queue is None:
+                    return
+                if self._last_state_ts is not None and ts < self._last_state_ts:
+                    self.actual_current_thread_late += 1
+                    return
+                self._queue.append({"type": "actual", "angles": vals, "ts": ts,
+                                    "note": CURRENT_THREAD_NOTE})
+                self._last_state_ts = ts
+                self.actual_sent_current_thread += 1
+                self._state_cv.notify()
+        except Exception:
+            self.actual_current_thread_errors += 1   # 壊れた値は積まずに数える
+
+    def close_current_actuals(self, timeout=None):
+        """依頼 202: 電流の記録スレッドの角度を受け付けるのをやめ、積んだ通知を送り切る（trial_end の前に呼ぶ）.
+
+        送り手のスレッドを待つのは timeout 秒（既定 CURRENT_ACTUALS_FLUSH_SEC）まで。送り切れたら、このあとの
+        通知は今までどおりその場で送る。送り切れなければ、まだの数を current_actuals_unsent に残し、
+        積んだ分とこのあとの通知（trial_end）は送り手が順に送る（本体は待たない。追い越さない）。
+        """
+        timeout = CURRENT_ACTUALS_FLUSH_SEC if timeout is None else timeout
+        with self._state_cv:
+            self._current_actuals_open = False
+            sender = self._sender
+            if sender is None:
+                return
+            self._sender_stop = True
+            self._state_cv.notify()
+        sender.join(timeout=timeout)
+        with self._state_cv:
+            if not self._sender_exited:
+                # 期限切れ: 積んだ分は捨てずに送り手に任せる（このあとの trial_end も列の最後に積む）
+                self.current_actuals_flush_timeout = True
+                self.current_actuals_unsent = len(self._queue or []) + self._inflight
+            else:
+                self._queue = None
+
 
 _STAGE_SAFE_RE = re.compile(r"[^A-Z0-9]+")
 
@@ -2117,7 +2251,7 @@
             _ACTIVE_CURRENTS.remove(cur)
 
 
-def _start_currents(run_dir, power=None):
+def _start_currents(run_dir, power=None, angle_sink=None):
     """依頼 121: 爪と肩の電流の記録スレッドを始める（失敗しても再生は止めない → None）.
 
     読み方・列・頻度は実機推論の記録（依頼 116）と同じ部品（policy_recorder.CurrentsRecorder）。
@@ -2126,12 +2260,15 @@
     states.csv（recorder.py が書く）の列と行は変えない。
     依頼 156: power（省略時は cmd_run が --power から入れた POWER。2A など）があれば、爪の位置と電圧の番地も読む
     （policy_recorder.PowerRegsRecorder → recording/power_regs.csv。読み始めてよい時の決め方は同じ）。
+    依頼 202: angle_sink（_Recorder.actual_from_currents）を渡すと、read_servo で読めた角度を
+    states.csv の actual 行（note = CURRENT_THREAD_NOTE）にも送る。読む命令・読む時機は変えない。
     """
     power = POWER if power is None else power
     try:
         _prec.install_daemon_lock()
         cls = _prec.PowerRegsRecorder if power else _prec.CurrentsRecorder
         cur = cls(run_dir, _prec.daemon_read_servo)
+        cur.angle_sink = angle_sink
         _ACTIVE_CURRENTS.append(cur)
         cur.start()
     except Exception as e:
@@ -4230,7 +4367,9 @@
                     time.sleep(RECORDER_START_SETTLE_SEC)
                     # 依頼 121: 爪と肩の電流を {run}/recording/currents.csv に残す（再生の間ずっと）
                     if not getattr(args, "no_currents", False):
-                        recorder.currents = _start_currents(run_dir)
+                        recorder.start_current_actuals()   # 依頼 202
+                        recorder.currents = _start_currents(
+                            run_dir, angle_sink=recorder.actual_from_currents)
                     else:
                         _log("--no-currents: 爪と肩の電流は残しません")
 
@@ -4270,7 +4409,23 @@
                         _warn("電流の記録を閉じるときに例外（続行）: {}: {}".format(
                             type(e).__name__, e))
                 if recorder is not None:
+                    try:
+                        recorder.close_current_actuals()   # 依頼 202: 積んだ通知を trial_end の前に送り切る
+                    except BaseException as e:
+                        _warn("電流の記録の角度の通知を閉じるときに例外（続行）: {}: {}".format(
+                            type(e).__name__, e))
                     log_record["recorder_actual_events_sent"] = recorder.actual_sent
+                    # 依頼 202: 電流の記録スレッドの角度で送った actual 行（上の数には入れない）
+                    log_record["recorder_actual_events_sent_current_thread"] = (
+                        recorder.actual_sent_current_thread)
+                    log_record["recorder_actual_current_thread_late"] = (
+                        recorder.actual_current_thread_late)
+                    log_record["recorder_actual_current_thread_errors"] = (
+                        recorder.actual_current_thread_errors)
+                    log_record["recorder_state_ts_backwards"] = recorder.state_ts_backwards
+                    log_record["recorder_current_actuals_unsent"] = recorder.current_actuals_unsent
+                    log_record["recorder_current_actuals_flush_timeout"] = (
+                        recorder.current_actuals_flush_timeout)
                     log_record["recorder_send_failures"] = recorder.send_failures
                     log_record["recorder_last_send_error"] = (
                         recorder.last_send_error)
@@ -4279,6 +4434,9 @@
                     except BaseException as e:
                         _warn("recorder への trial_end 通知で例外（続行）: {}: {}".format(
                             type(e).__name__, e))
+                    # 依頼 202: 送り手が送り終えた数（trial_end の直後の値）と、trial_end も送り手に任せたか（ふつうは False）
+                    log_record["recorder_state_rows_sent_by_sender"] = recorder.state_rows_sent_by_sender
+                    log_record["recorder_trial_end_via_sender"] = recorder.trial_end_via_sender
 
             result = log_record.get("result") or result
             print("=" * 78)
```



## 実機の前の確かめ：Pi の daemon の版と、recorder の受け口の取り合い

前の回の調べのときは Pi の電源が切れていて、daemon が11月5日の版（角度の読み直しを0.02秒にした版）かを確かめられていませんでした。実機の前に ssh で確かめ、daemon のプロセスが1本だけ動いていること、版を見分ける3つの語が4か所あることを見ました（出力はこの下のターミナルの全文の頭）。

次に、上カメラの録画を受け持つ recorder を立ち上げたら、`Address already in use` で止まりました。recorder が受ける UDP の5556番を、ほかのプログラムが使っていたためです。`lsof` で使っているプログラムを、`ps` でその中身と立ち上げた時刻を見ると、2日前（11/13 19:11）に立ち上げた recorder が残っていました。それを止めてから立ち上げ直しています。

### recorder のターミナルの全文


```
Last login: Sun Nov 15 16:46:44 on ttys006
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ % cd ~/r2r2r-scripts
python3 dynamic_tracking_limits/place/place_modules/recorder.py --top --no-side
Traceback (most recent call last):
  File "/Users/shimazueiichi/r2r2r-scripts/dynamic_tracking_limits/place/place_modules/recorder.py", line 742, in <module>
    sys.exit(main())
             ^^^^^^
  File "/Users/shimazueiichi/r2r2r-scripts/dynamic_tracking_limits/place/place_modules/recorder.py", line 540, in main
    sock.bind((UDP_HOST, UDP_PORT))
OSError: [Errno 48] Address already in use
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % lsof -nP -iUDP:5556
COMMAND     PID          USER   FD   TYPE             DEVICE SIZE/OFF NODE NAME
python3.1 63665 shimazueiichi    3u  IPv4 0xc4039887be739e0a      0t0  UDP 127.0.0.1:5556
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % ps -p 63665 -o lstart,command
STARTED                      COMMAND
金 11/13 19:11:54 2026      python3 dynamic_tracking_limits/place/place_modules/recorder.py --top --n
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % kill 63665
python3 dynamic_tracking_limits/place/place_modules/recorder.py --top --no-side
[RECO] UDP listen 127.0.0.1:5556
[RECO] --no-side: 横カメラは使わない
[RECO] --top: 上カメラ録画スレッド開始
[RECO] 待機中. 本線からの trial_start を待つ (Ctrl-C で終了)
[RECO-TOP] 上カメラ open 成功 index=2
[RECO] trial 開始 run_stem=run_0001_20261115_165039 → /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_165039/recording
[RECO-TOP] trial 終了 frames=1036 fps=30.001 status=ok
[RECO] trial 終了 run_stem=run_0001_20261115_165039 captured=0 written=0 eff_fps=0.00 status=ok
[RECO] trial 開始 run_stem=run_0001_20261115_165245 → /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_165245/recording
[RECO-TOP] trial 終了 frames=1082 fps=29.985 status=ok
[RECO] trial 終了 run_stem=run_0001_20261115_165245 captured=0 written=0 eff_fps=0.00 status=ok
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO] trial 開始 run_stem=run_0001_20261115_192142 → /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_192142/recording
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] trial 終了 frames=0 fps=0.0 status=ok
[RECO] trial 終了 run_stem=run_0001_20261115_192142 captured=0 written=0 eff_fps=0.00 status=ok
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
[RECO-TOP] read 連続失敗 → 上カメラを開き直す
[RECO-TOP] 上カメラ open 成功 index=2
```



## 案1を実機で2本：角度の間隔は0.32秒から0.12秒に

11/9 に撮った直す前の2本と比べられるように、同じ教えた記録（`drag_v2_20261109_094222.json`）を、同じ位置1・同じ爪の閉じる値20で再生しました。11/9 は電源が12V・2A、この回は5A です。

1本目（`run_0001_20261115_165039`）は、ブロックを位置5（-58, 245 mm）に置いたまま撮ってしまい、つかめていません。教えた記録の角度をそのまま再生するので、ブロックが教えた位置にないとつかめません。もう一つ、この1本は電源を入れたあとの休んだ姿勢（j4 -92.8°）から始まり、HOME まで92.8°を一気に動いています。安全側の確かめが出て `yes` を打って進めていました。角度の記録の比べには使えますが、お手本には入れません。2本目（`165245`）は位置1に置いて撮り、つかんで箱に入れています。

### 案1の2本のターミナルの全文（daemon の版の確かめから、比べた表まで）


```
Last login: Sun Nov 15 15:16:05 on ttys006
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ % ssh -i ~/.ssh/id_rsa_pi ubuntu@192.168.2.1 'pgrep -af mecharm_daemon; grep -c "read_angles_once_for_log\|GET_ANGLES_INTERVAL_SEC = 0.02\|def read_servo" /home/ubuntu/mecharm_daemon.py'
511 /usr/bin/python3 -u /home/ubuntu/mecharm_daemon.py
14191 bash -c pgrep -af mecharm_daemon; grep -c "read_angles_once_for_log\|GET_ANGLES_INTERVAL_SEC = 0.02\|def read_servo" /home/ubuntu/mecharm_daemon.py
4
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ % cd ~/r2r2r-scripts
python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py measure
python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py run --teach drag_v2_20261109_094222.json --grip-value 20 --power 5A
[RTD   ] 到達許容差は本線 run_pick_place.py の stage 値を使います（区間ごと。一律 8.0° は 2026-10-19 にやめた）:
[RTD   ]   HOME                       2.5°  ← rpp.TOL_HOME（stage1_to_home / HOME 復帰）
[RTD   ]   APPROACH_PICK              2.0°  ← rpp.TOL_APPROACH（approach 系）
[RTD   ]   PICK                       3.0°  ← rpp.TOL_PICK_PLACE（stage4_pick）
[RTD   ]   APPROACH_PICK (lift)       3.0°  ← rpp.TOL_LIFT_BACK（lift の残差 2.19° を吸収）
[RTD   ]   APPROACH_PLACE             3.0°  ← rpp.TOL_APPROACH_PLACE（stage7）
[RTD   ]   PLACE                      3.0°  ← rpp.TOL_PICK_PLACE（stage8_place）
[RTD   ]   APPROACH_PLACE (retreat)   3.0°  ← rpp.TOL_LIFT_BACK（stage10_lift_back）
[RTD   ] 到達を待つ最大時間 = clamp(2.0 + max|Δ|/20*3.0, 8.0, 30.0) 秒（本線と同じ wr._compute_arrival_timeout）
[RTD   ] measure: 上カメラで検出します（repeat=5 interval=0.3s）
[CAM] 接続中カメラ一覧:
  index=0  name=FaceTime HDカメラ
  index=1  name=Iriun Camera
  index=2  name=‎iPhone14 Pro MAXのカメラ
[CAM] 上カメラ(iPhone)  index=2
[CAM] 横カメラ(Iriun)   index=1
[DETECT] resolved top index: 2
[Mac] マット四隅検出中... (10フレーム)
[Mac] ✓ マット四隅検出: 10/10 フレーム成功
[Mac] ✓ 動的homography計算完了
[Mac] ✓ マット範囲: X=[292, 1690] Y=[0, 931]
[06f] TEMPLATES_DIR overridden to: /Users/shimazueiichi/r2r2r-scripts/dynamic_tracking_limits/place/templates
[06f] ROTATION_ANGLES_DEG overridden to: [0, 15, 30, 45, 60, 75]
[06f] SCALES overridden to: [0.85, 1.0, 1.15]
[テンプレ] loading white box templates from: /Users/shimazueiichi/r2r2r-scripts/dynamic_tracking_limits/place/templates
[テンプレ] glob '/Users/shimazueiichi/r2r2r-scripts/dynamic_tracking_limits/place/templates/*.png' → 8 file(s)
[テンプレ]   - white_box_20260520_163829_004.png
[テンプレ]   - white_box_20260520_163838_005.png
[テンプレ]   - white_box_20260520_163846_006.png
[テンプレ]   - white_box_20260520_163905_009.png
[テンプレ]   - white_box_20260520_163912_010.png
[テンプレ]   - white_box_20260520_163918_011.png
[テンプレ]   - white_box_20260520_163923_012.png
[テンプレ]   - white_box_20260520_163929_013.png
[テンプレ] 計 8 枚 (day165=8, auto=0)
[06f] WARN: 輪郭中心とテンプレ中心の距離が閾値超 |Δ|=104.3px > 60px → 輪郭捨てて fallback
[06f] DETECT: center=(1486,576) source=template_fallback score=0.626 angle=0° scale=1.15 size=(226x211) template=white_box_20260520_163838_005.png (eval 6.61s)
[DETECT][1/5] box Unity=(-0.220,+0.195) score=0.6257542967796326
  赤ブロック pixel=(1126, 682) → Unity=(-0.0581, 0.2450)
[DETECT][1/5] block Unity=(-0.058,+0.245) score=null
[06f] WARN: 輪郭中心とテンプレ中心の距離が閾値超 |Δ|=102.1px > 60px → 輪郭捨てて fallback
[06f] DETECT: center=(1486,576) source=template_fallback score=0.626 angle=0° scale=1.15 size=(226x211) template=white_box_20260520_163838_005.png (eval 6.58s)
[DETECT][2/5] box Unity=(-0.220,+0.195) score=0.6261917948722839
  赤ブロック pixel=(1126, 682) → Unity=(-0.0581, 0.2450)
[DETECT][2/5] block Unity=(-0.058,+0.245) score=null
[06f] WARN: 輪郭中心とテンプレ中心の距離が閾値超 |Δ|=105.2px > 60px → 輪郭捨てて fallback
[06f] DETECT: center=(1486,576) source=template_fallback score=0.627 angle=0° scale=1.15 size=(226x211) template=white_box_20260520_163838_005.png (eval 6.46s)
[DETECT][3/5] box Unity=(-0.220,+0.195) score=0.6267520785331726
  赤ブロック pixel=(1126, 682) → Unity=(-0.0581, 0.2450)
[DETECT][3/5] block Unity=(-0.058,+0.245) score=null
[06f] WARN: 輪郭中心とテンプレ中心の距離が閾値超 |Δ|=103.8px > 60px → 輪郭捨てて fallback
[06f] DETECT: center=(1486,576) source=template_fallback score=0.625 angle=0° scale=1.15 size=(226x211) template=white_box_20260520_163838_005.png (eval 6.49s)
[DETECT][4/5] box Unity=(-0.220,+0.195) score=0.6252273321151733
  赤ブロック pixel=(1126, 682) → Unity=(-0.0581, 0.2450)
[DETECT][4/5] block Unity=(-0.058,+0.245) score=null
[06f] WARN: 輪郭中心とテンプレ中心の距離が閾値超 |Δ|=103.8px > 60px → 輪郭捨てて fallback
[06f] DETECT: center=(1486,576) source=template_fallback score=0.625 angle=0° scale=1.15 size=(226x211) template=white_box_20260520_163838_005.png (eval 6.49s)
[DETECT][5/5] box Unity=(-0.220,+0.195) score=0.6250959634780884
  赤ブロック pixel=(1125, 682) → Unity=(-0.0577, 0.2450)
[DETECT][5/5] block Unity=(-0.058,+0.245) score=null
[RTD   ] measure: block = (-58.1, +245.0) mm
[RTD   ] measure: box   = (-220.4, +194.8) mm  score=0.6257542967796326
[RTD   ] 確認画像: /Volumes/KIOXIA/r2r2r-data/mecharm_calibration/teach_poses_20261115/measure_20261115_164947.jpg
[RTD   ] homography のもとになった四隅と、測り直した四隅の差: 最大 1.27px（上限 15.0px・やり直し 1 回）
[RTD   ] ブロックのばらつき: 1.0px = 0.45mm（5 枚・上限 4.0mm）
[RTD   ] 元の検出と測り直しの差: 0.00mm（上限 3.0mm）
[RTD   ] 保存しました: /Volumes/KIOXIA/r2r2r-data/mecharm_calibration/teach_poses_20261115/measure_20261115_164947.json
[RTD   ] 次は Pi で教示 → daemon 起動 → recorder.py --top --no-side 常駐 → run --teach <file> --execute
[RTD   ] 到達許容差は本線 run_pick_place.py の stage 値を使います（区間ごと。一律 8.0° は 2026-10-19 にやめた）:
[RTD   ]   HOME                       2.5°  ← rpp.TOL_HOME（stage1_to_home / HOME 復帰）
[RTD   ]   APPROACH_PICK              2.0°  ← rpp.TOL_APPROACH（approach 系）
[RTD   ]   PICK                       3.0°  ← rpp.TOL_PICK_PLACE（stage4_pick）
[RTD   ]   APPROACH_PICK (lift)       3.0°  ← rpp.TOL_LIFT_BACK（lift の残差 2.19° を吸収）
[RTD   ]   APPROACH_PLACE             3.0°  ← rpp.TOL_APPROACH_PLACE（stage7）
[RTD   ]   PLACE                      3.0°  ← rpp.TOL_PICK_PLACE（stage8_place）
[RTD   ]   APPROACH_PLACE (retreat)   3.0°  ← rpp.TOL_LIFT_BACK（stage10_lift_back）
[RTD   ] 到達を待つ最大時間 = clamp(2.0 + max|Δ|/20*3.0, 8.0, 30.0) 秒（本線と同じ wr._compute_arrival_timeout）
[RTD   ] 爪の閉じる値: 20（--grip-value）
[RTD   ] 電源: 5A（--power。試行 JSON の power に残し、爪の位置と電圧も読みます）
[RTD   ] モード: ドライラン（アームに何も送りません）
[RTD   ] Pi から教えた記録を取得します: ubuntu@192.168.2.1:r2r2r-scripts/dynamic_tracking_limits/drag_teaching/drag_v2_20261109_094222.json
[RTD   ] 取得しました → /var/folders/5w/2q2mc64n6yv63gfh31h34w6h0000gn/T/record_teach_demo_whft858n/drag_v2_20261109_094222.json
[RTD   ] 入力ファイル: drag_v2_20261109_094222.json
[RTD   ] 抽出ウェイポイント:
  APPROACH_PICK  <- phase APPROACH_PICK argmax_idx=240 (start=240 end=290, gap=13.89°)
                    angles = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
  PICK           <- gripper close mark idx=355（PICK phase 範囲内）
                    angles = [ -40.51,  +79.98,   -0.43,   +0.43,  -73.47,  -29.97]
  APPROACH_PLACE <- phase APPROACH_PLACE argmax_idx=470 (start=470 end=512, gap=27.86°)
                    angles = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
  PLACE          <- gripper open mark idx=552（PLACE phase 範囲内）
                    angles = [ +44.20,  +59.67,   +6.15,  +10.54,  -74.88,  -30.84]
[RTD   ] JOINT_LIMITS 一括検証 OK（全 endpoint + HOME）
[RTD   ] 姿勢検査 OK（全 155 姿勢が 有限値 + JOINT_LIMITS + J4_SAFE [-90.0, +60.0] 内）
[RTD   ] j4 の余裕は最小 15.12°（しきい値 3.0° 以上）
==============================================================================
[RTD   ] 実行プラン（daemon 経由・区間ごとに 1 回送信 → 到達待ち）
==============================================================================
  [STEP  1] MOVE → HOME (single send + settle)  speed=20
            current = 未取得（ドライラン・daemon に接続していない）
            to HOME = [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]
  [STEP  2] GRIPPER OPEN  daemon_set_gripper(0, 50, wait=0) ×1 回（daemon 事前 2.0s + 事後 2.0s + 待ち 2.0s）= 計 6.0s
            開いたかは確認しません（gv を使わず・開始前の y/n も無し。判定は終了後の y/n と動画）
  [STEP  3] MOVE → APPROACH_PICK  segment HOME → APPROACH_PICK  tol=2.0°  [rpp.TOL_APPROACH（approach 系）]
            from    = [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]
            to      = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            max |Δ| = 70.48°  1 回送信 speed=20  (~ 3.5s @ 20°/s 目安・到達待ち 最大 12.6s)
  [STEP  4] MOVE → PICK  segment APPROACH_PICK → PICK  [critical]  tol=3.0°  [rpp.TOL_PICK_PLACE（stage4_pick）]
            from    = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            to      = [ -40.51,  +79.98,   -0.43,   +0.43,  -73.47,  -29.97]
            max |Δ| = 13.89°  1 回送信 speed=20  (~ 0.7s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP  5] GRIPPER CLOSE  daemon_set_gripper_value(20, 50) + sleep(2.0s)
  [STEP  6] MOVE → APPROACH_PICK (lift)  segment PICK → APPROACH_PICK (lift)  tol=3.0°  [rpp.TOL_LIFT_BACK（lift の残差 2.19° を吸収）]
            from    = [ -40.51,  +79.98,   -0.43,   +0.43,  -73.47,  -29.97]
            to      = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            max |Δ| = 13.89°  1 回送信 speed=20  (~ 0.7s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP  7] MOVE → APPROACH_PLACE  segment APPROACH_PICK → APPROACH_PLACE  tol=3.0°  [rpp.TOL_APPROACH_PLACE（stage7）]
            from    = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            to      = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            max |Δ| = 84.10°  1 回送信 speed=20  (~ 4.2s @ 20°/s 目安・到達待ち 最大 14.6s)
  [STEP  8] MOVE → PLACE  segment APPROACH_PLACE → PLACE  [critical]  tol=3.0°  [rpp.TOL_PICK_PLACE（stage8_place）]
            from    = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            to      = [ +44.20,  +59.67,   +6.15,  +10.54,  -74.88,  -30.84]
            max |Δ| = 27.86°  1 回送信 speed=20  (~ 1.4s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP  9] GRIPPER OPEN  daemon_set_gripper(0, 50, wait=0) ×1 回（daemon 事前 2.0s + 事後 2.0s + 待ち 2.0s）= 計 6.0s
            開いたかは確認しません（gv を使わず・開始前の y/n も無し。判定は終了後の y/n と動画）
  [STEP 10] MOVE → APPROACH_PLACE (retreat)  segment PLACE → APPROACH_PLACE (retreat)  tol=3.0°  [rpp.TOL_LIFT_BACK（stage10_lift_back）]
            from    = [ +44.20,  +59.67,   +6.15,  +10.54,  -74.88,  -30.84]
            to      = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            max |Δ| = 27.86°  1 回送信 speed=20  (~ 1.4s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP 11] MOVE → HOME  segment APPROACH_PLACE → HOME  tol=2.5°  [rpp.TOL_HOME（stage1_to_home / HOME 復帰）]
            from    = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            to      = [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]
            max |Δ| = 56.95°  1 回送信 speed=20  (~ 2.8s @ 20°/s 目安・到達待ち 最大 10.5s)
==============================================================================
[RTD   ] 送信 = 8 回（STEP 1 + move 7 区間）, 想定所要時間 ≈ 31.8s（最悪 73.0s）
[RTD   ]   内訳: 先頭 settle 3.0s + 移動 14.8s（max|Δ| 合計 295.0° @ 20°/s 目安） + gripper 14.0s
[RTD   ]   到達確認: 許容は区間ごと（本線 run_pick_place.py の stage 値）/ 最大は clamp(2.0 + max|Δ|/20*3.0, 8.0, 30.0) 秒
[RTD   ]   届かないとき: 送信前から 1.0° 未満しか動いていなければ 5.0s 待って**同じ目標へ 1 回だけ**再送（本線と同じ）。それでも届かなければ ABORT（HOME へ自動で戻らない）
[RTD   ]   実測 j4: [-90.0, +60.0] の外は WARN / [-98.0, +68.0] の外は ABORT
==============================================================================
[RTD   ] measure: /Volumes/KIOXIA/r2r2r-data/mecharm_calibration/teach_poses_20261115/measure_20261115_164947.json
[RTD   ]   measured_at = 2026-11-15T16:49:49.117401  block = (-58.1, +245.0) mm  box = (-220.4, +194.8) mm
[RTD   ] 再生直前: 上カメラでマット四隅とブロック画素を確認します
[RTD   ] 再生直前: block = (-58.1, +245.0) mm（measure の homography で換算）
[RTD   ] 確認画像: /Volumes/KIOXIA/r2r2r-data/mecharm_calibration/teach_poses_20261115/prerun_20261115_164951.jpg
[RTD   ] ブロック位置の照合 OK（画素の差 0.0px <= 許容 10.3px = 5.0mm / mm 換算の差 0.00mm）
[RTD   ] マット四隅のずれ 最大 1.3px（上限 15.0px・やり直し 1 回）
[RTD   ] ドライランなので、ここで終了します（アームには何も送っていません）
[RTD   ] Pi 版と比べる点: 抽出ウェイポイント 4 姿勢と各区間の max|Δ| は同じ。送り方は単発（Pi 版は 0.1s 補間ストリーミング）なので n_steps / ticks は比較対象外。送信 8 回 / 想定所要 ≈ 31.8s
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py run --teach drag_v2_20261109_094222.json --grip-value 20 --power 5A --execute
[RTD   ] 到達許容差は本線 run_pick_place.py の stage 値を使います（区間ごと。一律 8.0° は 2026-10-19 にやめた）:
[RTD   ]   HOME                       2.5°  ← rpp.TOL_HOME（stage1_to_home / HOME 復帰）
[RTD   ]   APPROACH_PICK              2.0°  ← rpp.TOL_APPROACH（approach 系）
[RTD   ]   PICK                       3.0°  ← rpp.TOL_PICK_PLACE（stage4_pick）
[RTD   ]   APPROACH_PICK (lift)       3.0°  ← rpp.TOL_LIFT_BACK（lift の残差 2.19° を吸収）
[RTD   ]   APPROACH_PLACE             3.0°  ← rpp.TOL_APPROACH_PLACE（stage7）
[RTD   ]   PLACE                      3.0°  ← rpp.TOL_PICK_PLACE（stage8_place）
[RTD   ]   APPROACH_PLACE (retreat)   3.0°  ← rpp.TOL_LIFT_BACK（stage10_lift_back）
[RTD   ] 到達を待つ最大時間 = clamp(2.0 + max|Δ|/20*3.0, 8.0, 30.0) 秒（本線と同じ wr._compute_arrival_timeout）
[RTD   ] 爪の閉じる値: 20（--grip-value）
[RTD   ] 電源: 5A（--power。試行 JSON の power に残し、爪の位置と電圧も読みます）
[RTD   ] モード: EXECUTE（実機）  記録: ON
[RTD   ] Pi から教えた記録を取得します: ubuntu@192.168.2.1:r2r2r-scripts/dynamic_tracking_limits/drag_teaching/drag_v2_20261109_094222.json
[RTD   ] 取得しました → /var/folders/5w/2q2mc64n6yv63gfh31h34w6h0000gn/T/record_teach_demo_zj3abtve/drag_v2_20261109_094222.json
[RTD   ] 入力ファイル: drag_v2_20261109_094222.json
[RTD   ] 抽出ウェイポイント:
  APPROACH_PICK  <- phase APPROACH_PICK argmax_idx=240 (start=240 end=290, gap=13.89°)
                    angles = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
  PICK           <- gripper close mark idx=355（PICK phase 範囲内）
                    angles = [ -40.51,  +79.98,   -0.43,   +0.43,  -73.47,  -29.97]
  APPROACH_PLACE <- phase APPROACH_PLACE argmax_idx=470 (start=470 end=512, gap=27.86°)
                    angles = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
  PLACE          <- gripper open mark idx=552（PLACE phase 範囲内）
                    angles = [ +44.20,  +59.67,   +6.15,  +10.54,  -74.88,  -30.84]
[RTD   ] JOINT_LIMITS 一括検証 OK（全 endpoint + HOME）
[RTD   ] 姿勢検査 OK（全 155 姿勢が 有限値 + JOINT_LIMITS + J4_SAFE [-90.0, +60.0] 内）
[RTD   ] j4 の余裕は最小 15.12°（しきい値 3.0° 以上）
[RTD   ] 現在姿勢を daemon から取得します
[RTD   ] 現在姿勢 = [  -0.43,  +92.37,   -1.93,   -2.19,  -92.81,  -29.61]
[RTD   ] [WARN] 現在の実測 j4 = -92.81 が J4_SAFE [-90.0, +60.0] の外です（指令値の制限なので続行します・記録のみ）
==============================================================================
[RTD   ] 実行プラン（daemon 経由・区間ごとに 1 回送信 → 到達待ち）
==============================================================================
  [STEP  1] MOVE → HOME (single send + settle)  speed=20
            current = [  -0.43,  +92.37,   -1.93,   -2.19,  -92.81,  -29.61]
            to HOME = [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]
            max |Δ| = 92.81°  (settle 3.0s)
  [STEP  2] GRIPPER OPEN  daemon_set_gripper(0, 50, wait=0) ×1 回（daemon 事前 2.0s + 事後 2.0s + 待ち 2.0s）= 計 6.0s
            開いたかは確認しません（gv を使わず・開始前の y/n も無し。判定は終了後の y/n と動画）
  [STEP  3] MOVE → APPROACH_PICK  segment HOME → APPROACH_PICK  tol=2.0°  [rpp.TOL_APPROACH（approach 系）]
            from    = [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]
            to      = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            max |Δ| = 70.48°  1 回送信 speed=20  (~ 3.5s @ 20°/s 目安・到達待ち 最大 12.6s)
  [STEP  4] MOVE → PICK  segment APPROACH_PICK → PICK  [critical]  tol=3.0°  [rpp.TOL_PICK_PLACE（stage4_pick）]
            from    = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            to      = [ -40.51,  +79.98,   -0.43,   +0.43,  -73.47,  -29.97]
            max |Δ| = 13.89°  1 回送信 speed=20  (~ 0.7s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP  5] GRIPPER CLOSE  daemon_set_gripper_value(20, 50) + sleep(2.0s)
  [STEP  6] MOVE → APPROACH_PICK (lift)  segment PICK → APPROACH_PICK (lift)  tol=3.0°  [rpp.TOL_LIFT_BACK（lift の残差 2.19° を吸収）]
            from    = [ -40.51,  +79.98,   -0.43,   +0.43,  -73.47,  -29.97]
            to      = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            max |Δ| = 13.89°  1 回送信 speed=20  (~ 0.7s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP  7] MOVE → APPROACH_PLACE  segment APPROACH_PICK → APPROACH_PLACE  tol=3.0°  [rpp.TOL_APPROACH_PLACE（stage7）]
            from    = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            to      = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            max |Δ| = 84.10°  1 回送信 speed=20  (~ 4.2s @ 20°/s 目安・到達待ち 最大 14.6s)
  [STEP  8] MOVE → PLACE  segment APPROACH_PLACE → PLACE  [critical]  tol=3.0°  [rpp.TOL_PICK_PLACE（stage8_place）]
            from    = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            to      = [ +44.20,  +59.67,   +6.15,  +10.54,  -74.88,  -30.84]
            max |Δ| = 27.86°  1 回送信 speed=20  (~ 1.4s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP  9] GRIPPER OPEN  daemon_set_gripper(0, 50, wait=0) ×1 回（daemon 事前 2.0s + 事後 2.0s + 待ち 2.0s）= 計 6.0s
            開いたかは確認しません（gv を使わず・開始前の y/n も無し。判定は終了後の y/n と動画）
  [STEP 10] MOVE → APPROACH_PLACE (retreat)  segment PLACE → APPROACH_PLACE (retreat)  tol=3.0°  [rpp.TOL_LIFT_BACK（stage10_lift_back）]
            from    = [ +44.20,  +59.67,   +6.15,  +10.54,  -74.88,  -30.84]
            to      = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            max |Δ| = 27.86°  1 回送信 speed=20  (~ 1.4s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP 11] MOVE → HOME  segment APPROACH_PLACE → HOME  tol=2.5°  [rpp.TOL_HOME（stage1_to_home / HOME 復帰）]
            from    = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            to      = [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]
            max |Δ| = 56.95°  1 回送信 speed=20  (~ 2.8s @ 20°/s 目安・到達待ち 最大 10.5s)
==============================================================================
[RTD   ] 送信 = 8 回（STEP 1 + move 7 区間）, 想定所要時間 ≈ 31.8s（最悪 73.0s）
[RTD   ]   内訳: 先頭 settle 3.0s + 移動 14.8s（max|Δ| 合計 295.0° @ 20°/s 目安） + gripper 14.0s
[RTD   ]   到達確認: 許容は区間ごと（本線 run_pick_place.py の stage 値）/ 最大は clamp(2.0 + max|Δ|/20*3.0, 8.0, 30.0) 秒
[RTD   ]   届かないとき: 送信前から 1.0° 未満しか動いていなければ 5.0s 待って**同じ目標へ 1 回だけ**再送（本線と同じ）。それでも届かなければ ABORT（HOME へ自動で戻らない）
[RTD   ]   実測 j4: [-90.0, +60.0] の外は WARN / [-98.0, +68.0] の外は ABORT
==============================================================================
[RTD   ] measure: /Volumes/KIOXIA/r2r2r-data/mecharm_calibration/teach_poses_20261115/measure_20261115_164947.json
[RTD   ]   measured_at = 2026-11-15T16:49:49.117401  block = (-58.1, +245.0) mm  box = (-220.4, +194.8) mm
[RTD   ] 再生直前: 上カメラでマット四隅とブロック画素を確認します
[RTD   ] 再生直前: block = (-58.1, +245.0) mm（measure の homography で換算）
[RTD   ] 確認画像: /Volumes/KIOXIA/r2r2r-data/mecharm_calibration/teach_poses_20261115/prerun_20261115_165022.jpg
[RTD   ] ブロック位置の照合 OK（画素の差 0.0px <= 許容 10.3px = 5.0mm / mm 換算の差 0.00mm）
[RTD   ] マット四隅のずれ 最大 0.9px（上限 15.0px・やり直し 1 回）
[RTD   ] [SAFETY] 再生中はグリッパーが実機で開閉します。爪に指を挟まないこと。
[RTD   ] [SAFETY] 止めるときはアームの電源を切ること。Ctrl-C は新しい送信をやめるだけで、進行中の移動は止まりません。
[RTD   ] [SAFETY] 開いたかの自動確認はしません（gv は使わない）。STEP 2 で open を送ってから PICK へ降ります。
[RTD   ] 周囲に手・物が無いか確認してください。OK なら Enter で開始

[RTD   ] [WARN] 先頭移動の最大軸差 92.81° > 30.0°。急加速の可能性があります
[RTD   ] 続行するには 'yes' と入力してください（それ以外は中止）
yes
[RTD   ] 試行フォルダ: /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_165039
[RTD   ] 教えた記録のコピー: /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_165039/teach/drag_v2_20261109_094222.json
[RTD   ] recorder に trial_start を送りました。1.0s 待ってから動き出します（mp4 writer が開くまで）
[RTD   ] 爪と肩の電流を 1 秒 10 回で記録します（爪を動かしている間は読みません）→ /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_165039/recording/currents.csv
[RTD   ] 電源 5A: 爪の位置（番地 7:56/57）と電圧（2:62・7:62）も読みます（生の値・未確認の番地）→ /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_165039/recording/power_regs.csv
  [Pi] fresh_mode=1
[RTD   ] daemon_set_fresh_mode(1)（最新コマンド優先・本線 run_pick_place.py L3976 と同じ。647 試行の実績はこの状態）
[STEP  1] MOVE → HOME  daemon_send_angles(HOME, 20)
[STEP  1] 到達待ち 許容 2.5°[TOL_HOME（stage1_to_home / HOME 復帰）] / 最大 15.9s
[RTD   ] [WARN] 実測 j4 = -92.81 が J4_SAFE [-90.0, +60.0] の外です（記録のみ・送信は止めません）
[RTD   ] 先頭移動: 送信直前の実測で max|Δ| = 92.81° / 到達待ち 最大 15.9s
[RTD   ] [WARN] 送信直前の実測では current → HOME が 92.81°（> 30.0°）あります。周囲に手・物が無いか、もう一度目で確かめてください
[STEP  1] 3.0s 待ちます（settle）
[RTD   ] arrival OK (current → HOME, max|Δ|=1.23° <= tol 2.5°)
[STEP  2] GRIPPER OPEN → daemon_set_gripper(0, 50, wait=0)
[RTD   ] 静止確認 OK（step2_open: 連続 3 回・連続差 最大 0.09° <= 1.0°）
  [Pi] GRIPPER: OPEN result= None
[RTD   ] gripper open (1/1 回目) の daemon 往復 = 2.013s
[STEP  2] open 後 2.0s 待ちます（本線の daemon wait=2 相当・読み取りなし）
[STEP  2] gripper dwell 2.0s（読み取りなし）
[STEP  3] MOVE → APPROACH_PICK  segment HOME → APPROACH_PICK  (1 回送信 speed=20 → 到達待ち 許容 2.0°[TOL_APPROACH（approach 系）] / 最大 12.6s)
[RTD   ] 送信 OK（daemon 往復 1.029s）
[RECORD] [WARN] 番地 7:56 が 2 回続けて返事なし. この run ではもう読みません (本体を待たせないため. 再生は続けます)
[RTD   ] arrival OK (HOME → APPROACH_PICK, max|Δ|=0.97° <= tol 2.0°)
[STEP  4] MOVE → PICK  segment APPROACH_PICK → PICK  (1 回送信 speed=20 → 到達待ち 許容 3.0°[TOL_PICK_PLACE（stage4_pick）] / 最大 8.0s)  [critical]
[RTD   ] 送信 OK（daemon 往復 1.032s）
[RTD   ] arrival OK (APPROACH_PICK → PICK, max|Δ|=1.94° <= tol 3.0°)
[STEP  5] GRIPPER CLOSE → daemon_set_gripper_value(20, 50)
[RTD   ] 静止確認 OK（step5_close: 連続 3 回・連続差 最大 0.00° <= 1.0°）
  [Pi] GRIPPER: VALUE=20 speed=50 result= None
[RTD   ] gripper close (1/1 回目) の daemon 往復 = 0.013s
[STEP  5] gripper dwell 2.0s（読み取りなし）
[STEP  6] MOVE → APPROACH_PICK (lift)  segment PICK → APPROACH_PICK (lift)  (1 回送信 speed=20 → 到達待ち 許容 3.0°[TOL_LIFT_BACK（lift の残差 2.19° を吸収）] / 最大 8.0s)
[RTD   ] 送信 OK（daemon 往復 1.032s）
[RTD   ] arrival OK (PICK → APPROACH_PICK (lift), max|Δ|=1.84° <= tol 3.0°)
[STEP  7] MOVE → APPROACH_PLACE  segment APPROACH_PICK → APPROACH_PLACE  (1 回送信 speed=20 → 到達待ち 許容 3.0°[TOL_APPROACH_PLACE（stage7）] / 最大 14.6s)
[RTD   ] 送信 OK（daemon 往復 1.050s）
[RTD   ] arrival OK (APPROACH_PICK → APPROACH_PLACE, max|Δ|=1.58° <= tol 3.0°)
[STEP  8] MOVE → PLACE  segment APPROACH_PLACE → PLACE  (1 回送信 speed=20 → 到達待ち 許容 3.0°[TOL_PICK_PLACE（stage8_place）] / 最大 8.0s)  [critical]
[RTD   ] 送信 OK（daemon 往復 1.040s）
[RTD   ] arrival OK (APPROACH_PLACE → PLACE, max|Δ|=2.55° <= tol 3.0°)
[STEP  9] GRIPPER OPEN → daemon_set_gripper(0, 50, wait=0)
[RTD   ] 静止確認 OK（step9_open: 連続 3 回・連続差 最大 0.00° <= 1.0°）
  [Pi] GRIPPER: OPEN result= None
[RTD   ] gripper open (1/1 回目) の daemon 往復 = 2.004s
[STEP  9] open 後 2.0s 待ちます（本線の daemon wait=2 相当・読み取りなし）
[STEP  9] gripper dwell 2.0s（読み取りなし）
[STEP 10] MOVE → APPROACH_PLACE (retreat)  segment PLACE → APPROACH_PLACE (retreat)  (1 回送信 speed=20 → 到達待ち 許容 3.0°[TOL_LIFT_BACK（stage10_lift_back）] / 最大 8.0s)
[RTD   ] 送信 OK（daemon 往復 1.038s）
[RTD   ] arrival OK (PLACE → APPROACH_PLACE (retreat), max|Δ|=2.20° <= tol 3.0°)
[STEP 11] MOVE → HOME  segment APPROACH_PLACE → HOME  (1 回送信 speed=20 → 到達待ち 許容 2.5°[TOL_HOME（stage1_to_home / HOME 復帰）] / 最大 10.5s)
[RTD   ] 送信 OK（daemon 往復 1.056s）
[RTD   ] arrival OK (APPROACH_PLACE → HOME, max|Δ|=2.10° <= tol 2.5°)
  [Pi] fresh_mode=0
[RTD   ] daemon_set_fresh_mode(0) 完了
[RTD   ] [WARN] 実測 j4 が J4_SAFE 外に読めた回数 = 1（最初の数件: [-92.81]）。送信は止めていません（記録のみ・エイイチ判断。[-98.0, +68.0] の外なら ABORT する）
[RTD   ] 実測角の読み取り: ok 51/51 回, 実効 1.52 Hz（目標 3.0 Hz 以上）
[RTD   ] [WARN] 実測角の読み取りが目標 3.0 Hz を下回りました（1.52 Hz）。学習データの state 密度が 19 本より薄くなります
[RTD   ] send_angles の daemon 往復 (7 回): 平均 1.040s / p50 1.038s / 最大 1.056s（timeout 6.0s）
[RTD   ] [WARN] 送信 1 回に 1.056s かかった回があります。daemon は送信後に角度を読み直すので、動き始めで読めないと伸びます（単発送信なので試行全体への影響は小さい）
[RTD   ] 区間の所要（送信→到達確認まで）(8 区間): 平均 2.07s / 最大 4.49s
[RECORD] 電流の記録終了 43 行 (1.28 行/秒. 本体が眠っている間だけ読む. 爪の間 14.049 秒は読まない. 見込み超え 0 回. read_servo)  → /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_165039/recording/currents.csv
[RECORD] 爪の位置と電圧 34 行 (読めた数 {'7:56': 7, '7:57': 17, '2:62': 17, '7:62': 17}. もう読まなかった番地 7:56)  → /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_165039/recording/power_regs.csv
==============================================================================
[RTD   ] 再生 完了
==============================================================================
[RTD   ] つかめたか (y/n) > n
[RTD   ] 箱に入ったか (y/n) > n
[RTD   ] 試行 JSON: /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_165039/run_0001_20261115_165039.json
[LEDGER] append OK: /Volumes/KIOXIA/r2r2r-data/runs/pick_place_ledger_v3.csv (pick=no place=no recording_status=ok)
[RTD   ] 次に進むには: python3 /Users/shimazueiichi/r2r2r-scripts/pi05/build_demo_episodes.py --run run_0001_20261115_165039 --dataset mecharm_redblock_box_teach_v1
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py run --teach drag_v2_20261109_094222.json --grip-value 20 --power 5A --execute
[RTD   ] 到達許容差は本線 run_pick_place.py の stage 値を使います（区間ごと。一律 8.0° は 2026-10-19 にやめた）:
[RTD   ]   HOME                       2.5°  ← rpp.TOL_HOME（stage1_to_home / HOME 復帰）
[RTD   ]   APPROACH_PICK              2.0°  ← rpp.TOL_APPROACH（approach 系）
[RTD   ]   PICK                       3.0°  ← rpp.TOL_PICK_PLACE（stage4_pick）
[RTD   ]   APPROACH_PICK (lift)       3.0°  ← rpp.TOL_LIFT_BACK（lift の残差 2.19° を吸収）
[RTD   ]   APPROACH_PLACE             3.0°  ← rpp.TOL_APPROACH_PLACE（stage7）
[RTD   ]   PLACE                      3.0°  ← rpp.TOL_PICK_PLACE（stage8_place）
[RTD   ]   APPROACH_PLACE (retreat)   3.0°  ← rpp.TOL_LIFT_BACK（stage10_lift_back）
[RTD   ] 到達を待つ最大時間 = clamp(2.0 + max|Δ|/20*3.0, 8.0, 30.0) 秒（本線と同じ wr._compute_arrival_timeout）
[RTD   ] 爪の閉じる値: 20（--grip-value）
[RTD   ] 電源: 5A（--power。試行 JSON の power に残し、爪の位置と電圧も読みます）
[RTD   ] モード: EXECUTE（実機）  記録: ON
[RTD   ] Pi から教えた記録を取得します: ubuntu@192.168.2.1:r2r2r-scripts/dynamic_tracking_limits/drag_teaching/drag_v2_20261109_094222.json
[RTD   ] 取得しました → /var/folders/5w/2q2mc64n6yv63gfh31h34w6h0000gn/T/record_teach_demo_3_54l71x/drag_v2_20261109_094222.json
[RTD   ] 入力ファイル: drag_v2_20261109_094222.json
[RTD   ] 抽出ウェイポイント:
  APPROACH_PICK  <- phase APPROACH_PICK argmax_idx=240 (start=240 end=290, gap=13.89°)
                    angles = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
  PICK           <- gripper close mark idx=355（PICK phase 範囲内）
                    angles = [ -40.51,  +79.98,   -0.43,   +0.43,  -73.47,  -29.97]
  APPROACH_PLACE <- phase APPROACH_PLACE argmax_idx=470 (start=470 end=512, gap=27.86°)
                    angles = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
  PLACE          <- gripper open mark idx=552（PLACE phase 範囲内）
                    angles = [ +44.20,  +59.67,   +6.15,  +10.54,  -74.88,  -30.84]
[RTD   ] JOINT_LIMITS 一括検証 OK（全 endpoint + HOME）
[RTD   ] 姿勢検査 OK（全 155 姿勢が 有限値 + JOINT_LIMITS + J4_SAFE [-90.0, +60.0] 内）
[RTD   ] j4 の余裕は最小 15.12°（しきい値 3.0° 以上）
[RTD   ] 現在姿勢を daemon から取得します
[RTD   ] 現在姿勢 = [  -0.08,   +1.40,   +1.66,   +0.26,   +0.08,  -30.23]
==============================================================================
[RTD   ] 実行プラン（daemon 経由・区間ごとに 1 回送信 → 到達待ち）
==============================================================================
  [STEP  1] MOVE → HOME (single send + settle)  speed=20
            current = [  -0.08,   +1.40,   +1.66,   +0.26,   +0.08,  -30.23]
            to HOME = [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]
            max |Δ| = 1.66°  (settle 3.0s)
  [STEP  2] GRIPPER OPEN  daemon_set_gripper(0, 50, wait=0) ×1 回（daemon 事前 2.0s + 事後 2.0s + 待ち 2.0s）= 計 6.0s
            開いたかは確認しません（gv を使わず・開始前の y/n も無し。判定は終了後の y/n と動画）
  [STEP  3] MOVE → APPROACH_PICK  segment HOME → APPROACH_PICK  tol=2.0°  [rpp.TOL_APPROACH（approach 系）]
            from    = [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]
            to      = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            max |Δ| = 70.48°  1 回送信 speed=20  (~ 3.5s @ 20°/s 目安・到達待ち 最大 12.6s)
  [STEP  4] MOVE → PICK  segment APPROACH_PICK → PICK  [critical]  tol=3.0°  [rpp.TOL_PICK_PLACE（stage4_pick）]
            from    = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            to      = [ -40.51,  +79.98,   -0.43,   +0.43,  -73.47,  -29.97]
            max |Δ| = 13.89°  1 回送信 speed=20  (~ 0.7s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP  5] GRIPPER CLOSE  daemon_set_gripper_value(20, 50) + sleep(2.0s)
  [STEP  6] MOVE → APPROACH_PICK (lift)  segment PICK → APPROACH_PICK (lift)  tol=3.0°  [rpp.TOL_LIFT_BACK（lift の残差 2.19° を吸収）]
            from    = [ -40.51,  +79.98,   -0.43,   +0.43,  -73.47,  -29.97]
            to      = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            max |Δ| = 13.89°  1 回送信 speed=20  (~ 0.7s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP  7] MOVE → APPROACH_PLACE  segment APPROACH_PICK → APPROACH_PLACE  tol=3.0°  [rpp.TOL_APPROACH_PLACE（stage7）]
            from    = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            to      = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            max |Δ| = 84.10°  1 回送信 speed=20  (~ 4.2s @ 20°/s 目安・到達待ち 最大 14.6s)
  [STEP  8] MOVE → PLACE  segment APPROACH_PLACE → PLACE  [critical]  tol=3.0°  [rpp.TOL_PICK_PLACE（stage8_place）]
            from    = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            to      = [ +44.20,  +59.67,   +6.15,  +10.54,  -74.88,  -30.84]
            max |Δ| = 27.86°  1 回送信 speed=20  (~ 1.4s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP  9] GRIPPER OPEN  daemon_set_gripper(0, 50, wait=0) ×1 回（daemon 事前 2.0s + 事後 2.0s + 待ち 2.0s）= 計 6.0s
            開いたかは確認しません（gv を使わず・開始前の y/n も無し。判定は終了後の y/n と動画）
  [STEP 10] MOVE → APPROACH_PLACE (retreat)  segment PLACE → APPROACH_PLACE (retreat)  tol=3.0°  [rpp.TOL_LIFT_BACK（stage10_lift_back）]
            from    = [ +44.20,  +59.67,   +6.15,  +10.54,  -74.88,  -30.84]
            to      = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            max |Δ| = 27.86°  1 回送信 speed=20  (~ 1.4s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP 11] MOVE → HOME  segment APPROACH_PLACE → HOME  tol=2.5°  [rpp.TOL_HOME（stage1_to_home / HOME 復帰）]
            from    = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            to      = [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]
            max |Δ| = 56.95°  1 回送信 speed=20  (~ 2.8s @ 20°/s 目安・到達待ち 最大 10.5s)
==============================================================================
[RTD   ] 送信 = 8 回（STEP 1 + move 7 区間）, 想定所要時間 ≈ 31.8s（最悪 73.0s）
[RTD   ]   内訳: 先頭 settle 3.0s + 移動 14.8s（max|Δ| 合計 295.0° @ 20°/s 目安） + gripper 14.0s
[RTD   ]   到達確認: 許容は区間ごと（本線 run_pick_place.py の stage 値）/ 最大は clamp(2.0 + max|Δ|/20*3.0, 8.0, 30.0) 秒
[RTD   ]   届かないとき: 送信前から 1.0° 未満しか動いていなければ 5.0s 待って**同じ目標へ 1 回だけ**再送（本線と同じ）。それでも届かなければ ABORT（HOME へ自動で戻らない）
[RTD   ]   実測 j4: [-90.0, +60.0] の外は WARN / [-98.0, +68.0] の外は ABORT
==============================================================================
[RTD   ] measure: /Volumes/KIOXIA/r2r2r-data/mecharm_calibration/teach_poses_20261115/measure_20261115_164947.json
[RTD   ]   measured_at = 2026-11-15T16:49:49.117401  block = (-58.1, +245.0) mm  box = (-220.4, +194.8) mm
[RTD   ] 再生直前: 上カメラでマット四隅とブロック画素を確認します
[RTD   ] 再生直前: block = (+194.8, +188.2) mm（measure の homography で換算）
[RTD   ] 確認画像: /Volumes/KIOXIA/r2r2r-data/mecharm_calibration/teach_poses_20261115/prerun_20261115_165242.jpg
[RTD   ] [WARN] ブロックが measure 時から動いています（止めません・項目8）: ブロックが measure 時から 581.1px（≒259.1mm）動いています（許容 10.3px = 5.0mm）。ブロックを戻すか measure をやり直してください
[RTD   ] [WARN]   画素の差 581.1px（許容 10.3px = 5.0mm）/ mm 換算の差 259.15mm
[RTD   ] [WARN]   つかみ損ねる可能性があります。気になるなら Enter の前に measure を取り直してください
[RTD   ] [SAFETY] 再生中はグリッパーが実機で開閉します。爪に指を挟まないこと。
[RTD   ] [SAFETY] 止めるときはアームの電源を切ること。Ctrl-C は新しい送信をやめるだけで、進行中の移動は止まりません。
[RTD   ] [SAFETY] 開いたかの自動確認はしません（gv は使わない）。STEP 2 で open を送ってから PICK へ降ります。
[RTD   ] 周囲に手・物が無いか確認してください。OK なら Enter で開始

[RTD   ] 試行フォルダ: /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_165245
[RTD   ] 教えた記録のコピー: /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_165245/teach/drag_v2_20261109_094222.json
[RTD   ] recorder に trial_start を送りました。1.0s 待ってから動き出します（mp4 writer が開くまで）
[RTD   ] 爪と肩の電流を 1 秒 10 回で記録します（爪を動かしている間は読みません）→ /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_165245/recording/currents.csv
[RTD   ] 電源 5A: 爪の位置（番地 7:56/57）と電圧（2:62・7:62）も読みます（生の値・未確認の番地）→ /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_165245/recording/power_regs.csv
  [Pi] fresh_mode=1
[RTD   ] daemon_set_fresh_mode(1)（最新コマンド優先・本線 run_pick_place.py L3976 と同じ。647 試行の実績はこの状態）
[STEP  1] MOVE → HOME  daemon_send_angles(HOME, 20)
[STEP  1] 到達待ち 許容 2.5°[TOL_HOME（stage1_to_home / HOME 復帰）] / 最大 8.0s
[RTD   ] 先頭移動: 送信直前の実測で max|Δ| = 1.66° / 到達待ち 最大 8.0s
[STEP  1] 3.0s 待ちます（settle）
[RTD   ] arrival OK (current → HOME, max|Δ|=1.66° <= tol 2.5°)
[STEP  2] GRIPPER OPEN → daemon_set_gripper(0, 50, wait=0)
[RTD   ] 静止確認 OK（step2_open: 連続 3 回・連続差 最大 0.00° <= 1.0°）
  [Pi] GRIPPER: OPEN result= None
[RTD   ] gripper open (1/1 回目) の daemon 往復 = 2.012s
[STEP  2] open 後 2.0s 待ちます（本線の daemon wait=2 相当・読み取りなし）
[STEP  2] gripper dwell 2.0s（読み取りなし）
[STEP  3] MOVE → APPROACH_PICK  segment HOME → APPROACH_PICK  (1 回送信 speed=20 → 到達待ち 許容 2.0°[TOL_APPROACH（approach 系）] / 最大 12.6s)
[RTD   ] 送信 OK（daemon 往復 1.055s）
[RTD   ] arrival OK (HOME → APPROACH_PICK, max|Δ|=1.32° <= tol 2.0°)
[STEP  4] MOVE → PICK  segment APPROACH_PICK → PICK  (1 回送信 speed=20 → 到達待ち 許容 3.0°[TOL_PICK_PLACE（stage4_pick）] / 最大 8.0s)  [critical]
[RTD   ] 送信 OK（daemon 往復 1.028s）
[RTD   ] arrival OK (APPROACH_PICK → PICK, max|Δ|=1.67° <= tol 3.0°)
[STEP  5] GRIPPER CLOSE → daemon_set_gripper_value(20, 50)
[RTD   ] 静止確認 OK（step5_close: 連続 3 回・連続差 最大 0.00° <= 1.0°）
  [Pi] GRIPPER: VALUE=20 speed=50 result= None
[RTD   ] gripper close (1/1 回目) の daemon 往復 = 0.002s
[STEP  5] gripper dwell 2.0s（読み取りなし）
[STEP  6] MOVE → APPROACH_PICK (lift)  segment PICK → APPROACH_PICK (lift)  (1 回送信 speed=20 → 到達待ち 許容 3.0°[TOL_LIFT_BACK（lift の残差 2.19° を吸収）] / 最大 8.0s)
[RTD   ] 送信 OK（daemon 往復 1.030s）
[RTD   ] arrival OK (PICK → APPROACH_PICK (lift), max|Δ|=1.93° <= tol 3.0°)
[STEP  7] MOVE → APPROACH_PLACE  segment APPROACH_PICK → APPROACH_PLACE  (1 回送信 speed=20 → 到達待ち 許容 3.0°[TOL_APPROACH_PLACE（stage7）] / 最大 14.6s)
[RTD   ] 送信 OK（daemon 往復 1.031s）
[RTD   ] arrival OK (APPROACH_PICK → APPROACH_PLACE, max|Δ|=1.76° <= tol 3.0°)
[STEP  8] MOVE → PLACE  segment APPROACH_PLACE → PLACE  (1 回送信 speed=20 → 到達待ち 許容 3.0°[TOL_PICK_PLACE（stage8_place）] / 最大 8.0s)  [critical]
[RTD   ] 送信 OK（daemon 往復 1.021s）
[RTD   ] arrival OK (APPROACH_PLACE → PLACE, max|Δ|=2.99° <= tol 3.0°)
[STEP  9] GRIPPER OPEN → daemon_set_gripper(0, 50, wait=0)
[RTD   ] 静止確認 OK（step9_open: 連続 3 回・連続差 最大 0.09° <= 1.0°）
  [Pi] GRIPPER: OPEN result= None
[RTD   ] gripper open (1/1 回目) の daemon 往復 = 2.013s
[STEP  9] open 後 2.0s 待ちます（本線の daemon wait=2 相当・読み取りなし）
[STEP  9] gripper dwell 2.0s（読み取りなし）
[STEP 10] MOVE → APPROACH_PLACE (retreat)  segment PLACE → APPROACH_PLACE (retreat)  (1 回送信 speed=20 → 到達待ち 許容 3.0°[TOL_LIFT_BACK（stage10_lift_back）] / 最大 8.0s)
[RTD   ] 送信 OK（daemon 往復 1.031s）
[RTD   ] arrival OK (PLACE → APPROACH_PLACE (retreat), max|Δ|=2.28° <= tol 3.0°)
[STEP 11] MOVE → HOME  segment APPROACH_PLACE → HOME  (1 回送信 speed=20 → 到達待ち 許容 2.5°[TOL_HOME（stage1_to_home / HOME 復帰）] / 最大 10.5s)
[RTD   ] 送信 OK（daemon 往復 1.031s）
[RTD   ] arrival OK (APPROACH_PLACE → HOME, max|Δ|=2.37° <= tol 2.5°)
  [Pi] fresh_mode=0
[RTD   ] daemon_set_fresh_mode(0) 完了
[RTD   ] 実測角の読み取り: ok 56/56 回, 実効 1.60 Hz（目標 3.0 Hz 以上）
[RTD   ] [WARN] 実測角の読み取りが目標 3.0 Hz を下回りました（1.60 Hz）。学習データの state 密度が 19 本より薄くなります
[RTD   ] send_angles の daemon 往復 (7 回): 平均 1.032s / p50 1.031s / 最大 1.055s（timeout 6.0s）
[RTD   ] [WARN] 送信 1 回に 1.055s かかった回があります。daemon は送信後に角度を読み直すので、動き始めで読めないと伸びます（単発送信なので試行全体への影響は小さい）
[RTD   ] 区間の所要（送信→到達確認まで）(8 区間): 平均 2.25s / 最大 4.45s
[RECORD] 電流の記録終了 51 行 (1.45 行/秒. 本体が眠っている間だけ読む. 爪の間 14.049 秒は読まない. 見込み超え 0 回. read_servo)  → /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_165245/recording/currents.csv
[RECORD] 爪の位置と電圧 40 行 (読めた数 {'7:56': 20, '7:57': 20, '2:62': 20, '7:62': 20})  → /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_165245/recording/power_regs.csv
==============================================================================
[RTD   ] 再生 完了
==============================================================================
[RTD   ] つかめたか (y/n) > y
[RTD   ] 箱に入ったか (y/n) > y
[RTD   ] 試行 JSON: /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_165245/run_0001_20261115_165245.json
[LEDGER] append OK: /Volumes/KIOXIA/r2r2r-data/runs/pick_place_ledger_v3.csv (pick=yes place=yes recording_status=ok)
[RTD   ] 次に進むには: python3 /Users/shimazueiichi/r2r2r-scripts/pi05/build_demo_episodes.py --run run_0001_20261115_165245 --dataset mecharm_redblock_box_teach_v1
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % python3 pi05/teach_state_rate.py --before run_0001_20261109_094839 run_0001_20261109_095308 --after run_0001_20261115_165039 run_0001_20261115_165245 --out
```

### 直す前（11/9）と案1（11/15）を比べた表


```

## before (2 本)
  run | actual | うち電流 | 間 中央 | 90% | 1秒超 | poll中央 | send中央 | 本体だけ中央 | 本体90% | 電流だけ中央 | 逆順 | 送らず | 見込み超え | 静止reads | 再送 | 待ち | 結果
  run_0001_20261109_094839 | 66 | 0 | 0.324 | 1.057 | 11 | 0.324 | 1.056 | 0.324 | 1.057 | - | 0 | - | 0 | 12 | 0 | - | completed
  run_0001_20261109_095308 | 63 | 0 | 0.323 | 1.054 | 11 | 0.322 | 1.053 | 0.323 | 1.054 | - | 0 | - | 0 | 12 | 0 | - | completed
  (本ごとの中央値) actual 64.500 | うち電流 0.000 | 間 中央 0.324 | 90% 1.056 | 1秒超 11.000 | poll中央 0.323 | send中央 1.055 | 本体だけ中央 0.324 | 本体90% 1.056 | 電流だけ中央 - | 逆順 0.000 | 送らず - | 見込み超え 0.000 | 静止reads 12.000 | 再送 0.000

## after (2 本)
  run | actual | うち電流 | 間 中央 | 90% | 1秒超 | poll中央 | send中央 | 本体だけ中央 | 本体90% | 電流だけ中央 | 逆順 | 送らず | 見込み超え | 静止reads | 再送 | 待ち | 結果
  run_0001_20261115_165039 | 94 | 43 | 0.116 | 1.046 | 11 | 0.108 | 1.053 | 0.322 | 1.062 | 0.293 | 0 | 0 | 0 | 12 | 0 | - | completed
  run_0001_20261115_165245 | 107 | 51 | 0.116 | 0.674 | 11 | 0.112 | 1.048 | 0.324 | 1.048 | 0.285 | 0 | 0 | 0 | 12 | 0 | - | completed
  (本ごとの中央値) actual 100.500 | うち電流 47.000 | 間 中央 0.116 | 90% 0.860 | 1秒超 11.000 | poll中央 0.110 | send中央 1.051 | 本体だけ中央 0.323 | 本体90% 1.055 | 電流だけ中央 0.289 | 逆順 0.000 | 送らず 0.000 | 見込み超え 0.000 | 静止reads 12.000 | 再送 0.000

## 区間ごと (群ごとの中央値: 送信の往復 (待ちを含む) / daemon だけの往復 / 区間の長さ / 静止の確かめの reads)
  step 1 move HOME  before: n=2 rtt 1.039 daemon - 長さ 4.482 reads -  /  after: n=2 rtt 1.031 daemon - 長さ 4.470 reads -
  step 2 gripper open  before: n=2 rtt - daemon - 長さ - reads 4.000  /  after: n=2 rtt - daemon - 長さ - reads 4.000
  step 3 move APPROACH_PICK  before: n=2 rtt 1.037 daemon - 長さ 5.109 reads -  /  after: n=2 rtt 1.042 daemon - 長さ 3.490 reads -
  step 4 move PICK  before: n=2 rtt 1.037 daemon - 長さ 1.079 reads -  /  after: n=2 rtt 1.030 daemon - 長さ 1.063 reads -
  step 5 gripper close  before: n=2 rtt - daemon - 長さ - reads 4.000  /  after: n=2 rtt - daemon - 長さ - reads 4.000
  step 6 move APPROACH_PICK (lift)  before: n=2 rtt 1.041 daemon - 長さ 1.073 reads -  /  after: n=2 rtt 1.031 daemon - 長さ 1.059 reads -
  step 7 move APPROACH_PLACE  before: n=2 rtt 1.039 daemon - 長さ 3.005 reads -  /  after: n=2 rtt 1.040 daemon - 長さ 3.021 reads -
  step 8 move PLACE  before: n=2 rtt 1.030 daemon - 長さ 2.683 reads -  /  after: n=2 rtt 1.030 daemon - 長さ 1.069 reads -
  step 9 gripper open  before: n=2 rtt - daemon - 長さ - reads 4.000  /  after: n=2 rtt - daemon - 長さ - reads 4.000
  step 10 move APPROACH_PLACE (retreat)  before: n=2 rtt 1.046 daemon - 長さ 1.085 reads -  /  after: n=2 rtt 1.034 daemon - 長さ 1.067 reads -
  step 11 move HOME  before: n=2 rtt 1.029 daemon - 長さ 2.353 reads -  /  after: n=2 rtt 1.043 daemon - 長さ 2.045 reads -
```

| | 直す前（11/9・2本） | 案1（11/15・2本） |
|---|---|---|
| 角度の行の数 | 64.5 | 100.5（うち電流の記録から47） |
| 間隔の中央値 | 0.324秒 | 0.116秒 |
| 間隔の90%点 | 1.056秒 | 0.860秒 |
| 1秒を超える抜け | 11 | 11 |
| 送信の往復 | 1.055秒 | 1.051秒 |
| 静止の確かめの回数 | 12 | 12 |
| 時刻の逆順・見込み超え・再送 | 0 | 0 |

- ねらい：アームの動きを変えずに、捨てていた角度を記録に残す
- 変わったこと：間隔の中央値が0.324秒から0.116秒になった。送信の往復・静止の確かめの回数・再送は変わっていない
- 見込める効果：補った値で埋める間が短くなり、お手本の角度が実際の動きに近づく。ただし1秒を超える抜けは11か所のまま残った

区間の長さには、変わった所があります（HOME から APPROACH_PICK が5.1秒から3.5秒、APPROACH_PLACE から PLACE が2.7秒から1.1秒）。案1は角度を読むだけで動きには触れていないので、届くのが早くなったのは電源を5Aにしたためだと見ています。ただ、到達を0.32秒おきに確かめているので、区間の長さはもともと揺れます。




## 依頼213（案2）：送ったあとの1秒を Mac で待ち、その間も読む

案1で残った11か所の抜けは、8か所が送ったあとの約1秒、3か所が爪を動かしている間でした。前の回の調べでは、アームが動いた量の56〜59%が、送ったあとの1秒の中にありました。ここを読まないと、動いている最中の角度はお手本に入りません。

案2では、daemon には「待たずに返事をして」（`wait=0`）と送り、返事が来てから Mac の側で1.0秒待ちます。待つ長さは同じ1.0秒なので、前から決めている「送ったあとの待ちを短くしない」には当たりません。待つ場所を Pi の中から Mac に移すだけで、その間に電流の記録が角度を読めるようになります。ただ、送った直後にアームへ読みの命令を出すようになるので、物理的リスクは中と見て、codex のレビューを必ず通すことにしました。

### 依頼213 の依頼文

```markdown
---
作業フォルダ: /Users/shimazueiichi/r2r2r-scripts
上限時間: 120
---
# 依頼213：手教示の再生で、送信のあとの 1.0 秒の待ちを daemon から Mac 側へ移し、その間も角度を読む（依頼197 の案2）

実機は動かさない（実装・テスト・レビューまで）。Pi にもつながない（テストは偽の daemon で）。Log37。
物理的リスク：中（関節の指令の中身は変えないが、送った直後の 1 秒にシリアルを読むようになる）。codex のレビューを必ず通す。

## なぜ
依頼202（案1・c68ba07）を実機で2本確かめた（run_0001_20261115_165039・165245。比べた結果は KIOXIA runs/experiments/teach_state_rate/20261115_165444/）。角度の間隔の中央値は 0.324 → 0.116 秒になったが、1 秒を超える抜けは 11 のまま。送信の待ち（wait=1.0 で daemon が寝ている約 1.05 秒）の間は読めず、アームが動いた量の 56〜59% がこの中にある（依頼197）。
エイイチの決め（2026-11-15）：案2に進む。「SENDWAIT 1.0（DAY266: 短縮しない）」は「待つ長さは 1.0 秒のまま、待つ場所を daemon から Mac に移す」と読み替えてよい。待つ長さは縮めない。

## やること
1. record_teach_demo.py の `_send_angles_guarded` の送信を `daemon_send_angles(pose, speed, wait=0)` にし、返ったあと Mac 側で SEND_WAIT_SEC（1.0 秒）待ってから `_hold_until_arrival` に入る。この 1.0 秒の間は、案1 の電流の記録スレッドが読めるようにする（爪の open の事後の待ちを Mac 側に移したときと同じ形）
2. 到達の確かめが始まる時刻（送ってから約 1.03 秒後）、本体の読みの回数、静止の確かめ、爪の前後の止め方、爪の待ち、速さ・目標・再送の決まりは変えない
3. 送った直後の 1 秒の読みは、今の電流スレッドの読み方（read_servo・1 回の見込み時間を超えそうなら読まない）のまま。送信と読みが同じ鍵で順に出るか（送信の途中に読みが割り込まないか）を確かめる
4. 切り替えられるようにする（例 `--send-wait-on mac|daemon`、既定は mac）。daemon を選ぶと依頼202 までと同じ動きになる。どちらで撮ったかを試行 JSON に残す
5. Pi の daemon は 11/5 版（read_angles_once_for_log・GET_ANGLES_INTERVAL_SEC = 0.02・read_servo がある）が入っていることを 11/15 に確かめ済み。wait=0 で送ったときの daemon の動き（送った直後に1回読み直す）を tools/pi/mecharm_daemon.py で読んで、報告に書く
6. CLAUDE.md の禁止事項「time.sleep() を削除・短縮しない」との関係を報告に書く（今回は場所を移すだけで長さは同じ）。CLAUDE.md は変えない
7. 実機で確かめる手順とコマンドを報告に書く（位置1・drag_v2_20261109_094222.json・--grip-value 20 --power 5A で1本 → teach_state_rate.py で 165039・165245 と並べる。見る所：1 秒を超える抜けの数、送信の往復、区間の長さ、到達・再送、送信が無視されていないか）
8. テストを足し、既存のテスト（pi05/ と test_lab_start.sh。test_state_source は前から落ちるので除く）も通す。codex で差分を見てもらい、必須の指摘がなくなるまで直す
9. record_teach_demo.py は git の外なので、直す前の写しを .bak_pre_req213_20261115 で残す。ほかは変えたファイルだけを指定して git add・commit（git add . と git clean は使わない）

## 報告
変えた所、1 秒の間に読める見込みの回数、実機で確かめるコマンド、決めてほしいこと
```

### 依頼213 で Claude Code が返した報告

```markdown
# 結果：20261115_213_手教示の送信のあとの1秒をMacで待ち角度を読む

- 状態：完了
- 始めた時刻：2026-11-15 17:43
- 終わった時刻：2026-11-15 18:48（65分）
- 作業フォルダ：/Users/shimazueiichi/r2r2r-scripts
- この続きを Claude Code で話すとき：作業フォルダで `claude --resume f5be26c4-141a-4520-8f8d-c0380e3ba770`

## Claude Code の報告

やったこと
- record_teach_demo.py の送信を変えました。daemon には `wait=0` で送り、返事が来てから Mac 側で 1.0 秒待って、それから到達の確かめに入ります。
  - この 1.0 秒は、電流の記録スレッドに「daemon を使わない時間」として知らせるので、その間も角度を読めます。読み方は今のまま（read_servo・見込み 0.15 秒を超えそうなら読まない）です。
  - ソケットの期限は、daemon で待っていたときと同じ 4.0 秒を渡しています。何も渡さないと既定の 35 秒になるためです。
  - 送信が例外になっても 1.0 秒は待ちます。Ctrl-C のときは待ちません。
- `--send-wait-on mac|daemon` を足しました。既定は mac です。daemon を選ぶと依頼202 までと同じ動きになります。
- 試行 JSON のいちばん上・params・区間ごとに `send_wait_on` を残し、区間ごとに daemon だけの往復（`send_daemon_rtt_sec`）も残します。teach_state_rate.py にも「待ち」の列を足しました。
- 変えていないもの：関節の目標・速さ・送る回数、到達と静止の確かめ、爪の前後で読みを止めること、爪の待ち、再送の決まり。send_coords は使っていません。
- Pi の daemon（tools/pi/mecharm_daemon.py）で `wait=0` のときの動き：書き込み（約 10 ms）→ 眠らない → `read_angles_once_for_log()` で 1 回だけ読む（読み直さない）→ 返事。返事まで約 0.03 秒で、そのあと Mac が 1.0 秒待ちます。なので到達の確かめが始まるのは、今までと同じく送ってから約 1.03 秒後です。
- 送信と読みは同じ鍵の中で 1 件ずつ出ます。送信の途中に読みが割り込まないことをテストで確かめました。
- CLAUDE.md の「time.sleep() を削除・短縮しない」との関係：待つ長さは 1.0 秒のままで、daemon の中の眠りを Mac 側へ移しただけです。CLAUDE.md は変えていません。
- 既存の test_teach_currents.py と test_teach_current_actuals.py は daemon で待つ形に固定しました。この 2 つの偽の daemon は `wait` を見ずに 1.6 秒で返すので、mac だと Mac 側の 1.0 秒が上乗せになり、本物と違う時刻の流れになるためです。
- 直す前の写しは record_teach_demo.py.bak_pre_req213_20261115 に残しました。

結果
- **1 秒の間に読める見込み**：約 7〜8 回です。11/15 の本の read_servo は中央値 107〜114 ms で、送ってから約 0.8 秒までに始まる読みが入ります。1 本で 8 回送るので、actual 行が約 55〜65 行増える見込みです。
- **偽の daemon での数字**：
  - 1.0 秒ごとに 8 回読めました。
  - 1 秒を超える抜けは daemon で待つ形 11 → mac で待つ形 3 です（残りの 3 は爪の待ちで、爪の間は今までどおり読みません）。
  - 送ってから到達の確かめが始まるまでは、mac 1.039〜1.066 秒、daemon 1.040〜1.065 秒で、縮んでいません。
- **テスト**：新しい test_send_wait_mac.py は 25 件で、2 回続けて OK でした。pi05 のテスト 27 本（test_state_source を除く）はすべて OK、test_lab_start.sh は OK 237 / NG 0 です。
- **codex レビュー 3 回**：
  - 1 回目は必須 1 件：窓の終わりぎわの読みが長引くと、到達の確かめが遅れる。依頼121 からの読み方そのものなので読み方は変えず、テストを足しました（窓の終わりで 0.5 秒長引くと、本体の次の読みが 1.03 → 約 1.39 秒に遅れる。早まりはせず、見込み超え（overruns）に数える）。2 回目で「据え置きでよい」となりました。
  - 推奨 2 件（例外のときも往復時間を残す、テストを足す）は直しました。
  - 3 回目は必須なし・推奨なしでした。そのあと直したのはテストだけです。
- **時刻のゆらぎ**：混んだ Mac では、別々に流した 2 回の再生で本体の読みの数が 1 回ずれることがあります。依頼202 までと同じ形の既存テストでも 8 回中 1 回起きたので、前からあるものです。新しいテストは、読みの数の差を 1 回まで許し、stage と爪の通知はぴったり同じであることを見る形にしました。
- 実機は動かしておらず、Pi にもつないでいません。
- **実機で確かめるコマンド**（位置1 にブロックを置いてから）：
  1. `python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py measure`
  2. `python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py run --teach drag_v2_20261109_094222.json --grip-value 20 --power 5A`（ドライラン。「Mac 側」と出るのを見る）
  3. 同じコマンドに `--execute` を付けて 1 本撮る
  4. `python3 pi05/teach_state_rate.py --before run_0001_20261115_165039 run_0001_20261115_165245 --after run_0001_20261115_HHMMSS --out`
  5. 見る所：
     - 1 秒を超える抜けの数（前の 2 本は 11）
     - 送信の往復：rtt が約 1.03 秒、daemon だけの往復が約 0.03 秒
     - 区間の長さが前の 2 本と同じくらいか
     - 到達・再送、overruns が 0 のままか
     - 送信が無視されていないか（warnings に retry_sent が無いこと）
  6. 戻すときは `--send-wait-on daemon` を付けます。

変えたファイル
- dynamic_tracking_limits/drag_teaching/record_teach_demo.py（git の外）
- pi05/teach_state_rate.py
- pi05/test_send_wait_mac.py（新しく）
- pi05/test_teach_currents.py
- pi05/test_teach_current_actuals.py
- コミットは 4a017f3 です（record_teach_demo.py を除く 4 つを個別に add）。報告は claude_code_reports/20261115_213.txt と logs/20261115_1848.md に書きました。

決めてほしいこと
- 窓の終わりぎわに始めた読みが長引いたとき、本体の読みが遅れるのをどこまで許すか。今は依頼121 からの決まりのままで、最大で read_servo 1 回の期限 1.5 秒まで遅れ、overruns に数えます。この遅れが起こりうる回は、1 本あたり 8 回増えます。11/15 の 2 本は overruns 0、read_servo の最大は 212 ms でした。実機の 1 本で overruns を見てから、窓の終わりの余白（今 0.02 秒）を広げるかを決めてください。
- 実機の 1 本（上の手順）を撮るかどうかと、その時期。
```

### 依頼213 のコードの差分（コミット 4a017f3）

```diff
commit 4a017f3dd03178805c307ac6cf72ec54cac773e7
Author: Eiichi Shimazu <studio@adaptdesign.jp>
Date:   Sun Nov 15 18:47:59 2026 +0900

    手教示の再生で送信のあとの 1.0 秒を Mac 側で待つ形 (依頼 213・依頼 197 の案 2・Log37) のテストと集計の列を足す
    
    record_teach_demo.py (git の外) は daemon へ wait=0・期限 4.0 秒で送り, 返ってから Mac 側で SEND_WAIT_SEC (1.0 秒) 眠る
    (--send-wait-on mac が既定. daemon は依頼 202 までと同じ). 待つ長さは変えない. その間は電流の記録スレッドが read_servo で読む.
    - test_send_wait_mac.py: wait を本物の daemon どおり扱う偽の daemon で mac / daemon を比べる (25 件)
    - teach_state_rate.py: 本ごとの「待ち」(send_wait_on) と区間ごとの daemon だけの往復を出す
    - test_teach_currents.py / test_teach_current_actuals.py: 偽の daemon が wait を見ないので daemon 側の待ちに固定
    pi05 のテスト 27 本 OK (test_state_source を除く)・test_lab_start.sh OK 237. codex 3 回で必須なし. 実機は動かしていない.
    
    Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

diff --git a/pi05/teach_state_rate.py b/pi05/teach_state_rate.py
index 5020526..1e02685 100644
--- a/pi05/teach_state_rate.py
+++ b/pi05/teach_state_rate.py
@@ -138,6 +138,8 @@ def measure(d):
         out["json_error"] = f"{type(e).__name__}"
     cur = j.get("currents") or {}
     out.update({"result": j.get("result"), "overruns": cur.get("overruns"),
+                # 依頼 213: 送信のあとの 1.0 秒をどこで待ったか (mac / daemon. 依頼 213 より前の本は項目がないので -)
+                "send_wait_on": j.get("send_wait_on"),
                 "sent_current_thread": j.get("recorder_actual_events_sent_current_thread"),
                 "late_current_thread": j.get("recorder_actual_current_thread_late"),
                 "actual_sampling_reads_ok": (j.get("actual_sampling") or {}).get("reads_ok")})
@@ -147,6 +149,7 @@ def measure(d):
         segs.append({"run": name, "step": g.get("step"), "kind": g.get("kind"),
                      "name": g.get("to_name") if g.get("kind") == "move" else g.get("action"),
                      "send_rtt_sec": g.get("send_rtt_sec"), "segment_elapsed_sec": g.get("segment_elapsed_sec"),
+                     "send_daemon_rtt_sec": g.get("send_daemon_rtt_sec"),   # 依頼 213: daemon とのやりとりだけ
                      "retried": g.get("retried"), "arrival_ok": g.get("arrival_ok"),
                      "still_reads": sc.get("reads"), "still_elapsed_sec": sc.get("elapsed_sec"),
                      "still": sc.get("still")})
@@ -167,7 +170,7 @@ RUN_COLS = [("run", "run"), ("n_actual", "actual"), ("n_current_thread", "うち
             ("all_p90", "90%"), ("all_long_n", "1秒超"), ("all_poll_median", "poll中央"), ("all_send_median", "send中央"),
             ("main_median", "本体だけ中央"), ("main_p90", "本体90%"), ("cur_median", "電流だけ中央"),
             ("order_reversed", "逆順"), ("late_current_thread", "送らず"), ("overruns", "見込み超え"),
-            ("still_reads_total", "静止reads"), ("retried_n", "再送"), ("result", "結果")]
+            ("still_reads_total", "静止reads"), ("retried_n", "再送"), ("send_wait_on", "待ち"), ("result", "結果")]
 
 
 def print_group(label, ms):
@@ -180,12 +183,12 @@ def print_group(label, ms):
             v = [m[k] for m in ms if isinstance(m.get(k), (int, float))]
             return statistics.median(v) if v else None
         print("  (本ごとの中央値) " + " | ".join(
-            f"{h} {fmt(med(k))}" for k, h in RUN_COLS[1:] if k not in ("result",)))
+            f"{h} {fmt(med(k))}" for k, h in RUN_COLS[1:] if k not in ("result", "send_wait_on")))
 
 
 def print_segments(groups):
     """区間ごと (step 順) に, 群ごとの中央値を並べる. 区間の並びが群で違えば step の名前で分かる."""
-    print("\n## 区間ごと (群ごとの中央値: 送信の往復 / 区間の長さ / 静止の確かめの reads)")
+    print("\n## 区間ごと (群ごとの中央値: 送信の往復 (待ちを含む) / daemon だけの往復 / 区間の長さ / 静止の確かめの reads)")
     keys = []
     for _, segs in groups:
         for s in segs:
@@ -200,7 +203,8 @@ def print_segments(groups):
             def med(f):
                 v = [s[f] for s in ss if isinstance(s.get(f), (int, float)) and not isinstance(s.get(f), bool)]
                 return statistics.median(v) if v else None
-            cells.append(f"{label}: n={len(ss)} rtt {fmt(med('send_rtt_sec'))} 長さ {fmt(med('segment_elapsed_sec'))}"
+            cells.append(f"{label}: n={len(ss)} rtt {fmt(med('send_rtt_sec'))} daemon {fmt(med('send_daemon_rtt_sec'))}"
+                         f" 長さ {fmt(med('segment_elapsed_sec'))}"
                          f" reads {fmt(med('still_reads'))}")
         print(f"  step {k[0]} {k[1]} {k[2]}  " + "  /  ".join(cells))
 
diff --git a/pi05/test_send_wait_mac.py b/pi05/test_send_wait_mac.py
new file mode 100644
index 0000000..5ea86dd
--- /dev/null
+++ b/pi05/test_send_wait_mac.py
@@ -0,0 +1,464 @@
+#!/usr/bin/env python3
+"""test_send_wait_mac.py — 手教示の再生で, 送信のあとの 1.0 秒の待ちを daemon から Mac 側へ移し, その間も
+電流の記録スレッドが角度を読む形 (依頼 213. 依頼 197 の案 2) を偽の daemon で確かめる (アームなし・Pi なし. 2026-11-15).
+
+  python3 pi05/test_send_wait_mac.py          # 全部 (再生を 2 回通すので 1 分半ほど)
+  python3 pi05/test_send_wait_mac.py -v
+
+偽の daemon は test_teach_current_actuals.PoseDaemon (read_servo の角度が腕の今の角度) で, send_angles だけ
+本物の tools/pi/mecharm_daemon.py と同じ形にする: 書き込み → wait 秒眠る → 角度を 1 回読む → 返事.
+
+確かめること:
+  - --send-wait-on mac (既定): daemon へは wait=0・ソケットの期限 4.0 秒 (wait+3.0 と同じ) で送り, 返ってから
+    Mac 側で 1.0 秒待つ. この間に電流の記録スレッドが read_servo で読み, states.csv の actual 行になる
+  - 到達の確かめ (本体の最初の get_angles) が始まる時刻は送信の始めから 1.0 秒 + 書き込みと読み 1 回 のあと
+    (daemon で待つときと同じ. 縮んでいない)
+  - 本体が daemon に送る命令 (関節の目標・速さ・爪) と順, 本体の読みの回数, 到達・再送・静止の確かめは daemon で
+    待つときと同じ (違うのは send_angles の wait だけ)
+  - 送信と読みは同じ鍵で順に出る (送信の途中に read_servo が割り込まない. 鍵の中の時刻で重ならない)
+  - 爪の命令から待ちの終わりまでは今までどおり読まない
+  - --send-wait-on daemon は依頼 202 までと同じ (wait=1.0 を daemon へ. Mac 側で待たない. その間は読まない)
+  - 区間と試行 JSON に send_wait_on・send_daemon_rtt_sec が残る. teach_state_rate.py が待ちの列を出す
+  - _send_angles_guarded: 送信が例外でも 1.0 秒待ってから例外を返す・Ctrl-C は待たない・姿勢検査で弾いたら送らず待たない
+  - コマンドの --send-wait-on の既定は mac・ほかの値は受け付けない
+  - (codex R1) 窓の終わりぎわの read_servo が長引くと本体の次の読みはその分遅れる (早まらない・overruns に数える)
+  - (codex R3) 送信が 4.0 秒で返らなければ切れて, 1.0 秒待ってから例外. 次の命令はつなぎ直して通る
+KIOXIA にもアームにも触らない (一時フォルダと 127.0.0.1 だけ).
+"""
+import io
+import sys
+import tempfile
+import threading
+import time
+import unittest
+from pathlib import Path
+from unittest import mock
+
+_HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(_HERE))
+sys.path.insert(0, str(_HERE.parent / "dynamic_tracking_limits" / "drag_teaching"))
+
+import test_teach_currents as ttc  # noqa: E402
+import test_recorder_currents as trc  # noqa: E402
+import test_teach_current_actuals as tca  # noqa: E402  (PoseDaemon・write_states)
+import policy_recorder as pr  # noqa: E402
+import visual_servo_pick as vsp  # noqa: E402
+import record_teach_demo as rtd  # noqa: E402
+import teach_state_rate as tsr  # noqa: E402
+
+WRITE_SEC = 0.010           # 本物の _mc.send_angles() の書き込み (実測 約 10 ms)
+READ_ONCE_SEC = trc.OVERHEAD_SEC + trc.ANGLES_SEC   # 送ったあとの read_angles_once_for_log 1 回
+
+
+class WaitDaemon(tca.PoseDaemon):
+    """send_angles を本物の daemon と同じ形にする: 書き込み → wait 秒眠る → 角度を 1 回読む → 返事."""
+
+    def _handle(self, c):
+        if c.get("cmd") != "send_angles":
+            return super()._handle(c)
+        t0 = time.time()
+        self.cmds.append(c)
+        n = self.n_send
+        self.n_send += 1
+        time.sleep(WRITE_SEC)
+        if n not in self.ignore_sends:
+            start, goal = self.pose(), [float(x) for x in c["angles"]]
+            self.cur = goal
+            self.move = (start, goal, time.time(),
+                         max(abs(x - y) for x, y in zip(start, goal)) / ttc.ARM_DEG_PER_SEC)
+        wait = float(c.get("wait", 0))
+        if wait > 0:
+            time.sleep(wait)
+        time.sleep(READ_ONCE_SEC)
+        with self.span_lock:
+            self.spans.append(("send_angles", t0, time.time(), dict(c)))
+        return {"ok": True, "result": 1, "elapsed_ms": WRITE_SEC * 1000.0}
+
+
+def replay(mode, run_dir, ignore_sends=()):
+    """cmd_run と同じ順で再生を 1 回通す. 戻り値: dict (result・通知・log_record・daemon・鍵の中の時刻)."""
+    d = WaitDaemon(ignore_sends=ignore_sends)
+    rpcs = []
+
+    def obs(cmd_obj, resp, t0, t1, err):
+        rpcs.append(((cmd_obj or {}).get("cmd"), t0, t1, threading.current_thread().name))
+    pr.add_rpc_observer(obs)
+    try:
+        result, sent, log_record, recorder = tca.replay(d, run_dir, sink=True, send_wait_on=mode)
+    finally:
+        pr.remove_rpc_observer(obs)
+        d.close()
+    return {"result": result, "sent": sent, "lr": log_record, "rec": recorder, "d": d, "rpcs": rpcs}
+
+
+def sends(d):
+    return [s for s in d.spans if s[0] == "send_angles"]
+
+
+def next_main_get(d, after):
+    """after より後で最初の本体の get_angles の始め (記録スレッドは get_angles を使わない)."""
+    return min(s[1] for s in d.spans if s[0] == "get_angles" and s[1] >= after)
+
+
+class TestReplaySendWait(unittest.TestCase):
+    """再生を 2 回 (mac / daemon. どちらも電流を記録し角度を states.csv に渡す) 通して比べる."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.td = Path(tempfile.mkdtemp())
+        pr.install_daemon_lock()
+        cls.mac = replay("mac", cls.td / "run_0001_20991115_000001")
+        cls.dmn = replay("daemon", cls.td / "run_0002_20991115_000002")
+        root = cls.td / "states"
+        cls.st_mac = tca.write_states(root, "run_0001_20991115_000001", cls.mac["sent"])
+        cls.st_dmn = tca.write_states(root, "run_0002_20991115_000002", cls.dmn["sent"])
+
+    def test_completed(self):
+        self.assertEqual((self.mac["result"], self.dmn["result"]), ("completed", "completed"))
+
+    def test_wait_sent_to_daemon(self):
+        """mac は wait=0, daemon は wait=1.0 を送る. ほかの中身 (目標・速さ) と順は同じ."""
+        wm = {s[3].get("wait") for s in sends(self.mac["d"])}
+        wd = {s[3].get("wait") for s in sends(self.dmn["d"])}
+        self.assertEqual((wm, wd), ({0}, {rtd.SEND_WAIT_SEC}))
+        strip = lambda d: [(s[0], {k: v for k, v in s[3].items() if k != "wait"})  # noqa: E731
+                           for s in d.spans if s[0] in ("send_angles", "set_gripper", "set_gripper_value",
+                                                        "set_fresh_mode")]
+        self.assertEqual(strip(self.mac["d"]), strip(self.dmn["d"]))
+
+    def test_socket_timeout_kept(self):
+        """mac の wait=0 でもソケットの期限は daemon で待つときと同じ 4.0 秒 (既定の 35 秒にしない)."""
+        seen = []
+        orig = vsp._daemon_request
+
+        def spy(cmd_obj, timeout_override=None, **k):
+            seen.append((cmd_obj.get("wait"), timeout_override))
+            return {"ok": True, "elapsed_ms": 1.0}
+        with mock.patch.object(vsp, "_daemon_request", spy), mock.patch.object(rtd, "SEND_WAIT_ON", "mac"), \
+                mock.patch.object(rtd.time, "sleep", lambda s: None):
+            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t")
+        self.assertIs(vsp._daemon_request, orig)
+        self.assertEqual(seen, [(0, rtd.SEND_WAIT_SEC + 3.0)])
+
+    def test_arrival_start_not_earlier(self):
+        """本体の到達の確かめが始まるのは, どちらも送信の始めから 1.0 秒 + 書き込み + 読み 1 回 のあと."""
+        lo = rtd.SEND_WAIT_SEC + WRITE_SEC + READ_ONCE_SEC
+        delays = {}
+        for name, r in (("mac", self.mac), ("daemon", self.dmn)):
+            ds = []
+            for s in sends(r["d"]):
+                ds.append(next_main_get(r["d"], s[2]) - s[1])
+            delays[name] = ds
+            self.assertGreaterEqual(min(ds), lo - 0.002, name)
+        # mac は daemon と同じ (送信の返事を待つ時間と, 眠りの終わりから起きるまでの時間の分だけずれる)
+        for m, d in zip(delays["mac"], delays["daemon"]):
+            self.assertLess(abs(m - d), 0.08)
+        print(f"\n送信の始め → 到達の確かめの始め (秒): mac {[round(x, 3) for x in delays['mac']]}"
+              f" / daemon {[round(x, 3) for x in delays['daemon']]}")
+
+    def test_mac_reads_during_wait(self):
+        """mac: 送信の返事のあとの 1.0 秒に read_servo が入る. daemon: 送信の間に read_servo は入らない."""
+        per = []
+        for s in sends(self.mac["d"]):
+            end = s[2]
+            n = sum(1 for x in self.mac["d"].spans
+                    if x[0] == "read_servo" and end <= x[1] and x[2] <= end + rtd.SEND_WAIT_SEC + 0.05)
+            per.append(n)
+        self.assertTrue(all(n >= 5 for n in per), per)
+        for s in sends(self.dmn["d"]):
+            inside = [x for x in self.dmn["d"].spans if x[0] == "read_servo" and s[1] <= x[1] < s[2]]
+            self.assertEqual(inside, [])
+        rs = sorted(x[2] - x[1] for x in self.mac["d"].spans if x[0] == "read_servo")
+        print(f"\n送信のあとの 1.0 秒に読めた read_servo の回数 (偽の daemon. 1 回 中央値 {rs[len(rs) // 2] * 1000:.0f} ms):"
+              f" {per} 中央値 {sorted(per)[len(per) // 2]}")
+
+    def test_lock_serializes_send_and_read(self):
+        """送信と read_servo は同じ鍵の中で 1 件ずつ (鍵の中の時刻が重ならない). daemon 側の時刻でも重ならない."""
+        for r in (self.mac, self.dmn):
+            ivs = sorted((t0, t1, c) for c, t0, t1, _ in r["rpcs"] if c in ("send_angles", "read_servo", "get_angles"))
+            self.assertGreater(len(ivs), 50)
+            for (a0, a1, ca), (b0, b1, cb) in zip(ivs, ivs[1:]):
+                self.assertLessEqual(a1, b0 + 1e-6, f"{ca} と {cb} が重なる")
+            threads = {(c, th) for c, _, _, th in r["rpcs"] if c == "read_servo"}
+            self.assertTrue(threads and all(th == "record_currents" for _, th in threads))
+            sp = sorted(r["d"].spans, key=lambda s: s[1])
+            for a, b in zip(sp, sp[1:]):
+                self.assertLessEqual(a[2], b[1] + 1e-6)
+
+    def test_main_unchanged(self):
+        """本体の読みの回数・到達と静止の確かめの結果・本体の通知の並びは daemon で待つときと同じ."""
+        n_get = lambda r: sum(1 for s in r["d"].spans if s[0] == "get_angles")  # noqa: E731
+        # 到達の確かめの回数は腕が着くまでの実時間で決まるので, 別々に流した 2 回の再生では混んだ Mac で 1 回ずれる
+        # ことがある (test_teach_current_actuals の daemon どうしでも起きた). 読み方は同じなので差は 1 回までとする
+        self.assertLessEqual(abs(n_get(self.mac) - n_get(self.dmn)), 1)
+
+        def summary(lr):
+            return [(g.get("kind"), g.get("arrival_ok"), g.get("retried"), tuple(g.get("warnings") or ()),
+                     (g.get("still_check") or {}).get("still"), (g.get("still_check") or {}).get("reads"))
+                    for g in lr["segments"]]
+        self.assertEqual(summary(self.mac["lr"]), summary(self.dmn["lr"]))
+        no_act = lambda r: [k for k in tca.main_kinds(r["sent"]) if k[0] != "actual"]  # noqa: E731
+        self.assertEqual(no_act(self.mac), no_act(self.dmn))               # stage・爪の通知の並びと中身は同じ
+        n_act = lambda r: sum(1 for k in tca.main_kinds(r["sent"]) if k[0] == "actual")  # noqa: E731
+        self.assertLessEqual(abs(n_act(self.mac) - n_act(self.dmn)), 1)    # 本体の actual (= 本体の読み) は上と同じ扱い
+        self.assertEqual(self.mac["lr"]["currents"]["overruns"], 0)
+
+    def test_no_reads_during_gripper(self):
+        for r in (self.mac, self.dmn):
+            for cmd, g0, nxt in ttc.gripper_windows(r["d"].spans):
+                inside = [x for x in r["d"].spans if x[0] == "read_servo" and g0 <= x[1] < nxt - 0.03]
+                self.assertEqual(inside, [], f"{cmd} の待ちの間に read_servo")
+
+    def test_segment_records(self):
+        for r, mode in ((self.mac, "mac"), (self.dmn, "daemon")):
+            moves = [g for g in r["lr"]["segments"] if g.get("kind") == "move" or "send_rtt_sec" in g]
+            self.assertGreater(len(moves), 3)
+            for g in moves:
+                self.assertEqual(g["send_wait_on"], mode)
+                self.assertIsNotNone(g["send_daemon_rtt_sec"])
+                # send_rtt_sec はどちらでも 1.0 秒の待ちを含む
+                self.assertGreaterEqual(g["send_rtt_sec"], rtd.SEND_WAIT_SEC)
+                if mode == "mac":
+                    self.assertLess(g["send_daemon_rtt_sec"], 0.5)
+                else:
+                    self.assertGreaterEqual(g["send_daemon_rtt_sec"], rtd.SEND_WAIT_SEC)
+
+    def test_rate_table(self):
+        """teach_state_rate.py: mac は送信の間の抜けが埋まり 1 秒超の抜けが減る. 待ちの列は試行 JSON から読む."""
+        m_mac, segs = tsr.measure(self.st_mac.parent.parent)
+        m_dmn, _ = tsr.measure(self.st_dmn.parent.parent)
+        self.assertEqual(m_mac["order_reversed"], 0)
+        self.assertLess(m_mac["all_long_n"], m_dmn["all_long_n"])
+        self.assertLess(m_mac["all_p90"], m_dmn["all_p90"])
+        self.assertGreater(m_mac["n_current_thread"], m_dmn["n_current_thread"])
+        print(f"\n偽の daemon での actual の間: daemon で待つ 中央値 {m_dmn['all_median']:.3f} 90% {m_dmn['all_p90']:.3f}"
+              f" 1秒超 {m_dmn['all_long_n']} / mac で待つ 中央値 {m_mac['all_median']:.3f} 90% {m_mac['all_p90']:.3f}"
+              f" 1秒超 {m_mac['all_long_n']} (電流スレッドの行 {m_dmn['n_current_thread']} → {m_mac['n_current_thread']})")
+
+    def test_rate_table_send_wait_column(self):
+        td = Path(tempfile.mkdtemp())
+        run = td / "run_0009_20991115_000009"
+        (run / "recording").mkdir(parents=True)
+        (run / "recording" / "states.csv").write_text(self.st_mac.read_text())
+        import json
+        (run / f"{run.name}.json").write_text(json.dumps({"send_wait_on": "mac", "segments": [
+            {"step": 1, "kind": "move", "to_name": "HOME", "send_rtt_sec": 1.05, "send_daemon_rtt_sec": 0.03}]}))
+        m, segs = tsr.measure(run)
+        self.assertEqual(m["send_wait_on"], "mac")
+        self.assertEqual(segs[0]["send_daemon_rtt_sec"], 0.03)
+        with mock.patch("sys.stdout", new=io.StringIO()) as out:
+            tsr.print_group("後", [m])
+            tsr.print_segments([("後", segs)])
+        self.assertIn("待ち", out.getvalue())
+        self.assertIn("daemon 0.030", out.getvalue())
+
+
+class TestSendRetry(unittest.TestCase):
+    """送信無視 → 5 秒待って再送の経路も mac で通る (再送も Mac 側で 1.0 秒待つ)."""
+
+    def test_retry_path(self):
+        pr.install_daemon_lock()
+        r = replay("mac", Path(tempfile.mkdtemp()) / "run_0003_20991115_000003", ignore_sends=(1,))
+        self.assertEqual(r["result"], "completed")
+        seg = [g for g in r["lr"]["segments"] if g.get("retried")]
+        self.assertEqual(len(seg), 1)
+        self.assertIsNotNone(seg[0]["send_daemon_rtt_retry_sec"])
+        self.assertGreaterEqual(seg[0]["send_rtt_retry_sec"], rtd.SEND_WAIT_SEC)
+        self.assertEqual({s[3].get("wait") for s in sends(r["d"])}, {0})
+
+
+class SlowTailDaemon(WaitDaemon):
+    """送信の返事から slow_after 秒より後に始まる read_servo を slow_sec 秒遅らせる (窓の終わりぎわの読みが長引く場合)."""
+
+    def __init__(self, slow_after=0.7, slow_sec=0.5, send_extra=0.0):
+        self.slow_after, self.slow_sec, self.send_extra = slow_after, slow_sec, send_extra
+        self.send_end = None
+        super().__init__()
+
+    def _handle(self, c):
+        if c.get("cmd") == "send_angles":
+            time.sleep(self.send_extra)
+            resp = super()._handle(c)
+            self.send_end = time.time()
+            return resp
+        if c.get("cmd") == "read_servo" and self.send_end and time.time() - self.send_end > self.slow_after:
+            time.sleep(self.slow_sec)
+        return super()._handle(c)
+
+
+class TestSlowAndTimeout(unittest.TestCase):
+    """codex R1・R3: 窓の終わりで読みが長引いた場合と, 送信のソケットの期限切れを本物の通信 (127.0.0.1) で通す."""
+
+    def _with_daemon(self, d, fn):
+        vsp.close_daemon_socket()
+        try:
+            with mock.patch.object(vsp, "DAEMON_HOST", "127.0.0.1"), mock.patch.object(vsp, "DAEMON_PORT", d.port), \
+                    mock.patch.object(rtd, "SEND_WAIT_ON", "mac"), mock.patch("sys.stdout", new=io.StringIO()):
+                return fn()
+        finally:
+            vsp.close_daemon_socket()
+            d.close()
+
+    def test_slow_read_at_window_end(self):
+        """窓の終わりぎわに始めた read_servo が 0.5 秒長引くと, 本体の次の読みはその分だけ遅れる (早まらない).
+        遅れは read_servo 1 回の上限 (READ_SERVO_TIMEOUT_SEC) までで, overruns に数える. 1.0 秒の待ちそのものは縮まない.
+        読み方 (依頼 121 の窓の決まり) は変えていないので, 0.3 秒の到達の確かめの合間でも前から同じことが起こりうる."""
+        pr.install_daemon_lock()
+        d = SlowTailDaemon(slow_after=0.7, slow_sec=0.5)
+        td = Path(tempfile.mkdtemp())
+
+        def go():
+            rec = rtd._Recorder(False, "run_s")
+            rec.currents = rtd._start_currents(td)
+            time.sleep(0.2)
+            t0 = time.time()
+            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=rec)
+            t_back = time.time()
+            vsp.daemon_get_angles()
+            meta = rec.currents.stop()
+            rtd._ACTIVE_CURRENTS.remove(rec.currents)
+            return t0, t_back, meta
+        t0, t_back, meta = self._with_daemon(d, go)
+        get0 = next_main_get(d, t0)
+        self.assertGreaterEqual(t_back - t0, rtd.SEND_WAIT_SEC)            # Mac 側の待ちは縮まない
+        self.assertGreaterEqual(get0 - t0, rtd.SEND_WAIT_SEC + WRITE_SEC)  # 次の読みは早まらない
+        self.assertGreaterEqual(meta["overruns"], 1)                        # 見込み超えとして数える
+        self.assertLess(get0 - t0, rtd.SEND_WAIT_SEC + 0.1 + pr.READ_SERVO_TIMEOUT_SEC)
+        print(f"\n窓の終わりで read_servo が 0.5 秒長引いた場合: 送信の始め → 本体の次の読み {get0 - t0:.3f} 秒"
+              f" (長引かなければ 約 {rtd.SEND_WAIT_SEC + WRITE_SEC + READ_ONCE_SEC:.3f} 秒) overruns {meta['overruns']}")
+
+    def test_send_socket_timeout(self):
+        """daemon が 4.0 秒より長く返さなければ, 4.0 秒で切れて例外. そのあとも 1.0 秒待ってから例外を返す.
+        次の命令はつなぎ直して通る."""
+        d = SlowTailDaemon(send_extra=rtd.SEND_SOCKET_TIMEOUT_SEC + 0.6)
+
+        def go():
+            t0 = time.monotonic()
+            with self.assertRaises(Exception):
+                rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t")
+            el = time.monotonic() - t0
+            rtt = rtd._LAST_SEND["daemon_rtt_sec"]
+            time.sleep(1.0)                      # 偽の daemon が遅れた返事を書き終えるまで
+            a = vsp.daemon_get_angles()
+            return el, rtt, a
+        el, rtt, a = self._with_daemon(d, go)
+        self.assertAlmostEqual(rtt, rtd.SEND_SOCKET_TIMEOUT_SEC, delta=0.3)
+        self.assertGreaterEqual(el, rtd.SEND_SOCKET_TIMEOUT_SEC + rtd.SEND_WAIT_SEC - 0.05)
+        self.assertLess(el, rtd.SEND_SOCKET_TIMEOUT_SEC + rtd.SEND_WAIT_SEC + 0.5)
+        self.assertEqual(len(a), 6)
+
+
+class _Rec(object):
+    def __init__(self):
+        self.windows = []
+
+    def currents_window(self, sec):
+        self.windows.append(sec)
+
+
+class TestGuardedUnits(unittest.TestCase):
+    def setUp(self):
+        self.calls = []
+        self.slept = []
+        self.p = [mock.patch.object(rtd.time, "sleep", lambda s: self.slept.append(s)),
+                  mock.patch.object(rtd, "daemon_send_angles", self._send)]
+        for p in self.p:
+            p.start()
+        self.exc = None
+
+    def tearDown(self):
+        for p in self.p:
+            p.stop()
+
+    def _send(self, pose, speed, wait=0, timeout_override=None):
+        self.calls.append((list(pose), speed, wait, timeout_override, list(self.slept)))
+        if self.exc is not None:
+            raise self.exc
+        return {"ok": True}
+
+    def test_mac_waits_after_send(self):
+        rec = _Rec()
+        with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"):
+            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=rec)
+        self.assertEqual(self.calls, [(list(rtd.HOME_ANGLES), 20, 0, rtd.SEND_SOCKET_TIMEOUT_SEC, [])])  # 送る前は眠らない
+        self.assertEqual(self.slept, [rtd.SEND_WAIT_SEC])            # 送ったあとに 1.0 秒 (縮めない)
+        self.assertEqual(rec.windows, [rtd.SEND_WAIT_SEC])           # その間を電流の記録に知らせる
+        self.assertIsNotNone(rtd._LAST_SEND["daemon_rtt_sec"])
+
+    def test_mac_without_recorder(self):
+        with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"):
+            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t")
+        self.assertEqual(self.slept, [rtd.SEND_WAIT_SEC])
+
+    def test_daemon_mode_unchanged(self):
+        rec = _Rec()
+        with mock.patch.object(rtd, "SEND_WAIT_ON", "daemon"):
+            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=rec)
+        self.assertEqual(self.calls, [(list(rtd.HOME_ANGLES), 20, rtd.SEND_WAIT_SEC, None, [])])
+        self.assertEqual((self.slept, rec.windows), ([], []))
+
+    def test_mac_send_error_still_waits(self):
+        self.exc = RuntimeError("socket timeout")
+        rec = _Rec()
+        with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"), self.assertRaises(RuntimeError):
+            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=rec)
+        self.assertEqual(self.slept, [rtd.SEND_WAIT_SEC])
+        self.assertIsNotNone(rtd._LAST_SEND["daemon_rtt_sec"])
+
+    def test_daemon_send_error_keeps_rtt(self):
+        self.exc = RuntimeError("socket timeout")
+        with mock.patch.object(rtd, "SEND_WAIT_ON", "daemon"), self.assertRaises(RuntimeError):
+            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=_Rec())
+        self.assertEqual(self.slept, [])
+        self.assertIsNotNone(rtd._LAST_SEND["daemon_rtt_sec"])
+
+    def test_mac_ctrl_c_not_waited(self):
+        self.exc = KeyboardInterrupt()
+        with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"), self.assertRaises(KeyboardInterrupt):
+            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=_Rec())
+        self.assertEqual(self.slept, [])
+
+    def test_backstop_no_send_no_wait(self):
+        bad = list(rtd.HOME_ANGLES)
+        bad[0] = float("nan")
+        with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"), self.assertRaises(rtd._Aborted):
+            rtd._send_angles_guarded(bad, 20, "t", recorder=_Rec())
+        self.assertEqual((self.calls, self.slept), ([], []))
+        self.assertIsNone(rtd._LAST_SEND["daemon_rtt_sec"])
+
+
+class TestCli(unittest.TestCase):
+    def _parse(self, argv):
+        got = {}
+        with mock.patch.object(rtd, "cmd_run", lambda a: got.setdefault("a", a) and 0), \
+                mock.patch.object(sys, "argv", ["record_teach_demo.py"] + argv):
+            rtd.main()
+        return got["a"]
+
+    def test_default_mac(self):
+        self.assertEqual(self._parse(["run", "--teach", "x.json"]).send_wait_on, "mac")
+        self.assertEqual(self._parse(["run", "--teach", "x.json", "--send-wait-on", "daemon"]).send_wait_on, "daemon")
+
+    def test_bad_value(self):
+        with mock.patch("sys.stderr", new=io.StringIO()), self.assertRaises(SystemExit):
+            self._parse(["run", "--teach", "x.json", "--send-wait-on", "pi"])
+
+    def test_trial_json_has_send_wait_on(self):
+        """cmd_run の試行 JSON (log_record) と params に send_wait_on を入れている (cmd_run を最後まで通すには
+        カメラと Pi が要るので, ソースで確かめる)."""
+        import inspect
+        src = inspect.getsource(rtd.cmd_run)
+        head = src[src.index("log_record = {"):]
+        self.assertIn('"send_wait_on": SEND_WAIT_ON,', head[:head.index('"current_angles_before_replay"')])
+        self.assertEqual(src.count('"send_wait_on": SEND_WAIT_ON'), 2)       # いちばん上と params
+
+    def test_cmd_run_rejects_bad_value(self):
+        """cmd_run を直接呼ぶ形でも mac / daemon 以外は止める (グローバルは変えない)."""
+        a = mock.Mock(grip_value=None, power=None, send_wait_on="pi", no_currents=False, no_record=False)
+        with mock.patch("sys.stdout", new=io.StringIO()), self.assertRaises(SystemExit):
+            rtd.cmd_run(a)
+        self.assertEqual(rtd.SEND_WAIT_ON, "mac")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/pi05/test_teach_current_actuals.py b/pi05/test_teach_current_actuals.py
index 47540d1..d3f0e5c 100644
--- a/pi05/test_teach_current_actuals.py
+++ b/pi05/test_teach_current_actuals.py
@@ -65,14 +65,17 @@ class PoseDaemon(ttc.ArmDaemon):
         return resp
 
 
-def replay(daemon, run_dir, sink=True):
-    """cmd_run と同じ順で再生を 1 回通す. 戻り値: (result, 通知, log_record, recorder)."""
+def replay(daemon, run_dir, sink=True, send_wait_on="daemon"):
+    """cmd_run と同じ順で再生を 1 回通す. 戻り値: (result, 通知, log_record, recorder).
+    依頼 213: ttc.ArmDaemon は send_angles の wait を見ずに SEND_SEC (待ちを含む) で返すので, 既定は daemon 側で待つ形.
+    Mac 側で待つ形は test_send_wait_mac.py (wait を本物どおりに扱う偽の daemon) が send_wait_on="mac" で呼ぶ."""
     sent = []
     vsp.close_daemon_socket()
     log_record = {"current_angles_before_replay": list(rtd.HOME_ANGLES)}
     seq = rtd.wpsr._build_segments(ttc.WAYPOINTS)
     with mock.patch.object(vsp, "DAEMON_HOST", "127.0.0.1"), mock.patch.object(vsp, "DAEMON_PORT", daemon.port), \
             mock.patch.object(rtd.rpp, "recorder_notify", lambda p: sent.append(dict(p))), \
+            mock.patch.object(rtd, "SEND_WAIT_ON", send_wait_on), \
             mock.patch("sys.stdout", new=io.StringIO()):
         recorder = rtd._Recorder(True, run_dir.name)
         if sink:
diff --git a/pi05/test_teach_currents.py b/pi05/test_teach_currents.py
index 2793fd9..d1af2eb 100644
--- a/pi05/test_teach_currents.py
+++ b/pi05/test_teach_currents.py
@@ -131,13 +131,16 @@ WAYPOINTS = {               # HOME [0, 0, 0, 0, 0, -30] の近く. 関節の範
 
 def replay(daemon, run_dir, currents=True):
     """cmd_run と同じ順 (install_daemon_lock → _start_currents → _replay → stop) で再生を 1 回通す.
-    recorder.py への通知は送らずに集める. 戻り値: (result, 通知, log_record, 再生にかかった秒)."""
+    recorder.py への通知は送らずに集める. 戻り値: (result, 通知, log_record, 再生にかかった秒).
+    依頼 213: この偽の daemon は send_angles の wait を見ずに SEND_SEC (待ちを含む) で返すので,
+    送信のあとの待ちは daemon 側 (--send-wait-on daemon) に固定する. Mac 側で待つ形は test_send_wait_mac.py."""
     sent = []
     vsp.close_daemon_socket()
     log_record = {"current_angles_before_replay": list(rtd.HOME_ANGLES)}
     seq = rtd.wpsr._build_segments(WAYPOINTS)
     with mock.patch.object(vsp, "DAEMON_HOST", "127.0.0.1"), mock.patch.object(vsp, "DAEMON_PORT", daemon.port), \
             mock.patch.object(rtd.rpp, "recorder_notify", lambda p: sent.append(dict(p))), \
+            mock.patch.object(rtd, "SEND_WAIT_ON", "daemon"), \
             mock.patch("sys.stdout", new=io.StringIO()):
         recorder = rtd._Recorder(True, run_dir.name)
         if currents:
```

### 依頼213 の record_teach_demo.py の差分（git の外のため、直す前の写しとの差）


```diff
--- dynamic_tracking_limits/drag_teaching/record_teach_demo.py.bak_pre_req213_20261115	2026-11-15 00:26:31.699619895 +0000
+++ dynamic_tracking_limits/drag_teaching/record_teach_demo.py	2026-11-15 09:21:53.001091052 +0000
@@ -220,6 +220,19 @@
 # あと wait 秒 sleep してから送信後の角度を読む。wait=0 だと書き込み直後に読むため
 # 読み直し 12 回（≒3.7s）に化けやすい（段階C 1回目の lift が実測 3.7196s）。
 SEND_WAIT_SEC = rpp.SEND_WAIT_SEC                  # 1.0
+# 依頼 213（依頼 197 の案 2・エイイチ判断 2026-11-15）: 送信のあとの 1.0 秒を **どこで待つか**。
+#   "mac"（既定）: daemon には wait=0 で送り、返ってから Mac 側で SEND_WAIT_SEC 待つ。
+#                  この間は電流の記録スレッドが読める（_sleep_open で眠りを知らせる）。
+#   "daemon"     : 依頼 202 までと同じ。daemon が wait=SEND_WAIT_SEC で寝てから返す（この間は読めない）。
+# 待つ長さ（1.0 秒・DAY266: 短縮しない）は変えない。場所だけを移す。cmd_run が --send-wait-on の値を入れる。
+SEND_WAIT_ON_CHOICES = ("mac", "daemon")
+SEND_WAIT_ON = "mac"
+# 送信のソケットの期限。"daemon" では visual_servo_pick._daemon_request が wait+3.0 = 4.0 秒にする。
+# "mac" の wait=0 では既定 DAEMON_TIMEOUT_SEC（35 秒）になってしまうので、同じ 4.0 秒を timeout_override で渡す。
+SEND_SOCKET_TIMEOUT_SEC = SEND_WAIT_SEC + 3.0
+# 直近の _send_angles_guarded の daemon とのやりとりだけの往復（Mac 側の待ちを含まない）。"daemon" では
+# daemon の中の 1.0 秒を含む。区間の記録に残す（send_rtt_sec はどちらでも待ちを含む送信の始めから終わりまで）。
+_LAST_SEND = {"daemon_rtt_sec": None}
 FIRST_MOVE_WARN_DEG = wpsr.FIRST_MOVE_WARN_DEG     # 30.0
 
 # 2026-10-19（エイイチ判断・項目1）: 一律 8.0° はやめた。
@@ -2699,18 +2712,21 @@
     _log("daemon の新 cmd 確認 OK（send_angles_fast / get_angles_once）")
 
 
-def _send_angles_guarded(pose, speed, where):
+def _send_angles_guarded(pose, speed, where, recorder=None):
     """送信直前の backstop（codex R1 C2）.
 
     送る姿勢ごとに「有限値 → JOINT_LIMITS → J4_SAFE」を確かめ、
     外れていたら **送らずに** ABORT する。クランプして黙って姿勢を変えることはしない
     （教示姿勢を勝手に書き換えない）。
     計画時に全姿勢を検査済みでも、ここが最後の砦として全送信を通る。
+    依頼 213: SEND_WAIT_ON が "mac" なら、送ったあとの SEND_WAIT_SEC をここ（Mac 側）で待ってから返る。
+    recorder を渡すとその間を電流の記録スレッドに知らせる（読める）。
     """
     reason = _pose_violation(pose)
     if reason is not None:
         raise _Aborted(where, "送信直前の姿勢検査で弾きました（送信していません）: "
                               + reason)
+    _LAST_SEND["daemon_rtt_sec"] = None
     if USE_FAST_DAEMON_CMDS:
         # LOG352: 読み直し無しの送信（Pi 直と同じ送り方）
         return daemon_send_angles_fast(
@@ -2733,7 +2749,37 @@
     # アームは目標まで動き続けうる。止めるのは電源を切ることだけ
     #（2026-10-18 からの運用）。周囲の空間を空けて監視下で走らせること。
     # 送信回数は増やさない。待つのは daemon 側の 1 回だけ。
-    return daemon_send_angles(pose, speed, wait=SEND_WAIT_SEC)
+    if SEND_WAIT_ON == "daemon":
+        t0 = time.monotonic()
+        try:
+            return daemon_send_angles(pose, speed, wait=SEND_WAIT_SEC)
+        finally:
+            _LAST_SEND["daemon_rtt_sec"] = time.monotonic() - t0   # 例外でも残す（codex 2 回目 R2）
+    # 依頼 213（"mac"）: daemon は wait=0 で、書き込みのあと 1 回だけ角度を読んで（read_angles_once_for_log）
+    # すぐ返す。返ってから Mac 側で同じ SEND_WAIT_SEC 待つので、到達の確かめが始まる時刻は今までと同じ
+    # （書き込み → 1.0 秒 → 読み 1 回 → 返事、が 書き込み → 読み 1 回 → 返事 → 1.0 秒 になる）。
+    # 送信は install_daemon_lock の鍵の中の 1 回のやりとりなので、電流の記録スレッドの読みは
+    # 送信の途中に割り込まない（返事が来て鍵が外れてから、眠りを知らされた間だけ読む）。
+    # 送信が例外でも 1.0 秒は待つ（届いたかは分からないので、待ちを縮めずに到達の確かめへ進む）。
+    t0 = time.monotonic()
+    try:
+        resp = daemon_send_angles(pose, speed, wait=0,
+                                  timeout_override=SEND_SOCKET_TIMEOUT_SEC)
+    except Exception:
+        _LAST_SEND["daemon_rtt_sec"] = time.monotonic() - t0
+        _send_wait_on_mac(recorder)
+        raise
+    _LAST_SEND["daemon_rtt_sec"] = time.monotonic() - t0
+    _send_wait_on_mac(recorder)
+    return resp
+
+
+def _send_wait_on_mac(recorder):
+    """依頼 213: 送ったあとの SEND_WAIT_SEC（1.0 秒）を Mac 側で待つ。**長さは縮めない**（time.sleep と同じ）."""
+    if recorder is not None:
+        _sleep_open(recorder, SEND_WAIT_SEC)
+    else:
+        time.sleep(SEND_WAIT_SEC)
 
 
 def _note_send_failure(streak, label, detail, exc):
@@ -2832,6 +2878,8 @@
         t_first_send = None              # 送信の計時は送信直前に始める（R11b T5）
         first_rtt = None
         first_rtt_retry = None
+        first_daemon_rtt = None          # 依頼 213: daemon とのやりとりだけの往復（Mac 側の待ちを含まない）
+        first_daemon_rtt_retry = None
         first_arrived = None
         first_max = None
         first_actual = None
@@ -2877,7 +2925,9 @@
             first_send_attempted = True
             try:
                 t_first_send = time.monotonic()
-                _send_angles_guarded(HOME_ANGLES, SPEED_FIRST, "step1_HOME_START")
+                _send_angles_guarded(HOME_ANGLES, SPEED_FIRST, "step1_HOME_START",
+                                     recorder=recorder)
+                first_daemon_rtt = _LAST_SEND["daemon_rtt_sec"]
                 first_rtt = time.monotonic() - t_first_send
                 log_record["first_move_send_rtt_sec"] = round(first_rtt, 4)
                 streak["consecutive_send_failures"] = 0
@@ -2886,6 +2936,7 @@
                 raise
             except Exception as e:
                 # 2026-10-19 方針変更: 送信の例外でも止めない
+                first_daemon_rtt = _LAST_SEND["daemon_rtt_sec"]   # 依頼 213 codex R2: 失敗でも残す
                 _note_send_failure(streak, "先頭移動 (current → HOME)",
                                    "step1_HOME_START", e)
                 _warn("先頭移動の send_angles が失敗しました。止めません。"
@@ -2970,7 +3021,9 @@
                     _t_retry = time.monotonic()
                     try:
                         _send_angles_guarded(HOME_ANGLES, SPEED_FIRST,
-                                             "step1_HOME_START_retry")
+                                             "step1_HOME_START_retry",
+                                             recorder=recorder)
+                        first_daemon_rtt_retry = _LAST_SEND["daemon_rtt_sec"]
                         first_rtt_retry = time.monotonic() - _t_retry
                         _log("再送 OK（daemon 往復 {:.3f}s）".format(first_rtt_retry))
                     except _Aborted:
@@ -2978,6 +3031,7 @@
                         first_aborted_at = "retry_send_backstop"
                         raise
                     except Exception as e:
+                        first_daemon_rtt_retry = _LAST_SEND["daemon_rtt_sec"]
                         _note_send_failure(streak, "先頭移動 (current → HOME)",
                                            "step1_HOME_START_retry", e)
                         _warn("先頭移動の再送 send_angles が失敗しました。"
@@ -3074,6 +3128,12 @@
                 "warnings": list(first_warnings),
                 "send_rtt_retry_sec": (round(first_rtt_retry, 4)
                                        if first_rtt_retry is not None else None),
+                # 依頼 213: 送信のあとの 1.0 秒をどこで待ったか と daemon とのやりとりだけの往復
+                "send_wait_on": SEND_WAIT_ON,
+                "send_daemon_rtt_sec": (round(first_daemon_rtt, 4)
+                                        if first_daemon_rtt is not None else None),
+                "send_daemon_rtt_retry_sec": (round(first_daemon_rtt_retry, 4)
+                                              if first_daemon_rtt_retry is not None else None),
             })
 
         # codex R11 A1: 爪の直前の静止確認に「直前の move の目標と許容差」を使う。
@@ -3281,6 +3341,8 @@
             send_failures = 0
             send_rtt_sec = None
             send_rtt_retry_sec = None
+            send_daemon_rtt_sec = None        # 依頼 213
+            send_daemon_rtt_retry_sec = None
             arrived = None
             last_max = None
             last_actual = None
@@ -3317,7 +3379,9 @@
                 try:
                     _send_angles_guarded(
                         s["to"], SPEED_SINGLE,
-                        "step{}_{}".format(step_no, _stage_name(s["to_name"])))
+                        "step{}_{}".format(step_no, _stage_name(s["to_name"])),
+                        recorder=recorder)
+                    send_daemon_rtt_sec = _LAST_SEND["daemon_rtt_sec"]
                     send_rtt_sec = time.monotonic() - t_send
                     send_rtts.append(send_rtt_sec)
                     streak["consecutive_send_failures"] = 0
@@ -3332,6 +3396,7 @@
                     # 分かる**ので、そこで判断する（届いていなければ
                     # 「1.0° 未満 → 再送 → それでも 1.0° 未満」で ABORT になる）。
                     send_failures += 1
+                    send_daemon_rtt_sec = _LAST_SEND["daemon_rtt_sec"]   # 依頼 213 codex R2: 失敗でも残す
                     _note_send_failure(streak, label, "単発送信", e)
                     _warn("send_angles が失敗しました（区間 {}）。止めません。"
                           "到達確認で動いたかを見ます: {}: {}".format(
@@ -3427,7 +3492,9 @@
                             _send_angles_guarded(
                                 s["to"], SPEED_SINGLE,
                                 "step{}_{}_retry".format(
-                                    step_no, _stage_name(s["to_name"])))
+                                    step_no, _stage_name(s["to_name"])),
+                                recorder=recorder)
+                            send_daemon_rtt_retry_sec = _LAST_SEND["daemon_rtt_sec"]
                             send_rtt_retry_sec = time.monotonic() - t_send_retry
                             _log("再送 OK（daemon 往復 {:.3f}s）".format(
                                 send_rtt_retry_sec))
@@ -3438,6 +3505,7 @@
                             raise
                         except Exception as e:
                             send_failures += 1
+                            send_daemon_rtt_retry_sec = _LAST_SEND["daemon_rtt_sec"]
                             _note_send_failure(streak, label, "再送", e)
                             _warn("再送の send_angles が失敗しました。止めません。"
                                   "動いたかを到達確認で見ます: {}: {}".format(
@@ -3541,6 +3609,15 @@
                     "send_rtt_retry_sec": (round(send_rtt_retry_sec, 4)
                                            if send_rtt_retry_sec is not None
                                            else None),
+                    # 依頼 213: send_rtt_sec は どちらの待ち方でも 1.0 秒の待ちを含む（送信の始めから
+                    # 到達の確かめに入るまで）。send_daemon_rtt_sec は daemon とのやりとりだけ
+                    # （"mac" では待ちを含まない・"daemon" では含む）
+                    "send_wait_on": SEND_WAIT_ON,
+                    "send_daemon_rtt_sec": (round(send_daemon_rtt_sec, 4)
+                                            if send_daemon_rtt_sec is not None else None),
+                    "send_daemon_rtt_retry_sec": (round(send_daemon_rtt_retry_sec, 4)
+                                                  if send_daemon_rtt_retry_sec is not None
+                                                  else None),
                     # 2026-10-19 方針変更: 止めずに続けた事象はここに残す
                     "warnings": list(seg_warnings),
                 })
@@ -3860,7 +3937,7 @@
 
 
 def cmd_run(args):
-    global GRIP_VALUE, POWER
+    global GRIP_VALUE, POWER, SEND_WAIT_ON
     _note_tol_source()
 
     # 依頼 152: 爪の閉じる値（計画の表示・再生の閉じる指令・試行 JSON がすべてこの値を使う）
@@ -3885,6 +3962,18 @@
         _log("電源: {}（--power。試行 JSON の power に残し、爪の位置と電圧も読みます）".format(power))
     POWER = power
 
+    # 依頼 213: 送信のあとの 1.0 秒をどこで待つか（長さは変えない）
+    send_wait_on = getattr(args, "send_wait_on", None) or "mac"
+    if send_wait_on not in SEND_WAIT_ON_CHOICES:
+        _abort_msg("--send-wait-on は {} のどれかで指定してください（指定: {}）".format(
+            " / ".join(SEND_WAIT_ON_CHOICES), send_wait_on))
+        sys.exit(2)
+    SEND_WAIT_ON = send_wait_on
+    _log("送信のあとの {:.1f}s の待ち: {}".format(
+        SEND_WAIT_SEC,
+        "Mac 側（daemon へは wait=0。この間も電流の記録スレッドが読みます）" if SEND_WAIT_ON == "mac"
+        else "daemon 側（依頼 202 までと同じ。この間は読みません）"))
+
     if args.teach_local and args.execute:
         _abort_msg("--teach-local は ドライラン専用です（--execute とは併用できません）。"
                    "実機では Pi から取得した教えた記録だけを再生します")
@@ -4196,6 +4285,9 @@
             "grip_value": GRIP_VALUE,
             # 依頼 156: 電源の種類（--power。付けなければ None）
             "power": POWER,
+            # 依頼 213: 送信のあとの 1.0 秒をどこで待ったか（mac = Mac 側・電流の記録スレッドが読める /
+            # daemon = 依頼 202 までと同じ）
+            "send_wait_on": SEND_WAIT_ON,
             # 肩が上限を超えた姿勢の置き換え（計画段階で決まったもの）
             "shoulder_fix": shoulder_fix_payload,
             "teach": {
@@ -4300,10 +4392,14 @@
                 "DAEMON_SET_GRIPPER_PRE_SLEEP_SEC": DAEMON_SET_GRIPPER_PRE_SLEEP_SEC,
                 "gripper_open_check": "none (gv unused / no pre-start y/n)",
                 "SEND_WAIT_SEC": SEND_WAIT_SEC,
-                "send_socket_timeout_sec": SEND_WAIT_SEC + 3.0,
+                "send_wait_on": SEND_WAIT_ON,
+                "send_socket_timeout_sec": SEND_SOCKET_TIMEOUT_SEC,
                 "send_socket_timeout_source": (
                     "visual_servo_pick._daemon_request: wait>0 なら wait+3.0。"
-                    "timeout_override は短縮しかできないので渡していない"),
+                    "timeout_override は短縮しかできないので渡していない"
+                    if SEND_WAIT_ON == "daemon" else
+                    "依頼 213: daemon へは wait=0 で送り、SEND_WAIT_SEC は Mac 側で待つ。"
+                    "期限は daemon で待っていたときと同じ wait+3.0 を timeout_override で渡す"),
                 "GRIPPER_STILL_TOL_DEG": GRIPPER_STILL_TOL_DEG,
                 "GRIPPER_STILL_READS": GRIPPER_STILL_READS,
                 "GRIPPER_STILL_TIMEOUT_SEC": GRIPPER_STILL_TIMEOUT_SEC,
@@ -4519,6 +4615,10 @@
     ap_r.add_argument("--power", default=None,
                       help="電源の種類（例 2A / 5A。試行 JSON の power に残し、爪の位置と電圧の番地も "
                            "recording/power_regs.csv に読む。動き・待ち時間は変えない。依頼 156。pi05/POWER_AB.md）")
+    ap_r.add_argument("--send-wait-on", choices=SEND_WAIT_ON_CHOICES, default="mac",
+                      help="送信のあとの {:.1f} 秒をどこで待つか（既定 mac: daemon へは wait=0 で送り Mac 側で待つ。"
+                           "この間も電流の記録スレッドが角度を読む。daemon: 依頼 202 までと同じ）。"
+                           "待つ長さは変えない。試行 JSON の send_wait_on に残す。依頼 213".format(SEND_WAIT_SEC))
     ap_r.add_argument("--repeat", type=int, default=MEASURE_REPEAT_DEFAULT,
                       help="再生直前の検出回数（既定 {}）".format(MEASURE_REPEAT_DEFAULT))
     ap_r.add_argument("--interval", type=float, default=MEASURE_INTERVAL_DEFAULT,
```



## 案2の1本目（192142）：抜けは3か所に減ったが、上カメラの動画は0コマ

案2の1本目（`run_0001_20261115_192142`）は、つかんで箱に入れ、再送もありませんでした。1秒を超える抜けは3か所で、3か所とも爪を動かしている間です。

ところが、この1本は上カメラの動画が撮れていませんでした。measure の時点で上カメラの iPhone が見つからず（`上カメラ(iPhone Continuity)が見つかりません`）、ブロックの位置の確かめもできないまま進んでいます。recorder の記録を見ると、案1の2本を撮ったあと、上カメラの読み取りに続けて失敗しては開き直す、を繰り返していました。カメラの番号（index=2）は開けても、映像が来ていない状態です。この1本は `frames=0` で、動画のないお手本は学習に使えません。角度の記録の確かめには使えるので、比べる表には入れています。

### 案2の1本目までのターミナルの全文（measure の失敗から192142まで）


```
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % cd ~/r2r2r-scripts
python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py measure
python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py run --teach drag_v2_20261109_094222.json --grip-value 20 --power 5A
python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py run --teach drag_v2_20261109_094222.json --grip-value 20 --power 5A --execute
[RTD   ] 到達許容差は本線 run_pick_place.py の stage 値を使います（区間ごと。一律 8.0° は 2026-10-19 にやめた）:
[RTD   ]   HOME                       2.5°  ← rpp.TOL_HOME（stage1_to_home / HOME 復帰）
[RTD   ]   APPROACH_PICK              2.0°  ← rpp.TOL_APPROACH（approach 系）
[RTD   ]   PICK                       3.0°  ← rpp.TOL_PICK_PLACE（stage4_pick）
[RTD   ]   APPROACH_PICK (lift)       3.0°  ← rpp.TOL_LIFT_BACK（lift の残差 2.19° を吸収）
[RTD   ]   APPROACH_PLACE             3.0°  ← rpp.TOL_APPROACH_PLACE（stage7）
[RTD   ]   PLACE                      3.0°  ← rpp.TOL_PICK_PLACE（stage8_place）
[RTD   ]   APPROACH_PLACE (retreat)   3.0°  ← rpp.TOL_LIFT_BACK（stage10_lift_back）
[RTD   ] 到達を待つ最大時間 = clamp(2.0 + max|Δ|/20*3.0, 8.0, 30.0) 秒（本線と同じ wr._compute_arrival_timeout）
[RTD   ] measure: 上カメラで検出します（repeat=5 interval=0.3s）
[CAM] 接続中カメラ一覧:
  index=0  name=FaceTime HDカメラ
  index=1  name=Iriun Camera
[CAM] 上カメラ(iPhone)  index=None
[CAM] 横カメラ(Iriun)   index=1
[DETECT] camera_resolver で例外: 上カメラ(iPhone Continuity)が見つかりません。iPhone 14 Pro Max のロックを解除し、連係カメラをオンにして接続してください（自動ロックを『なし』にすると寝て落ちるのを防げます）（positions=null）
[RTD   ] measure: block = None
[RTD   ] measure: box   = None  score=None
[RTD   ] [WARN] ブロックが検出できませんでした。この measure では run の位置照合（ブロックが動いていないかの確認）が通りません
[RTD   ] [WARN] 白箱が検出できませんでした（台帳の box_x / box_z は空欄になります）
[RTD   ] [WARN] homography が作れていません（マット四隅の検出に失敗）。mm と画素の対応が取れないので、関係する値は null で保存します
[RTD   ] [WARN] 上カメラの確認で例外（記録のみ・本線は続行）: RuntimeError: 上カメラ(iPhone Continuity)が見つかりません。iPhone 14 Pro Max のロックを解除し、連係カメラをオンにして接続してください（自動ロックを『なし』にすると寝て落ちるのを防げます）
[RTD   ] [WARN] measure: 四隅を比べられませんでした（1 回目）
[RTD   ] [WARN] 上カメラの確認で例外（記録のみ・本線は続行）: RuntimeError: 上カメラ(iPhone Continuity)が見つかりません。iPhone 14 Pro Max のロックを解除し、連係カメラをオンにして接続してください（自動ロックを『なし』にすると寝て落ちるのを防げます）
[RTD   ] [WARN] measure: 四隅を比べられませんでした（2 回目）
[RTD   ] [WARN] 上カメラの確認で例外（記録のみ・本線は続行）: RuntimeError: 上カメラ(iPhone Continuity)が見つかりません。iPhone 14 Pro Max のロックを解除し、連係カメラをオンにして接続してください（自動ロックを『なし』にすると寝て落ちるのを防げます）
[RTD   ] [WARN] measure: 四隅を比べられませんでした（3 回目）
[RTD   ] [WARN] 上カメラの確認ができませんでした。測り直しの値は null で保存します
[RTD   ] [WARN] ブロックの検出サンプルが 0 件（最低 3 件）。ばらつきを判定できません（WARN のみ・保存します）
[RTD   ] [WARN] homography が無いので確認画像は作れません
[RTD   ] homography のもとになった四隅と、測り直した四隅の差: 最大 Nonepx（上限 15.0px・やり直し 3 回）
[RTD   ] [WARN] この measure の homography は信用できません: マット四隅が測り直しと 3 回とも食い違った（各回の最大: None, None, None）。mm の値が外れている可能性があります（WARN のみ・保存します）
[RTD   ] ブロックのばらつき: 0.0px = 0.00mm（0 枚・上限 4.0mm）
[RTD   ] [WARN] ブロックを検出できていません（None）。位置は null で保存します
[RTD   ] [WARN] ブロックの測り直しができていません（元の検出と突き合わせ不可）。（WARN のみ・保存します）
[RTD   ] 保存しました: /Volumes/KIOXIA/r2r2r-data/mecharm_calibration/teach_poses_20261115/measure_20261115_192122.json
[RTD   ] [WARN] この measure には WARN が 6 件あります: homography_missing, inspection_failed, too_few_samples, mat_corner_mismatch, block_not_detected, block_recheck_missing
[RTD   ] [WARN] 値が外れている可能性があります。気になるなら取り直してください（保存はしてあります）
[RTD   ] 次は Pi で教示 → daemon 起動 → recorder.py --top --no-side 常駐 → run --teach <file> --execute
[RTD   ] 到達許容差は本線 run_pick_place.py の stage 値を使います（区間ごと。一律 8.0° は 2026-10-19 にやめた）:
[RTD   ]   HOME                       2.5°  ← rpp.TOL_HOME（stage1_to_home / HOME 復帰）
[RTD   ]   APPROACH_PICK              2.0°  ← rpp.TOL_APPROACH（approach 系）
[RTD   ]   PICK                       3.0°  ← rpp.TOL_PICK_PLACE（stage4_pick）
[RTD   ]   APPROACH_PICK (lift)       3.0°  ← rpp.TOL_LIFT_BACK（lift の残差 2.19° を吸収）
[RTD   ]   APPROACH_PLACE             3.0°  ← rpp.TOL_APPROACH_PLACE（stage7）
[RTD   ]   PLACE                      3.0°  ← rpp.TOL_PICK_PLACE（stage8_place）
[RTD   ]   APPROACH_PLACE (retreat)   3.0°  ← rpp.TOL_LIFT_BACK（stage10_lift_back）
[RTD   ] 到達を待つ最大時間 = clamp(2.0 + max|Δ|/20*3.0, 8.0, 30.0) 秒（本線と同じ wr._compute_arrival_timeout）
[RTD   ] 爪の閉じる値: 20（--grip-value）
[RTD   ] 電源: 5A（--power。試行 JSON の power に残し、爪の位置と電圧も読みます）
[RTD   ] 送信のあとの 1.0s の待ち: Mac 側（daemon へは wait=0。この間も電流の記録スレッドが読みます）
[RTD   ] モード: ドライラン（アームに何も送りません）
[RTD   ] Pi から教えた記録を取得します: ubuntu@192.168.2.1:r2r2r-scripts/dynamic_tracking_limits/drag_teaching/drag_v2_20261109_094222.json
[RTD   ] 取得しました → /var/folders/5w/2q2mc64n6yv63gfh31h34w6h0000gn/T/record_teach_demo_btywtacj/drag_v2_20261109_094222.json
[RTD   ] 入力ファイル: drag_v2_20261109_094222.json
[RTD   ] 抽出ウェイポイント:
  APPROACH_PICK  <- phase APPROACH_PICK argmax_idx=240 (start=240 end=290, gap=13.89°)
                    angles = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
  PICK           <- gripper close mark idx=355（PICK phase 範囲内）
                    angles = [ -40.51,  +79.98,   -0.43,   +0.43,  -73.47,  -29.97]
  APPROACH_PLACE <- phase APPROACH_PLACE argmax_idx=470 (start=470 end=512, gap=27.86°)
                    angles = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
  PLACE          <- gripper open mark idx=552（PLACE phase 範囲内）
                    angles = [ +44.20,  +59.67,   +6.15,  +10.54,  -74.88,  -30.84]
[RTD   ] JOINT_LIMITS 一括検証 OK（全 endpoint + HOME）
[RTD   ] 姿勢検査 OK（全 155 姿勢が 有限値 + JOINT_LIMITS + J4_SAFE [-90.0, +60.0] 内）
[RTD   ] j4 の余裕は最小 15.12°（しきい値 3.0° 以上）
==============================================================================
[RTD   ] 実行プラン（daemon 経由・区間ごとに 1 回送信 → 到達待ち）
==============================================================================
  [STEP  1] MOVE → HOME (single send + settle)  speed=20
            current = 未取得（ドライラン・daemon に接続していない）
            to HOME = [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]
  [STEP  2] GRIPPER OPEN  daemon_set_gripper(0, 50, wait=0) ×1 回（daemon 事前 2.0s + 事後 2.0s + 待ち 2.0s）= 計 6.0s
            開いたかは確認しません（gv を使わず・開始前の y/n も無し。判定は終了後の y/n と動画）
  [STEP  3] MOVE → APPROACH_PICK  segment HOME → APPROACH_PICK  tol=2.0°  [rpp.TOL_APPROACH（approach 系）]
            from    = [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]
            to      = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            max |Δ| = 70.48°  1 回送信 speed=20  (~ 3.5s @ 20°/s 目安・到達待ち 最大 12.6s)
  [STEP  4] MOVE → PICK  segment APPROACH_PICK → PICK  [critical]  tol=3.0°  [rpp.TOL_PICK_PLACE（stage4_pick）]
            from    = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            to      = [ -40.51,  +79.98,   -0.43,   +0.43,  -73.47,  -29.97]
            max |Δ| = 13.89°  1 回送信 speed=20  (~ 0.7s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP  5] GRIPPER CLOSE  daemon_set_gripper_value(20, 50) + sleep(2.0s)
  [STEP  6] MOVE → APPROACH_PICK (lift)  segment PICK → APPROACH_PICK (lift)  tol=3.0°  [rpp.TOL_LIFT_BACK（lift の残差 2.19° を吸収）]
            from    = [ -40.51,  +79.98,   -0.43,   +0.43,  -73.47,  -29.97]
            to      = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            max |Δ| = 13.89°  1 回送信 speed=20  (~ 0.7s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP  7] MOVE → APPROACH_PLACE  segment APPROACH_PICK → APPROACH_PLACE  tol=3.0°  [rpp.TOL_APPROACH_PLACE（stage7）]
            from    = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            to      = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            max |Δ| = 84.10°  1 回送信 speed=20  (~ 4.2s @ 20°/s 目安・到達待ち 最大 14.6s)
  [STEP  8] MOVE → PLACE  segment APPROACH_PLACE → PLACE  [critical]  tol=3.0°  [rpp.TOL_PICK_PLACE（stage8_place）]
            from    = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            to      = [ +44.20,  +59.67,   +6.15,  +10.54,  -74.88,  -30.84]
            max |Δ| = 27.86°  1 回送信 speed=20  (~ 1.4s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP  9] GRIPPER OPEN  daemon_set_gripper(0, 50, wait=0) ×1 回（daemon 事前 2.0s + 事後 2.0s + 待ち 2.0s）= 計 6.0s
            開いたかは確認しません（gv を使わず・開始前の y/n も無し。判定は終了後の y/n と動画）
  [STEP 10] MOVE → APPROACH_PLACE (retreat)  segment PLACE → APPROACH_PLACE (retreat)  tol=3.0°  [rpp.TOL_LIFT_BACK（stage10_lift_back）]
            from    = [ +44.20,  +59.67,   +6.15,  +10.54,  -74.88,  -30.84]
            to      = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            max |Δ| = 27.86°  1 回送信 speed=20  (~ 1.4s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP 11] MOVE → HOME  segment APPROACH_PLACE → HOME  tol=2.5°  [rpp.TOL_HOME（stage1_to_home / HOME 復帰）]
            from    = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            to      = [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]
            max |Δ| = 56.95°  1 回送信 speed=20  (~ 2.8s @ 20°/s 目安・到達待ち 最大 10.5s)
==============================================================================
[RTD   ] 送信 = 8 回（STEP 1 + move 7 区間）, 想定所要時間 ≈ 31.8s（最悪 73.0s）
[RTD   ]   内訳: 先頭 settle 3.0s + 移動 14.8s（max|Δ| 合計 295.0° @ 20°/s 目安） + gripper 14.0s
[RTD   ]   到達確認: 許容は区間ごと（本線 run_pick_place.py の stage 値）/ 最大は clamp(2.0 + max|Δ|/20*3.0, 8.0, 30.0) 秒
[RTD   ]   届かないとき: 送信前から 1.0° 未満しか動いていなければ 5.0s 待って**同じ目標へ 1 回だけ**再送（本線と同じ）。それでも届かなければ ABORT（HOME へ自動で戻らない）
[RTD   ]   実測 j4: [-90.0, +60.0] の外は WARN / [-98.0, +68.0] の外は ABORT
==============================================================================
[RTD   ] measure: /Volumes/KIOXIA/r2r2r-data/mecharm_calibration/teach_poses_20261115/measure_20261115_192122.json
[RTD   ]   measured_at = 2026-11-15T19:21:22.025443  block = None  box = None
[RTD   ] 再生直前: 上カメラでマット四隅とブロック画素を確認します
[RTD   ] [WARN] 上カメラの確認で例外（記録のみ・本線は続行）: RuntimeError: 上カメラ(iPhone Continuity)が見つかりません。iPhone 14 Pro Max のロックを解除し、連係カメラをオンにして接続してください（自動ロックを『なし』にすると寝て落ちるのを防げます）
[RTD   ] [WARN] 再生直前: 四隅を比べられませんでした（1 回目）
[RTD   ] [WARN] 上カメラの確認で例外（記録のみ・本線は続行）: RuntimeError: 上カメラ(iPhone Continuity)が見つかりません。iPhone 14 Pro Max のロックを解除し、連係カメラをオンにして接続してください（自動ロックを『なし』にすると寝て落ちるのを防げます）
[RTD   ] [WARN] 再生直前: 四隅を比べられませんでした（2 回目）
[RTD   ] [WARN] 上カメラの確認で例外（記録のみ・本線は続行）: RuntimeError: 上カメラ(iPhone Continuity)が見つかりません。iPhone 14 Pro Max のロックを解除し、連係カメラをオンにして接続してください（自動ロックを『なし』にすると寝て落ちるのを防げます）
[RTD   ] [WARN] 再生直前: 四隅を比べられませんでした（3 回目）
[RTD   ] 再生直前: block = None（measure の homography で換算）
[RTD   ] [WARN] homography が無いので確認画像は作れません
[RTD   ] 弾いた理由と各回の記録を残しました: /Volumes/KIOXIA/r2r2r-data/mecharm_calibration/teach_poses_20261115/prerun_20261115_192124_rejected.json
[RTD   ] [WARN] measure に homography / ブロックの画素位置がありません（古い形式の measure です）。measure を取り直してください（**止めません**・WARN のみ）
[RTD   ] ドライランなので、ここで終了します（アームには何も送っていません）
[RTD   ] Pi 版と比べる点: 抽出ウェイポイント 4 姿勢と各区間の max|Δ| は同じ。送り方は単発（Pi 版は 0.1s 補間ストリーミング）なので n_steps / ticks は比較対象外。送信 8 回 / 想定所要 ≈ 31.8s
[RTD   ] 到達許容差は本線 run_pick_place.py の stage 値を使います（区間ごと。一律 8.0° は 2026-10-19 にやめた）:
[RTD   ]   HOME                       2.5°  ← rpp.TOL_HOME（stage1_to_home / HOME 復帰）
[RTD   ]   APPROACH_PICK              2.0°  ← rpp.TOL_APPROACH（approach 系）
[RTD   ]   PICK                       3.0°  ← rpp.TOL_PICK_PLACE（stage4_pick）
[RTD   ]   APPROACH_PICK (lift)       3.0°  ← rpp.TOL_LIFT_BACK（lift の残差 2.19° を吸収）
[RTD   ]   APPROACH_PLACE             3.0°  ← rpp.TOL_APPROACH_PLACE（stage7）
[RTD   ]   PLACE                      3.0°  ← rpp.TOL_PICK_PLACE（stage8_place）
[RTD   ]   APPROACH_PLACE (retreat)   3.0°  ← rpp.TOL_LIFT_BACK（stage10_lift_back）
[RTD   ] 到達を待つ最大時間 = clamp(2.0 + max|Δ|/20*3.0, 8.0, 30.0) 秒（本線と同じ wr._compute_arrival_timeout）
[RTD   ] 爪の閉じる値: 20（--grip-value）
[RTD   ] 電源: 5A（--power。試行 JSON の power に残し、爪の位置と電圧も読みます）
[RTD   ] 送信のあとの 1.0s の待ち: Mac 側（daemon へは wait=0。この間も電流の記録スレッドが読みます）
[RTD   ] モード: EXECUTE（実機）  記録: ON
[RTD   ] Pi から教えた記録を取得します: ubuntu@192.168.2.1:r2r2r-scripts/dynamic_tracking_limits/drag_teaching/drag_v2_20261109_094222.json
[RTD   ] 取得しました → /var/folders/5w/2q2mc64n6yv63gfh31h34w6h0000gn/T/record_teach_demo_79xn42ky/drag_v2_20261109_094222.json
[RTD   ] 入力ファイル: drag_v2_20261109_094222.json
[RTD   ] 抽出ウェイポイント:
  APPROACH_PICK  <- phase APPROACH_PICK argmax_idx=240 (start=240 end=290, gap=13.89°)
                    angles = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
  PICK           <- gripper close mark idx=355（PICK phase 範囲内）
                    angles = [ -40.51,  +79.98,   -0.43,   +0.43,  -73.47,  -29.97]
  APPROACH_PLACE <- phase APPROACH_PLACE argmax_idx=470 (start=470 end=512, gap=27.86°)
                    angles = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
  PLACE          <- gripper open mark idx=552（PLACE phase 範囲内）
                    angles = [ +44.20,  +59.67,   +6.15,  +10.54,  -74.88,  -30.84]
[RTD   ] JOINT_LIMITS 一括検証 OK（全 endpoint + HOME）
[RTD   ] 姿勢検査 OK（全 155 姿勢が 有限値 + JOINT_LIMITS + J4_SAFE [-90.0, +60.0] 内）
[RTD   ] j4 の余裕は最小 15.12°（しきい値 3.0° 以上）
[RTD   ] 現在姿勢を daemon から取得します
[RTD   ] 現在姿勢 = [  -0.26,   +1.49,   +1.66,   +0.26,   -0.26,  -30.23]
==============================================================================
[RTD   ] 実行プラン（daemon 経由・区間ごとに 1 回送信 → 到達待ち）
==============================================================================
  [STEP  1] MOVE → HOME (single send + settle)  speed=20
            current = [  -0.26,   +1.49,   +1.66,   +0.26,   -0.26,  -30.23]
            to HOME = [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]
            max |Δ| = 1.66°  (settle 3.0s)
  [STEP  2] GRIPPER OPEN  daemon_set_gripper(0, 50, wait=0) ×1 回（daemon 事前 2.0s + 事後 2.0s + 待ち 2.0s）= 計 6.0s
            開いたかは確認しません（gv を使わず・開始前の y/n も無し。判定は終了後の y/n と動画）
  [STEP  3] MOVE → APPROACH_PICK  segment HOME → APPROACH_PICK  tol=2.0°  [rpp.TOL_APPROACH（approach 系）]
            from    = [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]
            to      = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            max |Δ| = 70.48°  1 回送信 speed=20  (~ 3.5s @ 20°/s 目安・到達待ち 最大 12.6s)
  [STEP  4] MOVE → PICK  segment APPROACH_PICK → PICK  [critical]  tol=3.0°  [rpp.TOL_PICK_PLACE（stage4_pick）]
            from    = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            to      = [ -40.51,  +79.98,   -0.43,   +0.43,  -73.47,  -29.97]
            max |Δ| = 13.89°  1 回送信 speed=20  (~ 0.7s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP  5] GRIPPER CLOSE  daemon_set_gripper_value(20, 50) + sleep(2.0s)
  [STEP  6] MOVE → APPROACH_PICK (lift)  segment PICK → APPROACH_PICK (lift)  tol=3.0°  [rpp.TOL_LIFT_BACK（lift の残差 2.19° を吸収）]
            from    = [ -40.51,  +79.98,   -0.43,   +0.43,  -73.47,  -29.97]
            to      = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            max |Δ| = 13.89°  1 回送信 speed=20  (~ 0.7s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP  7] MOVE → APPROACH_PLACE  segment APPROACH_PICK → APPROACH_PLACE  tol=3.0°  [rpp.TOL_APPROACH_PLACE（stage7）]
            from    = [ -40.69,  +66.09,   +1.49,   +0.61,  -70.48,  -29.88]
            to      = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            max |Δ| = 84.10°  1 回送信 speed=20  (~ 4.2s @ 20°/s 目安・到達待ち 最大 14.6s)
  [STEP  8] MOVE → PLACE  segment APPROACH_PLACE → PLACE  [critical]  tol=3.0°  [rpp.TOL_PICK_PLACE（stage8_place）]
            from    = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            to      = [ +44.20,  +59.67,   +6.15,  +10.54,  -74.88,  -30.84]
            max |Δ| = 27.86°  1 回送信 speed=20  (~ 1.4s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP  9] GRIPPER OPEN  daemon_set_gripper(0, 50, wait=0) ×1 回（daemon 事前 2.0s + 事後 2.0s + 待ち 2.0s）= 計 6.0s
            開いたかは確認しません（gv を使わず・開始前の y/n も無し。判定は終了後の y/n と動画）
  [STEP 10] MOVE → APPROACH_PLACE (retreat)  segment PLACE → APPROACH_PLACE (retreat)  tol=3.0°  [rpp.TOL_LIFT_BACK（stage10_lift_back）]
            from    = [ +44.20,  +59.67,   +6.15,  +10.54,  -74.88,  -30.84]
            to      = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            max |Δ| = 27.86°  1 回送信 speed=20  (~ 1.4s @ 20°/s 目安・到達待ち 最大 8.0s)
  [STEP 11] MOVE → HOME  segment APPROACH_PLACE → HOME  tol=2.5°  [rpp.TOL_HOME（stage1_to_home / HOME 復帰）]
            from    = [ +43.41,  +31.81,  +18.54,   +6.24,  -56.95,  -29.88]
            to      = [  +0.00,   +0.00,   +0.00,   +0.00,   +0.00,  -30.00]
            max |Δ| = 56.95°  1 回送信 speed=20  (~ 2.8s @ 20°/s 目安・到達待ち 最大 10.5s)
==============================================================================
[RTD   ] 送信 = 8 回（STEP 1 + move 7 区間）, 想定所要時間 ≈ 31.8s（最悪 73.0s）
[RTD   ]   内訳: 先頭 settle 3.0s + 移動 14.8s（max|Δ| 合計 295.0° @ 20°/s 目安） + gripper 14.0s
[RTD   ]   到達確認: 許容は区間ごと（本線 run_pick_place.py の stage 値）/ 最大は clamp(2.0 + max|Δ|/20*3.0, 8.0, 30.0) 秒
[RTD   ]   届かないとき: 送信前から 1.0° 未満しか動いていなければ 5.0s 待って**同じ目標へ 1 回だけ**再送（本線と同じ）。それでも届かなければ ABORT（HOME へ自動で戻らない）
[RTD   ]   実測 j4: [-90.0, +60.0] の外は WARN / [-98.0, +68.0] の外は ABORT
==============================================================================
[RTD   ] measure: /Volumes/KIOXIA/r2r2r-data/mecharm_calibration/teach_poses_20261115/measure_20261115_192122.json
[RTD   ]   measured_at = 2026-11-15T19:21:22.025443  block = None  box = None
[RTD   ] 再生直前: 上カメラでマット四隅とブロック画素を確認します
[RTD   ] [WARN] 上カメラの確認で例外（記録のみ・本線は続行）: RuntimeError: 上カメラ(iPhone Continuity)が見つかりません。iPhone 14 Pro Max のロックを解除し、連係カメラをオンにして接続してください（自動ロックを『なし』にすると寝て落ちるのを防げます）
[RTD   ] [WARN] 再生直前: 四隅を比べられませんでした（1 回目）
[RTD   ] [WARN] 上カメラの確認で例外（記録のみ・本線は続行）: RuntimeError: 上カメラ(iPhone Continuity)が見つかりません。iPhone 14 Pro Max のロックを解除し、連係カメラをオンにして接続してください（自動ロックを『なし』にすると寝て落ちるのを防げます）
[RTD   ] [WARN] 再生直前: 四隅を比べられませんでした（2 回目）
[RTD   ] [WARN] 上カメラの確認で例外（記録のみ・本線は続行）: RuntimeError: 上カメラ(iPhone Continuity)が見つかりません。iPhone 14 Pro Max のロックを解除し、連係カメラをオンにして接続してください（自動ロックを『なし』にすると寝て落ちるのを防げます）
[RTD   ] [WARN] 再生直前: 四隅を比べられませんでした（3 回目）
[RTD   ] 再生直前: block = None（measure の homography で換算）
[RTD   ] [WARN] homography が無いので確認画像は作れません
[RTD   ] 弾いた理由と各回の記録を残しました: /Volumes/KIOXIA/r2r2r-data/mecharm_calibration/teach_poses_20261115/prerun_20261115_192126_rejected.json
[RTD   ] [WARN] measure に homography / ブロックの画素位置がありません（古い形式の measure です）。measure を取り直してください（**止めません**・WARN のみ）
[RTD   ] [SAFETY] 再生中はグリッパーが実機で開閉します。爪に指を挟まないこと。
[RTD   ] [SAFETY] 止めるときはアームの電源を切ること。Ctrl-C は新しい送信をやめるだけで、進行中の移動は止まりません。
[RTD   ] [SAFETY] 開いたかの自動確認はしません（gv は使わない）。STEP 2 で open を送ってから PICK へ降ります。
[RTD   ] 周囲に手・物が無いか確認してください。OK なら Enter で開始

[RTD   ] 試行フォルダ: /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_192142
[RTD   ] 教えた記録のコピー: /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_192142/teach/drag_v2_20261109_094222.json
[RTD   ] recorder に trial_start を送りました。1.0s 待ってから動き出します（mp4 writer が開くまで）
[RTD   ] 爪と肩の電流を 1 秒 10 回で記録します（爪を動かしている間は読みません）→ /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_192142/recording/currents.csv
[RTD   ] 電源 5A: 爪の位置（番地 7:56/57）と電圧（2:62・7:62）も読みます（生の値・未確認の番地）→ /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_192142/recording/power_regs.csv
  [Pi] fresh_mode=1
[RTD   ] daemon_set_fresh_mode(1)（最新コマンド優先・本線 run_pick_place.py L3976 と同じ。647 試行の実績はこの状態）
[STEP  1] MOVE → HOME  daemon_send_angles(HOME, 20)
[STEP  1] 到達待ち 許容 2.5°[TOL_HOME（stage1_to_home / HOME 復帰）] / 最大 8.0s
[RTD   ] 先頭移動: 送信直前の実測で max|Δ| = 1.66° / 到達待ち 最大 8.0s
[STEP  1] 3.0s 待ちます（settle）
[RTD   ] arrival OK (current → HOME, max|Δ|=1.66° <= tol 2.5°)
[STEP  2] GRIPPER OPEN → daemon_set_gripper(0, 50, wait=0)
[RTD   ] 静止確認 OK（step2_open: 連続 3 回・連続差 最大 0.00° <= 1.0°）
  [Pi] GRIPPER: OPEN result= None
[RTD   ] gripper open (1/1 回目) の daemon 往復 = 2.015s
[STEP  2] open 後 2.0s 待ちます（本線の daemon wait=2 相当・読み取りなし）
[STEP  2] gripper dwell 2.0s（読み取りなし）
[STEP  3] MOVE → APPROACH_PICK  segment HOME → APPROACH_PICK  (1 回送信 speed=20 → 到達待ち 許容 2.0°[TOL_APPROACH（approach 系）] / 最大 12.6s)
[RTD   ] 送信 OK（daemon 往復 1.055s）
[RTD   ] arrival OK (HOME → APPROACH_PICK, max|Δ|=1.05° <= tol 2.0°)
[STEP  4] MOVE → PICK  segment APPROACH_PICK → PICK  (1 回送信 speed=20 → 到達待ち 許容 3.0°[TOL_PICK_PLACE（stage4_pick）] / 最大 8.0s)  [critical]
[RTD   ] 送信 OK（daemon 往復 1.035s）
[RTD   ] arrival OK (APPROACH_PICK → PICK, max|Δ|=2.20° <= tol 3.0°)
[STEP  5] GRIPPER CLOSE → daemon_set_gripper_value(20, 50)
[RTD   ] 静止確認 OK（step5_close: 連続 3 回・連続差 最大 0.00° <= 1.0°）
  [Pi] GRIPPER: VALUE=20 speed=50 result= None
[RTD   ] gripper close (1/1 回目) の daemon 往復 = 0.012s
[STEP  5] gripper dwell 2.0s（読み取りなし）
[STEP  6] MOVE → APPROACH_PICK (lift)  segment PICK → APPROACH_PICK (lift)  (1 回送信 speed=20 → 到達待ち 許容 3.0°[TOL_LIFT_BACK（lift の残差 2.19° を吸収）] / 最大 8.0s)
[RTD   ] 送信 OK（daemon 往復 1.033s）
[RTD   ] arrival OK (PICK → APPROACH_PICK (lift), max|Δ|=2.28° <= tol 3.0°)
[STEP  7] MOVE → APPROACH_PLACE  segment APPROACH_PICK → APPROACH_PLACE  (1 回送信 speed=20 → 到達待ち 許容 3.0°[TOL_APPROACH_PLACE（stage7）] / 最大 14.6s)
[RTD   ] 送信 OK（daemon 往復 1.033s）
[RTD   ] arrival OK (APPROACH_PICK → APPROACH_PLACE, max|Δ|=2.11° <= tol 3.0°)
[STEP  8] MOVE → PLACE  segment APPROACH_PLACE → PLACE  (1 回送信 speed=20 → 到達待ち 許容 3.0°[TOL_PICK_PLACE（stage8_place）] / 最大 8.0s)  [critical]
[RTD   ] 送信 OK（daemon 往復 1.030s）
[RTD   ] arrival OK (APPROACH_PLACE → PLACE, max|Δ|=2.02° <= tol 3.0°)
[STEP  9] GRIPPER OPEN → daemon_set_gripper(0, 50, wait=0)
[RTD   ] 静止確認 OK（step9_open: 連続 3 回・連続差 最大 0.09° <= 1.0°）
  [Pi] GRIPPER: OPEN result= None
[RTD   ] gripper open (1/1 回目) の daemon 往復 = 2.015s
[STEP  9] open 後 2.0s 待ちます（本線の daemon wait=2 相当・読み取りなし）
[STEP  9] gripper dwell 2.0s（読み取りなし）
[STEP 10] MOVE → APPROACH_PLACE (retreat)  segment PLACE → APPROACH_PLACE (retreat)  (1 回送信 speed=20 → 到達待ち 許容 3.0°[TOL_LIFT_BACK（stage10_lift_back）] / 最大 8.0s)
[RTD   ] 送信 OK（daemon 往復 1.026s）
[RTD   ] arrival OK (PLACE → APPROACH_PLACE (retreat), max|Δ|=2.90° <= tol 3.0°)
[STEP 11] MOVE → HOME  segment APPROACH_PLACE → HOME  (1 回送信 speed=20 → 到達待ち 許容 2.5°[TOL_HOME（stage1_to_home / HOME 復帰）] / 最大 10.5s)
[RTD   ] 送信 OK（daemon 往復 1.132s）
[RTD   ] arrival OK (APPROACH_PLACE → HOME, max|Δ|=2.37° <= tol 2.5°)
  [Pi] fresh_mode=0
[RTD   ] daemon_set_fresh_mode(0) 完了
[RTD   ] 実測角の読み取り: ok 65/65 回, 実効 1.70 Hz（目標 3.0 Hz 以上）
[RTD   ] [WARN] 実測角の読み取りが目標 3.0 Hz を下回りました（1.70 Hz）。学習データの state 密度が 19 本より薄くなります
[RTD   ] send_angles の daemon 往復 (7 回): 平均 1.049s / p50 1.033s / 最大 1.132s（timeout 6.0s）
[RTD   ] [WARN] 送信 1 回に 1.132s かかった回があります。daemon は送信後に角度を読み直すので、動き始めで読めないと伸びます（単発送信なので試行全体への影響は小さい）
[RTD   ] 区間の所要（送信→到達確認まで）(8 区間): 平均 2.65s / 最大 4.96s
[RECORD] 電流の記録終了 117 行 (3.06 行/秒. 本体が眠っている間だけ読む. 爪の間 14.067 秒は読まない. 見込み超え 0 回. read_servo)  → /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_192142/recording/currents.csv
[RECORD] 爪の位置と電圧 93 行 (読めた数 {'7:56': 47, '7:57': 47, '2:62': 46, '7:62': 46})  → /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_192142/recording/power_regs.csv
==============================================================================
[RTD   ] 再生 完了
==============================================================================
[RTD   ] つかめたか (y/n) > y
[RTD   ] 箱に入ったか (y/n) > y
[RTD   ] 試行 JSON: /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261115_192142/run_0001_20261115_192142.json
[LEDGER] append OK: /Volumes/KIOXIA/r2r2r-data/runs/pick_place_ledger_v3.csv (pick=yes place=yes recording_status=ok)
[RTD   ] 次に進むには: python3 /Users/shimazueiichi/r2r2r-scripts/pi05/build_demo_episodes.py --run run_0001_20261115_192142 --dataset mecharm_redblock_box_teach_v1
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % 
```

iPhone のロックを外して連係カメラをつなぎ直し、recorder を立ち上げ直しました。そのあとの measure では、上カメラでマットの四隅を10/10で見つけ、ブロックを (198, 195) mm に見つけています。11/9 の本の位置（186, 194）から12mmずれていますが、教えた記録が使えなくなる目安（約40mm）より小さいので、そのまま撮りました。

### 上カメラをつなぎ直したあとの measure のターミナルの全文


```
Last login: Sun Nov 15 18:51:41 on ttys005
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ % python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py measure
python3: can't open file '/Users/shimazueiichi/dynamic_tracking_limits/drag_teaching/record_teach_demo.py': [Errno 2] No such file or directory
(base) shimazueiichi@shimadzueiichinoMacBook-Pro ~ % cd ~/r2r2r-scripts
python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py measure
[RTD   ] 到達許容差は本線 run_pick_place.py の stage 値を使います（区間ごと。一律 8.0° は 2026-10-19 にやめた）:
[RTD   ]   HOME                       2.5°  ← rpp.TOL_HOME（stage1_to_home / HOME 復帰）
[RTD   ]   APPROACH_PICK              2.0°  ← rpp.TOL_APPROACH（approach 系）
[RTD   ]   PICK                       3.0°  ← rpp.TOL_PICK_PLACE（stage4_pick）
[RTD   ]   APPROACH_PICK (lift)       3.0°  ← rpp.TOL_LIFT_BACK（lift の残差 2.19° を吸収）
[RTD   ]   APPROACH_PLACE             3.0°  ← rpp.TOL_APPROACH_PLACE（stage7）
[RTD   ]   PLACE                      3.0°  ← rpp.TOL_PICK_PLACE（stage8_place）
[RTD   ]   APPROACH_PLACE (retreat)   3.0°  ← rpp.TOL_LIFT_BACK（stage10_lift_back）
[RTD   ] 到達を待つ最大時間 = clamp(2.0 + max|Δ|/20*3.0, 8.0, 30.0) 秒（本線と同じ wr._compute_arrival_timeout）
[RTD   ] measure: 上カメラで検出します（repeat=5 interval=0.3s）
[CAM] 接続中カメラ一覧:
  index=0  name=FaceTime HDカメラ
  index=1  name=Iriun Camera
  index=2  name=‎iPhone14 Pro MAXのカメラ
[CAM] 上カメラ(iPhone)  index=2
[CAM] 横カメラ(Iriun)   index=1
[DETECT] resolved top index: 2
[Mac] マット四隅検出中... (10フレーム)
[Mac] ✓ マット四隅検出: 10/10 フレーム成功
[Mac] ✓ 動的homography計算完了
[Mac] ✓ マット範囲: X=[286, 1713] Y=[0, 949]
[06f] TEMPLATES_DIR overridden to: /Users/shimazueiichi/r2r2r-scripts/dynamic_tracking_limits/place/templates
[06f] ROTATION_ANGLES_DEG overridden to: [0, 15, 30, 45, 60, 75]
[06f] SCALES overridden to: [0.85, 1.0, 1.15]
[テンプレ] loading white box templates from: /Users/shimazueiichi/r2r2r-scripts/dynamic_tracking_limits/place/templates
[テンプレ] glob '/Users/shimazueiichi/r2r2r-scripts/dynamic_tracking_limits/place/templates/*.png' → 8 file(s)
[テンプレ]   - white_box_20260520_163829_004.png
[テンプレ]   - white_box_20260520_163838_005.png
[テンプレ]   - white_box_20260520_163846_006.png
[テンプレ]   - white_box_20260520_163905_009.png
[テンプレ]   - white_box_20260520_163912_010.png
[テンプレ]   - white_box_20260520_163918_011.png
[テンプレ]   - white_box_20260520_163923_012.png
[テンプレ]   - white_box_20260520_163929_013.png
[テンプレ] 計 8 枚 (day165=8, auto=0)
[06f] WARN: 輪郭中心とテンプレ中心の距離が閾値超 |Δ|=100.3px > 60px → 輪郭捨てて fallback
[06f] DETECT: center=(1461,562) source=template_fallback score=0.635 angle=0° scale=0.85 size=(167x156) template=white_box_20260520_163838_005.png (eval 5.39s)
[DETECT][1/5] box Unity=(-0.200,+0.191) score=0.6348251104354858
  赤ブロック pixel=(563, 590) → Unity=(0.1985, 0.1951)
[DETECT][1/5] block Unity=(+0.198,+0.195) score=null
[06f] WARN: 輪郭中心とテンプレ中心の距離が閾値超 |Δ|=100.0px > 60px → 輪郭捨てて fallback
[06f] DETECT: center=(1461,561) source=template_fallback score=0.635 angle=0° scale=0.85 size=(167x156) template=white_box_20260520_163838_005.png (eval 5.38s)
[DETECT][2/5] box Unity=(-0.200,+0.191) score=0.6348811984062195
  赤ブロック pixel=(564, 590) → Unity=(0.1981, 0.1951)
[DETECT][2/5] block Unity=(+0.198,+0.195) score=null
[06f] WARN: 輪郭中心とテンプレ中心の距離が閾値超 |Δ|=101.0px > 60px → 輪郭捨てて fallback
[06f] DETECT: center=(1461,561) source=template_fallback score=0.635 angle=0° scale=0.85 size=(167x156) template=white_box_20260520_163838_005.png (eval 5.99s)
[DETECT][3/5] box Unity=(-0.200,+0.191) score=0.6348477602005005
  赤ブロック pixel=(573, 591) → Unity=(0.1942, 0.1957)
[DETECT][3/5] block Unity=(+0.194,+0.196) score=null
[06f] WARN: 輪郭中心とテンプレ中心の距離が閾値超 |Δ|=100.6px > 60px → 輪郭捨てて fallback
[06f] DETECT: center=(1462,562) source=template_fallback score=0.635 angle=0° scale=0.85 size=(167x156) template=white_box_20260520_163838_005.png (eval 5.26s)
[DETECT][4/5] box Unity=(-0.200,+0.191) score=0.6350117921829224
  赤ブロック pixel=(564, 591) → Unity=(0.1981, 0.1956)
[DETECT][4/5] block Unity=(+0.198,+0.196) score=null
[06f] WARN: 輪郭中心とテンプレ中心の距離が閾値超 |Δ|=100.3px > 60px → 輪郭捨てて fallback
[06f] DETECT: center=(1462,562) source=template_fallback score=0.635 angle=0° scale=0.85 size=(167x156) template=white_box_20260520_163838_005.png (eval 5.22s)
[DETECT][5/5] box Unity=(-0.200,+0.191) score=0.6351670622825623
  赤ブロック pixel=(573, 580) → Unity=(0.1941, 0.1905)
[DETECT][5/5] block Unity=(+0.194,+0.190) score=null
[RTD   ] measure: block = (+198.1, +195.1) mm
[RTD   ] measure: box   = (-199.8, +191.4) mm  score=0.6348811984062195
[RTD   ] 確認画像: /Volumes/KIOXIA/r2r2r-data/mecharm_calibration/teach_poses_20261115/measure_20261115_192547.jpg
[RTD   ] homography のもとになった四隅と、測り直した四隅の差: 最大 0.45px（上限 15.0px・やり直し 1 回）
[RTD   ] ブロックのばらつき: 3.0px = 1.28mm（5 枚・上限 4.0mm）
[RTD   ] 元の検出と測り直しの差: 0.48mm（上限 3.0mm）
[RTD   ] 保存しました: /Volumes/KIOXIA/r2r2r-data/mecharm_calibration/teach_poses_20261115/measure_20261115_192547.json
[RTD   ] 次は Pi で教示 → daemon 起動 → recorder.py --top --no-side 常駐 → run --teach <file> --execute
(base) shimazueiichi@shimadzueiichinoMacBook-Pro r2r2r-scripts % 
```



## 案2の2本目（192614）：送ったのに、アームが19秒まったく動かなかった

上カメラを直して撮った案2の2本目（`run_0001_20261115_192614`）は、つかんで箱に入れ、動画も撮れました。ただ、STEP 3（HOME から APPROACH_PICK、いちばん大きい関節で70.48°動く区間）で、送ったあとにアームがまったく動きませんでした。到達の待ち（最大12.5秒）が切れたあと、再送の決まりで5秒待ってもう一度送り、そこで動いています。この区間は23.5秒かかりました。

【画像】LOG514_02_run192614_send_ignored.jpg 上カメラの4コマ。8秒で爪を開いたあと、20秒になってもアームは HOME のまま動かず、31秒で再送により動き出し、35秒でブロックの所へ着いた

この送信では、daemon だけの往復が0.132秒でした。いつもは0.03秒前後です。電流の記録の読みと送信が重なり、送信が順番を待たされたと見ています。同じ1本の STEP 4 も0.134秒でしたが、こちらは無視されていません。

### 192614 の STEP 3 の区間の記録と、送ってからの角度


```
STEP 3 の区間の記録（試行 JSON の segments[2]）
{
 "step": 3,
 "kind": "move",
 "from_name": "HOME",
 "to_name": "APPROACH_PICK",
 "stage": "APPROACH_PICK",
 "critical": false,
 "max_delta_deg": 70.48,
 "arrival_ok": true,
 "arrival_max_delta_deg": 1.14,
 "arrival_actual": [
  -41.04,
  67.14,
  1.93,
  0.87,
  -69.34,
  -30.05
 ],
 "send_failures": 0,
 "send_rtt_sec": 1.1369,
 "segment_elapsed_sec": 23.474,
 "aborted_at": null,
 "arrival_tol_deg": 2.0,
 "arrival_tol_source": "TOL_APPROACH（approach 系）",
 "arrival_timeout_sec": 12.53,
 "pre_actual": [
  -0.43,
  1.58,
  2.02,
  0.26,
  -0.26,
  -30.23
 ],
 "pre_max_delta_deg": 70.22,
 "retried": true,
 "retry_arrived": true,
 "retry_reason": "pre→last max|Δ| 0.00° < 1.0°（送信無視疑い）",
 "retry_move_deg": 0.0,
 "retry_move_after_deg": 69.08,
 "retry_no_move_threshold_deg": 1.0,
 "retry_pause_sec": 5.0,
 "send_rtt_retry_sec": 1.1226,
 "send_wait_on": "mac",
 "send_daemon_rtt_sec": 0.1319,
 "send_daemon_rtt_retry_sec": 0.1205,
 "warnings": [
  "retry_sent"
 ]
}

STEP 3 の送信（stage APPROACH_PICK）からの時刻と、読めた角度（j1・j2・j6・note）
ts,event_type,stage,j0,j1,j2,j3,j4,j5,speed,gripper_state,ts_send,ts_arrival,attempt,arrived,note
+0.000 stage,APPROACH_PICK,,,,,,,,,,,,,
+0.016 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+0.167 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+0.286 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+0.406 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+0.526 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+0.646 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+0.754 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+0.866 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+1.167 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+1.189 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+1.490 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+1.514 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+1.626 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+1.810 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+1.830 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+2.126 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+2.148 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+2.446 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+2.468 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+2.770 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+2.794 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+2.906 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+3.095 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+3.118 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+3.418 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+3.442 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+3.745 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+3.770 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+4.066 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+4.096 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+4.212 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+4.396 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+4.429 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+4.727 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+4.754 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+5.058 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+5.090 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+5.376 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+5.398 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+5.506 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+5.698 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+5.718 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+6.018 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+6.042 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+6.338 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+6.358 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+6.662 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+6.686 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+6.806 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+6.982 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+7.006 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+7.296 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+7.318 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+7.616 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+7.638 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+7.938 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+7.958 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+8.066 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+8.256 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+8.278 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+8.575 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+8.597 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+8.895 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+8.914 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+9.218 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+9.239 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+9.346 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+9.542 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+9.562 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+9.866 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+9.890 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+10.192 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+10.214 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+10.527 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+10.549 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+10.669 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+10.870 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+10.898 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+11.186 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+11.198 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+11.506 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+11.526 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+11.826 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+11.850 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+11.966 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+12.150 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+12.170 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+12.470 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+12.494 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+12.790 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+12.810 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+13.114 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+13.134 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+13.246 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+13.436 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+13.458 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,source=current_thread
+18.756 actual,APPROACH_PICK,-0.430,1.580,2.020,0.260,-0.260,-30.230,,,,,,,
+18.902 actual,APPROACH_PICK,-0.430,2.540,2.020,0.260,-0.700,-30.140,,,,,,,source=current_thread
+19.027 actual,APPROACH_PICK,-3.690,6.150,2.020,0.260,-4.480,-30.140,,,,,,,source=current_thread
+19.150 actual,APPROACH_PICK,-4.650,9.400,2.020,0.260,-8.170,-30.140,,,,,,,source=current_thread
+19.270 actual,APPROACH_PICK,-7.640,12.830,2.020,0.260,-11.680,-30.140,,,,,,,source=current_thread
+19.374 actual,APPROACH_PICK,-8.520,15.550,2.020,-0.080,-14.580,-30.140,,,,,,,source=current_thread
+19.488 actual,APPROACH_PICK,-11.160,18.800,2.020,0.350,-18.360,-30.050,,,,,,,source=current_thread
+19.610 actual,APPROACH_PICK,-13.180,22.410,2.020,-0.350,-21.970,-30.140,,,,,,,source=current_thread
+19.898 actual,APPROACH_PICK,-18.540,30.670,2.020,0.170,-30.760,-29.880,,,,,,,
+19.920 actual,APPROACH_PICK,-18.630,31.200,2.020,0.350,-31.370,-29.970,,,,,,,source=current_thread
+20.028 actual,APPROACH_PICK,-19.950,34.100,2.020,-0.520,-34.540,-30.050,,,,,,,source=current_thread
+20.218 actual,APPROACH_PICK,-22.930,39.370,2.020,0.170,-40.160,-29.970,,,,,,,
+20.241 actual,APPROACH_PICK,-23.370,39.990,2.020,-0.430,-40.780,-30.050,,,,,,,source=current_thread
+20.537 actual,APPROACH_PICK,-29.090,48.160,2.020,-0.520,-49.650,-30.050,,,,,,,
+20.558 actual,APPROACH_PICK,-29.440,48.510,2.020,-0.520,-50.090,-30.050,,,,,,,source=current_thread
+20.862 actual,APPROACH_PICK,-35.150,56.860,2.020,0.260,-59.320,-30.050,,,,,,,
+20.882 actual,APPROACH_PICK,-35.240,57.390,2.020,0.700,-59.850,-30.050,,,,,,,source=current_thread
+21.185 actual,APPROACH_PICK,-39.630,65.560,1.930,0.960,-68.020,-30.050,,,,,,,
+21.206 actual,APPROACH_PICK,-39.630,66.090,1.930,0.870,-68.020,-30.050,,,,,,,source=current_thread
+21.330 actual,APPROACH_PICK,-41.040,67.140,1.930,0.610,-68.020,-30.050,,,,,,,source=current_thread
+21.508 actual,APPROACH_PICK,-41.040,67.140,1.930,0.610,-68.020,-30.050,,,,,,,
+21.520 actual,APPROACH_PICK,-41.040,67.140,1.930,0.610,-68.020,-30.050,,,,,,,source=current_thread
+21.833 actual,APPROACH_PICK,-41.040,67.140,1.930,0.870,-68.020,-30.050,,,,,,,
+21.854 actual,APPROACH_PICK,-41.040,67.140,1.930,0.870,-68.020,-30.050,,,,,,,source=current_thread
+22.169 actual,APPROACH_PICK,-41.040,67.140,1.930,0.870,-68.020,-30.050,,,,,,,
+22.201 actual,APPROACH_PICK,-41.040,67.140,1.930,0.870,-68.020,-30.050,,,,,,,source=current_thread
+22.499 actual,APPROACH_PICK,-41.040,67.140,1.930,0.870,-68.020,-30.050,,,,,,,
+22.531 actual,APPROACH_PICK,-41.040,67.140,1.930,0.870,-68.020,-30.050,,,,,,,source=current_thread
+22.830 actual,APPROACH_PICK,-41.040,67.140,1.930,0.870,-68.020,-30.050,,,,,,,
+22.850 actual,APPROACH_PICK,-41.040,67.140,1.930,0.870,-68.020,-30.050,,,,,,,source=current_thread
+23.148 actual,APPROACH_PICK,-41.040,67.140,1.930,0.870,-68.110,-30.050,,,,,,,
+23.170 actual,APPROACH_PICK,-41.040,67.140,1.930,0.870,-68.110,-30.050,,,,,,,source=current_thread
+23.474 actual,APPROACH_PICK,-41.040,67.140,1.930,0.870,-69.340,-30.050,,,,,,,
+23.474 stage,PICK,,,,,,,,,,,,,
+23.493 actual,PICK,-41.040,67.140,1.930,0.870,-69.340,-30.050,,,,,,,
+23.642 actual,PICK,-41.040,69.250,1.930,0.700,-70.480,-30.050,,,,,,,source=current_thread
+23.750 actual,PICK,-41.040,72.500,1.840,0.790,-70.920,-30.050,,,,,,,source=current_thread
+23.870 actual,PICK,-41.040,76.280,1.400,0.700,-71.800,-30.050,,,,,,,source=current_thread
+23.990 actual,PICK,-41.040,79.100,0.350,0.700,-74.000,-29.970,,,,,,,source=current_thread
+24.098 actual,PICK,-41.040,80.410,0.260,0.520,-75.580,-29.880,,,,,,,source=current_thread
+24.210 actual,PICK,-41.040,80.410,0.260,0.520,-75.580,-29.790,,,,,,,source=current_thread
+24.334 actual,PICK,-41.040,80.410,0.260,0.520,-75.580,-29.790,,,,,,,source=current_thread
+24.650 actual,PICK,-41.040,80.410,0.260,0.520,-75.580,-29.790,,,,,,,
+24.669 actual,PICK,-41.040,80.410,0.260,0.520,-75.580,-29.790,,,,,,,
+24.694 actual,PICK,-41.040,80.410,0.260,0.520,-75.580,-29.790,,,,,,,source=current_thread
+24.810 actual,PICK,-41.040,80.410,0.260,0.520,-75.580,-29.790,,,,,,,source=current_thread
+24.990 actual,PICK,-41.040,80.410,0.260,0.520,-75.580,-29.790,,,,,,,
```

過去の手教示の再生と比べました。KIOXIA にある手教示の再生の試行 JSON 111本で、再送は19回ありました。そのうち18回は、届く手前で止まっていたか、動いている途中でした。送ったあとの動きが1°未満で「送信無視疑い」になったのは3回で、10/19 の2回は0.96°動いています。**動いた量が0.00°、つまり送信がまったく効かなかったのは、案2の192614の1回だけでした。**

### 手教示の再生111本の再送の一覧


```
手教示の再生の試行 JSON: 111 本 / 再送: 19 回
run | step | 行き先 | 待ち | 送ってから動いた量(°) | 再送の理由
run_0001_20261019_180242 | 6 | APPROACH_PICK (lift) | daemon | 13.63 | pre→last max|Δ| 13.63° >= 1.0°（部分移動/ストール疑い）
run_0001_20261019_181957 | 6 | APPROACH_PICK (lift) | daemon | 13.45 | pre→last max|Δ| 13.45° >= 1.0°（動いているので再送しない）
run_0001_20261019_182104 | 6 | APPROACH_PICK (lift) | daemon | 13.45 | pre→last max|Δ| 13.45° >= 1.0°（動いているので再送しない）
run_0001_20261019_182205 | 6 | APPROACH_PICK (lift) | daemon | 13.45 | pre→last max|Δ| 13.45° >= 1.0°（動いているので再送しない）
run_0001_20261019_184202 | 4 | PICK | daemon | 1.5 | pre→last max|Δ| 1.50° >= 1.0°（動いているので再送しない）
run_0001_20261019_184300 | 4 | PICK | daemon | 1.32 | pre→last max|Δ| 1.32° >= 1.0°（動いているので再送しない）
run_0001_20261019_184840 | 4 | PICK | daemon | 0.96 | pre→last max|Δ| 0.96° < 1.0°（送信無視疑い）
run_0001_20261019_184957 | 4 | PICK | daemon | 1.41 | pre→last max|Δ| 1.41° >= 1.0°（動いているので再送しない）
run_0001_20261019_185236 | 4 | PICK | daemon | 1.32 | pre→last max|Δ| 1.32° >= 1.0°（動いているので再送しない）
run_0001_20261019_185949 | 4 | PICK | daemon | 0.96 | pre→last max|Δ| 0.96° < 1.0°（送信無視疑い）
run_0001_20261109_102903 | 4 | PICK | daemon | 11.96 | pre→last max|Δ| 11.96° >= 1.0°（動いているので再送しない）
run_0001_20261109_124530 | 6 | APPROACH_PICK (lift) | daemon | 44.3 | pre→last max|Δ| 44.30° >= 1.0°（動いているので再送しない）
run_0001_20261109_124530 | 7 | APPROACH_PLACE | daemon | 67.13 | pre→last max|Δ| 67.13° >= 1.0°（動いているので再送しない）
run_0001_20261109_125209 | 6 | APPROACH_PICK (lift) | daemon | 8.97 | pre→last max|Δ| 8.97° >= 1.0°（動いているので再送しない）
run_0001_20261109_125209 | 7 | APPROACH_PLACE | daemon | 103.35 | pre→last max|Δ| 103.35° >= 1.0°（動いているので再送しない）
run_0001_20261109_125607 | 7 | APPROACH_PLACE | daemon | 103.53 | pre→last max|Δ| 103.53° >= 1.0°（動いているので再送しない）
run_0001_20261109_125825 | 6 | APPROACH_PICK (lift) | daemon | 26.28 | pre→last max|Δ| 26.28° >= 1.0°（動いているので再送しない）
run_0001_20261109_125825 | 7 | APPROACH_PLACE | daemon | 104.58 | pre→last max|Δ| 104.58° >= 1.0°（動いているので再送しない）
run_0001_20261115_192614 | 3 | APPROACH_PICK | mac | 0.0 | pre→last max|Δ| 0.00° < 1.0°（送信無視疑い）
```

### 案1の2本と案2の2本を比べた表


```

## before (2 本)
  run | actual | うち電流 | 間 中央 | 90% | 1秒超 | poll中央 | send中央 | 本体だけ中央 | 本体90% | 電流だけ中央 | 逆順 | 送らず | 見込み超え | 静止reads | 再送 | 待ち | 結果
  run_0001_20261115_165039 | 94 | 43 | 0.116 | 1.046 | 11 | 0.108 | 1.053 | 0.322 | 1.062 | 0.293 | 0 | 0 | 0 | 12 | 0 | - | completed
  run_0001_20261115_165245 | 107 | 51 | 0.116 | 0.674 | 11 | 0.112 | 1.048 | 0.324 | 1.048 | 0.285 | 0 | 0 | 0 | 12 | 0 | - | completed
  (本ごとの中央値) actual 100.500 | うち電流 47.000 | 間 中央 0.116 | 90% 0.860 | 1秒超 11.000 | poll中央 0.110 | send中央 1.051 | 本体だけ中央 0.323 | 本体90% 1.055 | 電流だけ中央 0.289 | 逆順 0.000 | 送らず 0.000 | 見込み超え 0.000 | 静止reads 12.000 | 再送 0.000

## after (2 本)
  run | actual | うち電流 | 間 中央 | 90% | 1秒超 | poll中央 | send中央 | 本体だけ中央 | 本体90% | 電流だけ中央 | 逆順 | 送らず | 見込み超え | 静止reads | 再送 | 待ち | 結果
  run_0001_20261115_192142 | 182 | 117 | 0.118 | 0.300 | 3 | 0.120 | 0.064 | 0.324 | 1.061 | 0.122 | 0 | 0 | 0 | 12 | 0 | mac | completed
  run_0001_20261115_192614 | 277 | 173 | 0.119 | 0.301 | 4 | 0.119 | 0.064 | 0.323 | 1.055 | 0.204 | 0 | 0 | 0 | 12 | 1 | mac | completed
  (本ごとの中央値) actual 229.500 | うち電流 145.000 | 間 中央 0.118 | 90% 0.300 | 1秒超 3.500 | poll中央 0.119 | send中央 0.064 | 本体だけ中央 0.324 | 本体90% 1.058 | 電流だけ中央 0.163 | 逆順 0.000 | 送らず 0.000 | 見込み超え 0.000 | 静止reads 12.000 | 再送 0.500

## 区間ごと (群ごとの中央値: 送信の往復 (待ちを含む) / daemon だけの往復 / 区間の長さ / 静止の確かめの reads)
  step 1 move HOME  before: n=2 rtt 1.031 daemon - 長さ 4.470 reads -  /  after: n=2 rtt 1.082 daemon 0.078 長さ 4.511 reads -
  step 2 gripper open  before: n=2 rtt - daemon - 長さ - reads 4.000  /  after: n=2 rtt - daemon - 長さ - reads 4.000
  step 3 move APPROACH_PICK  before: n=2 rtt 1.042 daemon - 長さ 3.490 reads -  /  after: n=2 rtt 1.096 daemon 0.092 長さ 14.217 reads -
  step 4 move PICK  before: n=2 rtt 1.030 daemon - 長さ 1.063 reads -  /  after: n=2 rtt 1.087 daemon 0.083 長さ 1.129 reads -
  step 5 gripper close  before: n=2 rtt - daemon - 長さ - reads 4.000  /  after: n=2 rtt - daemon - 長さ - reads 4.000
  step 6 move APPROACH_PICK (lift)  before: n=2 rtt 1.031 daemon - 長さ 1.059 reads -  /  after: n=2 rtt 1.039 daemon 0.036 長さ 1.078 reads -
  step 7 move APPROACH_PLACE  before: n=2 rtt 1.040 daemon - 長さ 3.021 reads -  /  after: n=2 rtt 1.035 daemon 0.031 長さ 3.012 reads -
  step 8 move PLACE  before: n=2 rtt 1.030 daemon - 長さ 1.069 reads -  /  after: n=2 rtt 1.032 daemon 0.030 長さ 2.679 reads -
  step 9 gripper open  before: n=2 rtt - daemon - 長さ - reads 4.000  /  after: n=2 rtt - daemon - 長さ - reads 4.000
  step 10 move APPROACH_PLACE (retreat)  before: n=2 rtt 1.034 daemon - 長さ 1.067 reads -  /  after: n=2 rtt 1.031 daemon 0.028 長さ 1.066 reads -
  step 11 move HOME  before: n=2 rtt 1.043 daemon - 長さ 2.045 reads -  /  after: n=2 rtt 1.085 daemon 0.080 長さ 2.744 reads -
```

| | 案1（165039・165245） | 案2（192142・192614） |
|---|---|---|
| 角度の行の数 | 100.5 | 229.5 |
| 間隔の中央値 | 0.116秒 | 0.118秒 |
| 間隔の90%点 | 0.860秒 | 0.300秒 |
| 1秒を超える抜け | 11 | 3.5（192142 は3、192614 は再送の前の5秒の待ちを含めて4） |
| daemon だけの往復 | ― | 0.03秒前後。ただし HOME からの送信など一部は0.08〜0.13秒 |
| 読みが長引いた回（overruns） | 0 | 0 |
| 再送 | 0 | 1（192614 の STEP 3） |

- ねらい：送ったあとの1秒、つまりアームがいちばん動いている間の角度も、お手本に入れる
- 変わったこと：1秒を超える抜けが11か所から3か所に、間隔の90%点が0.86秒から0.30秒になった
- 見込める効果：動いている最中の角度が、補った値ではなく測った値になる。ただし2本のうち1本で送信が無視され、このままでは撮るたびに止まる危うさがある

2本のうち1本、という数だけでは、案2のせいだと言い切れません。ただ、案1までの形の109本では一度も起きていないことと、無視された送信の往復が長かったことから、送った直後の読みが関わっている見込みが高いと見ています。




## 原因が分かるまで、お手本は案1の形で撮る

案2の切り替え（`--send-wait-on mac|daemon`）は、依頼213で付けてありました。`daemon` を選ぶと、案1までと同じく Pi の中で1秒待ちます。原因が分かるまで、お手本は `--send-wait-on daemon` で撮ることにし、原因を調べる依頼を出しました。

### 依頼215 の依頼文


```markdown
---
作業フォルダ: /Users/shimazueiichi/r2r2r-scripts
上限時間: 120
---
# 依頼215：案2（送信のあとの 1.0 秒を Mac で待つ・依頼213）で送信が無視された原因を調べ、読みとの重なりを避ける

実機は動かさない。Pi は読むだけ（daemon のログ・ファイル。daemon の再起動・置き換えはしない）。Log37。
物理的リスク：中（送信と読みの順番に触れる）。直すなら codex のレビューを必ず通す。

## なぜ
依頼213 の実機 2 本（--send-wait-on mac）のうち run_0001_20261115_192614 の STEP 3（HOME → APPROACH_PICK、max|Δ| 70.48°）で、送信のあとアームが全く動かず（pre→last 0.00°・送信無視疑い）、到達の待ちが切れてから 5 秒待って再送し、そこで届いた（区間 23.5 秒）。この送信の send_daemon_rtt_sec は 0.132 秒（ほかは 0.03 秒前後）。STEP 4 も 0.134 秒だったが無視はされていない。
手教示の再生 108 本（すべて daemon で待つ形）では再送 18 回があるが、0.00° の完全な無視は 1 回もない。もう 1 本の 192142（mac）は再送 0。
エイイチの決め（2026-11-15）：原因が分かるまで、お手本は --send-wait-on daemon で撮る。

## やること
1. 192614 の STEP 3・4 で、送信と電流の記録スレッドの read_servo が時刻上どう並んだかを、states.csv・currents.csv・試行 JSON・あれば鍵の待ちの記録から ms 単位で並べる。送信の直前・直後に read_servo が出ていたか、鍵の待ちで送信が何 ms 遅れたか
2. Pi の daemon のログ（/home/ubuntu/daemon.log など。読むだけ）で、19:26 前後の STEP 3 の send_angles を受けて書き込んだか、エラーや返事なしがないかを見る
3. tools/pi/mecharm_daemon.py と pymycobot 2.9.6 の send_angles・read_servo の作りから、送った直後（〜0.2 秒）の読みが送信を打ち消す・取りこぼす筋があるかを調べる（fresh_mode=1 との関係も）
4. 避け方の案を出す（例：送信のあと X 秒は電流スレッドに読ませない、read_servo ではなく get_angles だけにする、送信の前に読みが終わるのを待つ）。それぞれで抜けがどれだけ残るかの見込みと、物理的リスクを書く
5. 案のうち、物理的リスクが低く効きそうなものを 1 つ実装してよい（既定の --send-wait-on は mac のままでも daemon に戻してもよいが、どちらにしたかと理由を書く）。テストを足し、既存のテスト（pi05/ と test_lab_start.sh。test_state_source は除く）を通し、codex のレビューで必須の指摘がなくなるまで直す。原因がはっきりしないときは実装せず、調べた結果と案だけで止める
6. record_teach_demo.py は git の外なので、変えるなら直す前の写しを .bak_pre_req215_20261115 で残す。ほかは変えたファイルだけを指定して git add・commit（git add . と git clean は使わない）

## 報告
重なりの時刻の表、daemon のログで分かったこと、原因の見立て（確かさも）、避け方の案と選んだもの、実機で確かめる手順（何本撮って何を見るか）、決めてほしいこと
```

案1の形で撮った1本（`run_0001_20261115_192952`）は、つかんで箱に入れ、再送はありませんでした。上カメラの動画も撮れています。角度の間隔の中央値は0.117秒で、1秒を超える抜けは案1の形どおり11か所でした。

【画像】LOG514_01_run192952_daemon.jpg 案1の形で撮った192952の上カメラの4コマ。0秒の HOME から、19秒でブロックをつかみ、25秒で箱の上へ運び、36秒で HOME へ戻る

### 案2の2本と、案1の形で撮った192952を比べた表


```

## before (2 本)
  run | actual | うち電流 | 間 中央 | 90% | 1秒超 | poll中央 | send中央 | 本体だけ中央 | 本体90% | 電流だけ中央 | 逆順 | 送らず | 見込み超え | 静止reads | 再送 | 待ち | 結果
  run_0001_20261115_192142 | 182 | 117 | 0.118 | 0.300 | 3 | 0.120 | 0.064 | 0.324 | 1.061 | 0.122 | 0 | 0 | 0 | 12 | 0 | mac | completed
  run_0001_20261115_192614 | 277 | 173 | 0.119 | 0.301 | 4 | 0.119 | 0.064 | 0.323 | 1.055 | 0.204 | 0 | 0 | 0 | 12 | 1 | mac | completed
  (本ごとの中央値) actual 229.500 | うち電流 145.000 | 間 中央 0.118 | 90% 0.300 | 1秒超 3.500 | poll中央 0.119 | send中央 0.064 | 本体だけ中央 0.324 | 本体90% 1.058 | 電流だけ中央 0.163 | 逆順 0.000 | 送らず 0.000 | 見込み超え 0.000 | 静止reads 12.000 | 再送 0.500

## after (1 本)
  run | actual | うち電流 | 間 中央 | 90% | 1秒超 | poll中央 | send中央 | 本体だけ中央 | 本体90% | 電流だけ中央 | 逆順 | 送らず | 見込み超え | 静止reads | 再送 | 待ち | 結果
  run_0001_20261115_192952 | 125 | 61 | 0.117 | 0.306 | 11 | 0.112 | 1.053 | 0.324 | 1.053 | 0.296 | 0 | 0 | 0 | 12 | 0 | daemon | completed

## 区間ごと (群ごとの中央値: 送信の往復 (待ちを含む) / daemon だけの往復 / 区間の長さ / 静止の確かめの reads)
  step 1 move HOME  before: n=2 rtt 1.082 daemon 0.078 長さ 4.511 reads -  /  after: n=1 rtt 1.032 daemon 1.031 長さ 4.469 reads -
  step 2 gripper open  before: n=2 rtt - daemon - 長さ - reads 4.000  /  after: n=1 rtt - daemon - 長さ - reads 4
  step 3 move APPROACH_PICK  before: n=2 rtt 1.096 daemon 0.092 長さ 14.217 reads -  /  after: n=1 rtt 1.041 daemon 1.041 長さ 4.607 reads -
  step 4 move PICK  before: n=2 rtt 1.087 daemon 0.083 長さ 1.129 reads -  /  after: n=1 rtt 1.029 daemon 1.029 長さ 1.061 reads -
  step 5 gripper close  before: n=2 rtt - daemon - 長さ - reads 4.000  /  after: n=1 rtt - daemon - 長さ - reads 4
  step 6 move APPROACH_PICK (lift)  before: n=2 rtt 1.039 daemon 0.036 長さ 1.078 reads -  /  after: n=1 rtt 1.055 daemon 1.055 長さ 1.101 reads -
  step 7 move APPROACH_PLACE  before: n=2 rtt 1.035 daemon 0.031 長さ 3.012 reads -  /  after: n=1 rtt 1.030 daemon 1.030 長さ 2.987 reads -
  step 8 move PLACE  before: n=2 rtt 1.032 daemon 0.030 長さ 2.679 reads -  /  after: n=1 rtt 1.031 daemon 1.031 長さ 2.703 reads -
  step 9 gripper open  before: n=2 rtt - daemon - 長さ - reads 4.000  /  after: n=1 rtt - daemon - 長さ - reads 4
  step 10 move APPROACH_PLACE (retreat)  before: n=2 rtt 1.031 daemon 0.028 長さ 1.066 reads -  /  after: n=1 rtt 1.042 daemon 1.042 長さ 1.071 reads -
  step 11 move HOME  before: n=2 rtt 1.085 daemon 0.080 長さ 2.744 reads -  /  after: n=1 rtt 1.031 daemon 1.031 長さ 2.672 reads -
```

この1本のターミナルの出力は残していません。数字は試行の記録（`run_0001_20261115_192952.json` と `states.csv`）から読んでいます。

この回の終わりの時点で、お手本に使えるのは192952の1本と、案1の165245の1本です。165039 は位置5に置いたため、192142 は動画がないため、192614 は案2の形で送信が無視されたため、お手本には入れません。


## 次にやること：依頼215 で送信が無視された原因を確かめてから、お手本を撮り直す

| 順 | やること | 要るもの |
|---|---|---|
| 1 | 依頼215：192614 の送信と読みの重なりを ms 単位で並べ、Pi の daemon のログを読み、避け方を決める | 依頼箱 |
| 2 | 避け方が入ったら、案2の形で何本か撮り、送信の無視が起きないかを数える | 実機 |
| 3 | 決めた形で、位置1〜5のお手本を撮り直す | 実機 |
| 4 | 学習し直す | Runpod の GPU |
| 5 | 実機で推論し、判定の画面で成否を付けて、前の回の成功率59.8%と比べる | 実機・判定の画面 |

撮るときは、新しいターミナルを開くたびに `cd ~/r2r2r-scripts` から始めます。上カメラの iPhone は自動ロックを「なし」にし、recorder に「read 連続失敗」が出ていないことを確かめてから measure します。



## 追記：依頼215 ― 送信が無視された原因を調べた結果

公開したあとに、依頼215の結果が届きました（19:29〜19:40、11分）。コードは変えておらず、調べた結果と避け方の案だけです。

**読みと送信は重なっておらず、電流の記録が送信を打ち消した見込みは低い、というのが Claude Code の見立てです。** 送信の直前・直後に電流の記録の読みは出ておらず、順番待ちで送信が遅れたのは3回とも0 ms でした。daemon だけの往復が0.13秒に伸びたのは、daemon が書き込みの約10 ms 後に自分で出す角度の読みに、アームの制御基板が0.1秒以内に答えなかったためです。Pi の daemon のログ全体では、書き込みの直後に読むと4,708回のうち46%が返事なしで、1.0秒眠ってから読むと2,038回のうち1回だけでした。

いちばん疑わしい引き金は、daemon が書き込みの直後に出すこの読みです。案2で新しく生まれた違いはこれだけだからです。ただ、返事なしだった5回のうち4回は動いているので、確かさは「中くらいより下」とされました。形どうしで比べると、0.00°の無視は daemon で待つ形の約860回で0回、Mac で待つ形の16回で1回で、これが偶然で生じる見込みは約2%です。

避け方の案は次の3つに絞られました。

| 案 | やること | 抜けの見込み | 物理的リスク |
|---|---|---|---|
| A | daemon で待つ形を続ける（今のお手本の撮り方） | 送ったあとの約1.05秒は読めないまま | 低い。約860回で無視0回の実績 |
| F | 1.0秒を daemon と Mac に分ける（例：daemon で0.2秒、Mac で0.8秒） | 送ったあとの最初の0.2秒だけ読めない | 低い。待ちの合計は1.0秒のまま、daemon も変えない |
| B | 書き込みのあと読まない送り方（`send_angles_fast`）にし、最初の Q 秒は電流の記録にも読ませない | 送ったあとの最初の Q 秒だけ読めない | 低〜中。この送り方はログに使われた跡がない |

もう一つ、範囲の外で見つかったことがあります。Pi の Python 3.6 の pymycobot が、この日の17:53ごろ（Mac の時刻）に4.0.4へ入れ替わっていました。いま動いている daemon はその前に立ち上げたので、古い版（2.9.6）のまま動いています。次に daemon を立ち上げ直すと4.0.4になり、返事がないと同じ命令を最大3回書き直す作りに変わります。10/19 に、4.0.4 を拾ってすべての命令が1.5秒かかった前例もあるので、daemon を立ち上げ直す前に、どうするかを決める必要があります。

### 依頼215 で Claude Code が返した報告

```markdown
# 結果：20261115_215_案2で送信が無視された原因を調べ読みとの重なりを避ける

- 状態：完了
- 始めた時刻：2026-11-15 19:29
- 終わった時刻：2026-11-15 19:40（11分）
- 作業フォルダ：/Users/shimazueiichi/r2r2r-scripts
- この続きを Claude Code で話すとき：作業フォルダで `claude --resume 4e55a7c8-d6fe-468f-9b4a-97dd02c8a05b`

## Claude Code の報告

やったこと
- 192614 の STEP 3・4 と再送で、送信と電流の記録スレッドの読みが時刻上どう並んだかを、states.csv・currents.csv・試行 JSON から ms 単位で並べました。比べる本として、無視が出なかった mac の形の 192142 と daemon の形の 192952 も見ました。
- Pi の /home/ubuntu/daemon.log を読むだけで調べました。19:26 前後の流れと、ログ全体で送信の直後に読んだ結果を数えました。
- tools/pi/mecharm_daemon.py（Pi のものと md5 が一致）と pymycobot の送信・読みの作りを確かめました。
- 避け方の案を 6 つ並べ、見込みと物理的リスクを書きました。実装はしていません。

結果
- 重なりの時刻（0 ms は送信の直前に本体が角度を読み終えた時刻）:

| 区間 | daemon の直後の読み | Mac へ返った | 電流スレッドの最初の読み | 鍵の待ち |
|---|---|---|---|---|
| STEP 3（無視された） | 返事なし | +132 ms | +152 ms、動きは 0.00° | 0 ms |
| STEP 3 の再送 | 返事なし | +121 ms | +146 ms、すでに約 1° 動いていた | 0 ms |
| STEP 4 | 返事なし | +134 ms | +148 ms、2.11° 動いていた | 0 ms |

- 送信の直前・直後に電流スレッドの read_servo は出ていませんでした。鍵の待ちで送信が遅れたのは 3 回とも 0 ms です。電流スレッドが送信の +50〜+75 ms に読んだ回は 11 回あり、すべて動きました。
- send_daemon_rtt_sec が 0.13 秒に伸びたのは、鍵の待ちが原因ではありません。daemon が書き込みの約 10 ms 後に自分で出す角度の読みが、0.1 秒待っても返事なしだったためです。2 本で返事なしは 5 回あり、往復はどれも 0.12〜0.13 秒でした。角度が返った 11 回は 0.02〜0.05 秒です。
- daemon のログでは、STEP 3 の書き込みは 10 ms で終わっています。19:26 前後に例外や接続の切れ直しの記録はなく、fresh_mode=1 は daemon の形の本と同じです。ログ全体では、書き込みの直後に読むと 4708 回のうち 46% が返事なしでした。1.0 秒眠ってから読むと 2038 回のうち 1 回（0.05%）だけです。
- 見立てと確かさ:
  - 電流スレッドが送信を打ち消した見込みは低いです。動いた送信は +150〜+190 ms までに動き始めていますが、STEP 3 は電流スレッドの最初の読みの時点で 0.00° でした。それより前に送信は失われていたと見ています。
  - 引き金として一番疑わしいのは、daemon が書き込みの直後に出す読みです。mac の形で新しく生まれた違いはこれだけですが、確かさは中くらいより下です。返事なしの 5 回のうち 4 回は動いており、無視は 1 回だけだからです。
  - 形どうしの差は偶然とは考えにくいです。0.00° の無視は daemon の形で約 860 回中 0 回、mac の形で 16 回中 1 回でした。差が偶然で生じる見込みは約 2% です。
  - pymycobot の作りの上では、読みが送信を打ち消す処理はありません。打ち消しがあるとすれば制御基板の側です。
- 避け方の案:
  - 案 A：daemon の形を続ける。実績は約 860 回で無視 0 回、物理的リスクは低いです。ただし送信のあと約 1.05 秒は読めません。
  - 案 F：1.0 秒を daemon と Mac に分ける（例：daemon で 0.2 秒、Mac で 0.8 秒）。待ちの合計は縮まず、daemon も pymycobot も今のままです。書き込みのあと最初の読みが 0.2 秒あとにずれます。物理的リスクは低いです。
  - 案 B：書き込みのあと読まない send_angles_fast で送り、最初の Q 秒は電流スレッドにも読ませない。今のログにこの経路の使用は 1 回もないので、物理的リスクは低〜中です。
  - 案 C（電流スレッドを角度の読みだけにする）は、ほとんど効かない見込みです。案 D（送信の前に読みが終わるのを待つ）は今も鍵で待っていて、待ちは 0 ms なので効きません。案 E（daemon の直後の読みをやめる）は daemon の置き換えが要るので範囲の外です。
- 実装しなかった理由：原因が 1 回の事象からしか見えず、はっきりしないためです。効きそうな案 F・B は、0.2 秒や Q 秒といった数値を決める必要があります。コードの既定は mac のまま変えていません。お手本は決めどおり --send-wait-on daemon で撮ってください。
- 実機で確かめる手順（案が決まったら）：その形で 10 本（80 回の送信）撮ります。今の割合（16 回に 1 回）なら、80 回で 1 回も無視が出ない見込みは約 0.6% なので、0 回なら効いたと言えます。見るのは次の 5 つで、daemon の形も数本はさんで撮ると日によるぶれと分けられます。
  1. 試行 JSON で、動きが 0.00° のまま再送した回がないか
  2. send_daemon_rtt_sec（案 F なら普段は約 0.23 秒）
  3. daemon.log の「send_angles 後の現在角度: None」の回数
  4. 電流スレッドの最初の読みが、決めた秒数より後に出ているか
  5. 動き始め（+150〜+300 ms の動き）が daemon の形と同じか
- 範囲の外で気づいたこと：Pi の Python 3.6 の pymycobot が、今日（Pi 時刻 15:46、Mac で 17:53 ごろ）4.0.4 に入れ替わっています。依頼文の 2.9.6 ではありませんでした。動いている daemon はその前に起動したので、今も入れ替え前の版のままです。そのため送信の作りは、Python 2.7 側に残っている 2.9.6 で確かめました。daemon を起動し直すと 4.0.4 になり、返事がないと同じ命令を最大 3 回書き直す作りに変わります。

変えたファイル
- コード・テストは変えていません。git の commit もしていません。
- 報告として次の 2 つを書きました。
  - claude_code_reports/20261115_215.txt
  - logs/20261115_1945.md

決めてほしいこと
1. 避け方をどれにするか。A（daemon の形を続ける）、F（分け方の数値、例 0.2 秒と 0.8 秒）、B（send_angles_fast と、読ませない Q 秒の数値）のどれか。
2. record_teach_demo.py の --send-wait-on の既定を daemon に戻すか。
3. 原因を詰めるために、今の mac の形のまま何本か撮って無視の割合を測るか。無視されたときは 5 秒待って再送する、今までと同じ動きです。
4. Pi の pymycobot が 4.0.4 に替わっている件。誰が入れたかの確認と、daemon を起動し直す前に 2.9.6 に戻すかどうか。
```

### 依頼215 の詳しい報告（claude_code_reports/20261115_215.txt）

```
依頼215 案2（送信のあとの 1.0 秒を Mac で待つ・依頼213）で送信が無視された原因を調べ、読みとの重なりを避ける（Log37）

実機は動かしていない。Pi は読むだけ（daemon.log・daemon のファイル・pymycobot のファイル。daemon の再起動・置き換えはしていない）。
コードは変えていない（原因がはっきりせず、効きそうな案はどれも数値かやり方をエイイチが決める必要があるため。下の「決めてほしいこと」）。

■ 1. 重なりの時刻の表（ms 単位）
基準の 0 ms = 送信の直前の本体の読み（get_angles）が返った時刻（states.csv のその actual 行。送信はこの直後に出る）。
daemon の中の時刻は daemon.log（秒まで）と elapsed_ms から。電流スレッドの時刻は currents.csv の ts（角度を読んだ時刻）。
Δ は送信前の姿勢からの max|Δ|。

run_0001_20261115_192614（--send-wait-on mac）
| 区間 | 0 ms の時刻 | 書き込み終わり | daemon の直後の読み（get_angles） | Mac へ返った | 電流スレッド 1 回目 | 2 回目 | 3 回目 | 鍵の待ち |
| STEP 3 HOME→APPROACH_PICK（無視された） | 19:26:26.671 | 約 +10（elapsed 10.0 ms） | 返事なし（None）約 +10〜+120 | +132 | +152 Δ0.00（read_servo 118.5 ms） | +271 Δ0.00 | +391 Δ0.00 | 0 ms（直前の電流の読みは 6.3 秒前・爪の間は止めていた） |
| STEP 3 の再送 | 19:26:45.411 | 約 +10（9.8 ms） | 返事なし（None） | +121 | +146 j1 で 0.96°（1.58→2.54） | +272 j1 で 4.57° | +394 j1 で 7.82° | 0 ms（再送の前の 5 秒は電流を止めていた） |
| STEP 4 APPROACH_PICK→PICK | 19:26:50.149 | 約 +10 | 返事なし（None） | +134 | +148 Δ2.11 | +257 Δ5.36 | +377 Δ9.14 | 0 ms（直前の電流の読みは約 210 ms 前に終わり、その間に本体の読みが 1 回） |
比べる本 run_0001_20261115_192142（mac・無視なし）の STEP 3: 返った +52（直後の読みは角度が返った）、電流スレッド 1 回目 +75 Δ0.00、2 回目 +189 Δ2.46

分かったこと
- 送信の直前・直後に電流スレッドの read_servo は出ていない。送信の直前の 1 回は本体の get_angles（daemon でも mac でも同じ）。鍵の待ちで送信が遅れたのは 3 回とも 0 ms
- send_daemon_rtt_sec が 0.13 秒前後に伸びたのは、鍵の待ちではなく、daemon が書き込みの直後に読む get_angles が返事なしで 0.1 秒待ったため（下の 2）
- 送信の直後に最初に読みを出したのは daemon 自身（約 +10 ms）。電流スレッドの最初の読みは返事のあと（+52〜+152 ms）
- 動いた 15 回は、+146〜+190 ms までに 1〜3° 動き始めている（STEP 4・再送は +150 ms 前後で 1〜2°）。STEP 3 は +152・+271・+391 ms とも 0.00° なので、電流スレッドの最初の読み（+152 ms 前後に出た）より前に送信が失われていた見込みが高い
- 電流スレッドが書き込みの +50〜+75 ms に読んだ回は 2 本で 11 回あり、すべて動いた

■ 2. daemon のログで分かったこと（/home/ubuntu/daemon.log・読むだけ）
- Pi の時計は 2022-10-13 のままで、Mac より 約 2 時間 7 分 27 秒遅い。Pi 17:18:59 = Mac 19:26:26.7（STEP 3）
- STEP 3: 「cmd received: get_angles → send_angles 呼び出し前 … wait=0.0 → 呼び出し後 result=None, elapsed_ms=10.0 → send_angles 後の現在角度: None」。書き込みは通っている（例外なし）。直後の読みが返事なし
- 再送（17:19:18）・STEP 4（17:19:23）も同じく直後の読みが None。192142 の先頭 HOME・最後の HOME も None
- send_daemon_rtt_sec と直後の読みはきっちり対応する: None の 5 回は 0.12〜0.13 秒、角度が返った 11 回は 0.02〜0.05 秒
- 19:26 前後（17:18:44 接続〜17:19:47 切断）に、例外・Traceback・再接続・読み直しの記録はない。set_fresh_mode(1) は 17:18:48 に受けている（192952 の daemon 形の本も同じく 1）
- daemon.log 全体の send_angles の直後の読み:
  wait=0.0（直後に読む）4708 回のうち None 2185 回（46%）
  wait=1.0（1.0 秒眠ってから読む）2038 回のうち None 1 回（0.05%）
  → 書き込みの直後は、アームの制御基板が get_angles に 0.1 秒以内に答えないことが半分近くある

■ 3. daemon と pymycobot の作りから
- daemon（tools/pi/mecharm_daemon.py。Pi の ~/mecharm_daemon.py と md5 一致 fac7990b…）の send_angles: _mc.send_angles で書き込み → wait>0 なら眠る → read_angles_once_for_log() で get_angles を 1 回 → 返す。wait=0（mac の形）だと書き込みから約 10 ms で get_angles を出す。daemon の形（wait=1.0）だと書き込みのあと 1.0 秒は何も出ない
- 動いている daemon（Pi 時刻 14:34 起動）が読み込んでいる pymycobot は、起動したときの版（2.9.6 と見られる。Python 2.7 側に同じ版 2.9.6 が残っていたのでそれで作りを確かめた）:
  - send_angles は書き込むだけで返事を待たない（届いたか・受け付けたかは daemon にも分からない）
  - get_angles は書き込んで 0.1 秒まで返事を待ち、枠が揃わなければ None。受け取りの溜まり（入力バッファ）は空にしないので、遅れて来た返事は次の読みに混ざりうる（今回は電流スレッドの行に no_reply などの印がなく、混ざった跡は見えない）
  - pymycobot の中に「読みが送信を打ち消す」処理はない。打ち消すとすれば制御基板の側（受け付け中に次の頼みが来る）で、ここはコードからは確かめられない
- fresh_mode=1（最新の命令を優先）: 両方の形とも 1 で動いている。get_angles は動かす命令ではないので、作りの上では打ち消さない。ただ制御基板の中で「新しい枠が来た」ことが受け付け中の送信に効くかは分からない
- 気づいたこと（範囲の外・触っていない）: Pi の Python 3.6 の pymycobot は、Pi 時刻 15:46（Mac で今日 17:53 ごろ）に 4.0.4 へ入れ替わっている（/home/ubuntu/pymycobot-4.0.4-py3-none-any.whl）。daemon はその前に起動しているので今は古い版のまま動いているが、次に daemon を起動し直すと 4.0.4 になる。4.0.4 の MyCobot は send_angles も返事を待ち、返事がないと同じ命令を最大 3 回書き直す（1 回 0.5 秒待つ）作りで、送信の回数と時間が変わりうる

■ 4. 原因の見立て（確かさ）
- 電流スレッドの read_servo が送信を打ち消した: 低い。送信の直前・直後に重なっておらず（鍵の待ち 0 ms）、STEP 3 は電流スレッドの最初の読みより前に失われていた見込み。+50〜+75 ms の読み 11 回でも無視は起きていない
- daemon が書き込みの直後（約 +10 ms）に出す get_angles が引き金: 中くらいより下。mac の形で新しく生まれた違いはこれが一番大きく（daemon の形では 1.0 秒何も出ない）、無視された送信はこれが返事なしだった 5 回のうちの 1 回。ただ返事なしの 4 回は動いており、1 回だけでは決められない
- 形どうしの比べ: daemon の形は手教示 108 本（1 本 8 回送るので約 860 回）と 192952 で 0.00° の無視が 0 回、mac の形は 16 回中 1 回。形に関係なく起きるとしたら、合わせて 876 回のうち 1 回の無視が mac の 16 回に入る見込みは約 2%。mac の形に何か原因がある見込みは高いが、どれかは決めきれない
- 制御基板が送信を取りこぼした（読みとは関係なく）: 残る。daemon の形でも起こるなら 860 回で 1 回は出ていそうなので、確かさは低め

■ 5. 避け方の案（抜けの見込み・物理的リスク）
案 A daemon の形に戻す（--send-wait-on daemon・今の撮り方）
  抜けの見込み: 0.00° の無視は約 860 回で 0 回（1 回あたり 0.4% 未満）。再送 18 回（少しは動いた）は今までどおり残る
  失うもの: 送信のあとの約 1.05 秒は読めない（案 2 のねらい）
  物理的リスク: 低い（実績のある形）。コードの変更なし（既定の値だけ決めればよい）
案 F 1.0 秒を daemon と Mac に分ける（例: daemon に wait=0.2 で送り、返ってから Mac で 0.8 秒待つ。合わせて 1.0 秒で縮めない）
  ねらい: 書き込みのあと最初の読み（daemon の直後の読み）を 0.2 秒あとにずらす。daemon も pymycobot も今のまま
  抜けの見込み: 引き金が直後の読みならほぼ消える。0.2 秒あとの読みの返事なしの割合は分からない（0 秒では 46%、1.0 秒では 0.05%）。電流スレッドの読みは +0.2 秒からになる
  失うもの: 送信のあと 0.2 秒は読めない（今の 1.05 秒よりは短い）
  物理的リスク: 低い（送る中身・回数・待ちの合計は同じ。変わるのは読む時機だけ）。分け方の数値はエイイチが決める
案 B send_angles_fast（daemon に入っている・書き込みのあと読まない）で送り、Mac で 1.0 秒待つうち最初の Q 秒は電流スレッドにも読ませない
  抜けの見込み: 案 F と同じ程度。書き込みのあと Q 秒は誰も読まない
  物理的リスク: 低〜中。書き込みは同じ _mc.send_angles だが、今の daemon.log に send_angles_fast の使用は 1 回もなく、この経路は最近の実績がない。Q の値はエイイチが決める
案 C 電流スレッドを read_servo ではなく get_angles だけにする
  抜けの見込み: ほとんど減らない見込み（daemon の直後の読みは残る。電流スレッドは原因として薄い）。電流の記録がなくなる
  物理的リスク: 低い
案 D 送信の前に電流スレッドの読みが終わるのを待つ
  抜けの見込み: 減らない。今も鍵で待っており、今回の待ちは 0 ms。直前の読みは本体の get_angles（daemon の形と同じ）
  物理的リスク: 低い（ただ効かない）
案 E daemon の send_angles で wait=0 のとき直後の読みをやめる・少し待ってから読む
  抜けの見込み: 案 B・F と同じ。daemon の置き換えと再起動が要る（今は 4.0.4 に替わる問題もある）。範囲の外

選んだもの: どれも実装していない。
理由: 原因が 1 回の事象からしか見えず、はっきりしない（依頼の「原因がはっきりしないときは実装せず」）。効きそうな案 F・B は、0.2 秒や Q 秒の数値を決める必要があり、それはエイイチが決めること。
既定の --send-wait-on はコードでは mac のまま（変えていない）。お手本は依頼文のエイイチの決めどおり --send-wait-on daemon で撮る。

■ 6. 実機で確かめる手順（決まったら）
- 案 F か B を入れたら、mac の形を 10 本（1 本 8 回送るので 80 回）撮る。今の割合（16 回に 1 回）なら、80 回で 1 回も出ない見込みは約 0.6% なので、0 回ならかなり効いたと言える
- 見るもの:
  1. 試行 JSON の retried と retry_move_deg（0.00° の再送が 0 回か）
  2. send_daemon_rtt_sec（案 F なら約 0.23 秒、0.33 秒前後なら直後の読みが返事なし）
  3. daemon.log の「send_angles 後の現在角度: None」の回数（案 F で 0.2 秒あとでも None が多いか）
  4. 電流スレッドの最初の読みの時刻が書き込みから決めた秒数より後か（states.csv の source=current_thread の行）
  5. 動き始め（+150〜+300 ms の Δ）が daemon の形と同じか
- 合わせて daemon の形を数本はさんで撮ると、日によるぶれと分けられる
- daemon を起動し直す前に、pymycobot 4.0.4 のままでよいかを決めておく（下）

■ 変えたファイル
なし（コード・テストは変えていない。git の commit もしていない）
報告: claude_code_reports/20261115_215.txt（このファイル）、logs/20261115_1945.md

■ 決めてほしいこと
1. 避け方をどれにするか: A（daemon の形を続ける）／F（1.0 秒を daemon と Mac に分ける。分け方の数値、例 0.2 秒と 0.8 秒）／B（send_angles_fast と、読ませない Q 秒の数値）
2. record_teach_demo.py の --send-wait-on の既定を daemon に戻すか（今はコードの既定が mac で、撮るときに daemon を付けて運用している）
3. 原因を詰めるために、今の mac の形のまま撮って割合を測るか（無視されれば 5 秒待って再送する、今までと同じ動き）
4. Pi の pymycobot が今日 4.0.4 に入れ替わっている件（Pi 時刻 15:46）。daemon を次に起動し直すと 4.0.4 で動き、send_angles の書き直し（最大 3 回）など送り方が変わりうる。誰が入れたか・2.9.6 に戻すかの確認
```



## この回の終わりのコード

この回で変えた5つのファイルの、この回の終わりの全文です。`record_teach_demo.py` は git の外にあり、ほかの4つは r2r2r-scripts の git に入っています（コミット 4a017f3 の時点）。

### record_teach_demo.py


```python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""record_teach_demo.py — 手で教えた動きを daemon 経由で再生しながら π0.5 のお手本として記録する（Mac 側）.

目的:
  drag_teach_v2.py で教えた記録（teach JSON）を、Pi の検証済み再生
  （waypoint_streaming_replay.py = WPSR）と同じ計画・同じ送信流儀で
  **Mac から daemon 経由**で再生し、上カメラ映像（recorder.py）と実測角を
  一緒に残して、既存の学習パイプライン
  （build_demo_episodes.py → convert_to_lerobot.py）にそのまま流せる形にする。

サブコマンド:
  measure  上カメラでブロックと箱の Unity 座標を測って保存する（アームに触らない）
  run      teach JSON を Pi から取得 → 位置を測り直して照合 → 計画表示 → 再生＋記録

1 本のお手本を作る流れ:
  1. ブロックを置く（印は付けない）
  2. 【Mac】 record_teach_demo.py measure
  3. 【Pi】  daemon 停止 → drag_teach_v2.py teach → daemon 起動
  4. 【Mac】 recorder.py --top --no-side を別ターミナルで常駐
  5. 【Mac】 record_teach_demo.py run --teach drag_v2_XXXX.json --execute

再生の計画（姿勢抽出・区間分割・補間）は作り直さず、Pi と同じ実装を import して使う:
  - waypoint_replay           _load_teach / _extract_waypoints / JOINT_LIMITS 系ヘルパ
  - waypoint_streaming_replay _build_segments / _interpolate / _validate_endpoints と送信定数

アーム制御は daemon TCP 経由のみ（send_coords は使わない）。
台帳列は run_pick_place.py の LEDGER_COLS を import して使う（追記ガードを二重定義しない）。

CLI:
  python3 record_teach_demo.py measure [--repeat 5] [--log 352]
  python3 record_teach_demo.py run --teach drag_v2_20221013_144348.json            # ドライラン
  python3 record_teach_demo.py run --teach drag_v2_20221013_144348.json --execute
  python3 record_teach_demo.py run --teach ... --execute --no-record               # 段階C 検証用
  python3 record_teach_demo.py run --teach ... --execute --no-currents             # 電流を残さない（依頼 121）
  python3 record_teach_demo.py run --teach ... --execute --power 2A                # 電源の前後比較（依頼 156。pi05/POWER_AB.md）
"""

from __future__ import print_function

import argparse
import csv
import hashlib
import json
import math
import os
import re
import shutil
import subprocess
import sys
import tempfile
import threading
import time
import traceback
import types
from datetime import datetime
from pathlib import Path


# ---- パス解決 ----------------------------------------------------------------
_THIS = Path(__file__).resolve()
_DRAG_TEACHING_DIR = _THIS.parent
_SCRIPTS_ROOT = _THIS.parents[2]
_PLACE_MODULES_DIR = _SCRIPTS_ROOT / "dynamic_tracking_limits" / "place" / "place_modules"
for _p in (_SCRIPTS_ROOT, _PLACE_MODULES_DIR, _DRAG_TEACHING_DIR):
    sys.path.insert(0, str(_p))
# 依頼 121: 爪と肩の電流の記録は pi05/policy_recorder.py の部品を使う（読み方を 2 か所に書かない）。
# pi05 の同じ名前のモジュールが上の 3 つを隠さないよう、最後に足す。
_PI05_DIR = _SCRIPTS_ROOT / "pi05"
if str(_PI05_DIR) not in sys.path:
    sys.path.append(str(_PI05_DIR))


# ---- pymycobot スタブ --------------------------------------------------------
# waypoint_replay / waypoint_streaming_replay は Pi 用に
# `from pymycobot.mycobot import MyCobot` を持つ。Mac 上で import を通すために
# スタブを置く（run_pick_place.py / run_policy_client.py と同じやり方）。
# 呼び出すと例外になるので、うっかりシリアル直叩きに流れることはない。
if "pymycobot" not in sys.modules:
    _pkg = types.ModuleType("pymycobot")
    _mod = types.ModuleType("pymycobot.mycobot")

    class _MyCobotStub(object):
        def __init__(self, *args, **kwargs):
            raise RuntimeError(
                "record_teach_demo.py: MyCobot stub is not callable. "
                "アーム制御は daemon TCP 経由のみ。")

    _mod.MyCobot = _MyCobotStub
    sys.modules["pymycobot"] = _pkg
    sys.modules["pymycobot.mycobot"] = _mod


# ---- 流用 import ------------------------------------------------------------
# 再生の計画は Pi の検証済み版と同じものを使う（作り直さない）。
import waypoint_replay as wr                       # noqa: E402
import waypoint_streaming_replay as wpsr           # noqa: E402

# 位置検出（アーム制御・daemon 接続を一切しない読み取り専用モジュール）
from detect_positions_once import detect_positions  # noqa: E402

# daemon 経由のアーム制御（π0.5 実行 run_policy_client.py と同じ経路）
from visual_servo_pick import (                    # noqa: E402
    get_daemon_socket,
    close_daemon_socket,
    daemon_send_angles,
    daemon_get_angles,
    daemon_set_gripper,
    daemon_set_gripper_value,
    daemon_set_fresh_mode,
)
import visual_servo_pick as _vsp                   # noqa: E402


def _daemon_request(*args, **kwargs):
    """LOG352: 新 cmd (send_angles_fast / get_angles_once) 用。
    visual_servo_pick.py は無改変のまま、同じモジュールの _daemon_request を
    借りて同じ 1 本の TCP 接続を共有する（本線が依存するファイルを触らない）。
    依頼 121: import した時点の関数ではなく **呼んだときの** _vsp._daemon_request を使う
    （電流の記録スレッドと同じ鍵を通すため。policy_recorder.install_daemon_lock が差し替える）。
    """
    return _vsp._daemon_request(*args, **kwargs)

# 台帳列・保存先・マウントガード・recorder 通知・run_stem 採番は本線から import する。
# LEDGER_COLS を写し取らないので、本線が列を増やしたときに勝手にズレない。
import run_pick_place as rpp                       # noqa: E402
# 到達判定と silent_drop（送信の取りこぼし）の対処は本線から import する。
# run_pick_place.py が `from j0_sweep_scan import _send_and_wait_arrival` で
# 既に読み込んでいるモジュールなので、import による新しい副作用は無い。
import j0_sweep_scan as jss                        # noqa: E402
# 本線の FK 引き（fk_scan_motion_based_v2.csv を **読むだけ**・IK は解かない）。
# run_pick_place.py L74 が同じモジュールを import している。
import fk_lookup as fkl                            # noqa: E402
# fk_lookup が使うのと同じ numpy。FK テーブルの検索にだけ使う。
import numpy as np                                 # noqa: E402
# 依頼 121: 爪と肩の電流（currents.csv）。実機推論の記録（依頼 116）と同じ部品
import policy_recorder as _prec                    # noqa: E402


# ---- 定数 -------------------------------------------------------------------
LOG_PREFIX = "[RTD   ]"

# 再生の送信定数は WPSR からそのまま引く（v2 play 流儀の実績値）。
HOME_ANGLES = list(wpsr.HOME_ANGLES)
SPEED_FIRST = wpsr.SPEED_FIRST                     # 20
SPEED_PLAY = wpsr.SPEED_PLAY                       # 30（補間ストリーミング用・現在未使用）
# 単発送信方式の速度。19 本（run_pick_place.py の SPEED）と
# π0.5 実行（run_policy_client.py）に合わせて 20。
SPEED_SINGLE = 20
FIRST_MOVE_SETTLE_SEC = wpsr.FIRST_MOVE_SETTLE_SEC  # 3.0
GRIPPER_SPEED = wpsr.GRIPPER_SPEED                 # 50
# close の後の待ち。2026-10-19（エイイチ判断・項目4）: 1.5 → 本線と同値の 2.0。
# 出典: run_pick_place.py GRIPPER_SLEEP = 2.0（"DAY175 対策（>=2s）"）。
# _do_gripper は set_gripper_value の直後に time.sleep(GRIPPER_SLEEP) する。
GRIPPER_DWELL_SEC = rpp.GRIPPER_SLEEP              # 2.0
GRIP_VALUE = wpsr.GRIP_VALUE                       # 20（close の押し込み保持目標値）
# run --grip-value N で上の値を置き換える（依頼 152。付けなければ 20 のまま）。試行 JSON の grip_value と
# constants.GRIP_VALUE に残す
GRIP_VALUE_RANGE = (0, 100)
# run --power 2A / 5A（依頼 156。電源の前後比較）。試行 JSON の power に残し、爪の位置と電圧の番地も読む
POWER_RE = re.compile(r"^[0-9]+(\.[0-9]+)?A$")
POWER = None                                        # cmd_run が --power の値を入れる（GRIP_VALUE と同じ扱い）
STREAM_INTERVAL_SEC = wpsr.STREAM_INTERVAL_SEC     # 0.1
STEP_DEG_PER_TICK = wpsr.STEP_DEG_PER_TICK         # 2.0
ARRIVAL_POLL_SLEEP = jss.POLL_SLEEP                # 0.3（本線と同値）
# ---- 到達判定（2026-10-19 エイイチ判断・項目1）------------------------------
# 全区間一律 8.0° をやめ、**本線 run_pick_place.py の stage ごとの値**に揃える。
# 理由: 8.0° では「まだ動いている最中」に到達扱いになり、その姿勢で爪を閉じていた。
#   段階C 1回目の実測: PICK（max|Δ| 14.76°）を **0.383 秒**で到達扱い（残り 6.06°）。
#   j1 は 64.16° → 74.53° と 0.383s で 10.4°（≒27°/s）動いていた＝降下中。
#   その直後に close し、次の lift の send_angles が取りこぼされた。
# 値はすべて run_pick_place.py からの import（数値を書き写さない）。
ARRIVAL_TOL_BY_SEGMENT = {
    # 区間名（wpsr._build_segments の to_name）: (許容差, 本線の出典)
    "HOME":                     (rpp.TOL_HOME,          "TOL_HOME（stage1_to_home / HOME 復帰）"),
    "APPROACH_PICK":            (rpp.TOL_APPROACH,      "TOL_APPROACH（approach 系）"),
    "PICK":                     (rpp.TOL_PICK_PLACE,    "TOL_PICK_PLACE（stage4_pick）"),
    # 2026-10-19（エイイチ判断）: lift だけ 2.0 → 3.0 に緩める。
    # 段階C で 3 回とも残差 2.19° のまま 8 秒待ち切っていた
    #（ブロックの重みで下がる分）。本線 stage10 lift_back の TOL_LIFT_BACK = 3.0 と
    # 同じ理由（"実測残差 2.46〜2.55°（j2主因）を吸収"）なので、その定数を使う。
    "APPROACH_PICK (lift)":     (rpp.TOL_LIFT_BACK,     "TOL_LIFT_BACK（lift の残差 2.19° を吸収）"),
    # 本線は stage7 approach_place だけ TOL_APPROACH_PLACE = 3.0 を使う
    #（"大移動で最後の数度が埋まらない対策"）。approach 系だが 2.0 ではない。
    "APPROACH_PLACE":           (rpp.TOL_APPROACH_PLACE, "TOL_APPROACH_PLACE（stage7）"),
    "PLACE":                    (rpp.TOL_PICK_PLACE,    "TOL_PICK_PLACE（stage8_place）"),
    # 本線は stage10 lift_back だけ TOL_LIFT_BACK = 3.0
    #（"実測残差 2.46〜2.55°（j2主因）を吸収"）。これも approach 系だが 2.0 ではない。
    "APPROACH_PLACE (retreat)": (rpp.TOL_LIFT_BACK,     "TOL_LIFT_BACK（stage10_lift_back）"),
}
# 到達を待つ最大時間も本線に揃える（固定 8.0s をやめる）。
# 本線: timeout = max(jss.REACH_TIMEOUT_SEC, wr._compute_arrival_timeout(pre_max))
#   wr._compute_arrival_timeout = clamp(2.0 + (max|Δ| / 20) * 3.0, 8.0, 30.0)
# 大きい区間（max|Δ| 86.7° → 15.0s）に十分な時間を与える。許容差を締めたので
# 固定 8.0s のままだと「間に合わなかっただけ」で ABORT しうる。
ARRIVAL_TIMEOUT_MIN_SEC = jss.REACH_TIMEOUT_SEC    # 8.0
# ---- 爪を動かす前の静止確認（codex R11 A1）----------------------------------
# 許容差を締めても「1 回でも tol 内に読めたら到達」なので、**通過中**でも到達に
# なりうる（段階C 1回目: 14.76° の移動を 0.383s・残り 6.06° で到達扱い）。
# 爪の指令は「アームが止まってから」出す必要があるので、gripper の直前に
#   (a) 直前の move の目標から tol 内にいる
#   (b) 連続する実測の差が GRIPPER_STILL_TOL_DEG 以下
# を GRIPPER_STILL_READS 回続けて確認する。読めない回は成立とみなさない。
# 期限内に確認できなければ **爪へ何も送らずに ABORT**。
# しきい値は本線の「動いていない」判定と同じ 1.0°（jss.RETRY_NO_MOVE_THRESHOLD_DEG）。
# ポーリング間隔は到達確認と同じ 0.3s なので、速度 20（実測 ≒27°/s）で動いていれば
# 連続差は 8° 前後になり、静止（読み取りノイズ 1° 未満）とは明確に分かれる。
GRIPPER_STILL_TOL_DEG = jss.RETRY_NO_MOVE_THRESHOLD_DEG   # 1.0
GRIPPER_STILL_READS = 3            # 連続 3 回（≒0.9s）
GRIPPER_STILL_TIMEOUT_SEC = jss.REACH_TIMEOUT_SEC         # 8.0
# ---- silent_drop（送信の取りこぼし）の対処（項目3）--------------------------
# 本線 j0_sweep_scan._send_and_wait_arrival と同じ条件・同じ回数・同じ待ち。
#   到達タイムアウト後、送信前姿勢からの移動が 1.0° 未満なら「送信無視」とみなし、
#   5.0s 待って現在姿勢を読み直し、**同じ目標**へ 1 回だけ再送する。
#   1.0° 以上動いていたら部分移動/ストール疑いとして再送しない。
#   2 回目も届かなければ ABORT（ループしない・HOME へ自動で戻らない）。
RETRY_PAUSE_SEC = jss.RETRY_PAUSE_SEC              # 5.0
RETRY_NO_MOVE_THRESHOLD_DEG = jss.RETRY_NO_MOVE_THRESHOLD_DEG   # 1.0
# 本線は daemon_send_angles(..., wait=SEND_WAIT_SEC) で送る。daemon は書き込みの
# あと wait 秒 sleep してから送信後の角度を読む。wait=0 だと書き込み直後に読むため
# 読み直し 12 回（≒3.7s）に化けやすい（段階C 1回目の lift が実測 3.7196s）。
SEND_WAIT_SEC = rpp.SEND_WAIT_SEC                  # 1.0
# 依頼 213（依頼 197 の案 2・エイイチ判断 2026-11-15）: 送信のあとの 1.0 秒を **どこで待つか**。
#   "mac"（既定）: daemon には wait=0 で送り、返ってから Mac 側で SEND_WAIT_SEC 待つ。
#                  この間は電流の記録スレッドが読める（_sleep_open で眠りを知らせる）。
#   "daemon"     : 依頼 202 までと同じ。daemon が wait=SEND_WAIT_SEC で寝てから返す（この間は読めない）。
# 待つ長さ（1.0 秒・DAY266: 短縮しない）は変えない。場所だけを移す。cmd_run が --send-wait-on の値を入れる。
SEND_WAIT_ON_CHOICES = ("mac", "daemon")
SEND_WAIT_ON = "mac"
# 送信のソケットの期限。"daemon" では visual_servo_pick._daemon_request が wait+3.0 = 4.0 秒にする。
# "mac" の wait=0 では既定 DAEMON_TIMEOUT_SEC（35 秒）になってしまうので、同じ 4.0 秒を timeout_override で渡す。
SEND_SOCKET_TIMEOUT_SEC = SEND_WAIT_SEC + 3.0
# 直近の _send_angles_guarded の daemon とのやりとりだけの往復（Mac 側の待ちを含まない）。"daemon" では
# daemon の中の 1.0 秒を含む。区間の記録に残す（send_rtt_sec はどちらでも待ちを含む送信の始めから終わりまで）。
_LAST_SEND = {"daemon_rtt_sec": None}
FIRST_MOVE_WARN_DEG = wpsr.FIRST_MOVE_WARN_DEG     # 30.0

# 2026-10-19（エイイチ判断・項目1）: 一律 8.0° はやめた。
# 区間ごとに ARRIVAL_TOL_BY_SEGMENT（本線 run_pick_place.py の stage 値）を使う。
# 旧 8.0° は Pi 配備版 waypoint_streaming_replay.py（0.1s 補間ストリーミング）の
# 値で、ストリーミングでは「少し遅れている」の意味だったが、単発送信では
# 「まだ着いていない」の意味になり、動作中に爪を動かす原因になった
#（段階C 1回目: PICK を 0.383s・残り 6.06° で到達扱い → その姿勢で close）。

# 安全範囲。run_pick_place.py のモジュール定数をそのまま使う（二重定義しない）。
J4_SAFE_MIN = rpp.J4_SAFE_MIN                      # -90.0
J4_SAFE_MAX = rpp.J4_SAFE_MAX                      # +60.0

# ---- 肩（j1・0 始まりの index 1）の上限と、超えた姿勢の置き換え ------------
# 【訂正】2026-10-19 夕に入れた「j2 が +90° を超えたら WARN」は **軸を間違えて
# いた**（index 2 を見ていた）。問題の軸は **肩 = index 1** で、
# arm_kinematics.md の PICK_J1_FIXED も descend_angles[1] に入る値。
#
# 肩がこれを超える姿勢は、コントローラが受け付けず send_angles が捨てられる:
#   手で教えた PICK 肩 95.53 / 97.03 / 99.22 → 4 回とも無視（書き込みは通るのに不動）
#   手で教えた PICK 肩 80.59 → 通った
#   2026-06-26 に 110.5 が無視された記録あり
#   台帳の実測最大 89.73 / **命令の最大 88.0**（エイイチ 2026-10-19）
# 値は本線 fk_lookup.py の J1_SAFE_MAX をそのまま使う（二重定義しない）。
# 同モジュールの docstring が "silent drop の温床となる j1>88° の姿勢は候補から
# 除外する"（DAY257 後段）と書いており、本線の 647 試行が実際に送った j1 は
# 87.74 / 87.00 / 85.00（試行 JSON の stage4_pick target_angles 実測）。
SHOULDER_MAX_DEG = fkl.J1_SAFE_MAX          # 88.0
# 置き換え候補を絞る j0 の窓。候補行の爪先位置はその行の j0 で計算されているので、
# j0 を教示値に差し替えると窓の幅ぶん爪先がずれる（半径 0.32m で 3° ≒ 17mm）。
# 狭くすると候補が減り、広げると爪先差の見積りが当てにならなくなる。
# ±2.0° で「選定時の差」と「置き換え後の再評価の差」が一致することを実測で確認。
SHOULDER_FIX_J0_TOL_DEG = 2.0
# 候補の選び方は本線 PLACE と同じ形（距離 + 角度ペナルティ）。
#   score = 爪先の 3D 距離[m] + W * (|Δj2| + |Δj3| + |Δj4|)
# W は本線 fk_lookup.PLACE_W_J1_PENALTY_DEFAULT（0.002 m/deg = 1°≈2mm 相当）。
# 爪先が同程度なら、教えた姿勢に近い方を採る。
SHOULDER_FIX_ANGLE_PENALTY = fkl.PLACE_W_J1_PENALTY_DEFAULT
# 置き換えで爪先がこれ以上ずれたら、目立つ WARN を出す（**止めない**）。
SHOULDER_FIX_TIP_WARN_MM = 15.0

# ブロックが動いていないかの確認しきい値（measure 時 → 再生直前）
BLOCK_MOVE_TOL_MM = 5.0
# アームの根元（Unity 原点）から これ以内で検出した赤いものは**ブロックとして扱わない**
# （エイイチ判断 2026-10-19）。13:14 の measure が (+48, -34) mm = 根元から 58.8mm の
# 何か（赤いケーブルの可能性）をブロックとして拾っていたのに誰も気づけなかった。
# 教示で使う位置は根元から 200mm 以上離れている。
BLOCK_MIN_DIST_FROM_BASE_MM = 120.0

# ---- 検出のばらつき対策（エイイチ判断 2026-10-19）--------------------------
# homography はマット四隅から**毎回動的に**作られる。四隅の検出が揺れると、
# 同じ画素が別の mm になる。15:25 の measure は、同じ位置のブロックを
# (+212.0, +186.3) mm と記録した（直後の直読みは (+175.1, +195.9) mm）。
# 画素は (505, 585) と (590, 606) で 85px ずれており、mm で 37mm の外れ値だった。
# よって:
#   - measure は homography と四隅の画素位置を保存する
#   - 再生前の確認は **画素** で比べる（homography を作り直さない）
#   - mm は記録用に measure の homography で換算する
#   - 四隅が大きくずれていたら「カメラが動いた可能性」として止める
#   - measure 自体も、5 回の検出がばらついていたら保存せずに終える
#
# setup_homography_and_mat_range が使う四隅の mm 定義（同ファイル L275-280 と同値）。
# homography から四隅の画素位置を厳密に復元するために持つ。
MAT_CORNERS_MM = [(+310.0, -89.0),   # UL
                  (-310.0, -89.0),   # UR
                  (-310.0, +361.0),  # LR
                  (+310.0, +361.0)]  # LL
# 再生前の四隅が measure からこれ以上ずれていたら「カメラが動いた可能性」
MAT_CORNER_SHIFT_ABORT_PX = 15.0
# 四隅の検出は時々外れる（2026-10-19 実測: 同じカメラ・同じ配置で 30px 外れる回があった）。
# 1 回で決めず、15px 以内に収まるまで最大この回数やり直す（エイイチ判断）。
# 1 回でも収まればその回の値で続ける。全部外れたら「カメラが動いた可能性」で止める。
MAT_CORNER_RETRY_MAX = 3
# measure の 5 回の検出で、ブロックの位置がこれ以上ばらついたら保存しない。
# 2026-10-19（エイイチ判断）: 実測のばらつきが 1.30 / 1.80 / 3.15mm で、
# 3.0mm だと 3 回に 1 回落ちた。検出のぶれが 1〜3mm 程度あるので 4.0mm に緩める。
# この位置確認は**つかみ損ねを防ぐための補助**であって、アームの安全装置ではない
# （最終判定は人の y/n と動画）。誤って止まる回数を減らす方を優先する。
MEASURE_BLOCK_SPREAD_MAX_MM = 4.0
# ばらつきの判定に必要な成功サンプル数（codex R8 P5: 1 件だと広がり 0 で通ってしまう）
MEASURE_BLOCK_MIN_SAMPLES = 3
# detect_positions が出した位置と、測り直した中央値の差の上限（mm）。
# 元の検出だけが外れて、あとの画像が安定している場合を取り逃がさないため。
MEASURE_BLOCK_VS_RECHECK_MAX_MM = 3.0
# 再生前のブロック位置の照合に使う許容（mm）。measure の homography で画素に換算する
BLOCK_MOVE_TOL_MM_PX_BASIS = 5.0
# ばらつきを測るときに撮る枚数
INSPECT_FRAMES = 5

# 計画時に j4 の余裕がこれ未満の姿勢があれば WARN（codex R1 C2 追加分）。
# 2026-10-19 の教示データは PICK 姿勢 j4 = -88.68 で下限 -90 に 1.32° しかない。
J4_MARGIN_WARN_DEG = 3.0

# ---- 実測 j4 の扱い（エイイチ判断 2026-10-19・codex R2 C2 への回答）----------
# J4_SAFE (-90〜+60) は **指令値の制限**であって実測の絶対限界ではない。
#   - これまで J4_SAFE は送る前の候補を弾く用途だけで使ってきた
#     （DAY275 で j4=-104.20 の候補を送信前に除外）
#   - 実測は指令からずれる前提（DAY274 で指令 -89.2 に対し実測 -60.73）
#   - 電源投入直後の静止姿勢で j4=-95.97 と読めていて破損もない
# よって実測が J4_SAFE を少し外れるのは WARN + 試行 JSON 記録のままにする
# （到達許容 8° に対し j4 下限の余裕が 1.32° しかなく、実測で止めると正常な試行まで止まる）。
#
# ただし安全網を 1 つ置く: 実測が J4_SAFE ± J4_HARD_MARGIN_DEG の外に読めたら、
# 「到達の遅れ」では説明できない量なので ABORT する。
#
# 2026-10-19（項目1）: 到達許容差を本線の 2.0〜3.0° に締めたが、**この帯は
# 8.0° のまま据え置く**（-98.0 / +68.0 は変えない）。
# 理由: この 8.0° は「到達の遅れとして許す量」ではなく「物理的にありえない量の
# 線引き」として実機で決まった値で、締めると誤 ABORT が増える
#（教示データには計画時点で j4 の余裕が最小 1.32° の点がある）。
J4_HARD_MARGIN_DEG = 8.0
J4_HARD_MIN = J4_SAFE_MIN - J4_HARD_MARGIN_DEG   # -98.0
J4_HARD_MAX = J4_SAFE_MAX + J4_HARD_MARGIN_DEG   # +68.0
# measure が古いときの注意喚起（止めはしない）
MEASURE_STALE_WARN_SEC = 3600.0

# 位置検出の繰り返し回数（中央値集約）
MEASURE_REPEAT_DEFAULT = 5
MEASURE_INTERVAL_DEFAULT = 0.3

# 実測角の読み取り。move 区間は N tick に 1 回読む（0.1s 周期を崩さないため）。
# 3 tick に 1 回 = 約 3.3Hz（これまでの 19 本と同程度の 3Hz 以上）。
ACTUAL_READ_EVERY_N_TICKS = 3
ACTUAL_READ_TARGET_HZ = 3.0
# 依頼 202: 電流の記録スレッド（read_servo・本体が眠っている間だけ）が読んだ角度も states.csv の actual 行にする。
# 列は足さず note 列に入れて、本体の読み（到達・静止の確かめなど。note は空のまま）と区別する。
CURRENT_THREAD_NOTE = "source=current_thread"
CURRENT_ACTUALS_FLUSH_SEC = 1.0   # trial_end の前に、積んだ通知を送り切るのを待つ上限（ふつうは数 ms で終わる）
# 1 コマンドに許す時間。既定 DAEMON_TIMEOUT_SEC=35.0 のままだと 1 回の通信失敗で
# ストリームが長時間止まる（codex R1 C6）。send / get の両方に override を付ける。
# ---- LOG352: daemon の新 cmd を使う（段階C の実測を受けて）-------------------
# 既存 send_angles は送信後に read_angles_with_retry() を呼び、動作中は最悪
# 約 3.7 秒ブロックする（2026-10-19 実測: 474 送信中 27 回）。既存 get_angles も
# 同じ 12 回リトライなので、記録用の読み取りでも同じ停止が起きる。
# よって:
#   送信           → send_angles_fast（読み直し無し。Pi 直と同じ送り方）
#   記録用の読み取り → get_angles_once（1 回だけ読む。読めなければ None）
#   区間終端の到達確認 → 既存 get_angles（アームが止まりかけなのでリトライ有りで良い）
# 2026-10-19（エイイチ判断・方針変更）: 0.1 秒ごとの補間送信をやめ、
# **区間ごとに 1 回だけ send_angles を送って到達を待つ**方式にする
# （run_pick_place.py の 19 本と同じ動かし方）。
# 送信が 158 回 → 9 回になるので、新 cmd（send_angles_fast）は使わない。
# 既存 send_angles（送信後に角度を読み直す）のままで足りる。
USE_FAST_DAEMON_CMDS = False
# get_angles_once 1 回に許す時間（リトライしないので短くて足りる）
DAEMON_GET_ONCE_TIMEOUT_SEC = 2.0

# A4-3（エイイチ判断 2026-10-19）: 送信は 4.0s、読み取りは 2.0s。
# Pi の daemon は send_angles ハンドラの中で、送信後に read_angles_with_retry() を
# 呼ぶ（最悪 GET_ANGLES_RETRIES=12 × GET_ANGLES_INTERVAL_SEC=0.2 ≈ 2.4s）。
# 送信 timeout を 2.0s にすると健全な状態でも空振りし、3 回続くと
# SEND_FAIL_ABORT_STREAK で ABORT してしまう。よって最悪値より長い 4.0s にする。
# codex R8 O2（2026-10-19）: 単発送信では「1 回の失敗 = その区間唯一の指令が
# 未送達かもしれない」。到達確認で捕まえる作りにしていたが、
#   (a) 送信前の姿勢がたまたま目標の 8° 以内だと、送っていなくても「到達」になる
#   (b) 先頭 HOME は settle するだけで到達確認が無い
# ので「必ず捕まえる」は成立しなかった。**送信例外はその場で ABORT** にする
# （自動再送はしない）。補間ストリーミング時代の「連続 3 回で ABORT」は、
# 1 区間 1 送信になった時点で前提が変わっている。
SEND_FAIL_ABORT_ON_FIRST = True

# 単発送信方式では daemon の send_angles ハンドラが送信後に
# read_angles_with_retry() を呼ぶ（動き始めで失敗すると最悪 ≈3.7s）。
# 4.0s では際どいので 6.0s にする。1 試行の送信は 10 回なので待ちは問題にならない。
DAEMON_SEND_TIMEOUT_SEC = 6.0
# 区間終端の到達確認で使う既存 get_angles（12 回リトライ・最悪 ≈3.7s）の期限。
# codex R3 A2/C6: 2.0s だと健全な応答も打ち切りうるので、最悪値より長い 4.0s。
DAEMON_GET_TIMEOUT_SEC = 4.0
# ---- グリッパーの開閉（エイイチ判断 2026-10-19）----------------------------
# 経緯:
#  (1) open を送るだけで「開いたか」を確かめていなかった。2026-10-19 の段階C
#      3本目で PLACE の open が効かず、ブロックを持ったまま HOME へ戻った
#      （daemon の戻り値は None で、DAY175 の既知問題どおり成否と無関係）。
#  (2) そこで daemon の読み取り専用 cmd get_gripper_value（gv）で自動確認する
#      作りにした。が、段階C で PLACE の open 直後に gv が -1 を返し、その直後から
#      アームが send_angles を受け付けなくなった（書き込みは通り elapsed 10.5ms、
#      get_angles も 3.1Hz で読めるのにモーターが動かない。daemon を再起動する
#      まで gv は -1 のままだった = シリアル同期が壊れた疑い）。
#      T1/T2 で「静止中の gv 読み取りは壊さない」ことは確認したが、
#      爪が動いている最中の読み取りが引き金の可能性が残る（T3 は実施しない判断）。
#  (3) よって **gv による自動確認はやめる**。run_pick_place.py の stage9 と同じ形
#      にする（STAGE9_RELEASE_PRE_SLEEP = 2.0 / GRIPPER_SLEEP = 2.0 /
#      STAGE9_RELEASE_OPEN_ATTEMPTS = 2）。647 試行で詰まっていない実績のある形。
# 開いたかは **人が目で見て y/n で答える**（自動確認はしない）。
# 初回 open（PICK の前）も同じ形で、**Enter の前に目視確認の y/n を必須**にする。
# **爪の開閉の待ち時間は縮めない**。
# 2026-10-19（エイイチ判断・項目6）: open は **1 回の命令**にする。
# 本線 run_pick_place.py の _do_gripper("open") と同じ形:
#   daemon_set_gripper(0) 1 回 + time.sleep(GRIPPER_SLEEP = 2.0)
#   （daemon の set_gripper ハンドラが前に sleep(2)、ヘルパ既定 wait=2 で後に sleep(2)）
# → 固定待ちの合計 2.0 + 2.0 + 2.0 = 6.0s。
# stage9（PLACE の離し）だけは本線でも 2 回送り・前 2.0s つきで計 14.0s だが、
# 確認を減らす判断で **PLACE も 1 回**に揃える（本線 _do_gripper と同形）。
GRIPPER_OPEN_DWELL_SEC = rpp.GRIPPER_SLEEP   # 2.0（本線 GRIPPER_SLEEP）
GRIPPER_OPEN_ATTEMPTS = 1                    # 本線 _do_gripper("open") と同じ 1 回
# codex R10 S2: stage9 は daemon_set_gripper(0) を**既定 wait=2** で呼ぶので、
# Pi 側は「事前 sleep(2) → set_gripper_state → 事後 sleep(2)」になる
# （visual_servo_pick.py の daemon_set_gripper(state, speed=100, wait=2) /
#  daemon の set_gripper ハンドラ）。こちらは通知時刻を「指令が爪へ出た時刻」に
# したいので wait=0 で呼ぶ（事後 sleep を daemon にさせない）。
# そのぶんを **Mac 側で同じ 2.0s 待つ**。これを入れないと固定待ちの合計が
# 実績（stage9）より open 1 回あたり 2.0s 短くなる。**待ち時間は縮めない**。
# この 2.0s は **実測角の読み取りを挟まない**（爪を動かした直後にシリアルを
# 触らない。段階C の固まりは gv 読み取りの直後に起きたため）。
GRIPPER_OPEN_POST_SLEEP_SEC = 2.0
# daemon の set_gripper ハンドラが open/close の**前**に必ず入れる固定 sleep。
# DAY175 対策で daemon 側に入っている（daemon は無改変）。所要時間の見込みに使う。
DAEMON_SET_GRIPPER_PRE_SLEEP_SEC = 2.0

# 人の判定入力の再試行上限（stdin が空文字を返し続ける環境で無限ループにしない）
ASK_MAX_ATTEMPTS = 10
# 実測 j4 が J4_SAFE 外に読めたときに値を残すサンプル数の上限（総数は別に数える）
J4_SAMPLE_MAX = 200
# 観測異常（非有限値・実測 j4 の範囲外）の WARN を出す上限回数。
# 総数は試行 JSON の actual_sampling に必ず残すので、画面だけ絞る。
NONFINITE_WARN_MAX = 3
# 待ち時間中も実測角を読むときのスライス幅。
# 「実際に time.sleep した合計」が要求値を下回らない形で使う（codex R1 A7/D7）。
SLEEP_SLICE_SEC = 0.05

# recorder に trial_start を送ってから動き出すまでの間（mp4 writer が開く時間）
RECORDER_START_SETTLE_SEC = 1.0

# send_angles が連続でこの回数失敗したら ABORT する（エイイチ判断・2026-10-19）。
# Pi 直の send 例外（シリアル）と違い、daemon 経由の例外は通信断を意味する。
# 通信が切れたまま区間を進めても、記録が意味のない試行になるだけなので止める。
# 単発の例外は WARN のまま続行する（Pi 配備版と同じ）。成功1回で連続数はリセット。
SEND_FAIL_ABORT_STREAK = 3

# 保存先（KIOXIA のみ。未マウント時にローカルへ fallback しない）
# ismount はマウントポイント自身に対して効くので、volume ルートと
# データルートを分けて持つ（recorder.py の KIOXIA_MOUNT / RUNS_ROOT と同じ形）。
KIOXIA_MOUNT = Path("/Volumes/KIOXIA")
DATA_ROOT = KIOXIA_MOUNT / "r2r2r-data"
# MASTER 保存先テーブルの「校正データ → mecharm_calibration/{topic}_LOG{NNN}/」の行に当てはめる。
# 通し番号は DAY から LOG に切り替わっている（記事ファイルも LOG{NNN}_article.md）。
MEASURE_ROOT = DATA_ROOT / "mecharm_calibration"
MEASURE_DIR_PREFIX = "teach_poses_"

# Pi 側の teach JSON 置き場（ホーム相対）
PI_HOST = "192.168.2.1"
PI_USER = "ubuntu"
PI_KEY_PATH = os.path.expanduser("~/.ssh/id_rsa_pi")
PI_TEACH_DIR = "r2r2r-scripts/dynamic_tracking_limits/drag_teaching"
SCP_TIMEOUT_SEC = 30.0

# 台帳（本線と同じ 1 本・同じ列定義）
LEDGER_CSV_PATH = rpp.LEDGER_CSV_PATH
LEDGER_COLS = rpp.LEDGER_COLS

# recorder が書く recording_meta.json の有界待ち（本線 _append_ledger と同値）
RECORDING_META_POLL_TIMEOUT_SEC = 2.0
RECORDING_META_POLL_INTERVAL_SEC = 0.1


# ---- ログ -------------------------------------------------------------------
def _log(msg):
    print("{} {}".format(LOG_PREFIX, msg))


def _warn(msg):
    print("{} [WARN] {}".format(LOG_PREFIX, msg))


def _abort_msg(msg):
    print("{} [ABORT] {}".format(LOG_PREFIX, msg))


def _fmt_angles(a):
    return wr._format_angles(a)


# ---- 非有限値（NaN / inf）を一律「無効」として扱う -------------------------
# codex R1 C1/C2/C3: NaN は比較が全部 False になるので、上下限検査・距離しきい値を
# すり抜ける。さらに Python の max() は NaN を飛ばすことがあるため
# wr._max_axis_diff([0,0,0,0,NaN,0], [0]*6) が 0.0 を返し、未到達が「到達」に化ける。
# JSON も NaN / Infinity をパースするので、daemon や検出から入りうる。
# よって wr の検査（変更しない）の前段に有限値チェックを必ず置く。
def _is_finite_num(v):
    return (isinstance(v, (int, float)) and not isinstance(v, bool)
            and math.isfinite(float(v)))


def _is_finite_6(a):
    """6 要素すべてが有限の数値なら True."""
    if a is None or not isinstance(a, (list, tuple)) or len(a) != 6:
        return False
    return all(_is_finite_num(v) for v in a)


def _is_valid_angles(a):
    """有限値チェック + wr._is_valid_angles（物理マージン内）。両方通って初めて有効."""
    return _is_finite_6(a) and wr._is_valid_angles(a)


def _max_axis_diff_finite(a, b):
    """6 軸の |a[i]-b[i]| 最大値。非有限が混じるか長さ不正なら None を返す.

    wr._max_axis_diff は NaN を飛ばして偽の 0.0 を返しうるので、こちらで包む。
    """
    if not (_is_finite_6(a) and _is_finite_6(b)):
        return None
    diffs = [abs(float(a[i]) - float(b[i])) for i in range(6)]
    m = max(diffs)
    if not math.isfinite(m):
        return None
    return m


def _arrival_tol_for(to_name):
    """区間名から到達許容差を引く（本線 run_pick_place.py の stage 値）.

    知らない区間名は (None, None) を返す。呼び出し側は **ABORT** する
    （既定値で黙って通さない。教示データの区間構成が変わったことに
    気づかないまま緩い許容差で走るのを防ぐ）。
    戻り値: (tol_deg, 出典の文字列)
    """
    hit = ARRIVAL_TOL_BY_SEGMENT.get(to_name)
    if hit is None:
        return None, None
    return float(hit[0]), hit[1]


def _arrival_timeout_for(max_delta_deg):
    """到達を待つ最大時間（本線と同じ算出）.

    本線 j0_sweep_scan._send_and_wait_arrival:
      timeout = max(REACH_TIMEOUT_SEC, wr._compute_arrival_timeout(pre_max))
      wr._compute_arrival_timeout = clamp(2.0 + (max|Δ| / 20) * 3.0, 8.0, 30.0)
    """
    if max_delta_deg is None or not _is_finite_num(max_delta_deg):
        return ARRIVAL_TIMEOUT_MIN_SEC
    return max(ARRIVAL_TIMEOUT_MIN_SEC,
               float(wr._compute_arrival_timeout(float(max_delta_deg))))


def _note_tol_source():
    """到達許容差の出所を表示する（項目1 で本線の値に揃えたことを毎回残す）."""
    _log("到達許容差は本線 run_pick_place.py の stage 値を使います"
         "（区間ごと。一律 8.0° は 2026-10-19 にやめた）:")
    for _name in ("HOME", "APPROACH_PICK", "PICK", "APPROACH_PICK (lift)",
                  "APPROACH_PLACE", "PLACE", "APPROACH_PLACE (retreat)"):
        _tol, _src = _arrival_tol_for(_name)
        _log("  {:<26} {:.1f}°  ← rpp.{}".format(_name, _tol, _src))
    _log("到達を待つ最大時間 = clamp(2.0 + max|Δ|/20*3.0, {:.1f}, 30.0) 秒"
         "（本線と同じ wr._compute_arrival_timeout）".format(ARRIVAL_TIMEOUT_MIN_SEC))


# ---- マウントガード ----------------------------------------------------------
def _ensure_ssd_mounted():
    """KIOXIA が真にマウントされ書き込めるかを確認する.

    os.path.ismount で「ただのパス存在（shim）」を弾き、書き込みテストまで行う
    （recorder.py の ensure_kioxia_mounted と同じ強さ）。
    未マウント時はローカルへ fallback せず False を返す。
    """
    try:
        if not os.path.ismount(str(KIOXIA_MOUNT)):
            return False
    except Exception:
        return False
    try:
        if not DATA_ROOT.is_dir():
            return False
        test = DATA_ROOT / ".record_teach_demo_write_test"
        test.write_text("x")
        test.unlink()
        return True
    except Exception:
        return False


def _require_ssd(what):
    if _ensure_ssd_mounted():
        return
    _abort_msg("KIOXIA が未マウント or 書込不可: mount={} data={}（{}）。"
               "ローカルへは書きません".format(KIOXIA_MOUNT, DATA_ROOT, what))
    sys.exit(2)


class _MountLost(Exception):
    """書き込み直前にマウントが消えていた（codex R1 D6）."""


def _require_mount_now(what):
    """各保存の直前にマウントを再確認する（codex R1 D6）.

    Enter 待ちや再生中に SSD が外れた場合、ローカル側に /Volumes/KIOXIA/... の
    ディレクトリを新規作成させない（fallback 禁止）。失敗させる。
    """
    if _ensure_ssd_mounted():
        return
    raise _MountLost("KIOXIA が未マウント or 書込不可（{}）: mount={}".format(
        what, KIOXIA_MOUNT))


def _atomic_write_json(path, data):
    """本線 run_pick_place._atomic_write_json と同じ書き方（tmp → replace）."""
    rpp._atomic_write_json(path, data)


def _next_run_dir():
    """試行フォルダを 1 つ確保して (run_dir, run_stem) を返す.

    本線 run_pick_place._next_log_path() と同じ採番規則
    （LOG_ROOT / "run_{:04d}_{YYYYMMDD_HHMMSS}"）だが、
    codex R1 B4 を受けて **mkdir(exist_ok=False) で取り、取れなければ次の番号へ**進む。
    本線は exists() 判定 → mkdir(exist_ok=True) なので、同時起動で同じフォルダを
    掴みうる（本線側は変更しない。こちらだけ競合しない取り方にする）。
    """
    log_root = rpp.LOG_ROOT
    log_root.mkdir(parents=True, exist_ok=True)
    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
    for n in range(1, 10000):
        stem = "run_{:04d}_{}".format(n, ts)
        run_dir = log_root / stem
        try:
            run_dir.mkdir(parents=True, exist_ok=False)
        except FileExistsError:
            continue
        return run_dir, stem
    raise RuntimeError("run_stem の採番が 9999 を超えました")


# ---- measure ----------------------------------------------------------------
def _measure_dir(log_no=None):
    """計測バッチの置き場 mecharm_calibration/teach_poses_LOG{NNN}/.

    MASTER 保存先テーブルの「校正データ → mecharm_calibration/{topic}_LOG{NNN}/」に従う。
    --log 未指定時は LOG 番号を推測せず日付名にする（番号を勘で焼かない）。
    """
    if log_no is None:
        name = MEASURE_DIR_PREFIX + datetime.now().strftime("%Y%m%d")
    else:
        name = MEASURE_DIR_PREFIX + "LOG{}".format(int(log_no))
    return MEASURE_ROOT / name


def _h_to_corners_px(H):
    """homography から マット四隅の画素位置を厳密に復元する.

    H = getPerspectiveTransform(四隅画素, 四隅mm) なので、inv(H) を四隅 mm に
    当てれば、その H を作ったときの四隅画素がそのまま戻る。
    """
    import cv2
    import numpy as np
    Hinv = np.linalg.inv(np.asarray(H, dtype=np.float64))
    pts = np.array([[list(c) for c in MAT_CORNERS_MM]], dtype=np.float32)
    r = cv2.perspectiveTransform(pts, Hinv)
    return [[float(x), float(y)] for x, y in r[0]]


def _mm_from_px(H, px, py):
    """指定した homography で 画素 → Unity(m) に換算する（global を使わない）."""
    import cv2
    import numpy as np
    pt = np.array([[[float(px), float(py)]]], dtype=np.float32)
    r = cv2.perspectiveTransform(pt, np.asarray(H, dtype=np.float64))
    return float(r[0][0][0]) * 0.001, float(r[0][0][1]) * 0.001


def _px_from_mm(H, xz):
    """指定した homography で Unity(m) → 画素 に戻す."""
    import cv2
    import numpy as np
    if not (isinstance(xz, (list, tuple)) and len(xz) == 2
            and _is_finite_num(xz[0]) and _is_finite_num(xz[1])):
        return None
    Hinv = np.linalg.inv(np.asarray(H, dtype=np.float64))
    pt = np.array([[[float(xz[0]) * 1000.0, float(xz[1]) * 1000.0]]],
                  dtype=np.float32)
    r = cv2.perspectiveTransform(pt, Hinv)
    x, y = float(r[0][0][0]), float(r[0][0][1])
    if not (math.isfinite(x) and math.isfinite(y)):
        return None
    return [x, y]


def _mm_tol_to_px(H, xz, tol_mm):
    """その場所での tol_mm が何画素にあたるかを、H から換算する."""
    a = _px_from_mm(H, xz)
    b = _px_from_mm(H, [float(xz[0]) + tol_mm / 1000.0, float(xz[1])])
    c = _px_from_mm(H, [float(xz[0]), float(xz[1]) + tol_mm / 1000.0])
    if a is None or b is None or c is None:
        return None
    d1 = math.hypot(b[0] - a[0], b[1] - a[1])
    d2 = math.hypot(c[0] - a[0], c[1] - a[1])
    # x 方向と z 方向で画素換算が違うので、厳しい方（小さい方）を使う
    return min(d1, d2)


def _inspect_top_camera(n_frames=INSPECT_FRAMES):
    """上カメラを 1 回開いて、マット四隅とブロック画素を n 回測る.

    **homography は作り直さない**（visual_servo_pick._homography を上書きしない）。
    detect_positions が立てた homography と、報告された mm の対応を壊さないため。

    戻り値 dict または None:
      corners_px      : 四隅の画素（検出・平均後）
      block_px_samples: 各フレームのブロック画素（検出できた分だけ）
      block_px        : その中央値
      frame           : 最後のフレーム（描画用）
    """
    cap = None
    try:
        import cv2
        import numpy as np
        import camera_resolver
        import visual_servo_pick as vsp

        cams = camera_resolver.resolve_cameras(
            require_top=True, require_side=False, verbose=False)
        idx = (cams or {}).get("top")
        if idx is None:
            _warn("上カメラが解決できません")
            return None
        cap = cv2.VideoCapture(idx)
        if not cap.isOpened():
            _warn("上カメラを開けません")
            return None
        frames = vsp.capture_frames(cap, max(n_frames, vsp.MAT_CORNER_NUM_FRAMES),
                                    vsp.MAT_CORNER_WARMUP_FRAMES,
                                    vsp.MAT_CORNER_FRAME_INTERVAL)
        if not frames:
            _warn("上カメラから映像が来ません")
            return None
        all_corners = [c for c in (vsp.detect_corners(f) for f in frames)
                       if c is not None]
        corners = None
        if all_corners:
            corners = [[float(x), float(y)]
                       for x, y in vsp.remove_outliers_and_average(all_corners)]
        else:
            _warn("マット四隅を検出できませんでした（カメラ移動の確認ができません）")
        samples = []
        for f in frames[-n_frames:]:
            q = vsp.detect_red_block(f)
            if q is not None:
                samples.append([float(q[0]), float(q[1])])
        block_px = None
        if samples:
            xs = sorted(v[0] for v in samples)
            ys = sorted(v[1] for v in samples)
            block_px = [xs[len(xs) // 2], ys[len(ys) // 2]]
        return {"corners_px": corners, "block_px_samples": samples,
                "block_px": block_px, "frame": frames[-1],
                "n_frames": len(frames),
                "n_corner_ok": len(all_corners)}
    except Exception as e:
        _warn("上カメラの確認で例外（記録のみ・本線は続行）: {}: {}".format(
            type(e).__name__, e))
        return None
    finally:
        if cap is not None:
            try:
                cap.release()
            except Exception:
                pass


def _save_reject_json(out_dir, stamp, kind, reason, payload):
    """弾いたときの診断 JSON を残す（codex R9 R3）.

    「3 回とも四隅が外れた」のような**拒否されたケースこそ原因分析に要る**のに、
    以前は何も残らなかった。ファイル名は `*_rejected.json` にして、
    _find_latest_measure の正規表現（measure_YYYYMMDD_HHMMSS.json のみ一致）に
    引っかからないようにする（再生に使われない）。
    """
    try:
        out = dict(payload or {})
        out.update({
            "script": _THIS.name,
            "kind": kind,
            "rejected": True,
            "reason": reason,
            "at": datetime.now().isoformat(),
            "mat_corner_shift_abort_px": MAT_CORNER_SHIFT_ABORT_PX,
            "mat_corner_retry_max": MAT_CORNER_RETRY_MAX,
        })
        path = Path(out_dir) / "{}_{}_rejected.json".format(kind, stamp)
        _require_mount_now("拒否した測定の診断 JSON")
        _atomic_write_json(path, out)
        _log("弾いた理由と各回の記録を残しました: {}".format(path))
        return str(path)
    except Exception as e:
        _warn("診断 JSON を残せませんでした: {}: {}".format(type(e).__name__, e))
        return None


def _corner_shift_px(ref_corners, now_corners):
    """四隅のずれ（各隅の距離のリスト, 最大）を返す. 比べられなければ (None, None)."""
    if not (ref_corners and now_corners
            and len(ref_corners) == 4 and len(now_corners) == 4):
        return None, None
    sh = [math.hypot(now_corners[i][0] - ref_corners[i][0],
                     now_corners[i][1] - ref_corners[i][1]) for i in range(4)]
    return sh, max(sh)


def _inspect_until_corners_match(ref_corners, label):
    """四隅が ref_corners と 15px 以内に収まるまで、最大 3 回測り直す.

    エイイチ判断 2026-10-19: 四隅の検出は時々外れるが、これは
    「つかみ損ねを防ぐ補助」であってアームの安全装置ではない。
    1 回で止めると誤って止まる回数が増えるので、やり直してから判断する。

    戻り値: (採用した inspect の結果 or None, 試行の記録リスト)
      試行の記録: [{attempt, max_shift_px, shifts_px, ok, corners_ok, block_px}]
    """
    attempts = []
    chosen = None
    for attempt in range(1, MAT_CORNER_RETRY_MAX + 1):
        cand = _inspect_top_camera()
        shifts, mx = _corner_shift_px(ref_corners,
                                      (cand or {}).get("corners_px"))
        rec = {
            "attempt": attempt,
            "at": datetime.now().isoformat(),
            "corners_ok": bool(cand and cand.get("corners_px")),
            # codex R9 R3: 四隅そのものも残す（クラスタの判別まで出来るように）
            "corners_px": ((cand or {}).get("corners_px")),
            "ref_corners_px": ([[round(v, 2) for v in c] for c in ref_corners]
                               if ref_corners else None),
            "shifts_px": ([round(x, 2) for x in shifts] if shifts else None),
            "max_shift_px": (round(mx, 2) if mx is not None else None),
            "ok": bool(mx is not None and mx <= MAT_CORNER_SHIFT_ABORT_PX),
            "block_px": ((cand or {}).get("block_px")),
            "block_px_samples": ((cand or {}).get("block_px_samples")),
        }
        attempts.append(rec)
        if cand is not None:
            chosen = cand            # 最後に測れたものは残す（全部外れた時の記録用）
        if rec["ok"]:
            if attempt > 1:
                _log("{}: 四隅が {} 回目で収まりました（最大 {:.1f}px <= {:.1f}px）"
                     .format(label, attempt, mx, MAT_CORNER_SHIFT_ABORT_PX))
            return cand, attempts
        if mx is None:
            _warn("{}: 四隅を比べられませんでした（{} 回目）".format(label, attempt))
        else:
            _warn("{}: 四隅が最大 {:.1f}px ずれています（{} 回目 / 上限 {:.1f}px）{}"
                  .format(label, mx, attempt, MAT_CORNER_SHIFT_ABORT_PX,
                          "。測り直します" if attempt < MAT_CORNER_RETRY_MAX
                          else "。やり直しの上限に達しました"))
    return chosen, attempts


def _px_spread(samples):
    """画素サンプルの広がり（最大の2点間距離）を返す. 2 点未満なら 0.0."""
    if not samples or len(samples) < 2:
        return 0.0
    m = 0.0
    for i in range(len(samples)):
        for j in range(i + 1, len(samples)):
            d = math.hypot(samples[i][0] - samples[j][0],
                           samples[i][1] - samples[j][1])
            if d > m:
                m = d
    return m


def _save_check_image(out_path, tag, block_xz, box_xz, H=None, frame=None):
    """検出したブロックと箱に丸を付けた上カメラ画像を保存する.

    エイイチ判断 2026-10-19: 13:14 の measure が (+48, -34) mm =
    根元から 58.8mm の何か（赤いケーブルの可能性）をブロックとして拾っていたのに、
    画像が無いので誰も気づけなかった。毎回 1 枚残して目で確かめられるようにする。

    detect_positions が内部で立てた homography（visual_servo_pick._homography）を
    逆に使って、**報告された Unity 座標そのもの**を画素に戻して丸を描く
    （検出をやり直さないので、丸の位置と記録された数値が必ず一致する）。
    失敗しても例外にせず False を返す（記録の都合で本線を止めない）。
    """
    cap = None
    try:
        import cv2
        import numpy as np
        import camera_resolver
        import visual_servo_pick as vsp

        # H は明示で渡すのが基本（再生前は measure の homography を使う。
        # 作り直さないので vsp._homography は立っていない）。
        if H is None:
            H = getattr(vsp, "_homography", None)
        if H is None:
            _warn("homography が無いので確認画像は作れません")
            return False
        Hinv = np.linalg.inv(np.asarray(H, dtype=np.float64))

        if frame is None:
            cams = camera_resolver.resolve_cameras(
                require_top=True, require_side=False, verbose=False)
            idx = (cams or {}).get("top")
            if idx is None:
                _warn("上カメラが解決できないので確認画像は作れません")
                return False
            cap = cv2.VideoCapture(idx)
            if not cap.isOpened():
                _warn("上カメラを開けないので確認画像は作れません")
                return False
            for _ in range(10):
                ok, f = cap.read()
                if ok and f is not None:
                    frame = f
        if frame is None:
            _warn("上カメラから映像が来ないので確認画像は作れません")
            return False
        frame = frame.copy()

        def to_px(xz):
            """Unity (m) → マット mm → 画素."""
            if not (isinstance(xz, (list, tuple)) and len(xz) == 2
                    and _is_finite_num(xz[0]) and _is_finite_num(xz[1])):
                return None
            pt = np.array([[[float(xz[0]) * 1000.0, float(xz[1]) * 1000.0]]],
                          dtype=np.float32)
            r = cv2.perspectiveTransform(pt, Hinv)
            px, py = float(r[0][0][0]), float(r[0][0][1])
            if not (math.isfinite(px) and math.isfinite(py)):
                return None
            return int(round(px)), int(round(py))

        # 根元（Unity 原点）と、ブロックとして扱わない半径の輪
        base = to_px([0.0, 0.0])
        ring = []
        for k in range(0, 360, 6):
            a = math.radians(k)
            q = to_px([BLOCK_MIN_DIST_FROM_BASE_MM * math.cos(a) / 1000.0,
                       BLOCK_MIN_DIST_FROM_BASE_MM * math.sin(a) / 1000.0])
            if q:
                ring.append(q)
        if len(ring) > 2:
            cv2.polylines(frame, [np.array(ring, dtype=np.int32)], True,
                          (0, 165, 255), 2)
        if base:
            cv2.drawMarker(frame, base, (0, 165, 255), cv2.MARKER_CROSS, 24, 2)
            cv2.putText(frame, "base (<{:.0f}mm = not block)".format(
                BLOCK_MIN_DIST_FROM_BASE_MM),
                (base[0] + 14, base[1] - 10), cv2.FONT_HERSHEY_SIMPLEX,
                0.5, (0, 165, 255), 1, cv2.LINE_AA)

        for name, xz, color in (("block", block_xz, (0, 0, 255)),
                                ("box", box_xz, (255, 180, 0))):
            q = to_px(xz)
            if q is None:
                cv2.putText(frame, "{}: NOT DETECTED".format(name.upper()),
                            (20, 40 if name == "block" else 66),
                            cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2, cv2.LINE_AA)
                continue
            cv2.circle(frame, q, 26, color, 3)
            cv2.drawMarker(frame, q, color, cv2.MARKER_CROSS, 18, 2)
            d = _dist_from_base_mm(xz)
            cv2.putText(frame, "{} ({:+.0f},{:+.0f})mm  base{:.0f}mm".format(
                name, float(xz[0]) * 1000.0, float(xz[1]) * 1000.0,
                d if d is not None else -1),
                (q[0] + 30, q[1] - 12), cv2.FONT_HERSHEY_SIMPLEX, 0.55,
                color, 2, cv2.LINE_AA)
        cv2.putText(frame, tag, (20, frame.shape[0] - 16),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2, cv2.LINE_AA)

        out_path.parent.mkdir(parents=True, exist_ok=True)
        if not cv2.imwrite(str(out_path), frame):
            _warn("確認画像の書き込みに失敗しました: {}".format(out_path))
            return False
        _log("確認画像: {}".format(out_path))
        return True
    except Exception as e:
        _warn("確認画像を作れませんでした（記録のみ・本線は続行）: {}: {}".format(
            type(e).__name__, e))
        return False
    finally:
        if cap is not None:
            try:
                cap.release()
            except Exception:
                pass


def _detect_now(repeat, interval, tag):
    """上カメラでブロックと箱を検出する（アームに触らない）."""
    _log("{}: 上カメラで検出します（repeat={} interval={}s）".format(tag, repeat, interval))
    res = detect_positions(repeat=repeat, interval=interval)
    block = res.get("block_xz_m")
    box = res.get("box_xz_m")
    _log("{}: block = {}".format(tag, _fmt_xz_mm(block)))
    _log("{}: box   = {}  score={}".format(
        tag, _fmt_xz_mm(box), (res.get("detect_score") or {}).get("box")))
    return res


def _dist_from_base_mm(xz):
    """Unity 原点（アームの根元）からの距離 mm。計算できなければ None."""
    if not (isinstance(xz, (list, tuple)) and len(xz) == 2
            and _is_finite_num(xz[0]) and _is_finite_num(xz[1])):
        return None
    d = math.hypot(float(xz[0]) * 1000.0, float(xz[1]) * 1000.0)
    return d if math.isfinite(d) else None


def _block_too_close_to_base(block_xz):
    """ブロックが根元に近すぎないか。近すぎれば理由の文字列、問題なければ None."""
    d = _dist_from_base_mm(block_xz)
    if d is None:
        return None   # 値の妥当性は別のガード（_check_block_not_moved）が見る
    # codex R8 P2: 仕様は「120mm 以内」なので、ちょうど 120.0mm も弾く
    if d <= BLOCK_MIN_DIST_FROM_BASE_MM:
        return ("検出したブロックがアームの根元から {:.1f}mm しか離れていません"
                "（{:.1f}mm 以内は不可）。教示で使う位置は 200mm 以上離れているので、"
                "赤いケーブル等の別のものを拾っている可能性が高いです: {}".format(
                    d, BLOCK_MIN_DIST_FROM_BASE_MM, _fmt_xz_mm(block_xz)))
    return None


def _fmt_xz_mm(xz):
    if not (isinstance(xz, (list, tuple)) and len(xz) == 2
            and isinstance(xz[0], (int, float)) and isinstance(xz[1], (int, float))):
        return "None"
    return "({:+.1f}, {:+.1f}) mm".format(xz[0] * 1000.0, xz[1] * 1000.0)


def cmd_measure(args):
    _note_tol_source()
    _require_ssd("measure の保存")

    out_dir = _measure_dir(args.log)
    out_dir.mkdir(parents=True, exist_ok=True)

    t0 = time.time()
    res = _detect_now(args.repeat, args.interval, "measure")

    if res.get("block_xz_m") is None:
        _warn("ブロックが検出できませんでした。この measure では "
              "run の位置照合（ブロックが動いていないかの確認）が通りません")
    if res.get("box_xz_m") is None:
        _warn("白箱が検出できませんでした（台帳の box_x / box_z は空欄になります）")

    # codex R2 D6: 冒頭の _require_ssd のあとカメラ検出を挟むので、
    # 保存の直前にもマウントを再確認する（検出中の取り外しを想定）。
    try:
        _require_mount_now("measure の保存")
    except _MountLost as e:
        _abort_msg("{}。ローカルへは書きません（measure をやり直してください）".format(e))
        return 2

    stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    out_path = out_dir / "measure_{}.json".format(stamp)
    img_path = out_dir / "measure_{}.jpg".format(stamp)

    # detect_positions が立てた homography を押さえる（これが mm の基準になる）
    # 2026-10-19 方針変更（項目4）: measure の判定は**すべて WARN**にして、
    # 値が取れなくても（null でも）保存する。止めない。
    measure_warnings = []
    import visual_servo_pick as _vsp
    H = getattr(_vsp, "_homography", None)
    if H is None:
        _warn("homography が作れていません（マット四隅の検出に失敗）。"
              "mm と画素の対応が取れないので、関係する値は null で保存します")
        measure_warnings.append("homography_missing")
        H_list = None
        corners_px = None
    else:
        H_list = [[float(v) for v in row] for row in H]
        corners_px = _h_to_corners_px(H)

    corner_attempts = []

    def _reject_payload():
        return {
            "measure_dir": str(out_dir),
            "block_xz_m": res.get("block_xz_m"),
            "box_xz_m": res.get("box_xz_m"),
            "homography": H_list,
            "mat_corners_px": corners_px,
            "check_image": (str(img_path) if img_path.exists() else None),
            "mat_corner_attempts": corner_attempts,
        }

    # ばらつきの確認（同じ homography のまま、ブロック画素を複数回測る）。
    # 四隅が homography のもとと合わなければ最大 3 回やり直す（エイイチ判断）。
    _insp_res = _inspect_until_corners_match(corners_px, "measure")
    insp = _insp_res[0]
    corner_attempts[:] = _insp_res[1]
    if insp is None:
        _warn("上カメラの確認ができませんでした。測り直しの値は null で保存します")
        measure_warnings.append("inspection_failed")
    elif not insp.get("corners_px"):
        _warn("マット四隅を測り直せませんでした。homography の確かさを"
              "確認できません（WARN のみ・保存します）")
        measure_warnings.append("mat_corners_recheck_missing")
    n_samples = len(insp.get("block_px_samples") or []) if insp else 0
    if n_samples < MEASURE_BLOCK_MIN_SAMPLES:
        _warn("ブロックの検出サンプルが {} 件（最低 {} 件）。"
              "ばらつきを判定できません（WARN のみ・保存します）"
              .format(n_samples, MEASURE_BLOCK_MIN_SAMPLES))
        measure_warnings.append("too_few_samples")

    # 検出位置に丸を付けた上カメラ画像を、JSON と同じ時刻の名前で残す
    # （確認で撮ったフレームを使い回す。homography は detect_positions のもの）
    img_ok = _save_check_image(img_path, "measure {}".format(stamp),
                               res.get("block_xz_m"), res.get("box_xz_m"),
                               H=H, frame=(insp.get("frame") if insp else None))

    # measure 自身の homography が信用できるかを確かめる。
    # detect_positions は自前のフレームから四隅を取って homography を作る。
    # その四隅が、直後に測り直した四隅と大きく食い違うなら、homography が
    # 外れていて mm が信用できない（15:25 の 37mm 外れ値はこれ）。
    # 四隅の検出自体は安定している（続けて 4 回測って最大 1.1px）ので、
    # 食い違い = detect_positions 側の四隅が外れた、と読める。
    last_attempt = corner_attempts[-1] if corner_attempts else {}
    _log("homography のもとになった四隅と、測り直した四隅の差: 最大 {}px"
         "（上限 {:.1f}px・やり直し {} 回）".format(
             last_attempt.get("max_shift_px"), MAT_CORNER_SHIFT_ABORT_PX,
             len(corner_attempts)))
    if corner_attempts and not last_attempt.get("ok"):
        _warn("この measure の homography は信用できません: マット四隅が"
              "測り直しと {} 回とも食い違った（各回の最大: {}）。"
              "mm の値が外れている可能性があります（WARN のみ・保存します）"
              .format(len(corner_attempts),
                      ", ".join(str(a.get("max_shift_px"))
                                for a in corner_attempts)))
        measure_warnings.append("mat_corner_mismatch")
        if img_ok:
            _log("確認画像: {}".format(img_path))

    # 根元に近すぎるものはブロックとして扱わない（赤いケーブル等の誤検出）
    too_close = _block_too_close_to_base(res.get("block_xz_m"))
    if too_close:
        _warn(too_close + "（WARN のみ・保存します）")
        measure_warnings.append("block_too_close_to_base")
        if img_ok:
            _log("何を拾ったかは確認画像で見てください: {}".format(img_path))

    block_px = (_px_from_mm(H, res.get("block_xz_m")) if H is not None else None)
    # codex R8 P5: ばらつきは画素換算の概算ではなく、**固定した H で各サンプルを
    # mm に直して**判定する（斜め方向の換算誤差を持ち込まない）。
    _samples = (insp.get("block_px_samples") if insp else None) or []
    spread_px = _px_spread(_samples) if len(_samples) >= 2 else 0.0
    spread_mm = 0.0
    if H is not None and len(_samples) >= 2:
        mm_samples = [_mm_from_px(H, q[0], q[1]) for q in _samples]
        for i in range(len(mm_samples)):
            for j in range(i + 1, len(mm_samples)):
                d = math.hypot((mm_samples[i][0] - mm_samples[j][0]) * 1000.0,
                               (mm_samples[i][1] - mm_samples[j][1]) * 1000.0)
                if d > spread_mm:
                    spread_mm = d
    _log("ブロックのばらつき: {:.1f}px = {:.2f}mm（{} 枚・上限 {:.1f}mm）".format(
        spread_px, spread_mm, n_samples, MEASURE_BLOCK_SPREAD_MAX_MM))
    if spread_mm >= MEASURE_BLOCK_SPREAD_MAX_MM:
        _warn("検出が不安定です: ブロックのばらつきが {:.1f}px = {:.2f}mm"
              "（上限 {:.1f}mm）。（WARN のみ・保存します）".format(
                  spread_px, spread_mm, MEASURE_BLOCK_SPREAD_MAX_MM))
        measure_warnings.append("block_spread_over")
        if img_ok:
            _log("確認画像: {}".format(img_path))

    _b = res.get("block_xz_m")
    _b_ok = (isinstance(_b, (list, tuple)) and len(_b) == 2
             and _is_finite_num(_b[0]) and _is_finite_num(_b[1]))
    if not _b_ok:
        _warn("ブロックを検出できていません（{!r}）。位置は null で保存します"
              .format(_b))
        measure_warnings.append("block_not_detected")
    if insp is None or not insp.get("block_px"):
        _warn("ブロックの測り直しができていません（元の検出と突き合わせ不可）。"
              "（WARN のみ・保存します）")
        measure_warnings.append("block_recheck_missing")

    # codex R8 P5: detect_positions が出した位置と、測り直した中央値を突き合わせる。
    # **元の検出だけが外れて、あとの画像が安定している**場合を取り逃がさない
    # （15:25 の 37mm 外れ値はこの形だった）。
    recheck_mm = None
    vs_recheck_mm = None
    if H is not None and _b_ok and insp is not None and insp.get("block_px"):
        recheck_mm = _mm_from_px(H, insp["block_px"][0], insp["block_px"][1])
        vs_recheck_mm = math.hypot((recheck_mm[0] - _b[0]) * 1000.0,
                                   (recheck_mm[1] - _b[1]) * 1000.0)
        if not _is_finite_num(vs_recheck_mm):
            _warn("元の検出と測り直しの差を計算できません（null で保存します）")
            measure_warnings.append("vs_recheck_not_finite")
            vs_recheck_mm = None
        else:
            _log("元の検出と測り直しの差: {:.2f}mm（上限 {:.1f}mm）".format(
                vs_recheck_mm, MEASURE_BLOCK_VS_RECHECK_MAX_MM))
            if vs_recheck_mm > MEASURE_BLOCK_VS_RECHECK_MAX_MM:
                _warn("元の検出 {} と測り直し {} が {:.2f}mm 食い違います"
                      "（上限 {:.1f}mm）。元の検出が外れている可能性があります"
                      "（WARN のみ・保存します）".format(
                          _fmt_xz_mm(_b), _fmt_xz_mm(recheck_mm),
                          vs_recheck_mm, MEASURE_BLOCK_VS_RECHECK_MAX_MM))
                measure_warnings.append("vs_recheck_over")
                if img_ok:
                    _log("確認画像: {}".format(img_path))
    payload = {
        "script": _THIS.name,
        "kind": "teach_poses_measure",
        "log_no": (int(args.log) if args.log is not None else None),
        "measure_dir": str(out_dir),
        "measured_at": datetime.now().isoformat(),
        "measured_at_ts": t0,
        "repeat": args.repeat,
        "interval": args.interval,
        "block_xz_m": res.get("block_xz_m"),
        "box_xz_m": res.get("box_xz_m"),
        "detect_score": res.get("detect_score"),
        "n_captures": res.get("n_captures"),
        "resolved_top_index": res.get("resolved_top_index"),
        "check_image": (str(img_path) if img_ok else None),
        # 再生前の確認はこの homography と画素位置を基準にする（作り直さない）
        "homography": H_list,
        "mat_corners_px": corners_px,
        "mat_corners_mm": [list(c) for c in MAT_CORNERS_MM],
        "block_px": block_px,
        "box_px": (_px_from_mm(H, res.get("box_xz_m")) if H is not None else None),
        "block_px_samples": (insp.get("block_px_samples") if insp else None),
        "block_px_spread_px": round(spread_px, 2),
        "block_spread_mm": round(spread_mm, 2),
        "block_px_recheck": (insp.get("block_px") if insp else None),
        "block_recheck_xz_m": (list(recheck_mm) if recheck_mm else None),
        "block_vs_recheck_mm": (round(vs_recheck_mm, 2)
                                if vs_recheck_mm is not None else None),
        "block_vs_recheck_max_mm": MEASURE_BLOCK_VS_RECHECK_MAX_MM,
        "block_min_samples": MEASURE_BLOCK_MIN_SAMPLES,
        "block_px_spread_max_mm": MEASURE_BLOCK_SPREAD_MAX_MM,
        "mat_corners_px_recheck": (insp.get("corners_px") if insp else None),
        "mat_corner_attempts": corner_attempts,
        "mat_corner_retry_max": MAT_CORNER_RETRY_MAX,
        "mat_corner_shift_abort_px": MAT_CORNER_SHIFT_ABORT_PX,
        "block_dist_from_base_mm": (
            round(_dist_from_base_mm(res.get("block_xz_m")), 1)
            if _dist_from_base_mm(res.get("block_xz_m")) is not None else None),
        "box_dist_from_base_mm": (
            round(_dist_from_base_mm(res.get("box_xz_m")), 1)
            if _dist_from_base_mm(res.get("box_xz_m")) is not None else None),
        "block_min_dist_from_base_mm": BLOCK_MIN_DIST_FROM_BASE_MM,
        "note": "ブロックに印は付けない（シールが映ると π0.5 が印を目当てに動くおそれがある）",
        # 2026-10-19 方針変更（項目4）: 判定は WARN だけで、保存を止めない。
        # 何が引っかかったかは warnings に残す（空なら全部クリア）。
        "warnings": list(measure_warnings),
        "gate_policy": "warn_only (2026-10-19)",
    }
    _atomic_write_json(out_path, payload)
    _log("保存しました: {}".format(out_path))
    if measure_warnings:
        _warn("この measure には WARN が {} 件あります: {}".format(
            len(measure_warnings), ", ".join(measure_warnings)))
        _warn("値が外れている可能性があります。気になるなら取り直してください"
              "（保存はしてあります）")
    _log("次は Pi で教示 → daemon 起動 → recorder.py --top --no-side 常駐 → "
         "run --teach <file> --execute")
    return 0


_MEASURE_STAMP_RE = re.compile(r"^measure_(\d{8}_\d{6})\.json$")


def _find_latest_measure(explicit=None):
    """直近の measure JSON を返す. (path, payload) または (None, None)."""
    if explicit:
        p = Path(explicit).expanduser()
        if not p.is_file():
            return None, None
        try:
            return p, json.loads(p.read_text())
        except Exception:
            return p, None

    # codex R1 C3: パス全体の文字列順で並べると親ディレクトリ名が先に効く。
    # teach_poses_20261019/ と teach_poses_LOG352/ が混在すると "2" < "L" なので
    # 時刻の古い LOG352 側が「直近」に選ばれてしまう。
    # よって **ファイル名の時刻 measure_{YYYYMMDD_HHMMSS} をキーに並べる**。
    # 時刻として読めないファイル名は候補から外す（名前を推測で救わない）。
    candidates = []
    for p in MEASURE_ROOT.glob(MEASURE_DIR_PREFIX + "*/measure_*.json"):
        m = _MEASURE_STAMP_RE.match(p.name)
        if not m:
            _warn("measure のファイル名が measure_YYYYMMDD_HHMMSS.json 形式でないので "
                  "候補から外します: {}".format(p))
            continue
        candidates.append((m.group(1), str(p), p))
    if not candidates:
        return None, None
    candidates.sort()
    p = candidates[-1][2]
    try:
        return p, json.loads(p.read_text())
    except Exception:
        return p, None


# ---- teach JSON の取得 -------------------------------------------------------
def _fetch_teach_from_pi(name, dest_path):
    """Pi の teach JSON を scp で取ってくる. 成功時 remote_path を返す."""
    remote = "{}/{}".format(PI_TEACH_DIR, name)
    target = "{}@{}:{}".format(PI_USER, PI_HOST, remote)
    cmd = [
        "scp",
        "-i", PI_KEY_PATH,
        "-o", "ConnectTimeout=8",
        "-o", "StrictHostKeyChecking=no",
        "-o", "BatchMode=yes",
        target, str(dest_path),
    ]
    _log("Pi から教えた記録を取得します: {}".format(target))
    try:
        proc = subprocess.run(cmd, capture_output=True, text=True,
                              timeout=SCP_TIMEOUT_SEC)
    except subprocess.TimeoutExpired:
        _abort_msg("scp が {:.0f}s で応答しません: {}".format(SCP_TIMEOUT_SEC, target))
        sys.exit(1)
    except Exception as e:
        _abort_msg("scp の起動に失敗: {}: {}".format(type(e).__name__, e))
        sys.exit(1)
    if proc.returncode != 0:
        _abort_msg("scp 失敗 (rc={}): {}".format(proc.returncode,
                                                 (proc.stderr or "").strip()))
        sys.exit(1)
    _log("取得しました → {}".format(dest_path))
    return remote


def _sha256(path):
    h = hashlib.sha256()
    with open(str(path), "rb") as f:
        for chunk in iter(lambda: f.read(65536), b""):
            h.update(chunk)
    return h.hexdigest()


# ---- 検証 -------------------------------------------------------------------
def _pose_violation(pose):
    """1 姿勢を「有限値 → JOINT_LIMITS → J4_SAFE」の順に検査する.

    codex R1 C1/C2: NaN は上下限比較をすり抜けるので、必ず有限値を先に見る。
    問題なければ None、あれば理由の文字列を返す。
    """
    if not _is_finite_6(pose):
        return "6 軸の有限な数値でない（NaN / inf / 型不正 / 長さ不正）: {!r}".format(pose)
    viol = wr._check_joint_limits(pose)
    if viol:
        return "JOINT_LIMITS 違反: " + ", ".join(
            "j{}={:.3f} not in [{:.1f}, {:.1f}]".format(ax + 1, v, lo, hi)
            for ax, v, lo, hi in viol)
    j4 = float(pose[4])
    if j4 < J4_SAFE_MIN or j4 > J4_SAFE_MAX:
        return "J4_SAFE 違反: j4={:.3f} not in [{:+.1f}, {:+.1f}]".format(
            j4, J4_SAFE_MIN, J4_SAFE_MAX)
    return None


def _j4_margin(pose):
    """j4 の安全範囲までの余裕（度）。非有限なら None."""
    if not _is_finite_6(pose):
        return None
    j4 = float(pose[4])
    return min(j4 - J4_SAFE_MIN, J4_SAFE_MAX - j4)


def _fk_tip_of(pose):
    """角度の最近傍で、その姿勢の爪先位置を FK テーブルから引く（**読み取りのみ**）.

    本線 fk_lookup._load_fk_table() が fk_scan_motion_based_v2.csv を 1 度だけ
    読んでキャッシュしたものを借りる。CSV には一切書かない。
    IK は解かない（実在する FK 行を選ぶだけ）。
    戻り値: (ee [x, y, z] m, 行 index, 最大軸差 deg)。読めなければ (None, None, None)
    """
    try:
        joints, ees, _safe = fkl._load_fk_table()
        d = np.abs(joints - np.asarray(pose, dtype=float)).max(axis=1)
        i = int(np.argmin(d))
        return [float(v) for v in ees[i]], i, float(d[i])
    except (KeyboardInterrupt, SystemExit):
        raise
    except Exception as e:
        _warn("FK テーブルから爪先位置を引けませんでした（止めません）: {}: {}"
              .format(type(e).__name__, e))
        return None, None, None


def _shoulder_replacement(pose):
    """肩を SHOULDER_MAX_DEG 以内に収めた置き換え姿勢を FK テーブルから選ぶ.

    本線 fk_lookup と同じ考え方で選ぶ:
      - 候補は safe_mask の行だけ（JOINT_LIMITS(hard) ∩ j1 <= J1_SAFE_MAX）
      - **j0 と j5 は教えた値のまま**使うので、候補は j0 が教示値
        ±SHOULDER_FIX_J0_TOL_DEG の行に絞る（j0 を差し替えると爪先が回るため）
      - その中から score = 爪先の 3D 距離[m] + W*(|Δj2|+|Δj3|+|Δj4|) が最小の行
      - 返す姿勢は [教示 j0, 行 j1, 行 j2, 行 j3, 行 j4, 教示 j5]
    IK は解かない。send_coords は使わない。CSV は書き換えない。
    戻り値: (new_pose or None, detail dict)
    """
    detail = {
        "shoulder_max_deg": SHOULDER_MAX_DEG,
        "j0_tol_deg": SHOULDER_FIX_J0_TOL_DEG,
        "angle_penalty_m_per_deg": SHOULDER_FIX_ANGLE_PENALTY,
        "fk_table": fkl.FK_CSV.name,
        "method": "fk_nearest_tip_with_angle_penalty",
        "candidate_mask": ("fk_lookup.safe_mask(JOINT_LIMITS hard ∩ j1<=88)"
                           " ∩ |Δj0|<=tol ∩ J4_SAFE"),
        "j4_safe": [J4_SAFE_MIN, J4_SAFE_MAX],
    }
    tip, tip_row, tip_dang = _fk_tip_of(pose)
    detail["taught_tip_xyz_m"] = tip
    detail["taught_tip_fk_row"] = tip_row
    detail["taught_tip_angle_nn_max_deg"] = (round(tip_dang, 3)
                                             if tip_dang is not None else None)
    if tip is None:
        detail["result"] = "no_fk_table"
        return None, detail
    try:
        joints, ees, safe = fkl._load_fk_table()
        ee_t = np.asarray(tip, dtype=float)
        m = safe.copy()
        m &= np.abs(joints[:, 0] - float(pose[0])) <= SHOULDER_FIX_J0_TOL_DEG
        # codex V5: 本線の safe_mask は JOINT_LIMITS(hard) ∩ j1<=88 だけで、
        # **J4_SAFE を含まない**（fk_lookup.py L255 の設計）。
        # ここで当てておかないと、J4_SAFE 外の行を採って計画段階の姿勢検査で
        # 止まり、「置き換えなければ走れた試行」を止めてしまう。
        m &= (joints[:, 4] >= J4_SAFE_MIN) & (joints[:, 4] <= J4_SAFE_MAX)
        n_cand = int(m.sum())
        detail["n_candidates"] = n_cand
        if n_cand == 0:
            detail["result"] = "no_candidate"
            return None, detail
        idx = np.where(m)[0]
        dist3 = np.linalg.norm(ees[idx] - ee_t, axis=1)
        pen = (np.abs(joints[idx, 2] - float(pose[2]))
               + np.abs(joints[idx, 3] - float(pose[3]))
               + np.abs(joints[idx, 4] - float(pose[4])))
        best = int(idx[int(np.argmin(dist3 + SHOULDER_FIX_ANGLE_PENALTY * pen))])
        row = [float(v) for v in joints[best]]
        new_pose = [float(pose[0]), row[1], row[2], row[3], row[4], float(pose[5])]
        # codex V1: 返すのは「FK テーブルに実在する行そのもの」ではない
        #（j0 と j5 を教示値に差し替えている）。教示値が制限外なら最終姿勢が
        # JOINT_LIMITS / J4_SAFE を外れうるので、**採用前に同じ検査を当てる**。
        # 外れたら置き換えない（教えた姿勢のまま進む・止めない）。
        bad = _pose_violation(new_pose)
        if bad:
            detail["result"] = "replacement_rejected"
            detail["rejected_reason"] = bad
            detail["rejected_angles"] = [round(v, 3) for v in new_pose]
            _warn("置き換え候補が姿勢検査に通らないので採用しません"
                  "（教えた姿勢のまま進みます）: {}".format(bad))
            return None, detail
        detail["fk_row"] = best
        detail["fk_row_angles"] = [round(v, 3) for v in row]
        detail["fk_row_tip_xyz_m"] = [float(v) for v in ees[best]]
        detail["selected_tip_dist_mm"] = round(
            float(np.linalg.norm(ees[best] - ee_t)) * 1000.0, 2)
        # 置き換え後の姿勢（j0/j5 を教示値に戻した形）で爪先を**再評価**する。
        # 候補行の爪先はその行の j0 で計算されているので、選定時の距離とは別物。
        tip2, row2, dang2 = _fk_tip_of(new_pose)
        detail["new_tip_xyz_m"] = tip2
        detail["new_tip_fk_row"] = row2
        detail["new_tip_angle_nn_max_deg"] = (round(dang2, 3)
                                              if dang2 is not None else None)
        detail["tip_delta_mm"] = (
            round(float(np.linalg.norm(np.asarray(tip2) - ee_t)) * 1000.0, 2)
            if tip2 is not None else None)
        detail["tip_delta_xz_mm"] = (
            round(float(math.hypot(tip2[0] - ee_t[0], tip2[2] - ee_t[2]))
                  * 1000.0, 2) if tip2 is not None else None)
        detail["tip_delta_y_mm"] = (
            round(float(tip2[1] - ee_t[1]) * 1000.0, 2)
            if tip2 is not None else None)
        detail["result"] = "replaced"
        return new_pose, detail
    except (KeyboardInterrupt, SystemExit):
        raise
    except Exception as e:
        detail["result"] = "error"
        detail["error"] = "{}: {}".format(type(e).__name__, e)
        _warn("肩の置き換えで例外（止めません・教えた姿勢のまま進みます）: {}"
              .format(detail["error"]))
        return None, detail


def _fix_shoulder_over_max(waypoints):
    """肩が上限を超えた教示姿勢を、計画段階で置き換える（送信前）.

    **waypoints は書き換えず、新しい dict を返す**（元の教示値は記録に残す）。
    置き換えられなかった姿勢はそのまま返す（**止めない**）。
    戻り値: (new_waypoints, records list)
    """
    out = dict((k, list(v)) for k, v in waypoints.items())
    records = []
    for name in wr.PHASE_ORDER:
        pose = list(waypoints[name])
        if not (_is_finite_num(pose[1]) and float(pose[1]) > SHOULDER_MAX_DEG):
            continue
        new_pose, detail = _shoulder_replacement(pose)
        rec = {
            "phase": name,
            "taught_angles": [round(v, 3) for v in pose],
            "taught_shoulder_deg": round(float(pose[1]), 3),
        }
        rec.update(detail)
        if new_pose is None:
            rec["new_angles"] = None
            rec["applied"] = False
            _warn("{} の肩が {:+.2f}°（上限 {:.1f}°）ですが、置き換える姿勢が"
                  "見つかりませんでした（{}）。**教えた姿勢のまま進みます**"
                  .format(name, pose[1], SHOULDER_MAX_DEG,
                          detail.get("result")))
        else:
            out[name] = new_pose
            rec["new_angles"] = [round(v, 3) for v in new_pose]
            rec["new_shoulder_deg"] = round(float(new_pose[1]), 3)
            rec["applied"] = True
        records.append(rec)
    return out, records


def _print_shoulder_fix(records):
    """置き換えの前後を目立つ形で出す（計画表示の一部）."""
    if not records:
        return
    print("")
    print("!" * 78)
    print("{} [WARN] 肩（index 1）が上限 {:.1f}° を超える教示姿勢を "
          "{} 件置き換えました（送るのは置き換え後の姿勢です）。".format(
              LOG_PREFIX, SHOULDER_MAX_DEG, len(records)))
    print("{} [WARN] 理由: 手で教えた PICK 肩 95.53 / 97.03 / 99.22 は 4 回とも"
          "send_angles が捨てられた（80.59 は通った）。".format(LOG_PREFIX))
    print("{} [WARN] 本線は肩 87.74 / 87.00 / 85.00 を送って 647 試行動いている"
          "（命令の最大 88.0）。".format(LOG_PREFIX))
    for r in records:
        print("{}   {}".format(LOG_PREFIX, r["phase"]))
        print("{}     教えた姿勢   = {}  （肩 {:+.2f}）".format(
            LOG_PREFIX, _fmt_angles(r["taught_angles"]),
            r["taught_shoulder_deg"]))
        if r.get("applied"):
            print("{}     置き換え後   = {}  （肩 {:+.2f}）".format(
                LOG_PREFIX, _fmt_angles(r["new_angles"]), r["new_shoulder_deg"]))
            print("{}     爪先の差     = {} mm（xz {} / 上下 {}）  "
                  "FK 行 {} / 候補 {} 件".format(
                      LOG_PREFIX, r.get("tip_delta_mm"),
                      r.get("tip_delta_xz_mm"), r.get("tip_delta_y_mm"),
                      r.get("fk_row"), r.get("n_candidates")))
            print("{}     j0 と j5 は教えた値のまま（{:+.2f} / {:+.2f}）".format(
                LOG_PREFIX, r["taught_angles"][0], r["taught_angles"][5]))
            d = r.get("tip_delta_mm")
            if d is not None and d > SHOULDER_FIX_TIP_WARN_MM:
                print("{}     [WARN] 爪先が {} mm ずれています"
                      "（目安 {:.0f} mm 超）。つかみ損ねる可能性があります"
                      .format(LOG_PREFIX, d, SHOULDER_FIX_TIP_WARN_MM))
        else:
            print("{}     置き換えできませんでした（{}）。"
                  "教えた姿勢のまま送ります".format(
                      LOG_PREFIX, r.get("result")))
    print("{} [WARN] FK テーブル（{}）は読んだだけで、書き換えていません。"
          .format(LOG_PREFIX, fkl.FK_CSV.name))
    print("!" * 78)
    print("")


def _check_all_poses(seq, waypoints):
    """送る姿勢と、その間を通る姿勢を _pose_violation で検査する.

    単発送信方式では送るのは各区間の終点（= waypoint か HOME）だけだが、
    アームは 2 点間を補間して動くので、**その経路上の姿勢も検査する**
    （wpsr._interpolate の凸結合は JOINT_LIMITS / J4_SAFE に対して
    端点検査で足りるが、j4 の余裕の最小値を出すために実際に全点を見る）。
    戻り値: (has_violation, n_checked, min_j4_margin)
    """
    violations = []
    margins = []
    sh_over = []     # 肩 > SHOULDER_MAX_DEG の姿勢（WARN 用・止めない）

    def _check(where, tick, pose):
        reason = _pose_violation(pose)
        if reason:
            violations.append((where, tick, pose, reason))
        m = _j4_margin(pose)
        if m is not None:
            margins.append((m, where, tick, pose))
        # 肩（index 1）が受け付けられない帯に入っていないか（2026-10-19 実測）。
        # 【訂正】以前は index 2 を見ていた。問題の軸は index 1。
        if _is_finite_num(pose[1]) and float(pose[1]) > SHOULDER_MAX_DEG:
            sh_over.append((float(pose[1]), where, tick))

    _check("HOME", 0, HOME_ANGLES)
    for name in wr.PHASE_ORDER:
        _check(name, 0, waypoints[name])

    n_checked = 1 + len(wr.PHASE_ORDER)
    for s in seq:
        if s["kind"] != "move":
            continue
        # 送るのは終点だけだが、アームは 2 点間を補間して動くので経路上も見る
        for k, pose in enumerate(wpsr._interpolate(s["from"], s["to"], s["n_steps"])):
            n_checked += 1
            _check("{} → {}".format(s["from_name"], s["to_name"]), k + 1, pose)

    # 肩が受け付けられない帯に残っている姿勢を、目立つ形で知らせる（**止めない**）。
    # 通常は _fix_shoulder_over_max が計画段階で置き換えているので、ここに出るのは
    # 「置き換えられなかった姿勢」か「補間の経路上だけ超える姿勢」。
    # 姿勢検査の合否より先に出す（別の理由で止まる場合でも見えるように）。
    if sh_over:
        worst = max(sh_over)
        print("")
        print("!" * 78)
        print("{} [WARN] 肩（index 1）が +{:.1f}° を超える姿勢が {} 件残っています"
              "（最大 {:+.2f} / {} 経路上の点 {}）。".format(
                  LOG_PREFIX, SHOULDER_MAX_DEG, len(sh_over),
                  worst[0], worst[1], worst[2]))
        print("{} [WARN] **この姿勢はアームが受け付けず、送っても動きません。**"
              .format(LOG_PREFIX))
        print("{} [WARN] **ブロックを手前に寄せて教え直してください。**"
              .format(LOG_PREFIX))
        print("{} [WARN] 根拠: 手で教えた PICK 肩 95.53 / 97.03 / 99.22 は 4 回とも"
              "無視された / 80.59 は通った。本線の命令の最大は 88.0。"
              .format(LOG_PREFIX))
        print("{} [WARN] 止めはしません。このまま進めると、その区間で"
              "「送り直しても動かない」として中断する見込みです。".format(LOG_PREFIX))
        for v, where, tick in sorted(sh_over, reverse=True)[:5]:
            print("{}          肩={:+.2f}  {}  経路上の点 {}".format(
                LOG_PREFIX, v, where, tick))
        if len(sh_over) > 5:
            print("{}          ... 他 {} 件".format(LOG_PREFIX, len(sh_over) - 5))
        print("!" * 78)
        print("")

    if violations:
        _abort_msg("姿勢検査（有限値 / JOINT_LIMITS / J4_SAFE）違反が {} 件"
                   "（全 {} 姿勢を検査）".format(len(violations), n_checked))
        for where, tick, pose, reason in violations[:10]:
            _log("  {}  経路上の点 {}  {}".format(where, tick, reason))
        if len(violations) > 10:
            _log("  ... 他 {} 件".format(len(violations) - 10))
        return True, n_checked, None

    min_margin = min(margins) if margins else None
    _log("姿勢検査 OK（全 {} 姿勢が 有限値 + JOINT_LIMITS + "
         "J4_SAFE [{:+.1f}, {:+.1f}] 内）".format(
             n_checked, J4_SAFE_MIN, J4_SAFE_MAX))
    if min_margin is not None:
        m, where, tick, pose = min_margin
        if m < J4_MARGIN_WARN_DEG:
            # codex R1 C2 追加分: 余裕が薄い教示データを計画時に知らせる。
            _warn("j4 の余裕が最小 {:.2f}°（< {:.1f}°）です: {} 経路上の点 {} j4={:+.2f}。"
                  "実測が安全範囲の外に振れる可能性があります"
                  "（実測では止めません。試行 JSON に WARN として残します）".format(
                      m, J4_MARGIN_WARN_DEG, where, tick, float(pose[4])))
        else:
            _log("j4 の余裕は最小 {:.2f}°（しきい値 {:.1f}° 以上）".format(
                m, J4_MARGIN_WARN_DEG))
    return False, n_checked, (min_margin[0] if min_margin else None)


def _check_camera_and_block_px(measure_payload, insp):
    """再生前の確認を **画素** で行う（エイイチ判断 2026-10-19）.

    homography を作り直さず、measure が保存した homography と画素位置を基準にする。
      1. マット四隅が measure から大きくずれていたら「カメラが動いた可能性」→ 止める
      2. ブロックの画素位置を measure の画素位置と比べる
         （許容は 5mm 相当の画素数。measure の homography から換算する）
      3. mm の値は記録用に、measure の homography で換算する

    戻り値: (ok, detail dict, reason)
    """
    detail = {"basis": "pixel_with_measure_homography",
              "tol_mm": BLOCK_MOVE_TOL_MM_PX_BASIS,
              "mat_corner_shift_abort_px": MAT_CORNER_SHIFT_ABORT_PX}

    H = (measure_payload or {}).get("homography")
    m_block_px = (measure_payload or {}).get("block_px")
    m_corners = (measure_payload or {}).get("mat_corners_px")
    if not H or not m_block_px:
        detail["fail_kind"] = "measure_format"
        return False, detail, (
            "measure に homography / ブロックの画素位置がありません"
            "（古い形式の measure です）。measure を取り直してください")
    if insp is None:
        detail["fail_kind"] = "no_inspection"
        return False, detail, "再生直前に上カメラを確認できませんでした"

    # 1. カメラが動いていないか（マット四隅のずれ）
    n_corners = insp.get("corners_px")
    if m_corners and n_corners and len(m_corners) == len(n_corners) == 4:
        shifts = [math.hypot(n_corners[i][0] - m_corners[i][0],
                             n_corners[i][1] - m_corners[i][1])
                  for i in range(4)]
        detail["mat_corner_shift_px"] = [round(x, 2) for x in shifts]
        detail["mat_corner_shift_max_px"] = round(max(shifts), 2)
        if max(shifts) > MAT_CORNER_SHIFT_ABORT_PX:
            detail["fail_kind"] = "mat_corner_shift"
            return False, detail, (
                "マット四隅が measure 時から最大 {:.1f}px ずれています"
                "（上限 {:.1f}px・最大 {} 回やり直しても収まらず）。"
                "カメラが動いた可能性があるので止めます。"
                "measure を取り直してください（各隅のずれ: {}）".format(
                    max(shifts), MAT_CORNER_SHIFT_ABORT_PX, MAT_CORNER_RETRY_MAX,
                    ", ".join("{:.1f}".format(x) for x in shifts)))
    else:
        # codex R8 P4: 比べられない = カメラが動いていないことを確認できない。
        # WARN で通すと「確認せずに再生」になるので、照合失敗として扱う。
        detail["mat_corner_shift_px"] = None
        detail["fail_kind"] = "mat_corner_incomparable"
        return False, detail, (
            "マット四隅を比べられませんでした（measure 側 {} / 今回 {}）。"
            "カメラが動いていないことを確認できないので止めます".format(
                "有り" if m_corners else "無し",
                "有り" if n_corners else "無し"))

    # 2. ブロックの画素位置を比べる
    n_block_px = insp.get("block_px")
    if not n_block_px:
        detail["fail_kind"] = "block_undetected"
        return False, detail, (
            "再生直前にブロックを検出できません（画素位置が取れない）。"
            "動いていないかを確認できないので止めます")
    detail["measure_block_px"] = [round(v, 1) for v in m_block_px]
    detail["now_block_px"] = [round(v, 1) for v in n_block_px]
    dpx = math.hypot(n_block_px[0] - m_block_px[0], n_block_px[1] - m_block_px[1])
    detail["block_shift_px"] = round(dpx, 2)

    tol_px = _mm_tol_to_px(H, _mm_from_px(H, m_block_px[0], m_block_px[1]),
                           BLOCK_MOVE_TOL_MM_PX_BASIS)
    if tol_px is None or not math.isfinite(tol_px) or tol_px <= 0:
        detail["fail_kind"] = "tol_px_invalid"
        return False, detail, "許容の画素換算ができませんでした（homography が不正）"
    detail["tol_px"] = round(tol_px, 2)

    # 3. mm は記録用に measure の homography で換算する。
    # codex R9 Q3: 判定は **丸める前の値**で行う（丸めてから比べると
    # 5.004mm が 5.0mm になって許容内に化ける）。丸めは記録用にだけ使う。
    dist_mm_raw = None
    try:
        now_mm = _mm_from_px(H, n_block_px[0], n_block_px[1])
        mea_mm = _mm_from_px(H, m_block_px[0], m_block_px[1])
        dx_raw = (now_mm[0] - mea_mm[0]) * 1000.0
        dz_raw = (now_mm[1] - mea_mm[1]) * 1000.0
        dist_mm_raw = math.hypot(dx_raw, dz_raw)
        detail["now_block_xz_m"] = [now_mm[0], now_mm[1]]
        detail["measure_block_xz_m"] = [mea_mm[0], mea_mm[1]]
        detail["dx_mm"] = round(dx_raw, 2)
        detail["dz_mm"] = round(dz_raw, 2)
        detail["dist_mm"] = round(dist_mm_raw, 2)
    except Exception as e:
        detail["mm_error"] = "{}: {}".format(type(e).__name__, e)

    if dpx > tol_px:
        detail["ok"] = False
        detail["fail_kind"] = "block_moved"
        return False, detail, (
            "ブロックが measure 時から {:.1f}px（≒{:.1f}mm）動いています"
            "（許容 {:.1f}px = {:.1f}mm）。ブロックを戻すか measure を"
            "やり直してください".format(
                dpx, detail.get("dist_mm", float("nan")),
                tol_px, BLOCK_MOVE_TOL_MM_PX_BASIS))

    # codex R8 P4: 画素換算（_mm_tol_to_px）は x 方向と z 方向の厳しい方を採るが、
    # 射影変換では斜め方向がそれより緩くなりうる。**保存した H で換算した実距離**
    # も 5mm 以内であることを必須にする（H は作り直さないので揺れは入らない）。
    if dist_mm_raw is None or not _is_finite_num(dist_mm_raw):
        detail["ok"] = False
        detail["fail_kind"] = "block_move_mm_unknown"
        return False, detail, "ブロックの移動量を mm で計算できませんでした"
    if dist_mm_raw > BLOCK_MOVE_TOL_MM_PX_BASIS:
        detail["ok"] = False
        detail["fail_kind"] = "block_moved"
        return False, detail, (
            "ブロックが measure 時から {:.3f}mm 動いています（許容 {:.1f}mm）。"
            "画素では {:.1f}px で許容内でしたが、斜め方向の換算で超えました".format(
                dist_mm_raw, BLOCK_MOVE_TOL_MM_PX_BASIS, dpx))
    detail["ok"] = True
    return True, detail, None


def _check_block_not_moved(measure_payload, now_res):
    """measure 時と再生直前のブロック位置の差を見る.

    戻り値: (ok, detail dict, reason)。ok=False なら呼び出し側が止める。
    """
    m_block = (measure_payload or {}).get("block_xz_m")
    n_block = now_res.get("block_xz_m")

    def _valid(xz):
        # codex R1 C3: 非有限（NaN / inf）は hypot も NaN になり
        # 「NaN > 5.0 == False」でしきい値をすり抜けるので、ここで弾く。
        return (isinstance(xz, (list, tuple)) and len(xz) == 2
                and _is_finite_num(xz[0]) and _is_finite_num(xz[1]))

    if not _valid(m_block):
        return False, {"tol_mm": BLOCK_MOVE_TOL_MM,
                       "measure_block_xz_m": m_block}, \
            ("measure のブロック位置が無い、または有限な数値でありません（{!r}）。"
             "measure をやり直してください".format(m_block))
    if not _valid(n_block):
        return False, {"tol_mm": BLOCK_MOVE_TOL_MM,
                       "now_block_xz_m": n_block}, \
            ("再生直前のブロック位置が検出できない、または有限な数値でありません（{!r}）。"
             "ブロックが動いていないかを確認できないので止めます".format(n_block))

    dx_mm = (n_block[0] - m_block[0]) * 1000.0
    dz_mm = (n_block[1] - m_block[1]) * 1000.0
    dist_mm = math.hypot(dx_mm, dz_mm)
    detail = {
        "measure_block_xz_m": list(m_block),
        "now_block_xz_m": list(n_block),
        "dx_mm": round(dx_mm, 2),
        "dz_mm": round(dz_mm, 2),
        "dist_mm": round(dist_mm, 2),
        "tol_mm": BLOCK_MOVE_TOL_MM,
    }
    if not math.isfinite(dist_mm):
        # 両座標が有限でも、差の計算で inf が出る極端値を取りこぼさないための保険。
        detail["ok"] = False
        return False, detail, \
            "ブロック位置の差が有限な数値になりません（dx={!r} dz={!r}）".format(dx_mm, dz_mm)
    if dist_mm > BLOCK_MOVE_TOL_MM:
        detail["ok"] = False
        return False, detail, (
            "ブロックが measure 時から {:.1f}mm 動いています（許容 {:.1f}mm・"
            "dx={:+.1f} dz={:+.1f}）。ブロックを戻すか measure をやり直してください".format(
                dist_mm, BLOCK_MOVE_TOL_MM, dx_mm, dz_mm))
    detail["ok"] = True
    return True, detail, None


# ---- 計画表示 ---------------------------------------------------------------
def _plan_summary(seq):
    """単発送信方式の所要時間の見込み.

    各 move 区間は「1 回送信 → 到達確認（最大は区間ごと・本線と同じ算出）」。
    実際の移動時間は速度 20 で max|Δ| に比例するので、
    20°/s を目安にした概算と、到達確認の最大待ちの 2 通りを出す。
    """
    n_moves = 0
    n_grippers = 0
    n_opens = 0
    sum_delta = 0.0
    gripper_sec = 0.0
    for s in seq:
        if s["kind"] == "gripper":
            n_grippers += 1
            if s["action"] == "close":
                # close: daemon 側の事前 sleep は set_gripper_value には無い
                gripper_sec += GRIPPER_DWELL_SEC
            else:
                # open（項目6）: 1 回ごとに daemon 事前 2.0 + 事後相当 2.0 + 待ち 2.0
                n_opens += 1
                gripper_sec += (
                    GRIPPER_OPEN_ATTEMPTS * (DAEMON_SET_GRIPPER_PRE_SLEEP_SEC
                                             + GRIPPER_OPEN_POST_SLEEP_SEC
                                             + GRIPPER_OPEN_DWELL_SEC))
        else:
            n_moves += 1
            sum_delta += float(s["max_delta"])
    # 速度 20 ≒ 20°/s を目安にした移動時間の概算
    move_sec_est = sum_delta / 20.0
    worst_sec = (FIRST_MOVE_SETTLE_SEC + gripper_sec
                 + n_moves * ARRIVAL_TIMEOUT_MIN_SEC)
    total_sec = FIRST_MOVE_SETTLE_SEC + move_sec_est + gripper_sec
    return {
        "n_moves": n_moves,
        "n_grippers": n_grippers,
        "n_opens": n_opens,
        "gripper_open_sends": n_opens * GRIPPER_OPEN_ATTEMPTS,
        "sum_max_delta_deg": round(sum_delta, 2),
        "move_sec_est": round(move_sec_est, 1),
        "gripper_sec": round(gripper_sec, 1),
        "estimated_sec": round(total_sec, 1),
        "worst_case_sec": round(worst_sec, 1),
    }


def _print_plan(current, seq):
    """Pi 版 WPSR の _print_plan と同じ書式で出す（段階A で並べて比べられるように）.

    違いは送信口が daemon_* になる点だけ。姿勢・区間・tick 数は同じになるはず。
    """
    print("=" * 78)
    print("{} 実行プラン（daemon 経由・区間ごとに 1 回送信 → 到達待ち）".format(
        LOG_PREFIX))
    print("=" * 78)

    if current is not None:
        max_d0, _ = wr._max_axis_diff(HOME_ANGLES, current)
        print("  [STEP  1] MOVE → HOME (single send + settle)  speed={}".format(SPEED_FIRST))
        print("            current = {}".format(_fmt_angles(current)))
        print("            to HOME = {}".format(_fmt_angles(HOME_ANGLES)))
        print("            max |Δ| = {:.2f}°  (settle {:.1f}s)".format(
            max_d0, FIRST_MOVE_SETTLE_SEC))
    else:
        print("  [STEP  1] MOVE → HOME (single send + settle)  speed={}".format(SPEED_FIRST))
        print("            current = 未取得（ドライラン・daemon に接続していない）")
        print("            to HOME = {}".format(_fmt_angles(HOME_ANGLES)))

    step_no = 2
    for s in seq:
        if s["kind"] == "gripper":
            if s["action"] == "close":
                cmd_str = "daemon_set_gripper_value({}, {})".format(GRIP_VALUE, GRIPPER_SPEED)
                print("  [STEP {:>2}] GRIPPER {}  {} + sleep({:.1f}s)".format(
                    step_no, s["action"].upper(), cmd_str, GRIPPER_DWELL_SEC))
            else:
                cmd_str = "daemon_set_gripper(0, {}, wait=0)".format(GRIPPER_SPEED)
                # 本線 run_pick_place.py の _do_gripper("open") と同じ待ち方（項目6）
                print("  [STEP {:>2}] GRIPPER {}  {} ×{} 回"
                      "（daemon 事前 {:.1f}s + 事後 {:.1f}s + 待ち {:.1f}s）"
                      "= 計 {:.1f}s".format(
                          step_no, s["action"].upper(), cmd_str,
                          GRIPPER_OPEN_ATTEMPTS,
                          DAEMON_SET_GRIPPER_PRE_SLEEP_SEC,
                          GRIPPER_OPEN_POST_SLEEP_SEC, GRIPPER_OPEN_DWELL_SEC,
                          GRIPPER_OPEN_ATTEMPTS
                          * (DAEMON_SET_GRIPPER_PRE_SLEEP_SEC
                             + GRIPPER_OPEN_POST_SLEEP_SEC
                             + GRIPPER_OPEN_DWELL_SEC)))
                print("            開いたかは確認しません"
                      "（gv を使わず・開始前の y/n も無し。判定は終了後の y/n と動画）")
        else:
            _tol, _src = _arrival_tol_for(s["to_name"])
            print("  [STEP {:>2}] MOVE → {}  segment {} → {}{}  "
                  "tol={}{}".format(
                      step_no, s["to_name"], s["from_name"], s["to_name"],
                      "  [critical]" if s.get("critical") else "",
                      ("{:.1f}°".format(_tol) if _tol is not None
                       else "**未定義（実機では ABORT）**"),
                      ("  [rpp.{}]".format(_src) if _src else "")))
            print("            from    = {}".format(_fmt_angles(s["from"])))
            print("            to      = {}".format(_fmt_angles(s["to"])))
            print("            max |Δ| = {:.2f}°  1 回送信 speed={}  "
                  "(~ {:.1f}s @ 20°/s 目安・到達待ち 最大 {:.1f}s)".format(
                      s["max_delta"], SPEED_SINGLE,
                      float(s["max_delta"]) / 20.0,
                      _arrival_timeout_for(s["max_delta"])))
        step_no += 1

    summary = _plan_summary(seq)
    print("=" * 78)
    print("{} 送信 = {} 回（STEP 1 + move {} 区間）, "
          "想定所要時間 ≈ {:.1f}s（最悪 {:.1f}s）".format(
              LOG_PREFIX, summary["n_moves"] + 1, summary["n_moves"],
              summary["estimated_sec"], summary["worst_case_sec"]))
    print("{}   内訳: 先頭 settle {:.1f}s + 移動 {:.1f}s（max|Δ| 合計 {:.1f}° @ 20°/s 目安）"
          " + gripper {:.1f}s".format(
              LOG_PREFIX, FIRST_MOVE_SETTLE_SEC, summary["move_sec_est"],
              summary["sum_max_delta_deg"], summary["gripper_sec"]))
    print("{}   到達確認: 許容は区間ごと（本線 run_pick_place.py の stage 値）/ "
          "最大は clamp(2.0 + max|Δ|/20*3.0, {:.1f}, 30.0) 秒"
          .format(LOG_PREFIX, ARRIVAL_TIMEOUT_MIN_SEC))
    print("{}   届かないとき: 送信前から {:.1f}° 未満しか動いていなければ "
          "{:.1f}s 待って**同じ目標へ 1 回だけ**再送（本線と同じ）。"
          "それでも届かなければ ABORT（HOME へ自動で戻らない）"
          .format(LOG_PREFIX, RETRY_NO_MOVE_THRESHOLD_DEG, RETRY_PAUSE_SEC))
    print("{}   実測 j4: [{:+.1f}, {:+.1f}] の外は WARN / "
          "[{:+.1f}, {:+.1f}] の外は ABORT".format(
              LOG_PREFIX, J4_SAFE_MIN, J4_SAFE_MAX, J4_HARD_MIN, J4_HARD_MAX))
    print("=" * 78)
    return summary


# ---- recorder 通知 ----------------------------------------------------------
class _Recorder(object):
    """recorder.py への fire-and-forget 通知. --no-record なら何も送らない."""

    def __init__(self, enabled, run_stem):
        self.enabled = bool(enabled)
        self.run_stem = run_stem
        self.actual_sent = 0
        self.send_failures = 0
        self.last_send_error = None
        self.currents = None   # 依頼 121: policy_recorder.CurrentsRecorder（記録するときだけ）
        # 依頼 202: 電流の記録スレッドが読んだ角度も actual 行にする。states.csv の行が時刻順に並ぶよう、
        # start_current_actuals() から close_current_actuals() までは stage / actual / gripper_cmd の通知を
        # 鍵の中で 1 本の列に積み（鍵の中では送らない）、送り手のスレッドが積んだ順に送る
        # （codex R1 必須: 送信が遅れても本体と電流の記録スレッドは待たない）。
        self._state_lock = threading.Lock()
        self._state_cv = threading.Condition(self._state_lock)
        self._last_state_ts = None
        self._queue = None                        # 積んだ通知（列を使っている間だけ list）
        self._sender = None
        self._sender_stop = False
        self._current_actuals_open = False        # start_current_actuals() で開き、trial_end の前に閉じる
        self.actual_sent_current_thread = 0       # 電流の記録スレッドの角度で積んだ actual 行
        self.actual_current_thread_late = 0       # 先に積んだ行より前の時刻だったので積まなかった数
        self.actual_current_thread_errors = 0     # 角度・時刻が数にならず積まなかった数
        self.state_ts_backwards = 0               # 本体の行の時刻が前の行より前だった数（時計が戻ったとき. codex R2）
        self.current_actuals_unsent = 0           # close の期限の時点でまだ送り終えていなかった通知の数（途中の 1 件を含む）
        self.current_actuals_flush_timeout = False
        self.state_rows_sent_by_sender = 0        # 送り手のスレッドが送り終えた通知の数（試行 JSON は trial_end の直後の値）
        self.trial_end_via_sender = False         # 送り手が止まっていたので trial_end も列の最後に積んだ
        self._inflight = 0                        # 送り手が送っている途中の通知の数（0 か 1）
        self._sender_exited = False               # 送り手が列を空にして終わった（鍵の中で立てる）

    def start_current_actuals(self):
        """依頼 202: 電流の記録スレッドの角度を受け付け、通知を送り手のスレッドから送る形にする."""
        with self._state_lock:
            if self._sender is not None:
                return
            self._queue = []
            self._sender_stop = False
            self._sender_exited = False
            self._current_actuals_open = True
            self._sender = threading.Thread(target=self._send_loop, args=(self._queue,), daemon=True,
                                            name="record_state_sender")
        self._sender.start()

    def _send_loop(self, q):
        """積んだ通知を 1 件ずつ取り出して送る（close の期限を過ぎても捨てずに、trial_end まで積んだ順に送り切る）."""
        while True:
            with self._state_cv:
                while not q and not self._sender_stop:
                    self._state_cv.wait()
                if not q:
                    self._sender_exited = True
                    return
                p = q.pop(0)
                self._inflight = 1
            self._send(p)        # 鍵の外で送る（_send は例外を外へ出さない）
            with self._state_cv:
                self._inflight = 0
                self.state_rows_sent_by_sender += 1

    def _send_state(self, payload, state_row=True):
        """依頼 202: states.csv の行になる通知（stage / actual / gripper_cmd）.

        ts が無ければ鍵の中で今の時刻を入れる（rpp.recorder_notify が入れるのと同じ時刻）。
        列を使っている間は鍵の中で積むだけ（recorder.py は届いた順に書くので、積んだ順 = states.csv の順）。
        列を使っていなければ今までどおりその場で送る。
        """
        with self._state_cv:
            if state_row:
                if "ts" not in payload:
                    payload = dict(payload)
                    payload["ts"] = time.time()
                ts = float(payload["ts"])
                if self._last_state_ts is not None and ts < self._last_state_ts:
                    self.state_ts_backwards += 1      # 直さずに数えるだけ（codex R2）
                else:
                    self._last_state_ts = ts
            if self._queue is not None and not self._sender_exited:
                self._queue.append(payload)
                if not state_row:
                    self.trial_end_via_sender = True
                self._state_cv.notify()
                return
        self._send(payload)

    def _send(self, payload):
        """通知は fire-and-forget。**例外を外に出さない**（codex U1）.

        2026-10-19 方針変更: 止めるのは「送り直しても全く動かない」ときだけ。
        recorder への通知（stage / actual / gripper_cmd / trial_start / trial_end）
        が失敗しても再生を止めない。回数と最後のエラーを数えて試行 JSON に残す。
        KeyboardInterrupt / SystemExit は握らない（人の中断はそのまま通す）。
        """
        if not self.enabled:
            return
        try:
            rpp.recorder_notify(payload)
        except (KeyboardInterrupt, SystemExit):
            raise
        except BaseException as e:
            self.send_failures += 1
            self.last_send_error = "{}: {}".format(type(e).__name__, e)
            if self.send_failures <= NONFINITE_WARN_MAX:
                _warn("recorder への通知で例外（記録のみ・再生は続けます）: {}{}"
                      .format(self.last_send_error,
                              "（以降この警告は出しません）"
                              if self.send_failures == NONFINITE_WARN_MAX else ""))

    def trial_start(self):
        self._send({"type": "trial_start", "run_stem": self.run_stem})

    def trial_end(self):
        # 依頼 202: 送り手がまだ送り終えていなければ（close の期限切れ）、trial_end も列の最後に積む。
        # 送り手が積んだ順に送るので、states.csv の行が trial_end を追い越さない（本体は待たない）。
        self._send_state({"type": "trial_end", "run_stem": self.run_stem}, state_row=False)

    def stage(self, name):
        self._send_state({"type": "stage", "stage": name})

    def gripper_cmd(self, state, note, ts=None):
        """build_demo_episodes.py は gripper_cmd の gripper_state を 0/1 で読む.

        ts を渡すとその時刻で記録される（A4-2: 指令が daemon から戻った時刻）。
        open を 2 回送る場合も **1 回目が戻った時刻**で固定する
        （gv を使わないので「どちらの回で実際に開いたか」は記録に無い。
        codex R10 S3 / R10b T3: 1 回目が無視されて 2 回目で開いた試行では、
        ラベルの時刻が「daemon の事前 sleep 2.0 + 事後相当 2.0 + 待ち 2.0
        ≒ 6 秒 + 通信時間」ぶん早くなりうる。動画と attempt_log で確かめる）。
        省略時は rpp.recorder_notify が送信時刻を入れる。
        """
        payload = {"type": "gripper_cmd", "state": int(state), "note": str(note)}
        if ts is not None:
            payload["ts"] = float(ts)
        self._send_state(payload)

    def currents_window(self, sec):
        """依頼 121: これから sec 秒 daemon を使わない（眠る）と電流の記録に知らせる."""
        if self.currents is None:
            return
        try:
            self.currents.window(sec)
        except Exception:
            pass

    def pause_currents(self):
        """依頼 121: 爪の命令を送る前に電流の読み取りを止める（読んでいる途中ならその 1 回を待つ）.

        「爪を動かした直後にシリアルを触らない」（2026-10-19）を電流の記録でも守る。
        記録の失敗で再生を止めない（例外は外へ出さない）。
        """
        if self.currents is None:
            return
        try:
            self.currents.pause()
        except Exception as e:
            _warn("電流の記録を止められませんでした（再生は続けます）: {}: {}".format(
                type(e).__name__, e))

    def resume_currents(self):
        """依頼 121: 爪の待ちが終わったら電流の読み取りを再開する."""
        if self.currents is None:
            return
        try:
            self.currents.resume()
        except Exception as e:
            _warn("電流の記録を再開できませんでした（再生は続けます）: {}: {}".format(
                type(e).__name__, e))

    def actual(self, angles):
        self._send_state({"type": "actual",
                          "angles": [float(x) for x in angles]})
        self.actual_sent += 1

    def actual_from_currents(self, angles, ts):
        """依頼 202: 電流の記録スレッド（read_servo）が読んだ角度を actual 行として送る.

        時刻 ts は角度を読んだ時刻（currents.csv の ts と同じ）。本体の読み（到達・静止の確かめなど。
        note は空のまま）と区別するため note に CURRENT_THREAD_NOTE を入れる。
        先に積んだ行（本体の actual・stage・gripper_cmd）より前の時刻なら積まずに数える
        （states.csv の行を時刻順に保つため。電流スレッドは本体が眠っている間だけ読むので、ふつうは起きない）。
        電流スレッドから呼ばれる。鍵の中では積むだけで送らない（送るのは送り手のスレッド）。例外は外へ出さない。
        start_current_actuals() の前と close_current_actuals() のあとは何もしない。
        """
        try:
            vals = [float(x) for x in angles]
            ts = float(ts)
            if len(vals) != 6 or not all(math.isfinite(v) for v in vals) or not math.isfinite(ts):
                raise ValueError("bad angles")
            with self._state_cv:
                if not self._current_actuals_open or self._queue is None:
                    return
                if self._last_state_ts is not None and ts < self._last_state_ts:
                    self.actual_current_thread_late += 1
                    return
                self._queue.append({"type": "actual", "angles": vals, "ts": ts,
                                    "note": CURRENT_THREAD_NOTE})
                self._last_state_ts = ts
                self.actual_sent_current_thread += 1
                self._state_cv.notify()
        except Exception:
            self.actual_current_thread_errors += 1   # 壊れた値は積まずに数える

    def close_current_actuals(self, timeout=None):
        """依頼 202: 電流の記録スレッドの角度を受け付けるのをやめ、積んだ通知を送り切る（trial_end の前に呼ぶ）.

        送り手のスレッドを待つのは timeout 秒（既定 CURRENT_ACTUALS_FLUSH_SEC）まで。送り切れたら、このあとの
        通知は今までどおりその場で送る。送り切れなければ、まだの数を current_actuals_unsent に残し、
        積んだ分とこのあとの通知（trial_end）は送り手が順に送る（本体は待たない。追い越さない）。
        """
        timeout = CURRENT_ACTUALS_FLUSH_SEC if timeout is None else timeout
        with self._state_cv:
            self._current_actuals_open = False
            sender = self._sender
            if sender is None:
                return
            self._sender_stop = True
            self._state_cv.notify()
        sender.join(timeout=timeout)
        with self._state_cv:
            if not self._sender_exited:
                # 期限切れ: 積んだ分は捨てずに送り手に任せる（このあとの trial_end も列の最後に積む）
                self.current_actuals_flush_timeout = True
                self.current_actuals_unsent = len(self._queue or []) + self._inflight
            else:
                self._queue = None


_STAGE_SAFE_RE = re.compile(r"[^A-Z0-9]+")


def _stage_name(to_name):
    """'APPROACH_PICK (lift)' → 'APPROACH_PICK_LIFT'（states.csv の stage 列用）."""
    return _STAGE_SAFE_RE.sub("_", to_name.upper()).strip("_")


_ACTIVE_CURRENTS = []   # 依頼 121: 始めた電流の記録（cmd_run の最後に必ず止める）


def _sleep_open(recorder, sec):
    """time.sleep(sec) と同じ（**待つ長さは変えない**）。依頼 121: 眠る前に、この間は daemon を
    使わないと電流の記録に知らせる。電流はこの間だけ読むので、本体の daemon とのやりとりは
    電流の記録を待たない（到達・静止の確かめの回数と時刻が変わらない。codex R1・R2 必須）。
    """
    recorder.currents_window(sec)
    time.sleep(sec)


def _halt_currents():
    """依頼 121: 始めた電流の記録をすべて止める（socket を閉じる前に呼ぶ）.

    stop() が途中で中断されていても、止める印を立ててスレッドの終わりを待つ。
    1 本あたり待つのは最大 STOP_JOIN_SEC + READ_SERVO_TIMEOUT_SEC。待っている間の Ctrl-C は
    1 回だけ受け流してもう一度同じだけ待つ（2 回目の Ctrl-C はそのまま通す）。
    スレッドが終わったと分かるまで _ACTIVE_CURRENTS から外さない（codex R2 推奨）。
    """
    for cur in list(_ACTIVE_CURRENTS):
        cur.stop_flag = True
        bound = _prec.STOP_JOIN_SEC + _prec.READ_SERVO_TIMEOUT_SEC
        try:
            cur.t.join(timeout=bound)
        except KeyboardInterrupt:
            _warn("電流の記録スレッドの終わりを待っています（もう一度 Ctrl-C で待たずに進みます）")
            cur.t.join(timeout=bound)
        try:
            if getattr(cur, "meta", None) is None:
                cur.stop()
        except Exception as e:
            _warn("電流の記録を閉じるときに例外（続行）: {}: {}".format(type(e).__name__, e))
        if cur.t.is_alive():
            _warn("電流の記録スレッドが止まりません（socket を閉じて終えます）")
        else:
            _ACTIVE_CURRENTS.remove(cur)


def _start_currents(run_dir, power=None, angle_sink=None):
    """依頼 121: 爪と肩の電流の記録スレッドを始める（失敗しても再生は止めない → None）.

    読み方・列・頻度は実機推論の記録（依頼 116）と同じ部品（policy_recorder.CurrentsRecorder）。
    daemon のソケットを本体と共用するので、先に install_daemon_lock() で
    1 回のやりとりごとに鍵をかける（送る中身・タイムアウトは変えない）。
    states.csv（recorder.py が書く）の列と行は変えない。
    依頼 156: power（省略時は cmd_run が --power から入れた POWER。2A など）があれば、爪の位置と電圧の番地も読む
    （policy_recorder.PowerRegsRecorder → recording/power_regs.csv。読み始めてよい時の決め方は同じ）。
    依頼 202: angle_sink（_Recorder.actual_from_currents）を渡すと、read_servo で読めた角度を
    states.csv の actual 行（note = CURRENT_THREAD_NOTE）にも送る。読む命令・読む時機は変えない。
    """
    power = POWER if power is None else power
    try:
        _prec.install_daemon_lock()
        cls = _prec.PowerRegsRecorder if power else _prec.CurrentsRecorder
        cur = cls(run_dir, _prec.daemon_read_servo)
        cur.angle_sink = angle_sink
        _ACTIVE_CURRENTS.append(cur)
        cur.start()
    except Exception as e:
        _warn("電流の記録を始められませんでした（再生と映像の記録はそのまま続けます）: "
              "{}: {}".format(type(e).__name__, e))
        return None
    _log("爪と肩の電流を 1 秒 {:.0f} 回で記録します（爪を動かしている間は読みません）→ {}".format(
        _prec.RECORD_FPS, cur.dir / "currents.csv"))
    if power:
        _log("電源 {}: 爪の位置（番地 7:56/57）と電圧（2:62・7:62）も読みます（生の値・未確認の番地）→ {}".format(
            power, cur.dir / "power_regs.csv"))
    return cur


# ---- 実測角の読み取り --------------------------------------------------------
class _ActualSampler(object):
    """実測 6 軸を読んで recorder へ流す. 制御判断には使わない（観測）."""

    def __init__(self, recorder):
        self.recorder = recorder
        self.attempted = 0
        self.ok = 0
        self.last = None
        self.t_first = None
        self.t_last = None
        # codex R1 C1 / C2: 観測の異常は制御を止めずに数えて試行 JSON に残す
        self.attempted_once = 0   # 記録用（get_angles_once）の試行数
        self.ok_once = 0          # 同・成功数（1 回で読める率の実測）
        self.nonfinite_reads = 0
        self.j4_out_of_range = []        # 値のサンプル（上限あり）
        self.j4_out_of_range_count = 0    # 総数
        self.j4_hard_violation = None

    def read(self, once=True, timeout_override=None):
        """1 回読む. 成功時 6 要素 list、失敗時 None.

        once=True（既定・**記録用**）: daemon cmd `get_angles_once` を使う。
          daemon 側でリトライしないので、読めないときも最悪 1 回分で返る。
          既存 get_angles は 12 回リトライ（最悪 ≈3.7s）で、0.1s 周期の
          ストリーミング中に使うと送信まで止まる（2026-10-19 実測）。
        once=False（**区間終端の到達確認**）: 既存 get_angles（リトライ有り）を使う。
          アームが止まりかけているので読めるはずで、確実に読めた方が良い。

        codex R1 C1: 非有限値（NaN / inf）が 1 つでも混じる読み取りは **失敗扱い**。
        NaN は比較が全部 False になるため、そのまま到達判定に渡すと
        未到達を「到達」と誤判定する（max() が NaN を飛ばして 0.0 を返す）。
        """
        self.attempted += 1
        if once:
            self.attempted_once += 1
        try:
            if once and USE_FAST_DAEMON_CMDS:
                _to = (DAEMON_GET_ONCE_TIMEOUT_SEC if timeout_override is None
                       else min(DAEMON_GET_ONCE_TIMEOUT_SEC,
                                float(timeout_override)))
                a = daemon_get_angles_once(timeout_override=_to)
            else:
                # codex U2: 呼び出し側が残り時間を渡したら、それ以上は待たない
                _to = (DAEMON_GET_TIMEOUT_SEC if timeout_override is None
                       else min(DAEMON_GET_TIMEOUT_SEC, float(timeout_override)))
                a = daemon_get_angles(timeout_override=_to)
        except Exception as e:
            _warn("角度読み取りで例外（観測のみ・制御は続行）: {}: {}".format(
                type(e).__name__, e))
            return None
        if not _is_valid_angles(a):
            if a is not None and not _is_finite_6(a):
                self.nonfinite_reads += 1
                # 到達確認のポーリング中に連発するとログが埋まるので回数を絞る
                # （総数は actual_sampling.nonfinite_reads に必ず残る）。
                if self.nonfinite_reads <= NONFINITE_WARN_MAX:
                    _warn("実測角に有限でない値が入っていたので、この読み取りは失敗扱いに"
                          "します（到達とみなしません）: {!r}{}".format(
                              a, "（以降この警告は出しません）"
                                 if self.nonfinite_reads == NONFINITE_WARN_MAX else ""))
            return None
        vals = [float(x) for x in a]
        self.ok += 1
        if once:
            self.ok_once += 1
        self.last = vals
        # 実測 j4 が安全範囲外に読めても ABORT はしない。
        # 2026-10-19（方針変更・項目3）: **ハード帯（±98 / +68）も WARN だけ**にした。
        # 止めるのは「送り直しても全く動かない」ときだけという方針に合わせる。
        # 逸脱は数えて試行 JSON に残す（j4_hard_violation / j4_out_of_range）。
        j4 = vals[4]
        if j4 < J4_HARD_MIN or j4 > J4_HARD_MAX:
            if self.j4_hard_violation is None:
                self.j4_hard_violation = round(j4, 3)
                _warn("実測 j4 = {:+.2f} が [{:+.1f}, {:+.1f}] の外です。"
                      "**止めません**（WARN のみ・試行 JSON に残します）"
                      "（実測角 = {}）".format(
                          j4, J4_HARD_MIN, J4_HARD_MAX, _fmt_angles(vals)))
            self.j4_hard_violation_count = getattr(
                self, "j4_hard_violation_count", 0) + 1
        if j4 < J4_SAFE_MIN or j4 > J4_SAFE_MAX:
            self.j4_out_of_range_count += 1
            if len(self.j4_out_of_range) < J4_SAMPLE_MAX:
                self.j4_out_of_range.append(round(j4, 3))
            if self.j4_out_of_range_count <= NONFINITE_WARN_MAX:
                _warn("実測 j4 = {:+.2f} が J4_SAFE [{:+.1f}, {:+.1f}] の外です"
                      "（記録のみ・送信は止めません）{}".format(
                          j4, J4_SAFE_MIN, J4_SAFE_MAX,
                          "（以降この警告は出しません）"
                          if self.j4_out_of_range_count == NONFINITE_WARN_MAX else ""))
        now = time.time()
        if self.t_first is None:
            self.t_first = now
        self.t_last = now
        self.recorder.actual(vals)
        return vals

    def sleep_with_reads(self, duration_sec):
        """duration_sec 待つ間も実測角を読む.

        **実際に time.sleep した合計が duration_sec を下回らない**ように数える
        （codex R1 A7/D7）。読み取りにかかった時間は差し引かず、待ち時間の上に乗る。
        壁時計の経過が duration_sec より長くなるのは可（規約「time.sleep を
        削除・短縮しない」に合わせるため、短くなる方向だけを禁じる）。

        settle / gripper dwell の間にも state を残すため、爪の開閉前後が
        学習データで欠けないようにする。
        """
        if duration_sec <= 0:
            return
        remaining_sleep = float(duration_sec)
        # 読み取り周期の管理だけ monotonic を使う（時計の巻き戻しに影響されないため）。
        next_read_at = time.monotonic()
        while remaining_sleep > 0:
            if time.monotonic() >= next_read_at:
                self.read()   # ここでかかった時間は remaining_sleep から引かない
                next_read_at = time.monotonic() + (1.0 / ACTUAL_READ_TARGET_HZ)
                continue
            slice_sec = min(SLEEP_SLICE_SEC, remaining_sleep)
            # 依頼 121: 次に読むまで（か待ちの終わりまで）daemon を使わないと電流の記録に知らせる
            self.recorder.currents_window(
                min(remaining_sleep, max(0.0, next_read_at - time.monotonic())))
            time.sleep(slice_sec)
            remaining_sleep -= slice_sec

    def summary(self, motion_elapsed_sec):
        span = None
        if self.t_first is not None and self.t_last is not None:
            span = self.t_last - self.t_first
        hz = (self.ok / span) if (span and span > 0) else None
        return {
            "reads_attempted": self.attempted,
            "reads_ok": self.ok,
            "read_span_sec": (round(span, 3) if span is not None else None),
            "hz": (round(hz, 3) if hz is not None else None),
            "target_hz": ACTUAL_READ_TARGET_HZ,
            "read_every_n_ticks": ACTUAL_READ_EVERY_N_TICKS,
            "read_timeout_sec": DAEMON_GET_TIMEOUT_SEC,
            # LOG352: 記録用の読み取り（get_angles_once）の実測
            "once_cmd_used": bool(USE_FAST_DAEMON_CMDS),
            "reads_once_attempted": self.attempted_once,
            "reads_once_ok": self.ok_once,
            "reads_once_hit_rate": (round(self.ok_once / self.attempted_once, 3)
                                    if self.attempted_once else None),
            "motion_elapsed_sec": round(motion_elapsed_sec, 3),
            # codex R1 C1: 非有限値で失敗扱いにした読み取り回数
            "nonfinite_reads": self.nonfinite_reads,
            # codex R1 C2: 実測 j4 が J4_SAFE 外に読めた値（ABORT はしない・記録のみ）
            "j4_out_of_range_count": self.j4_out_of_range_count,
            "j4_out_of_range_values": self.j4_out_of_range[:20],
            # 実測 j4 の扱い（エイイチ判断）: J4_SAFE 外は WARN、
            # J4_SAFE ± J4_HARD_MARGIN_DEG の外は ABORT
            "j4_warn_band": [J4_SAFE_MIN, J4_SAFE_MAX],
            "j4_abort_band": [J4_HARD_MIN, J4_HARD_MAX],
            "j4_hard_violation": self.j4_hard_violation,
        }


# ---- 所要時間の統計（A4-3）--------------------------------------------------
def _stats(values, label):
    """秒のリストから n / mean / max / p50 / p99 を出す.

    A4-3（エイイチ判断 2026-10-19）: Pi の daemon は send_angles のたびに
    角度を読み直すので、0.1s 周期が守れず Pi 直より遅くなる可能性がある。
    それを数字で見るために、1 tick の send_angles 往復時間と tick 全体の周期を
    別々に残す。p99 は nearest-rank（並べて ceil(0.99*n) 番目）。
    """
    # codex R3 G2: 失敗 tick は None が入る。統計は成功分だけで出す
    # （失敗は timeout 上限に張り付くので混ぜると平均が歪む）。
    vals = [v for v in (values or []) if _is_finite_num(v)]
    if not vals:
        return {"label": label, "n": 0, "n_missing": len(values or []),
                "mean_sec": None, "max_sec": None,
                "p50_sec": None, "p99_sec": None}
    vs = sorted(float(v) for v in vals)
    n = len(vs)

    def _pick(q):
        idx = int(math.ceil(q * n)) - 1
        return vs[max(0, min(n - 1, idx))]

    return {
        "label": label,
        "n": n,
        "n_missing": len(values or []) - n,
        "mean_sec": round(sum(vs) / n, 4),
        "max_sec": round(vs[-1], 4),
        "p50_sec": round(_pick(0.50), 4),
        "p99_sec": round(_pick(0.99), 4),
    }


# ---- 到達確認 ---------------------------------------------------------------
def _hold_until_arrival(target, label, sampler, tol_deg, timeout_sec):
    """target を最後に送ったあと tol_deg 内に入るまでポーリングする.

    2026-10-19（項目1）: 許容差とタイムアウトを **区間ごとに引数で受ける**。
    許容差は本線 run_pick_place.py の stage 値、タイムアウトは本線と同じ
    wr._compute_arrival_timeout の算出。ポーリング間隔は jss.POLL_SLEEP = 0.3。
    読んだ実測角は recorder にも流す（sampler 経由）。
    戻り値: (arrived, last_max_d, last_actual)
    """
    t0 = time.time()
    last_max = None
    last_actual = None
    while time.time() - t0 < timeout_sec:
        # 到達確認はリトライ有りの既存 get_angles を使う（once=False）。
        # アームが止まりかけなので読めるはずで、確実に読めた方が良い。
        actual = sampler.read(once=False)   # 非有限を含む読み取りは None（C1）
        if actual is None:
            _sleep_open(sampler.recorder, ARRIVAL_POLL_SLEEP)
            continue
        last_actual = actual
        # codex R1 C1: wr._max_axis_diff は NaN を飛ばして偽の 0.0 を返しうるので
        # 有限値を保証する版を使う。None（計算不能）は「到達とみなさない」。
        max_d = _max_axis_diff_finite(actual, target)
        if max_d is None:
            _warn("到達差を有限な数値として計算できませんでした（到達とみなしません）: "
                  "actual={!r} target={!r}".format(actual, target))
            _sleep_open(sampler.recorder, ARRIVAL_POLL_SLEEP)
            continue
        last_max = max_d
        if max_d <= tol_deg:
            _log("arrival OK ({}, max|Δ|={:.2f}° <= tol {:.1f}°)".format(
                label, max_d, tol_deg))
            return True, max_d, last_actual
        _sleep_open(sampler.recorder, ARRIVAL_POLL_SLEEP)
    _warn("arrival timeout ({}, max|Δ|={}° > tol {:.1f}°, {:.1f}s)".format(
        label,
        ("{:.2f}".format(last_max) if last_max is not None else "None"),
        tol_deg, timeout_sec))
    return False, last_max, last_actual


def _wait_until_still(sampler, target, tol_deg, label):
    """爪を動かす前に、アームが止まっていることを確認する（codex R11 A1）.

    成立条件（両方）:
      (a) target から tol_deg 内にいる（target が None なら (a) は省略）
      (b) 連続する実測の差が GRIPPER_STILL_TOL_DEG 以下

    これを GRIPPER_STILL_READS 回続けて満たしたら True。
    読めない回・有限でない回はカウントをリセットする（成立とみなさない）。
    期限（GRIPPER_STILL_TIMEOUT_SEC）内に満たせなければ False。
    **この関数はアームへ何も送らない**（読み取りだけ）。
    戻り値: (still, detail dict)
    """
    # codex R11b T3: 期限は monotonic で見て、**読み取りの後にも**確認する
    # （読み取り自体に時間がかかるので、前だけ見ると期限を超えて成功しうる）。
    t0 = time.monotonic()
    prev = None
    run = 0
    reads = 0
    reads_ok = 0
    worst_step = None      # 連続差の最大（記録用）
    last_to_target = None
    timed_out = False
    while True:
        if time.monotonic() - t0 >= GRIPPER_STILL_TIMEOUT_SEC:
            timed_out = True
            break
        # codex U2: 読み取りにも残り時間を渡して、8 秒を本当の上限にする
        remaining = GRIPPER_STILL_TIMEOUT_SEC - (time.monotonic() - t0)
        if remaining <= 0.05:
            timed_out = True
            break
        reads += 1
        actual = sampler.read(once=False, timeout_override=remaining)
        if time.monotonic() - t0 >= GRIPPER_STILL_TIMEOUT_SEC:
            # 読み取り中に期限を超えた。この回の値では成立させない
            timed_out = True
            break
        if actual is None:
            prev = None
            run = 0
            _sleep_open(sampler.recorder, ARRIVAL_POLL_SLEEP)
            continue
        reads_ok += 1
        # 項目2: target が None なら「止まっているか」だけを見る
        ok_target = True
        if target is not None and tol_deg is not None:
            d = _max_axis_diff_finite(actual, target)
            last_to_target = d
            ok_target = (d is not None and d <= tol_deg)
        step = _max_axis_diff_finite(actual, prev) if prev is not None else None
        if step is not None and (worst_step is None or step > worst_step):
            worst_step = step
        ok_still = (step is not None and step <= GRIPPER_STILL_TOL_DEG)
        prev = actual
        if ok_target and ok_still:
            run += 1
            if run >= GRIPPER_STILL_READS:
                detail = {
                    "still": True, "reads": reads, "reads_ok": reads_ok,
                    "consecutive_ok": run,
                    "elapsed_sec": round(time.monotonic() - t0, 3),
                    "max_step_deg": (round(worst_step, 3)
                                     if worst_step is not None else None),
                    "to_target_deg": (round(last_to_target, 3)
                                      if last_to_target is not None else None),
                    "tol_deg": tol_deg,
                    "still_tol_deg": GRIPPER_STILL_TOL_DEG,
                    "required_reads": GRIPPER_STILL_READS,
                }
                _log("静止確認 OK（{}: 連続 {} 回・連続差 最大 {}° <= {:.1f}°"
                     "）".format(
                         label, run,
                         ("{:.2f}".format(worst_step)
                          if worst_step is not None else "None"),
                         GRIPPER_STILL_TOL_DEG))
                return True, detail
        else:
            run = 0
        # 残り時間を超えて眠らない（8 秒を本当の上限にする）
        _left = GRIPPER_STILL_TIMEOUT_SEC - (time.monotonic() - t0)
        if _left <= 0:
            timed_out = True
            break
        _sleep_open(sampler.recorder, min(ARRIVAL_POLL_SLEEP, _left))

    detail = {
        "still": False, "reads": reads, "reads_ok": reads_ok,
        "consecutive_ok": run,
        "timed_out": bool(timed_out),
        "elapsed_sec": round(time.monotonic() - t0, 3),
        "max_step_deg": (round(worst_step, 3) if worst_step is not None else None),
        "to_target_deg": (round(last_to_target, 3)
                          if last_to_target is not None else None),
        "tol_deg": tol_deg,
        "still_tol_deg": GRIPPER_STILL_TOL_DEG,
        "required_reads": GRIPPER_STILL_READS,
        "timeout_sec": GRIPPER_STILL_TIMEOUT_SEC,
    }
    return False, detail


# ---- 再生本体 ---------------------------------------------------------------
class _Aborted(Exception):
    def __init__(self, stage, reason):
        Exception.__init__(self, "{}: {}".format(stage, reason))
        self.stage = stage
        self.reason = reason


# ---- LOG352: daemon の新 cmd のラッパ ---------------------------------------
def daemon_send_angles_fast(angles, speed, timeout_override=None):
    """送信後に角度を読み直さない send_angles（daemon cmd: send_angles_fast）.

    visual_servo_pick._daemon_request を借りるので、既存ヘルパと同じ 1 本の
    TCP 接続を共有する（socket を二重に張らない）。
    """
    return _daemon_request({
        "cmd": "send_angles_fast",
        "angles": list(angles),
        "speed": int(speed),
    }, timeout_override=timeout_override)


def daemon_get_angles_once(timeout_override=DAEMON_GET_ONCE_TIMEOUT_SEC):
    """1 回だけ角度を読む（daemon cmd: get_angles_once）. 読めなければ None.

    daemon 側はリトライしないので、最悪でも _mc.get_angles() 1 回分で返る。
    「読めない」は異常ではないので daemon は ok=True / angles=None を返す。
    """
    try:
        resp = _daemon_request({"cmd": "get_angles_once"},
                               timeout_override=timeout_override)
    except RuntimeError as e:
        print("  [WARN] daemon_get_angles_once failed: {}".format(e))
        return None
    a = resp.get("angles")
    if not a or len(a) != 6:
        return None
    return a


def _require_fast_cmds():
    """Pi の daemon が新 cmd を持っているかを、アームを動かさずに確かめる.

    send_angles_fast には **わざと長さ不正の angles** を渡す。
    新 daemon は "angles must be length 6" を返し（_mc には触らない）、
    旧 daemon は "unknown cmd: send_angles_fast" を返すので区別できる。
    未配備なら 1 コマンドも送らずに ABORT する（157 tick ぶん失敗し続けさせない）。
    """
    try:
        _daemon_request({"cmd": "send_angles_fast", "angles": [0, 0, 0],
                         "speed": 20},
                        timeout_override=DAEMON_SEND_TIMEOUT_SEC)
        _abort_msg("daemon が長さ不正の angles を受け付けました。"
                   "送信ガードが期待どおりでないので止めます")
        sys.exit(1)
    except RuntimeError as e:
        msg = str(e)
        if "unknown cmd" in msg:
            _abort_msg("Pi の daemon が send_angles_fast を持っていません。"
                       "新しい mecharm_daemon.py を Pi に配備してから実行してください"
                       "（応答: {}）".format(msg))
            sys.exit(1)
        if "length 6" not in msg:
            _abort_msg("daemon の send_angles_fast の応答が想定外です: {}".format(msg))
            sys.exit(1)
    # get_angles_once も確認（こちらは副作用が無いのでそのまま呼ぶ）
    try:
        _daemon_request({"cmd": "get_angles_once"},
                        timeout_override=DAEMON_GET_ONCE_TIMEOUT_SEC)
    except RuntimeError as e:
        if "unknown cmd" in str(e):
            _abort_msg("Pi の daemon が get_angles_once を持っていません。"
                       "新しい mecharm_daemon.py を Pi に配備してください"
                       "（応答: {}）".format(e))
            sys.exit(1)
        _warn("get_angles_once の確認で例外（記録の読み取りだけ影響）: {}".format(e))
    _log("daemon の新 cmd 確認 OK（send_angles_fast / get_angles_once）")


def _send_angles_guarded(pose, speed, where, recorder=None):
    """送信直前の backstop（codex R1 C2）.

    送る姿勢ごとに「有限値 → JOINT_LIMITS → J4_SAFE」を確かめ、
    外れていたら **送らずに** ABORT する。クランプして黙って姿勢を変えることはしない
    （教示姿勢を勝手に書き換えない）。
    計画時に全姿勢を検査済みでも、ここが最後の砦として全送信を通る。
    依頼 213: SEND_WAIT_ON が "mac" なら、送ったあとの SEND_WAIT_SEC をここ（Mac 側）で待ってから返る。
    recorder を渡すとその間を電流の記録スレッドに知らせる（読める）。
    """
    reason = _pose_violation(pose)
    if reason is not None:
        raise _Aborted(where, "送信直前の姿勢検査で弾きました（送信していません）: "
                              + reason)
    _LAST_SEND["daemon_rtt_sec"] = None
    if USE_FAST_DAEMON_CMDS:
        # LOG352: 読み直し無しの送信（Pi 直と同じ送り方）
        return daemon_send_angles_fast(
            pose, speed, timeout_override=DAEMON_SEND_TIMEOUT_SEC)
    # 項目3 / D7: 本線 j0_sweep_scan._send_and_wait_arrival は
    #   daemon_send_angles(target, speed=SPEED, wait=SEND_WAIT_SEC)
    # で送る（timeout_override は渡さない）。テンプレートの固定事項
    # 「SENDWAIT = 1.0（DAY266: 短縮しない）」にも合う。
    #
    # codex R11 B5: timeout_override は渡さない。visual_servo_pick._daemon_request は
    #   timeout = (wait + 3.0) if wait > 0 else DAEMON_TIMEOUT_SEC
    #   deadline = min(timeout, timeout_override)
    # なので、wait=1.0 のとき override を渡しても **4.0s より長くはできない**
    #（override は短縮しかできない）。渡すと「6.0s にした」という意図と
    # 実際（4.0s）が食い違うだけなので渡さず、**本線と同じ 4.0s** にする。
    # daemon の最悪応答は wait 1.0 + 読み直し 12 回 ≒3.7s + 通信時間なので、
    # 4.0s を超えることがある。超えるとソケットが切れて例外 → その場で ABORT。
    # codex R11b T6: この ABORT は **後続の送信と爪の操作をやめる**だけで、
    # **実機の停止ではない**。daemon は応答の前に関節指令を送り終えているので、
    # アームは目標まで動き続けうる。止めるのは電源を切ることだけ
    #（2026-10-18 からの運用）。周囲の空間を空けて監視下で走らせること。
    # 送信回数は増やさない。待つのは daemon 側の 1 回だけ。
    if SEND_WAIT_ON == "daemon":
        t0 = time.monotonic()
        try:
            return daemon_send_angles(pose, speed, wait=SEND_WAIT_SEC)
        finally:
            _LAST_SEND["daemon_rtt_sec"] = time.monotonic() - t0   # 例外でも残す（codex 2 回目 R2）
    # 依頼 213（"mac"）: daemon は wait=0 で、書き込みのあと 1 回だけ角度を読んで（read_angles_once_for_log）
    # すぐ返す。返ってから Mac 側で同じ SEND_WAIT_SEC 待つので、到達の確かめが始まる時刻は今までと同じ
    # （書き込み → 1.0 秒 → 読み 1 回 → 返事、が 書き込み → 読み 1 回 → 返事 → 1.0 秒 になる）。
    # 送信は install_daemon_lock の鍵の中の 1 回のやりとりなので、電流の記録スレッドの読みは
    # 送信の途中に割り込まない（返事が来て鍵が外れてから、眠りを知らされた間だけ読む）。
    # 送信が例外でも 1.0 秒は待つ（届いたかは分からないので、待ちを縮めずに到達の確かめへ進む）。
    t0 = time.monotonic()
    try:
        resp = daemon_send_angles(pose, speed, wait=0,
                                  timeout_override=SEND_SOCKET_TIMEOUT_SEC)
    except Exception:
        _LAST_SEND["daemon_rtt_sec"] = time.monotonic() - t0
        _send_wait_on_mac(recorder)
        raise
    _LAST_SEND["daemon_rtt_sec"] = time.monotonic() - t0
    _send_wait_on_mac(recorder)
    return resp


def _send_wait_on_mac(recorder):
    """依頼 213: 送ったあとの SEND_WAIT_SEC（1.0 秒）を Mac 側で待つ。**長さは縮めない**（time.sleep と同じ）."""
    if recorder is not None:
        _sleep_open(recorder, SEND_WAIT_SEC)
    else:
        time.sleep(SEND_WAIT_SEC)


def _note_send_failure(streak, label, detail, exc):
    """send_angles の失敗を数えて WARN する（**止めない**）.

    2026-10-19 方針変更: 送信の例外では ABORT しない。連続回数は記録のために
    数えるだけで、止めるかどうかは到達確認（送り直しても動かないか）で決める。
    戻り値は互換のため残しているが、呼び出し側は使っていない。
    成功時のリセットは呼び出し側で `streak["consecutive_send_failures"] = 0`。
    """
    streak["total_send_failures"] += 1
    streak["consecutive_send_failures"] += 1
    streak["max_consecutive_send_failures"] = max(
        streak["max_consecutive_send_failures"],
        streak["consecutive_send_failures"])
    _warn("send_angles 例外 {} ({}): {}: {}（連続 {} 回目・**止めません**）".format(
        detail, label, type(exc).__name__, exc,
        streak["consecutive_send_failures"]))
    return streak["consecutive_send_failures"] >= SEND_FAIL_ABORT_STREAK


def _replay(seq, recorder, log_record):
    """Pi 配備版 WPSR と同じ 11 step を daemon 経由で流す.

    Pi 配備版との対応:
      - 到達確認タイムアウトは **critical 区間（次が爪の開閉）だけ ABORT**。
        それ以外は WARN のみで続行（配備版 L359-365 と同じ）。
      - 単発の send 例外は WARN のみで続行（配備版 L350-352 と同じ）。
      - 2026-10-19 方針変更（エイイチ指示）: **止めるのは「送り直しても全く
        動かない」ときだけ**。送信の例外・到達タイムアウト・爪の失敗・
        実測 j4 の逸脱・静止確認の失敗は、すべて WARN にして先へ進む。
      - ABORT 後はアームへ追加コマンドを送らない（自動 HOME 復帰はしない）。
    """
    segments_log = []
    send_rtts = []        # 区間ごとの send_angles 1 回の daemon 往復時間
    sampler = _ActualSampler(recorder)
    t_motion_start = time.monotonic()
    # 連続 send 失敗数は区間をまたいで数える（通信断は区間の境目では切れない）
    streak = {"consecutive_send_failures": 0, "max_consecutive_send_failures": 0,
              "total_send_failures": 0}

    try:
        # ---- 項目2（2026-10-19・調べた結果として **残す**）--------------------
        # 「本線は set_fresh_mode を呼ばない」という前回の報告は**誤り**だった。
        # 確かめたこと:
        #   - run_pick_place.py L3976 で daemon_set_fresh_mode(1) を呼び、
        #     L5047 / L5059（finally）で (0) に戻している
        #     → 19 本 = 647 試行は **fresh_mode = 1 で動いている**
        #   - j0_sweep_scan.py L709 も (1)、L978 で (0)
        #   - Pi の daemon（無改変・5b7bacf1）は起動時に fresh_mode を設定しない。
        #     init_mycobot() は MyCobot(...) と角度読みだけ。終了時（SIGTERM /
        #     main の finally）にだけ _mc.set_fresh_mode(0) を送る。
        #     _fresh_mode_state = 0 は daemon 内の記録用の変数にすぎない
        #   - 実ログの裏づけ: Pi の daemon.log.pre_LOG352（本線を動かしていた頃）に
        #     set_fresh_mode(1) が 3 件、(0) が 5 件
        # → **削除すると本線と違う状態になる**ので、(1) と finally の (0) を
        #   そのまま残す（本線と同じ明示設定）。
        # codex U1: ここで例外が出ても止めない（WARN のみ）。
        # visual_servo_pick.daemon_set_fresh_mode は RuntimeError を握って
        # False を返すが、それ以外の例外は上がりうる。
        try:
            daemon_set_fresh_mode(1)
            _log("daemon_set_fresh_mode(1)（最新コマンド優先・本線 "
                 "run_pick_place.py L3976 と同じ。647 試行の実績はこの状態）")
        except (KeyboardInterrupt, SystemExit):
            raise
        except BaseException as e:
            _warn("daemon_set_fresh_mode(1) で例外（止めません）: {}: {}".format(
                type(e).__name__, e))
            log_record["fresh_mode_set_error"] = "{}: {}".format(
                type(e).__name__, e)

        # ---- STEP 1: HOME へ単発送信 + settle ----
        recorder.stage("HOME_START")
        print("[STEP  1] MOVE → HOME  daemon_send_angles(HOME, {})".format(SPEED_FIRST))
        # codex R8 O2/O3: 先頭 HOME も **送信失敗はその場で ABORT** し、
        # settle のあとに **到達確認**を行い、区間記録を 1 件残す。
        # 以前は送信失敗しても settle するだけで次へ進み、到達確認も無かったので、
        # どこにいるか分からないまま爪を開いて APPROACH_PICK へ送っていた。
        # cmd_run が測った current → HOME の max|Δ|（記録用）
        _first_max_delta = _max_axis_diff_finite(
            HOME_ANGLES, log_record.get("current_angles_before_replay"))
        # 項目1: 先頭 HOME の許容差は本線の TOL_HOME（表から引く）
        first_warnings = []
        first_tol, first_tol_src = _arrival_tol_for("HOME")
        if first_tol is None:
            first_tol = float(rpp.TOL_PICK_PLACE)
            first_tol_src = "未定義 → TOL_PICK_PLACE で代用"
            _warn("先頭 HOME の到達許容差が決まっていません。"
                  "{:.1f}° で続けます（止めません）".format(first_tol))
            first_warnings.append("arrival_tol_undefined")
        first_timeout = _arrival_timeout_for(_first_max_delta)
        print("[STEP  1] 到達待ち 許容 {:.1f}°[{}] / 最大 {:.1f}s".format(
            first_tol, first_tol_src, first_timeout))
        t_first_seg = time.monotonic()   # 区間全体（読み直しを含む）
        t_first_send = None              # 送信の計時は送信直前に始める（R11b T5）
        first_rtt = None
        first_rtt_retry = None
        first_daemon_rtt = None          # 依頼 213: daemon とのやりとりだけの往復（Mac 側の待ちを含まない）
        first_daemon_rtt_retry = None
        first_arrived = None
        first_max = None
        first_actual = None
        first_aborted_at = None
        first_pre_actual = None
        first_send_attempted = False     # 送信を試みたか（R11b T5）
        first_retried = False
        first_retry_arrived = None
        first_retry_reason = None
        first_retry_move_after_deg = None
        first_retry_move_deg = None
        phase = "pre_read"
        try:
            # 項目3 + codex R11 A6: 再送の可否判定に送信前の姿勢が要る。
            # cmd_run が読んだ current_angles_before_replay は、そのあとに
            # カメラ確認と Enter 待ちを挟むので「送信直前」ではない
            #（Enter 待ちは人次第でいくらでも伸びる）。**ここで読み直す**。
            # 読めなければ送らずに ABORT（本線も「fallback はしない」）。
            first_pre_actual = sampler.read(once=False)
            if first_pre_actual is None:
                _warn("先頭移動の送信前の実測角が取れませんでした。"
                      "動いたかを判定できませんが**止めません**")
                first_warnings.append("pre_read_failed")
            # 読み直した姿勢で max|Δ| とタイムアウトを作り直す
            if first_pre_actual is not None:
                _first_max_delta = _max_axis_diff_finite(
                    HOME_ANGLES, first_pre_actual)
            first_timeout = _arrival_timeout_for(_first_max_delta)
            _log("先頭移動: 送信直前の実測で max|Δ| = {}° / 到達待ち 最大 {:.1f}s"
                 .format(("{:.2f}".format(_first_max_delta)
                          if _first_max_delta is not None else "None"),
                         first_timeout))
            # codex R11b T5: 読み直しで max|Δ| が増えていたら、ここでも警告する
            # （Enter 前の大移動 WARN は読み直し前の姿勢で出しているため）。
            if (_first_max_delta is not None
                    and _first_max_delta > FIRST_MOVE_WARN_DEG):
                _warn("送信直前の実測では current → HOME が {:.2f}°（> {:.1f}°）"
                      "あります。周囲に手・物が無いか、もう一度目で確かめてください"
                      .format(_first_max_delta, FIRST_MOVE_WARN_DEG))
                log_record["first_move_warn_after_reread_deg"] = round(
                    _first_max_delta, 3)
            phase = "send"
            first_send_attempted = True
            try:
                t_first_send = time.monotonic()
                _send_angles_guarded(HOME_ANGLES, SPEED_FIRST, "step1_HOME_START",
                                     recorder=recorder)
                first_daemon_rtt = _LAST_SEND["daemon_rtt_sec"]
                first_rtt = time.monotonic() - t_first_send
                log_record["first_move_send_rtt_sec"] = round(first_rtt, 4)
                streak["consecutive_send_failures"] = 0
            except _Aborted:
                first_aborted_at = "send_backstop"
                raise
            except Exception as e:
                # 2026-10-19 方針変更: 送信の例外でも止めない
                first_daemon_rtt = _LAST_SEND["daemon_rtt_sec"]   # 依頼 213 codex R2: 失敗でも残す
                _note_send_failure(streak, "先頭移動 (current → HOME)",
                                   "step1_HOME_START", e)
                _warn("先頭移動の send_angles が失敗しました。止めません。"
                      "到達確認で動いたかを見ます: {}: {}".format(
                          type(e).__name__, e))
                first_warnings.append("send_failed")

            print("[STEP  1] {:.1f}s 待ちます（settle）".format(
                FIRST_MOVE_SETTLE_SEC))
            sampler.sleep_with_reads(FIRST_MOVE_SETTLE_SEC)

            phase = "arrival_wait"
            first_arrived, first_max, first_actual = _hold_until_arrival(
                HOME_ANGLES, "current → HOME", sampler, first_tol, first_timeout)

            if not first_arrived:
                # 2026-10-19 方針変更: move 区間とまったく同じ扱い。
                #   1.0° 以上動いた → WARN で先へ進む
                #   1.0° 未満       → 5s 待って同じ HOME へ 1 回再送
                #     再送後 1.0° 以上 → WARN で先へ進む
                #     再送後も 1.0° 未満 → **ABORT（唯一）**
                phase = "arrival_decide"
                if first_pre_actual is not None and first_actual is not None:
                    first_retry_move_deg, _mlabel, _unexp = jss._retry_progress(
                        first_pre_actual, first_actual, first_tol)
                else:
                    first_retry_move_deg, _mlabel = None, "pre→last max|Δ|"
                _moved_ok = (first_retry_move_deg is not None
                             and _is_finite_num(first_retry_move_deg)
                             and first_retry_move_deg >= RETRY_NO_MOVE_THRESHOLD_DEG)
                _unknown = (first_retry_move_deg is None
                            or not _is_finite_num(first_retry_move_deg))

                if _moved_ok:
                    first_retry_reason = ("{} {:.2f}° >= {:.1f}°（動いているので"
                                          "再送しない）".format(
                                              _mlabel, first_retry_move_deg,
                                              RETRY_NO_MOVE_THRESHOLD_DEG))
                    _warn("先頭 HOME の到達確認タイムアウト（max|Δ|={}° > "
                          "tol {:.1f}°）ですが {}。**止めずに再生を始めます**"
                          .format(("{:.2f}".format(first_max)
                                   if first_max is not None else "None"),
                                  first_tol, first_retry_reason))
                    first_warnings.append("arrival_timeout_but_moved")
                elif _unknown:
                    first_retry_reason = "移動量が分からない（実測が無い）"
                    _warn("先頭 HOME の到達確認タイムアウト。{}ので再送の判定が"
                          "できません。**止めずに再生を始めます**".format(
                              first_retry_reason))
                    first_warnings.append("arrival_timeout_move_unknown")
                else:
                    first_retried = True
                    first_retry_reason = (
                        "{} {:.2f}° < {:.1f}°（送信無視疑い）".format(
                            _mlabel, first_retry_move_deg,
                            RETRY_NO_MOVE_THRESHOLD_DEG))
                    phase = "retry_pause"
                    _warn("先頭 HOME の送信が無視されたとみなします（{}）。"
                          "{:.1f}s 待って**同じ HOME へ**再送します".format(
                              first_retry_reason, RETRY_PAUSE_SEC))
                    first_warnings.append("retry_sent")
                    # 依頼 121: 復帰待ちの間は電流の記録もシリアルを触らない（codex R1 必須 2）
                    recorder.pause_currents()
                    time.sleep(RETRY_PAUSE_SEC)
                    recorder.resume_currents()

                    phase = "retry_pre_read"
                    _pre_retry = sampler.read(once=False)
                    if _pre_retry is None:
                        _warn("再送の前の実測角が取れませんでした。"
                              "1 回目の基準姿勢で判定します（止めません）")
                        first_warnings.append("retry_pre_read_failed")
                        _retry_base = (first_actual if first_actual is not None
                                       else first_pre_actual)
                    else:
                        _retry_base = _pre_retry
                    _timeout_retry = _arrival_timeout_for(
                        _max_axis_diff_finite(HOME_ANGLES, _retry_base)
                        if _retry_base is not None else _first_max_delta)

                    phase = "retry_send"
                    _t_retry = time.monotonic()
                    try:
                        _send_angles_guarded(HOME_ANGLES, SPEED_FIRST,
                                             "step1_HOME_START_retry",
                                             recorder=recorder)
                        first_daemon_rtt_retry = _LAST_SEND["daemon_rtt_sec"]
                        first_rtt_retry = time.monotonic() - _t_retry
                        _log("再送 OK（daemon 往復 {:.3f}s）".format(first_rtt_retry))
                    except _Aborted:
                        # 送信直前の姿勢検査（項目5 と同じもの）だけは止める
                        first_aborted_at = "retry_send_backstop"
                        raise
                    except Exception as e:
                        first_daemon_rtt_retry = _LAST_SEND["daemon_rtt_sec"]
                        _note_send_failure(streak, "先頭移動 (current → HOME)",
                                           "step1_HOME_START_retry", e)
                        _warn("先頭移動の再送 send_angles が失敗しました。"
                              "止めません: {}: {}".format(type(e).__name__, e))
                        first_warnings.append("retry_send_failed")

                    print("[STEP  1] {:.1f}s 待ちます（再送後の settle）".format(
                        FIRST_MOVE_SETTLE_SEC))
                    sampler.sleep_with_reads(FIRST_MOVE_SETTLE_SEC)

                    phase = "retry_arrival_wait"
                    (first_retry_arrived, first_max,
                     first_actual) = _hold_until_arrival(
                        HOME_ANGLES, "current → HOME（再送）", sampler,
                        first_tol, _timeout_retry)
                    first_arrived = bool(first_retry_arrived)

                    # ---- 唯一の ABORT: 再送しても全く動かない ----
                    _m2 = None
                    if _retry_base is not None and first_actual is not None:
                        _m2, _rl, _ru = jss._retry_progress(
                            _retry_base, first_actual, first_tol)
                    first_retry_move_after_deg = _m2
                    if first_retry_arrived:
                        _log("再送で HOME に到達しました")
                    elif (_m2 is not None and _is_finite_num(_m2)
                            and _m2 >= RETRY_NO_MOVE_THRESHOLD_DEG):
                        _warn("再送でも許容差に入りませんでしたが {:.2f}° "
                              "動いています（>= {:.1f}°）。"
                              "**止めずに再生を始めます**".format(
                                  _m2, RETRY_NO_MOVE_THRESHOLD_DEG))
                        first_warnings.append("retry_timeout_but_moved")
                    elif _m2 is None or not _is_finite_num(_m2):
                        _warn("再送のあとの移動量が分かりません。"
                              "**止めずに再生を始めます**")
                        first_warnings.append("retry_move_unknown")
                    else:
                        first_aborted_at = "retry_no_move"
                        raise _Aborted(
                            "step1_HOME_START",
                            "**送り直してもアームが動きません**"
                            "（再送後の移動 {:.2f}° < {:.1f}° / HOME まで {}°）。"
                            "これが唯一の中断条件です。これ以降は何も送りません"
                            .format(_m2, RETRY_NO_MOVE_THRESHOLD_DEG,
                                    ("{:.2f}".format(first_max)
                                     if first_max is not None else "None")))
        except BaseException:
            if first_aborted_at is None:
                first_aborted_at = phase
            raise
        finally:
            segments_log.append({
                "step": 1, "kind": "move",
                "from_name": "current", "to_name": "HOME",
                "stage": "HOME_START",
                "critical": False,
                "max_delta_deg": (round(_first_max_delta, 3)
                                  if _first_max_delta is not None else None),
                "arrival_ok": (None if first_arrived is None
                               else bool(first_arrived)),
                "arrival_max_delta_deg": (round(float(first_max), 3)
                                          if first_max is not None else None),
                "arrival_actual": first_actual,
                # codex R11b T5: 送信を試みていない（送信前の読みで止まった）場合は
                # 失敗 0 件。試みて例外になった場合だけ 1 件。
                "send_failures": (0 if (first_rtt is not None
                                        or not first_send_attempted) else 1),
                "send_attempted": bool(first_send_attempted),
                "send_rtt_sec": (round(first_rtt, 4)
                                 if first_rtt is not None else None),
                "segment_elapsed_sec": round(time.monotonic() - t_first_seg, 3),
                "aborted_at": first_aborted_at,
                "speed": SPEED_FIRST,
                "arrival_tol_deg": first_tol,
                "arrival_tol_source": first_tol_src,
                "arrival_timeout_sec": round(float(first_timeout), 2),
                "pre_actual": first_pre_actual,
                "pre_max_delta_deg": (round(_first_max_delta, 3)
                                      if _first_max_delta is not None else None),
                "retried": bool(first_retried),
                "retry_arrived": (None if first_retry_arrived is None
                                  else bool(first_retry_arrived)),
                "retry_reason": first_retry_reason,
                "retry_move_deg": (round(float(first_retry_move_deg), 3)
                                   if first_retry_move_deg is not None
                                   and _is_finite_num(first_retry_move_deg)
                                   else None),
                "retry_move_after_deg": (
                    round(float(first_retry_move_after_deg), 3)
                    if first_retry_move_after_deg is not None
                    and _is_finite_num(first_retry_move_after_deg) else None),
                "retry_no_move_threshold_deg": RETRY_NO_MOVE_THRESHOLD_DEG,
                "retry_pause_sec": (RETRY_PAUSE_SEC if first_retried else None),
                "warnings": list(first_warnings),
                "send_rtt_retry_sec": (round(first_rtt_retry, 4)
                                       if first_rtt_retry is not None else None),
                # 依頼 213: 送信のあとの 1.0 秒をどこで待ったか と daemon とのやりとりだけの往復
                "send_wait_on": SEND_WAIT_ON,
                "send_daemon_rtt_sec": (round(first_daemon_rtt, 4)
                                        if first_daemon_rtt is not None else None),
                "send_daemon_rtt_retry_sec": (round(first_daemon_rtt_retry, 4)
                                              if first_daemon_rtt_retry is not None else None),
            })

        # codex R11 A1: 爪の直前の静止確認に「直前の move の目標と許容差」を使う。
        # STEP 1 のあとは HOME が直前の目標。
        last_move_target = list(HOME_ANGLES)
        last_move_tol = first_tol

        # ---- STEP 2 以降 ----
        step_no = 2
        for s in seq:
            if s["kind"] == "gripper":
                is_close = (s["action"] == "close")
                state = 1 if is_close else 0
                if is_close:
                    cmd_str = "daemon_set_gripper_value({}, {})".format(
                        GRIP_VALUE, GRIPPER_SPEED)
                else:
                    cmd_str = "daemon_set_gripper(0, {}, wait=0)".format(GRIPPER_SPEED)
                print("[STEP {:>2}] GRIPPER {} → {}".format(
                    step_no, s["action"].upper(), cmd_str))
                # A4-2（エイイチ判断 2026-10-19）: recorder への通知は
                # **daemon 呼び出しが戻った直後**に送る（閉じる・開く両方）。
                # 開く経路の daemon ハンドラは set_gripper_state() の手前で
                # time.sleep(2) する（DAY175 対策・daemon は変えない）ので、
                # 呼び出しの前に通知すると「実際に爪へ命令が出る約2秒前」に
                # state が切り替わった記録になる。build_demo_episodes.py は
                # gripper_cmd の時刻で state を 0↔1 にするため、約2秒ぶんの
                # フレームが誤ラベルになる。wait=0 なので
                # 「戻った時刻 ≒ 実際に爪へ命令が出た時刻」。
                # 例外時も通知する（イベント自体を落とすと state が切り替わらない
                # 記録になるため）。失敗は note と試行 JSON に残す。
                # ---- 爪の開閉 ----
                # 2026-10-19（エイイチ判断・方針変更 + 項目4・項目6）:
                # get_gripper_value を使った開放確認をやめ、**本線
                # run_pick_place.py の _do_gripper と同じ形**にする。
                #   open:  daemon_set_gripper(0) 1 回 → 2.0s（daemon 事後相当）→ 2.0s
                #   close: set_gripper_value を 1 回 + 2.0s（本線 GRIPPER_SLEEP）
                # 理由: 段階C で PLACE の open のあと gv が -1 を返し、その直後から
                # アームが send_angles を受け付けなくなった（書き込みは通り
                # elapsed 10.5ms、get_angles も読めるのにモーターが動かない。
                # daemon を再起動するまで gv は -1 のままだった）。
                # T1/T2 で「静止中の gv 読み取りは壊さない」ことは確認したが、
                # 爪が動いている最中の読み取りが引き金の可能性が残る。
                # stage9 の形は 647 試行で詰まっていない実績がある。
                # **開いたかは人が目で見て y/n で答える**（自動確認はしない）。
                # ---- codex R11 A1 + 2026-10-19 方針変更（項目2）------------
                # 爪を動かす前に **止まるまで最大 8 秒待つ**。
                # 止まらなくても **ABORT はしない**。WARN を残して爪を動かす。
                # **目標との差は見ない**（止まっているかだけを見る）。
                # 到達確認は「1 回でも tol 内に読めたら到達」なので、通過中でも
                # 到達になりうる（段階C 1回目はその状態で close していた）。
                # ここで待つことで、動いている最中に爪を動かす確率を下げる。
                still_ok, still_detail = _wait_until_still(
                    sampler, None, None,
                    "step{}_{}".format(step_no, s["action"]))
                if not still_ok:
                    _warn("爪を動かす前の静止確認が取れませんでした"
                          "（連続差 最大 {}° / 連続 {} 回 < 必要 {} 回 / "
                          "{:.1f}s）。**止めずに爪を動かします**（WARN のみ）"
                          .format((("{:.2f}".format(still_detail["max_step_deg"]))
                                   if still_detail.get("max_step_deg") is not None
                                   else "None"),
                                  still_detail.get("consecutive_ok"),
                                  GRIPPER_STILL_READS, GRIPPER_STILL_TIMEOUT_SEC))

                is_open_cmd = not is_close
                attempts = GRIPPER_OPEN_ATTEMPTS if is_open_cmd else 1
                cmd_error = None
                attempt_log = []
                notify_ts = None
                last_rtt = None

                # 依頼 121: 爪の命令から待ち（dwell）が終わるまで、電流の記録スレッドも
                # daemon を読まない（下の「読み取りを挟まない」と同じ扱い）。
                # 読んでいる途中ならその 1 回（約 0.1 秒）が終わってから爪の命令を送る。
                # 再生の中で電流の記録を止めるのは、ここと再送の前の待ち（RETRY_PAUSE_SEC）の 2 か所。
                recorder.pause_currents()
                for attempt in range(1, attempts + 1):
                    t_cmd_send = time.monotonic()
                    t_cmd_wall = time.time()
                    try:
                        if is_close:
                            daemon_set_gripper_value(GRIP_VALUE, GRIPPER_SPEED)
                        else:
                            daemon_set_gripper(0, GRIPPER_SPEED, wait=0)
                        cmd_error = None
                    except Exception as e:
                        cmd_error = "{}: {}".format(type(e).__name__, e)
                    last_rtt = time.monotonic() - t_cmd_send
                    if cmd_error is not None:
                        break
                    # recorder へ出す時刻は **1 回目の指令時刻**で固定する
                    # （2 回目は同じ open を念のため送るだけ。state は変わらない）
                    if notify_ts is None:
                        notify_ts = t_cmd_wall + last_rtt
                    attempt_log.append({
                        "attempt": attempt,
                        "cmd_returned_ts": t_cmd_wall + last_rtt,
                        "daemon_roundtrip_sec": round(last_rtt, 4),
                    })
                    _log("gripper {} ({}/{} 回目) の daemon 往復 = {:.3f}s".format(
                        s["action"], attempt, attempts, last_rtt))
                    if is_open_cmd:
                        # codex R10 S2: 本線がヘルパ既定 wait=2 で得ている
                        # 事後 sleep の相当分。**読み取りを挟まない**で待つ
                        # （爪を動かした直後にシリアルを触らない）。
                        print("[STEP {:>2}] open 後 {:.1f}s 待ちます"
                              "（本線の daemon wait=2 相当・読み取りなし）"
                              .format(step_no, GRIPPER_OPEN_POST_SLEEP_SEC))
                        time.sleep(GRIPPER_OPEN_POST_SLEEP_SEC)
                    dwell = (GRIPPER_OPEN_DWELL_SEC if is_open_cmd
                             else GRIPPER_DWELL_SEC)
                    # codex R11b T4: ここも **読み取りを挟まない**。
                    # 本線 _do_gripper は time.sleep(GRIPPER_SLEEP) だけで、
                    # 爪の指令の直後に get_angles を出さない。close のあとに
                    # 読んでいたのは本線との差で、方針（爪を動かした直後に
                    # シリアルを触らない）にも反していた。
                    # 実測角の 2.0s の欠測は受け入れる（動画は止まらない）。
                    print("[STEP {:>2}] gripper dwell {}s（読み取りなし）".format(
                        step_no, dwell))
                    time.sleep(dwell)
                # 待ちが終わってから再開する。待ちの途中の例外（Ctrl-C など）では再開しない
                # （止めたまま、cmd_run の finally で記録を閉じる。codex R1 必須 1）。
                # 爪の命令が失敗して break したときは待たずに先へ進む（本体も読み始める）ので再開する。
                recorder.resume_currents()

                seg_rec = {
                    "step": step_no, "kind": "gripper", "action": s["action"],
                    "daemon_roundtrip_sec": (round(last_rtt, 4)
                                             if last_rtt is not None else None),
                    "error": cmd_error,
                    "attempts": len(attempt_log),
                    "attempt_log": attempt_log,
                    "method": ("open_once_no_readback" if is_open_cmd
                               else "set_gripper_value_once"),
                    "pre_sleep_sec": 0.0,
                    "post_sleep_sec": (GRIPPER_OPEN_POST_SLEEP_SEC if is_open_cmd
                                       else 0.0),
                    # codex R10b T3: daemon の事前 sleep(2) は set_gripper
                    #（open）ハンドラにだけある。close の set_gripper_value には無い。
                    "daemon_pre_sleep_sec": (DAEMON_SET_GRIPPER_PRE_SLEEP_SEC
                                             if is_open_cmd else 0.0),
                    "dwell_sec": (GRIPPER_OPEN_DWELL_SEC if is_open_cmd
                                  else GRIPPER_DWELL_SEC),
                    "verified_by": "human_y_n",
                    "still_check": still_detail,
                }

                if cmd_error is not None:
                    # 2026-10-19 方針変更: 爪の指令が失敗しても **止めない**。
                    # 爪が開いたか閉じたかは分からないが、WARN と試行 JSON に残して
                    # 先へ進む（最終判定は人の y/n と動画）。
                    _warn("{} が失敗しました（{}）。爪の状態は分かりませんが"
                          "**止めません**（WARN のみ）".format(cmd_str, cmd_error))
                    log_record.setdefault("gripper_errors", []).append({
                        "step": step_no, "action": s["action"], "error": cmd_error,
                    })

                seg_rec["state"] = state
                segments_log.append(seg_rec)
                # recorder への通知は「1 回目の指令が戻った時刻」で出す（A4-2）
                recorder.gripper_cmd(
                    state, "step{}_{}".format(step_no, s["action"]), ts=notify_ts)
                log_record["gripper_last_state"] = state
                step_no += 1
                continue

            # ---- move: 区間ごとに 1 回だけ送って到達を待つ ----
            # 2026-10-19（エイイチ判断）: 0.1 秒ごとの補間送信をやめた。
            # 19 本（run_pick_place.py）と同じ「1 回送って到達を待つ」動かし方。
            # 移動中の実測角は _hold_until_arrival のポーリング
            # （ARRIVAL_POLL_SLEEP = 0.3s → 約 3.3Hz）で読んで recorder へ流れる。
            #
            # codex R7 N2/N3（単発送信にしたことで新たに必要になった扱い）:
            #   補間ストリーミングでは「未到達」＝経路上で少し遅れている、だったので
            #   critical 以外は WARN で続行してよかった。
            #   単発送信では「未到達」＝**中継姿勢に着いていない**ので、そこから
            #   次の目標を送ると、どこにいるか分からない姿勢から関節空間の直線で
            #   移動することになり、ブロックや箱に当たりうる。
            #   よって **critical でなくても到達できなければ ABORT** する
            #   （Pi 配備版の「critical だけ ABORT」から意図的に変えた）。
            #   送信失敗（1 区間 1 指令なので未送達の可能性）も、同じ到達確認で
            #   捕まえて止める。自動再送はしない。
            label = "{} → {}".format(s["from_name"], s["to_name"])
            # 許容差は区間ごと（本線の stage 値）。
            # 2026-10-19 方針変更: 知らない区間名でも止めない。本線のいちばん緩い
            # 値（TOL_PICK_PLACE = 3.0）で続け、WARN と試行 JSON に残す。
            seg_warnings = []
            tol_deg, tol_src = _arrival_tol_for(s["to_name"])
            if tol_deg is None:
                tol_deg = float(rpp.TOL_PICK_PLACE)
                tol_src = "未定義 → TOL_PICK_PLACE で代用"
                _warn("区間名 {!r} の到達許容差が決まっていません。"
                      "本線のいちばん緩い値 {:.1f}° で続けます（止めません）"
                      .format(s["to_name"], tol_deg))
                seg_warnings.append("arrival_tol_undefined")
            timeout_sec = _arrival_timeout_for(s["max_delta"])
            print("[STEP {:>2}] MOVE → {}  segment {}  "
                  "(1 回送信 speed={} → 到達待ち 許容 {:.1f}°[{}] / 最大 {:.1f}s){}".format(
                      step_no, s["to_name"], label, SPEED_SINGLE,
                      tol_deg, tol_src, timeout_sec,
                      "  [critical]" if s.get("critical") else ""))
            recorder.stage(_stage_name(s["to_name"]))

            send_failures = 0
            send_rtt_sec = None
            send_rtt_retry_sec = None
            send_daemon_rtt_sec = None        # 依頼 213
            send_daemon_rtt_retry_sec = None
            arrived = None
            last_max = None
            last_actual = None
            aborted_at = None
            retried = False
            retry_arrived = None
            retry_reason = None
            retry_move_deg = None
            retry_move_after_deg = None
            pre_actual = None
            pre_max = None
            t_seg = time.monotonic()
            # codex R7 N6: 送信と到達待ちを **1 つの try/finally** で囲み、
            # どこで抜けても区間の記録を必ず 1 件残す
            # （以前は到達待ち中の Ctrl-C / 実測 j4 ハード帯 ABORT で記録が欠けた）。
            phase = "pre_read"
            try:
                # 再送の可否は「送信前姿勢 → 到達待ちで最後に読めた姿勢」の
                # 移動量で決める。2026-10-19 方針変更: 読めなくても止めない。
                # その場合は「動いたか不明」として扱い、再送もしないで次へ進む。
                pre_actual = sampler.read(once=False)
                if pre_actual is None:
                    _warn("送信前の実測角が取れませんでした（区間 {}）。"
                          "動いたかどうかを判定できないので、この区間は"
                          "「不明」として続けます（止めません）".format(label))
                    seg_warnings.append("pre_read_failed")
                pre_max = (_max_axis_diff_finite(s["to"], pre_actual)
                           if pre_actual is not None else None)
                timeout_sec = _arrival_timeout_for(
                    pre_max if pre_max is not None else s["max_delta"])

                phase = "send"
                t_send = time.monotonic()
                try:
                    _send_angles_guarded(
                        s["to"], SPEED_SINGLE,
                        "step{}_{}".format(step_no, _stage_name(s["to_name"])),
                        recorder=recorder)
                    send_daemon_rtt_sec = _LAST_SEND["daemon_rtt_sec"]
                    send_rtt_sec = time.monotonic() - t_send
                    send_rtts.append(send_rtt_sec)
                    streak["consecutive_send_failures"] = 0
                    _log("送信 OK（daemon 往復 {:.3f}s）".format(send_rtt_sec))
                except _Aborted:
                    # 送信直前の姿勢検査（backstop）で弾いた分はそのまま止める
                    aborted_at = "send_backstop"
                    raise
                except Exception as e:
                    # 2026-10-19 方針変更: 送信の例外でも止めない。
                    # 指令が届いたかは分からないが、**動いたかどうかは到達確認で
                    # 分かる**ので、そこで判断する（届いていなければ
                    # 「1.0° 未満 → 再送 → それでも 1.0° 未満」で ABORT になる）。
                    send_failures += 1
                    send_daemon_rtt_sec = _LAST_SEND["daemon_rtt_sec"]   # 依頼 213 codex R2: 失敗でも残す
                    _note_send_failure(streak, label, "単発送信", e)
                    _warn("send_angles が失敗しました（区間 {}）。止めません。"
                          "到達確認で動いたかを見ます: {}: {}".format(
                              label, type(e).__name__, e))
                    seg_warnings.append("send_failed")

                phase = "arrival_wait"
                arrived, last_max, last_actual = _hold_until_arrival(
                    s["to"], label, sampler, tol_deg, timeout_sec)

                if not arrived:
                    # ---- 2026-10-19 方針変更（エイイチ指示）------------------
                    # 止めるのは「**送り直しても全く動かない**」ときだけ。
                    #   1.0° 以上動いている        → WARN で次の区間へ
                    #   1.0° 未満                  → 5s 待って同じ目標へ 1 回再送
                    #     再送後に 1.0° 以上動いた → WARN で次の区間へ
                    #     再送後も 1.0° 未満       → **ABORT（唯一の ABORT）**
                    #   移動量が分からない          → WARN で次の区間へ
                    # 送るのは s["to"] だけ。HOME や別の姿勢へは絶対に送らない。
                    phase = "arrival_decide"
                    move_label = "pre→last max|Δ|"
                    if pre_actual is not None and last_actual is not None:
                        retry_move_deg, move_label, _unexp = (
                            jss._retry_progress(pre_actual, last_actual, tol_deg))
                    else:
                        retry_move_deg = None

                    moved_ok = (retry_move_deg is not None
                                and _is_finite_num(retry_move_deg)
                                and retry_move_deg >= RETRY_NO_MOVE_THRESHOLD_DEG)
                    move_unknown = (retry_move_deg is None
                                    or not _is_finite_num(retry_move_deg))

                    if moved_ok:
                        retry_reason = ("{} {:.2f}° >= {:.1f}°（動いているので"
                                        "再送しない）".format(
                                            move_label, retry_move_deg,
                                            RETRY_NO_MOVE_THRESHOLD_DEG))
                        _warn("到達確認タイムアウト（max|Δ|={}° > tol {:.1f}°）"
                              "ですが {}。**止めずに次の区間へ進みます**".format(
                                  ("{:.2f}".format(last_max)
                                   if last_max is not None else "None"),
                                  tol_deg, retry_reason))
                        seg_warnings.append("arrival_timeout_but_moved")
                    elif move_unknown:
                        retry_reason = ("移動量が分からない（送信前または到達待ちの"
                                        "実測が無い）")
                        _warn("到達確認タイムアウト（max|Δ|={}° > tol {:.1f}°）。"
                              "{}ので再送の判定ができません。"
                              "**止めずに次の区間へ進みます**".format(
                                  ("{:.2f}".format(last_max)
                                   if last_max is not None else "None"),
                                  tol_deg, retry_reason))
                        seg_warnings.append("arrival_timeout_move_unknown")
                    else:
                        # ---- 1.0° 未満しか動いていない → 再送（1 回だけ）----
                        retried = True
                        retry_reason = ("{} {:.2f}° < {:.1f}°（送信無視疑い）".format(
                            move_label, retry_move_deg,
                            RETRY_NO_MOVE_THRESHOLD_DEG))
                        phase = "retry_pause"
                        _warn("1 回目の送信が無視されたとみなします（{}）。"
                              "{:.1f}s 待って**同じ目標へ**再送します".format(
                                  retry_reason, RETRY_PAUSE_SEC))
                        seg_warnings.append("retry_sent")
                        # 復帰待ちの間はシリアルを触らない（本線と同じ）
                        # 依頼 121: 電流の記録も止める（codex R1 必須 2）
                        recorder.pause_currents()
                        time.sleep(RETRY_PAUSE_SEC)
                        recorder.resume_currents()

                        phase = "retry_pre_read"
                        pre_actual_retry = sampler.read(once=False)
                        if pre_actual_retry is None:
                            # 読めなくても止めない。1 回目の送信前姿勢（または
                            # 到達待ちの最後の姿勢）を再送の基準に使う。
                            _warn("再送の前の実測角が取れませんでした。"
                                  "1 回目の基準姿勢で判定します（止めません）")
                            seg_warnings.append("retry_pre_read_failed")
                            retry_base = (last_actual if last_actual is not None
                                          else pre_actual)
                        else:
                            retry_base = pre_actual_retry
                        pre_max_retry = (_max_axis_diff_finite(s["to"], retry_base)
                                         if retry_base is not None else None)
                        timeout_retry_sec = _arrival_timeout_for(
                            pre_max_retry if pre_max_retry is not None
                            else s["max_delta"])

                        phase = "retry_send"
                        t_send_retry = time.monotonic()
                        try:
                            _send_angles_guarded(
                                s["to"], SPEED_SINGLE,
                                "step{}_{}_retry".format(
                                    step_no, _stage_name(s["to_name"])),
                                recorder=recorder)
                            send_daemon_rtt_retry_sec = _LAST_SEND["daemon_rtt_sec"]
                            send_rtt_retry_sec = time.monotonic() - t_send_retry
                            _log("再送 OK（daemon 往復 {:.3f}s）".format(
                                send_rtt_retry_sec))
                        except _Aborted:
                            # 送信直前の姿勢検査（JOINT_LIMITS / J4_SAFE）だけは
                            # そのまま止める（項目5 の検証と同じもの）
                            aborted_at = "retry_send_backstop"
                            raise
                        except Exception as e:
                            send_failures += 1
                            send_daemon_rtt_retry_sec = _LAST_SEND["daemon_rtt_sec"]
                            _note_send_failure(streak, label, "再送", e)
                            _warn("再送の send_angles が失敗しました。止めません。"
                                  "動いたかを到達確認で見ます: {}: {}".format(
                                      type(e).__name__, e))
                            seg_warnings.append("retry_send_failed")

                        phase = "retry_arrival_wait"
                        retry_arrived, last_max, last_actual = _hold_until_arrival(
                            s["to"], label + "（再送）", sampler,
                            tol_deg, timeout_retry_sec)
                        arrived = bool(retry_arrived)

                        # ---- 唯一の ABORT: 再送しても全く動かない ----
                        retry2_move = None
                        if retry_base is not None and last_actual is not None:
                            retry2_move, _rlabel, _ru = jss._retry_progress(
                                retry_base, last_actual, tol_deg)
                        retry_move_after_deg = retry2_move
                        if retry_arrived:
                            _log("再送で到達しました（{}）".format(label))
                        elif (retry2_move is not None
                                and _is_finite_num(retry2_move)
                                and retry2_move >= RETRY_NO_MOVE_THRESHOLD_DEG):
                            _warn("再送でも許容差に入りませんでしたが "
                                  "{:.2f}° 動いています（>= {:.1f}°）。"
                                  "**止めずに次の区間へ進みます**".format(
                                      retry2_move, RETRY_NO_MOVE_THRESHOLD_DEG))
                            seg_warnings.append("retry_timeout_but_moved")
                        elif retry2_move is None or not _is_finite_num(retry2_move):
                            _warn("再送のあとの移動量が分かりません"
                                  "（基準または実測が無い）。"
                                  "**止めずに次の区間へ進みます**")
                            seg_warnings.append("retry_move_unknown")
                        else:
                            aborted_at = "retry_no_move"
                            raise _Aborted(
                                "step{}_{}".format(
                                    step_no, _stage_name(s["to_name"])),
                                "**送り直してもアームが動きません**"
                                "（再送後の移動 {:.2f}° < {:.1f}° / "
                                "目標まで {}°）。これが唯一の中断条件です。"
                                "これ以降は何も送りません"
                                "（HOME へは自動で戻りません）".format(
                                    retry2_move, RETRY_NO_MOVE_THRESHOLD_DEG,
                                    ("{:.2f}".format(last_max)
                                     if last_max is not None else "None")))

                # pose_used（台帳 37-50）用: PICK / PLACE で最後に読めた実測角。
                # 到達していなくても「実際にそこで爪を動かした姿勢」を残す。
                if s["to_name"] == "PICK" and last_actual is not None:
                    log_record.setdefault("pose_used", {})["pick_used"] = list(
                        last_actual)
                if s["to_name"] == "PLACE" and last_actual is not None:
                    log_record.setdefault("pose_used", {})["place_used"] = list(
                        last_actual)
            except BaseException:
                # 到達待ちの最中に外から来た中断（Ctrl-C / 実測 j4 のハード帯 ABORT など）
                # codex R8 O3: 送信中の中断を arrival_wait と書かない
                if aborted_at is None:
                    aborted_at = phase
                raise
            finally:
                segments_log.append({
                    "step": step_no, "kind": "move",
                    "from_name": s["from_name"], "to_name": s["to_name"],
                    "stage": _stage_name(s["to_name"]),
                    "critical": bool(s.get("critical")),
                    "max_delta_deg": round(float(s["max_delta"]), 3),
                    "arrival_ok": (None if arrived is None else bool(arrived)),
                    "arrival_max_delta_deg": (round(float(last_max), 3)
                                              if last_max is not None else None),
                    "arrival_actual": last_actual,
                    "send_failures": send_failures,
                    # 単発送信方式: 送信 1 回の daemon 往復時間と、
                    # 送信から到達確認が終わる（または中断する）までの実時間
                    "send_rtt_sec": (round(send_rtt_sec, 4)
                                     if send_rtt_sec is not None else None),
                    "segment_elapsed_sec": round(time.monotonic() - t_seg, 3),
                    "aborted_at": aborted_at,
                    # ---- 項目1: この区間に使った許容差とタイムアウト ----
                    "arrival_tol_deg": tol_deg,
                    "arrival_tol_source": tol_src,
                    "arrival_timeout_sec": round(float(timeout_sec), 2),
                    "pre_actual": pre_actual,
                    "pre_max_delta_deg": (round(float(pre_max), 3)
                                          if pre_max is not None else None),
                    # ---- 項目5: 送り直したか / 送り直しで届いたか ----
                    "retried": bool(retried),
                    "retry_arrived": (None if retry_arrived is None
                                      else bool(retry_arrived)),
                    "retry_reason": retry_reason,
                    "retry_move_deg": (round(float(retry_move_deg), 3)
                                       if retry_move_deg is not None
                                       and _is_finite_num(retry_move_deg) else None),
                    "retry_move_after_deg": (round(float(retry_move_after_deg), 3)
                                             if retry_move_after_deg is not None
                                             and _is_finite_num(retry_move_after_deg)
                                             else None),
                    "retry_no_move_threshold_deg": RETRY_NO_MOVE_THRESHOLD_DEG,
                    "retry_pause_sec": (RETRY_PAUSE_SEC if retried else None),
                    "send_rtt_retry_sec": (round(send_rtt_retry_sec, 4)
                                           if send_rtt_retry_sec is not None
                                           else None),
                    # 依頼 213: send_rtt_sec は どちらの待ち方でも 1.0 秒の待ちを含む（送信の始めから
                    # 到達の確かめに入るまで）。send_daemon_rtt_sec は daemon とのやりとりだけ
                    # （"mac" では待ちを含まない・"daemon" では含む）
                    "send_wait_on": SEND_WAIT_ON,
                    "send_daemon_rtt_sec": (round(send_daemon_rtt_sec, 4)
                                            if send_daemon_rtt_sec is not None else None),
                    "send_daemon_rtt_retry_sec": (round(send_daemon_rtt_retry_sec, 4)
                                                  if send_daemon_rtt_retry_sec is not None
                                                  else None),
                    # 2026-10-19 方針変更: 止めずに続けた事象はここに残す
                    "warnings": list(seg_warnings),
                })
            # codex R11 A1: 次の爪の静止確認が使う「直前の目標と許容差」
            last_move_target = list(s["to"])
            last_move_tol = tol_deg
            step_no += 1

        result = "completed"
        abort = None
    except _Aborted as e:
        _abort_msg("{}（これ以降の送信を停止します。HOME 復帰等は人が判断してください）"
                   .format(e.reason))
        result = "aborted"
        abort = {"stage": e.stage, "reason": e.reason}
    except KeyboardInterrupt:
        print("")
        _warn("Ctrl-C 検出。新しい送信を停止します（mc.stop は呼びません）")
        result = "interrupted"
        abort = {"stage": "keyboard_interrupt", "reason": "Ctrl-C"}
    except BaseException as e:
        # codex R1 D5: 予期しない例外も必ず「中断」として確定させる。
        # ここで握らないと試行 JSON・台帳に 1 行も残らず、追記義務
        # （data_manifest_rules 6節）を破る。再送はしない（自動 HOME 復帰もしない）。
        print("")
        _abort_msg("予期しない例外で中断します（これ以降の送信を停止します。"
                   "HOME 復帰等は人が判断してください）: {}: {}".format(
                       type(e).__name__, e))
        result = "error"
        abort = {"stage": "unexpected_exception",
                 "reason": "{}: {}".format(type(e).__name__, e),
                 "traceback": traceback.format_exc()}
    finally:
        # set_fresh_mode(0) は正常・異常いずれでも実行（Pi 配備版と同じ try/finally）
        try:
            daemon_set_fresh_mode(0)
            _log("daemon_set_fresh_mode(0) 完了")
        except Exception as e:
            _warn("daemon_set_fresh_mode(0) で例外: {}: {}".format(type(e).__name__, e))

    motion_elapsed = time.monotonic() - t_motion_start
    # A4-3: 1 tick の send_angles 往復時間と tick 全体の周期を、平均・最大・
    # p50・p99 で残す（daemon が送信のたびに角度を読み直すので、0.1s 周期が
    # 守れず Pi 直より遅くなる可能性がある。それを数字で見るため）。
    # 単発送信方式の計測。1 試行の送信は STEP 1 + 9 区間 = 10 回なので
    # 生の配列をそのまま残す（集約値だけでは遅い区間が追えない）。
    seg_elapsed = [sg.get("segment_elapsed_sec") for sg in segments_log
                   if sg.get("kind") == "move"]
    timing = {
        "mode": "single_send_per_segment",
        "speed": SPEED_SINGLE,
        "send_timeout_sec": DAEMON_SEND_TIMEOUT_SEC,
        # 項目1: 許容差は区間ごと（区間の記録に arrival_tol_deg がある）
        "arrival_tol_by_segment": {k: v[0]
                                   for k, v in ARRIVAL_TOL_BY_SEGMENT.items()},
        "arrival_tol_source": "run_pick_place.py の stage 値",
        "arrival_timeout_min_sec": ARRIVAL_TIMEOUT_MIN_SEC,
        "arrival_timeout_rule": "clamp(2.0 + max|Δ|/20*3.0, 8.0, 30.0)",
        # 項目3: silent_drop 対処
        "retry_policy": "本線 j0_sweep_scan._send_and_wait_arrival と同じ"
                        "（同じ目標へ 1 回だけ・ループしない・HOME へ戻さない）",
        "retry_pause_sec": RETRY_PAUSE_SEC,
        "retry_no_move_threshold_deg": RETRY_NO_MOVE_THRESHOLD_DEG,
        "arrival_poll_sleep_sec": ARRIVAL_POLL_SLEEP,
        # codex R7 N6: ここは **move 区間の成功送信数**（先頭 HOME は含まない）。
        # 先頭 HOME は first_move_send_rtt_sec に別枠で入る。
        "move_sends_ok": len(send_rtts),
        "first_move_send_included": False,
        "send_rtt_raw_sec": [round(t, 4) for t in send_rtts],
        "send_rtt": _stats(send_rtts, "send_rtt"),
        # 送信から到達確認が終わるまで（区間ごと・move 区間のみ）
        "segment_elapsed_raw_sec": [x for x in seg_elapsed],
        "segment_elapsed": _stats(seg_elapsed, "segment_elapsed"),
    }
    log_record["segments"] = segments_log
    log_record["actual_sampling"] = sampler.summary(motion_elapsed)
    log_record["tick_timing"] = timing
    log_record["send_failures"] = {
        "total": streak["total_send_failures"],
        "max_consecutive": streak["max_consecutive_send_failures"],
        "abort_streak": SEND_FAIL_ABORT_STREAK,
    }
    log_record["result"] = result
    log_record["abort"] = abort
    if sampler.last is not None:
        log_record["final_actual"] = list(sampler.last)
    if sampler.nonfinite_reads:
        _warn("実測角の読み取り {} 回が有限でない値のため失敗扱いになりました"
              "（試行 JSON の actual_sampling.nonfinite_reads）".format(
                  sampler.nonfinite_reads))
    if sampler.j4_out_of_range_count:
        _warn("実測 j4 が J4_SAFE 外に読めた回数 = {}（最初の数件: {}）。"
              "送信は止めていません（記録のみ・エイイチ判断。"
              "[{:+.1f}, {:+.1f}] の外なら ABORT する）".format(
                  sampler.j4_out_of_range_count, sampler.j4_out_of_range[:5],
                  J4_HARD_MIN, J4_HARD_MAX))

    hz = log_record["actual_sampling"]["hz"]
    _log("実測角の読み取り: ok {}/{} 回, 実効 {} Hz（目標 {} Hz 以上）".format(
        sampler.ok, sampler.attempted,
        ("{:.2f}".format(hz) if hz is not None else "計測不能"),
        ACTUAL_READ_TARGET_HZ))
    if hz is not None and hz < ACTUAL_READ_TARGET_HZ:
        _warn("実測角の読み取りが目標 {} Hz を下回りました（{:.2f} Hz）。"
              "学習データの state 密度が 19 本より薄くなります".format(
                  ACTUAL_READ_TARGET_HZ, hz))
    sr = timing["send_rtt"]
    se = timing["segment_elapsed"]
    if sr["n"]:
        _log("send_angles の daemon 往復 ({} 回): 平均 {:.3f}s / p50 {:.3f}s / "
             "最大 {:.3f}s（timeout {:.1f}s）".format(
                 sr["n"], sr["mean_sec"], sr["p50_sec"], sr["max_sec"],
                 DAEMON_SEND_TIMEOUT_SEC))
        if sr["max_sec"] is not None and sr["max_sec"] > 1.0:
            _warn("送信 1 回に {:.3f}s かかった回があります。daemon は送信後に"
                  "角度を読み直すので、動き始めで読めないと伸びます"
                  "（単発送信なので試行全体への影響は小さい）".format(sr["max_sec"]))
    if se["n"]:
        _log("区間の所要（送信→到達確認まで）({} 区間): 平均 {:.2f}s / "
             "最大 {:.2f}s".format(se["n"], se["mean_sec"], se["max_sec"]))

    return result


# ---- 人の判定 ---------------------------------------------------------------
def _ask_yes_no(question, max_attempts=ASK_MAX_ATTEMPTS):
    """y/n を聞く. EOF / Ctrl-C / 回数超過は 'unknown' を返す（勝手に yes にしない）.

    回数上限を置くのは、stdin が EOF を返さず空文字を返し続ける環境
    （リダイレクト・非対話シェル等）で無限ループにならないようにするため。
    """
    for _ in range(max_attempts):
        try:
            ans = input("{} {} (y/n) > ".format(LOG_PREFIX, question)).strip().lower()
        except (EOFError, KeyboardInterrupt):
            print("")
            _warn("入力が得られませんでした → unknown")
            return "unknown"
        if ans in ("y", "yes"):
            return "yes"
        if ans in ("n", "no"):
            return "no"
        print("{} y か n で答えてください".format(LOG_PREFIX))
    _warn("{} 回入力しても y/n になりませんでした → unknown".format(max_attempts))
    return "unknown"


# ---- 台帳追記 ---------------------------------------------------------------
def _ledger_mm(xz, idx):
    if not (isinstance(xz, (list, tuple)) and len(xz) > idx
            and isinstance(xz[idx], (int, float))):
        return ""
    return "{:.1f}".format(xz[idx] * 1000.0)


def _read_recording_meta(run_dir):
    """recorder が書く recording_meta.json を有界待ちで読む（本線と同値の 2.0s / 100ms）.

    後からの reconcile はしない（台帳は追記のみ・data_manifest 7節）。
    """
    path = ""
    fps = ""
    frames = ""
    status = "none"
    try:
        meta_path = Path(run_dir) / "recording" / "recording_meta.json"
        deadline = time.monotonic() + RECORDING_META_POLL_TIMEOUT_SEC
        while not meta_path.is_file():
            remaining = deadline - time.monotonic()
            if remaining <= 0:
                break
            time.sleep(min(RECORDING_META_POLL_INTERVAL_SEC, remaining))
        if meta_path.is_file():
            meta = json.loads(meta_path.read_text())
            path = str(meta.get("recording_path") or "recording/")
            f = meta.get("effective_fps")
            fps = "{:.3f}".format(f) if isinstance(f, (int, float)) else ""
            fc = meta.get("frames_captured")
            if not isinstance(fc, int):
                fc = meta.get("frame_count")
            frames = str(fc) if isinstance(fc, int) else ""
            status = str(meta.get("status") or "none")
    except Exception:
        status = "none"
    return path, fps, frames, status


def _append_ledger(log_record, run_stem, run_dir, recording_enabled):
    """試行 1 行を台帳へ追記する（完走でも中断でも・data_manifest 6節）.

    fire-and-forget: 例外で制御を止めない。ローカルへ fallback しない。
    列定義は run_pick_place.LEDGER_COLS を import して使い、実体ヘッダと
    一致しなければ追記しない（本線と同じ追記ガード）。
    """
    try:
        # codex R1 D6: 追記の直前にマウントを再確認（ローカルへ fallback しない）
        if not _ensure_ssd_mounted():
            print("[LEDGER] KIOXIA 未マウント or 書込不可 → CSV スキップ "
                  "（ローカルへは書きません）")
            return

        judgments = log_record.get("judgments") or {}
        pick_v = (judgments.get("pick") or {}).get("human_verdict") or ""
        place_v = (judgments.get("place") or {}).get("human_verdict") or ""

        before = log_record.get("positions_before_replay") or {}
        measure = log_record.get("measure") or {}
        block_xz = before.get("block_xz_m") or measure.get("block_xz_m")
        box_xz = before.get("box_xz_m") or measure.get("box_xz_m")

        final = log_record.get("final_actual") or [None] * 6

        def _fmt_j(v):
            return ("{:.2f}".format(v) if isinstance(v, (int, float)) else "")

        pose_used = log_record.get("pose_used") or {}
        pick_used = pose_used.get("pick_used") or [None] * 6
        place_used = pose_used.get("place_used") or [None] * 6

        teach_name = (log_record.get("teach") or {}).get("file") or ""
        pick_pose_id = "teach:{}:PICK".format(teach_name) if teach_name else ""
        place_pose_id = "teach:{}:PLACE".format(teach_name) if teach_name else ""

        grip = log_record.get("gripper_last_state")

        # 指示どおり、埋めるのは下の列だけ。それ以外は空欄のまま。
        # 例外は recording_* 4 列（79-82）。recording_status は
        # data_manifest 2節で「空欄不可」と定義されており、かつこのスクリプトは
        # 連続記録を残すこと自体が目的なので埋める（--no-record 時は "none"）。
        row = dict((c, "") for c in LEDGER_COLS)
        row.update({
            "timestamp":     log_record.get("ended_at") or datetime.now().isoformat(),
            "run_stem":      run_stem,
            "trial_no":      rpp._ledger_extract_trial_no(run_stem),
            "pick_verdict":  pick_v,
            "place_verdict": place_v,
            "block_pick_x":  _ledger_mm(block_xz, 0),
            "block_pick_z":  _ledger_mm(block_xz, 1),
            "box_x":         _ledger_mm(box_xz, 0),
            "box_z":         _ledger_mm(box_xz, 1),
            "final_j1":      _fmt_j(final[0]),
            "final_j2":      _fmt_j(final[1]),
            "final_j3":      _fmt_j(final[2]),
            "final_j4":      _fmt_j(final[3]),
            "final_j5":      _fmt_j(final[4]),
            "final_j6":      _fmt_j(final[5]),
            "gripper":       ("" if grip is None else str(grip)),
            "run_dir":       str(run_dir),
            "pick_pose_id":  pick_pose_id,
            "pick_used_j0":  _fmt_j(pick_used[0]),
            "pick_used_j1":  _fmt_j(pick_used[1]),
            "pick_used_j2":  _fmt_j(pick_used[2]),
            "pick_used_j3":  _fmt_j(pick_used[3]),
            "pick_used_j4":  _fmt_j(pick_used[4]),
            "pick_used_j5":  _fmt_j(pick_used[5]),
            "place_pose_id": place_pose_id,
            "place_used_j0": _fmt_j(place_used[0]),
            "place_used_j1": _fmt_j(place_used[1]),
            "place_used_j2": _fmt_j(place_used[2]),
            "place_used_j3": _fmt_j(place_used[3]),
            "place_used_j4": _fmt_j(place_used[4]),
            "place_used_j5": _fmt_j(place_used[5]),
        })

        if recording_enabled:
            rec_path, rec_fps, rec_frames, rec_status = _read_recording_meta(run_dir)
        else:
            rec_path, rec_fps, rec_frames, rec_status = "", "", "", "none"
        row.update({
            "recording_path":   rec_path,
            "recording_fps":    rec_fps,
            "recording_frames": rec_frames,
            "recording_status": rec_status,
        })
        log_record["recording_meta_read"] = {
            "recording_path": rec_path, "recording_fps": rec_fps,
            "recording_frames": rec_frames, "recording_status": rec_status,
        }

        is_new = not LEDGER_CSV_PATH.exists()
        if not is_new:
            # 本線と同じ追記ガード: 既存ヘッダと LEDGER_COLS が不一致なら追記しない
            # （不一致のまま append すると列ズレで台帳が汚れる）。
            try:
                with open(str(LEDGER_CSV_PATH), "r", newline="") as fchk:
                    existing_header = next(csv.reader(fchk), None)
            except Exception as e:
                print("[LEDGER] [WARN] ヘッダ読込失敗 ({}). append スキップ".format(e))
                return
            if existing_header != LEDGER_COLS:
                print("[LEDGER] [ABORT-APPEND] 既存ヘッダ ({} 列) と LEDGER_COLS "
                      "({} 列) が不一致 → append スキップ".format(
                          len(existing_header) if existing_header is not None else 0,
                          len(LEDGER_COLS)))
                return
        with open(str(LEDGER_CSV_PATH), "a", newline="") as f:
            w = csv.DictWriter(f, fieldnames=LEDGER_COLS)
            if is_new:
                w.writeheader()
            w.writerow(row)
        print("[LEDGER] append OK: {} (pick={} place={} recording_status={})".format(
            LEDGER_CSV_PATH, pick_v or "''", place_v or "''", rec_status))
    except Exception as e:
        print("[LEDGER] [WARN] append 例外（制御は継続）: {}: {}".format(
            type(e).__name__, e))


# ---- run --------------------------------------------------------------------
def _print_open_gripper_hint():
    print("")
    print("{} [SAFETY] 動きを止めるときはアームの電源を切ること"
          "（Ctrl-C では進行中の移動は止まりません）。".format(LOG_PREFIX))
    print("{} 爪が閉じたままの場合は、次の1行で開きます:".format(LOG_PREFIX))
    print("  python3 -c \"import sys;sys.path.insert(0,'{}');"
          "from visual_servo_pick import daemon_set_gripper;"
          "daemon_set_gripper(0)\"".format(_SCRIPTS_ROOT))


def cmd_run(args):
    global GRIP_VALUE, POWER, SEND_WAIT_ON
    _note_tol_source()

    # 依頼 152: 爪の閉じる値（計画の表示・再生の閉じる指令・試行 JSON がすべてこの値を使う）
    if getattr(args, "grip_value", None) is not None:
        if not (GRIP_VALUE_RANGE[0] <= args.grip_value <= GRIP_VALUE_RANGE[1]):
            _abort_msg("--grip-value は {}〜{} の整数で指定してください（指定: {}）".format(
                GRIP_VALUE_RANGE[0], GRIP_VALUE_RANGE[1], args.grip_value))
            sys.exit(2)
        GRIP_VALUE = int(args.grip_value)
    _log("爪の閉じる値: {}{}".format(
        GRIP_VALUE, "（--grip-value）" if getattr(args, "grip_value", None) is not None else "（既定）"))

    # 依頼 156: 電源の種類（試行 JSON の power に残し、爪の位置と電圧も読む）。動き・待ち時間は変えない
    power = getattr(args, "power", None)
    if power is not None:
        if not POWER_RE.match(power):
            _abort_msg("--power は 2A・5A のように 数字 + A で指定してください（指定: {}）".format(power))
            sys.exit(2)
        if getattr(args, "no_currents", False) or getattr(args, "no_record", False):
            _abort_msg("--power は電流の記録と一緒に使います（--no-currents・--no-record とは併用できません）")
            sys.exit(2)
        _log("電源: {}（--power。試行 JSON の power に残し、爪の位置と電圧も読みます）".format(power))
    POWER = power

    # 依頼 213: 送信のあとの 1.0 秒をどこで待つか（長さは変えない）
    send_wait_on = getattr(args, "send_wait_on", None) or "mac"
    if send_wait_on not in SEND_WAIT_ON_CHOICES:
        _abort_msg("--send-wait-on は {} のどれかで指定してください（指定: {}）".format(
            " / ".join(SEND_WAIT_ON_CHOICES), send_wait_on))
        sys.exit(2)
    SEND_WAIT_ON = send_wait_on
    _log("送信のあとの {:.1f}s の待ち: {}".format(
        SEND_WAIT_SEC,
        "Mac 側（daemon へは wait=0。この間も電流の記録スレッドが読みます）" if SEND_WAIT_ON == "mac"
        else "daemon 側（依頼 202 までと同じ。この間は読みません）"))

    if args.teach_local and args.execute:
        _abort_msg("--teach-local は ドライラン専用です（--execute とは併用できません）。"
                   "実機では Pi から取得した教えた記録だけを再生します")
        sys.exit(2)

    teach_name = os.path.basename(args.teach)
    if teach_name != args.teach or not teach_name:
        _abort_msg("--teach はファイル名だけを渡してください（ディレクトリは "
                   "{} 固定）: {!r}".format(PI_TEACH_DIR, args.teach))
        sys.exit(2)

    dry_run = not args.execute
    recording_enabled = (not args.no_record) and args.execute
    _log("モード: {}{}".format(
        "ドライラン（アームに何も送りません）" if dry_run else "EXECUTE（実機）",
        "" if dry_run else ("  記録: {}".format("ON" if recording_enabled else "OFF (--no-record)"))))

    # KIOXIA は実機 run で必須（JSON・台帳・recorder の置き場）。
    # ドライランでも measure を読むので存在は要る。
    _require_ssd("teach 記録のコピー・試行 JSON・台帳の保存")

    staging_dir = Path(tempfile.mkdtemp(prefix="record_teach_demo_"))
    staged_teach = staging_dir / teach_name
    remote_path = None
    try:
        # ---- 1. 教えた記録の取得 ----
        if args.teach_local:
            src = Path(args.teach_local).expanduser()
            if not src.is_file():
                _abort_msg("--teach-local が見つかりません: {}".format(src))
                sys.exit(1)
            shutil.copy2(str(src), str(staged_teach))
            remote_path = "(local) {}".format(src)
            _warn("ドライラン用に Pi ではなくローカルの教えた記録を読みました: {}".format(src))
        else:
            remote_path = _fetch_teach_from_pi(teach_name, staged_teach)

        teach_sha = _sha256(staged_teach)

        # ---- 2. 姿勢の取り出しと計画（Pi と同じ実装を使う）----
        payload, angles, phases, gripper_events, count = wr._load_teach(str(staged_teach))
        waypoints, sources = wr._extract_waypoints(angles, phases, gripper_events, count)

        _log("入力ファイル: {}".format(teach_name))
        _log("抽出ウェイポイント:")
        for name in wr.PHASE_ORDER:
            print("  {:<14} <- {}".format(name, sources[name]))
            print("  {:<14}    angles = {}".format("", _fmt_angles(waypoints[name])))

        # ---- 肩が上限を超えた姿勢の置き換え（計画段階・送信前）--------------
        # 手で教えた PICK は肩 95.53〜99.22° で、send_angles が 4 回とも捨てられた。
        # 本線は肩 87.74 / 87.00 / 85.00 を送って 647 試行動いている。
        # 爪先位置を保ったまま肩を上限内に収めた姿勢に差し替える。
        # FK テーブルは読むだけ。IK は解かない。send_coords は使わない。
        waypoints_taught = dict((k, list(v)) for k, v in waypoints.items())
        waypoints, shoulder_fix_records = _fix_shoulder_over_max(waypoints)
        _print_shoulder_fix(shoulder_fix_records)
        shoulder_fix_payload = {
            "shoulder_max_deg": SHOULDER_MAX_DEG,
            "shoulder_max_source": "fk_lookup.J1_SAFE_MAX（本線）",
            "j0_tol_deg": SHOULDER_FIX_J0_TOL_DEG,
            "angle_penalty_m_per_deg": SHOULDER_FIX_ANGLE_PENALTY,
            "tip_warn_mm": SHOULDER_FIX_TIP_WARN_MM,
            "fk_table": fkl.FK_CSV.name,
            "fk_table_readonly": True,
            "n_replaced": sum(1 for r in shoulder_fix_records if r.get("applied")),
            "records": shoulder_fix_records,
            "waypoints_taught": dict((k, [round(x, 3) for x in v])
                                     for k, v in waypoints_taught.items()),
            "waypoints_sent": dict((k, [round(x, 3) for x in v])
                                   for k, v in waypoints.items()),
        }

        seq = wpsr._build_segments(waypoints)

        if wpsr._validate_endpoints(seq):
            _abort_msg("JOINT_LIMITS 違反があるため送信せず終了します")
            sys.exit(1)
        _log("JOINT_LIMITS 一括検証 OK（全 endpoint + HOME）")

        bad, n_poses_checked, min_j4_margin = _check_all_poses(seq, waypoints)
        if bad:
            _abort_msg("姿勢検査に通らないため動かす前に終了します")
            sys.exit(1)

        # ---- 3. 計画表示 ----
        # 指示書の手順どおり、計画は位置照合より前に出す（ドライランで Pi 版の
        # 出力と並べて比べられるようにする。カメラ・daemon が無くても出る）。
        current = None
        if not dry_run:
            get_daemon_socket()
            if USE_FAST_DAEMON_CMDS:
                # LOG352: 新 cmd が Pi に配備されているかを、アームを動かさずに確認
                _require_fast_cmds()
            _log("現在姿勢を daemon から取得します")
            for _ in range(5):
                a = daemon_get_angles(timeout_override=DAEMON_GET_TIMEOUT_SEC)
                if _is_valid_angles(a):   # 非有限値も弾く（C1）
                    current = [float(x) for x in a]
                    break
                time.sleep(0.2)
            if current is None:
                _abort_msg("現在姿勢が取得できません（daemon を確認してください）")
                sys.exit(1)
            _log("現在姿勢 = {}".format(_fmt_angles(current)))
            # 2026-10-19 方針変更（項目3）: 実測 j4 の範囲外は **WARN のみ**。
            # ハード帯（±98 / +68）でも止めない。
            if not (J4_HARD_MIN <= current[4] <= J4_HARD_MAX):
                _warn("現在の実測 j4 = {:+.2f} が [{:+.1f}, {:+.1f}] の外です。"
                      "**止めません**（WARN のみ・試行 JSON に残します）"
                      .format(current[4], J4_HARD_MIN, J4_HARD_MAX))
            if not (J4_SAFE_MIN <= current[4] <= J4_SAFE_MAX):
                _warn("現在の実測 j4 = {:+.2f} が J4_SAFE [{:+.1f}, {:+.1f}] の外です"
                      "（指令値の制限なので続行します・記録のみ）".format(
                          current[4], J4_SAFE_MIN, J4_SAFE_MAX))

        summary = _print_plan(current, seq)

        # ---- 4. ブロックが動いていないかの確認 ----
        # 2026-10-19 方針変更（項目4・エイイチ指示）: **ここでは止めない**。
        # カメラのずれ・ブロック検出の失敗・120mm ガード・homography の不良は
        # すべて WARN にして再生を続ける。位置が取れなければ試行 JSON に null。
        # 位置確認はつかみ損ねを防ぐための補助で、アームの安全装置ではない。
        prerun_warnings = []

        def _gate(reason):
            _warn("{}（**止めません**・WARN のみ）".format(reason))
            prerun_warnings.append(str(reason)[:200])
            return False

        move_detail = {"tol_mm": BLOCK_MOVE_TOL_MM}
        now_res = {}
        measure_path, measure_payload = _find_latest_measure(args.measure)
        if measure_path is None:
            _gate("measure が見つかりません（{}/{}*/measure_*.json）。"
                  "先に `record_teach_demo.py measure` を実行してください".format(
                      MEASURE_ROOT, MEASURE_DIR_PREFIX))
        elif measure_payload is None:
            _gate("measure が読めません（壊れている可能性）: {}".format(measure_path))
        else:
            _log("measure: {}".format(measure_path))
            _log("  measured_at = {}  block = {}  box = {}".format(
                measure_payload.get("measured_at"),
                _fmt_xz_mm(measure_payload.get("block_xz_m")),
                _fmt_xz_mm(measure_payload.get("box_xz_m"))))
            m_ts = measure_payload.get("measured_at_ts")
            if isinstance(m_ts, (int, float)):
                age = time.time() - float(m_ts)
                if age > MEASURE_STALE_WARN_SEC:
                    _warn("measure が {:.0f} 分前のものです。ブロックを置き直したなら "
                          "measure をやり直してください".format(age / 60.0))

            # 再生前の確認は **homography を作り直さず画素で比べる**
            # （エイイチ判断 2026-10-19）。四隅の検出が揺れると同じ画素が別の mm に
            # なるため、mm で比べると 37mm の外れ値を掴む。
            now_stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            _log("再生直前: 上カメラでマット四隅とブロック画素を確認します")
            H_meas = (measure_payload or {}).get("homography")
            # 四隅が measure と合わなければ最大 3 回やり直す（エイイチ判断）。
            # 1 回でも 15px 以内に収まれば、その回の値で続ける。
            insp, corner_attempts = _inspect_until_corners_match(
                (measure_payload or {}).get("mat_corners_px"), "再生直前")

            # 記録用の mm は measure の homography で換算する
            now_res = {}
            if insp and insp.get("block_px") and H_meas:
                bx, bz = _mm_from_px(H_meas, insp["block_px"][0],
                                     insp["block_px"][1])
                now_res["block_xz_m"] = [bx, bz]
            now_res["box_xz_m"] = (measure_payload or {}).get("box_xz_m")
            now_res["n_captures"] = (insp.get("n_frames") if insp else None)
            _log("再生直前: block = {}（measure の homography で換算）".format(
                _fmt_xz_mm(now_res.get("block_xz_m"))))

            check_img = Path(measure_path).parent / "prerun_{}.jpg".format(now_stamp)
            check_img_ok = _save_check_image(
                check_img, "pre-run {}".format(now_stamp),
                now_res.get("block_xz_m"), now_res.get("box_xz_m"),
                H=H_meas, frame=(insp.get("frame") if insp else None))
            now_res["check_image"] = str(check_img) if check_img_ok else None

            # 根元に近すぎるものはブロックとして扱わない
            too_close = _block_too_close_to_base(now_res.get("block_xz_m"))
            if too_close:
                if check_img_ok:
                    _log("何を拾ったかは確認画像で見てください: {}".format(check_img))
                _gate(too_close)

            ok, move_detail, move_reason = _check_camera_and_block_px(
                measure_payload, insp)
            move_detail["mat_corner_attempts"] = corner_attempts
            move_detail["mat_corner_retry_max"] = MAT_CORNER_RETRY_MAX
            # 2026-10-19（エイイチ判断・項目8）: **ブロックのずれが 5mm を
            # 超えても止めない**。差を表示して試行 JSON に残すだけにする。
            # 位置確認はつかみ損ねを防ぐための補助で、アームの安全装置ではない。
            # カメラが動いた / 検出できない / homography が壊れている場合は、
            # 「measure と比べられない」= 位置確認が成立しないので従来どおり止める。
            block_moved_only = (move_detail.get("fail_kind") == "block_moved")
            if not ok and block_moved_only:
                move_detail["gate"] = "warn_only"
                _warn("ブロックが measure 時から動いています（止めません・項目8）: {}"
                      .format(move_reason))
                _warn("  画素の差 {:.1f}px（許容 {:.1f}px = {:.1f}mm）/ "
                      "mm 換算の差 {:.2f}mm".format(
                          move_detail.get("block_shift_px", float("nan")),
                          move_detail.get("tol_px", float("nan")),
                          BLOCK_MOVE_TOL_MM_PX_BASIS,
                          move_detail.get("dist_mm", float("nan"))))
                _warn("  つかみ損ねる可能性があります。"
                      "気になるなら Enter の前に measure を取り直してください")
            if not ok and not block_moved_only:
                # codex R9 R3: 止める前に各回の記録を残す（原因分析に要る）
                move_detail["reject_json"] = _save_reject_json(
                    Path(measure_path).parent, now_stamp, "prerun",
                    move_reason or "", {
                        "measure_path": str(measure_path),
                        "measure_mat_corners_px":
                            (measure_payload or {}).get("mat_corners_px"),
                        "measure_block_px":
                            (measure_payload or {}).get("block_px"),
                        "check_image": now_res.get("check_image"),
                        "detail": move_detail,
                    })
            if not ok and not block_moved_only:
                _gate(move_reason)
            elif ok:
                _log("ブロック位置の照合 OK（画素の差 {:.1f}px <= 許容 {:.1f}px "
                     "= {:.1f}mm / mm 換算の差 {:.2f}mm）".format(
                         move_detail.get("block_shift_px", float("nan")),
                         move_detail.get("tol_px", float("nan")),
                         BLOCK_MOVE_TOL_MM_PX_BASIS,
                         move_detail.get("dist_mm", float("nan"))))
                if move_detail.get("mat_corner_shift_max_px") is not None:
                    _log("マット四隅のずれ 最大 {:.1f}px（上限 {:.1f}px・"
                         "やり直し {} 回）".format(
                             move_detail["mat_corner_shift_max_px"],
                             MAT_CORNER_SHIFT_ABORT_PX, len(corner_attempts)))

        if dry_run:
            _log("ドライランなので、ここで終了します（アームには何も送っていません）")
            _log("Pi 版と比べる点: 抽出ウェイポイント 4 姿勢と各区間の max|Δ| は同じ。"
                 "送り方は単発（Pi 版は 0.1s 補間ストリーミング）なので "
                 "n_steps / ticks は比較対象外。送信 {} 回 / 想定所要 ≈ {:.1f}s".format(
                     summary["n_moves"] + 1, summary["estimated_sec"]))
            return 0

        print("{} [SAFETY] 再生中はグリッパーが実機で開閉します。爪に指を挟まないこと。"
              .format(LOG_PREFIX))
        # codex R3 C4: Ctrl-C は「新しい送信をやめる」だけで、すでに daemon へ
        # 渡った命令や進行中の移動は止まらない。実機の停止手段は電源を切ること
        # （2026-10-18 からの運用）。
        print("{} [SAFETY] 止めるときはアームの電源を切ること。"
              "Ctrl-C は新しい送信をやめるだけで、進行中の移動は止まりません。"
              .format(LOG_PREFIX))
        # 2026-10-19（エイイチ判断・項目7）: 開始前の「爪は開いているか」の y/n は
        # 削除した（本線 run_pick_place.py にも同じ確認は無く、STEP 2 の open が
        # PICK の前に必ず入る）。開いたかの自動確認はしない（gv は使わない）ので、
        # 判定は終了後の人の y/n と動画だけになる。
        print("{} [SAFETY] 開いたかの自動確認はしません（gv は使わない）。"
              "STEP 2 で open を送ってから PICK へ降ります。".format(LOG_PREFIX))
        print("{} 周囲に手・物が無いか確認してください。OK なら Enter で開始".format(LOG_PREFIX))
        try:
            input()
        except (EOFError, KeyboardInterrupt):
            print("")
            _abort_msg("開始前に中止しました（アームには何も送っていません）")
            sys.exit(1)

        first_max_diff = _max_axis_diff_finite(HOME_ANGLES, current)
        if first_max_diff is None:
            _abort_msg("現在姿勢と HOME の差を有限な数値として計算できません: "
                       "current={!r}".format(current))
            sys.exit(1)
        if first_max_diff > FIRST_MOVE_WARN_DEG:
            _warn("先頭移動の最大軸差 {:.2f}° > {:.1f}°。急加速の可能性があります".format(
                first_max_diff, FIRST_MOVE_WARN_DEG))
            print("{} 続行するには 'yes' と入力してください（それ以外は中止）".format(LOG_PREFIX))
            try:
                ans = input().strip()
            except (EOFError, KeyboardInterrupt):
                print("")
                ans = ""
            if ans != "yes":
                _abort_msg("中止しました（差分が大きいため・アームには何も送っていません）")
                sys.exit(1)

        # ---- 5. 試行フォルダの用意（データと対のコード原則）----
        # codex R1 D6: 保存の直前にマウントを再確認する（Enter 待ちの間に
        # SSD が外れていたら、ローカル側にディレクトリを作らせず失敗させる）。
        _require_mount_now("試行フォルダの作成")
        # codex R1 B4: 競合しない採番（mkdir(exist_ok=False) → 取れなければ次の番号）
        run_dir, run_stem = _next_run_dir()
        log_path = run_dir / (run_stem + ".json")
        teach_dir = run_dir / "teach"
        teach_dir.mkdir(parents=True, exist_ok=True)
        teach_copy = teach_dir / teach_name
        shutil.copy2(str(staged_teach), str(teach_copy))
        _log("試行フォルダ: {}".format(run_dir))
        _log("教えた記録のコピー: {}".format(teach_copy))

        log_record = {
            "script": _THIS.name,
            "source": "teach_replay",
            "run_stem": run_stem,
            "run_dir": str(run_dir),
            "started_at": datetime.now().isoformat(),
            "recording_enabled": recording_enabled,
            # 依頼 152: 爪の閉じる値（--grip-value。付けなければ 20）
            "grip_value": GRIP_VALUE,
            # 依頼 156: 電源の種類（--power。付けなければ None）
            "power": POWER,
            # 依頼 213: 送信のあとの 1.0 秒をどこで待ったか（mac = Mac 側・電流の記録スレッドが読める /
            # daemon = 依頼 202 までと同じ）
            "send_wait_on": SEND_WAIT_ON,
            # 肩が上限を超えた姿勢の置き換え（計画段階で決まったもの）
            "shoulder_fix": shoulder_fix_payload,
            "teach": {
                "file": teach_name,
                "remote_path": remote_path,
                "local_copy": str(teach_copy),
                "sha256": teach_sha,
                "schema_version": payload.get("schema_version"),
                "n_angles": count,
                # 置き換え後（= 実際に送る）姿勢。教えた値は shoulder_fix に残す
                "waypoints": dict((k, list(v)) for k, v in waypoints.items()),
                "waypoints_taught": dict((k, list(v))
                                         for k, v in waypoints_taught.items()),
                "waypoint_sources": dict(sources),
            },
            "measure": {
                "path": str(measure_path),
                "measured_at": measure_payload.get("measured_at"),
                "block_xz_m": measure_payload.get("block_xz_m"),
                "box_xz_m": measure_payload.get("box_xz_m"),
                "detect_score": measure_payload.get("detect_score"),
            },
            "positions_before_replay": {
                "block_xz_m": now_res.get("block_xz_m"),
                "box_xz_m": now_res.get("box_xz_m"),
                "detect_score": now_res.get("detect_score"),
                "n_captures": now_res.get("n_captures"),
                "resolved_top_index": now_res.get("resolved_top_index"),
                "check_image": now_res.get("check_image"),
                "block_dist_from_base_mm": (
                    round(_dist_from_base_mm(now_res.get("block_xz_m")), 1)
                    if _dist_from_base_mm(now_res.get("block_xz_m")) is not None
                    else None),
                "block_min_dist_from_base_mm": BLOCK_MIN_DIST_FROM_BASE_MM,
            },
            "block_move_check": move_detail,
            # 2026-10-19 方針変更（項目4）: 再生前の確認で止めずに続けた事象
            "prerun_warnings": list(prerun_warnings),
            # グリッパー確認の実施状況（後から、どう確認した試行か分かるように）
            "gripper_check": {
                # gv（get_gripper_value）は使わない。2026-10-19 の段階C で
                # 読み取りの直後にシリアル同期が壊れた疑いがあるため外した。
                "method": "open_twice_no_readback",
                "verified_by": "human_y_n",
                # 自動確認をしないので True/False は付けない（None のまま）。
                # build_demo_episodes.py が除外するのは verified が False の試行だけ
                # なので、None なら除外されない。実際に開いたかは人の judgments
                #（pick / place）と動画で判断する。
                "verified": None,
                # 項目7: 開始前の目視 y/n は削除した（本線と同じく確認しない）
                "first_open_visual_confirmed": None,
                # codex R10 S3: open を 2 回送るが、recorder へ出す時刻は
                # 1 回目で固定している（どちらで開いたかは記録に無い）。
                "label_time_assumes_first_attempt": True,
                "open_pre_sleep_sec": 0.0,
                "open_dwell_sec": GRIPPER_OPEN_DWELL_SEC,
                "open_attempts": GRIPPER_OPEN_ATTEMPTS,
            },
            "current_angles_before_replay": list(current),
            "plan": dict(summary, segments=[
                {
                    "kind": s["kind"],
                    "action": s.get("action"),
                    "from_name": s.get("from_name"),
                    "to_name": s.get("to_name"),
                    "critical": bool(s.get("critical")),
                    "max_delta_deg": (round(float(s["max_delta"]), 3)
                                      if "max_delta" in s else None),
                }
                for s in seq
            ]),
            "constants": {
                "HOME_ANGLES": list(HOME_ANGLES),
                "SPEED_FIRST": SPEED_FIRST,
                "SPEED_PLAY": SPEED_PLAY,
                "FIRST_MOVE_SETTLE_SEC": FIRST_MOVE_SETTLE_SEC,
                "SPEED_SINGLE": SPEED_SINGLE,
                "motion_mode": "single_send_per_segment",
                "GRIP_VALUE": GRIP_VALUE,
                "GRIPPER_SPEED": GRIPPER_SPEED,
                "GRIPPER_DWELL_SEC": GRIPPER_DWELL_SEC,
                "ARRIVAL_TOL_BY_SEGMENT": {k: v[0] for k, v
                                           in ARRIVAL_TOL_BY_SEGMENT.items()},
                "ARRIVAL_TIMEOUT_MIN_SEC": ARRIVAL_TIMEOUT_MIN_SEC,
                "RETRY_PAUSE_SEC": RETRY_PAUSE_SEC,
                "RETRY_NO_MOVE_THRESHOLD_DEG": RETRY_NO_MOVE_THRESHOLD_DEG,
                "SEND_FAIL_ABORT_STREAK": SEND_FAIL_ABORT_STREAK,
                "J4_SAFE": [J4_SAFE_MIN, J4_SAFE_MAX],
                "poses_checked": n_poses_checked,
                "min_j4_margin_deg": (round(min_j4_margin, 3)
                                      if min_j4_margin is not None else None),
                "J4_MARGIN_WARN_DEG": J4_MARGIN_WARN_DEG,
                "J4_HARD_ABORT_BAND": [J4_HARD_MIN, J4_HARD_MAX],
                "BLOCK_MOVE_TOL_MM": BLOCK_MOVE_TOL_MM,
                "DAEMON_SEND_TIMEOUT_SEC": DAEMON_SEND_TIMEOUT_SEC,
                "DAEMON_GET_TIMEOUT_SEC": DAEMON_GET_TIMEOUT_SEC,
                "USE_FAST_DAEMON_CMDS": USE_FAST_DAEMON_CMDS,
                "DAEMON_GET_ONCE_TIMEOUT_SEC": DAEMON_GET_ONCE_TIMEOUT_SEC,
                "GRIPPER_OPEN_ATTEMPTS": GRIPPER_OPEN_ATTEMPTS,
                "GRIPPER_OPEN_POST_SLEEP_SEC": GRIPPER_OPEN_POST_SLEEP_SEC,
                "GRIPPER_OPEN_DWELL_SEC": GRIPPER_OPEN_DWELL_SEC,
                "DAEMON_SET_GRIPPER_PRE_SLEEP_SEC": DAEMON_SET_GRIPPER_PRE_SLEEP_SEC,
                "gripper_open_check": "none (gv unused / no pre-start y/n)",
                "SEND_WAIT_SEC": SEND_WAIT_SEC,
                "send_wait_on": SEND_WAIT_ON,
                "send_socket_timeout_sec": SEND_SOCKET_TIMEOUT_SEC,
                "send_socket_timeout_source": (
                    "visual_servo_pick._daemon_request: wait>0 なら wait+3.0。"
                    "timeout_override は短縮しかできないので渡していない"
                    if SEND_WAIT_ON == "daemon" else
                    "依頼 213: daemon へは wait=0 で送り、SEND_WAIT_SEC は Mac 側で待つ。"
                    "期限は daemon で待っていたときと同じ wait+3.0 を timeout_override で渡す"),
                "GRIPPER_STILL_TOL_DEG": GRIPPER_STILL_TOL_DEG,
                "GRIPPER_STILL_READS": GRIPPER_STILL_READS,
                "GRIPPER_STILL_TIMEOUT_SEC": GRIPPER_STILL_TIMEOUT_SEC,
                "J4_HARD_MARGIN_DEG": J4_HARD_MARGIN_DEG,
                "arrival_tol_source": (
                    "run_pick_place.py の stage 値を import"
                    "（TOL_HOME 2.5 / TOL_APPROACH 2.0 / TOL_PICK_PLACE 3.0 / "
                    "TOL_APPROACH_PLACE 3.0 / TOL_LIFT_BACK 3.0）。"
                    "一律 8.0（Pi 配備版 waypoint_streaming_replay.py L69）は"
                    "2026-10-19 にやめた"),
            },
        }

        # ---- 6. 記録開始 → 再生 ----
        # codex R1 D5: ここから先は「何が起きても試行 JSON と台帳に 1 行残す」。
        # trial_start 直後の待ち時間中の Ctrl-C も同じ扱いに含める。
        #
        # codex R2 D5: 試行フォルダを確保したあとの全処理を **外側の try/finally** で
        # 囲み、その finally から「試行 JSON の保存」と「台帳 1 行」をそれぞれ独立に
        # 1 回だけ試みる。trial_end() 中の Ctrl-C や、表示処理の例外でも保存に到達する。
        result = "error"
        hint_shown = False
        recorder = None
        saved = {"json": False, "ledger": False}

        def _finalize():
            """試行 JSON と台帳を、それぞれ独立に 1 回だけ保存する.

            二重記帳しないよう `saved` フラグで番をする（この関数は finally から
            1 回呼ばれるだけだが、将来の経路追加でも二重にならないようにする）。
            """
            if not saved["json"]:
                saved["json"] = True   # 試行済みを先に立てる（再入しない）
                try:
                    _require_mount_now("試行 JSON の保存")   # D6
                    _atomic_write_json(log_path, log_record)
                    saved["json"] = "ok"
                    _log("試行 JSON: {}".format(log_path))
                except BaseException as e:
                    _warn("試行 JSON の保存に失敗しました（台帳追記は続けます）: "
                          "{}: {}".format(type(e).__name__, e))
            if not saved["ledger"]:
                saved["ledger"] = True
                try:
                    # 台帳は完走でも中断でも 1 行（data_manifest_rules 6節）
                    _append_ledger(log_record, run_stem, run_dir, recording_enabled)
                    saved["ledger"] = "ok"
                except BaseException as e:
                    print("[LEDGER] [WARN] append 呼び出しで例外: {}: {}".format(
                        type(e).__name__, e))

        try:
            try:
                recorder = _Recorder(recording_enabled, run_stem)
                recorder.trial_start()
                if recording_enabled:
                    _log("recorder に trial_start を送りました。{:.1f}s 待ってから"
                         "動き出します（mp4 writer が開くまで）".format(
                             RECORDER_START_SETTLE_SEC))
                    # 読み取りはまだ始めない（recorder の writer が開くのを待つだけ）
                    time.sleep(RECORDER_START_SETTLE_SEC)
                    # 依頼 121: 爪と肩の電流を {run}/recording/currents.csv に残す（再生の間ずっと）
                    if not getattr(args, "no_currents", False):
                        recorder.start_current_actuals()   # 依頼 202
                        recorder.currents = _start_currents(
                            run_dir, angle_sink=recorder.actual_from_currents)
                    else:
                        _log("--no-currents: 爪と肩の電流は残しません")

                result = _replay(seq, recorder, log_record)
            except BaseException as e:
                # _replay は自前で全例外を握るので、ここに来るのは trial_start や
                # settle 中の Ctrl-C / 例外。中断として確定させる。
                print("")
                _abort_msg("再生の開始前後で中断しました: {}: {}".format(
                    type(e).__name__, e))
                result = ("interrupted" if isinstance(e, KeyboardInterrupt)
                          else "error")
                log_record["result"] = result
                log_record["abort"] = {
                    "stage": "before_replay",
                    "reason": "{}: {}".format(type(e).__name__, e),
                    "traceback": traceback.format_exc(),
                }
            finally:
                log_record.setdefault("result", result)
                log_record["ended_at"] = datetime.now().isoformat()
                # codex R1 C5 / R2 C5: 爪を開く1行は、非完走のときの
                # **いちばん最初**に出す（人の判定入力・保存より前）。
                # trial_end より先に出す（trial_end 中の Ctrl-C でも案内が残る）。
                # gripper の指令が失敗した場合は、その場で ABORT する作りに
                # 変えた（2026-10-19）ので result が completed にならない。
                if log_record.get("result") != "completed":
                    _print_open_gripper_hint()
                    hint_shown = True
                if recorder is not None and recorder.currents is not None:
                    # 依頼 121: trial_end より先に止める（電流の記録は再生の間だけ）。
                    # ここで止まりきらなくても、cmd_run の最後の finally（socket を閉じる前）で
                    # もう一度スレッドの終わりを待つ（_halt_currents）。
                    try:
                        log_record["currents"] = recorder.currents.stop()
                    except BaseException as e:
                        _warn("電流の記録を閉じるときに例外（続行）: {}: {}".format(
                            type(e).__name__, e))
                if recorder is not None:
                    try:
                        recorder.close_current_actuals()   # 依頼 202: 積んだ通知を trial_end の前に送り切る
                    except BaseException as e:
                        _warn("電流の記録の角度の通知を閉じるときに例外（続行）: {}: {}".format(
                            type(e).__name__, e))
                    log_record["recorder_actual_events_sent"] = recorder.actual_sent
                    # 依頼 202: 電流の記録スレッドの角度で送った actual 行（上の数には入れない）
                    log_record["recorder_actual_events_sent_current_thread"] = (
                        recorder.actual_sent_current_thread)
                    log_record["recorder_actual_current_thread_late"] = (
                        recorder.actual_current_thread_late)
                    log_record["recorder_actual_current_thread_errors"] = (
                        recorder.actual_current_thread_errors)
                    log_record["recorder_state_ts_backwards"] = recorder.state_ts_backwards
                    log_record["recorder_current_actuals_unsent"] = recorder.current_actuals_unsent
                    log_record["recorder_current_actuals_flush_timeout"] = (
                        recorder.current_actuals_flush_timeout)
                    log_record["recorder_send_failures"] = recorder.send_failures
                    log_record["recorder_last_send_error"] = (
                        recorder.last_send_error)
                    try:
                        recorder.trial_end()
                    except BaseException as e:
                        _warn("recorder への trial_end 通知で例外（続行）: {}: {}".format(
                            type(e).__name__, e))
                    # 依頼 202: 送り手が送り終えた数（trial_end の直後の値）と、trial_end も送り手に任せたか（ふつうは False）
                    log_record["recorder_state_rows_sent_by_sender"] = recorder.state_rows_sent_by_sender
                    log_record["recorder_trial_end_via_sender"] = recorder.trial_end_via_sender

            result = log_record.get("result") or result
            print("=" * 78)
            _log("再生 {}".format({"completed": "完了",
                                   "aborted": "中断（ABORT）",
                                   "interrupted": "中断（Ctrl-C）",
                                   "error": "中断（予期しない例外）"}.get(result, result)))
            print("=" * 78)

            # ---- 7. 人の判定（完走でも中断でも聞く。中断も台帳に残す）----
            try:
                if result != "completed":
                    _warn("中断した試行です。判定は見たとおりに答えてください"
                          "（学習には pick/place どちらも yes の試行だけが使われます）")
                pick_verdict = _ask_yes_no("つかめたか")
                place_verdict = _ask_yes_no("箱に入ったか")
            except BaseException as e:
                _warn("判定の入力中に中断しました（unknown として記録します）: "
                      "{}: {}".format(type(e).__name__, e))
                pick_verdict = place_verdict = "unknown"
            log_record["judgments"] = {
                "pick": {"human_verdict": pick_verdict, "verdict": pick_verdict,
                         "source": "human"},
                "place": {"human_verdict": place_verdict, "verdict": place_verdict,
                          "source": "human"},
            }
        finally:
            # ---- 8〜9. 試行 JSON → 台帳（何が起きても 1 回だけ）----
            _finalize()

        if saved["json"] != "ok":
            _warn("試行 JSON が保存できていません。build_demo_episodes.py は "
                  "この試行を missing として飛ばします")
        _log("次に進むには: python3 {}/pi05/build_demo_episodes.py --run {} "
             "--dataset mecharm_redblock_box_teach_v1".format(_SCRIPTS_ROOT, run_stem))
        if not hint_shown and result != "completed":
            _print_open_gripper_hint()
        ok = (result == "completed")
        return 0 if ok else 1

    finally:
        _halt_currents()   # 依頼 121: 電流の記録スレッドを止めてから socket を閉じる
        try:
            close_daemon_socket()
        except Exception:
            pass
        shutil.rmtree(str(staging_dir), ignore_errors=True)


# ---- CLI --------------------------------------------------------------------
def main():
    ap = argparse.ArgumentParser(
        description="手で教えた動きを daemon 経由で再生しながら π0.5 のお手本として記録する")
    sub = ap.add_subparsers(dest="cmd")

    ap_m = sub.add_parser("measure", help="上カメラでブロックと箱の位置を測って保存する")
    ap_m.add_argument("--repeat", type=int, default=MEASURE_REPEAT_DEFAULT,
                      help="検出回数（中央値集約・既定 {}）".format(MEASURE_REPEAT_DEFAULT))
    ap_m.add_argument("--interval", type=float, default=MEASURE_INTERVAL_DEFAULT,
                      help="検出間隔 秒（既定 {}）".format(MEASURE_INTERVAL_DEFAULT))
    ap_m.add_argument("--log", type=int, default=None,
                      help="保存先を teach_poses_LOG{NNN}/ にする（例: --log 352）。"
                           "省略時は teach_poses_{YYYYMMDD}/（LOG 番号を推測しない）")
    ap_m.set_defaults(func=cmd_measure)

    ap_r = sub.add_parser("run", help="教えた記録を再生しながら記録する")
    ap_r.add_argument("--teach", required=True,
                      help="Pi の {}/ にある teach JSON のファイル名".format(PI_TEACH_DIR))
    ap_r.add_argument("--execute", action="store_true",
                      help="実機に送る（未指定はドライラン＝計画表示のみ）")
    ap_r.add_argument("--no-record", action="store_true",
                      help="recorder に通知しない（段階C の検証用）")
    ap_r.add_argument("--no-currents", action="store_true",
                      help="爪と肩の電流（currents.csv。依頼 121）を残さない。"
                           "電流の読み取りを一切せず、依頼 121 の前と同じ動きになる")
    ap_r.add_argument("--measure", default=None,
                      help="使う measure JSON を明示する（既定は直近を自動で探す）")
    ap_r.add_argument("--grip-value", type=int, default=None,
                      help="爪の閉じる値（既定 {}。試行 JSON の grip_value に残す。依頼 152）".format(GRIP_VALUE))
    ap_r.add_argument("--power", default=None,
                      help="電源の種類（例 2A / 5A。試行 JSON の power に残し、爪の位置と電圧の番地も "
                           "recording/power_regs.csv に読む。動き・待ち時間は変えない。依頼 156。pi05/POWER_AB.md）")
    ap_r.add_argument("--send-wait-on", choices=SEND_WAIT_ON_CHOICES, default="mac",
                      help="送信のあとの {:.1f} 秒をどこで待つか（既定 mac: daemon へは wait=0 で送り Mac 側で待つ。"
                           "この間も電流の記録スレッドが角度を読む。daemon: 依頼 202 までと同じ）。"
                           "待つ長さは変えない。試行 JSON の send_wait_on に残す。依頼 213".format(SEND_WAIT_SEC))
    ap_r.add_argument("--repeat", type=int, default=MEASURE_REPEAT_DEFAULT,
                      help="再生直前の検出回数（既定 {}）".format(MEASURE_REPEAT_DEFAULT))
    ap_r.add_argument("--interval", type=float, default=MEASURE_INTERVAL_DEFAULT,
                      help="再生直前の検出間隔 秒（既定 {}）".format(MEASURE_INTERVAL_DEFAULT))
    ap_r.add_argument("--teach-local", default=None,
                      help="【ドライラン専用】Pi ではなくローカルの teach JSON を読む "
                           "（Pi 不在でも計画を比べられるようにするため。--execute とは併用不可）")
    ap_r.set_defaults(func=cmd_run)

    args = ap.parse_args()
    if not getattr(args, "func", None):
        ap.print_help()
        return 2
    try:
        return args.func(args)
    except KeyboardInterrupt:
        print("")
        _warn("Ctrl-C で終了しました")
        _print_open_gripper_hint()
        return 130


if __name__ == "__main__":
    sys.exit(main())
```

### pi05/policy_recorder.py


```python
#!/usr/bin/env python3
"""policy_recorder.py — 実機推論 (run_policy_client.py --execute) の間, 上カメラと実測角を 1 秒 10 コマで残す (2026-10-29).

お手本 (record_teach_demo.py + recorder.py --top) と同じ形で書くので,
build_demo_episodes.build_one() がそのまま読める:
  {run_dir}/recording/states.csv          recorder.py と同じ列. actual / gripper_cmd / stage 行.
                                          stage 列 = その時の状態 (model / rewind / correct / home / wait)
  {run_dir}/recording/top.mp4             上カメラ (元の大きさ. 10 コマ/秒)
  {run_dir}/recording/top_frame_log.csv   frame_idx, capture_ts (+ mode 列. 1 コマごとの状態)
  {run_dir}/recording/top_meta.json       コマ数・実効 fps など

アームへは何も送らない (関節角を読むだけ). daemon のソケットは 1 本を本体と共用するので,
install_daemon_lock() で 1 回のやりとりごとに鍵をかける (読み書きが混ざらないように).

2026-10-31 依頼 46: 送っている間の角度の抜けについて
  daemon は send_angles を受けると, 送ったあとに角度を読み直す (動いている間は読めずにやり直す) まで
  返事をしない (約 1.6 秒. 爪は約 3.6 秒). daemon は 1 本のつながりを 1 件ずつ処理するので, その間は
  記録スレッドも角度を読めない. 腕はこの間に動き終わる (Log17 の記録で 1.5〜3.6 秒の抜け).
  記録の側で直せるのは次の 2 つだけ (送る指令・到着の判定・待ち時間は変えない):
    - 本体が読んだ角度 (到着の確かめ・送る直前の読み) も actual 行に残す (note=main)
    - daemon とのやりとり 1 回ごとの始まりと長さを残す (send_angles 行 / rpc 行). 送った目標と時刻が
      分かるので, あとから build_correction_episodes.py --gap-fill speed20 で抜けを埋められる
  抜けそのものをなくすには daemon の送ったあとの読み直しを変える必要がある (決めるのはエイイチ).

2026-11-07 依頼 116: 爪と肩の電流も残す
  記録スレッドは get_angles の代わりに daemon の read_servo (角度 + サーボの番地. 読むだけ) を 1 回呼ぶ
  (daemon への問い合わせの回数は今と同じ). states.csv の列と行は変えない (actual 行は今までどおり).
  同じ時刻の電流は {run_dir}/recording/currents.csv に書く (列は CURRENTS_COLS. ts は states.csv の actual 行と同じ値.
  角度を読んだ時刻 = 返事が着いた時刻 - daemon の中で角度のあとにかかった時間. rpc_ms は鍵の待ちも含む 1 回の長さ).
    番地 69 が下位・70 が上位. 上位の 128 が向き, 残りが大きさ:
      符号付きの値 = (70 & 128 なら -1) × (69 + 256 × (70 & 127))
    爪 (7) の 69/70 と肩 (2) の 69 は毎回読む. 肩の 70 は SHOULDER_HI_EVERY 回に 1 回だけ読む
    (11-07 の測り (diag/servo_current_20261107/180051_pad) で 番地 1 つ 約 20 ms・角度 約 18 ms.
     4 つを毎回読むと 1 回 約 105 ms で 10 Hz に収まらない. 3 つなら 約 85 ms).
    読まなかった番地・読めなかった番地は空. 肩の符号付きの値は 69 と 70 を同じ回に読めたときだけ書く.
  読めなかった回 (例外・返事なし) は値を空にして続ける. daemon に read_servo がなければ (unknown cmd)
  その run は get_angles に戻して角度だけ残す (currents.csv は列名だけ).
  daemon の時間の約 85% を記録が使うので, 同じプロセスのパッド・本体の命令は鍵を 平均 35 ms・最大 約 110 ms
  (読み取り 1 回分) 待つ. 読んだあとは YIELD_SEC 鍵を手放す (すぐ取り直さない. 先に通す保証ではない).
  read_servo が答えないときは READ_SERVO_TIMEOUT_SEC で切ってつなぎ直す (その間の stop は 約 2 秒待つ).
"""
import csv
import json
import math
import threading
import time
from pathlib import Path

import cv2

import visual_servo_pick as vsp

RECORD_FPS = 10.0
FRAME_INTERVAL = 1.0 / RECORD_FPS
ANGLE_INTERVAL = 1.0 / RECORD_FPS
FOURCC = "avc1"                 # recorder.py と同じ
STATES_COLS = ["ts", "event_type", "stage",
               "j0", "j1", "j2", "j3", "j4", "j5",
               "speed", "gripper_state",
               "ts_send", "ts_arrival", "attempt", "arrived",
               "note"]          # recorder.py の STATES_COLS と同じ
FRAME_LOG_COLS = ["frame_idx", "capture_ts", "mode"]
FLUSH_INTERVAL = 1.0
YIELD_SEC = 0.005               # 記録スレッドが読んだあと, 次を読むまでに少なくともあける時間 (依頼 116)
STOP_JOIN_SEC = 5.0             # stop() でスレッドの終わりを待つ上限
FRAME_WAIT_SEC = 2.0            # 本体が画像を求めたとき, 新しいコマを待つ上限
# 依頼 116: 電流 (サーボの番地 69 下位 / 70 上位). 7 = 爪, 2 = 肩
CURRENT_REGS = [(7, 69), (7, 70), (2, 69), (2, 70)]   # currents.csv の生の値の列の順
EVERY_REGS = [(7, 69), (7, 70), (2, 69)]              # 毎回読む
SHOULDER_HI_REG = (2, 70)
SHOULDER_HI_EVERY = 5           # 肩の上位 (向き) はこの回数に 1 回 (1 秒 2 回. 毎回読むと 10 Hz に収まらない)
CURRENTS_COLS = ["ts", "rpc_ms", "pi_ms",
                 "r7_69", "r7_70", "r2_69", "r2_70",
                 "gripper_current", "shoulder_current", "note"]


_rpc_observers = []             # daemon とのやりとり 1 回ごとに呼ぶ関数 (記録用. 依頼 46)


def add_rpc_observer(fn):
    if fn not in _rpc_observers:
        _rpc_observers.append(fn)


def remove_rpc_observer(fn):
    if fn in _rpc_observers:
        _rpc_observers.remove(fn)


def _notify_rpc(cmd_obj, resp, t0, t1, err):
    for fn in list(_rpc_observers):
        try:
            fn(cmd_obj, resp, t0, t1, err)
        except Exception:
            pass                # 記録の失敗で本体を止めない


def install_daemon_lock():
    """visual_servo_pick._daemon_request を「1 回のやりとりごとに鍵をかける」版に差し替える.

    daemon_get_angles / daemon_send_angles / daemon_set_gripper* はどれも
    モジュールの _daemon_request を呼ぶので, ここを差し替えれば全部に効く.
    記録スレッドの get_angles と本体の send_angles が同じソケットで混ざらないようにする.
    中身 (送る内容・タイムアウト) は変えない. 2 回呼んでも 1 回だけ差し替える.
    依頼 46: やりとりが終わったら (鍵を外してから) add_rpc_observer で足した関数に
    (送った dict, 返事 or None, 始めた時刻, 終わった時刻, 例外 or None) を渡す. 返事と例外はそのまま返す.
    再接続のときの入れ子の ping (外のやりとりの鍵の中) は渡さない (codex 推奨).
    観察は同じスレッドで呼ぶ (states.csv に 1 行書くだけ. 本体へ返るのがその分だけ遅れる).
    """
    if getattr(vsp._daemon_request, "_policy_locked", False):
        return
    orig = vsp._daemon_request
    lock = threading.RLock()
    depth = threading.local()       # 再接続の中の ping (鍵の中で呼ばれる入れ子) は観察に渡さない

    def _locked(*a, **k):
        cmd_obj = a[0] if a else k.get("cmd_obj")
        resp, err, t0, t1 = None, None, None, None
        nested = getattr(depth, "n", 0) > 0
        try:
            depth.n = getattr(depth, "n", 0) + 1
            with lock:
                t0 = time.time()
                try:
                    resp = orig(*a, **k)
                finally:
                    t1 = time.time()
        except BaseException as e:
            err = e
            raise
        finally:
            depth.n -= 1
            if _rpc_observers and t0 is not None and not nested:
                _notify_rpc(cmd_obj, resp, t0, t1, err)
        return resp
    _locked._policy_locked = True
    _locked._orig = orig
    vsp._daemon_request = _locked


class _ServoCurrents:
    """read_servo で角度と爪・肩の番地を 1 回読み, currents.csv に 1 行書く部品 (依頼 116).
    実機推論の記録 (PolicyRecorder) と教えた動きの再生の記録 (CurrentsRecorder. 依頼 121) の両方が使う
    (読み方を 2 か所に書かない). 使う側が持つもの: read_servo_fn・read_angles_fn・currents_mode・n_reads・
    read_ms・n_currents・n_currents_fail・currents_write_errors・cur_f・cur_w・csv_lock・_valid()・_maybe_flush()."""

    NO_READ_SERVO_MSG = "電流は残さず, 角度だけ記録します"

    def _servo_cmd(self):
        regs = list(EVERY_REGS)
        if self.n_reads % SHOULDER_HI_EVERY == 0:
            regs.append(SHOULDER_HI_REG)
        return {"cmd": "read_servo", "angles": True, "currents": False, "status": False,
                "gripper": False, "regs": [list(r) for r in regs], "raw": False}

    def _read_once(self):
        """角度を 1 回読む. read_servo のときは同じ回の番地を currents.csv に書く.
        戻り値は (角度 or None, 角度を読んだ時刻).
        read_servo の daemon は角度を先に読み, そのあと番地を読む. 返事が着いた時刻のままだと角度の時刻が
        番地の分 (60〜80 ms) 遅れるので, daemon の中で角度より後にかかった時間 (total_ms - angles の ms) を引く
        (帰りの通信の分 約 2 ms は引かない. codex R1 必須 1). 引けないとき (返事の形が違う) は着いた時刻."""
        if self.currents_mode != "read_servo":
            return self._read_angles_only()
        cmd_obj = self._servo_cmd()
        self.n_reads += 1
        t0 = time.time()
        resp, err = None, None
        try:
            resp = self.read_servo_fn(cmd_obj)
        except Exception as e:
            err = e
        t1 = time.time()
        if err is not None and "unknown cmd" in str(err):
            # daemon が古い (read_servo がない): この run は角度だけにする
            self.currents_mode = "get_angles_fallback"
            print(f"[RECORD] [WARN] daemon に read_servo がありません. {self.NO_READ_SERVO_MSG} "
                  "(tools/daemon_add_read_servo.sh)")
            return self._read_angles_only()
        self.read_ms.append((t1 - t0) * 1000.0)
        a, a_note, ts = None, "", t1
        if err is None and isinstance(resp, dict):
            it = (resp.get("items") or {}).get("angles") or {}
            v = it.get("value")
            try:
                if v is not None and self._valid(v):
                    a = [float(x) for x in v]
            except Exception:
                a = None
            a_note = "" if a is not None else ("angles=no_reply" if not v else "angles=invalid")
            try:
                after = (float(resp["total_ms"]) - float(it["ms"])) / 1000.0
                if 0.0 <= after <= t1 - t0:
                    ts = t1 - after
            except (KeyError, TypeError, ValueError):
                pass
        try:
            self._current_row(ts, t0, t1, cmd_obj, resp, err, a_note)
        except Exception as e:
            # 電流の行が書けなくても角度の記録は続ける (codex R1 必須 2). 数を top_meta.json に残す
            self.currents_write_errors += 1
            if self.currents_write_errors <= 3:
                print(f"[RECORD] [WARN] currents.csv に書けません: {type(e).__name__}: {e}")
        return a, ts

    def _read_angles_only(self):
        try:
            a = self.read_angles_fn()
        except Exception:
            a = None
        return a, time.time()

    def _current_row(self, ts, t0, t1, cmd_obj, resp, err, a_note):
        asked = {tuple(r) for r in cmd_obj["regs"]}
        got, notes = {}, []
        if err is not None:
            notes.append(f"error={type(err).__name__}: {str(err)[:80]}")
        elif not isinstance(resp, dict):
            notes.append("error=bad_response")
        else:
            for r in resp.get("regs") or []:
                try:
                    sid, addr, val = int(r[0]), int(r[1]), r[2]
                except Exception:
                    continue
                if (sid, addr) not in asked:
                    continue
                if isinstance(val, int) and not isinstance(val, bool) and 0 <= val <= 255:
                    got[(sid, addr)] = val
            missing = [f"{s}:{a}" for s, a in CURRENT_REGS if (s, a) in asked and (s, a) not in got]
            if missing:
                notes.append("no_reply=" + ",".join(missing))
            if a_note:
                notes.append(a_note)
        pi_ms = resp.get("total_ms") if err is None and isinstance(resp, dict) else None
        row = [f"{ts:.6f}", f"{(t1 - t0) * 1000.0:.1f}",
               f"{float(pi_ms):.1f}" if isinstance(pi_ms, (int, float)) else ""]
        row += ["" if got.get(r) is None else str(got[r]) for r in CURRENT_REGS]
        g = signed_current(got.get((7, 69)), got.get((7, 70)))
        sh = signed_current(got.get((2, 69)), got.get((2, 70)))
        row += ["" if g is None else str(g), "" if sh is None else str(sh), " ".join(notes)]
        if any((s, a) in asked and (s, a) not in got for s, a in CURRENT_REGS) or err is not None:
            self.n_currents_fail += 1
        with self.csv_lock:
            if self.cur_f.closed:
                return
            self.cur_w.writerow(row)
            self.n_currents += 1
            self._maybe_flush(ts)


class PolicyRecorder(_ServoCurrents):
    """カメラを読むスレッドと関節角を読むスレッドを持つ. 本体は grab() で最新のコマを受け取る."""

    def __init__(self, run_dir, cap, read_angles_fn, to_model_fn, angles_ok=None, read_servo_fn=None):
        """read_servo_fn: daemon に read_servo の dict を送って返事の dict を返す関数 (依頼 116).
        None なら今までどおり read_angles_fn で角度だけ読む (currents.csv は列名だけ)."""
        self.dir = Path(run_dir) / "recording"
        self.angles_ok = angles_ok      # 本体が読んだ角度を残すときの確かめ (None なら 6 個の有限な数)
        self.dir.mkdir(parents=True, exist_ok=True)
        self.cap = cap
        self.read_angles_fn = read_angles_fn
        self.read_servo_fn = read_servo_fn
        self.currents_mode = "read_servo" if read_servo_fn is not None else "off"
        self.n_reads = 0                # 記録スレッドの読み取りの回数 (肩の上位を読む回を決める)
        self.n_currents = 0             # currents.csv の行の数
        self.n_currents_fail = 0        # 1 つでも番地が読めなかった行の数
        self.read_ms = []               # read_servo 1 回の長さ (ms)
        self.currents_write_errors = 0  # currents.csv に書けなかった回数 (角度の記録は続ける)
        self.to_model_fn = to_model_fn
        self.mode = "model"
        self.stop_flag = False
        self.stopped_cleanly = None     # stop() のあと: スレッドが止まって書き切れたか
        self.csv_lock = threading.Lock()
        self.frame_cv = threading.Condition()
        self.latest = None              # (frame, capture_ts)
        self.writer = None
        self.size = None
        self.n_frames = 0
        self.n_actual = 0
        self.n_actual_fail = 0
        self.n_actual_main = 0          # 本体が読んだ角度を残した数 (依頼 46)
        self.n_sends = 0                # send_angles のやりとりを残した数
        self.write_errors = 0           # mp4 を開けない / 書けなかった回数 (codex R2 A5)
        self.started = time.time()
        self.last_flush = self.started
        self.states_f = (self.dir / "states.csv").open("w", newline="")
        self.states_w = csv.writer(self.states_f)
        self.states_w.writerow(STATES_COLS)
        self.flog_f = (self.dir / "top_frame_log.csv").open("w", newline="")
        self.flog_w = csv.writer(self.flog_f)
        self.flog_w.writerow(FRAME_LOG_COLS)
        self.cur_f = (self.dir / "currents.csv").open("w", newline="")
        self.cur_w = csv.writer(self.cur_f)
        self.cur_w.writerow(CURRENTS_COLS)
        self._state_row("stage", time.time())
        self.t_cam = threading.Thread(target=self._cam_loop, daemon=True, name="record_camera")
        self.t_ang = threading.Thread(target=self._angle_loop, daemon=True, name="record_angles")

    def start(self):
        self.t_cam.start()
        self.t_ang.start()
        add_rpc_observer(self._on_rpc)

    # ---- 本体から呼ぶ -------------------------------------------------------
    def set_mode(self, mode):
        if mode == self.mode:
            return
        self.mode = mode
        self._state_row("stage", time.time())

    def gripper(self, state):
        """グリッパーに指令した瞬間に呼ぶ (build_demo_episodes は指令の時刻で 0/1 を切り替える)."""
        self._state_row("gripper_cmd", time.time(), gripper_state=int(state))

    def grab(self):
        """呼んだあとに撮れたコマを返す (古いコマを渡さない). 戻り値は grab_rgb と同じ (rgb, bgr_small)."""
        t_req = time.time()
        deadline = t_req + FRAME_WAIT_SEC
        with self.frame_cv:
            while not self.stop_flag:
                if self.latest is not None and self.latest[1] >= t_req:
                    return self.to_model_fn(self.latest[0])
                left = deadline - time.time()
                if left <= 0:
                    break
                self.frame_cv.wait(left)
        return None, None

    def stop(self):
        """スレッドを止めて書き切る. 何度呼んでもよい."""
        if self.stop_flag:
            return
        remove_rpc_observer(self._on_rpc)
        self.stop_flag = True
        with self.frame_cv:
            self.frame_cv.notify_all()
        for t in (self.t_cam, self.t_ang):
            if t.is_alive():
                t.join(timeout=STOP_JOIN_SEC)
        ended = time.time()
        alive = [t.name for t in (self.t_cam, self.t_ang) if t.is_alive()]
        # codex R1-5: スレッドが止まっていないのに mp4 を閉じると, あとから write() が走って競合する.
        # 止まらなかったときは mp4 を閉じず (カメラも本体で閉じない: alive() を見る),
        # 記録を「異常」として残す (build_correction_episodes はこの run を使わない).
        self.stopped_cleanly = not alive and not self.write_errors
        with self.csv_lock:
            for f in (self.states_f, self.flog_f, self.cur_f):
                try:
                    f.flush(); f.close()
                except Exception:
                    if f is self.cur_f:
                        self.currents_write_errors += 1
                    try:
                        f.close()
                    except Exception:
                        pass
        if self.writer is not None and not alive:
            try:
                self.writer.release()
            except Exception:
                pass
        el = ended - self.started
        meta = {"frames": self.n_frames, "elapsed_sec": round(el, 3),
                "effective_fps": round(self.n_frames / el, 3) if el > 0 else 0.0,
                "width": self.size[0] if self.size else None,
                "height": self.size[1] if self.size else None,
                "actual_samples": self.n_actual, "actual_read_failures": self.n_actual_fail,
                "actual_hz": round(self.n_actual / el, 2) if el > 0 else 0.0,
                "actual_main_samples": self.n_actual_main, "send_rpcs": self.n_sends,
                "target_fps": RECORD_FPS, "status": ("thread_not_stopped" if alive else "write_error" if self.write_errors else "ok"),
                "write_errors": self.write_errors,
                "threads_alive": alive,
                "currents_mode": self.currents_mode, "currents_rows": self.n_currents,
                "currents_rows_incomplete": self.n_currents_fail,
                "currents_write_errors": self.currents_write_errors,
                "currents_regs_every": [f"{a}:{b}" for a, b in EVERY_REGS],
                "currents_shoulder_hi_every": SHOULDER_HI_EVERY,
                "read_servo_ms": _ms_stats(self.read_ms)}
        (self.dir / "top_meta.json").write_text(json.dumps(meta, indent=2, ensure_ascii=False))
        if alive:
            print(f"[RECORD] [WARN] 記録スレッドが止まりません ({', '.join(alive)}). "
                  "mp4 を閉じずに終えます (この記録は学習データに使いません)")
        print(f"[RECORD] 記録終了 コマ {self.n_frames} ({meta['effective_fps']} fps) "
              f"実測角 {self.n_actual} 回 ({meta['actual_hz']} Hz)  電流 {self.n_currents} 行"
              f" ({self.currents_mode})  → {self.dir}")

    # ---- 中身 ---------------------------------------------------------------
    def alive(self):
        """記録スレッドがまだ動いているか (stop() のあとに見る. 動いていればカメラを閉じない)."""
        return self.t_cam.is_alive() or self.t_ang.is_alive()

    def _state_row(self, ev, ts, angles=None, gripper_state=None, speed=None, ts_send=None, note=""):
        row = [f"{ts:.6f}", ev, self.mode]
        for k in range(6):
            row.append("" if angles is None else f"{float(angles[k]):.3f}")
        row += ["" if speed is None else str(speed), "" if gripper_state is None else str(gripper_state),
                "" if ts_send is None else f"{ts_send:.6f}", "", "", "", note]
        with self.csv_lock:
            if self.states_f.closed:
                return False
            self.states_w.writerow(row)
            self._maybe_flush(ts)
        return True

    def _valid(self, a):
        if self.angles_ok is not None:
            return bool(self.angles_ok(a))
        try:
            return len(a) == 6 and all(math.isfinite(float(v)) for v in a)
        except Exception:
            return False

    def _on_rpc(self, cmd_obj, resp, t0, t1, err):
        """daemon とのやりとり 1 回ごと (install_daemon_lock から). 何も送らない・読み直さない.

        get_angles: 本体 (記録スレッド以外) が読めた角度を actual 行に残す (note=main. 記録スレッドの分は
                    _angle_loop が残すので二重にしない)
        send_angles: 始めた時刻 (ts / ts_send)・目標・速度・やりとりの長さ (note) を send_angles 行に残す
        そのほか (ping 以外): rpc 行に cmd とやりとりの長さを残す
        """
        if self.stop_flag or not isinstance(cmd_obj, dict):
            return
        cmd = cmd_obj.get("cmd")
        dur = f"rpc_sec={t1 - t0:.3f}" + ("" if err is None else f" error={type(err).__name__}")
        if cmd == "read_servo" and threading.current_thread() is self.t_ang:
            return                      # 記録スレッドの読み取り (actual 行と currents.csv に残す. 依頼 116)
        if cmd == "get_angles":
            if threading.current_thread() is self.t_ang or err is not None or not isinstance(resp, dict):
                return
            a = resp.get("angles")
            if a is None or not self._valid(a):
                return
            if self._state_row("actual", t1, angles=a, note="main"):   # 書けた行だけ数える (codex 推奨)
                self.n_actual_main += 1
        elif cmd == "send_angles":
            ang = cmd_obj.get("angles")
            if self._state_row("send_angles", t0, angles=ang if ang is not None and len(ang) == 6 else None,
                               speed=cmd_obj.get("speed"), ts_send=t0, note=dur):
                self.n_sends += 1
        elif cmd != "ping":
            self._state_row("rpc", t0, ts_send=t0, note=f"cmd={cmd} {dur}")

    def _maybe_flush(self, now):
        if now - self.last_flush >= FLUSH_INTERVAL:
            try:
                self.states_f.flush(); self.flog_f.flush()
            except Exception:
                pass
            try:
                self.cur_f.flush()
            except Exception:
                self.currents_write_errors += 1     # 電流が書けていないことを残す (codex R2 推奨 3)
            self.last_flush = now

    def _cam_loop(self):
        last_written = 0.0
        while not self.stop_flag:
            ok, frame = self.cap.read()
            ts = time.time()
            if self.stop_flag:
                break
            if not ok or frame is None:
                time.sleep(0.02)
                continue
            with self.frame_cv:
                self.latest = (frame, ts)
                self.frame_cv.notify_all()
            if ts - last_written < FRAME_INTERVAL - 1e-3:
                continue
            last_written = ts
            try:
                if self.writer is None:
                    h, w = frame.shape[:2]
                    self.size = (w, h)
                    self.writer = cv2.VideoWriter(str(self.dir / "top.mp4"),
                                                  cv2.VideoWriter_fourcc(*FOURCC), RECORD_FPS, (w, h))
                    if not self.writer.isOpened():
                        raise RuntimeError(f"VideoWriter を開けない ({FOURCC})")
                if not self.writer.isOpened():
                    raise RuntimeError("VideoWriter が閉じている")
                self.writer.write(frame)
                with self.csv_lock:
                    if not self.flog_f.closed:
                        self.flog_w.writerow([self.n_frames, f"{ts:.6f}", self.mode])
                        self._maybe_flush(ts)
                self.n_frames += 1
            except Exception as e:
                self.write_errors += 1
                if self.write_errors <= 3:
                    print(f"[RECORD] [WARN] コマの書き込みに失敗: {e}")

    def _angle_loop(self):
        nxt = time.time()
        while not self.stop_flag:
            a, ts = self._read_once()     # read_servo のときは currents.csv と同じ時刻で actual 行を書く
            if a is None:
                self.n_actual_fail += 1
            else:
                self._state_row("actual", ts, angles=a)
                self.n_actual += 1
            nxt = _pace(nxt)


def _pace(nxt):
    """記録の読み取りの間合い (1 秒 RECORD_FPS 回). 次に読む予定の時刻を返す (依頼 116. 依頼 121 で 2 か所から使う)."""
    nxt += ANGLE_INTERVAL
    wait = nxt - time.time()
    if -wait > ANGLE_INTERVAL:
        nxt = time.time()       # 1 回分より大きく遅れた分は取り戻さない (詰めて読まない)
    # 1 回分までの遅れ (肩の上位も読む回は 100 ms を少し超える. 依頼 116) は, 次を早めに読んで取り戻す.
    # ただし読んだあとは必ず YIELD_SEC は鍵を手放す (すぐ取り直すと, 待っているパッドの命令が何回分も待つ)
    time.sleep(max(wait, YIELD_SEC))
    return nxt


WINDOW_MARGIN_SEC = 0.02        # 本体が眠る時間の終わりから引く分 (依頼 121)
READ_BUDGET_SEC = 0.15          # 1 回の読み取りに見込む時間 (11-07 の測りで 中央値 約 85 ms・肩の上位を読む回 約 105 ms)
WINDOW_POLL_SEC = 0.005         # 読んでよい時間を待つ間合い
CLOSE_LIMIT_SEC = 1.0           # stop() で currents.csv を閉じる・meta を書くのに待つ上限


def _bounded(fn, sec):
    """fn を別のスレッドで呼び, sec 秒だけ待つ. 終われば True (ファイルの書き込みで止まらないように. 依頼 121)."""
    t = threading.Thread(target=fn, daemon=True, name="record_currents_close")
    t.start()
    t.join(timeout=sec)
    return not t.is_alive()


class CurrentsRecorder(_ServoCurrents):
    """教えた動きの再生 (record_teach_demo.py run --execute) の間, 爪と肩の電流を currents.csv に残す (依頼 121).

    読み方・列・肩の上位を SHOULDER_HI_EVERY 回に 1 回にする扱い・読めない回を空にして続ける扱いは
    実機推論の記録 (PolicyRecorder. 依頼 116) と同じ部品 (_ServoCurrents) を使う. 違うのは次:
      - **本体 (再生) が daemon を使わずに眠っている間だけ読む**. 本体は眠る前に window(秒) で知らせる
        (到達の確かめ・静止の確かめの 0.3 秒の間・待ちの間の読み取りの合間). 読み始めてよいのは,
        読み終わる見込み (READ_BUDGET_SEC) が眠りの終わり - WINDOW_MARGIN_SEC より前のときだけ.
        なので見込みどおりに答える回は, 本体の daemon とのやりとりは電流の記録を待たない (到達・静止の確かめの
        回数と時刻は今までと同じ. codex R1・R2 必須). **残る場合**: read_servo が見込みより長くかかり, 本体が
        起きる時刻を超えた回は, 本体の次のやりとりがその分 (最大 READ_SERVO_TIMEOUT_SEC) 待つ. daemon とのやりとりが
        眠りの終わりを超えて続いた回を overruns に数える (本体がちょうどその時に daemon を使ったかは見ていない).
        間合いは 1 秒 RECORD_FPS 回まで (それより詰めて読まない). 本体が眠らない間 (send_angles の返事待ち
        約 1.6 秒・爪の命令と待ち・再送の前の待ち) は読まないので, 1 秒あたりの行は 10 より少ない
      - pause() から resume() までは window があっても読まない (爪の命令と待ち・再送の前の待ち.
        「爪を動かした直後にシリアルを触らない」(2026-10-19))
      - states.csv・top.mp4 は今までどおり recorder.py (別のプロセス) が書く. ここは currents.csv と
        currents_meta.json だけを書く. read_servo で読んだ角度は ts を決めるのに使い, angle_sink があれば
        angle_sink(角度, 読んだ時刻) で渡す (依頼 202: record_teach_demo が states.csv の actual 行にする.
        渡すのは読めた回だけ. 読み方・読む時機は変えない. 渡す側の失敗は loop_errors に数えて続ける)
      - daemon に read_servo がなければ (unknown cmd) 読むのをやめる (currents.csv は列名だけ)
    記録の失敗で再生を止めない (例外は外へ出さない. stop()・pause() は書き込みで止まったスレッドを待ち続けない).
    daemon のソケットは本体と共用なので, 使う前に install_daemon_lock() を呼ぶこと.
    """

    NO_READ_SERVO_MSG = "電流は残しません (再生と記録はそのまま続けます)"

    def __init__(self, run_dir, read_servo_fn):
        self.dir = Path(run_dir) / "recording"
        self.dir.mkdir(parents=True, exist_ok=True)
        self.read_servo_fn = read_servo_fn
        self.read_angles_fn = lambda: None
        self.angles_ok = None
        self.angle_sink = None          # 依頼 202: 読めた角度を渡す先 (角度, 読んだ時刻). None なら渡さない
        self.currents_mode = "read_servo"
        self.n_reads = 0
        self.n_currents = 0
        self.n_currents_fail = 0
        self.read_ms = []
        self.currents_write_errors = 0
        self.loop_errors = 0            # 読み取りの外側で起きた例外の数 (起きても続ける)
        self.overruns = 0               # 眠りの終わりを超えて読んでいた回 (本体が待った回)
        self.overrun_ms = []
        self.stop_flag = False
        self.paused = False
        self.allow_until = 0.0          # この時刻 (time.time) までに読み終わるなら読んでよい
        self.window_sec = 0.0           # 知らされた眠りの合計 (重なりを含む. 目安)
        self.next_at = 0.0
        self.gate = threading.Lock()    # 1 回の読み取り (と書き込み) の間持つ
        self.n_pauses = 0
        self.pause_gate_timeouts = 0
        self.paused_sec = 0.0
        self._paused_at = None
        self.csv_lock = threading.Lock()
        self.started = None
        self.meta = None
        self.last_flush = time.time()
        self.cur_f = (self.dir / "currents.csv").open("w", newline="")
        self.cur_w = csv.writer(self.cur_f)
        self.cur_w.writerow(CURRENTS_COLS)
        self.t = threading.Thread(target=self._loop, daemon=True, name="record_currents")

    def start(self):
        self.started = time.time()
        self.t.start()

    def window(self, sec):
        """本体が今から sec 秒 daemon を使わない (眠る) と知らせる. 読むのはこの間だけ."""
        if sec <= 0 or self.paused:     # 止めている間に知らされた眠りは使わない
            return
        now = time.time()
        self.window_sec += sec
        self.allow_until = max(self.allow_until, now + sec - WINDOW_MARGIN_SEC)

    def pause(self):
        """読み取りを止める. 読んでいる途中ならその 1 回が終わるまで待つ (上限 READ_SERVO_TIMEOUT_SEC + 0.5 秒.
        書き込みで止まったスレッドを待ち続けない. 上限を超えたら数えて止める印だけ立てる)."""
        got = self.gate.acquire(timeout=READ_SERVO_TIMEOUT_SEC + 0.5)
        try:
            if not got:
                self.pause_gate_timeouts += 1
            if not self.paused:
                self.paused = True
                self.n_pauses += 1
                self._paused_at = time.time()
            self.allow_until = 0.0
        finally:
            if got:
                self.gate.release()

    def resume(self):
        self.allow_until = 0.0          # 再開したら, 次に眠りを知らされるまで読まない
        if self.paused:
            self.paused = False
            if self._paused_at is not None:
                self.paused_sec += time.time() - self._paused_at
            self._paused_at = None

    def stop(self):
        """スレッドを止めて書き切り, 中身の数を dict で返す (currents_meta.json にも書く). 何度呼んでもよい.
        待つのは STOP_JOIN_SEC (スレッド) + CLOSE_LIMIT_SEC × 2 (閉じる・meta) まで."""
        if self.meta is not None:
            return self.meta
        self.stop_flag = True
        if self.t.is_alive():
            self.t.join(timeout=STOP_JOIN_SEC)
        ended = time.time()
        alive = self.t.is_alive()
        if self.paused and self._paused_at is not None:
            self.paused_sec += ended - self._paused_at     # 止めたまま終わった分
            self._paused_at = None

        def _close():
            with self.csv_lock:
                try:
                    self.cur_f.flush(); self.cur_f.close()
                except Exception:
                    self.currents_write_errors += 1
                    try:
                        self.cur_f.close()
                    except Exception:
                        pass
        closed = _bounded(_close, CLOSE_LIMIT_SEC)
        el = (ended - self.started) if self.started else 0.0
        run_sec = max(el - self.paused_sec, 0.0)
        self.meta = {"currents_mode": self.currents_mode, "currents_rows": self.n_currents,
                     "currents_rows_incomplete": self.n_currents_fail,
                     "currents_write_errors": self.currents_write_errors,
                     "loop_errors": self.loop_errors,
                     "currents_regs_every": [f"{a}:{b}" for a, b in EVERY_REGS],
                     "currents_shoulder_hi_every": SHOULDER_HI_EVERY,
                     "elapsed_sec": round(el, 3),
                     "paused_sec": round(self.paused_sec, 3), "pauses": self.n_pauses,
                     "pause_gate_timeouts": self.pause_gate_timeouts,
                     "window_sec": round(self.window_sec, 3),
                     "currents_hz": round(self.n_currents / el, 2) if el > 0 else 0.0,
                     "currents_hz_excl_paused": round(self.n_currents / run_sec, 2) if run_sec > 0 else 0.0,
                     "target_hz_max": RECORD_FPS,
                     "read_budget_sec": READ_BUDGET_SEC,
                     "overruns": self.overruns, "overrun_ms": _ms_stats(self.overrun_ms),
                     "read_servo_ms": _ms_stats(self.read_ms),
                     "status": ("thread_not_stopped" if alive else "ok" if closed else "close_timeout"),
                     "source": "record_teach_demo (依頼 121)",
                     "reads_only_while_main_sleeps": True}
        saved = {"ok": False, "error": None}

        def _save():
            try:
                (self.dir / "currents_meta.json").write_text(meta_text)
                saved["ok"] = True
            except Exception as e:
                saved["error"] = f"{type(e).__name__}: {e}"
        meta_text = json.dumps(self.meta, indent=2, ensure_ascii=False)
        if not _bounded(_save, CLOSE_LIMIT_SEC):
            saved["error"] = "timeout"
        # 書けたかを戻り値 (= 試行 JSON) に残す (codex R3 推奨 2. ファイルの中には書かない)
        self.meta["meta_file"] = "ok" if saved["ok"] else saved["error"]
        if not saved["ok"]:
            print(f"[RECORD] [WARN] currents_meta.json を書けません ({saved['error']}. 試行 JSON には残します)")
        print(f"[RECORD] 電流の記録終了 {self.n_currents} 行 ({self.meta['currents_hz']} 行/秒. 本体が眠っている間だけ"
              f"読む. 爪の間 {self.meta['paused_sec']} 秒は読まない. 見込み超え {self.overruns} 回. {self.currents_mode})"
              f"  → {self.dir / 'currents.csv'}")
        return self.meta

    def _maybe_flush(self, now):
        if now - self.last_flush >= FLUSH_INTERVAL:
            try:
                self.cur_f.flush()
            except Exception:
                self.currents_write_errors += 1
            self.last_flush = now

    def _valid(self, a):
        try:
            return len(a) == 6 and all(math.isfinite(float(v)) for v in a)
        except Exception:
            return False

    def _read_budget(self):
        """次の 1 回の読み取りに見込む時間 (依頼 156 の PowerRegsRecorder は番地を足す回だけ長くとる)."""
        return READ_BUDGET_SEC

    def _loop(self):
        while not self.stop_flag and self.currents_mode == "read_servo":
            now = time.time()
            if self.paused or now < self.next_at or now + self._read_budget() > self.allow_until:
                time.sleep(WINDOW_POLL_SEC)
                continue
            with self.gate:
                if self.paused or self.stop_flag or time.time() + self._read_budget() > self.allow_until:
                    continue
                t0 = time.time()
                limit = self.allow_until + WINDOW_MARGIN_SEC      # 本体が起きる時刻 (の見込み)
                self.next_at = t0 + ANGLE_INTERVAL
                n_before = len(self.read_ms)
                try:
                    a, ts = self._read_once()
                    if a is not None and self.angle_sink is not None:
                        self.angle_sink(a, ts)      # 依頼 202: states.csv の actual 行へ
                except Exception as e:      # 記録の失敗で再生を止めない
                    self.loop_errors += 1
                    if self.loop_errors <= 3:
                        print(f"[RECORD] [WARN] 電流の読み取りで例外: {type(e).__name__}: {e}")
                # daemon とのやりとりが終わった時刻 (currents.csv への書き込みは含めない. codex R3 推奨 1)
                rpc_end = (t0 + self.read_ms[-1] / 1000.0) if len(self.read_ms) > n_before else time.time()
                over = rpc_end - limit
                if over > 0:
                    self.overruns += 1
                    self.overrun_ms.append(over * 1000.0)


def signed_current(lo, hi):
    """番地 69 (下位) と 70 (上位) から符号付きの値. どちらかがなければ None (依頼 116)."""
    if lo is None or hi is None:
        return None
    v = lo + 256 * (hi & 127)
    return -v if hi & 128 else v


def _ms_stats(xs):
    if not xs:
        return None
    ys = sorted(xs)
    return {"n": len(ys), "median": round(ys[len(ys) // 2], 1),
            "p95": round(ys[min(len(ys) - 1, int(len(ys) * 0.95))], 1), "max": round(ys[-1], 1)}


READ_SERVO_TIMEOUT_SEC = 1.5    # 記録の read_servo 1 回の上限. 鍵を持ったまま既定のタイムアウトまで待つと
                                # パッドの stop も待たせるので短くする (いつもは 0.1 秒. 番地が 4 つとも
                                # 返事なしでも 0.9 秒ほど. codex R1 推奨 3). 超えたら次の回はつなぎ直す


def daemon_read_servo(cmd_obj):
    """記録スレッドの read_servo (依頼 116). 呼んだときの visual_servo_pick._daemon_request を使う
    (install_daemon_lock の鍵を通る)."""
    return vsp._daemon_request(cmd_obj, timeout_override=READ_SERVO_TIMEOUT_SEC)


# ---- 2026-11-12 依頼 156: 電源 (12V・2A → 5A) の前後比較のために, 爪の位置とサーボの電圧も読む ----------------
# record_teach_demo.py run --power 2A のときだけ使う (付けなければ CurrentsRecorder のまま. 実機推論は変えない).
# 番地は Feetech STS 想定で, この機体では確かめていない (tools/pi/servo_check_pi.py と同じ前提). 値は生のまま残す:
#   爪の位置  (7, 56) 下位・(7, 57) 上位 → gripper_pos (signed_current と同じ組み立て. 上位の 128 を向きとみなす)
#   電圧      (2, 62) 肩・(7, 62) 爪 (0.1V 想定)
# get_gripper_value は使わない (2026-10-19 段階C で, 開いた直後の gv のあとに daemon が固まった. 番地 69/70 と同じ
# get_servo_data で読む). 足した番地は currents.csv に入れず power_regs.csv に書く (currents.csv の列と行は今までどおり).
# 1 回に足すのは 2 つまで (番地 1 つ 約 20 ms. 肩の上位を読む回には足さない) なので, 1 回の読み取りは多くて 約 125 ms.
# 読み始めてよいかの決め方 (本体が眠っている間だけ) は同じで, 番地を足す回だけ見込みを 1 つにつき
# POWER_REG_BUDGET_SEC 長くとる (READ_BUDGET_SEC 0.15 → 0.19 秒). 足した番地が POWER_GIVE_UP 回続けて返事なしなら,
# その番地はその run ではもう頼まない (本体を待たせるのは多くてその回数まで. overruns に数える).
POWER_POS_REGS = [(7, 56), (7, 57)]
POWER_VOLT_REGS = [(2, 62), (7, 62)]
POWER_REGS = POWER_POS_REGS + POWER_VOLT_REGS
POWER_COLS = ["ts", "r7_56", "r7_57", "gripper_pos", "r2_62", "r7_62", "note"]
POWER_REG_BUDGET_SEC = 0.02     # 足した番地 1 つにつき, 読み始めてよいかの見込みに足す時間 (番地 1 つ 約 20 ms)
POWER_GIVE_UP = 2               # 足した番地が続けてこの回数 返事なしなら, その run ではもう頼まない (codex R1 必須 1:
                                # 2.9.6 は返事のない番地 1 つに 約 0.1 秒待つので, 頼み続けると本体を待たせる)


def power_extra_regs(n):
    """n 回目 (0 始まり) の読み取りに足す番地. 肩の上位を読む回 (n % SHOULDER_HI_EVERY == 0) には足さない.
    残りの回は 爪の位置 → 電圧 → 爪の位置 → 電圧 の順 (5 回に 2 回ずつ)."""
    k = n % SHOULDER_HI_EVERY
    if k == 0:
        return []
    return list(POWER_POS_REGS) if k % 2 == 1 else list(POWER_VOLT_REGS)


class PowerRegsRecorder(CurrentsRecorder):
    """CurrentsRecorder に爪の位置と電圧の番地を足す (依頼 156). 足した番地は {run}/recording/power_regs.csv.
    読めなかった番地は空にして note に no_reply を書く (止めない)."""

    def __init__(self, run_dir, read_servo_fn):
        super().__init__(run_dir, read_servo_fn)
        self.pw_f = (self.dir / "power_regs.csv").open("w", newline="")
        self.pw_w = csv.writer(self.pw_f)
        self.pw_w.writerow(POWER_COLS)
        self.pw_asked = {f"{s}:{a}": 0 for s, a in POWER_REGS}
        self.pw_got = {f"{s}:{a}": 0 for s, a in POWER_REGS}
        self.pw_rows = 0
        self.pw_write_errors = 0
        self.pw_noreply_run = {k: 0 for k in self.pw_asked}    # 続けて返事なしの回数
        self.pw_given_up = []                                   # もう頼まない番地 ("2:62" など)

    def _extras(self):
        return [r for r in power_extra_regs(self.n_reads) if f"{r[0]}:{r[1]}" not in self.pw_given_up]

    def _read_budget(self):
        return READ_BUDGET_SEC + POWER_REG_BUDGET_SEC * len(self._extras())

    def _servo_cmd(self):
        cmd = super()._servo_cmd()
        cmd["regs"] += [list(r) for r in self._extras()]
        return cmd

    def _current_row(self, ts, t0, t1, cmd_obj, resp, err, a_note):
        try:
            self._power_row(ts, cmd_obj, resp, err)
        except Exception as e:
            self.pw_write_errors += 1
            if self.pw_write_errors <= 3:
                print(f"[RECORD] [WARN] power_regs.csv に書けません: {type(e).__name__}: {e}")
        super()._current_row(ts, t0, t1, cmd_obj, resp, err, a_note)

    def _power_row(self, ts, cmd_obj, resp, err):
        asked = [tuple(r) for r in cmd_obj["regs"] if tuple(r) in POWER_REGS]
        if not asked:
            return
        got = {}
        if err is None and isinstance(resp, dict):
            for r in resp.get("regs") or []:
                try:
                    sid, addr, val = int(r[0]), int(r[1]), r[2]
                except Exception:
                    continue
                if (sid, addr) in asked and isinstance(val, int) and not isinstance(val, bool) and 0 <= val <= 255:
                    got[(sid, addr)] = val
        replied = err is None and isinstance(resp, dict)
        for r in asked:
            k = f"{r[0]}:{r[1]}"
            self.pw_asked[k] += 1
            if r in got:
                self.pw_got[k] += 1
                self.pw_noreply_run[k] = 0
            elif replied:               # daemon は答えたが, その番地だけ返事がない
                self.pw_noreply_run[k] += 1
                if self.pw_noreply_run[k] >= POWER_GIVE_UP and k not in self.pw_given_up:
                    self.pw_given_up.append(k)
                    print(f"[RECORD] [WARN] 番地 {k} が {POWER_GIVE_UP} 回続けて返事なし. この run ではもう読みません "
                          "(本体を待たせないため. 再生は続けます)")
        notes = []
        if err is not None:
            notes.append(f"error={type(err).__name__}: {str(err)[:80]}")
        elif not isinstance(resp, dict):
            notes.append("error=bad_response")
        missing = [f"{s}:{a}" for s, a in asked if (s, a) not in got]
        if missing and err is None and isinstance(resp, dict):
            notes.append("no_reply=" + ",".join(missing))
        pos = signed_current(got.get((7, 56)), got.get((7, 57)))

        def v(r):
            return "" if got.get(r) is None else str(got[r])
        row = [f"{ts:.6f}", v((7, 56)), v((7, 57)), "" if pos is None else str(pos),
               v((2, 62)), v((7, 62)), " ".join(notes)]
        with self.csv_lock:
            if self.pw_f.closed:
                return
            self.pw_w.writerow(row)
            self.pw_rows += 1

    def _maybe_flush(self, now):
        if now - self.last_flush >= FLUSH_INTERVAL:
            try:
                self.pw_f.flush()
            except Exception:
                self.pw_write_errors += 1
        super()._maybe_flush(now)

    def stop(self):
        if self.meta is not None:
            return self.meta
        meta = super().stop()

        def _close():
            with self.csv_lock:
                try:
                    self.pw_f.flush(); self.pw_f.close()
                except Exception:
                    self.pw_write_errors += 1
                    try:
                        self.pw_f.close()
                    except Exception:
                        pass
        closed = _bounded(_close, CLOSE_LIMIT_SEC)
        meta["power_regs"] = {
            "file": "power_regs.csv", "rows": self.pw_rows, "asked": dict(self.pw_asked), "got": dict(self.pw_got),
            "write_errors": self.pw_write_errors, "closed": closed, "given_up": list(self.pw_given_up),
            "regs": {"gripper_pos": ["7:56", "7:57"], "voltage": ["2:62", "7:62"]},
            "schedule": f"肩の上位を読まない回に 2 つずつ (爪の位置と電圧を交互). {SHOULDER_HI_EVERY} 回に 2 回ずつ",
            "note": "Feetech STS 想定の番地. この機体で未確認. 生の値 (電圧は 0.1V 想定)",
            "source": "record_teach_demo --power (依頼 156)"}
        # currents_meta.json は依頼 121 の中身のまま. 足した番地の数は power_regs_meta.json に書く (codex R1 推奨 6)
        pw_text = json.dumps(meta["power_regs"], indent=2, ensure_ascii=False)
        saved = {"ok": False}

        def _save():
            try:
                (self.dir / "power_regs_meta.json").write_text(pw_text)
                saved["ok"] = True
            except Exception:
                pass
        _bounded(_save, CLOSE_LIMIT_SEC)
        meta["power_regs"]["meta_file"] = "ok" if saved["ok"] else "error"
        print(f"[RECORD] 爪の位置と電圧 {self.pw_rows} 行 (読めた数 {self.pw_got}"
              f"{'. もう読まなかった番地 ' + ','.join(self.pw_given_up) if self.pw_given_up else ''})"
              f"  → {self.dir / 'power_regs.csv'}")
        return meta
```

### pi05/teach_state_rate.py


```python
#!/usr/bin/env python3
"""teach_state_rate.py — 手教示の記録 (record_teach_demo.py run --execute) の実測角の間隔を, 直す前と後の本で並べる
(2026-11-15 依頼 202. 数え方は依頼 197 の KIOXIA diag/teach_state_rate_20261115/measure_gaps.py と同じ).

依頼 202 で, 電流の記録スレッド (read_servo) が読んだ角度も states.csv の actual 行に書くようにした
(note 列が source=current_thread. 本体の読み = 到達・静止の確かめなどは note が空のまま). 実機で 1 本 → 5 本撮って,
  - states.csv の actual の間隔 (全部・本体の読みだけ・電流スレッドの読みだけ) の中央値・90% 点・1 秒超
  - 間の原因ごと (poll = 到達・静止の確かめの間 / send = 送信の待ち / gripper = 爪の待ち / stage_change)
  - 試行 JSON の segments: 動く区間ごとの送信の往復 (send_rtt_sec)・区間の長さ (segment_elapsed_sec)・再送・着いたか,
    爪の前の静止の確かめ (still_check の reads・elapsed_sec・still)
が直す前の本と同じ形かを見る. 合否の線は決めていない (表を出すだけ).

入力: {runs_root}/{run}/{run}.json と {run}/recording/states.csv (runs_root の既定は KIOXIA の runs/run_pick_place)
  python3 pi05/teach_state_rate.py --before run_0001_20261109_094839 run_0001_20261109_095308 --after run_0001_20261116_...
  python3 pi05/teach_state_rate.py --after /Volumes/KIOXIA/r2r2r-data/runs/run_pick_place/run_0001_20261116_...   # フォルダでも
  python3 pi05/teach_state_rate.py --before ... --after ... --out    # CSV も残す
--out のときだけ書く: /Volumes/KIOXIA/r2r2r-data/runs/experiments/teach_state_rate/{YYYYMMDD_HHMMSS}/
  runs.csv (本ごと)・segments.csv (区間ごと). KIOXIA がなければ止まる. 出し先がもうあれば止まる. run の記録には何も書かない.
"""
import argparse
import csv
import json
import os
import statistics
import sys
from datetime import datetime
from pathlib import Path

KIOXIA_MOUNT = Path("/Volumes/KIOXIA")
DATA_ROOT = KIOXIA_MOUNT / "r2r2r-data"
RUNS_ROOT = DATA_ROOT / "runs" / "run_pick_place"
OUT_ROOT = DATA_ROOT / "runs" / "experiments" / "teach_state_rate"
CURRENT_THREAD_NOTE = "source=current_thread"   # record_teach_demo.CURRENT_THREAD_NOTE と同じ
LONG = 1.0


def ensure_ssd_mounted():
    """KIOXIA がマウントされていて書けるか. だめなら止める (ローカルへは書かない)."""
    if not os.path.ismount(str(KIOXIA_MOUNT)):
        sys.exit(f"[ABORT] KIOXIA がマウントされていません: {KIOXIA_MOUNT}")
    if not DATA_ROOT.is_dir():
        sys.exit(f"[ABORT] {DATA_ROOT} がありません")


def run_dir(arg, runs_root):
    p = Path(arg)
    return p if p.is_dir() else Path(runs_root) / arg


def load_states(path):
    rows = []
    with Path(path).open(newline="") as f:
        for r in csv.DictReader(f):
            try:
                r["ts"] = float(r["ts"])
            except (KeyError, TypeError, ValueError):
                continue
            rows.append(r)
    return rows


def is_actual(r):
    return r.get("event_type") == "actual" and (r.get("j0") or "") != ""


def source_of(r):
    return "current_thread" if CURRENT_THREAD_NOTE in (r.get("note") or "").split() else "main"


def classify(rows):
    """actual の間ごとに原因を決める (依頼 197 の measure_gaps.classify と同じ決め方. 手教示の形).
    rows は states.csv の行 (stage・gripper_cmd も入ったまま)."""
    acts = [i for i, r in enumerate(rows) if is_actual(r)]
    out = []
    for a, b in zip(acts, acts[1:]):
        types = [m.get("event_type") for m in rows[a + 1:b]]
        prev = rows[a - 1].get("event_type") if a > 0 else ""
        if "gripper_cmd" in types or "gripper" in types:
            cause = "gripper"
        elif "commanded" in types or prev == "stage":
            cause = "send"          # record_teach_demo: stage → 送信前の読み → 送信 (wait=1.0)
        elif "stage" in types:
            cause = "stage_change"
        else:
            cause = "poll"
        out.append({"t0": rows[a]["ts"], "t1": rows[b]["ts"], "gap": rows[b]["ts"] - rows[a]["ts"],
                    "stage": rows[a].get("stage"), "cause": cause})
    return out


def pct(v, p):
    if not v:
        return None
    ys = sorted(v)
    k = (len(ys) - 1) * p / 100.0
    lo = int(k)
    hi = min(lo + 1, len(ys) - 1)
    return ys[lo] + (ys[hi] - ys[lo]) * (k - lo)


def gap_stats(gaps):
    v = [g["gap"] for g in gaps]
    tot = sum(v)
    lv = [x for x in v if x > LONG]
    return {"n": len(v), "median": pct(v, 50), "p90": pct(v, 90), "max": max(v) if v else None,
            "long_n": len(lv), "long_share": (sum(lv) / tot) if tot > 0 else None}


def order_ok(rows):
    """states.csv の行が時刻順に並んでいるか (依頼 202). 逆になった所の数."""
    return sum(1 for a, b in zip(rows, rows[1:]) if b["ts"] < a["ts"])


def measure(d):
    """1 本の値 (dict) と区間ごとの行 (list)."""
    d = Path(d)
    name = d.name
    rows = load_states(d / "recording" / "states.csv")
    acts = [r for r in rows if is_actual(r)]
    main_rows = [r for r in rows if not (is_actual(r) and source_of(r) == "current_thread")]
    g_all = classify(rows)
    g_main = classify(main_rows)
    cur_ts = [r["ts"] for r in acts if source_of(r) == "current_thread"]
    g_cur = [{"gap": b - a} for a, b in zip(cur_ts, cur_ts[1:])]
    out = {"run": name, "n_actual": len(acts), "n_main": len(acts) - len(cur_ts), "n_current_thread": len(cur_ts),
           "order_reversed": order_ok(rows)}
    for key, g in (("all", g_all), ("main", g_main), ("cur", g_cur)):
        s = gap_stats(g)
        for k, v in s.items():
            out[f"{key}_{k}"] = v
    for cause in ("poll", "send", "gripper"):
        s = gap_stats([g for g in g_all if g["cause"] == cause])
        out[f"all_{cause}_median"], out[f"all_{cause}_max"] = s["median"], s["max"]
    try:
        j = json.loads((d / f"{name}.json").read_text())
    except Exception as e:
        j = {}
        out["json_error"] = f"{type(e).__name__}"
    cur = j.get("currents") or {}
    out.update({"result": j.get("result"), "overruns": cur.get("overruns"),
                # 依頼 213: 送信のあとの 1.0 秒をどこで待ったか (mac / daemon. 依頼 213 より前の本は項目がないので -)
                "send_wait_on": j.get("send_wait_on"),
                "sent_current_thread": j.get("recorder_actual_events_sent_current_thread"),
                "late_current_thread": j.get("recorder_actual_current_thread_late"),
                "actual_sampling_reads_ok": (j.get("actual_sampling") or {}).get("reads_ok")})
    segs = []
    for g in j.get("segments") or []:
        sc = g.get("still_check") or {}
        segs.append({"run": name, "step": g.get("step"), "kind": g.get("kind"),
                     "name": g.get("to_name") if g.get("kind") == "move" else g.get("action"),
                     "send_rtt_sec": g.get("send_rtt_sec"), "segment_elapsed_sec": g.get("segment_elapsed_sec"),
                     "send_daemon_rtt_sec": g.get("send_daemon_rtt_sec"),   # 依頼 213: daemon とのやりとりだけ
                     "retried": g.get("retried"), "arrival_ok": g.get("arrival_ok"),
                     "still_reads": sc.get("reads"), "still_elapsed_sec": sc.get("elapsed_sec"),
                     "still": sc.get("still")})
    out["still_reads_total"] = sum(s["still_reads"] or 0 for s in segs)
    out["retried_n"] = sum(1 for s in segs if s["retried"])
    return out, segs


def fmt(v, nd=3):
    if v is None:
        return "-"
    if isinstance(v, float):
        return f"{v:.{nd}f}"
    return str(v)


RUN_COLS = [("run", "run"), ("n_actual", "actual"), ("n_current_thread", "うち電流"), ("all_median", "間 中央"),
            ("all_p90", "90%"), ("all_long_n", "1秒超"), ("all_poll_median", "poll中央"), ("all_send_median", "send中央"),
            ("main_median", "本体だけ中央"), ("main_p90", "本体90%"), ("cur_median", "電流だけ中央"),
            ("order_reversed", "逆順"), ("late_current_thread", "送らず"), ("overruns", "見込み超え"),
            ("still_reads_total", "静止reads"), ("retried_n", "再送"), ("send_wait_on", "待ち"), ("result", "結果")]


def print_group(label, ms):
    print(f"\n## {label} ({len(ms)} 本)")
    print("  " + " | ".join(h for _, h in RUN_COLS))
    for m in ms:
        print("  " + " | ".join(fmt(m.get(k)) for k, _ in RUN_COLS))
    if len(ms) > 1:
        def med(k):
            v = [m[k] for m in ms if isinstance(m.get(k), (int, float))]
            return statistics.median(v) if v else None
        print("  (本ごとの中央値) " + " | ".join(
            f"{h} {fmt(med(k))}" for k, h in RUN_COLS[1:] if k not in ("result", "send_wait_on")))


def print_segments(groups):
    """区間ごと (step 順) に, 群ごとの中央値を並べる. 区間の並びが群で違えば step の名前で分かる."""
    print("\n## 区間ごと (群ごとの中央値: 送信の往復 (待ちを含む) / daemon だけの往復 / 区間の長さ / 静止の確かめの reads)")
    keys = []
    for _, segs in groups:
        for s in segs:
            k = (s["step"], s["kind"], s["name"])
            if k not in keys:
                keys.append(k)
    for k in sorted(keys, key=lambda x: (x[0] is None, x[0] or 0)):
        cells = []
        for label, segs in groups:
            ss = [s for s in segs if (s["step"], s["kind"], s["name"]) == k]

            def med(f):
                v = [s[f] for s in ss if isinstance(s.get(f), (int, float)) and not isinstance(s.get(f), bool)]
                return statistics.median(v) if v else None
            cells.append(f"{label}: n={len(ss)} rtt {fmt(med('send_rtt_sec'))} daemon {fmt(med('send_daemon_rtt_sec'))}"
                         f" 長さ {fmt(med('segment_elapsed_sec'))}"
                         f" reads {fmt(med('still_reads'))}")
        print(f"  step {k[0]} {k[1]} {k[2]}  " + "  /  ".join(cells))


def write_out(results, segs_all):
    ensure_ssd_mounted()
    out = OUT_ROOT / datetime.now().strftime("%Y%m%d_%H%M%S")
    if out.exists():
        sys.exit(f"[ABORT] 出し先がもうあります: {out}")
    out.mkdir(parents=True)
    cols = sorted({k for r in results for k in r})
    cols = ["group"] + [c for c in cols if c != "group"]
    with (out / "runs.csv").open("w", newline="") as f:
        w = csv.DictWriter(f, fieldnames=cols)
        w.writeheader()
        w.writerows(results)
    if segs_all:
        with (out / "segments.csv").open("w", newline="") as f:
            w = csv.DictWriter(f, fieldnames=list(segs_all[0].keys()))
            w.writeheader()
            w.writerows(segs_all)
    print(f"\n→ {out}")


def main(argv=None):
    ap = argparse.ArgumentParser(description="手教示の記録の実測角の間隔を直す前と後で並べる (依頼 202)")
    ap.add_argument("--before", nargs="*", default=[], help="直す前の run (名前かフォルダ)")
    ap.add_argument("--after", nargs="*", default=[], help="直したあとの run (名前かフォルダ)")
    ap.add_argument("--runs-root", default=str(RUNS_ROOT))
    ap.add_argument("--out", action="store_true", help="KIOXIA の runs/experiments/teach_state_rate/ に CSV も残す")
    a = ap.parse_args(argv)
    if not a.before and not a.after:
        ap.error("--before か --after に run を 1 本以上")
    results, groups, segs_all = [], [], []
    for label, names in (("before", a.before), ("after", a.after)):
        if not names:
            continue
        ms, ss = [], []
        for n in names:
            d = run_dir(n, a.runs_root)
            if not (d / "recording" / "states.csv").exists():
                sys.exit(f"[ABORT] states.csv がありません: {d}")
            m, segs = measure(d)
            m["group"] = label
            for s in segs:
                s["group"] = label
            ms.append(m)
            ss += segs
        print_group(label, ms)
        results += ms
        groups.append((label, ss))
        segs_all += ss
    print_segments(groups)
    if a.out:
        write_out(results, segs_all)
    return 0


if __name__ == "__main__":
    sys.exit(main())
```

### pi05/test_send_wait_mac.py


```python
#!/usr/bin/env python3
"""test_send_wait_mac.py — 手教示の再生で, 送信のあとの 1.0 秒の待ちを daemon から Mac 側へ移し, その間も
電流の記録スレッドが角度を読む形 (依頼 213. 依頼 197 の案 2) を偽の daemon で確かめる (アームなし・Pi なし. 2026-11-15).

  python3 pi05/test_send_wait_mac.py          # 全部 (再生を 2 回通すので 1 分半ほど)
  python3 pi05/test_send_wait_mac.py -v

偽の daemon は test_teach_current_actuals.PoseDaemon (read_servo の角度が腕の今の角度) で, send_angles だけ
本物の tools/pi/mecharm_daemon.py と同じ形にする: 書き込み → wait 秒眠る → 角度を 1 回読む → 返事.

確かめること:
  - --send-wait-on mac (既定): daemon へは wait=0・ソケットの期限 4.0 秒 (wait+3.0 と同じ) で送り, 返ってから
    Mac 側で 1.0 秒待つ. この間に電流の記録スレッドが read_servo で読み, states.csv の actual 行になる
  - 到達の確かめ (本体の最初の get_angles) が始まる時刻は送信の始めから 1.0 秒 + 書き込みと読み 1 回 のあと
    (daemon で待つときと同じ. 縮んでいない)
  - 本体が daemon に送る命令 (関節の目標・速さ・爪) と順, 本体の読みの回数, 到達・再送・静止の確かめは daemon で
    待つときと同じ (違うのは send_angles の wait だけ)
  - 送信と読みは同じ鍵で順に出る (送信の途中に read_servo が割り込まない. 鍵の中の時刻で重ならない)
  - 爪の命令から待ちの終わりまでは今までどおり読まない
  - --send-wait-on daemon は依頼 202 までと同じ (wait=1.0 を daemon へ. Mac 側で待たない. その間は読まない)
  - 区間と試行 JSON に send_wait_on・send_daemon_rtt_sec が残る. teach_state_rate.py が待ちの列を出す
  - _send_angles_guarded: 送信が例外でも 1.0 秒待ってから例外を返す・Ctrl-C は待たない・姿勢検査で弾いたら送らず待たない
  - コマンドの --send-wait-on の既定は mac・ほかの値は受け付けない
  - (codex R1) 窓の終わりぎわの read_servo が長引くと本体の次の読みはその分遅れる (早まらない・overruns に数える)
  - (codex R3) 送信が 4.0 秒で返らなければ切れて, 1.0 秒待ってから例外. 次の命令はつなぎ直して通る
KIOXIA にもアームにも触らない (一時フォルダと 127.0.0.1 だけ).
"""
import io
import sys
import tempfile
import threading
import time
import unittest
from pathlib import Path
from unittest import mock

_HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(_HERE))
sys.path.insert(0, str(_HERE.parent / "dynamic_tracking_limits" / "drag_teaching"))

import test_teach_currents as ttc  # noqa: E402
import test_recorder_currents as trc  # noqa: E402
import test_teach_current_actuals as tca  # noqa: E402  (PoseDaemon・write_states)
import policy_recorder as pr  # noqa: E402
import visual_servo_pick as vsp  # noqa: E402
import record_teach_demo as rtd  # noqa: E402
import teach_state_rate as tsr  # noqa: E402

WRITE_SEC = 0.010           # 本物の _mc.send_angles() の書き込み (実測 約 10 ms)
READ_ONCE_SEC = trc.OVERHEAD_SEC + trc.ANGLES_SEC   # 送ったあとの read_angles_once_for_log 1 回


class WaitDaemon(tca.PoseDaemon):
    """send_angles を本物の daemon と同じ形にする: 書き込み → wait 秒眠る → 角度を 1 回読む → 返事."""

    def _handle(self, c):
        if c.get("cmd") != "send_angles":
            return super()._handle(c)
        t0 = time.time()
        self.cmds.append(c)
        n = self.n_send
        self.n_send += 1
        time.sleep(WRITE_SEC)
        if n not in self.ignore_sends:
            start, goal = self.pose(), [float(x) for x in c["angles"]]
            self.cur = goal
            self.move = (start, goal, time.time(),
                         max(abs(x - y) for x, y in zip(start, goal)) / ttc.ARM_DEG_PER_SEC)
        wait = float(c.get("wait", 0))
        if wait > 0:
            time.sleep(wait)
        time.sleep(READ_ONCE_SEC)
        with self.span_lock:
            self.spans.append(("send_angles", t0, time.time(), dict(c)))
        return {"ok": True, "result": 1, "elapsed_ms": WRITE_SEC * 1000.0}


def replay(mode, run_dir, ignore_sends=()):
    """cmd_run と同じ順で再生を 1 回通す. 戻り値: dict (result・通知・log_record・daemon・鍵の中の時刻)."""
    d = WaitDaemon(ignore_sends=ignore_sends)
    rpcs = []

    def obs(cmd_obj, resp, t0, t1, err):
        rpcs.append(((cmd_obj or {}).get("cmd"), t0, t1, threading.current_thread().name))
    pr.add_rpc_observer(obs)
    try:
        result, sent, log_record, recorder = tca.replay(d, run_dir, sink=True, send_wait_on=mode)
    finally:
        pr.remove_rpc_observer(obs)
        d.close()
    return {"result": result, "sent": sent, "lr": log_record, "rec": recorder, "d": d, "rpcs": rpcs}


def sends(d):
    return [s for s in d.spans if s[0] == "send_angles"]


def next_main_get(d, after):
    """after より後で最初の本体の get_angles の始め (記録スレッドは get_angles を使わない)."""
    return min(s[1] for s in d.spans if s[0] == "get_angles" and s[1] >= after)


class TestReplaySendWait(unittest.TestCase):
    """再生を 2 回 (mac / daemon. どちらも電流を記録し角度を states.csv に渡す) 通して比べる."""

    @classmethod
    def setUpClass(cls):
        cls.td = Path(tempfile.mkdtemp())
        pr.install_daemon_lock()
        cls.mac = replay("mac", cls.td / "run_0001_20991115_000001")
        cls.dmn = replay("daemon", cls.td / "run_0002_20991115_000002")
        root = cls.td / "states"
        cls.st_mac = tca.write_states(root, "run_0001_20991115_000001", cls.mac["sent"])
        cls.st_dmn = tca.write_states(root, "run_0002_20991115_000002", cls.dmn["sent"])

    def test_completed(self):
        self.assertEqual((self.mac["result"], self.dmn["result"]), ("completed", "completed"))

    def test_wait_sent_to_daemon(self):
        """mac は wait=0, daemon は wait=1.0 を送る. ほかの中身 (目標・速さ) と順は同じ."""
        wm = {s[3].get("wait") for s in sends(self.mac["d"])}
        wd = {s[3].get("wait") for s in sends(self.dmn["d"])}
        self.assertEqual((wm, wd), ({0}, {rtd.SEND_WAIT_SEC}))
        strip = lambda d: [(s[0], {k: v for k, v in s[3].items() if k != "wait"})  # noqa: E731
                           for s in d.spans if s[0] in ("send_angles", "set_gripper", "set_gripper_value",
                                                        "set_fresh_mode")]
        self.assertEqual(strip(self.mac["d"]), strip(self.dmn["d"]))

    def test_socket_timeout_kept(self):
        """mac の wait=0 でもソケットの期限は daemon で待つときと同じ 4.0 秒 (既定の 35 秒にしない)."""
        seen = []
        orig = vsp._daemon_request

        def spy(cmd_obj, timeout_override=None, **k):
            seen.append((cmd_obj.get("wait"), timeout_override))
            return {"ok": True, "elapsed_ms": 1.0}
        with mock.patch.object(vsp, "_daemon_request", spy), mock.patch.object(rtd, "SEND_WAIT_ON", "mac"), \
                mock.patch.object(rtd.time, "sleep", lambda s: None):
            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t")
        self.assertIs(vsp._daemon_request, orig)
        self.assertEqual(seen, [(0, rtd.SEND_WAIT_SEC + 3.0)])

    def test_arrival_start_not_earlier(self):
        """本体の到達の確かめが始まるのは, どちらも送信の始めから 1.0 秒 + 書き込み + 読み 1 回 のあと."""
        lo = rtd.SEND_WAIT_SEC + WRITE_SEC + READ_ONCE_SEC
        delays = {}
        for name, r in (("mac", self.mac), ("daemon", self.dmn)):
            ds = []
            for s in sends(r["d"]):
                ds.append(next_main_get(r["d"], s[2]) - s[1])
            delays[name] = ds
            self.assertGreaterEqual(min(ds), lo - 0.002, name)
        # mac は daemon と同じ (送信の返事を待つ時間と, 眠りの終わりから起きるまでの時間の分だけずれる)
        for m, d in zip(delays["mac"], delays["daemon"]):
            self.assertLess(abs(m - d), 0.08)
        print(f"\n送信の始め → 到達の確かめの始め (秒): mac {[round(x, 3) for x in delays['mac']]}"
              f" / daemon {[round(x, 3) for x in delays['daemon']]}")

    def test_mac_reads_during_wait(self):
        """mac: 送信の返事のあとの 1.0 秒に read_servo が入る. daemon: 送信の間に read_servo は入らない."""
        per = []
        for s in sends(self.mac["d"]):
            end = s[2]
            n = sum(1 for x in self.mac["d"].spans
                    if x[0] == "read_servo" and end <= x[1] and x[2] <= end + rtd.SEND_WAIT_SEC + 0.05)
            per.append(n)
        self.assertTrue(all(n >= 5 for n in per), per)
        for s in sends(self.dmn["d"]):
            inside = [x for x in self.dmn["d"].spans if x[0] == "read_servo" and s[1] <= x[1] < s[2]]
            self.assertEqual(inside, [])
        rs = sorted(x[2] - x[1] for x in self.mac["d"].spans if x[0] == "read_servo")
        print(f"\n送信のあとの 1.0 秒に読めた read_servo の回数 (偽の daemon. 1 回 中央値 {rs[len(rs) // 2] * 1000:.0f} ms):"
              f" {per} 中央値 {sorted(per)[len(per) // 2]}")

    def test_lock_serializes_send_and_read(self):
        """送信と read_servo は同じ鍵の中で 1 件ずつ (鍵の中の時刻が重ならない). daemon 側の時刻でも重ならない."""
        for r in (self.mac, self.dmn):
            ivs = sorted((t0, t1, c) for c, t0, t1, _ in r["rpcs"] if c in ("send_angles", "read_servo", "get_angles"))
            self.assertGreater(len(ivs), 50)
            for (a0, a1, ca), (b0, b1, cb) in zip(ivs, ivs[1:]):
                self.assertLessEqual(a1, b0 + 1e-6, f"{ca} と {cb} が重なる")
            threads = {(c, th) for c, _, _, th in r["rpcs"] if c == "read_servo"}
            self.assertTrue(threads and all(th == "record_currents" for _, th in threads))
            sp = sorted(r["d"].spans, key=lambda s: s[1])
            for a, b in zip(sp, sp[1:]):
                self.assertLessEqual(a[2], b[1] + 1e-6)

    def test_main_unchanged(self):
        """本体の読みの回数・到達と静止の確かめの結果・本体の通知の並びは daemon で待つときと同じ."""
        n_get = lambda r: sum(1 for s in r["d"].spans if s[0] == "get_angles")  # noqa: E731
        # 到達の確かめの回数は腕が着くまでの実時間で決まるので, 別々に流した 2 回の再生では混んだ Mac で 1 回ずれる
        # ことがある (test_teach_current_actuals の daemon どうしでも起きた). 読み方は同じなので差は 1 回までとする
        self.assertLessEqual(abs(n_get(self.mac) - n_get(self.dmn)), 1)

        def summary(lr):
            return [(g.get("kind"), g.get("arrival_ok"), g.get("retried"), tuple(g.get("warnings") or ()),
                     (g.get("still_check") or {}).get("still"), (g.get("still_check") or {}).get("reads"))
                    for g in lr["segments"]]
        self.assertEqual(summary(self.mac["lr"]), summary(self.dmn["lr"]))
        no_act = lambda r: [k for k in tca.main_kinds(r["sent"]) if k[0] != "actual"]  # noqa: E731
        self.assertEqual(no_act(self.mac), no_act(self.dmn))               # stage・爪の通知の並びと中身は同じ
        n_act = lambda r: sum(1 for k in tca.main_kinds(r["sent"]) if k[0] == "actual")  # noqa: E731
        self.assertLessEqual(abs(n_act(self.mac) - n_act(self.dmn)), 1)    # 本体の actual (= 本体の読み) は上と同じ扱い
        self.assertEqual(self.mac["lr"]["currents"]["overruns"], 0)

    def test_no_reads_during_gripper(self):
        for r in (self.mac, self.dmn):
            for cmd, g0, nxt in ttc.gripper_windows(r["d"].spans):
                inside = [x for x in r["d"].spans if x[0] == "read_servo" and g0 <= x[1] < nxt - 0.03]
                self.assertEqual(inside, [], f"{cmd} の待ちの間に read_servo")

    def test_segment_records(self):
        for r, mode in ((self.mac, "mac"), (self.dmn, "daemon")):
            moves = [g for g in r["lr"]["segments"] if g.get("kind") == "move" or "send_rtt_sec" in g]
            self.assertGreater(len(moves), 3)
            for g in moves:
                self.assertEqual(g["send_wait_on"], mode)
                self.assertIsNotNone(g["send_daemon_rtt_sec"])
                # send_rtt_sec はどちらでも 1.0 秒の待ちを含む
                self.assertGreaterEqual(g["send_rtt_sec"], rtd.SEND_WAIT_SEC)
                if mode == "mac":
                    self.assertLess(g["send_daemon_rtt_sec"], 0.5)
                else:
                    self.assertGreaterEqual(g["send_daemon_rtt_sec"], rtd.SEND_WAIT_SEC)

    def test_rate_table(self):
        """teach_state_rate.py: mac は送信の間の抜けが埋まり 1 秒超の抜けが減る. 待ちの列は試行 JSON から読む."""
        m_mac, segs = tsr.measure(self.st_mac.parent.parent)
        m_dmn, _ = tsr.measure(self.st_dmn.parent.parent)
        self.assertEqual(m_mac["order_reversed"], 0)
        self.assertLess(m_mac["all_long_n"], m_dmn["all_long_n"])
        self.assertLess(m_mac["all_p90"], m_dmn["all_p90"])
        self.assertGreater(m_mac["n_current_thread"], m_dmn["n_current_thread"])
        print(f"\n偽の daemon での actual の間: daemon で待つ 中央値 {m_dmn['all_median']:.3f} 90% {m_dmn['all_p90']:.3f}"
              f" 1秒超 {m_dmn['all_long_n']} / mac で待つ 中央値 {m_mac['all_median']:.3f} 90% {m_mac['all_p90']:.3f}"
              f" 1秒超 {m_mac['all_long_n']} (電流スレッドの行 {m_dmn['n_current_thread']} → {m_mac['n_current_thread']})")

    def test_rate_table_send_wait_column(self):
        td = Path(tempfile.mkdtemp())
        run = td / "run_0009_20991115_000009"
        (run / "recording").mkdir(parents=True)
        (run / "recording" / "states.csv").write_text(self.st_mac.read_text())
        import json
        (run / f"{run.name}.json").write_text(json.dumps({"send_wait_on": "mac", "segments": [
            {"step": 1, "kind": "move", "to_name": "HOME", "send_rtt_sec": 1.05, "send_daemon_rtt_sec": 0.03}]}))
        m, segs = tsr.measure(run)
        self.assertEqual(m["send_wait_on"], "mac")
        self.assertEqual(segs[0]["send_daemon_rtt_sec"], 0.03)
        with mock.patch("sys.stdout", new=io.StringIO()) as out:
            tsr.print_group("後", [m])
            tsr.print_segments([("後", segs)])
        self.assertIn("待ち", out.getvalue())
        self.assertIn("daemon 0.030", out.getvalue())


class TestSendRetry(unittest.TestCase):
    """送信無視 → 5 秒待って再送の経路も mac で通る (再送も Mac 側で 1.0 秒待つ)."""

    def test_retry_path(self):
        pr.install_daemon_lock()
        r = replay("mac", Path(tempfile.mkdtemp()) / "run_0003_20991115_000003", ignore_sends=(1,))
        self.assertEqual(r["result"], "completed")
        seg = [g for g in r["lr"]["segments"] if g.get("retried")]
        self.assertEqual(len(seg), 1)
        self.assertIsNotNone(seg[0]["send_daemon_rtt_retry_sec"])
        self.assertGreaterEqual(seg[0]["send_rtt_retry_sec"], rtd.SEND_WAIT_SEC)
        self.assertEqual({s[3].get("wait") for s in sends(r["d"])}, {0})


class SlowTailDaemon(WaitDaemon):
    """送信の返事から slow_after 秒より後に始まる read_servo を slow_sec 秒遅らせる (窓の終わりぎわの読みが長引く場合)."""

    def __init__(self, slow_after=0.7, slow_sec=0.5, send_extra=0.0):
        self.slow_after, self.slow_sec, self.send_extra = slow_after, slow_sec, send_extra
        self.send_end = None
        super().__init__()

    def _handle(self, c):
        if c.get("cmd") == "send_angles":
            time.sleep(self.send_extra)
            resp = super()._handle(c)
            self.send_end = time.time()
            return resp
        if c.get("cmd") == "read_servo" and self.send_end and time.time() - self.send_end > self.slow_after:
            time.sleep(self.slow_sec)
        return super()._handle(c)


class TestSlowAndTimeout(unittest.TestCase):
    """codex R1・R3: 窓の終わりで読みが長引いた場合と, 送信のソケットの期限切れを本物の通信 (127.0.0.1) で通す."""

    def _with_daemon(self, d, fn):
        vsp.close_daemon_socket()
        try:
            with mock.patch.object(vsp, "DAEMON_HOST", "127.0.0.1"), mock.patch.object(vsp, "DAEMON_PORT", d.port), \
                    mock.patch.object(rtd, "SEND_WAIT_ON", "mac"), mock.patch("sys.stdout", new=io.StringIO()):
                return fn()
        finally:
            vsp.close_daemon_socket()
            d.close()

    def test_slow_read_at_window_end(self):
        """窓の終わりぎわに始めた read_servo が 0.5 秒長引くと, 本体の次の読みはその分だけ遅れる (早まらない).
        遅れは read_servo 1 回の上限 (READ_SERVO_TIMEOUT_SEC) までで, overruns に数える. 1.0 秒の待ちそのものは縮まない.
        読み方 (依頼 121 の窓の決まり) は変えていないので, 0.3 秒の到達の確かめの合間でも前から同じことが起こりうる."""
        pr.install_daemon_lock()
        d = SlowTailDaemon(slow_after=0.7, slow_sec=0.5)
        td = Path(tempfile.mkdtemp())

        def go():
            rec = rtd._Recorder(False, "run_s")
            rec.currents = rtd._start_currents(td)
            time.sleep(0.2)
            t0 = time.time()
            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=rec)
            t_back = time.time()
            vsp.daemon_get_angles()
            meta = rec.currents.stop()
            rtd._ACTIVE_CURRENTS.remove(rec.currents)
            return t0, t_back, meta
        t0, t_back, meta = self._with_daemon(d, go)
        get0 = next_main_get(d, t0)
        self.assertGreaterEqual(t_back - t0, rtd.SEND_WAIT_SEC)            # Mac 側の待ちは縮まない
        self.assertGreaterEqual(get0 - t0, rtd.SEND_WAIT_SEC + WRITE_SEC)  # 次の読みは早まらない
        self.assertGreaterEqual(meta["overruns"], 1)                        # 見込み超えとして数える
        self.assertLess(get0 - t0, rtd.SEND_WAIT_SEC + 0.1 + pr.READ_SERVO_TIMEOUT_SEC)
        print(f"\n窓の終わりで read_servo が 0.5 秒長引いた場合: 送信の始め → 本体の次の読み {get0 - t0:.3f} 秒"
              f" (長引かなければ 約 {rtd.SEND_WAIT_SEC + WRITE_SEC + READ_ONCE_SEC:.3f} 秒) overruns {meta['overruns']}")

    def test_send_socket_timeout(self):
        """daemon が 4.0 秒より長く返さなければ, 4.0 秒で切れて例外. そのあとも 1.0 秒待ってから例外を返す.
        次の命令はつなぎ直して通る."""
        d = SlowTailDaemon(send_extra=rtd.SEND_SOCKET_TIMEOUT_SEC + 0.6)

        def go():
            t0 = time.monotonic()
            with self.assertRaises(Exception):
                rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t")
            el = time.monotonic() - t0
            rtt = rtd._LAST_SEND["daemon_rtt_sec"]
            time.sleep(1.0)                      # 偽の daemon が遅れた返事を書き終えるまで
            a = vsp.daemon_get_angles()
            return el, rtt, a
        el, rtt, a = self._with_daemon(d, go)
        self.assertAlmostEqual(rtt, rtd.SEND_SOCKET_TIMEOUT_SEC, delta=0.3)
        self.assertGreaterEqual(el, rtd.SEND_SOCKET_TIMEOUT_SEC + rtd.SEND_WAIT_SEC - 0.05)
        self.assertLess(el, rtd.SEND_SOCKET_TIMEOUT_SEC + rtd.SEND_WAIT_SEC + 0.5)
        self.assertEqual(len(a), 6)


class _Rec(object):
    def __init__(self):
        self.windows = []

    def currents_window(self, sec):
        self.windows.append(sec)


class TestGuardedUnits(unittest.TestCase):
    def setUp(self):
        self.calls = []
        self.slept = []
        self.p = [mock.patch.object(rtd.time, "sleep", lambda s: self.slept.append(s)),
                  mock.patch.object(rtd, "daemon_send_angles", self._send)]
        for p in self.p:
            p.start()
        self.exc = None

    def tearDown(self):
        for p in self.p:
            p.stop()

    def _send(self, pose, speed, wait=0, timeout_override=None):
        self.calls.append((list(pose), speed, wait, timeout_override, list(self.slept)))
        if self.exc is not None:
            raise self.exc
        return {"ok": True}

    def test_mac_waits_after_send(self):
        rec = _Rec()
        with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"):
            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=rec)
        self.assertEqual(self.calls, [(list(rtd.HOME_ANGLES), 20, 0, rtd.SEND_SOCKET_TIMEOUT_SEC, [])])  # 送る前は眠らない
        self.assertEqual(self.slept, [rtd.SEND_WAIT_SEC])            # 送ったあとに 1.0 秒 (縮めない)
        self.assertEqual(rec.windows, [rtd.SEND_WAIT_SEC])           # その間を電流の記録に知らせる
        self.assertIsNotNone(rtd._LAST_SEND["daemon_rtt_sec"])

    def test_mac_without_recorder(self):
        with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"):
            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t")
        self.assertEqual(self.slept, [rtd.SEND_WAIT_SEC])

    def test_daemon_mode_unchanged(self):
        rec = _Rec()
        with mock.patch.object(rtd, "SEND_WAIT_ON", "daemon"):
            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=rec)
        self.assertEqual(self.calls, [(list(rtd.HOME_ANGLES), 20, rtd.SEND_WAIT_SEC, None, [])])
        self.assertEqual((self.slept, rec.windows), ([], []))

    def test_mac_send_error_still_waits(self):
        self.exc = RuntimeError("socket timeout")
        rec = _Rec()
        with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"), self.assertRaises(RuntimeError):
            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=rec)
        self.assertEqual(self.slept, [rtd.SEND_WAIT_SEC])
        self.assertIsNotNone(rtd._LAST_SEND["daemon_rtt_sec"])

    def test_daemon_send_error_keeps_rtt(self):
        self.exc = RuntimeError("socket timeout")
        with mock.patch.object(rtd, "SEND_WAIT_ON", "daemon"), self.assertRaises(RuntimeError):
            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=_Rec())
        self.assertEqual(self.slept, [])
        self.assertIsNotNone(rtd._LAST_SEND["daemon_rtt_sec"])

    def test_mac_ctrl_c_not_waited(self):
        self.exc = KeyboardInterrupt()
        with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"), self.assertRaises(KeyboardInterrupt):
            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=_Rec())
        self.assertEqual(self.slept, [])

    def test_backstop_no_send_no_wait(self):
        bad = list(rtd.HOME_ANGLES)
        bad[0] = float("nan")
        with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"), self.assertRaises(rtd._Aborted):
            rtd._send_angles_guarded(bad, 20, "t", recorder=_Rec())
        self.assertEqual((self.calls, self.slept), ([], []))
        self.assertIsNone(rtd._LAST_SEND["daemon_rtt_sec"])


class TestCli(unittest.TestCase):
    def _parse(self, argv):
        got = {}
        with mock.patch.object(rtd, "cmd_run", lambda a: got.setdefault("a", a) and 0), \
                mock.patch.object(sys, "argv", ["record_teach_demo.py"] + argv):
            rtd.main()
        return got["a"]

    def test_default_mac(self):
        self.assertEqual(self._parse(["run", "--teach", "x.json"]).send_wait_on, "mac")
        self.assertEqual(self._parse(["run", "--teach", "x.json", "--send-wait-on", "daemon"]).send_wait_on, "daemon")

    def test_bad_value(self):
        with mock.patch("sys.stderr", new=io.StringIO()), self.assertRaises(SystemExit):
            self._parse(["run", "--teach", "x.json", "--send-wait-on", "pi"])

    def test_trial_json_has_send_wait_on(self):
        """cmd_run の試行 JSON (log_record) と params に send_wait_on を入れている (cmd_run を最後まで通すには
        カメラと Pi が要るので, ソースで確かめる)."""
        import inspect
        src = inspect.getsource(rtd.cmd_run)
        head = src[src.index("log_record = {"):]
        self.assertIn('"send_wait_on": SEND_WAIT_ON,', head[:head.index('"current_angles_before_replay"')])
        self.assertEqual(src.count('"send_wait_on": SEND_WAIT_ON'), 2)       # いちばん上と params

    def test_cmd_run_rejects_bad_value(self):
        """cmd_run を直接呼ぶ形でも mac / daemon 以外は止める (グローバルは変えない)."""
        a = mock.Mock(grip_value=None, power=None, send_wait_on="pi", no_currents=False, no_record=False)
        with mock.patch("sys.stdout", new=io.StringIO()), self.assertRaises(SystemExit):
            rtd.cmd_run(a)
        self.assertEqual(rtd.SEND_WAIT_ON, "mac")


if __name__ == "__main__":
    unittest.main()
```

### pi05/test_teach_current_actuals.py


```python
#!/usr/bin/env python3
"""test_teach_current_actuals.py — 手教示の記録 (states.csv) に電流の記録スレッドが読んだ角度も actual 行として書く形
(依頼 202. 依頼 197 の案 1) を偽の daemon で確かめる (アームなし・Pi なし. 2026-11-15).

  python3 pi05/test_teach_current_actuals.py          # 全部 (再生を 2 回通すので 1 分ほど)
  python3 pi05/test_teach_current_actuals.py -v

偽の daemon は test_teach_currents.ArmDaemon (依頼 121) で, read_servo の角度だけ腕の今の角度にする (元は固定の値).
再生は cmd_run と同じ順 (install_daemon_lock → start_current_actuals → _start_currents(angle_sink=
recorder.actual_from_currents) → _replay → stop → close_current_actuals). recorder.py へ送る通知を集め, recorder.py の TrialWriter.write_state で states.csv にする.

確かめること:
  - 電流スレッドが読めた角度が actual 行 (note = source=current_thread) になり, 時刻は currents.csv の ts と同じ
  - 本体の通知 (stage・本体の actual・gripper_cmd) と本体が daemon に送る命令は, 角度を渡さない再生と同じ
    (到達・静止の確かめの結果と回数・関節と爪の命令の順と中身)
  - states.csv の行は時刻順. 爪の命令から待ちの終わりまで電流スレッドの actual 行はない
  - 既存の読み手が壊れない: build_demo_episodes.load_states・build_correction_episodes.gap_fill_flags
    (依頼 196 の state_source)・teach_state_rate.py (数えるスクリプト)
  - _Recorder: 先に積んだ行より前の時刻は積まずに数える・close_current_actuals のあとは積まない・壊れた値は数える.
    送信が止まっても本体の通知と電流スレッドは待たない (codex R1)・送り切れない分は数える・時計が戻った行は数える (R2).
    送り切れないまま閉じても積んだ行は trial_end を追い越さない (trial_end も列の最後に積む. codex 2・3 回目 R1)
    start_current_actuals を呼ばなければ今までどおりその場で送る
  - CurrentsRecorder: angle_sink が例外を出しても読み取りは続く (loop_errors に数える)・読めない角度は渡さない
KIOXIA にもアームにも触らない (一時フォルダと 127.0.0.1 だけ).
"""
import csv
import importlib.util
import io
import sys
import tempfile
import threading
import time
import unittest
from pathlib import Path
from unittest import mock

_HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(_HERE))
sys.path.insert(0, str(_HERE.parent / "dynamic_tracking_limits" / "drag_teaching"))

import test_teach_currents as ttc  # noqa: E402  (ArmDaemon・WAYPOINTS. 偽の daemon と run_policy_client のスタブ)
import test_recorder_currents as trc  # noqa: E402
import policy_recorder as pr  # noqa: E402
import visual_servo_pick as vsp  # noqa: E402
import record_teach_demo as rtd  # noqa: E402
import build_demo_episodes as bde  # noqa: E402
import build_correction_episodes as bce  # noqa: E402
import teach_state_rate as tsr  # noqa: E402

_spec = importlib.util.spec_from_file_location(
    "recorder_for_test", str(_HERE.parent / "dynamic_tracking_limits" / "place" / "place_modules" / "recorder.py"))
reco = importlib.util.module_from_spec(_spec)
_spec.loader.exec_module(reco)

NOTE = rtd.CURRENT_THREAD_NOTE


class PoseDaemon(ttc.ArmDaemon):
    """read_servo の角度を腕の今の角度にする (states.csv に書かれる角度が動きに沿うか見るため)."""

    def _handle(self, c):
        resp = super()._handle(c)
        if c.get("cmd") == "read_servo" and isinstance(resp, dict) and "angles" in (resp.get("items") or {}):
            resp["items"]["angles"]["value"] = self.pose()
        return resp


def replay(daemon, run_dir, sink=True, send_wait_on="daemon"):
    """cmd_run と同じ順で再生を 1 回通す. 戻り値: (result, 通知, log_record, recorder).
    依頼 213: ttc.ArmDaemon は send_angles の wait を見ずに SEND_SEC (待ちを含む) で返すので, 既定は daemon 側で待つ形.
    Mac 側で待つ形は test_send_wait_mac.py (wait を本物どおりに扱う偽の daemon) が send_wait_on="mac" で呼ぶ."""
    sent = []
    vsp.close_daemon_socket()
    log_record = {"current_angles_before_replay": list(rtd.HOME_ANGLES)}
    seq = rtd.wpsr._build_segments(ttc.WAYPOINTS)
    with mock.patch.object(vsp, "DAEMON_HOST", "127.0.0.1"), mock.patch.object(vsp, "DAEMON_PORT", daemon.port), \
            mock.patch.object(rtd.rpp, "recorder_notify", lambda p: sent.append(dict(p))), \
            mock.patch.object(rtd, "SEND_WAIT_ON", send_wait_on), \
            mock.patch("sys.stdout", new=io.StringIO()):
        recorder = rtd._Recorder(True, run_dir.name)
        if sink:
            recorder.start_current_actuals()
        recorder.currents = rtd._start_currents(
            run_dir, angle_sink=recorder.actual_from_currents if sink else None)
        result = rtd._replay(seq, recorder, log_record)
        log_record["currents"] = recorder.currents.stop()
        recorder.close_current_actuals()
    vsp.close_daemon_socket()
    return result, sent, log_record, recorder


def write_states(runs_root, run_stem, sent):
    """recorder.py の TrialWriter で states.csv を書く (本物の書き手. 届いた順に書く)."""
    with mock.patch.object(reco, "RUNS_ROOT", runs_root), mock.patch("sys.stdout", new=io.StringIO()):
        tw = reco.TrialWriter(run_stem, 64, 48)
        for p in sent:
            if p["type"] in ("stage", "commanded", "gripper", "actual", "gripper_cmd"):
                tw.write_state(p["type"], p)
        tw.close("ok")
    return runs_root / run_stem / "recording" / "states.csv"


def is_cur(p):
    return p.get("type") == "actual" and p.get("note") == NOTE


def main_kinds(sent):
    return [(p["type"], p.get("stage"), p.get("state"), p.get("note")) for p in sent if not is_cur(p)]


class TestReplayCurrentActuals(unittest.TestCase):
    """再生を 2 回 (角度を渡す / 渡さない. どちらも電流は記録する) 通して比べる."""

    @classmethod
    def setUpClass(cls):
        cls.td = Path(tempfile.mkdtemp())
        pr.install_daemon_lock()
        cls.d_on, cls.d_off = PoseDaemon(), PoseDaemon()
        try:
            cls.on = replay(cls.d_on, cls.td / "run_0001_20991115_000000", sink=True)
            cls.off = replay(cls.d_off, cls.td / "run_0002_20991115_000000", sink=False)
        finally:
            cls.d_on.close()
            cls.d_off.close()
        cls.rec = cls.td / "run_0001_20991115_000000" / "recording"
        cls.states_root = cls.td / "states"
        cls.st_on = write_states(cls.states_root, "run_0001_20991115_000000", cls.on[1])
        cls.st_off = write_states(cls.states_root, "run_0002_20991115_000000", cls.off[1])

    def test_completed(self):
        self.assertEqual((self.on[0], self.off[0]), ("completed", "completed"))

    def test_current_rows_sent(self):
        cur = [p for p in self.on[1] if is_cur(p)]
        rec = self.on[3]
        self.assertGreater(len(cur), 30)
        self.assertEqual(len(cur), rec.actual_sent_current_thread)
        self.assertEqual(rec.actual_current_thread_errors, 0)
        self.assertFalse(any(is_cur(p) for p in self.off[1]))
        # 時刻は currents.csv の ts (角度を読んだ時刻) と同じ. 送らなかった分だけ少ない
        cts = [r[0] for r in ttc.read_csv(self.rec / "currents.csv")[1:]]
        got = [f"{p['ts']:.6f}" for p in cur]
        self.assertTrue(set(got) <= set(cts))
        self.assertEqual(len(cts) - len(got), rec.actual_current_thread_late)
        self.assertEqual(rec.actual_sent, self.off[3].actual_sent)      # 本体の actual の数 (試行 JSON) は今までの意味

    def test_main_unchanged(self):
        """本体の通知・本体の daemon への命令・到達と静止の確かめは角度を渡さない再生と同じ."""
        self.assertEqual(main_kinds(self.on[1]), main_kinds(self.off[1]))
        cmds = lambda d: [(s[0], s[3]) for s in d.spans if s[0] in  # noqa: E731
                          ("send_angles", "set_gripper", "set_gripper_value", "set_fresh_mode")]
        self.assertEqual(cmds(self.d_on), cmds(self.d_off))
        n_get = lambda d: sum(1 for s in d.spans if s[0] == "get_angles")  # noqa: E731
        self.assertEqual(n_get(self.d_on), n_get(self.d_off))         # 本体の読みの回数も同じ

        def summary(lr):
            return [(g.get("kind"), g.get("arrival_ok"), g.get("retried"), tuple(g.get("warnings") or ()),
                     (g.get("still_check") or {}).get("still"), (g.get("still_check") or {}).get("reads"))
                    for g in lr["segments"]]
        self.assertEqual(summary(self.on[2]), summary(self.off[2]))
        self.assertEqual(self.on[2]["currents"]["overruns"], 0)

    def test_states_csv_order_and_note(self):
        with self.st_on.open() as f:
            rows = list(csv.DictReader(f))
        self.assertEqual(list(rows[0].keys()), reco.STATES_COLS)         # 列は変えない
        ts = [float(r["ts"]) for r in rows]
        self.assertEqual(ts, sorted(ts))                                 # 時刻順
        acts = [r for r in rows if r["event_type"] == "actual"]
        notes = {r["note"] for r in acts}
        self.assertEqual(notes, {"", NOTE})
        self.assertTrue(all(r["j0"] != "" for r in acts))
        # 電流スレッドの行の stage は, その時刻に recorder.py が見ていた区間 (前の stage 行) と同じ
        cur_stage = ""
        for r in rows:
            if r["event_type"] == "stage":
                cur_stage = r["stage"]
            self.assertEqual(r["stage"], cur_stage)
        print("\nstates.csv の行の例 (直したあと):")
        for r in rows[:12]:
            print("  " + ",".join(r[c] for c in reco.STATES_COLS))

    def test_no_current_rows_during_gripper(self):
        cur_ts = [p["ts"] for p in self.on[1] if is_cur(p)]
        for cmd, g0, nxt in ttc.gripper_windows(self.d_on.spans):
            inside = [t for t in cur_ts if g0 <= t < nxt - 0.03]
            self.assertEqual(inside, [], f"{cmd} の待ちの間に電流スレッドの actual 行")

    def test_angles_follow_arm(self):
        """電流スレッドの角度は腕の動きに沿う (固定の値ではない)."""
        cur = [p["angles"] for p in self.on[1] if is_cur(p)]
        self.assertGreater(len({tuple(round(x, 1) for x in a) for a in cur}), 3)

    def test_readers(self):
        at_on, aq_on, gt_on, _ = bde.load_states(self.st_on)
        at_off, _, gt_off, _ = bde.load_states(self.st_off)
        n_cur = sum(1 for p in self.on[1] if is_cur(p))
        self.assertEqual(len(at_on), len(at_off) + n_cur)
        self.assertEqual(list(gt_on) == sorted(gt_on), True)
        self.assertEqual(len(gt_on), len(gt_off))
        # 依頼 196 の state_source: 実測の間が狭くなるので, 埋めたコマ (0.1 秒おきのコマで数える) の割合は増えない
        def filled_share(st):
            at, aq, _, _ = bde.load_states(st)
            t = bde.np.arange(at[0], at[-1], 0.1)
            return float((bce.gap_fill_flags(t, at, aq) != 0).mean())
        self.assertLessEqual(filled_share(self.st_on), filled_share(self.st_off))

    def test_rate_table(self):
        """数えるスクリプト (teach_state_rate.py) で直す前・後を数える. ポーリングの間が狭くなる."""
        m_on, _ = tsr.measure(self.st_on.parent.parent)
        m_off, _ = tsr.measure(self.st_off.parent.parent)
        self.assertEqual(m_on["order_reversed"], 0)
        self.assertEqual(m_on["n_main"], m_off["n_actual"])
        self.assertAlmostEqual(m_on["main_median"], m_off["all_median"], delta=0.03)   # 本体の読みだけなら今までと同じ形
        self.assertLess(m_on["all_poll_median"], m_off["all_poll_median"])
        print(f"\n偽の daemon での actual の間 (send_angles {ttc.SEND_SEC} 秒): 直す前 中央値 {m_off['all_median']:.3f}"
              f" 90% {m_off['all_p90']:.3f} poll {m_off['all_poll_median']:.3f} / 直したあと 中央値 {m_on['all_median']:.3f}"
              f" 90% {m_on['all_p90']:.3f} poll {m_on['all_poll_median']:.3f} (電流スレッドの行 {m_on['n_current_thread']})")


class TestRecorderUnits(unittest.TestCase):
    def setUp(self):
        self.sent = []
        self.p = mock.patch.object(rtd.rpp, "recorder_notify", lambda p: self.sent.append(dict(p)))
        self.p.start()
        self.rec = rtd._Recorder(True, "run_x")
        self.rec.start_current_actuals()

    def tearDown(self):
        self.rec.close_current_actuals()
        self.p.stop()

    def test_late_dropped(self):
        self.rec.actual([0] * 6)
        self.rec.actual_from_currents([1] * 6, self.rec._last_state_ts - 0.01)   # 本体の行より前 → 積まない
        self.rec.actual_from_currents([2] * 6, self.rec._last_state_ts + 0.01)
        self.rec.close_current_actuals()
        self.assertEqual([p.get("note") for p in self.sent], [None, NOTE])
        self.assertEqual((self.rec.actual_current_thread_late, self.rec.actual_sent_current_thread), (1, 1))
        self.assertEqual(self.rec.actual_sent, 1)

    def test_stage_counts_as_previous_row(self):
        self.rec.stage("PICK")
        self.rec.actual_from_currents([1] * 6, self.rec._last_state_ts - 0.001)
        self.rec.close_current_actuals()
        self.assertEqual([p["type"] for p in self.sent], ["stage"])

    def test_gripper_ts_kept(self):
        self.rec.gripper_cmd(1, "close", ts=123.0)
        self.rec.close_current_actuals()
        self.assertEqual(self.sent[-1]["ts"], 123.0)               # 渡した時刻のまま (今までどおり)

    def test_closed(self):
        self.rec.close_current_actuals()
        self.rec.actual_from_currents([1] * 6, time.time())
        self.assertEqual(self.sent, [])
        self.assertEqual(self.rec.actual_sent_current_thread, 0)
        self.rec.stage("X")                                        # 閉じたあとは今までどおりその場で送る
        self.assertEqual([p["type"] for p in self.sent], ["stage"])

    def test_bad_values(self):
        self.rec.actual_from_currents(["x"] * 6, time.time())
        self.rec.actual_from_currents([float("nan")] * 6, time.time())
        self.rec.actual_from_currents([1] * 5, time.time())
        self.rec.close_current_actuals()
        self.assertEqual((self.sent, self.rec.actual_current_thread_errors), ([], 3))

    def test_disabled(self):
        rec = rtd._Recorder(False, "run_x")
        rec.start_current_actuals()
        rec.actual_from_currents([1] * 6, time.time())
        rec.actual([1] * 6)
        rec.close_current_actuals()
        self.assertEqual(self.sent, [])

    def test_not_started_sends_inline(self):
        """start_current_actuals を呼ばなければ今までどおりその場で送り, 電流スレッドの角度は受け付けない."""
        rec = rtd._Recorder(True, "run_y")
        rec.actual([1] * 6)
        rec.actual_from_currents([2] * 6, time.time() + 1)
        self.assertEqual([p.get("note") for p in self.sent], [None])
        self.assertEqual(rec.actual_sent_current_thread, 0)

    def test_order_across_threads(self):
        """本体と電流スレッドが同時に積んでも, 届く順は時刻順."""
        stop = time.time() + 0.5

        def cur():
            while time.time() < stop:
                self.rec.actual_from_currents([1] * 6, time.time())
        th = threading.Thread(target=cur)
        th.start()
        while time.time() < stop:
            self.rec.actual([0] * 6)
            self.rec.stage("S")
        th.join()
        self.rec.close_current_actuals()
        ts = [p["ts"] for p in self.sent]
        self.assertGreater(self.rec.actual_sent_current_thread, 10)
        self.assertEqual(ts, sorted(ts))

    def test_clock_backwards_counted(self):
        self.rec.gripper_cmd(1, "close", ts=time.time() + 100)
        self.rec.actual([0] * 6)                                   # 前の行より前の時刻 → 送るが数える
        self.rec.close_current_actuals()
        self.assertEqual(len(self.sent), 2)
        self.assertEqual(self.rec.state_ts_backwards, 1)


class TestSlowNotify(unittest.TestCase):
    """codex R1 必須: 通知の送信が止まっても本体と電流スレッドは待たない. 閉じるのも上限まで.
    codex 2・3 回目 R1 必須: 送り切れないまま閉じても, 積んだ行は trial_end を追い越さない (trial_end も列の最後に積む)."""

    def _stuck(self):
        self.gate = threading.Event()
        self.sent = []

        def slow(p):
            if p.get("type") != "trial_end":
                self.gate.wait(5.0)
            self.sent.append(dict(p))
        return mock.patch.object(rtd.rpp, "recorder_notify", slow)

    def test_stuck_send(self):
        with self._stuck():
            rec = rtd._Recorder(True, "run_z")
            rec.start_current_actuals()
            t0 = time.time()
            for _ in range(20):
                rec.actual([0] * 6)
                rec.stage("S")
                rec.actual_from_currents([1] * 6, time.time())
            self.assertLess(time.time() - t0, 0.2)                    # 送信が止まっていても積むだけで戻る
            t1 = time.time()
            rec.close_current_actuals(timeout=0.3)
            rec.trial_end()
            self.assertLess(time.time() - t1, 1.0)                   # 閉じるのも trial_end も上限まで (本体は待たない)
            self.assertTrue(rec.current_actuals_flush_timeout)
            self.assertEqual(rec.current_actuals_unsent, 60)         # 期限の時点でまだの数 (途中の 1 件を含む)
            self.assertTrue(rec.trial_end_via_sender)
            self.gate.set()                                          # 送信が戻ると, 積んだ順に送り切る
            for _ in range(100):
                if self.sent and self.sent[-1]["type"] == "trial_end":
                    break
                time.sleep(0.02)
        types = [p["type"] for p in self.sent]
        self.assertEqual(len(types), 61)
        self.assertEqual(types[-1], "trial_end")                     # trial_end を追い越さない
        ts = [p["ts"] for p in self.sent[:-1]]
        self.assertEqual(ts, sorted(ts))
        self.assertEqual(rec.state_rows_sent_by_sender, 61)

    def test_normal_counts(self):
        sent = []
        with mock.patch.object(rtd.rpp, "recorder_notify", lambda p: sent.append(dict(p))):
            rec = rtd._Recorder(True, "run_v")
            rec.start_current_actuals()
            rec.stage("S")
            rec.actual_from_currents([1] * 6, time.time())
            rec.close_current_actuals()
            rec.trial_end()
        self.assertEqual([p["type"] for p in sent], ["stage", "actual", "trial_end"])
        self.assertEqual((rec.state_rows_sent_by_sender, rec.current_actuals_unsent,
                          rec.current_actuals_flush_timeout, rec.trial_end_via_sender), (2, 0, False, False))


class TestCurrentsRecorderSink(unittest.TestCase):
    def _run(self, sink, daemon):
        td = Path(tempfile.mkdtemp())
        with mock.patch("sys.stdout", new=io.StringIO()):
            cur = pr.CurrentsRecorder(td, lambda c: daemon._handle(c))
            cur.angle_sink = sink
            cur.start()
            t_end = time.time() + 1.0
            while time.time() < t_end:
                cur.window(0.3)
                time.sleep(0.3)
            meta = cur.stop()
        return cur, meta

    def test_sink_error_keeps_reading(self):
        d = trc.FakeDaemon()
        calls = []

        def bad(a, ts):
            calls.append(ts)
            raise RuntimeError("x")
        cur, meta = self._run(bad, d)
        try:
            self.assertGreaterEqual(len(calls), 2)
            self.assertEqual(meta["loop_errors"], len(calls))
            self.assertEqual(meta["currents_rows"], len(calls))       # 電流の行は今までどおり書く
        finally:
            d.close()

    def test_no_angles_not_sent(self):
        d = trc.FakeDaemon()
        orig = d._handle

        def no_angles(c):
            r = orig(c)
            if c.get("cmd") == "read_servo":
                r["items"] = {}
            return r
        d._handle = no_angles
        calls = []
        cur, meta = self._run(lambda a, ts: calls.append(ts), d)
        try:
            self.assertEqual(calls, [])
            self.assertGreaterEqual(meta["currents_rows"], 2)
        finally:
            d.close()


if __name__ == "__main__":
    unittest.main()
```



## 出典

- Physical Intelligence「π0.5」 https://www.pi.website/blog/pi05
- Anthropic「Claude Code」 https://www.anthropic.com/claude-code
- LOG512（フィジカルAI研究室を作る Log#36）mechArm 270 のお手本を測ったら、動きの半分は補った値だった https://pixelstomotors.com/record/mecharm-270-demo-data-half-motion-interpolated

