throughline 0.16.28 → 0.16.30

package/CHANGELOG.md

@@ -10,6 +10,37 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.16.30] — 2026-10-14
+
+### 修正
+
+- **Codexのゴール（`/goal`）で動くタスクで、Codexが自分で入れる続行の指示が、利用者の発言として会話の記録（L2）に残っていた**（[ADR 0061](docs/adr/0061-codex-internal-context-is-compacted-in-memory.md)）。続行のターンの入力は、`<codex_internal_context source="goal">`で始まる約6,300字の定型文で、利用者の発言としてrolloutに入る。Windowsの実機のタスクでは、利用者の発言15行のうち7行がこれで、字数の87%を占めていた。引き継ぎの記憶に入る直近のターンが同じ定型文で埋まり、利用者が打った依頼が押し出される形だった。
+  - 直した後は、開く印（`source`つき）・利用者が決めたゴールの文（`<objective>`）・閉じる印だけを残し、定型文を落とす。ターンは落とさない。
+  - 閉じる印が無い物と、発言の途中に印がある物は、触らない。
+
+### 変わる動き
+
+- ゴールで動くCodexのタスクで、続行のターンの利用者の発言が短い行になる。前の版が保存した長い行は、そのタスクの次の取り込みで置き換わる。
+- Claude Code・Grok・Cursorの記録の読み方は変えていない。
+
+## [0.16.29] — 2026-10-14
+
+### 修正
+
+- **Claude Codeで、作業中に届いた入力が、会話の記録（L2）に残っていなかった**（[ADR 0060](docs/adr/0060-claude-mid-turn-input-and-host-meta-rows.md)）。Claude Codeは、ターンが動いている間に届いた入力を、user行ではなく`attachment`の`queued_command`で書く。この製品はその行を読んでいなかった。Linuxの実機の4日ぶんの記録で、人の入力のuser行1,402に対して、途中で届いた人の入力は833通あり、記録に入っていたのは3通だった。
+  - 直した後は、途中で届いた入力を、届いた先のターンの依頼へ、届いた順に足す。前に見出しの1行（`（作業の途中で届いた入力）`）を置く。人が打った文と、別の会話から届いた発言が当たる。裏の作業の完了通知は足さない。
+  - 引き継ぎの記憶と、自動継続で後継へ運ぶ依頼にも入る。
+- **Claude Codeがskillを読んだ時などに書く行を、利用者の発言として記録していた**（同じADR）。`isMeta: true`で`origin`の無いuser行。この行でターンを区切っていたので、その前に本文が無いと、元の依頼が記録から消え、skillの本文が利用者の発言として残った。道具の入出力（L3）も、その行より前の分が入らなかった。自動継続で止めたターンでは、後継へ運ぶ依頼がskillの本文になっていた。
+  - 直した後は、この行をターンの始まりにも本文にもしない。別の会話から届いた発言（`origin`を持つ）は、今までどおり。
+- **Claude Codeで、ターンの終わりに待ち入力が2通以上続けて届いた時、最後の1通だけが記録されていた**（同じADR）。同じ番へ続けて届いたuser行（`turnPosition.promptIndex`が同じ）を、1つの依頼にまとめる。
+
+### 変わる動き
+
+- Claude Codeの会話で、利用者の発言の行に、作業中に届いた入力が見出しつきで足される。見出しの1行は、この製品が足した文。
+- skillの本文は、利用者の発言として記録されなくなる。道具の入出力には残る。
+- 前の版が記録したターンは書き直さない。直しが効くのは、この版が取り込むターンから。行の番号は変わらないので、前の版の行と重なって増える事は無い。
+- Codex・Grok・Cursorの記録の読み方は変えていない。
+
 ## [0.16.28] — 2026-10-14
 
 ### 修正
@@ -2558,7 +2589,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.28...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.16.30...HEAD
+[0.16.30]: https://github.com/kitepon/Throughline/compare/v0.16.29...v0.16.30
+[0.16.29]: https://github.com/kitepon/Throughline/compare/v0.16.28...v0.16.29
 [0.16.28]: https://github.com/kitepon/Throughline/compare/v0.16.27...v0.16.28
 [0.16.27]: https://github.com/kitepon/Throughline/compare/v0.16.26...v0.16.27
 [0.16.26]: https://github.com/kitepon/Throughline/compare/v0.16.25...v0.16.26

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

@@ -56,3 +56,9 @@ turn の間に入力が2通たまり、turn が終わった時に2通が続け
   本物の hook の命令（`process-turn`）へ、合成した transcript を通した（切り離した HOME）。
 - 確かめていない: 本物の Claude Code が、待っていた入力を2通続けて書く場面での、この版の動き。狙って起こすには、
   動いている turn の間に入力を2通ためる必要がある。次に起きた時は、失敗が記録されない事で分かる。
+
+## 追記（2026-10-14、ADR 0060）
+
+Context の「保存の欠けは無い」は、完了した turn の事だった。続けて届いた入力の1通目は、assistant 断片の無い group として
+保存されていなかった（コンテナの本物の transcript で 5 回）。ADR 0060 で、同じ `turnPosition.promptIndex` で続けて届いた
+user 行を1つの依頼にまとめる様にした。assistant 断片の無い group を飛ばす作りは、そのまま残している。

package/docs/adr/0060-claude-mid-turn-input-and-host-meta-rows.md

