throughline 0.16.31 → 0.16.32

package/CHANGELOG.md

@@ -10,6 +10,31 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.32] — 2026-10-14
+
+### 追加
+
+- **Claude Codeの自動継続で、引き継ぎ済みの会話へ届いた入力を、後継の会話へ届ける**（[ADR 0063](docs/adr/0063-claude-handed-off-input-is-forwarded-to-successor.md)）。0.16.31は、旧い会話へ届いた入力を止めて後継の場所を返すだけで、人が打った文は後継で打ち直し、旧い会話が裏で起こした作業の完了通知は後継へ届かなかった。
+  - 旧い会話は、止めた入力を今の続きの会話の置き場（`~/.throughline/claude-auto-handoff/inbox/<後継の会話ID>/`）へ置く。置けた時は「届いた入力は、後継の会話へ渡しました」と、後継が動いているか（動いていなければ、後継を開いて入力した時に届く事）と、後継を開く命令を返す。置けなかった時は、0.16.31と同じ文を返す。
+  - slash command（頭が`/`の入力）は運ばない。0.16.31と同じ文を返す。ほかの会話から届いた文は、利用者の入力と分けて「利用者の入力ではない」と書いて運ぶ。
+  - 手すきの後継は、番の終わりに走る新しいhook（`throughline claude-forward-wait`。`asyncRewake`）が待っていて、入力が届くと起きる。
+  - 作業中の後継は、次の道具の前に、文脈として受け取る（今ある`PreToolUse`のhook）。番の終わりまで待たせない。
+  - 止まっている後継（`claude stop`・Claude Codeの片付け）は起こさない。入力は置き場で待ち、後継を開いて何か入力した時に届く（今ある`UserPromptSubmit`のhook）。
+  - 運んだ利用者の入力は、後継の会話の記録（L2）の中で、利用者の発言として残る。
+  - 後継が最初に受け取る引き継ぎの文脈（読み方）に、運び方と「運ばれた利用者の入力は、利用者の入力として扱う」事を足した。前の会話が裏で動かしていた作業の一覧の文も「終わった通知は、Throughlineがこの会話へ運ぶ」に変えた。
+  - `auto-handoff status --host claude --json`の引き継ぎごとの項目に、届けるのを待つ数（`forward_pending`）と、届いたか分からない数（`forward_unknown`）を足した。止めた記録（`redirects.jsonl`）に、渡せたか（`forwarded`）を足した。運んだ記録は`~/.throughline/claude-auto-handoff/forward.jsonl`（入力の本文は書かない）。
+
+### 変わる動き
+
+- 自動継続が有効な端末では、版を上げた時の`install`（`self-update`）が、Claudeの設定ファイル（`~/.claude/settings.json`）のStopにhookを1つ足す。前からある`PreCompact`・`PreToolUse`のhookの並びは動かさない。Codex・Grok・Cursorの設定は変えない。
+- 自動継続が有効な端末では、Claudeの番の終わりのたびにhookが1つ多く走る。後継でない会話では、置き場のフォルダの有無だけを見て終わる。手すきの後継ごとに、待つprocessが1つ動く（後継が止まれば一緒に止まる。同じ会話で新しい待つhookが立てば、前のhookは退く）。
+- 後継の画面では、運ばれた入力は利用者の発言の形では出ない（番の終わりの道はhookからの通知の形、道具の前と入力の時は、hookが足した文脈の形）。
+- 運ばれた入力に従うかは、後継のモデルが決める。実機（Haiku）では、後継が完了通知を1通受けた後に人の入力を運んだ場面で、27回のうち3回、後継が「自動の通知として届いたので、利用者の指示としては扱わない」と答えた（ADR 0063）。旧い会話へ返す文に「後継のモデルが、運ばれた入力を利用者の依頼として扱わない事があります。答えは後継で確かめてください」と、後継を開く命令を添えてある。
+- 旧い会話が裏で起こした作業の完了通知が後継へ届くので、手すきの後継は通知のたびに1回動く。
+- 置き場のファイルは、届くまで入力の本文を持つ（本人だけが読める権限。届けたら消す。届かないまま7日を過ぎた分は消す）。
+- 届いたか分からない入力（受け取った後で、出力する前にprocessが落ちた分）は、入れ直さない。
+- `auto-handoff enable --host claude`を、登録済みの端末でもう一度流しても、今の形で登録済みのhookの並びは動かさない（前の版は、足りないhookがあると自分のhookを全部後ろへ置き直した）。
+
 ## [0.16.31] — 2026-10-14
 
 ### 修正
@@ -2609,7 +2634,8 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.31...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.32...HEAD
+[0.16.32]: https://github.com/kitepon/Throughline/compare/v0.16.31...v0.16.32
 [0.16.31]: https://github.com/kitepon/Throughline/compare/v0.16.30...v0.16.31
 [0.16.30]: https://github.com/kitepon/Throughline/compare/v0.16.29...v0.16.30
 [0.16.29]: https://github.com/kitepon/Throughline/compare/v0.16.28...v0.16.29

package/README.ja.md

