throughline 0.15.2 → 0.15.4

package/CHANGELOG.md

@@ -10,6 +10,47 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.15.4] — 2026-10-06
+
+### 修正
+
+- Claude Desktopで別のprojectへ移した会話を、移った後に1回もターンを終えないまま自動継続で引き継ぐと、後継へ記憶が入らない不具合を直す（0.15.2・0.15.3）。後継の最初の指示は、前任と後継のprojectが同じ時だけ前任を合流させる。前任の`sessions.project_path`を移った先へ付け替えるのはターン終了（Stop）だけだったので、その前に引き継ぐと移る前の場所のまま残り、合流が`project_mismatch`で見送られていた。後継は継続の指示だけを受け取り、記憶と止めた時点の依頼を持たずに動き出していた。
+- 自動圧縮を止める時（`pre-compact`）にも、移っている会話の`sessions.project_path`を移った先へ付け替える。
+
+### 確認した範囲
+
+- macOS、Claude Desktop（同梱の2.1.286、権限はバイパス、0.15.3）。画面から送った指示で、圧縮を止める・旧い会話を止める・後継を立てる・継続の指示が届く、の4段が通り、承認待ちは出なかった。1つ目の後継には記憶が入らず（上の不具合）、後継は自分でフォルダを調べて作業を続け、次の引き継ぎ（後継から後継、記憶あり）を経て作業を完了した。
+- macOS、同じ会話の本物のtranscriptの写しを使い、切り離したHOMEでhookを手で呼ぶ再現。0.15.3は`pre-compact`の後も`sessions.project_path`が移る前の場所で、後継の最初の指示は`project_mismatch`・注入なし。この版は移った先へ付け替わり、合流して注入する。
+
+### 確認していない範囲
+
+- Claude Desktopの画面で、この版の1つ目の後継に記憶が入ること。
+- Linuxで実物のClaude Codeを動かした通し。Windowsのバイパスの会話、Opus・Fableの後継（0.15.3と同じ）。
+
+
+## [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
 
 ### 修正
