throughline 0.16.18 → 0.16.20

package/CHANGELOG.md

@@ -10,6 +10,48 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.20] — 2026-10-11
+
+### 修正
+
+- Claude Codeの自動継続で、後継がターンを終えてもClaude Desktopへ移らず、裏の会話のまま残る場面があった（[ADR 0050](docs/adr/0050-claude-successor-with-held-peer-message-moves-to-desktop.md)）。Windowsの実機（Claude Code 2.1.296）で2026-10-10に2回起きた（1回は2時間42分後に移り、1回は残ったまま）。利用者の別の会話から`SendMessage`で届いた文を、Claude Codeが承認まで保留していた。保留がある間、`claude agents`はその会話を、ターンの後も`waiting`（`permission prompt`）と返す。Throughlineは手すき（`idle`）の後継だけを移していた。
+  - 後継が`waiting`を返す時は、後継のtranscriptの末尾を読む。終わったターン（`stop_reason`が`end_turn`のassistantの行）で止まっていて、3秒後も同じなら、手すきと同じに扱って移す。
+  - **移す時に保留されている文は、会話へ届かないまま消える**（オーナーの裁定）。
+  - 道具の許可を本当に待っている会話（ターンの途中）と、次のターンが動いている会話は、今までどおり移さない。
+  - transcriptから読むのは行の種類と`stop_reason`だけで、本文は読まない。
+
+### 対応の範囲
+
+| | macOS | Linux | Windows |
+|---|---|---|---|
+| Claude Code | 直した。単体試験と、実機（Claude Code 2.1.289、Claude Desktop）の試験用の会話。保留を作り、0.16.19は止めず、直した版は`claude stop`→本物の`claude --desktop --resume`でDesktopの会話になる事。ターンの途中の許可待ちは止めない事 | 対象外。Claude Desktopへ移す処理が無い（Claude Codeの`--desktop`が無い）。単体試験とCIだけ | 直した。単体試験と、実機（Claude Code 2.1.296）の試験用の会話。保留を作り、0.16.19は止めず、直した版は`claude stop`まで進む事。ターンの途中の許可待ちは止めない事。**試験用の会話では`claude --desktop --resume`を呼んでいない**（止めた後の会話を開く所は0.16.9からの処理で、変えていない） |
+| Codex | 変更なし（会話から会話への文の保留が無い。引き継ぎの部品も別） | 同じ | 同じ |
+| Grok | 変更なし（自動継続が無い） | 同じ | 同じ |
+| Cursor | 変更なし（自動継続が無い） | 同じ | 同じ |
+
+### 確かめていない事
+
+- 止めた時、送り手の会話へ「届かなかった」と伝わるか。
+- リモートコントロール（claude.ai/codeとClaudeのアプリ）の画面に、保留を承認する問いが出るか。
+- 保留を持つ会話へ指示が届いた直後（その行がtranscriptに書かれる前）に、移す処理が重なる場面。
+
+## [0.16.19] — 2026-10-11
+
+### 修正
+
+- Claude Codeの自動継続で、作業ツリー（`<repository>/.claude/worktrees/<名前>`）の後継をClaude Desktopが取り込んだ後にもう一度引き継ぐと、後継が元のrepositoryで立ち、前任の記憶が入らず、Desktopへも移らなかった（[ADR 0049](docs/adr/0049-claude-handoff-uses-registered-project.md)）。Windowsの実機（Claude Code 2.1.296）で2026-10-10 23:43に1回起きた。hookの`CLAUDE_PROJECT_DIR`が元のrepositoryを指し、会話を登録したproject（作業ツリー）と違っていた。
+  - 後継を立てるprojectを、会話が移った先（`relocated`）、会話を登録したproject（`sessions`。その場所が今もある時）、`CLAUDE_PROJECT_DIR`、hookのcwdの順で決める。
+  - 受領を確かめられなかった引き継ぎ（`unknown`・`handoff_delivery_unconfirmed`）でも、その後継がターンを終えたら、Claude Desktopへ移す。今までは裏の会話のまま残り、リモートコントロールからしか見えなかった。`state`と`error_code`は変えない。
+
+### 対応の範囲
+
+| | macOS | Linux | Windows |
+|---|---|---|---|
+| Claude Code | 直した。単体試験と、切り離した置き場での本物のhookの命令（作業ツリーで登録した会話へ、`CLAUDE_PROJECT_DIR`を元のrepositoryにして`pre-compact`を渡し、後継が作業ツリーで立って記憶が合流する事。直す前の版は`project_mismatch`になる事）。**本物のClaude Desktopが作業ツリーの後継を取り込む場面は、macOSでは未確認** | 直した。単体試験と、切り離した置き場での本物のhookの命令。Claude Desktopへ移す処理はLinuxでは対象外（Claude Codeの`--desktop`が無い）なので、`unknown`の後継を移す直しは働かない | 直した。単体試験と、切り離した置き場での本物のhookの命令（`CLAUDE_PROJECT_DIR`は`C:/…`の形）。実機で起きたのはこのOS。**直した版での本物の引き継ぎは、次に起きた時に記録で確かめる** |
+| Codex | 変更なし。projectはhookのcwdで決める。引き継ぎの部品も別 | 同じ | 同じ |
+| Grok | 変更なし（自動継続が無い） | 同じ | 同じ |
+| Cursor | 変更なし（自動継続が無い） | 同じ | 同じ |
+
 ## [0.16.18] — 2026-10-11
 
 ### 変更
@@ -2289,7 +2331,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.18...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.20...HEAD
+[0.16.20]: https://github.com/kitepon/Throughline/compare/v0.16.19...v0.16.20
+[0.16.19]: https://github.com/kitepon/Throughline/compare/v0.16.18...v0.16.19
 [0.16.18]: https://github.com/kitepon/Throughline/compare/v0.16.17...v0.16.18
 [0.16.17]: https://github.com/kitepon/Throughline/compare/v0.16.16...v0.16.17
 [0.16.16]: https://github.com/kitepon/Throughline/compare/v0.16.15...v0.16.16

package/README.md

