throughline 0.16.10 → 0.16.12

package/CHANGELOG.md

@@ -10,6 +10,50 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.12] — 2026-10-10
+
+### 修正
+
+- Codex Desktopの自動継続が、旧タスクの順番待ちに入力が残っていると`handoff_source_input_pending`で止まり、そのタスクでは何度入力しても同じ理由で止まり続けた。Windowsの実機で、2つのタスクに7回続き、どちらもそのまま使われなくなった。止めたタスクではCodexが順番待ちを動かさないので、順番待ちは空にならない。
+  - 引き継ぎを断らない。後継が作業を続けたのを確かめた後に、旧タスクの順番待ちの入力を、順番を保って後継の順番待ちへ運ぶ（[ADR 0045](docs/adr/0045-codex-handoff-carries-pending-queue.md)）。
+  - 二重に送らない。後継へ入れた結果が分からない入力は入れ直さず、旧タスクの順番待ちに残す。運べなくても引き継ぎは止めない。
+  - 0.16.11までで止まっていたタスクは、次の入力でやり直しが動き、引き継がれる。その時点で順番待ちに残っている入力は、全部後継へ運ばれる。
+
+### 変わらない事
+
+- 実行中の子agent、設定の不一致、追跡されていない旧handoff記憶で止まる扱い。引き継ぎ済みの旧タスクへ後から届く入力の扱い。Claude Codeの自動継続。
+
+### 確認した範囲
+
+- Linux（Codex Desktop同梱のCodex 0.162.0-alpha.2）の試験用フォルダで、本物のCodex Desktopに自動継続を2回続けて流した。最初のターンが動いている間に、順番待ちへ入力を1つ入れた。2回とも引き継ぎは`continued`になり、入力は後継から次の後継へ運ばれ、最後の後継で継続の指示のターンの後に1回だけ実行された。旧い2本のrolloutには出ていない。順番待ちは3本とも空になった。
+- macOS（同梱のCodex 0.162.0-alpha.2）とWindowsの同梱のCodexで、試験タスク2本の間で順番待ちを運んだ。入力2つが、先に入っていた1つの後ろへ元の順番で並び、旧い方は空になった。もう一度呼んでも入れ直さなかった。この2つの端末では、引き継ぎの通しは流していない。
+
+### 確認していない範囲
+
+- 0.16.11までで止まっていた実機のタスクが、次の入力で引き継がれる所（利用者の入力が要る）。
+- 後継へ入れる応答が本当に切れた時の動き（試験では作り物の応答で確かめた）。
+
+## [0.16.11] — 2026-10-09
+
+### 修正
+
+- `throughline auto-handoff mark-sources`が、名前の無いタスクを残していた。後継へ名前を付けない版（0.15より前）が作った後継は、継続の指示（`Throughline自動継続 <ID>…`）が題として見える。0.16.10は、この題のタスクへ印を付けず、名前も付けなかった。macOSの実機では、一覧に名前の無いタスクが12本（今の続き6本、旧タスク6本）残った。
+  - 古い引き継ぎから順に、名前の無い後継へ`<project名>｜<作業の概要>（自動引き継ぎ）`の名前を付けてから、旧タスクへ印を付ける。利用者が名前を付けたタスクは、名前を変えない。
+  - アーカイブ済みのタスクは触らない（Codexが名前の変更を断る）。0.16.10は失敗として数えていた。
+- 名前の無い後継がさらに引き継いだ時、旧タスクへ印が付かなかった。その後継を作った引き継ぎから名前を作り直し、印を付ける。
+
+### 追加
+
+- `throughline auto-handoff mark-sources --dry-run`。名前を書かず、付ける名前の一覧（`changes`）だけを返す。
+
+### 確認した範囲
+
+- macOS（Codex Desktop同梱のCodex 0.162.0-alpha.2）の実機の引き継ぎ29件（14系列）へ流した。`--dry-run`で付ける名前を確かめてから実行し、名前の無い後継12本へ名前、旧タスク6本へ印が付いた（0.16.10で付けた19本と合わせて、一覧に在る旧タスクは全部印あり）。失敗は0、もう一度流すと変更は0。Codexの`thread/list`で、系列ごとに印の無いタスクが今の続きの1本だけになった事を確かめた。
+
+### 確認していない範囲
+
+- 付け直した名前が、Codex Desktopの一覧の表示へいつ出るか（画面は見ていない）。
+
 ## [0.16.10] — 2026-10-09
 
 ### 修正
@@ -2103,7 +2147,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.10...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.12...HEAD
+[0.16.12]: https://github.com/kitepon/Throughline/compare/v0.16.11...v0.16.12
+[0.16.11]: https://github.com/kitepon/Throughline/compare/v0.16.10...v0.16.11
 [0.16.10]: https://github.com/kitepon/Throughline/compare/v0.16.9...v0.16.10
 [0.16.9]: https://github.com/kitepon/Throughline/compare/v0.16.8...v0.16.9
 [0.16.8]: https://github.com/kitepon/Throughline/compare/v0.16.7...v0.16.8

package/README.ja.md

@@ -29,11 +29,11 @@ throughline auto-handoff disable
 
 既定では無効です。`enable`は必要な`PreCompact(auto)`フックを登録し、そのフックの承認と有効状態を公式APIで確認します。`--project`を省略すると全projectを対象にします。macOS・Windows・LinuxのCodex Desktopで実機確認済みです（Windowsは0.16.6から、Linuxは0.16.7から）。Codex Desktopに同梱のCodexが0.162以上の時は、0.16.7以上が要ります。VS Code・CLIの自動継続は未検証です。
 
-自動圧縮の開始前に旧ターンを停止し、同じprojectの新しいタスクへ記憶を注入して表示します。新しいタスクには、前任のタスクの題から`<project名>｜<作業の概要>（自動引き継ぎ）`の名前を付けます。後継が作業を続けたのを確かめた後、旧タスクの名前の頭へ`【引き継ぎ済み】`を付けます（0.16.10から。それより前の版が引き継いだ分は`throughline auto-handoff mark-sources`で付け直せます）。一覧で、印の無い1本が今の続きです。元のモデル・推論強度・権限・モードなどが表示後も一致することを確認してから、継続指示を一度だけ送ります。後継でその入力と作業の進捗を観測して完了とします。手動`/compact`は発火対象に含めません。
+自動圧縮の開始前に旧ターンを停止し、同じprojectの新しいタスクへ記憶を注入して表示します。新しいタスクには、前任のタスクの題から`<project名>｜<作業の概要>（自動引き継ぎ）`の名前を付けます。後継が作業を続けたのを確かめた後、旧タスクの名前の頭へ`【引き継ぎ済み】`を付けます（0.16.10から。それより前の版が引き継いだ分は`throughline auto-handoff mark-sources`で付け直せます。名前の無い後継にも名前が付きます。`--dry-run`で、付ける名前だけを先に見られます）。一覧で、印の無い1本が今の続きです。元のモデル・推論強度・権限・モードなどが表示後も一致することを確認してから、継続指示を一度だけ送ります。後継でその入力と作業の進捗を観測して完了とします。手動`/compact`は発火対象に含めません。
 
 記憶は引き継ぎ全体の直近20ターンをL2全文、それより古いターンをL1で渡します。元のユーザー依頼と中断地点を保持し、tool結果とThinkingは注入しません。本文内の`auto-handoff detail`コマンドで、凍結したL2/L3を引き継ぎID・origin・turnから取得できます。A→B→Cの連続引き継ぎでも祖先の詳細を取得できます。
 