@@ -1790,7 +1831,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.15.2...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.15.4...HEAD
+[0.15.4]: https://github.com/kitepon/Throughline/compare/v0.15.3...v0.15.4
+[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

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` を一緒に返すと実行されない。
@@ -33,6 +33,7 @@ Claude Desktop の新しい会話は、画面を開いただけでは process
    印の project は、会話を起動した場所（`CLAUDE_PROJECT_DIR`）を、その OS の書き方にそろえたもの（0.14.2）。
    Claude Desktop で会話を別の project へ移している時は、transcript の `relocated` の行（`relocatedCwd`）が示す移った先を使う。
    `CLAUDE_PROJECT_DIR` は移る前の場所のまま届くため（0.15.2）。
+   この時、前任の `sessions.project_path` も移った先へ付け替える（0.15.4）。後継は同じ project の前任だけを合流させる。
    hook の cwd は Bash の `cd` に追従するので使わない。後継は起動した場所で立ち、その cwd で印を探す。
    手動の `/compact`、無効な project、subagent の中の圧縮（payload に `agent_id`）、script から起動した会話
    （`CLAUDE_CODE_ENTRYPOINT` が `sdk-` で始まる）では止めない。
@@ -40,7 +41,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 の時点では直前の発言が
    まだ書かれていないことがある）。
@@ -48,10 +50,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 字まで）。
@@ -61,9 +67,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 が記録を取り下げる。
@@ -108,4 +116,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.2",
+  "version": "0.15.4",
   "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,24 +8,24 @@
  *   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';
+import { claudeHostAdapter, readClaudeRelocatedCwd } from './hosts/claude.mjs';
 import {
   isJunkAssistantText,
   normalizeTerminalText,
@@ -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; }
@@ -219,7 +222,15 @@ export function requestClaudeAutoHandoff({
   }
 
   // /tl と同じ印。後継の最初の指示が、この会話を前任として合流させる。
-  writeBaton(openDb(), { projectPath, sessionId, now });
+  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 <> ?')
+      .run(projectPath, sessionId, projectPath);
+  }
+  writeBaton(db, { projectPath, sessionId, now });
   mkdirSync(dir, { recursive: true, mode: 0o700 });
   removeStale(dir, now);
   const handoffId = randomUUID();
@@ -476,44 +487,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;
+    '記憶の「実行されなかった道具」は、まだ実行されていません。最初にそれを実際に呼び出してから、先へ進んでください。' +
+    '「ここまでにしたこと」に載っている完了済みの操作は、重複実行しないでください。';
 }
 
 /**
@@ -526,15 +505,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 ?? {};
@@ -543,6 +533,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;
 }
 
@@ -553,17 +546,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);
@@ -573,7 +565,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);
@@ -597,31 +590,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,
@@ -71,13 +70,19 @@ test('PreCompact: 会話が別の project へ移っている時は、移った
   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] };
+  // SessionStart は移る前の場所で sessions の行を作っている
+  const relocatedDb = makeBatonDb();
+  relocatedDb.exec('CREATE TABLE sessions (session_id TEXT PRIMARY KEY, project_path TEXT NOT NULL)');
+  relocatedDb.prepare('INSERT INTO sessions VALUES (?, ?)').run(SESSION, scratch);
 
-  const { result, db } = request(dir, { config: onlyMoved, transcriptPath, env: { CLAUDE_PROJECT_DIR: scratch }, payload: { cwd: moved } });
+  const { result, db } = request(dir, { db: relocatedDb, 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);
+  assert.equal(db.prepare('SELECT project_path FROM sessions WHERE session_id = ?').get(SESSION).project_path, moved,
+    '後継は同じ project の前任だけを合流させるので、sessions の project も移った先にそろえる');
 }));
 
 test('PreCompact: 移っていない会話は、これまでどおり起動した project で決める', () => withDir(dir => {
@@ -243,64 +248,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,
@@ -309,9 +298,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 },
@@ -319,13 +307,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 };
@@ -364,12 +351,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') },
@@ -428,13 +413,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, [
@@ -474,13 +457,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);
@@ -488,23 +469,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 = [];
@@ -513,52 +490,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 を受け取る', () => {
@@ -710,19 +677,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/);
@@ -734,7 +696,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'));
@@ -759,6 +723,59 @@ test('hook: 自動圧縮を止め、次の道具を止めて worker を起動し
   assert.deepEqual([merged.triggered_path, merged.injection.auto_handoff_id], ['baton', record.handoff_id]);
 }));
 
+test('hook: 別の project へ移した会話（Claude Desktop）を、移った後に1回も Stop を通らないまま引き継いでも、後継へ記憶が入る', () => withDir(async home => {
+  // Desktop は「フォルダなし」で始めた会話を project へ移す。SessionStart は移る前の場所で呼ばれ、
+  // CLAUDE_PROJECT_DIR は移った後も移る前の場所のまま届く。
+  const scratch = join(home, 'scratch-2026-10-05-ac3fa8');
+  const project = join(home, 'project');
+  mkdirSync(scratch, { recursive: true });
+  mkdirSync(project, { recursive: true });
+  const transcriptPath = join(home, 'transcript.jsonl');
+  const base = Date.parse('2026-10-05T22:38:00Z');
+  const at = seconds => new Date(base + seconds * 1000).toISOString();
+  const moved = { ...fakeClaudePath(home), CLAUDE_PROJECT_DIR: scratch };
+  const hook = (command, payload, cwd = project) =>
+    cli(home, [command], JSON.stringify({ session_id: SESSION, cwd, transcript_path: transcriptPath, ...payload }), moved);
+
+  assert.equal(cli(home, ['auto-handoff', 'enable', '--host', 'claude', '--project', project, '--json']).status, 0);
+  assert.equal(hook('session-start', { hook_event_name: 'SessionStart', source: 'startup' }, scratch).status, 0);
+  writeFileSync(transcriptPath, jsonl([
+    user('14個を順に読んで', at(0)),
+    assistant('読み終えました。', at(60)),
+    { type: 'relocated', sessionId: SESSION, relocatedCwd: project },
+    user('part06 から part09 をもう一度読んで', at(3000)),
+    assistant('part06 から読みます。', at(3002)),
+    toolUse('toolu_6', 'Read', { file_path: join(project, 'part06.txt') }),
+  ]));
+
+  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_6', permission_mode: 'bypassPermissions' });
+  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 で止まる。本物は起動しない');
+
+  // 後継の最初の指示（起動時に渡された継続の指示）
+  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: project, 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\]: part06 から part09 をもう一度読んで\n/);
+  assert.match(first.stdout, /\*\*止める直前に呼ぼうとして、実行されなかった道具\*\*: Read .*part06\.txt\n/);
+
+  const db = new DatabaseSync(join(home, '.throughline', 'throughline.db'));
+  assert.equal(db.prepare('SELECT merged_into FROM sessions WHERE session_id = ?').get(SESSION).merged_into, SUCCESSOR);
+  assert.equal(db.prepare('SELECT project_path FROM sessions WHERE session_id = ?').get(SESSION).project_path, project);
+  db.close();
+}));
+
 test('hook: 自動継続が無効な時、自動圧縮を止めず、何も残さない', () => withDir(home => {
   const project = join(home, 'project');
   mkdirSync(project, { recursive: true });

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 = 会話作成のため適用しない。