throughline 0.3.25 → 0.4.1

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,94 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.4.1] — 2026-05-09
+
+### Changed
+
+- **`/clear` も baton を書き込むように変更**。UserPromptSubmit hook で `/clear`
+  を検出した時点で当該セッションの `session_id` を `handoff_batons` に書き、
+  次の新規 SessionStart が確定的にそのセッションを引き継ぐ。これにより、複数
+  VSCode ウィンドウなどで「最新更新セッション ≠ /clear したセッション」になる
+  シナリオで `findLatestClaudePredecessor` heuristic が誤った前任を選ぶ問題を
+  解消。
+- **2 経路の優先順位を入れ替え**: baton path が **primary**、`source='clear'`
+  の auto path は **fallback**。auto path は `/clear` が UserPromptSubmit hook
+  に届かない経路 (例: VSCode 拡張のメニュー由来) のためのフォールバック扱い。
+
+### Added
+
+- `src/prompt-submit.mjs`: `isClearCommand` 判定 (`/clear`, `/clear ...`,
+  前後空白許容、`/cleared` / `/clearcache` 等の prefix 偽陽性は拒否)。
+- `~/.throughline/logs/baton-write.log` の `trigger` フィールドに
+  `'tl' | 'clear'` を記録。
+- `src/prompt-submit.test.mjs`: `isBatonCommand` / `isClearCommand` の判定
+  テスト 14 件。
+- `src/hook-entrypoints.test.mjs`: `/clear` baton の subprocess+DB 実体テスト
+  3 件 (`/clear` 書き込み / `/tl` → `/clear` 後勝ち上書き / 通常 prompt は no-op)。
+
+### Notes
+
+- 既存の `THROUGHLINE_DISABLE_AUTO_HANDOFF=1` env は **fallback path のみに作用**
+  するようになった。typed `/clear` は env に関係なく baton 書き込み → 引継ぎ発火
+  する (= ユーザーが明示的に `/clear` を打った時点で「続けたい」という意思表示
+  と解釈する)。auto path (VSCode メニュー由来) には引き続き env が効く。
+
+### Repository hygiene
+
+- `.vscode/tasks.json` を git 追跡から外す (`.gitignore` に追加)。
+  `ensureMonitorTaskFile` が hook 発火ごとに絶対パスを書き換えるため、追跡
+  対象に置くと別 OS / 別マシンで毎回 dirty diff が出続けていた。各マシンでは
+  初回 hook 発火時に自動生成される。
+
+## [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

@@ -22,10 +22,10 @@ throughline install     # registers Claude hooks, Codex Stop hook, and Codex ski
 ```
 
 That's it. Open any Claude Code session and your turns flow into
-`~/.throughline/throughline.db` automatically. After 50 turns of work, type
-`/clear` (or just open a new chat), then `/tl` first if you want the next
-session to inherit the memory — the new session resumes mid-thought instead
-of starting from zero.
+`~/.throughline/throughline.db` automatically. After 50 turns of work, just
+type `/clear` — the new session resumes mid-thought instead of starting from
+zero. (For non-`/clear` boundaries such as a brand-new chat or a VSCode
+restart, type `/tl` first to mark the predecessor.)
 
 Global install also registers a Codex Stop hook in `~/.codex/hooks.json` and
 enables `[features].codex_hooks = true` in `~/.codex/config.toml`. The Codex
@@ -42,8 +42,8 @@ status, resume, summarize, or trim without typing the full guarded command.
 |---|---|---|---|
 | **Compression axis** | content **type** (text vs tool I/O) | **recency** (old → summarized) | none |
 | **Coding-assistant fit** | high — tool I/O is the heavy 80% | medium — also compresses what you want to keep | — |
-| **`/clear` survival** | ✅ via SQLite + `/tl` baton | depends on host | ❌ |
-| **Auto-inheritance risk** | zero (explicit `/tl`) | high | — |
+| **`/clear` survival** | ✅ via SQLite + typed `/clear` / `/tl` baton | depends on host | ❌ |
+| **Auto-inheritance risk** | low (typed `/clear` or `/tl` names the predecessor) | high | — |
 | **Runtime deps** | **zero** (Node 22.5+ built-in `node:sqlite`) | many | — |
 | **Multi-session token monitor** | ✅ Claude real `message.usage`; Codex rollout `token_count` when available | — | — |
 
@@ -141,66 +141,67 @@ 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: typed `/clear` and `/tl` write a baton, source-`clear` is the fallback
+
+Throughline 0.4.1+ supports two inheritance paths. The **baton path is the
+primary route**; the source-`clear` auto path is the fallback for cases where
+the user's `/clear` does not reach the `UserPromptSubmit` hook (for example
+the VSCode extension's menu-driven `/clear`).
+
+### baton path (primary): typed `/clear` or `/tl` → deterministic inheritance
+
+When the user types `/clear` or `/tl` in the prompt, the `UserPromptSubmit`
+hook writes a handoff baton with **that session's `session_id`** into the
+`handoff_batons` table. The next `SessionStart` (within the 1-hour TTL)
+consumes the baton and merges that exact predecessor's memory into the new
+session, regardless of the `source` value.
+
+This path is deterministic: it names the predecessor by id rather than
+guessing, so multi-window scenarios where "most recently updated session"
+does not equal "the session you just `/clear`-ed" still inherit correctly.
 
 ```
