throughline 0.14.0 → 0.14.1

package/CHANGELOG.md

@@ -10,6 +10,26 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.14.1] — 2026-10-05
+
+### 修正
+
+- Claude Codeの自動継続で、後継が完了済みの作業をやり直すことがあった不具合を直す。0.14.0は、止めたターンについて「止める直前の発言」1つしか後継へ渡していなかった。そのターンでそこまでにした発言と道具の呼び出しは、記憶に入っていなかった。macOSの実機（Haiku 4.5）で、後継2つが読み終えたファイルを最初から読み直した。
+- Codexの自動継続と同じく、後継を立てる前に、止めたターンをDBへ取り込む。発言は全部をつないで本文（L2）に、道具の入出力は止めた道具の呼び出しまで詳細（L3）に入れる。後継は`throughline detail HH:MM:SS`で、止めたターンの入出力を取り出せる。0.14.0では、止めたターンの入出力はどこにも残らなかった。
+- 後継へ渡す現在地に、次の2つを足す。
+  - **このターンでここまでにしたこと**: 発言と道具の呼び出しを古い順に並べる。作業フォルダの中のファイルは相対で書く。多い時は新しい側から2,400字まで載せ、残りは件数にする。
+  - **止める直前に呼ぼうとして、実行されなかった道具**: 圧縮を止めた後の応答が呼んだ道具。同じ応答に並んだ道具は全部ここに入る。
+- 止めたターンは現在地にだけ載せ、直前の対話（L2）の一覧に重ねない。依頼の上限は4,000字から3,500字にする。
+
+### 追加
+
+- `throughline auto-handoff status --host claude --json`の各引き継ぎに`in_flight_captured`を足す。止めたターンをDBへ取り込めた時に`true`。取り込めなくても引き継ぎは止めず、依頼とここまでにしたことは後継へ渡る。
+
+### 確認した範囲
+
+- macOS 27.0のClaude Code。端末の会話（2.1.289）と、Claude Desktopが同梱する本体（2.1.286）を端末から起動した会話の両方から始めた。直した版で、Haiku 4.5は4回、Opus 5.5は7回、連続で引き継いで作業を完了した。読み直しも読み飛ばしも無く、どの会話でも自動圧縮は走っていない。
+- Claude Desktopの画面から始めた会話、Windows、Fable、subagentが動いている最中の引き継ぎは確かめていない。
+
 ## [0.14.0] — 2026-10-05
 
 ### 変更
@@ -1676,7 +1696,8 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.14.0...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.14.1...HEAD
+[0.14.1]: https://github.com/kitepon/Throughline/compare/v0.14.0...v0.14.1
 [0.14.0]: https://github.com/kitepon/Throughline/compare/v0.13.0...v0.14.0
 [0.13.0]: https://github.com/kitepon/Throughline/compare/v0.12.9...v0.13.0
 [0.12.9]: https://github.com/kitepon/Throughline/compare/v0.12.8...v0.12.9

package/README.ja.md

@@ -59,7 +59,7 @@ throughline auto-handoff disable --host claude
 1. 自動圧縮の直前に、圧縮を止めます。`/tl`と同じ印を残します。
 2. 旧い会話の次の道具を、実行させずに止めます。旧い会話は止めるだけで、空にしません。
 3. 同じprojectに、新しいClaudeの会話を裏で立てます（`claude --bg`）。モデル・推論強度・権限は旧い会話から引き継ぎます。
-4. 新しい会話へ継続の指示を1通送ります。届いた時に、止めた時点の依頼と直近の会話の原文を注入します（上限9,500字）。
+4. 新しい会話へ継続の指示を1通送ります。届いた時に、止めた時点の依頼、そのターンでここまでにしたこと（発言と道具の呼び出し）、実行されなかった道具、直近の会話の原文を注入します（上限9,500字）。止めたターンの道具の入出力は、後継が`throughline detail`で取り出せます。
 
 続きは裏の会話で動きます。`claude agents`の一覧と`claude attach <id>`で見られます。Claude Desktopの画面には出ず、後継のターンが終わって入力待ちになった後にDesktopで開けます。手動`/compact`、subagentの中の圧縮、`claude -p`などscriptから起動した会話は対象に含めません。
 
@@ -69,7 +69,7 @@ throughline auto-handoff status --host claude --operation <handoff-id> --json
 
 後継の立ち上げや配送に失敗した時は、固定の理由を記録して止まります。結果が不明な指示は再送しません。圧縮を止めた後にモデルが道具を呼ばずにターンを終えた時は、後継を立てません。印は残るので、1時間以内に開いた新しい会話が記憶を引き継ぎます。
 
-有効にした端末では、Claudeの道具の呼び出しのたびに`PreToolUse`フックが1回走ります。LinuxのClaude Code 2.1.289で実機確認済みです。macOS・Windows、Claude Desktopから始まる会話は未検証です。[実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-05-claude-auto-handoff.md)を参照してください。
+有効にした端末では、Claudeの道具の呼び出しのたびに`PreToolUse`フックが1回走ります。LinuxとmacOSのClaude Code（2.1.289、Claude Desktop同梱の2.1.286）で実機確認済みです。Windowsと、Claude Desktopの画面から始めた会話は未検証です。[実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-05-claude-auto-handoff.md)を参照してください。
 
 ## 所有境界
 

package/README.md

@@ -58,7 +58,7 @@ throughline auto-handoff disable --host claude
 1. 自動圧縮の直前に、圧縮を止めます。`/tl`と同じ印を残します。
 2. 旧い会話の次の道具を、実行させずに止めます。旧い会話は止めるだけで、空にしません。
 3. 同じprojectに、新しいClaudeの会話を裏で立てます（`claude --bg`）。モデル・推論強度・権限は旧い会話から引き継ぎます。
-4. 新しい会話へ継続の指示を1通送ります。届いた時に、止めた時点の依頼と直近の会話の原文を注入します（上限9,500字）。
+4. 新しい会話へ継続の指示を1通送ります。届いた時に、止めた時点の依頼、そのターンでここまでにしたこと（発言と道具の呼び出し）、実行されなかった道具、直近の会話の原文を注入します（上限9,500字）。止めたターンの道具の入出力は、後継が`throughline detail`で取り出せます。
 
 続きは裏の会話で動きます。`claude agents`の一覧と`claude attach <id>`で見られます。Claude Desktopの画面には出ず、後継のターンが終わって入力待ちになった後にDesktopで開けます。手動`/compact`、subagentの中の圧縮、`claude -p`などscriptから起動した会話は対象に含めません。
 
@@ -68,7 +68,7 @@ throughline auto-handoff status --host claude --operation <handoff-id> --json
 
 後継の立ち上げや配送に失敗した時は、固定の理由を記録して止まります。結果が不明な指示は再送しません。圧縮を止めた後にモデルが道具を呼ばずにターンを終えた時は、後継を立てません。印は残るので、1時間以内に開いた新しい会話が記憶を引き継ぎます。
 
