commit da3b062d89d269806d3390a878418410619bfcbb
Author: Eiichi Shimazu <studio@adaptdesign.jp>
Date:   Mon Nov 16 11:19:58 2026 +0900

    手教示の再生で送信のあとの 1.0 秒を daemon 0.2 秒 + Mac 0.8 秒に分ける形 (依頼 225・依頼 215 の案 F) のテストと集計の列を足す
    
    record_teach_demo.py (git の外) に --send-wait-on split (既定) を足した分のテスト pi05/test_send_wait_split.py と,
    teach_state_rate.py に 送信が無視された回・daemon の読みが返事なしの見込み・daemon 往復の中央と最大・待ちの形の列を足す.
    test_send_wait_mac.py は既定が split に替わった所だけ直す. 報告 claude_code_reports/20261116_225.txt
    
    Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

diff --git a/claude_code_reports/20261116_225.txt b/claude_code_reports/20261116_225.txt
new file mode 100644
index 0000000..b963ace
--- /dev/null
+++ b/claude_code_reports/20261116_225.txt
@@ -0,0 +1,97 @@
+依頼225 Pi の pymycobot を 2.9.6 に戻して固定し、手教示の再生に案F（送ったあとの 1.0 秒を daemon 0.2 秒＋Mac 0.8 秒に分ける）を入れる
+
+実機は動かしていない。Pi にはつながらなかった（下の 1）。
+
+■ 1. pymycobot を 2.9.6 に戻す（Pi）… できていない
+- Pi（ubuntu@192.168.2.1）に SSH も ping も届かなかった（2026-11-16 10:20 ごろと 11:40 ごろの 2 回。Mac に 192.168.2.x の口がなく、有線がつながっていないか Pi の電源が切れている見込み）
+- そのため、いまの版・置き場所の確かめ、2.9.6 への入れ替え、import での確かめ、4.0.4 を誰が入れたかの手がかり読みは、どれもできていない
+- 用意だけした: Mac で 2.9.6 の wheel を取ってきた
+  tools/pi/wheels/pymycobot-2.9.6-py3-none-any.whl（48,059 バイト・sha256 58a6a0c231505630d1896f0d6bfb6596f89aaa2e23df8cdb96a6702d4e6e0a6d。中の __version__ = "2.9.6"・必要なのは pyserial だけ）
+  git には入れていない
+- Pi がつながったらやる手順（次の依頼かエイイチが流す。daemon は立ち上げ直さない。4.0.4 の whl は消さない）
+  1) 確かめる（読むだけ）
+     ssh -i ~/.ssh/id_rsa_pi ubuntu@192.168.2.1 'python3.6 -c "import pymycobot;print(pymycobot.__version__, pymycobot.__file__)"; python3.6 -m pip show pymycobot; ls -la --time-style=full-iso /home/ubuntu/*.whl'
+  2) 手がかり（読むだけ）
+     ssh ... 'grep -n pymycobot ~/.bash_history | tail -20; ls -la --time-style=full-iso ~/.cache/pip 2>/dev/null; grep -rl pymycobot ~/.cache/pip/log 2>/dev/null | head'
+  3) 送って入れる
+     scp -i ~/.ssh/id_rsa_pi tools/pi/wheels/pymycobot-2.9.6-py3-none-any.whl ubuntu@192.168.2.1:/home/ubuntu/
+     ssh ... 'python3.6 -m pip install --no-deps --force-reinstall /home/ubuntu/pymycobot-2.9.6-py3-none-any.whl'
+     （1 で置き場所が /usr/local など root のときは sudo が要る。--user で入っていたら --user を付ける。どちらかは 1 を見て決める）
+  4) 確かめる: ssh ... 'python3.6 -c "import pymycobot;print(pymycobot.__version__)"' が 2.9.6
+  5) 固定: 戻したあと pip で上げ直されないよう、何かの requirements に pymycobot==2.9.6 を書くかどうかは決めてほしいこと（下）
+
+■ 2. 案F を入れた（record_teach_demo.py）
+直す前の写し: dynamic_tracking_limits/drag_teaching/record_teach_demo.py.bak_pre_req225_20261116
+（teach_state_rate.py の写し pi05/teach_state_rate.py.bak_pre_req225_20261116）
+
+やったこと
+- --send-wait-on に split を足し、既定にした（mac・daemon もこれまでどおり選べる）
+  - split: daemon に wait=0.2 で送る（daemon は 書き込み → 0.2 秒眠る → 1 回読む → 返事）。返事が来てから Mac で 0.8 秒待つ
+  - 秒数は --split-daemon-wait（既定 0.2）・--split-mac-wait（既定 0.8）で変えられる。合計が 1.0 秒より短い・daemon が 0 以下・Mac が負・数でない・split 以外で付けた、のときは動く前に止める（ABORT）
+  - Mac で待つ 0.8 秒は _sleep_open で電流の記録スレッドに知らせる（依頼213 と同じく角度を読める）
+  - daemon が待つ 0.2 秒は送信のやりとりの中（install_daemon_lock の鍵の中）なので、電流の記録スレッドは読まない（テストで送信の間に read_servo が入らないことを確かめた）
+  - ソケットの期限: visual_servo_pick の決まりどおり wait+3.0 = 3.2 秒（timeout_override は短くしかできないので渡さない。daemon の形の 4.0 秒より短いが、daemon の返事は 0.2 秒 + 書き込み + 読み 1 回 で約 0.23〜0.33 秒）
+  - 送信が例外でも待ってから例外を返す。0.2 秒を経ずに早く返った（すぐの例外など）ときは、送信の始めから合わせて 1.0 秒になるまで Mac で待つ（codex 1 回目 R1）。Ctrl-C は待たない（今までと同じ）
+- 記録
+  - 試行 JSON のいちばん上・params・区間ごとに send_wait_on と send_daemon_wait_sec（split は 0.2）・send_mac_wait_sec（0.8）。これは設定の値で、例外のときに延ばした実際の秒数ではない
+  - states.csv の stage 行の note に「send_wait_on=split daemon_wait=0.2 mac_wait=0.8」（mac は daemon_wait=0 mac_wait=1、daemon は daemon_wait=1 mac_wait=0）。列は足していない。電流スレッドの actual 行の note（source=current_thread）は今までどおり
+  - 区間ごとに send_daemon_failed（例外になった送信 "send" / "retry"）
+- 数えるもの
+  - 試行 JSON の send_ignored: 送信が無視された回（到達の待ちが切れて、動いた角度が 1.0° 未満で再送した回）の数・うち 0.00° の数・1 回ごとの区間と動いた角度・再送で届いたか。ログにも「送信が無視されたとみなして再送した回: N 回」と出す
+  - 試行 JSON の daemon_read_none_suspects: daemon.log の「send_angles 後の現在角度: None」の代わりの見込みの数。Pi の時計がずれていて daemon.log は秒単位なので、1 本ごとに Mac から確実に数える方法が無い。依頼215 で分かった「返事なしだと daemon の往復が約 0.1 秒長い」を使い、send_daemon_rtt_sec − daemon の wait が 0.08 秒以上の送信を数える（例外になった送信は skipped_send_error に別に数える）。ロック待ちや通信の遅れも混ざりうるので見込み
+  - pi05/teach_state_rate.py の本ごとの表に「無視」「うち0.00°」「無視の角度」「読みNone見込み」「daemon往復中央」「daemon往復最大」「待ち」（split は split 0.2+0.8）を足した。依頼225 より前の本は区間の retried から無視を数える（同じ決まり）
+- 変えていないもの: 関節の目標・速さ・送る回数、到達と静止の確かめ、爪の前後で読みを止めること、爪の待ち、再送の決まり、tools/pi/mecharm_daemon.py（git の差分なし）。send_coords は使っていない（差分に無い）。CLAUDE.md の「time.sleep を短縮しない」: 合計 1.0 秒は縮めていない（daemon の中の time.sleep(0.2) と Mac 側の time.sleep(0.8) に分けただけで、早く返ったときは Mac 側を延ばす）
+
+テスト
+- pi05/test_send_wait_split.py（新しく 27 件）OK: wait=0.2 で送ること・ソケットの期限の決まり・到達の確かめが始まるのは送信の始めから 1.043〜1.051 秒（daemon の形 1.038〜1.046 秒。縮んでいない）・0.2 秒の間に read_servo が入らない・0.8 秒の間に読む・命令の中身と順・到達/再送/静止の結果が daemon の形と同じ・JSON と states.csv の記録・無視の数え方（偽の daemon で 1 回無視させて 無視 1 回・0.00°・daemon 往復中央 0.242 秒）・早い例外で 1.0 秒まで延ばす・本物のソケットで 3.2 秒で切れて 0.8 秒待ち次はつなぎ直して通る・コマンドの既定と止める条件
+- pi05/test_send_wait_mac.py: 既定が split に替わった所（既定の確かめ・stage 行の note が形ごとに違う所）だけ直した。25 件 OK
+- pi05/ のテスト 29 本: 27 本 OK。test_state_source は前から落ちる（依頼213 と同じ・今回と関係ない state_source の件）。test_teach_currents は一式で流したとき 1 件落ち（本体の get_angles の数が 1 回ずれる。依頼213 で書いた時刻のゆらぎ）、単独で流し直して 27 件 OK
+- codex の指摘を直したあとに流し直した: test_send_wait_split 27 件 OK・test_send_wait_mac 25 件 OK・test_teach_current_actuals 21 件 OK・test_teach_currents 27 件 OK・test_power_ab 20 件 OK・test_no_step_confirm 17 件 OK
+- ドライラン: python3 record_teach_demo.py run --teach drag_v2_20221013_152840_with_pos.json --teach-local drag_v2_20221013_152840_with_pos.json --grip-value 20 --power 5A
+  「送信のあとの 1.0s の待ち: daemon 0.2s + Mac 0.8s に分ける」と出て、計画を出して止まった。合計 0.9 秒と、daemon の形に --split-mac-wait を付けたものは ABORT
+
+codex レビュー（codex exec -s read-only）
+- 1 回目: 必須 1・推奨 2
+  - R1 必須: すぐの例外・早い ok=False では合計 1.0 秒を割る → 送信の始めから 1.0 秒に届くまで Mac で延ばす形に直した
+  - R2: None の見込みに通信の失敗が混ざる → 例外になった送信を別に数える形に直した
+  - R3: 異常のときのテスト → 足した
+- 2 回目: 必須なし。推奨 R2（先頭 HOME の 1 回目が通って再送が例外のときに混ざる）→ 4 か所すべてで例外になった送信を区間に残す形に直した。推奨 R3（本物のソケットで期限切れ）→ テストを足した
+- 3 回目: 必須なし。推奨 2 は据え置き
+  - R1: 先頭 HOME の再送の例外を再生を通して確かめるテスト（今は 4 か所に入っていることをソースで、数え方を手作りの区間で確かめている）
+  - R2: 3.2 秒は 1 回の受信の期限で、つなぎ直しまで含めた送信全体の上限ではない（daemon の形の 4.0 秒も同じ作り。待ちが縮む話ではない）
+
+■ 3. 位置1〜5 を撮るときのコマンド（エイイチ）
+Pi の pymycobot を 2.9.6 に戻すのは、daemon を立ち上げ直す前ならいつでもよい（今の daemon は 2.9.6 で動いている）。
+1. 位置 N の印にブロックを置いて測る
+   python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py measure
+2. ドライラン（「daemon 0.2s + Mac 0.8s に分ける」と出るのを見る）
+   python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py run --teach drag_v2_20261109_094222.json --grip-value 20 --power 5A
+3. 1 本撮る（既定が split。--send-wait-on split は付けても同じ）
+   python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py run --teach drag_v2_20261109_094222.json --grip-value 20 --power 5A --execute
+   （位置ごとの teach ファイルはこれまでのお手本の撮り方どおり）
+4. 無視が出たら案A に切り替えて撮り続ける
+   python3 dynamic_tracking_limits/drag_teaching/record_teach_demo.py run --teach ... --grip-value 20 --power 5A --execute --send-wait-on daemon
+5. 並べる（--out で CSV も残る）
+   python3 pi05/teach_state_rate.py --after run_0001_20261116_HHMMSS [ほかの本 ...] --out
+
+1 本ごとに見る所
+- 無視の回数: 実行の最後のログ「送信が無視されたとみなして再送した回: N 回」・試行 JSON の send_ignored（count・zero_move_count・events の retry_move_deg）・teach_state_rate.py の「無視」「うち0.00°」「無視の角度」。0.00° の無視が 1 回でも出たら案A へ
+- 1 秒を超える抜け: teach_state_rate.py の「1秒超」（依頼213 の前の 2 本は 11。爪の待ちの分は残る）と「send中央」
+- send_daemon_rtt_sec が約 0.23 秒か: 表の「daemon往復中央」「daemon往復最大」。約 0.33 秒の送信は daemon の直後の読みが返事なしだった見込みで、「読みNone見込み」に数が出る（0.2 秒あとでも返事なしが多いかを見る所）
+- daemon.log の None を本当に数えるとき（Pi の時計は Mac より約 2 時間 7 分遅い）: ssh ... "grep -c 'send_angles 後の現在角度: None' ~/daemon.log" を撮る前と後で取って差を見る
+- ほか今までどおり: 到達・再送（arrival_ok）、見込み超え（overruns）が 0 か、区間の長さ（segment_elapsed_sec）
+
+■ 変えたファイル
+- dynamic_tracking_limits/drag_teaching/record_teach_demo.py（git の外。写し record_teach_demo.py.bak_pre_req225_20261116）
+- pi05/teach_state_rate.py（写し pi05/teach_state_rate.py.bak_pre_req225_20261116）
+- pi05/test_send_wait_mac.py
+- pi05/test_send_wait_split.py（新しく）
+- tools/pi/wheels/pymycobot-2.9.6-py3-none-any.whl（新しく・git の外）
+- claude_code_reports/20261116_225.txt（この報告）
+コミット: 報告の最後の行
+
+■ 決めてほしいこと
+1. Pi の pymycobot を 2.9.6 に戻す作業: Pi につながらずできていない。Pi をつないだあと、上の手順で次の依頼として流すか、エイイチが流すか
+2. 2.9.6 の「固定」の形: pip で上げ直されないよう、Pi の requirements や手順書に pymycobot==2.9.6 を書くか（どこに書くか）
+3. 位置1〜5 を撮るかどうかと、その時期（Pi を戻してから）
+4. split のソケットの期限が 3.2 秒（daemon の形は 4.0 秒）になる。daemon の返事は 0.23〜0.33 秒の見込みなので足りるとみたが、4.0 秒にそろえたいなら visual_servo_pick.py を触ることになる（今回の範囲の外）
diff --git a/pi05/teach_state_rate.py b/pi05/teach_state_rate.py
index 1e02685..528b9bb 100644
--- a/pi05/teach_state_rate.py
+++ b/pi05/teach_state_rate.py
@@ -9,6 +9,9 @@
   - 試行 JSON の segments: 動く区間ごとの送信の往復 (send_rtt_sec)・区間の長さ (segment_elapsed_sec)・再送・着いたか,
     爪の前の静止の確かめ (still_check の reads・elapsed_sec・still)
 が直す前の本と同じ形かを見る. 合否の線は決めていない (表を出すだけ).
