throughline 0.16.7 → 0.16.8

package/CHANGELOG.md

@@ -10,6 +10,34 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.8] — 2026-10-08
+
+### 追加
+
+- Claude Codeの自動継続で、Claude Desktopの画面から始まった会話の後継を、そのターンの作業を終えた時にClaude Desktopへ移して開く（macOS。[ADR 0043](docs/adr/0043-claude-successor-opens-in-desktop.md)）。今までは、後継は裏の会話（`claude agents`の一覧）にだけ出て、Desktopの一覧には出なかった。Desktopで作業している時、旧い会話が止まり、続きが見えないまま裏で進んでいた。
+  - 後継がターンを終えると、手すきになるのを待って`claude stop`で止め、`claude --desktop --resume <session id>`で開く。Claude Codeは、裏で動いている会話（作業中も手すきも）をDesktopへ移さない。作業の間は、今までどおり裏で動く。
+  - 続けて引き継いだ時は、最後に作業を終えた後継だけを開く。
+  - 端末から始めた会話の後継は、今までどおり裏の会話のままにする。環境変数`THROUGHLINE_AUTO_HANDOFF_OPEN`で上書きできる（`desktop`は必ず開く、`off`は開かない）。
+- `auto-handoff status --host claude --json`の各引き継ぎへ、`desktop_state`（`waiting`・`requested`・`opened`・`superseded`・`failed`。対象外は`null`）と`desktop_error_code`を足す。
+
+### 変更
+
+- Desktopで開く引き継ぎでは、旧い会話を止めた理由の文に、後継がターンを終えた時にClaude Desktopへ開く事を書く。
+
+### 変わらない事
+
+- 後継の立て方（`claude --bg`）、記憶の渡し方、モデル・推論強度・権限の引き継ぎ。Codexの自動継続。schema（v12）。
+
+### 確認した範囲
+
+- macOS（Claude Code 2.1.289、Claude Desktop 2.26454.2、Haiku 4.5）の試験用フォルダで、端末から始めた会話に`THROUGHLINE_AUTO_HANDOFF_OPEN=desktop`を付けて流した。1回の引き継ぎでは、後継が作業を終えた4秒後にDesktopがその会話を取り込んだ。続けて3回の引き継ぎでは、最後の後継だけが取り込まれた。
+
+### 確認していない範囲
+
+- Claude Desktopの画面から始めた本物の会話での通し。印の付き方は、実物の会話記録の値（`"entrypoint":"claude-desktop"`）と単体の試験で確かめた。
+- WindowsとLinuxのClaude Desktop（この版は開かない）。
+- 長いターンの後継と、後継が質問で止まった時の見え方。
+
 ## [0.16.7] — 2026-10-08
 
 ### 修正
@@ -2027,7 +2055,8 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.7...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.8...HEAD
+[0.16.8]: https://github.com/kitepon/Throughline/compare/v0.16.7...v0.16.8
 [0.16.7]: https://github.com/kitepon/Throughline/compare/v0.16.6...v0.16.7
 [0.16.6]: https://github.com/kitepon/Throughline/compare/v0.16.5...v0.16.6
 [0.16.5]: https://github.com/kitepon/Throughline/compare/v0.16.4...v0.16.5

package/README.ja.md

@@ -61,7 +61,7 @@ throughline auto-handoff disable --host claude
 3. 同じprojectに、継続の指示を最初の指示として付けた新しいClaudeの会話を裏で立てます（`claude --bg`）。会話の名前は、前任の会話の題から`<project名>｜<作業の概要>（自動引き継ぎ）`にします。モデル・推論強度・権限は旧い会話から引き継ぎます。
 4. 最初の指示を受け取った時に、止めた時点の依頼、そのターンでここまでにしたこと（発言と道具の呼び出し）、実行されなかった道具、直近の会話の原文を注入します（上限9,500字）。止めたターンの道具の入出力は、後継が`throughline detail`で取り出せます。
 