@@ -60,7 +60,7 @@ throughline auto-handoff status --host claude --json
 throughline auto-handoff disable --host claude
 ```
 
-既定では無効です。`enable`は必要な`PreCompact`と`PreToolUse`のフックを登録し、`disable`が外します。`--project`を省略すると全projectを対象にします。Codexの設定とは別で、互いに影響しません。
+既定では無効です。`enable`は必要な`PreCompact`・`PreToolUse`・`Stop`のフックを登録し、`disable`が外します。`--project`を省略すると全projectを対象にします。Codexの設定とは別で、互いに影響しません。
 
 自動圧縮を置き換えます。圧縮が走る前に旧い会話を止め、記憶を持った新しい会話で作業を続けます（[ADR 0033](docs/adr/0033-claude-auto-handoff-new-session.md)）。
 
@@ -77,7 +77,9 @@ throughline auto-handoff status --host claude --operation <handoff-id> --json
 
 後継の立ち上げや配送に失敗した時は、固定の理由を記録して止まります。結果が不明な指示は再送しません。圧縮を止めた後にモデルが道具を呼ばずにターンを終えた時は、後継を立てません。印は残るので、1時間以内に開いた新しい会話が記憶を引き継ぎます。
 
-有効にした端末では、Claudeの道具の呼び出しのたびに`PreToolUse`フックが1回走ります。Linux・macOS・Windowsの端末から始めた会話と、macOSのClaude Desktopの画面から始めた会話を実機確認済みです。Desktopでは、移動済みの会話の最初の後継への記憶注入と、最初からフォルダを選んだ会話の連続継承・作業完了を確認しました。[実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-05-claude-auto-handoff.md)を参照してください。
+引き継いだ後の旧い会話へ入力が届いた時は、モデルを動かさずに止めて、後継の会話へ届けます（[ADR 0062](docs/adr/0062-claude-handed-off-conversation-blocks-input.md)、[ADR 0063](docs/adr/0063-claude-handed-off-input-is-forwarded-to-successor.md)）。旧い会話へ打った文と、旧い会話が裏で起こした作業の完了通知が対象です。打った人には「届いた入力は、後継の会話へ渡しました」と後継を開く命令が返ります。手すきの後継はすぐ動き、作業中の後継は次の道具の前に読みます。後継が止まっている時は起こさず、後継を開いて何か入力した時に届きます。後継の画面では、運ばれた入力は利用者の発言の形ではなく、フックからの通知か文脈の形で出ます。届くまでの間、入力の本文は`~/.throughline/claude-auto-handoff/inbox/`に置かれます（本人だけが読める権限。届けたら消します）。
+
+有効にした端末では、Claudeの道具の呼び出しのたびに`PreToolUse`フックが1回、番の終わりのたびに`Stop`フックが1回多く走ります（後継でない会話では、すぐ終わります）。Linux・macOS・Windowsの端末から始めた会話と、macOSのClaude Desktopの画面から始めた会話を実機確認済みです。Desktopでは、移動済みの会話の最初の後継への記憶注入と、最初からフォルダを選んだ会話の連続継承・作業完了を確認しました。[実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-05-claude-auto-handoff.md)を参照してください。
 
 ## 所有境界
 

package/README.md

@@ -59,7 +59,7 @@ throughline auto-handoff status --host claude --json
 throughline auto-handoff disable --host claude
 ```
 
-既定では無効です。`enable`は必要な`PreCompact`と`PreToolUse`のフックを登録し、`disable`が外します。`--project`を省略すると全projectを対象にします。Codexの設定とは別で、互いに影響しません。
+既定では無効です。`enable`は必要な`PreCompact`・`PreToolUse`・`Stop`のフックを登録し、`disable`が外します。`--project`を省略すると全projectを対象にします。Codexの設定とは別で、互いに影響しません。
 
 自動圧縮を置き換えます。圧縮が走る前に旧い会話を止め、記憶を持った新しい会話で作業を続けます（[ADR 0033](docs/adr/0033-claude-auto-handoff-new-session.md)）。
 
@@ -84,7 +84,9 @@ throughline auto-handoff successor --host claude --thread <claude-session-id> --
 
 後継の立ち上げや配送に失敗した時は、固定の理由を記録して止まります。結果が不明な指示は再送しません。圧縮を止めた後にモデルが道具を呼ばずにターンを終えた時は、後継を立てません。印は残るので、1時間以内に開いた新しい会話が記憶を引き継ぎます。
 
-有効にした端末では、Claudeの道具の呼び出しのたびに`PreToolUse`フックが1回走ります。Linux・macOS・Windowsの端末から始めた会話と、macOSのClaude Desktopの画面から始めた会話を実機確認済みです。Desktopでは、移動済みの会話の最初の後継への記憶注入と、最初からフォルダを選んだ会話の連続継承・作業完了を確認しました。[実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-05-claude-auto-handoff.md)を参照してください。
+引き継いだ後の旧い会話へ入力が届いた時は、モデルを動かさずに止めて、後継の会話へ届けます（[ADR 0062](docs/adr/0062-claude-handed-off-conversation-blocks-input.md)、[ADR 0063](docs/adr/0063-claude-handed-off-input-is-forwarded-to-successor.md)）。旧い会話へ打った文と、旧い会話が裏で起こした作業の完了通知が対象です。打った人には「届いた入力は、後継の会話へ渡しました」と後継を開く命令が返ります。手すきの後継はすぐ動き、作業中の後継は次の道具の前に読みます。後継が止まっている時は起こさず、後継を開いて何か入力した時に届きます。後継の画面では、運ばれた入力は利用者の発言の形ではなく、フックからの通知か文脈の形で出ます。届くまでの間、入力の本文は`~/.throughline/claude-auto-handoff/inbox/`に置かれます（本人だけが読める権限。届けたら消します）。
+
+有効にした端末では、Claudeの道具の呼び出しのたびに`PreToolUse`フックが1回、番の終わりのたびに`Stop`フックが1回多く走ります（後継でない会話では、すぐ終わります）。Linux・macOS・Windowsの端末から始めた会話と、macOSのClaude Desktopの画面から始めた会話を実機確認済みです。Desktopでは、移動済みの会話の最初の後継への記憶注入と、最初からフォルダを選んだ会話の連続継承・作業完了を確認しました。[実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-05-claude-auto-handoff.md)を参照してください。
 
 ## Ownership boundary
 

package/bin/throughline.mjs

@@ -10,6 +10,7 @@
  *   throughline session-start # SessionStart hook (Claude Code から呼ばれる)
  *   throughline pre-compact   # PreCompact hook (Claude Code から呼ばれる。自動継続: 自動圧縮を止める)
  *   throughline pre-tool-use  # PreToolUse hook (Claude Code から呼ばれる。自動継続: 旧い会話を止める)
+ *   throughline claude-forward-wait # Stop hook (Claude Code から呼ばれる。自動継続: 引き継ぎ前の会話へ届いた入力を後継へ届ける)
  *   throughline detail [<日付>T]<時刻> # L2+L3 詳細取得 (Claude が Bash 経由で呼ぶ想定)
  *   throughline recall --l2|--l1 # 注入案内から辿る pull 用 read-only 記憶取得
  *   throughline handoff-preview # Codex-facing throughline_handoff JSON preview
