throughline 0.2.0 → 0.3.0

package/README.md

@@ -51,17 +51,20 @@ Start any Claude Code session and your turns will begin flowing into
 
 ---
 
-## Three-layer memory model (schema v6)
+## Three-layer memory model (schema v7)
 
-| Layer | Name       | Where it lives        | Content                                                    | Cost per turn |
-| ----- | ---------- | --------------------- | ---------------------------------------------------------- | ------------- |
-| **L1** | Skeleton  | injected when old     | one-line Haiku-generated summary of the turn               | ~10 tok       |
-| **L2** | Body      | injected when recent  | user text + assistant reply, verbatim                      | full natural  |
-| **L3** | Detail    | SQLite only           | tool I/O, system messages, images (on-demand via command)  | heavy, retired |
+| Layer | Name       | Where it lives        | Content                                                               | Cost per turn |
+| ----- | ---------- | --------------------- | --------------------------------------------------------------------- | ------------- |
+| **L1** | Skeleton  | injected when old     | one-line Haiku-generated summary of the turn                          | ~10 tok       |
+| **L2** | Body      | injected when recent  | user text + assistant reply, verbatim                                 | full natural  |
+| **L3** | Detail    | SQLite only           | tool I/O, system messages, images, **extended thinking** (on-demand)  | heavy, retired |
 
 The layers are **complementary and disjoint** — nothing is duplicated across
-them. Thinking blocks are discarded entirely (not stored at either layer) to
-match the stock Claude Code behavior.
+them. Extended thinking blocks are stored at L3 (`kind='thinking'`) so the
+next session can see *what the previous Claude was thinking* at the moment it
+was interrupted, not just what it said aloud. On `SessionStart` the thinking
+of the **final turn** is injected inline above the L2 history; older thinking
+remains retrievable via `throughline detail <time>`.
 
 On `SessionStart`, Throughline rebuilds the context from SQLite and
 injects it as plain text:
@@ -81,19 +84,32 @@ of tool inputs, tool outputs, and hook output captured at L3 for that turn.
 
 ---
 
-## Explicit handoff via `/tl`
+## Explicit handoff via `/tl` (with in-flight memo)
 
 Inheritance is **opt-in**, not automatic. When you want the next session to
 pick up where this one left off, type `/tl` in the current session before you
 `/clear` or open a new chat. Without `/tl`, new sessions start fresh — no
 memory is carried over.
 
-The `/tl` slash command writes a **handoff baton** (the current `session_id`)
-into the `handoff_batons` table. On the next `SessionStart`, the hook reads the
-baton, and if it is less than **1 hour old**, merges that session's memory
-into the new session using a deterministic `UPDATE session_id = ?` inside a
-`BEGIN IMMEDIATE` transaction. The baton is consumed (deleted) atomically with
-the merge, so it cannot fire twice.
+The `/tl` slash command does two things:
+
+1. **Writes a handoff baton** (the current `session_id`) into the
+   `handoff_batons` table via the `UserPromptSubmit` hook.
+2. **Asks the current Claude to write an in-flight memo.** `/tl` instructs
+   Claude to summarize *what it was about to do next, its current hypothesis,
+   open questions, and in-progress TODOs*, then pipe that Markdown into
+   `throughline save-inflight`, which attaches it to the baton's `memo_text`
+   column. This captures the "currently thinking" state that plain transcript
+   replay cannot preserve.
+
+On the next `SessionStart`, the hook reads the baton, and if it is less than
+**1 hour old**, merges that session's memory into the new session using a
+deterministic `UPDATE session_id = ?` inside a `BEGIN IMMEDIATE` transaction.
+The baton is consumed (deleted) atomically with the merge, so it cannot fire
+twice. The injected resume context is reframed as **"resuming an interrupted
+task"** rather than *"reading past logs"*, and the in-flight memo plus the
+final turn's extended thinking appear at the top so the new Claude picks up
+mid-thought.
 
 ```
 Session A (type /tl)  -----------> baton written
@@ -181,6 +197,7 @@ you open the folder. Drop an equivalent config into your own project's
 | `throughline uninstall`                        | Remove Throughline hooks from the settings file              |
 | `throughline monitor [--all] [--session <id>]` | Run the multi-session token monitor                          |
 | `throughline detail <time>`                    | Retrieve L2 body text and L3 tool I/O for a turn (see below) |
+| `throughline save-inflight`                    | Called by `/tl` to attach an in-flight memo (stdin) to the current baton |
 | `throughline doctor`                           | Check Node version, hook registration, DB writability, PATH  |
 | `throughline status`                           | Print DB statistics (sessions, skeletons, bodies, details)   |
 | `throughline --version`                        | Print the installed version                                  |
@@ -189,9 +206,14 @@ Slash commands (invoked by the user in Claude Code):
 
 | Command       | What it does                                                      |
 | ------------- | ----------------------------------------------------------------- |
-| `/tl`         | Write a handoff baton so the next session inherits this one       |
+| `/tl`         | Write a handoff baton + ask Claude to save an in-flight memo for the next session |
 | `/sc-detail <time>` | Retrieve L2 body text and L3 tool I/O for a past turn       |
 
+> When `/tl` triggers, Claude will call `throughline save-inflight` via its
+> Bash tool. Claude Code will prompt for permission the first time; add
+> `Bash(throughline save-inflight:*)` to your allowlist to skip the prompt on
+> subsequent `/tl` invocations.
+
 Hook subcommands (invoked by Claude Code, not by humans):
 `session-start` (SessionStart), `process-turn` (Stop),
 `prompt-submit` (UserPromptSubmit — detects `/tl` and writes baton).
@@ -238,13 +260,13 @@ plain `.mjs` files.
     └── <session_id>.json     Per-session activity state for the monitor
 ```
 
