throughline 0.16.14 → 0.16.16

package/CHANGELOG.md

@@ -10,6 +10,57 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.16] — 2026-10-10
+
+### 追加
+
+- Claude Desktopから始まった会話の後継を、リモートコントロール付き（`--remote-control=<後継の名前>`）で立てる。後継は裏の会話で、ターンを終えるまでClaude Desktopの一覧に出ない。作業の最中も、claude.ai/codeとClaudeのアプリから様子を見て操作できる（[ADR 0048](docs/adr/0048-claude-desktop-origin-successor-has-remote-control.md)）。
+  - 端末から始めた会話の後継には付けない。後継がさらに引き継ぐ時は、元の会話の出どころを引き継ぐ。
+  - 付けて立てるのに失敗した時は、付けずに1回だけ立て直す。引き継ぎは止めない。
+  - `auto-handoff status --host claude --json`の`remote_control_state`で読める（`requested`: 付けて立てた、`unavailable`: 付けずに立て直した、`null`: 対象外）。
+  - 環境変数`THROUGHLINE_AUTO_HANDOFF_REMOTE_CONTROL`で上書きできる（`on`・`off`）。
+
+### 対応の範囲
+
+| | macOS | Linux | Windows |
+|---|---|---|---|
+| Claude Code | 追加した。試験用フォルダで、本物のworkerが後継をリモートコントロール付きで立て、transcriptにリモートのURLが入った（Claude Code 2.1.289、画面のあるsessionの端末）。sshから立てた時は、後継は立つがURLが入らなかった | 追加した。同じ確かめでURLが入った（2.1.296）。信頼していないフォルダでは、付けずに立て直す所まで動き、どちらも`Workspace not trusted`で立たなかった（今までと同じ） | 追加した。同じ確かめでURLが入った（2.1.296） |
+| Codex | 対象外。リモートコントロールはClaude Codeの機能 | 同じ | 同じ |
+| Grok | 対象外。同じ理由。自動継続の機能も無い | 同じ | 同じ |
+| Cursor | 対象外。同じ理由。自動継続の機能も無い | 同じ | 同じ |
+
+### 変わらない事
+
+- 後継がターンを終えた時にClaude Desktopへ移して開く動き。端末から始めた会話の引き継ぎ。
+
+### 確認していない範囲
+
+- claude.ai/codeとClaudeのアプリの側で、後継が見えて操作できる所（確かめたのは、後継のtranscriptにリモートのURLが入った事まで）。
+- Claude Desktopの会話の、本物の引き継ぎでの動き（試験は、端末から始めた会話にDesktopの印を付けて流した）。
+- リモートコントロールが使えない状態（未ログインなど）での実物の動き（試験では作り物の失敗で、付けずに立て直す事を確かめた）。
+
+## [0.16.15] — 2026-10-10
+
+### 追加
+
+- `throughline auto-handoff successor --thread <Codexの会話のID> --json`。あるCodexのタスクの「今の続き」を返す、読むだけの入口。ほかの製品が、旧タスクあての連絡を今の続きへ渡す時に使う。`auto-handoff status --json`は新しい20件だけを返すので、古い引き継ぎの続きを引けなかった。
+  - 返す物: `handed_off`（残っている後継があるか）、`current_thread_id`（引き継ぎを先までたどった、残っている一番先の後継。無ければ渡したID自身）、`chain`（そこまでの引き継ぎ）、`pending`（今の続きのタスクで、後継へ指示を送る前の引き継ぎ。`in_flight`がtrueならworkerが動いている最中、falseなら止まっていて`error_code`と`resume_state`が入る）。
+  - 消された後継とアーカイブ済みの後継は、無い物として扱う（旧タスクへ入力が来た時に開く後継と同じ決め方）。
+  - 記録が無い端末では、引き継ぎが1つも無い時と同じ答えを返す。記録は読み取り専用で開く。
+
+### 対応の範囲
+
+| | macOS | Linux | Windows |
+|---|---|---|---|
+| Codex（Desktop） | 追加した。実機の記録で確認（引き継ぎ済みのタスク2つから今の続きが返り、引き継ぎの無いタスクは自分自身が返った） | 追加した。実機の記録で確認（後継がアーカイブ済みの系列は、旧タスク自身が返った） | 追加した。実機の記録で確認（16本続いた系列の最初と途中から、同じ今の続きが返った。止まったタスクは`pending`に理由が出た） |
+| Claude Code | 対象外。Claude Codeの自動継続の記録は別の形で、`auto-handoff status --host claude --json`が全件を返す | 同じ | 同じ |
+| Grok | 対象外。自動継続の機能が無い | 同じ | 同じ |
+| Cursor | 対象外。自動継続の機能が無い | 同じ | 同じ |
+
+### 変わらない事
+
+- 引き継ぎの動き。`auto-handoff status --json`の出力。
+
 ## [0.16.14] — 2026-10-10
 
 ### 修正
@@ -2195,7 +2246,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.14...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.16...HEAD
+[0.16.16]: https://github.com/kitepon/Throughline/compare/v0.16.15...v0.16.16
+[0.16.15]: https://github.com/kitepon/Throughline/compare/v0.16.14...v0.16.15
 [0.16.14]: https://github.com/kitepon/Throughline/compare/v0.16.13...v0.16.14
 [0.16.13]: https://github.com/kitepon/Throughline/compare/v0.16.12...v0.16.13
 [0.16.12]: https://github.com/kitepon/Throughline/compare/v0.16.11...v0.16.12

package/README.ja.md

