throughline 0.3.25 → 0.4.0

package/.claude/commands/tl.md

@@ -4,27 +4,12 @@ description: 次の新規セッションに現セッションの記憶を引き
 
 Throughline の UserPromptSubmit hook が `/tl` を検出し、バトン（現セッション ID）を保存しました。
 
-次に必ずやること（スキップ厳禁）:
+これだけで完了です。**追加の操作は不要**。
 
-1. 今この時点の「中断地点の状態」を自分の文脈から思い出し、以下 4 項目を Markdown で整理する:
-   - **次の一手**: 今まさに何をやろうとしていたか（1-3 文、具体的に）
-   - **現在の方針 / 仮説**: 追っているバグの原因、設計の方向性、調査中の観点など
-   - **未解決の疑問**: 判断保留中の論点
-   - **進行中 TODO**: 完了済みを除いた現行 TODO（TodoWrite の最新状態や Plan の内容を踏まえて、意味のあるものだけ）
+このあと:
+- 1 時間以内に新セッションを開く（新 chat / VSCode 再起動など）と、Throughline がバトンを消費して前セッションの記憶 (L1 + L2 + L3 references) を新セッションに自動注入します
+- バトンは 1 時間で失効します
 
-2. Bash ツールで次のコマンドを実行し、stdin で上記 Markdown を流し込む:
+通常は `/clear` だけで自動引継ぎが発火するため、`/tl` は **`THROUGHLINE_DISABLE_AUTO_HANDOFF=1` で自動引継ぎを OFF にしているユーザー** または **`/clear` を経由せずに新セッションを開くケース** の明示意思マーカーとして使います。
 
-   ```bash
-   throughline save-inflight <<'EOF'
-   **次の一手**: ...
-   **現在の方針**: ...
-   **未解決の疑問**: ...
-   **進行中 TODO**:
-   - [ ] ...
-   - [ ] ...
-   EOF
-   ```
-
-Bash の出力 (`[throughline] in-flight memo saved (N chars) for next session`) がそのまま完了確認になります。追加のユーザーへの報告テキストは不要です。ツール呼び出し後は何も返さずターンを終えて構いません（必要なら一言だけ）。
-
-バトン（および in-flight メモ）は 1 時間で失効します。失効後に新セッションを開いた場合は引き継ぎは発火しません。
+ユーザーへの追加報告テキストは不要です。一言だけ完了を伝えるか、何も返さずターンを終えて構いません。

package/CHANGELOG.md

