throughline 0.16.25 → 0.16.26

package/CHANGELOG.md

@@ -10,6 +10,37 @@ 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
 
 ### 修正
@@ -2461,7 +2492,8 @@ 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.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

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/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.25",
+  "version": "0.16.26",
   "type": "module",
   "description": "Persistent memory hooks for Claude Code, Codex, Grok, and Cursor (/clear-safe context compression)",
   "keywords": [

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