@@ -68,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 Desktopから始まった会話の後継は、リモートコントロール付きで立てるので、作業の最中もclaude.ai/codeとClaudeのアプリから見られます（0.16.16から。[ADR 0048](docs/adr/0048-claude-desktop-origin-successor-has-remote-control.md)）。
+続きは裏の会話で動きます。`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には出ません。続けて引き継いだ時は、最後に作業を終えた後継だけを開きます。ほかの会話から`SendMessage`で届いた文をClaude Codeが承認待ちで保留している後継も、ターンが終わっていれば開きます。その時に保留されている文は、会話へ届かずに消えます（0.16.20から。[ADR 0050](docs/adr/0050-claude-successor-with-held-peer-message-moves-to-desktop.md)）。端末から始めた会話の後継は開きません。手で開く時は、`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/docs/adr/0049-claude-handoff-uses-registered-project.md

@@ -0,0 +1,49 @@
+# ADR 0049: Claude の引き継ぎは、会話を登録した project で後継を立てる。受領を確かめられなかった後継も Desktop へ移す
+
+日付: 2026-10-11
+
+## Context
+
+Claude Code の自動継続は、PreCompact の hook で、後継を立てる project を決める（ADR 0033）。決め方は、会話が別の project へ
+移っていれば移った先、そうでなければ hook の環境変数 `CLAUDE_PROJECT_DIR`、無ければ hook の cwd だった。後継の最初の指示は、
+前任と後継の project（`sessions.project_path`）が同じ時だけ、前任の記憶を合流させる。`sessions` の行は SessionStart の cwd で作る。
+
+2026-10-11、オーナーから「WindowsのClaudeの自動スルーラインで起動する新セッションってRemoteがONで立ち上がってるの？
+なんか意図した挙動と違う気がする」と指摘があった。Windows の実機（Claude Code 2.1.296）の記録を読んだ。
+
+- 0.16.16 より後の Claude の引き継ぎは5回。5回とも、後継はリモートコントロール付きで立っていた（ADR 0048）。
+  4回は、後継がターンを終えた後に Claude Desktop へ移っていた（ADR 0043）。
+- 1回（10/10 23:43）は、受領を確かめられないまま（`unknown`・`handoff_delivery_unconfirmed`）だった。後継は立って作業を
+  続けていたが、Desktop へ移らず、裏の会話のまま残った。見えるのはリモートコントロールからだけだった。
+- この回の前任は、作業ツリー（`<repository>/.claude/worktrees/<名前>`）で動く後継を、Claude Desktop が取り込んだ会話だった。
+  SessionStart の cwd は作業ツリーで、`sessions` の project も作業ツリーだった。PreCompact の時、`CLAUDE_PROJECT_DIR` は
+  元の repository を指していた。transcript に `relocated` の行は無い。
+- その結果、後継は元の repository（branch は `main`）で立った。前任と project が違うので、記憶は合流しなかった
+  （`merge_skip_reason: project_mismatch`）。合流しないと受領も残らないので、引き継ぎは `unknown` で終わった。
+- Desktop へ移す処理は、受領が残った引き継ぎ（`sent`）の後継だけを対象にしていた。`unknown` の記録には後継の session id が
+  無く、後継の Stop では何も起きなかった。
+
+## Decision
+
+1. PreCompact で後継を立てる project は、次の順で決める。会話が移った先（`relocated`）、会話を登録した project
+   （`sessions.project_path`。その場所が今もある時）、`CLAUDE_PROJECT_DIR`、hook の cwd。
+   印（baton）・有効かどうかの判定・後継を立てる場所は、同じ値を使う。
+2. `sessions` を読むのは、自動圧縮で、自動継続が有効で、まだ引き継ぎの記録が無い時だけ。読めない時と、登録した場所が
+   もう無い時（作業ツリーを消した後）は、今までと同じ値で進める。
+3. 受領を確かめられなかった引き継ぎ（`unknown`、後継の短い ID だけが記録にある）でも、その後継がターンを終えたら、
+   Desktop へ移す。継続の指示は起動時の引数で渡してあるので、ターンを終えた後継は指示を受けている。
+   後継の session id を記録へ入れる。`state` と `error_code` は変えない（記憶が合流しなかった事は、記録に残す）。
+4. 後継が立たなかった引き継ぎ（`failed`）は、今までどおり何もしない。
+
+## Consequences
+
+- 作業ツリーの会話は、Desktop が取り込んだ後に引き継いでも、同じ作業ツリーで続く。記憶も合流する。
+- 何かの理由で受領を確かめられなかった時も、後継は裏の会話のまま残らない。ただし、その後継に前任の記憶が入ったかは
+  別の話で、`unknown` の記録を見て確かめる必要がある。
+- 会話を起動した後で `CLAUDE_PROJECT_DIR` だけが変わる場面では、登録した project が優先される。会話を別の project へ
+  移す場面は、今までどおり `relocated` の行で分かる。
+- Stop の完了受領の project（`turn-processor`）は変えていない。Desktop が取り込んだ作業ツリーの会話の完了受領は、
+  今までどおり `CLAUDE_PROJECT_DIR`（元の repository）へ出る。
+- リモートコントロール付きで立てた後継は、Desktop へ移す時に止める（`claude stop`）。起動時のリモートの接続はそこで切れ、
+  移った後は Claude Desktop 自身のリモートの設定に従う。ここは変えていない。
+- Codex・Grok・Cursor は、hook の cwd で project を決める。この ADR の対象は Claude Code だけ。

package/docs/adr/0050-claude-successor-with-held-peer-message-moves-to-desktop.md