@@ -0,0 +1,123 @@
+# ADR 0060: Claude Code の、ターンの途中で届いた入力は依頼へ足し、host が書く meta の行ではターンを区切らない
+
+- Status: Accepted
+- Date: 2026-10-14
+
+## Context
+
+Claude Code の transcript から L2（`bodies`）を作る時、この製品は「本文を持つ user 行1つ + それに続く assistant の本文」を
+1つのターンとして読んでいた（`getLogicalTurnGroups`）。user 行なら何でもターンの始まりにし、`attachment` の行は L3 にだけ使っていた。
+
+2026-10-14、BellTeam のコンテナ（Linux、Claude Code 2.1.293・2.1.296、この製品は 0.16.27）の本物の transcript で、
+人の入力が L2 に入っていない形が3つ見つかった（本文は読んでいない。行の種類・印・長さ・時刻だけ）。
+
+### 1. ターンの途中で届いた入力
+
+Claude Code は、ターンが動いている間に届いた入力を、user 行ではなく `attachment` の行で書く。
+
+```text
+{"type":"attachment","attachment":{"type":"queued_command","prompt":…,"commandMode":"prompt","origin":{"kind":"human"},"humanTurn":true,…}}
+```
+
+`prompt` は文字列か、text と image の block の配列。裏の作業の完了通知も同じ形で届く（`commandMode: "task-notification"`、
+`origin.kind: "task-notification"`）。前後に `queue-operation` の `enqueue` と `remove` の行が並ぶ。ターンが終わるまで
+届けられなかった入力は、`dequeue` の後に普通の user 行になる（`promptSource: "queued"`）。
+
+10/10 からの 163 本で、人の入力の `queued_command` は 833 通あった（人の入力の user 行は 1,402）。L2 に入っていたのは 3 通
+（同じ文が別の行にもあった物）。作業中に打った文、ほかの席から差し込まれた文が、記憶に残っていなかった。
+
+### 2. host が書く meta の user 行
+
+Claude Code は、skill を読んだ時の本文や、端末で打った命令の注意書きを、`isMeta: true` の user 行で書く。`origin` は無い。
+skill の行は、直後に `attachment` の `command_permissions` が続く。
+
+この行をターンの始まりにしていたので、次の事が起きていた。
+
+- その行より前に assistant の本文が無いと、元の依頼は「本文の無い群」になって保存されない。meta の行の本文
+  （skill の手順）が、利用者の発言として保存される。
+- 本文があると、1つのターンが2つに割れる。
+- L3 は「最後の user 本文の行」から切り出すので、meta の行より前の道具の入出力が入らない。
+- 自動継続で止めたターンの依頼（`snapshotInFlight`）も「最後の user 本文」を読むので、後継へ運ぶ依頼が skill の本文になる。
+
+同じ 163 本で、`origin` の無い meta の行は 61 行（道具の後 27、人の入力の直後 11、meta の行の後 17、端末の命令の注意書き 6）。
+46 行が利用者の発言として L2 の群に入っていた。
+
+別の会話から届いた発言も `isMeta: true` だが、`origin.kind: "peer"` を持つ。届いた入力なので、今までどおりターンの始まりにする。
+
+### 3. ターンの終わりに続けて届いた待ち入力
+
+ターンの間に入力が2通以上たまると、ターンが終わった時に、2通が続けて user 行になる。2行とも `promptSource: "queued"` で、
+同じ `turnPosition.promptIndex` を持つ（同じ番へ届いた印）。
+
+1通目は「assistant の本文が無い群」になり、保存されなかった。ADR 0055 は、この形で Stop が失敗する事を直した時に
+「保存の欠けは無い」と書いたが、欠けていたのは完了したターンではなく、1通目の入力だった。同じ 163 本で 5 回。
+
+### ほかの host
+
+- Codex: ターンを host の開始と完了の印（`task_started`・`task_complete`）で区切り、その間の利用者の発言を全部持つ
+  （`codex-rollout-memory.mjs`）。同じ欠けは起きない作り。
+- Grok: `chat_history.jsonl` に、途中で届いた入力を表す別の行は見つからなかった（80 本）。人の入力の行が本文を挟まずに
+  続く形は 9 回あり、`prompt_index` は違っていた。止められたターンか、途中の入力かは分けていない。この ADR では扱わない。
+- Cursor: 10 本を見て、同じ形の行は無かった。
+
+## Decision
+
+1. **ターンの途中で届いた入力は、届いた先のターンの依頼へ、届いた順に足す。** `attachment` の `queued_command` で、
+   `origin.kind` が `human` か `peer` の物。直前に返した user の行の本文の後ろへ、空行・見出しの1行
+   （`（作業の途中で届いた入力）`）・本文の順で足す。本文は user 行と同じ正規化を通す（端末の制御の除去、別の会話の注意書きの除去）。
+   - `turn_number` は進めない。`attachment` は今までも本文行に数えていない。保存済みの番号とずれない。
+   - 完了通知（`origin.kind: "task-notification"`）は足さない。そのターン自身の裏の作業の結果で、L3 に残っている。
+   - `origin` の無い物、`isSidechain: true` の物、足す先の user 行がまだ無い物は足さない。
+   - ターンの始まり方（`start`）は変えない。完了通知で始まったターンへ人の入力が届いても、`self` のまま。
+2. **`isMeta: true` で `origin.kind` の無い user 行は、ターンの始まりにも本文にもしない**（`isClaudeHostWrittenMetaEntry`）。
+   圧縮の要約行（ADR 0032）と同じ扱い。`turn_number` は進める（その行を数えていた頃に保存した番号とずれない）。
+   L3 の切り出し（`sliceCurrentTurnEntries`・`sliceInFlightTurnEntries`）も、この行で区切らない。
+3. **同じ番へ続けて届いた user 行は、1つの依頼にまとめる。** 直前の user 行との間に assistant の本文が無く、両方が
+   `origin.kind` を持ち、`turnPosition.promptIndex` が同じ整数の時。空行でつなぐ。`turn_number`・時刻・`start`・`prompt_id` は
+   1通目の物。`turn_number` は2通目の分も進める。
+   - `promptIndex` が違う行、印の無い行、`origin` の無い行（端末で打った命令）は、まとめない。止められて本文を書かなかった
+     ターンの依頼は、今までどおり保存されない。
+4. 判定は、host が transcript に書いた印（`type`・`isMeta`・`origin.kind`・`turnPosition`）だけで行う。本文は読まない。
+5. 保存済みのターンは書き直さない。直しが効くのは、この版が取り込むターンから。
+
+## Consequences
+
+- 作業中に打った文と、ほかの席から差し込まれた文が、そのターンの利用者の発言として L2 に残る。引き継ぎの記憶と、
+  自動継続で後継へ運ぶ依頼（`in_flight.user`）にも入る。
+- 利用者の発言の行が長くなる。見出しの1行は、この製品が足した文で、利用者の文ではない。
+- skill の本文は L2 に入らなくなる（L3 には `Skill` の道具の入出力として残る）。
+- 前の版が取り込んだ会話では、meta の行で割れていた2つの群が1つにまとまる。`backfillBodies` は「群の断片の番号が1つでも
+  保存済みなら回収しない」ので、行は増えない。前の版が落とした依頼と途中の入力は、さかのぼっては入らない。
+- Stop の flush barrier（ADR 0026・0055）は `readTranscript` の上で動く。続けて届いた待ち入力は1つの群になるので、
+  「本文の無い群を飛ばす」場面が減る。飛ばす作りは残す（`promptIndex` の無い版の Claude Code、止められたターン）。
+- `auditor-context` と `caveat-context` の鮮度の照合は、transcript の最後の群の依頼と、保存済みの行の hash を比べる。
+  前の版が取り込んだ最後のターンに途中の入力や meta の行があると、版を上げた直後の1回だけ合わない（次のターンからは合う）。
+- 途中の入力がターンの最後の本文より後に書かれた時も、そのターンの依頼へ足す。Stop の取り込みがもう済んでいれば、
+  その入力は L2 に入らない（保存済みの行は書き直さない）。実物では見ていない。
+
+## 確かめた事・確かめていない事
+
+- 確かめた:
+  - 単体試験（途中の入力の文字列と配列、完了通知・sidechain・印なしを足さない、別の会話からの文、足す先が無い時、meta の行、
+    `origin` を持つ meta の行、続けて届いた待ち入力、まとめない3つの形、L3 の切り出し、前の版が保存した行と重ねない事、
+    止めたターンの取り込み）。直す前の版では、形を表す5本が落ちる。
+  - 本物の transcript へ、前の版と直した版の読み手を当てて比べた（DB は開かない。数だけ）。3つの OS とも、assistant の行の番号は
+    全部同じで、直した版の代表の番号に、前の版に無い物は 0。
+
+    | | 本数 | 群 | 人の入力の user 行が群の依頼にある数 | 途中の人の入力が群の依頼にある数 | 利用者の発言になっていた meta の行 |
+    |---|---|---|---|---|---|
+    | Linux（コンテナ） | 163 | 1,661 → 1,634 | 1,385 → 1,401（1,402 のうち） | 3 → 832（833 のうち） | 46 → 0 |
+    | macOS | 103 | 1,265 → 1,246 | 905 → 910（926 のうち） | 0 → 121（122 のうち） | 36 → 0 |
+    | Windows | 108 | 922 → 899 | 324 → 335（369 のうち） | 2 → 111（119 のうち） | 51 → 0 |
+
+    入らなかった途中の入力は、3つの OS とも全部「依頼へは足されたが、そのターンに assistant の本文が無い」物だった
+    （止められたターン。完了したターンの回収には出ない）。
+  - 別の会話からの文（`origin.kind: "peer"`）が、ターンの途中に `queued_command` で届く実物は、Windows に 187 通あった
+    （`commandMode: "prompt"`。頭は地の文か `<cross-session-message>`）。同じ扱いで依頼へ足される。
+  - 本物の Stop の入口（`process-turn`）へ、本物の transcript の写しを、使い捨ての HOME で通した。空の DB から（Linux 3 本、
+    macOS 4 本、Windows 2 本）: 途中の人の入力の数だけ見出しが入り、2回目の Stop は 0 行。前の版で取り込んだ後に直した版で
+    通す（Linux 3 本、macOS 4 本、Windows 1 本）: 行は増えない。
+- 確かめていない:
+  - 直した版を入れた端末で、本物の Claude Code が、途中の入力のあるターンを終えた時の L2。入れた後の追跡で読む。
+  - `turnPosition` を書かない版の Claude Code。その時は 3 が効かず、今までと同じ動きになる。`origin` を書かない版の
+    `queued_command`（macOS と Windows の古い行にある）は、足さない。

