throughline 0.16.32 → 0.16.33

package/CHANGELOG.md

@@ -10,6 +10,27 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.33] — 2026-10-14
+
+### 追加
+
+- **Claude Codeの自動継続で、後継の会話が止まっている時に旧い会話へ人が文を打ったら、後継を起こしてその文を最初の入力として渡す**（[ADR 0064](docs/adr/0064-claude-stopped-successor-is-woken-by-human-input.md)）。0.16.32は、止まっている後継（`claude stop`・Claude Codeの片付け）を起こさず、入力は後継を開いて何か入力した時に届いた。
+  - 起こすのは、人が打った文の時だけ。完了通知とほかの会話からの文では起こさない（今までどおり置き場で待つ）。
+  - 起こすのは、止まっていると確かめられた時だけ。後継で待つhookが生きていない、`claude agents --json --all`の後継の項目に`pid`・`status`を持つ物が無く裏の項目の`state`が`done`か`stopped`、後継のtranscriptが在って5秒より前に書かれた、Claude Desktopへ移した後継でない、後継に引き継ぎが進んでいない、文が12,000字以下。どれか1つでも確かめられなければ、0.16.32と同じに置き場で待つ。
+  - 起こす命令は`claude --bg --resume <後継の会話ID> -- <文>`。optionは付けない（裏の会話は立てた時のoptionを持っていて、optionなしの時だけ同じ会話のまま起きる。モデル・effort・権限のmode・名前はそのまま）。文は利用者の発言として後継へ入る。旧い会話の会話ごとの環境変数は渡さない。
+  - 起こす番は1つだけ（後継の置き場の印`waking`。起こせた後も60秒残す）。その間に届いた入力は、起きた後継のhookが受け取る。
+  - 写しが立った時（確かめた後に後継が動き出した）は、写しをすぐ`claude stop`・`claude rm`で止めて消し、文は置き場へ戻す。起こす命令が失敗した時も置き場へ戻す。起きたか分からない時は入れ直さない。
+  - 旧い会話へ返す文: 起きた時は「後継の会話が止まっていたので、Throughlineが起こして、この入力を後継の最初の入力として渡しました」。起こしている所・動いていた・確かめられなかった・分からない時は、それぞれの文と後継を開く命令。
+  - 運んだ記録（`forward.jsonl`）に`woken`・`wake-skipped`・`wake-copy`・`wake-failed`・`wake-unknown`、止めた記録（`redirects.jsonl`）と判定の記録に`wake`を足した。本文は書かない。
+  - `THROUGHLINE_AUTO_HANDOFF_WAKE=off`で起こさない（0.16.32の動き）。
+
+### 変わる動き
+
+- 旧い会話へ人が打った文のhookが、後継が止まって見える時だけ`claude agents`と起こす命令を流す分、1〜2.5秒長くなる。
+- 起きた後継は、Claude Codeが片付けるまで（手すきで61分）裏で動き、利用枠を使う。片付けられた後で旧い会話へ文を打つたびに、もう一度起きる。
+- `claude rm`で一覧から消した後継と、12,000字を超える文では起こさない。
+- 続けて打った2通めからは、起きた後継のhookの道（通知・文脈の形）で届く。その分は0.16.32と同じに、後継のモデルが従わない事がある。
+
 ## [0.16.32] — 2026-10-14
 
 ### 追加