@@ -0,0 +1,56 @@
+# ADR 0050: ほかの会話から届いた文を保留している後継も、ターンが終わっていれば Claude Desktop へ移す
+
+日付: 2026-10-11
+
+## Context
+
+Claude Desktop の画面から始まった会話の後継は、ターンを終えた時に Desktop へ移す（ADR 0043）。移す process は、
+`claude agents --json --all` でその後継が手すき（`status: idle`）になるのを待ち、`claude stop` で止めて、
+`claude --desktop --resume` で開く。手すきにならない時は止めずに戻り、次の Stop でやり直す。
+
+2026-10-11、Windows の実機（Claude Code 2.1.296）で、10/10 23:43 に立った後継が、ターンを終えた後も裏の会話のまま残った。
+記録を読んで分かった事は次のとおり。
+
+- 後継の transcript は、`stop_reason: end_turn` の assistant の行と `stop_hook_summary` で終わっていた。結果の無い道具の呼び出しは無い。
+- それでも `claude agents` は、その後継を `status: waiting`・`waitingFor: permission prompt` と返していた。
+- 理由は、会話から会話への文（`SendMessage`）の保留だった。Claude Code は、送り手と受け手で権限の設定が違う時、届いた文を
+  利用者が承認するまで保留する。transcript には `system` の行（`Held peer message … not delivered to Claude (1 held)`）が1行入る。
+  保留が1通でもある間、その会話は、作業中もターンの後も `waiting / permission prompt` を返す。
+- 送り手は利用者の別の会話で、Throughline が送った文ではない。
+- 同じ作業の1つ前の後継も同じだった。保留が入ってから解けるまでの2時間42分、移せなかった（Desktop へ移ったのは、後継が立ってから3時間34分後）。
+
+Windows と macOS の試験用の会話で、同じ状態を作って確かめた（Windows は権限の組み合わせ2通り、macOS は1通り）。
+
+- 保留を持つ会話は、`claude stop` で止められる。止めた後、`claude -p --resume` と `claude --desktop --resume` で続けられる。
+- 止めると、保留の文は会話へ届かないまま消える。transcript には、知らせの行の中に文の冒頭だけが残る。
+- 道具の許可を本当に待っている会話（ターンの途中）も、同じ `waiting / permission prompt` を返す。この時、transcript の最後は
+  道具を呼んだ assistant の行（`stop_reason: tool_use`）で、結果の行が無い。
+
+裏の会話の保留を承認する画面へ行く道は、端末の `claude attach` とリモートコントロールだけで、Claude Desktop には出ない。
+オーナーの裁定（Approval Box K-3LPKZE、2026-10-11）は「保留があっても、ターンが終わっていれば Desktop へ移す。
+保留中の文は消える」。
+
+## Decision
+
+1. 移す process は、後継が `waiting` を返す時、その後継の transcript の末尾を読む。次の全部が当たる時、手すきと同じに扱う。
+   - `claude agents` の `state` が `working` でない。
+   - 最後の `user`・`assistant` の行が assistant で、`stop_reason` が `end_turn` か `stop_sequence`。道具の呼び出しを含まない。
+   - その行の後に、取り出されても消されてもいない順番待ちの指示（`queue-operation` の `enqueue`）が無い。
+   - 次に見た時（3秒後）も、transcript の大きさが同じ。
+2. transcript の場所は、後継の Stop の hook が受け取った `transcript_path` を、引き継ぎの記録の `successor.transcript_path` に残して使う。
+   公開の表示（`auto-handoff status`）には出さない。
+3. transcript から読むのは、行の種類・`stop_reason`・発言の部品の種類・順番待ちの操作の種類だけ。本文は読まない。
+4. 当たらない時（ターンの途中の許可待ち、次のターンが動いている、transcript を読めない、記録に場所が無い）は、今までどおり止めずに戻る。
+5. `busy` の後継は、今までどおり待つ。
+
+## Consequences
+
+- ほかの会話から文が届いて保留されている後継も、ターンを終えれば Desktop に出る。
+- その時に保留されている文は、承認も拒否もされずに消える。受け手の会話には届かない。送り手の会話へ知らせが行くかは確かめていない。
+- 保留を持つ会話は、作業中も `waiting` を返す。指示が届いてから、その行が transcript に書かれるまでの間に2回続けて読むと、
+  始まったばかりのターンを止める恐れが残る。2回の間隔は3秒で、Claude Code は指示の行をすぐ書くので、起きる窓は狭い。
+- ターンの後も裏で動く処理（裏の shell、裏の subagent）を持つ会話は、止める時にその処理も止まる。手すき（`idle`）の後継を
+  止める時と同じで、ここは変えていない。
+- `stop_reason` を transcript に書かない版の Claude Code では、この判定は当たらない。今までどおり、保留が解けるまで待つ。
+- 0.16.19 までの版が残した記録には transcript の場所が無い。その後継は、次の Stop で場所が入ってから移る。
+- Linux は Desktop へ移す処理が無いので、対象外。Codex・Grok・Cursor は、会話から会話への文の保留が無いので、変更なし。

package/package.json

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

package/src/claude-auto-handoff.mjs

@@ -14,13 +14,14 @@
  *                                  利用者の承認まで止めるため（0.15.3）。
  *   5. 後継の Stop               : Claude Desktop から始まった会話の後継は、そのターンの作業を終えた時に
  *                                  Desktop へ移して開く（`claude stop` → `claude --desktop --resume`。macOS と Windows）。
- *                                  Claude Code は、裏で動いている会話を Desktop へ移さない。
+ *                                  Claude Code は、裏で動いている会話を Desktop へ移さない。ほかの会話から届いた文を
+ *                                  保留している後継も、ターンが終わっていれば移す（ADR 0050）。
  *
  * 旧い会話は止めるだけで、空にしない。手動の /compact と subagent の中の圧縮は対象にしない。
  * 状態は ~/.throughline/claude-auto-handoff/ のファイルに持つ（schema は変えない）。
  */
 
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, posix, resolve, win32 } from 'node:path';
 import { randomUUID } from 'node:crypto';
@@ -249,6 +250,23 @@ function nativeProjectPath(projectPath, platform) {
   return (platform === 'win32' ? win32 : posix).resolve(projectPath);
 }
 