-続きは裏の会話で動きます。`claude agents`の一覧と`claude attach <id>`で見られます。Desktopへ自動で表示はしません。Desktopで開く時は、作業完了を確認して`claude stop <id>`で裏の実行を停止し、`claude --desktop --resume <session-id>`を実行します。`session-id`は`claude agents --json --all`の`sessionId`です。手動`/compact`、subagentの中の圧縮、`claude -p`などscriptから起動した会話は対象に含めません。
+続きは裏の会話で動きます。`claude agents`の一覧と`claude attach <id>`で見られます。Claude Desktopの画面から始まった会話の後継は、そのターンの作業を終えた時に、Claude Desktopへ移して開きます（macOS、0.16.8から。[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から起動した会話は対象に含めません。
 
 ```bash
 throughline auto-handoff status --host claude --operation <handoff-id> --json

package/README.md

@@ -60,7 +60,7 @@ throughline auto-handoff disable --host claude
 3. 同じprojectに、継続の指示を最初の指示として付けた新しいClaudeの会話を裏で立てます（`claude --bg`）。会話の名前は、前任の会話の題から`<project名>｜<作業の概要>（自動引き継ぎ）`にします。モデル・推論強度・権限は旧い会話から引き継ぎます。
 4. 最初の指示を受け取った時に、止めた時点の依頼、そのターンでここまでにしたこと（発言と道具の呼び出し）、実行されなかった道具、直近の会話の原文を注入します（上限9,500字）。止めたターンの道具の入出力は、後継が`throughline detail`で取り出せます。
 
-続きは裏の会話で動きます。`claude agents`の一覧と`claude attach <id>`で見られます。Desktopへ自動で表示はしません。Desktopで開く時は、作業完了を確認して`claude stop <id>`で裏の実行を停止し、`claude --desktop --resume <session-id>`を実行します。`session-id`は`claude agents --json --all`の`sessionId`です。手動`/compact`、subagentの中の圧縮、`claude -p`などscriptから起動した会話は対象に含めません。
+続きは裏の会話で動きます。`claude agents`の一覧と`claude attach <id>`で見られます。Claude Desktopの画面から始まった会話の後継は、そのターンの作業を終えた時に、Claude Desktopへ移して開きます（macOS、0.16.8から。[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から起動した会話は対象に含めません。
 
 ```bash
 throughline auto-handoff status --host claude --operation <handoff-id> --json

package/docs/adr/0043-claude-successor-opens-in-desktop.md

@@ -0,0 +1,68 @@
+# ADR 0043: Claude Desktop から始まった会話の後継を、作業を終えた時に Desktop へ開く
+
+日付: 2026-10-08
+
+## Context
+
+Claude Code の自動継続は、後継を `claude --bg`（裏の会話）で立てる（ADR 0033）。Claude Desktop と端末は会話の一覧が別で、
+裏の会話は Desktop の一覧に出ない。Desktop で作業している利用者には、旧い会話が止まり、続きが見えないまま裏で進む
+（2026-10-08、オーナーの指摘「デスクトップで新しいセッションが見えてるかは不明ということかな？」「直してくれ」）。
+
+macOS（Claude Code 2.1.289、Claude Desktop 2.26454.2）で確かめた事:
+
+- 0.16.7 の後継3つは、Desktop の会話の置き場（`claude-code-sessions/…/local_<id>.json`）に入らず、Desktop のログにも出なかった。
+- 公式の入口は `claude --desktop --resume <session-id>`。公式の説明は「別の端末で開いている会話と、裏でまだ動いている会話は
+  移さない」と書いている（[一次ソース抜粋](../../rag/01-hooks/raw/claude-desktop-session-open-extract.md)）。
+- 裏の会話を3つの状態で試した。作業中（`claude agents` の `status: busy`）と、ターンを終えた手すき（`status: idle`）は、
+  どちらも `That session is running in the background` で断られた。`claude stop <id>` の後は通り、Desktop のログに
+  `Resume deep link: importing CLI session …` → `Imported CLI session … as Desktop session local_…` が出た。
+- `claude --desktop` は、出力が端末でないと動かない（`can't run non-interactively (… or redirected output)`）。
+  `script -q /dev/null claude --desktop --resume <id>` で擬似端末を挟むと、端末の無い process からも通る。
+- Desktop へ「resume」を渡す URL は公開されていない。Desktop の公開の link は `claude://code/new`（新しい会話の下書き）だけ。
+- Desktop の画面から始まった会話の transcript は、各行に `"entrypoint":"claude-desktop"` を持つ。端末と裏の会話は `cli`。
+
+動いている最中の後継を Desktop に出す道は無い。出せるのは、後継を止めた後だけ。
+
+## Decision
+
+1. Claude Desktop から始まった会話の後継は、**そのターンの作業を終えた時に**、Desktop へ移して開く。
+   作業の間は今までどおり裏で動く（モデル・推論強度・権限は旧い会話のまま）。
+2. Desktop から始まったかは、止める時点の transcript の最後の `entrypoint`（`claude-desktop`）と、hook の環境変数
+   `CLAUDE_CODE_ENTRYPOINT` で決め、引き継ぎの記録に `desktop.wanted` として残す。裏で作業している後継がさらに引き継ぐ時は、
+   元の会話の印を引き継ぐ。端末から始めた会話の後継は、今までどおり `claude agents` の一覧に出すだけにする。
+3. きっかけは後継自身の Stop hook。対象の後継がターンを終えたら、切り離した process を起動する。その process は
+   `claude agents --json --all` でその後継が手すき（`status: idle`）になるのを待ち、`claude stop <短い ID>` で止め、
+   擬似端末の中で `claude --desktop --resume <session id>` を呼ぶ。出力の `Opening session <id>` と終了 code で成否を決める。
+4. 後継が引き継ぎの途中（その後継自身の記録がある）なら移さない。作業は次の後継が続けるので、移すのは最後に作業を終えた
+   後継だけ。手すきにならないまま時間切れになった時は、止めずに戻り、次の Stop でやり直す。
+5. 対応は macOS だけ（擬似端末に `/usr/bin/script` を使う）。ほかの OS では印を付けず、今までどおり裏の会話のままにする。
+6. 環境変数 `THROUGHLINE_AUTO_HANDOFF_OPEN` で上書きできる。`desktop` は出どころに関係なく開き、`off` は開かない。
+7. 旧い会話を止めた理由の文に、後継がターンを終えた時に Desktop へ開く事を書く。
+8. 結果は記録の `desktop`（`state`: `requested`・`opened`・`superseded`・`failed`、`error_code`、`opened_at`）に残し、
+   `auto-handoff status --host claude --json` の `desktop_state`・`desktop_error_code` で読める。失敗しても引き継ぎの
+   `state` は変えない（作業は後継が済ませている）。
+
+## Consequences
+
+- Desktop で作業している利用者は、後継の作業が終わると、その会話が Desktop に開いて続きを打てる。
+- 後継が作業している間は、Desktop には出ない。長いターンの間は、旧い会話の止めた理由の文だけが手がかりになる。
+  途中の様子は `claude agents`・`claude attach <id>` で見られる。
+- Desktop へ移した会話の権限は、Desktop が決める（実測では `acceptEdits` で取り込まれた）。作業のターンは移す前に
+  終わっているので、作業中の権限は変わらない。
+- `claude stop` の後で `--desktop --resume` が失敗すると、後継は止まったまま裏に残る。記録に理由が残り、
+  `claude --resume <session id>` か、手で `claude --desktop --resume <session id>` で開ける。
+- Claude の Stop hook は、会話ごとに引き継ぎの記録の一覧を1回読む（記録は数個）。
+
+## 確かめた範囲
+
+macOS、Claude Code 2.1.289、Haiku 4.5、試験用フォルダ。端末から始めた会話に `THROUGHLINE_AUTO_HANDOFF_OPEN=desktop` を
+付けて流した（[実測](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-05-claude-auto-handoff.md)）。
+
+- 1回の引き継ぎ: 後継が 22:00:59 に作業を終え、22:01:03 に Desktop が取り込んだ。
+- 続けて3回の引き継ぎ: 最後の後継だけが移り（22:03:13）、途中の2つは移らなかった。
+
+## 確かめていない範囲
+
+- Claude Desktop の画面から始めた本物の会話での通し（印の付き方は、実物の transcript の値と単体の試験で確かめた）。
+- Windows と Linux の Claude Desktop。
+- 長いターンの後継と、後継が質問で止まった時の見え方。

package/package.json

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

package/src/claude-auto-handoff.mjs

@@ -12,6 +12,9 @@
  *   4. 後継の UserPromptSubmit   : その指示が baton を消費し、記憶を注入して、受領を残す。worker は受領を待つ。
  *                                  外から後継へ文を送らない。権限のバイパス中の会話は、外から届いた文を
  *                                  利用者の承認まで止めるため（0.15.3）。
+ *   5. 後継の Stop               : Claude Desktop から始まった会話の後継は、そのターンの作業を終えた時に
+ *                                  Desktop へ移して開く（`claude stop` → `claude --desktop --resume`）。
+ *                                  Claude Code は、裏で動いている会話を Desktop へ移さない。
  *
  * 旧い会話は止めるだけで、空にしない。手動の /compact と subagent の中の圧縮は対象にしない。
  * 状態は ~/.throughline/claude-auto-handoff/ のファイルに持つ（schema は変えない）。
@@ -37,6 +40,7 @@ import { captureInFlightTurn } from './turn-backfill.mjs';
 import { resolveMergeTarget } from './session-merger.mjs';
 import { writeBaton } from './baton.mjs';
 import { sameProjectPath } from './project-path.mjs';
+import { runWithPty } from './os/pty-run.mjs';
 import { spawnPortable, spawnPortableSync } from './os/portable-spawn-sync.mjs';
 import { composeAutoHandoffTitle } from './auto-handoff-title.mjs';
 
@@ -53,6 +57,11 @@ const BACKGROUNDED_PATTERN = /backgrounded\s+\S+\s+([0-9a-f]{8})\b/;
 const PER_SESSION_ENV = ['CLAUDECODE', 'CLAUDE_CODE_ENTRYPOINT', 'CLAUDE_CODE_MESSAGING_SOCKET',
   'CLAUDE_CODE_MESSAGING_TOKEN', 'CLAUDE_CODE_SSE_PORT', 'CLAUDE_PROJECT_DIR', 'CLAUDE_ENV_FILE'];
 
+// Claude Desktop の画面から始まった会話が transcript に持つ印。
+const DESKTOP_ENTRYPOINT = 'claude-desktop';
+// 後継を Desktop で開くかを、会話の出どころに関係なく決める（`desktop` で必ず開く、`off` で開かない）。
+const OPEN_OVERRIDE_ENV = 'THROUGHLINE_AUTO_HANDOFF_OPEN';
+
 // requested と failed は、次の道具の hook が後継の立ち上げを始められる。
 const RETRYABLE_STATES = new Set(['requested', 'failed']);
 // 後継の最初の指示は、worker が後継の ID を記録へ写す前に届くことがある（launching）。
@@ -133,6 +142,9 @@ export function publicClaudeAutoHandoff(record) {
     successor_session_id: successor?.session_id ?? null, successor_short_id: successor?.short_id ?? null,
     // 止めたターンを DB へ取り込めたか。false の時、後継は `throughline detail` でそのターンの入出力を取れない。
     in_flight_captured: Boolean(record.in_flight?.turn),
+    // 後継を Claude Desktop で開く引き継ぎか、開けたか（null は対象外）。
+    desktop_state: record.desktop?.wanted ? (record.desktop.state ?? 'waiting') : null,
+    desktop_error_code: record.desktop?.error_code ?? null,
     requested_at, updated_at };
 }
 