@@ -40,6 +40,14 @@ throughline auto-handoff status --operation <handoff-id> --json
 throughline auto-handoff resume --operation <handoff-id> --json
 ```
 
+あるタスクの今の続きは、次の命令で引けます（読むだけ。ほかの道具が、旧タスクあての連絡を今の続きへ渡す時に使います）。
+
+```bash
+throughline auto-handoff successor --thread <codex-thread-id> --json
+```
+
+`current_thread_id`が今の続きです（後継が無ければ渡したID自身）。`pending.in_flight`がtrueの間は、引き継ぎの途中です。
+
 原因を解消した後の`resume`は同じ引き継ぎと既知の後継を再利用します。配送後の結果不明は実際の入力・開始を観測した場合だけ回復し、作成結果が不明な後継は再作成しません。従来の手動`$throughline`とcurrent-thread実験の設定は独立しています。
 
 [実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-03-codex-auto-continuation.md)、[Windowsの実測](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-08-windows-codex-auto-handoff.md)、[Linuxの実測](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-08-linux-codex-auto-handoff.md)を参照してください。
@@ -61,7 +69,7 @@ throughline auto-handoff disable --host claude
 3. 同じprojectに、継続の指示を最初の指示として付けた新しいClaudeの会話を裏で立てます（`claude --bg`）。会話の名前は、前任の会話の題から`<project名>｜<作業の概要>（自動引き継ぎ）`にします。モデル・推論強度・権限は旧い会話から引き継ぎます。
 4. 最初の指示を受け取った時に、止めた時点の依頼、そのターンでここまでにしたこと（発言と道具の呼び出し）、実行されなかった道具、直近の会話の原文を注入します（上限9,500字）。止めたターンの道具の入出力は、後継が`throughline detail`で取り出せます。
 
-続きは裏の会話で動きます。`claude agents`の一覧と`claude attach <id>`で見られます。Claude Desktopの画面から始まった会話の後継は、そのターンの作業を終えた時に、Claude Desktopへ移して開きます（macOSは0.16.8から、Windowsは0.16.9から。LinuxのClaude Codeには`--desktop`が無いので開きません。[ADR 0043](docs/adr/0043-claude-successor-opens-in-desktop.md)）。Claude Codeは裏で動いている会話をDesktopへ移さないので、作業の間はDesktopには出ません。続けて引き継いだ時は、最後に作業を終えた後継だけを開きます。端末から始めた会話の後継は開きません。手で開く時は、`claude stop <id>`で裏の実行を停止し、`claude --desktop --resume <session-id>`を実行します。`session-id`は`claude agents --json --all`の`sessionId`です。環境変数`THROUGHLINE_AUTO_HANDOFF_OPEN`を`desktop`にすると出どころに関係なく開き、`off`にすると開きません。手動`/compact`、subagentの中の圧縮、`claude -p`などscriptから起動した会話は対象に含めません。
+続きは裏の会話で動きます。`claude agents`の一覧と`claude attach <id>`で見られます。Claude Desktopの画面から始まった会話の後継は、そのターンの作業を終えた時に、Claude Desktopへ移して開きます（macOSは0.16.8から、Windowsは0.16.9から。LinuxのClaude Codeには`--desktop`が無いので開きません。[ADR 0043](docs/adr/0043-claude-successor-opens-in-desktop.md)）。Claude Codeは裏で動いている会話をDesktopへ移さないので、作業の間はDesktopには出ません。続けて引き継いだ時は、最後に作業を終えた後継だけを開きます。端末から始めた会話の後継は開きません。手で開く時は、`claude stop <id>`で裏の実行を停止し、`claude --desktop --resume <session-id>`を実行します。`session-id`は`claude agents --json --all`の`sessionId`です。環境変数`THROUGHLINE_AUTO_HANDOFF_OPEN`を`desktop`にすると出どころに関係なく開き、`off`にすると開きません。手動`/compact`、subagentの中の圧縮、`claude -p`などscriptから起動した会話は対象に含めません。 Claude Desktopから始まった会話の後継は、リモートコントロール付きで立てるので、作業の最中もclaude.ai/codeとClaudeのアプリから見られます（0.16.16から。[ADR 0048](docs/adr/0048-claude-desktop-origin-successor-has-remote-control.md)）。
 
 ```bash
 throughline auto-handoff status --host claude --operation <handoff-id> --json

package/README.md

@@ -39,6 +39,14 @@ throughline auto-handoff status --operation <handoff-id> --json
 throughline auto-handoff resume --operation <handoff-id> --json
 ```
 
+あるタスクの今の続きは、次の命令で引けます（読むだけ。ほかの道具が、旧タスクあての連絡を今の続きへ渡す時に使います）。
+
+```bash
+throughline auto-handoff successor --thread <codex-thread-id> --json
+```
+
+`current_thread_id`が今の続きです（後継が無ければ渡したID自身）。`pending.in_flight`がtrueの間は、引き継ぎの途中です。
+
 原因を解消した後の`resume`は同じ引き継ぎと既知の後継を再利用します。配送後の結果不明は実際の入力・開始を観測した場合だけ回復し、作成結果が不明な後継は再作成しません。従来の手動`$throughline`とcurrent-thread実験の設定は独立しています。
 
 [実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-03-codex-auto-continuation.md)、[Windowsの実測](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-08-windows-codex-auto-handoff.md)、[Linuxの実測](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-08-linux-codex-auto-handoff.md)を参照してください。
@@ -60,7 +68,7 @@ throughline auto-handoff disable --host claude
 3. 同じprojectに、継続の指示を最初の指示として付けた新しいClaudeの会話を裏で立てます（`claude --bg`）。会話の名前は、前任の会話の題から`<project名>｜<作業の概要>（自動引き継ぎ）`にします。モデル・推論強度・権限は旧い会話から引き継ぎます。
 4. 最初の指示を受け取った時に、止めた時点の依頼、そのターンでここまでにしたこと（発言と道具の呼び出し）、実行されなかった道具、直近の会話の原文を注入します（上限9,500字）。止めたターンの道具の入出力は、後継が`throughline detail`で取り出せます。
 
-続きは裏の会話で動きます。`claude agents`の一覧と`claude attach <id>`で見られます。Claude Desktopの画面から始まった会話の後継は、そのターンの作業を終えた時に、Claude Desktopへ移して開きます（macOSは0.16.8から、Windowsは0.16.9から。LinuxのClaude Codeには`--desktop`が無いので開きません。[ADR 0043](docs/adr/0043-claude-successor-opens-in-desktop.md)）。Claude Codeは裏で動いている会話をDesktopへ移さないので、作業の間はDesktopには出ません。続けて引き継いだ時は、最後に作業を終えた後継だけを開きます。端末から始めた会話の後継は開きません。手で開く時は、`claude stop <id>`で裏の実行を停止し、`claude --desktop --resume <session-id>`を実行します。`session-id`は`claude agents --json --all`の`sessionId`です。環境変数`THROUGHLINE_AUTO_HANDOFF_OPEN`を`desktop`にすると出どころに関係なく開き、`off`にすると開きません。手動`/compact`、subagentの中の圧縮、`claude -p`などscriptから起動した会話は対象に含めません。
+続きは裏の会話で動きます。`claude agents`の一覧と`claude attach <id>`で見られます。Claude Desktopの画面から始まった会話の後継は、そのターンの作業を終えた時に、Claude Desktopへ移して開きます（macOSは0.16.8から、Windowsは0.16.9から。LinuxのClaude Codeには`--desktop`が無いので開きません。[ADR 0043](docs/adr/0043-claude-successor-opens-in-desktop.md)）。Claude Codeは裏で動いている会話をDesktopへ移さないので、作業の間はDesktopには出ません。続けて引き継いだ時は、最後に作業を終えた後継だけを開きます。端末から始めた会話の後継は開きません。手で開く時は、`claude stop <id>`で裏の実行を停止し、`claude --desktop --resume <session-id>`を実行します。`session-id`は`claude agents --json --all`の`sessionId`です。環境変数`THROUGHLINE_AUTO_HANDOFF_OPEN`を`desktop`にすると出どころに関係なく開き、`off`にすると開きません。手動`/compact`、subagentの中の圧縮、`claude -p`などscriptから起動した会話は対象に含めません。 Claude Desktopから始まった会話の後継は、リモートコントロール付きで立てるので、作業の最中もclaude.ai/codeとClaudeのアプリから見られます（0.16.16から。[ADR 0048](docs/adr/0048-claude-desktop-origin-successor-has-remote-control.md)）。
 
 ```bash
 throughline auto-handoff status --host claude --operation <handoff-id> --json

