throughline 0.16.25 → 0.16.27

package/CHANGELOG.md

@@ -10,6 +10,67 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.27] — 2026-10-13
+
+### 修正
+
+- **Aitermが起こしたClaude Codeの席の会話が、自動継続で裏の後継へ引き継がれ、呼び手の文が後継へ届かなくなっていた**（[ADR 0057](docs/adr/0057-claude-aiterm-seat-conversation-is-not-handed-off.md)）。Windowsの実機で2026-10-13に起きた（10-11にも1回）。
+  - Aitermの席は、起こした時の会話に結び付いている。後継は別の会話なので、呼び手が席へ送った文は旧い会話へ入り、後継の答えも呼び手へ戻らなかった。
+  - 直した後は、席の会話では自動圧縮を止めず、後継も立てない。席は同じ画面のまま続く。理由は判定のログに`aiterm_seat`で残る。
+  - 席と数えるのは、hookの環境に`AITERM_AGENT_LAUNCH_ID`があり、`AITERM_AGENT_VENDOR_SESSION_ID`がその会話のIDと同じ時だけ。起動の印だけでは外さない。裏の会話（`claude --bg`）はClaude Codeの常駐のprocessの環境を継ぐので、席の中から常駐が起きると、関係の無い裏の会話も席の印を持つ（Linux、Claude Code 2.1.296で実測）。
+  - **効くのは、`AITERM_AGENT_VENDOR_SESSION_ID`を出す版のAiterm（0.59.0の次の版）が起こした席から。** それまでの席は、今までどおり裏の後継へ引き継がれる。
+  - 席の会話に、後継を立てる前の引き継ぎの記録が残っている時は、記録を取り下げて圧縮と道具を通す。もう後継へ引き継いだ席の会話は、今までどおり後継を案内する。
+
+### 変わる動き
+
+- 効いた後の席では、文脈が一杯になるとClaude Codeの自動圧縮が走る。席の同じ画面で新しい会話へ替える形（圧縮なし）は、Aitermと合わせて次に作る。
+- Aitermの席でない会話（端末・Claude Desktopで直接使う会話、その後継）の引き継ぎは変わらない。
+
+### 対応の範囲
+
+| | macOS | Linux | Windows |
+|---|---|---|---|
+| Claude Code（Aitermの席） | 直した。単体試験と、実機で候補の版の本物のhookの入口（`pre-compact`・`pre-tool-use`）へ、席・席の印を継いだだけの会話・印の無い会話の環境を通した。本物の席での通しは、会話IDを出す版のAitermが出てから | 直した。macOSと同じ確認（2台）。裏の会話が常駐の環境を継ぐ事は、ここで見た | 直した。起きた端末。macOSと同じ確認。本物の席での通しは、会話IDを出す版のAitermが出てから |
+| Codex | 変更なし（自動継続はCodex Desktopだけ。Aitermの席のCLIは対象外） | 同じ | 同じ |
+| Grok | 変更なし（自動継続が無い） | 同じ | 同じ |
+| Cursor | 変更なし（自動継続が無い） | 同じ | 同じ |
+
+### 確かめていない事
+
+- 会話IDを出す版のAitermが起こした本物の席で、本物の自動圧縮が起きた時の動き。その版はまだ出ていない。
+- macOSとWindowsで、裏の会話が常駐の環境を継ぐか。
+
+## [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
 
 ### 修正