+依頼 225: 本ごとに, 撮った形 (待ち. split は daemon と Mac の秒数)・送信が無視された回 (無視 = 到達の待ちが切れて
+1.0° 未満で再送した回. うち 0.00°・そのときの角度)・daemon の送信のあとの読みが返事なしだった見込みの回数
+(試行 JSON の daemon_read_none_suspects. daemon.log の数そのものではない)・daemon だけの往復の中央と最大も出す.
 
 入力: {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_...
@@ -151,13 +154,39 @@ def measure(d):
                      "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"),
+                     "retry_move_deg": g.get("retry_move_deg"),   # 依頼 225: 再送したときの動いた角度
                      "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"])
+    # 依頼 225: 撮った形 (split は daemon と Mac の秒数も)・送信が無視された回・daemon の読みが返事なしの見込み
+    out["send_wait"] = wait_label(j)
+    ig = j.get("send_ignored")
+    if isinstance(ig, dict):
+        out["ignored_n"], out["ignored_zero_n"] = ig.get("count"), ig.get("zero_move_count")
+        moves = [e.get("retry_move_deg") for e in ig.get("events") or []]
+    else:   # 依頼 225 より前の本は区間の retried から数える (同じ決まり: 到達の待ちが切れて 1.0° 未満で再送)
+        moves = [s["retry_move_deg"] for s in segs if s["retried"]]
+        out["ignored_n"] = len(moves)
+        out["ignored_zero_n"] = sum(1 for v in moves if isinstance(v, (int, float)) and abs(v) < 0.005)
+    out["ignored_moves"] = " ".join(fmt(v, 2) for v in moves) or None
+    ns = j.get("daemon_read_none_suspects")
+    out["read_none_suspects"] = ns.get("suspects") if isinstance(ns, dict) else None
+    rtts = [s["send_daemon_rtt_sec"] for s in segs
+            if isinstance(s["send_daemon_rtt_sec"], (int, float)) and not isinstance(s["send_daemon_rtt_sec"], bool)]
+    out["daemon_rtt_median"] = statistics.median(rtts) if rtts else None
+    out["daemon_rtt_max"] = max(rtts) if rtts else None
     return out, segs
 
 
