throughline 0.4.0 → 0.4.1

package/CHANGELOG.md

@@ -10,6 +10,45 @@ 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

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,34 +141,42 @@ of tool inputs, tool outputs, and hook output captured at L3 for that turn.
 
 ---
 
-## Inheritance: auto via `/clear`, opt-out via env, opt-in via `/tl`
+## Inheritance: typed `/clear` and `/tl` write a baton, source-`clear` is the fallback
 
-Throughline 0.4.0+ supports two inheritance paths:
+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`).
 
-### auto path (default): `/clear` → automatic inheritance
+### baton path (primary): typed `/clear` or `/tl` → deterministic 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.
+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.
 
-### baton path (`/tl`): explicit inheritance signal
+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.
 
-For users who:
+```
+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)
+```
 
-- have `THROUGHLINE_DISABLE_AUTO_HANDOFF=1` set, **or**
-- want to inherit across a non-`/clear` boundary (new chat / VSCode restart),
+### auto path (fallback): `source='clear'` → heuristic inheritance
 
-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.
+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.
 
-```
-auto path:    Session A → /clear → Session B (auto-merges A)
-baton path:   Session A → /tl → (new chat / restart) → Session B (consumes baton, merges A)
-```
+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".
 
 ### What gets injected
 
@@ -667,17 +675,20 @@ Slash commands (invoked by the user in Claude Code):
 
 | Command       | What it does                                                      |
 | ------------- | ----------------------------------------------------------------- |
-| `/tl`         | Write a handoff baton (used as opt-in inheritance signal when `/clear` auto path is OFF or you skip `/clear`) |
+| `/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       |
 
-> 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).
+> 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
 
@@ -727,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` 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.)
+- `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
@@ -879,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>`.
 
 ---
@@ -902,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

@@ -242,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
 `);
 }

package/docs/INHERITANCE_ON_CLEAR_ONLY.md

@@ -1,17 +1,26 @@
 # 引き継ぎ発火条件の絞り込み調査 & 実装計画
 
-> **Status (2026-05-08 update): 本書は履歴扱い**
+> **Status (2026-05-09 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**になっている。
+> 段階的に修正され、**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)。
+> 現行仕様 (v0.4.1): **baton path (primary)** + auto path (fallback) の 2 経路。
+> typed `/clear` / `/tl` はどちらも UserPromptSubmit hook で baton を書き、次
+> SessionStart が確定的にそのセッションを引き継ぐ。auto path は VSCode 拡張
+> メニュー由来 `/clear` のように UserPromptSubmit に届かない経路のための
+> fallback で、`THROUGHLINE_DISABLE_AUTO_HANDOFF=1` で OFF にできる (typed
+> `/clear` / `/tl` は env と無関係に引き続き発火する)。詳細は
+> [THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md](THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md)。
 >
-> 本書は当時のバトン採用判断を残す履歴ドキュメント。
+> 本書は当時のバトン採用判断を残す履歴ドキュメント。「結局 baton primary に
+> 戻った」という結末は皮肉だが、当時の判断は VSCode 拡張側 source バグへの
+> 適切な対応だった。今回 baton primary を再採択した理由は (a) typed `/clear`
+> が UserPromptSubmit に確実に届く、(b) multi-window で「最新更新セッション
+> ≠ /clear したセッション」になる場合に heuristic が誤った前任を選ばない、
+> の 2 点。
 
 ## Status (2026-04-18 更新)
 

package/docs/PUBLIC_RELEASE_PLAN.md