-設定不一致、未処理入力、実行中の子agentや既知のnativeコマンド、追跡されていない旧handoff記憶では固定理由を残して停止します。失敗時はローカルの説明ページを開きます。新タスクだけで容量が尽きる場合も、新タスクを増やし続けません。結果不明の指示は自動で再送しません。
+設定不一致、実行中の子agentや既知のnativeコマンド、追跡されていない旧handoff記憶では固定理由を残して停止します。旧タスクの順番待ちに残っている入力（まだ送られていない物）は、後継が作業を続けた後に、順番を保って後継の順番待ちへ運びます（0.16.12から。それより前の版は、ここで引き継ぎを止めていました）。失敗時はローカルの説明ページを開きます。新タスクだけで容量が尽きる場合も、新タスクを増やし続けません。結果不明の指示は自動で再送しません。
 
 ```bash
 throughline auto-handoff status --operation <handoff-id> --json

package/README.md

@@ -28,11 +28,11 @@ throughline auto-handoff disable
 
 既定では無効です。`enable`は必要な`PreCompact(auto)`フックを登録し、そのフックの承認と有効状態を公式APIで確認します。`--project`を省略すると全projectを対象にします。macOS・Windows・LinuxのCodex Desktopで実機確認済みです（Windowsは0.16.6から、Linuxは0.16.7から）。Codex Desktopに同梱のCodexが0.162以上の時は、0.16.7以上が要ります。VS Code・CLIの自動継続は未検証です。
 
-自動圧縮の開始前に旧ターンを停止し、同じprojectの新しいタスクへ記憶を注入して表示します。新しいタスクには、前任のタスクの題から`<project名>｜<作業の概要>（自動引き継ぎ）`の名前を付けます。後継が作業を続けたのを確かめた後、旧タスクの名前の頭へ`【引き継ぎ済み】`を付けます（0.16.10から。それより前の版が引き継いだ分は`throughline auto-handoff mark-sources`で付け直せます）。一覧で、印の無い1本が今の続きです。元のモデル・推論強度・権限・モードなどが表示後も一致することを確認してから、継続指示を一度だけ送ります。後継でその入力と作業の進捗を観測して完了とします。手動`/compact`は発火対象に含めません。
+自動圧縮の開始前に旧ターンを停止し、同じprojectの新しいタスクへ記憶を注入して表示します。新しいタスクには、前任のタスクの題から`<project名>｜<作業の概要>（自動引き継ぎ）`の名前を付けます。後継が作業を続けたのを確かめた後、旧タスクの名前の頭へ`【引き継ぎ済み】`を付けます（0.16.10から。それより前の版が引き継いだ分は`throughline auto-handoff mark-sources`で付け直せます。名前の無い後継にも名前が付きます。`--dry-run`で、付ける名前だけを先に見られます）。一覧で、印の無い1本が今の続きです。元のモデル・推論強度・権限・モードなどが表示後も一致することを確認してから、継続指示を一度だけ送ります。後継でその入力と作業の進捗を観測して完了とします。手動`/compact`は発火対象に含めません。
 
 記憶は引き継ぎ全体の直近20ターンをL2全文、それより古いターンをL1で渡します。元のユーザー依頼と中断地点を保持し、tool結果とThinkingは注入しません。本文内の`auto-handoff detail`コマンドで、凍結したL2/L3を引き継ぎID・origin・turnから取得できます。A→B→Cの連続引き継ぎでも祖先の詳細を取得できます。
 
-設定不一致、未処理入力、実行中の子agentや既知のnativeコマンド、追跡されていない旧handoff記憶では固定理由を残して停止します。失敗時はローカルの説明ページを開きます。新タスクだけで容量が尽きる場合も、新タスクを増やし続けません。結果不明の指示は自動で再送しません。
+設定不一致、実行中の子agentや既知のnativeコマンド、追跡されていない旧handoff記憶では固定理由を残して停止します。旧タスクの順番待ちに残っている入力（まだ送られていない物）は、後継が作業を続けた後に、順番を保って後継の順番待ちへ運びます（0.16.12から。それより前の版は、ここで引き継ぎを止めていました）。失敗時はローカルの説明ページを開きます。新タスクだけで容量が尽きる場合も、新タスクを増やし続けません。結果不明の指示は自動で再送しません。
 
 ```bash
 throughline auto-handoff status --operation <handoff-id> --json

package/bin/throughline.mjs

@@ -412,8 +412,9 @@ Usage:
                               引き継ぎの状態と固定理由を確認
   throughline auto-handoff resume --operation <id> --json
                               同じ引き継ぎを再開（結果不明は再送しない）
-  throughline auto-handoff mark-sources [--json]
-                              引き継ぎ済みの旧タスクの名前へ印を付け直す
+  throughline auto-handoff mark-sources [--dry-run] [--json]
+                              今までの引き継ぎの名前を付け直す（旧タスクへ印、
+                              名前の無い後継へ名前）
   throughline auto-handoff detail --operation <id> --origin <session> --turn <n>
                               凍結したL2/L3を取得
   throughline auto-handoff enable|disable|status --host claude [--project <path>] [--json]

package/docs/adr/0044-codex-handed-off-source-is-marked.md

