throughline 0.16.22 → 0.16.24

package/CHANGELOG.md

@@ -10,6 +10,63 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.24] — 2026-10-11
+
+### 修正
+
+- **Claude Codeの自動継続で、後継へ前任の記憶が入らない事があった。同じprojectの別の会話へ、前任の記憶が入る事もあった**（[ADR 0053](docs/adr/0053-claude-successor-finds-predecessor-by-handoff-id.md)）。後継が前任を見つける所は、`/tl`と同じ「projectごとに1つの印」に頼っていた。印は引き継ぎを予約した時（`PreCompact`）に書き、期限は1時間。後継が立つのは、旧い会話が次に道具を使った時。その間に、同じprojectの別の会話が最初の指示を受けると、印を取るか、期限切れとして消していた。
+  - Windowsの実機で2026-10-11に起きた。同じフォルダに役の違うClaudeの会話が何本も動いていた。ある会話が17:21:55に引き継ぎを予約し、止まったのは19:43:09。18:43:06に別の会話の最初の指示が印を期限切れ（81分）として消し、19:43:14に後継が受けた最初の指示には記憶が1文字も入らなかった。引き継ぎは`unknown`（`handoff_delivery_unconfirmed`）で終わり、後継は別の役の仕事を始めた。
+  - 直した後は、後継の最初の指示の頭にある引き継ぎIDから記録を引いて、その記録の旧い会話を前任にする。projectごとの印は見ない。自動継続は、予約の時に印を書かない。`/tl`の印は変えていない。
+  - 0.16.23までの版が書いた印が残っている時は、後継が合流した時に消す。
+- **受領を確かめられなかった引き継ぎ（`unknown`）の記録を、後継が残っていても24時間で消していた**。消えると、旧い会話がまた道具を使えるようになり、同じ会話から2つ目の後継が立つ。後継のtranscriptが残っている間は消さない。
+
+- **Claude Codeの自動継続で、後継のeffortを、hookが値を渡さない時にも引き継ぐ**。後継は、止めた時点のモデルとeffortで立てる（`claude --bg --model … --effort …`）。モデルはtranscriptの最後の発言から、effortは`PreToolUse`のpayload（`effort.level`）から読んでいた。payloadにeffortが無い時は、transcriptの最後の発言の`effort`から読む（subagentの中の行は除く）。どちらにも無い時は、今までどおり端末の既定で立つ。
+  - 2026-10-11にWindowsの実機で、xhighの会話の続きがmediumになった。transcriptの`effort`の項目を読むと、落ちたのは引き継ぎの時ではなかった。後継はxhighで立ち（09:35〜10:39、発言365行がxhigh）、0.16.20の「後継をClaude Desktopへ移す処理」（`claude stop` → `claude --desktop --resume`）が10:39:59に開き直した後、mediumになっていた（10:43から）。その後の引き継ぎ2回は、止めた時点のmediumをそのまま渡した。移す処理は0.16.22から既定で無効（[ADR 0051](docs/adr/0051-claude-successor-desktop-move-is-opt-in.md)）。有効にした時は、開き直した会話のeffortがClaude Desktopの既定に戻る。これは直していない。
+  - モデルは落ちていない。同じ列の会話は全部`claude-opus-5-5`で、後継も文脈を90万token台まで使っている。
+
+### 追加
+
+- **Claudeの会話の「今の続き」を引く口**。`throughline auto-handoff successor --host claude --thread <session id> --json`（読むだけ）。`current_session_id`が今の続き（後継が無ければ渡したID自身）、`chain`がたどった引き継ぎ、`pending`が今の続きの会話にある、後継がまだ立っていない引き継ぎ（`requested`は予約だけで、会話は止まっていない）。後継のsession idが記録に無い時は、transcriptの名前から引く。ほかの道具が、旧い会話あての連絡を今の続きへ渡す時に使う。
+
+### 対応の範囲
+
+| | macOS | Linux | Windows |
+|---|---|---|---|
+| Claude Code | 直した（effortの控えは単体試験だけ）。単体試験と、実機で本物のhookの命令へ同じ順番（予約 → 別の会話の最初の指示 → 止める → 後継の最初の指示）を通した。入っていた0.16.23は前任の記憶が別の会話へ付き、後継は0文字。この版は後継だけに入る | 直した。同じ確認 | 直した。同じ確認。起きた端末 |
+| Codex | 変更なし（後継はApp Serverで作り、前任は引き継ぎの記録で決めている。projectごとの印を使わない。モデルとeffortは後継の設定へ写し、合わない時は引き継ぎを失敗にする） | 同じ | 同じ |
+| Grok | 変更なし（自動継続が無い。最初の指示の合流は、引き継ぎIDで始まる指示が無いので今までどおり） | 同じ | 同じ |
+| Cursor | 変更なし（自動継続が無い） | 同じ | 同じ |
+
+### 確かめていない事
+
+- 本物のClaude Codeが、同じprojectに会話が何本もある状態で引き継ぐ所。確認は、仮のHOMEで、本物のhookの命令（`session-start`・`pre-compact`・`prompt-submit`・`pre-tool-use`）へ、実機で起きた順番を通す形で行った。後継を立てる`claude --bg`は偽物に置き換えている。
+- 記憶が入らなかった後継へ、後から記憶を入れる処理は無い。`throughline recall --session <旧い会話のid>`で引ける。
+- effortの控え（transcriptから読む所）は、単体試験で確かめた。payloadにeffortが無い本物のClaude Codeでは通していない。Windowsの実機の引き継ぎ（Claude Code 2.1.296）では、payloadの値とtranscriptの値は毎回同じだった。
+- 旧い会話は、引き継ぎの後も文を受ければ文で答える（道具は断る）。この版では変えていない。
+
+## [0.16.23] — 2026-10-11
+
+### 修正
+
+- **`install`と`self-update`が、Codexの信用済みのhookを「変わったhook」にしていた**（[ADR 0052](docs/adr/0052-install-keeps-registered-codex-hook-command.md)）。Codexのhookの命令は`<node> <throughline.mjs> codex-hook <event>`で、`<node>`の表記は入れる側のPATHで決まる（PATHの上に今のnodeと同じ実体があればその表記、無ければ`process.execPath`）。`install`はhookを毎回作り直すので、前と違うPATHで入れると、同じnodeを指したまま文字列だけが変わった。Codexはhookの信用を命令の文字列で決めるので、Throughlineのhookが4つとも`modified`になり、新しい会話が起動の所で「Hooks need review」を出して、人が選ぶまで止まった。
+  - Linuxの実機で2026-10-11に起きた。09:20に`~/.local/bin`をPATHの先頭に付けて`self-update`を流し、`~/.local/lib/node-v24/bin/node`が、同じ実体を指すsymlinkの`~/.local/bin/node`に変わった。15:05に、常駐のprocessが立てるCodexの会話がそこで止まっていると知らせを受けた。
+  - 直した後は、登録済みの命令が今のnodeと`throughline.mjs`の実体（realpath）を指している時、その文字列のまま書く。`auto-handoff enable`が置く`PreCompact`も同じ。登録が無い時、旧い形の時、nodeかscriptの実体が違う時は、今までどおり書き直す。
+  - nodeの実体が変わった時（別の版の場所へ入れ直した時など）は命令が変わり、Codexは確認の画面を出す。これは変えていない。
+
+### 対応の範囲
+
+| | macOS | Linux | Windows |
+|---|---|---|---|
+| Codex | 直した。単体試験と、実機（Codex Desktop同梱の0.162.0-alpha.17.2）。仮のHOMEとCODEX_HOMEでhookを信用し、PATHだけ変えて入れ直すと、入っていた0.16.22は4つとも`modified`、この版は4つとも`trusted`で`hooks.json`は1バイトも変わらない | 直した。単体試験と、実機（codex-cli 0.162.1）で同じ確認 | 直した。単体試験（表記の違いは大文字と小文字で作る）と、実機（Codex Desktop同梱の0.162.0-alpha.17.2）で同じ確認 |
+| Claude Code | 変更なし（hookの命令は`throughline <subcommand>`で、nodeの場所が入らない） | 同じ | 同じ |
+| Grok | 変更なし。命令には同じ決め方でnodeの表記が入り、入れる側のPATHで変わる。Grokがhookの変更で確認を出すかは確かめていない | 同じ | 同じ |
+| Cursor | 変更なし。Grokと同じ | 同じ | 同じ |
+
+### 確かめていない事
+
+- 本物の`~/.codex`で、信用済みのhookを持つ端末へこの版を違うPATHから入れる所。確認は、仮のHOMEとCODEX_HOMEで、本物のCodexのApp Server（`hooks/list`）に信用の状態を聞く形で行った。
+- `doctor --codex`の「trusted」は、`trusted_hash`が記録されているかだけを見ている。Codexが今の命令と比べた結果は見ていないので、`modified`でも「trusted」と出る。この版では変えていない。
+
 ## [0.16.22] — 2026-10-11
 
 ### 変更
@@ -2378,7 +2435,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.22...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.24...HEAD
+[0.16.24]: https://github.com/kitepon/Throughline/compare/v0.16.23...v0.16.24
+[0.16.23]: https://github.com/kitepon/Throughline/compare/v0.16.22...v0.16.23
 [0.16.22]: https://github.com/kitepon/Throughline/compare/v0.16.21...v0.16.22
 [0.16.21]: https://github.com/kitepon/Throughline/compare/v0.16.20...v0.16.21
 [0.16.20]: https://github.com/kitepon/Throughline/compare/v0.16.19...v0.16.20