@@ -134,6 +134,8 @@ schema v4 で PostToolUse (`capture-tool`) は廃止、L2/L3 は Stop 内で一
 | **npm 公開 (v0.3.25): Codex global Stop hook / skill install** | `throughline install` が Claude hooks / slash commands に加えて `~/.codex/hooks.json` に絶対 node + installed `bin/throughline.mjs codex-hook stop` を `async: false` で登録し、`~/.codex/config.toml` の `[features].codex_hooks = true` を有効化し、`~/.codex/skills/throughline` に `$throughline` skill を配置する。Codex App Server / VSCode host の PATH 差分で bare `throughline` が見えない可能性があるため、hook は Caveat と同じ絶対パス型に寄せる。既存 Caveat / Spotter などの Codex hooks は保持し、`throughline uninstall` は Throughline 管理の Codex hook / skill だけを削除する。既に bare command または `async: true` で登録済みの Throughline Codex Stop hook は次回 install で更新する。実環境では `codex exec --json` child thread `019dfd4f-93ff-7522-8f89-bd1e1996c8d7` が Stop hook で自然 capture され、`doctor --codex` の latest DB session が `codex:019dfd4f-93ff-7522-8f89-bd1e1996c8d7` に進むことを確認した。さらに絶対パス型へ更新後、child thread `019dfd5e-1248-7c11-8ddc-97e1b0701e10` でも latest DB session が `codex:019dfd5e-1248-7c11-8ddc-97e1b0701e10` に進むことを確認した。hook shape 変更後に新規開始した VSCode-origin thread `019dfd62-9a9d-7211-bf91-89d8e3fc908e` でも `doctor --codex` の current thread と latest DB session が一致し、自然 Stop hook capture を確認済み。hook shape 変更前から開いていた VSCode-origin parent thread は、変更後の自然 Stop smoke としては扱わない。Caveat 側にも `async: false` Stop hook が動く実測があるため、Codex 側は Caveat と同じ同期 hook 方針に寄せる。`codex-capture` / `codex-summarize` / `codex-resume --memo-stdin` は診断・明示操作 surface として維持し、model-visible smoke は明示 opt-in。2026-05-08 以降、Stop hook auto-refresh は verified usage 90% 以上で guarded rollback / inject を試行し、estimate usage では mutation しない |
 | **npm 公開 (v0.3.25): Codex-first roadmap** | [THROUGHLINE_CODEX_FIRST_ROADMAP.md](THROUGHLINE_CODEX_FIRST_ROADMAP.md) を追加。次フェーズは Codex primary 実用化、Codex Rewind 互換、Claude 側 finalization の順で進める。Codex primary の L2→L1 backend は Codex CLI を本線とし、`codex-sidecar` は Claude primary からの review / risk-check / second opinion / 互換 L2→L1 経路として整理する |
 | **npm 公開 (v0.3.25): npm docs packaging** | README から参照する `docs/` と `CHANGELOG.md` を npm `files` に追加。`docs/throughline-handoff-context.example.json` を含め、README の sidecar dry-run 例が tarball 内でも成立するようにする |
+| **npm 公開 (v0.4.0): /clear auto-handoff + memo / save-inflight / /tl-trim retire** | 2026-05-08 Claude Code 2.1.128 で `source='clear'` が reliable になったため、`/clear` で自動引継ぎがデフォルト ON になる auto path を追加。`THROUGHLINE_DISABLE_AUTO_HANDOFF=1` で OFF にできる。`/tl` slash command は明示意思マーカーへ簡素化 (memo 4 項目入力廃止、`save-inflight` CLI 削除、`/tl-trim` slash command 廃止、`updateBatonMemo` 関数削除、`handoff_batons.memo_text` を schema v8 で drop)。注入は L1 + L2 + L3 references のみに簡素化し、memo / 中断直前 thinking セクションを削除。Codex 側 trim path は維持。詳細は [CHANGELOG.md](../CHANGELOG.md) と [THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md](THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md) |
+| **npm 公開 (v0.4.1): typed `/clear` も baton を書く + 2 経路の優先順位入れ替え** | 2026-05-09 `/clear` を UserPromptSubmit hook で検出した時点で当該セッションの `session_id` を `handoff_batons` に書き込み、次 SessionStart が確定的にそのセッションを引き継ぐ。これで multi-window で「最新更新セッション ≠ /clear したセッション」になるシナリオで `findLatestClaudePredecessor` heuristic が誤った前任を選ぶ問題を解消。2 経路の優先順位を **baton path = primary、auto path = fallback** に変更 (auto path は VSCode 拡張メニュー由来など UserPromptSubmit に届かない経路のフォールバック)。`THROUGHLINE_DISABLE_AUTO_HANDOFF=1` は fallback path のみに作用するようになった (typed `/clear` / `/tl` は env と無関係に発火する)。あわせて `.vscode/tasks.json` を git 追跡から外し (gitignore)、`ensureMonitorTaskFile` が hook 発火ごとに絶対パスを書き換える挙動による別環境での dirty diff を解消。`src/prompt-submit.test.mjs` を新設し、`isClearCommand` / `isBatonCommand` 判定 14 件と subprocess+DB 実体テスト 3 件を追加。詳細は [CHANGELOG.md](../CHANGELOG.md) |
 | **グローバル E2E 検証** | 2026-04-17 別ディレクトリから `throughline doctor` 全緑を確認 |
 
 ### ❌ 未完タスク

package/docs/THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md

