throughline 0.16.19 → 0.16.20

package/CHANGELOG.md

@@ -10,6 +10,31 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.20] — 2026-10-11
+
+### 修正
+
+- Claude Codeの自動継続で、後継がターンを終えてもClaude Desktopへ移らず、裏の会話のまま残る場面があった（[ADR 0050](docs/adr/0050-claude-successor-with-held-peer-message-moves-to-desktop.md)）。Windowsの実機（Claude Code 2.1.296）で2026-10-10に2回起きた（1回は2時間42分後に移り、1回は残ったまま）。利用者の別の会話から`SendMessage`で届いた文を、Claude Codeが承認まで保留していた。保留がある間、`claude agents`はその会話を、ターンの後も`waiting`（`permission prompt`）と返す。Throughlineは手すき（`idle`）の後継だけを移していた。
+  - 後継が`waiting`を返す時は、後継のtranscriptの末尾を読む。終わったターン（`stop_reason`が`end_turn`のassistantの行）で止まっていて、3秒後も同じなら、手すきと同じに扱って移す。
+  - **移す時に保留されている文は、会話へ届かないまま消える**（オーナーの裁定）。
+  - 道具の許可を本当に待っている会話（ターンの途中）と、次のターンが動いている会話は、今までどおり移さない。
+  - transcriptから読むのは行の種類と`stop_reason`だけで、本文は読まない。
+
+### 対応の範囲
+
+| | macOS | Linux | Windows |
+|---|---|---|---|
+| Claude Code | 直した。単体試験と、実機（Claude Code 2.1.289、Claude Desktop）の試験用の会話。保留を作り、0.16.19は止めず、直した版は`claude stop`→本物の`claude --desktop --resume`でDesktopの会話になる事。ターンの途中の許可待ちは止めない事 | 対象外。Claude Desktopへ移す処理が無い（Claude Codeの`--desktop`が無い）。単体試験とCIだけ | 直した。単体試験と、実機（Claude Code 2.1.296）の試験用の会話。保留を作り、0.16.19は止めず、直した版は`claude stop`まで進む事。ターンの途中の許可待ちは止めない事。**試験用の会話では`claude --desktop --resume`を呼んでいない**（止めた後の会話を開く所は0.16.9からの処理で、変えていない） |
+| Codex | 変更なし（会話から会話への文の保留が無い。引き継ぎの部品も別） | 同じ | 同じ |
+| Grok | 変更なし（自動継続が無い） | 同じ | 同じ |
+| Cursor | 変更なし（自動継続が無い） | 同じ | 同じ |
+
+### 確かめていない事
+
+- 止めた時、送り手の会話へ「届かなかった」と伝わるか。
+- リモートコントロール（claude.ai/codeとClaudeのアプリ）の画面に、保留を承認する問いが出るか。
+- 保留を持つ会話へ指示が届いた直後（その行がtranscriptに書かれる前）に、移す処理が重なる場面。
+
 ## [0.16.19] — 2026-10-11
 
 ### 修正
@@ -2306,7 +2331,8 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.19...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.20...HEAD
+[0.16.20]: https://github.com/kitepon/Throughline/compare/v0.16.19...v0.16.20
 [0.16.19]: https://github.com/kitepon/Throughline/compare/v0.16.18...v0.16.19
 [0.16.18]: https://github.com/kitepon/Throughline/compare/v0.16.17...v0.16.18
 [0.16.17]: https://github.com/kitepon/Throughline/compare/v0.16.16...v0.16.17

package/README.md

@@ -68,7 +68,7 @@ throughline auto-handoff disable --host claude
 3. 同じprojectに、継続の指示を最初の指示として付けた新しいClaudeの会話を裏で立てます（`claude --bg`）。会話の名前は、前任の会話の題から`<project名>｜<作業の概要>（自動引き継ぎ）`にします。モデル・推論強度・権限は旧い会話から引き継ぎます。
 4. 最初の指示を受け取った時に、止めた時点の依頼、そのターンでここまでにしたこと（発言と道具の呼び出し）、実行されなかった道具、直近の会話の原文を注入します（上限9,500字）。止めたターンの道具の入出力は、後継が`throughline detail`で取り出せます。
 
