throughline 0.15.1 → 0.15.3

package/CHANGELOG.md

@@ -10,6 +10,48 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.15.3] — 2026-10-06
+
+### 修正
+
+- Claude Codeの自動継続（`auto-handoff enable --host claude`）で、旧い会話が権限のバイパス（`bypassPermissions`）の時、後継が継続の指示を受け取らずに止まる不具合を直す。後継は旧い会話の権限を引き継ぐ。Claude Codeは、バイパス中の会話へ別の会話やprocessから届いた文を、送り手が権限のmodeを名乗らない限り利用者の承認まで止める（画面には`Held peer message`と出る）。0.15.2までは、後継を立てた後で受け口へ指示を送っていたので、ここで止まり、記録は`unknown`・`handoff_delivery_timeout`になっていた。バイパス以外の権限では起きない。
+- 継続の指示は、後継を立てる時の最初の指示として渡す（`claude --bg … "<指示>"`）。立てた後で外から送らない。後継の受信の設定（`crossSessionInbound`）は変えない（[ADR 0033](docs/adr/0033-claude-auto-handoff-new-session.md)の4と5を書き換え）。
+- 受領は、後継の最初の指示が`~/.throughline/claude-auto-handoff/<旧会話のsession_id>.accepted`に残し、workerがそれを待って`sent`にする。最初の指示は、workerが後継のIDを記録へ写す前に届くことがあるので、その間は指示が運ぶ引き継ぎIDで後継と認める。期限（60秒）までに残らなければ`unknown`・`handoff_delivery_unconfirmed`にし、後継は立て直さない。`handoff_successor_target_unavailable`と`handoff_delivery_timeout`は出なくなる。
+- 継続の指示の文に、「実行されなかった道具」はまだ実行されていないこと、最初にそれを呼び出すことを書き足す。指示が利用者の発言として届くようになり、Haiku 4.5の後継が、止められた道具をやり直さずに「読みました」と書いて先へ進んだ回があった（macOS、1回）。
+- 後継の`SessionStart`は受け口を控えなくなる。Codexの自動継続は変えない。
+
+### 確認した範囲
+
+- macOS、Claude Desktop（同梱の2.1.286、権限はバイパス、0.15.2）。作業フォルダを移した会話で、圧縮を止める・旧い会話を止める・後継を立てる、の3段がDesktopの画面から送った指示で通り、4段目が上の理由で止まることを確かめた。
+- macOS、端末の会話（Claude Code 2.1.289、Haiku 4.5）。この版で、バイパスの会話は4回、編集の自動許可（`acceptEdits`）の会話も4回、連続で引き継いで14個を読み切り完了。どの引き継ぎも`sent`で、承認待ちは出ない。指示の文を書き足す前の版では、バイパスで2回動かし、1回は完了、1回は上の「読みました」で未完了。
+- Windows 11、端末の会話（2.1.289、Haiku 4.5、`acceptEdits`）。この版で4回連続で引き継いで完了。最初の指示（改行と日本語を含む）は、そのまま後継のhookへ届く。
+
+### 確認していない範囲
+
+- Claude Desktopの画面で、この版が最後まで通ること（後継が指示を受け取って作業を終える所）。
+- Linuxで実物のClaude Codeを動かした通し。単体と結合の試験だけ。
+- Windowsのバイパスの会話、Opus・Fableの後継。
+
+
+## [0.15.2] — 2026-10-06
+
+### 修正
+
+- Claude Desktopで「フォルダなし」で始めて、後から作業フォルダへ移した会話では、自動継続（`auto-handoff enable --host claude`）を有効にしていても引き継ぎが始まらない不具合を直す。Desktopは会話を移した後も、hookへ渡す`CLAUDE_PROJECT_DIR`を移る前の場所のままにする。Throughlineはその値で対象のprojectかどうかを決めていたので、自動圧縮の前のhookが`auto_handoff_disabled`で見送り、圧縮がそのまま走っていた。
+- 会話が移った先は、Claude Codeがtranscriptへ書く`relocated`の行（`relocatedCwd`）から読む。移っている会話では、自動継続の有効判定と印（baton）のprojectを、移った先にする。
+- 同じ会話のターン終了では、完了ターンの控えを移った先のprojectへ書き、`sessions.project_path`を移った先へ付け替える。これまでは移る前の場所のまま残り、移った先のprojectの過去の会話（`handoff-context`、`throughline detail`）にも`observer-read`にも、その会話が出なかった。
+- 移っていない会話の扱いは変わらない。`relocated`の行が無ければ、これまでどおり`CLAUDE_PROJECT_DIR`、無ければhookの`cwd`を使う。
+
+### 確認した範囲
+
+- macOS（Claude Desktop同梱の2.1.286が書いた本物のtranscriptの写し、移った後に自動圧縮が2回走った会話）。切り離したHOMEでhookを手で呼び、0.14.2は`pre-compact`が終了コード0・`auto_handoff_disabled`、`sessions.project_path`と控えは移る前の場所。この版は`pre-compact`が終了コード2（圧縮を止める）・`requested`、`sessions.project_path`と控えは移った先、`observer-read`は移った先のprojectで`snapshot`を返す。
+- macOS、端末から始めた移っていない会話（Claude Code 2.1.289、Haiku 4.5）。この版で4回連続で引き継ぎ、14個を番号順に読み切って完了。自動圧縮は0回。
+
+### 確認していない範囲
+
+- Claude Desktopの画面で、この版が通しで引き継ぐこと（旧い会話を止める所と、後継を立てる所）。Desktopの画面からの送信が要るため、hookを手で呼ぶ確認までにとどまる。
+- Windows・Linuxで移した会話。`relocated`の行の読み取りは、Windowsの書き方の場所を単体の試験で確かめただけ。
+
 ## [0.15.1] — 2026-10-05
 
 ### 修正
@@ -1771,7 +1813,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.15.1...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.15.3...HEAD
+[0.15.3]: https://github.com/kitepon/Throughline/compare/v0.15.2...v0.15.3
+[0.15.2]: https://github.com/kitepon/Throughline/compare/v0.15.1...v0.15.2
 [0.15.1]: https://github.com/kitepon/Throughline/compare/v0.15.0...v0.15.1
 [0.15.0]: https://github.com/kitepon/Throughline/compare/v0.14.3...v0.15.0
 [0.14.3]: https://github.com/kitepon/Throughline/compare/v0.14.2...v0.14.3

package/docs/05_codex_first_roadmap.md

@@ -28,8 +28,8 @@
 最初の成立検証はCodex Desktopで行う。OSごとの仕組みと受入条件は共通にし、
 差分は既存の `src/os/` と配送ライブラリの環境適合へ閉じ込める。
 VS Code・CLIとClaude/Grok/Cursorの対応はhostごとに同じ条件で検証する。
-Claude Codeは同じ並び（圧縮を止める、旧い会話を止める、新しい会話を立てる、継続の指示を1通送る）を、
-Claude Codeの入口（hook、`claude --bg`、会話ごとの受け口）で行う（[ADR 0033](adr/0033-claude-auto-handoff-new-session.md)）。
+Claude Codeは同じ並び（圧縮を止める、旧い会話を止める、新しい会話を立てる、継続の指示を1通渡す）を、
+Claude Codeの入口（hook、最初の指示つきの`claude --bg`）で行う（[ADR 0033](adr/0033-claude-auto-handoff-new-session.md)）。
 この節の処理順と進行状態の細目はCodexだけに適用する。
 一つのhostの成功で他のhostも対応済みとはしない。
 

package/docs/adr/0033-claude-auto-handoff-new-session.md

@@ -14,10 +14,10 @@ Codex 版の各段に当たるものを、Claude Code 2.1.289 の公式文書と
 | Codex 版の段 | Claude Code で当たるもの | 確認 |
 |---|---|---|
 | 圧縮の前に旧タスクを止める | `PreCompact` の exit code 2 で圧縮を止める。`PreToolUse` が `permissionDecision: "deny"` と `continue: false` を返すと、その道具は実行されずにターンが止まる | 実機 |
-| 新しいタスクを作る | `claude --bg`。指示を付けずに起動すると、指示を待つ会話が立つ（`idle — send a prompt to start`） | 実機 |
+| 新しいタスクを作る | `claude --bg`。指示を付けずに起動すると、指示を待つ会話が立つ（`idle — send a prompt to start`）。指示を付けて起動すると、その指示でターンが始まる | 実機 |
 | 止めたターンを取り込んでから記憶を作る | hook で止めたターンでは Stop hook が走らない。worker が、後継を立てる前に transcript から取り込む | 実機（0.14.1） |
 | 記憶を入れる | 最初の指示の `UserPromptSubmit` hook の出力。`/tl` の印（baton）の引き継ぎと同じ | 実機 |
-| 「続けて」を送る | 会話ごとの受け口（inbox socket）。配送ライブラリ `aiterm-steer-delivery` 0.1.13 の `sendClaudeInbox` | 実機 |
+| 「続けて」を送る | `claude --bg` の最初の指示（0.15.3 から）。0.15.2 までは会話ごとの受け口（inbox socket）へ `aiterm-steer-delivery` の `sendClaudeInbox` で送っていた | 実機 |
 
 `PreCompact` の `continue` は捨てられるので、圧縮を止める hook と作業を止める hook は別になる。
 `PreToolUse` が `continue: false` だけを返すと、その道具は実行されてから止まる。`deny` を一緒に返すと実行されない。