package/README.md

@@ -63,7 +63,7 @@ throughline auto-handoff disable --host claude
 
 自動圧縮を置き換えます。圧縮が走る前に旧い会話を止め、記憶を持った新しい会話で作業を続けます（[ADR 0033](docs/adr/0033-claude-auto-handoff-new-session.md)）。
 
-1. 自動圧縮の直前に、圧縮を止めます。`/tl`と同じ印を残します。
+1. 自動圧縮の直前に、圧縮を止めて、引き継ぎを予約します。
 2. 旧い会話の次の道具を、実行させずに止めます。旧い会話は止めるだけで、空にしません。
 3. 同じprojectに、継続の指示を最初の指示として付けた新しいClaudeの会話を裏で立てます（`claude --bg`）。会話の名前は、前任の会話の題から`<project名>｜<作業の概要>（自動引き継ぎ）`にします。モデル・推論強度・権限は旧い会話から引き継ぎます。
 4. 最初の指示を受け取った時に、止めた時点の依頼、そのターンでここまでにしたこと（発言と道具の呼び出し）、実行されなかった道具、直近の会話の原文を注入します（上限9,500字）。止めたターンの道具の入出力は、後継が`throughline detail`で取り出せます。
@@ -74,6 +74,14 @@ throughline auto-handoff disable --host claude
 throughline auto-handoff status --host claude --operation <handoff-id> --json
 ```
 
+ある会話の今の続きは、次の命令で引けます（読むだけ。ほかの道具が、旧い会話あての連絡を今の続きへ渡す時に使います）。
+
+```bash
+throughline auto-handoff successor --host claude --thread <claude-session-id> --json
+```
+
+`current_session_id`が今の続きです（後継が無ければ渡したID自身）。`pending.state`が`requested`の間は、引き継ぎを予約しただけで、会話はまだ止まっていません。後継は、最初の指示が運ぶ引き継ぎIDで前任を決めます（[ADR 0053](docs/adr/0053-claude-successor-finds-predecessor-by-handoff-id.md)）。同じprojectに会話が何本あっても、前任の記憶は後継だけに入ります。
+
 後継の立ち上げや配送に失敗した時は、固定の理由を記録して止まります。結果が不明な指示は再送しません。圧縮を止めた後にモデルが道具を呼ばずにターンを終えた時は、後継を立てません。印は残るので、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)を参照してください。

package/docs/02_clear_auto_handoff_plan.md

@@ -25,7 +25,9 @@
 
 1. `SessionStart` は `pending_handoffs` に intent を登録するだけで、merge も注入もしない。
 2. 次の最初の `UserPromptSubmit` が実セッションの存在証明となり、pending intent を一度だけ消費する。
-3. 適格な baton があればその session id を優先する。baton が無く、`source='clear'` の
+3. 届いた指示が Claude の自動継続の配送（文の頭が `Throughline自動継続 <引き継ぎID>`）なら、その引き継ぎの記録の旧い会話を
+   前任にする。baton は見ない（[ADR 0053](adr/0053-claude-successor-finds-predecessor-by-handoff-id.md)）。
+   それ以外で、適格な baton があればその session id を優先する。baton が無く、`source='clear'` の
    auto predecessor があれば、その前任を使う。
 4. 前任 transcript を backfill してから merge し、予算内の再開文脈を注入する。
 

package/docs/adr/0051-claude-successor-desktop-move-is-opt-in.md

@@ -45,3 +45,6 @@ Desktop へ開き直していた（ADR 0043）。
   止めない。裏の命令が走っている会話を止めない。移した先でリモートコントロールが続く。作業ツリーの会話は作業ツリーで開く。
 - ADR 0050 の「保留の文を持つ後継も移す」と、ADR 0049 の「受領を確かめられなかった後継も移す」は、移す処理を
   有効にした時だけ働く。
+- 移す処理を有効にした時、開き直した会話の effort は Claude Desktop の既定に戻る。後継を立てる時に渡した `--effort` は、
+  その process だけの指定で、`claude --desktop --resume` には引き継がれない（2026-10-11、Windows の実機。xhigh で立てた後継が、
+  移した後 medium になっていた。0.16.24 の調べ）。

package/docs/adr/0052-install-keeps-registered-codex-hook-command.md

@@ -0,0 +1,42 @@
+# ADR 0052: install は、今の node を指す登録済みの Codex hook の命令を書き換えない
+
+- Status: Accepted
+- Date: 2026-10-11
+
+## Context
+
+Codex は、hook を1つずつ信用の対象にする。信用は `config.toml` の `hooks.state."<hooks.json>:<event>:<group>:<hook>".trusted_hash`
+に残り、hook の定義（命令の文字列を含む）から作った hash と比べる。hash が違う hook は「変わった hook」（`modified`）になり、
+新しい会話は起動の所で「Hooks need review」の画面を出して、人が選ぶまで止まる。
+
+Throughline の Codex hook の命令は `<node> <throughline.mjs> codex-hook <event>` で、`<node>` は
+`resolveCodexHookNodePath` が決める。PATH の上に今の node と同じ実体があればその表記、無ければ `process.execPath`。
+Homebrew の node を版ごとの場所（Cellar）で登録しないための決め方だが、同じ端末でも、入れる側の PATH で表記が変わる。
+
+2026-10-11、Linux の実機で、`~/.local/bin` を PATH の先頭に付けて `self-update` を流した。それまで
+`~/.local/lib/node-v24/bin/node` だった表記が、同じ実体を指す symlink の `~/.local/bin/node` に変わった。
+Throughline の hook は4つとも `modified` になり、新しい Codex の会話が確認の画面で止まった。常駐の process が
+立てる会話も、そこで止まった。
+
+`install` は、Throughline の hook を毎回作り直して書いていた。`doctor` と `factory-diagnostics` は、登録済みの命令と
+期待する命令を実体（realpath）で比べるので、表記が違っても「登録済み」と出す。`install` だけが、文字列で置き換えていた。
+
+## Decision
+
+1. `install` と `auto-handoff enable` は、登録済みの Throughline の Codex hook の命令が、期待する命令と同じ実体
+   （node と `throughline.mjs` の realpath、event）を指している時、その文字列のまま書く。
+2. 登録が無い時、旧い形の時、node か script の実体が違う時（realpath を解決できない時を含む）は、今までどおり
+   期待する命令で書く。
+3. 表記を「より安定した物」へ寄せるための書き換えはしない。
+
+## Consequences
+
+- 入れる側の PATH が変わっても、同じ node を使っている間は、Codex の信用が残る。
+- node の実体が変わった時（別の版の場所へ入れ直した時など）は命令が変わり、Codex は確認の画面を出す。これは避けない。
+  命令が指す実行ファイルが変わった事を、利用者が確かめる場面だから。
+- 版ごとの場所（Homebrew の Cellar など）で登録された命令は、その場所が残っている間はそのまま残る。場所が消えた後の
+  `install` で、期待する命令へ書き直す。その間 hook は失敗する。`doctor` と `factory-diagnostics` は、実体を
+  解決できない登録を「登録済み」と見ないので、そこで分かる。
+- `doctor --codex` の「trusted」は、`trusted_hash` が記録されているかだけを見ている。Codex が今の命令と比べた結果
+  （`trusted`・`modified`・`untrusted`）は、Codex の App Server の `hooks/list` でしか分からない。この ADR では変えない。
+- Grok と Cursor の hook の命令も同じ決め方で node の表記が入るが、この ADR では変えない。

package/docs/adr/0053-claude-successor-finds-predecessor-by-handoff-id.md

@@ -0,0 +1,49 @@
+# ADR 0053: Claude の自動継続の後継は、引き継ぎ ID で前任を決める
+
+- Status: Accepted
+- Date: 2026-10-11
+
+## Context
+
+Claude Code の自動継続（ADR 0033）は、`PreCompact(auto)` で圧縮を止めて引き継ぎを予約し、次の `PreToolUse` で旧い会話を止めて
+後継を立てる。後継が前任の記憶を受け取る所は、`/tl` と同じ仕組みを使っていた。予約の時に `handoff_batons`（project ごとに1行）へ
+「この project の次の新しい会話は、この会話の続き」という印を書き、後継の最初の `UserPromptSubmit` がその印を取って合流する。
+
+印には、自動継続に合わない所が3つあった。
+
+- 印を書くのは予約の時で、後継が立つ時ではない。待ちに入っている会話は、次に道具を使うまで止まらない。印の期限は1時間。
+- 印は project に1つ。同じ project の別の会話が予約すると、上書きされる。
+- 印は、その project で次に最初の指示を受けた新しい会話が取る。後継より先に別の会話が指示を受けると、その会話が前任の記憶を合流させる。
+
+2026-10-11、Windows の実機（0.16.23）で起きた。同じフォルダに、役の違う Claude の会話が何本も動いていた。ある会話が 17:21:55 に
+引き継ぎを予約し、道具を使って止まったのは 19:43:09 だった。その間の 18:43:06 に、同じフォルダの別の会話が最初の指示を受け、
+印は期限切れ（81分）として消された。19:43:14 に後継が最初の指示を受けた時、印は無く、記憶は1文字も入らなかった。引き継ぎは
+`unknown`（`handoff_delivery_unconfirmed`）で終わった。後継は記憶なしで自分で現在地を拾い、別の役の仕事を始めた。同じ役の会話が
+2つ同時に動き、止めた会話が受けていた依頼は、だれも始めなかった。
+
+後継の最初の指示は、文の頭に `Throughline自動継続 <引き継ぎID>` を持っている。引き継ぎの記録（旧い会話の session id で持つファイル）には
+同じ引き継ぎ ID と、後継の ID の頭8字が入っている。前任を決めるのに要る物は、印が無くてもそろっていた。
+
+## Decision
+
+1. 後継の最初の `UserPromptSubmit` は、届いた指示の頭の引き継ぎ ID から記録を引き、その記録の旧い会話を前任として合流させる。
+   project ごとの印は見ない。取りもしない。
+2. 引き継ぎ ID で前任と認めるのは、記録が後継を立てている状態（`launching`・`launched`・`sent`・`unknown`）で、記録に後継の ID の頭が
+   入っている時はそれと合う会話だけ。文の途中に引用された引き継ぎ ID は、配送として扱わない。
+3. 自動継続は、予約の時に project ごとの印を書かない。`/tl` の印は今までどおり（利用者が、次の新しい会話を前任の続きにすると
+   決めた時の物）。
+4. 0.16.23 までの版が書いた印が残っている時は、後継が合流した時に、その前任を指す印を消す。
+5. ある会話の今の続きを引く口を、Claude にも作る（`auto-handoff successor --host claude --thread <session id> --json`）。
+   記録を先までたどり、後継の session id が記録に無い時（受領を確かめられなかった引き継ぎ）は、transcript の名前から引く。
+6. 受領を確かめられなかった引き継ぎ（`unknown`）の記録も、後継の transcript が残っている間は、期限（24時間）で消さない。
+   消すと、旧い会話がまた道具を使えるようになり、同じ会話から2つ目の後継が立つ。
+
+## Consequences
+
+- 同じ project に Claude の会話が何本あっても、後継は自分の前任の記憶だけを受け取る。予約から止まるまでが何時間あっても同じ。
+- 同じ project で始まった別の新しい会話へ、引き継ぎ中の会話の記憶が入らない。
+- 自動継続が、利用者の `/tl` の印を上書きしない。
+- 引き継ぎの記録が消えた後（後継の transcript も無い時）に届いた継続の指示は、前任を引けず、記憶は入らない。
+- 旧い会話は、記録がある間、文を受ければ文で答える。道具は断る（変えていない）。旧い会話あての連絡を今の続きへ渡すのは、
+  連絡を運ぶ側の仕事で、5 の口で今の続きを引ける。
+- 記憶が入らなかった後継へ、後から記憶を入れる処理は無い。`throughline recall --session <旧い会話の id>` で引ける。

package/package.json

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

package/src/baton.mjs

@@ -113,3 +113,16 @@ export function consumeBaton(db, { projectPath, now = Date.now(), bornAt = now,
     throw err;
   }
 }
+
+/**
+ * ある会話を指している印を消す。自動継続の後継は、印ではなく引き継ぎ ID で前任を決める（ADR 0053）。
+ * 0.16.23 までの版が予約の時に書いた印が残っていると、同じ project の別の新しい会話がその前任を合流させるので、
+ * 後継が合流した時に消す。
+ *
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {{ sessionId: string }} params
+ * @returns {number} 消した行数
+ */
+export function discardBatonOf(db, { sessionId }) {
+  return Number(db.prepare('DELETE FROM handoff_batons WHERE session_id = ?').run(sessionId).changes);
+}

package/src/claude-auto-handoff.mjs

@@ -39,7 +39,6 @@ import {
 } from './transcript-reader.mjs';
 import { captureInFlightTurn } from './turn-backfill.mjs';
 import { resolveMergeTarget } from './session-merger.mjs';
-import { writeBaton } from './baton.mjs';
 import { sameProjectPath } from './project-path.mjs';
 import { runWithPty } from './os/pty-run.mjs';
 import { spawnPortable, spawnPortableSync } from './os/portable-spawn-sync.mjs';
@@ -69,6 +68,8 @@ const REMOTE_CONTROL_OVERRIDE_ENV = 'THROUGHLINE_AUTO_HANDOFF_REMOTE_CONTROL';
 const RETRYABLE_STATES = new Set(['requested', 'failed']);
 // 後継の最初の指示は、worker が後継の ID を記録へ写す前に届くことがある（launching）。
 const ACCEPTABLE_STATES = new Set(['launching', 'launched', 'sent', 'unknown']);
+/** 後継が立っている状態。 */
+const SUCCESSOR_STATES = new Set(['launched', 'sent', 'unknown']);
 
 export const claudeAutoHandoffDir = () => join(homedir(), '.throughline', 'claude-auto-handoff');
 // 0.15.2 までが受け口の控えを置いた場所。期限の掃除だけを続ける。
@@ -159,16 +160,36 @@ export function publicClaudeAutoHandoff(record) {
  * 後継の transcript は、Claude の projects の下の、後継を起動した project のフォルダに出来る。フォルダ名の付け方は
  * OS で違うので、旧い会話の transcript の場所から projects をたどり、その下のフォルダを順に見る。
  */
-function successorRemains(record) {
-  const successorId = record?.successor?.session_id;
-  if (record?.state !== 'sent' || !validSessionId(successorId) || typeof record.transcript_path !== 'string') return false;
-  const file = `${successorId}.jsonl`;
+/** Claude の projects の下から、後継の transcript を探して session id を返す。渡すのは session id か、その頭8字。 */
+function findSuccessorSessionId(record) {
+  const known = record?.successor?.session_id;
+  const prefix = validSessionId(known) ? known : record?.successor?.short_id;
+  if (typeof prefix !== 'string' || !/^[0-9a-f-]{8,}$/.test(prefix) || typeof record.transcript_path !== 'string') return null;
   const own = dirname(record.transcript_path);
-  if (existsSync(join(own, file))) return true;
+  const inFolder = folder => {
+    if (validSessionId(known)) return existsSync(join(folder, `${known}.jsonl`)) ? known : null;
+    let names;
+    try { names = readdirSync(folder); }
+    catch { return null; }
+    const file = names.find(name => name.startsWith(prefix) && name.endsWith('.jsonl'));
+    return file ? file.slice(0, -'.jsonl'.length) : null;
+  };
+  const found = inFolder(own);
+  if (found) return found;
   let folders;
   try { folders = readdirSync(dirname(own), { withFileTypes: true }); }
-  catch { return false; }
-  return folders.some(entry => entry.isDirectory() && existsSync(join(dirname(own), entry.name, file)));
+  catch { return null; }
+  for (const entry of folders) {
+    const id = entry.isDirectory() ? inFolder(join(dirname(own), entry.name)) : null;
+    if (id) return id;
+  }
+  return null;
+}
+
+function successorRemains(record) {
+  // 受領を確かめられなかった引き継ぎ（unknown）も、後継は立っている。記録を消すと、旧い会話からもう1つ後継が立つ。
+  if (!SUCCESSOR_STATES.has(record?.state)) return false;
+  return findSuccessorSessionId(record) !== null;
 }
 
 function removeStale(dir, now) {
@@ -200,6 +221,40 @@ function removeStale(dir, now) {
   }
 }
 
+/**
+ * ある会話の「今の続き」を引く（ほかの製品が、旧い会話あての連絡を今の続きへ渡すための入口）。読むだけ。
+ * 引き継ぎの記録を先までたどり、後継が立っている一番先の会話を返す。後継の session id が記録に無い時
+ * （受領を確かめられなかった引き継ぎ）は、transcript の名前から引く。引けなければ、そこで止まる。
+ * @returns {{
+ *   session_id: string, handed_off: boolean, current_session_id: string,
+ *   chain: Array<{handoff_id: string, source_session_id: string, successor_session_id: string|null, successor_short_id: string|null,
+ *     state: string, requested_at: number, updated_at: number}>,
+ *   pending: null | {handoff_id: string, source_session_id: string, state: string, error_code: string|null, requested_at: number, updated_at: number}
+ * }} current_session_id は、後継が無ければ session_id 自身。pending は、今の続きの会話にある、後継がまだ立っていない引き継ぎ
+ *   （requested: 予約だけで会話は止まっていない、launching: 後継を立てている所、failed: 後継は立たなかった）。
+ */
+export function resolveClaudeAutoHandoffSuccessor(sessionId, { dir = claudeAutoHandoffDir() } = {}) {
+  if (!validSessionId(sessionId)) throw new ClaudeHandoffError('auto_handoff_session_id_invalid');
+  const chain = [];
+  let current = sessionId;
+  let pending = null;
+  for (let depth = 0; depth < 200; depth++) {
+    const record = readClaudeAutoHandoff(current, dir);
+    if (!record) break;
+    if (!SUCCESSOR_STATES.has(record.state)) {
+      pending = { handoff_id: record.handoff_id, source_session_id: record.source_session_id, state: record.state,
+        error_code: record.error_code ?? null, requested_at: record.requested_at, updated_at: record.updated_at };
+      break;
+    }
+    const successorId = findSuccessorSessionId(record) ?? (validSessionId(record.successor?.session_id) ? record.successor.session_id : null);
+    chain.push({ handoff_id: record.handoff_id, source_session_id: record.source_session_id, successor_session_id: successorId,
+      successor_short_id: record.successor?.short_id ?? null, state: record.state, requested_at: record.requested_at, updated_at: record.updated_at });
+    if (!successorId || chain.some(step => step.source_session_id === successorId)) break;
+    current = successorId;
+  }
+  return { session_id: sessionId, handed_off: chain.length > 0, current_session_id: current, chain, pending };
+}
+
 /** script から起動した Claude（`claude -p`、Agent SDK）は、呼び出し元がその process の結果を待っている。止めない。 */
 function unsupportedEntrypoint(env) {
   return typeof env.CLAUDE_CODE_ENTRYPOINT === 'string' && env.CLAUDE_CODE_ENTRYPOINT.startsWith('sdk-');
@@ -333,7 +388,9 @@ export function requestClaudeAutoHandoff({
     return { status: 'skipped', block: false, reason: 'handoff_host_unsupported', sessionId, projectPath };
   }
 
-  // /tl と同じ印。後継の最初の指示が、この会話を前任として合流させる。
+  // 後継は、最初の指示が運ぶ引き継ぎ ID からこの記録を引いて、この会話を前任として合流させる（ADR 0053）。
+  // project ごとに1つしか無い `/tl` の印は書かない。印を書いてから後継が立つまでの間に、同じ project の別の会話が
+  // 印を消す・上書きする・取ることがあり、後継へ記憶が入らなかった（0.16.23、Windows で実測）。
   // 会話が別の project へ移っている時（Claude Desktop）は、sessions の project も移った先にそろえる。
   // 合流は前任と後継の project が同じ時だけ行う。付け替えは Stop でも行うが、移った後に1回も Stop を
   // 通らないまま引き継ぐ会話があり、その時は後継へ記憶が入らなかった（0.15.2・0.15.3、macOS で実測）。
@@ -341,7 +398,6 @@ export function requestClaudeAutoHandoff({
     open().prepare('UPDATE sessions SET project_path = ? WHERE session_id = ? AND project_path <> ?')
       .run(projectPath, sessionId, projectPath);
   }
-  writeBaton(open(), { projectPath, sessionId, now });
   mkdirSync(dir, { recursive: true, mode: 0o700 });
   removeStale(dir, now);
   const handoffId = randomUUID();
@@ -376,6 +432,23 @@ function readLatestModel(transcriptPath) {
   return null;
 }
 
+/** Claude Code の effort の値。 */
+const EFFORT_LEVELS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
+
+/**
+ * 止める時点の effort。transcript の最後の assistant 行（subagent の中の行は除く）から読む。
+ * hook の payload に effort が無い時の控え。読めなければ null（後継は、その端末の既定の effort で立つ）。
+ */
+function readLatestEffort(transcriptPath) {
+  const entries = readRawEntries(transcriptPath);
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const entry = entries[index];
+    if (entry?.type !== 'assistant' || entry.isSidechain) continue;
+    if (EFFORT_LEVELS.has(entry.effort)) return entry.effort;
+  }
+  return null;
+}
+
 /**
  * 止める会話の題。人が付けた題を先に読む（Claude Desktop の題と、`--name` で付いた後継の名前もこの行に入る）。
  * 無ければ Claude Code が付けた題を読む。
@@ -388,6 +461,8 @@ function readSessionTitle(transcriptPath) {
 }
 
 const CONTINUATION_MARKER = /Throughline自動継続 ([0-9a-f-]{36})/;
+/** 後継の最初の指示そのもの（文の頭にある時だけ）。会話の途中で引用された文は、配送として扱わない。 */
+const CONTINUATION_PREFIX = /^\s*Throughline自動継続 ([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?![0-9a-f-])/;
 
 // 後継へ渡す「このターンでここまでにしたこと」。1件の長さと件数を抑える。全文は取り込んだ details にある。
 const STEP_TEXT_MAX_CHARS = 300;
@@ -625,7 +700,24 @@ export function claudeContinuationInput(record) {
 }
 
 /**
- * 最初の UserPromptSubmit（baton の合流）から呼ぶ。前任がこの後継へ自動で引き継いだ会話なら、
+ * 最初の UserPromptSubmit から呼ぶ。届いた指示が自動継続の配送（文の頭が `Throughline自動継続 <引き継ぎID>`）なら、
+ * その引き継ぎの前任の session id を返す（ADR 0053）。記録が無い・後継が別の会話だと分かっている時は null。
+ * project ごとの印を使わないので、同じ project に会話が何本あっても、後継は自分の前任だけを合流させる。
+ *
+ * @returns {string|null}
+ */
+export function findClaudeAutoContinuationSource({ prompt, successorSessionId, dir = claudeAutoHandoffDir() }) {
+  if (typeof prompt !== 'string' || typeof successorSessionId !== 'string') return null;
+  const handoffId = CONTINUATION_PREFIX.exec(prompt)?.[1];
+  if (!handoffId) return null;
+  const record = listClaudeAutoHandoffs({ dir }).find(item => item.handoff_id === handoffId);
+  if (!record || !ACCEPTABLE_STATES.has(record.state) || record.source_session_id === successorSessionId) return null;
+  if (record.successor?.short_id && !successorSessionId.startsWith(record.successor.short_id)) return null;
+  return record.source_session_id;
+}
+
+/**
+ * 最初の UserPromptSubmit（前任の合流）から呼ぶ。前任がこの後継へ自動で引き継いだ会話なら、
  * 止めた時点の依頼を返す。届いた指示がこの引き継ぎの配送なら、受領を記録する。
  *
  * @returns {{handoffId: string, projectPath: string, inFlight: object|null, transcriptPath: string|null}|null}
@@ -711,7 +803,9 @@ export async function runClaudeAutoHandoffWorker(sessionId, {
   if (inFlight && openDb) inFlight.turn = captureStoppedTurn(record, openDb);
   update({
     state: 'launching',
-    settings: { ...record.settings, model: record.transcript_path ? readLatestModel(record.transcript_path) : null },
+    // モデルと effort は、止めた時点の物を後継へ渡す。effort は hook の payload の値を使い、無い時だけ transcript から読む。
+    settings: { ...record.settings, model: record.transcript_path ? readLatestModel(record.transcript_path) : null,
+      effort: record.settings?.effort ?? (record.transcript_path ? readLatestEffort(record.transcript_path) : null) },
     in_flight: inFlight,
   });
   const launch = remoteControl => spawn('claude', successorArgs(record, { remoteControl }), {

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

@@ -19,6 +19,8 @@ import {
   readFinishedTurnMark,
   requestClaudeDesktopOpen,
   runClaudeDesktopOpen,
+  findClaudeAutoContinuationSource,
+  resolveClaudeAutoHandoffSuccessor,
 } from './claude-auto-handoff.mjs';
 import { parseAutoHandoffArgs } from './cli/auto-handoff.mjs';
 
@@ -85,7 +87,6 @@ test('PreCompact: 会話が別の project へ移っている時は、移った
   assert.equal(result.block, true);
   assert.equal(result.projectPath, moved);
   assert.equal(readClaudeAutoHandoff(SESSION, dir).project_path, moved);
-  assert.equal(db.prepare('SELECT session_id FROM handoff_batons WHERE project_path = ?').get(moved).session_id, SESSION);
   assert.equal(db.prepare('SELECT project_path FROM sessions WHERE session_id = ?').get(SESSION).project_path, moved,
     '後継は同じ project の前任だけを合流させるので、sessions の project も移った先にそろえる');
 }));
@@ -117,8 +118,7 @@ test('PreCompact: CLAUDE_PROJECT_DIR が元の repository を指していても
   assert.equal(result.status, 'requested');
   assert.equal(result.projectPath, worktree, '後継は、前任が動いていた作業ツリーで立てる');
   assert.equal(readClaudeAutoHandoff(SESSION, dir).project_path, worktree);
-  assert.equal(db.prepare('SELECT session_id FROM handoff_batons WHERE project_path = ?').get(worktree).session_id, SESSION,
-    '印も作業ツリーに書く。後継は同じ project の前任だけを合流させる');
+  assert.equal(db.prepare('SELECT COUNT(*) AS c FROM handoff_batons').get().c, 0);
 
   // 有効かどうかも、登録した project で決める
   rmSync(join(dir, `${SESSION}.json`));
@@ -131,13 +131,13 @@ test('PreCompact: CLAUDE_PROJECT_DIR が元の repository を指していても
   assert.equal(request(dir, { db: registered(), ...adopted }).result.projectPath, repo);
 }));
 
-test('PreCompact: 自動圧縮で有効な時だけ、印と記録を残して圧縮を止める', () => withDir(dir => {
+test('PreCompact: 自動圧縮で有効な時だけ、記録を残して圧縮を止める。project ごとの印は書かない', () => withDir(dir => {
   const { result, db } = request(dir);
   assert.equal(result.status, 'requested');
   assert.equal(result.block, true);
   assert.equal(result.projectPath, '/work/app');
-  assert.deepEqual({ ...db.prepare('SELECT project_path, session_id, created_at FROM handoff_batons').get() },
-    { project_path: '/work/app', session_id: SESSION, created_at: 1_000 }, '/tl と同じ印');
+  // 後継は引き継ぎ ID で前任を引く（ADR 0053）。同じ project の別の会話が取れる印は残さない
+  assert.equal(db.prepare('SELECT COUNT(*) AS c FROM handoff_batons').get().c, 0);
   const record = readClaudeAutoHandoff(SESSION, dir);
   assert.equal(record.state, 'requested');
   assert.equal(record.handoff_id, result.handoffId);
@@ -145,7 +145,6 @@ test('PreCompact: 自動圧縮で有効な時だけ、印と記録を残して
   // 同じ圧縮で hook が2回届いても、同じ引き継ぎのまま止め続ける
   const again = request(dir, { db, now: 6_000 }).result;
   assert.deepEqual([again.status, again.block, again.handoffId], ['already_requested', true, result.handoffId]);
-  assert.equal(db.prepare('SELECT created_at FROM handoff_batons').get().created_at, 1_000);
 
   // 有効判定は会話を起動した project で行う（cwd は Bash の cd に追従する）
   rmSync(join(dir, `${SESSION}.json`));
@@ -164,7 +163,6 @@ test('PreCompact: Windows の `C:/…` の形の project は、後継が印を
   });
   assert.equal(result.status, 'requested');
   assert.equal(result.projectPath, 'C:\\Users\\k\\proj');
-  assert.equal(db.prepare('SELECT project_path FROM handoff_batons').get().project_path, 'C:\\Users\\k\\proj');
   assert.equal(readClaudeAutoHandoff(SESSION, dir).project_path, 'C:\\Users\\k\\proj');
 }));
 
@@ -224,20 +222,77 @@ test('PreCompact: 後継の会話が残っている引き継ぎの記録は、
   };
   const kept = 'aaaaaaaa-0000-4000-8000-000000000011', moved = 'aaaaaaaa-0000-4000-8000-000000000012';
   const gone = 'aaaaaaaa-0000-4000-8000-000000000013', unconfirmed = 'aaaaaaaa-0000-4000-8000-000000000014';
-  const failed = 'aaaaaaaa-0000-4000-8000-000000000015';
+  const failed = 'aaaaaaaa-0000-4000-8000-000000000015', unconfirmedAlive = 'aaaaaaaa-0000-4000-8000-000000000016';
   // 後継の transcript が、旧い会話と同じフォルダにある。別の project のフォルダにある（会話を移していた時）。
   writeFileSync(join(projects, '-work-app', `${record(kept)}.jsonl`), '');
   writeFileSync(join(projects, '-moved-app', `${record(moved)}.jsonl`), '');
-  // 後継が消されている。受領を確かめられなかった（後継の session id が無い）。立ち上げに失敗した。
+  // 受領を確かめられなかった（後継の session id が無い）が、後継の transcript は残っている。後継は動いているので、記録を消さない
+  record(unconfirmedAlive, { state: 'unknown', successor: { short_id: 'dddddddd', session_id: null } });
+  writeFileSync(join(projects, '-moved-app', 'dddddddd-0000-4000-8000-000000000016.jsonl'), '');
+  // 後継が消されている。受領を確かめられず、後継の transcript も無い。立ち上げに失敗した。
   record(gone);
-  record(unconfirmed, { state: 'unknown', successor: { short_id: 'bbbbbbbb', session_id: null } });
+  record(unconfirmed, { state: 'unknown', successor: { short_id: 'cccccccc', session_id: null } });
   writeFileSync(join(projects, '-work-app', `${record(failed, { state: 'failed' })}.jsonl`), '');
   request(dir, { now });
-  assert.deepEqual(readdirSync(dir).filter(name => name.endsWith('.json')).sort(), [`${SESSION}.json`, `${kept}.json`, `${moved}.json`].sort());
+  assert.deepEqual(readdirSync(dir).filter(name => name.endsWith('.json')).sort(),
+    [`${SESSION}.json`, `${kept}.json`, `${moved}.json`, `${unconfirmedAlive}.json`].sort());
   // 残した記録の会話は、圧縮と道具を止め続ける。同じ会話から2つ目の後継は立たない。
   assert.equal(request(dir, { now, payload: { session_id: kept } }).result.status, 'already_requested');
 }));
 
+test('後継の最初の指示: 文の頭の引き継ぎ ID から前任を引く。引用・別の会話・後継が立つ前の記録では引かない', () => withDir(dir => {
+  const handoffId = '11111111-2222-4333-8444-555555555555';
+  const write = fields => writeFileSync(join(dir, `${SESSION}.json`), JSON.stringify({ schema: 'throughline.claude-auto-handoff.v2',
+    handoff_id: handoffId, source_session_id: SESSION, project_path: '/work/app', state: 'launching', successor: null, ...fields }));
+  const prompt = claudeContinuationInput({ handoff_id: handoffId });
+  const find = (overrides = {}) => findClaudeAutoContinuationSource({ prompt, successorSessionId: SUCCESSOR, dir, ...overrides });
+
+  write({});
+  assert.equal(find(), SESSION, '後継の ID が記録へ入る前（launching）でも、引き継ぎ ID で引ける');
+  write({ state: 'unknown', successor: { short_id: SUCCESSOR.slice(0, 8), session_id: null } });
+  assert.equal(find(), SESSION, '受領を確かめられなかった後でも引ける');
+  assert.equal(find({ successorSessionId: 'ffffffff-0000-4000-8000-000000000001' }), null, '記録の後継と違う会話は、後継と認めない');
+  assert.equal(find({ successorSessionId: SESSION }), null, '前任自身は後継ではない');
+  assert.equal(find({ prompt: `この文は何？\n${prompt}` }), null, '会話の途中で引用された文は、配送として扱わない');
+  assert.equal(find({ prompt: prompt.replace(handoffId, '99999999-2222-4333-8444-555555555555') }), null, '記録に無い引き継ぎ ID');
+  assert.equal(find({ prompt: null }), null);
+  for (const state of ['requested', 'failed']) {
+    write({ state });
+    assert.equal(find(), null, `${state}: 後継が立っていない記録`);
+  }
+}));
+
+test('今の続き: 引き継ぎの記録を先までたどり、後継の ID が記録に無い時は transcript の名前から引く', () => withDir(dir => {
+  const projects = join(dir, 'claude', 'projects');
+  mkdirSync(join(projects, '-work-app'), { recursive: true }); mkdirSync(join(projects, '-work-app-wt'), { recursive: true });
+  const a = 'aaaaaaaa-0000-4000-8000-000000000021', b = 'bbbbbbbb-0000-4000-8000-000000000022', c = 'cccccccc-0000-4000-8000-000000000023';
+  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, '-work-app', `${id}.jsonl`),
+    requested_at: 1_000, updated_at: 2_000, error_code: null, ...fields }));
+  assert.deepEqual(resolveClaudeAutoHandoffSuccessor(a, { dir }),
+    { session_id: a, handed_off: false, current_session_id: a, chain: [], pending: null }, '記録が無い会話は、自分自身が今の続き');
+
+  // a → b（受領済み）→ c（受領を確かめられなかった。後継の transcript は別の project のフォルダにある）。c は引き継ぎを予約しただけ
+  record(a, { state: 'sent', successor: { short_id: 'bbbbbbbb', session_id: b } });
+  writeFileSync(join(projects, '-work-app', `${b}.jsonl`), '');
+  record(b, { state: 'unknown', error_code: 'handoff_delivery_unconfirmed', successor: { short_id: 'cccccccc', session_id: null } });
+  writeFileSync(join(projects, '-work-app-wt', `${c}.jsonl`), '');
+  record(c, { state: 'requested', successor: null });
+  const resolved = resolveClaudeAutoHandoffSuccessor(a, { dir });
+  assert.deepEqual([resolved.handed_off, resolved.current_session_id], [true, c]);
+  assert.deepEqual(resolved.chain.map(step => [step.source_session_id, step.successor_session_id, step.successor_short_id, step.state]),
+    [[a, b, 'bbbbbbbb', 'sent'], [b, c, 'cccccccc', 'unknown']]);
+  assert.deepEqual(resolved.pending, { handoff_id: 'h-cccccccc', source_session_id: c, state: 'requested', error_code: null, requested_at: 1_000, updated_at: 2_000 },
+    '予約だけの会話は、まだ止まっていない。今の続きはその会話のまま');
+  assert.equal(resolveClaudeAutoHandoffSuccessor(b, { dir }).current_session_id, c, '途中の会話から引いても同じ');
+
+  // 後継の transcript が見つからない時は、そこで止まる（分からない ID を作らない）
+  rmSync(join(projects, '-work-app-wt', `${c}.jsonl`));
+  const lost = resolveClaudeAutoHandoffSuccessor(a, { dir });
+  assert.deepEqual([lost.current_session_id, lost.chain.at(-1).successor_session_id, lost.chain.at(-1).successor_short_id], [b, null, 'cccccccc']);
+  assert.throws(() => resolveClaudeAutoHandoffSuccessor('../escape', { dir }), /auto_handoff_session_id_invalid/);
+}));
+
 test('PreToolUse: 記録のある会話の道具を実行させずに止め、止めた時点の依頼と設定を写して worker を1回だけ起動する', () => withDir(async dir => {
   const transcriptPath = join(dir, 'transcript.jsonl');
   writeFileSync(transcriptPath, jsonl([
@@ -297,13 +352,12 @@ test('PreToolUse: worker を起動できなければ failed にし、次の道
   assert.equal(readClaudeAutoHandoff(SESSION, dir).state, 'stopped');
 }));
 
-test('Stop: 圧縮を止めた後、道具を呼ばずにターンが終わったら記録を取り下げる（印は残す）', () => withDir(async dir => {
+test('Stop: 圧縮を止めた後、道具を呼ばずにターンが終わったら記録を取り下げる', () => withDir(async dir => {
   const { db } = request(dir);
   assert.equal(completeClaudeTurnWithoutHandoff({ sessionId: 'aaaaaaaa-0000-4000-8000-000000000009', dir }), false);
   assert.equal(completeClaudeTurnWithoutHandoff({ sessionId: `grok:${SESSION}`, dir }), false);
   assert.equal(completeClaudeTurnWithoutHandoff({ sessionId: SESSION, dir }), true);
   assert.equal(readClaudeAutoHandoff(SESSION, dir), null);
-  assert.equal(db.prepare('SELECT session_id FROM handoff_batons').get().session_id, SESSION);
 
   // 止めた後（worker が動いている）の記録は取り下げない
   request(dir);
@@ -337,6 +391,36 @@ const launchedOk = () => ({ status: 0, stdout: 'Starting background service…\n
 const successorStarts = (dir, predecessorId = SESSION) => args => acceptClaudeAutoContinuation({
   predecessorId, successorSessionId: SUCCESSOR, prompt: args.at(-1), dir, now: 5_000 });
 
+test('worker: hook の payload に effort が無い時は、止めた時点の effort を transcript から読んで後継へ渡す', () => withDir(async dir => {
+  const transcriptPath = join(dir, 'transcript.jsonl');
+  const turn = (text, timestamp, effort, extra = {}) => ({ ...assistant(text, timestamp, 'claude-opus-5-5'), effort, perTurnEffort: effort, ...extra });
+  writeFileSync(transcriptPath, jsonl([
+    user('設計を見直して', '2026-10-11T00:35:00Z'),
+    turn('見直します。', '2026-10-11T00:35:10Z', 'medium'),
+    // 利用者が途中で effort を上げた。subagent の中の行は、会話の effort ではない
+    turn('続けます。', '2026-10-11T00:40:00Z', 'xhigh'),
+    turn('調べます。', '2026-10-11T00:40:05Z', 'low', { isSidechain: true }),
+    { type: 'assistant', message: { role: 'assistant', model: 'claude-opus-5-5', content: [{ type: 'tool_use', id: 'toolu_3', name: 'Read', input: { file_path: '/work/app/a.txt' } }] } },
+  ]));
+  const launch = async payload => {
+    rmSync(join(dir, `${SESSION}.json`), { force: true }); rmSync(join(dir, `${SESSION}.claim`), { force: true });
+    request(dir, { transcriptPath });
+    await stopClaudeTurnForHandoff({ payload: { session_id: SESSION, cwd: '/work/app', transcript_path: transcriptPath, tool_use_id: 'toolu_3', ...payload },
+      dir, launchWorker: async () => {} });
+    const calls = [];
+    const record = await runClaudeAutoHandoffWorker(SESSION, { dir, env: { PATH: '/bin' }, acceptTimeoutMs: 50, pollMs: 10, transcriptTimeoutMs: 50,
+      spawn: (command, args) => { calls.push(args); return launchedOk(); } });
+    return { record, args: calls[0] };
+  };
+  const pick = args => ['--model', '--effort'].map(flag => args[args.indexOf(flag) + 1]);
+
+  const missing = await launch({});
+  assert.deepEqual(pick(missing.args), ['claude-opus-5-5', 'xhigh'], '最後の発言の effort（subagent の行は除く）');
+  assert.deepEqual([missing.record.settings.model, missing.record.settings.effort], ['claude-opus-5-5', 'xhigh']);
+  // payload に effort がある時は、その値を使う
+  assert.deepEqual(pick((await launch({ effort: { level: 'max' } })).args), ['claude-opus-5-5', 'max']);
+}));
+
 test('worker: 継続の指示を最初の指示として付けて後継を同じprojectに立て、後継の受領を待つ', () => withDir(async dir => {
   const { record, calls } = await runWorker(dir, { spawn: launchedOk, onLaunched: successorStarts(dir) });
   assert.equal(calls.spawn.length, 1);
@@ -1195,7 +1279,68 @@ test('hook: 自動圧縮を止め、次の道具を止めて worker を起動し
     [['manual', 'skipped', 'manual_compact'], ['auto', 'requested', null]]);
   assert.equal(decisions.filter(entry => entry.phase === 'pre-tool-use-stop').length, 1);
   const merged = decisions.find(entry => entry.phase === 'prompt-submit' && entry.merged);
-  assert.deepEqual([merged.triggered_path, merged.injection.auto_handoff_id], ['baton', record.handoff_id]);
+  assert.deepEqual([merged.triggered_path, merged.injection.auto_handoff_id], ['auto-handoff', record.handoff_id]);
+}));
+
+test('hook: 引き継ぎを予約してから止まるまでの間に、同じ project の別の会話が最初の指示を受けても、記憶は後継だけに入る', () => withDir(async home => {
+  // fox（Windows、0.16.23）で 2026-10-11 に起きた形。席の会話が 17:21 に引き継ぎを予約し、道具を使ったのは 19:43 だった。
+  // その間に、同じフォルダの別の会話が最初の指示を受けて project ごとの印を消し、後継へ記憶が1文字も入らなかった。
+  const project = join(home, 'project');
+  mkdirSync(project, { recursive: true });
+  const transcriptPath = join(home, 'transcript.jsonl');
+  const OTHER = 'cccccccc-1111-4222-8333-444444444444';
+  const extra = fakeClaudePath(home);
+  const hook = (command, payload, sessionId = SESSION) =>
+    cli(home, [command], JSON.stringify({ session_id: sessionId, cwd: project, transcript_path: transcriptPath, ...payload }), extra);
+
+  assert.equal(cli(home, ['auto-handoff', 'enable', '--host', 'claude', '--json']).status, 0);
+  assert.equal(hook('session-start', { hook_event_name: 'SessionStart', source: 'startup' }).status, 0);
+  writeFileSync(transcriptPath, jsonl([
+    user('Windows の席として、アプリを入れ直して', '2026-10-11T08:20:00Z'),
+    assistant('入れ直します。', '2026-10-11T08:20:02Z'),
+    toolUse('toolu_7', 'Bash', { command: 'echo reinstall' }),
+  ]));
+  assert.equal(hook('pre-compact', { hook_event_name: 'PreCompact', trigger: 'auto' }).status, 2);
+
+  // 同じ project で、別の役の新しい会話が始まり、最初の指示を受ける
+  const otherPayload = { session_id: OTHER, cwd: project, transcript_path: join(home, 'other.jsonl') };
+  assert.equal(cli(home, ['session-start'], JSON.stringify({ ...otherPayload, hook_event_name: 'SessionStart', source: 'startup' }), extra).status, 0);
+  const other = cli(home, ['prompt-submit'], JSON.stringify({ ...otherPayload, hook_event_name: 'UserPromptSubmit', prompt: 'Bot の仕事を続けて' }), extra);
+  assert.equal(other.status, 0, other.stderr);
+  assert.doesNotMatch(other.stdout, /Windows の席として/, '別の会話へ、席の会話の記憶を入れない');
+
+  // 席の会話が道具を使い、止まる。後継が立ち、最初の指示（継続の指示）を受ける
+  assert.equal(JSON.parse(hook('pre-tool-use', { hook_event_name: 'PreToolUse', tool_name: 'Bash', tool_use_id: 'toolu_7' }).stdout).continue, false);
+  const status = () => JSON.parse(cli(home, ['auto-handoff', 'status', '--host', 'claude', '--json']).stdout).handoffs;
+  for (let i = 0; i < 100 && status()[0].state !== 'failed'; i++) await new Promise(r => setTimeout(r, 100));
+  const recordFile = join(home, '.throughline', 'claude-auto-handoff', `${SESSION}.json`);
+  const record = JSON.parse(readFileSync(recordFile, 'utf8'));
+  writeFileSync(recordFile, JSON.stringify({ ...record, state: 'launched', error_code: null, successor: { short_id: SUCCESSOR.slice(0, 8), session_id: null } }));
+  const successorPayload = { session_id: SUCCESSOR, cwd: project, transcript_path: join(home, 'successor.jsonl') };
+  assert.equal(cli(home, ['session-start'], JSON.stringify({ ...successorPayload, hook_event_name: 'SessionStart', source: 'startup' }), extra).status, 0);
+  const first = cli(home, ['prompt-submit'], JSON.stringify({ ...successorPayload, hook_event_name: 'UserPromptSubmit',
+    prompt: claudeContinuationInput(record) }), extra);
+  assert.equal(first.status, 0, first.stderr);
+  assert.match(first.stdout, /^## Throughline: 自動継続の文脈\n/);
+  assert.match(first.stdout, /\*\*作業中のユーザー依頼\*\* \[\d\d:\d\d:\d\d\]: Windows の席として、アプリを入れ直して\n/);
+  assert.equal(existsSync(join(home, '.throughline', 'claude-auto-handoff', `${SESSION}.accepted`)), true, '最初の指示が受領を残す');
+
+  const db = new DatabaseSync(join(home, '.throughline', 'throughline.db'));
+  assert.equal(db.prepare('SELECT merged_into FROM sessions WHERE session_id = ?').get(SESSION).merged_into, SUCCESSOR);
+  assert.equal(db.prepare('SELECT COUNT(*) AS c FROM handoff_batons').get().c, 0);
+  db.close();
+  const decisions = readFileSync(join(home, '.throughline', 'logs', 'inheritance-decision.log'), 'utf8').trim().split('\n').map(JSON.parse)
+    .filter(entry => entry.phase === 'prompt-submit');
+  assert.deepEqual(decisions.map(entry => [entry.session_id, entry.triggered_path, entry.merged]),
+    [[OTHER, null, false], [SUCCESSOR, 'auto-handoff', true]]);
+
+  // 今の続きを引く口（ほかの製品が、旧い会話あての連絡を付け替える時に使う）
+  writeFileSync(join(home, 'successor.jsonl'), '');
+  const resolved = JSON.parse(cli(home, ['auto-handoff', 'successor', '--host', 'claude', '--thread', SESSION, '--json']).stdout);
+  assert.deepEqual([resolved.schema, resolved.host, resolved.session_id, resolved.handed_off], ['throughline.claude_auto_handoff_successor.v1', 'claude', SESSION, true]);
+  assert.equal(resolved.chain[0].successor_short_id, SUCCESSOR.slice(0, 8));
+  const missing = cli(home, ['auto-handoff', 'successor', '--host', 'claude', '--json']);
+  assert.deepEqual([missing.status, JSON.parse(missing.stdout)], [1, { status: 'failed', code: 'auto_handoff_thread_required' }]);
 }));
 
 test('hook: 作業ツリーの後継を Claude Desktop が取り込んだ後（CLAUDE_PROJECT_DIR は元の repository）に引き継いでも、後継は作業ツリーで立ち、記憶が入る', () => withDir(async home => {

package/src/cli/auto-handoff.mjs

@@ -10,11 +10,12 @@ import { installCodexAutoHandoffHook, installClaudeAutoHandoffHooks, removeClaud
   claudeAutoHandoffHooksRegistered } from './install.mjs';
 import { sameProjectPath } from '../project-path.mjs';
 import { readClaudeAutoHandoffConfig, writeClaudeAutoHandoffConfig } from '../claude-auto-handoff-config.mjs';
-import { listClaudeAutoHandoffs, publicClaudeAutoHandoff, runClaudeAutoHandoffWorker, runClaudeDesktopOpen } from '../claude-auto-handoff.mjs';
+import { listClaudeAutoHandoffs, publicClaudeAutoHandoff, resolveClaudeAutoHandoffSuccessor, runClaudeAutoHandoffWorker,
+  runClaudeDesktopOpen } from '../claude-auto-handoff.mjs';
 
 // Claude の自動継続 (ADR 0033)。引き継ぎの記録は旧い会話の session id で持つ。結果が不明な配送は
 // 再送しないので、resume は持たない。記憶の取得は通常の recall / detail を使うので、detail も持たない。
-const CLAUDE_ACTIONS = ['enable', 'disable', 'status', 'worker', 'desktop-open'];
+const CLAUDE_ACTIONS = ['enable', 'disable', 'status', 'worker', 'desktop-open', 'successor'];
 
 export function parseAutoHandoffArgs(args) {
   const out = { action: args[0] ?? 'status', host: 'codex', operation: null, project: null, origin: null, turn: null, database: null, thread: null, json: false, dryRun: false };
@@ -88,6 +89,10 @@ async function runClaude(parsed) {
   }
   if (parsed.action === 'worker') return publicClaudeAutoHandoff(await runClaudeAutoHandoffWorker(parsed.operation, { openDb: getDb }));
   if (parsed.action === 'desktop-open') return publicClaudeAutoHandoff(await runClaudeDesktopOpen(parsed.operation));
+  // ある会話の今の続きを返す。読むだけ（`--thread` には Claude の session id を渡す）。
+  if (parsed.action === 'successor') {
+    return { schema: 'throughline.claude_auto_handoff_successor.v1', host: 'claude', ...resolveClaudeAutoHandoffSuccessor(parsed.thread) };
+  }
   const handoffs = listClaudeAutoHandoffs()
     .filter(record => !parsed.project || sameProjectPath(record.project_path, parsed.project))
     .filter(record => !parsed.operation || record.handoff_id === parsed.operation || record.source_session_id === parsed.operation)

package/src/cli/install.mjs

@@ -250,15 +250,25 @@ function isSameExecutablePath(a, b, realpath) {
   return left !== null && right !== null && left === right;
 }
 
-function createCodexHooks() {
+// 登録済みの命令が今の node と script の実体を指している時は、その文字列のまま返す（ADR 0052）。
+// node の表記は入れる側の PATH で変わる。Codex は hook の信用を命令の文字列で決めるので、表記だけを書き換えると
+// 信用済みの hook が「変わった hook」になり、新しい会話が確認の画面で止まる。
+function registeredCodexHookCommand(expected, groups) {
+  const registered = (Array.isArray(groups) ? groups : []).flatMap(group => group?.hooks ?? []).map(hook => hook?.command)
+    .find(command => isEquivalentCodexHookCommand(command, expected));
+  return registered ?? expected;
+}
+
+function createCodexHooks(registered = {}) {
+  const command = (event, expected) => registeredCodexHookCommand(expected, registered?.[event]);
   return {
-    PreCompact: { matcher: 'auto', hooks: [{ type: 'command', command: buildCodexPreCompactHookCommand(),
+    PreCompact: { matcher: 'auto', hooks: [{ type: 'command', command: command('PreCompact', buildCodexPreCompactHookCommand()),
       timeout: 30, async: false, statusMessage: 'Throughline: 自動継続を準備' }] },
     UserPromptSubmit: {
       hooks: [
         {
           type: 'command',
-          command: buildCodexUserPromptSubmitHookCommand(),
+          command: command('UserPromptSubmit', buildCodexUserPromptSubmitHookCommand()),
           timeout: 30,
           async: false,
           statusMessage: null,
@@ -269,7 +279,7 @@ function createCodexHooks() {
       hooks: [
         {
           type: 'command',
-          command: buildCodexPostToolUseHookCommand(),
+          command: command('PostToolUse', buildCodexPostToolUseHookCommand()),
           timeout: 30,
           async: false,
           statusMessage: null,
@@ -280,7 +290,7 @@ function createCodexHooks() {
       hooks: [
         {
           type: 'command',
-          command: buildCodexStopHookCommand(),
+          command: command('Stop', buildCodexStopHookCommand()),
           timeout: 300,
           async: false,
           statusMessage: null,
@@ -628,7 +638,7 @@ function installCodexHooks() {
   const configPath = resolveCodexConfigPath();
   const current = readSettings(hooksPath);
   const existingHooks = current.hooks ?? {};
-  const codexHooks = createCodexHooks();
+  const codexHooks = createCodexHooks(existingHooks);
 
   for (const [key, entry] of Object.entries(codexHooks)) {
     const list = existingHooks[key] ?? [];
@@ -705,7 +715,7 @@ export function installCodexAutoHandoffHook(codexHome = join(homedir(), '.codex'
   const configPath = join(codexHome, 'config.toml');
   const current = readSettings(hooksPath);
   current.hooks ??= {};
-  const entry = createCodexHooks().PreCompact;
+  const entry = createCodexHooks(current.hooks).PreCompact;
   const groups = current.hooks.PreCompact ?? [];
   const existing = groups.flatMap(group => group.hooks ?? []).filter(hook => isThroughlineCodexHookCommand(hook.command));
   if (existing.length !== 1 || existing[0].command !== entry.hooks[0].command || existing[0].timeout !== 30) {

package/src/cli/install.test.mjs

@@ -1,17 +1,19 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { mkdtempSync, rmSync, existsSync, readFileSync, writeFileSync, mkdirSync, symlinkSync, realpathSync } from 'node:fs';
 import { tmpdir, homedir } from 'node:os';
 import { join } from 'node:path';
 
 import {
   buildCodexPostToolUseHookCommand,
+  buildCodexPreCompactHookCommand,
   buildCodexStopHookCommand,
   buildCodexUserPromptSubmitHookCommand,
   buildCursorHookCommand,
   buildGrokHookCommand,
   createGrokHooksFile,
   createCursorHookEntries,
+  installCodexAutoHandoffHook,
   isEquivalentCodexHookCommand,
   isThroughlineCodexHookCommand,
   isThroughlineCursorHookCommand,
@@ -855,3 +857,94 @@ test('install is idempotent: second run keeps exactly one tl.md and one hook ent
     home.restore();
   }
 });
+
+// 今の node を指す、別の表記。POSIX は symlink、Windows は大文字と小文字を入れ替えた path（どちらも realpath が同じになる）。
+function alternateNodeSpelling(dir) {
+  if (process.platform === 'win32') {
+    const upper = process.execPath.toUpperCase();
+    return upper !== process.execPath ? upper : process.execPath.toLowerCase();
+  }
+  mkdirSync(join(dir, 'altbin'), { recursive: true });
+  const link = join(dir, 'altbin', 'node');
+  symlinkSync(realpathSync.native(process.execPath), link);
+  return link;
+}
+
+test('install は、今の node を指す登録済みの Codex hook の命令を書き換えない（Codex の信用を保つ）', async () => {
+  const home = makeTempHome();
+  if (home.resolved !== home.dir) {
+    home.restore();
+    return;
+  }
+  const unsilence = silence();
+  try {
+    const hooksPath = join(home.dir, '.codex', 'hooks.json');
+    await run([]);
+    const nodePath = alternateNodeSpelling(home.dir);
+    const registered = {
+      PreCompact: buildCodexPreCompactHookCommand({ nodePath }),
+      UserPromptSubmit: buildCodexUserPromptSubmitHookCommand({ nodePath }),
+      PostToolUse: buildCodexPostToolUseHookCommand({ nodePath }),
+      Stop: buildCodexStopHookCommand({ nodePath }),
+    };
+    assert.notEqual(registered.Stop, buildCodexStopHookCommand({ nodePath: process.execPath }));
+    // ほかの PATH から入れた時の登録を作る。node の表記だけが違い、指す実体は同じ。
+    const file = JSON.parse(readFileSync(hooksPath, 'utf8'));
+    for (const [event, command] of Object.entries(registered)) {
+      const own = file.hooks[event].flatMap(group => group.hooks).filter(hook => isThroughlineCodexHookCommand(hook.command));
+      assert.equal(own.length, 1);
+      own[0].command = command;
+    }
+    file.hooks.Stop.push({ hooks: [{ type: 'command', command: '/usr/bin/node /opt/other/bin/other codex-hook stop', timeout: 5 }] });
+    const before = JSON.stringify(file, null, 2) + '\n';
+    writeFileSync(hooksPath, before);
+
+    await run([]);
+    assert.equal(readFileSync(hooksPath, 'utf8'), before);
+    const autoHandoff = installCodexAutoHandoffHook(join(home.dir, '.codex'));
+    assert.equal(autoHandoff.command, registered.PreCompact);
+    assert.equal(readFileSync(hooksPath, 'utf8'), before);
+
+    // 登録済みの node が今の node でない時は、今までどおり書き直す。
+    const moved = JSON.parse(before);
+    moved.hooks.Stop[0].hooks[0].command = buildCodexStopHookCommand({ nodePath: join(home.dir, 'gone', 'node') });
+    writeFileSync(hooksPath, JSON.stringify(moved, null, 2) + '\n');
+    await run([]);
+    const after = JSON.parse(readFileSync(hooksPath, 'utf8'));
+    assert.equal(after.hooks.Stop[0].hooks[0].command, buildCodexStopHookCommand());
+    assert.equal(after.hooks.UserPromptSubmit[0].hooks[0].command, registered.UserPromptSubmit);
+    assert.equal(after.hooks.PostToolUse[0].hooks[0].command, registered.PostToolUse);
+    assert.equal(after.hooks.PreCompact.at(-1).hooks[0].command, registered.PreCompact);
+  } finally {
+    unsilence();
+    home.restore();
+  }
+});
+
+test('install は、入れる側の PATH が変わっても Codex hook の命令を変えない', { skip: process.platform === 'win32' }, async () => {
+  const home = makeTempHome();
+  if (home.resolved !== home.dir) {
+    home.restore();
+    return;
+  }
+  const originalPath = process.env.PATH;
+  const unsilence = silence();
+  try {
+    const hooksPath = join(home.dir, '.codex', 'hooks.json');
+    const nodePath = alternateNodeSpelling(home.dir);
+    // node の symlink がある場所を PATH の先頭に置いて入れ、次は PATH に node が無い状態で入れる。
+    process.env.PATH = join(home.dir, 'altbin');
+    await run([]);
+    const first = readFileSync(hooksPath, 'utf8');
+    assert.equal(JSON.parse(first).hooks.Stop[0].hooks[0].command, buildCodexStopHookCommand({ nodePath }));
+    process.env.PATH = '';
+    assert.notEqual(buildCodexStopHookCommand(), buildCodexStopHookCommand({ nodePath }));
+    await run([]);
+    assert.equal(readFileSync(hooksPath, 'utf8'), first);
+  } finally {
+    if (originalPath === undefined) delete process.env.PATH;
+    else process.env.PATH = originalPath;
+    unsilence();
+    home.restore();
+  }
+});

package/src/handoff-executor.mjs

@@ -2,7 +2,7 @@
  * handoff-executor.mjs — 最初の UserPromptSubmit で実行する引き継ぎ本体
  *
  * 二相ハンドオフ (ADR 0014) の第二相。SessionStart が登録した pending intent を
- * 消費し、baton path 優先 → auto path の順で前任を merge して、予算内の
+ * 消費し、自動継続の配送 (ADR 0053) → baton path → auto path の順で前任を merge して、予算内の
  * resume context を組み立てて返す。呼び出し元 (prompt-submit) が stdout へ書く。
  *
  * 幽霊セッション (transcript を生成しない SessionStart) はプロンプトを発火しない
@@ -11,12 +11,12 @@
  */
 
 import { existsSync } from 'node:fs';
-import { consumeBaton } from './baton.mjs';
+import { consumeBaton, discardBatonOf } from './baton.mjs';
 import { consumePendingHandoff } from './pending-handoff.mjs';
 import { mergeSpecificPredecessor, resolveMergeTarget } from './session-merger.mjs';
 import { backfillBodies, deriveTranscriptPath, logBackfill } from './turn-backfill.mjs';
 import { buildBudgetedResumeContext, buildAutoContinuationContext } from './resume-context.mjs';
-import { acceptClaudeAutoContinuation } from './claude-auto-handoff.mjs';
+import { acceptClaudeAutoContinuation, findClaudeAutoContinuationSource } from './claude-auto-handoff.mjs';
 import { readAllSessionStates } from './state-file.mjs';
 
 /**
@@ -25,7 +25,7 @@ import { readAllSessionStates } from './state-file.mjs';
  *   prompt は届いた指示の本文。前任が自動継続で引き継いだ会話の時に、配送の受領を照合する (ADR 0033)。
  * @returns {{
  *   attempted: boolean,            // pending 行が存在した (= newborn の初回プロンプト)
- *   triggeredPath: 'baton' | 'auto' | null,
+ *   triggeredPath: 'auto-handoff' | 'baton' | 'auto' | null,  // auto-handoff は自動継続の後継 (ADR 0053)
  *   baton: object | null,          // consumeBaton の生返り値 (ログ用)
  *   pendingCreatedAt: number | null,
  *   mergeResult: object,           // mergeSpecificPredecessor の返り値 or skip
@@ -47,14 +47,26 @@ export function executeFirstPromptHandoff(db, { sessionId, projectPath, now = Da
     };
   }
 
+  // 自動継続の後継は、最初の指示が運ぶ引き継ぎ ID で前任を決める (ADR 0053)。project ごとに1つの印は見ない
+  // (同じ project の別の会話のための印を、後継が取らない)。
+  const continuationSourceId = findClaudeAutoContinuationSource({ prompt, successorSessionId: sessionId });
   // baton 適格性はセッション誕生時刻 (pending.createdAt) 基準。
   // 誕生後に書かれたバトンは future_baton として残置される (本来の後継のもの)。
-  const baton = consumeBaton(db, { projectPath, now, bornAt: pending.createdAt });
+  const baton = continuationSourceId ? null : consumeBaton(db, { projectPath, now, bornAt: pending.createdAt });
 
   let triggeredPath = null;
   let mergeResult = { merged: false, skipReason: 'no_trigger' };
 
-  if (baton.sessionId) {
+  if (continuationSourceId) {
+    triggeredPath = 'auto-handoff';
+    discardBatonOf(db, { sessionId: continuationSourceId });
+    const { target: predecessorId } = resolveMergeTarget(db, continuationSourceId);
+    mergeResult = mergeSpecificPredecessor(db, {
+      newSessionId: sessionId,
+      predecessorId,
+      now,
+    });
+  } else if (baton.sessionId) {
     triggeredPath = 'baton';
     const { target: predecessorId } = resolveMergeTarget(db, baton.sessionId);
     mergeResult = mergeSpecificPredecessor(db, {
@@ -87,8 +99,8 @@ export function executeFirstPromptHandoff(db, { sessionId, projectPath, now = Da
     // 前任が自動継続でこの会話へ引き継いだなら、止めた時点の依頼を現在地に載せる (ADR 0033)。
     // 止めたターンは Stop を通っていないので、state ファイルが無いことがある。hook が記録した
     // transcript の場所を、回収元の候補に足す。
-    const autoContinuation = triggeredPath === 'baton'
-      ? acceptClaudeAutoContinuation({ predecessorId: baton.sessionId, successorSessionId: sessionId, prompt, now })
+    const autoContinuation = triggeredPath === 'auto-handoff' || triggeredPath === 'baton'
+      ? acceptClaudeAutoContinuation({ predecessorId: continuationSourceId ?? baton.sessionId, successorSessionId: sessionId, prompt, now })
       : null;
     const predecessorTranscriptPath = [derivedTranscriptPath, stateTranscriptPath, autoContinuation?.transcriptPath]
       .find((candidate) => candidate && existsSync(candidate)) ?? null;