-続きは裏の会話で動きます。`claude agents`の一覧と`claude attach <id>`で見られます。Claude Desktopの画面から始まった会話の後継は、そのターンの作業を終えた時に、Claude Desktopへ移して開きます（macOSは0.16.8から、Windowsは0.16.9から。LinuxのClaude Codeには`--desktop`が無いので開きません。[ADR 0043](docs/adr/0043-claude-successor-opens-in-desktop.md)）。Claude Codeは裏で動いている会話をDesktopへ移さないので、作業の間はDesktopには出ません。続けて引き継いだ時は、最後に作業を終えた後継だけを開きます。端末から始めた会話の後継は開きません。手で開く時は、`claude stop <id>`で裏の実行を停止し、`claude --desktop --resume <session-id>`を実行します。`session-id`は`claude agents --json --all`の`sessionId`です。環境変数`THROUGHLINE_AUTO_HANDOFF_OPEN`を`desktop`にすると出どころに関係なく開き、`off`にすると開きません。手動`/compact`、subagentの中の圧縮、`claude -p`などscriptから起動した会話は対象に含めません。 Claude Desktopから始まった会話の後継は、リモートコントロール付きで立てるので、作業の最中もclaude.ai/codeとClaudeのアプリから見られます（0.16.16から。[ADR 0048](docs/adr/0048-claude-desktop-origin-successor-has-remote-control.md)）。
+続きは裏の会話で動きます。`claude agents`の一覧と`claude attach <id>`で見られます。Claude Desktopの画面から始まった会話の後継は、そのターンの作業を終えた時に、Claude Desktopへ移して開きます（macOSは0.16.8から、Windowsは0.16.9から。LinuxのClaude Codeには`--desktop`が無いので開きません。[ADR 0043](docs/adr/0043-claude-successor-opens-in-desktop.md)）。Claude Codeは裏で動いている会話をDesktopへ移さないので、作業の間はDesktopには出ません。続けて引き継いだ時は、最後に作業を終えた後継だけを開きます。ほかの会話から`SendMessage`で届いた文をClaude Codeが承認待ちで保留している後継も、ターンが終わっていれば開きます。その時に保留されている文は、会話へ届かずに消えます（0.16.20から。[ADR 0050](docs/adr/0050-claude-successor-with-held-peer-message-moves-to-desktop.md)）。端末から始めた会話の後継は開きません。手で開く時は、`claude stop <id>`で裏の実行を停止し、`claude --desktop --resume <session-id>`を実行します。`session-id`は`claude agents --json --all`の`sessionId`です。環境変数`THROUGHLINE_AUTO_HANDOFF_OPEN`を`desktop`にすると出どころに関係なく開き、`off`にすると開きません。手動`/compact`、subagentの中の圧縮、`claude -p`などscriptから起動した会話は対象に含めません。 Claude Desktopから始まった会話の後継は、リモートコントロール付きで立てるので、作業の最中もclaude.ai/codeとClaudeのアプリから見られます（0.16.16から。[ADR 0048](docs/adr/0048-claude-desktop-origin-successor-has-remote-control.md)）。
 
 ```bash
 throughline auto-handoff status --host claude --operation <handoff-id> --json

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

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

package/package.json

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

package/src/claude-auto-handoff.mjs

@@ -14,13 +14,14 @@
  *                                  利用者の承認まで止めるため（0.15.3）。
  *   5. 後継の Stop               : Claude Desktop から始まった会話の後継は、そのターンの作業を終えた時に
  *                                  Desktop へ移して開く（`claude stop` → `claude --desktop --resume`。macOS と Windows）。
- *                                  Claude Code は、裏で動いている会話を Desktop へ移さない。
+ *                                  Claude Code は、裏で動いている会話を Desktop へ移さない。ほかの会話から届いた文を
+ *                                  保留している後継も、ターンが終わっていれば移す（ADR 0050）。
  *
  * 旧い会話は止めるだけで、空にしない。手動の /compact と subagent の中の圧縮は対象にしない。
  * 状態は ~/.throughline/claude-auto-handoff/ のファイルに持つ（schema は変えない）。
  */
 
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, posix, resolve, win32 } from 'node:path';
 import { randomUUID } from 'node:crypto';
@@ -751,6 +752,59 @@ function readBackgroundAgent(shortId, { spawn, env }) {
   catch { return null; }
 }
 
+// 終わったターンの最後の assistant の行が持つ `stop_reason`。道具を呼んだ行（`tool_use`）と、途中で切れた行は含めない。
+const FINISHED_STOP_REASONS = new Set(['end_turn', 'stop_sequence']);
+// 後継の transcript は、末尾だけ読む。ターンの終わりの行は、最後の発言とその後の数行（hook のまとめ、題、保留の知らせ）にある。
+const TRANSCRIPT_TAIL_BYTES = 1024 * 1024;
+
+/** transcript の末尾の行を読む。途中から始まる最初の行は捨てる。読めない時は null。 */
+function readTranscriptTail(transcriptPath, bytes = TRANSCRIPT_TAIL_BYTES) {
+  let fd;
+  try {
+    fd = openSync(transcriptPath, 'r');
+    const { size } = fstatSync(fd);
+    const start = Math.max(0, size - bytes);
+    const buffer = Buffer.alloc(size - start);
+    const read = readSync(fd, buffer, 0, buffer.length, start);
+    const lines = buffer.toString('utf8', 0, read).split('\n');
+    if (start > 0) lines.shift();
+    const entries = [];
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try { entries.push(JSON.parse(line)); } catch { /* 書いている途中の最後の行 */ }
+    }
+    return { size, entries };
+  } catch { return null; }
+  finally { if (fd !== undefined) closeSync(fd); }
+}
+
+/**
+ * 後継の transcript が、終わったターンで止まっているか（ADR 0050）。
+ *
+ * 止まっている時は、その時の transcript の大きさを返す。呼ぶ側は、続けて2回同じ値が返った時だけ「動いていない」と見る。
+ * 止まっていない時（最後の発言が利用者の指示・道具の結果・道具を呼んだ assistant、または順番待ちの指示が残っている）と、
+ * 読めない時は null。会話の本文は読まない（行の種類と `stop_reason` だけを見る）。
+ */
+export function readFinishedTurnMark(transcriptPath) {
+  if (typeof transcriptPath !== 'string' || !transcriptPath) return null;
+  const tail = readTranscriptTail(transcriptPath);
+  if (!tail) return null;
+  const entries = tail.entries.filter(entry => entry && typeof entry === 'object' && entry.isSidechain !== true);
+  const last = entries.findLastIndex(entry => entry.type === 'user' || entry.type === 'assistant');
+  if (last < 0) return null;
+  const { type, message } = entries[last];
+  if (type !== 'assistant' || !FINISHED_STOP_REASONS.has(message?.stop_reason)) return null;
+  if (Array.isArray(message.content) && message.content.some(block => block?.type === 'tool_use')) return null;
+  // ターンの終わりの後に積まれた指示（`enqueue`）が、取り出されても消されてもいない。次のターンがすぐ始まる。
+  let queued = 0;
+  for (const entry of entries.slice(last + 1)) {
+    if (entry.type !== 'queue-operation') continue;
+    if (entry.operation === 'enqueue') queued += 1;
+    else if (entry.operation === 'dequeue' || entry.operation === 'remove') queued = Math.max(0, queued - 1);
+  }
+  return queued > 0 ? null : tail.size;
+}
+
 export async function launchClaudeDesktopOpen(sessionId, { dir = claudeAutoHandoffDir() } = {}) {
   if (!validSessionId(sessionId)) throw new ClaudeHandoffError('auto_handoff_session_id_invalid');
   mkdirSync(dir, { recursive: true, mode: 0o700 });
@@ -768,10 +822,11 @@ export async function launchClaudeDesktopOpen(sessionId, { dir = claudeAutoHando
 /**
  * 後継の Stop hook から呼ぶ。Claude Desktop で開く引き継ぎの後継が、ターンを終えた。
  * その会話を Desktop へ移す process を起動する。対象でない会話には何もしない（null）。
+ * `transcriptPath` は、その後継の transcript（Stop の payload の値）。移す process が、ターンが終わっているかを読む（ADR 0050）。
  *
  * @returns {Promise<string|null>} 起動した時は、その引き継ぎ ID
  */
-export async function requestClaudeDesktopOpen({ sessionId, dir = claudeAutoHandoffDir(), launch = launchClaudeDesktopOpen }) {
+export async function requestClaudeDesktopOpen({ sessionId, transcriptPath = null, dir = claudeAutoHandoffDir(), launch = launchClaudeDesktopOpen }) {
   if (!validSessionId(sessionId)) return null;
   // この会話自身が引き継ぎの途中なら、作業は次の後継が続ける。移すのは、最後に作業を終えた後継だけ。
   if (readJson(recordPath(sessionId, dir))) return null;
@@ -782,8 +837,9 @@ export async function requestClaudeDesktopOpen({ sessionId, dir = claudeAutoHand
     waiting.find(item => item.state === 'unknown' && !item.successor?.session_id &&
       typeof item.successor?.short_id === 'string' && sessionId.startsWith(item.successor.short_id));
   if (!record) return null;
-  updateRecord(record.source_session_id, { successor: { ...record.successor, session_id: sessionId },
-    desktop: { ...record.desktop, state: 'requested', error_code: null } }, { dir });
+  const successor = { ...record.successor, session_id: sessionId };
+  if (typeof transcriptPath === 'string' && transcriptPath) successor.transcript_path = transcriptPath;
+  updateRecord(record.source_session_id, { successor, desktop: { ...record.desktop, state: 'requested', error_code: null } }, { dir });
   try { await launch(record.source_session_id, { dir }); }
   catch {
     updateRecord(record.source_session_id, { desktop: { ...record.desktop, state: 'failed', error_code: 'desktop_open_start_failed' } }, { dir });
@@ -798,6 +854,10 @@ export async function requestClaudeDesktopOpen({ sessionId, dir = claudeAutoHand
  * Claude Code は、裏で動いている会話（作業中も、手すきも）を Desktop へ移さない。手すきになるのを待って
  * `claude stop` で止め、`claude --desktop --resume <session id>` で開く。この命令は出力が端末でないと動かないので、
  * 擬似端末（macOS）か新しい console（Windows）の中で呼ぶ。後継がまた動き出した時は止めずに戻り、次の Stop でやり直す。
+ *
+ * ほかの会話から届いた文を Claude Code が保留している後継は、ターンを終えても手すき（`idle`）にならず、
+ * `waiting`（`permission prompt`）のままになる。この時は transcript を読み、終わったターンで止まっていれば同じように移す。
+ * 保留されている文は、止める時に消える（ADR 0050）。道具の許可を本当に待っている会話（ターンの途中）は移さない。
  */
 export async function runClaudeDesktopOpen(sourceSessionId, {
   dir = claudeAutoHandoffDir(),
@@ -812,16 +872,22 @@ export async function runClaudeDesktopOpen(sourceSessionId, {
   if (!record) throw new ClaudeHandoffError('handoff_not_found');
   if (record.desktop?.state !== 'requested') return record;
   const set = fields => { record = updateRecord(sourceSessionId, { desktop: { ...record.desktop, ...fields } }, { dir }); return record; };
-  const { short_id: shortId, session_id: successorId } = record.successor ?? {};
+  const { short_id: shortId, session_id: successorId, transcript_path: successorTranscript } = record.successor ?? {};
   if (!shortId || !validSessionId(successorId)) return set({ state: 'failed', error_code: 'desktop_open_successor_unknown' });
   const childEnv = successorEnv(env);
 
   let idle = false;
+  let finishedMark = null;
   for (const deadline = Date.now() + idleTimeoutMs; Date.now() < deadline;) {
     // 後継がさらに引き継ぎを始めた。作業は次の後継が続けるので、この会話は移さない。
     if (readJson(recordPath(successorId, dir))) return set({ state: 'superseded' });
     const agent = readBackgroundAgent(shortId, { spawn, env: childEnv });
     if (agent?.status === 'idle') { idle = true; break; }
+    // 保留の文を持つ後継は、作業中もターンの後も `waiting` を返す。transcript が終わったターンで止まっていて、
+    // 次に見た時も同じ大きさなら、手すきと同じに扱う。1回だけでは決めない（指示が届いた直後は、その行がまだ無い）。
+    const mark = agent?.status === 'waiting' && agent.state !== 'working' ? readFinishedTurnMark(successorTranscript) : null;
+    if (mark !== null && mark === finishedMark) { idle = true; break; }
+    finishedMark = mark;
     await delay(pollMs);
   }
   // 手すきにならない（次のターンが始まった、一覧を読めない）。止めずに戻り、次の Stop でやり直す。

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

@@ -1,7 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { spawnSync } from 'node:child_process';
-import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, utimesSync, writeFileSync } from 'node:fs';
+import { appendFileSync, chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, utimesSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { delimiter, dirname, join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
@@ -16,6 +16,7 @@ import {
   listClaudeAutoHandoffs,
   publicClaudeAutoHandoff,
   claudeContinuationInput,
+  readFinishedTurnMark,
   requestClaudeDesktopOpen,
   runClaudeDesktopOpen,
 } from './claude-auto-handoff.mjs';
@@ -868,6 +869,97 @@ test('Desktop で開く: 後継が手すきになるのを待って止め、擬
   assert.equal(untouched.desktop.state, null);
 }));
 
+// ---- ほかの会話から届いた文を保留している後継（ADR 0050） ----
+
+// Claude Code 2.1.296 の transcript の形。ターンの最後の assistant は `stop_reason: end_turn`、道具を呼ぶ行は `tool_use`。
+const endTurn = text => ({ type: 'assistant', message: { role: 'assistant', stop_reason: 'end_turn', content: [{ type: 'text', text }] } });
+const callsTool = id => ({ type: 'assistant', message: { role: 'assistant', stop_reason: 'tool_use', content: [{ type: 'tool_use', id, name: 'Bash', input: {} }] } });
+const turnTail = [{ type: 'system', subtype: 'stop_hook_summary' }, { type: 'system', subtype: 'turn_duration' }, { type: 'last-prompt' }];
+// 保留の知らせは system の行で、user の行にも順番待ちの行にもならない（2026-10-11 の Windows と macOS の実測）
+const heldNotice = { type: 'system', subtype: 'informational', level: 'warning', content: 'Held peer message from another session' };
+
+test('transcript: 終わったターンで止まっている時だけ、印（transcript の大きさ）を返す', () => withDir(dir => {
+  const path = join(dir, 'successor.jsonl');
+  const mark = entries => { writeFileSync(path, jsonl(entries)); return readFinishedTurnMark(path); };
+  const finished = [user('続けて'), callsTool('t1'), toolResult('t1', 'ok'), endTurn('終わりました'), ...turnTail];
+
+  assert.equal(mark(finished), Buffer.byteLength(jsonl(finished)));
+  assert.equal(typeof mark([...finished, heldNotice]), 'number', '保留の知らせが後ろにあっても、ターンは終わっている');
+  assert.equal(mark([user('続けて'), callsTool('t1')]), null, '道具の許可を待っている（結果の無い道具の呼び出し）');
+  assert.equal(mark([user('続けて'), callsTool('t1'), toolResult('t1', 'ok')]), null, '道具の結果の後、次の発言を待っている');
+  assert.equal(mark([...finished, user('次はこれ')]), null, '次の指示が届いている');
+  assert.equal(mark([...finished, { type: 'queue-operation', operation: 'enqueue' }]), null, '順番待ちの指示が残っている');
+  assert.equal(typeof mark([...finished, { type: 'queue-operation', operation: 'enqueue' }, { type: 'queue-operation', operation: 'remove' }]), 'number',
+    '消された順番待ちは数えない');
+  assert.equal(mark([user('続けて'), assistant('途中')]), null, '`stop_reason` の無い行では決めない');
+  assert.equal(mark([user('続けて'), { type: 'assistant', message: { role: 'assistant', stop_reason: 'max_tokens', content: [{ type: 'text', text: '切れた' }] } }]), null);
+  assert.equal(typeof mark([...finished, { ...user('subagent の中'), isSidechain: true }]), 'number', 'subagent の行は見ない');
+  assert.equal(mark([]), null);
+  assert.equal(readFinishedTurnMark(join(dir, 'missing.jsonl')), null, '読めない時は決めない');
+  assert.equal(readFinishedTurnMark(null), null);
+
+  // 末尾だけを読む。長い transcript でも、最後のターンの行で決まる
+  const long = [...Array.from({ length: 400 }, (_, index) => user(`${index}`.padEnd(4_000, 'x'))), ...finished];
+  assert.equal(mark(long), Buffer.byteLength(jsonl(long)));
+}));
+
+test('Stop: 後継の transcript の場所を、移す process のために記録へ残す', () => withDir(async dir => {
+  writeRecord(dir, SESSION, {});
+  const launch = async () => {};
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, transcriptPath: '/home/u/.claude/projects/-work-app/successor.jsonl', dir, launch }), `h-${SESSION}`);
+  assert.deepEqual(readClaudeAutoHandoff(SESSION, dir).successor,
+    { short_id: SUCCESSOR.slice(0, 8), session_id: SUCCESSOR, transcript_path: '/home/u/.claude/projects/-work-app/successor.jsonl' });
+  assert.equal(JSON.stringify(publicClaudeAutoHandoff(readClaudeAutoHandoff(SESSION, dir))).includes('successor.jsonl'), false, '公開の表示には場所を出さない');
+}));
+
+test('Desktop で開く: 保留の文で waiting のままの後継も、ターンが終わっていれば止めて開く。ターンの途中の許可待ちは移さない', () => withDir(async dir => {
+  const shortId = SUCCESSOR.slice(0, 8);
+  const transcript = join(dir, 'successor.jsonl');
+  const finished = [user('続けて'), callsTool('t1'), toolResult('t1', 'ok'), endTurn('終わりました'), ...turnTail, heldNotice];
+  const run = async ({ entries, agent = {}, recordTranscript = transcript, onPoll = () => {} }) => {
+    writeFileSync(transcript, jsonl(entries));
+    writeRecord(dir, SESSION, { successor: { short_id: shortId, session_id: SUCCESSOR, ...(recordTranscript ? { transcript_path: recordTranscript } : {}) },
+      desktop: { wanted: true, state: 'requested', error_code: null, opened_at: null } });
+    const calls = [];
+    let polls = 0;
+    const spawn = (command, args) => {
+      calls.push(args[0]);
+      if (args[0] !== 'agents') return { status: 0, stdout: '' };
+      onPoll(polls += 1);
+      return { status: 0, stdout: JSON.stringify([{ id: shortId, kind: 'background', status: 'waiting', waitingFor: 'permission prompt', state: 'done', ...agent }]) };
+    };
+    const pty = (command, args) => { calls.push(args.join(' ')); return { status: 0, stdout: `Opening session ${SUCCESSOR} in Claude Desktop` }; };
+    const record = await runClaudeDesktopOpen(SESSION, { dir, env: {}, spawn, pty, idleTimeoutMs: 80, pollMs: 5 });
+    return { record, calls };
+  };
+  const untouched = result => {
+    assert.equal(result.calls.some(call => call === 'stop' || call.startsWith('--desktop')), false, '止めない・開かない');
+    assert.equal(result.record.desktop.state, null, '次の Stop でやり直せる');
+  };
+
+  // Windows と macOS の実測（2026-10-11）: ほかの会話から届いた文を保留している間、ターンを終えても `waiting / permission prompt`
+  const held = await run({ entries: finished });
+  assert.deepEqual(held.calls, ['agents', 'agents', 'stop', `--desktop --resume ${SUCCESSOR}`], '続けて2回、同じ所で止まっているのを見てから止める');
+  assert.equal(held.record.desktop.state, 'opened');
+  // ターンの終わりに付く見立てが blocked の時（実機の後継）も同じ
+  assert.equal((await run({ entries: finished, agent: { state: 'blocked' } })).record.desktop.state, 'opened');
+
+  // 道具の許可を本当に待っている（ターンの途中）
+  untouched(await run({ entries: [user('続けて'), callsTool('t1')] }));
+  // 保留を持ったまま、次のターンが動いている
+  untouched(await run({ entries: [...finished, user('次はこれ'), callsTool('t2'), toolResult('t2', 'ok')] }));
+  untouched(await run({ entries: finished, agent: { state: 'working' } }));
+  // 見ている間に transcript が伸び続ける（指示が届いた）
+  untouched(await run({ entries: finished, onPoll: () => appendFileSync(transcript, jsonl([{ type: 'last-prompt' }])) }));
+  const arrived = await run({ entries: finished, onPoll: count => { if (count === 2) appendFileSync(transcript, jsonl([user('次はこれ')])); } });
+  untouched(arrived);
+  // transcript の場所が記録に無い（0.16.19 までの版が残した記録）・読めない時は、今までどおり待つ
+  untouched(await run({ entries: finished, recordTranscript: null }));
+  untouched(await run({ entries: finished, recordTranscript: join(dir, 'missing.jsonl') }));
+  // busy は、transcript が終わったターンに見えても移さない
+  untouched(await run({ entries: finished, agent: { status: 'busy' } }));
+}));
+
 test('公開CLI: --host claude は enable・disable・status・worker を受け取る', () => {
   assert.equal(parseAutoHandoffArgs(['status', '--json']).host, 'codex');
   assert.deepEqual(

package/src/turn-processor.mjs

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