-有効にした端末では、Claudeの道具の呼び出しのたびに`PreToolUse`フックが1回走ります。LinuxのClaude Code 2.1.289で実機確認済みです。macOS・Windows、Claude Desktopから始まる会話は未検証です。[実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-05-claude-auto-handoff.md)を参照してください。
+有効にした端末では、Claudeの道具の呼び出しのたびに`PreToolUse`フックが1回走ります。LinuxとmacOSのClaude Code（2.1.289、Claude Desktop同梱の2.1.286）で実機確認済みです。Windowsと、Claude Desktopの画面から始めた会話は未検証です。[実測と検証範囲](https://github.com/kitepon/Throughline/blob/main/evidence/2026-10-05-claude-auto-handoff.md)を参照してください。
 
 ## Ownership boundary
 

package/docs/adr/0033-claude-auto-handoff-new-session.md

@@ -15,6 +15,7 @@ Codex 版の各段に当たるものを、Claude Code 2.1.289 の公式文書と
 |---|---|---|
 | 圧縮の前に旧タスクを止める | `PreCompact` の exit code 2 で圧縮を止める。`PreToolUse` が `permissionDecision: "deny"` と `continue: false` を返すと、その道具は実行されずにターンが止まる | 実機 |
 | 新しいタスクを作る | `claude --bg`。指示を付けずに起動すると、指示を待つ会話が立つ（`idle — send a prompt to start`） | 実機 |
+| 止めたターンを取り込んでから記憶を作る | hook で止めたターンでは Stop hook が走らない。worker が、後継を立てる前に transcript から取り込む | 実機（0.14.1） |
 | 記憶を入れる | 最初の指示の `UserPromptSubmit` hook の出力。`/tl` の印（baton）の引き継ぎと同じ | 実機 |
 | 「続けて」を送る | 会話ごとの受け口（inbox socket）。配送ライブラリ `aiterm-steer-delivery` 0.1.13 の `sendClaudeInbox` | 実機 |
 
@@ -39,12 +40,23 @@ Claude Desktop の新しい会話は、画面を開いただけでは process
    `--settings '{"worktree":{"bgIsolation":"none"}}'` で同じ作業ツリーを編集させる。
    依頼と直前の発言は、止めた道具の呼び出しが transcript に書かれるのを待ってから読む（hook の時点では直前の発言が
    まだ書かれていないことがある）。
+   後継を立てる前に、**止めたターンを DB へ取り込む**（0.14.1。Codex の自動継続と同じ）。発言は全部をつないで
+   bodies の本文にし、道具の入出力は transcript の末尾（止めた道具の呼び出し）まで details に入れる。
+   完了したターンは最後の本文だけを残すが、止めたターンには結論の発言が無いので、全部を残す。
+   取り込めなくても引き継ぎは止めない。理由は worker のログに残り、状態の `in_flight_captured` が `false` になる。
 4. **継続の指示を1通送る**: 後継の `SessionStart` hook が、同じ project に立ち上げ中の引き継ぎがある時だけ、
    自分の受け口（`CLAUDE_CODE_MESSAGING_SOCKET` と token）を控える。worker はそれを読んで消し、
    `sendClaudeInbox` で継続の指示を1通送る。配送は公開 API だけを使い、Throughline の中に送信の実装を持たない。
    届いた時の `UserPromptSubmit` が baton を消費して前任を合流させ、記憶を注入する。
-   注入は ADR 0016 と同じ予算（9,500 字）で、ヘッダに作業ディレクトリ、現在地に止めた時点の依頼（4,000 字まで）と
-   直前の発言（1,500 字まで）、続けて案内と直近の L2 を載せる。宣言文は求めない。
+   注入は ADR 0016 と同じ予算（9,500 字）で、ヘッダに作業ディレクトリ、現在地、案内、直近の L2 の順に載せる。
+   宣言文は求めない。現在地は止めたターンで、次の順に載せる（0.14.1）。
+   - 止めた時点の依頼（3,500 字まで）。
+   - このターンでここまでにしたこと。発言と道具の呼び出し（名前と対象。失敗は印を付ける）を古い順に並べる。
+     新しい側から 2,400 字まで載せ、載せなかった古い側は件数にする。記録には直近 80 件までを持つ。
+   - 止める直前の発言（1,500 字まで）。一覧に同じ文がそのまま載っている時は重ねない。
+   - 止める直前に呼ぼうとして、実行されなかった道具。圧縮を止めた後の応答が呼んだ道具は、どれも実行されていない。
+     hook は並んで走るので、同じ応答（`message.id`）の道具をまとめて扱う。
+   止めたターンは現在地にだけ載せ、L2 の一覧には重ねない。そのターンの道具の入出力は `throughline detail` で取り出せる。
 5. **受領**: 継続の指示は引き継ぎ ID を含む。後継の最初の指示がその ID を含む時だけ、受領を記録する。
    `sendClaudeInbox` の結果が `accepted` なら `sent`、`not_sent` なら `failed`、`unknown` なら `unknown` にする。
    結果が不明な時は再送しない。後継が作業を進めたことまでは確かめない（オーナーの判断: 不要）。
@@ -71,8 +83,11 @@ Claude Desktop の新しい会話は、画面を開いただけでは process
 - 続きは裏の会話（agent view）で動く。`claude agents` の一覧と `claude attach <id>` で見られる。Claude Desktop の画面には
   出ず、後継のターンが終わって入力待ちになった後に Desktop で開ける。
 - `PreToolUse` hook は、有効な端末の全ての Claude の会話で、道具の呼び出しのたびに1回走る。
-- 止めたターンは Stop hook を通らない。本文は後継の最初の指示の時に回収するが、返事の本文が1つも無いまま止めた
-  ターンは bodies に入らず、依頼は現在地だけに載る。止めたターンの tool 入出力は L3 に入らない。
+- 止めたターンは Stop hook を通らない。worker が取り込む（0.14.1）。発言が1つも無いまま止めたターンは、
+  user の行と道具の入出力だけが入る。完了の受領（Stop が出すもの）は、止めたターンには出さない。
+- 0.14.0 は、止めたターンについて直前の発言1つだけを後継へ渡し、道具の入出力をどこにも残さなかった。
+  macOS の実機で、Haiku の後継が読み終えたファイルを最初から読み直した。Codex 版は止めたターンを取り込んでから
+  記憶を作っており、その段を写していなかった。
 - 圧縮が「文脈上限の error から回復するため」に起きた時は、止めると元の error でその要求が失敗する（公式文書）。
   この場合の後継の立ち上げは、次の道具の呼び出しまで起きない。
 - 別の会話から届いた発言（`Another Claude session sent a message:`）は、Claude Code が後ろに付ける定型の注意書きを
@@ -81,6 +96,9 @@ Claude Desktop の新しい会話は、画面を開いただけでは process
 
 ## 確認した範囲
 
-- Linux の Claude Code 2.1.289。対話画面の会話から始めて、後継へ3回連続で引き継ぎ、最後の後継が作業を完了した。
-  4つの会話のどれにも圧縮の記録は無く、止めた道具は実行されていなかった。
-- macOS・Windows、Claude Desktop から始まる会話、subagent が動いている最中の引き継ぎは確かめていない。
+- Linux の Claude Code 2.1.289。対話画面の会話から始めて、Haiku 4.5 で3回、Opus 5.5 で6回、連続で引き継ぎ、
+  最後の後継が作業を完了した（0.14.0）。0.14.1 でも Haiku 4.5 で確認した。
+- macOS 27.0。端末の会話（2.1.289）と、Claude Desktop が同梱する本体（2.1.286）を端末から起動した会話から始めた。
+  0.14.1 で、Haiku 4.5 は4回、Opus 5.5 は7回、連続で引き継いで完了した。読み直しも読み飛ばしも無い。
+- どの会話にも圧縮の記録は無く、止めた道具は実行されていなかった。
+- Claude Desktop の画面から始めた会話、Windows、Fable、subagent が動いている最中の引き継ぎは確かめていない。

package/package.json

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

package/src/claude-auto-handoff.mjs

@@ -7,7 +7,8 @@
  *   1. PreCompact (trigger=auto) : 圧縮を止め（exit code 2）、/tl と同じ印（baton）と引き継ぎの記録を残す。
  *   2. PreToolUse                : 記録がある会話の次の道具を、実行させずに止める（deny + continue:false）。
  *                                  止めた時点の依頼・設定を記録へ写し、後継を立てる worker を起動する。
- *   3. worker                    : `claude --bg` で、指示を待つ新しい会話を同じ project に立てる。
+ *   3. worker                    : 止めたターンを DB へ取り込み（発言の全部と道具の入出力）、ここまでにしたことを
+ *                                  記録へ写す。`claude --bg` で、指示を待つ新しい会話を同じ project に立てる。
  *   4. worker                    : 後継の SessionStart が残した受け口へ、配送ライブラリで継続の指示を1通送る。
  *                                  届いた時の UserPromptSubmit が baton を消費し、記憶を注入する。
  *
@@ -25,7 +26,15 @@ import { sendClaudeInbox } from 'aiterm-steer-delivery';
 import { readClaudeAutoHandoffConfig, claudeAutoHandoffEnabledFor } from './claude-auto-handoff-config.mjs';
 import { CLAUDE_HOST, hostOfSessionId } from './hosts/identity.mjs';
 import { claudeHostAdapter } from './hosts/claude.mjs';
-import { normalizeTerminalText, readLatestUserGroup, readRawEntries } from './transcript-reader.mjs';
+import {
+  isJunkAssistantText,
+  normalizeTerminalText,
+  readLatestUserGroup,
+  readRawEntries,
+  sliceInFlightTurnEntries,
+} from './transcript-reader.mjs';
+import { captureInFlightTurn } from './turn-backfill.mjs';
+import { resolveMergeTarget } from './session-merger.mjs';
 import { writeBaton } from './baton.mjs';
 import { sameProjectPath } from './project-path.mjs';
 import { spawnPortable, spawnPortableSync } from './os/portable-spawn-sync.mjs';
@@ -113,11 +122,13 @@ export function listClaudeAutoHandoffs({ dir = claudeAutoHandoffDir() } = {}) {
     .sort((a, b) => a.requested_at - b.requested_at);
 }
 
-/** 外へ見せる項目だけ。依頼の本文と受け口は含めない。 */
+/** 外へ見せる項目だけ。依頼の本文・発言・道具の対象と、受け口は含めない。 */
 export function publicClaudeAutoHandoff(record) {
   const { handoff_id, source_session_id, project_path, state, error_code, requested_at, updated_at, successor } = record;
   return { handoff_id, source_session_id, project_path, state, error_code: error_code ?? null,
     successor_session_id: successor?.session_id ?? null, successor_short_id: successor?.short_id ?? null,
+    // 止めたターンを DB へ取り込めたか。false の時、後継は `throughline detail` でそのターンの入出力を取れない。
+    in_flight_captured: Boolean(record.in_flight?.turn),
     requested_at, updated_at };
 }
 
@@ -227,24 +238,132 @@ function readLatestModel(transcriptPath) {
 
 const CONTINUATION_MARKER = /Throughline自動継続 ([0-9a-f-]{36})/;
 
+// 後継へ渡す「このターンでここまでにしたこと」。1件の長さと件数を抑える。全文は取り込んだ details にある。
+const STEP_TEXT_MAX_CHARS = 300;
+const STEP_TARGET_MAX_CHARS = 160;
+const STEPS_KEPT = 80;
+const STOPPED_TOOLS_KEPT = 10;
+// 道具の呼び出しを1行にする時に見せる入力。知らない道具は名前だけにする。
+const TOOL_TARGET_KEYS = ['file_path', 'notebook_path', 'path', 'command', 'pattern', 'url', 'description', 'query', 'prompt', 'skill'];
+
+function clipLine(text, maxChars) {
+  const line = String(text).replace(/\s+/g, ' ').trim();
+  return line.length <= maxChars ? line : `${line.slice(0, maxChars - 1)}…`;
+}
+
+const TOOL_PATH_KEYS = new Set(['file_path', 'notebook_path', 'path']);
+
+/** 作業ディレクトリの中の場所は相対で書く（後継の記憶のヘッダに作業ディレクトリがある）。長い場所は末尾を残す。 */
+function clipPath(value, projectPath) {
+  let line = value.trim();
+  if (projectPath && line.startsWith(projectPath) && /^[\\/]/.test(line.slice(projectPath.length))) {
+    line = line.slice(projectPath.length + 1);
+  }
+  return line.length <= STEP_TARGET_MAX_CHARS ? line : `…${line.slice(-(STEP_TARGET_MAX_CHARS - 1))}`;
+}
+
+function toolTarget(input, projectPath) {
+  if (!input || typeof input !== 'object') return '';
+  for (const key of TOOL_TARGET_KEYS) {
+    if (typeof input[key] !== 'string' || !input[key].trim()) continue;
+    return TOOL_PATH_KEYS.has(key) ? clipPath(input[key], projectPath) : clipLine(input[key], STEP_TARGET_MAX_CHARS);
+  }
+  return '';
+}
+
+/**
+ * 止めたターンで、止めるまでにした発言と道具の呼び出し（古い順）と、止めた道具。
+ *
+ * 圧縮を止めた後の応答が呼んだ道具は、どれも実行されていない（同じ応答に並んだ道具は全部止める）。
+ * hook が並んで走るので、記録に残る止めた道具の id は、応答の中の最初の道具とは限らない。
+ * 同じ応答（message.id）の道具を、まとめて「止めた道具」にする。
+ */
+function readInFlightSteps(transcriptPath, stoppedToolUseId, projectPath) {
+  const steps = [];
+  const toolById = new Map();
+  for (const entry of sliceInFlightTurnEntries(readRawEntries(transcriptPath)).slice(1)) {
+    const blocks = entry?.message?.content;
+    if (!Array.isArray(blocks)) continue;
+    if (entry.type === 'assistant') {
+      const at = typeof entry.timestamp === 'string' ? Date.parse(entry.timestamp) : NaN;
+      for (const block of blocks) {
+        if (block?.type === 'text' && typeof block.text === 'string' && block.text.trim() && !isJunkAssistantText(block.text)) {
+          steps.push({ kind: 'text', content: clipLine(block.text, STEP_TEXT_MAX_CHARS), timestamp: Number.isNaN(at) ? null : at });
+        } else if (block?.type === 'tool_use' && typeof block.id === 'string') {
+          const step = { kind: 'tool', id: block.id, response: entry.message.id ?? null, name: block.name ?? 'unknown',
+            target: toolTarget(block.input, projectPath), failed: false };
+          steps.push(step);
+          toolById.set(block.id, step);
+        }
+      }
+    } else if (entry.type === 'user') {
+      for (const block of blocks) {
+        if (block?.type === 'tool_result' && block.is_error === true && toolById.has(block.tool_use_id)) {
+          toolById.get(block.tool_use_id).failed = true;
+        }
+      }
+    }
+  }
+  const stopped = toolById.get(stoppedToolUseId);
+  const firstStopped = stopped
+    ? steps.findIndex(step => step.kind === 'tool' &&
+        (step.id === stopped.id || (stopped.response !== null && step.response === stopped.response)))
+    : -1;
+  const done = firstStopped < 0 ? steps : steps.slice(0, firstStopped);
+  const stoppedTools = firstStopped < 0 ? [] : steps.slice(firstStopped).filter(step => step.kind === 'tool');
+  const earlier = done.slice(0, Math.max(0, done.length - STEPS_KEPT));
+  const tools = {};
+  for (const step of earlier) if (step.kind === 'tool') tools[step.name] = (tools[step.name] ?? 0) + 1;
+  return {
+    steps: done.slice(earlier.length).map(step => step.kind === 'text'
+      ? { kind: 'text', content: step.content, timestamp: step.timestamp }
+      : { kind: 'tool', name: step.name, target: step.target, failed: step.failed }),
+    earlier_steps: earlier.length > 0 ? { texts: earlier.filter(step => step.kind === 'text').length, tools } : null,
+    stopped_tools: stoppedTools.slice(0, STOPPED_TOOLS_KEPT).map(step => ({ name: step.name, target: step.target })),
+    stopped_tools_total: stoppedTools.length,
+  };
+}
+
 /**
  * 止めた時点の作業途中のターン。後継の会話が止められた時は、最後の user 発言が前の引き継ぎの
  * 継続の指示になっている。その時は、前の引き継ぎが運んだ元の依頼を引き続き運ぶ。
+ * turn は、このターンを DB へ取り込んだ時の場所（worker が取り込みの後に入れる）。
  */
-function snapshotInFlight(transcriptPath, dir) {
-  const latest = readLatestUserGroup(transcriptPath);
+function snapshotInFlight(record, dir) {
+  const latest = readLatestUserGroup(record.transcript_path);
   if (!latest) return null;
-  const lastFragment = latest.fragments.at(-1) ?? null;
+  const lastFragment = latest.fragments.filter(fragment => !isJunkAssistantText(fragment.content)).at(-1) ?? null;
   const previousHandoffId = CONTINUATION_MARKER.exec(latest.user.content)?.[1];
   const carried = previousHandoffId
-    ? listClaudeAutoHandoffs({ dir }).find(record => record.handoff_id === previousHandoffId)?.in_flight?.user
+    ? listClaudeAutoHandoffs({ dir }).find(other => other.handoff_id === previousHandoffId)?.in_flight?.user
     : null;
   return {
     user: carried ?? { content: latest.user.content, timestamp: latest.user.timestamp },
     last_fragment: lastFragment ? { content: lastFragment.content, timestamp: lastFragment.timestamp } : null,
+    ...readInFlightSteps(record.transcript_path, record.stopped_tool_use_id, record.project_path),
+    turn: null,
   };
 }
 
+/**
+ * 止めたターンを DB へ取り込む (Codex の自動継続が、記憶を作る前に止めたターンを取り込むのと同じ)。
+ * 後継が前任を合流させる前に済ませる。取り込めなくても引き継ぎは止めない。依頼と、ここまでにしたことは
+ * 記録から後継へ渡る。取り込めなかった理由は worker のログに残り、記録の turn が null のままになる。
+ */
+function captureStoppedTurn(record, openDb) {
+  try {
+    const db = openDb();
+    const { target, origin } = resolveMergeTarget(db, record.source_session_id);
+    const captured = captureInFlightTurn(db, { targetSessionId: target, originSessionId: origin,
+      transcriptPath: record.transcript_path, now: Date.now() });
+    return captured && { origin_session_id: origin, turn_number: captured.turnNumber, user_at: captured.userAt,
+      assistant_at: captured.assistantAt, details: captured.details };
+  } catch (error) {
+    process.stderr.write(`[auto-handoff] in-flight turn capture failed: ${error instanceof Error ? error.message : 'unknown'}\n`);
+    return null;
+  }
+}
+
 /** 止めた道具の呼び出しが transcript に書かれるまで待つ。その前の発言が出そろった印になる。 */
 async function waitForStoppedToolUse(record, { timeoutMs, pollMs }) {
   if (!record.transcript_path || !record.stopped_tool_use_id) return;
@@ -426,6 +545,7 @@ export async function runClaudeAutoHandoffWorker(sessionId, {
   env = process.env,
   spawn = spawnPortableSync,
   send = sendClaudeInbox,
+  openDb = null,
   transcriptTimeoutMs = 5_000,
   targetTimeoutMs = 30_000,
   sendTimeoutMs = 30_000,
@@ -437,12 +557,15 @@ export async function runClaudeAutoHandoffWorker(sessionId, {
   const update = fields => { record = updateRecord(sessionId, fields, { dir }); return record; };
   const fail = code => update({ state: 'failed', error_code: code });
 
-  // 止めた時点の依頼と、その時のモデルを写す。後継の最初の指示が、この依頼を現在地として受け取る。
+  // 止めた時点の依頼・ここまでにしたこと・その時のモデルを写し、止めたターンを DB へ取り込む。
+  // 後継の最初の指示が、これを現在地として受け取る。
   await waitForStoppedToolUse(record, { timeoutMs: transcriptTimeoutMs, pollMs });
+  const inFlight = record.transcript_path ? snapshotInFlight(record, dir) : null;
+  if (inFlight && openDb) inFlight.turn = captureStoppedTurn(record, openDb);
   update({
     state: 'launching',
     settings: { ...record.settings, model: record.transcript_path ? readLatestModel(record.transcript_path) : null },
-    in_flight: record.transcript_path ? snapshotInFlight(record.transcript_path, dir) : null,
+    in_flight: inFlight,
   });
   const launched = spawn('claude', successorArgs(record), {
     cwd: record.project_path, env: successorEnv(env), encoding: 'utf8', timeout: 60_000, stdio: ['ignore', 'pipe', 'pipe'],

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

@@ -46,8 +46,8 @@ function makeBatonDb() {
 const user = (text, timestamp, extra = {}) => ({ type: 'user', timestamp, ...extra, message: { role: 'user', content: text } });
 const assistant = (text, timestamp, model = 'claude-fable-5-1') =>
   ({ type: 'assistant', timestamp, message: { role: 'assistant', model, content: [{ type: 'text', text }] } });
-const toolUse = (id, name) =>
-  ({ type: 'assistant', message: { role: 'assistant', model: 'claude-fable-5-1', content: [{ type: 'tool_use', id, name, input: {} }] } });
+const toolUse = (id, name, input = {}) =>
+  ({ type: 'assistant', message: { role: 'assistant', model: 'claude-fable-5-1', content: [{ type: 'tool_use', id, name, input }] } });
 const toolResult = (id, text) => ({ type: 'user', message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: id, content: text }] } });
 const jsonl = entries => entries.map(entry => JSON.stringify(entry)).join('\n') + '\n';
 
@@ -308,6 +308,14 @@ test('worker: 止めた時点の依頼とモデルを transcript から写し、
   assert.deepEqual(first.record.in_flight, {
     user: { content: '14個のファイルを順に読んで', timestamp: Date.parse('2026-10-04T03:00:10Z') },
     last_fragment: { content: 'part05 を読みました。次に part06 を読みます。', timestamp: Date.parse('2026-10-04T03:00:14Z') },
+    steps: [
+      { kind: 'text', content: 'part04 を読みました。', timestamp: Date.parse('2026-10-04T03:00:12Z') },
+      { kind: 'text', content: 'part05 を読みました。次に part06 を読みます。', timestamp: Date.parse('2026-10-04T03:00:14Z') },
+    ],
+    earlier_steps: null,
+    stopped_tools: [{ name: 'Read', target: '' }],
+    stopped_tools_total: 1,
+    turn: null,
   }, '止めた道具の直前の発言まで出そろってから写す');
 
   // 後継 B が止められた時、最後の user 発言は A からの継続の指示。現在地には元の依頼を運ぶ
@@ -323,9 +331,120 @@ test('worker: 止めた時点の依頼とモデルを transcript から写し、
   assert.deepEqual(second.record.in_flight, {
     user: { content: '14個のファイルを順に読んで', timestamp: Date.parse('2026-10-04T03:00:10Z') },
     last_fragment: { content: 'part09 を読みました。次に part10 を読みます。', timestamp: Date.parse('2026-10-04T03:01:20Z') },
+    steps: [{ kind: 'text', content: 'part09 を読みました。次に part10 を読みます。', timestamp: Date.parse('2026-10-04T03:01:20Z') }],
+    earlier_steps: null,
+    stopped_tools: [{ name: 'Read', target: '' }],
+    stopped_tools_total: 1,
+    turn: null,
   });
 }));
 
+function makeMemoryDb() {
+  const db = makeBatonDb();
+  db.exec(`
+    CREATE TABLE sessions (session_id TEXT PRIMARY KEY, merged_into TEXT);
+    CREATE TABLE bodies (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL, origin_session_id TEXT NOT NULL,
+      turn_number INTEGER NOT NULL, role TEXT NOT NULL, text TEXT NOT NULL, token_count INTEGER, created_at INTEGER NOT NULL,
+      turn_start TEXT, UNIQUE(session_id, origin_session_id, turn_number, role));
+    CREATE TABLE details (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL, origin_session_id TEXT,
+      turn_number INTEGER, tool_name TEXT NOT NULL, input_text TEXT, output_text TEXT, token_count INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL, kind TEXT, source_id TEXT);
+    CREATE UNIQUE INDEX uq_details_source ON details(session_id, origin_session_id, source_id) WHERE source_id IS NOT NULL;
+  `);
+  return db;
+}
+
+test('worker: 止めたターンを DB へ取り込み、ここまでにしたことと、実行されなかった道具を記録へ写す', () => withDir(async dir => {
+  const block = (id, content, timestamp) =>
+    ({ type: 'assistant', timestamp, message: { id, role: 'assistant', model: 'claude-opus-5', content: [content] } });
+  const result = (id, text, isError = false) =>
+    ({ type: 'user', message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: id, content: text, ...(isError ? { is_error: true } : {}) }] } });
+  const transcript = join(dir, 'work.jsonl');
+  writeFileSync(transcript, jsonl([
+    user('前の依頼', '2026-10-04T02:00:00Z'),
+    assistant('前の回答', '2026-10-04T02:00:05Z', 'claude-opus-5'),
+    user('a.mjs を直して', '2026-10-04T03:00:00Z'),
+    block('m1', { type: 'text', text: '読みます。' }, '2026-10-04T03:00:01Z'),
+    block('m1', { type: 'tool_use', id: 't1', name: 'Read', input: { file_path: '/work/a.mjs' } }, '2026-10-04T03:00:01Z'),
+    result('t1', 'export const a = 1;'),
+    block('m2', { type: 'text', text: '直します。' }, '2026-10-04T03:00:03Z'),
+    block('m2', { type: 'tool_use', id: 't2', name: 'Edit', input: { file_path: '/work/app/src/a.mjs', old_string: '1', new_string: '2' } }, '2026-10-04T03:00:03Z'),
+    result('t2', 'ok'),
+    block('m3', { type: 'tool_use', id: 't3', name: 'Bash', input: { command: 'npm test\n  --silent' } }, '2026-10-04T03:00:05Z'),
+    result('t3', 'Exit code 1', true),
+    // ここで自動圧縮を止めた。次の応答が呼んだ道具は、2つとも実行されていない
+    block('m4', { type: 'text', text: '試験が落ちました。\n原因を見ます。' }, '2026-10-04T03:00:08Z'),
+    block('m4', { type: 'tool_use', id: 't4', name: 'Read', input: { file_path: `/work/app/test/${'d'.repeat(200)}/a.test.mjs` } }, '2026-10-04T03:00:08Z'),
+    block('m4', { type: 'tool_use', id: 't5', name: 'Grep', input: { pattern: 'expect\\(' } }, '2026-10-04T03:00:08Z'),
+    result('t5', 'PreToolUse:Grep hook error', true),
+    result('t4', 'PreToolUse:Read hook error', true),
+  ]));
+  const db = makeMemoryDb();
+  requestClaudeAutoHandoff({ payload: { session_id: SESSION, trigger: 'auto', cwd: '/work/app', transcript_path: transcript },
+    env: {}, config: ENABLED, openDb: () => db, dir });
+  // hook は並んで走る。記録に残る止めた道具は、応答の中の2つ目のこともある
+  await stopClaudeTurnForHandoff({ payload: { session_id: SESSION, cwd: '/work/app', transcript_path: transcript, tool_use_id: 't5' },
+    dir, launchWorker: async () => {} });
+  const record = await runClaudeAutoHandoffWorker(SESSION, { dir, env: {}, pollMs: 10, targetTimeoutMs: 300, transcriptTimeoutMs: 300,
+    openDb: () => db,
+    send: async () => ({ status: 'accepted', outcome_unknown: false, reason: 'receiver_confirmed' }),
+    spawn: () => {
+      recordClaudeSuccessorTarget({ payload: { session_id: SUCCESSOR, source: 'startup', cwd: '/work/app' },
+        env: { CLAUDE_CODE_MESSAGING_SOCKET: '/tmp/cc-socks/1.sock' }, dir });
+      return { status: 0, stderr: '', stdout: 'backgrounded · a41a97ae · tl-app (idle — send a prompt to start)\n' };
+    } });
+  assert.equal(record.state, 'sent');
+  assert.deepEqual(record.in_flight.steps, [
+    { kind: 'text', content: '読みます。', timestamp: Date.parse('2026-10-04T03:00:01Z') },
+    { kind: 'tool', name: 'Read', target: '/work/a.mjs', failed: false },
+    { kind: 'text', content: '直します。', timestamp: Date.parse('2026-10-04T03:00:03Z') },
+    { kind: 'tool', name: 'Edit', target: 'src/a.mjs', failed: false },
+    { kind: 'tool', name: 'Bash', target: 'npm test --silent', failed: true },
+    { kind: 'text', content: '試験が落ちました。 原因を見ます。', timestamp: Date.parse('2026-10-04T03:00:08Z') },
+  ], '前のターンは入れない。止めた道具は、ここまでにしたことに入れない。作業ディレクトリの中は相対で書く');
+  assert.deepEqual(record.in_flight.stopped_tools, [
+    { name: 'Read', target: `…${'d'.repeat(159 - '/a.test.mjs'.length)}/a.test.mjs` }, { name: 'Grep', target: 'expect\\(' }],
+    '長い場所は末尾を残す');
+  assert.equal(record.in_flight.stopped_tools_total, 2);
+  assert.deepEqual(record.in_flight.turn, { origin_session_id: SESSION, turn_number: 5,
+    user_at: Date.parse('2026-10-04T03:00:00Z'), assistant_at: Date.parse('2026-10-04T03:00:08Z'), details: 10 });
+  assert.equal(publicClaudeAutoHandoff(record).in_flight_captured, true);
+  assert.equal(JSON.stringify(publicClaudeAutoHandoff(record)).includes('a.mjs'), false, '道具の対象は外へ見せない');
+
+  // DB: 止めたターンは、発言を全部つないだ本文と、道具の入出力（止めた道具を含む）で入る
+  assert.deepEqual(db.prepare('SELECT session_id, turn_number, role, text, created_at FROM bodies ORDER BY id').all().map(row => ({ ...row })), [
+    { session_id: SESSION, turn_number: 5, role: 'user', text: 'a.mjs を直して', created_at: Date.parse('2026-10-04T03:00:00Z') },
+    { session_id: SESSION, turn_number: 5, role: 'assistant', text: '読みます。\n\n直します。\n\n試験が落ちました。\n原因を見ます。',
+      created_at: Date.parse('2026-10-04T03:00:08Z') },
+  ]);
+  assert.deepEqual(db.prepare(`SELECT kind, tool_name, turn_number FROM details WHERE origin_session_id = ? ORDER BY id`).all(SESSION)
+    .map(row => `${row.kind}:${row.tool_name}:${row.turn_number}`), [
+    'tool_input:Read:5', 'tool_output:Read:5', 'tool_input:Edit:5', 'tool_output:Edit:5', 'tool_input:Bash:5', 'tool_output:Bash:5',
+    'tool_input:Read:5', 'tool_input:Grep:5', 'tool_output:Grep:5', 'tool_output:Read:5']);
+}));
+
+test('worker: 止めたターンを取り込めなくても後継を立て、取り込めなかったことを記録に残す', () => withDir(async dir => {
+  const transcript = join(dir, 'work.jsonl');
+  writeFileSync(transcript, jsonl([user('依頼', '2026-10-04T03:00:00Z'), assistant('途中です。', '2026-10-04T03:00:02Z'), toolUse('toolu_1', 'Read')]));
+  const db = makeBatonDb(); // bodies も sessions も無い
+  requestClaudeAutoHandoff({ payload: { session_id: SESSION, trigger: 'auto', cwd: '/work/app', transcript_path: transcript },
+    env: {}, config: ENABLED, openDb: () => db, dir });
+  await stopClaudeTurnForHandoff({ payload: { session_id: SESSION, cwd: '/work/app', transcript_path: transcript, tool_use_id: 'toolu_1' },
+    dir, launchWorker: async () => {} });
+  const record = await runClaudeAutoHandoffWorker(SESSION, { dir, env: {}, pollMs: 10, targetTimeoutMs: 300, transcriptTimeoutMs: 300,
+    openDb: () => db,
+    send: async () => ({ status: 'accepted', outcome_unknown: false, reason: 'receiver_confirmed' }),
+    spawn: () => {
+      recordClaudeSuccessorTarget({ payload: { session_id: SUCCESSOR, source: 'startup', cwd: '/work/app' },
+        env: { CLAUDE_CODE_MESSAGING_SOCKET: '/tmp/cc-socks/1.sock' }, dir });
+      return { status: 0, stderr: '', stdout: 'backgrounded · a41a97ae · tl-app (idle — send a prompt to start)\n' };
+    } });
+  assert.equal(record.state, 'sent');
+  assert.equal(record.in_flight.turn, null);
+  assert.equal(record.in_flight.steps.length, 1);
+  assert.equal(publicClaudeAutoHandoff(record).in_flight_captured, false);
+}));
+
 test('worker: 立ち上げ・受け口・配送の失敗は固定の理由を残し、結果が不明な配送は再送しない', () => withDir(async dir => {
   const sendOk = async () => ({ status: 'accepted', outcome_unknown: false, reason: 'receiver_confirmed' });
   const cases = [
@@ -501,10 +620,10 @@ test('hook: 自動圧縮を止め、次の道具を止めて worker を起動し
     user('成果物の1行目には必ず「約束: MANGO-4417」と書くこと', at(0)),
     assistant('了解しました。', at(1)),
     user('big1.txt と big2.txt を読んで result.txt を作って', at(10)),
-    toolUse('toolu_1', 'Read'),
+    toolUse('toolu_1', 'Read', { file_path: '/p/big1.txt' }),
     toolResult('toolu_1', 'big1 contents'),
     assistant('big1.txt を読み終えました。次に big2.txt を読みます。', at(12)),
-    toolUse('toolu_2', 'Read'),
+    toolUse('toolu_2', 'Read', { file_path: '/p/big2.txt' }),
   ]));
   const extra = fakeClaudePath(home);
   const hook = (command, payload, sessionId = SESSION) =>
@@ -529,7 +648,7 @@ test('hook: 自動圧縮を止め、次の道具を止めて worker を起動し
   assert.deepEqual(status().map(item => item.state), ['requested']);
 
   // 次の道具: 実行させずに止め、worker を起動する
-  const stopped = hook('pre-tool-use', { hook_event_name: 'PreToolUse', tool_name: 'Read', permission_mode: 'acceptEdits' });
+  const stopped = hook('pre-tool-use', { hook_event_name: 'PreToolUse', tool_name: 'Read', tool_use_id: 'toolu_2', permission_mode: 'acceptEdits' });
   assert.equal(stopped.status, 0, stopped.stderr);
   const output = JSON.parse(stopped.stdout);
   assert.equal(output.continue, false);
@@ -544,6 +663,10 @@ test('hook: 自動圧縮を止め、次の道具を止めて worker を起動し
   const recordFile = join(handoffDir, `${SESSION}.json`);
   const record = JSON.parse(readFileSync(recordFile, 'utf8'));
   assert.equal(record.settings.permission_mode, 'acceptEdits');
+  // worker は後継を立てる前に、止めたターンを DB へ取り込んでいる
+  assert.equal(handoff.in_flight_captured, true);
+  assert.equal(record.in_flight.turn.origin_session_id, SESSION);
+  assert.equal(record.in_flight.turn.details, 3);
   writeFileSync(recordFile, JSON.stringify({ ...record, state: 'launching', error_code: null }));
   const started = hook('session-start', { hook_event_name: 'SessionStart', source: 'startup' }, SUCCESSOR);
   assert.equal(started.status, 0, started.stderr);
@@ -561,8 +684,11 @@ test('hook: 自動圧縮を止め、次の道具を止めて worker を起動し
   assert.equal(first.status, 0, first.stderr);
   assert.match(first.stdout, /^## Throughline: 自動継続の文脈\n/);
   assert.match(first.stdout, /### 現在地 \(作業の途中で止めたターン\)\n\*\*作業中のユーザー依頼\*\* \[\d\d:\d\d:\d\d\]: big1\.txt と big2\.txt を読んで result\.txt を作って\n/);
-  assert.match(first.stdout, /\*\*止める直前のあなたの発言\*\* \[\d\d:\d\d:\d\d\]: big1\.txt を読み終えました。次に big2\.txt を読みます。\n/);
+  assert.match(first.stdout, new RegExp('\\*\\*このターンでここまでにしたこと\\*\\*（古い順。どれも完了済み。道具の入出力の全文: `throughline detail \\d\\d:\\d\\d:\\d\\d`）:\\n' +
+    '- 道具: Read /p/big1\\.txt\\n- 発言: big1\\.txt を読み終えました。次に big2\\.txt を読みます。\\n' +
+    '\\*\\*止める直前に呼ぼうとして、実行されなかった道具\\*\\*: Read /p/big2\\.txt\\n'));
   assert.match(first.stdout, /\[user\]: 成果物の1行目には必ず「約束: MANGO-4417」と書くこと\n/);
+  assert.equal(first.stdout.split('big1.txt と big2.txt を読んで').length, 2, '止めたターンの依頼は現在地に1回だけ');
   assert.doesNotMatch(first.stdout, /宣言|\/clear/);
   assert.ok(first.stdout.length <= 9_501);
   assert.ok(JSON.parse(readFileSync(recordFile, 'utf8')).accepted_at > 0, '届いた指示で受領を記録する');
@@ -571,6 +697,14 @@ test('hook: 自動圧縮を止め、次の道具を止めて worker を起動し
   const db = new DatabaseSync(join(home, '.throughline', 'throughline.db'));
   assert.equal(db.prepare('SELECT merged_into FROM sessions WHERE session_id = ?').get(SESSION).merged_into, SUCCESSOR);
   assert.deepEqual(db.prepare('SELECT DISTINCT session_id FROM bodies').all().map(row => row.session_id), [SUCCESSOR]);
+  // 止めたターンは、道具の入出力ごと後継の記憶に入っている（`throughline detail` で取り出せる）
+  assert.deepEqual(db.prepare(`SELECT b.role, b.text, (SELECT COUNT(*) FROM details d WHERE d.session_id = b.session_id
+      AND d.origin_session_id = b.origin_session_id AND d.turn_number = b.turn_number) AS details
+    FROM bodies b WHERE b.origin_session_id = ? AND b.turn_number = ? ORDER BY b.id`).all(SESSION, record.in_flight.turn.turn_number)
+    .map(row => ({ ...row })), [
+    { role: 'user', text: 'big1.txt と big2.txt を読んで result.txt を作って', details: 3 },
+    { role: 'assistant', text: 'big1.txt を読み終えました。次に big2.txt を読みます。', details: 3 },
+  ]);
   assert.equal(db.prepare('SELECT COUNT(*) AS c FROM handoff_batons').get().c, 0);
   db.close();
 

package/src/cli/auto-handoff.mjs

@@ -1,7 +1,7 @@
 import { isAbsolute, resolve } from 'node:path';
 import { existsSync } from 'node:fs';
 import { withCodexReceiver, platformDesktopFinder, realCodexHome } from 'aiterm-steer-delivery';
-import { openReadOnlyDb, DB_PATH, CURRENT_VERSION } from '../db.mjs';
+import { getDb, openReadOnlyDb, DB_PATH, CURRENT_VERSION } from '../db.mjs';
 import { listAutoHandoffs, getAutoHandoff } from '../codex-auto-handoff-store.mjs';
 import { renderFrozenDetail } from '../codex-auto-handoff-memory.mjs';
 import { readAutoHandoffConfig, writeAutoHandoffConfig } from '../codex-auto-handoff-config.mjs';
@@ -84,7 +84,7 @@ async function runClaude(parsed) {
     removeClaudeAutoHandoffHooks();
     return { status: 'disabled', host: 'claude', config };
   }
-  if (parsed.action === 'worker') return publicClaudeAutoHandoff(await runClaudeAutoHandoffWorker(parsed.operation));
+  if (parsed.action === 'worker') return publicClaudeAutoHandoff(await runClaudeAutoHandoffWorker(parsed.operation, { openDb: getDb }));
   const handoffs = listClaudeAutoHandoffs()
     .filter(record => !parsed.project || sameProjectPath(record.project_path, parsed.project))
     .filter(record => !parsed.operation || record.handoff_id === parsed.operation || record.source_session_id === parsed.operation)

package/src/resume-context.mjs

@@ -68,16 +68,19 @@ const AUTO_CONTINUATION_HEADER = (projectPath) =>
   `- 前の会話は文脈の上限に近づいたため、Throughline が自動圧縮の前に止めて、この新しい会話へ引き継ぎました。` +
   `下記は、前の会話で **あなた自身とユーザーが交わした会話の原文** です。\n` +
   `- 「現在地」のターンは **作業の途中で止めたもの** です。ユーザーの追加入力を待たず、未完了の作業をそのまま続けてください。\n` +
-  `- 完了済みの操作を繰り返さないでください。止める直前に呼ぼうとした道具は実行されていません。` +
-  `直前の実行結果が分からない時は、作業ツリーや記録を確かめてから続けてください。\n` +
-  '- **完了したターンの詳細**: **`Bash` ツールで `throughline detail HH:MM:SS` を実行** ' +
-  `(該当ターンの本文＋詳細を stdout に返します)`;
+  `- 「ここまでにしたこと」と「直前の対話」に載っている操作は **完了しています**。繰り返さないでください。` +
+  `未実行なのは「実行されなかった道具」だけです。そこから続けてください。\n` +
+  `- 直前の実行結果が分からない時は、作業ツリーや詳細を確かめてから続けてください。\n` +
+  '- **各ターンの詳細**（止めたターンを含む）: **`Bash` ツールで `throughline detail HH:MM:SS` を実行** ' +
+  `(該当ターンの本文＋道具の入出力を stdout に返します)`;
 
 const AUTO_CONTINUATION_ANCHOR_TITLE = '### 現在地 (作業の途中で止めたターン)';
-// 途中で止めたターンは、本文の断片が無ければ bodies に入らない。依頼の原文を必ず渡せる場所は
-// ここだけなので、/clear のアンカー (600 字) より厚く取る。
-const IN_FLIGHT_USER_MAX_CHARS = 4_000;
+// 止めたターンは現在地にだけ載せ、L2 の一覧からは外す（同じ依頼を二度載せない）。
+// /clear のアンカー (600 字) より厚く取る。3つの上限を足しても、ヘッダと案内を合わせて予算に収まる。
+const IN_FLIGHT_USER_MAX_CHARS = 3_500;
 const IN_FLIGHT_ASSISTANT_MAX_CHARS = 1_500;
+// 止めたターンでここまでにしたこと（発言と道具の呼び出し）。新しい側から、入るだけ載せる。
+const IN_FLIGHT_STEPS_MAX_CHARS = 2_400;
 
 // v0.10.12以前にThroughline自身がassistantへ付与させていた宣言行。
 // 製品由来のメタ情報だけを引き継ぎ材料から除き、会話本文への模倣連鎖を止める。
@@ -501,7 +504,8 @@ function renderBudgetedSections(db, sections, { sessionId, excludeOriginId, maxC
   const older = loadOlderTurnStats(db, {
     sessionId,
     excludeOriginId,
-    windowKeys: new Set(turns.map((t) => t.turnKey)),
+    // 現在地にだけ載せたターン（自動継続の止めたターン）は、窓の外の古いターンに数えない。
+    windowKeys: new Set([...turns.map((t) => t.turnKey), ...(sections.anchorTurnKeys ?? [])]),
   });
 
   const guidanceLines = buildGuidanceLines({
@@ -549,11 +553,62 @@ function truncateInFlight(text, maxChars) {
   return `${trimmed.slice(0, head)} …(長いため中略 ${trimmed.length - maxChars} 字)… ${trimmed.slice(-tail)}`;
 }
 
+/**
+ * 止めたターンでここまでにしたことを、現在地の行にする。
+ * 新しい側から予算に入るだけ載せ、載せなかった古い側は件数だけを1行にまとめる。
+ * @returns {{lines: string[], shownTexts: Set<string>}}
+ */
+function renderInFlightSteps(inFlight, detailClock) {
+  const steps = [...(inFlight.steps ?? [])];
+  const earlier = inFlight.earlier_steps ?? null;
+  // 一覧の最後が止める直前の発言で、1行に詰めると元の文と変わる（改行がある・長い）時は、
+  // 一覧から外して、下の「止める直前のあなたの発言」に全文で載せる。
+  const last = steps.at(-1);
+  const lastFragment = inFlight.last_fragment;
+  if (last?.kind === 'text' && lastFragment && last.timestamp === lastFragment.timestamp &&
+      last.content !== lastFragment.content.trim()) {
+    steps.pop();
+  }
+  if (steps.length === 0 && !earlier) return { lines: [], shownTexts: new Set() };
+
+  const rendered = steps.map((step) =>
+    step.kind === 'text'
+      ? `- 発言: ${step.content}`
+      : `- 道具: ${step.name}${step.target ? ` ${step.target}` : ''}${step.failed ? ' → 失敗' : ''}`,
+  );
+  let budget = IN_FLIGHT_STEPS_MAX_CHARS;
+  let first = rendered.length;
+  while (first > 0 && budget - (rendered[first - 1].length + 1) >= 0) {
+    first -= 1;
+    budget -= rendered[first].length + 1;
+  }
+  const omitted = steps.slice(0, first);
+  const omittedTexts = (earlier?.texts ?? 0) + omitted.filter((step) => step.kind === 'text').length;
+  const omittedTools =
+    Object.values(earlier?.tools ?? {}).reduce((sum, count) => sum + count, 0) +
+    omitted.filter((step) => step.kind === 'tool').length;
+
+  const lines = [
+    `**このターンでここまでにしたこと**（古い順。どれも完了済み` +
+      (detailClock ? `。道具の入出力の全文: \`throughline detail ${detailClock}\`` : '') +
+      `）:`,
+  ];
+  if (omittedTexts + omittedTools > 0) {
+    lines.push(`- （これより前に、発言 ${omittedTexts} 件・道具 ${omittedTools} 回）`);
+  }
+  lines.push(...rendered.slice(first));
+  return {
+    lines,
+    shownTexts: new Set(steps.slice(first).filter((step) => step.kind === 'text').map((step) => step.content)),
+  };
+}
+
 /**
  * 自動継続で立てた新しい会話へ注入するテキスト (ADR 0033)。
  *
  * 構成は /clear の引き継ぎと同じ予算付き（ヘッダ + 現在地 + 案内 + 入るだけの L2）。違いは現在地で、
- * DB の最新ターンではなく、止めた時点に記録した作業途中のターンを載せる。
+ * DB の最新ターンではなく、止めた時点に記録した作業途中のターンを載せる。依頼、ここまでにしたこと
+ * （発言と道具の呼び出し）、止める直前の発言、実行されなかった道具の順。止めたターンは L2 の一覧から外す。
  *
  * @param {import('node:sqlite').DatabaseSync} db
  * @param {{
@@ -561,6 +616,11 @@ function truncateInFlight(text, maxChars) {
  *   inFlight: {
  *     user: {content: string, timestamp: number|null},
  *     last_fragment: {content: string, timestamp: number|null} | null,
+ *     steps?: Array<{kind: 'text', content: string, timestamp: number|null} | {kind: 'tool', name: string, target: string, failed: boolean}>,
+ *     earlier_steps?: {texts: number, tools: Record<string, number>} | null,
+ *     stopped_tools?: Array<{name: string, target: string}>,
+ *     stopped_tools_total?: number,
+ *     turn?: {origin_session_id: string, turn_number: number, user_at: number, assistant_at: number|null} | null,
  *   } | null,
  *   projectPath?: string | null,  前の会話の作業ディレクトリ。依頼の中の相対的な場所の基準として渡す
  *   maxChars?: number,
@@ -573,17 +633,31 @@ export function buildAutoContinuationContext(
   const stored = buildResumeSections(db, { sessionId, isInheritance: true, handoffDisclosure: 'silent' });
   const stamp = (timestamp) => (timestamp == null ? '' : ` [${formatClock(timestamp)}]`);
   const anchorLines = [];
+  const turn = inFlight?.turn ?? null;
+  const turnKey = turn ? `${turn.origin_session_id}\x00${turn.turn_number}` : null;
   if (inFlight) {
     anchorLines.push(
       `**作業中のユーザー依頼**${stamp(inFlight.user.timestamp)}: ` +
         truncateInFlight(inFlight.user.content, IN_FLIGHT_USER_MAX_CHARS),
     );
-    if (inFlight.last_fragment) {
+    const steps = renderInFlightSteps(inFlight, turn ? formatClock(turn.assistant_at ?? turn.user_at) : null);
+    anchorLines.push(...steps.lines);
+    // 一覧に同じ文がそのまま載っている時は、重ねて載せない。改行のある発言や長い発言は、ここに全文を載せる。
+    if (inFlight.last_fragment && !steps.shownTexts.has(inFlight.last_fragment.content.trim())) {
       anchorLines.push(
         `**止める直前のあなたの発言**${stamp(inFlight.last_fragment.timestamp)}: ` +
           truncateInFlight(inFlight.last_fragment.content, IN_FLIGHT_ASSISTANT_MAX_CHARS),
       );
     }
+    const stoppedTools = inFlight.stopped_tools ?? [];
+    if (stoppedTools.length > 0) {
+      const more = (inFlight.stopped_tools_total ?? stoppedTools.length) - stoppedTools.length;
+      anchorLines.push(
+        `**止める直前に呼ぼうとして、実行されなかった道具**: ` +
+          stoppedTools.map((tool) => `${tool.name}${tool.target ? ` ${tool.target}` : ''}`).join('、') +
+          (more > 0 ? `（ほか ${more} 件）` : ''),
+      );
+    }
   }
   if (!stored && anchorLines.length === 0) return null;
 
@@ -593,8 +667,10 @@ export function buildAutoContinuationContext(
       header: AUTO_CONTINUATION_HEADER(projectPath),
       anchorTitle: AUTO_CONTINUATION_ANCHOR_TITLE,
       anchorLines,
+      anchorTurnKeys: turnKey ? [turnKey] : [],
       l1Lines: [],
-      l2Lines: stored?.l2Lines ?? [],
+      // 止めたターンは現在地に載せた。L2 の一覧には、それより前のターンだけを載せる。
+      l2Lines: (stored?.l2Lines ?? []).filter((line) => line.turnKey !== turnKey),
     },
     { sessionId, excludeOriginId: null, maxChars },
   );

package/src/resume-context.test.mjs

@@ -939,7 +939,7 @@ test('buildAutoContinuationContext: 現在地は止めた時点のターンで
   assert.doesNotMatch(anchor, /前の依頼/);
   assert.match(result.text, /### 直前の対話 \(L2 \/ active work thread, 古い順\)\n\[\d\d:\d\d:\d\d\] \[user\]: 前の依頼\n\[\d\d:\d\d:\d\d\] \[assistant\]: 前の回答/);
   assert.doesNotMatch(result.text, /宣言|\/clear|圧縮の要約/);
-  assert.match(result.text, /止める直前に呼ぼうとした道具は実行されていません/);
+  assert.match(result.text, /未実行なのは「実行されなかった道具」だけです/);
   assert.equal(result.injectedL2Turns, 1);
 });
 
@@ -957,8 +957,8 @@ test('buildAutoContinuationContext: 長い依頼は先頭と末尾を残し、
     },
   });
   assert.ok(result.totalChars <= INJECTION_BUDGET_CHARS, `${result.totalChars}`);
-  assert.match(result.text, /\*\*作業中のユーザー依頼\*\* \[\d\d:\d\d:\d\d\]: 先頭の指示ヰ+ …\(長いため中略 2010 字\)… ヰ+末尾の指示\n/);
-  assert.equal((result.text.match(/ヰ/g) ?? []).length, 3_990);
+  assert.match(result.text, /\*\*作業中のユーザー依頼\*\* \[\d\d:\d\d:\d\d\]: 先頭の指示ヰ+ …\(長いため中略 2510 字\)… ヰ+末尾の指示\n/);
+  assert.equal((result.text.match(/ヰ/g) ?? []).length, 3_490);
   assert.equal((result.text.match(/ヱ/g) ?? []).length, 1_500);
   assert.match(result.text, /ヱ …\(長いため中略 1500 字\)… ヱ/);
   assert.ok(result.injectedL2Turns >= 1, '最新の保存済みターンは入る');
@@ -966,3 +966,71 @@ test('buildAutoContinuationContext: 長い依頼は先頭と末尾を残し、
   assert.equal(result.injectedL2Turns + result.remainingL2Turns, 12);
   assert.match(result.text, /throughline recall --l2 --session S /);
 });
+
+test('buildAutoContinuationContext: 止めたターンでここまでにしたことと、実行されなかった道具を現在地に載せ、そのターンをL2に重ねない', () => {
+  const db = makeDb();
+  insertBody(db, { session: 'S', origin: 'P0', turn: 1, role: 'user', text: '前の依頼', createdAt: 1_000 });
+  insertBody(db, { session: 'S', origin: 'P0', turn: 1, role: 'assistant', text: '前の回答', createdAt: 2_000 });
+  // worker が取り込んだ止めたターン（発言を全部つないだ本文）
+  insertBody(db, { session: 'S', origin: 'P', turn: 7, role: 'user', text: '今の依頼', createdAt: 3_000 });
+  insertBody(db, { session: 'S', origin: 'P', turn: 7, role: 'assistant', text: 'a を直しました。\n\nb を読みます。', createdAt: 5_000 });
+  const result = buildAutoContinuationContext(db, {
+    sessionId: 'S',
+    inFlight: {
+      user: { content: '今の依頼', timestamp: 3_000 },
+      last_fragment: { content: 'b を読みます。', timestamp: 5_000 },
+      steps: [
+        { kind: 'tool', name: 'Edit', target: '/work/a.mjs', failed: false },
+        { kind: 'tool', name: 'Bash', target: 'npm test', failed: true },
+        { kind: 'text', content: 'a を直しました。', timestamp: 4_000 },
+        { kind: 'text', content: 'b を読みます。', timestamp: 5_000 },
+      ],
+      earlier_steps: null,
+      stopped_tools: [{ name: 'Read', target: '/work/b.mjs' }, { name: 'Read', target: '/work/c.mjs' }],
+      stopped_tools_total: 3,
+      turn: { origin_session_id: 'P', turn_number: 7, user_at: 3_000, assistant_at: 5_000 },
+    },
+  });
+  const anchor = result.text.slice(result.text.indexOf('### 現在地'), result.text.indexOf('### さらに前の記憶'));
+  assert.match(anchor, new RegExp(
+    '\\*\\*作業中のユーザー依頼\\*\\* \\[\\d\\d:\\d\\d:\\d\\d\\]: 今の依頼\\n' +
+    '\\*\\*このターンでここまでにしたこと\\*\\*（古い順。どれも完了済み。道具の入出力の全文: `throughline detail \\d\\d:\\d\\d:\\d\\d`）:\\n' +
+    '- 道具: Edit /work/a\\.mjs\\n- 道具: Bash npm test → 失敗\\n- 発言: a を直しました。\\n- 発言: b を読みます。\\n' +
+    '\\*\\*止める直前に呼ぼうとして、実行されなかった道具\\*\\*: Read /work/b\\.mjs、Read /work/c\\.mjs（ほか 1 件）\\n'));
+  assert.doesNotMatch(anchor, /止める直前のあなたの発言/, '一覧に同じ文が載っている発言は重ねない');
+  const l2 = result.text.slice(result.text.indexOf('### 直前の対話'));
+  assert.match(l2, /\[user\]: 前の依頼\n\[\d\d:\d\d:\d\d\] \[assistant\]: 前の回答/);
+  assert.doesNotMatch(l2, /今の依頼|a を直しました/, '止めたターンは現在地だけに載せる');
+  assert.equal(result.injectedL2Turns, 1);
+  assert.equal(result.olderTurns, 0, '止めたターンを、窓の外の古いターンに数えない');
+});
+
+test('buildAutoContinuationContext: 改行のある直前の発言は全文を載せ、多い手順は新しい側から入るだけ載せて残りは件数にする', () => {
+  const db = makeDb();
+  const steps = [];
+  for (let n = 1; n <= 80; n++) {
+    steps.push({ kind: 'tool', name: 'Read', target: `/work/file-${String(n).padStart(3, '0')}-${'x'.repeat(40)}.mjs`, failed: false });
+  }
+  steps.push({ kind: 'text', content: '方針: 1. 型を直す 2. 試験を足す', timestamp: 9_000 });
+  const result = buildAutoContinuationContext(db, {
+    sessionId: 'S',
+    inFlight: {
+      user: { content: '大きな依頼', timestamp: 1_000 },
+      last_fragment: { content: '方針:\n1. 型を直す\n2. 試験を足す', timestamp: 9_000 },
+      steps,
+      earlier_steps: { texts: 4, tools: { Read: 30, Edit: 6 } },
+      stopped_tools: [{ name: 'Edit', target: '/work/types.mjs' }],
+      stopped_tools_total: 1,
+      turn: null,
+    },
+  });
+  assert.ok(result.totalChars <= INJECTION_BUDGET_CHARS, `${result.totalChars}`);
+  assert.match(result.text, /\*\*このターンでここまでにしたこと\*\*（古い順。どれも完了済み）:\n- （これより前に、発言 4 件・道具 (\d+) 回）\n- 道具: Read /);
+  const omittedTools = Number(/これより前に、発言 4 件・道具 (\d+) 回/.exec(result.text)[1]);
+  const shownTools = (result.text.match(/^- 道具: Read /gm) ?? []).length;
+  assert.equal(omittedTools + shownTools, 36 + 80, '載せた分と件数にした分で全部');
+  assert.ok(shownTools >= 20 && shownTools < 80, `${shownTools}`);
+  assert.doesNotMatch(result.text, /- 発言: 方針/, '下に全文を載せる発言は、一覧に重ねない');
+  assert.match(result.text, /- 道具: Read \/work\/file-080-x+\.mjs\n\*\*止める直前のあなたの発言\*\* \[\d\d:\d\d:\d\d\]: 方針:\n1\. 型を直す\n2\. 試験を足す\n\*\*止める直前に呼ぼうとして、実行されなかった道具\*\*: Edit \/work\/types\.mjs\n/);
+});
+

package/src/transcript-reader.mjs

@@ -387,6 +387,28 @@ export function sliceCurrentTurnEntries(entries) {
   return entries.slice(userTextIdx, lastAssistantTextIdx + 1);
 }
 
+/**
+ * 作業途中で止めたターンのエントリ範囲 (ADR 0033)。最後の user 本文の行から、transcript の末尾まで。
+ *
+ * sliceCurrentTurnEntries は最後の assistant 本文で切るので、その後に呼んだ道具が入らない。
+ * hook で止めたターンは、止めた道具の呼び出しと結果が末尾に並ぶ。それも同じターンとして返す。
+ *
+ * @param {Array<object>} entries readRawEntries の結果
+ * @returns {Array<object>}
+ */
+export function sliceInFlightTurnEntries(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i];
+    if (entryKind(e) !== 'user' || isCompactSummaryEntry(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)
+      : typeof blocks === 'string' && blocks.length > 0;
+    if (hasText) return entries.slice(i);
+  }
+  return [];
+}
+
 /**
  * 論理ターン内の全エントリから L3 (details) 用の生レコードを抽出する。
  *

package/src/transcript-reader.test.mjs

@@ -10,6 +10,7 @@ import {
   getLogicalTurnGroups,
   readLatestUserGroup,
   sliceCurrentTurnEntries,
+  sliceInFlightTurnEntries,
   extractDetailBlocks,
 } from './transcript-reader.mjs';
 import { DETAIL_KIND } from './constants.mjs';
@@ -528,3 +529,26 @@ test('extractDetailBlocks: 複数ツール連続呼び出しを全て拾う', ()
     [DETAIL_KIND.TOOL_INPUT, DETAIL_KIND.TOOL_OUTPUT, DETAIL_KIND.TOOL_INPUT, DETAIL_KIND.TOOL_OUTPUT],
   );
 });
+
+test('sliceInFlightTurnEntries: 最後の user 本文から末尾まで。最後の発言の後に呼んだ道具と、圧縮の要約行より前の本文も扱う', () => {
+  const entries = [
+    { type: 'user', message: { role: 'user', content: '前の依頼' } },
+    { type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: '前の回答' }] } },
+    { type: 'user', message: { role: 'user', content: [{ type: 'text', text: '今の依頼' }] } },
+    { type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: '途中です。' }] } },
+    { type: 'assistant', message: { role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'Read', input: {} }] } },
+    { type: 'user', message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: 'hook error' }] } },
+    { type: 'attachment', attachment: { type: 'hook_stopped_continuation' } },
+  ];
+  const slice = sliceInFlightTurnEntries(entries);
+  assert.equal(slice.length, 5);
+  assert.equal(slice[0].message.content[0].text, '今の依頼');
+  assert.equal(sliceCurrentTurnEntries(entries).length, 2, '完了したターン用の切り出しは、最後の発言で終わる');
+  assert.deepEqual(extractDetailBlocks(slice).map((d) => d.source_id), ['t1', 't1:result', null]);
+
+  // 圧縮の要約行はターンの始まりにしない
+  const summary = { type: 'user', isCompactSummary: true, message: { role: 'user', content: '要約…' } };
+  assert.equal(sliceInFlightTurnEntries([entries[2], entries[3], summary, entries[4]]).length, 4);
+  assert.deepEqual(sliceInFlightTurnEntries([entries[1]]), []);
+});
+

package/src/turn-backfill.mjs

@@ -20,7 +20,14 @@
 import { appendFileSync, mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { getLogicalTurnGroups } from './transcript-reader.mjs';
+import {
+  extractDetailBlocks,
+  getLogicalTurnGroups,
+  isJunkAssistantText,
+  readLatestUserGroup,
+  readRawEntries,
+  sliceInFlightTurnEntries,
+} from './transcript-reader.mjs';
 
 /**
  * バックフィル回収実績を ~/.throughline/logs/backfill.log に 1 行 JSON で記録する。
@@ -132,3 +139,75 @@ export function backfillBodies(db, { targetSessionId, originSessionId, transcrip
     turnNumbers: groups.map((group) => group.representative.index),
   };
 }
+
+/**
+ * 作業途中で止めたターンを bodies と details へ取り込む (ADR 0033)。
+ *
+ * hook で止めたターンでは Stop hook が走らない。止めた側（自動継続の worker）が、後継を立てる前に呼ぶ。
+ * Codex の自動継続が、止めたターンを取り込んでから記憶を作るのと同じ。
+ *
+ *   - 完了したターンは最後の本文（代表断片）だけを残すが、止めたターンには結論の発言が無い。
+ *     ここまでの発言を全部つないで assistant の本文にする。本文が1つも無ければ user の行だけを入れる。
+ *   - turn_number は最後の本文断片の index（無ければ user 行の index）。backfillBodies は断片の index が
+ *     bodies にある群を回収しないので、後継が前任を合流させる時に、代表断片の行が重ねて入らない。
+ *   - details は最後の user 本文の行から transcript の末尾まで。止めた道具の呼び出しも入る。
+ *     source_id の UNIQUE で、同じターンをもう一度取り込んでも増えない。
+ *
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {object} opts
+ * @param {string} opts.targetSessionId 書き込み先 session_id（合流済みなら合流先）
+ * @param {string} opts.originSessionId transcript を持つ session_id
+ * @param {string|null|undefined} opts.transcriptPath
+ * @param {number} opts.now timestamp が無い時と details の created_at
+ * @returns {{turnNumber: number, userAt: number, assistantAt: number|null, insertedBodies: boolean, details: number}|null}
+ */
+export function captureInFlightTurn(db, { targetSessionId, originSessionId, transcriptPath, now }) {
+  const latest = readLatestUserGroup(transcriptPath);
+  if (!latest) return null;
+  const fragments = latest.fragments.filter((f) => !isJunkAssistantText(f.content));
+  const candidates = [latest.user.turn_number, ...latest.fragments.map((f) => f.index)];
+  const captured = db
+    .prepare(
+      `SELECT turn_number FROM bodies
+       WHERE origin_session_id = ? AND turn_number IN (${candidates.map(() => '?').join(',')})
+       ORDER BY turn_number DESC LIMIT 1`,
+    )
+    .get(originSessionId, ...candidates);
+  const turnNumber = captured?.turn_number ?? fragments.at(-1)?.index ?? latest.user.turn_number;
+  const userAt = latest.user.timestamp ?? now;
+  const assistantAt = fragments.length > 0 ? (fragments.at(-1).timestamp ?? now) : null;
+  const assistantText = fragments.map((f) => f.content.trim()).join('\n\n');
+  const detailBlocks = extractDetailBlocks(sliceInFlightTurnEntries(readRawEntries(transcriptPath)));
+
+  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 (?, ?, ?, ?, ?, ?, ?, ?)`,
+  );
+  const insertDetail = db.prepare(
+    `INSERT OR IGNORE INTO details
+       (session_id, origin_session_id, turn_number, tool_name, input_text, output_text,
+        token_count, created_at, kind, source_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  );
+  db.exec('BEGIN');
+  try {
+    if (!captured) {
+      insertBody.run(targetSessionId, originSessionId, turnNumber, 'user', latest.user.content,
+        Math.round(latest.user.content.length / 4), userAt, latest.user.start);
+      if (assistantText) {
+        insertBody.run(targetSessionId, originSessionId, turnNumber, 'assistant', assistantText,
+          Math.round(assistantText.length / 4), assistantAt, null);
+      }
+    }
+    for (const d of detailBlocks) {
+      insertDetail.run(targetSessionId, originSessionId, turnNumber, d.tool_name, d.input_text, d.output_text,
+        Math.round(((d.input_text?.length ?? 0) + (d.output_text?.length ?? 0)) / 4), now, d.kind, d.source_id);
+    }
+    db.exec('COMMIT');
+  } catch (err) {
+    db.exec('ROLLBACK');
+    throw err;
+  }
+  return { turnNumber, userAt, assistantAt, insertedBodies: !captured, details: detailBlocks.length };
+}

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, deriveTranscriptPath } from './turn-backfill.mjs';
+import { backfillBodies, captureInFlightTurn, deriveTranscriptPath } from './turn-backfill.mjs';
 
 function makeDb() {
   const db = new DatabaseSync(':memory:');
@@ -277,3 +277,77 @@ test('backfillBodies: 圧縮の要約行を数えていた頃に保存したタ
     },
   );
 });
+
+// --- 作業途中で止めたターンの取り込み (ADR 0033) ---
+
+function withDetails(db) {
+  db.exec(`
+    CREATE TABLE details (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL, origin_session_id TEXT,
+      turn_number INTEGER, tool_name TEXT NOT NULL, input_text TEXT, output_text TEXT, token_count INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL, kind TEXT, source_id TEXT);
+    CREATE UNIQUE INDEX uq_details_source ON details(session_id, origin_session_id, source_id) WHERE source_id IS NOT NULL;
+  `);
+  return 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 }] } });
+
+test('captureInFlightTurn: 止めたターンの発言を全部つないで本文にし、末尾の道具まで details に入れる。合流時の回収は重ねない', () => {
+  withData(
+    [
+      entry('user', '前の依頼', '2026-10-04T02:00:00Z'),
+      entry('assistant', '前の回答', '2026-10-04T02:00:05Z'),
+      entry('user', '3つ読んで', '2026-10-04T03:00:00Z'),
+      toolUse('t1', 'Read', { file_path: '/w/1' }),
+      toolResult('t1', 'one'),
+      entry('assistant', '1 を読みました。', '2026-10-04T03:00:02Z'),
+      toolUse('t2', 'Read', { file_path: '/w/2' }),
+      toolResult('t2', 'two'),
+      entry('assistant', '2 を読みました。', '2026-10-04T03:00:04Z'),
+      toolUse('t3', 'Read', { file_path: '/w/3' }),
+      toolResult('t3', 'PreToolUse:Read hook error'),
+    ],
+    (path) => {
+      const db = withDetails(makeDb());
+      const captured = captureInFlightTurn(db, { targetSessionId: 'S', originSessionId: 'S', transcriptPath: path, now: 9_000 });
+      assert.deepEqual(captured, { turnNumber: 4, userAt: Date.parse('2026-10-04T03:00:00Z'),
+        assistantAt: Date.parse('2026-10-04T03:00:04Z'), insertedBodies: true, details: 6 });
+      assert.deepEqual(db.prepare('SELECT turn_number, role, text, turn_start FROM bodies ORDER BY id').all().map((row) => ({ ...row })), [
+        { turn_number: 4, role: 'user', text: '3つ読んで', turn_start: 'unknown' },
+        { turn_number: 4, role: 'assistant', text: '1 を読みました。\n\n2 を読みました。', turn_start: null },
+      ]);
+      assert.deepEqual(db.prepare('SELECT source_id, turn_number FROM details ORDER BY id').all().map((row) => `${row.source_id}@${row.turn_number}`),
+        ['t1@4', 't1:result@4', 't2@4', 't2:result@4', 't3@4', 't3:result@4'], '最後の発言の後に呼んだ、止めた道具も入る');
+
+      // もう一度取り込んでも増えない
+      const again = captureInFlightTurn(db, { targetSessionId: 'S', originSessionId: 'S', transcriptPath: path, now: 9_500 });
+      assert.equal(again.turnNumber, 4);
+      assert.equal(again.insertedBodies, false);
+      assert.equal(db.prepare('SELECT COUNT(*) AS n FROM details').get().n, 6);
+
+      // 後継が前任を合流させる時の回収: 完了した前のターンだけを入れ、止めたターンへ代表断片を重ねない
+      const backfill = backfillBodies(db, { targetSessionId: 'S', originSessionId: 'S', transcriptPath: path, now: 9_900 });
+      assert.equal(backfill.insertedTurns, 1);
+      assert.equal(backfill.skippedExisting, 1);
+      assert.equal(db.prepare(`SELECT text FROM bodies WHERE turn_number = 4 AND role = 'assistant'`).get().text,
+        '1 を読みました。\n\n2 を読みました。');
+    },
+  );
+});
+
+test('captureInFlightTurn: 発言が1つも無いターンは、user の行と道具の入出力だけを入れる', () => {
+  withData(
+    [entry('user', '黙って読んで', '2026-10-04T03:00:00Z'), toolUse('t1', 'Read', { file_path: '/w/1' }), toolResult('t1', 'one'),
+      toolUse('t2', 'Read', { file_path: '/w/2' })],
+    (path) => {
+      const db = withDetails(makeDb());
+      const captured = captureInFlightTurn(db, { targetSessionId: 'S', originSessionId: 'S', transcriptPath: path, now: 9_000 });
+      assert.deepEqual(captured, { turnNumber: 0, userAt: Date.parse('2026-10-04T03:00:00Z'), assistantAt: null, insertedBodies: true, details: 3 });
+      assert.deepEqual(db.prepare('SELECT turn_number, role, text FROM bodies').all().map((row) => ({ ...row })),
+        [{ turn_number: 0, role: 'user', text: '黙って読んで' }]);
+      assert.equal(captureInFlightTurn(db, { targetSessionId: 'S', originSessionId: 'S', transcriptPath: join(path, 'none'), now: 1 }), null);
+    },
+  );
+});
+