throughline 0.15.4 → 0.16.0

package/CHANGELOG.md

@@ -10,6 +10,51 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.0] — 2026-10-07
+
+### 変更
+
+- 自動継続が立てる後継に、`<project 名>｜<作業の概要>（自動引き継ぎ）`の名前を付ける（[ADR 0037](docs/adr/0037-auto-handoff-successor-title.md)）。一覧を見た時に、どのprojectの何の作業の続きかを読めるようにする。
+  - Claude Code: 今までの名前は`tl-<フォルダ名>-<引き継ぎIDの先頭8桁>`で、Claude Desktopの一覧にもそのまま出ていた。作業の概要は前任の会話の題（Claude Desktopの題、人が付けた題、Claude Codeが付けた題の順）から取り、題が無ければ止めた時点の依頼の最初の行を使う。
+  - Codex: 今までは後継タスクに名前を付けておらず、継続の指示（`Throughline自動継続 <ID> / <ID>`）がそのまま題として見えていた。前任のタスクの題を概要にして、後継を作った直後に`thread/name/set`で付ける。前任がこの版より前に立てた名前の無い後継なら、引き継ぎの記録をさかのぼって元のタスクの題を使う。
+- 概要は40字で切る。引き継ぎを重ねても、project名と印は積み重ならない。AIは呼ばない。
+- Codexで名前を付けられなかった時も、引き継ぎは止めない（理由はworkerのログに残る）。
+
+### 確認した範囲
+
+- Linux（Claude Code 2.1.292、Haiku）の切り離した置き場で、本物の会話に自動圧縮と道具のhookを渡した。後継は`p1｜read file fruit colors（自動引き継ぎ）`の名前で立ち、継続の指示を受け取った。その後継からもう一度引き継ぐと、3つ目も同じ名前になった。
+- Linux（Codex 0.160.1）のapp-serverで、新しいスレッドに最初のターンの前に付けた名前が、ターンの後も残る。
+- 公開するpackageを展開して、本物のworkerから後継を立て、`claude agents`に出る名前が渡した名前と一致することを3環境で見た（題は日本語・全角の記号・`&`・二重引用符を含む）: Linux（Claude Code 2.1.292）、macOS（2.1.289）、Windows 11（2.1.292、PowerShellのshim経由、Node 24.20.0）。
+- macOSのCodex Desktopに同梱のCodex（0.160.1）が`thread/name/set`を持つ。
+
+### 確認していない範囲
+
+- Codex Desktopの実機での自動継続の通し（後継タスクが一覧に新しい名前で出るところ）。確かめたのは、同じ版のCodexのapp-serverで名前が付いて残ることまで。
+- Claude Desktopの一覧に新しい名前が出るところ。今までの名前（`tl-…`）がDesktopの題としてそのまま出ていたことは、macOSの記録で見ている。
+
+## [0.15.5] — 2026-10-07
+
+### 修正
+
+- Windowsで、同じhookが続けて走る会話（Cursorが約10秒おきにターンを回す会話など）の間に、hookが`disk I/O error`で落ちることがある不具合を直す（[ADR 0036](docs/adr/0036-first-read-retry-on-io-error.md)）。落ちるのはDBを開いた直後の最初の読み取りで、落ちたhookはその回の記憶の注入や保存をしなかった。hookはDBを閉じずに終わる。終わったprocessの片付けと次のprocessの最初の読み取りが重なると、SQLiteがWALの索引を切り詰められずに失敗を返していた。最初の読み取りを、`disk I/O error`の間だけ25msごとに読み直す（hookは最長5秒）。
+- 読み取り専用でDBを開く所（`handoff-context`、`latest-session`、`auto-handoff status`、`recall`、`factory-diagnostics`、`caveat-context`、Spotter向けの`auditor-context`とObserver向けの読み出し）も同じ形で落ちていたので、同じ読み直しを通す。`migrate`も通す。
+
+### 追加
+
+- `hook-failures.log`に、SQLiteの拡張code（`errcode`）を残す。`disk I/O error`は文面が同じでも、codeで原因が分かれる。
+
+### 確認した範囲
+
+- Windows 11（Node 24.20.0）の切り離した置き場。DBを開いて閉じずに終わる短命のprocessを6列で続ける再現で、直す前は5,295本のうち128本が`disk I/O error`（code 1546）で落ち、読み直しを入れると5,180本とも開けた（読み直したのは139本、最大2回、最長74ms）。読み取り専用は、直す前に4,059本のうち217本が落ちた。
+- 同じ端末で、足した試験（240本）がこの版では2回とも通り、読み直しを外すと同じ試験が`disk I/O error`で落ちる。
+- Linux（Node 26）では、直す前から同じ再現で1,398本とも開ける。
+
+### 確認していない範囲
+
+- Windowsのどの操作が失敗を返したか。SQLiteのcode（切り詰めの失敗）までで、その下は確かめていない。
+- 2026-10-04に同じ端末で起きたSessionStartとUserPromptSubmitの失敗が、同じ形だったか（当時の版は理由を残していない）。
+- Codexの状態DBなど、他の製品のDBを読む所（`codex-restore-source-audit`）は変えていない。
+
 ## [0.15.4] — 2026-10-06
 
 ### 修正