@@ -31,6 +31,8 @@ Claude Desktop の新しい会話は、画面を開いただけでは process
 1. **圧縮を止める**: `PreCompact` hook（`throughline pre-compact`、matcher 無し）が、`trigger: "auto"` で自動継続が
    有効な project の時だけ、`/tl` と同じ印（baton）と引き継ぎの記録を残し、exit code 2 で圧縮を止める。
    印の project は、会話を起動した場所（`CLAUDE_PROJECT_DIR`）を、その OS の書き方にそろえたもの（0.14.2）。
+   Claude Desktop で会話を別の project へ移している時は、transcript の `relocated` の行（`relocatedCwd`）が示す移った先を使う。
+   `CLAUDE_PROJECT_DIR` は移る前の場所のまま届くため（0.15.2）。
    hook の cwd は Bash の `cd` に追従するので使わない。後継は起動した場所で立ち、その cwd で印を探す。
    手動の `/compact`、無効な project、subagent の中の圧縮（payload に `agent_id`）、script から起動した会話
    （`CLAUDE_CODE_ENTRYPOINT` が `sdk-` で始まる）では止めない。
@@ -38,7 +40,8 @@ Claude Desktop の新しい会話は、画面を開いただけでは process
    実行させずに止める。旧い会話は止めるだけで、空にしない。同じ応答に並んだ道具も全て止め、後継の立ち上げは1回だけ行う。
    記録が無い会話では、記録のファイルの有無だけを見て終わる。subagent の中の道具は止めない。
 3. **新しい会話を立てる**: 切り離した worker が、止めた時点の依頼・モデル・推論強度・権限を記録へ写し、
-   同じ project で `claude --bg` を指示なしで起動する。起動時に `--model`・`--effort`・`--permission-mode` を渡し、
+   同じ project で `claude --bg` を、継続の指示を最初の指示として付けて起動する（0.15.3。下の4）。
+   起動時に `--model`・`--effort`・`--permission-mode` を渡し、
    `--settings '{"worktree":{"bgIsolation":"none"}}'` で同じ作業ツリーを編集させる。
    依頼と直前の発言は、止めた道具の呼び出しが transcript に書かれるのを待ってから読む（hook の時点では直前の発言が
    まだ書かれていないことがある）。
@@ -46,10 +49,14 @@ Claude Desktop の新しい会話は、画面を開いただけでは process
    bodies の本文にし、道具の入出力は transcript の末尾（止めた道具の呼び出し）まで details に入れる。
    完了したターンは最後の本文だけを残すが、止めたターンには結論の発言が無いので、全部を残す。
    取り込めなくても引き継ぎは止めない。理由は worker のログに残り、状態の `in_flight_captured` が `false` になる。
-4. **継続の指示を1通送る**: 後継の `SessionStart` hook が、同じ project に立ち上げ中の引き継ぎがある時だけ、
-   自分の受け口（`CLAUDE_CODE_MESSAGING_SOCKET` と token）を控える。worker はそれを読んで消し、
-   `sendClaudeInbox` で継続の指示を1通送る。配送は公開 API だけを使い、Throughline の中に送信の実装を持たない。
-   届いた時の `UserPromptSubmit` が baton を消費して前任を合流させ、記憶を注入する。
+4. **継続の指示を1通渡す**: 継続の指示は、後継を起動する時の最初の指示として渡す（0.15.3、オーナーの判断 2026-10-06）。
+   立てた後で外から送らない。Claude Code は、権限のバイパス中の会話へ届いた文を、送り手が権限の mode を名乗らない限り
+   利用者の承認まで止める（cross-session messaging の決まり。画面には `Held peer message` と出る）。
+   後継は旧い会話の権限を引き継ぐので、旧い会話がバイパスだと、0.15.2 までの配送（後継の受け口へ `sendClaudeInbox` で送る）は
+   承認待ちで止まり、引き継ぎが進まなかった。後継の設定で受信を緩める方法（`crossSessionInbound: accept`）は採らない。
+   バイパス中の後継が、他の会話からの文も確認なしで受け取るようになるため。
+   `claude` は stdin も指示に足すので、起動時に stdin は渡さない。
+   その指示の `UserPromptSubmit` が baton を消費して前任を合流させ、記憶を注入する。
    注入は ADR 0016 と同じ予算（9,500 字）で、ヘッダに作業ディレクトリ、現在地、案内、直近の L2 の順に載せる。
    宣言文は求めない。現在地は止めたターンで、次の順に載せる（0.14.1）。
    - 止めた時点の依頼（3,500 字まで）。
@@ -59,9 +66,11 @@ Claude Desktop の新しい会話は、画面を開いただけでは process
    - 止める直前に呼ぼうとして、実行されなかった道具。圧縮を止めた後の応答が呼んだ道具は、どれも実行されていない。
      hook は並んで走るので、同じ応答（`message.id`）の道具をまとめて扱う。
    止めたターンは現在地にだけ載せ、L2 の一覧には重ねない。そのターンの道具の入出力は `throughline detail` で取り出せる。
-5. **受領**: 継続の指示は引き継ぎ ID を含む。後継の最初の指示がその ID を含む時だけ、受領を記録する。
-   `sendClaudeInbox` の結果が `accepted` なら `sent`、`not_sent` なら `failed`、`unknown` なら `unknown` にする。
-   結果が不明な時は再送しない。後継が作業を進めたことまでは確かめない（オーナーの判断: 不要）。
+5. **受領**: 継続の指示は引き継ぎ ID を含む。後継の最初の指示がその ID を含む時だけ、受領を残す
+   （`<旧会話の session_id>.accepted`。記録は worker だけが書き換える）。最初の指示は、worker が後継の ID を記録へ写す前に
+   届くことがあるので、その間は指示が運ぶ引き継ぎ ID で後継と認める。worker は受領を待ち、残れば `sent`、
+   期限（60秒）までに残らなければ `unknown`（`handoff_delivery_unconfirmed`）にする。
+   受領を確かめられない時も、後継を立て直さない。後継が作業を進めたことまでは確かめない（オーナーの判断: 不要）。
 6. **連続の引き継ぎ**: 後継も同じ hook で止まり、次の後継へ引き継ぐ。後継の最後の user 発言は前の引き継ぎの
    継続の指示なので、現在地には前の引き継ぎが運んだ元の依頼を引き続き載せる。
 7. **道具を呼ばずに終わったターン**: 圧縮を止めた後、モデルが道具を呼ばずにターンを終えたら、Stop hook が記録を取り下げる。
@@ -106,4 +115,8 @@ Claude Desktop の新しい会話は、画面を開いただけでは process
 - Windows 11。端末の会話（2.1.289）から始めた。0.14.2 で、Haiku 4.5 は4回、連続で引き継いで完了した。
   0.14.1 までは、印（baton）に残す project の場所が `C:/…` の形で、後継が `C:\…` の形で探して見つけられなかった。
   印と記録に残す場所は、その OS の書き方にそろえる（0.14.2）。
-- Claude Desktop の画面から始めた会話、Fable、subagent が動いている最中の引き継ぎは確かめていない。
+- Claude Desktop の画面から送った指示（同梱の 2.1.286、権限はバイパス、作業フォルダを移した会話、0.15.2）。圧縮を止める・
+  旧い会話を止める・後継を立てる、の3段は通った。継続の指示は、バイパス中の後継が承認待ちで止めた（0.15.3 で渡し方を変えた理由）。
+- 0.15.3（継続の指示を最初の指示として渡す）。macOS の端末の会話（2.1.289、Haiku 4.5）で、バイパスは4回、`acceptEdits` も4回、
+  連続で引き継いで完了。Windows 11 の端末の会話（`acceptEdits`）でも4回連続で引き継いで完了した。
+- 0.15.3 が Claude Desktop の画面で最後まで通ること、Linux の実物での通し、Fable、subagent が動いている最中の引き継ぎは確かめていない。

package/package.json

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

package/src/claude-auto-handoff.mjs

@@ -8,21 +8,21 @@
  *   2. PreToolUse                : 記録がある会話の次の道具を、実行させずに止める（deny + continue:false）。
  *                                  止めた時点の依頼・設定を記録へ写し、後継を立てる worker を起動する。
  *   3. worker                    : 止めたターンを DB へ取り込み（発言の全部と道具の入出力）、ここまでにしたことを
- *                                  記録へ写す。`claude --bg` で、指示を待つ新しい会話を同じ project に立てる。
- *   4. worker                    : 後継の SessionStart が残した受け口へ、配送ライブラリで継続の指示を1通送る。
- *                                  届いた時の UserPromptSubmit が baton を消費し、記憶を注入する。
+ *                                  記録へ写す。`claude --bg` を、継続の指示を最初の指示として付けて、同じ project に立てる。
+ *   4. 後継の UserPromptSubmit   : その指示が baton を消費し、記憶を注入して、受領を残す。worker は受領を待つ。
+ *                                  外から後継へ文を送らない。権限のバイパス中の会話は、外から届いた文を
+ *                                  利用者の承認まで止めるため（0.15.3）。
  *
  * 旧い会話は止めるだけで、空にしない。手動の /compact と subagent の中の圧縮は対象にしない。
  * 状態は ~/.throughline/claude-auto-handoff/ のファイルに持つ（schema は変えない）。
  */
 
-import { closeSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, dirname, join, posix, resolve, win32 } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { setTimeout as delay } from 'node:timers/promises';
-import { sendClaudeInbox } from 'aiterm-steer-delivery';
 import { readClaudeAutoHandoffConfig, claudeAutoHandoffEnabledFor } from './claude-auto-handoff-config.mjs';
 import { CLAUDE_HOST, hostOfSessionId } from './hosts/identity.mjs';
 import { claudeHostAdapter } from './hosts/claude.mjs';