@@ -7,6 +7,16 @@ A 案 (= /clear で自動引継ぎ + /tl は逃げ道として残す + /tl-trim
 > 過去の経緯 (なぜ `/tl` バトンを採用したか) は [INHERITANCE_ON_CLEAR_ONLY.md](INHERITANCE_ON_CLEAR_ONLY.md) を参照。
 > 本書は **2026-05-08 時点の現状検証 + 新理想設計** を扱う。
 
+> **2026-05-09 (v0.4.1) update**: 2 経路の優先順位を **入れ替えた**。
+> baton path が **primary**、auto path は **fallback**。理由: typed `/clear`
+> は UserPromptSubmit に届くので baton 書き込みで確定的に当該セッションを
+> 指名できる。一方 VSCode 拡張のメニュー由来 `/clear` は UserPromptSubmit
+> に届かない (= `findLatestClaudePredecessor` heuristic が誤った前任を選ぶ
+> リスクあり) ため、auto path を残してフォールバック化した。typed `/clear`
+> も UserPromptSubmit hook で baton を書く ([src/prompt-submit.mjs](../src/prompt-submit.mjs))。
+> `THROUGHLINE_DISABLE_AUTO_HANDOFF=1` は **fallback path のみに作用** する
+> ようになった (typed `/clear` / `/tl` には効かない)。
+
 ---
 
 ## 1. 確定した事実 (実機検証済み)
@@ -57,28 +67,33 @@ source: [code.claude.com/docs/en/hooks](https://code.claude.com/docs/en/hooks)
 
 ## 2. 採用する理想設計
 
-### 2.1 引継ぎ発火条件 (2 経路)
+### 2.1 引継ぎ発火条件 (2 経路、v0.4.1 で baton primary に変更)
 
 | 経路 | 条件 | 起動 |
 |---|---|---|
-| **auto path** | `source='clear'` かつ env `THROUGHLINE_DISABLE_AUTO_HANDOFF` の値が `'1'` でない | 自動引継ぎ |
-| **baton path** | `handoff_batons` テーブルに TTL (1 時間) 内 baton あり (= ユーザーが `/tl` を打った) | `source` 値関係なく引継ぎ |
+| **baton path (primary)** | `handoff_batons` テーブルに TTL (1 時間) 内 baton あり (= ユーザーが `/tl` または `/clear` を打った) | `source` 値関係なく確定的に引継ぎ |
+| **auto path (fallback)** | baton 不在 + `source='clear'` + env `THROUGHLINE_DISABLE_AUTO_HANDOFF` が `'1'` でない | `findLatestClaudePredecessor` heuristic で引継ぎ |
 
 判定ロジック (擬似コード):
 
 ```
+on UserPromptSubmit(prompt, session_id, project_path):
+  if isBatonCommand(prompt) or isClearCommand(prompt):
+    writeBaton(project_path, session_id, now)  // typed /clear / /tl が確定的に baton を書く
+
 on SessionStart(source, session_id, project_path):
   baton = consumeBaton(project_path)  // atomic SELECT + DELETE, TTL 超過は sessionId=null で返る
   if baton.sessionId:
-    inject(curated_memory)  // baton path
+    inject(curated_memory_from(baton.sessionId))  // baton path (primary, env 関係なく発火)
     return
   if source == 'clear' and env.THROUGHLINE_DISABLE_AUTO_HANDOFF != '1':
-    inject(curated_memory)  // auto path
+    predecessor = findLatestClaudePredecessor(project_path, session_id)
+    inject(curated_memory_from(predecessor))  // auto path (fallback)
     return
   // 何もしない
 ```
 
-`consumeBaton` が先発なので「両方同時成立」は構造上発生しない (= baton ありなら baton 経路、無ければ source 判定)。
+`consumeBaton` が先発なので「両方同時成立」は構造上発生しない (= baton ありなら baton 経路、無ければ source 判定)。typed `/clear` も UserPromptSubmit hook で baton を書くため、通常はほぼ常に baton path が走る。auto path は VSCode 拡張のメニュー由来 `/clear` のように UserPromptSubmit に届かない経路のためのフォールバック。
 
 ### 2.2 注入内容: L1 + L2 + L3 refs のみ (baton/auto どちらの経路でも同一)
 
@@ -105,10 +120,13 @@ on SessionStart(source, session_id, project_path):
   - `handoff_batons.memo_text` 列を **drop** (schema v8 migration)
   - `src/baton.mjs` の `updateBatonMemo` 関数を **削除** (memo_text 列が drop されるため)
 - `prompt-submit.mjs` の baton 書き込み path は **維持** (`UserPromptSubmit` hook で `/tl` 検出 + writeBaton)
+- v0.4.1 で `/clear` も同じ hook で baton を書くように拡張 ([src/prompt-submit.mjs](../src/prompt-submit.mjs) `isClearCommand`)
 
 ユーザーから見た `/tl` の使い方:
-- 自動引継ぎ ON (デフォルト): `/tl` を打たなくても `/clear` で自動引継ぎ。打っても挙動は同じ
-- 自動引継ぎ OFF (env で disable): `/tl` を打ってから新セッションスタートすれば baton 経由で引継ぎ
+- typed `/clear` (デフォルト): `/clear` を打った時点で baton が書かれ、次セッションが確定的に引継ぐ。`/tl` を打つ必要なし
+- VSCode メニュー `/clear` 経由: UserPromptSubmit に届かないので baton は書かれず、auto path (fallback) が `findLatestClaudePredecessor` で前任を選ぶ
+- 非 `/clear` 境界 (新規 chat / VSCode 再起動): `/tl` で baton を立ててから新セッションを開く
+- env で auto OFF: typed `/clear` / `/tl` は引き続き動く (env は fallback 専用)
 
 ### 2.4 `/tl-trim` 廃止 (Codex 側を壊さない)
 

package/package.json

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

package/src/cli/install.mjs

@@ -415,7 +415,7 @@ export async function run(args = []) {
   console.log('有効な hooks:');
   console.log('  SessionStart     → throughline session-start  (セッション記録・バトン消費・引き継ぎ注入)');
   console.log('  Stop             → throughline process-turn   (L1 要約 + L2 本文保存 + L3 詳細保存)');
-  console.log('  UserPromptSubmit → throughline prompt-submit  (/tl バトン書き込み)');
+  console.log('  UserPromptSubmit → throughline prompt-submit  (/tl & /clear バトン書き込み)');
   if (codex) {
     console.log(`  Codex Stop       → ${buildCodexStopHookCommand()} (Codex rollout capture + L1 要約)`);
   }

package/src/hook-entrypoints.test.mjs

@@ -98,6 +98,89 @@ test('prompt-submit subprocess writes a /tl baton into an isolated DB', () => {
   }
 });
 
+test('prompt-submit subprocess writes a /clear baton (specific session marker)', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    const result = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        session_id: 'cleared-session',
+        cwd: project,
+        prompt: '/clear',
+      }),
+    });
+
+    assert.equal(result.status, 0, result.stderr);
+
+    const db = openDb(home);
+    const row = db.prepare('SELECT project_path, session_id FROM handoff_batons').get();
+    assert.equal(row.project_path, project);
+    assert.equal(row.session_id, 'cleared-session');
+    db.close();
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('prompt-submit: /clear baton overwrites previous /tl baton in same project', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    const tl = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({ session_id: 'session-A', cwd: project, prompt: '/tl' }),
+    });
+    assert.equal(tl.status, 0, tl.stderr);
+
+    const clear = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({ session_id: 'session-B', cwd: project, prompt: '/clear' }),
+    });
+    assert.equal(clear.status, 0, clear.stderr);
+
+    const db = openDb(home);
+    const row = db.prepare('SELECT session_id FROM handoff_batons').get();
+    assert.equal(row.session_id, 'session-B', 'most recent baton write wins');
+    db.close();
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('prompt-submit: non-baton prompt does not write any baton', () => {
+  const home = makeTempHome();
+  const project = makeTempProject();
+  try {
+    const result = runNode([join(REPO_ROOT, 'src/prompt-submit.mjs')], {
+      home,
+      cwd: project,
+      input: JSON.stringify({
+        session_id: 'session-X',
+        cwd: project,
+        prompt: 'hello world',
+      }),
+    });
+
+    assert.equal(result.status, 0, result.stderr);
+
+    if (existsSync(join(home, '.throughline', 'throughline.db'))) {
+      const db = openDb(home);
+      const row = db.prepare('SELECT COUNT(*) AS n FROM handoff_batons').get();
+      assert.equal(row.n, 0, 'a normal prompt must not create any baton');
+      db.close();
+    }
+  } finally {
+    rmSync(project, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
 test('session-start subprocess consumes baton and injects inherited resume context', () => {
   const home = makeTempHome();
   const project = makeTempProject();

package/src/prompt-submit.mjs

@@ -1,11 +1,17 @@
 #!/usr/bin/env node
 /**
- * UserPromptSubmit hook — /tl スラッシュコマンド検出 + バトン書き込み
+ * UserPromptSubmit hook — /tl & /clear スラッシュコマンド検出 + バトン書き込み
  *
  * stdin: { session_id, cwd, prompt, hook_event_name, ... }
  *
  * 動作:
  *   - prompt が /tl (単独 or /tl ... 形式) で始まっていればバトンを書き込んで終了
+ *   - prompt が /clear (単独 or /clear ... 形式) で始まっていれば、現セッションの
+ *     session_id をバトンに書き込んで終了。
+ *     (これにより SessionStart 側の findLatestClaudePredecessor heuristic に頼らず、
+ *      確定的に「/clear が打たれたセッション」を新セッションに引き継げる。複数
+ *      VSCode ウィンドウ等で「最新更新セッション = clear されたセッション」が
+ *      成立しない multi-window シナリオで誤った前任を選ばないための確定的指名)
  *   - それ以外は何もせず exit 0（プロンプトはそのまま Claude に渡る）
  *   - 本 hook は注入を一切行わない (SessionStart の引き継ぎ注入と二重にならないため)
  *
@@ -43,6 +49,18 @@ export function isBatonCommand(prompt) {
   return false;
 }
 
+/**
+ * プロンプトが /clear バトン発動コマンドか判定する。
+ * 許容: "/clear", "/clear\n", "/clear 何か" (前後空白は trim 済み前提)
+ */
+export function isClearCommand(prompt) {
+  if (typeof prompt !== 'string') return false;
+  const trimmed = prompt.trim();
+  if (trimmed === '/clear') return true;
+  if (trimmed.startsWith('/clear ') || trimmed.startsWith('/clear\n')) return true;
+  return false;
+}
+
 export async function run() {
   let raw = '';
   await new Promise((resolve) => {
@@ -66,7 +84,10 @@ export async function run() {
     process.stderr.write(`[vscode-task] ${msg}\n`);
   }
 
-  if (!isBatonCommand(prompt)) {
+  const tlMatch = isBatonCommand(prompt);
+  const clearMatch = !tlMatch && isClearCommand(prompt);
+
+  if (!tlMatch && !clearMatch) {
     process.exit(0);
     return;
   }
@@ -87,6 +108,7 @@ export async function run() {
     ts: new Date(now).toISOString(),
     session_id,
     project_path: projectPath,
+    trigger: tlMatch ? 'tl' : 'clear',
   });
 
   process.exit(0);

package/src/prompt-submit.test.mjs

@@ -0,0 +1,66 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { isBatonCommand, isClearCommand } from './prompt-submit.mjs';
+
+test('isBatonCommand: bare /tl', () => {
+  assert.equal(isBatonCommand('/tl'), true);
+});
+
+test('isBatonCommand: /tl with trailing newline', () => {
+  assert.equal(isBatonCommand('/tl\n'), true);
+});
+
+test('isBatonCommand: /tl with leading/trailing whitespace', () => {
+  assert.equal(isBatonCommand('  /tl  '), true);
+});
+
+test('isBatonCommand: /tl with arguments', () => {
+  assert.equal(isBatonCommand('/tl some memo'), true);
+});
+
+test('isBatonCommand: rejects /tl-prefixed identifier', () => {
+  assert.equal(isBatonCommand('/tldr summary'), false);
+});
+
+test('isBatonCommand: rejects /clear', () => {
+  assert.equal(isBatonCommand('/clear'), false);
+});
+
+test('isBatonCommand: rejects empty / non-string', () => {
+  assert.equal(isBatonCommand(''), false);
+  assert.equal(isBatonCommand(null), false);
+  assert.equal(isBatonCommand(undefined), false);
+  assert.equal(isBatonCommand(42), false);
+});
+
+test('isClearCommand: bare /clear', () => {
+  assert.equal(isClearCommand('/clear'), true);
+});
+
+test('isClearCommand: /clear with trailing newline', () => {
+  assert.equal(isClearCommand('/clear\n'), true);
+});
+
+test('isClearCommand: /clear with leading/trailing whitespace', () => {
+  assert.equal(isClearCommand('  /clear  '), true);
+});
+
+test('isClearCommand: /clear with arguments', () => {
+  assert.equal(isClearCommand('/clear something'), true);
+});
+
+test('isClearCommand: rejects /clear-prefixed identifier', () => {
+  assert.equal(isClearCommand('/cleared'), false);
+  assert.equal(isClearCommand('/clearcache'), false);
+});
+
+test('isClearCommand: rejects /tl', () => {
+  assert.equal(isClearCommand('/tl'), false);
+});
+
+test('isClearCommand: rejects empty / non-string', () => {
+  assert.equal(isClearCommand(''), false);
+  assert.equal(isClearCommand(null), false);
+  assert.equal(isClearCommand(undefined), false);
+  assert.equal(isClearCommand(42), false);
+});