-Schema v6:
+Schema v7:
 
 - `sessions` — one row per `session_id`, with `project_path` and `merged_into`
 - `skeletons` — L1 one-liners, keyed by `(session_id, origin_session_id, turn, role)`
 - `bodies` — L2 verbatim text (user + assistant), same key shape
-- `details` — L3 records with `kind` column (`tool_input` / `tool_output` / `system` / `image`) and `source_id` for idempotent re-processing
-- `handoff_batons` — one row per `project_path`, holding the `session_id` that `/tl` has nominated to hand off. Consumed and deleted by the next `SessionStart` if within the 1-hour TTL.
+- `details` — L3 records with `kind` column (`tool_input` / `tool_output` / `system` / `image` / `thinking`) and `source_id` for idempotent re-processing
+- `handoff_batons` — one row per `project_path`, with `session_id`, `created_at`, and `memo_text` (the in-flight memo written by `save-inflight` after `/tl`). Consumed and deleted by the next `SessionStart` if within the 1-hour TTL.
 - `injection_log` — audit trail of injection events
 
 All memory tables carry an `origin_session_id` so rebonded rows keep their
@@ -316,7 +338,7 @@ unchanged here.
 
 **Database got corrupted / want a clean slate**
 Delete `~/.throughline/throughline.db` (and the `-shm` / `-wal` companion files)
-and `~/.throughline/state/*.json`. A fresh database with schema v6 is created on
+and `~/.throughline/state/*.json`. A fresh database with schema v7 is created on
 the next hook fire.
 
 **New session didn't inherit memory from the previous one**

package/bin/throughline.mjs