package/docs/adr/0061-codex-internal-context-is-compacted-in-memory.md

@@ -0,0 +1,63 @@
+# ADR 0061: Codex が自分で起こしたターンの入力は、印とゴールの文だけを記憶に残す
+
+- Status: Accepted
+- Date: 2026-10-14
+
+## Context
+
+Codex は、ゴール（`/goal`）が実行中のタスクで、手すきになるたびに自分で次のターンを起こす（ADR 0059）。そのターンの入力は、
+rollout に user の発言（`response_item` の `message`、`role: "user"`）として入る。本文は `<codex_internal_context source="goal">` で
+始まり `</codex_internal_context>` で終わる。中身は、続け方の決まりを書いた定型文で、利用者が決めたゴールの文を
+`<objective>` … `</objective>` に持つ。Linux の実機の試験タスクで読んだ1通は 6,343 字で、ゴールの文はそのうち約 200 字だった。
+
+この製品は、user の発言から `# AGENTS.md instructions` と `<hook_prompt` で始まる物だけを外していた。ゴールの続行の入力は、
+利用者の発言としてそのまま L2 に入っていた。
+
+2026-10-13 の Windows の実機のタスクでは、L2 の user 15 行のうち 7 行がこの入力で（各 6,293 字）、user の字数の 87% を占めていた
+（行の数と長さだけを読んだ。本文は読んでいない）。ゴールで動かすタスクでは、引き継ぎの記憶に入る直近のターンの user の本文が、
+同じ定型文の繰り返しになる。記憶の字数の枠を定型文が使い、利用者が実際に打った依頼が押し出される。
+
+ゴールそのものは、ADR 0059 で、引き継ぎの時に後継へ運んでいる。記憶に定型文を残す理由は無い。
+
+## Decision
+
+1. user の発言が `<codex_internal_context` の開く印で始まり、閉じる印 `</codex_internal_context>` を持つ時、開く印（属性ごと）・
+   `<objective>` … `</objective>`（あれば）・閉じる印だけを残す（`compactCodexInternalContext`）。ほかの中身は落とす。
+   - 開く印の `source` は、何のターンかを表すので残す。
+   - ゴールの文は、利用者が決めた文なので残す。そのターンが何を目指して動いたかが、記憶から読める。
+   - 閉じる印の後ろに文があれば、残す。
+   - 閉じる印が無い時は、何も落とさない。形が分からない物を推測で切らない。
+   - 発言の途中に印がある物（頭に別の文がある物）は、触らない。
+2. ターンは落とさない。user の行は短い行として残る。ターンの番号の数え方は変えない。
+3. 同じ正規化を、user の発言を読む3か所（`event_msg` の `user_message`、`response_item` の `message`、圧縮で置き換わった履歴）に
+   通す。巻き戻しの照合は、3か所の本文を比べるので、揃えておく。
+4. 判定は印だけで行う。定型文の言い回しは読まない。Codex が定型文を変えても、印と `<objective>` が同じなら動く。
+
+## Consequences
+
+- ゴールで動くタスクの L2 で、続行のターンの user の行が、約 6,300 字から「印 + ゴールの文」になる。
+- Codex の取り込みは、タスクの bodies を毎回全部入れ直す。前の版が保存した長い行は、次の取り込みで短い行に置き換わる。
+  本文が変わったターンの L1 の要約は消えて、作り直される（今までの決まりのまま）。
+- 引き継ぎ済みの旧タスクは、取り込みが走らないので、前の版が保存した行のまま残る。
+- `<objective>` の中身は、Codex が書いた形のまま残る（`&lt;` などの置き換えを戻さない）。
+- Claude Code・Grok・Cursor には、この形の入力が無い。変えない。
+
+## 確かめた事・確かめていない事
+
+- 確かめた:
+  - 単体試験（定型文を落とす、後ろの文を残す、ゴールの文が無い形、閉じる印が無い・頭に無い・似た名前の印を触らない、
+    rollout を通した時の3つのターン）。
+  - 本物の rollout へ、前の版と直した版の読み手を当てて比べた（DB は開かない。数だけ）。3つの OS とも、ターンの数と行の数は同じで、
+    続行の入力でない user の行と assistant の行は1つも変わらない。
+
+    | | 続行の入力のある rollout | 続行の入力の行 | その字数 | 直した後の一番長い行 |
+    |---|---|---|---|---|
+    | Linux | 9 本（試験のタスク） | 17 → 17 | 107,635 → 5,491 | 323 字 |
+    | macOS | 9 本（本物 1 本と試験のタスク） | 21 → 21 | 132,486 → 6,248 | 536 字 |
+    | Windows | 7 本（本物 3 本と試験のタスク） | 2,069 → 2,069 | 13,020,355 → 579,482 | 691 字 |
+
+  - 取り込みの入口（`codex-capture`）へ、試験のタスクの rollout の写しを、使い捨ての HOME で、前の版 → 直した版 → 直した版の順に
+    通した（3つの OS）。前の版が入れた長い行（6,335〜6,567 字）が、直した版の取り込みで短い行（323〜557 字）に置き換わり、行の数と
+    details は変わらない。もう1回通しても同じ。
+- 確かめていない: `source` が `goal` 以外の `<codex_internal_context>`。実物を見ていない。同じ形（開く印と閉じる印）なら、
+  印だけが残る。直した版を入れた端末で、本物の Codex がゴールの続行のターンを終えた時の L2 は、入れた後の追跡で読む。