@@ -2634,7 +2655,8 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.32...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.33...HEAD
+[0.16.33]: https://github.com/kitepon/Throughline/compare/v0.16.32...v0.16.33
 [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

package/README.ja.md

@@ -77,7 +77,7 @@ throughline auto-handoff status --host claude --operation <handoff-id> --json
 
 後継の立ち上げや配送に失敗した時は、固定の理由を記録して止まります。結果が不明な指示は再送しません。圧縮を止めた後にモデルが道具を呼ばずにターンを終えた時は、後継を立てません。印は残るので、1時間以内に開いた新しい会話が記憶を引き継ぎます。
 
-引き継いだ後の旧い会話へ入力が届いた時は、モデルを動かさずに止めて、後継の会話へ届けます（[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/`に置かれます（本人だけが読める権限。届けたら消します）。
+引き継いだ後の旧い会話へ入力が届いた時は、モデルを動かさずに止めて、後継の会話へ届けます（[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)）。旧い会話へ打った文と、旧い会話が裏で起こした作業の完了通知が対象です。打った人には「届いた入力は、後継の会話へ渡しました」と後継を開く命令が返ります。手すきの後継はすぐ動き、作業中の後継は次の道具の前に読みます。後継が止まっている時（`claude stop`・Claude Codeの片付け）は、旧い会話へ人が打った文の時だけ、後継を起こしてその文を最初の入力として渡します（[ADR 0064](docs/adr/0064-claude-stopped-successor-is-woken-by-human-input.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

@@ -84,7 +84,7 @@ throughline auto-handoff successor --host claude --thread <claude-session-id> --
 
 後継の立ち上げや配送に失敗した時は、固定の理由を記録して止まります。結果が不明な指示は再送しません。圧縮を止めた後にモデルが道具を呼ばずにターンを終えた時は、後継を立てません。印は残るので、1時間以内に開いた新しい会話が記憶を引き継ぎます。
 
-引き継いだ後の旧い会話へ入力が届いた時は、モデルを動かさずに止めて、後継の会話へ届けます（[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/`に置かれます（本人だけが読める権限。届けたら消します）。
+引き継いだ後の旧い会話へ入力が届いた時は、モデルを動かさずに止めて、後継の会話へ届けます（[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)）。旧い会話へ打った文と、旧い会話が裏で起こした作業の完了通知が対象です。打った人には「届いた入力は、後継の会話へ渡しました」と後継を開く命令が返ります。手すきの後継はすぐ動き、作業中の後継は次の道具の前に読みます。後継が止まっている時（`claude stop`・Claude Codeの片付け）は、旧い会話へ人が打った文の時だけ、後継を起こしてその文を最初の入力として渡します（[ADR 0064](docs/adr/0064-claude-stopped-successor-is-woken-by-human-input.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/docs/adr/0064-claude-stopped-successor-is-woken-by-human-input.md

@@ -0,0 +1,113 @@
+# ADR 0064: 止まっている後継の会話は、人が旧い会話へ打った文で起こして届ける
+
+- Status: Accepted
+- Date: 2026-10-14
+
+## Context
+
+ADR 0063 は、引き継ぎ済みの Claude の会話へ届いた入力を、後継の会話へ届ける形にした。後継が止まっている時
+（`claude stop`、Claude Code が手すきの裏の会話を 61 分で片付けた時）は起こさず、入力は置き場で待ち、後継を開いて何か
+入力した時に届く。後継が片付けられた後で旧い会話へ打った文は、利用者が後継を開くまで届かない。
+
+利用者の決め（2026-10-14、「止まっている後継の会話へ届いた入力を、どう扱うか」）は「人が打った文の時だけ、止まっている
+後継を自動で起こして届ける。完了通知では起こさない」。その時に示した条件は「動いている会話へ起こす命令を流すと写しが
+立つので、止まっている事を確かめる道を 3 つの OS で確かめてから出す」。
+
+Claude Code 2.1.296 で、次を実機で確かめた（Linux・macOS・Windows の3つとも同じ結果。自分で立てた裏の会話、Haiku。
+利用者の設定の hook を外し、試しの hook だけを付けた。試しの文は自分で決めた物）。
+
+| 見た事 | 結果 |
+|---|---|
+| `claude agents --json --all` の項目（手すきで動いている裏の会話） | `state: done`・`status: idle`・`pid` がある |
+| 同（作業中） | `state: working`・`status: busy`・`pid` がある |
+| 同（手すきの時に `claude stop` で止めた） | `state: done`。`status` と `pid` の鍵が無い |
+| 同（作業の途中で `claude stop` で止めた） | `state: stopped`。`status` と `pid` の鍵が無い |
+| 同（Claude Code が 61 分で片付けた） | `state: done`。`pid` の鍵が無い（Linux。macOS・Windows は公開の後に読む） |
+| 同（コンテナごと止められた） | `state: done`。`status` と `pid` の鍵が無い（Linux） |
+| 同（`claude rm` で消した） | 一覧に出ない。transcript は残る。立てた時の option の控え（`~/.claude/jobs/<頭8字>/state.json`）は消える |
+| 同（止めた裏の会話を、端末の `claude --resume` で開いている・`claude -p --resume` が走っている） | 裏の項目（`pid` なし）とは別に、同じ会話 ID の `kind: interactive` の項目が `pid`・`status` 付きで出る |
+| 同（無い会話 ID へ `--bg --resume` を流した直後） | その ID で新しい会話が立ち、8 秒後も `state: working` で `pid` がまだ無い |
+| 止めた会話へ `claude --bg --resume <ID> "<文>"`（option なし） | 同じ会話 ID のまま起き、文が `origin.kind: human` の利用者の行として入り、モデルが答えた。出力は `note: woke session <頭8字> with its saved options (--name, --permission-mode, --model, …)`。モデル・権限の mode・名前は、立てた時の物のまま。0.6〜1.1 秒で返る |
+| 同（option を付けて流す） | 止めた会話でも写しが立つ。出力は `the flags you passed started a copy as <頭8字>. Without flags, the same command continues <頭8字> itself.` |
+| 動いている会話（手すき・作業中・端末で開いている・`claude -p --resume` が走っている）へ option なしで流す | 写しが立ち、写しが文に答えた。出力は `started a copy as <頭8字>`（`is already running in the background` か `is open in another Claude Code process`）。元の会話は変わらない |
+| 止めた会話へ、起こす命令を同時に2つ流す | 2つとも「起こした」と返ったのに、利用者の行は1つだけ入った（もう1つは消えた）。fox では2つめが写しになった。1.5 秒後の3つめは写しになった |
+| 起きた後継の最初の番 | 置き場で待っていた完了通知は、入力の hook の文脈として届いた。番の終わりに待つ hook が立った |
+| 頭が `-` の文・改行・`"`・`%PATH%`・`$HOME`・`&`・`|`・`<>`・`^`・日本語を含む文を `--` の後に置いて流す | そのまま同じ文が届いた（Windows も） |
+| 別のフォルダから流す | 同じ会話 ID のまま起きた |
+| `claude rm` で消した会話へ、切り離す option を付けて流す | 同じ会話 ID で起きたが、名前は新しく付き直した |
+
+## Decision
+
+1. **起こすのは、人が旧い会話へ打った文の時だけ。** ADR 0063 で運ぶ入力のうち、種類が `prompt`（利用者の入力）の時だけ
+   起こす。完了通知（`task-notification`）とほかの会話からの文（`peer`）では起こさない（今までどおり置き場で待つ）。
+   slash command は今までどおり運ばない。
+2. **起こすのは、止まっていると確かめられた時だけ。** 次を全部満たす時に限る。どれか1つでも確かめられなければ起こさず、
+   0.16.32 の動き（置き場で待つ）にする。
+   - 後継で待つ hook の process が生きていない（生きていれば、後継は動いている）。
+   - 引き継ぎの記録が、後継を Claude Desktop へ移した印（`desktop.state: opened`）を持っていない。
+   - 後継（今の続きの会話）に、Throughline の引き継ぎが進んでいない（予約・立ち上げ中・失敗の記録が無い）。
+   - 後継の transcript が在る（無い会話 ID へ流すと、その ID で新しい会話が立つ）。最後に書かれてから 5 秒より経っている。
+   - `claude agents --json --all` を読めて、後継の会話 ID の項目に、`pid` か `status` を持つ物が1つも無い。
+     `kind: background` の項目があり、その `state` が `done` か `stopped`。
+   - 文が 12,000 字以下で、NUL を含まない（Windows の命令行は全体で 32,767 字まで）。
+3. **起こす命令。** `claude --bg --resume <後継の会話 ID> -- <文>` を、後継の project のフォルダで流す。option は付けない
+   （裏の会話は立てた時の option を持っていて、option なしの時だけ同じ会話のまま起きる）。文は `--` の後に置く。
+   旧い会話の会話ごとの環境変数（`CLAUDECODE`・`CLAUDE_CODE_ENTRYPOINT`・`CLAUDE_CODE_SESSION_ID`・`CLAUDE_PID`・
+   `CLAUDE_EFFORT` など）は渡さない。旧い会話の `UserPromptSubmit` の hook の中で、その場で流す（一覧 10 秒・起こす命令
+   15 秒で打ち切る。ふだんは合わせて 1〜2.5 秒）。結果が分かってから、打った人へ返す文を決める。
+4. **起こす番は1つだけ。** 後継の置き場に印（`waking`）を排他で作れた hook だけが起こす。起こせた後も印は 60 秒残し、
+   その間に届いた入力は起こさずに置き場へ置く（起きた後継の hook が、次の道具の前か番の終わりに受け取る）。
+5. **渡す文を二重に届けない。** 起こす命令で渡す文は、置き場の受け取り済み（`claimed`）として書いてから命令を流す。
+   起きた後継の入力の hook は、受け取り済みの文を文脈として渡さない。
+   - 起きた（出力の ID が後継の頭8字）: 受け取り済みの文を消す。
+   - 写しが立った（出力に `started a copy as`、または出力の ID が後継と違う）: 写しは渡した文で動き出すので、すぐ
+     `claude stop`・`claude rm` で止めて一覧から消す（写しの transcript は消さない）。文は置き場へ戻す。後継は動いているので、
+     後継の hook が受け取る。
+   - 失敗した（命令が無い・立ち上がる前に失敗した・exit code が 0 でなく ID も無い）: 文を置き場へ戻す。
+   - 分からない（時間切れ・exit code 0 で ID が読めない など）: 入れ直さない（ADR 0063 の 6 と同じ）。受け取り済みに残り、
+     `auto-handoff status --host claude` の届いたか分からない数に出る。
+6. **打った人へ返す文。**
+   - 起きた: 「後継の会話が止まっていたので、Throughlineが起こして、この入力を後継の最初の入力として渡しました。後継は
+     裏で作業を続けます」と、後継を開く命令。
+   - 起こしている所だった: 「届いた入力は、後継の会話へ渡しました。後継は、先に届いた入力で起きている所です」と、従わない
+     事がある旨と、後継を開く命令。
+   - 動いていた（一覧で動いている・写しが立った・transcript が書かれたばかり）: 0.16.32 の「後継は動いています」の文。
+   - 確かめられなかった・失敗した: 0.16.32 の「後継は今、入力を待ち受けていません」の文。
+   - 分からない: 「起こそうとしましたが、起きて入力を受け取ったか確かめられませんでした。二重に届かないよう、この入力は
+     入れ直していません。後継を開いて確かめてください」と、後継を開く命令。
+7. **記録。** 運んだ記録（`forward.jsonl`）に `woken`・`wake-skipped`（理由）・`wake-copy`（写しの頭8字）・
+   `wake-failed`・`wake-unknown` を足す。止めた記録（`redirects.jsonl`）と判定の記録に、起こした結果（`wake`）を足す。
+   本文は書かない。
+8. **止める上書き。** 環境変数 `THROUGHLINE_AUTO_HANDOFF_WAKE=off` の時は起こさない（0.16.32 の動き）。
+
+## Consequences
+
+- 後継が止まっている時も、旧い会話へ打った文は、打ち直さなくても後継へ届く。利用者の発言の形（`origin.kind: human` の
+  利用者の行）で届くので、ADR 0063 の「後継のモデルが、運ばれた入力を利用者の依頼として扱わない」が起きない。
+- 起きた後継は、立てた時のモデル・effort・権限の mode・名前（・リモートコントロール）で動く。Claude Code が片付けるまで
+  （手すきで 61 分）裏で動き続け、利用枠を使う。片付けられた後で旧い会話へ文を打つたびに、もう一度起きる。
+- 起きた後継の画面では、渡した文は利用者の発言として出る。旧い会話の画面には、止めた理由（「起こして渡しました」）と
+  元の文が出る。
+- 旧い会話へ打った文の hook が、後継が止まって見える時だけ、`claude agents`（と起こす命令）を流す分、1〜2.5 秒長くなる。
+- 確かめた後から起こすまでの間に後継が動き出すと、写しが立つ。写しはすぐ止めて消すが、止めるまでの約 1 秒は写しが
+  文で動く。
+- `claude rm` で一覧から消した後継は、起こさない（立てた時の option の控えが消えていて、起こすと設定が変わる。端末で
+  開いているかも確かめられない）。0.16.32 と同じに置き場で待つ。
+- 12,000 字を超える文は起こさずに置き場で待つ。
+- 起こす命令を同時に2つ流さないので、続けて打った2通めからは、起きた後継の hook の道（通知・文脈の形）で届く。
+  その分は ADR 0063 と同じに、後継のモデルが従わない事がある。
+
+## 確かめた事・確かめていない事
+
+- 確かめた事は、Context の表と、この版の試験（CHANGELOG の 0.16.33）。
+- 直した版を、本物の Claude Code 2.1.296 の裏の会話（Haiku）へ通した。Linux・macOS・Windows の3つ。利用者の設定の hook を
+  外し、直した版を切り離した HOME で呼ぶ hook だけを付けた（直した版が流す `claude` は、HOME を本物へ戻す shim を通した）。
+  結果は CHANGELOG と保守の記録に書く。
+- 確かめていない:
+  - Claude Desktop の画面とリモートコントロール（スマホ）で、起きた後継がどう見えるか。リモートコントロール付きで立てた
+    後継が、起きた後もリモートコントロール付きか（立てた時の option の控えには入る）。
+  - Windows で `claude` が単体の `claude.exe` の時の、文の渡り方（確かめた fox の `claude` は npm の shim で、Throughline は
+    `claude.ps1` を PowerShell から呼ぶ。記号と改行を含む文は、この道でそのまま届いた）。
+  - 61 分で片付けられた会話へ起こす命令を流した時の動き。一覧の形は Linux で `state: done`・`pid` なし（止めた会話と同じ形）と
+    見たので、同じに起きる見込み。macOS・Windows の一覧の形も含めて、3つの OS で公開の後に読む。
+  - 本物の自動継続の後継での実地（入れた後の追跡で、`forward.jsonl` の `woken` を読む）。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "throughline",
-  "version": "0.16.32",
+  "version": "0.16.33",
   "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,7 +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';
+import { acquireClaudeWakeClaim, claudeForwardKind, claudeForwardWaiterAlive, enqueueClaudeForward, ensureClaudeForwardInbox, holdClaudeForward, logClaudeForward, 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');
@@ -742,15 +742,197 @@ function handedOffReason(record, dir) {
  * 後継で待つ hook が生きていれば、後継は動いている。生きていなければ、後継は止まっているか、待つ hook が登録される前に
  * 立った会話で、入力は後継が次に動く時まで置き場で待つ。どちらかを、打った人へ返す。
  */
-function forwardedReason(record, dir, successorSessionId) {
+function openSuccessorCommand(record, dir) {
   const { shortId, sessionId } = currentSuccessor(record, dir);
-  const open = `claude attach ${shortId}` + (sessionId ? `（一覧に無い時は claude --resume ${sessionId}）` : '');
+  return `claude attach ${shortId}` + (sessionId ? `（一覧に無い時は claude --resume ${sessionId}）` : '');
+}
+
+function forwardedReason(record, dir, successorSessionId, { running = false, waking = false } = {}) {
+  const open = openSuccessorCommand(record, dir);
   return `この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: ${record.handoff_id}）。` +
     '届いた入力は、後継の会話へ渡しました。' +
-    (claudeForwardWaiterAlive(successorSessionId, dir)
-      ? '後継は動いています。手すきならすぐ、作業中なら次の道具の前か番の終わりに届きます。' +
+    (waking
+      ? '後継は、先に届いた入力で起きている所です。起きた後継が、次の道具の前か番の終わりに読みます。' +
         `後継のモデルが、運ばれた入力を利用者の依頼として扱わない事があります。答えは後継で確かめてください: ${open}`
-      : `後継は今、入力を待ち受けていません（止まっているか、この版より前に立った会話です）。後継を開いて何か入力した時に届きます: ${open}`);
+      : running || claudeForwardWaiterAlive(successorSessionId, dir)
+        ? '後継は動いています。手すきならすぐ、作業中なら次の道具の前か番の終わりに届きます。' +
+          `後継のモデルが、運ばれた入力を利用者の依頼として扱わない事があります。答えは後継で確かめてください: ${open}`
+        : `後継は今、入力を待ち受けていません（止まっているか、この版より前に立った会話です）。後継を開いて何か入力した時に届きます: ${open}`);
+}
+
+/** 止まっていた後継を起こして、入力を最初の入力として渡せた時に見せる文 (ADR 0064)。 */
+function wokenReason(record, dir) {
+  return `この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: ${record.handoff_id}）。` +
+    '後継の会話が止まっていたので、Throughlineが起こして、この入力を後継の最初の入力として渡しました。' +
+    `後継は裏で作業を続けます: ${openSuccessorCommand(record, dir)}`;
+}
+
+/** 起こす命令を流したが、起きたか確かめられなかった時に見せる文 (ADR 0064)。入力は入れ直さない。 */
+function wakeUnknownReason(record, dir) {
+  return `この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: ${record.handoff_id}）。` +
+    '後継の会話が止まっていたので起こそうとしましたが、起きて入力を受け取ったか確かめられませんでした。' +
+    `二重に届かないよう、この入力は入れ直していません。後継を開いて確かめてください: ${openSuccessorCommand(record, dir)}`;
+}
+
+// ---- 止まっている後継を、人が旧い会話へ打った文で起こす (ADR 0064) ----
+
+// 起こす命令で渡す文の上限（UTF-16 の長さ）。Windows の命令行は全体で 32,767 字まで。引用で増える分を見込む。
+export const CLAUDE_WAKE_TEXT_MAX_CHARS = 12_000;
+// 起こしてよい、裏の会話の state（一覧の項目に `pid` も `status` も無い時だけ）。手すきで止めた・片付けられた会話は
+// `done`、作業の途中で止めた会話は `stopped`。立ち上げ中の会話は `working` で、`pid` がまだ無い事がある。
+const STOPPED_BACKGROUND_STATES = new Set(['done', 'stopped']);
+// 後継の transcript がこれより新しく書かれていたら、動いていると見なして起こさない。
+const RECENTLY_WRITTEN_MS = 5_000;
+// 止まっていない会話へ起こす命令を流すと、Claude Code は写しを立てて、こう書く（2.1.296）。
+const WAKE_COPY_PATTERN = /started a copy as ([0-9a-f]{8})\b/;
+// 起こす仕組みを止める上書き（`off`）。
+const WAKE_OVERRIDE_ENV = 'THROUGHLINE_AUTO_HANDOFF_WAKE';
+
+// 起こす命令に渡さない、旧い会話の環境変数（hook は旧い会話の中で走る）。後継は、保存された自分の設定で起きる。
+const WAKE_STRIPPED_ENV = ['CLAUDE_CODE_SESSION_ID', 'CLAUDE_PID', 'CLAUDE_CODE_CHILD_SESSION', 'CLAUDE_CODE_SESSION_ATTENDED',
+  'CLAUDE_EFFORT', 'CLAUDE_CODE_EXECPATH'];
+
+function wakeCommandEnv(env) {
+  const next = successorEnv(env);
+  for (const key of WAKE_STRIPPED_ENV) delete next[key];
+  return next;
+}
+
+/** 起こす命令で渡せる文か。長すぎる文と、命令の引数に入らない文字（NUL）を含む文は渡さない。 */
+export function claudeWakeTextAllowed(text) {
+  return typeof text === 'string' && text.trim() !== '' && text.length <= CLAUDE_WAKE_TEXT_MAX_CHARS && !text.includes('\0');
+}
+
+/**
+ * `claude agents --json --all` で、その会話が止まっていると確かめられるか。
+ * 同じ会話 ID の項目が1つでも `pid` か `status` を持てば動いている（裏の会話を端末で開いた時と、`claude -p --resume` が
+ * 走っている時は、裏の項目とは別に `interactive` の項目が出る）。裏の項目が無い・一覧を読めない時は、確かめられない。
+ *
+ * @returns {{stopped: boolean, reason: string}}
+ */
+export function readClaudeSessionStopped(sessionId, { spawn = spawnPortableSync, env = process.env } = {}) {
+  const listed = spawn('claude', ['agents', '--json', '--all'], { env, encoding: 'utf8', timeout: 10_000, stdio: ['ignore', 'pipe', 'pipe'] });
+  if (listed.error || listed.status !== 0) return { stopped: false, reason: 'list_failed' };
+  let entries;
+  try { entries = JSON.parse(`${listed.stdout ?? ''}`); }
+  catch { return { stopped: false, reason: 'list_failed' }; }
+  if (!Array.isArray(entries)) return { stopped: false, reason: 'list_failed' };
+  const same = entries.filter(entry => entry?.sessionId === sessionId);
+  if (!same.length) return { stopped: false, reason: 'not_listed' };
+  if (same.some(entry => entry.pid || Object.hasOwn(entry, 'status'))) return { stopped: false, reason: 'running' };
+  const background = same.find(entry => entry.kind === 'background');
+  if (!background) return { stopped: false, reason: 'not_background' };
+  if (!STOPPED_BACKGROUND_STATES.has(background.state)) return { stopped: false, reason: 'not_stopped' };
+  return { stopped: true, reason: 'stopped' };
+}
+
+/** 後継の transcript の場所（旧い会話の transcript と同じ projects の下を探す）。見つからなければ null。 */
+function findSessionTranscript(record, sessionId) {
+  if (typeof record?.transcript_path !== 'string' || !validSessionId(sessionId)) return null;
+  const own = dirname(record.transcript_path);
+  const direct = join(own, `${sessionId}.jsonl`);
+  if (existsSync(direct)) return direct;
+  let folders;
+  try { folders = readdirSync(dirname(own), { withFileTypes: true }); }
+  catch { return null; }
+  for (const entry of folders) {
+    const path = entry.isDirectory() ? join(dirname(own), entry.name, `${sessionId}.jsonl`) : null;
+    if (path && existsSync(path)) return path;
+  }
+  return null;
+}
+
+/**
+ * 起こす命令を流す。option は付けない。裏の会話は、立てた時の option（モデル・effort・権限の mode・名前・リモート
+ * コントロール）を持っていて、option なしの時だけ、同じ会話のままそれで起きる。option を付けると、止まっている
+ * 会話でも写しが立つ。文は `--` の後に置く（頭が `-` の文を option として読ませない）。
+ *
+ * @returns {{outcome: 'woken'|'copy'|'failed'|'unknown', copyShortId?: string}}
+ */
+function runClaudeWake({ sessionId, text, cwd, env, spawn }) {
+  const result = spawn('claude', ['--bg', '--resume', sessionId, '--', text], {
+    cwd, env, encoding: 'utf8', timeout: 15_000, stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  if (result.error) {
+    // 立ち上がる前の失敗（命令が無い・実行できない）は届いていない。時間切れは、命令が途中まで進んだかもしれない。
+    return { outcome: result.error.code === 'ETIMEDOUT' ? 'unknown' : 'failed' };
+  }
+  const out = normalizeTerminalText(`${result.stdout ?? ''}${result.stderr ?? ''}`);
+  const copy = WAKE_COPY_PATTERN.exec(out)?.[1];
+  if (copy) return { outcome: 'copy', copyShortId: copy };
+  const shortId = BACKGROUNDED_PATTERN.exec(out)?.[1];
+  if (result.status === 0 && shortId === sessionId.slice(0, 8)) return { outcome: 'woken' };
+  if (result.status === 0 && shortId) return { outcome: 'copy', copyShortId: shortId };
+  if (result.status !== 0 && !shortId) return { outcome: 'failed' };
+  return { outcome: 'unknown' };
+}
+
+/**
+ * 後継が止まっていて、人が旧い会話へ文を打った時に、後継を起こしてその文を最初の入力として渡す (ADR 0064)。
+ * 利用者の決め（K-9UHCLQ、2026-10-14）は「人が打った文の時だけ起こす。完了通知では起こさない」。
+ *
+ * 止まっていると確かめられない時は何もしない（`skipped`。入力は呼んだ側が置き場へ置く）。写しが立った時は、写しを
+ * 止めて一覧から消し、入力を置き場へ戻す（`queued`）。起こす命令が失敗した時も置き場へ戻す。起きたか分からない時は
+ * 入れ直さない（`unknown`）。
+ *
+ * @returns {{outcome: 'woken'|'queued'|'unknown'|'skipped', reason: string, running?: boolean, waking?: boolean}}
+ */
+export function wakeStoppedClaudeSuccessor({ record, successorSessionId, sourceSessionId, text, now = Date.now(),
+  dir = claudeAutoHandoffDir(), env = process.env, spawn = spawnPortableSync }) {
+  const skip = (reason, extra = {}) => {
+    logClaudeForward({ event: 'wake-skipped', reason, session_id: successorSessionId }, dir);
+    return { outcome: 'skipped', reason, ...extra };
+  };
+  if (`${env[WAKE_OVERRIDE_ENV] ?? ''}`.trim().toLowerCase() === 'off') return { outcome: 'skipped', reason: 'disabled' };
+  if (claudeForwardWaiterAlive(successorSessionId, dir)) return { outcome: 'skipped', reason: 'waiter_alive', running: true };
+  if (!claudeWakeTextAllowed(text)) return skip('text_not_allowed');
+  // Claude Desktop へ移した後継は、Desktop が開いている。裏で起こすと、同じ会話を2か所で動かす事になる。
+  if (record.desktop?.state === 'opened') return skip('desktop');
+  try {
+    if (resolveClaudeAutoHandoffSuccessor(successorSessionId, { dir }).pending) return skip('handoff_pending');
+  } catch { return skip('handoff_pending'); }
+  const transcript = findSessionTranscript(record, successorSessionId);
+  if (!transcript) return skip('transcript_missing'); // 無い会話 ID へ流すと、その ID で新しい会話が立つ
+  try {
+    if (Date.now() - statSync(transcript).mtimeMs < RECENTLY_WRITTEN_MS) return skip('recently_written', { running: true });
+  } catch { return skip('transcript_missing'); }
+  const release = acquireClaudeWakeClaim(successorSessionId, { dir, now });
+  if (!release) return skip('waking', { waking: true });
+  const wakeEnv = wakeCommandEnv(env);
+  const state = readClaudeSessionStopped(successorSessionId, { spawn, env: wakeEnv });
+  if (!state.stopped) {
+    release();
+    return skip(state.reason, { running: state.reason === 'running' });
+  }
+  const held = holdClaudeForward({ successorSessionId, sourceSessionId, handoffId: record.handoff_id, kind: 'prompt', text, now, dir });
+  if (!held) { release(); return skip('store_failed'); }
+  const cwd = typeof record.project_path === 'string' && existsSync(record.project_path) ? record.project_path : undefined;
+  const woke = runClaudeWake({ sessionId: successorSessionId, text, cwd, env: wakeEnv, spawn });
+  const base = { session_id: successorSessionId, source_session_id: sourceSessionId, chars: text.length };
+  if (woke.outcome === 'woken') {
+    held.settle();
+    logClaudeForward({ event: 'woken', ...base }, dir);
+    return { outcome: 'woken', reason: 'woken' }; // 番の印は残す（期限で切れる）
+  }
+  if (woke.outcome === 'copy') {
+    // 写しは、渡した文で動き出す。後継と同じ作業を2か所でしないよう、すぐ止めて一覧から消す。入力は置き場へ戻す
+    // （後継は動いているので、後継の hook が受け取る）。
+    for (const verb of ['stop', 'rm']) {
+      spawn('claude', [verb, woke.copyShortId], { env: wakeEnv, encoding: 'utf8', timeout: 10_000, stdio: ['ignore', 'pipe', 'pipe'] });
+    }
+    const queued = held.release();
+    release();
+    logClaudeForward({ event: 'wake-copy', ...base, copy_short_id: woke.copyShortId, queued }, dir);
+    return queued ? { outcome: 'queued', reason: 'copy', running: true } : { outcome: 'unknown', reason: 'copy' };
+  }
+  if (woke.outcome === 'failed') {
+    const queued = held.release();
+    release();
+    logClaudeForward({ event: 'wake-failed', ...base, queued }, dir);
+    return queued ? { outcome: 'queued', reason: 'failed' } : { outcome: 'unknown', reason: 'failed' };
+  }
+  logClaudeForward({ event: 'wake-unknown', ...base }, dir);
+  return { outcome: 'unknown', reason: 'unknown' };
 }
 
 function stopOutput(record, dir) {
@@ -792,7 +974,7 @@ function recordClaudeRedirect(entry, dir) {
  *
  * @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 }) {
+export function redirectClaudeHandedOffPrompt({ payload, now = Date.now(), dir = claudeAutoHandoffDir(), env = process.env, spawn = spawnPortableSync }) {
   const sessionId = payload?.session_id;
   if (!validSessionId(sessionId) || payload.agent_id || isAitermSeatConversation(env, sessionId)) return null;
   const record = readClaudeAutoHandoff(sessionId, dir);
@@ -803,13 +985,23 @@ export function redirectClaudeHandedOffPrompt({ payload, now = Date.now(), dir =
   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 });
+  const canForward = forwardKind !== null && validSessionId(successorSessionId) && successorSessionId !== sessionId;
+  // 人が打った文で、後継が止まっていれば、後継を起こしてその文を渡す (ADR 0064)。完了通知とほかの会話からの文では起こさない。
+  const wake = canForward && forwardKind === 'prompt'
+    ? wakeStoppedClaudeSuccessor({ record, successorSessionId, sourceSessionId: sessionId, text: payload.prompt, now, dir, env, spawn })
+    : null;
+  const forwarded = canForward && (wake?.outcome === 'woken' || wake?.outcome === 'queued' ||
+    (wake?.outcome !== 'unknown' && 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, forwarded }, dir);
-  return { output: { decision: 'block', reason: forwarded ? forwardedReason(record, dir, successorSessionId) : handedOffReason(record, dir) },
-    kind, handoffId: record.handoff_id, successorShortId, forwarded };
+    successor_short_id: successorShortId, kind, forwarded,
+    ...(wake && wake.reason !== 'disabled' ? { wake: wake.outcome === 'skipped' ? `skipped:${wake.reason}` : wake.outcome } : {}) }, dir);
+  const reason = wake?.outcome === 'woken' ? wokenReason(record, dir)
+    : wake?.outcome === 'unknown' ? wakeUnknownReason(record, dir)
+      : forwarded ? forwardedReason(record, dir, successorSessionId, { running: Boolean(wake?.running), waking: Boolean(wake?.waking) })
+        : handedOffReason(record, dir);
+  return { output: { decision: 'block', reason }, kind, handoffId: record.handoff_id, successorShortId, forwarded,
+    ...(wake ? { wake: wake.outcome } : {}) };
 }
 
 /**

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

@@ -1611,7 +1611,9 @@ test('引き継ぎ済みの会話へ届いた入力: 後継が残っている時
   const record = (id, fields) => writeFileSync(join(dir, `${id}.json`), JSON.stringify({ schema: 'throughline.claude-auto-handoff.v2',
     handoff_id: `h-${id.slice(0, 8)}`, source_session_id: id, project_path: '/work/app', transcript_path: join(projects, `${id}.jsonl`),
     requested_at: 1_000, updated_at: 2_000, error_code: null, ...fields }));
-  const submit = (id, prompt, extra = {}, env = {}) => redirectClaudeHandedOffPrompt({ payload: { session_id: id, prompt, ...extra }, now: 5_000, dir, env });
+  const noClaude = () => ({ error: Object.assign(new Error('spawn claude ENOENT'), { code: 'ENOENT' }) });
+  const submit = (id, prompt, extra = {}, env = {}) => redirectClaudeHandedOffPrompt({ payload: { session_id: id, prompt, ...extra }, now: 5_000, dir, env, spawn: noClaude });
+  const settled = path => { const past = new Date(Date.now() - 60_000); utimesSync(path, past, past); };
   const redirects = () => existsSync(join(dir, 'redirects.jsonl'))
     ? readFileSync(join(dir, 'redirects.jsonl'), 'utf8').trim().split('\n').map(line => JSON.parse(line)) : [];
 
@@ -1625,26 +1627,28 @@ test('引き継ぎ済みの会話へ届いた入力: 後継が残っている時
   assert.deepEqual(redirects(), []);
 
   writeFileSync(join(projects, `${b}.jsonl`), '');
+  settled(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', forwarded: true });
+    kind: 'prompt', handoffId: 'h-aaaaaaaa', successorShortId: 'bbbbbbbb', forwarded: true, wake: 'skipped' });
   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', 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, wake: 'skipped:list_failed' },
     { 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 },
+    { at: '1970-01-01T00:00:05.000Z', source_session_id: a, handoff_id: 'h-aaaaaaaa', successor_short_id: 'bbbbbbbb', kind: 'prompt', forwarded: true, wake: 'skipped:list_failed' },
   ], '止めた記録に入力の本文は書かない');
 
   // 後継がさらに引き継がれている時は、その先を示す。道具を断る時の文も同じ
   record(b, { state: 'unknown', successor: { short_id: 'cccccccc', session_id: null } });
   writeFileSync(join(projects, `${c}.jsonl`), '');
+  settled(join(projects, `${c}.jsonl`));
   assert.match(submit(a, '依頼').output.reason, /claude attach cccccccc（一覧に無い時は claude --resume cccccccc-0000-4000-8000-000000000033）$/);
   assert.match(submit(b, '依頼').output.reason, /引き継ぎID: h-bbbbbbbb.*claude attach cccccccc（一覧に無い時は claude --resume cccccccc-0000-4000-8000-000000000033）$/);
   const denied = await stopClaudeTurnForHandoff({ payload: { session_id: a, cwd: '/work/app' }, dir,
@@ -1659,6 +1663,7 @@ test('公開CLI: prompt-submit は、引き継ぎ済みの会話の入力を止
   const projects = join(home, '.claude', 'projects', '-work-app');
   mkdirSync(dir, { recursive: true }); mkdirSync(projects, { recursive: true });
   writeFileSync(join(projects, `${SUCCESSOR}.jsonl`), '');
+  utimesSync(join(projects, `${SUCCESSOR}.jsonl`), new Date(Date.now() - 60_000), new Date(Date.now() - 60_000));
   writeFileSync(join(dir, `${SESSION}.json`), JSON.stringify({ schema: 'throughline.claude-auto-handoff.v2', handoff_id: 'h-1',
     source_session_id: SESSION, project_path: '/work/app', transcript_path: join(projects, `${SESSION}.jsonl`), state: 'sent',
     requested_at: 1_000, updated_at: 2_000, error_code: null, successor: { short_id: SUCCESSOR.slice(0, 8), session_id: SUCCESSOR } }));

package/src/claude-forward.mjs

@@ -8,6 +8,7 @@
  *   ~/.throughline/claude-auto-handoff/inbox/<後継の会話 ID>/claimed/…            受け取った所が出力するまでの置き場
  *   ~/.throughline/claude-auto-handoff/inbox/<後継の会話 ID>/full/…               長すぎる入力の全文
  *   ~/.throughline/claude-auto-handoff/inbox/<後継の会話 ID>/waiter                今、待つ番の hook の印
+ *   ~/.throughline/claude-auto-handoff/inbox/<後継の会話 ID>/waking                止まっている後継を起こしている所の印 (ADR 0064)
  *   ~/.throughline/claude-auto-handoff/forward.jsonl                              運んだ記録（本文は書かない）
  *
  * 届いたか分からない入力は入れ直さない。受け取る所は、ファイルを `claimed` へ改名してから出力し、出力した後で消す。
@@ -79,19 +80,75 @@ export function logClaudeForward(entry, dir = defaultDir()) {
  * 旧い会話が止めた入力を、後継の置き場へ置く。
  * @returns {boolean} 置けたか
  */
-export function enqueueClaudeForward({ successorSessionId, sourceSessionId, handoffId, kind, text, now = Date.now(), dir = defaultDir() }) {
+export function enqueueClaudeForward(input) {
+  return writeClaudeForward(input) !== null;
+}
+
+/** 入力を1ファイルに書く。`claimed` が真なら、受け取り済みの置き場へ書く。書いたファイルの名前と場所を返す。 */
+function writeClaudeForward({ successorSessionId, sourceSessionId, handoffId, kind, text, now = Date.now(), dir = defaultDir(), claimed = false }) {
   const inbox = claudeForwardInboxDir(successorSessionId, dir);
-  if (!inbox || typeof text !== 'string' || !text.trim()) return false;
+  if (!inbox || typeof text !== 'string' || !text.trim()) return null;
   try {
-    mkdirSync(inbox, { recursive: true, mode: 0o700 });
+    const folder = claimed ? join(inbox, 'claimed') : inbox;
+    mkdirSync(folder, { recursive: true, mode: 0o700 });
     const name = `${String(now).padStart(13, '0')}-${randomUUID().slice(0, 8)}.json`;
-    const temporary = join(inbox, `${name}.tmp`);
+    const path = join(folder, claimed ? `${name}.${process.pid}` : name);
+    const temporary = join(folder, `${name}.tmp`);
     writeFileSync(temporary, JSON.stringify({ schema: 'throughline.claude-forward.v1', at: now,
       source_session_id: sourceSessionId ?? null, handoff_id: handoffId ?? null,
       kind: KINDS.includes(kind) ? kind : 'prompt', text }) + '\n', { mode: 0o600, flag: 'wx' });
-    renameSync(temporary, join(inbox, name));
-    return true;
-  } catch { return false; }
+    renameSync(temporary, path);
+    return { inbox, name, path };
+  } catch { return null; }
+}
+
+/**
+ * 止まっている後継を起こす命令で直接渡す入力を、受け取り済み（`claimed`）として置く (ADR 0064)。置き場の入力として
+ * 待たせると、起きた後継の hook が同じ文を文脈としてもう1回渡すため。起こす命令が終わったら、届いた時は `settle()`、
+ * 届かなかったと確かめられた時は `release()`（置き場へ戻す）を呼ぶ。どちらも呼ばなければ、届いたか分からない入力として
+ * `claimed` に残る（入れ直さない）。
+ *
+ * @returns {{settle: () => void, release: () => boolean}|null} 書けなかった時は null
+ */
+export function holdClaudeForward(input) {
+  const written = writeClaudeForward({ ...input, claimed: true });
+  if (!written) return null;
+  return {
+    settle: () => rmSync(written.path, { force: true }),
+    release: () => {
+      try { renameSync(written.path, join(written.inbox, written.name)); return true; }
+      catch { return false; }
+    },
+  };
+}
+
+const WAKE_CLAIM_TTL_MS = 60_000;
+
+/**
+ * 止まっている後継を起こす番を取る (ADR 0064)。起こす命令を同時に2つ流すと、どちらも「起こした」と返るのに、
+ * 後継へ届くのは1通だけになる（Claude Code 2.1.296 の実測）。番を取れなかった入力は、置き場で待たせる。
+ * 起こせた後も印は消さず、60 秒の間は次の入力で起こさない（起きたばかりの後継は、一覧でまだ止まって見える事がある）。
+ *
+ * @returns {(() => void)|null} 番を返す関数。取れなかった時は null
+ */
+export function acquireClaudeWakeClaim(sessionId, { dir = defaultDir(), now = Date.now() } = {}) {
+  const inbox = claudeForwardInboxDir(sessionId, dir);
+  if (!inbox) return null;
+  const path = join(inbox, 'waking');
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      mkdirSync(inbox, { recursive: true, mode: 0o700 });
+      writeFileSync(path, `${process.pid}-${now}`, { mode: 0o600, flag: 'wx' });
+      return () => rmSync(path, { force: true });
+    } catch (error) {
+      if (error.code !== 'EEXIST') return null;
+      try {
+        if (now - statSync(path).mtimeMs <= WAKE_CLAIM_TTL_MS) return null;
+        rmSync(path, { force: true }); // 期限を過ぎた印
+      } catch { /* 別の hook が消した */ }
+    }
+  }
+  return null;
 }
 
 function pendingNames(inbox) {
@@ -287,7 +344,7 @@ export function removeStaleClaudeForwards({ dir = defaultDir(), now = Date.now()
       try { names = readdirSync(join(inbox, sub)); }
       catch { continue; }
       for (const name of names) {
-        if (sub === '' && (name === 'claimed' || name === 'full' || name === 'waiter')) continue;
+        if (sub === '' && (name === 'claimed' || name === 'full' || name === 'waiter' || name === 'waking')) continue;
         const path = join(inbox, sub, name);
         try {
           if (now - statSync(path).mtimeMs > PENDING_TTL_MS) { rmSync(path, { force: true }); if (sub !== 'full') dropped++; }

package/src/claude-forward.test.mjs

@@ -13,8 +13,10 @@ import {
   claudeForwardWaiterAlive,
   registerClaudeForwardWaiter,
   claudeForwardInboxDir,
+  acquireClaudeWakeClaim,
   enqueueClaudeForward,
   ensureClaudeForwardInbox,
+  holdClaudeForward,
   hasPendingClaudeForwards,
   moveClaudeForwards,
   readClaudeForwardStatus,
@@ -24,7 +26,7 @@ import {
   unwrapClaudeForwardedDelivery,
 } from './claude-forward.mjs';
 import { waitForClaudeForwards } from './claude-forward-wait.mjs';
-import { acceptClaudeAutoContinuation, publicClaudeAutoHandoff, redirectClaudeHandedOffPrompt } from './claude-auto-handoff.mjs';
+import { CLAUDE_WAKE_TEXT_MAX_CHARS, acceptClaudeAutoContinuation, publicClaudeAutoHandoff, readClaudeSessionStopped, redirectClaudeHandedOffPrompt } from './claude-auto-handoff.mjs';
 import { MID_TURN_INPUT_MARK, readTranscript } from './transcript-reader.mjs';
 
 const REPO_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
@@ -33,6 +35,11 @@ const OLD = 'aaaaaaaa-0000-4000-8000-000000000041';
 const NEXT = 'bbbbbbbb-0000-4000-8000-000000000042';
 const LAST = 'cccccccc-0000-4000-8000-000000000043';
 
+// 一覧を読めない `claude`（試験では本物の claude を呼ばない）
+const NO_CLAUDE = () => ({ error: Object.assign(new Error('spawn claude ENOENT'), { code: 'ENOENT' }) });
+// 後継の transcript を、止まってしばらく経った物にする（書かれたばかりの transcript の後継は、動いていると見なす）
+const settled = path => { const past = new Date(Date.now() - 60_000); utimesSync(path, past, past); };
+
 function withDir(fn) {
   const dir = mkdtempSync(join(tmpdir(), 'tl-claude-forward-'));
   const finish = () => rmSync(dir, { recursive: true, force: true });
@@ -201,9 +208,10 @@ test('旧い会話の側: 止めた入力を今の続きの会話の置き場へ
   const record = (id, fields) => writeFileSync(join(dir, `${id}.json`), JSON.stringify({ schema: 'throughline.claude-auto-handoff.v2',
     handoff_id: `h-${id.slice(0, 8)}`, source_session_id: id, project_path: '/work/app', transcript_path: join(projects, `${id}.jsonl`),
     requested_at: 1_000, updated_at: 2_000, error_code: null, state: 'sent', ...fields }));
-  const submit = (id, prompt) => redirectClaudeHandedOffPrompt({ payload: { session_id: id, prompt }, now: 1_760_000_000_000, dir, env: {} });
+  const submit = (id, prompt) => redirectClaudeHandedOffPrompt({ payload: { session_id: id, prompt }, now: 1_760_000_000_000, dir, env: {}, spawn: NO_CLAUDE });
   record(OLD, { successor: { short_id: 'bbbbbbbb', session_id: NEXT } });
   writeFileSync(join(projects, `${NEXT}.jsonl`), '');
+  settled(join(projects, `${NEXT}.jsonl`));
 
   const human = submit(OLD, '旧い会話へ打った文');
   assert.equal(human.forwarded, true);
@@ -222,6 +230,7 @@ test('旧い会話の側: 止めた入力を今の続きの会話の置き場へ
   // 後継がさらに引き継がれている時は、その先の置き場へ置く
   record(NEXT, { state: 'unknown', successor: { short_id: 'cccccccc', session_id: null } });
   writeFileSync(join(projects, `${LAST}.jsonl`), '');
+  settled(join(projects, `${LAST}.jsonl`));
   assert.equal(submit(OLD, '後継の先へ届く文').forwarded, true);
   assert.deepEqual(readClaudeForwardStatus(NEXT, { dir }).pending, 2);
   assert.match(claimClaudeForwards({ sessionId: LAST, dir }).text, /引き継ぎ前の会話（aaaaaaaa）.*\n後継の先へ届く文$/s);
@@ -351,3 +360,177 @@ test('公開CLI: pre-tool-use は、後継の置き場で待っている入力
   assert.equal(tool(NEXT).stdout, '', '同じ入力を2回は届けない');
   assert.equal(existsSync(join(home, '.throughline', 'throughline.db')), false);
 }));
+
+// ---- 止まっている後継を、人の入力で起こして届ける (ADR 0064) ----
+
+test('置き場: 起こす命令で渡す入力は受け取り済みとして置き、届いたら消し、届かなかったら置き場へ戻す', () => withDir(dir => {
+  const held = holdClaudeForward({ successorSessionId: NEXT, sourceSessionId: OLD, handoffId: 'h-1', kind: 'prompt', text: '起こして渡す文', now: 1_000, dir });
+  assert.deepEqual(readClaudeForwardStatus(NEXT, { dir, now: 2_000 }), { pending: 0, unknown: 0 });
+  assert.equal(hasPendingClaudeForwards(NEXT, dir), false, '起きた後継の hook が、同じ文を文脈としてもう1回渡さない');
+  assert.equal(held.release(), true);
+  assert.match(claimClaudeForwards({ sessionId: NEXT, dir }).text, /\n起こして渡す文$/);
+  const done = holdClaudeForward({ successorSessionId: NEXT, sourceSessionId: OLD, handoffId: 'h-1', kind: 'prompt', text: '届いた文', now: 1_000, dir });
+  done.settle();
+  assert.deepEqual(readdirSync(join(claudeForwardInboxDir(NEXT, dir), 'claimed')).filter(name => name.includes('-')).length, 1, '前の claim の残りだけ');
+  assert.equal(holdClaudeForward({ successorSessionId: '../x', text: 'x', dir }), null);
+}));
+
+test('置き場: 起こす番は1つだけ。60 秒を過ぎた印は取り直せる。片付けは印を入力として数えない', () => withDir(dir => {
+  const release = acquireClaudeWakeClaim(NEXT, { dir, now: Date.now() });
+  assert.equal(typeof release, 'function');
+  assert.equal(acquireClaudeWakeClaim(NEXT, { dir, now: Date.now() }), null, '起こしている間は、次の入力で起こさない');
+  release();
+  const again = acquireClaudeWakeClaim(NEXT, { dir, now: Date.now() });
+  assert.equal(typeof again, 'function');
+  const mark = join(claudeForwardInboxDir(NEXT, dir), 'waking');
+  const past = new Date(Date.now() - 61_000); utimesSync(mark, past, past);
+  assert.equal(typeof acquireClaudeWakeClaim(NEXT, { dir, now: Date.now() }), 'function', '期限を過ぎた印');
+  utimesSync(mark, new Date(0), new Date(0));
+  removeStaleClaudeForwards({ dir, now: Date.now(), keepSessionIds: new Set([NEXT]) });
+  assert.equal(existsSync(join(dir, 'forward.jsonl')), false, '印は期限切れの入力として数えない');
+  assert.equal(acquireClaudeWakeClaim('../x', { dir }), null);
+}));
+
+test('一覧の読み方: 裏の項目に pid も status も無く、state が done か stopped の時だけ止まっていると読む', () => {
+  const read = (entries, extra = {}) => readClaudeSessionStopped(NEXT, { spawn: () => ({ status: 0, stdout: JSON.stringify(entries), ...extra }) });
+  const bg = fields => ({ id: 'bbbbbbbb', kind: 'background', sessionId: NEXT, name: 'n', cwd: '/w', startedAt: 1, ...fields });
+  assert.deepEqual(read([bg({ state: 'done' })]), { stopped: true, reason: 'stopped' }, '手すきで止めた・片付けられた');
+  assert.deepEqual(read([bg({ state: 'stopped' })]), { stopped: true, reason: 'stopped' }, '作業の途中で止めた');
+  assert.equal(read([bg({ state: 'done', pid: 10, status: 'idle' })]).reason, 'running', '手すきで動いている');
+  assert.equal(read([bg({ state: 'working', pid: 10, status: 'busy' })]).reason, 'running', '作業中');
+  assert.equal(read([bg({ state: 'done' }), { kind: 'interactive', sessionId: NEXT, pid: 11, status: 'idle', name: 'n' }]).reason, 'running', '端末で開いている・claude -p --resume が走っている');
+  assert.equal(read([bg({ state: 'working' })]).reason, 'not_stopped', '立ち上げ中（pid がまだ無い）');
+  assert.equal(read([bg({ state: 'failed' })]).reason, 'not_stopped');
+  assert.equal(read([{ ...bg({ state: 'done' }), sessionId: LAST }]).reason, 'not_listed', 'claude rm で一覧から消した');
+  assert.equal(read([{ kind: 'interactive', sessionId: NEXT, name: 'n' }]).reason, 'not_background');
+  assert.equal(read([], { status: 1 }).reason, 'list_failed');
+  assert.equal(read(null, { stdout: 'not json' }).reason, 'list_failed');
+  assert.equal(readClaudeSessionStopped(NEXT, { spawn: NO_CLAUDE }).reason, 'list_failed');
+});
+
+test('旧い会話の側: 人が打った文で、後継が止まっていれば、後継を起こしてその文を最初の入力として渡す', () => withDir(dir => {
+  const projects = join(dir, 'claude', 'projects', '-work-app');
+  const project = join(dir, 'app');
+  mkdirSync(projects, { recursive: true }); mkdirSync(project);
+  writeFileSync(join(dir, `${OLD}.json`), JSON.stringify({ schema: 'throughline.claude-auto-handoff.v2', handoff_id: 'h-aaaaaaaa',
+    source_session_id: OLD, project_path: project, transcript_path: join(projects, `${OLD}.jsonl`), requested_at: 1_000, updated_at: 2_000,
+    error_code: null, state: 'sent', successor: { short_id: 'bbbbbbbb', session_id: NEXT } }));
+  const transcript = join(projects, `${NEXT}.jsonl`);
+  writeFileSync(transcript, ''); settled(transcript);
+  const bg = fields => ({ id: 'bbbbbbbb', kind: 'background', sessionId: NEXT, name: 'n', cwd: project, startedAt: 1, ...fields });
+  let listing = [bg({ state: 'done' })];
+  let woke = { status: 0, stdout: 'backgrounded · bbbbbbbb · n\n  claude attach bbbbbbbb    open in this terminal\nnote: woke session bbbbbbbb with its saved options (--name, --model).\n' };
+  const calls = [];
+  const spawn = (command, args, options) => {
+    calls.push({ args, cwd: options.cwd, env: options.env });
+    if (args[0] === 'agents') return { status: 0, stdout: JSON.stringify(listing) };
+    if (args[0] === '--bg') return typeof woke === 'function' ? woke() : woke;
+    return { status: 0, stdout: `${args[0]}ped` };
+  };
+  const env = { CLAUDECODE: '1', CLAUDE_CODE_ENTRYPOINT: 'cli', CLAUDE_CODE_SESSION_ID: OLD, PATH: '/bin' };
+  const submit = (prompt, extraEnv = {}) => redirectClaudeHandedOffPrompt({ payload: { session_id: OLD, prompt }, now: Date.now(), dir, env: { ...env, ...extraEnv }, spawn });
+  const inbox = claudeForwardInboxDir(NEXT, dir);
+  const pending = () => readClaudeForwardStatus(NEXT, { dir }).pending;
+  const claimed = () => { try { return readdirSync(join(inbox, 'claimed')).length; } catch { return 0; } };
+  const events = () => readFileSync(join(dir, 'forward.jsonl'), 'utf8').trim().split('\n').map(line => JSON.parse(line));
+  const freeClaim = () => rmSync(join(inbox, 'waking'), { force: true });
+  const open = `claude attach bbbbbbbb（一覧に無い時は claude --resume ${NEXT}）`;
+
+  // 1) 止まっている後継: 起こして、文をそのまま渡す。option は付けず、文は -- の後。会話ごとの環境変数は渡さない
+  const text = '-v を付けて、もう一度ビルドして\n2行目';
+  const woken = submit(text);
+  assert.deepEqual([woken.wake, woken.forwarded], ['woken', true]);
+  assert.equal(woken.output.reason, 'この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: h-aaaaaaaa）。' +
+    `後継の会話が止まっていたので、Throughlineが起こして、この入力を後継の最初の入力として渡しました。後継は裏で作業を続けます: ${open}`);
+  assert.deepEqual(calls.map(call => call.args), [['agents', '--json', '--all'], ['--bg', '--resume', NEXT, '--', text]]);
+  assert.equal(calls[1].cwd, project);
+  assert.deepEqual(Object.keys(calls[1].env).filter(key => key.startsWith('CLAUDE')), [], '旧い会話の環境変数を後継へ渡さない');
+  assert.deepEqual([pending(), claimed()], [0, 0], '渡した文は置き場に残さない（起きた後継の hook が二重に渡さない）');
+  assert.deepEqual(events().at(-1), { at: events().at(-1).at, event: 'woken', session_id: NEXT, source_session_id: OLD, chars: text.length });
+  assert.equal(readFileSync(join(dir, 'forward.jsonl'), 'utf8').includes('ビルド'), false, '運んだ記録に本文は書かない');
+  assert.equal(JSON.parse(readFileSync(join(dir, 'redirects.jsonl'), 'utf8').trim().split('\n').at(-1)).wake, 'woken');
+
+  // 2) 起こした直後の次の入力: 番の印が残っているので起こさず、置き場へ置く
+  calls.length = 0;
+  const second = submit('続けてもう1つ');
+  assert.deepEqual([second.wake, second.forwarded, pending()], ['skipped', true, 1]);
+  assert.match(second.output.reason, /後継は、先に届いた入力で起きている所です。起きた後継が、次の道具の前か番の終わりに読みます。/);
+  assert.deepEqual(calls, [], '一覧も読まない');
+  freeClaim();
+
+  // 3) 動いている後継（手すき・作業中・端末で開いている）: 起こさず、置き場へ置いて「動いています」と返す
+  for (const entries of [[bg({ state: 'done', pid: 5, status: 'idle' })], [bg({ state: 'working', pid: 5, status: 'busy' })],
+    [bg({ state: 'done' }), { kind: 'interactive', sessionId: NEXT, pid: 6, status: 'idle', name: 'n' }]]) {
+    listing = entries; calls.length = 0;
+    const result = submit('動いている後継へ');
+    assert.deepEqual([result.wake, result.forwarded], ['skipped', true]);
+    assert.match(result.output.reason, /後継は動いています。/);
+    assert.deepEqual(calls.map(call => call.args[0]), ['agents'], '起こす命令は流さない');
+    assert.equal(existsSync(join(inbox, 'waking')), false, '起こさなかった時は番を返す');
+  }
+
+  // 4) 止まっていると確かめられない（一覧に無い・立ち上げ中・一覧を読めない）: 起こさず、0.16.32 と同じ文
+  for (const entries of [[], [bg({ state: 'working' })], 'unreadable']) {
+    listing = entries; calls.length = 0;
+    const result = submit('確かめられない後継へ');
+    assert.deepEqual([result.wake, result.forwarded], ['skipped', true]);
+    assert.match(result.output.reason, /後継は今、入力を待ち受けていません（止まっているか、この版より前に立った会話です）。/);
+    assert.equal(calls.some(call => call.args[0] === '--bg'), false);
+  }
+
+  // 5) 写しが立った（確かめた後に後継が動き出した）: 写しを止めて一覧から消し、入力は置き場へ戻す
+  listing = [bg({ state: 'done' })]; calls.length = 0;
+  woke = { status: 0, stdout: 'backgrounded · 12345678\nnote: session bbbbbbbb is already running in the background, so this started a copy as 12345678.\n' };
+  const before = pending();
+  const copied = submit('写しが立つ入力');
+  assert.deepEqual([copied.wake, copied.forwarded, pending()], ['queued', true, before + 1]);
+  assert.deepEqual(calls.map(call => call.args), [['agents', '--json', '--all'], ['--bg', '--resume', NEXT, '--', '写しが立つ入力'], ['stop', '12345678'], ['rm', '12345678']]);
+  assert.match(copied.output.reason, /届いた入力は、後継の会話へ渡しました。後継は動いています。/);
+  assert.deepEqual([events().at(-1).event, events().at(-1).copy_short_id, events().at(-1).queued], ['wake-copy', '12345678', true]);
+
+  // 6) 起こす命令が失敗した: 置き場へ戻す
+  woke = { status: 1, stdout: '', stderr: 'Error: something went wrong\n' }; calls.length = 0;
+  const failed = submit('失敗する入力');
+  assert.deepEqual([failed.wake, failed.forwarded, pending()], ['queued', true, before + 2]);
+  assert.match(failed.output.reason, /後継は今、入力を待ち受けていません/);
+
+  // 7) 起きたか分からない（時間切れ）: 入れ直さない
+  woke = () => ({ error: Object.assign(new Error('spawnSync claude ETIMEDOUT'), { code: 'ETIMEDOUT' }) });
+  const unknown = submit('分からない入力');
+  assert.deepEqual([unknown.wake, unknown.forwarded, pending(), claimed()], ['unknown', false, before + 2, 1]);
+  assert.equal(unknown.output.reason, 'この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: h-aaaaaaaa）。' +
+    '後継の会話が止まっていたので起こそうとしましたが、起きて入力を受け取ったか確かめられませんでした。' +
+    `二重に届かないよう、この入力は入れ直していません。後継を開いて確かめてください: ${open}`);
+  assert.equal(events().at(-1).event, 'wake-unknown');
+  freeClaim();
+
+  // 8) 起こさない入力: 完了通知・ほかの会話からの文・長すぎる文・NUL を含む文・上書きで止めた時・書かれたばかりの transcript
+  woke = { status: 0, stdout: 'backgrounded · bbbbbbbb · n\n' }; calls.length = 0;
+  assert.equal(submit('<task-notification>\n<task-id>b1</task-id>\n<status>completed</status>\n</task-notification>').wake, undefined);
+  assert.equal(submit('Another Claude session sent a message:\n確認をお願いします').wake, undefined);
+  assert.equal(submit('あ'.repeat(CLAUDE_WAKE_TEXT_MAX_CHARS + 1)).wake, 'skipped');
+  assert.equal(submit('NUL\0入り').wake, 'skipped');
+  assert.equal(submit('止めた時', { THROUGHLINE_AUTO_HANDOFF_WAKE: 'off' }).wake, 'skipped');
+  writeFileSync(transcript, '{}\n');
+  const fresh = submit('書かれたばかり');
+  assert.match(fresh.output.reason, /後継は動いています。/);
+  settled(transcript);
+  assert.deepEqual(calls, [], 'どれも一覧を読まず、起こす命令も流さない');
+  // Claude Desktop へ移した後継も起こさない
+  const record = JSON.parse(readFileSync(join(dir, `${OLD}.json`), 'utf8'));
+  writeFileSync(join(dir, `${OLD}.json`), JSON.stringify({ ...record, desktop: { wanted: true, state: 'opened' } }));
+  assert.equal(submit('Desktop へ移した後継').wake, 'skipped');
+  assert.deepEqual(calls, []);
+  writeFileSync(join(dir, `${OLD}.json`), JSON.stringify(record));
+
+  // 9) 後継がさらに引き継がれている時は、一番先の会話を起こす
+  writeFileSync(join(dir, `${NEXT}.json`), JSON.stringify({ schema: 'throughline.claude-auto-handoff.v2', handoff_id: 'h-bbbbbbbb',
+    source_session_id: NEXT, project_path: project, transcript_path: transcript, requested_at: 1_000, updated_at: 2_000,
+    error_code: null, state: 'sent', successor: { short_id: 'cccccccc', session_id: LAST } }));
+  writeFileSync(join(projects, `${LAST}.jsonl`), ''); settled(join(projects, `${LAST}.jsonl`));
+  listing = [{ id: 'cccccccc', kind: 'background', sessionId: LAST, state: 'done', name: 'n', cwd: project, startedAt: 1 }];
+  woke = { status: 0, stdout: 'backgrounded · cccccccc · n\nnote: woke session cccccccc with its saved options (--name).\n' };
+  const chained = submit('一番先へ');
+  assert.equal(chained.wake, 'woken');
+  assert.deepEqual(calls.at(-1).args, ['--bg', '--resume', LAST, '--', '一番先へ']);
+}));

package/src/prompt-submit.mjs

@@ -178,6 +178,7 @@ export async function run() {
         successor_short_id: redirect.successorShortId,
         input_kind: redirect.kind,
         forwarded: redirect.forwarded,
+        ...(redirect.wake ? { wake: redirect.wake } : {}),
       });
       process.stdout.write(`${JSON.stringify(redirect.output)}\n`);
       process.exit(0);