throughline 0.1.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 v4)
+## 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,30 +84,63 @@ of tool inputs, tool outputs, and hook output captured at L3 for that turn.
 
 ---
 
-## `/clear`-safe with memory rebonding
+## 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 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.
 
-When you run `/clear`, the conversation transcript is discarded, but the SQLite
-database is untouched. On the next session start:
+```
+Session A (type /tl)  -----------> baton written
+                                       |
+                      /clear           |
+                         |             ▼
+                      Session B  ---- reads baton, merges A into B, deletes baton ---->
+                         |
+                      (type /tl again to hand off further)
+```
 
-1. `SessionStart` hook fires with a new `session_id`
-2. Throughline finds the previous session in the same project
-3. It **rebonds** all `skeletons` / `bodies` / `details` rows from the previous
-   session into the new session (via `UPDATE session_id = ?`) inside a
-   `BEGIN IMMEDIATE` transaction
-4. A handover banner is injected:
-   `## Throughline: セッション記憶（N ターン引き継ぎ）`
+Why explicit baton instead of auto-inherit:
 
-Each row keeps its **origin_session_id**, so memories accumulate through chains
-of `/clear` rather than being lost or overwritten:
+- **Zero false positives.** A parallel window, a VSCode restart, or a genuine
+  new task in the same repo won't accidentally inherit the previous session's
+  memory. Only an explicit `/tl` triggers inheritance.
+- **VSCode extension compatibility.** The `SessionStart` hook's `source` field
+  is rewritten to `"startup"` by the Claude Code VSCode extension even after
+  `/clear` (see [issue #49937](https://github.com/anthropics/claude-code/issues/49937)),
+  so source-based detection is unreliable. A user-driven baton sidesteps this.
+- **Deterministic.** No time-window heuristic, no PID guessing, no ancestor
+  walking. The user declares intent; the hook carries it out.
+
+Each merged row keeps its `origin_session_id`, so repeated `/tl` handoffs
+accumulate memory through chains:
 
 ```
-S1 (4 turns) -- /clear --> S2 (merges S1, adds 3 turns) -- /clear --> S3 (merges S2, adds 5 turns)
-                           origin=S1×4                                origin=S1×4, S2×3, S3×5
+S1 (4 turns) --/tl,/clear--> S2 (merges S1, adds 3 turns) --/tl,/clear--> S3 (merges S2, adds 5 turns)
+                             origin=S1×4                                  origin=S1×4, S2×3, S3×5
 ```
 
-No time-window heuristic, no PID guessing, no ancestor walking. Just a
-deterministic UPDATE inside a SQLite transaction.
-
 ---
 
 ## Multi-session token monitor
@@ -161,12 +197,26 @@ 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                                  |
 
+Slash commands (invoked by the user in Claude Code):
+
+| Command       | What it does                                                      |
+| ------------- | ----------------------------------------------------------------- |
+| `/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).
+`session-start` (SessionStart), `process-turn` (Stop),
+`prompt-submit` (UserPromptSubmit — detects `/tl` and writes baton).
 
 ### `throughline detail` — for AI, not humans
 
@@ -210,16 +260,17 @@ plain `.mjs` files.
     └── <session_id>.json     Per-session activity state for the monitor
 ```
 
-Schema v5:
+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
+- `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 tables carry an `origin_session_id` so rebonded rows keep their lineage
-after a `/clear` chain.
+All memory tables carry an `origin_session_id` so rebonded rows keep their
+lineage across a chain of `/tl` handoffs.
 
 ---
 
@@ -287,9 +338,15 @@ 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 v4 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**
+This is the designed behavior — inheritance requires an explicit `/tl` in the
+previous session. If you forgot to type it before `/clear`, the memory is still
+in SQLite but won't auto-inject. You can still retrieve specific turns with
+`/sc-detail <time>`.
+
 ---
 
 ## Development
@@ -297,7 +354,7 @@ the next hook fire.
 ```bash
 git clone https://github.com/kitepon-rgb/Throughline.git
 cd Throughline
-npm link                              # Put `throughline` on PATH
+npm link                              # Put `throughline` on PATH (dev only)
 throughline install --project         # Register hooks for this repo only
 node --test src/turn-processor.test.mjs src/session-merger.test.mjs
 ```
@@ -316,7 +373,8 @@ the folder in VS Code.
 ## Design docs
 
 - [`docs/L1_L2_L3_REDESIGN.md`](docs/L1_L2_L3_REDESIGN.md) — **current design
-  spec** for the L1/L2/L3 differential layer model (schema v4). Authoritative.
+  spec** for the L1/L2/L3 differential layer model (schema v4 base + v5 L3
+  classification extension). Authoritative.
 - [`docs/PUBLIC_RELEASE_PLAN.md`](docs/PUBLIC_RELEASE_PLAN.md) — public release
   plan (CLI surface, package.json layout, § 0 fallback rule)
 - [`docs/archive/`](docs/archive/) — superseded design documents kept for

package/bin/throughline.mjs

@@ -32,12 +32,18 @@ switch (cmd) {
   case 'session-start':
     await import('../src/session-start.mjs');
     break;
+  case 'prompt-submit':
+    await import('../src/prompt-submit.mjs');
+    break;
   case 'monitor':
     await import('../src/token-monitor.mjs');
     break;
   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;
@@ -63,16 +69,18 @@ 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
   throughline process-turn    Stop hook
+  throughline prompt-submit   UserPromptSubmit hook (/tl baton writer)
 `);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "throughline",
-  "version": "0.1.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

@@ -0,0 +1,121 @@
+/**
+ * baton.mjs — 引き継ぎバトン管理
+ *
+ * バトン方式の設計 (docs/INHERITANCE_ON_CLEAR_ONLY.md):
+ *   - ユーザーが旧セッションで /tl スラッシュコマンドを打つ → UserPromptSubmit hook が
+ *     baton テーブルに (project_path, session_id, created_at) を INSERT OR REPLACE
+ *   - 新セッションの SessionStart hook が baton を消費:
+ *     TTL 1 時間以内 かつ session_id が自分自身でない → 前任として merge
+ *     期限切れ or 自己指名 → 破棄
+ *   - 消費は atomic (BEGIN IMMEDIATE トランザクション内で SELECT + DELETE)
+ *
+ * なぜバトン方式か:
+ *   - VSCode 拡張では SessionStart payload の source が /clear 後も "startup" に潰される
+ *     ため source 値だけで /clear を識別できない (GitHub issue #49937)
+ *   - 時間差ヒューリスティック (案 D) は誤爆の可能性があり、ユーザー明示の意思表示を
+ *     引き継ぎ発火の唯一の条件とする方が決定論的
+ */
+
+/**
+ * バトン TTL (ミリ秒)。ユーザーが /tl を打ってから新セッション開始までの猶予。
+ * 超過したバトンは consumeBaton で破棄される（merge されない）。
+ */
+export const BATON_TTL_MS = 60 * 60 * 1000; // 1 時間
+
+/**
+ * 現在セッション (= /tl を発動したセッション) を次回 SessionStart で merge 対象に指名する。
+ * 同 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 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, 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, 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, memo_text FROM handoff_batons WHERE project_path = ? COLLATE NOCASE`,
+      )
+      .get(projectPath);
+
+    if (!row) {
+      db.exec('COMMIT');
+      return { sessionId: null, skipReason: 'missing' };
+    }
+
+    db.prepare('DELETE FROM handoff_batons WHERE project_path = ? COLLATE NOCASE').run(
+      projectPath,
+    );
+    const ageMs = now - row.created_at;
+
+    if (ageMs > ttlMs) {
+      db.exec('COMMIT');
+      return { sessionId: null, skipReason: 'expired', ageMs };
+    }
+
+    db.exec('COMMIT');
+    return {
+      sessionId: row.session_id,
+      ageMs,
+      memoText: row.memo_text ?? null,
+    };
+  } catch (err) {
+    try {
+      db.exec('ROLLBACK');
+    } catch {
+      // ignore
+    }
+    throw err;
+  }
+}

package/src/baton.test.mjs

@@ -0,0 +1,144 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { DatabaseSync } from 'node:sqlite';
+import { writeBaton, consumeBaton, updateBatonMemo, BATON_TTL_MS } from './baton.mjs';
+
+function makeDb() {
+  const db = new DatabaseSync(':memory:');
+  db.exec(`
+    CREATE TABLE handoff_batons (
+      project_path TEXT    PRIMARY KEY,
+      session_id   TEXT    NOT NULL,
+      created_at   INTEGER NOT NULL,
+      memo_text    TEXT
+    );
+  `);
+  return db;
+}
+
+test('BATON_TTL_MS default is 1 hour', () => {
+  assert.equal(BATON_TTL_MS, 60 * 60 * 1000);
+});
+
+test('writeBaton: inserts a fresh baton', () => {
+  const db = makeDb();
+  writeBaton(db, { projectPath: '/proj', sessionId: 'S1', now: 1000 });
+  const row = db.prepare('SELECT * FROM handoff_batons').get();
+  assert.equal(row.project_path, '/proj');
+  assert.equal(row.session_id, 'S1');
+  assert.equal(row.created_at, 1000);
+});
+
+test('writeBaton: overwrites previous baton for same project_path', () => {
+  const db = makeDb();
+  writeBaton(db, { projectPath: '/proj', sessionId: 'S1', now: 1000 });
+  writeBaton(db, { projectPath: '/proj', sessionId: 'S2', now: 2000 });
+  const rows = db.prepare('SELECT * FROM handoff_batons').all();
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0].session_id, 'S2');
+  assert.equal(rows[0].created_at, 2000);
+});
+
+test('writeBaton: separate project_paths coexist', () => {
+  const db = makeDb();
+  writeBaton(db, { projectPath: '/a', sessionId: 'A', now: 1000 });
+  writeBaton(db, { projectPath: '/b', sessionId: 'B', now: 1000 });
+  const rows = db.prepare('SELECT * FROM handoff_batons ORDER BY project_path').all();
+  assert.equal(rows.length, 2);
+  assert.equal(rows[0].project_path, '/a');
+  assert.equal(rows[1].project_path, '/b');
+});
+
+test('consumeBaton: returns sessionId and deletes when within TTL', () => {
+  const db = makeDb();
+  writeBaton(db, { projectPath: '/proj', sessionId: 'S1', now: 1000 });
+  const result = consumeBaton(db, {
+    projectPath: '/proj',
+    now: 1000 + 30 * 60 * 1000, // 30 min後
+    ttlMs: BATON_TTL_MS,
+  });
+  assert.equal(result.sessionId, 'S1');
+  assert.equal(result.ageMs, 30 * 60 * 1000);
+
+  const rows = db.prepare('SELECT * FROM handoff_batons').all();
+  assert.equal(rows.length, 0, 'baton should be deleted after consumption');
+});
+
+test('consumeBaton: returns expired when age exceeds TTL, still deletes', () => {
+  const db = makeDb();
+  writeBaton(db, { projectPath: '/proj', sessionId: 'S1', now: 1000 });
+  const result = consumeBaton(db, {
+    projectPath: '/proj',
+    now: 1000 + 2 * 60 * 60 * 1000, // 2 時間後
+    ttlMs: BATON_TTL_MS,
+  });
+  assert.equal(result.sessionId, null);
+  assert.equal(result.skipReason, 'expired');
+  assert.ok(result.ageMs > BATON_TTL_MS);
+
+  const rows = db.prepare('SELECT * FROM handoff_batons').all();
+  assert.equal(rows.length, 0, 'expired baton should still be deleted');
+});
+
+test('consumeBaton: returns missing when no baton exists', () => {
+  const db = makeDb();
+  const result = consumeBaton(db, { projectPath: '/proj', now: 1000 });
+  assert.equal(result.sessionId, null);
+  assert.equal(result.skipReason, 'missing');
+});
+
+test('consumeBaton: scopes per project_path (does not cross-consume)', () => {
+  const db = makeDb();
+  writeBaton(db, { projectPath: '/a', sessionId: 'A', now: 1000 });
+  const result = consumeBaton(db, { projectPath: '/b', now: 1000 });
+  assert.equal(result.sessionId, null);
+  assert.equal(result.skipReason, 'missing');
+
+  // /a のバトンは残っているはず
+  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/install.mjs

@@ -19,6 +19,7 @@ import { homedir } from 'node:os';
 const SC_COMMANDS = [
   'throughline process-turn',
   'throughline session-start',
+  'throughline prompt-submit',
   // 旧コマンド（アンインストール時に除去する）
   'throughline inject-context',
   'throughline capture-tool',
@@ -35,6 +36,9 @@ const SC_HOOKS = {
   Stop: {
     hooks: [{ type: 'command', command: 'throughline process-turn' }],
   },
+  UserPromptSubmit: {
+    hooks: [{ type: 'command', command: 'throughline prompt-submit' }],
+  },
 };
 
 function resolveSettingsPath(args) {
@@ -102,8 +106,9 @@ export async function run(args = []) {
   console.log(`  ${settingsPath}`);
   console.log('');
   console.log('有効な hooks:');
-  console.log('  SessionStart → throughline session-start  (セッション記録・記憶張り替え・L1/L2 注入)');
-  console.log('  Stop         → throughline process-turn   (L1 要約 + L2 本文保存 + L3 詳細保存)');
+  console.log('  SessionStart     → throughline session-start  (セッション記録・バトン消費・引き継ぎ注入)');
+  console.log('  Stop             → throughline process-turn   (L1 要約 + L2 本文保存 + L3 詳細保存)');
+  console.log('  UserPromptSubmit → throughline prompt-submit  (/tl バトン書き込み)');
   console.log('');
   console.log('  アンインストール: throughline uninstall');
 }

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（未知値判定に使う） */