package/bin/throughline.mjs

@@ -412,6 +412,8 @@ Usage:
                               引き継ぎの状態と固定理由を確認
   throughline auto-handoff resume --operation <id> --json
                               同じ引き継ぎを再開（結果不明は再送しない）
+  throughline auto-handoff successor --thread <codex-thread-id> --json
+                              あるCodexのタスクの今の続きを返す（読むだけ）
   throughline auto-handoff mark-sources [--dry-run] [--json]
                               今までの引き継ぎの名前を付け直す（旧タスクへ印、
                               名前の無い後継へ名前）

package/docs/adr/0048-claude-desktop-origin-successor-has-remote-control.md

@@ -0,0 +1,47 @@
+# ADR 0048: Claude Desktop から始まった会話の後継は、リモートコントロール付きで立てる
+
+日付: 2026-10-10
+
+## Context
+
+Claude Code の自動継続は、後継を `claude --bg`（裏の会話）で立てる（ADR 0033）。Claude Desktop から始まった会話の後継は、
+ターンを終えた時に Desktop へ移して開く（ADR 0043）。動いている最中の裏の会話は Desktop へ移せないので、後継が作業している間は、
+Desktop の一覧に何も出ない。
+
+2026-10-10、Windows の実機で、本物の会話の最初の引き継ぎが起きた（Claude Desktop の会話、約 96.8 万トークン）。引き継ぎは成功したが、
+後継は裏で作業を続け、オーナーには状況が見えなかった（「スルーラインは発動したのか？状況がわからん」「リモートコントロールは有効に
+なっているのかな」）。旧い会話は Desktop の会話で、リモートの接続の記録があった。後継には無かった。Throughline が後継を立てる時に、
+リモートコントロールの指定を付けていなかった。
+
+Claude Code には `--remote-control [name]` がある。付けて立てた会話は、claude.ai/code と Claude のアプリから見て操作できる。
+実機で確かめた事（試験用フォルダ、Haiku）:
+
+- `claude --bg --name=<名前> --remote-control=<名前> …` は、Windows・Linux（Claude Code 2.1.296）と macOS（2.1.289）で通る。
+  立った会話は裏の会話（`kind: background`）で、transcript の `remote_session_change` にリモートの URL が入る。
+- 名前は `=` の形で渡す。名前を省ける option なので、離して書くと次の引数を名前として読む。
+- macOS で ssh から立てた時は、指定は通り会話も立つが、URL が入らなかった。画面のある session の端末からは入った。
+  本物の引き継ぎの worker は Claude Desktop の下で動く。
+- 信頼していないフォルダでは、リモートコントロールの有無に関係なく `Workspace not trusted` で立たない。
+
+## Decision
+
+1. Claude Desktop から始まった会話の後継と、その後継がさらに引き継ぐ時の後継を、`--remote-control=<後継の名前>` を付けて立てる。
+   端末から始めた会話の後継には付けない（オーナーの裁定。Approval Box K-4DNZDK）。
+2. Desktop から始まったかは、ADR 0043 と同じく、止める時点の transcript の最後の `entrypoint`（`claude-desktop`）と、hook の環境変数
+   `CLAUDE_CODE_ENTRYPOINT` で決める。OS は問わない。引き継ぎの記録に `remote_control.wanted` として残す。
+3. 付けて立てるのに失敗した時（終了 code が 0 でない、裏の会話の ID が返らない）は、付けずに1回だけ立て直す。引き継ぎは止めない。
+   後継が立っていない事が分かっている時だけ立て直すので、後継は2つにならない。
+4. 結果を記録の `remote_control.state`（`requested`: 付けて立てた、`unavailable`: 付けずに立て直した）に残し、
+   `auto-handoff status --host claude --json` の `remote_control_state` で読める。付けて立てた後に、Claude Code がリモートへ
+   つなげたかまでは見ない。
+5. 環境変数 `THROUGHLINE_AUTO_HANDOFF_REMOTE_CONTROL` で上書きできる。`on` は出どころに関係なく付け、`off` は付けない。
+6. 旧い会話を止めた理由の文に、後継がリモートコントロール付きで立つ事を書く。
+7. 後継がターンを終えた時に Desktop へ移して開く動き（ADR 0043）は変えない。
+
+## Consequences
+
+- Desktop で作業している利用者は、後継が作業している最中も、claude.ai/code と Claude のアプリから様子を見て操作できる。
+- リモートコントロールを付けた会話は、利用者のアカウントでログインした端末から操作できる状態になる。
+- claude.ai/code とアプリの一覧に、Desktop から始まった会話の後継が並ぶ。
+- すでに動いている後継には付かない。次の引き継ぎから付く。
+- リモートコントロールは Claude Code の機能なので、Codex・Grok・Cursor には当てはまらない。

package/package.json

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

package/src/claude-auto-handoff.mjs