@@ -10,6 +10,55 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.4.0] — 2026-05-08
+
+### Breaking changes
+
+- **`/clear` で自動引継ぎがデフォルト ON** に変更。Claude Code 2.1.128 で
+  SessionStart hook の `source='clear'` が reliable になったため、`/clear` 後の
+  新セッションは自動的に前セッションの memory を merge + 注入する。
+  ([GitHub issue #49937](https://github.com/anthropics/claude-code/issues/49937)
+  は解決済み)
+- **`THROUGHLINE_DISABLE_AUTO_HANDOFF=1`** env var で auto path を OFF にできる。
+- **`/tl` の役割を明示意思マーカーに簡素化**。memo 4 項目入力の指示を削除し、
+  baton を立てるだけの slash command に。`/tl` は env で auto OFF にしている
+  ユーザー、または `/clear` を経由しない引継ぎに使う逃げ道。
+- **`/tl-trim` slash command 廃止**。memo 入力 + dry-run preview の役割を持って
+  いたが、memo 廃止と軽量化方針で役割なしに。Codex 経路の `throughline trim`
+  CLI は維持 (`--host codex` での guarded execute / preflight など)。
+- **`throughline save-inflight` CLI 削除**。memo 廃止に伴う除去。
+- **`updateBatonMemo` 関数削除**。`src/baton.mjs` の export から外した。
+- **schema v8 migration**: `handoff_batons.memo_text` 列を drop。
+- **注入内容を L1 + L2 + L3 references のみに簡素化**。memo セクション、
+  中断直前 thinking セクション、Claude 向け footer の使い方説明を削除。L2 全文
+  に「次に何をしようとしていたか」が含まれているため redundant。
+
+### Added
+
+- `src/db.mjs`: schema v8 migration (handoff_batons.memo_text 列 drop)。
+- `src/session-start.mjs`: 引継ぎ判定の 2 経路ロジック:
+  1. baton path: `consumeBaton` 先発で baton ありなら merge + 注入
+  2. auto path: baton 無し + `source='clear'` + env disable 無し で同 project の
+     最新 Claude unmerged session を自動 predecessor に merge + 注入
+- `inheritance-decision.log` に `triggered_path` / `auto_handoff_disabled`
+  フィールドを追加。`baton_has_memo` フィールドは削除。
+- `src/resume-context.mjs`: L3 references 一覧を注入テキストに追加
+  (Codex `renderCodexRolloutMemoryPreview` 形式の `- ${kind}:
+  \`throughline detail <time>\``)。Reading Contract / Continuation Instruction
+  も Codex 風 framing に揃えた。
+
+### Notes
+
+- `src/handoff-record.mjs` の memo / thinking projection は **維持**: Codex 側
+  (`codex-handoff.mjs`, `codex-resume.mjs`, `codex-handoff-smoke.mjs` など) が
+  `memory.inflightMemo` / `memory.latestThinking` を参照しているため。Claude
+  側は resume-context.mjs で「使わない」だけ。
+- `src/cli/trim.mjs` は **維持**: Codex 経路 (`--host codex`) と doctor
+  (`--trim --host claude`) で使う `describeTrimHost('claude')` の dry-run 表示
+  が依存しているため。`/tl-trim` slash command が無くなっても CLI は残る。
+- 既存 `~/.throughline/logs/inflight-memo.log` ファイルは新版で書き込まれない。
+  ユーザー側で手動削除可能。
+
 ## [0.3.25] — 2026-05-08
 
 ### Added

package/README.ja.md

@@ -126,60 +126,58 @@ L3 に保存された `kind` 別 (ツール入力 / ツール出力 / hook 出
 
 ---
 
-## 明示的引き継ぎ — `/tl` (in-flight メモ付き)
+## 引き継ぎ: `/clear` で自動、env で OFF、`/tl` で明示
 
-引き継ぎは **明示的** であり、自動ではありません。次セッションへ「ここから続けてほしい」と
-渡したいときは、現セッションで `/clear` または新規チャットを開く **前に** `/tl` を打ちます。
-`/tl` 無しの場合、新セッションはまっさらな状態で始まり、過去メモリは引き継がれません。
+Throughline 0.4.0 から引き継ぎは 2 経路:
 
-`/tl` は 2 つの仕事をします:
+### auto path (デフォルト): `/clear` で自動引き継ぎ
 
-1. **引き継ぎバトンの書き込み**。現在の `session_id` を `handoff_batons` テーブルへ、
-   `UserPromptSubmit` hook 経由で記録します。
-2. **現 Claude に in-flight メモを書かせる**。`/tl` は Claude に対し、
-   *次に何をしようとしていたか、現在の仮説、未解決の問い、進行中 TODO* を Markdown で
-   要約し、`throughline save-inflight` 経由でバトンの `memo_text` カラムに添付するよう
-   指示します。これにより、トランスクリプト再生だけでは保てない「いま考え中だった内容」を保存できます。
+Claude Code 2.1.128 以降は `/clear` 直後の SessionStart hook に
+`source='clear'` が確実に乗ります。Throughline がこれを検出して、前セッションの
+メモリを新セッションに自動 merge します。**ユーザー操作不要** — `/clear`
+だけで新チャットが「途中から」再開されます。
 
-次の `SessionStart` では、hook がバトンを読み、**1 時間以内** であれば
-そのセッションのメモリを `BEGIN IMMEDIATE` トランザクション内で
-`UPDATE session_id = ?` を使って決定論的にマージします。バトンはマージと
-原子的に消費 (削除) されるため、二重発火しません。注入される再開コンテキストは
-**「中断されたタスクの再開」** として再フレーミングされ、in-flight メモと最終ターンの
-拡張思考が先頭に来ることで、新 Claude は思考の途中から拾えます。
+`THROUGHLINE_DISABLE_AUTO_HANDOFF=1` を環境変数に立てると auto path を OFF にできます。
+
+### baton path (`/tl`): 明示意思マーカー
+
+次のいずれかのユーザー向け:
+
+- `THROUGHLINE_DISABLE_AUTO_HANDOFF=1` を立てている、**または**
+- `/clear` 経由しないで引き継ぎたい (新 chat / VSCode 再起動など)
+
+新セッションを開く前に `/tl` を打つと `UserPromptSubmit` hook が baton を書き、
+次の `SessionStart` (1 時間以内) が baton を消費して merge します。
+`source` 値関係なく発火します。
 
 ```
-Session A (/tl を打つ)  -----------> バトン書き込み
-                                          |
-                          /clear           |
-                             |             ▼
-                          Session B  ---- バトン読込 → A を B にマージ → バトン削除 ---->
-                             |
-                          (もう一度 /tl で更に渡せる)
+auto path:    Session A → /clear → Session B (A を auto-merge)
+baton path:   Session A → /tl → (新 chat / 再起動) → Session B (baton を消費して A を merge)
 ```
 
-明示的バトン方式を選んだ理由:
+### 注入されるもの
+
+両経路で同じ curated memory が注入されます:
 
-- **誤継承ゼロ**。並行ウィンドウや VSCode 再起動、同じリポジトリでの新規タスクが、
-  前セッションのメモリを誤って引き継ぐことはありません。`/tl` 明示時のみ発火。
-- **VSCode 拡張対応**。`SessionStart` hook の `source` フィールドは VSCode 拡張で
-  `/clear` 後も `"startup"` に書き換えられてしまう
-  ([issue #49937](https://github.com/anthropics/claude-code/issues/49937))。
-  source 判定は信用できないため、ユーザー駆動のバトンで回避。
-- **決定論的**。時間窓ヒューリスティック、PID 推測、祖先プロセス追跡なし。
-  ユーザーが意思を宣言し、hook が実行する。それだけ。
+- L1 サマリー (古い turn の一行要約)
+- L2 verbatim (直近 20 turn の本文)
+- L3 references (`throughline detail <時刻>` で引き出すコマンド一覧、本文は SQLite に残置)
 
-各マージ行は `origin_session_id` を保持するので、`/tl` を繰り返すと
+注入は **「中断されたタスクの再開」** として再フレーミングされます。L2 verbatim に
+最終 assistant turn (= 次に何をしようとしていたか) が含まれるため、別途 memo /
+extended thinking セクションは注入されません。
+
+各マージ行は `origin_session_id` を保持するので、繰り返し引き継ぐと
 記憶がチェーン状に蓄積します:
 
 ```
-S1 (4 ターン) --/tl,/clear--> S2 (S1 をマージ + 3 ターン追加) --/tl,/clear--> S3 (S2 をマージ + 5 ターン追加)
-                              origin=S1×4                                    origin=S1×4, S2×3, S3×5
+S1 (4 ターン) --/clear--> S2 (S1 を auto-merge + 3 ターン追加) --/clear--> S3 (S2 を auto-merge + 5 ターン追加)
+                          origin=S1×4                                    origin=S1×4, S2×3, S3×5
 ```
 
 ---
 
-## Codex sidecar と `/tl-trim` プレビュー
+## Codex sidecar と Codex trim
 
 Throughline の主軸は引き続き **Claude Code** です。Codex 対応は、Claude hooks /
 slash command / transcript / baton / resume behavior を置き換えるものではなく、
@@ -189,20 +187,11 @@ adapter / projection として追加されます。
 `codex-sidecar` が `summarize-l1` preset で設定されている場合はその要約に
 Codex sidecar を使えます。使えない場合は、従来どおり Claude Haiku 経路を使います。
 
-`/tl-trim` は現在 **dry-run のみ** です。何ターンを trim 候補にするか、
-どの recent context を残すか、どの curated memory を戻す必要があるかを表示します。
-automatic rollback / inject は host primitive の検証が終わるまで無効です。
-
-```bash
-throughline doctor --trim --host claude
-printf '**次の一手**: 今の実装を続ける\n' \
-  | throughline trim --dry-run --host claude --memo-stdin
-```
-
-重要なのは current-work framing です。L1/L2 をそのまま戻すだけだと、
-モデルがそれを「過去ログ」として読んでしまうことがあります。Throughline は recent L2 を
-active work thread として構造化し、古い仮説は後続の判断で上書きされ得ること、
-そして中断地点から続行することを、注入 memory の先頭と末尾で明示します。
+Codex 側 trim (= same-thread context trim) は `throughline trim --execute --host codex`
+で発火します。Claude 側は `/clear` での auto path 引継ぎが本線になったため、
+`/tl-trim` slash command は v0.4.0 で廃止されました。current-work framing は
+SessionStart 注入の Reading Contract / Continuation Instruction で同じ意図を
+継承しています。
 
 ---
 
@@ -238,13 +227,13 @@ throughline monitor --session <id-prefix>
 | `throughline monitor` | マルチセッション監視を起動 |
 | `throughline monitor --diag` | TTY/columns/env 診断ダンプ (描画バグ切り分け用) |
 | `throughline detail <時刻>` | あるターンの L2 本文と L3 ツール I/O を取得 (Claude が使う) |
-| `throughline save-inflight` | `/tl` から呼ばれ、現バトンに in-flight メモを添付 (stdin 経由) |
 | `throughline doctor` | Node バージョン、hook 登録状況、DB、PATH をチェック |
 | `throughline doctor --trim --host claude` | trim boundary と手動手順を診断 |
 | `throughline handoff-preview --session <id>` | Codex 向け `throughline_handoff` JSON projection を表示 |
 | `throughline codex-sidecar-diagnostics` | この project の `codex-sidecar` diagnostics status を確認 |
 | `throughline codex-sidecar-dry-run` | App Server を呼ばずに read-only sidecar request を正規化表示 |
-| `throughline trim --dry-run` | `/tl-trim` 用の dry-run preview。自動 rollback はしない |
+| `throughline trim --dry-run --host codex` | Codex same-thread trim の dry-run preview |
+| `throughline trim --execute --host codex` | Codex 同 thread の guarded rollback + DB memory inject |
 | `throughline doctor --session <id-prefix>` | 特定セッションの state/transcript ズレを診断 |
 | `throughline status` | DB 統計表示 (sessions / skeletons / bodies / details) |
 | `throughline --version` | インストール済みバージョンを表示 |
@@ -253,13 +242,12 @@ throughline monitor --session <id-prefix>
 
 | コマンド | 役割 |
 | --- | --- |
-| `/tl` | 引き継ぎバトンを書き込み + Claude に in-flight メモを書かせる |
-| `/tl-trim` | 現 Claude が current-work memo を書き、trim dry-run を実行 |
+| `/tl` | 引き継ぎバトンを書き込む (auto path を OFF にしているユーザー / `/clear` 経由しない引継ぎの逃げ道) |
 | `/sc-detail <時刻>` | 過去ターンの L2 本文と L3 ツール I/O を取得 |
 
-> `/tl` 発火時、Claude は Bash 経由で `throughline save-inflight` を呼びます。
-> 初回は許可確認が出るので、`Bash(throughline save-inflight:*)` を allowlist に
-> 追加すると以後の確認はスキップできます。
+> v0.4.0 から auto-handoff がデフォルト ON です。`/clear` だけで新セッションが
+> 「途中から」再開されます。`THROUGHLINE_DISABLE_AUTO_HANDOFF=1` で OFF にできます。
+> `/tl` は OFF 設定下、または `/clear` 経由しない引継ぎ用の明示マーカー。
 
 ---
 

package/README.md

@@ -141,66 +141,59 @@ of tool inputs, tool outputs, and hook output captured at L3 for that turn.
 
 ---
 
-## 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.
+## Inheritance: auto via `/clear`, opt-out via env, opt-in via `/tl`
+
+Throughline 0.4.0+ supports two inheritance paths:
+
+### auto path (default): `/clear` → automatic inheritance
+
+Since Claude Code 2.1.128, the SessionStart hook receives `source='clear'`
+reliably after `/clear`. Throughline detects this and automatically merges the
+previous session's memory into the new one. **No user action required** —
+just type `/clear` and the new chat resumes mid-thought.
+
+Set `THROUGHLINE_DISABLE_AUTO_HANDOFF=1` in your environment to opt out.
+
+### baton path (`/tl`): explicit inheritance signal
+
+For users who:
+
+- have `THROUGHLINE_DISABLE_AUTO_HANDOFF=1` set, **or**
+- want to inherit across a non-`/clear` boundary (new chat / VSCode restart),
+
+type `/tl` before opening the new session. The `UserPromptSubmit` hook writes
+a handoff baton; the next `SessionStart` (within 1 hour) consumes the baton
+and merges the previous session's memory, regardless of the `source` value.
 
 ```
-Session A (type /tl)  -----------> baton written
-                                       |
-                      /clear           |
-                         |             ▼
-                      Session B  ---- reads baton, merges A into B, deletes baton ---->
-                         |
-                      (type /tl again to hand off further)
+auto path:    Session A → /clear → Session B (auto-merges A)
+baton path:   Session A → /tl → (new chat / restart) → Session B (consumes baton, merges A)
 ```
 
-Why explicit baton instead of auto-inherit:
+### What gets injected
+
+Both paths inject the **same** curated memory:
 
-- **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.
+- L1 summaries (older turns, one-line)
+- L2 verbatim (most recent 20 turns, full text)
+- L3 references (`throughline detail <time>` retrieval commands; bodies stay in SQLite)
 
-Each merged row keeps its `origin_session_id`, so repeated `/tl` handoffs
+The injection is reframed as **"resuming an interrupted task"** rather than
+"reading past logs". The L2 verbatim already contains the last assistant
+turn — what Claude was about to do next — so no separate memo or extended
+thinking section is injected.
+
+Each merged row keeps its `origin_session_id`, so repeated handoffs
 accumulate memory through chains:
 
 ```
-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
+S1 (4 turns) --/clear--> S2 (auto-merges S1, adds 3 turns) --/clear--> S3 (auto-merges S2, adds 5 turns)
+                         origin=S1×4                                   origin=S1×4, S2×3, S3×5
 ```
 
 ---
 
-## Codex sidecar and `/tl-trim` preview
+## Codex sidecar and Codex trim
 
 Throughline is still **Claude Code first**. Codex support is an adapter layer:
 it can project the same `HandoffRecord` into a `throughline_handoff` JSON block,
@@ -241,11 +234,7 @@ summarization. When `codex-sidecar` is configured for `summarize-l1`,
 Throughline can use it for that step; otherwise it keeps the existing Claude
 Haiku path. This is an explicit compatibility mode, not silent auto-detection.
 
-`/tl-trim` starts from dry-run. It previews how many captured turns would be
-trimmed, what recent turns would remain, and what curated memory would need to
-be injected back.
-
-**Codex rollback / inject is enabled again.** The 2026-05-06 incident initially
+**Codex rollback / inject is enabled.** The 2026-05-06 incident initially
 looked like a rolled-back user prompt could reappear after VS Code restart /
 reconnect, but controlled model-visible rollback smokes did not reproduce that
 path. `throughline trim --execute --host codex` now sends the guarded
@@ -311,12 +300,9 @@ rollout text, not an exact host tokenizer measurement. If rollback candidate
 turns are `0`, there is no current trim saving under the active keep-recent
 setting.
 
-Claude primary remains manual-only for conversation rewind. Throughline can
-prepare the current-work memory preview, but it does not drive Claude Code's
-interactive rewind UI or claim an automatic Claude rewind path. After a manual
-conversation-only rewind, give Claude the preview from `/tl-trim` / `trim
---dry-run`; the preview uses the same active-work framing as Codex so restored
-L1/L2 reads as the current task rather than as a passive archive.
+Claude-side rewind UI itself is not driven by Throughline. The auto-handoff
+flow is `/clear` → new SessionStart → automatic injection of curated memory.
+Throughline does not invoke `/rewind` or any Claude Code internal command.
 
 Codex-primary setup has an installed Stop hook after global
 `throughline install`. In real sessions, verify capture rather than assuming it:
@@ -380,8 +366,8 @@ references while pointing back to the full `codex-resume` context. `--format
 item-json` returns a Codex developer-message item for hosts that accept
 structured item injection; it is a rendering surface only and does not mutate
 the Codex thread by itself. `--memo-stdin` prepends an explicit Codex-primary
-in-flight memo to that rendered context; this is the first Codex-side equivalent
-of `/tl`'s "what was I about to do next" signal, without touching Claude batons.
+current-work memo to that rendered context; this is a Codex-side opt-in for
+"what was I about to do next" signal, independent from the Claude `/tl` baton.
 `throughline codex-visibility-smoke` is the experimental mutation check for
 that rendered memory: it injects the active-work developer message and starts a
 marker-check model turn through the Codex app-server, so it requires the
@@ -650,7 +636,6 @@ entry to the `tasks` array yourself:
 | `throughline monitor [--all] [--session <id>]` | Run the multi-session token monitor                          |
 | `throughline monitor --diag`                   | Dump TTY/columns/env diagnostics (for debugging monitor render bugs) |
 | `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 doctor --session <id-prefix>`     | Diagnose a specific session — detect state/transcript drift, idle vs. stuck |
 | `throughline doctor --trim --host claude\|codex` | Diagnose trim host boundaries, manual procedure, and Codex host primitive blockage |
@@ -672,7 +657,7 @@ entry to the `tasks` array yourself:
 | `throughline codex-threads`                    | List read-only Codex thread id candidates for the current project |
 | `throughline codex-sidecar-diagnostics`        | Check `codex-sidecar` diagnostics status for this project     |
 | `throughline codex-sidecar-dry-run`            | Print a normalized read-only sidecar request without running the app server |
-| `throughline trim --dry-run`                   | Preview `/tl-trim` context trim memory and host boundary; does not rollback automatically |
+| `throughline trim --dry-run --host codex`      | Preview Codex same-thread context trim memory and host boundary; does not rollback automatically |
 | `throughline trim --preflight --host codex`    | Read/resume the explicit Codex thread and verify turn-count guards without rollback/inject |
 | `throughline trim --execute --host codex`      | Explicit Codex rollback-inject path; requires Codex thread identity, injectable DB memory, and rollout/app-server turn-count agreement |
 | `throughline status`                           | Print DB statistics (sessions, skeletons, bodies, details)   |
@@ -682,14 +667,13 @@ 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 |
-| `/tl-trim`    | Ask Claude to write a current-work memo and run trim dry-run      |
+| `/tl`         | Write a handoff baton (used as opt-in inheritance signal when `/clear` auto path is OFF or you skip `/clear`) |
 | `/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.
+> Auto-handoff is ON by default since v0.4.0: just type `/clear` and the new
+> chat resumes mid-thought. Set `THROUGHLINE_DISABLE_AUTO_HANDOFF=1` in your
+> environment to opt out. `/tl` is for users who opt out, or who want to
+> inherit across non-`/clear` boundaries (new chat / VSCode restart).
 
 Hook subcommands (invoked by Claude Code, not by humans):
 `session-start` (SessionStart), `process-turn` (Stop),
@@ -743,7 +727,7 @@ Schema v7:
 - `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` / `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.
+- `handoff_batons` — one row per `project_path`, with `session_id` and `created_at`. Consumed and deleted by the next `SessionStart` if within the 1-hour TTL. (v8 dropped the `memo_text` column when memo was retired in v0.4.0.)
 - `injection_log` — audit trail of injection events
 
 All memory tables carry an `origin_session_id` so rebonded rows keep their

package/bin/throughline.mjs

@@ -27,7 +27,7 @@
  *   throughline codex-threads # List read-only Codex thread id candidates
  *   throughline codex-sidecar-diagnostics # Check codex-sidecar availability
  *   throughline codex-sidecar-dry-run # Print normalized sidecar request
- *   throughline trim --dry-run # Preview same-session context trim plan
+ *   throughline trim --execute --host codex # Codex same-thread guarded trim
  *   throughline doctor        # 環境チェック
  *   throughline status        # DB 統計表示
  *   throughline --version     # バージョン表示
@@ -60,9 +60,6 @@ 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 'handoff-preview':
     await (await import('../src/cli/handoff-preview.mjs')).run(rest);
     break;
@@ -149,7 +146,6 @@ Usage:
   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 handoff-preview   Print Codex-facing throughline_handoff JSON
   throughline codex-capture     Capture active Codex rollout turns into DB
                               (requires --codex-thread-id or env thread id)
@@ -226,13 +222,15 @@ Usage:
                               Check codex-sidecar diagnostics status
   throughline codex-sidecar-dry-run
                               Print normalized read-only sidecar request
-  throughline trim --dry-run   Preview same-session context trim plan
-                              (Codex: accepts --codex-thread-id <id> or
+  throughline trim --dry-run --host codex
+                              Preview Codex same-thread context trim plan
+                              (accepts --codex-thread-id <id> or
                               THROUGHLINE_CODEX_THREAD_ID / CODEX_THREAD_ID)
                               (text preview accepts --preview-max-chars <n>)
-  throughline trim --preflight
-                              Codex-only app-server read/resume guard; does not rollback
-  throughline trim --execute  Codex rollback/inject guard; requires a Codex
+  throughline trim --preflight --host codex
+                              Codex app-server read/resume guard; does not rollback
+  throughline trim --execute --host codex
+                              Codex rollback/inject guard; requires a Codex
                               thread id, injectable DB memory, and matching
                               rollout/app-server turns
   throughline doctor            Check environment

package/docs/INHERITANCE_ON_CLEAR_ONLY.md

@@ -1,5 +1,18 @@
 # 引き継ぎ発火条件の絞り込み調査 & 実装計画
 
+> **Status (2026-05-08 update): 本書は履歴扱い**
+>
+> 当時 (2026-04-18) は VSCode 拡張 2.1.112 で `/clear` 後も `source='startup'` に
+> 潰される問題があり、バトン方式 (案 E) を採用した。その後 Claude Code 2.1.105
+> (VSCode `/clear` not clearing context fix) と 2.1.126 (Windows env fix) で
+> 段階的に修正され、**2.1.128 で `source='clear'` が reliable**になっている。
+>
+> 現行仕様 (v0.4.0): auto path (`/clear` で自動引継ぎ) + baton path (`/tl` 明示
+> マーカー) の 2 経路。`THROUGHLINE_DISABLE_AUTO_HANDOFF=1` で auto path を OFF
+> にできる。詳細は [THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md](THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md)。
+>
+> 本書は当時のバトン採用判断を残す履歴ドキュメント。
+
 ## Status (2026-04-18 更新)
 
 - **Phase 0 実機検証: 完了**

package/docs/PUBLIC_RELEASE_PLAN.md

@@ -78,7 +78,8 @@ schema v4 で PostToolUse (`capture-tool`) は廃止、L2/L3 は Stop 内で一
 | schema v4 migration（bodies 追加、judgments DROP） | [src/db.mjs](../src/db.mjs) |
 | schema v5 migration（details に kind / source_id 追加、L3 分離書き込み対応） | [src/db.mjs](../src/db.mjs) |
 | schema v6 migration（handoff_batons テーブル追加、`/tl` バトン引き継ぎ方式） | [src/db.mjs](../src/db.mjs), [src/baton.mjs](../src/baton.mjs) |
-| schema v7 migration（`handoff_batons.memo_text` カラム追加、in-flight メモ保存） | [src/db.mjs](../src/db.mjs), [src/baton.mjs](../src/baton.mjs), [src/cli/save-inflight.mjs](../src/cli/save-inflight.mjs) |
+| schema v7 migration（`handoff_batons.memo_text` カラム追加、in-flight メモ保存） | (v8 で memo_text drop、save-inflight 削除済み) |
+| schema v8 migration（`handoff_batons.memo_text` drop、`/clear` auto path 化、`save-inflight` / `/tl-trim` / `updateBatonMemo` 削除、注入を L1+L2+L3 refs のみに簡素化） | [src/db.mjs](../src/db.mjs), [src/session-start.mjs](../src/session-start.mjs), [src/resume-context.mjs](../src/resume-context.mjs), [docs/THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md](THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md) |
 | VSCode `.vscode/tasks.json` の自動プロビジョニング（token-monitor の folderOpen 自動起動） | [src/vscode-task.mjs](../src/vscode-task.mjs) |
 | Stop フック時の state.usage スナップショット（monitor の「止まって見える」問題の切り分け用） | [src/state-file.mjs](../src/state-file.mjs), [src/turn-processor.mjs](../src/turn-processor.mjs) |
 | `throughline doctor --session <id-prefix>` セッション診断（state/transcript ズレ検出） | [src/cli/doctor.mjs](../src/cli/doctor.mjs) |