throughline 0.16.2 → 0.16.4

package/CHANGELOG.md

@@ -10,6 +10,52 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.4] — 2026-10-07
+
+### 変更
+
+- Codex StopのL1要約backend（Codex CLI）の失敗を、1回ごとにruntime errorとして数えるのをやめる（[ADR 0041](docs/adr/0041-l1-summarizer-backend-unrecovered.md)）。この失敗は、通信の断、利用上限、認証切れ、利用者の取り消しでも起きる。会話の取り込みは済んでいて、要約は次のStopがやり直し、recallはL2の本文を返すので、修理の対象として自動で登録しない。理由と外部CLIのstderrの末尾は、今までどおり端末の`hook-failures.log`に残る。hookの終了codeとstderrは変えない。
+- 最初の失敗から24時間を過ぎても成功を確認できない時だけ、`L1_SUMMARIZER_BACKEND_UNRECOVERED`（`warn`）で数える。要約が成功したら、その記録を`recovered`で解決にする。
+- Codexの自動継続のworkerは、要約のbackendの失敗を`handoff_summarizer_backend_failed`で止める（今までは汎用の`handoff_worker_failed`）。失敗の画面に、通信の断・利用上限・認証切れで起きる事、記録と入力が失われていない事、再開の仕方を書く。
+
+### 変わらない事
+
+- BugHubへ送る本文の形。項目は足していない。
+- hook処理の失敗（`HOOK_*_FAILED`）の数え方と重大度。これらの経路に通信は無い。
+- BugHubへの送信の失敗は、今までどおり送信の状態にだけ残し、runtime errorには数えない。
+
+### 確認していない範囲
+
+- 要約が失敗し続ける間のCodexの画面への影響。
+- 本物のCodex CLIが、通信の断・利用上限・認証切れのそれぞれで返す終了codeとstderr。
+
+## [0.16.3] — 2026-10-07
+
+### 修正
+
+- Codexの自動継続で、引き継ぎの最中（継続の指示を送る前）に旧タスクへ入力が来ると、同じ旧タスクから2つ目の引き継ぎが立っていたのを直す（[ADR 0040](docs/adr/0040-auto-handoff-no-second-successor-while-pending.md)）。1つ目は`handoff_source_advanced`で失敗して失敗の画面を出し、記憶だけが入った後継が残っていた。workerが動いている引き継ぎがある間は、新しい引き継ぎを作らず、ターンを止めて進んでいる引き継ぎのIDを示す。入力を受けただけで止まったturnは、元turnの境界を進めた物として数えない。
+- 後継を作った後、配送の前に止まった引き継ぎは、次の入力で同じ引き継ぎをやり直す（同じID、出来ている後継を使う）。今までは別の引き継ぎを作り、後継が2つになっていた。後継を利用者がもう使っている時、後継が消えている時、旧タスクが進んでいる時、後継を作る前に止まった時は、今までどおり新しい引き継ぎを作る。
+- 2つの入力がほぼ同時に来た時は、先に記録した方だけが引き継ぎを作る。
+- 引き継ぎの最中に旧タスクへ来た入力は、後継へ渡す記憶に入れない。
+- Claude Codeの自動継続で、引き継ぎの記録を24時間で掃除していたため、その後に同じ会話からもう1つ後継が立っていたのを直す。後継の会話が残っている間は、記録を消さない。
+
+### 変わらない事
+
+- 後継が残っていない（消した、アーカイブした）旧タスクからは、今までどおり新しい後継を立てる。
+- 止める場所は`PreCompact(auto)`のまま。旧タスクが圧縮に掛からない間は、旧タスクはそのまま動く。
+- DBの形は変えない（v12）。
+
+### 確認した範囲
+
+- macOSで、公開するtarballを切り離したHOMEへ入れ、2026-10-07の実物のrolloutと`codex_handoffs`の写しへ当てた。止まった入力が続くrolloutで境界が進まない事、最中の入力で行もworkerも増えない事、引き継ぎ済みの旧タスクと引き継いでいないタスクが0.16.2と同じ動きである事。
+- 同じ旧タスクへ6つの入力を同じ時刻に入れて、引き継ぎが1つだけ出来る事（LinuxとmacOS、本物のprocess）。
+
+### 確認していない範囲
+
+- 本物のCodex Desktopでの通しと、画面で最中の入力を止めた理由がどう見えるか。
+- 同じ引き継ぎのやり直しを、本物の後継のタスクで。
+- Claude Codeの記録を残す事を、本物のClaude Codeの会話で。
+
 ## [0.16.2] — 2026-10-07
 
 ### 修正
@@ -1913,7 +1959,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.2...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.4...HEAD
+[0.16.4]: https://github.com/kitepon/Throughline/compare/v0.16.3...v0.16.4
+[0.16.3]: https://github.com/kitepon/Throughline/compare/v0.16.2...v0.16.3
 [0.16.2]: https://github.com/kitepon/Throughline/compare/v0.16.1...v0.16.2
 [0.16.1]: https://github.com/kitepon/Throughline/compare/v0.16.0...v0.16.1
 [0.16.0]: https://github.com/kitepon/Throughline/compare/v0.15.5...v0.16.0

package/docs/05_codex_first_roadmap.md

@@ -162,6 +162,9 @@ DBには引き継ぎID、元thread/turn、project/Codex環境、snapshot参照
 元thread/turnの要求は一意にし、フックの重複で後継を増やさない。
 継続の指示が届いた旧タスクへ新しいturnが来た時は、後継が残っている間は要求を作らず、
 ターンを止めて今の後継を示して開く（[ADR 0039](adr/0039-codex-auto-handoff-one-successor-per-source.md)）。
+継続の指示を送る前の引き継ぎがある旧タスクへ新しいturnが来た時も、要求を作らない。workerが動いていれば
+進んでいる引き継ぎを返して止め、後継を作ったまま止まっていれば同じ引き継ぎをやり直す
+（[ADR 0040](adr/0040-auto-handoff-no-second-successor-while-pending.md)）。
 schema変更は `src/db.mjs` と製品所有migrationへ置き、
 schemaの版とmigrationは同じ製品releaseで更新する。
 

package/docs/adr/0040-auto-handoff-no-second-successor-while-pending.md

