throughline 0.16.27 → 0.16.28

package/CHANGELOG.md

@@ -10,6 +10,42 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.28] — 2026-10-14
+
+### 修正
+
+- **Codex Desktopで、ゴール（`/goal`）を持つタスクを引き継いだ後、旧タスクが止まらず、「タスク終了」の通知と後継への画面の切り替えが続いていた**（[ADR 0059](docs/adr/0059-codex-handoff-carries-thread-goal.md)）。Windowsの実機で2026-10-13に起きた。
+  - Codexは、タスクが手すきになるたびにゴールを読み、実行中なら自分で次のターンを起こす。旧タスクにゴールが実行中のまま残っていたので、止めるたびに次のターンが始まった。22:04から1〜2秒おきに2,067回。入力は全部Codex自身の続行の指示で、人の入力は無かった。Throughlineはそのたびにターンを止めて、後継を画面に開いていた。
+  - 後継にはゴールが運ばれていなかった。ゴールで動かしていた作業は、引き継ぎを境に、自分では続かなくなっていた。
+  - 直した後は、引き継ぎの最初に旧タスクのゴールを一時停止にし、後継が作業を続けたのを確かめた後で、ゴールを後継へ運ぶ。目標の文はそのまま、予算は使った分を引いた残りを渡す。動いていたゴールは後継でも動き、利用者が止めていたゴールは止めたまま移る。旧タスクのゴールは、一時停止のまま残す。
+  - 完了したゴールと、Codexが上限や行き詰まりで止めたゴールは運ばない。後継にもうゴールがあれば書き換えない。
+  - ゴールを読めない・書けない時も、引き継ぎは止めない。
+  - 引き継ぎが途中で止まった時は、旧タスクのゴールを実行中へ戻さない（戻すと、続行のターンと引き継ぎの失敗が繰り返される）。失敗の画面に、ゴールを止めてある事を書く。
+- **引き継ぎ済みの旧タスクへ、人の入力ではないターンが来た時にも、後継を画面に開いていた**（同じADR）。ターンの入力がCodex自身の文脈だけの時は、止めて後継を示すが、画面は切り替えない。
+- **0.16.27までの版が引き継いだ旧タスクに、ゴールが実行中のまま残っている時の片付け**（同じADR）。引き継ぎ済みの旧タスクへターンが来た時に、別のprocessで旧タスクのゴールを確かめる。実行中なら一時停止にし、今の後継にゴールが無ければ運ぶ。同じ旧タスクへは30秒に1回まで。片付けた事は`~/.throughline/codex-auto-handoff/goal-settles.jsonl`へ1行残す（時刻・ID・付けた状態。目標の文は書かない）。
+
+### 変わる動き
+
+- ゴールを持つタスクの引き継ぎで、旧タスクのゴールが「一時停止」になり、後継に同じゴールが付く。後継のゴールの使用量は0から数え直す。
+- 後から片付けたゴール（上の3つめ）は、後継が手すきの時は、その場では動き出さない。後継の次のターンが終わった時からCodexが続ける。
+- 旧タスクの画面のゴールの表示は、Codex Desktopがそのタスクを読み直すまで、古いまま見える事がある。
+
+### 対応の範囲
+
+| | macOS | Linux | Windows |
+|---|---|---|---|
+| Codex | 直した。単体試験と、実機で、直した版の関数（止める・運ぶ・片付ける）をCodex Desktop同梱のCodex（0.162.0-alpha.17.2）へ通した（25項目）。止めなければCodexが次のターンを起こし続ける事、止めた後は起きない事、後継がゴールを続けて完了する事まで | 直した。同じ確認を、codex-cli 0.162.1（コンテナ）で。本物のCodex Desktop（同梱の0.162.0-alpha.2）で、ゴールを持つタスクを自動圧縮の手前まで進める通しも流した（入っている0.16.27へ、直した3ファイルを一時だけ重ねた）。8回続けて引き継ぎ、毎回、旧タスクのゴールは一時停止・後継のゴールは実行中になり、最後の後継が作業を終えてゴールを完了した。引き継いだ後の旧タスクへ来たターンは0回（引き継ぎの最中に、1秒以内に4〜5回） | 直した。起きた端末。旧タスクのゴールを一時停止にして、連続が止まるのを見た。同じ確認を、Codex Desktop同梱のCodex（0.162.0-alpha.17.2）で（25項目）。起きた旧タスクの本物の記録へ、直した版のhookの入口を読むだけで当てた（止める・後継を開かない・片付けを起こす、の答え） |
+| Claude Code | 変更なし（タスクごとのゴールが無い） | 同じ | 同じ |
+| Grok | 変更なし（自動継続が無い） | 同じ | 同じ |
+| Cursor | 変更なし（自動継続が無い） | 同じ | 同じ |
+
+### 確かめていない事
+
+- macOSとWindowsの本物のCodex Desktopの画面で、ゴールを持つタスクが自動圧縮の手前まで進んで引き継がれる通し。通したのはLinuxのCodex Desktopだけ。macOSとWindowsは、Desktop同梱のCodexへ関数を通す所までで、画面のタスクは使っていない。
+- 0.16.27までの版が引き継いだ旧タスクの片付け（別のprocessを起こす所）を、本物のhookから通す事。関数と、起こす引数と、起きた旧タスクの記録に対するhookの答えは確かめた。Windowsの起きた旧タスクは、手で一時停止にしてあるので、もうこの道を通らない。
+- Codex Desktopは、完了したゴールを自分で消す（Linuxの実機で、完了の直後に画面の側が`thread/goal/clear`を送った）。完了の前に画面の側がゴールを書き換える場面があるかは見ていない。
+- ゴールの続行の指示（Codex自身の文脈）は、記憶では今までどおり利用者の発言として残る。この版では変えていない。
+
 ## [0.16.27] — 2026-10-13
 
 ### 修正
@@ -2522,7 +2558,8 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.27...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.28...HEAD
+[0.16.28]: https://github.com/kitepon/Throughline/compare/v0.16.27...v0.16.28
 [0.16.27]: https://github.com/kitepon/Throughline/compare/v0.16.26...v0.16.27
 [0.16.26]: https://github.com/kitepon/Throughline/compare/v0.16.25...v0.16.26
 [0.16.25]: https://github.com/kitepon/Throughline/compare/v0.16.24...v0.16.25

package/README.ja.md

@@ -29,7 +29,7 @@ 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`で付け直せます。名前の無い後継にも名前が付きます。`--dry-run`で、付ける名前だけを先に見られます）。一覧で、印の無い1本が今の続きです。元のモデル・推論強度・権限・モードなどが表示後も一致することを確認してから、継続指示を一度だけ送ります。後継でその入力と作業の進捗を観測して完了とします。手動`/compact`は発火対象に含めません。
+自動圧縮の開始前に旧ターンを停止し、同じprojectの新しいタスクへ記憶を注入して表示します。新しいタスクには、前任のタスクの題から`<project名>｜<作業の概要>（自動引き継ぎ）`の名前を付けます。後継が作業を続けたのを確かめた後、旧タスクの名前の頭へ`【引き継ぎ済み】`を付けます（0.16.10から。それより前の版が引き継いだ分は`throughline auto-handoff mark-sources`で付け直せます。名前の無い後継にも名前が付きます。`--dry-run`で、付ける名前だけを先に見られます）。一覧で、印の無い1本が今の続きです。元のモデル・推論強度・権限・モードなどが表示後も一致することを確認してから、継続指示を一度だけ送ります。後継でその入力と作業の進捗を観測して完了とします。手動`/compact`は発火対象に含めません。旧タスクにCodexのゴール（`/goal`）があれば、引き継ぎの最初に一時停止にし、後継が作業を続けた後で後継へ運びます（0.16.28から。動いていたゴールは後継でも動き、止めていたゴールは止めたまま移ります）。
 
 記憶は引き継ぎ全体の直近20ターンをL2全文、それより古いターンをL1で渡します。元のユーザー依頼と中断地点を保持し、tool結果とThinkingは注入しません。本文内の`auto-handoff detail`コマンドで、凍結したL2/L3を引き継ぎID・origin・turnから取得できます。A→B→Cの連続引き継ぎでも祖先の詳細を取得できます。
 

package/README.md

@@ -28,7 +28,7 @@ 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`で付け直せます。名前の無い後継にも名前が付きます。`--dry-run`で、付ける名前だけを先に見られます）。一覧で、印の無い1本が今の続きです。元のモデル・推論強度・権限・モードなどが表示後も一致することを確認してから、継続指示を一度だけ送ります。後継でその入力と作業の進捗を観測して完了とします。手動`/compact`は発火対象に含めません。
+自動圧縮の開始前に旧ターンを停止し、同じprojectの新しいタスクへ記憶を注入して表示します。新しいタスクには、前任のタスクの題から`<project名>｜<作業の概要>（自動引き継ぎ）`の名前を付けます。後継が作業を続けたのを確かめた後、旧タスクの名前の頭へ`【引き継ぎ済み】`を付けます（0.16.10から。それより前の版が引き継いだ分は`throughline auto-handoff mark-sources`で付け直せます。名前の無い後継にも名前が付きます。`--dry-run`で、付ける名前だけを先に見られます）。一覧で、印の無い1本が今の続きです。元のモデル・推論強度・権限・モードなどが表示後も一致することを確認してから、継続指示を一度だけ送ります。後継でその入力と作業の進捗を観測して完了とします。手動`/compact`は発火対象に含めません。旧タスクにCodexのゴール（`/goal`）があれば、引き継ぎの最初に一時停止にし、後継が作業を続けた後で後継へ運びます（0.16.28から。動いていたゴールは後継でも動き、止めていたゴールは止めたまま移ります）。
 
 記憶は引き継ぎ全体の直近20ターンをL2全文、それより古いターンをL1で渡します。元のユーザー依頼と中断地点を保持し、tool結果とThinkingは注入しません。本文内の`auto-handoff detail`コマンドで、凍結したL2/L3を引き継ぎID・origin・turnから取得できます。A→B→Cの連続引き継ぎでも祖先の詳細を取得できます。
 