@@ -187,6 +199,26 @@ function unsupportedEntrypoint(env) {
   return typeof env.CLAUDE_CODE_ENTRYPOINT === 'string' && env.CLAUDE_CODE_ENTRYPOINT.startsWith('sdk-');
 }
 
+/** transcript の最後の行が持つ出どころ（`cli`、`claude-desktop` など）。読めなければ null。 */
+function readLatestEntrypoint(transcriptPath) {
+  if (typeof transcriptPath !== 'string') return null;
+  let entries;
+  try { entries = readRawEntries(transcriptPath); } catch { return null; }
+  return entries.findLast(entry => typeof entry?.entrypoint === 'string')?.entrypoint ?? null;
+}
+
+/**
+ * この会話の後継を、Claude Desktop で開くか。
+ * Desktop の画面から始まった会話と、その後継がさらに引き継ぐ時だけ開く。端末から始めた会話の後継は
+ * `claude agents` の一覧に出るので、Desktop へは移さない。開く命令を通せるのは macOS だけ。
+ */
+function openInDesktopWanted({ sessionId, transcriptPath, env, dir, platform }) {
+  if (platform !== 'darwin' || env[OPEN_OVERRIDE_ENV] === 'off') return false;
+  if (env[OPEN_OVERRIDE_ENV] === 'desktop') return true;
+  if (env.CLAUDE_CODE_ENTRYPOINT === DESKTOP_ENTRYPOINT || readLatestEntrypoint(transcriptPath) === DESKTOP_ENTRYPOINT) return true;
+  return listClaudeAutoHandoffs({ dir }).some(record => record.successor?.session_id === sessionId && record.desktop?.wanted);
+}
+
 /**
  * 会話を起動した project の場所を、その OS の書き方にそろえる。
  *
@@ -273,6 +305,8 @@ export function requestClaudeAutoHandoff({
     successor: null,
     error_code: null,
     accepted_at: null,
+    desktop: { wanted: openInDesktopWanted({ sessionId, transcriptPath: payload.transcript_path, env, dir, platform }),
+      state: null, error_code: null, opened_at: null },
   });
   return { status: 'requested', block: true, sessionId, projectPath, handoffId };
 }
@@ -452,7 +486,10 @@ export async function launchClaudeAutoHandoffWorker(sessionId, { dir = claudeAut
 function stopOutput(record) {
   const reason = record.successor?.short_id
     ? `この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: ${record.handoff_id}）。続きは後継の会話で行ってください: claude attach ${record.successor.short_id}`
-    : `Throughlineが、自動圧縮の代わりに新しい会話へ引き継ぎます（引き継ぎID: ${record.handoff_id}）。後継の会話は \`claude agents\` の一覧に出ます。`;
+    : `Throughlineが、自動圧縮の代わりに新しい会話へ引き継ぎます（引き継ぎID: ${record.handoff_id}）。` +
+      (record.desktop?.wanted
+        ? '後継の会話は裏で作業を続け、そのターンを終えた時にClaude Desktopへ開きます。途中の様子は `claude agents` の一覧で見られます。'
+        : '後継の会話は `claude agents` の一覧に出ます。');
   return {
     continue: false,
     stopReason: reason,
@@ -645,3 +682,93 @@ export async function runClaudeAutoHandoffWorker(sessionId, {
   }
   return update({ state: 'unknown', error_code: 'handoff_delivery_unconfirmed' });
 }
+
+/** `claude agents --json --all` から、その後継（裏の会話）の行を読む。読めない時は null。 */
+function readBackgroundAgent(shortId, { spawn, env }) {
+  const listed = spawn('claude', ['agents', '--json', '--all'], { env, encoding: 'utf8', timeout: 30_000, stdio: ['ignore', 'pipe', 'pipe'] });
+  if (listed.error || listed.status !== 0) return null;
+  try { return JSON.parse(listed.stdout).find(agent => agent?.id === shortId && agent.kind === 'background') ?? null; }
+  catch { return null; }
+}
+
+export async function launchClaudeDesktopOpen(sessionId, { dir = claudeAutoHandoffDir() } = {}) {
+  if (!validSessionId(sessionId)) throw new ClaudeHandoffError('auto_handoff_session_id_invalid');
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const log = openSync(join(dir, `${sessionId}.desktop.log`), 'a', 0o600);
+  try {
+    const child = spawnPortable(process.execPath,
+      [CLI_PATH, 'auto-handoff', 'desktop-open', '--host', 'claude', '--operation', sessionId, '--json'],
+      { detached: true, stdio: ['ignore', log, log], windowsHide: true });
+    await new Promise((resolveSpawn, reject) => { child.once('spawn', resolveSpawn); child.once('error', reject); });
+    child.unref();
+    return child.pid;
+  } finally { closeSync(log); }
+}
+
+/**
+ * 後継の Stop hook から呼ぶ。Claude Desktop で開く引き継ぎの後継が、ターンを終えた。
+ * その会話を Desktop へ移す process を起動する。対象でない会話には何もしない（null）。
+ *
+ * @returns {Promise<string|null>} 起動した時は、その引き継ぎ ID
+ */
+export async function requestClaudeDesktopOpen({ sessionId, dir = claudeAutoHandoffDir(), launch = launchClaudeDesktopOpen }) {
+  if (!validSessionId(sessionId)) return null;
+  // この会話自身が引き継ぎの途中なら、作業は次の後継が続ける。移すのは、最後に作業を終えた後継だけ。
+  if (readJson(recordPath(sessionId, dir))) return null;
+  const record = listClaudeAutoHandoffs({ dir }).find(item => item.successor?.session_id === sessionId &&
+    item.state === 'sent' && item.desktop?.wanted && !item.desktop.state);
+  if (!record) return null;
+  updateRecord(record.source_session_id, { 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 });
+    return null;
+  }
+  return record.handoff_id;
+}
+
+/**
+ * 作業を終えた後継を、Claude Desktop へ移して開く。
+ *
+ * Claude Code は、裏で動いている会話（作業中も、手すきも）を Desktop へ移さない。手すきになるのを待って
+ * `claude stop` で止め、`claude --desktop --resume <session id>` で開く。この命令は出力が端末でないと動かないので、
+ * 擬似端末の中で呼ぶ。後継がまた動き出した時は止めずに戻り、次の Stop でやり直す。
+ */
+export async function runClaudeDesktopOpen(sourceSessionId, {
+  dir = claudeAutoHandoffDir(),
+  env = process.env,
+  spawn = spawnPortableSync,
+  pty = runWithPty,
+  idleTimeoutMs = 120_000,
+  pollMs = 1_000,
+} = {}) {
+  let record = readClaudeAutoHandoff(sourceSessionId, dir);
+  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 ?? {};
+  if (!shortId || !validSessionId(successorId)) return set({ state: 'failed', error_code: 'desktop_open_successor_unknown' });
+  const childEnv = successorEnv(env);
+
+  let idle = false;
+  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; }
+    await delay(pollMs);
+  }
+  // 手すきにならない（次のターンが始まった、一覧を読めない）。止めずに戻り、次の Stop でやり直す。
+  if (!idle) return set({ state: null });
+
+  const stopped = spawn('claude', ['stop', shortId], { env: childEnv, encoding: 'utf8', timeout: 30_000, stdio: ['ignore', 'pipe', 'pipe'] });
+  if (stopped.error || stopped.status !== 0) return set({ state: 'failed', error_code: 'desktop_open_stop_failed' });
+  const opened = pty('claude', ['--desktop', '--resume', successorId], { cwd: record.project_path, env: childEnv, timeout: 60_000 });
+  const output = normalizeTerminalText(`${opened?.stdout ?? ''}${opened?.stderr ?? ''}`);
+  if (!opened || opened.error || opened.status !== 0 || !output.includes(`Opening session ${successorId}`)) {
+    // 理由を端末内のログに残す（命令の出力だけ。会話の中身は含まれない）。
+    process.stderr.write(`[auto-handoff] claude --desktop --resume exit=${opened?.status ?? 'unsupported'} output=${JSON.stringify(output.slice(-400))}\n`);
+    return set({ state: 'failed', error_code: opened ? 'desktop_open_failed' : 'desktop_open_platform_unsupported' });
+  }
+  return set({ state: 'opened', error_code: null, opened_at: Date.now() });
+}

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