@@ -45,7 +45,7 @@ const CLI_PATH = resolve(dirname(fileURLToPath(import.meta.url)), '../bin/throug
 const STALE_RECORD_MS = 24 * 60 * 60 * 1000;
 // session id を記録のファイル名に使う。Claude の id は UUID で、path の区切りを含む値は受け付けない。
 const CLAUDE_SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
-// `claude --bg` の出力（例: "backgrounded · a41a97ae · name (idle — send a prompt to start)"）。
+// `claude --bg` の出力（例: "backgrounded · a41a97ae · name"。指示なしで立てた時は "(idle — send a prompt to start)" が続く）。
 // 後継の中から起動した時は ID に色の制御文字が付くので、外してから読む。
 const BACKGROUNDED_PATTERN = /backgrounded\s+\S+\s+([0-9a-f]{8})\b/;
 // 後継へ渡さない、会話ごとの環境変数。後継は自分の値を持つ。
@@ -54,11 +54,14 @@ const PER_SESSION_ENV = ['CLAUDECODE', 'CLAUDE_CODE_ENTRYPOINT', 'CLAUDE_CODE_ME
 
 // requested と failed は、次の道具の hook が後継の立ち上げを始められる。
 const RETRYABLE_STATES = new Set(['requested', 'failed']);
-const TARGET_WAIT_STATES = new Set(['launching', 'launched']);
-const ACCEPTABLE_STATES = new Set(['launched', 'sending', 'sent', 'unknown']);
+// 後継の最初の指示は、worker が後継の ID を記録へ写す前に届くことがある（launching）。
+const ACCEPTABLE_STATES = new Set(['launching', 'launched', 'sent', 'unknown']);
 
 export const claudeAutoHandoffDir = () => join(homedir(), '.throughline', 'claude-auto-handoff');
+// 0.15.2 までが受け口の控えを置いた場所。期限の掃除だけを続ける。
 const targetsDir = (dir) => join(dir, 'targets');
+// 後継の最初の指示が残す受領。記録（worker が書き換える）とは別のファイルにして、書き込みが重ならないようにする。
+const acceptancePath = (sessionId, dir) => join(dir, `${sessionId}.accepted`);
 
 class ClaudeHandoffError extends Error {
   constructor(code) { super(code); this.code = code; }
@@ -141,7 +144,7 @@ function removeStale(dir, now) {
       throw error;
     }
     for (const name of names) {
-      if (!/\.(json|claim|log)$/.test(name)) continue;
+      if (!/\.(json|claim|log|accepted)$/.test(name)) continue;
       const path = join(folder, name);
       let modifiedAt;
       try { modifiedAt = statSync(path).mtimeMs; }
@@ -197,8 +200,10 @@ export function requestClaudeAutoHandoff({
   const path = recordPath(sessionId, dir);
   const existing = readClaudeAutoHandoff(sessionId, dir);
   // 有効判定は会話を起動した project で行う。hook の cwd は Bash の cd に追従する。
+  // 会話が別の project へ移っている時（Claude Desktop）は、移った先で行う。
   const projectPath = nativeProjectPath(
-    claudeHostAdapter.completionProjectPath({ cwd: payload.cwd ?? process.cwd(), env }), platform);
+    claudeHostAdapter.completionProjectPath({
+      cwd: payload.cwd ?? process.cwd(), env, transcriptPath: payload.transcript_path }), platform);
 
   if (payload.trigger !== 'auto') {
     // 人が /compact を選んだ。まだ止めていない記録は取り下げる。
@@ -474,44 +479,12 @@ export function completeClaudeTurnWithoutHandoff({ sessionId, dir = claudeAutoHa
 
 /** 後継へ送る継続の指示。引き継ぎIDを含め、後継の最初の指示がこの配送のものかを照合できるようにする。 */
 export function claudeContinuationInput(record) {
+  // この文は後継の最初の指示（利用者の発言）として届く。止めた道具をやり直さずに「済んだ」と書いて
+  // 先へ進む後継が出たので（Haiku 4.5、macOS で実測）、実行されていない道具から始めることを明記する。
   return `Throughline自動継続 ${record.handoff_id}\n` +
     '注入された記憶と元のユーザー依頼に従い、未完了の作業をそのまま継続してください。' +
-    '直前の実行結果を確認し、完了済みの操作を重複実行しないでください。';
-}
-
-/**
- * SessionStart から呼ぶ。同じ project で後継の立ち上げ中の引き継ぎがある時だけ、この会話の受け口を控える。
- * worker が、`claude --bg` の返した ID と会話の ID を照合して読み、読んだら消す。
- */
-export function recordClaudeSuccessorTarget({ payload, env = process.env, dir = claudeAutoHandoffDir(), now = Date.now() }) {
-  const sessionId = payload?.session_id;
-  const socketPath = env.CLAUDE_CODE_MESSAGING_SOCKET;
-  if (!validSessionId(sessionId) || payload.agent_id || payload.source !== 'startup' ||
-      typeof socketPath !== 'string' || !socketPath) return false;
-  const cwd = payload.cwd ?? process.cwd();
-  const waiting = listClaudeAutoHandoffs({ dir }).some(record =>
-    TARGET_WAIT_STATES.has(record.state) && sameProjectPath(record.project_path, cwd) &&
-    (!record.successor?.short_id || sessionId.startsWith(record.successor.short_id)));
-  if (!waiting) return false;
-  writeJsonPrivate(join(targetsDir(dir), `${sessionId}.json`), {
-    session_id: sessionId, socket_path: socketPath, token: env.CLAUDE_CODE_MESSAGING_TOKEN ?? null, recorded_at: now,
-  });
-  return true;
-}
-
-function takeSuccessorTarget(shortId, dir) {
-  let names;
-  try { names = readdirSync(targetsDir(dir)); }
-  catch (error) {
-    if (error.code === 'ENOENT') return null;
-    throw error;
-  }
-  const name = names.find(entry => entry.startsWith(shortId) && entry.endsWith('.json'));
-  if (!name) return null;
-  const path = join(targetsDir(dir), name);
-  const target = readJson(path);
-  rmSync(path, { force: true });
-  return target;
+    '記憶の「実行されなかった道具」は、まだ実行されていません。最初にそれを実際に呼び出してから、先へ進んでください。' +
+    '「ここまでにしたこと」に載っている完了済みの操作は、重複実行しないでください。';
 }
 
 /**
@@ -524,15 +497,26 @@ export function acceptClaudeAutoContinuation({ predecessorId, successorSessionId
   dir = claudeAutoHandoffDir(), now = Date.now() }) {
   if (!validSessionId(predecessorId) || typeof successorSessionId !== 'string') return null;
   const record = readClaudeAutoHandoff(predecessorId, dir);
-  if (!record || !ACCEPTABLE_STATES.has(record.state) || !record.successor?.short_id ||
-      !successorSessionId.startsWith(record.successor.short_id)) return null;
-  if (typeof prompt === 'string' && prompt.includes(`Throughline自動継続 ${record.handoff_id}`) && !record.accepted_at) {
-    updateRecord(predecessorId, { accepted_at: now }, { dir, now });
+  if (!record || !ACCEPTABLE_STATES.has(record.state)) return null;
+  const carriesInstruction = typeof prompt === 'string' && prompt.includes(`Throughline自動継続 ${record.handoff_id}`);
+  // 後継の ID が記録に入っていれば ID で、まだなら指示が運ぶ引き継ぎ ID で、後継と認める。
+  const isSuccessor = record.successor?.short_id
+    ? successorSessionId.startsWith(record.successor.short_id)
+    : carriesInstruction;
+  if (!isSuccessor) return null;
+  if (carriesInstruction && !record.accepted_at && !existsSync(acceptancePath(predecessorId, dir))) {
+    writeJsonPrivate(acceptancePath(predecessorId, dir),
+      { handoff_id: record.handoff_id, successor_session_id: successorSessionId, accepted_at: now });
   }
   return { handoffId: record.handoff_id, projectPath: record.project_path, inFlight: record.in_flight ?? null,
     transcriptPath: record.transcript_path ?? null };
 }
 
+function readAcceptance(sessionId, handoffId, dir) {
+  const acceptance = readJson(acceptancePath(sessionId, dir));
+  return acceptance?.handoff_id === handoffId && typeof acceptance.accepted_at === 'number' ? acceptance : null;
+}
+
 function successorArgs(record) {
   const args = ['--bg', '--name', `tl-${basename(record.project_path)}-${record.handoff_id.slice(0, 8)}`];
   const { model, effort, permission_mode: permissionMode } = record.settings ?? {};
@@ -541,6 +525,9 @@ function successorArgs(record) {
   if (permissionMode) args.push('--permission-mode', permissionMode);
   // 後継は旧い会話の続きなので、同じ作業ツリーを編集する。別の worktree へ移さない。
   args.push('--settings', JSON.stringify({ worktree: { bgIsolation: 'none' } }));
+  // 継続の指示は、起動時の最初の指示として渡す。立てた後で外から送ると、権限のバイパス中の後継は
+  // その文を利用者の承認まで止める（Claude Code の cross-session messaging の決まり）。
+  args.push(claudeContinuationInput(record));
   return args;
 }
 
@@ -551,17 +538,16 @@ function successorEnv(env) {
 }
 
 /**
- * 後継を立てて、継続の指示を1通送る。失敗は固定の理由を記録して止まる。送信の結果が不明な時は再送しない。
+ * 継続の指示を付けて後継を立て、後継の最初の指示が受領を残すのを待つ。失敗は固定の理由を記録して止まる。
+ * 受領を確かめられない時も、後継を立て直さない（同じ指示を持った会話を2つ作らない）。
  */
 export async function runClaudeAutoHandoffWorker(sessionId, {
   dir = claudeAutoHandoffDir(),
   env = process.env,
   spawn = spawnPortableSync,
-  send = sendClaudeInbox,
   openDb = null,
   transcriptTimeoutMs = 5_000,
-  targetTimeoutMs = 30_000,
-  sendTimeoutMs = 30_000,
+  acceptTimeoutMs = 60_000,
   pollMs = 200,
 } = {}) {
   let record = readClaudeAutoHandoff(sessionId, dir);
@@ -571,7 +557,8 @@ export async function runClaudeAutoHandoffWorker(sessionId, {
   const fail = code => update({ state: 'failed', error_code: code });
 
   // 止めた時点の依頼・ここまでにしたこと・その時のモデルを写し、止めたターンを DB へ取り込む。
-  // 後継の最初の指示が、これを現在地として受け取る。
+  // 後継の最初の指示が、これを現在地として受け取る。前の引き継ぎの受領が残っていれば消す。
+  rmSync(acceptancePath(sessionId, dir), { force: true });
   await waitForStoppedToolUse(record, { timeoutMs: transcriptTimeoutMs, pollMs });
   const inFlight = record.transcript_path ? snapshotInFlight(record, dir) : null;
   if (inFlight && openDb) inFlight.turn = captureStoppedTurn(record, openDb);
@@ -595,31 +582,15 @@ export async function runClaudeAutoHandoffWorker(sessionId, {
   }
   update({ state: 'launched', successor: { short_id: shortId, session_id: null } });
 
-  let target = null;
-  for (const deadline = Date.now() + targetTimeoutMs; !target && Date.now() < deadline;) {
-    target = takeSuccessorTarget(shortId, dir);
-    if (!target) await delay(pollMs);
+  // 指示は起動時に渡してある。後継の最初の UserPromptSubmit が受領を残すのを待つ。
+  for (const deadline = Date.now() + acceptTimeoutMs; Date.now() < deadline;) {
+    const acceptance = readAcceptance(sessionId, record.handoff_id, dir);
+    if (acceptance) {
+      rmSync(acceptancePath(sessionId, dir), { force: true });
+      return update({ state: 'sent', error_code: null, accepted_at: acceptance.accepted_at,
+        successor: { short_id: shortId, session_id: acceptance.successor_session_id } });
+    }
+    await delay(pollMs);
   }
-  if (!target) return fail('handoff_successor_target_unavailable');
-  update({ successor: { short_id: shortId, session_id: target.session_id } });
-
-  // ここから先は後継へ指示が届き得る。結果が不明でも、同じ指示をもう一度送らない。
-  update({ state: 'sending' });
-  const result = await send(
-    { socket_path: target.socket_path, ...(target.token ? { token: target.token } : {}) },
-    claudeContinuationInput(record),
-    {
-      timeout_ms: sendTimeoutMs,
-      confirm_acceptance: async signal => {
-        while (!signal.aborted) {
-          if (readClaudeAutoHandoff(sessionId, dir)?.accepted_at) return true;
-          await delay(pollMs);
-        }
-        return false;
-      },
-    },
-  );
-  if (result.status === 'accepted') return update({ state: 'sent', error_code: null });
-  if (result.status === 'not_sent') return fail(`handoff_delivery_${result.reason}`);
-  return update({ state: 'unknown', error_code: `handoff_delivery_${result.reason}` });
+  return update({ state: 'unknown', error_code: 'handoff_delivery_unconfirmed' });
 }

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

@@ -10,7 +10,6 @@ import {
   requestClaudeAutoHandoff,
   stopClaudeTurnForHandoff,
   completeClaudeTurnWithoutHandoff,
-  recordClaudeSuccessorTarget,
   acceptClaudeAutoContinuation,
   runClaudeAutoHandoffWorker,
   readClaudeAutoHandoff,
@@ -63,6 +62,33 @@ function request(dir, overrides = {}) {
   return { result, db };
 }
 
+test('PreCompact: 会話が別の project へ移っている時は、移った先で有効かどうかを決める（Claude Desktop）', () => withDir(dir => {
+  // Desktop は「フォルダなし」で始めた会話を後から project へ移す。CLAUDE_PROJECT_DIR は移る前のまま届く。
+  const scratch = '/Users/kite/Library/Application Support/Claude/scratch-workspaces/a/b/scratch-2026-10-05-ac3fa8';
+  const moved = '/Users/kite/tl-claude-probe';
+  const transcriptPath = join(dir, 'moved.jsonl');
+  writeFileSync(transcriptPath, jsonl([user('読んで', '2026-10-05T22:38:17.050Z'), assistant('読みました', '2026-10-05T22:39:18.926Z'),
+    { type: 'relocated', sessionId: SESSION, relocatedCwd: moved }]));
+  const onlyMoved = { enabled: true, projects: [moved] };
+
+  const { result, db } = request(dir, { config: onlyMoved, transcriptPath, env: { CLAUDE_PROJECT_DIR: scratch }, payload: { cwd: moved } });
+  assert.equal(result.status, 'requested');
+  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);
+}));
+
+test('PreCompact: 移っていない会話は、これまでどおり起動した project で決める', () => withDir(dir => {
+  const transcriptPath = join(dir, 'plain.jsonl');
+  writeFileSync(transcriptPath, jsonl([user('読んで', '2026-10-05T22:38:17.050Z'), assistant('読みました', '2026-10-05T22:39:18.926Z')]));
+  const { result } = request(dir, { config: { enabled: true, projects: ['/work/app/sub'] }, transcriptPath,
+    env: { CLAUDE_PROJECT_DIR: '/work/app' }, payload: { cwd: '/work/app/sub' } });
+  assert.equal(result.status, 'skipped');
+  assert.equal(result.reason, 'auto_handoff_disabled');
+  assert.equal(result.projectPath, '/work/app');
+}));
+
 test('PreCompact: 自動圧縮で有効な時だけ、印と記録を残して圧縮を止める', () => withDir(dir => {
   const { result, db } = request(dir);
   assert.equal(result.status, 'requested');
@@ -216,64 +242,48 @@ test('Stop: 圧縮を止めた後、道具を呼ばずにターンが終わっ
   assert.equal(readClaudeAutoHandoff(SESSION, dir).state, 'stopped');
 }));
 
-/** 止めた直後の記録を作り、後継の SessionStart と配送を差し替えて worker を走らせる。 */
-async function runWorker(dir, { spawn, send, onLaunched }) {
+/** 止めた直後の記録を作り、後継の起動を差し替えて worker を走らせる。 */
+async function runWorker(dir, { spawn, onLaunched }) {
   request(dir);
   await stopClaudeTurnForHandoff({ payload: { session_id: SESSION, cwd: '/work/app', permission_mode: 'acceptEdits',
     effort: { level: 'high' } }, dir, launchWorker: async () => {} });
-  const calls = { spawn: [], send: [] };
+  const calls = { spawn: [] };
   const record = await runClaudeAutoHandoffWorker(SESSION, {
     dir, env: { PATH: '/bin', CLAUDECODE: '1', CLAUDE_CODE_ENTRYPOINT: 'claude-desktop', CLAUDE_CODE_MESSAGING_SOCKET: '/old.sock',
       CLAUDE_CODE_MESSAGING_TOKEN: 'old-token', CLAUDE_PROJECT_DIR: '/work/app', CLAUDE_CODE_USE_BEDROCK: '1' },
-    targetTimeoutMs: 300, sendTimeoutMs: 300, pollMs: 10,
+    acceptTimeoutMs: 300, pollMs: 10,
     spawn: (command, args, options) => {
       calls.spawn.push({ command, args, options });
       const result = spawn(command, args, options);
-      if (result.status === 0) onLaunched?.();
+      if (result.status === 0) onLaunched?.(args);
       return result;
     },
-    send: async (target, text, options) => { calls.send.push({ target, text }); return send(target, text, options); },
   });
   return { record, calls };
 }
 
-const launchedOk = () => ({ status: 0, stdout: 'Starting background service…\nbackgrounded · a41a97ae · tl-app-1234 (idle — send a prompt to start)\n', stderr: '' });
-const successorStarts = dir => () => recordClaudeSuccessorTarget({
-  payload: { session_id: SUCCESSOR, source: 'startup', cwd: '/work/app' },
-  env: { CLAUDE_CODE_MESSAGING_SOCKET: '/tmp/cc-socks/271650.sock', CLAUDE_CODE_MESSAGING_TOKEN: 'secret-token' }, dir });
-
-test('worker: 指示を待つ後継を同じprojectに立て、後継の受け口へ継続の指示を1通送る', () => withDir(async dir => {
-  const { record, calls } = await runWorker(dir, {
-    spawn: launchedOk,
-    onLaunched: successorStarts(dir),
-    send: async (target, text, options) => {
-      // 届いた指示で、後継の最初の UserPromptSubmit が受領を記録する
-      const accepted = acceptClaudeAutoContinuation({ predecessorId: SESSION, successorSessionId: SUCCESSOR, prompt: text, dir });
-      assert.ok(accepted);
-      return await options.confirm_acceptance(new AbortController().signal)
-        ? { status: 'accepted', outcome_unknown: false, reason: 'receiver_confirmed' }
-        : { status: 'unknown', outcome_unknown: true, reason: 'unconfirmed' };
-    },
-  });
+const launchedOk = () => ({ status: 0, stdout: 'Starting background service…\nbackgrounded · a41a97ae · tl-app-1234\n', stderr: '' });
+// 後継の最初の UserPromptSubmit。起動時に渡された指示で、受領を残す。worker が後継の ID を記録へ写す前に届く。
+const successorStarts = (dir, predecessorId = SESSION) => args => acceptClaudeAutoContinuation({
+  predecessorId, successorSessionId: SUCCESSOR, prompt: args.at(-1), dir, now: 5_000 });
+
+test('worker: 継続の指示を最初の指示として付けて後継を同じprojectに立て、後継の受領を待つ', () => withDir(async dir => {
+  const { record, calls } = await runWorker(dir, { spawn: launchedOk, onLaunched: successorStarts(dir) });
   assert.equal(calls.spawn.length, 1);
   const { command, args, options } = calls.spawn[0];
   assert.equal(command, 'claude');
   assert.deepEqual(args, ['--bg', '--name', `tl-app-${record.handoff_id.slice(0, 8)}`, '--effort', 'high',
-    '--permission-mode', 'acceptEdits', '--settings', '{"worktree":{"bgIsolation":"none"}}'],
-    '指示は起動時に渡さない。モデルは transcript が無いので付かない');
+    '--permission-mode', 'acceptEdits', '--settings', '{"worktree":{"bgIsolation":"none"}}', claudeContinuationInput(record)],
+    '指示は起動時に渡す（外から送ると、権限のバイパス中の後継が承認まで止める）。モデルは transcript が無いので付かない');
+  assert.match(args.at(-1), new RegExp(`^Throughline自動継続 ${record.handoff_id}\\n注入された記憶と元のユーザー依頼に従い、未完了の作業をそのまま継続してください。`));
   assert.equal(options.cwd, '/work/app');
   assert.deepEqual(options.env, { PATH: '/bin', CLAUDE_CODE_USE_BEDROCK: '1' }, '会話ごとの環境変数は後継へ渡さない');
+  assert.deepEqual(options.stdio, ['ignore', 'pipe', 'pipe'], 'stdin を渡さない（claude は stdin も指示に足す）');
 
-  assert.equal(calls.send.length, 1);
-  assert.deepEqual(calls.send[0].target, { socket_path: '/tmp/cc-socks/271650.sock', token: 'secret-token' });
-  assert.equal(calls.send[0].text, claudeContinuationInput(record));
-  assert.match(calls.send[0].text, new RegExp(`^Throughline自動継続 ${record.handoff_id}\\n注入された記憶と元のユーザー依頼に従い、未完了の作業をそのまま継続してください。`));
-
-  assert.deepEqual([record.state, record.error_code], ['sent', null]);
+  assert.deepEqual([record.state, record.error_code, record.accepted_at], ['sent', null, 5_000]);
   assert.deepEqual(record.successor, { short_id: 'a41a97ae', session_id: SUCCESSOR });
-  assert.deepEqual(readdirSync(join(dir, 'targets')), [], '受け口の控えは読んだら消す');
-  assert.doesNotMatch(JSON.stringify(publicClaudeAutoHandoff(record)), /secret-token|cc-socks/);
-  assert.doesNotMatch(readFileSync(join(dir, `${SESSION}.json`), 'utf8'), /secret-token/, 'token は記録に残さない');
+  assert.equal(existsSync(join(dir, `${SESSION}.accepted`)), false, '受領の控えは読んだら消す');
+  assert.equal(existsSync(join(dir, 'targets')), false, '受け口は控えない');
 
   // 引き継ぎ済みの会話の道具は、後継を案内して止める
   const output = await stopClaudeTurnForHandoff({ payload: { session_id: SESSION, cwd: '/work/app' }, dir,
@@ -282,9 +292,8 @@ test('worker: 指示を待つ後継を同じprojectに立て、後継の受け
 }));
 
 test('worker: 止めた時点の依頼とモデルを transcript から写し、色付きの出力からも後継のIDを読む。後継が止められた時は元の依頼を運ぶ', () => withDir(async dir => {
-  const sendOk = async () => ({ status: 'accepted', outcome_unknown: false, reason: 'receiver_confirmed' });
   const colored = () => ({ status: 0, stderr: '',
-    stdout: 'backgrounded · \u001b[36ma41a97ae\u001b[39m · tl-app-1234\u001b[2m (idle — send a prompt to start)\u001b[22m\n' });
+    stdout: 'backgrounded · \u001b[36ma41a97ae\u001b[39m · tl-app-1234\u001b[2m\u001b[22m\n' });
   const run = async (sessionId, transcriptPath, toolUseId) => {
     const db = makeBatonDb();
     requestClaudeAutoHandoff({ payload: { session_id: sessionId, trigger: 'auto', cwd: '/work/app', transcript_path: transcriptPath },
@@ -292,13 +301,12 @@ test('worker: 止めた時点の依頼とモデルを transcript から写し、
     await stopClaudeTurnForHandoff({ payload: { session_id: sessionId, cwd: '/work/app', transcript_path: transcriptPath,
       tool_use_id: toolUseId }, dir, launchWorker: async () => {} });
     const calls = [];
-    const record = await runClaudeAutoHandoffWorker(sessionId, { dir, env: {}, send: sendOk, pollMs: 10, targetTimeoutMs: 300,
+    const record = await runClaudeAutoHandoffWorker(sessionId, { dir, env: {}, pollMs: 10, acceptTimeoutMs: 300,
       transcriptTimeoutMs: 300,
       spawn: (command, args) => {
         calls.push(args);
         // 止めた道具の呼び出しは、hook の後で transcript に書かれる
-        recordClaudeSuccessorTarget({ payload: { session_id: SUCCESSOR, source: 'startup', cwd: '/work/app' },
-          env: { CLAUDE_CODE_MESSAGING_SOCKET: '/tmp/cc-socks/1.sock' }, dir });
+        successorStarts(dir, sessionId)(args);
         return colored();
       } });
     return { record, calls };
@@ -337,12 +345,10 @@ test('worker: 止めた時点の依頼とモデルを transcript から写し、
   // 後継 B が止められた時、最後の user 発言は A からの継続の指示。現在地には元の依頼を運ぶ
   const transcriptB = join(dir, 'b.jsonl');
   writeFileSync(transcriptB, jsonl([
-    user(`Another Claude session sent a message:\n${claudeContinuationInput(first.record)}\n\nThis came from another Claude session — not typed by your user.`,
-      '2026-10-04T03:01:00Z'),
+    user(claudeContinuationInput(first.record), '2026-10-04T03:01:00Z'),
     assistant('part09 を読みました。次に part10 を読みます。', '2026-10-04T03:01:20Z', 'claude-opus-5'),
     { type: 'assistant', message: { role: 'assistant', model: 'claude-opus-5', content: [{ type: 'tool_use', id: 'toolu_10', name: 'Read', input: {} }] } },
   ]));
-  rmSync(join(dir, 'targets'), { recursive: true, force: true });
   const second = await run(SUCCESSOR, transcriptB, 'toolu_10');
   assert.deepEqual(second.record.in_flight, {
     user: { content: '14個のファイルを順に読んで', timestamp: Date.parse('2026-10-04T03:00:10Z') },
@@ -401,13 +407,11 @@ test('worker: 止めたターンを DB へ取り込み、ここまでにした
   // hook は並んで走る。記録に残る止めた道具は、応答の中の2つ目のこともある
   await stopClaudeTurnForHandoff({ payload: { session_id: SESSION, cwd: '/work/app', transcript_path: transcript, tool_use_id: 't5' },
     dir, launchWorker: async () => {} });
-  const record = await runClaudeAutoHandoffWorker(SESSION, { dir, env: {}, pollMs: 10, targetTimeoutMs: 300, transcriptTimeoutMs: 300,
+  const record = await runClaudeAutoHandoffWorker(SESSION, { dir, env: {}, pollMs: 10, acceptTimeoutMs: 300, transcriptTimeoutMs: 300,
     openDb: () => db,
-    send: async () => ({ status: 'accepted', outcome_unknown: false, reason: 'receiver_confirmed' }),
-    spawn: () => {
-      recordClaudeSuccessorTarget({ payload: { session_id: SUCCESSOR, source: 'startup', cwd: '/work/app' },
-        env: { CLAUDE_CODE_MESSAGING_SOCKET: '/tmp/cc-socks/1.sock' }, dir });
-      return { status: 0, stderr: '', stdout: 'backgrounded · a41a97ae · tl-app (idle — send a prompt to start)\n' };
+    spawn: (command, args) => {
+      successorStarts(dir)(args);
+      return { status: 0, stderr: '', stdout: 'backgrounded · a41a97ae · tl-app\n' };
     } });
   assert.equal(record.state, 'sent');
   assert.deepEqual(record.in_flight.steps, [
@@ -447,13 +451,11 @@ test('worker: 止めたターンを取り込めなくても後継を立て、取
     env: {}, config: ENABLED, openDb: () => db, dir, platform: 'linux' });
   await stopClaudeTurnForHandoff({ payload: { session_id: SESSION, cwd: '/work/app', transcript_path: transcript, tool_use_id: 'toolu_1' },
     dir, launchWorker: async () => {} });
-  const record = await runClaudeAutoHandoffWorker(SESSION, { dir, env: {}, pollMs: 10, targetTimeoutMs: 300, transcriptTimeoutMs: 300,
+  const record = await runClaudeAutoHandoffWorker(SESSION, { dir, env: {}, pollMs: 10, acceptTimeoutMs: 300, transcriptTimeoutMs: 300,
     openDb: () => db,
-    send: async () => ({ status: 'accepted', outcome_unknown: false, reason: 'receiver_confirmed' }),
-    spawn: () => {
-      recordClaudeSuccessorTarget({ payload: { session_id: SUCCESSOR, source: 'startup', cwd: '/work/app' },
-        env: { CLAUDE_CODE_MESSAGING_SOCKET: '/tmp/cc-socks/1.sock' }, dir });
-      return { status: 0, stderr: '', stdout: 'backgrounded · a41a97ae · tl-app (idle — send a prompt to start)\n' };
+    spawn: (command, args) => {
+      successorStarts(dir)(args);
+      return { status: 0, stderr: '', stdout: 'backgrounded · a41a97ae · tl-app\n' };
     } });
   assert.equal(record.state, 'sent');
   assert.equal(record.in_flight.turn, null);
@@ -461,23 +463,19 @@ test('worker: 止めたターンを取り込めなくても後継を立て、取
   assert.equal(publicClaudeAutoHandoff(record).in_flight_captured, false);
 }));
 
-test('worker: 立ち上げ・受け口・配送の失敗は固定の理由を残し、結果が不明な配送は再送しない', () => withDir(async dir => {
-  const sendOk = async () => ({ status: 'accepted', outcome_unknown: false, reason: 'receiver_confirmed' });
+test('worker: 立ち上げの失敗は固定の理由を残し、受領を確かめられない時は後継を立て直さない', () => withDir(async dir => {
   const cases = [
-    [{ spawn: () => ({ error: Object.assign(new Error('not found'), { code: 'ENOENT' }) }), send: sendOk }, 'failed', 'handoff_claude_cli_unavailable', 0],
-    [{ spawn: () => ({ status: 1, stdout: '', stderr: 'Workspace not trusted' }), send: sendOk }, 'failed', 'handoff_successor_launch_failed', 0],
-    [{ spawn: () => ({ status: 0, stdout: 'unexpected output', stderr: '' }), send: sendOk }, 'failed', 'handoff_successor_launch_failed', 0],
-    [{ spawn: launchedOk, send: sendOk }, 'failed', 'handoff_successor_target_unavailable', 0],
-    [{ spawn: launchedOk, onLaunched: successorStarts(dir),
-      send: async () => ({ status: 'not_sent', outcome_unknown: false, reason: 'connect_failed' }) }, 'failed', 'handoff_delivery_connect_failed', 1],
-    [{ spawn: launchedOk, onLaunched: successorStarts(dir),
-      send: async () => ({ status: 'unknown', outcome_unknown: true, reason: 'unconfirmed' }) }, 'unknown', 'handoff_delivery_unconfirmed', 1],
+    [{ spawn: () => ({ error: Object.assign(new Error('not found'), { code: 'ENOENT' }) }) }, 'failed', 'handoff_claude_cli_unavailable'],
+    [{ spawn: () => ({ status: 1, stdout: '', stderr: 'Workspace not trusted' }) }, 'failed', 'handoff_successor_launch_failed'],
+    [{ spawn: () => ({ status: 0, stdout: 'unexpected output', stderr: '' }) }, 'failed', 'handoff_successor_launch_failed'],
+    // 後継は立ったが、最初の指示の受領が期限までに残らない
+    [{ spawn: launchedOk }, 'unknown', 'handoff_delivery_unconfirmed'],
   ];
-  for (const [deps, state, code, sends] of cases) {
+  for (const [deps, state, code] of cases) {
     rmSync(join(dir, `${SESSION}.json`), { force: true });
     rmSync(join(dir, `${SESSION}.claim`), { force: true });
-    const { record, calls } = await runWorker(dir, deps);
-    assert.deepEqual([record.state, record.error_code, calls.send.length], [state, code, sends], code);
+    const { record } = await runWorker(dir, deps);
+    assert.deepEqual([record.state, record.error_code], [state, code], code);
   }
   // 結果が不明な引き継ぎは、次の道具でも立ち上げ直さない
   const launched = [];
@@ -486,52 +484,42 @@ test('worker: 立ち上げ・受け口・配送の失敗は固定の理由を残
   assert.equal((await runClaudeAutoHandoffWorker(SESSION, { dir, spawn: () => { throw new Error('must not spawn'); } })).state, 'unknown');
 }));
 
-test('SessionStart: 後継の立ち上げ中の引き継ぎがある project の、新しく始まった会話だけが受け口を控える', () => withDir(async dir => {
-  const env = { CLAUDE_CODE_MESSAGING_SOCKET: '/tmp/cc-socks/1.sock', CLAUDE_CODE_MESSAGING_TOKEN: 't' };
-  const start = (overrides = {}, environment = env) => recordClaudeSuccessorTarget({
-    payload: { session_id: SUCCESSOR, source: 'startup', cwd: '/work/app', ...overrides }, env: environment, dir });
-  assert.equal(start(), false, '引き継ぎが無い');
-  request(dir);
-  assert.equal(start(), false, 'まだ旧い会話を止めていない');
-
-  const write = fields => writeFileSync(join(dir, `${SESSION}.json`),
-    JSON.stringify({ ...readClaudeAutoHandoff(SESSION, dir), ...fields }));
-  write({ state: 'launching' });
-  assert.equal(start({ cwd: '/work/other' }), false, '別の project');
-  assert.equal(start({ source: 'resume' }), false);
-  assert.equal(start({ source: 'compact' }), false);
-  assert.equal(start({ agent_id: 'agent-1' }), false);
-  assert.equal(start({}, {}), false, '受け口を持たない会話');
-  assert.equal(start({ session_id: `grok:${SUCCESSOR}` }), false);
-  assert.equal(start(), true);
-  rmSync(join(dir, 'targets'), { recursive: true });
-
-  write({ state: 'launched', successor: { short_id: 'a41a97ae', session_id: null } });
-  assert.equal(start({ session_id: 'bbbbbbbb-0000-4000-8000-000000000001' }), false, '後継のIDと合わない会話');
-  assert.equal(start(), true);
-  write({ state: 'sent' });
-  rmSync(join(dir, 'targets'), { recursive: true });
-  assert.equal(start(), false, '送り終えた引き継ぎ');
-}));
-
-test('最初の指示: 後継だけが止めた時点の依頼を受け取り、この引き継ぎの配送だけが受領になる', () => withDir(async dir => {
+test('最初の指示: 後継だけが止めた時点の依頼を受け取り、この引き継ぎの指示だけが受領になる', () => withDir(async dir => {
   request(dir);
   await stopClaudeTurnForHandoff({ payload: { session_id: SESSION, cwd: '/work/app' }, dir, launchWorker: async () => {} });
   const accept = (overrides = {}) => acceptClaudeAutoContinuation({ predecessorId: SESSION, successorSessionId: SUCCESSOR, dir, ...overrides });
-  assert.equal(accept(), null, '後継がまだ立っていない');
+  const acceptance = () => existsSync(join(dir, `${SESSION}.accepted`))
+    ? JSON.parse(readFileSync(join(dir, `${SESSION}.accepted`), 'utf8')) : null;
   const record = readClaudeAutoHandoff(SESSION, dir);
+  const instruction = claudeContinuationInput(record);
+  assert.equal(accept({ prompt: instruction }), null, '後継をまだ立てていない（stopped）');
   const inFlight = { user: { content: '依頼', timestamp: 1 }, last_fragment: null };
-  writeFileSync(join(dir, `${SESSION}.json`), JSON.stringify({ ...record, state: 'sending',
-    successor: { short_id: 'a41a97ae', session_id: SUCCESSOR }, in_flight: inFlight }));
-  assert.equal(accept({ successorSessionId: 'bbbbbbbb-0000-4000-8000-000000000001' }), null, '後継ではない会話');
+  const expected = { handoffId: record.handoff_id, projectPath: '/work/app', inFlight, transcriptPath: null };
+  const write = fields => writeFileSync(join(dir, `${SESSION}.json`), JSON.stringify({ ...record, in_flight: inFlight, ...fields }));
+
+  // 立ち上げ中（後継の ID はまだ記録に無い）: 指示が運ぶ引き継ぎ ID で後継と認める
+  write({ state: 'launching' });
+  assert.equal(accept(), null, '指示を持たない会話');
+  assert.equal(accept({ prompt: '別の指示' }), null, '同じ project で人が始めた別の会話');
+  assert.equal(accept({ prompt: 'Throughline自動継続 00000000-0000-4000-8000-000000000000\n…' }), null, '別の引き継ぎの指示');
+  assert.equal(acceptance(), null);
+  assert.deepEqual(accept({ prompt: instruction, now: 9_000 }), expected);
+  assert.deepEqual(acceptance(), { handoff_id: record.handoff_id, successor_session_id: SUCCESSOR, accepted_at: 9_000 });
+  assert.equal(readClaudeAutoHandoff(SESSION, dir).accepted_at, null, '記録は worker だけが書き換える');
+  accept({ prompt: instruction, now: 9_999 });
+  assert.equal(acceptance().accepted_at, 9_000, '受領は1回だけ残す');
+  rmSync(join(dir, `${SESSION}.accepted`));
+
+  // 後継の ID が記録に入った後: ID で後継と認める
+  write({ state: 'launched', successor: { short_id: 'a41a97ae', session_id: null } });
+  assert.equal(accept({ successorSessionId: 'bbbbbbbb-0000-4000-8000-000000000001', prompt: instruction }), null, '後継ではない会話');
   assert.equal(accept({ predecessorId: 'aaaaaaaa-0000-4000-8000-000000000009' }), null);
   assert.equal(accept({ predecessorId: `codex:${SESSION}` }), null);
-
   // 人が先に別の指示を打った時は、依頼は渡すが受領にはしない
-  assert.deepEqual(accept({ prompt: '別の指示' }), { handoffId: record.handoff_id, projectPath: '/work/app', inFlight, transcriptPath: null });
-  assert.equal(readClaudeAutoHandoff(SESSION, dir).accepted_at, null);
-  accept({ prompt: `Another Claude session sent a message:\n${claudeContinuationInput(record)}`, now: 9_000 });
-  assert.equal(readClaudeAutoHandoff(SESSION, dir).accepted_at, 9_000);
+  assert.deepEqual(accept({ prompt: '別の指示' }), expected);
+  assert.equal(acceptance(), null);
+  accept({ prompt: instruction, now: 9_500 });
+  assert.equal(acceptance().accepted_at, 9_500);
 }));
 
 test('公開CLI: --host claude は enable・disable・status・worker を受け取る', () => {
@@ -683,19 +671,14 @@ test('hook: 自動圧縮を止め、次の道具を止めて worker を起動し
   assert.equal(handoff.in_flight_captured, true);
   assert.equal(record.in_flight.turn.origin_session_id, SESSION);
   assert.equal(record.in_flight.turn.details, 3);
+  // 後継の最初の指示は、worker が後継の ID を記録へ写す前（launching）に届くことがある
   writeFileSync(recordFile, JSON.stringify({ ...record, state: 'launching', error_code: null }));
   const started = hook('session-start', { hook_event_name: 'SessionStart', source: 'startup' }, SUCCESSOR);
   assert.equal(started.status, 0, started.stderr);
   assert.equal(started.stdout, '');
-  assert.equal(existsSync(join(handoffDir, 'targets')), false, '受け口を持たない会話は控えない');
-  const withSocket = cli(home, ['session-start'], JSON.stringify({ session_id: SUCCESSOR, cwd: project, hook_event_name: 'SessionStart', source: 'startup' }),
-    { ...extra, CLAUDE_CODE_MESSAGING_SOCKET: join(home, 'in.sock'), CLAUDE_CODE_MESSAGING_TOKEN: 'secret-token' });
-  assert.equal(withSocket.status, 0, withSocket.stderr);
-  assert.deepEqual(readdirSync(join(handoffDir, 'targets')), [`${SUCCESSOR}.json`]);
-  writeFileSync(recordFile, JSON.stringify({ ...record, state: 'sending', error_code: null,
-    successor: { short_id: SUCCESSOR.slice(0, 8), session_id: SUCCESSOR } }));
-
-  const prompt = `Another Claude session sent a message:\n${claudeContinuationInput(record)}`;
+  assert.equal(existsSync(join(handoffDir, 'targets')), false, '受け口は控えない');
+
+  const prompt = claudeContinuationInput(record);
   const first = cli(home, ['prompt-submit'], JSON.stringify({ session_id: SUCCESSOR, cwd: project, hook_event_name: 'UserPromptSubmit', prompt }), extra);
   assert.equal(first.status, 0, first.stderr);
   assert.match(first.stdout, /^## Throughline: 自動継続の文脈\n/);
@@ -707,7 +690,9 @@ test('hook: 自動圧縮を止め、次の道具を止めて worker を起動し
   assert.equal(first.stdout.split('big1.txt と big2.txt を読んで').length, 2, '止めたターンの依頼は現在地に1回だけ');
   assert.doesNotMatch(first.stdout, /宣言|\/clear/);
   assert.ok(first.stdout.length <= 9_501);
-  assert.ok(JSON.parse(readFileSync(recordFile, 'utf8')).accepted_at > 0, '届いた指示で受領を記録する');
+  const acceptance = JSON.parse(readFileSync(join(handoffDir, `${SESSION}.accepted`), 'utf8'));
+  assert.deepEqual([acceptance.handoff_id, acceptance.successor_session_id], [record.handoff_id, SUCCESSOR], '最初の指示が受領を残す');
+  assert.ok(acceptance.accepted_at > 0);
 
   // 記憶は後継へ合流している（今の /tl の引き継ぎと同じ）
   const db = new DatabaseSync(join(home, '.throughline', 'throughline.db'));

package/src/hook-entrypoints.test.mjs

@@ -863,6 +863,57 @@ test('process-turn subprocess backfills all completed logical turns from a multi
   }
 });
 
+test('process-turn subprocess files a relocated Claude Desktop conversation under the project it moved to', () => {
+  // Desktop は「フォルダなし」で始めた会話を後から project へ移す。hook の CLAUDE_PROJECT_DIR は移る前のまま届く。
+  const home = makeTempHome();
+  const scratch = makeTempProject();
+  const moved = makeTempProject();
+  const transcriptPath = join(moved, 'transcript.jsonl');
+  const sessionId = '04bf5ab3-4b29-4b35-9b85-02a48eec51a1';
+  const entries = [
+    { type: 'user', message: { role: 'user', content: [{ type: 'text', text: 'first request' }] } },
+    { type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: 'first answer' }] } },
+  ];
+  const stop = (lastAssistantMessage) => runNode([join(REPO_ROOT, 'src/turn-processor.mjs')], {
+    home,
+    cwd: moved,
+    env: { CLAUDE_PROJECT_DIR: scratch },
+    input: JSON.stringify({ session_id: sessionId, cwd: moved, transcript_path: transcriptPath, last_assistant_message: lastAssistantMessage }),
+  });
+  try {
+    // 移る前: SessionStart が移る前の場所で行を作り、最初の Stop も移る前の場所へ受領を書く。
+    const started = runNode([join(REPO_ROOT, 'src/session-start.mjs')], {
+      home, cwd: scratch, input: JSON.stringify({ session_id: sessionId, cwd: scratch, source: 'startup', transcript_path: transcriptPath }),
+    });
+    assert.equal(started.status, 0, started.stderr);
+    writeFileSync(transcriptPath, entries.map((entry) => JSON.stringify(entry)).join('\n') + '\n', 'utf8');
+    assert.equal(stop('first answer').status, 0);
+    let db = openDb(home);
+    assert.equal(db.prepare('SELECT project_path FROM sessions WHERE session_id = ?').get(sessionId).project_path, scratch);
+    db.close();
+    assert.equal(readCompletedTurnReceiptSnapshot({ projectPath: scratch, env: childEnv(home) }).receipts.length, 1);
+
+    // 移った後の Stop: sessions の project を付け替え、全ターンの受領を移った先へ出す。
+    appendFileSync(transcriptPath, [
+      { type: 'relocated', sessionId, relocatedCwd: moved },
+      { type: 'user', message: { role: 'user', content: [{ type: 'text', text: 'second request' }] } },
+      { type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: 'second answer' }] } },
+    ].map((entry) => JSON.stringify(entry)).join('\n') + '\n', 'utf8');
+    const second = stop('second answer');
+    assert.equal(second.status, 0, second.stderr);
+    db = openDb(home);
+    assert.equal(db.prepare('SELECT project_path FROM sessions WHERE session_id = ?').get(sessionId).project_path, moved);
+    assert.equal(db.prepare('SELECT COUNT(*) AS n FROM bodies').get().n, 4);
+    db.close();
+    const receipts = readCompletedTurnReceiptSnapshot({ projectPath: moved, env: childEnv(home) });
+    assert.deepEqual(receipts.receipts.map((entry) => entry.sequence), [1, 2]);
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+    rmSync(moved, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
 test('process-turn subprocess captures the completed turn when the next user entry lands right after Stop', () => {
   const home = makeTempHome();
   const project = makeTempProject();

package/src/hosts/claude.mjs

@@ -4,7 +4,8 @@
  * Claude は Throughline の基準 host。hook payload は snake_case のまま届き、
  * 引き継ぎ注入は UserPromptSubmit hook の stdout でモデルへ渡る。
  */
-import { isAbsolute } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { isAbsolute, posix, win32 } from 'node:path';
 import { CLAUDE_HOST, hostOfSessionId } from './identity.mjs';
 
 // Claude Code の背景 task 通知は user 発言として transcript に入る。識別子・出力 path・
@@ -36,6 +37,40 @@ export function compactClaudePeerMessage(text) {
   return note < 0 ? text : text.slice(0, note);
 }
 
+// Claude Desktop は「フォルダなし」で始めた会話を、後から実在の project へ移せる。移すと transcript に
+// `{"type":"relocated","relocatedCwd":"<移った先>"}` の行が入り、transcript 自体も移った先の project の
+// 置き場へ移る。hook へ渡る CLAUDE_PROJECT_DIR は、移る前の場所のまま残る（2.1.286 で実測）。
+const RELOCATED_MARKER = '"relocated"';
+
+/**
+ * 会話が最後に移った先。移っていない会話、transcript が読めない時は null。
+ * @param {string | null | undefined} transcriptPath
+ * @returns {string | null}
+ */
+export function readClaudeRelocatedCwd(transcriptPath) {
+  if (typeof transcriptPath !== 'string' || !transcriptPath) return null;
+  let raw;
+  try { raw = readFileSync(transcriptPath, 'utf8'); }
+  catch { return null; }
+  // 道具の出力が同じ文字列を含むことがある。行を JSON として読み、行そのものの type で確かめる。
+  for (let end = raw.length; end > 0;) {
+    const marker = raw.lastIndexOf(RELOCATED_MARKER, end - 1);
+    if (marker < 0) return null;
+    const lineStart = raw.lastIndexOf('\n', marker) + 1;
+    const newline = raw.indexOf('\n', marker);
+    const line = raw.slice(lineStart, newline < 0 ? raw.length : newline);
+    try {
+      const entry = JSON.parse(line);
+      const moved = entry?.type === 'relocated' ? entry.relocatedCwd : null;
+      if (typeof moved === 'string' && (posix.isAbsolute(moved) || win32.isAbsolute(moved))) return moved;
+    } catch {
+      // 書きかけの行。前の行を探す。
+    }
+    end = lineStart;
+  }
+  return null;
+}
+
 export const claudeHostAdapter = Object.freeze({
   host: CLAUDE_HOST,
   matchesSessionId: (sessionId) => hostOfSessionId(sessionId) === CLAUDE_HOST,
@@ -45,7 +80,10 @@ export const claudeHostAdapter = Object.freeze({
   // 完了受領はセッションを起動した project に書く。hook payload の cwd は Bash の cd に
   // 追従するため、作業中に下位ディレクトリへ移ると起動 project の feed から漏れる。
   // Claude Code は hook の環境変数 CLAUDE_PROJECT_DIR に起動 project を渡す。
-  completionProjectPath({ cwd, env }) {
+  // 会話が別の project へ移っている時は、移った先を使う（CLAUDE_PROJECT_DIR は移る前のまま）。
+  completionProjectPath({ cwd, env, transcriptPath }) {
+    const relocated = readClaudeRelocatedCwd(transcriptPath);
+    if (relocated) return relocated;
     const projectDir = env?.CLAUDE_PROJECT_DIR;
     return typeof projectDir === 'string' && isAbsolute(projectDir) ? projectDir : cwd;
   },

package/src/hosts/claude.test.mjs

@@ -1,6 +1,9 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { claudeHostAdapter } from './claude.mjs';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { claudeHostAdapter, readClaudeRelocatedCwd } from './claude.mjs';
 import { codexHostAdapter } from './codex.mjs';
 import { cursorHostAdapter } from './cursor.mjs';
 import { grokHostAdapter } from './grok.mjs';
@@ -18,3 +21,57 @@ test('Codex, Grok, and Cursor completion receipts keep the hook cwd', () => {
     assert.equal(adapter.completionProjectPath({ cwd: '/work/bot', env: { CLAUDE_PROJECT_DIR: '/elsewhere' } }), '/work/bot');
   }
 });
+
+function withTranscript(lines, fn) {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-claude-host-'));
+  const transcriptPath = join(dir, 'transcript.jsonl');
+  try {
+    writeFileSync(transcriptPath, lines.join('\n'), 'utf8');
+    return fn(transcriptPath);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+// Claude Desktop 2.1.286 が書く行の形（Mac で実測）。順序は2通りある。
+const relocatedLine = (cwd) => JSON.stringify({ type: 'relocated', sessionId: '04bf5ab3-4b29-4b35-9b85-02a48eec51a1', relocatedCwd: cwd });
+const userLine = (text) => JSON.stringify({ type: 'user', message: { role: 'user', content: text } });
+
+test('readClaudeRelocatedCwd: 移っていない会話と読めない transcript は null', () => {
+  assert.equal(readClaudeRelocatedCwd(null), null);
+  assert.equal(readClaudeRelocatedCwd(join(tmpdir(), 'tl-claude-host-missing', 'none.jsonl')), null);
+  withTranscript([userLine('hello'), ''], (path) => assert.equal(readClaudeRelocatedCwd(path), null));
+});
+
+test('readClaudeRelocatedCwd: 最後に移った先を返す', () => {
+  withTranscript([userLine('a'), relocatedLine('/Users/kite/first'), userLine('b'), relocatedLine('/Users/kite/tl-claude-probe'),
+    JSON.stringify({ type: 'agent-name', agentName: 'x' }), ''], (path) => {
+    assert.equal(readClaudeRelocatedCwd(path), '/Users/kite/tl-claude-probe');
+  });
+  withTranscript([relocatedLine('C:\\Users\\kite_\\proj')], (path) => {
+    assert.equal(readClaudeRelocatedCwd(path), 'C:\\Users\\kite_\\proj');
+  });
+});
+
+test('readClaudeRelocatedCwd: 道具の出力に同じ文字列があっても、行そのものの type だけを見る', () => {
+  const quoted = JSON.stringify({ type: 'user', message: { role: 'user', content: [
+    { type: 'tool_result', tool_use_id: 't1', content: relocatedLine('/quoted/in/output') }] } });
+  withTranscript([relocatedLine('/Users/kite/real'), quoted, '{"type":"relocated","relocatedCwd":"/partial'], (path) => {
+    assert.equal(readClaudeRelocatedCwd(path), '/Users/kite/real');
+  });
+  withTranscript([quoted, relocatedLine('relative/path'), JSON.stringify({ type: 'relocated' })], (path) => {
+    assert.equal(readClaudeRelocatedCwd(path), null);
+  });
+});
+
+test('Claude completion receipts follow the project the conversation moved to (Claude Desktop)', () => {
+  const scratch = '/Users/kite/Library/Application Support/Claude/scratch-workspaces/a/b/scratch-2026-10-05-ac3fa8';
+  withTranscript([userLine('a'), relocatedLine('/Users/kite/tl-claude-probe'), ''], (transcriptPath) => {
+    assert.equal(claudeHostAdapter.completionProjectPath({
+      cwd: '/Users/kite/tl-claude-probe/sub', env: { CLAUDE_PROJECT_DIR: scratch }, transcriptPath,
+    }), '/Users/kite/tl-claude-probe');
+  });
+  withTranscript([userLine('a'), ''], (transcriptPath) => {
+    assert.equal(claudeHostAdapter.completionProjectPath({ cwd: '/work/bot/sub', env: { CLAUDE_PROJECT_DIR: '/work/bot' }, transcriptPath }), '/work/bot');
+  });
+});

package/src/session-start.mjs

@@ -24,9 +24,8 @@
  *
  * 【自動継続の後継】 ADR 0033
  *
- *   同じ project で後継の立ち上げ中の引き継ぎがある時だけ、この会話の受け口（inbox socket）を
- *   控える。worker がそれを読んで、継続の指示を1通送る。記憶の注入は、その指示が届いた時の
- *   UserPromptSubmit（上の二相ハンドオフの第二相）が行う。
+ *   後継は、継続の指示を最初の指示として付けて起動される。SessionStart では何もしない。
+ *   記憶の注入と受領は、その指示の UserPromptSubmit（上の二相ハンドオフの第二相）が行う。
  */
 
 import { getDb } from './db.mjs';
@@ -41,7 +40,6 @@ import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
 import { logHookFailure } from './hook-failure-log.mjs';
 import { CLAUDE_HOST, hostAdapterForSessionId, hostOfSessionId, NON_CLAUDE_SESSION_PREFIXES, parseHookPayload } from './hosts/index.mjs';
 import { executeFirstPromptHandoff } from './handoff-executor.mjs';
-import { recordClaudeSuccessorTarget } from './claude-auto-handoff.mjs';
 
 const ENV_DISABLE_AUTO_HANDOFF = 'THROUGHLINE_DISABLE_AUTO_HANDOFF';
 
@@ -170,11 +168,6 @@ export async function run() {
     pending_registered: true,
   });
 
-  // 自動継続の後継として立ち上がった会話なら、worker が指示を送れるように受け口を控える (ADR 0033)。
-  if (hostOfSessionId(session_id) === CLAUDE_HOST) {
-    recordClaudeSuccessorTarget({ payload, env: process.env, now });
-  }
-
   // Cursor は beforeSubmitPrompt が additional_context を持たない。
   // 新規 composer 会話の sessionStart が公式の注入口なので、ここで第二相を実行する。
   // Claude の幽霊 SessionStart 問題はこの host では sessionStart = 会話作成のため適用しない。

package/src/turn-processor.mjs

@@ -49,6 +49,8 @@ import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
 import { logHookFailure } from './hook-failure-log.mjs';
 import { writeCompletedTurnReceipt } from './completed-turn-receipts.mjs';
 import { hostAdapterForSessionId, parseHookPayload } from './hosts/index.mjs';
+import { readClaudeRelocatedCwd } from './hosts/claude.mjs';
+import { CLAUDE_HOST } from './hosts/identity.mjs';
 import { completeClaudeTurnWithoutHandoff } from './claude-auto-handoff.mjs';
 
 /** 直近 N ターンは bodies を生で残し、それより古いものだけ L1 要約する。 */
@@ -316,6 +318,20 @@ async function processStop() {
     db.prepare('UPDATE sessions SET updated_at = ? WHERE session_id = ?').run(now, target);
   }
 
+  // 完了受領と sessions の project は、会話を起動した project に合わせる。会話が別の project へ
+  // 移っている時（Claude Desktop）は、移った先へ付け替える。付け替えないと、移った先の project の
+  // 過去の会話にも Observer feed にも、この会話が出ない。
+  const hostAdapter = hostAdapterForSessionId(session_id);
+  const relocatedProjectPath = hostAdapter.host === CLAUDE_HOST ? readClaudeRelocatedCwd(transcript_path) : null;
+  const completionProjectPath = relocatedProjectPath ?? hostAdapter.completionProjectPath({
+    cwd: cwd ?? process.cwd(),
+    env: process.env,
+  });
+  if (relocatedProjectPath) {
+    db.prepare('UPDATE sessions SET project_path = ? WHERE session_id IN (?, ?) AND project_path <> ?')
+      .run(relocatedProjectPath, session_id, target, relocatedProjectPath);
+  }
+
   // L2 = transcript 全体を論理ターン群で走査し、未捕捉の完了ターンを一括回収する。
   // 従来の「最後の 1 ペアのみ保存」は Stop の空振り・不発が永久穴になった (docs/12 B-1)。
   // user / assistant は「1 往復 = 1 ターン」として同じ turn_number（= 代表 assistant
@@ -349,10 +365,6 @@ async function processStop() {
   // 過去のStopでDBだけ回収済みだったpairもreceipt storeの冪等性で穴埋めする。
   // receipt failure は Stop hook の failure として上位へ伝播させる。L1/L3/usage は
   // receipt 後の派生処理なので、そこで失敗しても completed pair を取り消さない。
-  const completionProjectPath = hostAdapterForSessionId(session_id).completionProjectPath({
-    cwd: cwd ?? process.cwd(),
-    env: process.env,
-  });
   for (const completedTurnNumber of backfill.turnNumbers) {
     publishCapturedClaudeCompletionReceipt(db, {
       target,