@@ -2461,7 +2522,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.25...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.27...HEAD
+[0.16.27]: https://github.com/kitepon/Throughline/compare/v0.16.26...v0.16.27
+[0.16.26]: https://github.com/kitepon/Throughline/compare/v0.16.25...v0.16.26
 [0.16.25]: https://github.com/kitepon/Throughline/compare/v0.16.24...v0.16.25
 [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

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/0033-claude-auto-handoff-new-session.md

@@ -106,6 +106,14 @@ Claude Desktop の新しい会話は、画面を開いただけでは process
   落として保存する。
 - 依存の `aiterm-steer-delivery` を 0.1.9 から 0.1.13 に上げる。Codex の配送の入口は変わらない。
 
+## 追記（2026-10-13、ADR 0057）
+
+Decision 1 の「止めない会話」に、Aiterm が起こした席の会話を足した。席は起こした時の会話に結び付いていて、裏の後継へ
+引き継ぐと、呼び手の文が後継へ届かない。席と数える条件と、常駐の process が環境を継がせる事は ADR 0057 に書いた。
+
+hook で止めたターンで Stop hook が走らない事は、Claude Code 2.1.296（Windows）の実機の記録でも同じだった
+（10:48:08 に止めた会話の次の Stop は、後から文が入った 11:02:52）。
+
 ## 確認した範囲
 
 - Linux の Claude Code 2.1.289。対話画面の会話から始めて、Haiku 4.5 で3回、Opus 5.5 で6回、連続で引き継ぎ、

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/docs/adr/0057-claude-aiterm-seat-conversation-is-not-handed-off.md

@@ -0,0 +1,88 @@
+# ADR 0057: Aiterm が起こした席の Claude の会話は、裏の後継へ引き継がない
+
+- Status: Accepted
+- Date: 2026-10-13
+
+## Context
+
+Claude Code の自動継続（ADR 0033）は、自動圧縮を止め、次の道具でターンを止めて、`claude --bg` の後継へ引き継ぐ。
+引き継ぎを外すのは、手動の `/compact`、無効な project、subagent の中の圧縮、script から起動した会話
+（`CLAUDE_CODE_ENTRYPOINT` が `sdk-` で始まる）だけだった。
+
+Aiterm が起こした Claude の席（Bot がほかの端末に起こす子、通話の MCP が立てる席）は、入口が `cli` の対話の会話なので、
+人の端末の会話と同じに引き継がれていた。席での振る舞いは、決めていなかった。
+
+2026-10-13 10:48（JST）、Windows の実機で、Aiterm の remote で起こした席の会話が後継へ引き継がれた。Throughline の記録では
+引き継ぎは成立している（`sent`）。席の側では次の事が起きた（Aiterm の担当の調べ）。
+
+- Aiterm の席は、起こした時の会話 ID に結び付いている。別の会話の番の終わりは、席の物と数えない。
+- 後継は Claude Code の常駐の process の下で動き、席の端末とは別の木にある。
+- 呼び手が席へ送った文は旧い会話へ入り、後継へ届かない。後継の答えも呼び手へ戻らない。2通が落ち、呼び手が
+  `claude attach` で手でつないだ。
+
+同じ形は 2026-10-11 にも1回起きている（通話の MCP が立てた席）。BellTeam のコンテナは、席の配送が終わらなくなる事が
+分かっていたので、自動継続を無効にしてある。Windows・macOS・Linux の3台は全 project で有効にしていて、そこへ Aiterm が
+起こした席が入っていた。
+
+オーナーの決め（2026-10-13）: 席では引き継がない形を先に入れ、続けて「席の同じ画面で新しい会話へ替える」形を Aiterm と
+作る。後の形が出来れば、席でも圧縮は走らない。この ADR は先に入れる分を決める。
+
+### 席を何で見分けるか
+
+Aiterm は、席の process の環境へ起動の印（`AITERM_AGENT_LAUNCH_ID`、`AITERM_AGENT_KIND` など）を入れる。人が Aiterm の
+端末の中で手で起こした claude には付かない（その端末にあるのは `AITERM_SESSION_ID` と `AITERM_STATE_BASE` だけ）。
+
+印だけで席と決める形は、採れなかった。Linux の実機（Claude Code 2.1.296）で、裏の会話を2本、違う環境で続けて立てた。
+1本目は `AITERM_AGENT_LAUNCH_ID` を付け、2本目は `AITERM_AGENT_*` を全部外した環境から立てた。2本目の会話の hook
+（`SessionStart`・`UserPromptSubmit`・`Stop`）が受けた環境は、1本目と同じ印を持っていた。裏の会話は、起こした側ではなく、
+Claude Code の常駐の process の環境を継ぐ。常駐は、最初に起こした process の環境を持ち続ける。
+
+つまり、席の中（席の Bash、席の hook が起こす Throughline の worker）から常駐が起きると、その後に立つ裏の会話は、席と
+関係が無くても席の印を持つ。印だけで外すと、利用者の会話の後継（裏の会話）まで引き継ぎから外れ、自動圧縮が走る。
+Throughline は自動圧縮を置き換える物で、利用者の会話でそれが起きるのは、席の文が落ちる事より重い。
+
+Aiterm は、席の Claude を `--session-id <ID>` で起こし、その ID だけを席の物と数える。Aiterm の担当と合わせて、この ID を
+席の環境へ `AITERM_AGENT_VENDOR_SESSION_ID` として出してもらう（Aiterm 0.59.0 の次の版から。席の途中で変わらない）。
+
+## Decision
+
+1. **席の会話**は、hook の環境に `AITERM_AGENT_LAUNCH_ID` があり、かつ `AITERM_AGENT_VENDOR_SESSION_ID` が hook の
+   `session_id` と同じ会話とする（`isAitermSeatConversation`）。起動の印だけでは席と数えない。
+2. `PreCompact(auto)` は、席の会話では圧縮を止めず、引き継ぎの記録も残さない。理由は `aiterm_seat`。判定の順は、
+   手動の `/compact` → 進んでいる引き継ぎ → 無効な project → script から起動した会話 → 席。自動継続が無効な端末の
+   席は、今までどおり `auto_handoff_disabled` で終わる。
+3. 席の会話に、後継を立てる前の記録（`requested`・`failed`）が残っている時は、`PreCompact` と `PreToolUse` が記録と
+   立ち上げの札を取り下げ、圧縮と道具を通す。席を外す前の版が予約した会話と、会話 ID を出さない版の Aiterm の時に
+   予約した会話が、これに当たる。
+4. もう後継へ引き継いだ席の会話（`stopped` から先）は、今までどおり圧縮と道具を止め、後継を案内する。続きは後継にある。
+5. 席の印を継いだだけの会話（席が起こした子、席の中から起きた常駐が立てた裏の会話）は、会話 ID が違うので、
+   今までどおり引き継ぐ。
+6. 会話 ID を出さない版の Aiterm が起こした席は、見分けられないので、今までどおり引き継ぐ。
+7. `AITERM_AGENT_LAUNCH_ID` と `AITERM_AGENT_VENDOR_SESSION_ID` の名前と意味は、Aiterm の担当と合わせた物とする。
+   変える時は、先に知らせ合う。
+
+## Consequences
+
+- この版が効くのは、`AITERM_AGENT_VENDOR_SESSION_ID` を出す版の Aiterm が起こした席から。それまでの席は、今までどおり
+  裏の後継へ引き継がれ、呼び手の文は後継へ届かない。
+- 効いた後の席は、同じ画面のまま続き、呼び手との行き来は切れない。文脈が一杯になると、Claude Code の自動圧縮が走る
+  （BellTeam のコンテナの席と同じ）。圧縮より前の細かい文脈は、Claude の要約に置き換わる。会話の記録は、今までどおり
+  Stop で Throughline に入る。
+- 「host の自動圧縮を通さない」（ADR 0033）は、席の会話については、同じ画面で新しい会話へ替える形が出来るまで外す。
+- 席の会話を起こし直す・`/clear` するなどで会話 ID が変わった時は、環境の ID と合わなくなり、今までどおり引き継ぐ。
+- 席の環境へ足す印は、同じ道でほかの裏の会話へ継がれる。この先、席だけの動きを足す時も、会話 ID の一致で席と決めてから
+  印を読む。
+- 後継を立てる worker は、席の `AITERM_AGENT_*` を外さずに `claude --bg` を呼ぶ（外すのは会話ごとの `CLAUDE_CODE_*` など）。
+  常駐が動いている時は、後継の環境は常駐の物になるので、外しても変わらない。ここは変えていない。
+
+## 確認した範囲
+
+- 単体試験と、本物の CLI の入口（`pre-compact`・`pre-tool-use`）を仮の HOME で動かす試験。
+- 公開前に、候補の tarball を macOS（Node 26.11.1）・Linux（Node 24.20.0 と 26.11.1）・Windows 11（Node 24.20.0）へ置き、
+  仮の HOME で本物の hook の入口へ5つの場面を通した。席の環境は圧縮も道具も止めず記録を残さない。席の印を継いだだけの
+  環境・起動の印だけの環境・印の無い環境は、今までどおり圧縮を止めて引き継ぎを予約する。予約が残った席の会話は、次の
+  道具で記録を取り下げる。4台とも同じ結果だった。
+- 裏の会話が常駐の環境を継ぐ事は、Linux（Claude Code 2.1.296）だけで見た。macOS と Windows では見ていない
+  （動いている常駐の下に試験の会話を立てる事になるので、流していない）。
+- `AITERM_AGENT_VENDOR_SESSION_ID` を出す版の Aiterm は、まだ出ていない。本物の席での通し（本物の自動圧縮が起き、
+  席が同じ画面のまま答えを返す所）は、その版が入った後に確かめる。

package/package.json

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

package/src/claude-auto-handoff.mjs

@@ -260,6 +260,24 @@ function unsupportedEntrypoint(env) {
   return typeof env.CLAUDE_CODE_ENTRYPOINT === 'string' && env.CLAUDE_CODE_ENTRYPOINT.startsWith('sdk-');
 }
 
+// Aiterm が席の Claude に付ける印（ADR 0057）。名前と意味は Aiterm の担当と合わせてある。変える時は先に知らせ合う。
+// 起動の印と、席の Claude を起こした時の会話 ID（`--session-id` の値。席の途中で変わらない）。
+const AITERM_LAUNCH_ENV = 'AITERM_AGENT_LAUNCH_ID';
+const AITERM_SEAT_SESSION_ENV = 'AITERM_AGENT_VENDOR_SESSION_ID';
+
+/**
+ * Aiterm が起こした席の会話か（ADR 0057）。席は起こした時の会話に結び付いていて、呼び手はその会話の番の終わりを待っている。
+ * 裏の後継へ引き継ぐと、呼び手の文は後継へ届かず、後継の答えも呼び手へ戻らない。席の会話は引き継がない。
+ *
+ * 席と数えるのは、環境の会話 ID がこの会話の ID と同じ時だけ。起動の印だけでは決めない。印は席の Claude が起こした子へ
+ * 継がれ、裏の会話（`claude --bg`）は常駐の process の環境を継ぐ。席の中から常駐が起きると、その後に立つ裏の会話は、
+ * 席と関係が無くても席の印を持つ（Linux、Claude Code 2.1.296 で実測）。印だけで外すと、利用者の会話の後継まで外れる。
+ * 会話 ID を出さない版の Aiterm が起こした席は、見分けられないので、今までどおり引き継ぐ。
+ */
+export function isAitermSeatConversation(env, sessionId) {
+  return Boolean(env?.[AITERM_LAUNCH_ENV]) && typeof sessionId === 'string' && env[AITERM_SEAT_SESSION_ENV] === sessionId;
+}
+
 /** transcript の最後の行が持つ出どころ（`cli`、`claude-desktop` など）。読めなければ null。 */
 function readLatestEntrypoint(transcriptPath) {
   if (typeof transcriptPath !== 'string') return null;
@@ -377,8 +395,12 @@ export function requestClaudeAutoHandoff({
     if (existing?.state === 'requested') rmSync(path, { force: true });
     return { status: 'skipped', block: false, reason: 'manual_compact', sessionId, projectPath };
   }
+  const seat = isAitermSeatConversation(env, sessionId);
+  // 席の会話に、後継を立てる前の記録が残っている（席を外す前の版が予約した）。取り下げて、圧縮を通す。
+  const withdrawn = seat && existing && RETRYABLE_STATES.has(existing.state);
+  if (withdrawn) withdrawRecord(sessionId, dir);
   // 引き継ぎが進んでいる会話は、設定が後から変わっても圧縮させない。
-  if (existing) {
+  if (existing && !withdrawn) {
     return { status: 'already_requested', block: true, sessionId, projectPath, handoffId: existing.handoff_id };
   }
   if (!claudeAutoHandoffEnabledFor(config, projectPath)) {
@@ -387,6 +409,9 @@ export function requestClaudeAutoHandoff({
   if (unsupportedEntrypoint(env)) {
     return { status: 'skipped', block: false, reason: 'handoff_host_unsupported', sessionId, projectPath };
   }
+  if (seat) {
+    return { status: 'skipped', block: false, reason: 'aiterm_seat', sessionId, projectPath };
+  }
 
   // 後継は、最初の指示が運ぶ引き継ぎ ID からこの記録を引いて、この会話を前任として合流させる（ADR 0053）。
   // project ごとに1つしか無い `/tl` の印は書かない。印を書いてから後継が立つまでの間に、同じ project の別の会話が
@@ -613,6 +638,12 @@ export async function launchClaudeAutoHandoffWorker(sessionId, { dir = claudeAut
   } finally { closeSync(log); }
 }
 
+/** 後継を立てる前の記録と、立ち上げの札を消す。その会話は、記録が無い会話と同じ扱いに戻る。 */
+function withdrawRecord(sessionId, dir) {
+  rmSync(recordPath(sessionId, dir), { force: true });
+  rmSync(join(dir, `${sessionId}.claim`), { force: true });
+}
+
 function stopOutput(record) {
   const reason = record.successor?.short_id
     ? `この会話はThroughlineが新しい会話へ引き継ぎ済みです（引き継ぎID: ${record.handoff_id}）。続きは後継の会話で行ってください: claude attach ${record.successor.short_id}`
@@ -631,7 +662,8 @@ function stopOutput(record) {
 /**
  * PreToolUse hook の本体。引き継ぎの記録がある会話の道具を、実行させずに止める。
  * 最初に止めた hook だけが、止めた時点の依頼と設定を記録へ写し、後継を立てる worker を起動する。
- * 記録が無い会話と、subagent の中の道具には何もしない（null）。
+ * 記録が無い会話と、subagent の中の道具には何もしない（null）。Aiterm が起こした席の会話に、後継を立てる前の記録が
+ * 残っている時は、記録を取り下げて何もしない（ADR 0057）。
  *
  * @returns {Promise<object|null>} Claude Code へ返す hook 出力
  */
@@ -640,12 +672,18 @@ export async function stopClaudeTurnForHandoff({
   now = Date.now(),
   dir = claudeAutoHandoffDir(),
   launchWorker = launchClaudeAutoHandoffWorker,
+  env = process.env,
 }) {
   const sessionId = payload?.session_id;
   if (!validSessionId(sessionId) || payload.agent_id) return null;
   let record = readClaudeAutoHandoff(sessionId, dir);
   if (!record) return null;
   if (RETRYABLE_STATES.has(record.state)) {
+    // 席の会話は引き継がない（ADR 0057）。席を外す前の版が残した、後継を立てる前の記録は取り下げ、道具を通す。
+    if (isAitermSeatConversation(env, sessionId)) {
+      withdrawRecord(sessionId, dir);
+      return null;
+    }
     // 同じ応答に並んだ道具の hook は同時に走る。立ち上げは1回だけ。
     const claim = join(dir, `${sessionId}.claim`);
     if (record.state === 'failed') rmSync(claim, { force: true });

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

@@ -21,6 +21,7 @@ import {
   runClaudeDesktopOpen,
   findClaudeAutoContinuationSource,
   resolveClaudeAutoHandoffSuccessor,
+  isAitermSeatConversation,
 } from './claude-auto-handoff.mjs';
 import { parseAutoHandoffArgs } from './cli/auto-handoff.mjs';
 
@@ -182,6 +183,93 @@ test('PreCompact: 手動・無効・対象外のproject・scriptから起動し
   assert.equal(request(dir, { env: { CLAUDE_CODE_ENTRYPOINT: 'claude-desktop' } }).result.status, 'requested');
 }));
 
+test('席の判定: 起動の印があり、環境の会話 ID がこの会話と同じ時だけ席と数える', () => {
+  const OTHER = 'cccccccc-1111-4222-8333-444444444444';
+  for (const [env, expected, label] of [
+    [{}, false, '印なし（人の端末、Desktop）'],
+    [{ AITERM_SESSION_ID: 't1', AITERM_STATE_BASE: '/tmp' }, false, 'Aiterm の素の端末で人が起こした claude'],
+    [{ AITERM_AGENT_LAUNCH_ID: 'abc', AITERM_AGENT_KIND: 'claude' }, false, '会話 ID を出さない版の Aiterm の席。印だけでは決めない'],
+    [{ AITERM_AGENT_LAUNCH_ID: 'abc', AITERM_AGENT_VENDOR_SESSION_ID: '' }, false, '空の会話 ID'],
+    [{ AITERM_AGENT_VENDOR_SESSION_ID: SESSION }, false, '起動の印が無い'],
+    [{ AITERM_AGENT_LAUNCH_ID: '', AITERM_AGENT_VENDOR_SESSION_ID: SESSION }, false, '空の印'],
+    [{ AITERM_AGENT_LAUNCH_ID: 'abc', AITERM_AGENT_KIND: 'claude', AITERM_AGENT_VENDOR_SESSION_ID: SESSION }, true, '席の会話'],
+    [{ AITERM_AGENT_LAUNCH_ID: 'abc', AITERM_AGENT_KIND: 'claude', AITERM_AGENT_VENDOR_SESSION_ID: OTHER }, false,
+      '席の印を継いだ別の会話（席が起こした子、席の中から起きた常駐が立てた裏の会話）'],
+  ]) assert.equal(isAitermSeatConversation(env, SESSION), expected, label);
+  assert.equal(isAitermSeatConversation(undefined, SESSION), false);
+  assert.equal(isAitermSeatConversation({ AITERM_AGENT_LAUNCH_ID: 'abc' }, undefined), false);
+});
+
+const SEAT = { AITERM_AGENT_LAUNCH_ID: 'abc', AITERM_AGENT_KIND: 'claude', AITERM_AGENT_VENDOR_SESSION_ID: SESSION };
+// 席の印を継いだだけの、別の会話の環境
+const SEAT_DESCENDANT = { ...SEAT, AITERM_AGENT_VENDOR_SESSION_ID: SUCCESSOR };
+
+test('PreCompact: Aiterm の席の会話は引き継がない。圧縮を止めず、記録も残さない', () => withDir(dir => {
+  for (const env of [SEAT, { ...SEAT, CLAUDE_CODE_ENTRYPOINT: 'cli' }]) {
+    const { result, db } = request(dir, { env });
+    assert.deepEqual([result.status, result.block, result.reason], ['skipped', false, 'aiterm_seat']);
+    assert.equal(db.prepare('SELECT COUNT(*) AS c FROM handoff_batons').get().c, 0);
+    assert.deepEqual(listClaudeAutoHandoffs({ dir }), []);
+  }
+  // 自動継続が無効な端末の席は、今までどおり「無効」で終わる
+  assert.equal(request(dir, { env: SEAT, config: { enabled: false, projects: [] } }).result.reason, 'auto_handoff_disabled');
+  // 席の印を継いだ別の会話と、会話 ID を出さない版の Aiterm の席は、今までどおり引き継ぐ
+  for (const env of [SEAT_DESCENDANT, { AITERM_AGENT_LAUNCH_ID: 'abc', AITERM_AGENT_KIND: 'claude' }]) {
+    assert.equal(request(dir, { env }).result.status, 'requested');
+    rmSync(join(dir, `${SESSION}.json`));
+  }
+}));
+
+test('PreCompact: 席の会話に残っていた、後継を立てる前の記録は取り下げる。後継を立てた後の記録は保つ', () => withDir(dir => {
+  // 席を外す前の版（か、会話 ID を出さない版の Aiterm の時）に予約した記録
+  assert.equal(request(dir).result.status, 'requested');
+  writeFileSync(join(dir, `${SESSION}.claim`), '');
+  const withdrawn = request(dir, { env: SEAT }).result;
+  assert.deepEqual([withdrawn.status, withdrawn.block, withdrawn.reason], ['skipped', false, 'aiterm_seat']);
+  assert.equal(readClaudeAutoHandoff(SESSION, dir), null);
+  assert.equal(existsSync(join(dir, `${SESSION}.claim`)), false);
+
+  // もう後継へ引き継いだ席の会話は、今までどおり圧縮させない（続きは後継にある）
+  const { result } = request(dir);
+  const path = join(dir, `${SESSION}.json`);
+  writeFileSync(path, JSON.stringify({ ...JSON.parse(readFileSync(path, 'utf8')), state: 'sent',
+    successor: { short_id: SUCCESSOR.slice(0, 8), session_id: SUCCESSOR } }));
+  const kept = request(dir, { env: SEAT }).result;
+  assert.deepEqual([kept.status, kept.block, kept.handoffId], ['already_requested', true, result.handoffId]);
+  assert.equal(readClaudeAutoHandoff(SESSION, dir).state, 'sent');
+}));
+
+test('PreToolUse: 席の会話は止めない。後継を立てる前の記録は取り下げ、道具を通す', () => withDir(async dir => {
+  const payload = { session_id: SESSION, cwd: '/work/app', tool_name: 'Read', tool_use_id: 'toolu_2' };
+  const launched = [];
+  const launchWorker = async sessionId => { launched.push(sessionId); };
+
+  for (const state of ['requested', 'failed']) {
+    request(dir);
+    const path = join(dir, `${SESSION}.json`);
+    writeFileSync(path, JSON.stringify({ ...JSON.parse(readFileSync(path, 'utf8')), state }));
+    writeFileSync(join(dir, `${SESSION}.claim`), '');
+    assert.equal(await stopClaudeTurnForHandoff({ payload, dir, launchWorker, env: SEAT }), null, state);
+    assert.equal(readClaudeAutoHandoff(SESSION, dir), null, state);
+    assert.equal(existsSync(join(dir, `${SESSION}.claim`)), false, state);
+  }
+  assert.deepEqual(launched, [], '後継は立てない');
+
+  // 席の印を継いだ別の会話は、今までどおり止めて後継を立てる
+  request(dir);
+  const child = await stopClaudeTurnForHandoff({ payload, dir, launchWorker, env: SEAT_DESCENDANT });
+  assert.equal(child.continue, false);
+  assert.deepEqual(launched, [SESSION]);
+
+  // もう後継へ引き継いだ席の会話の道具は、今までどおり止めて後継を案内する
+  const path = join(dir, `${SESSION}.json`);
+  writeFileSync(path, JSON.stringify({ ...JSON.parse(readFileSync(path, 'utf8')), state: 'sent',
+    successor: { short_id: SUCCESSOR.slice(0, 8), session_id: SUCCESSOR } }));
+  const stopped = await stopClaudeTurnForHandoff({ payload, dir, launchWorker, env: SEAT });
+  assert.equal(stopped.continue, false);
+  assert.match(stopped.stopReason, new RegExp(`claude attach ${SUCCESSOR.slice(0, 8)}`));
+}));
+
 test('PreCompact: 手動の/compactは止める前の記録を取り下げ、subagentの圧縮は親の記録に触らない', () => withDir(dir => {
   request(dir);
   assert.equal(request(dir, { payload: { trigger: 'auto', agent_id: 'agent-1' } }).result.reason, 'subagent_compact');
@@ -1455,6 +1543,36 @@ test('hook: 自動継続が無効な時、自動圧縮を止めず、何も残
   assert.equal(existsSync(join(home, '.throughline', 'throughline.db')), false, '無効な時は DB も開かない');
 }));
 
+test('hook: Aiterm の席の会話は、自動継続が有効でも自動圧縮を止めず、道具も止めない', () => withDir(home => {
+  const project = join(home, 'project');
+  mkdirSync(project, { recursive: true });
+  const seat = { AITERM_AGENT_LAUNCH_ID: '4c83fc1dd27459a9', AITERM_AGENT_KIND: 'claude', AITERM_SESSION_ID: 'seat-1',
+    AITERM_AGENT_VENDOR_SESSION_ID: SESSION };
+  const payload = { session_id: SESSION, cwd: project, transcript_path: join(home, 'transcript.jsonl') };
+  assert.equal(cli(home, ['auto-handoff', 'enable', '--host', 'claude', '--json']).status, 0);
+
+  const pre = cli(home, ['pre-compact'], JSON.stringify({ ...payload, hook_event_name: 'PreCompact', trigger: 'auto' }), seat);
+  assert.deepEqual([pre.status, pre.stdout, pre.stderr], [0, '', '']);
+  const tool = cli(home, ['pre-tool-use'], JSON.stringify({ ...payload, hook_event_name: 'PreToolUse', tool_name: 'Read', tool_use_id: 'toolu_1' }), seat);
+  assert.deepEqual([tool.status, tool.stdout, tool.stderr], [0, '', '']);
+  assert.deepEqual(JSON.parse(cli(home, ['auto-handoff', 'status', '--host', 'claude', '--json']).stdout).handoffs, []);
+  const decisions = readFileSync(join(home, '.throughline', 'logs', 'inheritance-decision.log'), 'utf8').trim().split('\n').map(line => JSON.parse(line));
+  assert.deepEqual(decisions.filter(entry => entry.phase === 'pre-compact').map(entry => [entry.auto_continuation, entry.skip_reason]),
+    [['skipped', 'aiterm_seat']]);
+
+  // 席の印を継いだだけの別の会話（会話 ID が違う）と、印の無い会話は、今までどおり止める
+  const OTHER = 'cccccccc-1111-4222-8333-444444444444';
+  const descendant = cli(home, ['pre-compact'], JSON.stringify({ ...payload, session_id: OTHER, hook_event_name: 'PreCompact', trigger: 'auto' }), seat);
+  assert.equal(descendant.status, 2);
+  assert.equal(cli(home, ['pre-compact'], JSON.stringify({ ...payload, hook_event_name: 'PreCompact', trigger: 'manual', session_id: OTHER }), seat).status, 0);
+  const plain = cli(home, ['pre-compact'], JSON.stringify({ ...payload, hook_event_name: 'PreCompact', trigger: 'auto' }));
+  assert.equal(plain.status, 2);
+  // その記録が残った席の会話（席を外す前の版が予約した形）は、次の道具で取り下げる
+  const next = cli(home, ['pre-tool-use'], JSON.stringify({ ...payload, hook_event_name: 'PreToolUse', tool_name: 'Read', tool_use_id: 'toolu_2' }), seat);
+  assert.deepEqual([next.status, next.stdout], [0, '']);
+  assert.deepEqual(JSON.parse(cli(home, ['auto-handoff', 'status', '--host', 'claude', '--json']).stdout).handoffs, []);
+}));
+
 test('hook: 自分の失敗では圧縮も道具も止めず（exit code 1）、理由を端末に残す', () => withDir(home => {
   const compact = cli(home, ['pre-compact'], '{"trigger":"auto"}');
   assert.deepEqual([compact.status, compact.stdout], [1, '']);

package/src/claude-pre-compact.mjs

@@ -8,7 +8,8 @@
  * 圧縮を止める。Claude Code は PreCompact の exit code 2 を「圧縮を止める」と解釈する。
  * 止めた後の会話は圧縮されないまま続き、次の道具の hook（PreToolUse）が作業を止める。
  *
- * 手動の /compact、無効な project、subagent の中の圧縮では、何も止めずに exit code 0 で終わる。
+ * 手動の /compact、無効な project、subagent の中の圧縮、Aiterm が起こした席の会話（ADR 0057）では、何も止めずに
+ * exit code 0 で終わる。
  * この hook 自身が失敗した時は exit code 1 で終わり、圧縮は止めない。
  */
 

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');