throughline 0.16.24 → 0.16.26

package/CHANGELOG.md

@@ -10,6 +10,63 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.26] — 2026-10-12
+
+### 修正
+
+- **Grokが会話を自動圧縮した後、圧縮をまたいだターンが保存されず、その会話のStopが毎回失敗していた**（[ADR 0056](docs/adr/0056-grok-rewritten-chat-history-keeps-captured-turns-apart.md)）。Linuxの実機（BellTeamコンテナ、Grok 1.0.46）で2026-10-12に起きた。失敗の文面は`completed pair was not captured before receipt publication`。
+  - Grokは自動圧縮で`chat_history.jsonl`を書き直す。Throughlineはターンの番号を記録の中の位置で振っているので、書き直した後の位置が、保存済みの別のターンの番号と重なった。重なった群を「保存済み」として飛ばし、完了受領を書く所で失敗していた。
+  - 代表の断片の位置が重なる形では、失敗も出ずに、圧縮をまたいだターンが落ちていた（2026-09-30の別の会話）。
+  - 直した後は、Grokの記録では、同じ位置に同じ本文のassistant行がある時だけ保存済みとする。書き直しの後のターンは、世代を分けた番号（世代×1,000,000＋位置）で保存する。すでに番号が重なっている会話は、この版の最初のStopで、落ちていたターンが入る。
+- **Grokが自分で書いたuser行（`system_reminder`・`compaction_meta`）を、人の発言として保存していた**（同じADR）。依頼の直後に注意書きが来ると、そのターンのuserの本文が注意書きになっていた。ターンの途中に来ると、1つのターンが2つに割れていた。直した後は、ターンの始まりにも本文にもしない。Throughlineが引き継ぎで注入する行も、この印で書いている。
+- **Claude Codeで、ターンが終わった直後に待っていた入力が2通以上届くと、Stopが`Claude Stop transcript completion was not visible before deadline`で失敗していた**（[ADR 0055](docs/adr/0055-stop-flush-barrier-skips-queued-inputs.md)）。Linuxの実機（BellTeamコンテナ）で2026-10-12に起きた。
+  - 完了したターンを探す処理が、直後の入力を1通までしか遡らなかった（ADR 0026）。2通が続けて書かれると、完了したターンは2つ前の群になる。
+  - 保存の欠けは無かった。次のStopが、そのターンをまとめて取り込む。受領がそのぶん遅れ、失敗が1回数えられていた。
+  - 直した後は、assistantの本文が無い群（続けて届いた入力）を飛ばして、完了したターンを探す。採用の条件（未捕捉である事、次のターンが本文を書き始めていない事）は変えていない。
+
+### 対応の範囲
+
+| | macOS | Linux | Windows |
+|---|---|---|---|
+| Grok（記録の書き直し・合成行） | 直した。単体試験と、実機で本物のhookの命令（`process-turn`）へ合成した記録を通した。本物のGrokの自動圧縮をまたぐ場面は見ていない | 直した。起きた端末（コンテナ）。同じ確認と、コンテナの本物のDBのGrokの会話110件をメモリへ写した空実行（書き直しと判定したのは圧縮の跡がある2件だけ）。本物の自動圧縮をまたぐ場面は、直した版では見ていない | 直した。macOSと同じ確認。本物の自動圧縮をまたぐ場面は見ていない |
+| Claude Code（待っていた入力が2通以上） | 直した。単体試験と、実機で本物のhookの命令へ合成した記録を通した。本物のClaude Codeでこの形が起きた事は無い | 直した。起きた端末（コンテナ）。同じ確認。直した版で本物の形が起きた事は、まだ無い | 直した。macOSと同じ確認 |
+| Codex | 変更なし（Stopは別の入口で、rolloutから取り込む。rolloutは追記だけ） | 同じ | 同じ |
+| Cursor | 変更なし（Stopの待ちを使わない。記録を書き直すかは確かめていない。コンテナの取り込みの記録169会話に、群が減った跡は無い） | 同じ | 同じ |
+
+### 確かめていない事
+
+- 本物のGrokが自動圧縮をまたぐ場面での、この版の動き。狙って起こせるかを確かめていない。コンテナの、番号が重なっている会話の次のStopで分かる。
+- Grokの巻き戻しが`chat_history.jsonl`をどう書き直すか。実物を見ていない。
+- 圧縮をまたいだターンの、元の依頼の文が`chat_history.jsonl`に残っているか。保存されるuserの本文は、圧縮の後に残った印の無いuser行。
+- 本物のClaude Codeが、待っていた入力を2通続けて書く場面での、この版の動き。
+- Cursorが記録を書き直すか。
+
+## [0.16.25] — 2026-10-12
+
+### 修正
+
+- **macOSのCodex Desktopで、引き継ぎのたびに`handoff_hook_identity_invalid`の失敗が記録されていた**（[ADR 0054](docs/adr/0054-codex-compaction-of-thread-without-rollout-is-left-alone.md)）。引き継ぎそのものは成功していた。0.16.18で失敗の行へ残すようにした合図の形を、2026-10-11の2回（0.16.23）で読めた。
+  - 合図は、引き継ぎ元でも引き継ぎ先でもない会話から来ていた。記録の場所（`transcript_path`）がnullで、会話のIDとターンのIDは正しい形。Codex Desktopのログでは、Desktop自身が立てた、画面に出ない会話（MCPが起動し、ターンが始まって終わる。画面の側は「unknown conversation」として受ける）。旧タスクのターンが止まった直後と、後継の画面を開いた直後に1つずつ出来て、最初のターンで自動圧縮を始めていた。
+  - Throughlineは、これを失敗として記録し、その会話のターンを止めていた。
+  - 直した後は、`PreCompact(auto)`の合図に記録の場所が無い時、引き継ぎの対象にしない。失敗にせず、圧縮を止める指示も返さない。通した事を`~/.throughline/codex-auto-handoff/unrecorded-compactions.jsonl`へ1行残す（時刻・会話のID・ターンのID・モデル名）。
+  - 記録の場所が相対pathの時と、記録を持つ会話の扱いは変えていない。
+  - 0.16.14（[ADR 0047](docs/adr/0047-codex-internal-compaction-is-stopped-without-error.md)）が想定した形（ターンのIDが`auto-compact-N`）は、実機ではまだ来ていない。
+
+### 対応の範囲
+
+| | macOS | Linux | Windows |
+|---|---|---|---|
+| Codex | 直した。起きた端末。単体試験と、実機で本物のhookの命令へ起きた形の合図を渡した（入っていた0.16.24は失敗を記録して`continue: false`。この版は何も出力せず、失敗の記録は増えない）。本物のCodex Desktopの引き継ぎでは、まだ通していない | 直した。同じ確認。実機でこの失敗が起きた事は無い | 直した。同じ確認。実機でこの失敗が起きた事は無い |
+| Claude Code | 変更なし（この失敗はCodexの`PreCompact`だけが出す。Claude Codeの会話は必ず記録を持つ） | 同じ | 同じ |
+| Grok | 変更なし（自動継続が無い） | 同じ | 同じ |
+| Cursor | 変更なし（自動継続が無い） | 同じ | 同じ |
+
+### 確かめていない事
+
+- 本物のCodex Desktopが、記録なしの会話から合図を出す場面での、この版の動き。狙って起こせない。次のmacOSの引き継ぎで、失敗ログが増えず、`unrecorded-compactions.jsonl`に行が出る事で確かめる。
+- Codex Desktopが、その会話を何に使っているか。Throughlineが止めていた間に、Desktopの側で欠けていた物があったかも分かっていない。
+- 2026-10-10の5回（0.16.12と0.16.16）は、失敗の行に形が残っていない。同じ検査・同じ場面だが、同じ形だったとは確かめられない。
+
 ## [0.16.24] — 2026-10-11
 
 ### 修正