@@ -61,6 +61,8 @@ const PER_SESSION_ENV = ['CLAUDECODE', 'CLAUDE_CODE_ENTRYPOINT', 'CLAUDE_CODE_ME
 const DESKTOP_ENTRYPOINT = 'claude-desktop';
 // 後継を Desktop で開くかを、会話の出どころに関係なく決める（`desktop` で必ず開く、`off` で開かない）。
 const OPEN_OVERRIDE_ENV = 'THROUGHLINE_AUTO_HANDOFF_OPEN';
+// 後継をリモートコントロール付きで立てるかの上書き。`on` は出どころに関係なく付け、`off` は付けない。
+const REMOTE_CONTROL_OVERRIDE_ENV = 'THROUGHLINE_AUTO_HANDOFF_REMOTE_CONTROL';
 
 // requested と failed は、次の道具の hook が後継の立ち上げを始められる。
 const RETRYABLE_STATES = new Set(['requested', 'failed']);
@@ -145,6 +147,9 @@ export function publicClaudeAutoHandoff(record) {
     // 後継を Claude Desktop で開く引き継ぎか、開けたか（null は対象外）。
     desktop_state: record.desktop?.wanted ? (record.desktop.state ?? 'waiting') : null,
     desktop_error_code: record.desktop?.error_code ?? null,
+    // 後継をリモートコントロール付きで立てる引き継ぎか（null は対象外）。requested は指定を付けて立てた、unavailable は付けずに立て直した。
+    // 付けて立てた後に、Claude Code がリモートへつなげたかまでは見ていない。
+    remote_control_state: record.remote_control?.wanted ? (record.remote_control.state ?? 'waiting') : null,
     requested_at, updated_at };
 }
 
@@ -220,6 +225,19 @@ function openInDesktopWanted({ sessionId, transcriptPath, env, dir, platform })
   return listClaudeAutoHandoffs({ dir }).some(record => record.successor?.session_id === sessionId && record.desktop?.wanted);
 }
 