@@ -35,9 +35,14 @@ Codex Desktop の自動継続は、後継のタスクに `<project 名>｜<作
 4. 途中で止まった引き継ぎ（`failed`・`unknown`）の旧タスクには付けない。作業はまだ旧タスクにある。
 5. 印の付いた名前から後継の名前を作る時は、印を外す（やり直しで、印の付いた旧タスクの題を読む事がある）。
 6. 印を付けない版（0.16.9 まで）が引き継いだ分は、`throughline auto-handoff mark-sources` で付け直す。
-   `continued` の引き継ぎの旧タスクを古い順に見て、生きている後継がある物だけに付ける。後継が消されている旧タスクは、
-   今の続きなので付けない。何度流しても同じ結果になる。
-7. 引き継ぎ済みの旧タスクへ入力した時の扱い（止めて後継を開く。ADR 0039）は変えない。
+   `continued` の引き継ぎを古い順に見て、生きている後継がある旧タスクだけに印を付ける。後継が消されている旧タスクは、
+   今の続きなので付けない。アーカイブ済みのタスクは触らない。何度流しても同じ結果になる。`--dry-run` は名前を書かず、
+   付ける名前だけを返す。
+7. 付け直しでは、名前の無い後継へ後継の名前（ADR 0037 の形）も付ける（0.16.11）。後継へ名前を付けない版（0.15 より前）が
+   作った後継は、継続の指示が題として見える。macOS の実機では、こういうタスクが一覧に12本あった。古い引き継ぎから順に
+   付けるので、後ろの後継の名前は、前の引き継ぎで付けた名前から作られる。利用者が名前を付けたタスクは変えない。
+8. 名前の無い後継がさらに引き継いだ時は、その後継を作った引き継ぎから名前を作り直して、印を付ける。
+9. 引き継ぎ済みの旧タスクへ入力した時の扱い（止めて後継を開く。ADR 0039）は変えない。
 
 ## Consequences
 

package/docs/adr/0045-codex-handoff-carries-pending-queue.md

@@ -0,0 +1,52 @@
+# ADR 0045: Codex の旧タスクの順番待ちに残った入力は、引き継ぎを断らずに後継へ運ぶ
+
+日付: 2026-10-10
+
+## Context
+
+Codex Desktop の自動継続は、旧タスクの公式の順番待ち（`thread/queue/list`）に入力が残っていると、
+`handoff_source_input_pending` で引き継ぎを止めていた。後継を作る前に、未処理の入力を取りこぼさないための決まりだった。
+
+2026-10-09、Windows の実機で、この理由の失敗が2つのタスクに7回続いた。どちらのタスクも、そのまま使われなくなった。
+
+- 1つ目のタスク: 13:17 と 14:43 に止まり、14:45 が最後の書き込み。
+- 2つ目のタスク: 20:55 に止まり、21:06〜21:07 の4回の入力も全部止まった。21:08 が最後の書き込み。
+
+原因は、止める順番と Codex の順番待ちの決まりの組み合わせにあった。
+
+- 自動継続は、`PreCompact(auto)` の hook でターンを止めてから、worker が順番待ちを見る。
+- Codex は、順番待ちの入力を「その入力でターンを始めた時」に消す（`codex-rs/ext/queue/src/service.rs` の
+  `dispatch_if_idle`。`StartIfIdleSubmission::Started` の後に `delete_locked`）。順番待ちに残っている入力は、まだ送られていない。
+- 途中で止めたタスク（`AgentStatus::Interrupted`）では、Codex は順番待ちを動かさない（同じ file の `wake_if_loaded` と
+  `on_thread_idle`）。次に人が送ったターンが普通に終わるまで動かない。
+- 旧タスクは文脈が上限に達しているので、次に人が送ったターンも `PreCompact(auto)` で止まる。順番待ちは空にならず、
+  引き継ぎは同じ理由で止まり続ける。利用者には、何を打ってもタスクが止まるように見える。
+
+順番待ちに入力が入るのは、ターンが動いている間に届いた物（利用者が続けて打った文、ほかの道具が
+`thread/queue/add` で入れた通知や返信）。長いターンの間に1つ届くだけで、このタスクは引き継げなくなる。
+
+Codex の app-server には、順番待ちを読む・入れる・消す口がある（`thread/queue/list`・`thread/queue/add`・
+`thread/queue/delete`）。別の process からも使える。
+
+## Decision
+
+1. 旧タスクの順番待ちに入力が残っていても、引き継ぎを断らない。`handoff_source_input_pending` は出さない。
+2. 後継が作業を続けたのを確かめた後（`continued` の直後）に、旧タスクの順番待ちの入力を、順番を保って後継の順番待ちへ運ぶ。
+   後継へ `thread/queue/add`（`input` と `clientUserMessageId` はそのまま）で入れてから、旧タスクから `thread/queue/delete` で消す。
+   後継の最初のターン（継続の指示）は始まっているので、運んだ入力はその後ろに並び、ターンが終わるたびに1つずつ始まる。
+3. 二重に送らない。運ぶ入力の ID を、入れる前に引き継ぎの記録（`runtime_json.queueCarry.moving`）へ書き、入った後に
+   `moved` へ移す。入れた結果が分からない入力（応答が切れた、途中で worker が終わった）は `unknown` へ入れ、入れ直さない。
+   その入力は旧タスクの順番待ちに残る。Codex がはっきり断った入力も旧タスクに残す。
+4. 運べなくても、引き継ぎの `state` は変えない。後継はもう作業を続けている。理由と数は worker のログに残す。
+5. 後継がさらに引き継ぐ時も同じ。運んだ入力がまだ後継の順番待ちに残っていれば、次の後継へ運ぶ。
+6. 途中で止まった引き継ぎ（`failed`・`unknown`）では、順番待ちを動かさない。やり直しで `continued` になった時に運ぶ。
+7. 引き継ぎ済みの旧タスクへ後から届く入力の扱い（ADR 0039）は変えない。この ADR が扱うのは、引き継ぎの時点で残っていた入力だけ。
+
+## Consequences
+
+- 順番待ちに入力があるタスクも引き継げる。0.16.11 までで止まっていたタスクは、次の入力でやり直しが動き、引き継がれる
+  （その時点で順番待ちに残っている入力は、全部後継へ運ばれる）。
+- 運んだ入力は、後継の継続の指示のターンが終わった後に実行される。旧タスクで待っていた順番と同じ。
+- ほかの道具が旧タスクの ID で持っている配送の記録は、後継の ID へは書き換わらない。入力そのものは後継で実行される。
+- 入れた結果が分からない入力は、旧タスクの順番待ちに残る。旧タスクは引き継ぎ済みなので、その入力は実行されない。
+  数は `auto-handoff status --operation <ID>` では出ないので、worker のログ（`queue carried`）で読む。

package/package.json

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

package/src/auto-handoff-title.mjs

@@ -54,18 +54,25 @@ function withoutDonePrefix(text) {
   return rest;
 }
 
+/** 名前として使える1行を取る。空の値と、題として見えている継続の指示は null。 */
+export function usableAutoHandoffTitle(title) {
+  if (typeof title !== 'string') return null;
+  const firstLine = title.split(/\r?\n/).map(oneLine).find(Boolean) ?? '';
+  return !firstLine || CONTINUATION_INPUT_PATTERN.test(firstLine) ? null : firstLine;
+}
+
 /**
  * 引き継ぎが済んだ旧タスクの名前を作る。元の名前の頭に印を付けるだけで、元の名前は残す。
- * 一覧で、印の無い1本が今の続きだと読めるようにする。もう印が付いている名前と、名前にできない値は null（付け直さない）。
+ * 一覧で、印の無い1本が今の続きだと読めるようにする。もう印が付いている名前は null（付け直さない）。
  * @param {string|null|undefined} title 旧タスクの今の名前。名前が無いタスクでは、最初の依頼の文
+ * @param {string|null} [fallback] title が名前にならない時（名前を付けない版が作った後継。継続の指示が題として見える）に使う名前
  */
-export function markHandedOffTitle(title) {
-  if (typeof title !== 'string') return null;
-  const firstLine = title.split(/\r?\n/).map(oneLine).find(Boolean) ?? '';
-  if (!firstLine || firstLine.startsWith(AUTO_HANDOFF_DONE_PREFIX)) return null;
-  // 継続の指示が題として見えている後継（名前を付けない版が作った物）は、指示の文を名前にしない。
-  if (CONTINUATION_INPUT_PATTERN.test(firstLine)) return null;
-  return AUTO_HANDOFF_DONE_PREFIX + clip(firstLine, SUMMARY_MAX_CHARS + 20);
+export function markHandedOffTitle(title, fallback = null) {
+  const firstLine = typeof title === 'string' ? title.split(/\r?\n/).map(oneLine).find(Boolean) ?? '' : '';
+  if (firstLine.startsWith(AUTO_HANDOFF_DONE_PREFIX)) return null;
+  const name = usableAutoHandoffTitle(title) ?? usableAutoHandoffTitle(fallback);
+  if (!name || name.startsWith(AUTO_HANDOFF_DONE_PREFIX)) return null;
+  return AUTO_HANDOFF_DONE_PREFIX + clip(name, SUMMARY_MAX_CHARS + 20);
 }
 
 /**

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

@@ -60,6 +60,15 @@ test('引き継ぎ済みの印は名前の頭に付け、元の名前を残す
   }
 });
 
+test('名前にならない題（空・継続の指示）の旧タスクは、渡された名前へ印を付ける', () => {
+  const instruction = 'Throughline自動継続 39cdb98e-9e68-4dff-8a53-38d1fd861a8b';
+  assert.equal(markHandedOffTitle(instruction, 'BellTeam｜ベルチーム（自動引き継ぎ）'), '【引き継ぎ済み】BellTeam｜ベルチーム（自動引き継ぎ）');
+  assert.equal(markHandedOffTitle(null, 'BellTeam（自動引き継ぎ）'), '【引き継ぎ済み】BellTeam（自動引き継ぎ）');
+  assert.equal(markHandedOffTitle('利用者の題', 'BellTeam（自動引き継ぎ）'), '【引き継ぎ済み】利用者の題', '名前がある時は、今の名前を使う');
+  assert.equal(markHandedOffTitle('【引き継ぎ済み】x', 'y'), null);
+  assert.equal(markHandedOffTitle(instruction, instruction), null);
+});
+
 test('印の付いた旧タスクの名前から概要を取る時は、印を外す', () => {
   assert.equal(autoHandoffSummaryOf('【引き継ぎ済み】BellTeam｜ベルチーム（自動引き継ぎ）'), 'ベルチーム');
   assert.equal(autoHandoffSummaryOf('【引き継ぎ済み】ベルチーム'), 'ベルチーム');

package/src/cli/auto-handoff.mjs

@@ -17,7 +17,7 @@ import { listClaudeAutoHandoffs, publicClaudeAutoHandoff, runClaudeAutoHandoffWo
 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 };
+  const out = { action: args[0] ?? 'status', host: 'codex', operation: null, project: null, origin: null, turn: null, database: null, json: false, dryRun: false };
   if (!['enable', 'disable', 'status', 'resume', 'detail', 'worker', 'desktop-open', 'mark-sources'].includes(out.action)) throw Error('auto_handoff_action_invalid');
   const allowed = ['host', ...{ enable: ['project'], disable: [], status: ['project', 'operation'],
     resume: ['operation'], worker: ['operation'], 'desktop-open': ['operation'], 'mark-sources': [], detail: ['operation', 'origin', 'turn', 'database'] }[out.action]];
@@ -26,6 +26,7 @@ export function parseAutoHandoffArgs(args) {
     if (seen.has(args[i])) throw Error('auto_handoff_argument_invalid');
     seen.add(args[i]);
     if (args[i] === '--json') { out.json = true; continue; }
+    if (args[i] === '--dry-run' && out.action === 'mark-sources') { out.dryRun = true; continue; }
     const key = { '--host': 'host', '--operation': 'operation', '--project': 'project', '--origin': 'origin', '--turn': 'turn', '--database': 'database' }[args[i]];
     if (!key || !allowed.includes(key) || !args[i + 1] || args[i + 1].startsWith('--')) throw Error('auto_handoff_argument_invalid');
     out[key] = args[++i];
@@ -128,9 +129,9 @@ export async function run(args = []) {
       process.stdout.write(parsed.json ? JSON.stringify({ status: 'ok', text }) + '\n' : text + '\n');
       return 0;
     } else if (parsed.action === 'mark-sources') {
-      // 印を付けない版（0.16.9 まで）が引き継いだ旧タスクへ、引き継ぎ済みの印を付け直す。何度流しても同じ結果になる。
+      // 0.16.9 までの版が引き継いだ分の名前を付け直す（名前の無い後継へ名前、旧タスクへ引き継ぎ済みの印）。何度流しても同じ結果になる。
       const db = getDb();
-      result = { status: 'ok', ...await markAutoHandoffSources(db) };
+      result = { status: 'ok', dry_run: parsed.dryRun, ...await markAutoHandoffSources(db, { dryRun: parsed.dryRun }) };
     } else if (parsed.action === 'worker') {
       result = publicOperation(await runAutoHandoffWorker(parsed.operation));
     } else if (parsed.action === 'resume') {

package/src/codex-auto-handoff.mjs

@@ -12,7 +12,7 @@ import { getDb, DB_PATH } from './db.mjs';
 import { findCodexThreadCandidate } from './codex-thread-index.mjs';
 import { captureCodexRolloutToDb } from './codex-capture.mjs';
 import { readAutoHandoffConfig, autoHandoffEnabledFor } from './codex-auto-handoff-config.mjs';
-import { getAutoHandoff, requestAutoHandoff, updateAutoHandoff, failAutoHandoff, listContinuedAutoHandoffs,
+import { getAutoHandoff, requestAutoHandoff, updateAutoHandoff, failAutoHandoff, listContinuedAutoHandoffs, findAutoHandoffForTarget,
   claimAutoHandoff, releaseAutoHandoff, freezeCodexMemory, continuationInput,
   findAutoHandoffForTurn, listDeliveredAutoHandoffsForSource, listUndeliveredAutoHandoffsForSource,
   HANDOFF_TERMINAL_STATES } from './codex-auto-handoff-store.mjs';
@@ -20,7 +20,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, markHandedOffTitle } from './auto-handoff-title.mjs';
+import { composeAutoHandoffTitle, markHandedOffTitle, usableAutoHandoffTitle } 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');
@@ -241,9 +241,11 @@ async function sourceNativeState(operation, runtime) {
       if (thread?.id !== operation.source_thread_id || thread.parentThreadId || thread.canAcceptDirectInput === false ||
           thread.source?.subAgent) throw error('handoff_source_not_primary');
       if (!sameProjectPath(thread.cwd, operation.project_path)) throw error('handoff_source_project_mismatch');
+      // 順番待ちに残っている入力は、まだ送られていない（Codex は、ターンを始めた時に順番待ちから消す）。
+      // 止めた旧タスクでは順番待ちが動かないので、ここで断ると何度入力しても同じ理由で止まり続ける。
+      // 断らずに進み、後継が作業を続けた後で後継の順番待ちへ運ぶ（carryAutoHandoffQueue）。
       const queue = await request('thread/queue/list', { threadId: operation.source_thread_id, limit: 1 });
       if (!Array.isArray(queue.data)) throw error('handoff_queue_shape_invalid');
-      if (queue.data.length) throw error('handoff_source_input_pending');
       const children = await request('thread/list', { ancestorThreadId: operation.source_thread_id,
         sourceKinds: ['subAgent'], limit: 100, archived: false });
       if (!Array.isArray(children.data) || children.nextCursor) throw error('handoff_children_unavailable');
@@ -287,14 +289,15 @@ export async function nameAutoHandoffTarget(request, targetId, name) {
  * 引き継ぎが済んだ旧タスクの名前の頭へ、引き継ぎ済みの印を付ける。同じ名前の後継が一覧に並んでも、
  * 印の無い1本が今の続きだと分かるようにする。今の名前を読んでから付けるので、利用者が付け直した名前も残る。
  * 名前は表示だけに使うので、付けられなくても引き継ぎは止めない（理由は worker のログに残す）。
+ * @param {{fallbackTitle?: string|null}} [options] 旧タスクに名前が無い時に使う名前（名前を付けない版が作った後継）
  * @returns {Promise<'marked'|'kept'|'failed'>} kept はもう印がある・名前にできる値が無い
  */
-export async function markAutoHandoffSource(operation, runtime, { connect = withCodexReceiver } = {}) {
+export async function markAutoHandoffSource(operation, runtime, { connect = withCodexReceiver, fallbackTitle = null } = {}) {
   try {
     return await connect(autoHandoffDeliveryProfile, { thread_id: operation.source_thread_id, codex_home: operation.codex_home },
       async request => {
         const read = await request('thread/read', { threadId: operation.source_thread_id, includeTurns: false });
-        const name = markHandedOffTitle(read.thread?.name ?? read.thread?.preview ?? null);
+        const name = markHandedOffTitle(read.thread?.name ?? read.thread?.preview ?? null, fallbackTitle);
         if (!name) return 'kept';
         await request('thread/name/set', { threadId: operation.source_thread_id, name });
         return 'marked';
@@ -306,19 +309,142 @@ export async function markAutoHandoffSource(operation, runtime, { connect = with
 }
 
 /**
- * 今までに済んだ引き継ぎの旧タスクへ、まとめて印を付ける（印を付けない版が作った分の付け直し）。
- * 後継が消されている引き継ぎは、旧タスクが今の続きなので付けない。
+ * 止めた時に旧タスクの順番待ちに残っていた入力（まだ送られていない）を、順番を保って後継の順番待ちへ運ぶ。
+ * 後継へ入れてから旧タスクの順番待ちから消す。後継へ入れた結果が分からない入力は、二重に送らないために
+ * 入れ直さず、旧タスクの順番待ちに残す。運べなくても引き継ぎは止めない（後継はもう作業を続けている）。
+ * @returns {Promise<{moved: number, unknown: number, left: number}>} left は、断られて旧タスクに残った数
  */
-export async function markAutoHandoffSources(db, { executable = platformDesktopFinder()(), mark = markAutoHandoffSource,
-  findThread = findCodexThreadCandidate } = {}) {
+export async function carryAutoHandoffQueue(db, operation, runtime, { connect = withCodexReceiver } = {}) {
+  const sourceId = operation.source_thread_id; const targetId = operation.target_thread_id;
+  const stored = getAutoHandoff(db, operation.handoff_id).runtime?.queueCarry ?? {};
+  const carry = { moved: [...(stored.moved ?? [])], unknown: [...(stored.unknown ?? [])], left: 0 };
+  // 前の worker が、後継へ入れる途中で終わった。入ったかどうかが分からない。
+  if (stored.moving && !carry.moved.includes(stored.moving)) carry.unknown.push(stored.moving);
+  const save = moving => updateAutoHandoff(db, operation.handoff_id, { runtime_json: {
+    ...(getAutoHandoff(db, operation.handoff_id).runtime ?? {}), queueCarry: { moved: carry.moved, unknown: carry.unknown, moving } } });
+  const summary = () => ({ moved: carry.moved.length, unknown: carry.unknown.length, left: carry.left });
+  try {
+    if (stored.moving) save(null);
+    await connect(autoHandoffDeliveryProfile, { thread_id: sourceId, codex_home: operation.codex_home }, async request => {
+      const items = [];
+      for (let cursor = null, page = 0; page < 50; page++) {
+        const listed = await request('thread/queue/list', { threadId: sourceId, cursor, limit: 100 });
+        if (!Array.isArray(listed.data)) throw error('handoff_queue_shape_invalid');
+        items.push(...listed.data);
+        cursor = listed.nextCursor ?? null;
+        if (!cursor) break;
+      }
+      for (const item of items) {
+        if (carry.unknown.includes(item.id)) continue;
+        if (!carry.moved.includes(item.id)) {
+          save(item.id);
+          try {
+            await request('thread/queue/add', { threadId: targetId, input: item.input, clientUserMessageId: item.clientUserMessageId });
+          } catch (cause) {
+            // はっきり断られた入力は後継に入っていない。旧タスクに残す。それ以外は結果不明として扱う。
+            if (cause?.delivery_code === 'CODEX_RECEIVER_REJECTED') { carry.left++; save(null); continue; }
+            carry.unknown.push(item.id); save(null);
+            throw cause;
+          }
+          carry.moved.push(item.id);
+          save(null);
+        }
+        await request('thread/queue/delete', { threadId: sourceId, queuedSubmissionId: item.id });
+      }
+    }, runtime);
+  } catch (cause) {
+    process.stderr.write(`[auto-handoff] queue carry failed: ${cause?.delivery_code ?? cause?.code ?? 'unknown'}\n`);
+  }
+  if (carry.moved.length || carry.unknown.length || carry.left) {
+    process.stderr.write(`[auto-handoff] queue carried: ${JSON.stringify(summary())}\n`);
+  }
+  return summary();
+}
+
+/** 旧タスクが、名前を付けない版の作った後継だった時の名前。その後継を作った引き継ぎから、後継の名前を作り直す。 */
+export function autoHandoffSourceFallbackTitle(db, operation) {
+  const creator = findAutoHandoffForTarget(db, operation.source_thread_id);
+  return creator ? autoHandoffTargetName(db, creator) : null;
+}
+
+async function listArchivedThreadIds(request) {
+  const ids = new Set();
+  for (let cursor = null, page = 0; page < 200; page++) {
+    const listed = await request('thread/list', { archived: true, limit: 100, cursor });
+    for (const thread of listed.data ?? []) ids.add(thread.id);
+    cursor = listed.nextCursor ?? null;
+    if (!cursor) break;
+  }
+  return ids;
+}
+
+/**
+ * 今までに済んだ引き継ぎへ、まとめて名前を付け直す（0.16.9 までの版が引き継いだ分）。古い引き継ぎから順に、
+ * (1) 名前の無い後継（名前を付けない版が作った物。継続の指示が題として見える）へ、後継の名前を付ける。
+ * (2) 生きている後継がある旧タスクの名前の頭へ、引き継ぎ済みの印を付ける。
+ * アーカイブ済みのタスクは触らない（Codex が名前の変更を断る。一覧にも出ない）。後継が消されている旧タスクは、
+ * 今の続きなので印を付けない。何度流しても同じ結果になる。dryRun は名前を書かず、付ける名前だけを返す。
+ * @returns {Promise<{marked: number, named: number, kept: number, failed: number, skipped: number, changes: Array<{thread_id: string, name: string}>}>}
+ */
+export async function markAutoHandoffSources(db, { executable = platformDesktopFinder()(), connect = withCodexReceiver,
+  findThread = findCodexThreadCandidate, dryRun = false } = {}) {
   const runtime = { executable, timeout_ms: 30_000 };
-  const result = { marked: 0, kept: 0, failed: 0, skipped: 0 };
-  const seen = new Set();
+  const result = { marked: 0, named: 0, kept: 0, failed: 0, skipped: 0, changes: [] };
+  const byHome = new Map();
   for (const operation of listContinuedAutoHandoffs(db)) {
-    if (seen.has(operation.source_thread_id)) continue;
-    seen.add(operation.source_thread_id);
-    if (!findLiveAutoHandoffSuccessor(db, operation.source_thread_id, { findThread })) { result.skipped++; continue; }
-    result[await mark(operation, runtime)]++;
+    if (!byHome.has(operation.codex_home)) byHome.set(operation.codex_home, []);
+    byHome.get(operation.codex_home).push(operation);
+  }
+  for (const [codexHome, operations] of byHome) {
+    await connect(autoHandoffDeliveryProfile, { codex_home: codexHome }, async request => {
+      const archived = await listArchivedThreadIds(request);
+      // この回で読んだ名前と、付けた名前。後ろの引き継ぎは、前の引き継ぎで付けた名前から作る。
+      const titles = new Map();
+      const read = async threadId => {
+        if (!titles.has(threadId)) {
+          const thread = (await request('thread/read', { threadId, includeTurns: false })).thread;
+          titles.set(threadId, { name: usableAutoHandoffTitle(thread?.name), preview: usableAutoHandoffTitle(thread?.preview) });
+        }
+        return titles.get(threadId);
+      };
+      const rename = async (threadId, name) => {
+        if (!dryRun) await request('thread/name/set', { threadId, name });
+        titles.set(threadId, { ...titles.get(threadId), name });
+        result.changes.push({ thread_id: threadId, name });
+      };
+      const failed = cause => {
+        result.failed++;
+        process.stderr.write(`[auto-handoff] mark-sources failed: ${cause?.delivery_code ?? cause?.code ?? 'unknown'}\n`);
+      };
+      const marked = new Set();
+      for (const operation of operations) {
+        const { source_thread_id: sourceId, target_thread_id: targetId } = operation;
+        let source = null;
+        if (!archived.has(sourceId)) {
+          try { source = await read(sourceId); } catch { /* 消された旧タスク。名前は読めない */ }
+        }
+        let target = null;
+        if (!archived.has(targetId)) {
+          try { target = await read(targetId); } catch { /* 消された後継。付ける相手が無い */ }
+        }
+        if (target && !target.name) {
+          try {
+            await rename(targetId, composeAutoHandoffTitle({ projectPath: operation.project_path,
+              titles: [source?.name, source?.preview] }));
+            result.named++;
+          } catch (cause) { failed(cause); }
+        }
+        if (marked.has(sourceId)) continue;
+        marked.add(sourceId);
+        if (!source || !findLiveAutoHandoffSuccessor(db, sourceId, { findThread })) { result.skipped++; continue; }
+        try {
+          const name = markHandedOffTitle(source.name ?? source.preview);
+          if (!name) { result.kept++; continue; }
+          await rename(sourceId, name);
+          result.marked++;
+        } catch (cause) { failed(cause); }
+      }
+    }, runtime);
   }
   return result;
 }
@@ -396,6 +522,7 @@ export async function runAutoHandoffWorker(id, { db = getDb(), resume = false, d
   const deps = { processes: readRuntimeProcesses, readSource: sourceState,
     nativeState: sourceNativeState, capture: captureCodexRolloutToDb, summaries: ensureAutoHandoffSummaries,
     createTarget, readTarget: targetState, openTarget, verify: verifyCodexParent, markSource: markAutoHandoffSource,
+    carryQueue: carryAutoHandoffQueue,
     submit: submitCodexParentAnswer, notify: showAutoHandoffFailure, wait: waitForHandoff,
     executable: () => platformDesktopFinder()(), liveSuccessor: findLiveAutoHandoffSuccessor, ...dependencies };
   let operation = getAutoHandoff(db, id);
@@ -510,8 +637,10 @@ export async function runAutoHandoffWorker(id, { db = getDb(), resume = false, d
         return target.correlatedTurnId && target.progress ? target : null;
       }, { timeoutMs: 180_000, timeoutCode: 'handoff_target_progress_unconfirmed' });
       update({ state: 'continued', started_turn_id: target.correlatedTurnId, resume_state: null, error_code: null });
+      // 旧タスクの順番待ちに残った入力を後継へ運ぶ。後継の最初のターン（継続の指示）が始まった後なので、順番は変わらない。
+      await deps.carryQueue(db, operation, runtime);
       // 後継が作業を続けたのを確かめてから付ける。途中で止まった引き継ぎの旧タスクには付けない。
-      await deps.markSource(operation, runtime);
+      await deps.markSource(operation, runtime, { fallbackTitle: autoHandoffSourceFallbackTitle(db, operation) });
     }
     return operation;
   } catch (cause) {

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

@@ -14,7 +14,7 @@ import { collectAutoHandoffMemory, ensureAutoHandoffSummaries, renderAutoHandoff
 import { readCodexHandoffState, settingsMatch, threadStartSettings, resolvePreparedSettings } from './hosts/codex-handoff-state.mjs';
 import { runAutoHandoffWorker, requestCodexAutoHandoff, sourceBoundary,
   autoHandoffTargetName, nameAutoHandoffTarget, findLiveAutoHandoffSuccessor,
-  markAutoHandoffSource, markAutoHandoffSources } from './codex-auto-handoff.mjs';
+  markAutoHandoffSource, markAutoHandoffSources, autoHandoffSourceFallbackTitle, carryAutoHandoffQueue } from './codex-auto-handoff.mjs';
 import { parseAutoHandoffArgs } from './cli/auto-handoff.mjs';
 
 async function withDb(fn) {
@@ -116,7 +116,12 @@ function workerDependencies(db, settings, submit, counters) {
     readTarget: operation => ({ settings, latestTurnId: ['submitted', 'unknown'].includes(operation.state) ? 'new-turn' : null,
       correlatedTurnId: ['submitted', 'unknown'].includes(operation.state) ? 'new-turn' : null, progress: true }),
     openTarget: () => {}, verify: async () => {}, submit,
-    markSource: async operation => { (counters.marked ??= []).push(`${operation.source_thread_id}:${operation.state}`); return 'marked'; },
+    carryQueue: async (db, operation) => { (counters.carried ??= []).push(`${operation.source_thread_id}:${operation.state}`); return { moved: 0, unknown: 0, left: 0 }; },
+    markSource: async (operation, runtime, options) => {
+      (counters.marked ??= []).push(`${operation.source_thread_id}:${operation.state}`);
+      assert.ok('fallbackTitle' in options);
+      return 'marked';
+    },
     notify: () => { counters.notified++; },
     wait: async check => { const result = await check(); if (!result) throw Error('観測できません'); return result; },
   };
@@ -131,6 +136,7 @@ test('停止→記憶→作成→配送→進捗を確認し、重複workerは
   await runAutoHandoffWorker(operation.handoff_id, { db, dependencies: deps });
   assert.equal(counters.created, 1); assert.equal(counters.submitted, 1); assert.equal(counters.notified, 0);
   assert.deepEqual(counters.marked, ['worker-source:continued'], '後継が作業を続けたのを確かめた後に、旧タスクへ印を1回だけ付ける');
+  assert.deepEqual(counters.carried, ['worker-source:continued'], '後継が作業を続けたのを確かめた後に、順番待ちを1回だけ運ぶ');
 }));
 
 test('配送結果不明は再送せず、実際の入力・開始を観測して同じ後継から回復する', async () => withDb(async db => {
@@ -173,8 +179,8 @@ test('作成応答を失った時は結果不明を保存し、再開でも後
   assert.equal(counters.created, 1); assert.equal(counters.submitted, 0);
 }));
 
-test('未処理入力・実行中の子・出所不明の継承記憶では後継を作らない', async () => withDb(async db => {
-  for (const code of ['handoff_source_input_pending', 'handoff_native_child_pending', 'handoff_memory_lineage_untracked']) {
+test('実行中の子・出所不明の継承記憶では後継を作らない', async () => withDb(async db => {
+  for (const code of ['handoff_native_child_pending', 'handoff_memory_lineage_untracked']) {
     const op = request(db, code, { now: 1 }).operation;
     const counters = { created: 0, submitted: 0, notified: 0 };
     const deps = workerDependencies(db, {}, async () => { counters.submitted++; }, counters);
@@ -513,19 +519,130 @@ test('印を付けた旧タスクから作る後継の名前には、印を持
   assert.equal(autoHandoffTargetName(db, operation), 'BellTeam｜ベルチーム（自動引き継ぎ）');
 }));
 
-test('今までの引き継ぎの旧タスクへまとめて印を付け、後継が消えた引き継ぎと途中で止まった引き継ぎには付けない', async () => withDb(async db => {
-  const done = (source, target, fields = {}) => updateAutoHandoff(db, request(db, source).operation.handoff_id,
+test('今までの引き継ぎへまとめて名前を付け直す。名前の無い後継へ名前を付け、生きている後継がある旧タスクへ印を付ける', async () => withDb(async db => {
+  const done = (source, target, fields = {}) => updateAutoHandoff(db, request(db, source, { projectPath: '/Users/kite/Developer/BellTeam' }).operation.handoff_id,
     { state: 'continued', target_thread_id: target, queued_submission_id: `receipt-${target}`, ...fields }).operation;
-  done('A', 'B');
-  done('B', 'C');
-  done('X', 'gone');
+  // A（利用者の題）→ B（名前を付けない版が作った。継続の指示が題に見える）→ C（同じ）。X の後継は消えた。Y は旧タスクがアーカイブ済み。
+  const ab = done('A', 'B'); const bc = done('B', 'C');
+  done('X', 'gone'); done('Y', 'Y2');
   updateAutoHandoff(db, request(db, 'F').operation.handoff_id, { state: 'failed', target_thread_id: 'F2', error_code: 'handoff_target_not_loaded' });
-  const marked = [];
-  const result = await markAutoHandoffSources(db, { executable: 'fixture',
-    findThread: ({ threadId }) => threadId === 'gone' ? null : { rolloutPath: `/r/${threadId}`, mtimeMs: 1 },
-    mark: async operation => { marked.push(operation.source_thread_id); return operation.source_thread_id === 'B' ? 'kept' : 'marked'; } });
-  assert.deepEqual(marked, ['A', 'B']);
-  assert.deepEqual(result, { marked: 1, kept: 1, failed: 0, skipped: 1 });
+  const threads = new Map([
+    ['A', { name: 'ベルチームの改良', preview: '最初の依頼' }],
+    ['B', { name: null, preview: continuationInput(ab) }],
+    ['C', { name: null, preview: continuationInput(bc) }],
+    ['X', { name: 'Xの題', preview: 'x' }],
+    ['Y', { name: 'Yの題', preview: 'y' }], ['Y2', { name: '利用者が付けた名前', preview: 'y2' }],
+  ]);
+  const calls = [];
+  const connect = async (profile, parent, action) => action(async (method, params) => {
+    if (method === 'thread/list') { assert.equal(params.archived, true); return { data: [{ id: 'Y' }], nextCursor: null }; }
+    if (method === 'thread/read') {
+      if (!threads.has(params.threadId)) throw Object.assign(new Error('no rollout'), { delivery_code: 'CODEX_RECEIVER_REJECTED' });
+      return { thread: { id: params.threadId, ...threads.get(params.threadId) } };
+    }
+    assert.equal(method, 'thread/name/set');
+    assert.notEqual(params.threadId, 'Y', 'アーカイブ済みのタスクは触らない');
+    calls.push(`${params.threadId}=${params.name}`);
+    threads.set(params.threadId, { ...threads.get(params.threadId), name: params.name });
+    return {};
+  });
+  const options = { executable: 'fixture', connect,
+    findThread: ({ threadId }) => threadId === 'gone' ? null : { rolloutPath: `/r/${threadId}`, mtimeMs: 1 } };
+  // dryRun は名前を書かず、付ける名前だけを返す
+  const preview = await markAutoHandoffSources(db, { ...options, dryRun: true });
+  assert.deepEqual(calls, []);
+  assert.deepEqual(preview.changes.map(change => `${change.thread_id}=${change.name}`), [
+    'B=BellTeam｜ベルチームの改良（自動引き継ぎ）', 'A=【引き継ぎ済み】ベルチームの改良',
+    'C=BellTeam｜ベルチームの改良（自動引き継ぎ）', 'B=【引き継ぎ済み】BellTeam｜ベルチームの改良（自動引き継ぎ）']);
+  const { changes, ...result } = await markAutoHandoffSources(db, options);
+  assert.equal(changes.length, 4);
+  assert.deepEqual(calls, [
+    'B=BellTeam｜ベルチームの改良（自動引き継ぎ）', 'A=【引き継ぎ済み】ベルチームの改良',
+    'C=BellTeam｜ベルチームの改良（自動引き継ぎ）', 'B=【引き継ぎ済み】BellTeam｜ベルチームの改良（自動引き継ぎ）']);
+  // X は後継が消えているので付けない。Y はアーカイブ済みなので付けない。
+  assert.deepEqual(result, { marked: 2, named: 2, kept: 0, failed: 0, skipped: 2 });
+  assert.equal(threads.get('C').name, 'BellTeam｜ベルチームの改良（自動引き継ぎ）', '印の無い1本が今の続き');
+  assert.equal(threads.get('Y2').name, '利用者が付けた名前');
+
+  // もう一度流しても、何も付け直さない
+  calls.length = 0;
+  assert.deepEqual(await markAutoHandoffSources(db, options), { marked: 0, named: 0, kept: 2, failed: 0, skipped: 2, changes: [] });
+  assert.deepEqual(calls, []);
+}));
+
+test('名前の無い旧タスク（名前を付けない版が作った後継）がさらに引き継いだ時は、作り直した後継の名前へ印を付ける', async () => withDb(async db => {
+  const first = updateAutoHandoff(db, request(db, 'A', { projectPath: '/Users/kite/Developer/BellTeam' }).operation.handoff_id,
+    { state: 'continued', target_thread_id: 'B', queued_submission_id: 'receipt-B', runtime_json: { projectId: null, title: 'ベルチームの改良' } }).operation;
+  const second = request(db, 'B', { projectPath: '/Users/kite/Developer/BellTeam' }).operation;
+  assert.equal(autoHandoffSourceFallbackTitle(db, first), null, '最初の旧タスクは、どの引き継ぎの後継でもない');
+  const fallbackTitle = autoHandoffSourceFallbackTitle(db, second);
+  assert.equal(fallbackTitle, 'BellTeam｜ベルチームの改良（自動引き継ぎ）');
+  const sent = [];
+  const connect = async (profile, parent, action) => action(async (method, params) => {
+    sent.push([method, params]);
+    return method === 'thread/read' ? { thread: { name: null, preview: continuationInput(first) } } : {};
+  });
+  assert.equal(await markAutoHandoffSource(second, {}, { connect, fallbackTitle }), 'marked');
+  assert.deepEqual(sent.at(-1), ['thread/name/set', { threadId: 'B', name: '【引き継ぎ済み】BellTeam｜ベルチームの改良（自動引き継ぎ）' }]);
+}));
+
+test('旧タスクの順番待ちに残った入力を、順番を保って後継へ運び、旧タスクから消す', async () => withDb(async db => {
+  const operation = updateAutoHandoff(db, request(db, 'S').operation.handoff_id, { state: 'continued', target_thread_id: 'T' }).operation;
+  const queues = { S: [{ id: 'q1', input: [{ type: 'text', text: '1つ目' }], clientUserMessageId: 'c1' },
+    { id: 'q2', input: [{ type: 'text', text: '2つ目' }], clientUserMessageId: 'c2' }], T: [{ id: 't0', input: [], clientUserMessageId: 'continuation' }] };
+  const calls = [];
+  const receiver = (fail = () => null) => async (profile, parent, action) => action(async (method, params) => {
+    calls.push(`${method}:${params.threadId}:${params.queuedSubmissionId ?? params.clientUserMessageId ?? ''}`);
+    const failure = fail(method, params);
+    if (failure) throw failure;
+    if (method === 'thread/queue/list') return { data: queues[params.threadId], nextCursor: null };
+    if (method === 'thread/queue/add') { queues[params.threadId].push({ id: `t-${params.clientUserMessageId}`, input: params.input, clientUserMessageId: params.clientUserMessageId }); return { queuedSubmission: {} }; }
+    if (method === 'thread/queue/delete') { queues[params.threadId] = queues[params.threadId].filter(item => item.id !== params.queuedSubmissionId); return {}; }
+    throw Error(method);
+  });
+  assert.deepEqual(await carryAutoHandoffQueue(db, operation, {}, { connect: receiver() }), { moved: 2, unknown: 0, left: 0 });
+  assert.deepEqual(calls, ['thread/queue/list:S:', 'thread/queue/add:T:c1', 'thread/queue/delete:S:q1', 'thread/queue/add:T:c2', 'thread/queue/delete:S:q2']);
+  assert.deepEqual(queues.T.map(item => item.clientUserMessageId), ['continuation', 'c1', 'c2'], '継続の指示の後ろへ、元の順番で並ぶ');
+  assert.deepEqual(queues.S, []);
+  assert.deepEqual(getAutoHandoff(db, operation.handoff_id).runtime.queueCarry, { moved: ['q1', 'q2'], unknown: [], moving: null });
+  assert.equal(getAutoHandoff(db, operation.handoff_id).state, 'continued');
+
+  // もう一度呼んでも、運んだ入力を入れ直さない
+  calls.length = 0;
+  assert.deepEqual(await carryAutoHandoffQueue(db, operation, {}, { connect: receiver() }), { moved: 2, unknown: 0, left: 0 });
+  assert.deepEqual(calls, ['thread/queue/list:S:']);
+}));
+
+test('後継へ入れた結果が分からない入力は入れ直さず、断られた入力は旧タスクに残す。どちらも引き継ぎは止めない', async () => withDb(async db => {
+  const make = name => updateAutoHandoff(db, request(db, name).operation.handoff_id, { state: 'continued', target_thread_id: `${name}-T` }).operation;
+  const queue = () => [{ id: 'q1', input: [], clientUserMessageId: 'c1' }, { id: 'q2', input: [], clientUserMessageId: 'c2' }];
+  const receiver = (items, added, fail) => async (profile, parent, action) => action(async (method, params) => {
+    if (method === 'thread/queue/list') return { data: items, nextCursor: null };
+    if (method === 'thread/queue/add') { const failure = fail(params); if (failure) throw failure; added.push(params.clientUserMessageId); return {}; }
+    if (method === 'thread/queue/delete') { items.splice(items.findIndex(item => item.id === params.queuedSubmissionId), 1); return {}; }
+    throw Error(method);
+  });
+  // 応答が途中で切れた（入ったかどうかが分からない）。そこで止め、次に呼ばれても入れ直さない
+  const lost = make('lost'); let items = queue(); let added = [];
+  const timeout = () => Object.assign(new Error('timeout'), { delivery_code: 'CODEX_RECEIVER_TIMEOUT' });
+  assert.deepEqual(await carryAutoHandoffQueue(db, lost, {}, { connect: receiver(items, added, params => params.clientUserMessageId === 'c1' ? timeout() : null) }),
+    { moved: 0, unknown: 1, left: 0 });
+  assert.deepEqual(await carryAutoHandoffQueue(db, lost, {}, { connect: receiver(items, added, () => null) }), { moved: 1, unknown: 1, left: 0 });
+  assert.deepEqual(added, ['c2']); assert.deepEqual(items.map(item => item.id), ['q1'], '結果不明の入力は旧タスクに残る');
+  assert.equal(getAutoHandoff(db, lost.handoff_id).state, 'continued');
+
+  // 前の worker が、入れる途中で終わっていた
+  const crashed = make('crashed'); items = queue(); added = [];
+  updateAutoHandoff(db, crashed.handoff_id, { runtime_json: { ...(crashed.runtime ?? {}), queueCarry: { moved: [], unknown: [], moving: 'q1' } } });
+  assert.deepEqual(await carryAutoHandoffQueue(db, crashed, {}, { connect: receiver(items, added, () => null) }), { moved: 1, unknown: 1, left: 0 });
+  assert.deepEqual(added, ['c2']);
+
+  // はっきり断られた入力は後継に入っていない。旧タスクに残し、次の入力は運ぶ
+  const rejected = make('rejected'); items = queue(); added = [];
+  const reject = () => Object.assign(new Error('rejected'), { delivery_code: 'CODEX_RECEIVER_REJECTED' });
+  assert.deepEqual(await carryAutoHandoffQueue(db, rejected, {}, { connect: receiver(items, added, params => params.clientUserMessageId === 'c1' ? reject() : null) }),
+    { moved: 1, unknown: 0, left: 1 });
+  assert.deepEqual(added, ['c2']); assert.deepEqual(items.map(item => item.id), ['q1']);
 }));
 
 // 元turn（止めた）の後に、旧タスクへ来た入力のturnが続くrollout。laterは後続turnの行。
@@ -728,5 +845,6 @@ test('要約のbackendが使えない時、workerは固定の理由で止まり
     assert.equal(result.state, 'failed'); assert.equal(result.error_code, expected); assert.equal(result.resume_state, 'source_stopped');
     assert.equal(counters.created, 0); assert.equal(counters.submitted, 0); assert.equal(counters.notified, 1);
     assert.equal(counters.marked, undefined, '途中で止まった引き継ぎの旧タスクには印を付けない');
+    assert.equal(counters.carried, undefined, '途中で止まった引き継ぎでは、順番待ちを動かさない');
   }
 }));