@@ -41,6 +41,9 @@ switch (cmd) {
   case 'detail':
     (await import('../src/sc-detail.mjs')).run(rest);
     break;
+  case 'save-inflight':
+    await (await import('../src/cli/save-inflight.mjs')).run();
+    break;
   case 'doctor':
     await (await import('../src/cli/doctor.mjs')).run();
     break;
@@ -66,13 +69,14 @@ async function showHelp() {
   console.log(`throughline v${version}
 
 Usage:
-  throughline install         Register hooks in ~/.claude/settings.json
-  throughline uninstall       Remove hooks
-  throughline monitor         Multi-session token monitor (use --all, --session <id>)
-  throughline detail <time>   Retrieve L2+L3 detail for a turn (e.g. 14:23:05 or 14:23-14:30)
-  throughline doctor          Check environment
-  throughline status          Show DB statistics
-  throughline --version       Show version
+  throughline install           Register hooks in ~/.claude/settings.json
+  throughline uninstall         Remove hooks
+  throughline monitor           Multi-session token monitor (use --all, --session <id>)
+  throughline detail <time>     Retrieve L2+L3 detail for a turn (e.g. 14:23:05 or 14:23-14:30)
+  throughline save-inflight     Save in-flight memo (stdin) to the current /tl baton
+  throughline doctor            Check environment
+  throughline status            Show DB statistics
+  throughline --version         Show version
 
 Hook subcommands (called by Claude Code):
   throughline session-start   SessionStart hook

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "throughline",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "description": "Claude Code hooks plugin for structured context compression (/clear-safe persistent memory)",
   "keywords": [

package/src/baton.mjs

@@ -24,36 +24,68 @@ export const BATON_TTL_MS = 60 * 60 * 1000; // 1 時間
 
 /**
  * 現在セッション (= /tl を発動したセッション) を次回 SessionStart で merge 対象に指名する。
- * 同 project_path の既存バトンは上書きされる (INSERT OR REPLACE)。最新意図のみ有効。
+ * 同 project_path の既存バトンがあれば session_id / created_at のみ上書き。
+ * v7 で追加された memo_text は保持する（連続した /tl → save-inflight の順番で
+ * 呼ばれた場合に、再度 /tl を打った時点で古い memo が消えないようにする）。
  *
  * @param {import('node:sqlite').DatabaseSync} db
  * @param {{ projectPath: string, sessionId: string, now?: number }} params
  */
 export function writeBaton(db, { projectPath, sessionId, now = Date.now() }) {
   db.prepare(
-    `INSERT OR REPLACE INTO handoff_batons (project_path, session_id, created_at)
-     VALUES (?, ?, ?)`,
+    `INSERT INTO handoff_batons (project_path, session_id, created_at)
+     VALUES (?, ?, ?)
+     ON CONFLICT(project_path) DO UPDATE SET
+       session_id = excluded.session_id,
+       created_at = excluded.created_at`,
   ).run(projectPath, sessionId, now);
 }
 
+/**
+ * 既存バトンの memo_text を更新する。バトンが存在しない場合は NOOP。
+ * /tl 発動後、現行セッションの Claude が `throughline save-inflight` CLI 経由で
+ * 呼び出す。memo_text は Markdown 形式の「次の一手 / 現在の方針 / 未解決 /
+ * 進行中 TODO」をまとめたテキスト。
+ *
+ * Windows 互換: ドライブレター（`C:` / `c:`）やパス区切りの差異で
+ * /tl 書き込み時と save-inflight 呼び出し時の project_path が一致しない
+ * ケースがあるため、SQLite の COLLATE NOCASE で大小無視で照合する。
+ *
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {{ projectPath: string, memoText: string, now?: number }} params
+ * @returns {{ updated: boolean }}
+ */
+export function updateBatonMemo(db, { projectPath, memoText }) {
+  const result = db
+    .prepare(
+      `UPDATE handoff_batons SET memo_text = ? WHERE project_path = ? COLLATE NOCASE`,
+    )
+    .run(memoText, projectPath);
+  return { updated: (result.changes ?? 0) > 0 };
+}
+
 /**
  * 同 project_path のバトンを読み出して削除する (atomic)。
  *
  * 戻り値:
- *   - { sessionId, ageMs }   : バトン存在 かつ TTL 以内
+ *   - { sessionId, ageMs, memoText }   : バトン存在 かつ TTL 以内
  *   - { sessionId: null, skipReason: 'expired', ageMs }  : TTL 超過で破棄
  *   - { sessionId: null, skipReason: 'missing' }          : バトン無し
  *
+ * memoText は /tl 後に save-inflight で書き込まれた in-flight メモ。
+ * 未保存なら null。
+ *
  * @param {import('node:sqlite').DatabaseSync} db
  * @param {{ projectPath: string, now?: number, ttlMs?: number }} params
- * @returns {{ sessionId: string | null, ageMs?: number, skipReason?: 'expired' | 'missing' }}
+ * @returns {{ sessionId: string | null, ageMs?: number, memoText?: string | null, skipReason?: 'expired' | 'missing' }}
  */
 export function consumeBaton(db, { projectPath, now = Date.now(), ttlMs = BATON_TTL_MS }) {
   db.exec('BEGIN IMMEDIATE');
   try {
+    // Windows 互換: ドライブレターの大小差を吸収するため COLLATE NOCASE
     const row = db
       .prepare(
-        `SELECT session_id, created_at FROM handoff_batons WHERE project_path = ?`,
+        `SELECT session_id, created_at, memo_text FROM handoff_batons WHERE project_path = ? COLLATE NOCASE`,
       )
       .get(projectPath);
 
@@ -62,7 +94,9 @@ export function consumeBaton(db, { projectPath, now = Date.now(), ttlMs = BATON_
       return { sessionId: null, skipReason: 'missing' };
     }
 
-    db.prepare('DELETE FROM handoff_batons WHERE project_path = ?').run(projectPath);
+    db.prepare('DELETE FROM handoff_batons WHERE project_path = ? COLLATE NOCASE').run(
+      projectPath,
+    );
     const ageMs = now - row.created_at;
 
     if (ageMs > ttlMs) {
@@ -71,7 +105,11 @@ export function consumeBaton(db, { projectPath, now = Date.now(), ttlMs = BATON_
     }
 
     db.exec('COMMIT');
-    return { sessionId: row.session_id, ageMs };
+    return {
+      sessionId: row.session_id,
+      ageMs,
+      memoText: row.memo_text ?? null,
+    };
   } catch (err) {
     try {
       db.exec('ROLLBACK');

package/src/baton.test.mjs

@@ -1,7 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { DatabaseSync } from 'node:sqlite';
-import { writeBaton, consumeBaton, BATON_TTL_MS } from './baton.mjs';
+import { writeBaton, consumeBaton, updateBatonMemo, BATON_TTL_MS } from './baton.mjs';
 
 function makeDb() {
   const db = new DatabaseSync(':memory:');
@@ -9,7 +9,8 @@ function makeDb() {
     CREATE TABLE handoff_batons (
       project_path TEXT    PRIMARY KEY,
       session_id   TEXT    NOT NULL,
-      created_at   INTEGER NOT NULL
+      created_at   INTEGER NOT NULL,
+      memo_text    TEXT
     );
   `);
   return db;
@@ -97,3 +98,47 @@ test('consumeBaton: scopes per project_path (does not cross-consume)', () => {
   const rows = db.prepare("SELECT * FROM handoff_batons WHERE project_path = '/a'").all();
   assert.equal(rows.length, 1);
 });
+
+test('updateBatonMemo: writes memo_text into existing baton', () => {
+  const db = makeDb();
+  writeBaton(db, { projectPath: '/proj', sessionId: 'S1', now: 1000 });
+  const result = updateBatonMemo(db, { projectPath: '/proj', memoText: '次の一手: X' });
+  assert.equal(result.updated, true);
+  const row = db.prepare('SELECT memo_text FROM handoff_batons').get();
+  assert.equal(row.memo_text, '次の一手: X');
+});
+
+test('updateBatonMemo: is a NOOP when no baton exists (no throw)', () => {
+  const db = makeDb();
+  const result = updateBatonMemo(db, { projectPath: '/missing', memoText: 'hello' });
+  assert.equal(result.updated, false);
+});
+
+test('writeBaton: preserves memo_text when same project_path is re-batoned', () => {
+  const db = makeDb();
+  writeBaton(db, { projectPath: '/proj', sessionId: 'S1', now: 1000 });
+  updateBatonMemo(db, { projectPath: '/proj', memoText: 'preserved memo' });
+  // 同じ project_path に再度 /tl を打っても memo は残る
+  writeBaton(db, { projectPath: '/proj', sessionId: 'S2', now: 2000 });
+  const row = db.prepare('SELECT * FROM handoff_batons').get();
+  assert.equal(row.session_id, 'S2');
+  assert.equal(row.created_at, 2000);
+  assert.equal(row.memo_text, 'preserved memo');
+});
+
+test('consumeBaton: returns memoText when set', () => {
+  const db = makeDb();
+  writeBaton(db, { projectPath: '/proj', sessionId: 'S1', now: 1000 });
+  updateBatonMemo(db, { projectPath: '/proj', memoText: '中断メモ' });
+  const result = consumeBaton(db, { projectPath: '/proj', now: 1000 + 1000 });
+  assert.equal(result.sessionId, 'S1');
+  assert.equal(result.memoText, '中断メモ');
+});
+
+test('consumeBaton: returns memoText=null when not set', () => {
+  const db = makeDb();
+  writeBaton(db, { projectPath: '/proj', sessionId: 'S1', now: 1000 });
+  const result = consumeBaton(db, { projectPath: '/proj', now: 1000 + 1000 });
+  assert.equal(result.sessionId, 'S1');
+  assert.equal(result.memoText, null);
+});

package/src/cli/save-inflight.mjs

@@ -0,0 +1,81 @@
+/**
+ * throughline save-inflight — /tl 発動後、現行 Claude が中断地点の in-flight メモを
+ * stdin 経由で書き込む CLI。
+ *
+ * 使い方 (Claude Code の Bash ツールから):
+ *   throughline save-inflight <<'EOF'
+ *   **次の一手**: ...
+ *   **現在の方針**: ...
+ *   **未解決の疑問**: ...
+ *   **進行中 TODO**: ...
+ *   EOF
+ *
+ * 動作:
+ *   1. stdin を UTF-8 で全部読む
+ *   2. 空なら exit 1 (§0 フォールバック禁止 — サイレント成功しない)
+ *   3. cwd に対応する handoff_batons 行の memo_text を UPDATE
+ *   4. バトン未登録なら updated=false で警告して exit 1
+ *
+ * 呼び出し元: [.claude/commands/tl.md] が Claude に実行させる
+ */
+
+import { getDb } from '../db.mjs';
+import { updateBatonMemo } from '../baton.mjs';
+import { readFileSync, appendFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+
+function logInflight(entry) {
+  const path = join(homedir(), '.throughline', 'logs', 'inflight-memo.log');
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    appendFileSync(path, JSON.stringify(entry) + '\n', 'utf8');
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'unknown';
+    process.stderr.write(`[save-inflight:log] ${msg}\n`);
+  }
+}
+
+export async function run() {
+  let memoText;
+  try {
+    memoText = readFileSync(0, 'utf8').trim();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'unknown';
+    process.stderr.write(`[save-inflight] failed to read stdin: ${msg}\n`);
+    process.exit(1);
+    return;
+  }
+
+  if (!memoText) {
+    process.stderr.write(
+      '[save-inflight] stdin was empty. Provide the in-flight memo via stdin (here-doc or pipe).\n',
+    );
+    process.exit(1);
+    return;
+  }
+
+  const projectPath = process.cwd();
+  const db = getDb();
+  const { updated } = updateBatonMemo(db, { projectPath, memoText });
+
+  logInflight({
+    ts: new Date().toISOString(),
+    project_path: projectPath,
+    memo_length: memoText.length,
+    baton_updated: updated,
+  });
+
+  if (!updated) {
+    process.stderr.write(
+      `[save-inflight] no baton found for ${projectPath}. ` +
+        `Run /tl first so the baton exists, then save-inflight can attach the memo.\n`,
+    );
+    process.exit(1);
+    return;
+  }
+
+  process.stdout.write(
+    `[throughline] in-flight memo saved (${memoText.length} chars) for next session\n`,
+  );
+}

package/src/constants.mjs

@@ -10,6 +10,7 @@ export const DETAIL_KIND = Object.freeze({
   TOOL_OUTPUT: 'tool_output',
   SYSTEM: 'system',
   IMAGE: 'image',
+  THINKING: 'thinking',
 });
 
 /** 上記の値すべての Set（未知値判定に使う） */

package/src/db.mjs

@@ -9,7 +9,7 @@ import { join } from 'path';
 
 const DB_DIR = join(homedir(), '.throughline');
 const DB_PATH = join(DB_DIR, 'throughline.db');
-const CURRENT_VERSION = 6;
+const CURRENT_VERSION = 7;
 
 let _db = null;
 
@@ -191,6 +191,17 @@ function initSchema(db) {
     `);
   }
 
+  // v6 → v7: handoff_batons に memo_text 列追加（/tl 発動時に現行 Claude 自身が
+  // 書き込む in-flight メモ。「次の一手」「現在の方針」「未解決」「進行中 TODO」
+  // の短い Markdown テキスト。次セッションの SessionStart が resume-context の
+  // 先頭に注入して「中断地点からの再開」感を復元する）
+  if (version < 7) {
+    const batonCols = db.prepare('PRAGMA table_info(handoff_batons)').all();
+    if (!batonCols.some((c) => c.name === 'memo_text')) {
+      db.exec('ALTER TABLE handoff_batons ADD COLUMN memo_text TEXT');
+    }
+  }
+
   if (version < CURRENT_VERSION) {
     db.exec(`PRAGMA user_version = ${CURRENT_VERSION}`);
   }

package/src/resume-context.mjs

@@ -1,23 +1,34 @@
 /**
- * resume-context.mjs — L1+L2 の再注入テキストを組み立てる共有モジュール
+ * resume-context.mjs — 中断地点からの再開注入テキストを組み立てる共有モジュール
  *
  * 呼び出し元:
  *   - session-start.mjs (isInheritance=true, 引き継ぎヘッダ)
  *
- * 新設計（schema v4）:
+ * 設計（schema v7 対応）:
+ *   - 注入順: ヘッダ → [in-flight メモ] → [中断直前の思考] → L1 要約 → L2 本文 → フッタ
+ *   - in-flight メモ: /tl 発動時に現行 Claude が書いた「次の一手 / 方針 / 未解決 / TODO」
+ *   - 中断直前の思考: 最終ターンの assistant extended thinking (details kind='thinking')
  *   - 直近 N=20 ターンは bodies から L2 全文を注入
  *   - それ以前は skeletons から L1 要約のみ注入
- *   - 各行頭に [HH:MM:SS] 時刻プレフィックス（bodies.created_at ベース、DB 永続）
+ *   - 各行頭に [HH:MM:SS] 時刻プレフィックス（created_at ベース、DB 永続）
  *   - 末尾に /sc-detail <時刻> ガイドを追記
- *   - judgments セクションは廃止
  *   - 現セッションのターンは注入しない（Claude Code 本体のコンテキストに既にあるため）
+ *   - フレーミングを「過去の記憶」から「中断した作業の再開」に変更 (B 案)
  */
 
 const N_RECENT_L2 = 20;
 
 const RESUME_HEADER_TEMPLATE = (turnCount) =>
-  `## Throughline: セッション記憶（${turnCount} ターン引き継ぎ）\n` +
-  `**[Throughline] 前セッションの記憶を引き継ぎました。応答の冒頭で「前の記憶を ${turnCount} ターン引き継ぎました」とユーザーに報告してください。**`;
+  `## Throughline: 中断した作業の再開（${turnCount} ターン分の文脈を保持）\n` +
+  `\n` +
+  `**前セッションで進行中だった作業を、この新セッションで引き継いでいます。以下が中断時点の状態です:**\n` +
+  `- 中断直前の in-flight メモ（前セッション末尾で Claude 自身が書いた「次の一手・方針・未解決・TODO」）\n` +
+  `- 中断直前の思考 (最終ターンの extended thinking)\n` +
+  `- 直近 ${N_RECENT_L2} ターンの会話本文 (L2)\n` +
+  `- それ以前の要約 (L1)\n` +
+  `\n` +
+  `応答の冒頭でユーザーに「前の作業を ${turnCount} ターン分引き継ぎました」と報告してください。` +
+  `作業方針は前セッションのものを踏襲し、中断地点から自然に続行してください。`;
 
 const NORMAL_HEADER = '## Throughline: セッション記憶';
 
@@ -25,11 +36,11 @@ const FOOTER_GUIDE =
   '---\n' +
   '**[Claude 向け — 記憶の使い方]**\n' +
   '上の L1 要約や L2 本文を読んで「具体的なコマンドやツール出力、ファイル内容を確認したい」と感じたら、' +
-  '推測せずに **Bash ツールで `throughline detail <時刻>` を実行** して L3（ツール入出力・hook 出力）を取得してください。\n' +
+  '推測せずに **Bash ツールで `throughline detail <時刻>` を実行** して L3（ツール入出力・hook 出力・thinking）を取得してください。\n' +
   '- 単一時刻: `throughline detail 14:23:05`\n' +
   '- 時刻範囲: `throughline detail 14:23-14:30`\n' +
   '\n' +
-  '返る内容: 指定ターンの L2 会話本文 + L3（tool_input / tool_output / system 別にグループ化）。\n' +
+  '返る内容: 指定ターンの L2 会話本文 + L3（tool_input / tool_output / system / thinking 別にグループ化）。\n' +
   'ユーザーに「詳細を見せて」と言われた時だけでなく、**ユーザー発言の文脈が過去ターンに依存しているのに L1/L2 だけでは情報不足だと判断した時**に、Claude 自身の判断で呼び出して構いません。';
 
 /**
@@ -44,29 +55,75 @@ function formatTime(unixMs) {
 }
 
 /**
- * 本文を 1 行にまとめる（改行は空白に畳む）。
+ * 最新ターン番号 (= 中断直前) の thinking ブロックを details から取り出す。
+ * origin 除外がある場合はそれも考慮する。
+ *
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {string} sessionId
+ * @param {string | null} excludeOriginId
+ * @returns {Array<{ output_text: string, created_at: number }>}
  */
-function flattenText(text) {
-  if (!text) return '';
-  return text.replace(/\n+/g, ' ').trim();
+function loadLatestThinking(db, sessionId, excludeOriginId) {
+  const hasExclude = Boolean(excludeOriginId);
+
+  // 最新 (origin_session_id, turn_number) を bodies から特定
+  const latestQuery = hasExclude
+    ? `SELECT origin_session_id, turn_number, created_at
+       FROM bodies
+       WHERE session_id = ? AND origin_session_id != ? AND role = 'assistant'
+       ORDER BY created_at DESC
+       LIMIT 1`
+    : `SELECT origin_session_id, turn_number, created_at
+       FROM bodies
+       WHERE session_id = ? AND role = 'assistant'
+       ORDER BY created_at DESC
+       LIMIT 1`;
+
+  let latest;
+  try {
+    latest = hasExclude
+      ? db.prepare(latestQuery).get(sessionId, excludeOriginId)
+      : db.prepare(latestQuery).get(sessionId);
+  } catch {
+    return [];
+  }
+  if (!latest) return [];
+
+  // その (origin_session_id, turn_number) に紐づく kind='thinking' を取り出す
+  try {
+    const rows = db
+      .prepare(
+        `SELECT output_text, created_at FROM details
+         WHERE session_id = ? AND origin_session_id = ? AND turn_number = ? AND kind = 'thinking'
+         ORDER BY created_at ASC`,
+      )
+      .all(sessionId, latest.origin_session_id, latest.turn_number);
+    return rows.filter((r) => typeof r.output_text === 'string' && r.output_text.length > 0);
+  } catch {
+    return [];
+  }
 }
 
 /**
  * L1+L2 注入テキストを組み立てる。
  *
  * @param {import('node:sqlite').DatabaseSync} db
- * @param {{ sessionId: string, isInheritance: boolean, excludeOriginId?: string | null }} params
- *        sessionId: 合流先 session_id (merge target)
- *        excludeOriginId: 注入対象から除外する origin_session_id（= 現セッションの origin）
- *                         指定すると「前任チェーンのターンのみ」を注入する
+ * @param {{
+ *   sessionId: string,
+ *   isInheritance: boolean,
+ *   excludeOriginId?: string | null,
+ *   inflightMemo?: string | null,
+ * }} params
  * @returns {string | null}
  */
-export function buildResumeContext(db, { sessionId, isInheritance, excludeOriginId = null }) {
+export function buildResumeContext(
+  db,
+  { sessionId, isInheritance, excludeOriginId = null, inflightMemo = null },
+) {
   if (!sessionId) return null;
 
   const hasExclude = Boolean(excludeOriginId);
 
-  // 直近 N 件の bodies を取得
   const bodiesQuery = hasExclude
     ? `SELECT origin_session_id, turn_number, role, text, created_at
        FROM bodies
@@ -92,7 +149,7 @@ export function buildResumeContext(db, { sessionId, isInheritance, excludeOrigin
   }
   const bodyRows = bodyRowsDesc.reverse(); // ASC に戻す
 
-  // 古い側の L1（bodies に既に含まれるターンを除いたもの）を skeletons から取得
+  // 古い側の L1（bodies に既に含まれるターンを除いたもの）
   const bodySet = new Set(
     bodyRows.map((r) => `${r.origin_session_id}\x00${r.turn_number}`),
   );
@@ -115,7 +172,14 @@ export function buildResumeContext(db, { sessionId, isInheritance, excludeOrigin
     (s) => !bodySet.has(`${s.origin_session_id}\x00${s.turn_number}`),
   );
 
-  if (bodyRows.length === 0 && l1Rows.length === 0) {
+  const thinkingRows = loadLatestThinking(db, sessionId, excludeOriginId);
+
+  if (
+    bodyRows.length === 0 &&
+    l1Rows.length === 0 &&
+    thinkingRows.length === 0 &&
+    !inflightMemo
+  ) {
     return null;
   }
 
@@ -123,12 +187,26 @@ export function buildResumeContext(db, { sessionId, isInheritance, excludeOrigin
   const header = isInheritance ? RESUME_HEADER_TEMPLATE(turnCount) : NORMAL_HEADER;
   const lines = [header];
 
+  if (inflightMemo && inflightMemo.trim().length > 0) {
+    lines.push('');
+    lines.push('### 中断直前の in-flight メモ（前セッションの Claude 自身による要約）');
+    lines.push(inflightMemo.trim());
+  }
+
+  if (thinkingRows.length > 0) {
+    lines.push('');
+    lines.push('### 中断直前の思考 (最終ターンの extended thinking)');
+    for (const r of thinkingRows) {
+      lines.push(`[${formatTime(r.created_at)}] ${r.output_text}`);
+    }
+  }
+
   if (l1Rows.length > 0) {
     lines.push('');
     lines.push('### それ以前の要約 (L1)');
     for (const r of l1Rows) {
       if (!r.summary || r.summary === '(no content)') continue;
-      lines.push(`[${formatTime(r.created_at)}] ${flattenText(r.summary)}`);
+      lines.push(`[${formatTime(r.created_at)}] ${r.summary.replace(/\n+/g, ' ').trim()}`);
     }
   }
 

package/src/session-start.mjs

@@ -83,14 +83,20 @@ async function main() {
     baton_session_id: baton.sessionId ?? null,
     baton_age_ms: baton.ageMs ?? null,
     baton_skip_reason: baton.skipReason ?? null,
+    baton_has_memo: Boolean(baton.memoText),
     merged: mergeResult.merged,
     merge_skip_reason: mergeResult.skipReason ?? null,
     predecessor_id: mergeResult.predecessorId ?? null,
   });
 
   // 3. 合流成立なら引き継ぎヘッダ付きで注入
+  //    バトンに付いていた in-flight メモも併せて先頭セクションに注入する
   if (mergeResult.merged) {
-    const text = buildResumeContext(db, { sessionId: session_id, isInheritance: true });
+    const text = buildResumeContext(db, {
+      sessionId: session_id,
+      isInheritance: true,
+      inflightMemo: baton.memoText ?? null,
+    });
     if (text) {
       process.stdout.write(text + '\n');
     }

package/src/transcript-reader.mjs

@@ -197,7 +197,7 @@ export function sliceCurrentTurnEntries(entries) {
  * 分類ルール:
  *   - assistant の tool_use ブロック → tool_input (name, input を JSON 化して input_text に)
  *   - user の tool_result ブロック → tool_output (content を output_text に、ANSI 剥離)
- *   - assistant/user の thinking ブロック → 破棄
+ *   - assistant の thinking ブロック → thinking (b.thinking を output_text に)
  *   - assistant/user の text ブロック → 扱わない（L2 bodies 側の責務）
  *   - attachment entry (hook_success) → system (hookName + content を出力に)
  *   - system entry (stop_hook_summary) → skip（hook タイミング情報で意味なし）
@@ -215,7 +215,8 @@ export function extractDetailBlocks(turnEntries) {
     if (e.type === 'assistant') {
       const blocks = e.message?.content;
       if (!Array.isArray(blocks)) continue;
-      for (const b of blocks) {
+      for (let i = 0; i < blocks.length; i++) {
+        const b = blocks[i];
         if (!b || !b.type) continue;
         if (b.type === 'tool_use' && typeof b.id === 'string') {
           toolNameById.set(b.id, b.name ?? 'unknown');
@@ -226,6 +227,16 @@ export function extractDetailBlocks(turnEntries) {
             input_text: JSON.stringify(b.input ?? null),
             output_text: null,
           });
+        } else if (b.type === 'thinking' && typeof b.thinking === 'string') {
+          // 固有 id が無いため entry uuid + block index で冪等キーを合成
+          const sourceId = e.uuid ? `${e.uuid}:thinking:${i}` : null;
+          out.push({
+            kind: DETAIL_KIND.THINKING,
+            tool_name: 'thinking',
+            source_id: sourceId,
+            input_text: null,
+            output_text: b.thinking,
+          });
         } else if (b.type === 'image') {
           out.push({
             kind: DETAIL_KIND.IMAGE,
@@ -235,7 +246,7 @@ export function extractDetailBlocks(turnEntries) {
             output_text: '[image]',
           });
         }
-        // text / thinking は扱わない
+        // text は扱わない
       }
     } else if (e.type === 'user') {
       const blocks = e.message?.content;

package/src/transcript-reader.test.mjs

@@ -114,22 +114,80 @@ test('extractDetailBlocks: tool_use と tool_result をペアで抽出', () => {
   assert.equal(output.output_text, 'hi\n');
 });
 
-test('extractDetailBlocks: thinking / text ブロックは L3 に入れない', () => {
+test('extractDetailBlocks: assistant の thinking ブロックを kind=thinking で抽出、text は無視', () => {
   const entries = [
     userEntry('prompt'),
     {
       type: 'assistant',
+      uuid: 'asst-1',
       message: {
         role: 'assistant',
         content: [
-          { type: 'thinking', thinking: 'internal thoughts' },
+          { type: 'thinking', thinking: 'internal thoughts', signature: 'sig' },
           { type: 'text', text: 'response' },
         ],
       },
     },
   ];
   const details = extractDetailBlocks(entries);
-  assert.equal(details.length, 0);
+  assert.equal(details.length, 1);
+  assert.equal(details[0].kind, DETAIL_KIND.THINKING);
+  assert.equal(details[0].tool_name, 'thinking');
+  assert.equal(details[0].source_id, 'asst-1:thinking:0');
+  assert.equal(details[0].input_text, null);
+  assert.equal(details[0].output_text, 'internal thoughts');
+});
+
+test('extractDetailBlocks: 同 entry 内で thinking + tool_use + image が混在しても全て抽出', () => {
+  const entries = [
+    userEntry('prompt'),
+    {
+      type: 'assistant',
+      uuid: 'asst-2',
+      message: {
+        role: 'assistant',
+        content: [
+          { type: 'thinking', thinking: 'first thought' },
+          { type: 'tool_use', id: 'toolu_1', name: 'Read', input: { path: '/x' } },
+          { type: 'thinking', thinking: 'second thought' },
+          { type: 'image', source: {} },
+          { type: 'text', text: 'done' },
+        ],
+      },
+    },
+    asstTextEntry('wrap'),
+  ];
+  const details = extractDetailBlocks(entries);
+  // thinking x2, tool_input x1, image x1 = 4
+  assert.equal(details.length, 4);
+  const thinkings = details.filter((d) => d.kind === DETAIL_KIND.THINKING);
+  assert.equal(thinkings.length, 2);
+  assert.equal(thinkings[0].source_id, 'asst-2:thinking:0');
+  assert.equal(thinkings[1].source_id, 'asst-2:thinking:2');
+  assert.equal(thinkings[0].output_text, 'first thought');
+  assert.equal(thinkings[1].output_text, 'second thought');
+});
+
+test('extractDetailBlocks: thinking エントリに uuid が無くても source_id=null で通過する', () => {
+  const entries = [
+    userEntry('prompt'),
+    {
+      type: 'assistant',
+      // uuid 欠損
+      message: {
+        role: 'assistant',
+        content: [
+          { type: 'thinking', thinking: 'thought without uuid' },
+          { type: 'text', text: 'reply' },
+        ],
+      },
+    },
+  ];
+  const details = extractDetailBlocks(entries);
+  const thinking = details.find((d) => d.kind === DETAIL_KIND.THINKING);
+  assert.ok(thinking);
+  assert.equal(thinking.source_id, null);
+  assert.equal(thinking.output_text, 'thought without uuid');
 });
 
 test('extractDetailBlocks: attachment (hook_success) を system として抽出', () => {