@@ -0,0 +1,99 @@
+# ADR 0040: 引き継ぎの最中と、止まった引き継ぎから、2つ目の後継を立てない
+
+日付: 2026-10-07
+
+## Context
+
+ADR 0039（0.16.2）は、継続の指示が届いた後継が残っている旧タスクから、2つ目の後継を立てない様にした。
+オーナーは、1つのタスクや会話で自動継続が2回以上発動しない事を求めた（2026-10-07）。0.16.2 のコードを動かして、
+同じ旧タスクから2つ目の後継が立つ道が残っている事を確かめた。
+
+Codex:
+
+1. **引き継ぎの最中の入力。** worker が継続の指示を送る前（macOS の実績で、要求から継続の確認まで 9〜74 秒）に
+   旧タスクへ入力が来ると、`PreCompact(auto)` がもう一度発火する。ADR 0039 の判定は「指示が届いた引き継ぎ」だけを
+   見るので、別の引き継ぎを作った。1つ目の worker は、元の turn が最新でなくなった事を `handoff_source_advanced` と
+   判定して失敗し、失敗の画面を出す。1つ目が作った後継（記憶だけが入り、指示は無い）が残り、2つ目の引き継ぎが
+   別の後継を立てる。
+2. **後継を作った後、配送の前に止まった引き継ぎ。** 次の入力で、やり直しではなく別の引き継ぎを作った。
+   前の後継が残り、後継が2つになる。
+
+Claude Code:
+
+3. **記録の期限。** 記録は24時間で掃除していた（ADR 0033 の10）。掃除の後、引き継ぎ済みの会話で自動圧縮が起きると、
+   同じ会話からもう1つ後継が立つ。
+
+hook が止めた入力の turn は、Codex Desktop 0.160.1 の rollout に次の並びで残る（2026-10-07 の実物）。
+`thread_settings_applied`、`task_started`、user の `message`、`item_completed`、約1秒後の `turn_aborted`。
+モデルの発言も道具の呼び出しも無い。
+
+オーナーは3つの案から「止める場所は今のまま、穴だけ塞ぐ」を選んだ（2026-10-07）。入力を受けた時点で断る案
+（`UserPromptSubmit` の `decision: "block"`。Codex 0.160.1 と Claude Code 2.1.292 の実物で、モデルが呼ばれない事を
+確かめた）と、DB の一意を元タスクだけにする案は採らない。
+
+## Decision
+
+1. Codex の `PreCompact(auto)` は、その旧タスクに、継続の指示をまだ送っていない引き継ぎがあり、その worker が
+   動いている時、新しい引き継ぎを作らない。`continue: false` でターンを止め、止めた理由に進んでいる引き継ぎの ID を書く。
+   worker が動いているかは、記録の worker の process（pid と誕生時刻）が process 一覧にあるかで見る。
+   worker を起動してから worker が名乗るまでの間（15 秒）は、記録の更新時刻で見る。
+   process 一覧を読めない時は、記録の更新から 10 分の間だけ、動いている物として扱う（後継を2つにしない側へ倒す）。
+2. 入力を受けただけで止まった turn は、元 turn の境界を進めない。worker は、元 turn より後の turn がどれも
+   「止まっていて、モデルの発言・道具の呼び出し・完了・圧縮が無い」時、今までどおり引き継ぎを続ける。
+   後の turn に動きがあれば、今までどおり `handoff_source_advanced` で止まる。まだ止まり切っていない turn は、
+   止まるまで待つ（30 秒。過ぎれば `handoff_source_stop_unconfirmed`）。
+3. 止めた後で旧タスクへ来た入力は、凍結する記憶へ入れない。後継へは渡さない入力（ADR 0039 の Consequences）。
+4. 後継を作った後、配送の前に止まった引き継ぎは、次の入力で同じ引き継ぎをやり直す。条件は、後継のタスクが
+   残っていて、後継にまだ turn が無く、止まった後の旧タスクに動きが無い事。`failed` は止まった工程から再開し、
+   worker が居なくなった途中の記録はその状態から続ける。
+   条件に合わない時（後継を利用者がもう使っている、後継が消えている、結果不明、旧タスクが進んでいる）と、
+   後継を作る前に止まった引き継ぎからは、今までどおり新しい引き継ぎを作る。後継を作る前の失敗は、残る物が無い。
+5. 2つの入力がほぼ同時に来た時は、先に記録した方だけが引き継ぎを作る。「継続の指示をまだ送っていない引き継ぎが
+   増えていないか」の確認と記録を、1つの transaction で行う。後から来た方は、1の扱いになる。
+   ADR 0039 の5（worker が指示を送る直前の確認）は残す。
+6. 1と4で止めた事は、`~/.throughline/codex-auto-handoff/redirects.jsonl` に `kind`（`in_flight`・`retry`）を付けて残す。
+   ADR 0039 の行（後継を示した回）には `kind` を付けない。
+7. Claude Code の記録は、後継の会話が残っている間は、24時間を過ぎても掃除しない。後継が残っているかは、
+   受領が残った引き継ぎ（`sent`）について、後継の transcript があるかで見る。transcript は、旧い会話の transcript の
+   場所から Claude の projects をたどり、その下のフォルダを順に見る（フォルダ名の付け方は OS で違う）。
+   後継が消えた記録、受領を確かめられなかった記録、失敗した記録は、今までどおり期限で掃除する。
+8. DB の形は変えない（v12）。ADR 0039 の3（後継が残っていない旧タスクからは、新しい引き継ぎを作る）は変えない。
+
+ADR 0039 の2のうち「配送の前に失敗した引き継ぎからは、今までどおり新しい引き継ぎを作る」は、4で置き換える。
+ADR 0033 の10のうち「24時間を過ぎたものは次の引き継ぎの時に掃除する」は、7で置き換える。
+
+## Consequences
+
+- 引き継ぎの最中に旧タスクへ打った入力は、止まる。後継へは渡らない。後継が開いてから、後継で打ち直す。
+- 引き継ぎの最中に来た入力では、失敗の画面は出ない。記憶だけが入った後継も残らない。
+- 後継を消した（アーカイブした）旧タスクからは、今までどおり新しい後継が立つ。1つの旧タスクから後継が2つ出来るのは、
+  この時と、4の条件に合わなかった時だけになる。
+- 旧タスクが圧縮に掛からない間（手動の `/compact` の後など）は、旧タスクはそのまま動く。止めるのは `PreCompact(auto)` の時だけ。
+- Claude Code の引き継ぎ済みの会話は、後継が残っている間、道具と圧縮を止め続ける。道具を呼ばない会話は続けられるが、
+  圧縮されないので、続けると文脈の上限に当たる（0.16.2 までも、記録が残っている間は同じ）。
+- worker が動いているかを見るために、`PreCompact(auto)` の hook が process 一覧を読む事がある。読むのは、その旧タスクに
+  途中の引き継ぎがあり、worker が名乗っている時だけ。
+
+## 確認した範囲
+
+- 0.16.2 のコードで、1・2・3の道を再現した（切り離した HOME と空の DB）。
+- hook が止めた turn の並びは、macOS の Codex Desktop（同梱の Codex 0.160.1）で 2026-10-07 に起きた2回の記録を読んだ。
+- macOS（公開する tarball、切り離した HOME、本物の `codex_handoffs` の写し）。
+  - 2026-10-07 の実物の rollout（元 turn の後に、hook が止めた入力が2つ）で、境界の判定は「止まったまま」になった。
+    0.16.2 は同じ rollout を `handoff_source_advanced` と判定する。
+  - 1つ目の引き継ぎを指示を送る前の状態へ戻した写しへ、本物の入口（`codex-hook pre-compact`）で新しい turn を渡した。
+    `continue: false`、新しい行 0、worker の起動 0、Desktop を開く呼び出し 0。worker が名乗る前（更新時刻）と、
+    worker が動いている時（macOS の process 一覧）の両方で同じ。worker が居なくなり後継も残っていない時は、新しい引き継ぎを作った。
+  - 引き継ぎ済みの旧タスクへの入力（ADR 0039）と、引き継いでいないタスクは、0.16.2 と同じ動き。
+- 同じ旧タスクへ6つの入力を同じ時刻に入れた（本物の process、Linux は5回、macOS は3回）。どの回も、引き継ぎの行は1つ、
+  worker の起動は1回。0.16.2 は6つずつ出来る。
+- hook の本体と worker の本体を通した（Linux、Codex Desktop に触る所だけ差し替え）。最中に来て止まった入力では、
+  1つ目の引き継ぎが `continued` まで進み、失敗の画面は出ず、凍結した記憶に後から来た入力は入らなかった。
+  旧タスクでモデルが答えた時は、後継を作る前に `handoff_source_advanced` で止まった。
+
+## 確認していない範囲
+
+- 本物の Codex Desktop での通し（引き継ぎの最中に、画面から旧タスクへ打つ）。画面で、止めた理由がどう見えるか。
+- 4（同じ引き継ぎのやり直し）を、本物の後継のタスクで。後継にまだ turn が無い状態は、試験の差し替えでだけ見た。
+- Windows と Linux の Codex Desktop。Codex の自動継続は macOS でだけ使われている。
+- 7（Claude Code の記録を残す事）を、本物の Claude Code の会話で。試験で、transcript のフォルダが同じ時と別の時を見た。

package/docs/adr/0041-l1-summarizer-backend-unrecovered.md

@@ -0,0 +1,77 @@
+# ADR 0041: L1 要約 backend の失敗は、復帰を確認できない時だけ数える
+
+日付: 2026-10-07
+
+## Context
+
+オーナーは、通信失敗の報告・重大度・担当の決まりを定めた（2026-10-07、BugHub の `NETWORK_REPORTING.md`）。
+通信環境そのものの不調と、その状態への製品の対処不良を分ける。通常のオフライン、正常な取り消し、
+適切に処理された一時的な失敗を、自動で製品の欠陥として登録しない。必要な診断は保持する。重大度は
+エラーコードや回数だけで固定せず、機能停止・データの喪失・重複・復帰の可否を根拠に付ける。
+
+Throughline が runtime error として数える code は7つで、通信の失敗が入るのは `L1_SUMMARIZER_BACKEND_FAILED`
+（ADR 0028）だけだった。Codex Stop の要約は外部 CLI（`codex exec`）を呼ぶ。通信の断、利用上限、認証切れ、
+model の失敗、利用者の取り消しによる停止で、CLI は非0で終わるか空を返す。0.16.3 までは、この失敗を
+1回ごとに `warn` で数え、BugHub へ未解決の記録として送っていた。
+
+この失敗への Throughline の対処は、次のとおり（ADR 0015・0016・0028）。
+
+- 会話の取り込みは、要約の前に commit している。記憶は失われない。
+- 要約は、次の Stop が同じ turn からやり直す。重複は作らない。
+- L1 が無い間、recall は L2 の本文を返す。
+- hook は終了 code 1 と stderr で失敗を示す。理由と外部 CLI の stderr の末尾は、端末の `hook-failures.log` に残る。
+
+1回ごとの失敗は「適切に処理された一時的な失敗」に当たり、修理の対象として登録する物ではない。
+一方、backend が使えないまま続く端末では、古い turn の要約が作られず、Codex の自動継続は要約を作れずに
+止まる。この影響を隠さない。
+
+他の通信の扱いは、次のとおりで、変えない。
+
+- BugHub への送信の失敗（`unreachable` など）は、送信の状態（`runtime-errors report-status`）にだけ残し、
+  runtime error には数えない。次の時機に、その時点の累計を送り直す。hook の結果は変えない。
+- Claude Code の要約は、Codex CLI → Haiku → L2 の本文の、宣言済みの fallback。backend の失敗では throw せず、数えない。
+- `self-update` の npm の失敗は、呼び出し元へ結果として返す。runtime error には数えない。
+- hook 処理の失敗（`HOOK_*_FAILED`）の経路に、通信は無い。
+
+## Decision
+
+1. `L1_SUMMARIZER_BACKEND_FAILED` を、runtime error として数えるのをやめる。失敗の理由と stderr の末尾は、
+   今までどおり `hook-failures.log` に、この code の名前で残す（端末内だけ）。hook の終了 code と stderr は変えない。
+2. 端末ごとに、成功を確認できていない間の最初と最後の失敗の時刻を持つ
+   （`~/.throughline/l1-backend-recovery.json`。会話の内容も失敗の文面も書かない）。
+3. 最初の失敗から24時間を過ぎた後の失敗は、`L1_SUMMARIZER_BACKEND_UNRECOVERED` として数える。
+   component は `codex_l1_summarizer`、template は
+   `Throughline L1 summarizer backend (Codex CLI) has not recovered for over 24 hours`、severity は `warn`。
+4. severity を `warn` にする根拠は影響。記憶は失われていない（取り込みは済み、recall は L2 を返す）。重複は無い。
+   backend が戻れば、次の Stop で自動で復帰する。機能が止まるのは、Codex の自動継続が古い turn の要約を
+   作れない時で、その時は5の画面が出て、入力と記録は残り、再開できる。
+5. Codex の自動継続の worker は、要約の backend の失敗を、汎用の `handoff_worker_failed` ではなく
+   `handoff_summarizer_backend_failed` で止める。失敗の画面に、通信の断・利用上限・認証切れで起きる事、
+   記録と入力が失われていない事、backend が使える様になった後に旧タスクへ入力すると引き継ぎを始め直す事を書く。
+6. backend が要約を返したら、2の記録を消す。3を数えていた時は、その記録を `recovered` で解決にする
+   （製品の明示の解決。BugHub へは次の送信で届く）。復帰の後の失敗は、また最初から数える。
+7. 前の版が `L1_SUMMARIZER_BACKEND_FAILED` を記録した store を読める様に、その定義は残す。
+8. 送信の本文の形（BugHub の契約）は変えない。項目を足さない。
+
+ADR 0028 の1（1回ごとに数える）と5（severity の根拠のうち、数える条件）は、この ADR で置き換える。
+ADR 0028 の2（対象の error）・3（終了 code と stderr）・4（`hook-failures.log`）は変えない。
+
+## Consequences
+
+- 通信の一時的な断、利用上限、取り消しで要約が1回失敗しても、BugHub には何も出ない。端末の `hook-failures.log` で読める。
+- backend が使えないままの端末は、最初の失敗から24時間を過ぎた後の失敗で、BugHub に `warn` の未解決として出る。
+  これは「復帰を確認できていない」という事実で、原因が通信環境か、認証か、製品かは決めていない。
+  記録の担当は Throughline の保守だが、通信環境や認証の修理は、その環境を管理する担当へ渡す。
+- 「24時間」は、最初の失敗からの経過で見る。その間ずっと失敗し続けていた証明ではない（間に Stop が無ければ、
+  試していない）。記録は成功で自動で解決になる。
+- 要約が成功したかを見るのは、要約を実際に行った Stop だけ。20 turn 以内のスレッドの Stop は、復帰の証拠にしない。
+- runtime error store は、知らない code を持つ記録を schema invalid として拒否する。この版で
+  `L1_SUMMARIZER_BACKEND_UNRECOVERED` を記録した端末を 0.16.3 以前へ戻すと、store を読めなくなる。
+- 0.16.3 までに `L1_SUMMARIZER_BACKEND_FAILED` を記録した端末の記録は、そのまま残る。書き換えない。
+  保守の担当が、端末の正規の入口（`runtime-errors resolve`）で、根拠を付けて閉じる。
+
+## 確認していない範囲
+
+- 要約が失敗し続ける間、Codex の Stop hook は毎回 exit 1 になる。Codex の画面への影響は調べていない（ADR 0028 と同じ）。
+- 本物の Codex CLI が、通信の断・利用上限・認証切れのそれぞれで、どの終了 code と stderr を返すか。
+  試験は、非0で終わる代わりの CLI で行った。