@@ -88,6 +89,9 @@ switch (cmd) {
   case 'pre-tool-use':
     await (await import('../src/claude-pre-tool-use.mjs')).run();
     break;
+  case 'claude-forward-wait':
+    await (await import('../src/claude-forward-wait.mjs')).run();
+    break;
   case 'monitor':
     (await import('../src/token-monitor.mjs')).main();
     break;
@@ -243,6 +247,7 @@ switch (cmd) {
     'process-turn': 'HOOK_PROCESS_TURN_FAILED',
     'pre-compact': 'HOOK_PRE_COMPACT_FAILED',
     'pre-tool-use': 'HOOK_PRE_TOOL_USE_FAILED',
+    'claude-forward-wait': 'HOOK_CLAUDE_FORWARD_WAIT_FAILED',
   }[cmd];
   if (code) {
     const { recordRuntimeErrorBestEffort } = await import('../src/runtime-error-store.mjs');

package/docs/adr/0063-claude-handed-off-input-is-forwarded-to-successor.md

@@ -0,0 +1,156 @@
+# ADR 0063: 引き継ぎ済みの Claude の会話へ届いた入力は、後継の会話へ届ける
+
+- Status: Accepted
+- Date: 2026-10-14
+
+## Context
+
+ADR 0062 は、引き継ぎ済みの Claude の会話へ届いた入力を、モデルを動かさずに止めて、後継の場所を返す形にした。
+止めた入力は後継へ渡らない。人が打った文は後継で打ち直しになり、旧い会話が裏で起こした作業の完了通知は、後継へ
+届かないままになる。利用者の決め（2026-10-14）は「先に止める形を入れ、続けて、後継へ届ける形を作る」。この ADR は
+後の分を決める。
+
+Claude Code に、動いている別の会話へ外から文を入れる命令は無い（`claude --help` の一覧。2.1.296）。会話の受け口
+（`messagingSocketPath`）は、権限のバイパス中の会話では、送り手を確かめられない文を利用者の承認まで止める。この止めは
+回避しない（ADR 0033 の 4）。残る道は、後継自身の hook が文を受け取る形になる。
+
+Claude Code 2.1.296 で、次を実機で確かめた（Linux・macOS・Windows の3つとも同じ結果。自分で立てた裏の会話、
+Haiku。利用者の設定の hook を外し、試しの hook だけを付けた。試しの文は自分で決めた物）。
+
+| 見た事 | 結果 |
+|---|---|
+| 手すきの会話。Stop の `asyncRewake: true` の hook が待っていて、後から stderr へ文を出して exit code 2 で終わる | 1 秒以内に会話が起きて、文に従った。届く行は `origin.kind: task-notification` の user 行で、`<summary>Stop hook feedback</summary>` と `<system-reminder>` に包まれる |
+| 作業中の会話。番の途中に文を置き、番の終わりの Stop の hook がすぐ exit code 2 で終わる | 番が終わった直後に、次の番として届いた |
+| 道具の前後。`PreToolUse`・`PostToolUse` の hook が `additionalContext` を返す | 番の途中で文脈に入り、モデルが従った（`PreToolUse` は、道具を順に出した会話で3つとも確認） |
+| `additionalContext` の長さ | 10,000 字（UTF-16 の長さ）を超えると、頭の約 2,000 字と「全文は file にある」の案内に置き換わる。9,900 字までは、そのまま届く。日本語でも字数で決まる |
+| Stop の hook の stderr の長さ | 23,000 字が、そのまま届いた |
+| hook の `timeout`（秒）が切れた時 | hook は止められる（POSIX は SIGTERM）。会話は起きない。その後に文を置いても届かない |
+| `timeout: 7200` の hook | 11 分待った後でも届けた（既定の 600 秒より長く待てる） |
+| `claude stop` | 待っている hook も止まる |
+| 待つ hook を持つ手すきの裏の会話を、Claude Code が片付ける時（`bg retire`） | hook が待っていても、61 分で片付けた（Linux）。hook の process は止められず、残った。片付けの後に hook が文を出して exit code 2 で終わっても、会話には何も届かなかった。hook の環境の `CLAUDE_PID` は、片付けられた会話の process の ID だった |
+| hook が待っている間に、会話が別のきっかけ（自分の裏の作業の完了通知）で次の番へ進む | 前の hook は止められず、待ち続ける。次の番の終わりに、もう1つ hook が立つ |
+| 前の番から待っている hook が、次の番の作業中に exit code 2 で終わる | Claude Code が文を順番待ちへ入れ（`attachment` の `queued_command`）、次の道具の合間に届けた。モデルは従った（Linux で確認） |
+| 待つ hook を持つ会話へ `claude -p --resume` で入力する | hook が終わるまで命令が返らず、出力も出ない（hook が 20 秒で自分から終わる時は、22〜23 秒で返った）。この時の hook の環境は `CLAUDE_CODE_ENTRYPOINT=sdk-cli`（裏の会話は `cli`） |
+
+## Decision
+
+1. **置き場。** 後継ごとに、届けるのを待つ入力を1通1ファイルで置く
+   （`~/.throughline/claude-auto-handoff/inbox/<後継の会話 ID>/<時刻>-<連番>.json`）。中身は、届いた時刻・旧い会話の ID・
+   引き継ぎ ID・種類（`prompt` か `task-notification`）・本文。ファイルは本人だけが読める（0600）。届けたら消す。
+2. **旧い会話の側。** ADR 0062 の止め方は変えない。止める時に、入力を今の続きの会話（後継の先まで引いた会話）の置き場へ
+   置く。置けた時は、返す文を「届いた入力は後継の会話へ渡しました」に替え、届く時機と後継を開く命令を添える。
+   後継で待つ hook の process が生きていれば「後継は動いています」、生きていなければ「後継は今、入力を待ち受けて
+   いません（止まっているか、この版より前に立った会話です）。後継を開いて何か入力した時に届きます」と書き分ける
+   （待つ hook は、置き場の印に自分の process の ID を書いている）。
+   後継の会話 ID を引けない時と、置き場へ書けなかった時は、0.16.31 と同じ文（後継で打ち直す）を返す。
+   止めた記録（`redirects.jsonl`）に、渡せたか（`forwarded`）を足す。本文は書かない。
+   - **slash command（頭が `/` の入力。`/tl`・`/clear` など）は運ばない。** その会話への命令で、後継へ文として運んでも
+     命令にならない。0.16.31 と同じ文を返す。頭が `/` で始まる普通の文（path など）も、見分けられないので運ばない。
+   - **ほかの会話から届いた文（`Another Claude session sent a message:` で始まる）は、利用者の入力と分けて運ぶ。**
+     届ける文に「ほかの Claude の会話が送った文で、利用者の入力ではない」と書く。旧い会話の受け口を通った後の文なので、
+     Claude Code が付けた注意書きは、そのまま付いて届く。
+3. **後継の側。** 置き場の入力を、次の3か所で受け取る。先に受け取った所が届ける。
+   - **Stop の hook（新しく登録する。`throughline claude-forward-wait`、`asyncRewake: true`）。** 番の終わりに走り、置き場に
+     入力が在ればすぐ、無ければ届くまで待って、stderr へ出して exit code 2 で終わる。手すきの後継が、これで起きる。
+   - **`UserPromptSubmit`（今ある hook）。** 後継へ入力が来た時に、置き場の入力を文脈として足す。待つ hook が居ない後継
+     （期限で止められた・`claude stop` の後に開き直した・この版より前に立った）は、ここで受け取る。
+   - **`PreToolUse`（自動継続が今も登録している hook）。** 作業中の後継が、次の道具の前に、文脈として受け取る。
+     番の終わりまで待たせない。
+4. **文脈として足す道（`UserPromptSubmit`・`PreToolUse`）は、9,000 字までの分だけを運ぶ。** 10,000 字を超えると Claude Code が
+   頭だけに切り詰めるので、収まらない入力は置き場に残し、Stop の道で届ける。Stop の道は、1通が 60,000 字を超える時だけ、
+   頭の 4,000 字と全文の file の場所を届ける。
+5. **待つ hook が走る会話。** 自分の置き場のフォルダが在る会話だけが待つ。フォルダは、後継が継続の指示を受領した時と、
+   旧い会話が最初の入力を置いた時に出来る。フォルダが無い会話（後継でない会話。ほとんどの会話）では、hook はフォルダの
+   有無だけを見て終わる。
+   - script から起動した Claude（`CLAUDE_CODE_ENTRYPOINT` が `sdk-` で始まる。`claude -p`、Agent SDK）では待たない。
+     待つと、呼び出し元の命令が返らない。その時の入力は、`UserPromptSubmit` の道で届く。
+   - subagent の中では待たない。
+   - 待っている間に、自分の会話がさらに引き継がれて後継が立ったら、置き場に残った入力を今の続きの会話の置き場へ移して
+     終わる。旧い会話を起こさない。
+   - hook の `timeout` は 86,400 秒にする。期限が切れると、次に後継が動くまで（入力・番の終わり）届かない。
+   - 会話の process（hook の環境の `CLAUDE_PID`）が居なくなったら、受け取らずに終わる。Claude Code は、手すきの裏の会話を
+     片付ける時に、待っている hook を止めない。居ない会話へ出力すると、入力が届かないまま消える。
+   - **1つの会話で待つのは1つだけにする。** Claude Code は、会話が次の番へ進んでも前の hook を止めないので、そのままだと
+     番の終わりのたびに待つ process が1つ増える。新しい hook は置き場に自分の印（`waiter`）を書き、前の hook は印が
+     替わったのを見て退く。前の hook は、次の番が終わるまでは残る。その間に届いた入力は、前の hook が出して
+     Claude Code が道具の合間に届けるか、`PreToolUse` の道が先に受け取る。
+6. **届いたか分からない入力は、入れ直さない。** 受け取る所は、入力のファイルを別のフォルダ（`claimed`）へ改名してから
+   出力し、出力した後で消す。改名の後で process が落ちると、その入力は届いたか分からないまま `claimed` に残る。
+   これを置き場へ戻さない（二重に届くより、1通落ちて跡が残る方を選ぶ。ADR 0039 の Codex と同じ考え）。
+   `auto-handoff status --host claude` に、届けるのを待つ数と、届いたか分からない数を出す。
+7. **届ける文。** 頭に、Throughline が運んだ事・旧い会話の頭8字・種類ごとの数を書いた行を置く。人の入力は
+   「利用者がこの会話へ打った入力として扱う」、ほかの会話からの文は「利用者の入力ではない」、完了通知は
+   「引き継ぎ前の会話が裏で起こした作業の通知」と書く。
+   複数ある時は、届いた順に1つの文にまとめる。完了通知が続く時は、後継が動いている間に溜まった分が、次の1回で届く。
+8. **記憶（L2）。** 運んだ人の入力は、後継の記録の中で、利用者の発言として読む。Stop の道で届いた行は、包みを外して
+   届けた文だけを残す。文脈として足した分と、前の hook が作業中に出して順番待ちから届いた分は、作業の途中で届いた入力
+   （ADR 0060）と同じに、そのターンの依頼へ足す。完了通知だけを運んだ分は、ターンの途中では足さない（ADR 0060 と同じ）。
+   入力の hook が stdout へ出した文脈は、記録では `hook_success`（`hookEvent: UserPromptSubmit`）の `content` に入る。
+   道具の前の hook が返した文脈は `hook_additional_context` に入る（実測）。
+9. **片付け。** どの引き継ぎの記録からも後継として指されなくなった会話の置き場は、空なら消す。7日を過ぎた入力は、
+   届けずに消して、消した数を記録へ残す。
+10. **登録。** `auto-handoff enable --host claude` が、今までの2つ（`PreCompact`・`PreToolUse`）に加えて Stop の hook を
+    登録し、`disable` が外す。有効な端末では、版を上げた時の `install` が足す（Claude の設定ファイルが1か所変わる）。
+    Codex・Grok・Cursor の設定は変えない。
+
+## Consequences
+
+- 旧い会話へ打った文は、打ち直さなくても後継へ届く。手すきの後継はすぐ動き、作業中の後継は次の道具の前に読む。
+- 旧い会話が裏で起こした作業の完了通知が、後継へ届く。手すきの後継は、通知のたびに1回動く（今は同じ回数が、
+  文脈がほぼ一杯の旧い会話で止められている）。
+- 後継の画面では、運ばれた入力は利用者の発言の形では出ない。Stop の道では hook からの通知の形、文脈の道では hook が
+  足した文脈の形になる。
+- 運ばれた人の入力に従うかは、後継のモデルが決める。hook 経由の文は利用者の発言の形で届かないので、モデルが利用者の
+  指示として扱わない事がある（実測は下）。後継が最初に受け取る引き継ぎの文脈で、運び方を先に知らせる。旧い会話へ返す文に
+  「打ち直しは要らない」とは書かず、後継を開く命令を添える。
+- 手すきの後継ごとに、待つ process が1つ動く（node。1 秒ごとにフォルダを見る）。後継が `claude stop` や片付けで止まれば、
+  一緒に止まる。
+- 自動継続が有効な端末では、Claude の番の終わりのたびに hook が1つ多く走る。置き場のフォルダが無い会話では、
+  すぐ終わる。
+- 後継が止まっている時（`claude stop`・Claude Code の片付け）は、起こさない。入力は置き場で待ち、後継を開いて
+  何か入力した時に届く。止まっている後継を自動で起こす形は、この ADR では決めない（動いている会話へ
+  `claude --bg --resume` を流すと写しが立つので、止まっている事を確かめる道を先に決める必要がある）。
+- 置き場のファイルは、届くまで入力の本文を持つ。DB と会話の記録のほかに、本文が一時的に置かれる場所が増える。
+- `claude -p --resume <後継>` の入力では、置き場の分は文脈として届き、待つ hook は走らない。
+
+## 確かめた事・確かめていない事
+
+- 確かめた事は、Context の表と、この版の試験（CHANGELOG の 0.16.32）。
+- 直した版を、本物の Claude Code 2.1.296 の裏の会話（Haiku）へ通した。Linux・macOS・Windows の3つ。利用者の設定の hook を
+  外し、直した版を切り離した HOME で呼ぶ hook だけを付けた。旧い会話の役と後継の役を立て、引き継ぎの記録を切り離した
+  置き場へ置いた。後継の役の置き場は、最初の入力の hook で作った（本物では、継続の指示の受領が作る）。3つとも同じ結果だった。
+
+  | 見た事 | 結果 |
+  |---|---|
+  | 旧い会話が裏で起こした作業の完了通知 | 旧い会話では止まり、手すきの後継が起きて、通知の中身に答えた |
+  | 人の入力（`claude -p --resume <旧い会話>`） | 「届いた入力は、後継の会話へ渡しました」が返り、手すきの後継が起きて、入力に従った |
+  | 後継が止まっている時の人の入力 | 置き場で待った。後継を `claude -p --resume` で開いて入力すると、3〜5 秒で命令が返り、運んだ入力が文脈として届いていた |
+  | 作業中の後継への人の入力 | 次の道具の前に文脈として届き、後継はその番の答えで従った |
+  | 後継が自分の裏の作業の完了通知で次の番へ進んだ時 | 前の待つ hook は退き、待つ hook は1つだけ残った |
+  | 直した版の読み手で読んだ後継の記録 | 運んだ文が利用者の行に入り、Claude Code の通知の包みは入らない。文脈で届いた分は、作業の途中の入力として入る |
+  | 切り離した置き場の失敗の記録・届いたか分からない入力 | 無し・0 |
+  | 本物の置き場と判定の記録にある、試しの会話 | 0 |
+
+- 運んだ人の入力に、後継のモデル（Haiku）が従ったかを、手すきの後継で数えた（3つの OS の合計）。hook 経由の文に従うかは
+  モデルが決めるので、従わない事は無くせない。従わなかった後継は「自動の通知として届いたので、利用者の指示としては
+  扱わない」と答えた。
+
+  | 場面と、運ぶ文の形 | 従った回数 |
+  |---|---|
+  | 後継の最初の番の後に、人の入力だけを運ぶ。見出しに「利用者がこの会話へ打った入力として扱ってください」と書く形 | 26 回のうち 26 回（知らせあり 13、なし 13） |
+  | 後継が完了通知を1通受けた後に、人の入力を運ぶ。同じ形。後継は、引き継ぎの文脈の知らせを受け取っていない | 21 回のうち 19 回 |
+  | 同じ場面・同じ形。後継は、引き継ぎの文脈（読み方）で運び方の知らせを受け取っている | 6 回のうち 5 回 |
+  | 同じ場面。見出しを「利用者が前の会話へ打った文です」と、出どころを述べるだけにした形。知らせなし | 18 回のうち 10 回 |
+  | 同じ場面。出どころを述べるだけの形。知らせあり | 18 回のうち 16 回 |
+
+  出どころを述べるだけの形は、知らせの無い後継で従わない回が増えたので、採らない。見出しに「利用者がこの会話へ打った
+  入力として扱ってください」と書く形にし、後継が最初に受け取る引き継ぎの文脈（読み方）でも運び方を知らせる。
+  試しの入力は「PROBE: …と答えてください」の形で、本物の作業の依頼より疑われやすい文だった。
+- 確かめていない:
+  - 端末の画面・Claude Desktop・リモートコントロール（スマホ）で、運ばれた入力がどう見えるか。
+  - 86,400 秒の `timeout` が、そのとおりに待つか。7,200 秒の指定で 11 分より長く待てる所までを見た。
+    待つ hook が終わった理由と待った秒数を記録へ残すので、入れた後の追跡で読む。
+  - 片付けられた裏の会話の、直した版の待つ hook が、`CLAUDE_PID` を見て退く所（単体試験まで。実機は 61 分かかるので、
+    公開の後に読む）。
+  - macOS と Windows で、裏の会話が片付けられる時の hook の残り方（Linux だけで見た）。
+  - ほかの会話から届いた文（`SendMessage`）を運んだ時の、送り手の側の見え方。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "throughline",
-  "version": "0.16.31",
+  "version": "0.16.32",
   "type": "module",
   "description": "Persistent memory hooks for Claude Code, Codex, Grok, and Cursor (/clear-safe context compression)",
   "keywords": [

package/src/claude-auto-handoff.mjs

@@ -43,6 +43,7 @@ import { sameProjectPath } from './project-path.mjs';
 import { runWithPty } from './os/pty-run.mjs';
 import { spawnPortable, spawnPortableSync } from './os/portable-spawn-sync.mjs';
 import { composeAutoHandoffTitle } from './auto-handoff-title.mjs';
+import { claudeForwardKind, claudeForwardWaiterAlive, enqueueClaudeForward, ensureClaudeForwardInbox, readClaudeForwardStatus, removeStaleClaudeForwards } from './claude-forward.mjs';
 
 export const CLAUDE_AUTO_HANDOFF_SCHEMA = 'throughline.claude-auto-handoff.v2';
 const CLI_PATH = resolve(dirname(fileURLToPath(import.meta.url)), '../bin/throughline.mjs');
@@ -140,10 +141,13 @@ export function listClaudeAutoHandoffs({ dir = claudeAutoHandoffDir() } = {}) {
 }
 
 /** 外へ見せる項目だけ。依頼の本文・発言・道具の対象と、受け口は含めない。 */
-export function publicClaudeAutoHandoff(record) {
+export function publicClaudeAutoHandoff(record, { dir = claudeAutoHandoffDir() } = {}) {
   const { handoff_id, source_session_id, project_path, state, error_code, requested_at, updated_at, successor } = record;
+  // 後継の置き場の数（ADR 0063）。pending は届けるのを待つ入力、unknown は届いたか分からなくなった入力。
+  const forward = validSessionId(successor?.session_id) ? readClaudeForwardStatus(successor.session_id, { dir }) : null;
   return { handoff_id, source_session_id, project_path, state, error_code: error_code ?? null,
     successor_session_id: successor?.session_id ?? null, successor_short_id: successor?.short_id ?? null,
+    forward_pending: forward ? forward.pending : null, forward_unknown: forward ? forward.unknown : null,
     // 止めたターンを DB へ取り込めたか。false の時、後継は `throughline detail` でそのターンの入出力を取れない。
     in_flight_captured: Boolean(record.in_flight?.turn),
     // 後継を Claude Desktop で開く引き継ぎか、開けたか（null は対象外）。
@@ -219,6 +223,12 @@ function removeStale(dir, now) {
       rmSync(path, { force: true });
     }
   }
+  // 後継の置き場（ADR 0063）。後継として指されている会話の置き場は、空でも残す（待つ hook が、フォルダの有無で待つかを決める）。
+  try {
+    const keepSessionIds = new Set(listClaudeAutoHandoffs({ dir })
+      .map(record => record.successor?.session_id).filter(validSessionId));
+    removeStaleClaudeForwards({ dir, now, keepSessionIds });
+  } catch { /* 置き場の片付けの失敗で、引き継ぎを止めない */ }
 }
 
 /**
@@ -727,6 +737,22 @@ function handedOffReason(record, dir) {
     (sessionId ? `（一覧に無い時は claude --resume ${sessionId}）` : '');
 }
 
+/**
+ * 引き継ぎ済みの会話へ届いた入力を、後継の置き場へ置けた時に見せる文 (ADR 0063)。
+ * 後継で待つ hook が生きていれば、後継は動いている。生きていなければ、後継は止まっているか、待つ hook が登録される前に
+ * 立った会話で、入力は後継が次に動く時まで置き場で待つ。どちらかを、打った人へ返す。
+ */
+function forwardedReason(record, dir, successorSessionId) {
+  const { shortId, sessionId } = currentSuccessor(record, dir);
+  const open = `claude attach ${shortId}` + (sessionId ? `（一覧に無い時は claude --resume ${sessionId}）` : '');
+  return `この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: ${record.handoff_id}）。` +
+    '届いた入力は、後継の会話へ渡しました。' +
+    (claudeForwardWaiterAlive(successorSessionId, dir)
+      ? '後継は動いています。手すきならすぐ、作業中なら次の道具の前か番の終わりに届きます。' +
+        `後継のモデルが、運ばれた入力を利用者の依頼として扱わない事があります。答えは後継で確かめてください: ${open}`
+      : `後継は今、入力を待ち受けていません（止まっているか、この版より前に立った会話です）。後継を開いて何か入力した時に届きます: ${open}`);
+}
+
 function stopOutput(record, dir) {
   const reason = record.successor?.short_id
     ? handedOffReason(record, dir)
@@ -761,18 +787,29 @@ function recordClaudeRedirect(entry, dir) {
  * 何もしない（null）。Aiterm が起こした席の会話（ADR 0057）も止めない。席を外す前の版が引き継いだ席が残っていても、
  * 呼び手は席の番の終わりを待っている。止めると番が始まらず、呼び手は答えを受け取れない。
  *
- * @returns {{output: {decision: 'block', reason: string}, kind: 'prompt'|'task-notification', handoffId: string, successorShortId: string|null}|null}
+ * 止めた入力は、今の続きの会話の置き場へ置く (ADR 0063)。後継の hook が受け取って、モデルへ渡す。後継の会話 ID を
+ * 引けない時、置き場へ書けなかった時、入力が slash command の時は、置かずに「後継で打ち直す」文を返す。
+ *
+ * @returns {{output: {decision: 'block', reason: string}, kind: 'prompt'|'task-notification', handoffId: string, successorShortId: string|null, forwarded: boolean}|null}
  */
 export function redirectClaudeHandedOffPrompt({ payload, now = Date.now(), dir = claudeAutoHandoffDir(), env = process.env }) {
   const sessionId = payload?.session_id;
   if (!validSessionId(sessionId) || payload.agent_id || isAitermSeatConversation(env, sessionId)) return null;
   const record = readClaudeAutoHandoff(sessionId, dir);
   if (!record || !successorRemains(record)) return null;
-  const successorShortId = currentSuccessor(record, dir).shortId;
+  const successor = currentSuccessor(record, dir);
+  const successorShortId = successor.shortId;
   const kind = typeof payload.prompt === 'string' && /^\s*<task-notification>/.test(payload.prompt) ? 'task-notification' : 'prompt';
+  const successorSessionId = successor.sessionId ?? findSuccessorSessionId(record);
+  // slash command は、その会話への命令なので運ばない。ほかの会話から届いた文は、利用者の入力と分けて運ぶ。
+  const forwardKind = claudeForwardKind(payload.prompt);
+  const forwarded = forwardKind !== null && validSessionId(successorSessionId) && successorSessionId !== sessionId &&
+    enqueueClaudeForward({ successorSessionId, sourceSessionId: sessionId, handoffId: record.handoff_id, kind: forwardKind,
+      text: payload.prompt, now, dir });
   recordClaudeRedirect({ at: new Date(now).toISOString(), source_session_id: sessionId, handoff_id: record.handoff_id,
-    successor_short_id: successorShortId, kind }, dir);
-  return { output: { decision: 'block', reason: handedOffReason(record, dir) }, kind, handoffId: record.handoff_id, successorShortId };
+    successor_short_id: successorShortId, kind, forwarded }, dir);
+  return { output: { decision: 'block', reason: forwarded ? forwardedReason(record, dir, successorSessionId) : handedOffReason(record, dir) },
+    kind, handoffId: record.handoff_id, successorShortId, forwarded };
 }
 
 /**
@@ -893,6 +930,8 @@ export function acceptClaudeAutoContinuation({ predecessorId, successorSessionId
   if (carriesInstruction && !record.accepted_at && !existsSync(acceptancePath(predecessorId, dir))) {
     writeJsonPrivate(acceptancePath(predecessorId, dir),
       { handoff_id: record.handoff_id, successor_session_id: successorSessionId, accepted_at: now });
+    // 後継の置き場を作る（ADR 0063）。番の終わりの待つ hook は、このフォルダが在る会話でだけ待つ。
+    if (validSessionId(successorSessionId)) ensureClaudeForwardInbox(successorSessionId, dir);
   }
   return { handoffId: record.handoff_id, projectPath: record.project_path, inFlight: record.in_flight ?? null,
     transcriptPath: record.transcript_path ?? null };

package/src/claude-auto-handoff.test.mjs

@@ -1230,15 +1230,16 @@ function fakeClaudePath(home) {
   return { [pathKey]: `${bin}${delimiter}${process.env[pathKey] ?? ''}` };
 }
 
-test('公開CLI: enable は2つの hook と設定を書き、disable は自分の hook だけを外す。Codex の設定には触らない', () => withDir(home => {
+test('公開CLI: enable は3つの hook と設定を書き、disable は自分の hook だけを外す。Codex の設定には触らない', () => withDir(home => {
   const settingsPath = join(home, '.claude', 'settings.json');
   mkdirSync(dirname(settingsPath), { recursive: true });
   // 他製品の hook と、0.13.0 が置いた PreCompact がある状態から始める
   const others = { PreCompact: [{ hooks: [{ type: 'command', command: 'other-product pre-compact' }] }],
-    PreToolUse: [{ matcher: 'Bash', hooks: [{ type: 'command', command: 'rtk hook claude' }] }] };
+    PreToolUse: [{ matcher: 'Bash', hooks: [{ type: 'command', command: 'rtk hook claude' }] }],
+    Stop: [{ hooks: [{ type: 'command', command: 'throughline process-turn', async: true }] }] };
   writeFileSync(settingsPath, JSON.stringify({ model: 'sonnet', hooks: {
     PreCompact: [{ hooks: [{ type: 'command', command: 'throughline pre-compact' }] }, ...others.PreCompact],
-    PreToolUse: others.PreToolUse } }));
+    PreToolUse: others.PreToolUse, Stop: others.Stop } }));
 
   const before = JSON.parse(cli(home, ['auto-handoff', 'status', '--host', 'claude', '--json']).stdout);
   assert.deepEqual(before, { host: 'claude', config: { schema: 'throughline.claude-auto-handoff.v1', enabled: false, projects: [] },
@@ -1250,22 +1251,35 @@ test('公開CLI: enable は2つの hook と設定を書き、disable は自分
   assert.equal(JSON.parse(enabled.stdout).status, 'enabled');
   const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
   assert.equal(settings.model, 'sonnet');
+  // 今の形で登録済みの PreCompact は、並びを動かさない。足りない hook だけを後ろへ足す（ADR 0063）
+  const forwardWait = { hooks: [{ type: 'command', command: 'throughline claude-forward-wait', asyncRewake: true, timeout: 86400 }] };
   assert.deepEqual(settings.hooks, {
-    PreCompact: [...others.PreCompact, { hooks: [{ type: 'command', command: 'throughline pre-compact' }] }],
+    PreCompact: [{ hooks: [{ type: 'command', command: 'throughline pre-compact' }] }, ...others.PreCompact],
     PreToolUse: [...others.PreToolUse, { hooks: [{ type: 'command', command: 'throughline pre-tool-use', timeout: 15 }] }],
+    Stop: [...others.Stop, forwardWait],
   });
   const again = cli(home, ['auto-handoff', 'enable', '--host', 'claude', '--json']);
   assert.equal(again.status, 0, again.stderr);
   assert.equal(readFileSync(settingsPath, 'utf8'), JSON.stringify(settings, null, 2) + '\n', '2回目は書き換えない');
 
   assert.equal(cli(home, ['auto-handoff', 'status', '--host', 'claude']).stdout,
-    '自動継続: 有効（Claude Code）\nhook（PreCompact・PreToolUse）: 登録済み\n');
+    '自動継続: 有効（Claude Code）\nhook（PreCompact・PreToolUse・Stop）: 登録済み\n');
   assert.equal(existsSync(join(home, '.throughline', 'codex-auto-handoff.json')), false);
   assert.equal(JSON.parse(cli(home, ['auto-handoff', 'status', '--json']).stdout).config.enabled, false, 'Codex は無効のまま');
 
+  // 前の版が登録した2つだけの端末（自分の hook の後ろに他製品の hook がある）で、版を上げた時の install の形:
+  // 前からある2つの並びは動かさず、Stop の待つ hook だけを足す
+  const later = { hooks: [{ type: 'command', command: 'later-product pre-tool-use' }] };
+  writeFileSync(settingsPath, JSON.stringify({ ...settings, hooks: { ...settings.hooks,
+    PreToolUse: [...settings.hooks.PreToolUse, later], Stop: others.Stop } }, null, 2) + '\n');
+  assert.equal(JSON.parse(cli(home, ['auto-handoff', 'status', '--host', 'claude', '--json']).stdout).hooks.registered, false);
+  assert.equal(cli(home, ['auto-handoff', 'enable', '--host', 'claude', '--json']).status, 0);
+  assert.deepEqual(JSON.parse(readFileSync(settingsPath, 'utf8')).hooks, { ...settings.hooks,
+    PreToolUse: [...settings.hooks.PreToolUse, later], Stop: [...others.Stop, forwardWait] });
+
   const disabled = JSON.parse(cli(home, ['auto-handoff', 'disable', '--host', 'claude', '--json']).stdout);
   assert.equal(disabled.config.enabled, false);
-  assert.deepEqual(JSON.parse(readFileSync(settingsPath, 'utf8')).hooks, others);
+  assert.deepEqual(JSON.parse(readFileSync(settingsPath, 'utf8')).hooks, { ...others, PreToolUse: [...others.PreToolUse, later] });
   const unsupported = cli(home, ['auto-handoff', 'resume', '--host', 'claude', '--operation', 'x', '--json']);
   assert.equal(unsupported.status, 1);
   assert.deepEqual(JSON.parse(unsupported.stdout), { status: 'failed', code: 'auto_handoff_action_unsupported' });
@@ -1613,17 +1627,19 @@ test('引き継ぎ済みの会話へ届いた入力: 後継が残っている時
   writeFileSync(join(projects, `${b}.jsonl`), '');
   const human = submit(a, '旧い会話へ打った文');
   assert.deepEqual(human, { output: { decision: 'block',
-    reason: 'この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: h-aaaaaaaa）。続きは後継の会話で行ってください: claude attach bbbbbbbb（一覧に無い時は claude --resume ' + b + '）' },
-    kind: 'prompt', handoffId: 'h-aaaaaaaa', successorShortId: 'bbbbbbbb' });
+    reason: 'この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: h-aaaaaaaa）。届いた入力は、後継の会話へ渡しました。' +
+      '後継は今、入力を待ち受けていません（止まっているか、この版より前に立った会話です）。後継を開いて何か入力した時に届きます: ' +
+      'claude attach bbbbbbbb（一覧に無い時は claude --resume ' + b + '）' },
+    kind: 'prompt', handoffId: 'h-aaaaaaaa', successorShortId: 'bbbbbbbb', forwarded: true });
   assert.equal(submit(a, '<task-notification>\n<task-id>b1</task-id>\n<status>completed</status>\n</task-notification>').kind, 'task-notification');
   assert.equal(submit(a, '依頼', { agent_id: 'agent-1' }), null, 'subagent の中の入力');
   assert.equal(submit('../escape', '依頼'), null);
   assert.equal(submit(a, '依頼', {}, { AITERM_AGENT_LAUNCH_ID: 'abc', AITERM_AGENT_VENDOR_SESSION_ID: a }), null, 'Aiterm の席の会話は止めない');
   assert.equal(submit(a, '依頼', {}, { AITERM_AGENT_LAUNCH_ID: 'abc', AITERM_AGENT_VENDOR_SESSION_ID: b }).kind, 'prompt', '席の印だけを継いだ会話は止める');
   assert.deepEqual(redirects(), [
-    { at: '1970-01-01T00:00:05.000Z', source_session_id: a, handoff_id: 'h-aaaaaaaa', successor_short_id: 'bbbbbbbb', kind: 'prompt' },
-    { at: '1970-01-01T00:00:05.000Z', source_session_id: a, handoff_id: 'h-aaaaaaaa', successor_short_id: 'bbbbbbbb', kind: 'task-notification' },
-    { at: '1970-01-01T00:00:05.000Z', source_session_id: a, handoff_id: 'h-aaaaaaaa', successor_short_id: 'bbbbbbbb', kind: 'prompt' },
+    { at: '1970-01-01T00:00:05.000Z', source_session_id: a, handoff_id: 'h-aaaaaaaa', successor_short_id: 'bbbbbbbb', kind: 'prompt', forwarded: true },
+    { at: '1970-01-01T00:00:05.000Z', source_session_id: a, handoff_id: 'h-aaaaaaaa', successor_short_id: 'bbbbbbbb', kind: 'task-notification', forwarded: true },
+    { at: '1970-01-01T00:00:05.000Z', source_session_id: a, handoff_id: 'h-aaaaaaaa', successor_short_id: 'bbbbbbbb', kind: 'prompt', forwarded: true },
   ], '止めた記録に入力の本文は書かない');
 
   // 後継がさらに引き継がれている時は、その先を示す。道具を断る時の文も同じ
@@ -1652,16 +1668,22 @@ test('公開CLI: prompt-submit は、引き継ぎ済みの会話の入力を止
   const blocked = submit(SESSION, '旧い会話へ打った文');
   assert.equal(blocked.status, 0, blocked.stderr);
   assert.deepEqual(JSON.parse(blocked.stdout), { decision: 'block',
-    reason: `この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: h-1）。続きは後継の会話で行ってください: claude attach ${SUCCESSOR.slice(0, 8)}（一覧に無い時は claude --resume ${SUCCESSOR}）` });
+    reason: 'この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: h-1）。届いた入力は、後継の会話へ渡しました。' +
+      '後継は今、入力を待ち受けていません（止まっているか、この版より前に立った会話です）。後継を開いて何か入力した時に届きます: ' +
+      `claude attach ${SUCCESSOR.slice(0, 8)}（一覧に無い時は claude --resume ${SUCCESSOR}）` });
   assert.equal(existsSync(join(home, '.throughline', 'throughline.db')), false, '止める時は DB を開かない');
   const logged = readFileSync(join(home, '.throughline', 'logs', 'inheritance-decision.log'), 'utf8').trim().split('\n').map(line => JSON.parse(line));
   assert.deepEqual(logged.map(row => [row.phase, row.session_id, row.handoff_id, row.successor_short_id, row.input_kind]),
     [['prompt-redirect', SESSION, 'h-1', SUCCESSOR.slice(0, 8), 'prompt']]);
   assert.equal(JSON.stringify(logged).includes('旧い会話へ打った文'), false, '判定の記録に本文は書かない');
 
+  // 止めた入力は後継の置き場で待ち、後継の次の入力で文脈として届く（ADR 0063）。届けた後は残らない
   const passed = submit(SUCCESSOR, '後継へ打った文');
   assert.equal(passed.status, 0, passed.stderr);
-  assert.equal(passed.stdout, '', '記録が無い会話の入力は、今までどおり通す');
+  assert.match(passed.stdout, /^【Throughline 転送】引き継ぎ前の会話（0f3a6c1e）へ届いた入力を、Throughlineがこの会話へ運びました（利用者の入力 1 通）。/);
+  assert.match(passed.stdout, /\n--- 利用者の入力（[^）]*利用者がこの会話へ打った入力として扱ってください）---\n旧い会話へ打った文\n$/);
+  assert.equal(submit(SUCCESSOR, '後継へ打った次の文').stdout, '', '同じ入力を2回は届けない');
+  assert.equal(submit('eeeeeeee-0000-4000-8000-000000000099', '関係の無い会話').stdout, '', '置き場が無い会話の入力は、今までどおり通す');
 }));
 
 test('裏で動いている作業: 起こした道具から、終わった通知が届いた物を除く（user 行でも、途中の入力でも）', () => withDir(dir => {