@@ -16,6 +16,8 @@ import {
   listClaudeAutoHandoffs,
   publicClaudeAutoHandoff,
   claudeContinuationInput,
+  requestClaudeDesktopOpen,
+  runClaudeDesktopOpen,
 } from './claude-auto-handoff.mjs';
 import { parseAutoHandoffArgs } from './cli/auto-handoff.mjs';
 
@@ -57,7 +59,7 @@ function request(dir, overrides = {}) {
       ...overrides.payload },
     env: overrides.env ?? {}, config: overrides.config ?? ENABLED, openDb: () => db, dir, now: overrides.now ?? 1_000,
     // 試験の project は POSIX の書き方（/work/app）。Windows の CI でも同じ値で比べる
-    platform: 'linux',
+    platform: overrides.platform ?? 'linux',
   });
   return { result, db };
 }
@@ -593,6 +595,138 @@ test('最初の指示: 後継だけが止めた時点の依頼を受け取り、
   assert.equal(acceptance().accepted_at, 9_500);
 }));
 
+// ---- 後継を Claude Desktop で開く ----
+
+function writeRecord(dir, sourceId, fields) {
+  writeFileSync(join(dir, `${sourceId}.json`), JSON.stringify({ schema: 'throughline.claude-auto-handoff.v2', handoff_id: `h-${sourceId}`,
+    source_session_id: sourceId, project_path: '/work/app', transcript_path: null, state: 'sent', requested_at: 1_000, updated_at: 1_000,
+    settings: null, in_flight: null, successor: { short_id: SUCCESSOR.slice(0, 8), session_id: SUCCESSOR }, error_code: null, accepted_at: 2_000,
+    desktop: { wanted: true, state: null, error_code: null, opened_at: null }, ...fields }));
+}
+
+test('PreCompact: Claude Desktop から始まった会話と、その後継の引き継ぎだけ、後継を Desktop で開く印を付ける（macOS）', () => withDir(dir => {
+  const wanted = overrides => {
+    rmSync(join(dir, `${SESSION}.json`), { force: true });
+    request(dir, overrides);
+    return readClaudeAutoHandoff(SESSION, dir).desktop;
+  };
+  const desktopTranscript = join(dir, 'desktop.jsonl');
+  writeFileSync(desktopTranscript, jsonl([{ ...user('読んで', '2026-10-08T12:00:00.000Z'), entrypoint: 'claude-desktop' },
+    { ...assistant('読みました', '2026-10-08T12:00:05.000Z'), entrypoint: 'claude-desktop' }]));
+  const cliTranscript = join(dir, 'cli.jsonl');
+  writeFileSync(cliTranscript, jsonl([{ ...user('読んで', '2026-10-08T12:00:00.000Z'), entrypoint: 'cli' }]));
+
+  assert.deepEqual(wanted({ platform: 'darwin', transcriptPath: desktopTranscript }), { wanted: true, state: null, error_code: null, opened_at: null });
+  assert.equal(wanted({ platform: 'darwin', env: { CLAUDE_CODE_ENTRYPOINT: 'claude-desktop' } }).wanted, true);
+  assert.equal(wanted({ platform: 'darwin', transcriptPath: cliTranscript }).wanted, false, '端末から始めた会話の後継は、claude agents の一覧に出る');
+  assert.equal(wanted({ platform: 'darwin' }).wanted, false);
+  assert.equal(wanted({ platform: 'linux', transcriptPath: desktopTranscript }).wanted, false, '開く命令を通せるのは macOS だけ');
+  assert.equal(wanted({ platform: 'win32', payload: { cwd: 'C:\\work\\app' }, env: { CLAUDE_CODE_ENTRYPOINT: 'claude-desktop' } }).wanted, false);
+  assert.equal(wanted({ platform: 'darwin', transcriptPath: cliTranscript, env: { THROUGHLINE_AUTO_HANDOFF_OPEN: 'desktop' } }).wanted, true);
+  assert.equal(wanted({ platform: 'darwin', transcriptPath: desktopTranscript, env: { THROUGHLINE_AUTO_HANDOFF_OPEN: 'off' } }).wanted, false);
+
+  // 裏で作業している後継がさらに引き継ぐ時は、元の会話の出どころを引き継ぐ（後継の transcript は cli）。
+  writeRecord(dir, 'origin-desktop', { successor: { short_id: SESSION.slice(0, 8), session_id: SESSION } });
+  assert.equal(wanted({ platform: 'darwin', transcriptPath: cliTranscript }).wanted, true);
+  writeRecord(dir, 'origin-desktop', { successor: { short_id: SESSION.slice(0, 8), session_id: SESSION }, desktop: { wanted: false, state: null } });
+  assert.equal(wanted({ platform: 'darwin', transcriptPath: cliTranscript }).wanted, false);
+}));
+
+test('PreToolUse: Desktop で開く引き継ぎは、止めた理由に、後継がターンを終えた時に Desktop へ開く事を書く', () => withDir(async dir => {
+  const desktopTranscript = join(dir, 'desktop.jsonl');
+  writeFileSync(desktopTranscript, jsonl([{ ...user('読んで', '2026-10-08T12:00:00.000Z'), entrypoint: 'claude-desktop' }]));
+  request(dir, { platform: 'darwin', transcriptPath: desktopTranscript });
+  const output = await stopClaudeTurnForHandoff({ payload: { session_id: SESSION, cwd: '/work/app', tool_use_id: 't1' }, dir, launchWorker: async () => 1 });
+  assert.match(output.stopReason, /そのターンを終えた時にClaude Desktopへ開きます。途中の様子は `claude agents` の一覧で見られます。$/);
+}));
+
+test('Stop: Desktop で開く引き継ぎの後継がターンを終えたら、移す process を1回だけ起動する', () => withDir(async dir => {
+  const launched = [];
+  const launch = async (id) => { launched.push(id); };
+  // 対象でない会話
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), null);
+  writeRecord(dir, SESSION, { desktop: { wanted: false, state: null } });
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), null, '端末から始めた会話の後継は移さない');
+  writeRecord(dir, SESSION, { state: 'unknown' });
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), null, '受領を確かめられていない後継は移さない');
+  // 対象の後継
+  writeRecord(dir, SESSION, {});
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: SESSION, dir, launch }), null, '旧い会話自身の Stop では動かない');
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), `h-${SESSION}`);
+  assert.deepEqual(launched, [SESSION]);
+  assert.equal(readClaudeAutoHandoff(SESSION, dir).desktop.state, 'requested');
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), null, '2回目の Stop では起動しない');
+  assert.deepEqual(launched, [SESSION]);
+
+  // 後継自身が引き継ぎの途中（作業は次の後継が続ける）なら、移さない
+  writeRecord(dir, SESSION, {});
+  writeRecord(dir, SUCCESSOR, { state: 'stopped', successor: null });
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch }), null);
+  assert.deepEqual(launched, [SESSION]);
+
+  // 起動に失敗した時は理由を残す
+  rmSync(join(dir, `${SUCCESSOR}.json`));
+  assert.equal(await requestClaudeDesktopOpen({ sessionId: SUCCESSOR, dir, launch: async () => { throw new Error('spawn'); } }), null);
+  assert.deepEqual([readClaudeAutoHandoff(SESSION, dir).desktop.state, readClaudeAutoHandoff(SESSION, dir).desktop.error_code], ['failed', 'desktop_open_start_failed']);
+}));
+
+test('Desktop で開く: 後継が手すきになるのを待って止め、擬似端末の中で claude --desktop --resume を呼ぶ', () => withDir(async dir => {
+  const shortId = SUCCESSOR.slice(0, 8);
+  const run = async ({ statuses, stopStatus = 0, opened, beforePoll = () => {} }) => {
+    writeRecord(dir, SESSION, { desktop: { wanted: true, state: 'requested', error_code: null, opened_at: null } });
+    const calls = [];
+    const spawn = (command, args, options) => {
+      calls.push([command, ...args]);
+      if (args[0] === 'agents') {
+        beforePoll();
+        const status = statuses.length > 1 ? statuses.shift() : statuses[0];
+        return { status: 0, stdout: JSON.stringify([{ id: shortId, kind: 'interactive', status: 'idle' }, { id: 'ffffffff', kind: 'background', status: 'idle' },
+          ...(status === null ? [] : [{ id: shortId, kind: 'background', status, sessionId: SUCCESSOR }])]) };
+      }
+      assert.deepEqual(options.env, { PATH: '/bin' }, '会話ごとの環境変数は渡さない');
+      return { status: stopStatus, stdout: `stopped ${shortId}\n` };
+    };
+    const pty = (command, args, options) => { calls.push(['pty', command, ...args, options.cwd]); return opened; };
+    const record = await runClaudeDesktopOpen(SESSION, { dir, env: { PATH: '/bin', CLAUDECODE: '1', CLAUDE_CODE_ENTRYPOINT: 'cli' }, spawn, pty, idleTimeoutMs: 60, pollMs: 5 });
+    return { record, calls };
+  };
+  const ok = { status: 0, stdout: `\u0004\b\bOpening session ${SUCCESSOR} in Claude Desktop\r\n`, stderr: '' };
+
+  // macOS の実測（2026-10-08）: 作業中は busy、ターンを終えると idle。どちらも `--desktop --resume` は断られ、stop の後だけ通る。
+  const done = await run({ statuses: ['busy', 'busy', 'idle'], opened: ok });
+  assert.deepEqual(done.calls.slice(-2), [['claude', 'stop', shortId], ['pty', 'claude', '--desktop', '--resume', SUCCESSOR, '/work/app']]);
+  assert.equal(done.calls.filter(call => call[1] === 'agents').length, 3);
+  assert.deepEqual([done.record.desktop.state, done.record.desktop.error_code, typeof done.record.desktop.opened_at], ['opened', null, 'number']);
+  assert.equal(done.record.state, 'sent', '引き継ぎの状態は変えない');
+  assert.deepEqual([publicClaudeAutoHandoff(done.record).desktop_state, publicClaudeAutoHandoff(done.record).desktop_error_code], ['opened', null]);
+
+  // 手すきにならない（次のターンが始まった）: 止めずに戻り、次の Stop でやり直せる状態にする
+  const busy = await run({ statuses: ['busy'], opened: ok });
+  assert.equal(busy.calls.some(call => call[1] === 'stop' || call[0] === 'pty'), false);
+  assert.equal(busy.record.desktop.state, null);
+  const missing = await run({ statuses: [null], opened: ok });
+  assert.equal(missing.calls.some(call => call[1] === 'stop'), false, '一覧に無い会話は止めない');
+
+  // 待つ間に、後継がさらに引き継ぎを始めた
+  const superseded = await run({ statuses: ['busy'], opened: ok,
+    beforePoll: () => writeRecord(dir, SUCCESSOR, { state: 'requested', successor: null }) });
+  assert.equal(superseded.record.desktop.state, 'superseded');
+  assert.equal(superseded.calls.some(call => call[1] === 'stop'), false);
+  rmSync(join(dir, `${SUCCESSOR}.json`));
+
+  // 止められない・開けない時は、固定の理由を残す
+  const stopFailed = await run({ statuses: ['idle'], stopStatus: 1, opened: ok });
+  assert.deepEqual([stopFailed.record.desktop.state, stopFailed.record.desktop.error_code], ['failed', 'desktop_open_stop_failed']);
+  assert.equal(stopFailed.calls.some(call => call[0] === 'pty'), false);
+  const refused = await run({ statuses: ['idle'], opened: { status: 1, stdout: `Session ${SUCCESSOR} is open in another terminal. Run /desktop there instead.\r\n`, stderr: '' } });
+  assert.deepEqual([refused.record.desktop.state, refused.record.desktop.error_code], ['failed', 'desktop_open_failed']);
+
+  // 対象でない記録には何もしない
+  writeRecord(dir, SESSION, {});
+  const untouched = await runClaudeDesktopOpen(SESSION, { dir, spawn: () => { throw new Error('must not run'); }, pty: () => { throw new Error('must not run'); } });
+  assert.equal(untouched.desktop.state, null);
+}));
+
 test('公開CLI: --host claude は enable・disable・status・worker を受け取る', () => {
   assert.equal(parseAutoHandoffArgs(['status', '--json']).host, 'codex');
   assert.deepEqual(
@@ -601,8 +735,10 @@ test('公開CLI: --host claude は enable・disable・status・worker を受け
   );
   assert.equal(parseAutoHandoffArgs(['status', '--host', 'claude', '--operation', 'id']).operation, 'id');
   assert.equal(parseAutoHandoffArgs(['worker', '--host', 'claude', '--operation', SESSION]).action, 'worker');
+  assert.equal(parseAutoHandoffArgs(['desktop-open', '--host', 'claude', '--operation', SESSION]).action, 'desktop-open');
   for (const args of [['resume', '--host', 'claude', '--operation', 'id'], ['detail', '--host', 'claude', '--operation', 'id', '--origin', 'A', '--turn', '1'],
-    ['worker', '--host', 'claude'], ['status', '--host', 'grok'], ['status', '--host'], ['disable', '--host', 'claude', '--project', REPO_ROOT]]) {
+    ['worker', '--host', 'claude'], ['status', '--host', 'grok'], ['status', '--host'], ['disable', '--host', 'claude', '--project', REPO_ROOT],
+    ['desktop-open', '--host', 'claude'], ['desktop-open', '--operation', SESSION]]) {
     assert.throws(() => parseAutoHandoffArgs(args), JSON.stringify(args));
   }
 });