package/docs/adr/0059-codex-handoff-carries-thread-goal.md

@@ -0,0 +1,96 @@
+# ADR 0059: Codex の旧タスクのゴールは、引き継ぎの初めに止めて、後継へ運ぶ
+
+日付: 2026-10-13
+
+## Context
+
+Codex には、タスクごとのゴール（`/goal`）がある。目標の文を決めておくと、タスクが手すきになるたびに Codex が自分で
+次のターンを起こし、目標が終わるまで続ける。
+
+2026-10-13、Windows の Codex Desktop（同梱の Codex 0.162.0-alpha.17.2、Throughline 0.16.27）で、自動継続が
+引き継いだ後の旧タスクが止まらなかった。
+
+- 22:04:09 に旧タスクを止めて引き継ぎを始め、22:05:44 に後継が作業を続けた（`continued`）。引き継ぎ自体は成功している。
+- 旧タスクには、20:10 に利用者が付けたゴールが「実行中」のまま残っていた。後継にはゴールが無かった。
+- 旧タスクでは、22:04:10 から 1〜2 秒おきに新しいターンが始まり続けた。23:43:35 までに 2,067 回。
+  どのターンも入力は Codex 自身の文脈（`<codex_internal_context source="goal">` で始まる続行の指示）だけで、人の入力は 0。
+- ターンが始まるたびに、文脈が上限を超えているので `PreCompact(auto)` が来る。Throughline は「引き継ぎ済みの旧タスクへ
+  新しい入力が来た」（ADR 0039）として、ターンを止め、後継を画面に開いた。
+- 利用者には、「タスク終了」の通知が続き、画面が後継へ切り替わり続ける様に見えた。旧タスクの記録（rollout）は
+  約34MB まで増えた。モデルは呼ばれていない（止めるのはモデルを呼ぶ前）。
+- 引き継ぎの最中（22:04:10〜22:05:44）にも同じターンが来ていた。こちらは「引き継ぎの最中の入力」（ADR 0040）として
+  止まっていた。
+
+原因は、Throughline がゴールを扱っていなかった事にある。
+
+- Codex は、タスクが手すきになるたびに DB のゴールを読み、`active` なら続行の指示でターンを始める
+  （`codex-rs/ext/goal/src/extension.rs` の `on_thread_idle` → `runtime.rs` の `continue_if_idle`）。
+  hook が止めたターン（`turn_aborted`、`interrupted`）の後も同じ。利用者が自分で中断した時だけの持ち越しの印は、hook の止めでは付かない。
+- 後継は新しいタスクなので、ゴールを持たない。後継は継続の指示の1ターンを終えると、そこで止まる。
+  ゴールで動かしていた作業が、引き継ぎを境に自分では続かなくなっていた。
+
+Codex の app-server には、ゴールを読む・変える・消す口がある（`thread/goal/get`・`thread/goal/set`・`thread/goal/clear`。
+experimental）。別の process から使える。確かめた事（Linux の Codex 0.162.1 と、Windows の実機）:
+
+- 別の process が `status: 'paused'` を書くと、タスクを開いている process は次の手すきで続行を起こさない
+  （Windows の実機で、連続が1ターンの内に止まった）。
+- ゴールの無いタスクへ、別の process が目標の文つきで `status: 'active'` を書ける。そのタスクがターンを動かしている間に
+  書くと、タスクを開いている process は、そのターンの後から続行を起こす。
+- 手すきのタスクへ `active` を書いても、その場では続行が起きない。次にそのタスクのターンが終わった時から起きる。
+- `status: 'paused'` と目標の文を一緒に渡して、止まった状態のゴールを新しく作れる。
+
+## Decision
+
+1. worker は、引き継ぎの最初に、旧タスクのゴールを読む。`active` なら `paused` にする（`pauseAutoHandoffSourceGoal`）。
+   ゴールは消さない。止めたかどうかを、引き継ぎの記録（`runtime_json.goalCarry.paused`）へ書く。目標の文は記録へ写さない。
+2. 後継が作業を続けたのを確かめた後（`continued` の直後、順番待ちを運ぶより先）に、旧タスクのゴールを後継へ運ぶ
+   （`carryAutoHandoffGoal`）。後継の最初のターン（継続の指示）が動いている間に付けるので、そのターンの後から Codex が続ける。
+   - 目標の文はそのまま写す。予算（`tokenBudget`）があれば、旧タスクで使った分を引いた残りを渡す。
+   - この製品が止めたゴールは、後継では `active` にする。利用者が止めていたゴール（`paused`）は、`paused` のまま運ぶ。
+   - 完了したゴール（`complete`）と、Codex が上限や行き詰まりで止めたゴール（`budgetLimited`・`usageLimited`・`blocked`）は運ばない。
+   - 後継にもうゴールがあれば、書き換えない。
+   - 運ぶ時に旧タスクのゴールが `active` なら（最初の一時停止が効かなかった）、先に `paused` にしてから運ぶ。
+3. 旧タスクのゴールは `paused` のまま残す。旧タスクは引き継ぎ済みなので、そのゴールは動かない。
+4. ゴールを読めない・書けない時も、引き継ぎは止めない（ゴールの口が無い版の Codex を含む）。理由は worker のログに残す。
+5. 途中で止まった引き継ぎ（`failed`・`unknown`）では、ゴールを後継へ運ばず、旧タスクのゴールも `active` へ戻さない。
+   戻すと、止まったままの旧タスクで、続行のターンと引き継ぎの失敗が繰り返される。失敗の画面に、ゴールを止めてある事と、
+   旧タスクで続ける時の戻し方を書く。やり直しで `continued` になった時に運ぶ。同じ旧タスクから新しい引き継ぎを作った時は、
+   前の引き継ぎが止めていた事を引き継ぐ（後継では `active` にする）。
+6. 引き継ぎ済みの旧タスクへターンが来た時（ADR 0039 の道）に、次の2つを足す。
+   - そのターンの入力が Codex 自身の文脈だけなら（`<codex_internal_context` で始まる物だけ）、後継を画面に開かない。
+     人が入力していないのに画面を切り替えない。ターンを止めて後継を示す事は変えない。
+   - 旧タスクにゴールが動いたまま残っていないかを、別の process で確かめる（`auto-handoff settle-goal`。hook は待たない）。
+     動いていれば `paused` にし、今の一番先の後継にゴールが無ければ `active` で運ぶ。同じ旧タスクへは30秒に1回まで。
+     0.16.27 までの版が引き継いだ旧タスクと、引き継いだ後で利用者が旧タスクのゴールを再開した時が当たる。
+     片付けた事は `~/.throughline/codex-auto-handoff/goal-settles.jsonl` へ1行残す（時刻・ID・付けた状態。目標の文は書かない）。
+
+## Consequences
+
+- ゴールで動かしていたタスクは、引き継いだ後も後継がゴールで続ける。旧タスクは止まる。
+- 引き継ぎの最中に来る続行のターンは、worker がゴールを止めるまでの数秒の分だけになる。
+- 後継のゴールの使用量（`tokensUsed`・`timeUsedSeconds`）は 0 から数え直しになる。予算は残りを渡すので、合計の上限は変わらない。
+- 6 の片付けで運んだゴールは、後継が手すきの時は、その場では動き出さない。後継の次のターンが終わった時から Codex が続ける。
+- 旧タスクの画面のゴールの表示は、別の process が書いた変更なので、Codex Desktop がそのタスクを読み直すまで古いまま見える事がある。
+- `continued` を記録した直後に worker が落ちると、ゴールは旧タスクで止まったまま、後継へは運ばれない。旧タスクは動かないので
+  連続は起きない。利用者が後継でゴールを付け直す必要がある。
+- `blocked` などで止まっているゴールは運ばない。旧タスクに残る。
+- 引き継ぎ1回につき、Codex の app-server への接続が2回増える（最初の読み書きと、運ぶ時）。
+- Claude Code の自動継続は変えない。Claude Code にはタスクごとのゴールが無い。
+
+## 確かめた範囲
+
+| | macOS | Linux | Windows |
+|---|---|---|---|
+| Codex Desktop | 直した版の関数（止める・運ぶ・片付ける）を、Desktop 同梱の Codex（0.162.0-alpha.17.2）へ通した（25項目） | 同じ確認を codex-cli 0.162.1 で。本物の Codex Desktop（同梱の 0.162.0-alpha.2）で、ゴールを持つタスクの引き継ぎを8回続けて通した | 起きた端末。旧タスクのゴールを `paused` にして、連続が止まるのを見た。関数の確認（25項目）を Desktop 同梱の Codex（0.162.0-alpha.17.2）で。起きた旧タスクの本物の記録へ、直した版の hook の入口を読むだけで当てた |
+| Claude Code | 変更なし（ゴールが無い） | 同じ | 同じ |
+| Grok | 変更なし（自動継続が無い） | 同じ | 同じ |
+| Cursor | 変更なし（自動継続が無い） | 同じ | 同じ |
+
+Linux の通し（2026-10-14 00:05〜00:14 JST）で見た事:
+
+- タスクを Codex Desktop で開くと、実行中のゴールを持つタスクは、入力を待たずに続行のターンを始めた。
+- 引き継ぎのたびに、止めたターンの直後から続行のターンが 0.15 秒ほどの間隔で来た。worker がゴールを止めるまでの1秒以内に 4〜5 回で、
+  その後は来ていない。8回とも `goalCarry` は `{"paused":true,"carried":"active"}`。
+- 最後の後継が作業を終えるとゴールは完了になり、Codex Desktop の画面の側が `thread/goal/clear` を送ってゴールを消した。
+
+macOS と Windows の本物の Codex Desktop の画面で、ゴールを持つタスクが引き継がれる通しは、公開の時点では確かめていない。