+/**
+ * その会話を sessions へ登録した project（SessionStart の cwd）。行が無い時、その場所がもう無い時は null。
+ *
+ * 作業ツリーで動く後継を Claude Desktop が取り込むと、hook の CLAUDE_PROJECT_DIR は元の repository を指す
+ * （Windows、Claude Code 2.1.296 で実測）。そこで後継を立てると、後継は別の作業ツリーで始まり、前任と project が
+ * 違うので記憶も合流しない（ADR 0049）。登録した project で立てれば、前任と後継の project がそろう。
+ */
+function registeredProjectPath(db, sessionId, platform) {
+  let registered;
+  // sessions を読めない時は、hook の環境から読んだ project で進める（今までと同じ動き）。
+  try { registered = db.prepare('SELECT project_path FROM sessions WHERE session_id = ?').get(sessionId)?.project_path; }
+  catch { return null; }
+  if (typeof registered !== 'string' || !(posix.isAbsolute(registered) || win32.isAbsolute(registered))) return null;
+  const native = nativeProjectPath(registered, platform);
+  return existsSync(native) ? native : null;
+}
+
 /**
  * PreCompact hook の本体。自動圧縮で、その project が有効な時だけ、印と記録を残して圧縮を止める。
  *
@@ -277,9 +295,15 @@ export function requestClaudeAutoHandoff({
   const existing = readClaudeAutoHandoff(sessionId, dir);
   // 有効判定は会話を起動した project で行う。hook の cwd は Bash の cd に追従する。
   // 会話が別の project へ移っている時（Claude Desktop）は、移った先で行う。
-  const projectPath = nativeProjectPath(
-    claudeHostAdapter.completionProjectPath({
-      cwd: payload.cwd ?? process.cwd(), env, transcriptPath: payload.transcript_path }), platform);
+  const relocated = readClaudeRelocatedCwd(payload.transcript_path);
+  const hookProjectPath = nativeProjectPath(
+    relocated ?? claudeHostAdapter.completionProjectPath({ cwd: payload.cwd ?? process.cwd(), env }), platform);
+  let db = null;
+  const open = () => (db ??= openDb());
+  // 自動圧縮で、機能が有効な時だけ、会話を登録した project を読む（ADR 0049）。
+  const projectPath = payload.trigger === 'auto' && !existing && config.enabled && !relocated
+    ? registeredProjectPath(open(), sessionId, platform) ?? hookProjectPath
+    : hookProjectPath;
 
   if (payload.trigger !== 'auto') {
     // 人が /compact を選んだ。まだ止めていない記録は取り下げる。
@@ -298,15 +322,14 @@ export function requestClaudeAutoHandoff({
   }
 
   // /tl と同じ印。後継の最初の指示が、この会話を前任として合流させる。
-  const db = openDb();
   // 会話が別の project へ移っている時（Claude Desktop）は、sessions の project も移った先にそろえる。
   // 合流は前任と後継の project が同じ時だけ行う。付け替えは Stop でも行うが、移った後に1回も Stop を
   // 通らないまま引き継ぐ会話があり、その時は後継へ記憶が入らなかった（0.15.2・0.15.3、macOS で実測）。
-  if (readClaudeRelocatedCwd(payload.transcript_path)) {
-    db.prepare('UPDATE sessions SET project_path = ? WHERE session_id = ? AND project_path <> ?')
+  if (relocated) {
+    open().prepare('UPDATE sessions SET project_path = ? WHERE session_id = ? AND project_path <> ?')
       .run(projectPath, sessionId, projectPath);
   }
-  writeBaton(db, { projectPath, sessionId, now });
+  writeBaton(open(), { projectPath, sessionId, now });
   mkdirSync(dir, { recursive: true, mode: 0o700 });
   removeStale(dir, now);
   const handoffId = randomUUID();
@@ -729,6 +752,59 @@ function readBackgroundAgent(shortId, { spawn, env }) {
   catch { return null; }
 }
 
+// 終わったターンの最後の assistant の行が持つ `stop_reason`。道具を呼んだ行（`tool_use`）と、途中で切れた行は含めない。
+const FINISHED_STOP_REASONS = new Set(['end_turn', 'stop_sequence']);
+// 後継の transcript は、末尾だけ読む。ターンの終わりの行は、最後の発言とその後の数行（hook のまとめ、題、保留の知らせ）にある。
+const TRANSCRIPT_TAIL_BYTES = 1024 * 1024;
+
+/** transcript の末尾の行を読む。途中から始まる最初の行は捨てる。読めない時は null。 */
+function readTranscriptTail(transcriptPath, bytes = TRANSCRIPT_TAIL_BYTES) {
+  let fd;
+  try {
+    fd = openSync(transcriptPath, 'r');
+    const { size } = fstatSync(fd);
+    const start = Math.max(0, size - bytes);
+    const buffer = Buffer.alloc(size - start);
+    const read = readSync(fd, buffer, 0, buffer.length, start);
+    const lines = buffer.toString('utf8', 0, read).split('\n');
+    if (start > 0) lines.shift();
+    const entries = [];
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try { entries.push(JSON.parse(line)); } catch { /* 書いている途中の最後の行 */ }
+    }
+    return { size, entries };
+  } catch { return null; }
+  finally { if (fd !== undefined) closeSync(fd); }
+}
+
+/**
+ * 後継の transcript が、終わったターンで止まっているか（ADR 0050）。
+ *
+ * 止まっている時は、その時の transcript の大きさを返す。呼ぶ側は、続けて2回同じ値が返った時だけ「動いていない」と見る。
+ * 止まっていない時（最後の発言が利用者の指示・道具の結果・道具を呼んだ assistant、または順番待ちの指示が残っている）と、
+ * 読めない時は null。会話の本文は読まない（行の種類と `stop_reason` だけを見る）。
+ */
+export function readFinishedTurnMark(transcriptPath) {
+  if (typeof transcriptPath !== 'string' || !transcriptPath) return null;
+  const tail = readTranscriptTail(transcriptPath);
+  if (!tail) return null;
+  const entries = tail.entries.filter(entry => entry && typeof entry === 'object' && entry.isSidechain !== true);
+  const last = entries.findLastIndex(entry => entry.type === 'user' || entry.type === 'assistant');
+  if (last < 0) return null;
+  const { type, message } = entries[last];
+  if (type !== 'assistant' || !FINISHED_STOP_REASONS.has(message?.stop_reason)) return null;
+  if (Array.isArray(message.content) && message.content.some(block => block?.type === 'tool_use')) return null;
+  // ターンの終わりの後に積まれた指示（`enqueue`）が、取り出されても消されてもいない。次のターンがすぐ始まる。
+  let queued = 0;
+  for (const entry of entries.slice(last + 1)) {
+    if (entry.type !== 'queue-operation') continue;
+    if (entry.operation === 'enqueue') queued += 1;
+    else if (entry.operation === 'dequeue' || entry.operation === 'remove') queued = Math.max(0, queued - 1);
+  }
+  return queued > 0 ? null : tail.size;
+}
+
 export async function launchClaudeDesktopOpen(sessionId, { dir = claudeAutoHandoffDir() } = {}) {
   if (!validSessionId(sessionId)) throw new ClaudeHandoffError('auto_handoff_session_id_invalid');
   mkdirSync(dir, { recursive: true, mode: 0o700 });
@@ -746,17 +822,24 @@ export async function launchClaudeDesktopOpen(sessionId, { dir = claudeAutoHando
 /**
  * 後継の Stop hook から呼ぶ。Claude Desktop で開く引き継ぎの後継が、ターンを終えた。
  * その会話を Desktop へ移す process を起動する。対象でない会話には何もしない（null）。
+ * `transcriptPath` は、その後継の transcript（Stop の payload の値）。移す process が、ターンが終わっているかを読む（ADR 0050）。
  *
  * @returns {Promise<string|null>} 起動した時は、その引き継ぎ ID
  */
-export async function requestClaudeDesktopOpen({ sessionId, dir = claudeAutoHandoffDir(), launch = launchClaudeDesktopOpen }) {
+export async function requestClaudeDesktopOpen({ sessionId, transcriptPath = null, dir = claudeAutoHandoffDir(), launch = launchClaudeDesktopOpen }) {
   if (!validSessionId(sessionId)) return null;
   // この会話自身が引き継ぎの途中なら、作業は次の後継が続ける。移すのは、最後に作業を終えた後継だけ。
   if (readJson(recordPath(sessionId, dir))) return null;
-  const record = listClaudeAutoHandoffs({ dir }).find(item => item.successor?.session_id === sessionId &&
-    item.state === 'sent' && item.desktop?.wanted && !item.desktop.state);
+  const waiting = listClaudeAutoHandoffs({ dir }).filter(item => item.desktop?.wanted && !item.desktop.state);
+  // 受領を確かめられなかった引き継ぎ（unknown）は、後継の session id が記録に無い。その後継がターンを終えたなら、
+  // 後継は動いている。裏の会話のまま残さず、同じように Desktop へ移す（ADR 0049）。
+  const record = waiting.find(item => item.state === 'sent' && item.successor?.session_id === sessionId) ??
+    waiting.find(item => item.state === 'unknown' && !item.successor?.session_id &&
+      typeof item.successor?.short_id === 'string' && sessionId.startsWith(item.successor.short_id));
   if (!record) return null;
-  updateRecord(record.source_session_id, { desktop: { ...record.desktop, state: 'requested', error_code: null } }, { dir });
+  const successor = { ...record.successor, session_id: sessionId };
+  if (typeof transcriptPath === 'string' && transcriptPath) successor.transcript_path = transcriptPath;
+  updateRecord(record.source_session_id, { successor, desktop: { ...record.desktop, state: 'requested', error_code: null } }, { dir });
   try { await launch(record.source_session_id, { dir }); }
   catch {
     updateRecord(record.source_session_id, { desktop: { ...record.desktop, state: 'failed', error_code: 'desktop_open_start_failed' } }, { dir });
@@ -771,6 +854,10 @@ export async function requestClaudeDesktopOpen({ sessionId, dir = claudeAutoHand
  * Claude Code は、裏で動いている会話（作業中も、手すきも）を Desktop へ移さない。手すきになるのを待って
  * `claude stop` で止め、`claude --desktop --resume <session id>` で開く。この命令は出力が端末でないと動かないので、
  * 擬似端末（macOS）か新しい console（Windows）の中で呼ぶ。後継がまた動き出した時は止めずに戻り、次の Stop でやり直す。
+ *
+ * ほかの会話から届いた文を Claude Code が保留している後継は、ターンを終えても手すき（`idle`）にならず、
+ * `waiting`（`permission prompt`）のままになる。この時は transcript を読み、終わったターンで止まっていれば同じように移す。
+ * 保留されている文は、止める時に消える（ADR 0050）。道具の許可を本当に待っている会話（ターンの途中）は移さない。
  */
 export async function runClaudeDesktopOpen(sourceSessionId, {
   dir = claudeAutoHandoffDir(),
@@ -785,16 +872,22 @@ export async function runClaudeDesktopOpen(sourceSessionId, {
   if (!record) throw new ClaudeHandoffError('handoff_not_found');
   if (record.desktop?.state !== 'requested') return record;
   const set = fields => { record = updateRecord(sourceSessionId, { desktop: { ...record.desktop, ...fields } }, { dir }); return record; };
-  const { short_id: shortId, session_id: successorId } = record.successor ?? {};
+  const { short_id: shortId, session_id: successorId, transcript_path: successorTranscript } = record.successor ?? {};
   if (!shortId || !validSessionId(successorId)) return set({ state: 'failed', error_code: 'desktop_open_successor_unknown' });
   const childEnv = successorEnv(env);
 
   let idle = false;
+  let finishedMark = null;
   for (const deadline = Date.now() + idleTimeoutMs; Date.now() < deadline;) {
     // 後継がさらに引き継ぎを始めた。作業は次の後継が続けるので、この会話は移さない。
     if (readJson(recordPath(successorId, dir))) return set({ state: 'superseded' });
     const agent = readBackgroundAgent(shortId, { spawn, env: childEnv });
     if (agent?.status === 'idle') { idle = true; break; }
+    // 保留の文を持つ後継は、作業中もターンの後も `waiting` を返す。transcript が終わったターンで止まっていて、
+    // 次に見た時も同じ大きさなら、手すきと同じに扱う。1回だけでは決めない（指示が届いた直後は、その行がまだ無い）。
+    const mark = agent?.status === 'waiting' && agent.state !== 'working' ? readFinishedTurnMark(successorTranscript) : null;
+    if (mark !== null && mark === finishedMark) { idle = true; break; }
+    finishedMark = mark;
     await delay(pollMs);
   }
   // 手すきにならない（次のターンが始まった、一覧を読めない）。止めずに戻り、次の Stop でやり直す。

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

@@ -1,7 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { spawnSync } from 'node:child_process';
-import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, utimesSync, writeFileSync } from 'node:fs';
+import { appendFileSync, chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, utimesSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { delimiter, dirname, join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
@@ -16,6 +16,7 @@ import {
   listClaudeAutoHandoffs,
   publicClaudeAutoHandoff,
   claudeContinuationInput,
+  readFinishedTurnMark,
   requestClaudeDesktopOpen,
   runClaudeDesktopOpen,
 } from './claude-auto-handoff.mjs';
@@ -97,6 +98,37 @@ test('PreCompact: 移っていない会話は、これまでどおり起動し
   assert.equal(result.projectPath, '/work/app');
 }));
 
+test('PreCompact: CLAUDE_PROJECT_DIR が元の repository を指していても、会話を登録した作業ツリーで引き継ぐ（Claude Desktop が取り込んだ後継）', () => withDir(dir => {
+  // 作業ツリーで動く後継を Desktop が取り込むと、hook の cwd は作業ツリー、CLAUDE_PROJECT_DIR は元の repository になる
+  const repo = join(dir, 'repo');
+  const worktree = join(repo, '.claude', 'worktrees', 'core-ui');
+  mkdirSync(worktree, { recursive: true });
+  const registered = () => {
+    const db = makeBatonDb();
+    db.exec('CREATE TABLE sessions (session_id TEXT PRIMARY KEY, project_path TEXT NOT NULL)');
+    db.prepare('INSERT INTO sessions VALUES (?, ?)').run(SESSION, worktree);
+    return db;
+  };
+  const adopted = { env: { CLAUDE_PROJECT_DIR: repo }, payload: { cwd: worktree }, platform: process.platform };
+
+  const { result, db } = request(dir, { db: registered(), ...adopted });
+  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 の前任だけを合流させる');
+
+  // 有効かどうかも、登録した project で決める
+  rmSync(join(dir, `${SESSION}.json`));
+  assert.equal(request(dir, { db: registered(), ...adopted, config: { enabled: true, projects: [repo] } }).result.reason, 'auto_handoff_disabled');
+  assert.equal(request(dir, { db: registered(), ...adopted, config: { enabled: true, projects: [worktree] } }).result.status, 'requested');
+
+  // 登録した場所がもう無い時（作業ツリーを消した後）は、hook の環境から読んだ project で進める
+  rmSync(join(dir, `${SESSION}.json`));
+  rmSync(worktree, { recursive: true });
+  assert.equal(request(dir, { db: registered(), ...adopted }).result.projectPath, repo);
+}));
+
 test('PreCompact: 自動圧縮で有効な時だけ、印と記録を残して圧縮を止める', () => withDir(dir => {
   const { result, db } = request(dir);
   assert.equal(result.status, 'requested');
@@ -725,8 +757,8 @@ test('Stop: Desktop で開く引き継ぎの後継がターンを終えたら、
   assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), null);
   writeRecord(dir, SESSION, { desktop: { wanted: false, state: null } });
   assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), null, '端末から始めた会話の後継は移さない');
-  writeRecord(dir, SESSION, { state: 'unknown' });
-  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), null, '受領を確かめられていない後継は移さない');
+  writeRecord(dir, SESSION, { state: 'failed', error_code: 'handoff_successor_launch_failed', successor: null });
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), null, '後継が立たなかった引き継ぎでは動かない');
   // 対象の後継
   writeRecord(dir, SESSION, {});
   assert.equal(await requestClaudeDesktopOpen({ sessionId: SESSION, dir, launch }), null, '旧い会話自身の Stop では動かない');
@@ -748,6 +780,32 @@ test('Stop: Desktop で開く引き継ぎの後継がターンを終えたら、
   assert.deepEqual([readClaudeAutoHandoff(SESSION, dir).desktop.state, readClaudeAutoHandoff(SESSION, dir).desktop.error_code], ['failed', 'desktop_open_start_failed']);
 }));
 
+test('Stop: 受領を確かめられなかった引き継ぎ（unknown）でも、その後継がターンを終えたら Desktop へ移す', () => withDir(async dir => {
+  const launched = [];
+  const launch = async (id) => { launched.push(id); };
+  // worker は、後継の最初の指示の受領を待ち切れなかった。記録にあるのは後継の短い ID だけ
+  const unconfirmed = { state: 'unknown', error_code: 'handoff_delivery_unconfirmed', accepted_at: null,
+    successor: { short_id: SUCCESSOR.slice(0, 8), session_id: null } };
+  writeRecord(dir, SESSION, unconfirmed);
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: 'bbbbbbbb-0000-4000-8000-000000000002', dir, launch }), null, '別の会話の Stop では動かない');
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), `h-${SESSION}`);
+  assert.deepEqual(launched, [SESSION]);
+  const record = readClaudeAutoHandoff(SESSION, dir);
+  assert.deepEqual(record.successor, { short_id: SUCCESSOR.slice(0, 8), session_id: SUCCESSOR }, '移す process が使う後継の ID を記録へ入れる');
+  assert.deepEqual([record.state, record.error_code, record.desktop.state], ['unknown', 'handoff_delivery_unconfirmed', 'requested'],
+    '受領を確かめられなかった事は、記録に残したままにする');
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), null, '2回目の Stop では起動しない');
+
+  // 移す process は、その記録で後継を止めて Desktop で開く
+  const calls = [];
+  const opened = await runClaudeDesktopOpen(SESSION, { dir, env: {}, pollMs: 10, idleTimeoutMs: 500,
+    spawn: (command, args) => { calls.push(args.slice(0, 2).join(' '));
+      return args[0] === 'agents' ? { status: 0, stdout: JSON.stringify([{ id: SUCCESSOR.slice(0, 8), kind: 'background', status: 'idle' }]) } : { status: 0, stdout: '' }; },
+    pty: (command, args) => { calls.push(args.join(' ')); return { status: 0, stdout: `Opening session ${SUCCESSOR} in Claude Desktop` }; } });
+  assert.deepEqual(calls, ['agents --json', `stop ${SUCCESSOR.slice(0, 8)}`, `--desktop --resume ${SUCCESSOR}`]);
+  assert.deepEqual([opened.state, opened.desktop.state], ['unknown', 'opened']);
+}));
+
 test('Desktop で開く: 後継が手すきになるのを待って止め、擬似端末の中で claude --desktop --resume を呼ぶ', () => withDir(async dir => {
   const shortId = SUCCESSOR.slice(0, 8);
   const run = async ({ statuses, stopStatus = 0, opened, beforePoll = () => {} }) => {
@@ -811,6 +869,97 @@ test('Desktop で開く: 後継が手すきになるのを待って止め、擬
   assert.equal(untouched.desktop.state, null);
 }));
 
+// ---- ほかの会話から届いた文を保留している後継（ADR 0050） ----
+
+// Claude Code 2.1.296 の transcript の形。ターンの最後の assistant は `stop_reason: end_turn`、道具を呼ぶ行は `tool_use`。
+const endTurn = text => ({ type: 'assistant', message: { role: 'assistant', stop_reason: 'end_turn', content: [{ type: 'text', text }] } });
+const callsTool = id => ({ type: 'assistant', message: { role: 'assistant', stop_reason: 'tool_use', content: [{ type: 'tool_use', id, name: 'Bash', input: {} }] } });
+const turnTail = [{ type: 'system', subtype: 'stop_hook_summary' }, { type: 'system', subtype: 'turn_duration' }, { type: 'last-prompt' }];
+// 保留の知らせは system の行で、user の行にも順番待ちの行にもならない（2026-10-11 の Windows と macOS の実測）
+const heldNotice = { type: 'system', subtype: 'informational', level: 'warning', content: 'Held peer message from another session' };
+
+test('transcript: 終わったターンで止まっている時だけ、印（transcript の大きさ）を返す', () => withDir(dir => {
+  const path = join(dir, 'successor.jsonl');
+  const mark = entries => { writeFileSync(path, jsonl(entries)); return readFinishedTurnMark(path); };
+  const finished = [user('続けて'), callsTool('t1'), toolResult('t1', 'ok'), endTurn('終わりました'), ...turnTail];
+
+  assert.equal(mark(finished), Buffer.byteLength(jsonl(finished)));
+  assert.equal(typeof mark([...finished, heldNotice]), 'number', '保留の知らせが後ろにあっても、ターンは終わっている');
+  assert.equal(mark([user('続けて'), callsTool('t1')]), null, '道具の許可を待っている（結果の無い道具の呼び出し）');
+  assert.equal(mark([user('続けて'), callsTool('t1'), toolResult('t1', 'ok')]), null, '道具の結果の後、次の発言を待っている');
+  assert.equal(mark([...finished, user('次はこれ')]), null, '次の指示が届いている');
+  assert.equal(mark([...finished, { type: 'queue-operation', operation: 'enqueue' }]), null, '順番待ちの指示が残っている');
+  assert.equal(typeof mark([...finished, { type: 'queue-operation', operation: 'enqueue' }, { type: 'queue-operation', operation: 'remove' }]), 'number',
+    '消された順番待ちは数えない');
+  assert.equal(mark([user('続けて'), assistant('途中')]), null, '`stop_reason` の無い行では決めない');
+  assert.equal(mark([user('続けて'), { type: 'assistant', message: { role: 'assistant', stop_reason: 'max_tokens', content: [{ type: 'text', text: '切れた' }] } }]), null);
+  assert.equal(typeof mark([...finished, { ...user('subagent の中'), isSidechain: true }]), 'number', 'subagent の行は見ない');
+  assert.equal(mark([]), null);
+  assert.equal(readFinishedTurnMark(join(dir, 'missing.jsonl')), null, '読めない時は決めない');
+  assert.equal(readFinishedTurnMark(null), null);
+
+  // 末尾だけを読む。長い transcript でも、最後のターンの行で決まる
+  const long = [...Array.from({ length: 400 }, (_, index) => user(`${index}`.padEnd(4_000, 'x'))), ...finished];
+  assert.equal(mark(long), Buffer.byteLength(jsonl(long)));
+}));
+
+test('Stop: 後継の transcript の場所を、移す process のために記録へ残す', () => withDir(async dir => {
+  writeRecord(dir, SESSION, {});
+  const launch = async () => {};
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, transcriptPath: '/home/u/.claude/projects/-work-app/successor.jsonl', dir, launch }), `h-${SESSION}`);
+  assert.deepEqual(readClaudeAutoHandoff(SESSION, dir).successor,
+    { short_id: SUCCESSOR.slice(0, 8), session_id: SUCCESSOR, transcript_path: '/home/u/.claude/projects/-work-app/successor.jsonl' });
+  assert.equal(JSON.stringify(publicClaudeAutoHandoff(readClaudeAutoHandoff(SESSION, dir))).includes('successor.jsonl'), false, '公開の表示には場所を出さない');
+}));
+
+test('Desktop で開く: 保留の文で waiting のままの後継も、ターンが終わっていれば止めて開く。ターンの途中の許可待ちは移さない', () => withDir(async dir => {
+  const shortId = SUCCESSOR.slice(0, 8);
+  const transcript = join(dir, 'successor.jsonl');
+  const finished = [user('続けて'), callsTool('t1'), toolResult('t1', 'ok'), endTurn('終わりました'), ...turnTail, heldNotice];
+  const run = async ({ entries, agent = {}, recordTranscript = transcript, onPoll = () => {} }) => {
+    writeFileSync(transcript, jsonl(entries));
+    writeRecord(dir, SESSION, { successor: { short_id: shortId, session_id: SUCCESSOR, ...(recordTranscript ? { transcript_path: recordTranscript } : {}) },
+      desktop: { wanted: true, state: 'requested', error_code: null, opened_at: null } });
+    const calls = [];
+    let polls = 0;
+    const spawn = (command, args) => {
+      calls.push(args[0]);
+      if (args[0] !== 'agents') return { status: 0, stdout: '' };
+      onPoll(polls += 1);
+      return { status: 0, stdout: JSON.stringify([{ id: shortId, kind: 'background', status: 'waiting', waitingFor: 'permission prompt', state: 'done', ...agent }]) };
+    };
+    const pty = (command, args) => { calls.push(args.join(' ')); return { status: 0, stdout: `Opening session ${SUCCESSOR} in Claude Desktop` }; };
+    const record = await runClaudeDesktopOpen(SESSION, { dir, env: {}, spawn, pty, idleTimeoutMs: 80, pollMs: 5 });
+    return { record, calls };
+  };
+  const untouched = result => {
+    assert.equal(result.calls.some(call => call === 'stop' || call.startsWith('--desktop')), false, '止めない・開かない');
+    assert.equal(result.record.desktop.state, null, '次の Stop でやり直せる');
+  };
+
+  // Windows と macOS の実測（2026-10-11）: ほかの会話から届いた文を保留している間、ターンを終えても `waiting / permission prompt`
+  const held = await run({ entries: finished });
+  assert.deepEqual(held.calls, ['agents', 'agents', 'stop', `--desktop --resume ${SUCCESSOR}`], '続けて2回、同じ所で止まっているのを見てから止める');
+  assert.equal(held.record.desktop.state, 'opened');
+  // ターンの終わりに付く見立てが blocked の時（実機の後継）も同じ
+  assert.equal((await run({ entries: finished, agent: { state: 'blocked' } })).record.desktop.state, 'opened');
+
+  // 道具の許可を本当に待っている（ターンの途中）
+  untouched(await run({ entries: [user('続けて'), callsTool('t1')] }));
+  // 保留を持ったまま、次のターンが動いている
+  untouched(await run({ entries: [...finished, user('次はこれ'), callsTool('t2'), toolResult('t2', 'ok')] }));
+  untouched(await run({ entries: finished, agent: { state: 'working' } }));
+  // 見ている間に transcript が伸び続ける（指示が届いた）
+  untouched(await run({ entries: finished, onPoll: () => appendFileSync(transcript, jsonl([{ type: 'last-prompt' }])) }));
+  const arrived = await run({ entries: finished, onPoll: count => { if (count === 2) appendFileSync(transcript, jsonl([user('次はこれ')])); } });
+  untouched(arrived);
+  // transcript の場所が記録に無い（0.16.19 までの版が残した記録）・読めない時は、今までどおり待つ
+  untouched(await run({ entries: finished, recordTranscript: null }));
+  untouched(await run({ entries: finished, recordTranscript: join(dir, 'missing.jsonl') }));
+  // busy は、transcript が終わったターンに見えても移さない
+  untouched(await run({ entries: finished, agent: { status: 'busy' } }));
+}));
+
 test('公開CLI: --host claude は enable・disable・status・worker を受け取る', () => {
   assert.equal(parseAutoHandoffArgs(['status', '--json']).host, 'codex');
   assert.deepEqual(
@@ -1008,6 +1157,55 @@ test('hook: 自動圧縮を止め、次の道具を止めて worker を起動し
   assert.deepEqual([merged.triggered_path, merged.injection.auto_handoff_id], ['baton', record.handoff_id]);
 }));
 
+test('hook: 作業ツリーの後継を Claude Desktop が取り込んだ後（CLAUDE_PROJECT_DIR は元の repository）に引き継いでも、後継は作業ツリーで立ち、記憶が入る', () => withDir(async home => {
+  // fox（Windows、Claude Code 2.1.296）で 2026-10-10 に起きた形。SessionStart の cwd は作業ツリー、
+  // PreCompact の時の CLAUDE_PROJECT_DIR は元の repository だった。
+  const repo = join(home, 'repo');
+  const worktree = join(repo, '.claude', 'worktrees', 'core-ui');
+  mkdirSync(worktree, { recursive: true });
+  const transcriptPath = join(home, 'transcript.jsonl');
+  const adopted = { ...fakeClaudePath(home), CLAUDE_PROJECT_DIR: repo, CLAUDE_CODE_ENTRYPOINT: 'claude-desktop' };
+  const hook = (command, payload) =>
+    cli(home, [command], JSON.stringify({ session_id: SESSION, cwd: worktree, transcript_path: transcriptPath, ...payload }), adopted);
+
+  assert.equal(cli(home, ['auto-handoff', 'enable', '--host', 'claude', '--json']).status, 0);
+  assert.equal(hook('session-start', { hook_event_name: 'SessionStart', source: 'resume' }).status, 0);
+  writeFileSync(transcriptPath, jsonl([
+    { ...user('画面の余白を直して', '2026-10-10T14:40:00Z'), entrypoint: 'claude-desktop', cwd: worktree },
+    assistant('余白を直します。', '2026-10-10T14:40:02Z'),
+    toolUse('toolu_9', 'Read', { file_path: join(worktree, 'ui.css') }),
+  ]));
+
+  const pre = hook('pre-compact', { hook_event_name: 'PreCompact', trigger: 'auto' });
+  assert.equal(pre.status, 2, pre.stderr);
+  const stopped = hook('pre-tool-use', { hook_event_name: 'PreToolUse', tool_name: 'Read', tool_use_id: 'toolu_9', permission_mode: 'auto' });
+  assert.equal(JSON.parse(stopped.stdout).continue, false);
+  const status = () => JSON.parse(cli(home, ['auto-handoff', 'status', '--host', 'claude', '--json']).stdout).handoffs;
+  let handoff;
+  for (let i = 0; i < 100 && (handoff = status()[0]).state !== 'failed'; i++) await new Promise(r => setTimeout(r, 100));
+  assert.equal(handoff.error_code, 'handoff_successor_launch_failed', '偽の claude で止まる。本物は起動しない');
+  assert.equal(handoff.project_path, worktree, '後継を立てる場所は、前任が動いていた作業ツリー');
+
+  // 後継は作業ツリーで立ち、最初の指示（起動時に渡された継続の指示）を受ける
+  const recordFile = join(home, '.throughline', 'claude-auto-handoff', `${SESSION}.json`);
+  const record = JSON.parse(readFileSync(recordFile, 'utf8'));
+  writeFileSync(recordFile, JSON.stringify({ ...record, state: 'launching', error_code: null }));
+  const successorPayload = { session_id: SUCCESSOR, cwd: record.project_path, hook_event_name: 'SessionStart', source: 'startup' };
+  assert.equal(cli(home, ['session-start'], JSON.stringify(successorPayload), fakeClaudePath(home)).status, 0);
+  const first = cli(home, ['prompt-submit'], JSON.stringify({ ...successorPayload, hook_event_name: 'UserPromptSubmit',
+    prompt: claudeContinuationInput(record) }), fakeClaudePath(home));
+  assert.equal(first.status, 0, first.stderr);
+  assert.match(first.stdout, /^## Throughline: 自動継続の文脈\n/);
+  assert.match(first.stdout, /\*\*作業中のユーザー依頼\*\* \[\d\d:\d\d:\d\d\]: 画面の余白を直して\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);
+  db.close();
+  const decisions = readFileSync(join(home, '.throughline', 'logs', 'inheritance-decision.log'), 'utf8').trim().split('\n').map(JSON.parse);
+  assert.deepEqual(decisions.filter(entry => entry.phase === 'prompt-submit').map(entry => [entry.merged, entry.merge_skip_reason ?? null]), [[true, null]]);
+}));
+
 test('hook: 別の project へ移した会話（Claude Desktop）を、移った後に1回も Stop を通らないまま引き継いでも、後継へ記憶が入る', () => withDir(async home => {
   // Desktop は「フォルダなし」で始めた会話を project へ移す。SessionStart は移る前の場所で呼ばれ、
   // CLAUDE_PROJECT_DIR は移った後も移る前の場所のまま届く。

package/src/turn-processor.mjs

@@ -273,7 +273,7 @@ async function processStop() {
   completeClaudeTurnWithoutHandoff({ sessionId: session_id });
   // Claude Desktop から始まった会話の後継が、ターンを終えた。Desktop へ移して開く process を起動する。
   // 失敗しても、会話の保存は続ける。
-  try { await requestClaudeDesktopOpen({ sessionId: session_id }); }
+  try { await requestClaudeDesktopOpen({ sessionId: session_id, transcriptPath: transcript_path }); }
   catch (err) { process.stderr.write(`[auto-handoff] desktop open: ${err instanceof Error ? err.message : 'unknown'}\n`); }
 
   // VSCode で開かれたプロジェクトに .vscode/tasks.json を自動プロビジョニングする。