package/src/cli/auto-handoff.mjs

@@ -10,17 +10,17 @@ import { installCodexAutoHandoffHook, installClaudeAutoHandoffHooks, removeClaud
   claudeAutoHandoffHooksRegistered } from './install.mjs';
 import { sameProjectPath } from '../project-path.mjs';
 import { readClaudeAutoHandoffConfig, writeClaudeAutoHandoffConfig } from '../claude-auto-handoff-config.mjs';
-import { listClaudeAutoHandoffs, publicClaudeAutoHandoff, runClaudeAutoHandoffWorker } from '../claude-auto-handoff.mjs';
+import { listClaudeAutoHandoffs, publicClaudeAutoHandoff, runClaudeAutoHandoffWorker, runClaudeDesktopOpen } from '../claude-auto-handoff.mjs';
 
 // Claude の自動継続 (ADR 0033)。引き継ぎの記録は旧い会話の session id で持つ。結果が不明な配送は
 // 再送しないので、resume は持たない。記憶の取得は通常の recall / detail を使うので、detail も持たない。
-const CLAUDE_ACTIONS = ['enable', 'disable', 'status', 'worker'];
+const CLAUDE_ACTIONS = ['enable', 'disable', 'status', 'worker', 'desktop-open'];
 
 export function parseAutoHandoffArgs(args) {
   const out = { action: args[0] ?? 'status', host: 'codex', operation: null, project: null, origin: null, turn: null, database: null, json: false };
-  if (!['enable', 'disable', 'status', 'resume', 'detail', 'worker'].includes(out.action)) throw Error('auto_handoff_action_invalid');
+  if (!['enable', 'disable', 'status', 'resume', 'detail', 'worker', 'desktop-open'].includes(out.action)) throw Error('auto_handoff_action_invalid');
   const allowed = ['host', ...{ enable: ['project'], disable: [], status: ['project', 'operation'],
-    resume: ['operation'], worker: ['operation'], detail: ['operation', 'origin', 'turn', 'database'] }[out.action]];
+    resume: ['operation'], worker: ['operation'], 'desktop-open': ['operation'], detail: ['operation', 'origin', 'turn', 'database'] }[out.action]];
   const seen = new Set();
   for (let i = 1; i < args.length; i++) {
     if (seen.has(args[i])) throw Error('auto_handoff_argument_invalid');
@@ -31,10 +31,10 @@ export function parseAutoHandoffArgs(args) {
     out[key] = args[++i];
   }
   if (!['codex', 'claude'].includes(out.host)) throw Error('auto_handoff_host_invalid');
-  if (out.host === 'claude' && !CLAUDE_ACTIONS.includes(out.action)) throw Error('auto_handoff_action_unsupported');
+  if (out.host === 'claude' ? !CLAUDE_ACTIONS.includes(out.action) : out.action === 'desktop-open') throw Error('auto_handoff_action_unsupported');
   if (out.project && !isAbsolute(out.project)) out.project = resolve(out.project);
   if (out.project && out.operation) throw Error('auto_handoff_argument_invalid');
-  if (['worker', 'resume', 'detail'].includes(out.action) && !out.operation) throw Error('auto_handoff_operation_required');
+  if (['worker', 'resume', 'detail', 'desktop-open'].includes(out.action) && !out.operation) throw Error('auto_handoff_operation_required');
   if (out.action === 'detail') {
     out.turn = Number(out.turn);
     if (!out.origin || !Number.isSafeInteger(out.turn) || out.turn < 1) throw Error('auto_handoff_detail_identity_required');
@@ -85,6 +85,7 @@ async function runClaude(parsed) {
     return { status: 'disabled', host: 'claude', config };
   }
   if (parsed.action === 'worker') return publicClaudeAutoHandoff(await runClaudeAutoHandoffWorker(parsed.operation, { openDb: getDb }));
+  if (parsed.action === 'desktop-open') return publicClaudeAutoHandoff(await runClaudeDesktopOpen(parsed.operation));
   const handoffs = listClaudeAutoHandoffs()
     .filter(record => !parsed.project || sameProjectPath(record.project_path, parsed.project))
     .filter(record => !parsed.operation || record.handoff_id === parsed.operation || record.source_session_id === parsed.operation)

package/src/os/pty-run.mjs

@@ -0,0 +1,13 @@
+/**
+ * os/pty-run.mjs — 端末を要求するコマンドを、端末の無い process から呼ぶ
+ *
+ * darwin: `script -q /dev/null <command> <args…>` が擬似端末を作る。
+ * 他の OS は未対応で、null を返す（呼び出し元が見送る）。
+ */
+import { spawnSync } from 'node:child_process';
+
+export function runWithPty(command, args, { platform = process.platform, spawnImpl = spawnSync, ...options } = {}) {
+  if (platform !== 'darwin') return null;
+  return spawnImpl('/usr/bin/script', ['-q', '/dev/null', command, ...args],
+    { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], ...options });
+}

package/src/turn-processor.mjs

@@ -52,7 +52,7 @@ 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';
+import { completeClaudeTurnWithoutHandoff, requestClaudeDesktopOpen } from './claude-auto-handoff.mjs';
 
 /** 直近 N ターンは bodies を生で残し、それより古いものだけ L1 要約する。 */
 export const L2_WINDOW = 20;
@@ -271,6 +271,10 @@ async function processStop() {
 
   // 自動圧縮を止めた後、道具を呼ばずにターンが終わった。続ける作業が無いので、引き継ぎの記録を取り下げる (ADR 0033)。
   completeClaudeTurnWithoutHandoff({ sessionId: session_id });
+  // Claude Desktop から始まった会話の後継が、ターンを終えた。Desktop へ移して開く process を起動する。
+  // 失敗しても、会話の保存は続ける。
+  try { await requestClaudeDesktopOpen({ sessionId: session_id }); }
+  catch (err) { process.stderr.write(`[auto-handoff] desktop open: ${err instanceof Error ? err.message : 'unknown'}\n`); }
 
   // VSCode で開かれたプロジェクトに .vscode/tasks.json を自動プロビジョニングする。
   // 2 回目以降は冪等性チェックで即 return するので毎ターン走っても安全。