package/package.json

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

package/src/cli/auto-handoff.mjs

@@ -5,7 +5,8 @@ import { getDb, openReadOnlyDb, DB_PATH, CURRENT_VERSION } from '../db.mjs';
 import { listAutoHandoffs, getAutoHandoff } from '../codex-auto-handoff-store.mjs';
 import { renderFrozenDetail } from '../codex-auto-handoff-memory.mjs';
 import { readAutoHandoffConfig, writeAutoHandoffConfig } from '../codex-auto-handoff-config.mjs';
-import { autoHandoffDeliveryProfile, runAutoHandoffWorker, markAutoHandoffSources, resolveAutoHandoffSuccessor } from '../codex-auto-handoff.mjs';
+import { autoHandoffDeliveryProfile, runAutoHandoffWorker, markAutoHandoffSources, resolveAutoHandoffSuccessor,
+  settleAutoHandoffSourceGoal } from '../codex-auto-handoff.mjs';
 import { installCodexAutoHandoffHook, installClaudeAutoHandoffHooks, removeClaudeAutoHandoffHooks,
   claudeAutoHandoffHooksRegistered } from './install.mjs';
 import { sameProjectPath } from '../project-path.mjs';
@@ -19,9 +20,9 @@ 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, thread: null, json: false, dryRun: false };
-  if (!['enable', 'disable', 'status', 'resume', 'detail', 'worker', 'desktop-open', 'mark-sources', 'successor'].includes(out.action)) throw Error('auto_handoff_action_invalid');
+  if (!['enable', 'disable', 'status', 'resume', 'detail', 'worker', 'desktop-open', 'mark-sources', 'successor', 'settle-goal'].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': [], successor: ['thread'], detail: ['operation', 'origin', 'turn', 'database'] }[out.action]];
+    resume: ['operation'], worker: ['operation'], 'desktop-open': ['operation'], 'mark-sources': [], successor: ['thread'], 'settle-goal': ['operation', 'thread'], 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');
@@ -36,8 +37,8 @@ export function parseAutoHandoffArgs(args) {
   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', 'desktop-open'].includes(out.action) && !out.operation) throw Error('auto_handoff_operation_required');
-  if (out.action === 'successor' && !out.thread) throw Error('auto_handoff_thread_required');
+  if (['worker', 'resume', 'detail', 'desktop-open', 'settle-goal'].includes(out.action) && !out.operation) throw Error('auto_handoff_operation_required');
+  if (['successor', 'settle-goal'].includes(out.action) && !out.thread) throw Error('auto_handoff_thread_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');
@@ -146,6 +147,9 @@ export async function run(args = []) {
       // 0.16.9 までの版が引き継いだ分の名前を付け直す（名前の無い後継へ名前、旧タスクへ引き継ぎ済みの印）。何度流しても同じ結果になる。
       const db = getDb();
       result = { status: 'ok', dry_run: parsed.dryRun, ...await markAutoHandoffSources(db, { dryRun: parsed.dryRun }) };
+    } else if (parsed.action === 'settle-goal') {
+      // 引き継ぎ済みの旧タスクに動いたまま残ったゴールを止めて、今の後継へ運ぶ（hook が起こす。ADR 0059）。
+      result = await settleAutoHandoffSourceGoal(getDb(), { operationId: parsed.operation, threadId: parsed.thread });
     } else if (parsed.action === 'worker') {
       result = publicOperation(await runAutoHandoffWorker(parsed.operation));
     } else if (parsed.action === 'resume') {

package/src/cli/grok-continue.test.mjs

@@ -1,9 +1,9 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { spawnSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
+import { readFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import {
@@ -141,7 +141,7 @@ test('missing grok binary does not spawn', () => {
   assert.equal(spawned.length, 0);
 });
 
-test('successful continue spawn uses source project cwd and waits', () => {
+test('successful continue spawn uses source project cwd and waits', (t) => {
   const io = capture();
   const spawned = [];
   const uuid = '22222222-2222-4222-8222-222222222222';
@@ -164,6 +164,7 @@ test('successful continue spawn uses source project cwd and waits', () => {
   assert.equal(spawned.length, 1);
   assert.equal(io.out, `grok:${uuid}\n`);
   const { grokArgv, launchFile, cwd } = spawned[0];
+  t.after(() => rmSync(dirname(launchFile), { recursive: true, force: true }));
   assert.equal(cwd, REPO_ROOT);
   assert.equal(grokArgv.includes('--rules'), false);
   assert.ok(grokArgv.at(-1).includes(CONTEXT));
@@ -232,7 +233,11 @@ test('bin usage error is exit 2 without spawning a real grok', () => {
   const result = spawnSync(process.execPath, [BIN_PATH, 'grok-continue'], {
     cwd: REPO_ROOT,
     encoding: 'utf8',
-    env: { ...process.env, HOME: join(tmpdir(), 'tl-grok-continue-missing-home') },
+    env: {
+      ...process.env,
+      HOME: join(tmpdir(), 'tl-grok-continue-missing-home'),
+      USERPROFILE: join(tmpdir(), 'tl-grok-continue-missing-home'),
+    },
   });
   assert.equal(result.status, 2);
   assert.match(result.stderr, /Usage: throughline grok-continue --session <id>/);

package/src/cli/runtime-errors.test.mjs

@@ -1,9 +1,8 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { spawnSync } from 'node:child_process';
-import { mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { testTempDir } from '../test-temp-dir.mjs';
 import { fileURLToPath } from 'node:url';
 
 import { parseArgs, run } from './runtime-errors.mjs';
@@ -43,7 +42,7 @@ test('runtime-errors CLI: internal failure is fixed and does not reflect excepti
 });
 
 test('runtime-errors CLI: snapshot and diagnostics are JSON-only and contain no state path', () => {
-  const root = mkdtempSync(join(tmpdir(), 'throughline-runtime-cli-'));
+  const root = testTempDir('throughline-runtime-cli-');
   const env = {
     ...process.env,
     HOME: root,

package/src/codex-auto-handoff.mjs

@@ -1,4 +1,4 @@
-import { mkdirSync, openSync, closeSync, writeFileSync, appendFileSync, realpathSync } from 'node:fs';
+import { mkdirSync, openSync, closeSync, writeFileSync, appendFileSync, realpathSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, resolve, relative, isAbsolute } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -73,6 +73,30 @@ export async function launchAutoHandoffWorker(id, { resume = false } = {}) {
   } finally { closeSync(log); }
 }
 
+// 同じ旧タスクのゴールを確かめる process を起こす間隔。ゴールの続行は1〜2秒おきに来るので、来るたびには起こさない。
+const GOAL_SETTLE_INTERVAL_MS = 30_000;
+
+/**
+ * 引き継ぎ済みの旧タスクにゴールが動いたまま残っていないかを、別の process に確かめさせる（hook は待たない）。
+ * 同じ旧タスクへは GOAL_SETTLE_INTERVAL_MS に1回まで。
+ * @returns {Promise<boolean>} 起こしたか
+ */
+export async function launchAutoHandoffGoalSettle(threadId, operation, { now = Date.now(), spawn = spawnPortable } = {}) {
+  const dir = join(stateRoot(), 'goal-settle');
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const marker = join(dir, threadId);
+  try { if (now - statSync(marker).mtimeMs < GOAL_SETTLE_INTERVAL_MS) return false; } catch { /* まだ1回も起こしていない */ }
+  writeFileSync(marker, '', { mode: 0o600 });
+  const log = openSync(join(stateRoot(), `${operation.handoff_id}.log`), 'a', 0o600);
+  try {
+    const child = spawn(process.execPath, [CLI_PATH, 'auto-handoff', 'settle-goal', '--operation', operation.handoff_id,
+      '--thread', threadId, '--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 true;
+  } finally { closeSync(log); }
+}
+
 function liveSuccessors(db, threadId, options, seen) {
   const found = [];
   for (const operation of listDeliveredAutoHandoffsForSource(db, threadId)) {
@@ -144,6 +168,12 @@ function recordAutoHandoffRedirect(entry) {
   appendFileSync(join(stateRoot(), 'redirects.jsonl'), JSON.stringify(entry) + '\n', { mode: 0o600 });
 }
 
+/** 引き継ぎ済みの旧タスクに残っていたゴールを片付けた記録。会話の本文も、ゴールの目標の文も書かない。 */
+function recordGoalSettle(entry) {
+  mkdirSync(stateRoot(), { recursive: true, mode: 0o700 });
+  appendFileSync(join(stateRoot(), 'goal-settles.jsonl'), JSON.stringify(entry) + '\n', { mode: 0o600 });
+}
+
 // workerを起動してから、workerが自分のprocessを記録へ名乗るまでの間。この間の引き継ぎは、進んでいる物として扱う。
 const WORKER_START_GRACE_MS = 15_000;
 // workerが1回の引き継ぎに掛ける時間の上限（各段の待ち時間の合計より長い）。process一覧を読めない時だけ使う。
@@ -192,6 +222,7 @@ function settleUndeliveredAutoHandoff(db, threadId, { rolloutPath, processes, re
 export async function requestCodexAutoHandoff({ payload, db = null,
   config = readAutoHandoffConfig(), launchWorker = launchAutoHandoffWorker,
   findThread = findCodexThreadCandidate, openThread = openSuccessor, recordRedirect = recordAutoHandoffRedirect,
+  settleGoal = launchAutoHandoffGoalSettle,
   recordInternalCompaction = recordInternalCompactionStop, recordUnrecordedCompaction = recordUnrecordedCompactionPass,
   processes = readRuntimeProcesses, readTarget = targetState, now = Date.now() } = {}) {
   if (payload.trigger !== 'auto' || !autoHandoffEnabledFor(config, payload.cwd)) return { status: 'skipped' };
@@ -229,9 +260,16 @@ export async function requestCodexAutoHandoff({ payload, db = null,
   const sameTurn = findAutoHandoffForTurn(actualDb, threadId, turnId);
   const successor = sameTurn ? null : findLiveAutoHandoffSuccessor(actualDb, threadId, { findThread });
   if (successor) {
-    const opened = openThread(successor);
+    // Codex が自分で起こしたターン（ゴールの続行など）では、後継を開かない。人が入力していないのに、画面が後継へ
+    // 切り替わり続ける（2026-10-13、Windows。旧タスクに残ったゴールが1〜2秒おきにターンを起こし、約2,000回）。
+    const internal = state.internalInputOnly === true;
+    const opened = internal ? false : openThread(successor);
+    // 旧タスクにゴールが動いたまま残っていると、止めてもすぐ次のターンが来る。別の process で止めて、後継へ運ぶ (ADR 0059)。
+    let goalSettle = false;
+    try { goalSettle = await settleGoal(threadId, successor, { now }); } catch { /* 起こせなくても、このターンは止める */ }
     recordRedirect({ at: new Date().toISOString(), source_thread_id: threadId, source_turn_id: turnId,
-      handoff_id: successor.handoff_id, target_thread_id: successor.target_thread_id, opened });
+      handoff_id: successor.handoff_id, target_thread_id: successor.target_thread_id, opened,
+      ...(internal ? { internal: true } : {}), ...(goalSettle ? { goal_settle: true } : {}) });
     return { status: 'ok', operationId: successor.handoff_id, inserted: false, redirected: true,
       targetThreadId: successor.target_thread_id, opened, continue: false,
       stopReason: `このタスクはThroughlineが新しいタスクへ引き継ぎ済みです（引き継ぎID: ${successor.handoff_id}）。` +
@@ -446,6 +484,88 @@ export async function carryAutoHandoffQueue(db, operation, runtime, { connect =
   return summary();
 }
 
+// Codex のゴール（`/goal`。目標が終わるまで、タスクが手すきになるたびに Codex が自分で次のターンを起こす）のうち、
+// 後継へ運ぶ状態。動いている物と、利用者が止めている物だけ。完了した物と、Codex が上限や行き詰まりで止めた物は運ばない。
+const CARRIED_GOAL_STATUSES = new Set(['active', 'paused']);
+
+/**
+ * 旧タスクのゴールを一時停止にする。動いたままのゴールは、hook が止めたターンの直後から、Codex が次のターンを
+ * 起こし続ける。ゴールは消さない（後継へ運ぶ元にする。旧タスクで続けたい時は、利用者が再開できる）。
+ * ゴールを扱えなくても引き継ぎは止めない（理由は worker のログに残す）。
+ * @returns {Promise<'paused'|'idle'|'none'|'failed'>} idle は動いていないゴールがある、none はゴールが無い
+ */
+export async function pauseAutoHandoffSourceGoal(operation, runtime, { connect = withCodexReceiver } = {}) {
+  const threadId = operation.source_thread_id;
+  try {
+    return await connect(autoHandoffDeliveryProfile, { thread_id: threadId, codex_home: operation.codex_home }, async request => {
+      const goal = (await request('thread/goal/get', { threadId })).goal;
+      if (!goal) return 'none';
+      if (goal.status !== 'active') return 'idle';
+      await request('thread/goal/set', { threadId, status: 'paused' });
+      return 'paused';
+    }, runtime);
+  } catch (cause) {
+    process.stderr.write(`[auto-handoff] source goal pause failed: ${cause?.delivery_code ?? cause?.code ?? 'unknown'}\n`);
+    return 'failed';
+  }
+}
+
+/**
+ * 旧タスクのゴールを後継へ運ぶ。目標の文と、予算の残りを写す。旧タスクで動いていたゴールは後継でも動かし、
+ * 利用者が止めていたゴールは止めたまま運ぶ。後継にもうゴールがあれば書き換えない。旧タスクのゴールは消さない。
+ * 運べなくても引き継ぎは止めない（後継はもう作業を続けている。理由は worker のログに残す）。
+ * @param {{wasActive?: boolean, onlyActive?: boolean, sourceThreadId?: string}} [options] wasActive は、引き継ぎの初めに
+ *   この製品が一時停止にしたゴール（後継では動かす）。onlyActive は、今も動いているゴールだけを運ぶ（止まっている物には触らない）。
+ * @returns {Promise<'active'|'paused'|'kept'|'none'|'failed'>} active・paused は後継へ付けた状態、kept は後継にもうゴールがある
+ */
+export async function carryAutoHandoffGoal(operation, runtime, { connect = withCodexReceiver, wasActive = false,
+  onlyActive = false, sourceThreadId = operation.source_thread_id } = {}) {
+  const targetId = operation.target_thread_id;
+  try {
+    return await connect(autoHandoffDeliveryProfile, { thread_id: sourceThreadId, codex_home: operation.codex_home }, async request => {
+      const goal = (await request('thread/goal/get', { threadId: sourceThreadId })).goal;
+      if (!goal || !CARRIED_GOAL_STATUSES.has(goal.status) || typeof goal.objective !== 'string') return 'none';
+      let active = wasActive;
+      if (goal.status === 'active') {
+        // 初めの一時停止が効かなかった、または引き継いだ後で動き出した。旧タスクを先に止める。
+        await request('thread/goal/set', { threadId: sourceThreadId, status: 'paused' });
+        active = true;
+      } else if (onlyActive) return 'none';
+      if ((await request('thread/goal/get', { threadId: targetId })).goal) return 'kept';
+      const status = active ? 'active' : 'paused';
+      // 予算は、旧タスクで使った分を引いた残りを渡す（使い切ったゴールは Codex が budgetLimited にするので、ここへ来ない）。
+      const budget = Number.isSafeInteger(goal.tokenBudget)
+        ? Math.max(1, goal.tokenBudget - (Number.isSafeInteger(goal.tokensUsed) ? goal.tokensUsed : 0)) : null;
+      await request('thread/goal/set', { threadId: targetId, objective: goal.objective, status,
+        ...(budget == null ? {} : { tokenBudget: budget }) });
+      return status;
+    }, runtime);
+  } catch (cause) {
+    process.stderr.write(`[auto-handoff] goal carry failed: ${cause?.delivery_code ?? cause?.code ?? 'unknown'}\n`);
+    return 'failed';
+  }
+}
+
+/**
+ * 引き継ぎ済みの旧タスクにゴールが動いたまま残っていた時の片付け（hook が起こす）。旧タスクのゴールを一時停止にし、
+ * 今の後継にゴールが無ければ運ぶ。0.16.27 までの版が引き継いだ旧タスクと、引き継いだ後で利用者が再開したゴールが当たる。
+ * @returns {Promise<{status: 'settled'|'skipped', goal?: string, reason?: string}>}
+ */
+export async function settleAutoHandoffSourceGoal(db, { operationId, threadId }, { executable = () => platformDesktopFinder()(),
+  carryGoal = carryAutoHandoffGoal, findThread = findCodexThreadCandidate, record = recordGoalSettle } = {}) {
+  if (!CODEX_NATIVE_ID_PATTERN.test(threadId ?? '')) throw error('handoff_thread_id_invalid');
+  // 起こされてからここまでの間に、後継がさらに引き継いでいる事がある。今の一番先の後継へ運ぶ。
+  const successor = findLiveAutoHandoffSuccessor(db, threadId, { findThread });
+  if (!successor || !getAutoHandoff(db, operationId)) return { status: 'skipped', reason: 'handoff_successor_unavailable' };
+  const goal = await carryGoal(successor, { executable: executable(), timeout_ms: 30_000 }, { sourceThreadId: threadId, onlyActive: true });
+  if (goal !== 'none') {
+    record({ at: new Date().toISOString(), source_thread_id: threadId, handoff_id: successor.handoff_id,
+      target_thread_id: successor.target_thread_id, goal });
+    process.stderr.write(`[auto-handoff] goal settled: ${goal}\n`);
+  }
+  return { status: 'settled', goal };
+}
+
 // 受け取った記憶をそのまま運ぶ上限。超えた分は切り、切った事を記録する（後継の記憶に出す）。
 const INHERITED_MEMORY_MAX_CHARS = 120_000;
 
@@ -606,6 +726,7 @@ export function showAutoHandoffFailure(operation) {
 <p><a href="codex://threads/${escape(operation.source_thread_id)}">旧タスクを開く</a>${operation.target_thread_id ? ` / <a href="codex://threads/${escape(operation.target_thread_id)}">後継タスクを開く</a>` : ''}</p>
 <p>理由: <code>${escape(operation.error_code)}</code></p><p>引き継ぎID: <code>${escape(operation.handoff_id)}</code></p>
 ${operation.error_code === 'handoff_summarizer_backend_failed' ? '<p>記憶の要約に使うCodex CLIが失敗しました。通信の断、利用上限、認証切れなどで起きます。会話の記録と入力は失われていません。Codex CLIが使える様になった後、旧タスクへ入力すると、引き継ぎをもう一度始めます。</p>' : ''}
+${operation.runtime?.goalCarry?.paused ? '<p>旧タスクのゴール（/goal）は、同じターンが繰り返されない様に一時停止にしてあります。引き継ぎを再開して後継が動けば、ゴールは後継へ運ばれます。旧タスクのまま続ける時は、旧タスクでゴールを再開してください。</p>' : ''}
 <p>状態: ${escape(operation.state)} / 停止した工程: ${escape(operation.resume_state)}</p>
 <p>確認: <code>throughline auto-handoff status --operation ${escape(operation.handoff_id)}</code></p>
 <p>原因を解消した後の再開: <code>throughline auto-handoff resume --operation ${escape(operation.handoff_id)}</code></p>
@@ -618,7 +739,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,
+    carryQueue: carryAutoHandoffQueue, pauseGoal: pauseAutoHandoffSourceGoal, carryGoal: carryAutoHandoffGoal,
     submit: submitCodexParentAnswer, notify: showAutoHandoffFailure, wait: waitForHandoff,
     executable: () => platformDesktopFinder()(), liveSuccessor: findLiveAutoHandoffSuccessor, ...dependencies };
   let operation = getAutoHandoff(db, id);
@@ -644,6 +765,13 @@ export async function runAutoHandoffWorker(id, { db = getDb(), resume = false, d
       throw error('handoff_mutation_outcome_unknown');
     }
     const runtime = { executable: deps.executable(), timeout_ms: 30_000 };
+    // 旧タスクのゴールを先に止める。動いたままだと、止めたターンの直後から Codex が次のターンを起こし続ける。
+    // 同じ旧タスクの前の引き継ぎ（途中で止まった物）が止めていたゴールは、動いていた物として後継へ運ぶ (ADR 0059)。
+    if (!operation.runtime?.goalCarry) {
+      const paused = await deps.pauseGoal(operation, runtime) === 'paused' ||
+        listUndeliveredAutoHandoffsForSource(db, operation.source_thread_id).some(other => other.runtime?.goalCarry?.paused);
+      update({ runtime_json: { ...(operation.runtime ?? {}), goalCarry: { paused } } });
+    }
     if (operation.state === 'requested') {
       const state = await deps.wait(() => {
         const state = deps.readSource(operation);
@@ -663,7 +791,7 @@ export async function runAutoHandoffWorker(id, { db = getDb(), resume = false, d
       }
       const native = await deps.nativeState(operation, runtime);
       update({ state: 'source_stopped', settings_json: state.settings,
-        runtime_json: { ...native, databasePath: DB_PATH, ...(inheritedMemory ? { inheritedMemory } : {}) } });
+        runtime_json: { ...(operation.runtime ?? {}), ...native, databasePath: DB_PATH, ...(inheritedMemory ? { inheritedMemory } : {}) } });
     }
     // 最中に来た入力のturnが止まり切るまでの間は、境界がまだ見えない。短く待ってから判定する。
     const confirmSourceBoundary = () => deps.wait(() => sourceBoundary(operation, deps.readSource(operation)) || null,
@@ -737,6 +865,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 });
+      // 旧タスクのゴールを後継へ運ぶ。後継の最初のターンが動いている間に付けると、そのターンの後から Codex が続ける。
+      const goal = await deps.carryGoal(operation, runtime, { wasActive: operation.runtime?.goalCarry?.paused === true });
+      update({ runtime_json: { ...(getAutoHandoff(db, id).runtime ?? {}), goalCarry: { ...(operation.runtime?.goalCarry ?? {}), carried: goal } } });
+      if (goal !== 'none') globalThis.process.stderr.write(`[auto-handoff] goal carried: ${goal}\n`);
       // 旧タスクの順番待ちに残った入力を後継へ運ぶ。後継の最初のターン（継続の指示）が始まった後なので、順番は変わらない。
       await deps.carryQueue(db, operation, runtime);
       // 後継が作業を続けたのを確かめてから付ける。途中で止まった引き継ぎの旧タスクには付けない。

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

@@ -7,6 +7,8 @@ import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { EventEmitter } from 'node:events';
+import { testTempDir } from './test-temp-dir.mjs';
 import { requestAutoHandoff, updateAutoHandoff, getAutoHandoff, freezeCodexMemory,
   claimAutoHandoff, continuationInput } from './codex-auto-handoff-store.mjs';
 import { collectAutoHandoffMemory, ensureAutoHandoffSummaries, renderAutoHandoffMemory,
@@ -15,7 +17,8 @@ import { readCodexHandoffState, settingsMatch, threadStartSettings, resolvePrepa
 import { runAutoHandoffWorker, requestCodexAutoHandoff, sourceBoundary,
   autoHandoffTargetName, nameAutoHandoffTarget, findLiveAutoHandoffSuccessor,
   markAutoHandoffSource, markAutoHandoffSources, autoHandoffSourceFallbackTitle, carryAutoHandoffQueue,
-  untrackedInheritedMemory, resolveAutoHandoffSuccessor, hookIdentityShape } from './codex-auto-handoff.mjs';
+  untrackedInheritedMemory, resolveAutoHandoffSuccessor, hookIdentityShape,
+  pauseAutoHandoffSourceGoal, carryAutoHandoffGoal, settleAutoHandoffSourceGoal, launchAutoHandoffGoalSettle } from './codex-auto-handoff.mjs';
 import { parseAutoHandoffArgs } from './cli/auto-handoff.mjs';
 
 async function withDb(fn) {
@@ -117,6 +120,10 @@ 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,
+    pauseGoal: async operation => { (counters.goal ??= []).push(`pause:${operation.state}`); return counters.goalPause ?? 'none'; },
+    carryGoal: async (operation, runtime, options) => {
+      (counters.goal ??= []).push(`carry:${operation.state}:${options.wasActive}`); return counters.goalCarry ?? 'none';
+    },
     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}`);
@@ -193,7 +200,7 @@ test('実行中の子がある時は後継を作らない', async () => withDb(a
 }));
 
 test('rollout の developer 記憶から、受け取った Throughline の記憶の本文を最初の1つだけ読む', () => {
-  const dir = mkdtempSync(join(tmpdir(), 'tl-inherited-'));
+  const dir = testTempDir('tl-inherited-');
   const file = join(dir, 'rollout.jsonl');
   const developer = text => ({ type: 'response_item', payload: { type: 'message', role: 'developer', content: [{ type: 'input_text', text }] } });
   const rows = [{ type: 'session_meta', payload: { id: 'T', cwd: '/project', originator: 'Codex Desktop', source: 'vscode' } },
@@ -445,7 +452,7 @@ test('引き継ぎ済みの旧タスクへ新しい入力が来ても後継を
   const payload = desktopSource(home, thread, '33333333-3333-3333-3333-333333333333');
   const config = { enabled: true, projects: [home], openHost: 'desktop' };
   const seen = { launched: 0, opened: [], recorded: [], asked: [] };
-  const args = { db, config, payload, launchWorker: async () => { seen.launched++; },
+  const args = { db, config, payload, launchWorker: async () => { seen.launched++; }, settleGoal: async () => false,
     findThread: query => { seen.asked.push(query); return { mtimeMs: 1 }; },
     openThread: operation => { seen.opened.push(operation.target_thread_id); return true; },
     recordRedirect: entry => { seen.recorded.push(entry); } };
@@ -1025,3 +1032,248 @@ test('要約のbackendが使えない時、workerは固定の理由で止まり
     assert.equal(counters.carried, undefined, '途中で止まった引き継ぎでは、順番待ちを動かさない');
   }
 }));
+
+// Codex のゴールの口の代わり。goals は thread id ごとの今のゴール（無ければ null）。
+function goalReceiver(goals, sent, fail = null) {
+  return async (profile, parent, action) => action(async (method, params) => {
+    sent.push([method, params]);
+    if (method === fail) throw Object.assign(new Error('rejected'), { delivery_code: 'CODEX_RECEIVER_REJECTED' });
+    if (method === 'thread/goal/get') return { goal: goals[params.threadId] ?? null };
+    if (method === 'thread/goal/set') {
+      const { threadId, ...fields } = params;
+      goals[threadId] = { tokenBudget: null, tokensUsed: 0, ...(goals[threadId] ?? {}), ...fields };
+      return { goal: goals[threadId] };
+    }
+    throw new Error(`想定していない要求: ${method}`);
+  });
+}
+
+test('旧タスクの動いているゴールを一時停止にし、止まっているゴールと無いゴールには触らない。扱えなくても引き継ぎは止めない', async () => {
+  const operation = { source_thread_id: 'S', codex_home: '/home' };
+  let sent = []; let goals = { S: { status: 'active', objective: '目標' } };
+  assert.equal(await pauseAutoHandoffSourceGoal(operation, {}, { connect: goalReceiver(goals, sent) }), 'paused');
+  assert.deepEqual(sent, [['thread/goal/get', { threadId: 'S' }], ['thread/goal/set', { threadId: 'S', status: 'paused' }]]);
+  assert.equal(goals.S.objective, '目標', '目標の文は消さない');
+
+  for (const [goal, expected] of [[null, 'none'], [{ status: 'paused', objective: '目標' }, 'idle'], [{ status: 'complete', objective: '目標' }, 'idle']]) {
+    sent = [];
+    assert.equal(await pauseAutoHandoffSourceGoal(operation, {}, { connect: goalReceiver({ S: goal }, sent) }), expected);
+    assert.equal(sent.length, 1, '読むだけ');
+  }
+  // ゴールの口が無い版の Codex、口が断った時。
+  assert.equal(await pauseAutoHandoffSourceGoal(operation, {}, { connect: goalReceiver({}, [], 'thread/goal/get') }), 'failed');
+  assert.equal(await pauseAutoHandoffSourceGoal(operation, {}, { connect: goalReceiver({ S: { status: 'active', objective: 'x' } }, [], 'thread/goal/set') }), 'failed');
+});
+
+test('旧タスクのゴールを後継へ運ぶ。動いていた物は動かし、利用者が止めていた物は止めたまま運び、予算は残りを渡す', async () => {
+  const operation = { source_thread_id: 'S', target_thread_id: 'T', codex_home: '/home' };
+  // この製品が引き継ぎの初めに止めたゴール。後継では動かす。旧タスクのゴールは止めたまま残す。
+  let goals = { S: { status: 'paused', objective: '目標', tokenBudget: 1000, tokensUsed: 300 } }; let sent = [];
+  assert.equal(await carryAutoHandoffGoal(operation, {}, { connect: goalReceiver(goals, sent), wasActive: true }), 'active');
+  assert.deepEqual(sent.at(-1), ['thread/goal/set', { threadId: 'T', objective: '目標', status: 'active', tokenBudget: 700 }]);
+  assert.equal(goals.S.status, 'paused'); assert.equal(goals.S.objective, '目標');
+
+  // 利用者が止めていたゴール。止めたまま運ぶ。予算の無いゴールは、予算を付けない。
+  goals = { S: { status: 'paused', objective: '目標', tokenBudget: null, tokensUsed: 300 } }; sent = [];
+  assert.equal(await carryAutoHandoffGoal(operation, {}, { connect: goalReceiver(goals, sent) }), 'paused');
+  assert.deepEqual(sent.at(-1), ['thread/goal/set', { threadId: 'T', objective: '目標', status: 'paused' }]);
+
+  // 初めの一時停止が効いていなかった時は、ここで旧タスクを先に止めてから、後継で動かす。
+  goals = { S: { status: 'active', objective: '目標' } }; sent = [];
+  assert.equal(await carryAutoHandoffGoal(operation, {}, { connect: goalReceiver(goals, sent) }), 'active');
+  assert.deepEqual(sent.map(([method, params]) => `${method}:${params.threadId}:${params.status ?? ''}`),
+    ['thread/goal/get:S:', 'thread/goal/set:S:paused', 'thread/goal/get:T:', 'thread/goal/set:T:active']);
+
+  // 後継にもうゴールがある時は書き換えない。
+  goals = { S: { status: 'paused', objective: '目標' }, T: { status: 'active', objective: '別の目標' } }; sent = [];
+  assert.equal(await carryAutoHandoffGoal(operation, {}, { connect: goalReceiver(goals, sent), wasActive: true }), 'kept');
+  assert.equal(goals.T.objective, '別の目標'); assert.ok(!sent.some(([method]) => method === 'thread/goal/set'));
+
+  // ゴールが無い、完了した、Codex が上限や行き詰まりで止めた。運ばない。
+  for (const goal of [null, { status: 'complete', objective: '目標' }, { status: 'budgetLimited', objective: '目標' },
+    { status: 'usageLimited', objective: '目標' }, { status: 'blocked', objective: '目標' }]) {
+    sent = [];
+    assert.equal(await carryAutoHandoffGoal(operation, {}, { connect: goalReceiver({ S: goal }, sent), wasActive: true }), 'none');
+    assert.equal(sent.length, 1, '読むだけ');
+  }
+  // 今も動いているゴールだけを運ぶ指定では、止まっているゴールに触らない。
+  goals = { S: { status: 'paused', objective: '目標' } }; sent = [];
+  assert.equal(await carryAutoHandoffGoal(operation, {}, { connect: goalReceiver(goals, sent), onlyActive: true }), 'none');
+  assert.equal(sent.length, 1); assert.equal(goals.T, undefined);
+  // 別の旧タスク（後継のさらに前のタスク）を指定できる。
+  goals = { OLD: { status: 'active', objective: '目標' } }; sent = [];
+  assert.equal(await carryAutoHandoffGoal(operation, {}, { connect: goalReceiver(goals, sent), onlyActive: true, sourceThreadId: 'OLD' }), 'active');
+  assert.equal(goals.OLD.status, 'paused'); assert.equal(goals.T.status, 'active');
+  // 運べなくても例外にしない。
+  assert.equal(await carryAutoHandoffGoal(operation, {}, { connect: goalReceiver({ S: { status: 'paused', objective: 'x' } }, [], 'thread/goal/set') }), 'failed');
+});
+
+// 1つのDBで何度も引き継ぐ試験では、後継のIDを旧タスクごとに変える（後継のIDは一意）。
+function uniqueTarget(deps, source) {
+  const createTarget = deps.createTarget;
+  deps.createTarget = async (db, operation) => {
+    await createTarget(db, operation);
+    updateAutoHandoff(db, operation.handoff_id, { target_thread_id: `target-${source}` });
+  };
+}
+
+test('workerは、最初に旧タスクのゴールを止め、後継が作業を続けた後でゴールを運ぶ。順番待ちを運ぶより先', async () => withDb(async db => {
+  const run = async (source, counters, before = () => {}) => {
+    const operation = request(db, source, { now: 1 }).operation;
+    before(operation);
+    const deps = workerDependencies(db, {}, async () => ({ queued_submission_id: 'receipt' }), counters);
+    uniqueTarget(deps, source);
+    const order = []; const carryQueue = deps.carryQueue, carryGoal = deps.carryGoal;
+    deps.carryQueue = async (...args) => { order.push('queue'); return carryQueue(...args); };
+    deps.carryGoal = async (...args) => { order.push('goal'); return carryGoal(...args); };
+    return { result: await runAutoHandoffWorker(operation.handoff_id, { db, dependencies: deps }), order };
+  };
+  // 動いているゴールがあった。
+  let counters = { created: 0, notified: 0, goalPause: 'paused', goalCarry: 'active' };
+  let { result, order } = await run('goal-active', counters);
+  assert.equal(result.state, 'continued');
+  assert.deepEqual(counters.goal, ['pause:requested', 'carry:continued:true']);
+  assert.deepEqual(order, ['goal', 'queue']);
+  assert.deepEqual(getAutoHandoff(db, result.handoff_id).runtime.goalCarry, { paused: true, carried: 'active' });
+  assert.equal(getAutoHandoff(db, result.handoff_id).runtime.targetPrepared, true, 'ゴールの記録で、ほかの記録を消さない');
+
+  // ゴールが無い・扱えない時も引き継ぎは進む。
+  for (const [index, goalPause] of ['none', 'idle', 'failed'].entries()) {
+    counters = { created: 0, notified: 0, goalPause, goalCarry: goalPause === 'idle' ? 'paused' : 'none' };
+    ({ result } = await run(`goal-${index}`, counters));
+    assert.equal(result.state, 'continued'); assert.equal(counters.notified, 0);
+    assert.deepEqual(counters.goal, ['pause:requested', 'carry:continued:false']);
+  }
+
+  // 途中で止まった引き継ぎをやり直す時は、ゴールをもう一度は読まず、最初に止めた事を覚えている。
+  counters = { created: 0, notified: 0, goalPause: 'paused', goalCarry: 'active' };
+  const operation = request(db, 'goal-resume', { now: 1 }).operation;
+  const deps = workerDependencies(db, {}, async () => ({ queued_submission_id: 'receipt' }), counters);
+  uniqueTarget(deps, 'goal-resume');
+  deps.summaries = () => { throw new Error('別の失敗'); };
+  const failed = await runAutoHandoffWorker(operation.handoff_id, { db, dependencies: deps });
+  assert.equal(failed.state, 'failed'); assert.deepEqual(failed.runtime.goalCarry, { paused: true });
+  assert.deepEqual(counters.goal, ['pause:requested'], '途中で止まった引き継ぎでは、ゴールを後継へ運ばない');
+  deps.summaries = () => {}; counters.goalPause = 'idle';
+  const resumed = await runAutoHandoffWorker(operation.handoff_id, { db, resume: true, dependencies: deps });
+  assert.equal(resumed.state, 'continued');
+  assert.deepEqual(counters.goal, ['pause:requested', 'carry:continued:true']);
+
+  // 同じ旧タスクの前の引き継ぎ（途中で止まった物）が止めていたゴールは、新しい引き継ぎでも動いていた物として運ぶ。
+  counters = { created: 0, notified: 0, goalPause: 'idle', goalCarry: 'active' };
+  ({ result } = await run('goal-earlier', counters, current => {
+    const earlier = requestAutoHandoff(db, { threadId: 'goal-earlier', turnId: 'earlier-turn', projectPath: '/project',
+      rolloutPath: '/codex/rollout.jsonl', codexHome: '/codex', openHost: 'desktop', now: 0 }).operation;
+    updateAutoHandoff(db, earlier.handoff_id, { state: 'failed', runtime_json: { goalCarry: { paused: true } } });
+    assert.notEqual(earlier.handoff_id, current.handoff_id);
+  }));
+  assert.deepEqual(counters.goal, ['pause:requested', 'carry:continued:true']);
+}));
+
+// Codex がゴールの続行で起こして、hook が止めたターンの実物の並び（Windows の Codex Desktop 0.162.0-alpha.17.2、2026-10-13）。
+function goalContinuation(turn, at) {
+  return [
+    { timestamp: `${at}.460Z`, type: 'event_msg', payload: { type: 'task_started', turn_id: turn } },
+    { timestamp: `${at}.782Z`, type: 'response_item', payload: { type: 'message', role: 'user',
+      content: [{ type: 'input_text', text: '<codex_internal_context source="goal">\nContinue working toward the active thread goal.\n</codex_internal_context>' }] } },
+    { timestamp: `${at}.802Z`, type: 'event_msg', payload: { type: 'turn_aborted', turn_id: turn, reason: 'interrupted' } },
+  ];
+}
+
+test('rollout から、ターンの入力が Codex 自身の文脈だけだったかを読む', async () => withDb((db, home) => {
+  const thread = '11111111-1111-1111-1111-111111111111';
+  const file = sourceRollout(home, thread, 'turn-a', [...goalContinuation('turn-goal', '2026-10-07T00:50:00'),
+    ...stoppedInput('turn-person', '2026-10-07T00:51:00')]);
+  const read = turnId => readCodexHandoffState(file, { threadId: thread, turnId }).internalInputOnly;
+  assert.equal(read('turn-goal'), true); assert.equal(read('turn-person'), false); assert.equal(read('turn-a'), false);
+  assert.equal(readCodexHandoffState(file, { threadId: thread }).internalInputOnly, false, 'turn を指定しない時は最後の turn');
+  // 入力が turn の開始より前に記録される並びでも同じ。
+  const [started, input, aborted] = goalContinuation('turn-goal-2', '2026-10-07T00:52:00');
+  const early = sourceRollout(home, '22222222-2222-2222-2222-222222222222', 'turn-a', [input, started, aborted]);
+  assert.equal(readCodexHandoffState(early, { threadId: '22222222-2222-2222-2222-222222222222', turnId: 'turn-goal-2' }).internalInputOnly, true);
+  // ターンの途中で Codex が足す環境の知らせ（日付が変わった時など）は、入力の出どころに数えない（macOS の Codex Desktop 0.162.0-alpha.17.2 の実物）。
+  const [started3, input3, aborted3] = goalContinuation('turn-goal-3', '2026-10-07T00:53:00');
+  const environment = { timestamp: '2026-10-07T00:53:00.790Z', type: 'response_item', payload: { type: 'message', role: 'user',
+    content: [{ type: 'input_text', text: '<environment_context>\n  <current_date>2026-10-08</current_date>\n</environment_context>' }] } };
+  const dated = sourceRollout(home, '33333333-3333-3333-3333-333333333333', 'turn-a', [started3, input3, environment, aborted3]);
+  assert.equal(readCodexHandoffState(dated, { threadId: '33333333-3333-3333-3333-333333333333', turnId: 'turn-goal-3' }).internalInputOnly, true);
+}));
+
+test('引き継ぎ済みの旧タスクへゴールの続行が来た時は、止めるが後継を開かず、ゴールの片付けを起こす', async () => withDb(async (db, home) => {
+  const thread = '11111111-1111-1111-1111-111111111111', turnA = '22222222-2222-2222-2222-222222222222';
+  const goalTurn = '33333333-3333-3333-3333-333333333333', personTurn = '44444444-4444-4444-4444-444444444444';
+  const first = delivered(db, home, thread, turnA, 'successor-1', 1);
+  const config = { enabled: true, projects: [home], openHost: 'desktop' };
+  const seen = { opened: [], recorded: [], settled: [] };
+  const args = { db, config, launchWorker: async () => { throw new Error('後継を増やしてはいけない'); }, findThread: () => ({ mtimeMs: 1 }),
+    openThread: operation => { seen.opened.push(operation.target_thread_id); return true; },
+    recordRedirect: entry => { seen.recorded.push(entry); },
+    settleGoal: async (threadId, operation) => { seen.settled.push([threadId, operation.handoff_id]); return seen.settled.length === 1; } };
+  const payload = (turn, later) => ({ trigger: 'auto', cwd: home, session_id: thread, turn_id: turn,
+    transcript_path: sourceRollout(home, thread, turnA, later) });
+
+  const goal = await requestCodexAutoHandoff({ ...args, payload: payload(goalTurn, goalContinuation(goalTurn, '2026-10-07T00:50:00')) });
+  assert.equal(goal.continue, false); assert.equal(goal.redirected, true); assert.equal(goal.opened, false);
+  assert.deepEqual(seen.opened, [], '人が入力していないターンでは、画面を後継へ切り替えない');
+  assert.deepEqual(seen.settled, [[thread, first.handoff_id]]);
+  assert.deepEqual({ ...seen.recorded[0], at: null }, { at: null, source_thread_id: thread, source_turn_id: goalTurn,
+    handoff_id: first.handoff_id, target_thread_id: 'successor-1', opened: false, internal: true, goal_settle: true });
+
+  // 人の入力では、今までどおり後継を開く。ゴールの片付けは、起こす側が間隔を空ける（ここでは2回めを起こさない）。
+  const person = await requestCodexAutoHandoff({ ...args, payload: payload(personTurn, stoppedInput(personTurn, '2026-10-07T00:51:00')) });
+  assert.equal(person.opened, true); assert.deepEqual(seen.opened, ['successor-1']);
+  assert.equal(seen.recorded[1].internal, undefined); assert.equal(seen.recorded[1].goal_settle, undefined);
+  // 片付けを起こせなくても、ターンは止める。
+  const broken = await requestCodexAutoHandoff({ ...args, settleGoal: async () => { throw new Error('起こせません'); },
+    payload: payload(goalTurn, goalContinuation(goalTurn, '2026-10-07T00:50:00')) });
+  assert.equal(broken.continue, false); assert.equal(broken.redirected, true);
+}));
+
+test('ゴールの片付けは、同じ旧タスクへは間隔を空けて1つだけ起こす', async () => withDb(async () => {
+  const spawned = [];
+  const spawn = (command, args, options) => {
+    spawned.push({ args, detached: options.detached });
+    const child = new EventEmitter(); child.unref = () => {}; child.pid = 1;
+    queueMicrotask(() => child.emit('spawn'));
+    return child;
+  };
+  const operation = { handoff_id: 'handoff-1' };
+  assert.equal(await launchAutoHandoffGoalSettle('thread-a', operation, { spawn }), true);
+  assert.deepEqual(spawned[0].args.slice(1), ['auto-handoff', 'settle-goal', '--operation', 'handoff-1', '--thread', 'thread-a', '--json']);
+  assert.equal(spawned[0].detached, true);
+  assert.equal(await launchAutoHandoffGoalSettle('thread-a', operation, { spawn }), false, '続けて来ても起こさない');
+  assert.equal(await launchAutoHandoffGoalSettle('thread-b', operation, { spawn }), true, '別の旧タスクは別に数える');
+  assert.equal(await launchAutoHandoffGoalSettle('thread-a', operation, { spawn, now: Date.now() + 31_000 }), true, '間隔が空けば、もう一度起こす');
+  assert.equal(spawned.length, 3);
+}));
+
+test('片付けは、旧タスクの動いているゴールを止めて、今の一番先の後継へ運び、記録を1行残す', async () => withDb(async (db, home) => {
+  const thread = '11111111-1111-1111-1111-111111111111';
+  const first = delivered(db, home, thread, 'turn-a', 'successor-1', 1);
+  const second = delivered(db, home, 'successor-1', 'turn-b', 'successor-2', 2);
+  const seen = { carried: [], recorded: [] };
+  const options = goal => ({ executable: () => '公式Desktop試験fixture', findThread: () => ({ mtimeMs: 1 }),
+    carryGoal: async (operation, runtime, carry) => { seen.carried.push([operation.handoff_id, carry, runtime.executable]); return goal; },
+    record: entry => { seen.recorded.push(entry); } });
+  const settled = await settleAutoHandoffSourceGoal(db, { operationId: first.handoff_id, threadId: thread }, options('active'));
+  assert.deepEqual(settled, { status: 'settled', goal: 'active' });
+  assert.deepEqual(seen.carried, [[second.handoff_id, { sourceThreadId: thread, onlyActive: true }, '公式Desktop試験fixture']]);
+  assert.deepEqual({ ...seen.recorded[0], at: null }, { at: null, source_thread_id: thread, handoff_id: second.handoff_id,
+    target_thread_id: 'successor-2', goal: 'active' });
+  // 動いているゴールが無ければ、記録を増やさない。
+  assert.deepEqual(await settleAutoHandoffSourceGoal(db, { operationId: first.handoff_id, threadId: thread }, options('none')), { status: 'settled', goal: 'none' });
+  assert.equal(seen.recorded.length, 1);
+  // 後継が残っていない旧タスクは、今の続きなので触らない。
+  const gone = await settleAutoHandoffSourceGoal(db, { operationId: first.handoff_id, threadId: thread }, { ...options('active'), findThread: () => null });
+  assert.equal(gone.status, 'skipped'); assert.equal(seen.carried.length, 2);
+  await assert.rejects(settleAutoHandoffSourceGoal(db, { operationId: first.handoff_id, threadId: 'x y' }, options('active')), /handoff_thread_id_invalid/);
+}));
+
+test('公開CLIのsettle-goalは、引き継ぎIDと旧タスクのIDの両方を要る', () => {
+  const parsed = parseAutoHandoffArgs(['settle-goal', '--operation', 'id', '--thread', 'thread', '--json']);
+  assert.equal(parsed.action, 'settle-goal'); assert.equal(parsed.operation, 'id'); assert.equal(parsed.thread, 'thread');
+  for (const args of [['settle-goal', '--operation', 'id'], ['settle-goal', '--thread', 'thread'],
+    ['settle-goal', '--operation', 'id', '--thread', 'thread', '--host', 'claude']]) {
+    assert.throws(() => parseAutoHandoffArgs(args));
+  }
+});

package/src/haiku-summarizer.test.mjs

@@ -3,7 +3,14 @@ import assert from 'node:assert/strict';
 import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { delimiter, join } from 'node:path';
-import { summarizeToL1, resolveL1Ratio } from './haiku-summarizer.mjs';
+import { testTempDir } from './test-temp-dir.mjs';
+
+// haiku-summarizer は import の時に homedir() から隔離 cwd の道を決める。
+// 試験が動かす利用者の本物の home へ ~/.throughline を作らないよう、先に home を差し替える。
+const TEST_HOME = testTempDir('tl-l1-home-');
+process.env.HOME = TEST_HOME;
+process.env.USERPROFILE = TEST_HOME;
+const { summarizeToL1, resolveL1Ratio } = await import('./haiku-summarizer.mjs');
 
 function makeBin(dir, name, body) {
   const script = join(dir, `${name}.mjs`);

package/src/hosts/codex-handoff-state.mjs

@@ -95,6 +95,11 @@ export function threadStartSettings(settings) {
     ...permissions, config: { model_reasoning_effort: settings.effort } };
 }
 
+// Codex が自分でターンへ入れる文脈の頭（`codex-rs/core/src/context/internal_model_context.rs` の `CONTEXT_START_MARKER`）。
+const CODEX_INTERNAL_CONTEXT_PATTERN = /^\s*<codex_internal_context[\s>]/;
+// Codex がターンの途中で足す環境の知らせ（日付や作業フォルダが変わった時）。入力の出どころには数えない。
+const CODEX_ENVIRONMENT_CONTEXT_PATTERN = /^\s*<environment_context>/;
+
 export function readCodexHandoffState(path, { threadId = null, turnId = null, deliveryText = null } = {}) {
   const rows = decodeRows(path);
   let meta = null, rawSettings = null, preparedSettings = null, context = null, latestTurnId = null;
@@ -110,6 +115,15 @@ export function readCodexHandoffState(path, { threadId = null, turnId = null, de
   // activity はモデルの発言・道具の呼び出し・圧縮・完了のどれかがあったか。入力を受けただけで止まった turn は activity が false。
   const laterTurns = [];
   let sourceSeen = false, later = null;
+  // 見ている turn（turnId を指定した時はその turn、しない時は最後の turn）の入力の出どころ。Codex が自分で入れる文脈
+  // （ゴールの続行の指示など。`<codex_internal_context …>` で始まる）と、それ以外の入力（人やほかの製品が送った物）を分ける。
+  const inputKinds = { turn: { internal: false, other: false }, pending: { internal: false, other: false } };
+  const noteInput = text => {
+    if (CODEX_ENVIRONMENT_CONTEXT_PATTERN.test(text)) return;
+    const watched = !turnId || latestTurnId === turnId;
+    const kinds = turnOpen ? (watched ? inputKinds.turn : null) : inputKinds.pending;
+    if (kinds) kinds[CODEX_INTERNAL_CONTEXT_PATTERN.test(text) ? 'internal' : 'other'] = true;
+  };
   for (const row of rows) {
     const payload = row.payload;
     if (later && (row.type === 'compacted' || row.type === 'token_usage_record')) later.activity = true;
@@ -126,6 +140,8 @@ export function readCodexHandoffState(path, { threadId = null, turnId = null, de
       if (turnId && latestTurnId === turnId) sourceSeen = true;
       else if (turnId && sourceSeen) { later = { turnId: latestTurnId, closed: false, activity: false }; laterTurns.push(later); }
       hasTurnInput = pendingUser != null;
+      if (!turnId || latestTurnId === turnId) inputKinds.turn = inputKinds.pending;
+      inputKinds.pending = { internal: false, other: false };
       if (!turnId || latestTurnId === turnId) {
         turnStartAt = Date.parse(row.timestamp); pendingCalls.clear(); completedTools = 0;
         stoppedAt = null; stoppedReason = null; completedAt = null;
@@ -158,6 +174,7 @@ export function readCodexHandoffState(path, { threadId = null, turnId = null, de
         const text = (payload.content ?? []).filter(c => typeof c.text === 'string').map(c => c.text).join('\n');
         const input = text.trim() && !text.startsWith('# AGENTS.md instructions') && !text.startsWith('<hook_prompt');
         if (input) {
+          noteInput(text);
           if (turnOpen) hasTurnInput = true;
           else pendingUser = text;
         }
@@ -193,6 +210,7 @@ export function readCodexHandoffState(path, { threadId = null, turnId = null, de
       else pendingUser = payload.message;
     }
     if (row.type === 'event_msg' && payload?.type === 'user_message') {
+      noteInput(typeof payload.message === 'string' ? payload.message : '');
       if (turnOpen) hasTurnInput = true;
       else pendingUser = payload.message;
     }
@@ -218,5 +236,7 @@ export function readCodexHandoffState(path, { threadId = null, turnId = null, de
   return { meta, settings, rawSettings, preparedSettings, context, latestTurnId, turnStartAt, stoppedAt, stoppedReason,
     completedAt, correlatedTurnId, hasTurnInput, progress, completedTools, pendingCallCount: pendingCalls.size,
     pendingNativeSessionCount: nativeSessions.size, inheritedThroughlineMemory, inheritedThroughlineMemoryText, laterTurns,
+    // 見ている turn の入力が、Codex が自分で入れた文脈だけだった（人の入力ではない）。
+    internalInputOnly: inputKinds.turn.internal && !inputKinds.turn.other,
     compactedRows: rows.filter(r => r.type === 'compacted').length };
 }

package/src/room-context.test.mjs

@@ -11,7 +11,8 @@ const bin = fileURLToPath(new URL('../bin/throughline.mjs', import.meta.url));
 test('公開CLIは部屋ごとの直近3発言を現在の発言まで返す', () => {
   const home = mkdtempSync(join(tmpdir(), 'tl-room-context-'));
   const run = (input) => spawnSync(process.execPath, [bin, 'room-context', '--json'], {
-    env: { ...process.env, HOME: home }, input: JSON.stringify(input), encoding: 'utf8',
+    // Windows は USERPROFILE で home を決める。HOME だけだと、動かす利用者の本物の DB を開く。
+    env: { ...process.env, HOME: home, USERPROFILE: home }, input: JSON.stringify(input), encoding: 'utf8',
   });
   const base = { projectPath: '/srv/bellteam', roomId: 'room-a', speaker: 'クオ', text: '発言' };
   try {

package/src/runtime-error-hook.test.mjs

@@ -1,10 +1,10 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { execFileSync, spawnSync } from 'node:child_process';
-import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { DatabaseSync } from 'node:sqlite';
-import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
+import { testTempDir } from './test-temp-dir.mjs';
 import { fileURLToPath } from 'node:url';
 import { defaultRuntimeErrorConfigPath, defaultRuntimeErrorStorePath } from './runtime-error-store.mjs';
 import { applyWindowsPrivateAcl } from './os/windows-acl-test-helper.mjs';
@@ -12,7 +12,7 @@ import { applyWindowsPrivateAcl } from './os/windows-acl-test-helper.mjs';
 const BIN = fileURLToPath(new URL('../bin/throughline.mjs', import.meta.url));
 
 function createEnabledEnvironment(prefix) {
-  const root = mkdtempSync(join(tmpdir(), prefix));
+  const root = testTempDir(prefix);
   const env = {
     ...process.env,
     HOME: root,

package/src/runtime-error-report.test.mjs

@@ -2,10 +2,10 @@ import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { spawn, spawnSync } from 'node:child_process';
 import { createHash, createHmac } from 'node:crypto';
-import { chmodSync, existsSync, mkdtempSync, readFileSync, symlinkSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, readFileSync, symlinkSync, writeFileSync } from 'node:fs';
 import { createServer } from 'node:http';
-import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { testTempDir } from './test-temp-dir.mjs';
 import { fileURLToPath } from 'node:url';
 
 import {
@@ -37,7 +37,7 @@ const KEY_ID = 'test-host.throughline';
 const NOW = Date.parse('2026-10-03T08:00:00.000Z');
 
 function createEnvironment(prefix = 'throughline-report-') {
-  const root = mkdtempSync(join(tmpdir(), prefix));
+  const root = testTempDir(prefix);
   const env = {
     ...process.env,
     HOME: root,

package/src/runtime-error-store.test.mjs

@@ -1,9 +1,9 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import childProcess, { spawn } from 'node:child_process';
-import { chmodSync, existsSync, mkdtempSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
+import { testTempDir } from './test-temp-dir.mjs';
 
 import {
   acknowledgeRuntimeErrors,
@@ -22,7 +22,7 @@ import { applyWindowsPrivateAcl, verifyWindowsPrivateAcl } from './os/windows-ac
 const TEST_PLATFORM = process.platform === 'win32' ? 'win32' : 'darwin';
 
 function sandbox() {
-  const root = mkdtempSync(join(tmpdir(), 'throughline-runtime-errors-'));
+  const root = testTempDir('throughline-runtime-errors-');
   const env = {
     HOME: root,
     USERPROFILE: root,

package/src/spike-transcript-writer.test.mjs

@@ -1,9 +1,9 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { DatabaseSync } from 'node:sqlite';
-import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
+import { readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { testTempDir } from './test-temp-dir.mjs';
 import { spikeInject, generateSpikeTracer } from './spike-transcript-writer.mjs';
 
 function makeDb() {
@@ -76,7 +76,7 @@ function seedSession(db, { newSessionId = 'NEW', originId = 'ORIG' } = {}) {
 }
 
 function makeTempJsonl() {
-  const dir = mkdtempSync(join(tmpdir(), 'spike-writer-test-'));
+  const dir = testTempDir('spike-writer-test-');
   return join(dir, 'session.jsonl');
 }
 

package/src/test-temp-dir.mjs

@@ -0,0 +1,24 @@
+// 試験が作る一時フォルダを、その試験 file の process が終わる時に消す。
+// CI のランナーは使い捨てではないので、消さないと回ごとに OS の一時フォルダへ積もる
+// （rabbit の /tmp に 3,026 個。2026-10-13 の計測）。
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const created = [];
+
+process.on('exit', () => {
+  for (const dir of created) {
+    try {
+      rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+    } catch {
+      // 開いたままの file が残る時（Windows）は消せない。試験の成否は変えない。
+    }
+  }
+});
+
+export function testTempDir(prefix) {
+  const dir = mkdtempSync(join(tmpdir(), prefix));
+  created.push(dir);
+  return dir;
+}

package/src/transcript-reader.test.mjs

@@ -1,8 +1,8 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
+import { writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { testTempDir } from './test-temp-dir.mjs';
 import {
   normalizeTerminalText,
   normalizeToolResultContent,
@@ -36,7 +36,7 @@ test('normalizeTerminalText: CRLF を LF にし、行内 CR は最後の上書
 });
 
 function writeTranscript(entries) {
-  const dir = mkdtempSync(join(tmpdir(), 'tl-transcript-'));
+  const dir = testTempDir('tl-transcript-');
   const path = join(dir, 't.jsonl');
   writeFileSync(path, entries.map((e) => JSON.stringify(e)).join('\n') + '\n');
   return path;