@@ -1831,7 +1876,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.15.4...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.0...HEAD
+[0.16.0]: https://github.com/kitepon/Throughline/compare/v0.15.5...v0.16.0
+[0.15.5]: https://github.com/kitepon/Throughline/compare/v0.15.4...v0.15.5
 [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

package/README.ja.md

@@ -29,7 +29,7 @@ throughline auto-handoff disable
 
 既定では無効です。`enable`は必要な`PreCompact(auto)`フックを登録し、そのフックの承認と有効状態を公式APIで確認します。`--project`を省略すると全projectを対象にします。macOSのCodex Desktopで実機確認済みです。VS Code・CLI・他OSの自動継続は未検証です。
 
-自動圧縮の開始前に旧ターンを停止し、同じprojectの新しいタスクへ記憶を注入して表示します。元のモデル・推論強度・権限・モードなどが表示後も一致することを確認してから、継続指示を一度だけ送ります。後継でその入力と作業の進捗を観測して完了とします。手動`/compact`は発火対象に含めません。
+自動圧縮の開始前に旧ターンを停止し、同じprojectの新しいタスクへ記憶を注入して表示します。新しいタスクには、前任のタスクの題から`<project名>｜<作業の概要>（自動引き継ぎ）`の名前を付けます。元のモデル・推論強度・権限・モードなどが表示後も一致することを確認してから、継続指示を一度だけ送ります。後継でその入力と作業の進捗を観測して完了とします。手動`/compact`は発火対象に含めません。
 
 記憶は引き継ぎ全体の直近20ターンをL2全文、それより古いターンをL1で渡します。元のユーザー依頼と中断地点を保持し、tool結果とThinkingは注入しません。本文内の`auto-handoff detail`コマンドで、凍結したL2/L3を引き継ぎID・origin・turnから取得できます。A→B→Cの連続引き継ぎでも祖先の詳細を取得できます。
 
@@ -58,10 +58,10 @@ throughline auto-handoff disable --host claude
 
 1. 自動圧縮の直前に、圧縮を止めます。`/tl`と同じ印を残します。
 2. 旧い会話の次の道具を、実行させずに止めます。旧い会話は止めるだけで、空にしません。
-3. 同じprojectに、新しいClaudeの会話を裏で立てます（`claude --bg`）。モデル・推論強度・権限は旧い会話から引き継ぎます。
-4. 新しい会話へ継続の指示を1通送ります。届いた時に、止めた時点の依頼、そのターンでここまでにしたこと（発言と道具の呼び出し）、実行されなかった道具、直近の会話の原文を注入します（上限9,500字）。止めたターンの道具の入出力は、後継が`throughline detail`で取り出せます。
+3. 同じprojectに、継続の指示を最初の指示として付けた新しいClaudeの会話を裏で立てます（`claude --bg`）。会話の名前は、前任の会話の題から`<project名>｜<作業の概要>（自動引き継ぎ）`にします。モデル・推論強度・権限は旧い会話から引き継ぎます。
+4. 最初の指示を受け取った時に、止めた時点の依頼、そのターンでここまでにしたこと（発言と道具の呼び出し）、実行されなかった道具、直近の会話の原文を注入します（上限9,500字）。止めたターンの道具の入出力は、後継が`throughline detail`で取り出せます。
 
-続きは裏の会話で動きます。`claude agents`の一覧と`claude attach <id>`で見られます。Claude Desktopの画面には出ず、後継のターンが終わって入力待ちになった後にDesktopで開けます。手動`/compact`、subagentの中の圧縮、`claude -p`などscriptから起動した会話は対象に含めません。
+続きは裏の会話で動きます。`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から起動した会話は対象に含めません。
 
 ```bash
 throughline auto-handoff status --host claude --operation <handoff-id> --json
@@ -69,7 +69,7 @@ throughline auto-handoff status --host claude --operation <handoff-id> --json
 
 後継の立ち上げや配送に失敗した時は、固定の理由を記録して止まります。結果が不明な指示は再送しません。圧縮を止めた後にモデルが道具を呼ばずにターンを終えた時は、後継を立てません。印は残るので、1時間以内に開いた新しい会話が記憶を引き継ぎます。
 
-有効にした端末では、Claudeの道具の呼び出しのたびに`PreToolUse`フックが1回走ります。Linux・macOS・WindowsのClaude Code 2.1.289（macOSはClaude Desktop同梱の2.1.286も）で、端末から始めた会話を実機確認済みです。Claude Desktopの画面から始めた会話は未検証です。[実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-05-claude-auto-handoff.md)を参照してください。
+有効にした端末では、Claudeの道具の呼び出しのたびに`PreToolUse`フックが1回走ります。Linux・macOS・Windowsの端末から始めた会話と、macOSのClaude Desktopの画面から始めた会話を実機確認済みです。Desktopでは、移動済みの会話の最初の後継への記憶注入と、最初からフォルダを選んだ会話の連続継承・作業完了を確認しました。[実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-05-claude-auto-handoff.md)を参照してください。
 
 ## 所有境界
 

package/README.md

@@ -28,7 +28,7 @@ throughline auto-handoff disable
 
 既定では無効です。`enable`は必要な`PreCompact(auto)`フックを登録し、そのフックの承認と有効状態を公式APIで確認します。`--project`を省略すると全projectを対象にします。macOSのCodex Desktopで実機確認済みです。VS Code・CLI・他OSの自動継続は未検証です。
 
-自動圧縮の開始前に旧ターンを停止し、同じprojectの新しいタスクへ記憶を注入して表示します。元のモデル・推論強度・権限・モードなどが表示後も一致することを確認してから、継続指示を一度だけ送ります。後継でその入力と作業の進捗を観測して完了とします。手動`/compact`は発火対象に含めません。
+自動圧縮の開始前に旧ターンを停止し、同じprojectの新しいタスクへ記憶を注入して表示します。新しいタスクには、前任のタスクの題から`<project名>｜<作業の概要>（自動引き継ぎ）`の名前を付けます。元のモデル・推論強度・権限・モードなどが表示後も一致することを確認してから、継続指示を一度だけ送ります。後継でその入力と作業の進捗を観測して完了とします。手動`/compact`は発火対象に含めません。
 
 記憶は引き継ぎ全体の直近20ターンをL2全文、それより古いターンをL1で渡します。元のユーザー依頼と中断地点を保持し、tool結果とThinkingは注入しません。本文内の`auto-handoff detail`コマンドで、凍結したL2/L3を引き継ぎID・origin・turnから取得できます。A→B→Cの連続引き継ぎでも祖先の詳細を取得できます。
 
@@ -57,10 +57,10 @@ throughline auto-handoff disable --host claude
 
 1. 自動圧縮の直前に、圧縮を止めます。`/tl`と同じ印を残します。
 2. 旧い会話の次の道具を、実行させずに止めます。旧い会話は止めるだけで、空にしません。
-3. 同じprojectに、新しいClaudeの会話を裏で立てます（`claude --bg`）。モデル・推論強度・権限は旧い会話から引き継ぎます。
-4. 新しい会話へ継続の指示を1通送ります。届いた時に、止めた時点の依頼、そのターンでここまでにしたこと（発言と道具の呼び出し）、実行されなかった道具、直近の会話の原文を注入します（上限9,500字）。止めたターンの道具の入出力は、後継が`throughline detail`で取り出せます。
+3. 同じprojectに、継続の指示を最初の指示として付けた新しいClaudeの会話を裏で立てます（`claude --bg`）。会話の名前は、前任の会話の題から`<project名>｜<作業の概要>（自動引き継ぎ）`にします。モデル・推論強度・権限は旧い会話から引き継ぎます。
+4. 最初の指示を受け取った時に、止めた時点の依頼、そのターンでここまでにしたこと（発言と道具の呼び出し）、実行されなかった道具、直近の会話の原文を注入します（上限9,500字）。止めたターンの道具の入出力は、後継が`throughline detail`で取り出せます。
 
-続きは裏の会話で動きます。`claude agents`の一覧と`claude attach <id>`で見られます。Claude Desktopの画面には出ず、後継のターンが終わって入力待ちになった後にDesktopで開けます。手動`/compact`、subagentの中の圧縮、`claude -p`などscriptから起動した会話は対象に含めません。
+続きは裏の会話で動きます。`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から起動した会話は対象に含めません。
 
 ```bash
 throughline auto-handoff status --host claude --operation <handoff-id> --json
@@ -68,7 +68,7 @@ throughline auto-handoff status --host claude --operation <handoff-id> --json
 
 後継の立ち上げや配送に失敗した時は、固定の理由を記録して止まります。結果が不明な指示は再送しません。圧縮を止めた後にモデルが道具を呼ばずにターンを終えた時は、後継を立てません。印は残るので、1時間以内に開いた新しい会話が記憶を引き継ぎます。
 
-有効にした端末では、Claudeの道具の呼び出しのたびに`PreToolUse`フックが1回走ります。Linux・macOS・WindowsのClaude Code 2.1.289（macOSはClaude Desktop同梱の2.1.286も）で、端末から始めた会話を実機確認済みです。Claude Desktopの画面から始めた会話は未検証です。[実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-05-claude-auto-handoff.md)を参照してください。
+有効にした端末では、Claudeの道具の呼び出しのたびに`PreToolUse`フックが1回走ります。Linux・macOS・Windowsの端末から始めた会話と、macOSのClaude Desktopの画面から始めた会話を実機確認済みです。Desktopでは、移動済みの会話の最初の後継への記憶注入と、最初からフォルダを選んだ会話の連続継承・作業完了を確認しました。[実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-05-claude-auto-handoff.md)を参照してください。
 
 ## Ownership boundary
 

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

@@ -92,8 +92,8 @@ Claude Desktop の新しい会話は、画面を開いただけでは process
 ## Consequences
 
 - 有効な project では、Claude Code の自動圧縮は走らない。旧い会話は、止めた道具の hook の文を出して止まる。
-- 続きは裏の会話（agent view）で動く。`claude agents` の一覧と `claude attach <id>` で見られる。Claude Desktop の画面には
-  出ず、後継のターンが終わって入力待ちになった後に Desktop で開ける。
+- 続きは裏の会話（agent view）で動く。`claude agents` の一覧と `claude attach <id>` で見られる。Desktopへは自動表示しない。
+  作業完了を確認して裏の実行を停止した後、`claude --desktop --resume <session-id>`で同じ会話をDesktopに開ける。
 - `PreToolUse` hook は、有効な端末の全ての Claude の会話で、道具の呼び出しのたびに1回走る。
 - 止めたターンは Stop hook を通らない。worker が取り込む（0.14.1）。発言が1つも無いまま止めたターンは、
   user の行と道具の入出力だけが入る。完了の受領（Stop が出すもの）は、止めたターンには出さない。
@@ -120,4 +120,5 @@ Claude Desktop の新しい会話は、画面を開いただけでは process
   旧い会話を止める・後継を立てる、の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 が動いている最中の引き継ぎは確かめていない。
+- 0.15.4。macOSのClaude Desktopの画面から、移動済みの会話（Opus 5.5、high、バイパス）と、最初からフォルダを選んだ会話（同モデル・強度、auto）を試した。前者は最初の後継へ記憶が入り、4個の再読を完了した。後者は3回引き継ぎ、14個を順に読み、結果を作った。圧縮・読み直し・読み飛ばし・承認待ちは無かった。試行の経緯と範囲は[実測記録](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-05-claude-auto-handoff.md#claude-desktopの画面2026-10-06)を参照する。
+- 0.15.3以降のLinuxの実物での通し、Windowsのバイパス、Fable、subagentが動いている最中の引き継ぎは確かめていない。

package/docs/adr/0036-first-read-retry-on-io-error.md

@@ -0,0 +1,50 @@
+# ADR 0036: DB を開いた最初の読み取りは、`disk I/O error` の間だけ読み直す
+
+日付: 2026-10-07
+
+## Context
+
+Windows（0.15.4、2026-10-07）で、UserPromptSubmit の hook が2回 `disk I/O error` で落ちた。落ちた位置は
+`getDb()` の中の最初の読み取り（`db.prepare('PRAGMA journal_mode')`）だった。Cursor の会話が約10秒おきに
+ターンを回している最中で、Cursor は同じ hook を2本ほぼ同時に起動する。
+
+同じ端末の切り離した置き場で再現した。DB を開いて読み、**閉じずに `process.exit` で終わる**短命の process を
+6列で続けると、5,295 本のうち 128 本（約2%）が同じ位置・同じ文面で落ちた。node:sqlite の拡張 code は
+1546（`SQLITE_IOERR_TRUNCATE`）。読み取り専用で開いた process は、4,059 本のうち 217 本が落ちた。
+Linux（Node 26）では 1,398 本で 0 本。process の中で開いて閉じるのを繰り返す形（閉じてから次を開く）では、
+Windows でも 8,906 回で 0 回だった。
+
+SQLite は WAL の索引（`-shm`）を開く時、他に接続が無いと見ると索引を 0 バイトへ切り詰める。Windows は、
+他の process が map したままのファイルを切り詰めさせない。閉じずに終わった process の片付けと、次の process の
+最初の読み取りが重なると、この切り詰めが断られる、と読める（Windows のどの API がどの code で断ったかは、
+node:sqlite からは取れないので確かめていない）。Throughline の hook は DB を閉じずに `process.exit` で終わる。
+
+失敗した読み取りを同じ接続で読み直すと、同じ再現で 5,180 本とも開けた。読み直したのは 139 本、
+最大2回、最長 74ms だった。接続を閉じて開き直す形でも同じ結果だった（5,227 本、最長 87ms）。
+
+2026-10-04 に同じ端末（0.12.4）で起きた SessionStart と UserPromptSubmit の失敗（ADR 0031 の Consequences で
+「原因は分かっていない」とした分）は、UserPromptSubmit が今回と同じ記録（fingerprint）に数えられている。
+0.12.4 は理由を端末に残さなかったので、同じ形だったとは確かめられない。
+
+## Decision
+
+1. `src/db.mjs` に `settleFirstRead(db, { timeoutMs })` を置く。`PRAGMA user_version` を読み、
+   SQLite の `disk I/O error`（拡張 code の下位 8 bit が 10）で断られたら 25ms 待って読み直す。
+   既定の期限は `busy_timeout` と同じ 5 秒。期限まで解けなければ、同じ失敗をそのまま返す。
+2. 他の失敗は読み直さない。lock の待ちは今までどおり `busy_timeout` が受け持つ。
+3. Throughline の DB を開く所は、開いた直後にここを通す: `getDb()`、`openReadOnlyDb()`、`migrateDefaultDb()`、
+   `auditor-context`（2か所）、`caveat-context`、`factory-diagnostics`、`recall`。hook の途中で呼ばれる
+   `caveat-context` と Observer 向けの読み出しは、それぞれの `busy_timeout` と同じ 1 秒を期限にする。
+4. hook は今までどおり DB を閉じずに終わる。終わる時に閉じると、最後の接続が checkpoint と WAL の削除を
+   行い、hook の終了が遅くなる。host に止められた process は閉じられないので、閉じる側だけでは無くせない。
+5. `hook-failures.log` に、node:sqlite が付ける拡張 code（`errcode`）を残す。`disk I/O error` は文面が同じでも
+   code で原因が分かれる。
+
+## Consequences
+
+- Windows で同じ hook が続けて走る会話でも、DB を開く所で落ちなくなる。重なった時は 25〜100ms ほど待つ。
+- 本当に読めない DB（壊れたディスクなど）では、失敗が返るまで期限の分だけ待つ（hook は最長 5 秒）。
+  今までは即座に失敗していた。
+- Codex の状態 DB など、他の製品の DB を読む所（`codex-restore-source-audit`）と、lock 用の小さな DB
+  （WAL を使わない）は変えていない。
+- macOS と Linux では、この失敗は元から起きていない。読み取りが1回増えるだけで、動きは変わらない。

package/docs/adr/0037-auto-handoff-successor-title.md

@@ -0,0 +1,47 @@
+# ADR 0037: 自動継続の後継に「project 名｜作業の概要（自動引き継ぎ）」の名前を付ける
+
+日付: 2026-10-07
+
+## Context
+
+自動継続が立てる後継は、一覧で何の project の何の続きかを読めなかった（2026-10-07、オーナーの指摘）。
+
+- Claude Code: 後継を `claude --bg --name tl-<フォルダ名>-<引き継ぎ ID の先頭8桁>` で立てていた。Claude Desktop の一覧にも
+  この名前がそのまま題として出る（macOS で実測: `tl-tl-claude-probe-3eacc0af`）。作業の中身は名前に入らない。
+- Codex: 後継タスクに名前を付けていなかった。Codex は名前の無いタスクを最初の user 発言で表示するので、継続の指示
+  （`Throughline自動継続 <引き継ぎ ID> / <配送 ID>`）がそのまま題として見える。macOS の実機で、自動継続が立てた
+  後継4つに名前が無いことを `session_index.jsonl` で確かめた。project 名も作業の中身も読めない。
+
+前任の題は host が既に持っている。
+
+- Claude Code は会話記録に題を書く。端末の会話は `ai-title`（Claude Code が付ける。変わるたびに行が増える）、
+  Claude Desktop の会話と人が名前を変えた会話は `custom-title`。`--name` で立てた会話も `custom-title` に入り、
+  `ai-title` は付かない（Linux 2.1.292、macOS の記録で確認）。
+- Codex は `thread/read` が `name`（Desktop が付けた題、または人が付けた題）と `preview`（最初の user 発言）を返す。
+  自動継続は、前任の状態を読む時にこの値を既に取っている（`runtime.title`）。名前は `thread/name/set` で付けられ、
+  最初のターンの前に付けた名前はターンの後も残る（Linux 0.160.1 で確認）。書かれるのは `session_index.jsonl` だけで、
+  rollout には何も足されない。
+
+## Decision
+
+1. 後継の名前を `<project 名>｜<作業の概要>（自動引き継ぎ）` にする。project 名は project の場所の最後のフォルダ名。
+   概要が取れない時は `<project 名>（自動引き継ぎ）`。形は `src/auto-handoff-title.mjs` に1か所だけ置く。
+2. 作業の概要は前任の題から取る。AI は呼ばない（引き継ぎを遅らせず、後継を立てる前に失敗する所を増やさない）。
+   - Claude Code: 最後の `custom-title`、無ければ最後の `ai-title`、どちらも無ければ止めた時点の依頼の最初の行。
+   - Codex: 前任の `name`、無ければ `preview`。
+3. 概要は最初の行だけを1行にして、40字で切る。制御文字と二重引用符は落とす（名前は起動の引数として渡す。
+   Windows は PowerShell の shim を通る）。
+4. 前任がこの形の名前を持つ後継なら、中の概要だけを取り出して使う。引き継ぎを重ねても project 名と印は
+   積み重ならない。継続の指示は概要にしない。Codex で前任が名前の無い後継（この版より前に立てたもの）の時は、
+   引き継ぎの記録をさかのぼって元のタスクの題を使う。
+5. Claude Code へは `--name=<名前>` の形で渡す。フォルダ名が `-` で始まっても option として読まれない。
+6. Codex は、後継を作った直後、記憶を注入する前に `thread/name/set` を呼ぶ。名前は表示だけに使うので、
+   断られても引き継ぎは止めず、worker のログに理由の code を残す。
+
+## Consequences
+
+- 名前に引き継ぎ ID が入らなくなる。後継の ID は今までどおり記録（Claude は `successor.short_id`、Codex は
+  `target_thread_id`）と `auto-handoff status` にある。Throughline は名前で後継を探していない。
+- 同じ会話から引き継ぎを重ねると、後継は同じ名前になる。一覧では新しい順で見分ける。
+- 概要は前任の題を写すだけなので、題が作業の中身からずれていれば、名前もずれる。
+- 記録の schema は変えない。

package/package.json

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

package/rag/01-hooks/raw/claude-compact-hooks-extract.md

@@ -53,7 +53,8 @@
   `backgrounded · <id> · <name> (idle — send a prompt to start)` と出て、指示を待つ会話が立つ（実機。SessionStart は走る）。
   `--model`・`--effort`・`--permission-mode`・`--name`・`--settings` を受ける。`--session-id` は無視される
   （短い ID は session id の先頭8桁）。別の background session の中から起動すると、出力の ID に色の制御文字が付く。
-- 動いている background session は Desktop へ移せない（`claude --desktop --resume`）。ターンが終わった後は開ける。
+- 動いている background session は Desktop へ移せない（`claude --desktop --resume`）。裏の実行を停止した後に開ける。
+  現行の公式仕様は[Desktopの会話を開く一次ソース抜粋](claude-desktop-session-open-extract.md)を参照する。
 
 ## 既存の会話へ外から送る口（inbox socket）
 

package/rag/01-hooks/raw/claude-desktop-session-open-extract.md

@@ -0,0 +1,15 @@
+# Claude Code: 既存の会話をDesktopで開く
+
+- 出典: [Desktop application — Coming from the CLI?](https://code.claude.com/docs/en/desktop#coming-from-the-cli)
+- 取得日: 2026-10-06
+- 確度: 公式仕様
+
+既存のCLI会話を開く公開コマンド:
+
+```sh
+claude --desktop --resume <session-id>
+```
+
+> Claude Code doesn’t move a session that is open in another terminal or still running in the background.
+
+画面での確認結果は[Desktop受入記録](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-05-claude-auto-handoff.md#完了した後継をdesktopで開く)に置く。

package/rag/INDEX.md

@@ -29,6 +29,7 @@ rag/
 
 ## Claude自動継続の根拠
 
+- [既存の会話をDesktopで開く一次ソース抜粋](01-hooks/raw/claude-desktop-session-open-extract.md) — `claude --desktop --resume <session-id>`は裏の実行を停止した会話を開く。実行中のbackground sessionは移せない。Desktop受入で最後の後継の完了報告を画面から確認した。
 - [圧縮・会話の起動・受け口の一次ソース抜粋](01-hooks/raw/claude-compact-hooks-extract.md) — `PreCompact`は圧縮を止められる（exit code 2）が`continue`は捨てられる。`PreToolUse`の`deny`+`continue:false`で道具を実行させずにターンを止められる。`claude --bg`は指示なしで起動すると指示待ちの会話が立つ。会話ごとの受け口（inbox socket）へ外から1通送ると、入力待ちの会話でターンが始まる。[実測](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-05-claude-auto-handoff.md)で、対話の会話から後継へ3回連続で引き継ぎ、圧縮は1回も走らなかった。Finding 6・第三仮説（PreCompactでの再投影）に対する現行の答えは[ADR 0033](../docs/adr/0033-claude-auto-handoff-new-session.md)。
 
 ## Question this RAG was built to answer

package/src/auditor-context.mjs

@@ -7,7 +7,7 @@ import { CLAUDE_HOST, CODEX_HOST, isCodexSessionId } from './hosts/identity.mjs'
 import { parseCodexRolloutFile } from './codex-rollout-memory.mjs';
 import { getLogicalTurnGroups } from './transcript-reader.mjs';
 import { hashAuditorBody, normalizeAuditorBody } from './body-digest.mjs';
-import { CURRENT_VERSION } from './db.mjs';
+import { CURRENT_VERSION, settleFirstRead } from './db.mjs';
 
 export { hashAuditorBody, normalizeAuditorBody } from './body-digest.mjs';
 
@@ -86,6 +86,7 @@ export function readAuditorContext({
   }
 
   try {
+    settleFirstRead(db);
     const version = Number(db.prepare('PRAGMA user_version').get()?.user_version ?? 0);
     if (version < 9 || version > AUDITOR_CONTEXT_DB_SCHEMA_VERSION) {
       return emptyResult('schema_mismatch', 'unsupported_db_schema', {
@@ -201,6 +202,7 @@ export function readCompletedPairProjection({
     throw new AuditorContextError('E_AUDITOR_CONTEXT_DB_OPEN', 'auditor context DB could not be opened', { cause });
   }
   try {
+    settleFirstRead(db, { timeoutMs: OBSERVER_PROJECTION_BUSY_TIMEOUT_MS });
     const version = Number(db.prepare('PRAGMA user_version').get()?.user_version ?? 0);
     if (version < 9 || version > AUDITOR_CONTEXT_DB_SCHEMA_VERSION) throw new AuditorContextError('E_AUDITOR_CONTEXT_SCHEMA', 'auditor context DB schema is unsupported');
     const session = db.prepare('SELECT session_id, project_path FROM sessions WHERE session_id = ?').get(sessionId);

package/src/auto-handoff-title.mjs

@@ -0,0 +1,57 @@
+/**
+ * 自動継続が立てる後継（Claude の会話、Codex のタスク）の名前。
+ *
+ * 形は「project 名｜作業の概要（自動引き継ぎ）」。一覧を見た時に、どの project の、何の作業の続きかを読める
+ * ようにする。作業の概要は前任の題から取り、AI は呼ばない。前任の題が取れない時は project 名と印だけにする。
+ */
+
+export const AUTO_HANDOFF_TITLE_MARK = '自動引き継ぎ';
+const SEPARATOR = '｜';
+const SUFFIX = `（${AUTO_HANDOFF_TITLE_MARK}）`;
+// 一覧の幅で末尾の印が切れにくい長さに、概要を抑える。
+const SUMMARY_MAX_CHARS = 40;
+// 継続の指示（Claude・Codex とも、この語と引き継ぎ ID で始まる）。名前の付いていない後継は、これが題として見える。
+const CONTINUATION_INPUT_PATTERN = /^Throughline自動継続 [0-9a-f]{8}-/;
+
+/** project の場所から、名前に使うフォルダ名を取る。Windows の場所を他の OS で読んでも同じ値にする。 */
+export function autoHandoffProjectName(projectPath) {
+  if (typeof projectPath !== 'string') return '';
+  return oneLine(projectPath.split(/[\\/]+/).filter(Boolean).at(-1) ?? '');
+}
+
+function oneLine(text) {
+  // 起動の引数として渡すので、制御文字と改行を落とす。二重引用符は Windows の引数の受け渡しで崩れるので落とす。
+  return text.replace(/[\u0000-\u001f\u007f"]+/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function clip(text, maxChars) {
+  const chars = Array.from(text);
+  return chars.length <= maxChars ? text : `${chars.slice(0, maxChars - 1).join('').trimEnd()}…`;
+}
+
+/**
+ * 前任の題や依頼から、作業の概要を取る。前任がこの形の名前を持つ後継なら、中の概要だけを取り出す
+ * （引き継ぎを重ねても、project 名と印が積み重ならない）。概要にならない値は null。
+ */
+export function autoHandoffSummaryOf(title) {
+  if (typeof title !== 'string') return null;
+  const firstLine = title.split(/\r?\n/).map(oneLine).find(Boolean) ?? '';
+  if (!firstLine || CONTINUATION_INPUT_PATTERN.test(firstLine)) return null;
+  if (firstLine.endsWith(SUFFIX)) {
+    const body = firstLine.slice(0, -SUFFIX.length);
+    const at = body.indexOf(SEPARATOR);
+    const inner = at < 0 ? '' : body.slice(at + SEPARATOR.length).trim();
+    return inner ? clip(inner, SUMMARY_MAX_CHARS) : null;
+  }
+  return clip(firstLine, SUMMARY_MAX_CHARS);
+}
+
+/**
+ * 後継の名前を作る。
+ * @param {{projectPath: string, titles?: Array<string|null|undefined>}} input titles は概要の候補（先頭から使えるものを採る）
+ */
+export function composeAutoHandoffTitle({ projectPath, titles = [] }) {
+  const project = autoHandoffProjectName(projectPath);
+  const summary = titles.map(autoHandoffSummaryOf).find(Boolean) ?? null;
+  return [project, summary].filter(Boolean).join(SEPARATOR) + SUFFIX;
+}

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

@@ -0,0 +1,50 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { autoHandoffProjectName, autoHandoffSummaryOf, composeAutoHandoffTitle } from './auto-handoff-title.mjs';
+
+test('名前は「project 名｜作業の概要（自動引き継ぎ）」の形にする', () => {
+  assert.equal(composeAutoHandoffTitle({ projectPath: '/Users/kite/Developer/BellTeam', titles: ['ASCからの連絡を確認'] }),
+    'BellTeam｜ASCからの連絡を確認（自動引き継ぎ）');
+  assert.equal(composeAutoHandoffTitle({ projectPath: '/work/app', titles: [null, '', '  ', '2つ目の候補'] }),
+    'app｜2つ目の候補（自動引き継ぎ）', '使える最初の候補を採る');
+  assert.equal(composeAutoHandoffTitle({ projectPath: '/work/app' }), 'app（自動引き継ぎ）', '概要が取れない時は project 名と印だけ');
+});
+
+test('project 名は場所の最後のフォルダ名。Windows の場所を他の OS で読んでも同じ', () => {
+  assert.equal(autoHandoffProjectName('C:\\Users\\kite_\\Developer\\Throughline'), 'Throughline');
+  assert.equal(autoHandoffProjectName('C:\\Users\\kite_\\tl-claude-probe\\'), 'tl-claude-probe');
+  assert.equal(autoHandoffProjectName('/srv/bellteam/bots/bot-220e0f1b/'), 'bot-220e0f1b');
+  assert.equal(autoHandoffProjectName(null), '');
+});
+
+test('前任がこの形の名前を持つ後継なら、中の概要だけを取り出す', () => {
+  const first = composeAutoHandoffTitle({ projectPath: '/work/app', titles: ['hookの失敗を直す'] });
+  assert.equal(autoHandoffSummaryOf(first), 'hookの失敗を直す');
+  assert.equal(composeAutoHandoffTitle({ projectPath: '/work/app', titles: [first] }), first, '引き継ぎを重ねても同じ名前');
+  assert.equal(composeAutoHandoffTitle({ projectPath: '/work/moved', titles: [first] }), 'moved｜hookの失敗を直す（自動引き継ぎ）',
+    'project 名は今の場所から付け直す');
+  assert.equal(autoHandoffSummaryOf('app（自動引き継ぎ）'), null, '概要の無い名前からは、概要を作らない');
+  assert.equal(composeAutoHandoffTitle({ projectPath: '/work/app', titles: ['app（自動引き継ぎ）', '元の依頼'] }),
+    'app｜元の依頼（自動引き継ぎ）');
+});
+
+test('継続の指示は概要にしない（名前の無い後継は、これが題として見える）', () => {
+  const claude = 'Throughline自動継続 89903aed-a0a8-486e-9932-a10ce526d2d5\n注入された記憶と元のユーザー依頼に従い、未完了の作業をそのまま継続してください。';
+  const codex = 'Throughline自動継続 89903aed-a0a8-486e-9932-a10ce526d2d5 / b90f43ab-7056-4216-9737-a7430a6768ca\n注入された記憶と…';
+  assert.equal(autoHandoffSummaryOf(claude), null);
+  assert.equal(autoHandoffSummaryOf(codex), null);
+  assert.equal(composeAutoHandoffTitle({ projectPath: '/work/app', titles: [codex, 'ASCからの連絡を確認'] }),
+    'app｜ASCからの連絡を確認（自動引き継ぎ）');
+  assert.equal(autoHandoffSummaryOf('Throughline自動継続の試験'), 'Throughline自動継続の試験', '人が付けた題は残す');
+});
+
+test('概要は最初の行を1行にして、長さを抑える', () => {
+  assert.equal(autoHandoffSummaryOf('\n  1行目の  依頼\t文  \n2行目'), '1行目の 依頼 文');
+  assert.equal(autoHandoffSummaryOf('say "hello" & exit'), 'say hello & exit', '二重引用符は落とす');
+  const long = autoHandoffSummaryOf('あ'.repeat(100));
+  assert.equal(Array.from(long).length, 40);
+  assert.ok(long.endsWith('…'));
+  assert.equal(autoHandoffSummaryOf(long), long, '切った概要は、もう一度通しても変わらない');
+  assert.equal(Array.from(autoHandoffSummaryOf(`${'😀'.repeat(50)}`)).length, 40, '絵文字を途中で割らない');
+  assert.equal(autoHandoffSummaryOf(undefined), null);
+});

package/src/caveat-context.mjs

@@ -1,5 +1,6 @@
 import { existsSync } from 'node:fs';
 import { DatabaseSync } from 'node:sqlite';
+import { settleFirstRead } from './db.mjs';
 
 import {
   AUDITOR_CONTEXT_DB_SCHEMA_VERSION,
@@ -31,6 +32,7 @@ export function readCaveatContext({
   try {
     db = new DatabaseSync(dbPath, { readOnly: true });
     db.exec('PRAGMA busy_timeout = 1000');
+    settleFirstRead(db, { timeoutMs: 1000 });
     const version = Number(db.prepare('PRAGMA user_version').get()?.user_version ?? 0);
     if (version < 9 || version > AUDITOR_CONTEXT_DB_SCHEMA_VERSION) return empty('schema_mismatch');
 

package/src/claude-auto-handoff.mjs

@@ -19,7 +19,7 @@
 
 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 { 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';
@@ -38,6 +38,7 @@ import { resolveMergeTarget } from './session-merger.mjs';
 import { writeBaton } from './baton.mjs';
 import { sameProjectPath } from './project-path.mjs';
 import { spawnPortable, spawnPortableSync } from './os/portable-spawn-sync.mjs';
+import { composeAutoHandoffTitle } from './auto-handoff-title.mjs';
 
 export const CLAUDE_AUTO_HANDOFF_SCHEMA = 'throughline.claude-auto-handoff.v2';
 const CLI_PATH = resolve(dirname(fileURLToPath(import.meta.url)), '../bin/throughline.mjs');
@@ -262,6 +263,17 @@ function readLatestModel(transcriptPath) {
   return null;
 }
 
+/**
+ * 止める会話の題。人が付けた題を先に読む（Claude Desktop の題と、`--name` で付いた後継の名前もこの行に入る）。
+ * 無ければ Claude Code が付けた題を読む。
+ */
+function readSessionTitle(transcriptPath) {
+  const entries = readRawEntries(transcriptPath);
+  const latest = (type, key) => entries.findLast(entry => entry?.type === type &&
+    typeof entry[key] === 'string' && entry[key].trim())?.[key] ?? null;
+  return latest('custom-title', 'customTitle') ?? latest('ai-title', 'aiTitle');
+}
+
 const CONTINUATION_MARKER = /Throughline自動継続 ([0-9a-f-]{36})/;
 
 // 後継へ渡す「このターンでここまでにしたこと」。1件の長さと件数を抑える。全文は取り込んだ details にある。
@@ -525,8 +537,15 @@ function readAcceptance(sessionId, handoffId, dir) {
   return acceptance?.handoff_id === handoffId && typeof acceptance.accepted_at === 'number' ? acceptance : null;
 }
 
+/** 後継の名前。一覧で、どの project の何の作業の続きかを読めるようにする。概要は前任の題、無ければ元の依頼から取る。 */
+function successorName(record) {
+  return composeAutoHandoffTitle({ projectPath: record.project_path,
+    titles: [record.transcript_path ? readSessionTitle(record.transcript_path) : null, record.in_flight?.user?.content] });
+}
+
 function successorArgs(record) {
-  const args = ['--bg', '--name', `tl-${basename(record.project_path)}-${record.handoff_id.slice(0, 8)}`];
+  // 名前は `--name=` の形で渡す。project のフォルダ名が `-` で始まっても、option として読まれない。
+  const args = ['--bg', `--name=${successorName(record)}`];
   const { model, effort, permission_mode: permissionMode } = record.settings ?? {};
   if (model) args.push('--model', model);
   if (effort) args.push('--effort', effort);

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

@@ -278,9 +278,10 @@ test('worker: 継続の指示を最初の指示として付けて後継を同じ
   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',
+  assert.deepEqual(args, ['--bg', '--name=app（自動引き継ぎ）', '--effort', 'high',
     '--permission-mode', 'acceptEdits', '--settings', '{"worktree":{"bgIsolation":"none"}}', claudeContinuationInput(record)],
-    '指示は起動時に渡す（外から送ると、権限のバイパス中の後継が承認まで止める）。モデルは transcript が無いので付かない');
+    '指示は起動時に渡す（外から送ると、権限のバイパス中の後継が承認まで止める）。モデルは transcript が無いので付かない。' +
+    '名前は、前任の題も依頼も読めないので project 名と印だけ');
   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' }, '会話ごとの環境変数は後継へ渡さない');
@@ -334,7 +335,8 @@ test('worker: 止めた時点の依頼とモデルを transcript から写し、
   assert.equal(first.record.state, 'sent');
   assert.equal(first.record.successor.short_id, 'a41a97ae');
   assert.equal(first.record.settings.model, 'claude-opus-5');
-  assert.deepEqual(first.calls[0].slice(3, 5), ['--model', 'claude-opus-5']);
+  assert.deepEqual(first.calls[0].slice(1, 4), ['--name=app｜14個のファイルを順に読んで（自動引き継ぎ）', '--model', 'claude-opus-5'],
+    '前任に題が無い時は、元の依頼を名前の概要にする');
   assert.deepEqual(first.record.in_flight, {
     user: { content: '14個のファイルを順に読んで', timestamp: Date.parse('2026-10-04T03:00:10Z') },
     last_fragment: { content: 'part05 を読みました。次に part06 を読みます。', timestamp: Date.parse('2026-10-04T03:00:14Z') },
@@ -351,6 +353,8 @@ test('worker: 止めた時点の依頼とモデルを transcript から写し、
   // 後継 B が止められた時、最後の user 発言は A からの継続の指示。現在地には元の依頼を運ぶ
   const transcriptB = join(dir, 'b.jsonl');
   writeFileSync(transcriptB, jsonl([
+    // `--name` で立てた会話には、Claude Code が名前を題として書く
+    { type: 'custom-title', customTitle: first.calls[0][1].slice('--name='.length), sessionId: SUCCESSOR },
     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: {} }] } },
@@ -365,6 +369,39 @@ test('worker: 止めた時点の依頼とモデルを transcript から写し、
     stopped_tools_total: 1,
     turn: null,
   });
+  assert.equal(second.calls[0][1], first.calls[0][1], '引き継ぎを重ねても、project 名と印は積み重ならない');
+}));
+
+test('worker: 後継の名前は project 名・前任の題・自動引き継ぎの印で作る。人が付けた題を Claude Code の題より先に使う', () => withDir(async dir => {
+  const nameFor = async (sessionId, titleLines) => {
+    const transcriptPath = join(dir, `${sessionId}.jsonl`);
+    writeFileSync(transcriptPath, jsonl([
+      user('14個のファイルを順に読んで', '2026-10-04T03:00:10Z'),
+      ...titleLines,
+      assistant('part04 を読みました。', '2026-10-04T03:00:12Z'),
+    ]));
+    const db = makeBatonDb();
+    requestClaudeAutoHandoff({ payload: { session_id: sessionId, trigger: 'auto', cwd: '/work/app', transcript_path: transcriptPath },
+      env: {}, config: ENABLED, openDb: () => db, dir, platform: 'linux' });
+    await stopClaudeTurnForHandoff({ payload: { session_id: sessionId, cwd: '/work/app', transcript_path: transcriptPath },
+      dir, launchWorker: async () => {} });
+    let name = null;
+    await runClaudeAutoHandoffWorker(sessionId, { dir, env: {}, pollMs: 10, acceptTimeoutMs: 300, transcriptTimeoutMs: 50,
+      spawn: (command, args) => { name = args[1]; successorStarts(dir, sessionId)(args); return launchedOk(); } });
+    return name;
+  };
+  // 端末の会話: Claude Code が付けた題（新しい方）
+  assert.equal(await nameFor('aaaaaaaa-0000-4000-8000-000000000001', [
+    { type: 'ai-title', aiTitle: 'ファイルの読み込み' }, { type: 'ai-title', aiTitle: '14ファイル順序読み込みと結果記録' },
+  ]), '--name=app｜14ファイル順序読み込みと結果記録（自動引き継ぎ）');
+  // Claude Desktop の会話と、人が名前を変えた会話: 題は custom-title に入る
+  assert.equal(await nameFor('aaaaaaaa-0000-4000-8000-000000000002', [
+    { type: 'custom-title', customTitle: 'MCP共有ラッパー設計' }, { type: 'ai-title', aiTitle: '別の題' },
+  ]), '--name=app｜MCP共有ラッパー設計（自動引き継ぎ）');
+  // 改行・二重引用符・長い題は、1行の引数として渡せる形にする
+  assert.equal(await nameFor('aaaaaaaa-0000-4000-8000-000000000003', [
+    { type: 'custom-title', customTitle: `"結果" を\n${'長'.repeat(60)}` },
+  ]), '--name=app｜結果 を（自動引き継ぎ）');
 }));
 
 function makeMemoryDb() {

package/src/cli/factory-diagnostics.mjs

@@ -6,7 +6,7 @@ import { defaultAuditorContextDbPath } from '../auditor-context.mjs';
 import { buildFactoryDiagnostics } from '../factory-diagnostics.mjs';
 import { findCodexThreadCandidate, defaultCodexHome } from '../codex-thread-index.mjs';
 import { resolveCodexThreadIdentity } from '../codex-thread-identity.mjs';
-import { CURRENT_VERSION } from '../db.mjs';
+import { CURRENT_VERSION, settleFirstRead } from '../db.mjs';
 import { isEquivalentCodexHookCommand } from './install.mjs';
 import { _internal as doctorInternal } from './doctor.mjs';
 
@@ -51,6 +51,7 @@ export function inspectFactoryDatabase({
   let db;
   try {
     db = new DatabaseSync(dbPath, { readOnly: true });
+    settleFirstRead(db);
     const schemaVersion = Number(db.prepare('PRAGMA user_version').get()?.user_version ?? 0);
     if (schemaVersion !== CURRENT_VERSION || !hasFactoryDatabaseShape(db)) {
       return databaseResult('not_ready', schemaVersion, false);

package/src/cli/recall.mjs

@@ -23,6 +23,7 @@ import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
+import { settleFirstRead } from '../db.mjs';
 import { formatTime } from '../handoff-record.mjs';
 import { groupL3ByTurn, buildPartsSummary } from '../l3-summary.mjs';
 
@@ -267,6 +268,7 @@ export function run(argv) {
   }
 
   try {
+    settleFirstRead(db);
     const result = runRecall(db, opts);
     process.stdout.write(`${result.text}\n`);
     return 0;

package/src/codex-auto-handoff.mjs

@@ -18,6 +18,7 @@ import { ensureAutoHandoffSummaries, renderAutoHandoffMemory } from './codex-aut
 import { CODEX_NATIVE_ID_PATTERN, CodexHandoffError, readCodexHandoffState,
   settingsMatch, threadStartSettings } from './hosts/codex-handoff-state.mjs';
 import { resolvePreparedSettings } from './hosts/codex-handoff-state.mjs';
+import { composeAutoHandoffTitle } from './auto-handoff-title.mjs';
 
 const CLI_PATH = resolve(dirname(fileURLToPath(import.meta.url)), '../bin/throughline.mjs');
 const stateRoot = () => join(homedir(), '.throughline', 'codex-auto-handoff');
@@ -120,6 +121,30 @@ async function sourceNativeState(operation, runtime) {
     }, runtime);
 }
 
+/**
+ * 後継タスクの名前。一覧で、どの project の何の作業の続きかを読めるようにする。概要は前任の題から取る。
+ * 前任が名前の無い後継（題が継続の指示になっている）なら、引き継ぎをさかのぼって元のタスクの題を使う。
+ */
+export function autoHandoffTargetName(db, operation) {
+  const titles = [];
+  for (let current = operation, depth = 0; current && depth < 20; depth++) {
+    titles.push(current.runtime?.title);
+    current = current.previous_handoff_id ? getAutoHandoff(db, current.previous_handoff_id) : null;
+  }
+  return composeAutoHandoffTitle({ projectPath: operation.project_path, titles });
+}
+
+/** 後継タスクに名前を付ける。名前は表示だけに使うので、付けられなくても引き継ぎは止めない（理由は worker のログに残す）。 */
+export async function nameAutoHandoffTarget(request, targetId, name) {
+  try {
+    await request('thread/name/set', { threadId: targetId, name });
+    return true;
+  } catch (cause) {
+    process.stderr.write(`[auto-handoff] thread/name/set failed: ${cause?.delivery_code ?? cause?.code ?? 'unknown'}\n`);
+    return false;
+  }
+}
+
 async function createTarget(db, operation, runtime) {
   const targetId = await withCodexReceiver(autoHandoffDeliveryProfile, { thread_id: operation.source_thread_id, codex_home: operation.codex_home },
     async request => {
@@ -133,6 +158,8 @@ async function createTarget(db, operation, runtime) {
         if (!CODEX_NATIVE_ID_PATTERN.test(targetId ?? '') || !sameProjectPath(start.cwd, operation.project_path)) throw error('handoff_target_response_invalid');
         updateAutoHandoff(db, operation.handoff_id, { target_thread_id: targetId, mutation_stage: 'inject' });
       }
+      // 最初のターンの前に付ける。付けないと、継続の指示がそのままタスクの題として見える。
+      await nameAutoHandoffTarget(request, targetId, autoHandoffTargetName(db, operation));
       if (!operation.runtime.targetMemoryInjected) {
         const text = renderAutoHandoffMemory(db, operation);
         await request('thread/inject_items', { threadId: targetId, items: [{ type: 'message', role: 'developer',

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

@@ -10,7 +10,8 @@ import { requestAutoHandoff, updateAutoHandoff, getAutoHandoff, freezeCodexMemor
 import { collectAutoHandoffMemory, ensureAutoHandoffSummaries, renderAutoHandoffMemory,
   renderFrozenDetail } from './codex-auto-handoff-memory.mjs';
 import { readCodexHandoffState, settingsMatch, threadStartSettings } from './hosts/codex-handoff-state.mjs';
-import { runAutoHandoffWorker, requestCodexAutoHandoff, sourceBoundary } from './codex-auto-handoff.mjs';
+import { runAutoHandoffWorker, requestCodexAutoHandoff, sourceBoundary,
+  autoHandoffTargetName, nameAutoHandoffTarget } from './codex-auto-handoff.mjs';
 import { parseAutoHandoffArgs } from './cli/auto-handoff.mjs';
 
 async function withDb(fn) {
@@ -291,3 +292,30 @@ test('forkした子の先頭metadataを保持し、継承された親metadataで
   assert.equal(state.stoppedAt, state.turnStartAt);
   assert.throws(() => readCodexHandoffState(file, { threadId: 'parent' }), /handoff_thread_mismatch/);
 }));
+
+test('後継タスクの名前は project 名・前任の題・自動引き継ぎの印で作り、名前の無い後継からは元のタスクの題をさかのぼる', async () => withDb(async db => {
+  const named = (operation, title) => updateAutoHandoff(db, operation.handoff_id, { runtime_json: { projectId: null, title } }).operation;
+  const a = named(request(db, 'A', { projectPath: '/Users/kite/Developer/BellTeam' }).operation, 'ASCからの連絡を確認');
+  assert.equal(autoHandoffTargetName(db, a), 'BellTeam｜ASCからの連絡を確認（自動引き継ぎ）');
+
+  // A の後継 B は、名前を付けない版が作った。題は継続の指示として見える
+  updateAutoHandoff(db, a.handoff_id, { target_thread_id: 'B' });
+  const b = named(request(db, 'B', { projectPath: '/Users/kite/Developer/BellTeam' }).operation, continuationInput(a));
+  assert.equal(b.previous_handoff_id, a.handoff_id);
+  assert.equal(autoHandoffTargetName(db, b), 'BellTeam｜ASCからの連絡を確認（自動引き継ぎ）');
+
+  // B の後継 C は、この形の名前を持つ。重ねても同じ名前になる
+  updateAutoHandoff(db, b.handoff_id, { target_thread_id: 'C' });
+  const c = named(request(db, 'C', { projectPath: '/Users/kite/Developer/BellTeam' }).operation, autoHandoffTargetName(db, b));
+  assert.equal(autoHandoffTargetName(db, c), 'BellTeam｜ASCからの連絡を確認（自動引き継ぎ）');
+
+  // 題がどこにも無い時は project 名と印だけ
+  const lone = named(request(db, 'D', { projectPath: 'C:\\Users\\kite_\\Throughline' }).operation, '');
+  assert.equal(autoHandoffTargetName(db, lone), 'Throughline（自動引き継ぎ）');
+
+  const sent = [];
+  assert.equal(await nameAutoHandoffTarget(async (method, params) => { sent.push([method, params]); return {}; }, 'T', 'BellTeam（自動引き継ぎ）'), true);
+  assert.deepEqual(sent, [['thread/name/set', { threadId: 'T', name: 'BellTeam（自動引き継ぎ）' }]]);
+  const rejected = async () => { throw Object.assign(new Error('unknown method'), { delivery_code: 'CODEX_RECEIVER_REJECTED' }); };
+  assert.equal(await nameAutoHandoffTarget(rejected, 'T', 'x'), false, '名前を付けられなくても、引き継ぎは止めない');
+}));

package/src/db-contention.test.mjs

@@ -5,6 +5,7 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { settleFirstRead } from './db.mjs';
 
 const DB_MODULE_URL = pathToFileURL(fileURLToPath(new URL('./db.mjs', import.meta.url))).href;
 
@@ -120,3 +121,64 @@ test('getDbは、新しいDBを複数のprocessが同時に開いても、全員
     }
   }
 });
+
+test('settleFirstReadは、disk I/O errorの間だけ最初の読み取りを読み直す', () => {
+  const ioError = Object.assign(new Error('disk I/O error'), { errcode: 1546 });
+  let calls = 0;
+  settleFirstRead({
+    prepare() {
+      calls += 1;
+      if (calls <= 2) throw ioError;
+      return { get: () => ({ user_version: 12 }) };
+    },
+  });
+  assert.equal(calls, 3);
+
+  // 他の失敗は読み直さず、そのまま返す。lock の待ちは busy_timeout が受け持つ。
+  const locked = Object.assign(new Error('database is locked'), { errcode: 5 });
+  let lockedCalls = 0;
+  assert.throws(() => settleFirstRead({ prepare() { lockedCalls += 1; throw locked; } }), /database is locked/u);
+  assert.equal(lockedCalls, 1);
+
+  // 期限まで解けなければ、同じ失敗を返す。
+  let persistentCalls = 0;
+  assert.throws(
+    () => settleFirstRead({ prepare() { persistentCalls += 1; throw ioError; } }, { timeoutMs: 60 }),
+    /disk I\/O error/u,
+  );
+  assert.ok(persistentCalls >= 2, `calls ${persistentCalls}`);
+});
+
+test('getDbとopenReadOnlyDbは、DBを閉じずに終わる短命のprocessが続いても開ける', async () => {
+  // hookはDBを閉じずに終わる。Windowsでは、終わったprocessの片付けと次のprocessの最初の読み取りが重なると、
+  // SQLiteが `disk I/O error` を返した（修理前は実機で、240本のうち5本以上が落ちる割合）。他のOSでは元から起きない。
+  const home = mkdtempSync(join(tmpdir(), 'throughline-db-unclosed-'));
+  const env = { ...process.env, HOME: home, USERPROFILE: home };
+  const lanes = 6;
+  const perLane = 40;
+  const failures = [];
+  try {
+    const initialize = spawn(process.execPath, ['--input-type=module', '-e', `
+      import { getDb } from ${JSON.stringify(DB_MODULE_URL)};
+      getDb().close();
+    `], { env, stdio: ['ignore', 'ignore', 'pipe'] });
+    assert.equal((await waitForExit(initialize)).code, 0);
+
+    await Promise.all(Array.from({ length: lanes }, async (_, lane) => {
+      for (let index = 0; index < perLane; index += 1) {
+        const open = (lane + index) % 2 === 0 ? 'getDb()' : 'openReadOnlyDb()';
+        const child = spawn(process.execPath, ['--input-type=module', '-e', `
+          import { getDb, openReadOnlyDb } from ${JSON.stringify(DB_MODULE_URL)};
+          const db = ${open};
+          db.prepare('SELECT count(*) AS n FROM sessions').get();
+          process.exit(0);
+        `], { env, stdio: ['ignore', 'ignore', 'pipe'] });
+        const result = await waitForExit(child);
+        if (result.code !== 0) failures.push({ open, ...result });
+      }
+    }));
+    assert.deepEqual(failures, []);
+  } finally {
+    rmSync(home, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
+  }
+});

package/src/db.mjs

@@ -18,6 +18,7 @@ export function openReadOnlyDb(path = DB_PATH) {
   const db = new DatabaseSync(path, { readOnly: true });
   try {
     db.exec(`PRAGMA busy_timeout = ${DB_BUSY_TIMEOUT_MS}`);
+    settleFirstRead(db);
     return db;
   } catch (error) {
     db.close();
@@ -32,10 +33,39 @@ function isSqliteBusy(error) {
   return /database is locked/u.test(String(error?.message ?? ''));
 }
 
+function isSqliteIoError(error) {
+  if (typeof error?.errcode === 'number') return (error.errcode & 0xff) === 10;
+  return /disk I\/O error/u.test(String(error?.message ?? ''));
+}
+
 function sleepSync(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 
+/**
+ * 開いた接続の最初の読み取りを済ませる。`disk I/O error` の間は 25ms ごとに読み直す (ADR 0036)。
+ *
+ * Windows では、DB を閉じずに終わった process の片付けと、次の process の最初の読み取りが重なると、
+ * SQLite が WAL の索引 (-shm) を切り詰められず `disk I/O error` (SQLITE_IOERR_TRUNCATE) を返す。
+ * hook は DB を閉じずに終わるので、同じ hook が続けて走る会話で起きる。重なりは 100ms ほどで解ける。
+ * 最初の読み取りが通った接続は索引を持ち続けるので、後の読み書きではこの形にならない。
+ * 読み取り専用の接続でも起きるので、Throughline の DB を開く所は全部ここを通す。
+ * @param {DatabaseSync} db
+ * @param {{ timeoutMs?: number }} [options]
+ */
+export function settleFirstRead(db, { timeoutMs = DB_BUSY_TIMEOUT_MS } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    try {
+      db.prepare('PRAGMA user_version').get();
+      return;
+    } catch (error) {
+      if (!isSqliteIoError(error) || Date.now() >= deadline) throw error;
+      sleepSync(WAL_SWITCH_RETRY_MS);
+    }
+  }
+}
+
 /**
  * journal mode を WAL にする。既に WAL なら何も書かない。
  *
@@ -395,6 +425,7 @@ export function migrateDefaultDb() {
   try {
     db = new DatabaseSync(DB_PATH);
     db.exec(`PRAGMA busy_timeout = ${DB_BUSY_TIMEOUT_MS}`);
+    settleFirstRead(db);
     db.exec('PRAGMA foreign_keys = ON');
 
     const beforeSchemaVersion = Number(db.prepare('PRAGMA user_version').get().user_version ?? 0);
@@ -452,6 +483,7 @@ export function getDb() {
   const db = new DatabaseSync(DB_PATH);
   try {
     db.exec(`PRAGMA busy_timeout = ${DB_BUSY_TIMEOUT_MS}`);
+    settleFirstRead(db);
     ensureWalJournalMode(db);
     db.exec('PRAGMA foreign_keys = ON');
     initSchema(db);

package/src/hook-failure-log.mjs

@@ -52,6 +52,9 @@ export function logHookFailure(code, error, { home, now = Date.now(), stderr = p
   // どの処理で落ちたかが分からない（2026-10-04、Windows の SessionStart と UserPromptSubmit の失敗）。
   const frames = stackFrames(error);
   if (frames.length > 0) entry.stack = frames;
+  // SQLite の失敗は、文面が同じでも番号で原因が分かれる（`disk I/O error` は 1546 なら索引の切り詰め、
+  // 522 なら読み取り）。node:sqlite が付ける拡張 code を残す。
+  if (typeof error?.errcode === 'number') entry.errcode = error.errcode;
   // どの会話の失敗かを残す（errorが `hookContext` を持つ時）。回数と文面だけでは、失敗した会話を
   // 端末の他の記録から探すことになる。
   const context = error?.hookContext;

package/src/hook-failure-log.test.mjs

@@ -95,6 +95,19 @@ test('logHookFailureは、失敗した位置をstackの先頭から残す', () =
   }
 });
 
+test('logHookFailureは、SQLiteの拡張codeを残す', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-hook-failure-log-'));
+  try {
+    logHookFailure('HOOK_PROMPT_SUBMIT_FAILED', Object.assign(new Error('disk I/O error'), { errcode: 1546 }), { home });
+    logHookFailure('HOOK_PROMPT_SUBMIT_FAILED', new Error('no errcode'), { home });
+    const [first, second] = readFileSync(hookFailureLogPath({ home }), 'utf8').trim().split('\n').map((line) => JSON.parse(line));
+    assert.equal(first.errcode, 1546);
+    assert.equal('errcode' in second, false);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
 test('logHookFailureは、長い文面を上限で切る', () => {
   const home = mkdtempSync(join(tmpdir(), 'tl-hook-failure-log-'));
   try {