+/**
+ * この会話の後継を、リモートコントロール付きで立てるか（ADR 0048）。
+ * Claude Desktop の画面から始まった会話と、その後継がさらに引き継ぐ時だけ付ける。後継は裏の会話で、ターンを終えるまで
+ * Desktop の一覧に出ない。リモートコントロールがあれば、作業の最中も claude.ai/code と Claude のアプリから見られる。
+ * 端末から始めた会話の後継は `claude agents`・`claude attach` で見られるので付けない。
+ */
+function remoteControlWanted({ sessionId, transcriptPath, env, dir }) {
+  if (env[REMOTE_CONTROL_OVERRIDE_ENV] === 'off') return false;
+  if (env[REMOTE_CONTROL_OVERRIDE_ENV] === 'on') return true;
+  if (env.CLAUDE_CODE_ENTRYPOINT === DESKTOP_ENTRYPOINT || readLatestEntrypoint(transcriptPath) === DESKTOP_ENTRYPOINT) return true;
+  return listClaudeAutoHandoffs({ dir }).some(record => record.successor?.session_id === sessionId && record.remote_control?.wanted);
+}
+
 /**
  * 会話を起動した project の場所を、その OS の書き方にそろえる。
  *
@@ -308,6 +326,7 @@ export function requestClaudeAutoHandoff({
     accepted_at: null,
     desktop: { wanted: openInDesktopWanted({ sessionId, transcriptPath: payload.transcript_path, env, dir, platform }),
       state: null, error_code: null, opened_at: null },
+    remote_control: { wanted: remoteControlWanted({ sessionId, transcriptPath: payload.transcript_path, env, dir }), state: null },
   });
   return { status: 'requested', block: true, sessionId, projectPath, handoffId };
 }
@@ -489,7 +508,8 @@ function stopOutput(record) {
     ? `この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: ${record.handoff_id}）。続きは後継の会話で行ってください: claude attach ${record.successor.short_id}`
     : `Throughlineが、自動圧縮の代わりに新しい会話へ引き継ぎます（引き継ぎID: ${record.handoff_id}）。` +
       (record.desktop?.wanted
-        ? '後継の会話は裏で作業を続け、そのターンを終えた時にClaude Desktopへ開きます。途中の様子は `claude agents` の一覧で見られます。'
+        ? '後継の会話は裏で作業を続け、そのターンを終えた時にClaude Desktopへ開きます。途中の様子は `claude agents` の一覧で見られます。' +
+          (record.remote_control?.wanted ? '後継はリモートコントロール付きで立てるので、claude.ai/code とClaudeのアプリからも見られます。' : '')
         : '後継の会話は `claude agents` の一覧に出ます。');
   return {
     continue: false,
@@ -605,9 +625,12 @@ function successorName(record) {
     titles: [record.transcript_path ? readSessionTitle(record.transcript_path) : null, record.in_flight?.user?.content] });
 }
 
-function successorArgs(record) {
+function successorArgs(record, { remoteControl = false } = {}) {
   // 名前は `--name=` の形で渡す。project のフォルダ名が `-` で始まっても、option として読まれない。
-  const args = ['--bg', `--name=${successorName(record)}`];
+  const name = successorName(record);
+  const args = ['--bg', `--name=${name}`];
+  // リモートコントロールの名前も `=` の形で渡す（名前を省ける option なので、離して書くと次の引数を名前として読む）。
+  if (remoteControl) args.push(`--remote-control=${name}`);
   const { model, effort, permission_mode: permissionMode } = record.settings ?? {};
   if (model) args.push('--model', model);
   if (effort) args.push('--effort', effort);
@@ -656,13 +679,27 @@ export async function runClaudeAutoHandoffWorker(sessionId, {
     settings: { ...record.settings, model: record.transcript_path ? readLatestModel(record.transcript_path) : null },
     in_flight: inFlight,
   });
-  const launched = spawn('claude', successorArgs(record), {
+  const launch = remoteControl => spawn('claude', successorArgs(record, { remoteControl }), {
     cwd: record.project_path, env: successorEnv(env), encoding: 'utf8', timeout: 60_000, stdio: ['ignore', 'pipe', 'pipe'],
   });
+  const backgroundedId = result => BACKGROUNDED_PATTERN.exec(normalizeTerminalText(`${result.stdout ?? ''}`))?.[1];
+  let launched = launch(Boolean(record.remote_control?.wanted));
+  if (record.remote_control?.wanted) {
+    if (!launched.error && launched.status === 0 && backgroundedId(launched)) {
+      update({ remote_control: { ...record.remote_control, state: 'requested' } });
+    } else if (!launched.error && !backgroundedId(launched)) {
+      // リモートコントロールを付けると立てられない（未ログイン、古い Claude Code など）。後継は立っていないので、
+      // 付けずに立て直す。引き継ぎは止めない。
+      process.stderr.write(`[auto-handoff] claude --bg --remote-control exit=${launched.status} ` +
+        `stderr=${JSON.stringify(`${launched.stderr ?? ''}`.slice(0, 300))}; retrying without remote control\n`);
+      update({ remote_control: { ...record.remote_control, state: 'unavailable' } });
+      launched = launch(false);
+    }
+  }
   if (launched.error) {
     return fail(launched.error.code === 'ENOENT' ? 'handoff_claude_cli_unavailable' : 'handoff_successor_launch_failed');
   }
-  const shortId = BACKGROUNDED_PATTERN.exec(normalizeTerminalText(`${launched.stdout ?? ''}`))?.[1];
+  const shortId = backgroundedId(launched);
   if (launched.status !== 0 || !shortId) {
     // 理由を端末内の worker のログに残す（指示や記憶は含まれない、起動コマンドの出力だけ）。
     process.stderr.write(`[auto-handoff] claude --bg exit=${launched.status} stdout=${JSON.stringify(`${launched.stdout ?? ''}`.slice(0, 500))} ` +

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

@@ -639,7 +639,83 @@ test('PreToolUse: Desktop で開く引き継ぎは、止めた理由に、後継
   writeFileSync(desktopTranscript, jsonl([{ ...user('読んで', '2026-10-08T12:00:00.000Z'), entrypoint: 'claude-desktop' }]));
   request(dir, { platform: 'darwin', transcriptPath: desktopTranscript });
   const output = await stopClaudeTurnForHandoff({ payload: { session_id: SESSION, cwd: '/work/app', tool_use_id: 't1' }, dir, launchWorker: async () => 1 });
-  assert.match(output.stopReason, /そのターンを終えた時にClaude Desktopへ開きます。途中の様子は `claude agents` の一覧で見られます。$/);
+  assert.match(output.stopReason, /そのターンを終えた時にClaude Desktopへ開きます。途中の様子は `claude agents` の一覧で見られます。後継はリモートコントロール付きで立てるので、claude\.ai\/code とClaudeのアプリからも見られます。$/);
+}));
+
+test('PreCompact: Claude Desktop から始まった会話と、その後継の引き継ぎだけ、後継をリモートコントロール付きで立てる印を付ける（OS に関係なく）', () => withDir(dir => {
+  const wanted = overrides => {
+    rmSync(join(dir, `${SESSION}.json`), { force: true });
+    request(dir, overrides);
+    return readClaudeAutoHandoff(SESSION, dir).remote_control;
+  };
+  const desktopTranscript = join(dir, 'desktop.jsonl');
+  writeFileSync(desktopTranscript, jsonl([{ ...user('読んで', '2026-10-10T05:00:00.000Z'), entrypoint: 'claude-desktop' }]));
+  const cliTranscript = join(dir, 'cli.jsonl');
+  writeFileSync(cliTranscript, jsonl([{ ...user('読んで', '2026-10-10T05:00:00.000Z'), entrypoint: 'cli' }]));
+  for (const platform of ['darwin', 'win32', 'linux']) {
+    const payload = platform === 'win32' ? { cwd: 'C:\\work\\app' } : undefined;
+    assert.deepEqual(wanted({ platform, payload, transcriptPath: desktopTranscript }), { wanted: true, state: null }, platform);
+    assert.equal(wanted({ platform, payload, env: { CLAUDE_CODE_ENTRYPOINT: 'claude-desktop' } }).wanted, true, platform);
+    assert.equal(wanted({ platform, payload, transcriptPath: cliTranscript }).wanted, false, `${platform}: 端末から始めた会話の後継には付けない`);
+    assert.equal(wanted({ platform, payload }).wanted, false, platform);
+    assert.equal(wanted({ platform, payload, transcriptPath: cliTranscript, env: { THROUGHLINE_AUTO_HANDOFF_REMOTE_CONTROL: 'on' } }).wanted, true, platform);
+    assert.equal(wanted({ platform, payload, transcriptPath: desktopTranscript, env: { THROUGHLINE_AUTO_HANDOFF_REMOTE_CONTROL: 'off' } }).wanted, false, platform);
+  }
+  // 裏で作業している後継がさらに引き継ぐ時は、元の会話の出どころを引き継ぐ（後継の transcript は cli）。
+  writeRecord(dir, 'origin-desktop', { successor: { short_id: SESSION.slice(0, 8), session_id: SESSION }, remote_control: { wanted: true, state: 'requested' } });
+  assert.equal(wanted({ platform: 'darwin', transcriptPath: cliTranscript }).wanted, true);
+  writeRecord(dir, 'origin-desktop', { successor: { short_id: SESSION.slice(0, 8), session_id: SESSION }, remote_control: { wanted: false, state: null } });
+  assert.equal(wanted({ platform: 'darwin', transcriptPath: cliTranscript }).wanted, false);
+}));
+
+test('worker: 印のある引き継ぎは、後継を --remote-control=<後継の名前> 付きで立てる。印の無い引き継ぎには付けない', () => withDir(async dir => {
+  const run = async (sessionId, env) => {
+    const transcriptPath = join(dir, `${sessionId}.jsonl`);
+    writeFileSync(transcriptPath, jsonl([{ ...user('14個のファイルを順に読んで', '2026-10-10T05:00:10Z'), entrypoint: env.CLAUDE_CODE_ENTRYPOINT ?? 'cli' },
+      { type: 'custom-title', customTitle: 'マビノギ BOT 開発' }, assistant('part04 を読みました。', '2026-10-10T05:00:12Z')]));
+    const db = makeBatonDb();
+    requestClaudeAutoHandoff({ payload: { session_id: sessionId, trigger: 'auto', cwd: '/work/OpenLogicool', transcript_path: transcriptPath },
+      env, config: ENABLED, openDb: () => db, dir, platform: 'linux' });
+    await stopClaudeTurnForHandoff({ payload: { session_id: sessionId, cwd: '/work/OpenLogicool', transcript_path: transcriptPath },
+      dir, launchWorker: async () => {} });
+    const launches = [];
+    const record = await runClaudeAutoHandoffWorker(sessionId, { dir, env: {}, pollMs: 10, acceptTimeoutMs: 300, transcriptTimeoutMs: 50,
+      spawn: (command, args) => { launches.push(args); successorStarts(dir, sessionId)(args); return launchedOk(); } });
+    return { record, launches };
+  };
+  const desktop = await run('bbbbbbbb-0000-4000-8000-000000000001', { CLAUDE_CODE_ENTRYPOINT: 'claude-desktop' });
+  assert.equal(desktop.launches.length, 1);
+  assert.deepEqual(desktop.launches[0].slice(0, 3), ['--bg', '--name=OpenLogicool｜マビノギ BOT 開発（自動引き継ぎ）', '--remote-control=OpenLogicool｜マビノギ BOT 開発（自動引き継ぎ）']);
+  assert.equal(desktop.record.state, 'sent');
+  assert.deepEqual(desktop.record.remote_control, { wanted: true, state: 'requested' });
+  assert.equal(publicClaudeAutoHandoff(desktop.record).remote_control_state, 'requested');
+
+  const terminal = await run('bbbbbbbb-0000-4000-8000-000000000002', {});
+  assert.ok(!terminal.launches[0].some(arg => arg.startsWith('--remote-control')));
+  assert.deepEqual(terminal.record.remote_control, { wanted: false, state: null });
+  assert.equal(publicClaudeAutoHandoff(terminal.record).remote_control_state, null);
+}));
+
+test('worker: リモートコントロールを付けると立てられない時は、付けずに立て直す。引き継ぎは止めない', () => withDir(async dir => {
+  const sessionId = 'cccccccc-0000-4000-8000-000000000001';
+  const transcriptPath = join(dir, `${sessionId}.jsonl`);
+  writeFileSync(transcriptPath, jsonl([{ ...user('読んで', '2026-10-10T05:00:10Z'), entrypoint: 'claude-desktop' }, assistant('読みました。', '2026-10-10T05:00:12Z')]));
+  const db = makeBatonDb();
+  requestClaudeAutoHandoff({ payload: { session_id: sessionId, trigger: 'auto', cwd: '/work/app', transcript_path: transcriptPath },
+    env: {}, config: ENABLED, openDb: () => db, dir, platform: 'darwin' });
+  await stopClaudeTurnForHandoff({ payload: { session_id: sessionId, cwd: '/work/app', transcript_path: transcriptPath }, dir, launchWorker: async () => {} });
+  const launches = [];
+  const record = await runClaudeAutoHandoffWorker(sessionId, { dir, env: {}, pollMs: 10, acceptTimeoutMs: 300, transcriptTimeoutMs: 50,
+    spawn: (command, args) => {
+      launches.push(args.some(arg => arg.startsWith('--remote-control')));
+      if (launches.length === 1) return { status: 1, stdout: '', stderr: 'Remote Control requires a claude.ai login' };
+      successorStarts(dir, sessionId)(args); return launchedOk();
+    } });
+  assert.deepEqual(launches, [true, false], '1回目は付けて、2回目は付けずに立てる');
+  assert.equal(record.state, 'sent'); assert.equal(record.error_code, null);
+  assert.deepEqual(record.remote_control, { wanted: true, state: 'unavailable' });
+  assert.equal(publicClaudeAutoHandoff(record).remote_control_state, 'unavailable');
+  assert.equal(publicClaudeAutoHandoff(record).desktop_state, 'waiting', 'Desktop へ開く印は変わらない');
 }));
 
 test('Stop: Desktop で開く引き継ぎの後継がターンを終えたら、移す process を1回だけ起動する', () => withDir(async dir => {

package/src/cli/auto-handoff.mjs

@@ -5,7 +5,7 @@ import { getDb, openReadOnlyDb, DB_PATH, CURRENT_VERSION } from '../db.mjs';
 import { listAutoHandoffs, getAutoHandoff } from '../codex-auto-handoff-store.mjs';
 import { renderFrozenDetail } from '../codex-auto-handoff-memory.mjs';
 import { readAutoHandoffConfig, writeAutoHandoffConfig } from '../codex-auto-handoff-config.mjs';
-import { autoHandoffDeliveryProfile, runAutoHandoffWorker, markAutoHandoffSources } from '../codex-auto-handoff.mjs';
+import { autoHandoffDeliveryProfile, runAutoHandoffWorker, markAutoHandoffSources, resolveAutoHandoffSuccessor } from '../codex-auto-handoff.mjs';
 import { installCodexAutoHandoffHook, installClaudeAutoHandoffHooks, removeClaudeAutoHandoffHooks,
   claudeAutoHandoffHooksRegistered } from './install.mjs';
 import { sameProjectPath } from '../project-path.mjs';
@@ -17,17 +17,17 @@ import { listClaudeAutoHandoffs, publicClaudeAutoHandoff, runClaudeAutoHandoffWo
 const CLAUDE_ACTIONS = ['enable', 'disable', 'status', 'worker', 'desktop-open'];
 
 export function parseAutoHandoffArgs(args) {
-  const out = { action: args[0] ?? 'status', host: 'codex', operation: null, project: null, origin: null, turn: null, database: null, json: false, dryRun: false };
-  if (!['enable', 'disable', 'status', 'resume', 'detail', 'worker', 'desktop-open', 'mark-sources'].includes(out.action)) throw Error('auto_handoff_action_invalid');
+  const out = { action: args[0] ?? 'status', host: 'codex', operation: null, project: null, origin: null, turn: null, database: null, thread: null, json: false, dryRun: false };
+  if (!['enable', 'disable', 'status', 'resume', 'detail', 'worker', 'desktop-open', 'mark-sources', 'successor'].includes(out.action)) throw Error('auto_handoff_action_invalid');
   const allowed = ['host', ...{ enable: ['project'], disable: [], status: ['project', 'operation'],
-    resume: ['operation'], worker: ['operation'], 'desktop-open': ['operation'], 'mark-sources': [], detail: ['operation', 'origin', 'turn', 'database'] }[out.action]];
+    resume: ['operation'], worker: ['operation'], 'desktop-open': ['operation'], 'mark-sources': [], successor: ['thread'], detail: ['operation', 'origin', 'turn', 'database'] }[out.action]];
   const seen = new Set();
   for (let i = 1; i < args.length; i++) {
     if (seen.has(args[i])) throw Error('auto_handoff_argument_invalid');
     seen.add(args[i]);
     if (args[i] === '--json') { out.json = true; continue; }
     if (args[i] === '--dry-run' && out.action === 'mark-sources') { out.dryRun = true; continue; }
-    const key = { '--host': 'host', '--operation': 'operation', '--project': 'project', '--origin': 'origin', '--turn': 'turn', '--database': 'database' }[args[i]];
+    const key = { '--host': 'host', '--operation': 'operation', '--project': 'project', '--origin': 'origin', '--turn': 'turn', '--database': 'database', '--thread': 'thread' }[args[i]];
     if (!key || !allowed.includes(key) || !args[i + 1] || args[i + 1].startsWith('--')) throw Error('auto_handoff_argument_invalid');
     out[key] = args[++i];
   }
@@ -36,6 +36,7 @@ export function parseAutoHandoffArgs(args) {
   if (out.project && !isAbsolute(out.project)) out.project = resolve(out.project);
   if (out.project && out.operation) throw Error('auto_handoff_argument_invalid');
   if (['worker', 'resume', 'detail', 'desktop-open'].includes(out.action) && !out.operation) throw Error('auto_handoff_operation_required');
+  if (out.action === 'successor' && !out.thread) throw Error('auto_handoff_thread_required');
   if (out.action === 'detail') {
     out.turn = Number(out.turn);
     if (!out.origin || !Number.isSafeInteger(out.turn) || out.turn < 1) throw Error('auto_handoff_detail_identity_required');
@@ -128,6 +129,14 @@ export async function run(args = []) {
       finally { db.close(); }
       process.stdout.write(parsed.json ? JSON.stringify({ status: 'ok', text }) + '\n' : text + '\n');
       return 0;
+    } else if (parsed.action === 'successor') {
+      // あるタスクの今の続きを返す。読むだけ。DB がまだ無い端末では、引き継ぎが1つも無いのと同じ答えにする。
+      const db = existsSync(DB_PATH) ? openReadOnlyDb() : null;
+      try {
+        if (db && db.prepare('PRAGMA user_version').get().user_version !== CURRENT_VERSION) throw Error('auto_handoff_schema_mismatch');
+        result = { schema: 'throughline.codex_auto_handoff_successor.v1', ...(db ? resolveAutoHandoffSuccessor(db, parsed.thread)
+          : { thread_id: parsed.thread, handed_off: false, current_thread_id: parsed.thread, chain: [], pending: null }) };
+      } finally { db?.close(); }
     } else if (parsed.action === 'mark-sources') {
       // 0.16.9 までの版が引き継いだ分の名前を付け直す（名前の無い後継へ名前、旧タスクへ引き継ぎ済みの印）。何度流しても同じ結果になる。
       const db = getDb();

package/src/codex-auto-handoff.mjs

@@ -301,6 +301,39 @@ export async function nameAutoHandoffTarget(request, targetId, name) {
   }
 }
 
+/**
+ * あるタスクの「今の続き」を引く（ほかの製品が、旧タスクあての連絡を今の続きへ渡すための入口）。読むだけ。
+ * 引き継ぎを先までたどり、残っている一番先の後継を返す。消された後継は無い物として扱う。
+ * @returns {{
+ *   thread_id: string, handed_off: boolean, current_thread_id: string,
+ *   chain: Array<{handoff_id: string, source_thread_id: string, target_thread_id: string, state: string, created_at: number, updated_at: number}>,
+ *   pending: null | {handoff_id: string, source_thread_id: string, state: string, error_code: string|null, resume_state: string|null,
+ *     in_flight: boolean, created_at: number, updated_at: number}
+ * }} current_thread_id は、後継が無ければ thread_id 自身。pending は、今の続きのタスクで、後継へ指示を送る前の引き継ぎ
+ *   （一番新しい1つ）。in_flight が true なら worker が動いている最中、false なら止まっている（error_code と resume_state を見る）。
+ */
+export function resolveAutoHandoffSuccessor(db, threadId, { findThread = findCodexThreadCandidate,
+  processes = readRuntimeProcesses, now = Date.now() } = {}) {
+  if (!CODEX_NATIVE_ID_PATTERN.test(threadId ?? '')) throw error('handoff_thread_id_invalid');
+  // 残っている一番先の後継（旧タスクへ入力が来た時に開く物と同じ）。そこから threadId まで、作った引き継ぎをさかのぼる。
+  const leaf = findLiveAutoHandoffSuccessor(db, threadId, { findThread });
+  const path = [];
+  for (let operation = leaf, depth = 0; operation && depth < 200; depth++) {
+    path.unshift(operation);
+    if (operation.source_thread_id === threadId) break;
+    operation = findAutoHandoffForTarget(db, operation.source_thread_id);
+  }
+  const chain = path.map(operation => ({ handoff_id: operation.handoff_id, source_thread_id: operation.source_thread_id,
+    target_thread_id: operation.target_thread_id, state: operation.state, created_at: operation.created_at, updated_at: operation.updated_at }));
+  const current = leaf ? leaf.target_thread_id : threadId;
+  const undelivered = listUndeliveredAutoHandoffsForSource(db, current)[0] ?? null;
+  const pending = undelivered ? { handoff_id: undelivered.handoff_id, source_thread_id: undelivered.source_thread_id,
+    state: undelivered.state, error_code: undelivered.error_code ?? null, resume_state: undelivered.resume_state ?? null,
+    in_flight: !HANDOFF_TERMINAL_STATES.has(undelivered.state) && workerActive(undelivered, processes, now),
+    created_at: undelivered.created_at, updated_at: undelivered.updated_at } : null;
+  return { thread_id: threadId, handed_off: chain.length > 0, current_thread_id: current, chain, pending };
+}
+
 /**
  * 引き継ぎが済んだ旧タスクの名前の頭へ、引き継ぎ済みの印を付ける。同じ名前の後継が一覧に並んでも、
  * 印の無い1本が今の続きだと分かるようにする。今の名前を読んでから付けるので、利用者が付け直した名前も残る。

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

@@ -15,7 +15,7 @@ import { readCodexHandoffState, settingsMatch, threadStartSettings, resolvePrepa
 import { runAutoHandoffWorker, requestCodexAutoHandoff, sourceBoundary,
   autoHandoffTargetName, nameAutoHandoffTarget, findLiveAutoHandoffSuccessor,
   markAutoHandoffSource, markAutoHandoffSources, autoHandoffSourceFallbackTitle, carryAutoHandoffQueue,
-  untrackedInheritedMemory } from './codex-auto-handoff.mjs';
+  untrackedInheritedMemory, resolveAutoHandoffSuccessor } from './codex-auto-handoff.mjs';
 import { parseAutoHandoffArgs } from './cli/auto-handoff.mjs';
 
 async function withDb(fn) {
@@ -287,6 +287,58 @@ test('PreCompactの重複ではworkerを増やさず、manualと別projectでは
   assert.equal((await requestCodexAutoHandoff({ ...args, config: { ...config, projects: ['/other'] } })).status, 'skipped');
 }));
 
+test('タスクの今の続きを引く。先までたどり、消えた後継は無い物として扱い、途中の引き継ぎと止まった引き継ぎを見分ける', async () => withDb(async db => {
+  const id = n => `${String(n).repeat(8)}-${String(n).repeat(4)}-${String(n).repeat(4)}-${String(n).repeat(4)}-${String(n).repeat(12)}`;
+  const [A, B, C, D, X, Y, Z] = [1, 2, 3, 4, 5, 6, 7].map(id);
+  const done = (source, target) => updateAutoHandoff(db, request(db, source).operation.handoff_id,
+    { state: 'continued', target_thread_id: target, queued_submission_id: `receipt-${target}` }).operation;
+  const gone = new Set();
+  const options = { findThread: ({ threadId }) => gone.has(threadId) ? null : { rolloutPath: `/r/${threadId}`, mtimeMs: 1 }, processes: () => [], now: 1_000_000 };
+  // 引き継ぎの無いタスクは、自分が今の続き
+  assert.deepEqual(resolveAutoHandoffSuccessor(db, X, options), { thread_id: X, handed_off: false, current_thread_id: X, chain: [], pending: null });
+
+  const ab = done(A, B); const bc = done(B, C);
+  const fromA = resolveAutoHandoffSuccessor(db, A, options);
+  assert.equal(fromA.handed_off, true); assert.equal(fromA.current_thread_id, C); assert.equal(fromA.pending, null);
+  assert.deepEqual(fromA.chain.map(item => [item.handoff_id, item.source_thread_id, item.target_thread_id, item.state]),
+    [[ab.handoff_id, A, B, 'continued'], [bc.handoff_id, B, C, 'continued']]);
+  assert.equal(resolveAutoHandoffSuccessor(db, B, options).current_thread_id, C);
+  assert.deepEqual(resolveAutoHandoffSuccessor(db, B, options).chain.map(item => item.handoff_id), [bc.handoff_id]);
+  assert.equal(resolveAutoHandoffSuccessor(db, C, options).handed_off, false);
+
+  // 今の続き C が、さらに引き継いでいる最中（worker が動いている）
+  const cd = updateAutoHandoff(db, request(db, C).operation.handoff_id, { state: 'memory_ready' }).operation;
+  db.prepare('UPDATE codex_handoffs SET worker_identity_json = ?, updated_at = ? WHERE handoff_id = ?').run(JSON.stringify({ pid: 4242, started_identity: 'w' }), 999_000, cd.handoff_id);
+  const running = resolveAutoHandoffSuccessor(db, A, { ...options, processes: () => [{ pid: 4242, started_identity: 'w' }] });
+  assert.equal(running.current_thread_id, C); assert.equal(running.pending.handoff_id, cd.handoff_id);
+  assert.equal(running.pending.in_flight, true); assert.equal(running.pending.state, 'memory_ready');
+  // worker が居なくなっていれば、途中で止まった物として返す
+  assert.equal(resolveAutoHandoffSuccessor(db, A, options).pending.in_flight, false);
+
+  // C の引き継ぎが失敗して止まった
+  updateAutoHandoff(db, cd.handoff_id, { state: 'failed', error_code: 'handoff_summarizer_backend_failed', resume_state: 'source_stopped' });
+  const stopped = resolveAutoHandoffSuccessor(db, A, options);
+  assert.equal(stopped.current_thread_id, C);
+  assert.deepEqual([stopped.pending.state, stopped.pending.error_code, stopped.pending.resume_state, stopped.pending.in_flight],
+    ['failed', 'handoff_summarizer_backend_failed', 'source_stopped', false]);
+
+  // やり直して D へ続いた。C が消されても、D が残っていれば D が今の続き
+  updateAutoHandoff(db, cd.handoff_id, { state: 'continued', error_code: null, resume_state: null, target_thread_id: D, queued_submission_id: 'receipt-D' });
+  gone.add(C);
+  const toD = resolveAutoHandoffSuccessor(db, A, options);
+  assert.equal(toD.current_thread_id, D); assert.equal(toD.chain.length, 3); assert.equal(toD.pending, null);
+  // 後継が全部消されたら、旧タスクが今の続きに戻る
+  gone.add(D); gone.add(B);
+  assert.deepEqual(resolveAutoHandoffSuccessor(db, A, options), { thread_id: A, handed_off: false, current_thread_id: A, chain: [], pending: null });
+
+  // 後継が出来る前に失敗したタスク（後継なし）
+  updateAutoHandoff(db, request(db, Y).operation.handoff_id, { state: 'failed', error_code: 'handoff_target_not_loaded', resume_state: 'memory_ready' });
+  const failed = resolveAutoHandoffSuccessor(db, Y, options);
+  assert.equal(failed.handed_off, false); assert.equal(failed.current_thread_id, Y); assert.equal(failed.pending.error_code, 'handoff_target_not_loaded');
+  assert.throws(() => resolveAutoHandoffSuccessor(db, 'not-a-thread', options), /handoff_thread_id_invalid/);
+  void Z;
+}));
+
 test('Codexの内部の文脈（auto-compact-N）からの圧縮は、例外にせず止めて記録する。引き継ぎは作らない', async () => withDb(async (db, home) => {
   const thread = '11111111-1111-1111-1111-111111111111';
   const file = join(home, 'rollout.jsonl'); writeFileSync(file, '');