+def wait_label(j):
+    """依頼 225: 撮った形の表示. split は 'split 0.2+0.8'. 項目がない本 (依頼 213 より前) は None."""
+    w = j.get("send_wait_on")
+    if w == "split":
+        return "split {:g}+{:g}".format(j.get("send_daemon_wait_sec") or 0, j.get("send_mac_wait_sec") or 0)
+    return w
+
+
 def fmt(v, nd=3):
     if v is None:
         return "-"
@@ -170,7 +199,10 @@ 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", "再送"), ("send_wait_on", "待ち"), ("result", "結果")]
+            ("still_reads_total", "静止reads"), ("retried_n", "再送"),
+            ("ignored_n", "無視"), ("ignored_zero_n", "うち0.00°"), ("ignored_moves", "無視の角度"),
+            ("read_none_suspects", "読みNone見込み"), ("daemon_rtt_median", "daemon往復中央"),
+            ("daemon_rtt_max", "daemon往復最大"), ("send_wait", "待ち"), ("result", "結果")]
 
 
 def print_group(label, ms):
@@ -183,7 +215,7 @@ 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", "send_wait_on")))
+            f"{h} {fmt(med(k))}" for k, h in RUN_COLS[1:] if k not in ("result", "send_wait", "ignored_moves")))
 
 
 def print_segments(groups):