-Session A (type /tl)  -----------> baton written
-                                       |
-                      /clear           |
-                         |             ▼
-                      Session B  ---- reads baton, merges A into B, deletes baton ---->
-                         |
-                      (type /tl again to hand off further)
+typed /clear: Session A → /clear → Session B (consumes A's baton, merges A)
+typed /tl:    Session A → /tl    → (new chat / restart) → Session B (consumes baton, merges A)
 ```
 
-Why explicit baton instead of auto-inherit:
+### auto path (fallback): `source='clear'` → heuristic inheritance
+
+Since Claude Code 2.1.128, the SessionStart hook receives `source='clear'`
+reliably after `/clear`. When no baton is present (for example because the
+`/clear` was triggered by the VSCode extension's menu and never reached
+`UserPromptSubmit`), Throughline falls back to `findLatestClaudePredecessor`
+to pick the most recent unmerged session for the same project and merges it.
 
-- **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.
+Set `THROUGHLINE_DISABLE_AUTO_HANDOFF=1` in your environment to opt out of
+this fallback. **The env var only affects the fallback**; typed `/clear` and
+`/tl` still write a baton and inherit because the user explicitly signalled
+"continue this work".
 
-Each merged row keeps its `origin_session_id`, so repeated `/tl` handoffs
+### What gets injected
+
+Both paths inject the **same** curated memory:
+
+- 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)
+
+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 +242,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 +308,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 +374,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 +644,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 +665,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,18 +675,20 @@ 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 (explicit inheritance signal across non-`/clear` boundaries — new chat / VSCode restart) |
+| `/clear`      | Built-in Claude Code reset. Throughline's `UserPromptSubmit` hook also writes a baton so the next session inherits the cleared session's memory |
 | `/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.
+> Since v0.4.1, both `/clear` and `/tl` typed in the prompt write a baton
+> identifying the current session, so the next `SessionStart` deterministically
+> inherits that exact predecessor. The `source='clear'` auto path remains as a
+> fallback for `/clear` triggered outside `UserPromptSubmit` (for example via
+> the VSCode extension menu); `THROUGHLINE_DISABLE_AUTO_HANDOFF=1` only opts
+> out of that fallback.
 
 Hook subcommands (invoked by Claude Code, not by humans):
 `session-start` (SessionStart), `process-turn` (Stop),
-`prompt-submit` (UserPromptSubmit — detects `/tl` and writes baton).
+`prompt-submit` (UserPromptSubmit — detects `/tl` and `/clear` and writes a baton).
 
 ### `throughline detail` — for AI, not humans
 
@@ -743,7 +738,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`. Written by the `UserPromptSubmit` hook when the user types `/tl` or `/clear`. 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
@@ -895,9 +890,15 @@ 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
+Since v0.4.1, both typed `/clear` and `/tl` write a baton, and the auto path
+falls back on `source='clear'` for menu-driven `/clear`. If inheritance still
+did not happen, the most likely cause is one of: (a) the previous session was
+never recorded (no Stop hook fired — check `throughline status`), (b) the
+1-hour baton TTL expired before the new session opened, (c) the new session's
+`project_path` (cwd) differs from the previous one, so they live in different
+session chains, or (d) you set `THROUGHLINE_DISABLE_AUTO_HANDOFF=1` and the
+`/clear` came from the VSCode menu which never reaches `UserPromptSubmit`.
+Memory is still in SQLite — you can retrieve specific turns with
 `/sc-detail <time>`.
 
 ---
@@ -918,8 +919,11 @@ Run the monitor directly without a global install:
 node src/token-monitor.mjs
 ```
 
-The `.vscode/tasks.json` in this repo auto-launches the monitor when you open
-the folder in VS Code.
+When any Throughline hook fires for the first time in a folder, it
+auto-generates `.vscode/tasks.json` with an absolute path to the monitor
+executable for the current machine. The file is **gitignored** (since v0.4.1)
+because the absolute path is per-machine. Reload the VS Code window after
+the first generation to pick up the auto-start task.
 
 ---
 

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
@@ -244,7 +242,7 @@ Usage:
 Hook subcommands (called by Claude Code / Codex):
   throughline session-start   SessionStart hook
   throughline process-turn    Stop hook
-  throughline prompt-submit   UserPromptSubmit hook (/tl baton writer)
+  throughline prompt-submit   UserPromptSubmit hook (/tl & /clear baton writer)
   throughline codex-hook stop Codex Stop hook
 `);
 }