package/package.json

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

package/src/codex-rollout-memory.mjs

@@ -383,7 +383,7 @@ function compactedPayloadToUserMessages(payload, timestamp) {
     .map((item) => ({
       time: timestamp ?? null,
       role: 'user',
-      text: normalizeMessageText(messageContentToText(item.content)),
+      text: normalizeUserMessageText(messageContentToText(item.content)),
     }))
     .filter((message) => message.text.length > 0);
 }
@@ -485,7 +485,7 @@ function removeRolledBackTurns(activeTurns, count) {
 
 function eventPayloadToMemoryMessage(payload, timestamp) {
   if (payload.type === 'user_message') {
-    const text = normalizeMessageText(payload.message);
+    const text = normalizeUserMessageText(payload.message);
     if (!text || shouldSkipUserMessage(text)) return null;
     return {
       time: timestamp ?? null,
@@ -509,7 +509,8 @@ function eventPayloadToMemoryMessage(payload, timestamp) {
 
 function responseItemToConversationMessage(payload, timestamp) {
   if (payload?.type !== 'message' || !['user', 'assistant', 'developer'].includes(payload.role)) return null;
-  const text = normalizeMessageText(messageContentToText(payload.content));
+  const rawText = messageContentToText(payload.content);
+  const text = payload.role === 'user' ? normalizeUserMessageText(rawText) : normalizeMessageText(rawText);
   if (!text) return null;
   if (payload.role === 'developer' && !isThroughlineInjectedDeveloperMemory(text)) return null;
   if (payload.role === 'user' && shouldSkipUserMessage(text)) return null;
@@ -551,6 +552,35 @@ function normalizeMessageText(value) {
   return value.replace(/\s+/g, ' ').trim();
 }
 
+/** user の発言の正規化。空白をまとめた後、Codex が自分で書いた文脈の定型文を落とす (ADR 0061)。 */
+function normalizeUserMessageText(value) {
+  return compactCodexInternalContext(normalizeMessageText(value));
+}
+
+const CODEX_INTERNAL_CONTEXT_OPEN = /^<codex_internal_context(?:\s[^>]*)?>/;
+const CODEX_INTERNAL_CONTEXT_CLOSE = '</codex_internal_context>';
+const CODEX_INTERNAL_OBJECTIVE = /<objective>[\s\S]*?<\/objective>/;
+
+/**
+ * Codex が自分で起こしたターンの入力（ゴールの続行の指示など）は、`<codex_internal_context …>` で包まれて
+ * user の発言として rollout に入る。中身は毎回ほぼ同じ約 6,000 字の定型文で、人の発言ではない。記憶には、
+ * 開く印（`source` が何のターンかを表す）、利用者が決めたゴールの文（`<objective>`）、閉じる印だけを残す。
+ * 閉じる印の後ろに文があれば、それは残す。閉じる印が無い時は、形が分からないので何も落とさない。
+ * @param {string} text 空白をまとめた後の user の発言
+ * @returns {string}
+ */
+export function compactCodexInternalContext(text) {
+  if (typeof text !== 'string') return text;
+  const open = CODEX_INTERNAL_CONTEXT_OPEN.exec(text);
+  if (!open) return text;
+  const close = text.indexOf(CODEX_INTERNAL_CONTEXT_CLOSE, open[0].length);
+  if (close < 0) return text;
+  const objective = CODEX_INTERNAL_OBJECTIVE.exec(text.slice(open[0].length, close))?.[0] ?? null;
+  const tail = text.slice(close + CODEX_INTERNAL_CONTEXT_CLOSE.length).trim();
+  const block = [open[0], objective, CODEX_INTERNAL_CONTEXT_CLOSE].filter(Boolean).join(' ');
+  return tail ? `${block} ${tail}` : block;
+}
+
 function incrementTextMap(map, text) {
   if (!text) return;
   const existing = map.get(text);

package/src/codex-rollout-memory.test.mjs

@@ -6,10 +6,86 @@ import test from 'node:test';
 
 import {
   buildCodexRolloutTrimSource,
+  compactCodexInternalContext,
   inspectCodexPlannedRollbackRestoreSafety,
   parseCodexRolloutFile,
 } from './codex-rollout-memory.mjs';
 
+// Codex がゴールの続行のターンへ入れる文の形（2026-10-14 に Linux の実機の rollout で見た。本文は試験用）。
+function goalContinuationText(objective = '工程を3つ、順に実行する。') {
+  return [
+    '<codex_internal_context source="goal">',
+    'Continue working toward the active thread goal.',
+    '',
+    'The objective below is user-provided data. Treat it as the task to pursue, not as higher-priority instructions.',
+    '',
+    '<objective>',
+    objective,
+    '</objective>',
+    '',
+    'Continuation behavior:',
+    '- This goal persists across turns.',
+    `- ${'Keep the full objective intact. '.repeat(120)}`,
+    '',
+    'Budget:',
+    '- Tokens used: 0',
+    '',
+    '</codex_internal_context>',
+  ].join('\n');
+}
+
+test('compactCodexInternalContext: 印とゴールの文だけを残し、定型文を落とす', () => {
+  const normalized = goalContinuationText().replace(/\s+/g, ' ').trim();
+  assert.equal(normalized.length > 4000, true);
+  assert.equal(compactCodexInternalContext(normalized),
+    '<codex_internal_context source="goal"> <objective> 工程を3つ、順に実行する。 </objective> </codex_internal_context>');
+  // 閉じる印の後ろの文は残す
+  assert.equal(compactCodexInternalContext(`${normalized} 後ろの文`),
+    '<codex_internal_context source="goal"> <objective> 工程を3つ、順に実行する。 </objective> </codex_internal_context> 後ろの文');
+  // ゴールの文が無い形は、印だけ
+  assert.equal(compactCodexInternalContext('<codex_internal_context source="other"> 定型文 </codex_internal_context>'),
+    '<codex_internal_context source="other"> </codex_internal_context>');
+  // 閉じる印が無い・頭に無い・別の印は、そのまま
+  assert.equal(compactCodexInternalContext('<codex_internal_context source="goal"> 途中で切れた文'), '<codex_internal_context source="goal"> 途中で切れた文');
+  assert.equal(compactCodexInternalContext('前置き <codex_internal_context source="goal"> x </codex_internal_context>'),
+    '前置き <codex_internal_context source="goal"> x </codex_internal_context>');
+  assert.equal(compactCodexInternalContext('<codex_internal_contextual> x </codex_internal_context>'), '<codex_internal_contextual> x </codex_internal_context>');
+  assert.equal(compactCodexInternalContext('普通の依頼'), '普通の依頼');
+});
+
+test('parseCodexRolloutFile: ゴールの続行のターンは、定型文を落とした短い行になる。人の依頼と道具はそのまま', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-project-'));
+  try {
+    const goalItem = () => responseItem({ type: 'message', role: 'user', content: [{ type: 'input_text', text: goalContinuationText() }] });
+    const rollout = writeRollout(home, {
+      id: '019dfaba-f87e-7f41-a144-d5ca7c6dd7fa',
+      cwd: project,
+      events: [
+        event('user_message', { message: '最初の依頼' }),
+        event('task_started'),
+        event('agent_message', { message: '最初の回答' }),
+        event('task_complete'),
+        event('task_started'),
+        goalItem(),
+        event('agent_message', { message: 'ゴールの続きの報告' }),
+        event('task_complete'),
+        event('task_started'),
+        goalItem(),
+      ],
+    });
+    const parsed = parseCodexRolloutFile(rollout);
+    assert.deepEqual(parsed.activeTurns.map((turn) => turn.messages.map((message) => [message.role, message.text.length < 200 ? message.text : `long:${message.text.length}`])), [
+      [['user', '最初の依頼'], ['assistant', '最初の回答']],
+      [['user', '<codex_internal_context source="goal"> <objective> 工程を3つ、順に実行する。 </objective> </codex_internal_context>'], ['assistant', 'ゴールの続きの報告']],
+      [['user', '<codex_internal_context source="goal"> <objective> 工程を3つ、順に実行する。 </objective> </codex_internal_context>']],
+    ]);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
 test('parseCodexRolloutFile: applies rollback events before rendering active work', () => {
   const home = mkdtempSync(join(tmpdir(), 'tl-codex-home-'));
   const project = mkdtempSync(join(tmpdir(), 'tl-codex-project-'));

package/src/transcript-reader.mjs

@@ -5,7 +5,9 @@
  * 実際のフォーマット（確認済み）:
  *   {type: "user",      message: {role: "user",      content: [{type:"text", text:"..."}]}, ...}
  *   {type: "assistant", message: {role: "assistant", content: [{type:"text", text:"..."}, {type:"thinking", ...}]}, ...}
- *   他に queue-operation, attachment, file-history-snapshot 等があるが無視する
+ *   {type: "attachment", attachment: {type: "queued_command", prompt, origin: {kind}}, ...}
+ *     ターンの途中で届いた入力。届いた先のターンの依頼へ足す (ADR 0060)
+ *   他に queue-operation, file-history-snapshot, ほかの attachment 等があるが、本文としては無視する
  */
 
 import { readFileSync, existsSync } from 'fs';
@@ -34,6 +36,59 @@ export function isCompactSummaryEntry(entry) {
   return entry?.isCompactSummary === true;
 }
 
+/**
+ * Claude Code が自分で書く meta の user 行か（ADR 0060）。skill を読んだ時の本文、端末で打った命令の注意書きなど。
+ * type は user だが、人の発言でも、外から届いた入力でもない。ターンの始まりにも本文にもしない。
+ * 別の会話から届いた発言も `isMeta: true` だが、`origin.kind` を持つ。届いた入力なので、ここには入れない。
+ * @param {object} entry
+ */
+export function isClaudeHostWrittenMetaEntry(entry) {
+  return entry?.type === 'user'
+    && entry.message !== null && typeof entry.message === 'object'
+    && entry.isMeta === true
+    && typeof entry.origin?.kind !== 'string';
+}
+
+/** ターンの始まりにも本文にもしない user 行か。圧縮の要約（ADR 0032）と、host が書いた meta の行（ADR 0060）。 */
+function isHostWrittenClaudeUserEntry(entry) {
+  return isCompactSummaryEntry(entry) || isClaudeHostWrittenMetaEntry(entry);
+}
+
+// ターンの途中で届いた入力のうち、依頼へ足す物。人が打った文と、別の会話から届いた発言。
+// 裏の作業の完了通知（task-notification）は、そのターン自身の作業の結果なので足さない。
+const CLAUDE_MID_TURN_INPUT_ORIGINS = Object.freeze(['human', 'peer']);
+
+/** ターンの途中で届いた入力を、依頼の後ろへ足す時の見出し。記憶を読む側が、最初の依頼と見分けられる様にする。 */
+export const MID_TURN_INPUT_MARK = '（作業の途中で届いた入力）';
+
+/**
+ * Claude Code が、動いているターンへ届けた入力の本文（ADR 0060）。当たらない行は null。
+ * 手すきの時に届けば user 行になる入力が、ターンの途中では `attachment` の `queued_command` で書かれる。
+ * @param {object} entry transcript JSONL の 1 行
+ * @returns {string|null}
+ */
+function claudeMidTurnInputText(entry) {
+  if (entry?.type !== 'attachment' || entry.isSidechain === true) return null;
+  const attachment = entry.attachment;
+  if (attachment?.type !== 'queued_command') return null;
+  if (!CLAUDE_MID_TURN_INPUT_ORIGINS.includes(attachment.origin?.kind)) return null;
+  if (typeof attachment.prompt !== 'string' && !Array.isArray(attachment.prompt)) return null;
+  const text = normalizeTerminalText(compactClaudePeerMessage(extractText(attachment.prompt)));
+  return text ? text : null;
+}
+
+/**
+ * ターンの終わりに、待っていた入力が続けて user 行になった物か（ADR 0060）。Claude Code は、同じ番へ届けた
+ * user 行に同じ `turnPosition.promptIndex` を付ける。両方が `origin.kind` を持つ（届いた入力である）時だけ当たる。
+ */
+function isSameClaudePromptDelivery(previous, entry) {
+  const index = entry.turnPosition?.promptIndex;
+  return Number.isSafeInteger(index)
+    && previous?.promptIndex === index
+    && typeof entry.origin?.kind === 'string'
+    && previous.hasOrigin === true;
+}
+
 const GROK_HOST_WRITTEN_SYNTHETIC_REASONS = Object.freeze(['compaction_meta', 'system_reminder']);
 
 /**
@@ -72,9 +127,14 @@ export function readTranscript(transcriptPath) {
   const raw = readFileSync(transcriptPath, 'utf8');
 
   const turns = [];
-  // turn_number は transcript 内の本文行の通し番号。圧縮の要約行は返さないが番号は進める。
-  // 番号を詰めると、要約行を数えていた頃に保存した bodies の turn_number と食い違う。
+  // turn_number は transcript 内の本文行の通し番号。圧縮の要約行と host が書いた meta の行は返さないが、番号は進める。
+  // 番号を詰めると、その行を数えていた頃に保存した bodies の turn_number と食い違う。
   let position = 0;
+  // 直前に返した user の行。ターンの途中で届いた入力と、続けて届いた待ち入力を、この行の本文へ足す (ADR 0060)。
+  let currentUser = null;
+  // currentUser の後に assistant の本文が出たか。出た後の user 行は、次のターンの始まり。
+  let currentUserAnswered = false;
+  let currentUserDelivery = null;
   for (const line of raw.split('\n')) {
     const trimmed = line.trim();
     if (!trimmed) continue;
@@ -86,6 +146,13 @@ export function readTranscript(transcriptPath) {
       continue;
     }
 
+    // ターンの途中で届いた入力。本文行ではないので、番号は進めない。
+    const midTurnInput = claudeMidTurnInputText(entry);
+    if (midTurnInput !== null) {
+      if (currentUser) currentUser.content += `\n\n${MID_TURN_INPUT_MARK}\n${midTurnInput}`;
+      continue;
+    }
+
     // user / assistant エントリのみ対象。Claude は type、Cursor jsonl は role。
     const kind = entryKind(entry);
     if (kind !== 'user' && kind !== 'assistant') continue;
@@ -113,10 +180,18 @@ export function readTranscript(transcriptPath) {
     if (isCompactSummaryEntry(entry)) continue;
     // Grok の合成行も host が書いた行。番号は進める（数えていた頃に保存した turn_number と食い違わせない）。
     if (isGrokHostWrittenUserEntry(entry)) continue;
+    // Claude Code の meta の行も host が書いた行。ここで区切ると、その前の依頼が本文の無い群になって消える。
+    if (isClaudeHostWrittenMetaEntry(entry)) continue;
+
+    if (role === 'user' && currentUser && !currentUserAnswered && isSameClaudePromptDelivery(currentUserDelivery, entry)) {
+      // 待っていた入力が、同じ番へ続けて届いた。1つの依頼にまとめる。別の行にすると、手前の入力が本文の無い群になって消える。
+      currentUser.content += `\n\n${text}`;
+      continue;
+    }
 
     const ts = typeof entry.timestamp === 'string' ? Date.parse(entry.timestamp) : NaN;
     // grok chat_history.jsonl は Claude の message 包みを持たず type/content 直置き。
-    turns.push({
+    const turn = {
       role,
       content: text,
       turn_number: turnNumber,
@@ -128,7 +203,18 @@ export function readTranscript(transcriptPath) {
             prompt_id: typeof entry.promptId === 'string' ? entry.promptId : null,
           }
         : {}),
-    });
+    };
+    turns.push(turn);
+    if (role === 'user') {
+      currentUser = turn;
+      currentUserAnswered = false;
+      currentUserDelivery = {
+        promptIndex: entry.turnPosition?.promptIndex,
+        hasOrigin: typeof entry.origin?.kind === 'string',
+      };
+    } else {
+      currentUserAnswered = true;
+    }
   }
 
   return turns;
@@ -403,8 +489,8 @@ export function sliceCurrentTurnEntries(entries) {
   for (let i = lastAssistantTextIdx - 1; i >= 0; i--) {
     const e = entries[i];
     if (entryKind(e) !== 'user') continue;
-    // 圧縮の要約行はターンの始まりではない。圧縮より前の tool 入出力も同じターンに含める。
-    if (isCompactSummaryEntry(e)) continue;
+    // 圧縮の要約行と host が書いた meta の行は、ターンの始まりではない。その前の tool 入出力も同じターンに含める。
+    if (isHostWrittenClaudeUserEntry(e)) continue;
     const blocks = e.message?.content;
     if (Array.isArray(blocks)) {
       if (blocks.some((b) => b && b.type === 'text' && typeof b.text === 'string' && b.text.length > 0)) {
@@ -433,7 +519,7 @@ export function sliceCurrentTurnEntries(entries) {
 export function sliceInFlightTurnEntries(entries) {
   for (let i = entries.length - 1; i >= 0; i--) {
     const e = entries[i];
-    if (entryKind(e) !== 'user' || isCompactSummaryEntry(e)) continue;
+    if (entryKind(e) !== 'user' || isHostWrittenClaudeUserEntry(e)) continue;
     const blocks = e.message?.content;
     const hasText = Array.isArray(blocks)
       ? blocks.some((b) => b && b.type === 'text' && typeof b.text === 'string' && b.text.length > 0)

package/src/transcript-reader.test.mjs

@@ -552,3 +552,162 @@ test('sliceInFlightTurnEntries: 最後の user 本文から末尾まで。最後
   assert.deepEqual(sliceInFlightTurnEntries([entries[1]]), []);
 });
 
+
+// --- ADR 0060: Claude Code の、ターンの途中で届いた入力・host が書く meta の行・続けて届いた待ち入力 ---
+
+function humanEntry(text, extra = {}) {
+  return { type: 'user', origin: { kind: 'human' }, promptSource: 'typed', message: { role: 'user', content: text }, ...extra };
+}
+function queuedCommandEntry(prompt, extra = {}) {
+  return {
+    type: 'attachment',
+    attachment: { type: 'queued_command', prompt, commandMode: 'prompt', origin: { kind: 'human' }, humanTurn: true, ...extra },
+  };
+}
+/** skill を読んだ時などに Claude Code が書く行。origin が無い。 */
+function hostMetaEntry(text) {
+  return { type: 'user', isMeta: true, message: { role: 'user', content: [{ type: 'text', text }] } };
+}
+
+test('readTranscript: ターンの途中で届いた人の入力は、そのターンの依頼へ届いた順に足す。番号は進めない', () => {
+  const path = writeTranscript([
+    humanEntry('最初の依頼'),
+    asstToolUseEntry('toolu_1', 'Read', { file_path: '/a' }),
+    queuedCommandEntry('途中の追加1'),
+    userToolResultEntry('toolu_1', 'ok'),
+    asstTextEntry('途中の報告'),
+    queuedCommandEntry([{ type: 'text', text: '途中の追加2' }, { type: 'image', source: {} }]),
+    asstTextEntry('最終回答'),
+    humanEntry('次の依頼'),
+    asstTextEntry('次の回答'),
+  ]);
+  const turns = readTranscript(path);
+  assert.deepEqual(turns.map((t) => [t.role, t.turn_number]), [
+    ['user', 0], ['assistant', 1], ['assistant', 2], ['user', 3], ['assistant', 4],
+  ]);
+  assert.equal(turns[0].content,
+    '最初の依頼\n\n（作業の途中で届いた入力）\n途中の追加1\n\n（作業の途中で届いた入力）\n途中の追加2');
+  assert.equal(turns[0].start, 'prompt');
+  assert.equal(turns[3].content, '次の依頼');
+  const groups = getLogicalTurnGroups(path);
+  assert.equal(groups[0].representative.index, 2);
+  assert.equal(groups[0].user.content.startsWith('最初の依頼\n\n（作業の途中で届いた入力）\n途中の追加1'), true);
+});
+
+test('readTranscript: 途中で届いた完了通知と、subagent の中の入力は依頼へ足さない。別の会話からの文は注意書きを落として足す', () => {
+  const path = writeTranscript([
+    humanEntry('依頼'),
+    queuedCommandEntry('<task-notification>\n<status>completed</status>\n</task-notification>',
+      { commandMode: 'task-notification', origin: { kind: 'task-notification' }, humanTurn: undefined }),
+    { ...queuedCommandEntry('subagent への入力'), isSidechain: true },
+    queuedCommandEntry('印の無い入力', { origin: undefined }),
+    queuedCommandEntry('Another Claude session sent a message:\n本文\n\nThis came from another Claude session, not a human.',
+      { origin: { kind: 'peer' } }),
+    asstTextEntry('回答'),
+  ]);
+  assert.equal(readTranscript(path)[0].content,
+    '依頼\n\n（作業の途中で届いた入力）\nAnother Claude session sent a message:\n本文');
+});
+
+test('readTranscript: 依頼より前に書かれた途中の入力は、足す先が無いので捨てる', () => {
+  const path = writeTranscript([queuedCommandEntry('宙に浮いた入力'), asstTextEntry('回答')]);
+  assert.deepEqual(readTranscript(path).map((t) => [t.role, t.content]), [['assistant', '回答']]);
+});
+
+test('readTranscript: host が書いた meta の行（origin なし）は返さず、ターンも区切らない。番号は詰めない', () => {
+  const path = writeTranscript([
+    humanEntry('依頼'),
+    asstToolUseEntry('toolu_1', 'Skill', { skill: 'x' }),
+    userToolResultEntry('toolu_1', 'Launching skill: x'),
+    hostMetaEntry('Base directory for this skill: /x\n\n手順…'),
+    asstTextEntry('最終回答'),
+  ]);
+  assert.deepEqual(readTranscript(path).map((t) => [t.role, t.content, t.turn_number]), [
+    ['user', '依頼', 0],
+    ['assistant', '最終回答', 2],
+  ]);
+  const groups = getLogicalTurnGroups(path);
+  assert.equal(groups.length, 1);
+  assert.equal(groups[0].user.content, '依頼');
+  assert.equal(groups[0].representative.index, 2);
+  assert.equal(readLatestUserGroup(path).user.content, '依頼');
+});
+
+test('readTranscript: origin を持つ meta の行（別の会話から届いた発言）は、今までどおりターンの始まり', () => {
+  const path = writeTranscript([
+    humanEntry('依頼'),
+    asstTextEntry('回答'),
+    { type: 'user', isMeta: true, origin: { kind: 'peer', from: 'x' },
+      message: { role: 'user', content: 'Another Claude session sent a message:\n本文\n\nThis came from another Claude session.' } },
+    asstTextEntry('返事'),
+  ]);
+  assert.deepEqual(getLogicalTurnGroups(path).map((g) => [g.user.content, g.user.start]), [
+    ['依頼', 'prompt'],
+    ['Another Claude session sent a message:\n本文', 'unknown'],
+  ]);
+});
+
+test('readTranscript: ターンの終わりに続けて届いた待ち入力（同じ promptIndex）は、1つの依頼にまとめる', () => {
+  const queued = (text, promptIndex, id) => humanEntry(text,
+    { promptSource: 'queued', promptId: id, turnPosition: { promptIndex, turnIndex: promptIndex } });
+  const path = writeTranscript([
+    humanEntry('前の依頼', { promptId: 'p0', turnPosition: { promptIndex: 8, turnIndex: 8 } }),
+    asstTextEntry('前の回答'),
+    queued('待っていた1通目', 9, 'p1'),
+    { type: 'attachment', attachment: { type: 'hook_success', hookEvent: 'UserPromptSubmit', content: '' } },
+    queued('待っていた2通目', 9, 'p2'),
+    asstTextEntry('回答'),
+    queued('別の番の入力', 10, 'p3'),
+    asstTextEntry('次の回答'),
+  ]);
+  const turns = readTranscript(path);
+  assert.deepEqual(turns.map((t) => [t.role, t.content, t.turn_number]), [
+    ['user', '前の依頼', 0],
+    ['assistant', '前の回答', 1],
+    ['user', '待っていた1通目\n\n待っていた2通目', 2],
+    ['assistant', '回答', 4],
+    ['user', '別の番の入力', 5],
+    ['assistant', '次の回答', 6],
+  ]);
+  assert.equal(turns[2].prompt_id, 'p1');
+  assert.equal(getLogicalTurnGroups(path)[1].representative.index, 4);
+});
+
+test('readTranscript: promptIndex が違う・印が無い・間に本文がある user 行は、まとめない', () => {
+  const at = (promptIndex) => ({ turnPosition: { promptIndex, turnIndex: promptIndex } });
+  assert.deepEqual(readTranscript(writeTranscript([
+    humanEntry('止められた依頼', at(1)), humanEntry('打ち直した依頼', at(2)), asstTextEntry('回答'),
+  ])).map((t) => t.content), ['止められた依頼', '打ち直した依頼', '回答']);
+  assert.deepEqual(readTranscript(writeTranscript([
+    userEntry('印の無い行'), userEntry('印の無い行2'), asstTextEntry('回答'),
+  ])).map((t) => t.content), ['印の無い行', '印の無い行2', '回答']);
+  // 端末で打った命令の行（origin なし）は、同じ promptIndex を持っていても人の入力とまとめない
+  assert.deepEqual(readTranscript(writeTranscript([
+    { type: 'user', message: { role: 'user', content: '<local-command-stdout>x</local-command-stdout>' }, ...at(3) },
+    humanEntry('依頼', at(3)), asstTextEntry('回答'),
+  ])).map((t) => t.content), ['<local-command-stdout>x</local-command-stdout>', '依頼', '回答']);
+});
+
+test('sliceCurrentTurnEntries / sliceInFlightTurnEntries: host が書いた meta の行で区切らず、その前の道具も同じターンに含める', () => {
+  const entries = [
+    humanEntry('前の依頼'),
+    asstTextEntry('前の回答'),
+    humanEntry('今の依頼'),
+    asstToolUseEntry('toolu_1', 'Read', { file_path: '/a' }),
+    userToolResultEntry('toolu_1', 'before skill'),
+    asstToolUseEntry('toolu_2', 'Skill', { skill: 'x' }),
+    userToolResultEntry('toolu_2', 'Launching skill: x'),
+    hostMetaEntry('skill の本文'),
+    asstToolUseEntry('toolu_3', 'Write', { file_path: '/b' }),
+    userToolResultEntry('toolu_3', 'after skill'),
+  ];
+  const inFlight = sliceInFlightTurnEntries(entries);
+  assert.equal(inFlight[0].message.content, '今の依頼');
+  assert.deepEqual(
+    extractDetailBlocks(inFlight).filter((d) => d.kind === DETAIL_KIND.TOOL_INPUT).map((d) => d.tool_name),
+    ['Read', 'Skill', 'Write'],
+  );
+  const done = sliceCurrentTurnEntries([...entries, asstTextEntry('最終回答')]);
+  assert.equal(done[0].message.content, '今の依頼');
+  assert.equal(done.length, 9);
+});

package/src/turn-backfill.test.mjs

@@ -504,3 +504,63 @@ test('captureInFlightTurn: 発言が1つも無いターンは、user の行と
   );
 });
 
+
+// --- ADR 0060: host が書いた meta の行でターンを区切っていた頃の行と、途中で届いた入力 ---
+
+test('backfillBodies: meta の行で区切っていた頃に保存したターンは、群がまとまっても重ねて入れない', () => {
+  const meta = { type: 'user', isMeta: true, message: { role: 'user', content: [{ type: 'text', text: 'skill の本文' }] } };
+  const human = (text) => entry('user', text, undefined, { origin: { kind: 'human' } });
+  const seeded = (turns) => {
+    const db = makeDb();
+    const insert = db.prepare(`INSERT INTO bodies (session_id, origin_session_id, turn_number, role, text, created_at) VALUES (?, ?, ?, ?, ?, 1)`);
+    for (const [turn, user] of turns) {
+      insert.run('target', 'origin', turn, 'user', user);
+      insert.run('target', 'origin', turn, 'assistant', 'saved');
+    }
+    return db;
+  };
+  const run = (db, entries) => withData(entries, (path) =>
+    backfillBodies(db, { targetSessionId: 'target', originSessionId: 'origin', transcriptPath: path, now: 999 }));
+
+  // 前の版: [依頼, 途中の報告] と [skill の本文, 最終回答] の2群。今の版: 1群（断片 1 と 3）。
+  const both = seeded([[1, '依頼'], [3, 'skill の本文']]);
+  const split = [human('依頼'), entry('assistant', '途中の報告'), meta, entry('assistant', '最終回答')];
+  assert.deepEqual(pick(run(both, split)), { groups: 1, insertedTurns: 0, skippedExisting: 1 });
+  assert.equal(both.prepare('SELECT COUNT(*) AS n FROM bodies').get().n, 4);
+
+  // 前の版: 依頼は本文の無い群で消え、[skill の本文, 最終回答] だけが入っていた。
+  const lost = seeded([[2, 'skill の本文']]);
+  assert.deepEqual(pick(run(lost, [human('依頼'), meta, entry('assistant', '最終回答')])),
+    { groups: 1, insertedTurns: 0, skippedExisting: 1 });
+
+  // 新しい会話では、依頼が user の行になる。
+  const fresh = makeDb();
+  assert.deepEqual(pick(run(fresh, [human('依頼'), meta, entry('assistant', '最終回答')])),
+    { groups: 1, insertedTurns: 1, skippedExisting: 0 });
+  assert.deepEqual(fresh.prepare('SELECT turn_number, role, text, turn_start FROM bodies ORDER BY role DESC').all().map((r) => ({ ...r })), [
+    { turn_number: 2, role: 'user', text: '依頼', turn_start: 'prompt' },
+    { turn_number: 2, role: 'assistant', text: '最終回答', turn_start: null },
+  ]);
+});
+
+function pick(result) {
+  return { groups: result.groups, insertedTurns: result.insertedTurns, skippedExisting: result.skippedExisting };
+}
+
+test('backfillBodies / captureInFlightTurn: ターンの途中で届いた入力は、依頼の行へ入る', () => {
+  const steer = (prompt) => ({ type: 'attachment', attachment: { type: 'queued_command', prompt, origin: { kind: 'human' } } });
+  const entries = [
+    entry('user', '依頼', undefined, { origin: { kind: 'human' } }),
+    steer('追加の指示'),
+    entry('assistant', '回答'),
+  ];
+  const done = makeDb();
+  withData(entries, (path) => backfillBodies(done, { targetSessionId: 'target', originSessionId: 'origin', transcriptPath: path, now: 999 }));
+  assert.equal(done.prepare(`SELECT text FROM bodies WHERE role = 'user'`).get().text, '依頼\n\n（作業の途中で届いた入力）\n追加の指示');
+
+  const stopped = makeDb();
+  stopped.exec(`CREATE TABLE details (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT, origin_session_id TEXT, turn_number INTEGER,
+    tool_name TEXT, input_text TEXT, output_text TEXT, token_count INTEGER, created_at INTEGER, kind TEXT, source_id TEXT)`);
+  withData(entries.slice(0, 2), (path) => captureInFlightTurn(stopped, { targetSessionId: 'target', originSessionId: 'origin', transcriptPath: path, now: 999 }));
+  assert.equal(stopped.prepare(`SELECT text FROM bodies WHERE role = 'user'`).get().text, '依頼\n\n（作業の途中で届いた入力）\n追加の指示');
+});