diff --git a/pi05/test_send_wait_mac.py b/pi05/test_send_wait_mac.py
index 5ea86dd..5b3b4fb 100644
--- a/pi05/test_send_wait_mac.py
+++ b/pi05/test_send_wait_mac.py
@@ -9,7 +9,7 @@
 本物の tools/pi/mecharm_daemon.py と同じ形にする: 書き込み → wait 秒眠る → 角度を 1 回読む → 返事.
 
 確かめること:
-  - --send-wait-on mac (既定): daemon へは wait=0・ソケットの期限 4.0 秒 (wait+3.0 と同じ) で送り, 返ってから
+  - --send-wait-on mac (依頼 225 で既定は split に替わった. split は test_send_wait_split.py): daemon へは wait=0・ソケットの期限 4.0 秒 (wait+3.0 と同じ) で送り, 返ってから
     Mac 側で 1.0 秒待つ. この間に電流の記録スレッドが read_servo で読み, states.csv の actual 行になる
   - 到達の確かめ (本体の最初の get_angles) が始まる時刻は送信の始めから 1.0 秒 + 書き込みと読み 1 回 のあと
     (daemon で待つときと同じ. 縮んでいない)
@@ -20,7 +20,7 @@
   - --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・ほかの値は受け付けない
+  - コマンドの --send-wait-on の既定は split (依頼 225)・mac / daemon も選べる・ほかの値は受け付けない
   - (codex R1) 窓の終わりぎわの read_servo が長引くと本体の次の読みはその分遅れる (早まらない・overruns に数える)
   - (codex R3) 送信が 4.0 秒で返らなければ切れて, 1.0 秒待ってから例外. 次の命令はつなぎ直して通る
 KIOXIA にもアームにも触らない (一時フォルダと 127.0.0.1 だけ).