package/package.json

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

package/src/claude-auto-handoff.mjs

@@ -136,6 +136,23 @@ export function publicClaudeAutoHandoff(record) {
     requested_at, updated_at };
 }
 
+/**
+ * 後継の会話が残っているか。受領が残った引き継ぎ（後継の session id が分かっている物）だけを見る。
+ * 後継の transcript は、Claude の projects の下の、後継を起動した project のフォルダに出来る。フォルダ名の付け方は
+ * OS で違うので、旧い会話の transcript の場所から projects をたどり、その下のフォルダを順に見る。
+ */
+function successorRemains(record) {
+  const successorId = record?.successor?.session_id;
+  if (record?.state !== 'sent' || !validSessionId(successorId) || typeof record.transcript_path !== 'string') return false;
+  const file = `${successorId}.jsonl`;
+  const own = dirname(record.transcript_path);
+  if (existsSync(join(own, file))) return true;
+  let folders;
+  try { folders = readdirSync(dirname(own), { withFileTypes: true }); }
+  catch { return false; }
+  return folders.some(entry => entry.isDirectory() && existsSync(join(dirname(own), entry.name, file)));
+}
+
 function removeStale(dir, now) {
   for (const folder of [dir, targetsDir(dir)]) {
     let names;
@@ -153,7 +170,14 @@ function removeStale(dir, now) {
         if (error.code === 'ENOENT') continue; // 別の hook が同時に消した
         throw error;
       }
-      if (now - modifiedAt > STALE_RECORD_MS) rmSync(path, { force: true });
+      if (now - modifiedAt <= STALE_RECORD_MS) continue;
+      // 後継が残っている会話の記録は消さない。消すと、旧い会話からもう1つ後継が立つ。
+      if (folder === dir && name.endsWith('.json')) {
+        let record = null;
+        try { record = readJson(path); } catch { /* 読めない記録は、期限どおり消す */ }
+        if (successorRemains(record)) continue;
+      }
+      rmSync(path, { force: true });
     }
   }
 }

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

@@ -174,6 +174,34 @@ test('PreCompact: session id が無い・pathを含む時は失敗し、期限
   assert.deepEqual(readdirSync(join(dir, 'targets')), []);
 }));
 