@@ -2435,7 +2492,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.24...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.26...HEAD
+[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
 [0.16.24]: https://github.com/kitepon/Throughline/compare/v0.16.23...v0.16.24
 [0.16.23]: https://github.com/kitepon/Throughline/compare/v0.16.22...v0.16.23
 [0.16.22]: https://github.com/kitepon/Throughline/compare/v0.16.21...v0.16.22

package/docs/adr/0021-grok-host-capture.md

@@ -65,3 +65,8 @@ Grok 1.0.4 バイナリの hook 出力型は `GateHookJson`（PreToolUse deny/up
 2026-08-17 実機受入: `grok:01a00ff1-3f97-70e2-ba76-5acd90561a84` の `/tl` が
 `c01a2689-5b4f-4977-97ce-f73fcf317f94` を Dotagents 棚に立て、初手末尾は待機、
 後継は待って止まった。v0.10.0 で公開。
+
+## 追記（2026-10-12、ADR 0056）
+
+Grok は自動圧縮で `chat_history.jsonl` を書き直す。位置だけで保存済みを決めると、圧縮をまたいだターンが落ちる。
+Grok が自分で書く user 行（`compaction_meta`・`system_reminder`）の扱いと合わせて、ADR 0056 で直した。

package/docs/adr/0026-stop-flush-barrier-next-user.md

@@ -58,3 +58,8 @@ latest user group は次の turn になっていて、assistant 本文はまだ
 
 L1 の要約が走る Stop では、L3 の抽出が transcript を読み直すまでに数秒かかる。その間に次の turn が本文を
 書くと、L3 が次の turn の行から取られる可能性がある。コードを読んだ見立てで、再現は確かめていない。
+
+## 追記（2026-10-12、ADR 0055）
+
+Decision 5（2つ以上前の group は見ない）は、待っていた入力が2通以上続けて届く形を落としていた。ADR 0055 で、
+assistant 断片の無い group を飛ばして探すように変えた。assistant 断片を持つ group を2つ以上遡らない事は変えていない。

package/docs/adr/0047-codex-internal-compaction-is-stopped-without-error.md

@@ -53,3 +53,10 @@ Codex は、利用者のターンとは別に、自分で作る内部の文脈
 - 0.16.18 で、この失敗の行へ合図の形（`identity`。ID・種類・絶対 path かどうか）を残す。次に起きた行を読んで、
   扱いを決める。この ADR の Decision 1〜4 は、それまで変えない。
 
+## 追記（2026-10-12）
+
+0.16.23 の macOS の実機で、形の付いた失敗が2回出た（2026-10-11 16:22:00 と 16:23:01）。不正だったのは `transcript_path`
+（null）で、ターンの ID は UUID だった。合図の会話は、引き継ぎ元でも引き継ぎ先でもない、Codex Desktop が自分で立てた
+記録なしの会話だった。扱いは [ADR 0054](0054-codex-compaction-of-thread-without-rollout-is-left-alone.md) で決めた。
+この ADR の Decision 1〜4（記録を持つ会話の、ターンの ID が `auto-compact-N` の合図）は変えていない。実機でその形が
+来た事は、まだ無い（macOS の実機に `internal-compactions.jsonl` は出来ていない）。

package/docs/adr/0053-claude-successor-finds-predecessor-by-handoff-id.md

@@ -47,3 +47,7 @@ Claude Code の自動継続（ADR 0033）は、`PreCompact(auto)` で圧縮を
 - 旧い会話は、記録がある間、文を受ければ文で答える。道具は断る（変えていない）。旧い会話あての連絡を今の続きへ渡すのは、
   連絡を運ぶ側の仕事で、5 の口で今の続きを引ける。
 - 記憶が入らなかった後継へ、後から記憶を入れる処理は無い。`throughline recall --session <旧い会話の id>` で引ける。
+- ほかの製品が、次の2つの形に頼っている（通話MCP `grokbot-bridge` 0.3.6 の `UserPromptSubmit` の hook。後継へ、前任が持っていた
+  通話の引き取りを知らせる）。変える時は、先にその製品の担当へ知らせる。
+  - 後継の最初の指示の頭: `Throughline自動継続 ` に続けて、36字の引き継ぎ ID。
+  - `auto-handoff status --host claude --operation <引き継ぎID> --json` の `handoffs[0].source_session_id`。

package/docs/adr/0054-codex-compaction-of-thread-without-rollout-is-left-alone.md

@@ -0,0 +1,62 @@
+# ADR 0054: 記録（rollout）を持たない Codex の会話の自動圧縮には、手を出さない
+
+- Status: Accepted
+- Date: 2026-10-12
+
+## Context
+
+Codex の自動継続（ADR 0034）は、`PreCompact(auto)` の hook で圧縮を止めて、新しいタスクへ引き継ぐ。hook は、合図の
+会話の ID・記録の場所（`transcript_path`）・ターンの ID を検査し、合わなければ `handoff_hook_identity_invalid` で失敗にして、
+圧縮を止める指示（`continue: false`）を返していた。
+
+macOS の実機で、この失敗が7回出た（2026-10-10 に5回、10-11 に2回）。どれも Codex の引き継ぎの直後で、引き継ぎそのものは
+成功している。0.16.14（ADR 0047）は「ターンの ID が `auto-compact-N`」の形を想定して直したが、外れていた。0.16.18 で
+失敗の行へ合図の形を残し、10-11 の2回で形が分かった。
+
+| | 1回目 | 2回目 |
+|---|---|---|
+| 失敗の時刻（JST） | 16:22:00.396 | 16:23:01.422 |
+| 会話の ID | `01a129d6-fe64…`（作られたのは 16:21:58.116） | `01a129d7-e996…`（16:22:58.326） |
+| ターンの ID | UUID（16:21:58.225） | UUID（16:22:58.611） |
+| `transcript_path` | null | null |
+| `cwd`・モデル・`trigger` | 絶対 path・`gpt-6.1-sol`・`auto` | 同じ |
+| agent の ID・種類 | 無し | 無し |
+
+引き継ぎは 16:21:57.996 に予約（旧タスク `01a124ce-f984…`）、後継 `01a129d7-de33…` が 16:22:55.411 に出来て、
+16:23:06 に済んだ。失敗した合図の会話は、旧タスクでも後継でもない。
+
+Codex Desktop のログ（アプリの行だけを読んだ）では、この2つの会話は Desktop 自身の App Server の中にあり、MCP が
+起動し、`turn/started` と `turn/completed` が出ている。画面の側は「unknown conversation」として受けている。1つ目は
+旧タスクのターンが止まって通知を出した直後、2つ目は後継の画面を開いた直後に出来ている。Throughline の worker は、
+後継のほかに会話を作らない（`thread/start` は1か所）。要約の `codex exec --ephemeral` は別のモデル（既定
+`gpt-5.6-luna`）で動く。
+
+つまり、Codex Desktop が自分で立てた、画面に出ない・記録を持たない会話が、最初のターンで自動圧縮を始め、その合図が
+Throughline の hook へ来ていた。Throughline は失敗として記録し、その会話のターンを止めていた（2回とも、hook の失敗の
+0.3〜0.5 秒後に `turn/completed`）。Desktop がその会話を何に使っているかは、分かっていない。
+
+Throughline は、会話の記録（rollout）から発言を取り込む。記録を持たない会話は取り込んでいないので、引き継ぐ記憶が無く、
+後継も作れない。
+
+## Decision
+
+1. `PreCompact(auto)` の合図の `transcript_path` が null か、項目が無い時は、引き継ぎの対象にしない。失敗にせず、
+   `continue: false` も返さない（hook は何も出力せず、終了 code 0）。圧縮は Codex がそのまま行う。
+2. 通した事を `~/.throughline/codex-auto-handoff/unrecorded-compactions.jsonl` に1行残す（時刻・会話の ID・ターンの ID・
+   モデル名。記号の混じる値は長さだけ）。会話の本文と path は書かない。
+3. `transcript_path` が文字列で、絶対 path でない時は、今までどおり失敗にする（記録を持つはずの会話で、場所だけが不正）。
+4. 記録を持つ会話の扱い（ADR 0034・0047）は変えない。
+
+## Consequences
+
+- macOS の Codex Desktop の引き継ぎのたびに出ていた失敗の記録が、出なくなる見込み。次の実機の引き継ぎで、失敗ログが
+  増えず、`unrecorded-compactions.jsonl` に行が出る事で確かめる。
+- Desktop が立てる画面に出ない会話は、Throughline に止められなくなり、Codex の圧縮が通る。自動継続を入れる前
+  （0.11.0 より前）と同じ動きに戻る。
+- 「host の自動圧縮を通さない」という決め（ADR 0034）は、Throughline が記録している会話についての物として読む。
+  記録を持たない会話は、その外に置く。
+- 利用者が自分で起こす記録なしの会話（`codex exec --ephemeral` など）も、同じ扱いになる。今までは失敗として止めていた。
+  どちらでも引き継ぎは出来ない。
+- Codex が、記録を持つ会話の最初のターンで、記録を作る前に `transcript_path` を null で渡す事があれば、その圧縮も通る。
+  実機では見ていない。起きた時は `unrecorded-compactions.jsonl` の会話の ID が、後で記録を持つ会話と一致する事で気づける。
+- 10-10 の5回は、失敗の行に形が残っていない。同じ検査・同じ場面（引き継ぎの直後）だが、同じ形だったとは確かめられない。

package/docs/adr/0055-stop-flush-barrier-skips-queued-inputs.md

@@ -0,0 +1,58 @@
+# ADR 0055: Stop の直後に待っていた入力が2通以上届いた時、flush barrier は本文の無い group を飛ばして完了した turn を探す
+
+- Status: Accepted
+- Date: 2026-10-12
+
+## Context
+
+ADR 0026 は、Stop の直後に次の user 行（queue から届いた入力）が書かれた時、1つ前の group を完了した turn として
+採用する。「2つ以上前の group は見ない」と決めていた（Decision 5）。
+
+2026-10-12 に BellTeam コンテナ（Linux、0.16.5）で、Claude Code の会話の Stop が
+`Claude Stop transcript completion was not visible before deadline` で1回失敗した。transcript の並びは次のとおり
+（本文は読んでいない。行の種類・時刻・長さだけ）。
+
+```text
+10:22:59.869  queue-operation enqueue
+10:23:30.015  queue-operation enqueue
+10:23:32.062  assistant の最終行（end_turn）
+10:23:32.147  stop_hook_summary
+10:23:32.172  queue-operation dequeue（2件、同じ時刻）
+10:23:32.216  user 行（待っていた入力の1通目）
+10:23:32.217  user 行（待っていた入力の2通目）
+10:23:34.215  HOOK_PROCESS_TURN_FAILED（Stop から 2.0 秒後）
+10:23:39.699  次の turn の assistant 行
+```
+
+turn の間に入力が2通たまり、turn が終わった時に2通が続けて user 行になった。latest group は2通目、1つ前の group は
+1通目で、どちらにも assistant 本文が無い。完了した turn は2つ前の group にあるので、marker は一致しない。
+
+失敗した turn の L2 と完了受領は、19 秒後の次の Stop（10:23:53.167）の backfill が書いた（`groups` 88 → 90、
+`inserted_turns` 2）。保存の欠けは無い。害は、受領が次の Stop まで遅れる事と、失敗が1回数えられる事。
+
+最新の 0.16.25 でも同じ（合成した transcript で、待っていた入力が1通なら採用、2通と3通は失敗）。
+
+## Decision
+
+1. 1つ前の group を探す時、assistant 断片が1つも無い group（続けて届いた入力）は飛ばす。assistant 断片を持つ
+   一番近い group を「1つ前」として扱う。
+2. 採用の条件は ADR 0026 のまま。latest group に assistant 断片が無い、その group の非 junk assistant 本文が marker と
+   一致する、その turn が bodies に未捕捉、の全部を満たす時だけ採用する。
+3. assistant 断片を持つ group は飛ばさない。その group より前は見ない。ADR 0026 の Decision 5 は
+   「assistant 断片を持つ group を、2つ以上は遡らない」と読み替える。
+4. 根拠は ADR 0026 と同じで、transcript が追記だけである事。後ろに user 行が見えている group は、行が出そろっている。
+
+## Consequences
+
+- 待っていた入力が何通あっても、完了した turn の L2・完了受領・L3 が同じ Stop で書かれる。
+- 途中で止められて本文を1つも書かなかった turn（user 行だけの group）も、同じ扱いで飛ばす。その手前の turn が
+  今回の marker と同文で、まだ捕捉されていない時だけ採用される。捕捉済みなら、今までどおり待って deadline で失敗する。
+- この待ちを使うのは Claude Code の Stop だけ。Grok と Cursor は使わない（`waitsForStopTranscriptFlush: false`）。
+  Codex の Stop は別の入口（rollout からの取り込み）で処理する。
+
+## 確かめた事・確かめていない事
+
+- 確かめた: 単体試験（2通・3通・捕捉済み・次の turn が本文を書き始めた後・本文を持つ group が無い）。
+  本物の hook の命令（`process-turn`）へ、合成した transcript を通した（切り離した HOME）。
+- 確かめていない: 本物の Claude Code が、待っていた入力を2通続けて書く場面での、この版の動き。狙って起こすには、
+  動いている turn の間に入力を2通ためる必要がある。次に起きた時は、失敗が記録されない事で分かる。

package/docs/adr/0056-grok-rewritten-chat-history-keeps-captured-turns-apart.md

@@ -0,0 +1,79 @@
+# ADR 0056: Grok が書き直した chat_history は、保存済みのターンと本文で見分け、世代ごとに番号を分ける
+
+- Status: Accepted
+- Date: 2026-10-12
+
+## Context
+
+Throughline は、会話の記録（transcript）の中の位置を `turn_number` にして、発言を bodies へ保存する
+（`backfillBodies`）。記録を読むたびに全部の群を見て、群の断片の位置が bodies にあれば「保存済み」として飛ばす。
+Claude Code と Codex の記録は追記だけなので、位置は変わらない。
+
+Grok は、文脈がいっぱいになると会話を自動圧縮し、`chat_history.jsonl` を書き直す。書き直した後のファイルは、
+要約の行（`synthetic_reason: "compaction_meta"`）、印の無い user 行1つ、続きの指示（`compaction_meta`）、
+注意書き（`system_reminder`）、圧縮をまたいだターンの assistant の行、の並びになる。会話の置き場には
+`compaction/segment_NNN.md` と `compaction_checkpoints/` が出来る。位置は 0 から振り直しになる。
+
+2026-10-12 に BellTeam コンテナ（Linux、0.16.5、Grok 1.0.46）で、Stop が
+`completed pair was not captured before receipt publication` で2回失敗した（Grok は Stop の hook を2本起こす）。
+
+- 会話は毎朝の予定で動く Grok の席。bodies には 6 ターン（位置 8・13・19・23・30・36）が保存済みだった。
+- 08:17:41 に Grok が自動圧縮した（`compaction/` の時刻）。ファイルは 105 行、群は 6 → 1 になった。
+- 08:24:04 の Stop で、その1群の断片は位置 5〜9。位置 8 が保存済みの番号と重なり、群ごと「保存済み」として飛ばした。
+  代表の断片は位置 9 で、bodies に無い。完了受領を書く所で、対の行が見つからず失敗した。
+- 圧縮をまたいだターンの依頼と回答は、Throughline の記憶に入らなかった。この会話の後の Stop も、同じ群で毎回失敗する。
+
+同じコンテナの別の Grok の会話（2026-09-30、圧縮3回）では、代表の位置が保存済みの番号と重なっていた。この形は
+失敗が出ず、古いターンの受領が出し直されるだけで、圧縮をまたいだターンは黙って落ちていた。その後のターンは、
+古い番号の間に入って保存されていた（位置 14 の後に 12）。
+
+コンテナの Grok の記録 101 件のうち、圧縮の跡があるのはこの2件。最新の 0.16.25 でも同じ（合成した記録で再現）。
+
+もう1つ、Grok が自分で書く user 行の扱いがあった。`system_reminder` の行は、Throughline が user の発言として
+読んでいた。記録の中の 238 行の前後を種類だけで数えると、依頼（`prompt_index` を持つ行）の直後が 23、道具の結果の
+後で assistant の行が続く（ターンの途中）のが 37、依頼の前が 165、残りの 13 は圧縮の直後（4）と、後ろに何も無い行（9）
+だった。依頼の直後に来ると、そのターンの user の本文が注意書きになる。ターンの途中に来ると、1つのターンが2つの群に
+割れる。終わったターンの後に注意書きだけが来て、依頼なしで次のターンが始まる形は、1つも無かった。
+
+## Decision
+
+1. **Grok が自分で書いた user 行は、ターンの始まりにも本文にもしない。** 対象は `synthetic_reason` が
+   `compaction_meta` と `system_reminder` の行（`message` を持たない Grok の形の行だけ）。位置は進める。
+   Claude Code の圧縮の要約行（ADR 0032）と同じ扱い。`task_completed` は host が自分から始めるターンなので、
+   今までどおりターンの始まりにする。知らない印の行も今までどおり。
+2. **書き直される記録では、保存済みかを本文でも確かめる。** host の adapter に `rewritesTranscript` を足し、
+   Grok だけ true にする。true の host では、群の断片と同じ位置に、同じ本文の assistant 行がある時だけ「保存済み」とする。
+3. **書き直しの後のターンは、世代を分けた番号で保存する。** 世代 g のターンは
+   `g × 1,000,000 + 記録の中の位置`。世代 0 は今までの番号と同じ。今の世代は、保存済みの番号の最大から読む
+   （`floor(turn_number / 1,000,000)`）。別の表や置き場は持たない。
+4. **書き直されたかは、今の世代の保存済みの行で決める。** 今の世代で保存した assistant 行のうち、記録の同じ位置に
+   同じ本文が無い行が1つでもあれば、書き直されたとして次の世代へ進む。保存していない群は、新しい世代の番号で入れる。
+   古い世代の行と本文が合う群（巻き戻しで残った前半など）は、保存済みとして飛ばす。
+5. **完了受領は、行が実際にある番号で出す。** 保存済みの群は、合った行の番号を返す。合成行の扱いが変わる前に
+   2つの群として保存されていたターンは、後ろの行の番号で出す。
+6. Claude Code・Codex・Cursor は今までどおり、位置だけで決める。
+
+## Consequences
+
+- Grok の自動圧縮をまたいだターンが保存され、受領も出る。その会話の後の Stop も失敗しない。
+- すでに番号が重なっている会話（上の2件）は、この版の最初の Stop で、落ちていたターンが世代 1 の番号で入る。
+  圧縮の後に古い番号の間へ入っていたターンは、そのままの番号で残る（並びは直さない）。
+- 圧縮をまたいだターンの user の本文は、圧縮の後に残った印の無い user 行になる（始まり方は `unknown`）。元の依頼の
+  文が `chat_history.jsonl` に残っているかは、確かめていない。
+- 巻き戻しで消されたターンは、bodies に残る。起きた会話として記憶に残す。
+- `turn_number` は 1,000,000 以上になる事がある。番号を記録の位置として使う処理は、Grok には無い（L3 の抽出と
+  flush barrier は Claude Code の記録の形だけを読む）。1つの記録に 1,000,000 行以上の本文がある事は想定しない。
+- 保存済みかの判定が assistant の本文の一致に頼る。Grok の assistant の本文の取り出し方を変える時は、保存済みの
+  行と合わなくなって、全部の群が次の世代へ重ねて入る。変える時は、この判定も一緒に見直す。
+- 同じ位置に同じ本文の行が、書き直しの前後でたまたま並ぶと、後の方を保存済みと見て落とす。位置と本文の両方が
+  合う必要があるので、起きにくい。
+
+## 確かめた事・確かめていない事
+
+- 確かめた: 単体試験（圧縮の2つの形、2回目の圧縮、巻き戻し、合成行を user として保存していた頃の行との両立、
+  追記だけの host は不変）。本物の hook の命令（`process-turn`）へ、合成した記録を通した（切り離した HOME）。
+  コンテナの本物の DB の Grok の会話 110 件を、メモリへ写して空実行した（書き直しと判定したのは圧縮の跡がある2件だけ、
+  2回目の実行で増えない）。
+- 確かめていない: 本物の Grok が圧縮をまたぐ場面での、この版の動き（狙って起こせるかを確かめていない）。
+  Grok の巻き戻しが `chat_history.jsonl` をどう書き直すか（実物を見ていない。試験の形は想定）。
+  Cursor が記録を書き直すか（コンテナの取り込みの記録 169 会話に、群が減った跡は無い）。

package/package.json

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

package/src/claude-auto-handoff.mjs

@@ -689,7 +689,10 @@ export function completeClaudeTurnWithoutHandoff({ sessionId, dir = claudeAutoHa
   return true;
 }
 
-/** 後継へ送る継続の指示。引き継ぎIDを含め、後継の最初の指示がこの配送のものかを照合できるようにする。 */
+/**
+ * 後継へ送る継続の指示。引き継ぎIDを含め、後継の最初の指示がこの配送のものかを照合できるようにする。
+ * 文の頭の形（`Throughline自動継続 ` + 36字の引き継ぎID）は、ほかの製品の hook も読んでいる（ADR 0053）。変える時は先に知らせる。
+ */
 export function claudeContinuationInput(record) {
   // この文は後継の最初の指示（利用者の発言）として届く。止めた道具をやり直さずに「済んだ」と書いて
   // 先へ進む後継が出たので（Haiku 4.5、macOS で実測）、実行されていない道具から始めることを明記する。

package/src/codex-auto-handoff.mjs

@@ -132,6 +132,12 @@ function recordInternalCompactionStop(entry) {
   appendFileSync(join(stateRoot(), 'internal-compactions.jsonl'), JSON.stringify(entry) + '\n', { mode: 0o600 });
 }
 
+/** 記録（rollout）を持たない会話の自動圧縮を通した記録。引き継ぎの行は増えないので、起きた事をここに残す。会話の本文は書かない。 */
+function recordUnrecordedCompactionPass(entry) {
+  mkdirSync(stateRoot(), { recursive: true, mode: 0o700 });
+  appendFileSync(join(stateRoot(), 'unrecorded-compactions.jsonl'), JSON.stringify(entry) + '\n', { mode: 0o600 });
+}
+
 /** 引き継ぎ済みの旧タスクを止めた記録。引き継ぎの行は増えないので、起きた事をここに残す。会話の本文は書かない。 */
 function recordAutoHandoffRedirect(entry) {
   mkdirSync(stateRoot(), { recursive: true, mode: 0o700 });
@@ -186,10 +192,18 @@ function settleUndeliveredAutoHandoff(db, threadId, { rolloutPath, processes, re
 export async function requestCodexAutoHandoff({ payload, db = null,
   config = readAutoHandoffConfig(), launchWorker = launchAutoHandoffWorker,
   findThread = findCodexThreadCandidate, openThread = openSuccessor, recordRedirect = recordAutoHandoffRedirect,
-  recordInternalCompaction = recordInternalCompactionStop,
+  recordInternalCompaction = recordInternalCompactionStop, recordUnrecordedCompaction = recordUnrecordedCompactionPass,
   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;
+  // 記録（rollout）を持たない会話からの合図。Codex Desktop は、ターンの終わりや会話を開いた時に、画面に出ない会話を
+  // 自分で立てる（2026-10-11、macOS。`transcript_path` が null、会話の ID は引き継ぎ元でも引き継ぎ先でもない）。
+  // Throughline はその会話を記録していないので、引き継ぐ記憶が無く、後継も作れない。失敗にせず、圧縮にも手を出さない (ADR 0054)。
+  if (payload.transcript_path === null || payload.transcript_path === undefined) {
+    recordUnrecordedCompaction({ at: new Date(now).toISOString(), thread_id: identityText(threadId), turn_id: identityText(turnId),
+      model: identityText(payload.model) });
+    return { status: 'skipped', unrecordedThread: true };
+  }
   const located = CODEX_NATIVE_ID_PATTERN.test(threadId ?? '') &&
     typeof payload.transcript_path === 'string' && isAbsolute(payload.transcript_path) && isAbsolute(payload.cwd ?? '');
   // Codex が自分で作った内部の文脈（ターンの ID が `auto-compact-N`）からの圧縮。利用者のターンではないので、

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

@@ -339,6 +339,34 @@ test('タスクの今の続きを引く。先までたどり、消えた後継
   void Z;
 }));
 
+test('記録（rollout）を持たない会話からの圧縮の合図は、失敗にせず、圧縮にも手を出さない。引き継ぎは作らない', async () => withDb(async (db, home) => {
+  // 2026-10-11 16:22 JST、macOS の Codex Desktop。会話の ID は引き継ぎ元でも引き継ぎ先でもなく、`transcript_path` が null だった
+  const payload = { trigger: 'auto', cwd: home, session_id: '01a129d6-fe64-7010-9c79-19fe3b82c64d', turn_id: '01a129d6-fed1-7662-8286-280519f8d9bf',
+    transcript_path: null, model: 'gpt-6.1-sol' };
+  const config = { enabled: true, projects: [home], openHost: 'desktop' };
+  let launched = 0; const passed = [], stopped = [];
+  const args = { db, config, payload, launchWorker: async () => { launched++; }, recordUnrecordedCompaction: entry => passed.push(entry),
+    recordInternalCompaction: entry => stopped.push(entry), now: Date.parse('2026-10-11T07:22:00.396Z') };
+  const result = await requestCodexAutoHandoff(args);
+  assert.deepEqual(result, { status: 'skipped', unrecordedThread: true }, '圧縮を止める指示（continue: false）を返さない');
+  assert.equal(launched, 0);
+  assert.equal(db.prepare('SELECT COUNT(*) n FROM codex_handoffs').get().n, 0, '引き継ぎの行は作らない');
+  assert.deepEqual(passed, [{ at: '2026-10-11T07:22:00.396Z', thread_id: payload.session_id, turn_id: payload.turn_id, model: 'gpt-6.1-sol' }]);
+  assert.deepEqual(stopped, []);
+
+  // 項目そのものが無い時と、ターンの ID が内部の形の時も同じ。記号の混じる値は、記録へ中身を残さない
+  await requestCodexAutoHandoff({ ...args, payload: { trigger: 'auto', cwd: home, session_id: payload.session_id, turn_id: 'auto-compact-1', model: 'a model/with spaces' } });
+  assert.deepEqual(passed[1], { at: '2026-10-11T07:22:00.396Z', thread_id: payload.session_id, turn_id: 'auto-compact-1', model: 'text(19)' });
+  assert.deepEqual(stopped, []);
+
+  // 記録の場所が相対の時は、今までどおり失敗（記録を持つはずの会話で、場所だけが不正）
+  await assert.rejects(requestCodexAutoHandoff({ ...args, payload: { ...payload, transcript_path: 'relative/rollout.jsonl' } }), /handoff_hook_identity_invalid/);
+  // 無効な project と手動の圧縮は、記録も残さない
+  assert.equal((await requestCodexAutoHandoff({ ...args, config: { ...config, projects: ['/other'] } })).status, 'skipped');
+  assert.equal((await requestCodexAutoHandoff({ ...args, payload: { ...payload, trigger: 'manual' } })).status, 'skipped');
+  assert.equal(passed.length, 2);
+}));
+
 test('Codexの内部の文脈（auto-compact-N）からの圧縮は、例外にせず止めて記録する。引き継ぎは作らない', async () => withDb(async (db, home) => {
   const thread = '11111111-1111-1111-1111-111111111111';
   const file = join(home, 'rollout.jsonl'); writeFileSync(file, '');
@@ -360,16 +388,16 @@ test('Codexの内部の文脈（auto-compact-N）からの圧縮は、例外に
 
   // 形の決まっていない ID と、場所の分からない呼び出しは、今までどおり失敗として扱う
   for (const broken of [{ turn_id: 'something-else' }, { turn_id: undefined }, { turn_id: 'auto-compact-' }, { session_id: 'not-a-uuid' },
-    { transcript_path: null }, { transcript_path: 'relative/rollout.jsonl' }]) {
+    { transcript_path: 'relative/rollout.jsonl' }]) {
     await assert.rejects(requestCodexAutoHandoff({ ...args, payload: { ...payload, ...broken } }), /handoff_hook_identity_invalid/);
   }
   assert.equal(recorded.length, 1);
 
   // 失敗には、どの値が不正だったかの形を付ける。path と記号の混じる値は、中身を残さない
-  const shaped = await requestCodexAutoHandoff({ ...args, payload: { ...payload, turn_id: 'something else', transcript_path: null,
+  const shaped = await requestCodexAutoHandoff({ ...args, payload: { ...payload, turn_id: 'something else', transcript_path: 'relative/rollout.jsonl',
     agent_type: 'reviewer', model: 'gpt-5.5' } }).catch(error => error);
   assert.equal(shaped.code, 'handoff_hook_identity_invalid');
-  assert.deepEqual(shaped.hookIdentity, { session_id: thread, turn_id: 'text(14)', transcript_path: 'null', cwd: 'absolute',
+  assert.deepEqual(shaped.hookIdentity, { session_id: thread, turn_id: 'text(14)', transcript_path: 'relative(22)', cwd: 'absolute',
     agent_id: 'undefined', agent_type: 'reviewer', model: 'gpt-5.5', trigger: 'auto' });
   assert.deepEqual(hookIdentityShape({ session_id: thread, turn_id: 'auto-compact-', transcript_path: 'relative/rollout.jsonl', cwd: 7 }),
     { session_id: thread, turn_id: 'auto-compact-', transcript_path: 'relative(22)', cwd: 'number',

package/src/hosts/claude.mjs

@@ -77,6 +77,8 @@ export const claudeHostAdapter = Object.freeze({
   // Claude Stop payload の last_assistant_message を transcript 可視化の
   // barrier に使う (ADR 0012)。
   waitsForStopTranscriptFlush: true,
+  // Claude Code の transcript は追記だけ。圧縮は要約行を足す (ADR 0032)。
+  rewritesTranscript: false,
   // 完了受領はセッションを起動した project に書く。hook payload の cwd は Bash の cd に
   // 追従するため、作業中に下位ディレクトリへ移ると起動 project の feed から漏れる。
   // Claude Code は hook の環境変数 CLAUDE_PROJECT_DIR に起動 project を渡す。

package/src/hosts/codex.mjs

@@ -17,6 +17,7 @@ export const codexHostAdapter = Object.freeze({
   completionProjectPath: ({ cwd }) => cwd,
   // 既存挙動: Claude Stop hook の flush barrier は grok 以外 (codex: 含む) に適用される。
   waitsForStopTranscriptFlush: true,
+  rewritesTranscript: false,
   deliverHandoffInjection({ text, stdout = process.stdout }) {
     stdout.write(text + '\n');
     return { delivered: true };

package/src/hosts/cursor.mjs

@@ -116,6 +116,8 @@ export const cursorHostAdapter = Object.freeze({
   // transcript path も cwd から導くため、hook の cwd がそのまま起動 project である。
   completionProjectPath: ({ cwd }) => cwd,
   waitsForStopTranscriptFlush: false,
+  // Cursor が transcript を書き直すかは確かめていない。書き直した跡を見ていないので、今までの扱いのまま (ADR 0056)。
+  rewritesTranscript: false,
   consumesHandoffAtSessionStart: true,
   deliverHandoffInjection({ text, stdout = process.stdout }) {
     stdout.write(`${JSON.stringify({ additional_context: text })}\n`);

package/src/hosts/grok.mjs

@@ -77,6 +77,8 @@ export const grokHostAdapter = Object.freeze({
   // Claude Stop transcript flush barrier は Claude transcript の完了行を待つ機構。
   // Grok の chat_history には適用しない (既存挙動)。
   waitsForStopTranscriptFlush: false,
+  // Grok は自動圧縮と巻き戻しで chat_history.jsonl を書き直す。位置だけでは保存済みのターンを見分けられない (ADR 0056)。
+  rewritesTranscript: true,
   // Grok は UserPromptSubmit stdout をモデルへ渡さないため chat_history に直接注入する。
   deliverHandoffInjection({ payload, text }) {
     const injected = injectGrokHandoffContext(payload.transcript_path, text);

package/src/hosts/identity.test.mjs

@@ -66,6 +66,7 @@ test('every host adapter satisfies the shared hook contract', () => {
     assert.equal(typeof adapter.host, 'string');
     assert.equal(adapter.matchesSessionId(sessionId), true);
     assert.equal(typeof adapter.waitsForStopTranscriptFlush, 'boolean');
+    assert.equal(typeof adapter.rewritesTranscript, 'boolean');
     assert.equal(typeof adapter.consumesHandoffAtSessionStart, 'boolean');
     assert.equal(typeof adapter.deliverHandoffInjection, 'function');
     assert.equal(typeof adapter.resolveCommandPrompt, 'function');
@@ -78,6 +79,11 @@ test('flush barrier applies to claude and codex sessions, not grok or cursor', (
   assert.equal(hostAdapterForSessionId('codex:t1').waitsForStopTranscriptFlush, true);
   assert.equal(hostAdapterForSessionId('grok:t1').waitsForStopTranscriptFlush, false);
   assert.equal(hostAdapterForSessionId('cursor:t1').waitsForStopTranscriptFlush, false);
+  // transcript を書き直すと分かっている host は Grok だけ（ADR 0056）。
+  assert.equal(hostAdapterForSessionId('claude-session').rewritesTranscript, false);
+  assert.equal(hostAdapterForSessionId('codex:t1').rewritesTranscript, false);
+  assert.equal(hostAdapterForSessionId('grok:t1').rewritesTranscript, true);
+  assert.equal(hostAdapterForSessionId('cursor:t1').rewritesTranscript, false);
 });
 
 test('only Cursor consumes handoff at sessionStart', () => {

package/src/transcript-reader-grok.test.mjs

@@ -4,7 +4,7 @@ import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
-import { getLogicalTurnGroups, readTranscript } from './transcript-reader.mjs';
+import { getLogicalTurnGroups, isGrokHostWrittenUserEntry, readTranscript } from './transcript-reader.mjs';
 
 test('readTranscript accepts Grok chat_history.jsonl user/assistant rows', () => {
   const dir = mkdtempSync(join(tmpdir(), 'tl-grok-transcript-'));
@@ -35,3 +35,82 @@ test('readTranscript accepts Grok chat_history.jsonl user/assistant rows', () =>
     rmSync(dir, { recursive: true, force: true });
   }
 });
+
+function withGrokHistory(rows, fn) {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-grok-transcript-'));
+  const path = join(dir, 'chat_history.jsonl');
+  writeFileSync(path, rows.map((row) => JSON.stringify(row)).join('\n'));
+  try {
+    return fn(path);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+const grokUser = (text, extra = {}) => ({ type: 'user', content: [{ type: 'text', text }], ...extra });
+const grokAssistant = (text) => ({ type: 'assistant', content: text, model_id: 'm' });
+
+test('Grok が自分で書いた user 行（system_reminder・compaction_meta）は、ターンの始まりにも本文にもしない。番号は進める', () => {
+  withGrokHistory([
+    { type: 'system', content: 'system prompt' },
+    grokUser('preamble'),
+    grokUser('reminder before the prompt', { synthetic_reason: 'system_reminder' }),
+    grokUser('request one', { prompt_index: 0 }),
+    grokUser('reminder right after the prompt', { synthetic_reason: 'system_reminder' }),
+    grokAssistant('working'),
+    { type: 'tool_result', tool_call_id: 't', content: 'out' },
+    grokUser('reminder in the middle of the turn', { synthetic_reason: 'system_reminder' }),
+    grokAssistant('answer one'),
+    grokUser('background task finished', { synthetic_reason: 'task_completed' }),
+    grokAssistant('answer to the notification'),
+  ], (path) => {
+    assert.deepEqual(
+      readTranscript(path).map((t) => [t.turn_number, t.role, t.content]),
+      [
+        [0, 'user', 'preamble'],
+        [2, 'user', 'request one'],
+        [4, 'assistant', 'working'],
+        [6, 'assistant', 'answer one'],
+        [7, 'user', 'background task finished'],
+        [8, 'assistant', 'answer to the notification'],
+      ],
+    );
+    const groups = getLogicalTurnGroups(path);
+    assert.deepEqual(
+      groups.map((g) => [g.user.content, g.user.start, g.fragments.map((f) => f.index), g.representative.index]),
+      [
+        ['request one', 'prompt', [4, 6], 6],
+        ['background task finished', 'self', [8], 8],
+      ],
+    );
+  });
+});
+
+test('Grok の自動圧縮で書き直された chat_history は、要約の行を飛ばして、残った user 行からのターンとして読む', () => {
+  withGrokHistory([
+    { type: 'system', content: 'system prompt' },
+    grokUser('summary of the conversation so far', { synthetic_reason: 'compaction_meta' }),
+    grokUser('line kept by the compaction'),
+    grokUser('instructions to continue', { synthetic_reason: 'compaction_meta' }),
+    grokUser('reminder', { synthetic_reason: 'system_reminder' }),
+    grokAssistant('continuing'),
+    grokAssistant('final answer'),
+  ], (path) => {
+    const groups = getLogicalTurnGroups(path);
+    assert.equal(groups.length, 1);
+    assert.equal(groups[0].user.content, 'line kept by the compaction');
+    assert.equal(groups[0].user.start, 'unknown');
+    assert.deepEqual(groups[0].fragments.map((f) => f.index), [4, 5]);
+  });
+});
+
+test('isGrokHostWrittenUserEntry は Grok の印だけを見る。Claude の行と、知らない印の行は対象にしない', () => {
+  assert.equal(isGrokHostWrittenUserEntry(grokUser('x', { synthetic_reason: 'system_reminder' })), true);
+  assert.equal(isGrokHostWrittenUserEntry(grokUser('x', { synthetic_reason: 'compaction_meta' })), true);
+  assert.equal(isGrokHostWrittenUserEntry(grokUser('x', { synthetic_reason: 'task_completed' })), false);
+  assert.equal(isGrokHostWrittenUserEntry(grokUser('x', { synthetic_reason: 'something_new' })), false);
+  assert.equal(isGrokHostWrittenUserEntry(grokUser('x', { prompt_index: 3 })), false);
+  assert.equal(isGrokHostWrittenUserEntry({ type: 'assistant', content: 'x', synthetic_reason: 'system_reminder' }), false);
+  assert.equal(isGrokHostWrittenUserEntry({
+    type: 'user', synthetic_reason: 'system_reminder', message: { role: 'user', content: [{ type: 'text', text: 'x' }] },
+  }), false);
+});

package/src/transcript-reader.mjs

@@ -34,6 +34,21 @@ export function isCompactSummaryEntry(entry) {
   return entry?.isCompactSummary === true;
 }
 
+const GROK_HOST_WRITTEN_SYNTHETIC_REASONS = Object.freeze(['compaction_meta', 'system_reminder']);
+
+/**
+ * Grok が chat_history.jsonl へ自分で書く user 行か（ADR 0056）。type は user だが、人の発言ではない。
+ * `compaction_meta` は自動圧縮の要約と続きの指示、`system_reminder` は host の注意書き（Throughline の
+ * 引き継ぎの注入もこの印で書く）。ターンの始まりにも本文にもしない。`task_completed` は host が自分から
+ * 始めるターンの始まりなので、ここには入れない。
+ * @param {object} entry
+ */
+export function isGrokHostWrittenUserEntry(entry) {
+  return entry?.type === 'user'
+    && entry.message === undefined
+    && GROK_HOST_WRITTEN_SYNTHETIC_REASONS.includes(entry.synthetic_reason);
+}
+
 function extractText(content) {
   if (typeof content === 'string') return content;
   if (Array.isArray(content)) {
@@ -96,6 +111,8 @@ export function readTranscript(transcriptPath) {
     const turnNumber = position++;
     // 圧縮の要約は host が書いた行。ターンは圧縮をまたいで続くので、ここで区切らない。
     if (isCompactSummaryEntry(entry)) continue;
+    // Grok の合成行も host が書いた行。番号は進める（数えていた頃に保存した turn_number と食い違わせない）。
+    if (isGrokHostWrittenUserEntry(entry)) continue;
 
     const ts = typeof entry.timestamp === 'string' ? Date.parse(entry.timestamp) : NaN;
     // grok chat_history.jsonl は Claude の message 包みを持たず type/content 直置き。
@@ -221,6 +238,10 @@ export function readLatestUserGroup(transcriptPath) {
  * Stopの直後に次のuser行（queueから届いた入力）が書かれた時、完了したturnは
  * latestではなく1つ前のgroupになる。fragmentTurnNumbers はgroup内の全assistant断片のindex。
  *
+ * queueの入力は2通以上が続けて書かれることがある（ADR 0055）。その時、latestの手前には
+ * assistant断片の無いgroupが並ぶ。previous は、それらを飛ばして、assistant断片を持つ
+ * 一番近いgroupにする。
+ *
  * @param {string} transcriptPath
  * @returns {{
  *   latest: {userTurnNumber: number, assistantTurnNumber: number|null, assistantContent: string|null, fragmentTurnNumbers: number[]},
@@ -229,11 +250,14 @@ export function readLatestUserGroup(transcriptPath) {
  */
 export function readLatestLogicalTurnCompletions(transcriptPath) {
   const turns = readTranscript(transcriptPath);
-  const userIndexes = [];
-  for (let index = turns.length - 1; index >= 0 && userIndexes.length < 2; index--) {
-    if (turns[index].role === 'user') userIndexes.push(index);
+  let latestUserIndex = -1;
+  for (let index = turns.length - 1; index >= 0; index--) {
+    if (turns[index].role === 'user') {
+      latestUserIndex = index;
+      break;
+    }
   }
-  if (userIndexes.length === 0) return null;
+  if (latestUserIndex < 0) return null;
 
   const describe = (start, end) => {
     let representative = null;
@@ -251,10 +275,20 @@ export function readLatestLogicalTurnCompletions(transcriptPath) {
       fragmentTurnNumbers,
     };
   };
-  return {
-    latest: describe(userIndexes[0], turns.length),
-    previous: userIndexes.length === 2 ? describe(userIndexes[1], userIndexes[0]) : null,
-  };
+  let previous = null;
+  let end = latestUserIndex;
+  for (let index = latestUserIndex - 1; index >= 0; index--) {
+    if (turns[index].role !== 'user') continue;
+    const group = describe(index, end);
+    if (group.fragmentTurnNumbers.length > 0) {
+      previous = group;
+      break;
+    }
+    // assistant断片の無いgroup（続けて届いた入力）。1つ手前を見る。最初のgroupまで断片が無ければ、それを返す。
+    previous = group;
+    end = index;
+  }
+  return { latest: describe(latestUserIndex, turns.length), previous };
 }
 
 /**

package/src/turn-backfill.mjs

@@ -20,6 +20,7 @@
 import { appendFileSync, mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
+import { hostAdapterForSessionId } from './hosts/index.mjs';
 import {
   extractDetailBlocks,
   getLogicalTurnGroups,
@@ -57,6 +58,98 @@ export function deriveTranscriptPath(projectPath, sessionId) {
   return join(homedir(), '.claude', 'projects', mungedProjectPath, `${sessionId}.jsonl`);
 }
 
+/**
+ * 書き直される transcript の、世代1つぶんの turn_number の幅（ADR 0056）。
+ * 世代 g のターンは `g * TRANSCRIPT_GENERATION_SPAN + transcript 内の位置` で保存する。世代 0 は今までの番号と同じ。
+ */
+export const TRANSCRIPT_GENERATION_SPAN = 1_000_000;
+
+/**
+ * host が transcript を書き直す会話（Grok の自動圧縮・巻き戻し）の回収 (ADR 0056)。
+ *
+ * turn_number は transcript 内の位置なので、書き直された後の位置は、保存済みの別のターンの番号と重なる。
+ * 位置だけで「保存済み」を決めると、書き直しをまたいだターンを飛ばす。ここでは本文も比べる。
+ *
+ *   - 保存済みか: どれかの世代で、群の断片と同じ位置に、同じ本文の assistant 行がある。
+ *   - 書き直されたか: 今の世代で保存した assistant 行のうち、transcript の同じ位置に同じ本文が無い行がある。
+ *     その時は次の世代へ進み、保存していない群を新しい世代の番号で入れる。
+ *
+ * 世代は保存済みの turn_number から読める（`floor(turn_number / SPAN)`）ので、別の置き場を持たない。
+ */
+function backfillRewritableTranscript(db, { targetSessionId, originSessionId, groups, now }) {
+  const stored = new Map();
+  let currentGeneration = 0;
+  for (const row of db
+    .prepare(`SELECT turn_number, text FROM bodies WHERE origin_session_id = ? AND role = 'assistant'`)
+    .all(originSessionId)) {
+    stored.set(row.turn_number, row.text);
+    currentGeneration = Math.max(currentGeneration, Math.floor(row.turn_number / TRANSCRIPT_GENERATION_SPAN));
+  }
+  const generations = Array.from({ length: currentGeneration + 1 }, (_, index) => currentGeneration - index);
+
+  const fragmentAt = new Map();
+  for (const g of groups) for (const f of g.fragments) fragmentAt.set(f.index, f.content);
+  const currentBase = currentGeneration * TRANSCRIPT_GENERATION_SPAN;
+  const rewritten = [...stored].some(([turnNumber, text]) =>
+    turnNumber >= currentBase && fragmentAt.get(turnNumber - currentBase) !== text);
+  const writeBase = (rewritten ? currentGeneration + 1 : currentGeneration) * TRANSCRIPT_GENERATION_SPAN;
+
+  /** 保存済みの群なら、その行の turn_number。断片が複数の行に当たる時は、最後の行。 */
+  const storedTurnNumber = (g) => {
+    for (const generation of generations) {
+      const base = generation * TRANSCRIPT_GENERATION_SPAN;
+      for (let index = g.fragments.length - 1; index >= 0; index--) {
+        const f = g.fragments[index];
+        if (stored.get(base + f.index) === f.content) return base + f.index;
+      }
+    }
+    return null;
+  };
+
+  const insertBody = db.prepare(
+    `INSERT OR IGNORE INTO bodies
+       (session_id, origin_session_id, turn_number, role, text, token_count, created_at, turn_start)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+  );
+  let insertedTurns = 0;
+  let skippedExisting = 0;
+  const turnNumbers = [];
+
+  db.exec('BEGIN');
+  try {
+    for (const g of groups) {
+      const existing = storedTurnNumber(g);
+      if (existing !== null) {
+        skippedExisting++;
+        turnNumbers.push(existing);
+        continue;
+      }
+      const turnNumber = writeBase + g.representative.index;
+      const assistantAt = g.representative.timestamp ?? now;
+      const userAt = g.user.timestamp ?? assistantAt;
+      insertBody.run(targetSessionId, originSessionId, turnNumber, 'user', g.user.content,
+        Math.round(g.user.content.length / 4), userAt, g.user.start);
+      insertBody.run(targetSessionId, originSessionId, turnNumber, 'assistant', g.representative.content,
+        Math.round(g.representative.content.length / 4), assistantAt, null);
+      insertedTurns++;
+      turnNumbers.push(turnNumber);
+    }
+    db.exec('COMMIT');
+  } catch (err) {
+    db.exec('ROLLBACK');
+    throw err;
+  }
+
+  return {
+    groups: groups.length,
+    insertedTurns,
+    skippedExisting,
+    lastTurnNumber: turnNumbers.at(-1),
+    turnNumbers,
+    rewritten,
+  };
+}
+
 /**
  * transcript の未捕捉完了ターンを bodies へ回収する。
  *
@@ -73,6 +166,9 @@ export function backfillBodies(db, { targetSessionId, originSessionId, transcrip
   if (groups.length === 0) {
     return { groups: 0, insertedTurns: 0, skippedExisting: 0, lastTurnNumber: null, turnNumbers: [] };
   }
+  if (hostAdapterForSessionId(originSessionId).rewritesTranscript) {
+    return backfillRewritableTranscript(db, { targetSessionId, originSessionId, groups, now });
+  }
 
   const existing = new Set(
     db

package/src/turn-backfill.test.mjs

@@ -4,7 +4,7 @@ import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir, homedir } from 'node:os';
 import { join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
-import { backfillBodies, captureInFlightTurn, deriveTranscriptPath } from './turn-backfill.mjs';
+import { backfillBodies, captureInFlightTurn, deriveTranscriptPath, TRANSCRIPT_GENERATION_SPAN } from './turn-backfill.mjs';
 
 function makeDb() {
   const db = new DatabaseSync(':memory:');
@@ -293,6 +293,159 @@ function withDetails(db) {
 const toolUse = (id, name, input) => ({ type: 'assistant', message: { role: 'assistant', content: [{ type: 'tool_use', id, name, input }] } });
 const toolResult = (id, content) => ({ type: 'user', message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: id, content }] } });
 
+// --- host が書き直す transcript（Grok。ADR 0056） ---
+
+const GROK = 'grok:11111111-2222-3333-4444-555555555555';
+const grokUser = (text, extra = {}) => ({ type: 'user', content: [{ type: 'text', text }], ...extra });
+const grokAssistant = (text) => ({ type: 'assistant', content: text, model_id: 'm' });
+const grokSystem = { type: 'system', content: 'system prompt' };
+const storedRows = (db) => db
+  .prepare('SELECT turn_number, role, text FROM bodies ORDER BY turn_number, role DESC')
+  .all()
+  .map((row) => `${row.turn_number}${row.role[0]}=${row.text}`);
+const grokBackfill = (db, entries) =>
+  withData(entries, (path) => backfillBodies(db, { targetSessionId: GROK, originSessionId: GROK, transcriptPath: path, now: 999 }));
+
+const GROK_BEFORE_COMPACTION = [
+  grokSystem,
+  grokUser('preamble'),
+  grokUser('reminder', { synthetic_reason: 'system_reminder' }),
+  grokUser('request 1', { prompt_index: 0 }),
+  grokAssistant('working 1'),
+  grokAssistant('answer 1'), // 4
+  grokUser('request 2', { prompt_index: 1 }),
+  grokAssistant('working 2'),
+  grokAssistant('working 2b'),
+  grokAssistant('answer 2'), // 8
+];
+// 圧縮の後。位置 4〜9 に、圧縮をまたいだターンの断片が並ぶ。位置 4 と 8 は保存済みの番号と重なる。
+const grokAfterCompaction = (fragments) => [
+  grokSystem,
+  grokUser('summary', { synthetic_reason: 'compaction_meta' }),
+  grokUser('line kept by the compaction'),
+  grokUser('continue', { synthetic_reason: 'compaction_meta' }),
+  grokUser('reminder', { synthetic_reason: 'system_reminder' }),
+  ...fragments.map(grokAssistant),
+];
+
+test('backfillBodies: Grok が圧縮で書き直した後のターンは、番号が保存済みのターンと重なっても、新しい世代の番号で保存する', () => {
+  const db = makeDb();
+  const first = grokBackfill(db, GROK_BEFORE_COMPACTION);
+  assert.deepEqual(first.turnNumbers, [4, 8]);
+  assert.equal(first.rewritten, false);
+
+  // 代表ではない断片（位置 8）だけが保存済みの番号と重なる形。直す前は、群を飛ばした後に受領で失敗した。
+  const after = grokAfterCompaction(['after 1', 'after 2', 'after 3', 'after 4', 'after 5', 'answer 3']);
+  const second = grokBackfill(db, after);
+  const span = TRANSCRIPT_GENERATION_SPAN;
+  assert.deepEqual(
+    { groups: second.groups, insertedTurns: second.insertedTurns, skippedExisting: second.skippedExisting, rewritten: second.rewritten },
+    { groups: 1, insertedTurns: 1, skippedExisting: 0, rewritten: true },
+  );
+  assert.deepEqual(second.turnNumbers, [span + 9]);
+  assert.equal(second.lastTurnNumber, span + 9);
+  assert.deepEqual(storedRows(db), [
+    '4u=request 1', '4a=answer 1', '8u=request 2', '8a=answer 2',
+    `${span + 9}u=line kept by the compaction`, `${span + 9}a=answer 3`,
+  ]);
+
+  // 同じ transcript をもう一度読んでも増えず、世代も進まない。
+  const again = grokBackfill(db, after);
+  assert.deepEqual(
+    { insertedTurns: again.insertedTurns, skippedExisting: again.skippedExisting, rewritten: again.rewritten, turnNumbers: again.turnNumbers },
+    { insertedTurns: 0, skippedExisting: 1, rewritten: false, turnNumbers: [span + 9] },
+  );
+
+  // 次のターンは同じ世代の続きの番号で入る。
+  const next = grokBackfill(db, [...after, grokUser('request 4', { prompt_index: 3 }), grokAssistant('answer 4')]);
+  assert.deepEqual(next.turnNumbers, [span + 9, span + 11]);
+  assert.equal(next.insertedTurns, 1);
+  assert.equal(next.rewritten, false);
+});
+
+test('backfillBodies: Grok の書き直し後に、代表の断片の番号が保存済みのターンと重なっても、黙って落とさない', () => {
+  const db = makeDb();
+  grokBackfill(db, GROK_BEFORE_COMPACTION);
+  // 代表（位置 8）が、保存済みの「answer 2」の番号と重なる形。直す前は、失敗も出さずに落としていた。
+  const result = grokBackfill(db, grokAfterCompaction(['after 1', 'after 2', 'after 3', 'after 4', 'answer 3']));
+  assert.equal(result.insertedTurns, 1);
+  assert.deepEqual(result.turnNumbers, [TRANSCRIPT_GENERATION_SPAN + 8]);
+  assert.equal(
+    db.prepare(`SELECT text FROM bodies WHERE turn_number = ? AND role = 'assistant'`).get(TRANSCRIPT_GENERATION_SPAN + 8).text,
+    'answer 3',
+  );
+  assert.equal(db.prepare(`SELECT text FROM bodies WHERE turn_number = 8 AND role = 'assistant'`).get().text, 'answer 2');
+});
+
+test('backfillBodies: Grok の2回目の書き直しは、さらに次の世代の番号になる', () => {
+  const db = makeDb();
+  const span = TRANSCRIPT_GENERATION_SPAN;
+  grokBackfill(db, GROK_BEFORE_COMPACTION);
+  grokBackfill(db, grokAfterCompaction(['after 1', 'answer 3'])); // 世代 1 の位置 5
+  const third = grokBackfill(db, grokAfterCompaction(['later 1', 'later 2', 'answer 5']));
+  assert.equal(third.rewritten, true);
+  assert.deepEqual(third.turnNumbers, [2 * span + 6]);
+  assert.deepEqual(storedRows(db).filter((row) => row.includes('a=')), [
+    '4a=answer 1', '8a=answer 2', `${span + 5}a=answer 3`, `${2 * span + 6}a=answer 5`,
+  ]);
+});
+
+test('backfillBodies: Grok の巻き戻しで後ろだけが変わった時、変わっていないターンは重ねて入れない', () => {
+  const db = makeDb();
+  grokBackfill(db, GROK_BEFORE_COMPACTION);
+  // 「request 2」より後ろを巻き戻して、別の依頼をした。位置 6〜7 に別の本文が入る。
+  const rewound = [...GROK_BEFORE_COMPACTION.slice(0, 6), grokUser('request 2 again', { prompt_index: 1 }), grokAssistant('working'), grokAssistant('new answer 2')];
+  const result = grokBackfill(db, rewound);
+  assert.deepEqual(
+    { insertedTurns: result.insertedTurns, skippedExisting: result.skippedExisting, rewritten: result.rewritten },
+    { insertedTurns: 1, skippedExisting: 1, rewritten: true },
+  );
+  assert.deepEqual(result.turnNumbers, [4, TRANSCRIPT_GENERATION_SPAN + 7]);
+  assert.deepEqual(storedRows(db).filter((row) => row.includes('a=')), [
+    '4a=answer 1', '8a=answer 2', `${TRANSCRIPT_GENERATION_SPAN + 7}a=new answer 2`,
+  ]);
+});
+
+test('backfillBodies: Grok の合成行を user として保存していた頃のターンは、群がまとまっても重ねて入れない', () => {
+  const db = makeDb();
+  // 直す前は、ターンの途中の system_reminder が群を2つに割っていた（代表は位置 3 と 5）。
+  const insert = db.prepare(`INSERT INTO bodies (session_id, origin_session_id, turn_number, role, text, created_at) VALUES (?, ?, ?, ?, ?, 1)`);
+  for (const [turn, role, text] of [[3, 'user', 'request 1'], [3, 'assistant', 'working 1'], [5, 'user', 'reminder'], [5, 'assistant', 'answer 1']]) {
+    insert.run(GROK, GROK, turn, role, text);
+  }
+  const result = grokBackfill(db, [
+    grokSystem,
+    grokUser('preamble'),
+    grokUser('reminder', { synthetic_reason: 'system_reminder' }),
+    grokUser('request 1', { prompt_index: 0 }),
+    grokAssistant('working 1'), // 3
+    grokUser('reminder', { synthetic_reason: 'system_reminder' }),
+    grokAssistant('answer 1'), // 5
+  ]);
+  assert.deepEqual(
+    { groups: result.groups, insertedTurns: result.insertedTurns, skippedExisting: result.skippedExisting, rewritten: result.rewritten },
+    { groups: 1, insertedTurns: 0, skippedExisting: 1, rewritten: false },
+  );
+  // 受領は、行が実際にある番号（最後に当たった行）で出す。
+  assert.deepEqual(result.turnNumbers, [5]);
+  assert.equal(db.prepare('SELECT COUNT(*) AS n FROM bodies').get().n, 4);
+});
+
+test('backfillBodies: 追記だけの host（Claude Code）は、今までどおり位置だけで保存済みを決める', () => {
+  const db = makeDb();
+  const insert = db.prepare(`INSERT INTO bodies (session_id, origin_session_id, turn_number, role, text, created_at) VALUES (?, ?, ?, ?, ?, 1)`);
+  insert.run('target', 'origin', 1, 'user', 'stored under another text');
+  insert.run('target', 'origin', 1, 'assistant', 'stored under another text');
+  withData([entry('user', 'question'), entry('assistant', 'answer')], (path) => {
+    const result = backfillBodies(db, { targetSessionId: 'target', originSessionId: 'origin', transcriptPath: path, now: 999 });
+    assert.deepEqual(
+      { insertedTurns: result.insertedTurns, skippedExisting: result.skippedExisting, turnNumbers: result.turnNumbers },
+      { insertedTurns: 0, skippedExisting: 1, turnNumbers: [1] },
+    );
+    assert.equal(result.rewritten, undefined);
+  });
+});
+
 test('captureInFlightTurn: 止めたターンの発言を全部つないで本文にし、末尾の道具まで details に入れる。合流時の回収は重ねない', () => {
   withData(
     [

package/src/turn-processor.test.mjs

@@ -152,6 +152,71 @@ test('Claude Stop flush barrierは、前後の空白を除いてmarkerと本文
   }
 });
 
+test('Claude Stop flush barrierは、Stop直後に待っていた入力が2通以上続けて届いても、未捕捉の完了turnを採用する', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'throughline-stop-flush-queued-inputs-'));
+  const transcriptPath = join(root, 'transcript.jsonl');
+  const text = (role, value) => ({ type: role, message: { role, content: [{ type: 'text', text: value }] } });
+  let elapsed = 0;
+  const clock = { now: () => elapsed, wait: async (milliseconds) => { elapsed += milliseconds; } };
+  const write = (entries) => writeFileSync(transcriptPath, entries.map((entry) => JSON.stringify(entry)).join('\n'), 'utf8');
+  const completed = [
+    text('user', 'first request'),
+    text('assistant', 'first answer'),
+    text('user', 'second request'),
+    text('assistant', 'second answer'),
+  ];
+  try {
+    for (const queued of [2, 3]) {
+      write([...completed, ...Array.from({ length: queued }, (_, index) => text('user', `queued request ${index}`))]);
+      const captured = [];
+      elapsed = 0;
+      const result = await waitForClaudeStopTranscriptFlush({
+        transcriptPath,
+        lastAssistantMessage: 'second answer',
+        timeoutMs: 100,
+        intervalMs: 10,
+        isTurnCaptured: (fragmentTurnNumbers) => { captured.push(fragmentTurnNumbers); return false; },
+        ...clock,
+      });
+      assert.deepEqual(result, { status: 'ready', userTurnNumber: 2, assistantTurnNumber: 3 }, `queued=${queued}`);
+      assert.deepEqual(captured, [[3]]);
+      assert.equal(elapsed, 0, 'the completed turn is already flushed; no waiting');
+    }
+
+    // 捕捉済みの同文answerは今回のStopの完了ではない。
+    elapsed = 0;
+    await assert.rejects(waitForClaudeStopTranscriptFlush({
+      transcriptPath, lastAssistantMessage: 'second answer', timeoutMs: 30, intervalMs: 10,
+      isTurnCaptured: () => true, ...clock,
+    }), /not visible before deadline/);
+
+    // 本文を持つgroupを飛ばして、その前のturnを採用しない。
+    elapsed = 0;
+    await assert.rejects(waitForClaudeStopTranscriptFlush({
+      transcriptPath, lastAssistantMessage: 'first answer', timeoutMs: 30, intervalMs: 10,
+      isTurnCaptured: () => false, ...clock,
+    }), /not visible before deadline/);
+
+    // 届いた入力のturnが本文を書き始めていたら採用しない。
+    appendFileSync(transcriptPath, `\n${JSON.stringify(text('assistant', 'working on the queued requests'))}`, 'utf8');
+    elapsed = 0;
+    await assert.rejects(waitForClaudeStopTranscriptFlush({
+      transcriptPath, lastAssistantMessage: 'second answer', timeoutMs: 30, intervalMs: 10,
+      isTurnCaptured: () => false, ...clock,
+    }), /not visible before deadline/);
+
+    // 本文を持つgroupが1つも無い時は、採用する物が無い。
+    write([text('user', 'only request'), text('user', 'queued request 0'), text('user', 'queued request 1')]);
+    elapsed = 0;
+    await assert.rejects(waitForClaudeStopTranscriptFlush({
+      transcriptPath, lastAssistantMessage: 'second answer', timeoutMs: 30, intervalMs: 10,
+      isTurnCaptured: () => false, ...clock,
+    }), /not visible before deadline/);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test('Claude Stop flush barrierは、Stop直後に次のuser行が届いても、未捕捉の完了turnを待たずに採用する', async () => {
   const root = mkdtempSync(join(tmpdir(), 'throughline-stop-flush-next-user-'));
   const transcriptPath = join(root, 'transcript.jsonl');