@@ -197,7 +197,9 @@ class TestReplaySendWait(unittest.TestCase):
                      (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
+        # 依頼 225: stage 行の note は撮った形 (send_wait_on=...) なので形ごとに違う. それ以外は同じ
+        no_act = lambda r: [k[:3] + ((None,) if k[0] == "stage" else k[3:])  # noqa: E731
+                            for k in tca.main_kinds(r["sent"]) if k[0] != "actual"]
         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 (= 本体の読み) は上と同じ扱い
@@ -435,8 +437,10 @@ class TestCli(unittest.TestCase):
             rtd.main()
         return got["a"]
 
-    def test_default_mac(self):
-        self.assertEqual(self._parse(["run", "--teach", "x.json"]).send_wait_on, "mac")
+    def test_default_split(self):
+        # 依頼 225: 既定は split. mac / daemon も選べる
+        self.assertEqual(self._parse(["run", "--teach", "x.json"]).send_wait_on, "split")
+        self.assertEqual(self._parse(["run", "--teach", "x.json", "--send-wait-on", "mac"]).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):
@@ -453,11 +457,11 @@ class TestCli(unittest.TestCase):
         self.assertEqual(src.count('"send_wait_on": SEND_WAIT_ON'), 2)       # いちばん上と params
 
     def test_cmd_run_rejects_bad_value(self):
-        """cmd_run を直接呼ぶ形でも mac / daemon 以外は止める (グローバルは変えない)."""
+        """cmd_run を直接呼ぶ形でも split / 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")
+        self.assertEqual(rtd.SEND_WAIT_ON, "split")
 
 
 if __name__ == "__main__":
diff --git a/pi05/test_send_wait_split.py b/pi05/test_send_wait_split.py
new file mode 100644
index 0000000..0665d4a
--- /dev/null
+++ b/pi05/test_send_wait_split.py
@@ -0,0 +1,440 @@
+#!/usr/bin/env python3
+"""test_send_wait_split.py — 手教示の再生で, 送信のあとの 1.0 秒を daemon 0.2 秒 + Mac 0.8 秒に分ける形
+(依頼 225. 依頼 215 の案 F) を偽の daemon で確かめる (アームなし・Pi なし. 2026-11-16).
+
+  python3 pi05/test_send_wait_split.py          # 全部 (再生を 3 回通すので 1 分半ほど)
+  python3 pi05/test_send_wait_split.py -v
+
+偽の daemon は test_send_wait_mac.WaitDaemon (本物の send_angles と同じ: 書き込み → wait 秒眠る → 1 回読む → 返事).
+
+確かめること:
+  - --send-wait-on split (既定): daemon へは wait=0.2 で送る (ソケットの期限は wait+3.0 の決まりどおり.
+    timeout_override は渡さない). 返ってから Mac 側で 0.8 秒待つ. 合わせて 1.0 秒で, 到達の確かめが始まるのは
+    送信の始めから 1.0 秒 + 書き込み + 読み 1 回 のあと (daemon で待つときと同じ. 縮んでいない)
+  - daemon が眠っている 0.2 秒 (送信のやりとりの中) に read_servo は入らない. Mac で待つ 0.8 秒には入る
+  - 本体が daemon に送る命令 (関節の目標・速さ・爪) と順, 到達・再送・静止の確かめは daemon で待つときと同じ
+    (違うのは send_angles の wait だけ)
+  - 区間と試行 JSON に send_wait_on・send_daemon_wait_sec・send_mac_wait_sec が残る. states.csv の stage 行の note に
+    send_wait_on=split daemon_wait=0.2 mac_wait=0.8 が残る
+  - 送信が無視された回 (send_ignored) と daemon の読みが返事なしの見込み (daemon_read_none_suspects) を試行 JSON に出し,
+    teach_state_rate.py の表に出す (依頼 225 より前の本は区間の retried から数える)
+  - _send_angles_guarded: 送信が例外でも 0.8 秒待ってから例外を返す・Ctrl-C は待たない・秒数はグローバルで変わる
+  - コマンド: 既定 split・--split-daemon-wait / --split-mac-wait (既定 0.2 / 0.8). 合計 1.0 秒未満・daemon 0 以下・
+    split 以外での指定は止める
+KIOXIA にもアームにも触らない (一時フォルダと 127.0.0.1 だけ).
+"""
+import csv
+import io
+import json
+import sys
+import tempfile
+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_send_wait_mac as tswm  # noqa: E402  (WaitDaemon・replay)
+import test_teach_current_actuals as tca  # 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 teach_state_rate as tsr  # noqa: E402
+
+SPLIT_NOTE = "send_wait_on=split daemon_wait=0.2 mac_wait=0.8"
+
+
+class TestReplaySplit(unittest.TestCase):
+    """再生を 2 回 (split / daemon) 通して比べる."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.td = Path(tempfile.mkdtemp())
+        pr.install_daemon_lock()
+        cls.spl = tswm.replay("split", cls.td / "run_0001_20991116_000001")
+        cls.dmn = tswm.replay("daemon", cls.td / "run_0002_20991116_000002")
+        root = cls.td / "states"
+        cls.st_spl = tca.write_states(root, "run_0001_20991116_000001", cls.spl["sent"])
+
+    def test_completed(self):
+        self.assertEqual((self.spl["result"], self.dmn["result"]), ("completed", "completed"))
+
+    def test_wait_sent_to_daemon(self):
+        """split は wait=0.2, daemon は wait=1.0 を送る. ほかの中身 (目標・速さ) と順は同じ."""
+        ws = {s[3].get("wait") for s in tswm.sends(self.spl["d"])}
+        wd = {s[3].get("wait") for s in tswm.sends(self.dmn["d"])}
+        self.assertEqual((ws, wd), ({0.2}, {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.spl["d"]), strip(self.dmn["d"]))
+
+    def test_socket_timeout_rule(self):
+        """split は timeout_override を渡さない (visual_servo_pick の wait+3.0 = 3.2 秒になる)."""
+        seen = []
+
+        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", "split"), \
+                mock.patch.object(rtd.time, "sleep", lambda s: None):
+            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t")
+        self.assertEqual(seen, [(0.2, None)])
+
+    def test_arrival_start_not_earlier(self):
+        """本体の到達の確かめが始まるのは, どちらも送信の始めから 1.0 秒 + 書き込み + 読み 1 回 のあと."""
+        lo = rtd.SEND_WAIT_SEC + tswm.WRITE_SEC + tswm.READ_ONCE_SEC
+        delays = {}
+        for name, r in (("split", self.spl), ("daemon", self.dmn)):
+            ds = [tswm.next_main_get(r["d"], s[2]) - s[1] for s in tswm.sends(r["d"])]
+            delays[name] = ds
+            self.assertGreaterEqual(min(ds), lo - 0.002, name)
+        for a, b in zip(delays["split"], delays["daemon"]):
+            self.assertLess(abs(a - b), 0.08)
+        print(f"\n送信の始め → 到達の確かめの始め (秒): split {[round(x, 3) for x in delays['split']]}"
+              f" / daemon {[round(x, 3) for x in delays['daemon']]}")
+
+    def test_no_reads_during_daemon_wait(self):
+        """daemon が眠る 0.2 秒 (送信のやりとりの中) に read_servo は入らない. 返事のあとの 0.8 秒には入る."""
+        d = self.spl["d"]
+        rs = [x for x in d.spans if x[0] == "read_servo"]
+        n_after = 0
+        for s in tswm.sends(d):
+            inside = [x for x in rs if s[1] - 0.001 <= x[1] < s[2] or s[1] < x[2] <= s[2]]
+            self.assertEqual(inside, [], "送信の間に read_servo")
+            self.assertGreaterEqual(s[2] - s[1], 0.2)           # daemon の中で 0.2 秒眠っている
+            first = [x[1] for x in rs if x[1] >= s[2]]
+            if first and first[0] < s[2] + rtd.SEND_SPLIT_MAC_WAIT_SEC:
+                n_after += 1
+                self.assertGreaterEqual(first[0] - s[1], 0.2)   # 書き込みから 0.2 秒より後
+        self.assertGreaterEqual(n_after, len(tswm.sends(d)) - 1)
+
+    def test_same_checks_as_daemon(self):
+        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.spl["lr"]), summary(self.dmn["lr"]))
+        no_act = lambda r: [k[:3] for k in tca.main_kinds(r["sent"]) if k[0] != "actual"]  # noqa: E731
+        self.assertEqual(no_act(self.spl), no_act(self.dmn))
+        self.assertEqual(self.spl["lr"]["currents"]["overruns"], 0)
+
+    def test_segment_records(self):
+        moves = [g for g in self.spl["lr"]["segments"] if "send_rtt_sec" in g]
+        self.assertGreater(len(moves), 3)
+        for g in moves:
+            self.assertEqual((g["send_wait_on"], g["send_daemon_wait_sec"], g["send_mac_wait_sec"]),
+                             ("split", 0.2, 0.8))
+            self.assertGreaterEqual(g["send_rtt_sec"], rtd.SEND_WAIT_SEC)
+            self.assertGreaterEqual(g["send_daemon_rtt_sec"], 0.2)
+            self.assertLess(g["send_daemon_rtt_sec"], 0.5)
+        dm = [g for g in self.dmn["lr"]["segments"] if "send_rtt_sec" in g]
+        self.assertEqual({(g["send_daemon_wait_sec"], g["send_mac_wait_sec"]) for g in dm},
+                         {(rtd.SEND_WAIT_SEC, 0.0)})
+
+    def test_ignored_summary_zero(self):
+        lr = self.spl["lr"]
+        self.assertEqual((lr["send_ignored"]["count"], lr["send_ignored"]["zero_move_count"]), (0, 0))
+        self.assertEqual(lr["daemon_read_none_suspects"]["suspects"], 0)
+        self.assertEqual(lr["daemon_read_none_suspects"]["daemon_wait_sec"], 0.2)
+        self.assertGreater(lr["daemon_read_none_suspects"]["sends"], 3)
+
+    def test_stage_note_in_states_csv(self):
+        stage_notes = {p.get("note") for p in self.spl["sent"] if p["type"] == "stage"}
+        self.assertEqual(stage_notes, {SPLIT_NOTE})
+        with self.st_spl.open() as f:
+            rows = list(csv.DictReader(f))
+        st = [r for r in rows if r["event_type"] == "stage"]
+        self.assertTrue(st)
+        self.assertTrue(all(r["note"] == SPLIT_NOTE for r in st))
+        # 電流スレッドの行の note は今までどおり
+        self.assertTrue(any(r["note"] == rtd.CURRENT_THREAD_NOTE for r in rows if r["event_type"] == "actual"))
+        dn = {p.get("note") for p in self.dmn["sent"] if p["type"] == "stage"}
+        self.assertEqual(dn, {"send_wait_on=daemon daemon_wait=1 mac_wait=0"})
+
+    def test_rate_table(self):
+        m, segs = tsr.measure(self.st_spl.parent.parent)
+        self.assertEqual(m["order_reversed"], 0)
+        self.assertGreater(m["n_current_thread"], 0)
+
+
+class TestRetrySplit(unittest.TestCase):
+    """送信無視 → 5 秒待って再送の経路も split で通り, 無視の回が数えられる."""
+
+    def test_retry_counted(self):
+        pr.install_daemon_lock()
+        td = Path(tempfile.mkdtemp())
+        r = tswm.replay("split", td / "run_0003_20991116_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.assertGreaterEqual(seg[0]["send_daemon_rtt_retry_sec"], 0.2)
+        self.assertEqual({s[3].get("wait") for s in tswm.sends(r["d"])}, {0.2})
+        ig = r["lr"]["send_ignored"]
+        self.assertEqual(ig["count"], 1)
+        self.assertEqual(ig["zero_move_count"], 1 if seg[0]["retry_move_deg"] < 0.005 else 0)
+        self.assertEqual(ig["events"][0]["retry_move_deg"], seg[0]["retry_move_deg"])
+        # teach_state_rate.py の表
+        st = tca.write_states(td / "states", "run_0003_20991116_000003", r["sent"])
+        run = st.parent.parent
+        (run / f"{run.name}.json").write_text(json.dumps(r["lr"], default=str))
+        m, _ = tsr.measure(run)
+        self.assertEqual((m["ignored_n"], m["send_wait"]), (1, None))   # 再生だけなので いちばん上の send_wait_on はない
+        self.assertIsNotNone(m["ignored_moves"])
+        self.assertEqual(m["read_none_suspects"], 0)
+        print(f"\nsplit の再送: 無視 {m['ignored_n']} 回 (角度 {m['ignored_moves']}) daemon 往復中央 "
+              f"{m['daemon_rtt_median']:.3f} 秒")
+
+
+class TestSplitSocketTimeout(unittest.TestCase):
+    """codex 2 回目 R3: 本物の通信 (127.0.0.1) で, split の送信が wait+3.0 = 3.2 秒で切れ, そのあと Mac で 0.8 秒待って
+    から例外を返す. 次の命令はつなぎ直して通る."""
+
+    def test_timeout_real_socket(self):
+        d = tswm.SlowTailDaemon(send_extra=3.2 + 0.6)
+        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", "split"), mock.patch("sys.stdout", new=io.StringIO()):
+                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.5)                      # 偽の daemon が遅れた返事を書き終えるまで
+                a = vsp.daemon_get_angles()
+        finally:
+            vsp.close_daemon_socket()
+            d.close()
+        self.assertAlmostEqual(rtt, 3.2, delta=0.3)
+        self.assertGreaterEqual(el, 3.2 + rtd.SEND_SPLIT_MAC_WAIT_SEC - 0.05)
+        self.assertLess(el, 3.2 + rtd.SEND_SPLIT_MAC_WAIT_SEC + 0.5)
+        self.assertEqual(len(a), 6)
+
+
+class TestSummaries(unittest.TestCase):
+    def test_none_suspects(self):
+        segs = [{"send_daemon_rtt_sec": 0.23}, {"send_daemon_rtt_sec": 0.33, "send_daemon_rtt_retry_sec": 0.22},
+                {"kind": "gripper"}, {"send_daemon_rtt_sec": None}]
+        with mock.patch.object(rtd, "SEND_WAIT_ON", "split"):
+            r = rtd._daemon_read_none_suspects(segs)
+        self.assertEqual((r["sends"], r["suspects"], r["skipped_send_error"]), (3, 1, 0))
+        with mock.patch.object(rtd, "SEND_WAIT_ON", "split"):   # codex 1 回目 R2: 送信が例外の区間は別に数える
+            r = rtd._daemon_read_none_suspects([
+                {"send_daemon_rtt_sec": 3.2, "send_daemon_failed": ["send"]},
+                {"send_daemon_rtt_sec": 0.23, "send_daemon_failed": []},
+                # codex 2 回目 R2: 1 回目は通って再送が例外 (先頭 HOME でも同じ項目)
+                {"send_daemon_rtt_sec": 0.33, "send_daemon_rtt_retry_sec": 3.2, "send_daemon_failed": ["retry"]}])
+        self.assertEqual((r["sends"], r["suspects"], r["skipped_send_error"]), (2, 1, 2))
+        with mock.patch.object(rtd, "SEND_WAIT_ON", "mac"):     # mac は wait=0: 0.03 / 0.13 (依頼 215)
+            r = rtd._daemon_read_none_suspects([{"send_daemon_rtt_sec": 0.03}, {"send_daemon_rtt_sec": 0.13}])
+        self.assertEqual(r["suspects"], 1)
+
+    def test_ignored_summary(self):
+        segs = [{"kind": "move", "step": 1, "retried": True, "retry_move_deg": 0.0, "to_name": "HOME"},
+                {"kind": "move", "retried": False}, {"kind": "gripper"},
+                {"kind": "move", "step": 4, "retried": True, "retry_move_deg": 0.4}]
+        r = rtd._send_ignored_summary(segs)
+        self.assertEqual((r["count"], r["zero_move_count"], r["move_segments"]), (2, 1, 3))
+        self.assertEqual([e["step"] for e in r["events"]], [1, 4])
+
+    def test_rate_table_old_json(self):
+        """依頼 225 より前の本 (send_ignored がない) は区間の retried から数える. 待ちの列は mac / daemon のまま."""
+        td = Path(tempfile.mkdtemp())
+        run = td / "run_0009_20991116_000009"
+        (run / "recording").mkdir(parents=True)
+        (run / "recording" / "states.csv").write_text(
+            "ts,event_type,stage,j0,j1,j2,j3,j4,j5,speed,gripper_state,ts_send,ts_arrival,attempt,arrived,note\n"
+            "1.0,stage,HOME,,,,,,,,,,,,,\n1.1,actual,HOME,0,0,0,0,0,0,,,,,,,\n")
+        (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.13,
+             "retried": True, "retry_move_deg": 0.0},
+            {"step": 2, "kind": "move", "to_name": "A", "send_rtt_sec": 1.03, "send_daemon_rtt_sec": 0.03}]}))
+        m, _ = tsr.measure(run)
+        self.assertEqual((m["ignored_n"], m["ignored_zero_n"], m["ignored_moves"]), (1, 1, "0.00"))
+        self.assertEqual((m["send_wait"], m["read_none_suspects"]), ("mac", None))
+        self.assertAlmostEqual(m["daemon_rtt_median"], 0.08)
+        self.assertEqual(m["daemon_rtt_max"], 0.13)
+
+    def test_rate_table_split_label(self):
+        self.assertEqual(tsr.wait_label({"send_wait_on": "split", "send_daemon_wait_sec": 0.2,
+                                         "send_mac_wait_sec": 0.8}), "split 0.2+0.8")
+        self.assertEqual(tsr.wait_label({"send_wait_on": "daemon"}), "daemon")
+        self.assertIsNone(tsr.wait_label({}))
+        m = {"run": "r", "send_wait": "split 0.2+0.8", "ignored_n": 0, "ignored_zero_n": 0,
+             "ignored_moves": None, "read_none_suspects": 0}
+        with mock.patch("sys.stdout", new=io.StringIO()) as out:
+            tsr.print_group("後", [m, dict(m)])
+        for h in ("無視", "うち0.00°", "読みNone見込み", "split 0.2+0.8"):
+            self.assertIn(h, out.getvalue())
+
+
+class _Rec(object):
+    def __init__(self):
+        self.windows = []
+
+    def currents_window(self, sec):
+        self.windows.append(sec)
+
+
+class TestGuardedSplit(unittest.TestCase):
+    def setUp(self):
+        self.calls, self.slept, self.exc = [], [], None
+        self.clock = [100.0]    # 偽の時計. 偽の送信は本物と同じく wait + 0.03 秒かかる (例外のときはすぐ返る)
+        self.p = [mock.patch.object(rtd.time, "sleep", lambda s: self.slept.append(s)),
+                  mock.patch.object(rtd.time, "monotonic", lambda: self.clock[0]),
+                  mock.patch.object(rtd, "daemon_send_angles", self._send),
+                  mock.patch.object(rtd, "SEND_WAIT_ON", "split")]
+        for p in self.p:
+            p.start()
+
+    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
+        self.clock[0] += wait + 0.03
+        return {"ok": True}
+
+    def test_split_waits_after_send(self):
+        rec = _Rec()
+        rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=rec)
+        self.assertEqual(self.calls, [(list(rtd.HOME_ANGLES), 20, 0.2, None, [])])
+        self.assertEqual(self.slept, [0.8])
+        self.assertEqual(rec.windows, [0.8])            # Mac の 0.8 秒だけ電流の記録に知らせる
+        self.assertIsNotNone(rtd._LAST_SEND["daemon_rtt_sec"])
+
+    def test_split_without_recorder(self):
+        rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t")
+        self.assertEqual(self.slept, [0.8])
+
+    def test_split_other_seconds(self):
+        with mock.patch.object(rtd, "SEND_SPLIT_DAEMON_WAIT_SEC", 0.3), \
+                mock.patch.object(rtd, "SEND_SPLIT_MAC_WAIT_SEC", 0.7):
+            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=_Rec())
+            self.assertEqual(rtd._send_wait_note(), "send_wait_on=split daemon_wait=0.3 mac_wait=0.7")
+        self.assertEqual((self.calls[0][2], self.slept), (0.3, [0.7]))
+
+    def test_split_send_error_still_waits(self):
+        """codex 1 回目 R1・R3: 送信がすぐ例外になっても, 送信の始めから合わせて 1.0 秒まで待ってから例外を返す."""
+        self.exc = RuntimeError("daemon error")
+        rec = _Rec()
+        with self.assertRaises(RuntimeError):
+            rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t", recorder=rec)
+        self.assertEqual(self.slept, [1.0])              # すぐ返ったので 0.8 ではなく 1.0
+        self.assertEqual(rec.windows, self.slept)        # 延ばした分も電流の記録に知らせる
+        self.assertIsNotNone(rtd._LAST_SEND["daemon_rtt_sec"])
+
+    def test_split_fast_return_padded(self):
+        """daemon が 0.2 秒眠らずに早く返った (ok の返事でも) ときも合わせて 1.0 秒にする. 0.2 秒以上かかれば 0.8 秒."""
+        clock = self.clock
+        if True:
+            def send(pose, speed, wait=0, timeout_override=None):
+                clock[0] += 0.05
+                return {"ok": True}
+            with mock.patch.object(rtd, "daemon_send_angles", send):
+                rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t")
+            self.assertAlmostEqual(self.slept[-1], 0.95)
+
+            def send2(pose, speed, wait=0, timeout_override=None):
+                clock[0] += 0.23
+                return {"ok": True}
+            with mock.patch.object(rtd, "daemon_send_angles", send2):
+                rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t")
+            self.assertEqual(self.slept[-1], 0.8)
+
+            def send3(pose, speed, wait=0, timeout_override=None):
+                clock[0] += 3.2
+                raise RuntimeError("socket timeout")
+            with mock.patch.object(rtd, "daemon_send_angles", send3), self.assertRaises(RuntimeError):
+                rtd._send_angles_guarded(list(rtd.HOME_ANGLES), 20, "t")
+            self.assertEqual(self.slept[-1], 0.8)        # 期限切れでも Mac の 0.8 秒は縮めない
+
+    def test_split_ctrl_c_not_waited(self):
+        self.exc = KeyboardInterrupt()
+        with 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 self.assertRaises(rtd._Aborted):
+            rtd._send_angles_guarded(bad, 20, "t", recorder=_Rec())
+        self.assertEqual((self.calls, self.slept), ([], []))
+
+
+class TestCliSplit(unittest.TestCase):
+    def setUp(self):
+        self.saved = (rtd.SEND_WAIT_ON, rtd.SEND_SPLIT_DAEMON_WAIT_SEC, rtd.SEND_SPLIT_MAC_WAIT_SEC)
+
+    def tearDown(self):
+        rtd.SEND_WAIT_ON, rtd.SEND_SPLIT_DAEMON_WAIT_SEC, rtd.SEND_SPLIT_MAC_WAIT_SEC = self.saved
+
+    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_defaults(self):
+        self.assertEqual(rtd.SEND_WAIT_ON_CHOICES, ("split", "mac", "daemon"))
+        self.assertEqual((rtd.SEND_SPLIT_DAEMON_WAIT_SEC, rtd.SEND_SPLIT_MAC_WAIT_SEC), (0.2, 0.8))
+        a = self._parse(["run", "--teach", "x.json"])
+        self.assertEqual((a.send_wait_on, a.split_daemon_wait, a.split_mac_wait), ("split", None, None))
+        a = self._parse(["run", "--teach", "x.json", "--split-daemon-wait", "0.3", "--split-mac-wait", "0.7"])
+        self.assertEqual((a.split_daemon_wait, a.split_mac_wait), (0.3, 0.7))
+        self.assertEqual(self._parse(["run", "--teach", "x.json", "--send-wait-on", "daemon"]).send_wait_on, "daemon")
+
+    def _cmd_run(self, **kw):
+        base = dict(grip_value=None, power=None, send_wait_on="split", split_daemon_wait=None,
+                    split_mac_wait=None, no_currents=False, no_record=False, teach_local=None, execute=False,
+                    teach="dir/x.json")    # 秒数の確かめのあと, --teach のディレクトリで止まる (Pi・カメラに触らない)
+        base.update(kw)
+        with mock.patch("sys.stdout", new=io.StringIO()) as out, self.assertRaises(SystemExit):
+            rtd.cmd_run(mock.Mock(**base))
+        return out.getvalue()
+
+    def test_cmd_run_rejects(self):
+        for kw in ({"split_daemon_wait": 0.1, "split_mac_wait": 0.8},     # 合計 0.9 < 1.0
+                   {"split_daemon_wait": 0.0, "split_mac_wait": 1.0},     # daemon 0 (wait=0 は mac の形)
+                   {"split_mac_wait": -0.1},
+                   {"split_daemon_wait": float("nan")},
+                   {"send_wait_on": "mac", "split_mac_wait": 0.8}):      # split 以外では使えない
+            out = self._cmd_run(**kw)
+            self.assertIn("--split", out, kw)
+            self.assertEqual(rtd.SEND_WAIT_ON, self.saved[0], kw)          # 止めたときはグローバルを変えない
+            self.assertEqual(rtd.SEND_SPLIT_DAEMON_WAIT_SEC, 0.2, kw)
+
+    def test_cmd_run_sets_split(self):
+        out = self._cmd_run()
+        self.assertEqual((rtd.SEND_WAIT_ON, rtd.SEND_SPLIT_DAEMON_WAIT_SEC, rtd.SEND_SPLIT_MAC_WAIT_SEC),
+                         ("split", 0.2, 0.8))
+        self.assertIn("daemon 0.2s + Mac 0.8s", out)
+        self._cmd_run(split_daemon_wait=0.3, split_mac_wait=0.7)
+        self.assertEqual((rtd.SEND_SPLIT_DAEMON_WAIT_SEC, rtd.SEND_SPLIT_MAC_WAIT_SEC), (0.3, 0.7))
+        self._cmd_run(send_wait_on="daemon")
+        self.assertEqual(rtd.SEND_WAIT_ON, "daemon")
+
+    def test_trial_json_fields(self):
+        import inspect
+        src = inspect.getsource(rtd.cmd_run)
+        self.assertEqual(src.count('"send_daemon_wait_sec": _send_wait_daemon_sec()'), 2)   # いちばん上と params
+        rsrc = inspect.getsource(rtd._replay)
+        self.assertIn('log_record["send_ignored"] = _send_ignored_summary(segments_log)', rsrc)
+        self.assertEqual(rsrc.count('"send_mac_wait_sec": _send_wait_mac_sec()'), 2)       # 先頭 HOME と各区間
+        # codex 2 回目 R2: 例外になった送信は 4 か所 (先頭 HOME・その再送・各区間・その再送) すべてで残す
+        self.assertEqual(rsrc.count('_failed.append("send")'), 2)
+        self.assertEqual(rsrc.count('_failed.append("retry")'), 2)
+        self.assertEqual(rsrc.count('"send_daemon_failed": list('), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()