+test('PreCompact: 後継の会話が残っている引き継ぎの記録は、期限を過ぎても消さない', () => withDir(dir => {
+  const now = Date.parse('2026-10-04T12:00:00Z');
+  const old = new Date(now - 25 * 3_600_000);
+  const projects = join(dir, 'claude', 'projects');
+  mkdirSync(join(projects, '-work-app'), { recursive: true }); mkdirSync(join(projects, '-moved-app'), { recursive: true });
+  const record = (id, fields) => {
+    writeFileSync(join(dir, `${id}.json`), JSON.stringify({ schema: 'throughline.claude-auto-handoff.v2', handoff_id: `h-${id}`,
+      source_session_id: id, project_path: '/work/app', transcript_path: join(projects, '-work-app', `${id}.jsonl`),
+      state: 'sent', successor: { short_id: 'bbbbbbbb', session_id: `bbbbbbbb-${id.slice(9)}` }, ...fields }));
+    utimesSync(join(dir, `${id}.json`), old, old);
+    return fields?.successor?.session_id ?? `bbbbbbbb-${id.slice(9)}`;
+  };
+  const kept = 'aaaaaaaa-0000-4000-8000-000000000011', moved = 'aaaaaaaa-0000-4000-8000-000000000012';
+  const gone = 'aaaaaaaa-0000-4000-8000-000000000013', unconfirmed = 'aaaaaaaa-0000-4000-8000-000000000014';
+  const failed = 'aaaaaaaa-0000-4000-8000-000000000015';
+  // 後継の transcript が、旧い会話と同じフォルダにある。別の project のフォルダにある（会話を移していた時）。
+  writeFileSync(join(projects, '-work-app', `${record(kept)}.jsonl`), '');
+  writeFileSync(join(projects, '-moved-app', `${record(moved)}.jsonl`), '');
+  // 後継が消されている。受領を確かめられなかった（後継の session id が無い）。立ち上げに失敗した。
+  record(gone);
+  record(unconfirmed, { state: 'unknown', successor: { short_id: 'bbbbbbbb', session_id: null } });
+  writeFileSync(join(projects, '-work-app', `${record(failed, { state: 'failed' })}.jsonl`), '');
+  request(dir, { now });
+  assert.deepEqual(readdirSync(dir).filter(name => name.endsWith('.json')).sort(), [`${SESSION}.json`, `${kept}.json`, `${moved}.json`].sort());
+  // 残した記録の会話は、圧縮と道具を止め続ける。同じ会話から2つ目の後継は立たない。
+  assert.equal(request(dir, { now, payload: { session_id: kept } }).result.status, 'already_requested');
+}));
+
 test('PreToolUse: 記録のある会話の道具を実行させずに止め、止めた時点の依頼と設定を写して worker を1回だけ起動する', () => withDir(async dir => {
   const transcriptPath = join(dir, 'transcript.jsonl');
   writeFileSync(transcriptPath, jsonl([

package/src/cli/codex-hook.mjs

@@ -1,4 +1,4 @@
-import { recordRuntimeErrorBestEffort } from '../runtime-error-store.mjs';
+import { recordRuntimeErrorBestEffort, resolveRecoveredRuntimeErrorBestEffort } from '../runtime-error-store.mjs';
 import { logHookFailure } from '../hook-failure-log.mjs';
 
 function parseArgs(argv) {
@@ -422,6 +422,13 @@ export async function run(argv = []) {
         payload,
         env: process.env,
       });
+      // backend が要約を返した。失敗の後なら、復帰を確認できた（ADR 0041）。失敗の記録が無い時は、ファイルの有無を見るだけ。
+      if (result.summarized?.summarized?.some((turn) => turn.source === 'codex-cli')) {
+        const { noteL1BackendSuccess } = await import('../l1-backend-recovery.mjs');
+        if (noteL1BackendSuccess().reported) {
+          resolveRecoveredRuntimeErrorBestEffort('L1_SUMMARIZER_BACKEND_UNRECOVERED', { env: process.env });
+        }
+      }
     }
     if (parsed.event === 'pre-compact' && result.continue === false) {
       process.stdout.write(JSON.stringify({ continue: false, stopReason: result.stopReason }) + '\n');
@@ -434,7 +441,16 @@ export async function run(argv = []) {
     process.exit(result.continue === false || result.status === 'ok' || result.status === 'skipped' ? 0 : 1);
   } catch (err) {
     const code = codexHookFailureCode(err);
-    recordRuntimeErrorBestEffort(code, { env: process.env });
+    if (code === 'L1_SUMMARIZER_BACKEND_FAILED') {
+      // 取り込みは済み、要約は次の Stop がやり直す。1回ごとの失敗（通信の断・利用上限・取り消しを含む）は
+      // 端末の診断（hook-failures.log）にだけ残す。復帰を24時間確認できていない時だけ数える（ADR 0041）。
+      const { noteL1BackendFailure } = await import('../l1-backend-recovery.mjs');
+      if (noteL1BackendFailure().unrecovered) {
+        recordRuntimeErrorBestEffort('L1_SUMMARIZER_BACKEND_UNRECOVERED', { env: process.env });
+      }
+    } else {
+      recordRuntimeErrorBestEffort(code, { env: process.env });
+    }
     logHookFailure(code, err);
     const msg = err instanceof Error ? err.message : 'unknown';
     if (parsed.json) {

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

@@ -37,6 +37,16 @@ export function listDeliveredAutoHandoffsForSource(db, threadId) {
     ORDER BY created_at DESC`).all(threadId).map(decode);
 }
 
+/**
+ * 継続の指示をまだ送っていない引き継ぎ（新しい順）。進んでいる最中の物と、配送の前に止まった物。
+ * 同じ旧タスクへ次の入力が来た時に、別の引き継ぎを作る前にここを見る。
+ */
+export function listUndeliveredAutoHandoffsForSource(db, threadId) {
+  return db.prepare(`SELECT * FROM codex_handoffs WHERE source_thread_id = ? AND queued_submission_id IS NULL
+    AND state NOT IN ('submitted', 'continued') AND (mutation_stage IS NULL OR mutation_stage <> 'submit')
+    ORDER BY created_at DESC, rowid DESC`).all(threadId).map(decode);
+}
+
 export function listAutoHandoffs(db, { projectPath = null, limit = 20 } = {}) {
   const rows = projectPath == null
     ? db.prepare('SELECT * FROM codex_handoffs ORDER BY created_at DESC LIMIT ?').all(limit)
@@ -106,13 +116,35 @@ export function releaseAutoHandoff(db, id, identity) {
     .run(id, JSON.stringify(identity));
 }
 
+/**
+ * 元turnを止めた後で旧タスクへ来た入力のturn番号。hookが止めたturnで、入力だけが残っている。
+ * 末尾から、止めた時刻より後に始まり、userの発言だけで、道具の記録が無いturnを、後続turnの数まで数える。
+ */
+function turnsAfterSourceStop(bodies, details, source) {
+  const after = new Set();
+  let remaining = source.laterTurns?.length ?? 0;
+  if (!remaining || !Number.isFinite(source.stoppedAt)) return after;
+  for (const number of [...new Set(bodies.map(row => row.turn_number))].sort((a, b) => b - a)) {
+    const rows = bodies.filter(row => row.turn_number === number);
+    if (rows.some(row => row.role !== 'user' || !(row.created_at > source.stoppedAt)) ||
+        details.some(row => row.turn_number === number)) break;
+    after.add(number);
+    if (--remaining === 0) break;
+  }
+  return after;
+}
+
 export function freezeCodexMemory(db, operation, settings, source) {
   const session = db.prepare('SELECT session_id, project_path FROM sessions WHERE session_id = ?')
     .get(operation.source_session_id);
   if (!session || session.project_path !== operation.project_path) throw new Error('handoff_memory_source_mismatch');
   const load = table => db.prepare(`SELECT * FROM ${table} WHERE session_id = ? ORDER BY created_at, id`)
     .all(operation.source_session_id);
-  const bodies = load('bodies'), skeletons = load('skeletons'), details = load('details');
+  const all = { bodies: load('bodies'), skeletons: load('skeletons'), details: load('details') };
+  // 引き継ぎの最中に旧タスクへ来た入力は、後継へ渡さない。記憶は元turnまでで凍結する。
+  const after = turnsAfterSourceStop(all.bodies, all.details, source);
+  const keep = row => !after.has(row.turn_number);
+  const bodies = all.bodies.filter(keep), skeletons = all.skeletons.filter(keep), details = all.details.filter(keep);
   return {
     version: 1, session: { ...session }, settings,
     sourceTurnId: operation.source_turn_id,

package/src/codex-auto-handoff.mjs

@@ -14,7 +14,8 @@ import { captureCodexRolloutToDb } from './codex-capture.mjs';
 import { readAutoHandoffConfig, autoHandoffEnabledFor } from './codex-auto-handoff-config.mjs';
 import { getAutoHandoff, requestAutoHandoff, updateAutoHandoff, failAutoHandoff,
   claimAutoHandoff, releaseAutoHandoff, freezeCodexMemory, continuationInput,
-  findAutoHandoffForTurn, listDeliveredAutoHandoffsForSource } from './codex-auto-handoff-store.mjs';
+  findAutoHandoffForTurn, listDeliveredAutoHandoffsForSource, listUndeliveredAutoHandoffsForSource,
+  HANDOFF_TERMINAL_STATES } from './codex-auto-handoff-store.mjs';
 import { ensureAutoHandoffSummaries, renderAutoHandoffMemory } from './codex-auto-handoff-memory.mjs';
 import { CODEX_NATIVE_ID_PATTERN, CodexHandoffError, readCodexHandoffState,
   settingsMatch, threadStartSettings } from './hosts/codex-handoff-state.mjs';
@@ -38,7 +39,12 @@ const sourceState = (operation, options = {}) => readCodexHandoffState(operation
   { threadId: operation.source_thread_id, turnId: operation.source_turn_id, ...options });
 
 export function sourceBoundary(operation, state) {
-  if (state.latestTurnId !== operation.source_turn_id) throw error('handoff_source_advanced');
+  if (state.latestTurnId !== operation.source_turn_id) {
+    // 引き継ぎの最中に旧タスクへ来た入力は、hookが止める。入力を受けただけで止まったturnは、元turnの境界を進めない。
+    const later = state.laterTurns ?? [];
+    if (!later.length || later.some(turn => turn.activity)) throw error('handoff_source_advanced');
+    if (later.some(turn => !turn.closed)) return false;
+  }
   if (state.pendingCallCount) throw error('handoff_source_operation_pending');
   if (state.pendingNativeSessionCount) throw error('handoff_native_session_pending');
   return Number.isFinite(state.stoppedAt) && state.stoppedAt >= operation.created_at;
@@ -55,11 +61,11 @@ export async function waitForHandoff(check, { timeoutMs = 120_000, intervalMs =
   throw error(timeoutCode);
 }
 
-export async function launchAutoHandoffWorker(id) {
+export async function launchAutoHandoffWorker(id, { resume = false } = {}) {
   mkdirSync(stateRoot(), { recursive: true, mode: 0o700 });
   const log = openSync(join(stateRoot(), `${id}.log`), 'a', 0o600);
   try {
-    const child = spawnPortable(process.execPath, [CLI_PATH, 'auto-handoff', 'worker', '--operation', id, '--json'],
+    const child = spawnPortable(process.execPath, [CLI_PATH, 'auto-handoff', resume ? 'resume' : 'worker', '--operation', id, '--json'],
       { detached: true, stdio: ['ignore', log, log], windowsHide: true });
     await new Promise((resolveSpawn, reject) => { child.once('spawn', resolveSpawn); child.once('error', reject); });
     child.unref();
@@ -103,9 +109,55 @@ function recordAutoHandoffRedirect(entry) {
   appendFileSync(join(stateRoot(), 'redirects.jsonl'), JSON.stringify(entry) + '\n', { mode: 0o600 });
 }
 
+// workerを起動してから、workerが自分のprocessを記録へ名乗るまでの間。この間の引き継ぎは、進んでいる物として扱う。
+const WORKER_START_GRACE_MS = 15_000;
+// workerが1回の引き継ぎに掛ける時間の上限（各段の待ち時間の合計より長い）。process一覧を読めない時だけ使う。
+const WORKER_RUN_LIMIT_MS = 10 * 60_000;
+
+/** その引き継ぎのworkerが動いているか。名乗る前は、記録の更新時刻で見る。 */
+function workerActive(operation, processes, now) {
+  const identity = operation.worker_identity;
+  if (!identity) return now - operation.updated_at < WORKER_START_GRACE_MS;
+  let table;
+  // process一覧を読めない時は、後継を2つにしない側へ倒す。記録が新しい間は、動いている物として扱う。
+  try { table = processes(); } catch { return now - operation.updated_at < WORKER_RUN_LIMIT_MS; }
+  return table.some(p => p.pid === identity.pid && p.started_identity === identity.started_identity);
+}
+
+/**
+ * 配送の前に止まった引き継ぎを、同じ引き継ぎとしてやり直せるか。後継のタスクが出来ていて、まだ誰も使っておらず、
+ * 止まった後の旧タスクに動きが無い時だけ。後継が出来る前に止まった物は残る物が無いので、新しい引き継ぎで足りる。
+ */
+function resumableAfterStop(operation, rolloutPath, readTarget) {
+  if (operation.mutation_stage || !operation.target_thread_id) return false;
+  try {
+    const target = readTarget(operation);
+    if (!target || target.latestTurnId) return false;
+    const later = readCodexHandoffState(rolloutPath,
+      { threadId: operation.source_thread_id, turnId: operation.source_turn_id }).laterTurns;
+    return later.length > 0 && !later.some(turn => turn.activity);
+  } catch { return false; }
+}
+
+/**
+ * 同じ旧タスクの、継続の指示をまだ送っていない引き継ぎの扱い。workerが動いていれば「最中」、後継が出来たまま
+ * 止まっていれば「やり直し」。どちらでもなければ null（新しい引き継ぎを作る）。
+ */
+function settleUndeliveredAutoHandoff(db, threadId, { rolloutPath, processes, readTarget, now }) {
+  const undelivered = listUndeliveredAutoHandoffsForSource(db, threadId);
+  let table = null;
+  const running = () => (table ??= processes());
+  const inFlight = undelivered.find(operation => !HANDOFF_TERMINAL_STATES.has(operation.state) && workerActive(operation, running, now));
+  if (inFlight) return { kind: 'in_flight', operation: inFlight, seen: undelivered };
+  const stopped = undelivered.find(operation => operation.state !== 'unknown' && resumableAfterStop(operation, rolloutPath, readTarget));
+  if (stopped) return { kind: 'retry', operation: stopped, seen: undelivered };
+  return { kind: null, seen: undelivered };
+}
+
 export async function requestCodexAutoHandoff({ payload, db = null,
   config = readAutoHandoffConfig(), launchWorker = launchAutoHandoffWorker,
-  findThread = findCodexThreadCandidate, openThread = openSuccessor, recordRedirect = recordAutoHandoffRedirect } = {}) {
+  findThread = findCodexThreadCandidate, openThread = openSuccessor, recordRedirect = recordAutoHandoffRedirect,
+  processes = readRuntimeProcesses, readTarget = targetState, now = Date.now() } = {}) {
   if (payload.trigger !== 'auto' || !autoHandoffEnabledFor(config, payload.cwd)) return { status: 'skipped' };
   const threadId = payload.session_id, turnId = payload.turn_id;
   if (!CODEX_NATIVE_ID_PATTERN.test(threadId ?? '') || !CODEX_NATIVE_ID_PATTERN.test(turnId ?? '') ||
@@ -121,8 +173,8 @@ export async function requestCodexAutoHandoff({ payload, db = null,
   const codexHome = rolloutPath.slice(0, sessionPart.index);
   const actualDb = db ?? getDb();
   // 引き継ぎ済みの旧タスクへ、新しい入力が来た。作業は後継が持っているので、後継を増やさずに止めて後継を示す。
-  const successor = findAutoHandoffForTurn(actualDb, threadId, turnId) ? null
-    : findLiveAutoHandoffSuccessor(actualDb, threadId, { findThread });
+  const sameTurn = findAutoHandoffForTurn(actualDb, threadId, turnId);
+  const successor = sameTurn ? null : findLiveAutoHandoffSuccessor(actualDb, threadId, { findThread });
   if (successor) {
     const opened = openThread(successor);
     recordRedirect({ at: new Date().toISOString(), source_thread_id: threadId, source_turn_id: turnId,
@@ -133,8 +185,42 @@ export async function requestCodexAutoHandoff({ payload, db = null,
         `続きは後継のタスク「${autoHandoffTargetName(actualDb, successor)}」で行ってください: ` +
         `codex://threads/${successor.target_thread_id}` };
   }
-  const { operation, inserted } = requestAutoHandoff(actualDb, { threadId, turnId, projectPath: state.meta.cwd,
-    rolloutPath, codexHome, openHost: config.openHost });
+  // 引き継ぎの最中（継続の指示を送る前）と、後継が出来たまま止まった旧タスクへ、新しい入力が来た。
+  // 別の引き継ぎを作ると後継が2つになるので、進んでいる引き継ぎを返すか、同じ引き継ぎをやり直す。
+  let settled = sameTurn ? { kind: null, seen: [] }
+    : settleUndeliveredAutoHandoff(actualDb, threadId, { rolloutPath, processes, readTarget, now });
+  let created = null;
+  if (!settled.kind) {
+    // 2つの入力がほぼ同時に来た時は、先に記録した方だけが引き継ぎを作る。確認と記録を1つのtransactionで行う。
+    actualDb.exec('BEGIN IMMEDIATE');
+    try {
+      const seen = new Set(settled.seen.map(operation => operation.handoff_id));
+      const raced = sameTurn ? null : listUndeliveredAutoHandoffsForSource(actualDb, threadId)
+        .find(operation => !seen.has(operation.handoff_id) && !HANDOFF_TERMINAL_STATES.has(operation.state));
+      if (raced) settled = { kind: 'in_flight', operation: raced };
+      else created = requestAutoHandoff(actualDb, { threadId, turnId, projectPath: state.meta.cwd,
+        rolloutPath, codexHome, openHost: config.openHost });
+      actualDb.exec('COMMIT');
+    } catch (cause) {
+      actualDb.exec('ROLLBACK');
+      throw cause;
+    }
+  }
+  if (settled.kind) {
+    const pending = settled.operation;
+    if (settled.kind === 'retry') {
+      try { await launchWorker(pending.handoff_id, { resume: pending.state === 'failed' }); }
+      catch { throw error('handoff_worker_start_failed'); }
+    }
+    recordRedirect({ at: new Date().toISOString(), kind: settled.kind, source_thread_id: threadId, source_turn_id: turnId,
+      handoff_id: pending.handoff_id, target_thread_id: pending.target_thread_id ?? null, opened: false });
+    return { status: 'ok', operationId: pending.handoff_id, inserted: false, continue: false,
+      ...(settled.kind === 'retry' ? { resumed: true } : { inFlight: true }),
+      stopReason: settled.kind === 'retry'
+        ? `Throughlineが、途中で止まった引き継ぎをやり直します（引き継ぎID: ${pending.handoff_id}）。後継のタスクが開いたら、続きはそちらで行ってください。`
+        : `Throughlineが、このタスクを新しいタスクへ引き継いでいる最中です（引き継ぎID: ${pending.handoff_id}）。後継のタスクが開いたら、続きはそちらで行ってください。` };
+  }
+  const { operation, inserted } = created;
   if (inserted) {
     try { await launchWorker(operation.handoff_id); }
     catch {
@@ -256,6 +342,7 @@ export function showAutoHandoffFailure(operation) {
 <h1>自動継続を完了できませんでした</h1><p>引き継ぎは下記の工程で止まっています。タスクと記録を確認してください。</p>
 <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>' : ''}
 <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>
@@ -310,8 +397,11 @@ 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 } });
     }
+    // 最中に来た入力のturnが止まり切るまでの間は、境界がまだ見えない。短く待ってから判定する。
+    const confirmSourceBoundary = () => deps.wait(() => sourceBoundary(operation, deps.readSource(operation)) || null,
+      { timeoutMs: 30_000, timeoutCode: 'handoff_source_stop_unconfirmed' });
     if (operation.state === 'source_stopped') {
-      if (!sourceBoundary(operation, deps.readSource(operation))) throw error('handoff_source_stop_unconfirmed');
+      await confirmSourceBoundary();
       if (!operation.snapshot) {
         const captured = deps.capture(db, { threadId: operation.source_thread_id, codexHome: operation.codex_home,
           projectPath: operation.project_path });
@@ -319,7 +409,14 @@ export async function runAutoHandoffWorker(id, { db = getDb(), resume = false, d
         const state = deps.readSource(operation);
         update({ snapshot_json: freezeCodexMemory(db, operation, operation.settings, state) });
       }
-      deps.summaries(db, operation);
+      try { deps.summaries(db, operation); }
+      catch (cause) {
+        // 古いturnの要約を作るbackend（Codex CLI）が使えない。通信の断・利用上限・認証切れでも起きる。
+        // 汎用の理由にせず、固定の理由で止める。失敗の画面に、失われた物が無い事と再開の仕方を書く（ADR 0041）。
+        if ((cause?.source === 'codex-cli' && ['codex_cli_failed', 'empty_output'].includes(cause.reason)) ||
+            cause?.message === 'handoff_l1_unavailable') throw error('handoff_summarizer_backend_failed');
+        throw cause;
+      }
       update({ state: 'memory_ready' });
     }
     if (operation.state === 'memory_ready') {
@@ -344,7 +441,7 @@ export async function runAutoHandoffWorker(id, { db = getDb(), resume = false, d
       update({ state: 'target_ready' });
     }
     if (operation.state === 'target_ready') {
-      if (!sourceBoundary(operation, deps.readSource(operation))) throw error('handoff_source_stop_unconfirmed');
+      await confirmSourceBoundary();
       await deps.nativeState(operation, runtime);
       const target = deps.readTarget(operation);
       if (target?.latestTurnId || !target?.settings || !settingsMatch(operation.runtime.preparedSettings, target.settings)) throw error('handoff_target_advanced');

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

@@ -429,3 +429,205 @@ test('後継タスクの名前は project 名・前任の題・自動引き継
   const rejected = async () => { throw Object.assign(new Error('unknown method'), { delivery_code: 'CODEX_RECEIVER_REJECTED' }); };
   assert.equal(await nameAutoHandoffTarget(rejected, 'T', 'x'), false, '名前を付けられなくても、引き継ぎは止めない');
 }));
+
+// 元turn（止めた）の後に、旧タスクへ来た入力のturnが続くrollout。laterは後続turnの行。
+function sourceRollout(home, thread, turn, later = [], stoppedAt = '2026-10-07T00:49:01.000Z') {
+  const dir = join(home, 'codex', 'sessions'); mkdirSync(dir, { recursive: true });
+  const file = join(dir, `rollout-${thread}.jsonl`);
+  const rows = [
+    { timestamp: '2026-10-07T00:47:00.000Z', type: 'session_meta', payload: { id: thread, originator: 'Codex Desktop', source: 'vscode', cwd: home } },
+    { timestamp: '2026-10-07T00:47:08.000Z', type: 'event_msg', payload: { type: 'task_started', turn_id: turn } },
+    { timestamp: '2026-10-07T00:47:09.000Z', type: 'response_item', payload: { type: 'message', role: 'user', content: [{ text: '進めて' }] } },
+    { timestamp: '2026-10-07T00:47:15.000Z', type: 'response_item', payload: { type: 'message', role: 'assistant', content: [{ text: '進めるね' }] } },
+    { timestamp: stoppedAt, type: 'event_msg', payload: { type: 'turn_aborted', turn_id: turn, reason: 'interrupted' } },
+    ...later,
+  ];
+  writeFileSync(file, rows.map(row => JSON.stringify(row)).join('\n') + '\n');
+  return file;
+}
+
+// hookが止めたturnの、Codex Desktop 0.160.1 の実物の並び（入力を受けて、1秒ほどで止まる）。
+function stoppedInput(turn, at, { closed = true } = {}) {
+  return [
+    { timestamp: `${at}.071Z`, type: 'event_msg', payload: { type: 'thread_settings_applied', thread_settings: {
+      model: 'model', cwd: '/project', model_provider_id: 'openai', approval_policy: 'never', permission_profile: { type: 'disabled' } } } },
+    { timestamp: `${at}.078Z`, type: 'event_msg', payload: { type: 'task_started', turn_id: turn } },
+    { timestamp: `${at}.206Z`, type: 'response_item', payload: { type: 'message', role: 'user', content: [{ text: '動いてる？' }] } },
+    { timestamp: `${at}.207Z`, type: 'event_msg', payload: { type: 'item_completed', turn_id: turn, item: { type: 'UserMessage' } } },
+    ...(closed ? [{ timestamp: `${at}.213Z`, type: 'event_msg', payload: { type: 'turn_aborted', turn_id: turn, reason: 'interrupted' } }] : []),
+  ];
+}
+
+test('入力を受けただけで止まった後続turnは元turnの境界を進めず、動きのある後続turnは進んだと判定する', async () => withDb((db, home) => {
+  const thread = '11111111-1111-1111-1111-111111111111', turn = '22222222-2222-2222-2222-222222222222';
+  const operation = { source_thread_id: thread, source_turn_id: turn, created_at: Date.parse('2026-10-07T00:49:00.000Z') };
+  const read = later => readCodexHandoffState(sourceRollout(home, thread, turn, later), { threadId: thread, turnId: turn });
+  assert.deepEqual(read([]).laterTurns, []);
+  assert.equal(sourceBoundary(operation, read([])), true);
+  // 止まった入力が2つ続いても、元turnの境界のまま。
+  const two = read([...stoppedInput('turn-b', '2026-10-07T00:56:48'), ...stoppedInput('turn-c', '2026-10-07T00:56:58')]);
+  assert.deepEqual(two.laterTurns, [{ turnId: 'turn-b', closed: true, activity: false }, { turnId: 'turn-c', closed: true, activity: false }]);
+  assert.equal(two.latestTurnId, 'turn-c'); assert.equal(two.stoppedAt, Date.parse('2026-10-07T00:49:01.000Z'));
+  assert.equal(sourceBoundary(operation, two), true);
+  // まだ止まり切っていない入力は、止まるまで待つ（境界は未確認）。
+  assert.equal(sourceBoundary(operation, read(stoppedInput('turn-b', '2026-10-07T00:56:48', { closed: false }))), false);
+  // モデルの発言・道具の呼び出し・完了・圧縮があれば、旧タスクは進んでいる。
+  const activity = [
+    { timestamp: '2026-10-07T00:56:50.000Z', type: 'response_item', payload: { type: 'message', role: 'assistant', content: [{ text: '動いてるよ' }] } },
+    { timestamp: '2026-10-07T00:56:50.000Z', type: 'response_item', payload: { type: 'function_call', call_id: 'c1', name: 'exec_command', arguments: '{}' } },
+    { timestamp: '2026-10-07T00:56:50.000Z', type: 'response_item', payload: { type: 'reasoning' } },
+    { timestamp: '2026-10-07T00:56:50.000Z', type: 'event_msg', payload: { type: 'agent_message', message: '動いてるよ' } },
+    { timestamp: '2026-10-07T00:56:50.000Z', type: 'event_msg', payload: { type: 'task_complete', turn_id: 'turn-b' } },
+    { timestamp: '2026-10-07T00:56:50.000Z', type: 'compacted', payload: {} },
+  ];
+  for (const row of activity) {
+    const state = read([...stoppedInput('turn-b', '2026-10-07T00:56:48', { closed: false }), row]);
+    assert.equal(state.laterTurns[0].activity, true, JSON.stringify(row.payload));
+    assert.throws(() => sourceBoundary(operation, state), /handoff_source_advanced/);
+  }
+  // 元turnの開始が見えないrolloutで最新turnが違う時は、今までどおり進んだと判定する。
+  assert.throws(() => sourceBoundary(operation, { latestTurnId: 'other', stoppedAt: Date.now(), pendingCallCount: 0 }), /handoff_source_advanced/);
+}));
+
+test('引き継ぎの最中に旧タスクへ入力が来ても、別の引き継ぎを作らず、進んでいる引き継ぎを返して止める', async () => withDb(async (db, home) => {
+  const thread = '11111111-1111-1111-1111-111111111111', turnA = '22222222-2222-2222-2222-222222222222';
+  const turnB = '33333333-3333-3333-3333-333333333333', turnC = '44444444-4444-4444-4444-444444444444';
+  const config = { enabled: true, projects: [home], openHost: 'desktop' };
+  const seen = { launched: [], recorded: [], opened: 0 };
+  const worker = { pid: 4242, started_identity: 'worker-born' };
+  const base = { db, config, launchWorker: async (id, options) => { seen.launched.push([id, options?.resume ?? false]); },
+    findThread: () => null, openThread: () => { seen.opened++; return true; }, recordRedirect: entry => { seen.recorded.push(entry); },
+    processes: () => [worker], readTarget: () => null };
+  const first = await requestCodexAutoHandoff({ ...base, payload: desktopSource(home, thread, turnA) });
+  assert.equal(first.inserted, true); assert.equal(seen.launched.length, 1);
+  const count = () => db.prepare('SELECT COUNT(*) AS n FROM codex_handoffs').get().n;
+
+  // workerが名乗る前（起動した直後）に来た入力。
+  const early = await requestCodexAutoHandoff({ ...base, payload: desktopSource(home, thread, turnB) });
+  assert.equal(early.inFlight, true); assert.equal(early.inserted, false); assert.equal(early.continue, false);
+  assert.equal(early.operationId, first.operationId); assert.match(early.stopReason, /引き継いでいる最中/);
+  assert.equal(count(), 1); assert.equal(seen.launched.length, 1);
+
+  // workerが後継を作った後（継続の指示を送る前）に来た入力。時間が経っていても、workerが動いていれば最中。
+  updateAutoHandoff(db, first.operationId, { state: 'memory_ready', target_thread_id: 'target-1', worker_identity_json: worker });
+  const later = await requestCodexAutoHandoff({ ...base, now: Date.now() + 3_600_000, payload: desktopSource(home, thread, turnC) });
+  assert.equal(later.inFlight, true); assert.equal(later.operationId, first.operationId);
+  assert.equal(count(), 1); assert.equal(seen.launched.length, 1); assert.equal(seen.opened, 0);
+  assert.deepEqual(seen.recorded.map(entry => [entry.kind, entry.source_turn_id, entry.handoff_id, entry.target_thread_id, entry.opened]),
+    [['in_flight', turnB, first.operationId, null, false], ['in_flight', turnC, first.operationId, 'target-1', false]]);
+
+  // 同じturnのhookがもう一度来た時は、今までどおり同じ引き継ぎを返す（最中の扱いにしない）。
+  const again = await requestCodexAutoHandoff({ ...base, payload: desktopSource(home, thread, turnA) });
+  assert.equal(again.operationId, first.operationId); assert.equal(again.inFlight, undefined); assert.equal(again.inserted, false);
+
+  // process一覧を読めない時は、記録が新しい間だけ最中として扱う（後継を2つにしない側へ倒す）。
+  const unreadable = () => { throw new Error('process一覧を読めません'); };
+  assert.equal((await requestCodexAutoHandoff({ ...base, processes: unreadable, payload: desktopSource(home, thread, turnC) })).inFlight, true);
+  assert.equal(count(), 1);
+
+  // workerが居なくなり、後継も残っていない引き継ぎは、最中に数えない。今までどおり新しい引き継ぎを作る。
+  const dead = await requestCodexAutoHandoff({ ...base, processes: () => [], payload: desktopSource(home, thread, turnC) });
+  assert.equal(dead.inserted, true); assert.notEqual(dead.operationId, first.operationId); assert.equal(count(), 2);
+}));
+
+test('後継が出来たまま止まった引き継ぎは、次の入力で同じ引き継ぎをやり直し、別の後継を作らない', async () => withDb(async (db, home) => {
+  const thread = '11111111-1111-1111-1111-111111111111', turnA = '22222222-2222-2222-2222-222222222222';
+  const turnB = '33333333-3333-3333-3333-333333333333';
+  const config = { enabled: true, projects: [home], openHost: 'desktop' };
+  const seen = { launched: [], recorded: [] };
+  const base = { db, config, launchWorker: async (id, options) => { seen.launched.push([id, options?.resume ?? false]); },
+    findThread: () => null, openThread: () => { throw new Error('開かない'); }, recordRedirect: entry => { seen.recorded.push(entry); },
+    processes: () => [] };
+  const count = () => db.prepare('SELECT COUNT(*) AS n FROM codex_handoffs').get().n;
+  const fail = (turn, fields) => {
+    const rollout = sourceRollout(home, thread, turn);
+    const operation = requestAutoHandoff(db, { threadId: thread, turnId: turn, projectPath: home, rolloutPath: rollout,
+      codexHome: join(home, 'codex'), openHost: 'desktop', now: 1 }).operation;
+    return updateAutoHandoff(db, operation.handoff_id, { target_thread_id: 'target-1', state: 'failed',
+      resume_state: 'memory_ready', error_code: 'handoff_target_not_loaded', ...fields }).operation;
+  };
+  const input = (turn, later) => {
+    const file = sourceRollout(home, thread, turnA, later);
+    return { trigger: 'auto', cwd: home, session_id: thread, turn_id: turn, transcript_path: file };
+  };
+  const failed = fail(turnA, {});
+  const open = stoppedInput(turnB, '2026-10-07T00:56:48', { closed: false });
+
+  // 後継が残っていて、まだ誰も使っておらず、旧タスクに動きが無い。同じ引き継ぎを再開する。
+  const resumed = await requestCodexAutoHandoff({ ...base, readTarget: () => ({ latestTurnId: null }), payload: input(turnB, open) });
+  assert.equal(resumed.resumed, true); assert.equal(resumed.inserted, false); assert.equal(resumed.continue, false);
+  assert.equal(resumed.operationId, failed.handoff_id); assert.match(resumed.stopReason, /やり直します/);
+  assert.deepEqual(seen.launched, [[failed.handoff_id, true]]); assert.equal(count(), 1);
+  assert.deepEqual(seen.recorded.map(entry => [entry.kind, entry.handoff_id, entry.target_thread_id]), [['retry', failed.handoff_id, 'target-1']]);
+
+  // 後継を利用者がもう使っている・後継が消えている・結果不明・旧タスクが進んでいる時は、今までどおり新しい引き継ぎを作る。
+  const fresh = async (fields, readTarget, later = open) => {
+    db.prepare('DELETE FROM codex_handoffs').run(); seen.launched.length = 0;
+    const row = fail(turnA, fields);
+    const result = await requestCodexAutoHandoff({ ...base, readTarget, payload: input(turnB, later) });
+    assert.equal(result.inserted, true); assert.notEqual(result.operationId, row.handoff_id);
+    assert.deepEqual(seen.launched, [[result.operationId, false]]); assert.equal(count(), 2);
+  };
+  await fresh({}, () => ({ latestTurnId: 'used-by-user' }));
+  await fresh({}, () => null);
+  await fresh({ state: 'unknown', mutation_stage: 'inject' }, () => ({ latestTurnId: null }));
+  await fresh({ target_thread_id: null }, () => ({ latestTurnId: null }));
+  await fresh({}, () => ({ latestTurnId: null }), [
+    ...stoppedInput('turn-x', '2026-10-07T00:55:00', { closed: false }),
+    { timestamp: '2026-10-07T00:55:02.000Z', type: 'response_item', payload: { type: 'message', role: 'assistant', content: [{ text: '続けたよ' }] } },
+    { timestamp: '2026-10-07T00:55:03.000Z', type: 'event_msg', payload: { type: 'task_complete', turn_id: 'turn-x' } },
+    ...open,
+  ]);
+}));
+
+test('workerは、最中に来て止まった入力では失敗せず、旧タスクが進んだ時だけ止まる', async () => withDb(async db => {
+  const run = async (source, laterTurns) => {
+    const operation = request(db, source, { now: 1 }).operation;
+    const counters = { created: 0, submitted: 0, notified: 0 };
+    const deps = workerDependencies(db, {}, async () => { counters.submitted++; return { queued_submission_id: 'receipt' }; }, counters);
+    const read = deps.readSource;
+    deps.readSource = item => ({ ...read(item), latestTurnId: 'input-during-handoff', laterTurns });
+    return { result: await runAutoHandoffWorker(operation.handoff_id, { db, dependencies: deps }), counters };
+  };
+  const stopped = await run('stopped-input', [{ turnId: 'input-during-handoff', closed: true, activity: false }]);
+  assert.equal(stopped.result.state, 'continued'); assert.equal(stopped.counters.submitted, 1); assert.equal(stopped.counters.notified, 0);
+  const advanced = await run('advanced', [{ turnId: 'input-during-handoff', closed: true, activity: true }]);
+  assert.equal(advanced.result.state, 'failed'); assert.equal(advanced.result.error_code, 'handoff_source_advanced');
+  assert.equal(advanced.counters.created, 0); assert.equal(advanced.counters.submitted, 0);
+}));
+
+test('引き継ぎの最中に旧タスクへ来た入力は、凍結する記憶へ入れない', async () => withDb(db => {
+  const operation = request(db, 'frozen-source', { now: 1 }).operation;
+  const session = operation.source_session_id;
+  db.prepare('INSERT INTO sessions (session_id,project_path,created_at,updated_at) VALUES (?, ?, 1, 1)').run(session, '/project');
+  const body = db.prepare('INSERT INTO bodies (session_id,origin_session_id,turn_number,role,text,created_at) VALUES (?, ?, ?, ?, ?, ?)');
+  body.run(session, session, 1, 'user', '進めて', 100); body.run(session, session, 1, 'assistant', '途中まで進めた', 100);
+  body.run(session, session, 2, 'user', '動いてる？', 300); body.run(session, session, 3, 'user', 'ん？', 310);
+  db.prepare('INSERT INTO details (session_id,origin_session_id,turn_number,tool_name,kind,output_text,created_at) VALUES (?, ?, 1, ?, ?, ?, ?)')
+    .run(session, session, 'exec_command', 'tool_output', '結果', 999);
+  const later = [{ turnId: 'b', closed: true, activity: false }, { turnId: 'c', closed: true, activity: false }];
+  const frozen = freezeCodexMemory(db, operation, {}, { stoppedAt: 200, laterTurns: later });
+  assert.deepEqual(frozen.bodies.map(row => row.text), ['進めて', '途中まで進めた']);
+  assert.equal(frozen.sourceTurnNumber, 1); assert.equal(frozen.details.length, 1);
+  // 後続turnが無い時と、止める前からあった発言は、今までどおり全部入れる。
+  assert.equal(freezeCodexMemory(db, operation, {}, { stoppedAt: 200 }).bodies.length, 4);
+  assert.equal(freezeCodexMemory(db, operation, {}, { stoppedAt: 305, laterTurns: later }).bodies.length, 3);
+  assert.equal(freezeCodexMemory(db, operation, {}, { stoppedAt: 200, laterTurns: [later[0]] }).bodies.length, 3);
+}));
+
+test('要約のbackendが使えない時、workerは固定の理由で止まり、後継を作らない', async () => withDb(async db => {
+  const backend = reason => Object.assign(new Error('Codex CLI summarizer failed: exit 1'), { source: 'codex-cli', reason });
+  const cases = [[backend('codex_cli_failed'), 'handoff_summarizer_backend_failed'], [backend('empty_output'), 'handoff_summarizer_backend_failed'],
+    [new Error('handoff_l1_unavailable'), 'handoff_summarizer_backend_failed'],
+    // 製品側の誤り（要約の呼び方の間違い）と、他の失敗は、今までどおり汎用の理由。
+    [backend('recursion_guard'), 'handoff_worker_failed'], [new Error('別の失敗'), 'handoff_worker_failed']];
+  for (const [index, [cause, expected]] of cases.entries()) {
+    const operation = request(db, `summarizer-${index}`, { now: 1 }).operation;
+    const counters = { created: 0, submitted: 0, notified: 0 };
+    const deps = workerDependencies(db, {}, async () => { counters.submitted++; }, counters);
+    deps.summaries = () => { throw cause; };
+    const result = await runAutoHandoffWorker(operation.handoff_id, { db, dependencies: deps });
+    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);
+  }
+}));

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

@@ -102,8 +102,13 @@ export function readCodexHandoffState(path, { threadId = null, turnId = null, de
   const nativeSessions = new Set();
   let inheritedThroughlineMemory = false;
   let completedTools = 0;
+  // turnId を指定した時だけ、その turn より後に始まった turn を並べる。closed は止まった（turn_aborted）か完了したか、
+  // activity はモデルの発言・道具の呼び出し・圧縮・完了のどれかがあったか。入力を受けただけで止まった turn は activity が false。
+  const laterTurns = [];
+  let sourceSeen = false, later = null;
   for (const row of rows) {
     const payload = row.payload;
+    if (later && (row.type === 'compacted' || row.type === 'token_usage_record')) later.activity = true;
     // forkの先頭は子自身のmetadata。後続にコピーされた親のmetadataは識別へ使わない。
     if (row.type === 'session_meta') { meta ??= payload; continue; }
     if (row.type === 'turn_context' && (!turnId || payload.turn_id === turnId)) context = payload;
@@ -114,6 +119,8 @@ export function readCodexHandoffState(path, { threadId = null, turnId = null, de
     if (row.type === 'event_msg' && payload?.type === 'task_started') {
       latestTurnId = payload.turn_id;
       turnOpen = true;
+      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) {
         turnStartAt = Date.parse(row.timestamp); pendingCalls.clear(); completedTools = 0;
@@ -126,6 +133,12 @@ export function readCodexHandoffState(path, { threadId = null, turnId = null, de
       stoppedAt = Date.parse(row.timestamp); stoppedReason = payload.reason;
     }
     if (row.type === 'event_msg' && ['turn_aborted', 'task_complete'].includes(payload?.type) && payload.turn_id === latestTurnId) turnOpen = false;
+    if (later && row.type === 'event_msg' && payload?.turn_id === later.turnId) {
+      if (payload.type === 'turn_aborted') later.closed = true;
+      if (payload.type === 'task_complete') { later.closed = true; later.activity = true; }
+    }
+    if (later && row.type === 'event_msg' && payload?.type === 'agent_message') later.activity = true;
+    if (later && row.type === 'response_item' && !(payload?.type === 'message' && payload.role !== 'assistant')) later.activity = true;
     if (row.type === 'event_msg' && payload?.type === 'task_complete' && payload.turn_id === (turnId ?? latestTurnId)) {
       completedAt = Date.parse(row.timestamp);
     }
@@ -197,6 +210,6 @@ 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,
+    pendingNativeSessionCount: nativeSessions.size, inheritedThroughlineMemory, laterTurns,
     compactedRows: rows.filter(r => r.type === 'compacted').length };
 }

package/src/l1-backend-recovery.mjs

@@ -0,0 +1,74 @@
+/**
+ * l1-backend-recovery.mjs — L1 要約の backend（Codex CLI）が失敗してから、復帰を確認できたかの記録 (ADR 0041)
+ *
+ * Codex Stop の要約は外部 CLI を呼ぶ。通信の断、利用上限、認証切れ、利用者の取り消しでも失敗する。
+ * 会話の取り込みは済んでいて、要約は次の Stop がやり直すので、1回ごとの失敗は修理の対象として数えない。
+ * 最初の失敗から期限（24時間）を過ぎても成功を確認できていない時だけ、runtime error として数える。
+ *
+ * 端末ごとに1つのファイル（~/.throughline/l1-backend-recovery.json）に、成功を確認できていない間の
+ * 最初と最後の失敗の時刻だけを持つ。会話の内容も失敗の文面も書かない（文面は hook-failures.log に残る）。
+ * 読み書きの失敗は stderr に出し、hook の結果を変えない。
+ */
+
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+export const L1_BACKEND_RECOVERY_SCHEMA = 'throughline.l1_backend_recovery.v1';
+export const L1_BACKEND_UNRECOVERED_MS = 24 * 60 * 60 * 1000;
+
+export function l1BackendRecoveryPath({ home = homedir() } = {}) {
+  return join(home, '.throughline', 'l1-backend-recovery.json');
+}
+
+function read(path) {
+  try {
+    const state = JSON.parse(readFileSync(path, 'utf8'));
+    if (state?.schema !== L1_BACKEND_RECOVERY_SCHEMA || !Number.isFinite(state.first_failure_at)) return null;
+    return state;
+  } catch (error) {
+    if (error.code !== 'ENOENT') process.stderr.write(`[l1-backend-recovery] ${error.message}\n`);
+    return null;
+  }
+}
+
+/**
+ * backend の失敗を1回記す。最初の失敗から期限を過ぎていれば unrecovered を返す。
+ * @returns {{ unrecovered: boolean, firstFailureAt: number|null }}
+ */
+export function noteL1BackendFailure({ home, now = Date.now() } = {}) {
+  const path = l1BackendRecoveryPath({ home });
+  try {
+    const previous = read(path);
+    const firstFailureAt = previous?.first_failure_at ?? now;
+    const unrecovered = now - firstFailureAt >= L1_BACKEND_UNRECOVERED_MS;
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify({ schema: L1_BACKEND_RECOVERY_SCHEMA, first_failure_at: firstFailureAt,
+      last_failure_at: now, reported: Boolean(previous?.reported) || unrecovered })}\n`, { mode: 0o600 });
+    renameSync(temporary, path);
+    return { unrecovered, firstFailureAt };
+  } catch (error) {
+    process.stderr.write(`[l1-backend-recovery] ${error.message}\n`);
+    return { unrecovered: false, firstFailureAt: null };
+  }
+}
+
+/**
+ * backend が要約を返した。失敗の記録があれば消す。期限を過ぎて runtime error に数えていた時は reported を返す。
+ * 記録が無い時（ふだん）は、ファイルの有無を1回見るだけで終わる。
+ * @returns {{ recovered: boolean, reported: boolean }}
+ */
+export function noteL1BackendSuccess({ home } = {}) {
+  const path = l1BackendRecoveryPath({ home });
+  if (!existsSync(path)) return { recovered: false, reported: false };
+  try {
+    const previous = read(path);
+    rmSync(path, { force: true });
+    return { recovered: true, reported: Boolean(previous?.reported) };
+  } catch (error) {
+    process.stderr.write(`[l1-backend-recovery] ${error.message}\n`);
+    return { recovered: false, reported: false };
+  }
+}

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

@@ -144,7 +144,7 @@ function makeBin(dir, name, body) {
   return command;
 }
 
-test('Codex StopでL1要約backendが失敗した時、取り込みは残り、別のcodeで1回数える', () => {
+test('Codex StopのL1要約backendの失敗は1回ごとには数えず、24時間復帰を確認できない時だけ数え、成功で解決にする', () => {
   const { root, env } = createEnabledEnvironment('throughline-runtime-hook-summarizer-');
   const threadId = '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9';
   const project = join(root, 'project');
@@ -168,20 +168,29 @@ test('Codex StopでL1要約backendが失敗した時、取り込みは残り、
   mkdirSync(binDir, { recursive: true });
   const codex = makeBin(binDir, 'codex', "process.stderr.write('ERROR: usage limit reached\\n');\nprocess.exit(42);\n");
 
-  const result = spawnSync(process.execPath, [BIN, 'codex-hook', 'stop'], {
-    env: { ...env, CODEX_HOME: codexHome, THROUGHLINE_CODEX_CLI_BIN: codex },
+  const stop = (bin) => spawnSync(process.execPath, [BIN, 'codex-hook', 'stop'], {
+    env: { ...env, CODEX_HOME: codexHome, THROUGHLINE_CODEX_CLI_BIN: bin },
     input: JSON.stringify({ session_id: threadId, transcript_path: rolloutPath, cwd: project }),
     encoding: 'utf8',
   });
+  const records = () => {
+    const storePath = defaultRuntimeErrorStorePath(env);
+    if (!existsSync(storePath)) return [];
+    return JSON.parse(readFileSync(storePath, 'utf8')).records
+      .map((record) => [record.error_code, record.component, record.severity, record.count, record.status, record.reason_code]);
+  };
+  const recoveryPath = join(root, '.throughline', 'l1-backend-recovery.json');
+  const result = stop(codex);
 
   // hook は明示して失敗する（終了 code と stderr は変えない）。
   assert.equal(result.status, 1, result.stderr);
   assert.match(result.stderr, /\[codex-hook\] Codex CLI summarizer failed: exit 42/);
 
-  const store = JSON.parse(readFileSync(defaultRuntimeErrorStorePath(env), 'utf8'));
-  assert.deepEqual(store.records.map((record) => [record.error_code, record.component, record.severity, record.count]), [
-    ['L1_SUMMARIZER_BACKEND_FAILED', 'codex_l1_summarizer', 'warn', 1],
-  ]);
+  // 1回の失敗は、修理の対象として数えない。通信の断・利用上限・取り消しでも起き、次の Stop がやり直す。
+  assert.deepEqual(records(), []);
+  const first = JSON.parse(readFileSync(recoveryPath, 'utf8'));
+  assert.equal(first.schema, 'throughline.l1_backend_recovery.v1'); assert.equal(first.reported, false);
+  assert.deepEqual(Object.keys(first).sort(), ['first_failure_at', 'last_failure_at', 'reported', 'schema']);
 
   // 取り込みは要約の前に commit 済み。
   const db = new DatabaseSync(join(root, '.throughline', 'throughline.db'));
@@ -198,6 +207,31 @@ test('Codex StopでL1要約backendが失敗した時、取り込みは残り、
   assert.equal(entry.code, 'L1_SUMMARIZER_BACKEND_FAILED');
   assert.equal(entry.reason, 'codex_cli_failed');
   assert.match(entry.stderr, /usage limit reached/);
+
+  // 続けて失敗しても、最初の失敗から24時間に届くまでは数えない。
+  assert.equal(stop(codex).status, 1);
+  assert.deepEqual(records(), []);
+  assert.equal(JSON.parse(readFileSync(recoveryPath, 'utf8')).first_failure_at, first.first_failure_at);
+
+  // 最初の失敗から24時間を過ぎても成功を確認できていない。warn で数える。
+  writeFileSync(recoveryPath, JSON.stringify({ ...first, first_failure_at: Date.now() - 25 * 3_600_000 }));
+  assert.equal(stop(codex).status, 1);
+  assert.deepEqual(records(), [['L1_SUMMARIZER_BACKEND_UNRECOVERED', 'codex_l1_summarizer', 'warn', 1, 'open', null]]);
+  assert.equal(JSON.parse(readFileSync(recoveryPath, 'utf8')).reported, true);
+  assert.equal(stop(codex).status, 1);
+  assert.deepEqual(records(), [['L1_SUMMARIZER_BACKEND_UNRECOVERED', 'codex_l1_summarizer', 'warn', 2, 'open', null]]);
+
+  // backend が要約を返した。失敗の記録を消し、数えていた記録を recovered で解決にする。
+  const working = makeBin(binDir, 'codex-ok', "process.stdout.write('要約\\n');\n");
+  const recovered = stop(working);
+  assert.equal(recovered.status, 0, recovered.stderr);
+  assert.equal(existsSync(recoveryPath), false);
+  assert.deepEqual(records(), [['L1_SUMMARIZER_BACKEND_UNRECOVERED', 'codex_l1_summarizer', 'warn', 2, 'resolved', 'recovered']]);
+
+  // 復帰した後の失敗は、また最初から数える（すぐには数えない）。
+  assert.equal(stop(codex).status, 1);
+  assert.deepEqual(records(), [['L1_SUMMARIZER_BACKEND_UNRECOVERED', 'codex_l1_summarizer', 'warn', 2, 'resolved', 'recovered']]);
+  assert.equal(JSON.parse(readFileSync(recoveryPath, 'utf8')).reported, false);
 });
 
 test('store failure preserves product failure and emits only fixed storage diagnostic', () => {

package/src/runtime-error-observer.mjs

@@ -1,7 +1,10 @@
-import { observeRuntimeError } from './runtime-error-store.mjs';
+import { observeRuntimeError, resolveRuntimeError, runtimeErrorFingerprint } from './runtime-error-store.mjs';
 
 try {
-  const result = observeRuntimeError({ code: process.argv[2] });
+  // 第2引数が recovered の時は、その code の記録を「復帰を確認した」として解決にする（ADR 0041）。
+  const result = process.argv[3] === 'recovered'
+    ? resolveRuntimeError(runtimeErrorFingerprint(process.argv[2]), { reasonCode: 'recovered' })
+    : observeRuntimeError({ code: process.argv[2] });
   process.exitCode = result.status === 'disabled' ? 3 : 0;
 } catch {
   process.exitCode = 1;

package/src/runtime-error-store.mjs

@@ -64,14 +64,30 @@ const DEFINITIONS = Object.freeze({
     template: 'Throughline Codex hook processing failed',
   }),
   // Codex Stop の取り込みは済み、L1 要約の backend（Codex CLI）だけが失敗した（ADR 0028）。
+  // 0.16.4 からは数えない（ADR 0041）。1回ごとの失敗は、通信の断・利用上限・取り消しでも起き、次の Stop がやり直す。
+  // 前の版が記録した store を読める様に、定義は残す。
   L1_SUMMARIZER_BACKEND_FAILED: Object.freeze({
     component: 'codex_l1_summarizer',
     // BugHub が受ける severity は fatal・high・warn・info だけ。他の値は report 全体が 422 になる。
     severity: 'warn',
     template: 'Throughline L1 summarizer backend (Codex CLI) failed',
   }),
+  // L1 要約の backend が失敗し、最初の失敗から24時間を過ぎても成功を確認できていない（ADR 0041）。
+  // 記憶は失われていない（取り込みは済み、recall は L2 を返す）。要約が成功した時に、recovered で解決にする。
+  L1_SUMMARIZER_BACKEND_UNRECOVERED: Object.freeze({
+    component: 'codex_l1_summarizer',
+    severity: 'warn',
+    template: 'Throughline L1 summarizer backend (Codex CLI) has not recovered for over 24 hours',
+  }),
 });
 
+/** 定型 code の fingerprint。記録は code ごとに1つ。 */
+export function runtimeErrorFingerprint(code) {
+  const definition = DEFINITIONS[code];
+  if (!definition) throw new TypeError('未登録の runtime error code です');
+  return createHash('sha256').update(['throughline', definition.component, code, definition.template].join('\0')).digest('hex');
+}
+
 export function defaultRuntimeErrorConfigPath(env = process.env) {
   if (isWindows(env)) {
     return join(windowsLocalAppData(env), 'throughline', 'runtime-errors.config.json');
@@ -143,9 +159,7 @@ export function observeRuntimeError(input, options = {}) {
   return withStoreLock(options, (privateDirectory) => {
     const now = normalizeTimestamp(input.now);
     const version = normalizeVersion(options.version ?? PACKAGE_VERSION);
-    const fingerprint = createHash('sha256')
-      .update(['throughline', definition.component, input.code, definition.template].join('\0'))
-      .digest('hex');
+    const fingerprint = runtimeErrorFingerprint(input.code);
     const store = readStore(options, { privateDirectory });
     const existing = store.records.find((record) => record.fingerprint === fingerprint);
     const sequence = nextSequence(store);
@@ -307,10 +321,15 @@ export function getRuntimeErrorDiagnostics(options = {}) {
   }
 }
 
+/** 復帰を確認できた記録を、recovered で解決にする。記録が無い時と、解決済みの時は何もしない。 */
+export function resolveRecoveredRuntimeErrorBestEffort(code, options = {}) {
+  return recordRuntimeErrorBestEffort(code, { ...options, action: 'recovered' });
+}
+
 export function recordRuntimeErrorBestEffort(code, options = {}) {
-  const { stderr = process.stderr, ...storeOptions } = options;
+  const { stderr = process.stderr, action = null, ...storeOptions } = options;
   try {
-    const child = childProcess.spawnSync(process.execPath, [fileURLToPath(new URL('./runtime-error-observer.mjs', import.meta.url)), code], {
+    const child = childProcess.spawnSync(process.execPath, [fileURLToPath(new URL('./runtime-error-observer.mjs', import.meta.url)), code, ...(action ? [action] : [])], {
       env: storeOptions.env ?? process.env,
       encoding: 'utf8',
       stdio: 'ignore',