throughline 0.4.5 → 0.4.7

package/CHANGELOG.md

@@ -10,6 +10,31 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.4.7] — 2026-05-09
+
+### Changed
+
+- Codex Stop hook auto-refresh now uses an 80% verified-usage threshold instead
+  of 90%, so Throughline can refresh before Codex native auto-compact while
+  still staying above the monitor's 70% warning band. Estimate-only usage and
+  estimated context windows still do not mutate the thread.
+- Token monitor now discovers active Codex rollout files directly from
+  `~/.codex/sessions/**/rollout-*.jsonl`, so current Codex sessions appear even
+  when the Codex Stop hook has not written a Throughline state file.
+- Token monitor now displays Codex session ids as the raw first 8 thread-id
+  characters (`019e085c`) instead of the confusing prefixed slice (`codex:01`).
+  Codex in-flight turns still overlay transient `output_tokens` in the token
+  count, but the model column no longer adds a separate `live+<tokens>` marker.
+
+## [0.4.6] — 2026-05-09
+
+### Changed
+
+- Codex monitor usage now overlays transient `output_tokens` while a Codex turn
+  is open. During an in-flight turn the row displays `input_tokens +
+  output_tokens` and marks the model with `live+<tokens>`; after `task_complete`
+  the row drops back to verified `input_tokens` only.
+
 ## [0.4.5] — 2026-05-09
 
 ### Fixed

package/README.ja.md

@@ -18,13 +18,13 @@
 
 ```bash
 npm install -g throughline
-throughline install     # ~/.claude/settings.json に hook を登録
+throughline install     # hook / Codex skill / VS Code monitor task を登録
 ```
 
 これだけ。Claude Code のセッションを開けば、以後すべてのターンが
 `~/.throughline/throughline.db` に自動で流れていく。50 ターン作業した後、
-次のセッションへ記憶を引き継ぎたければ `/clear` の前に `/tl` を打つ。新セッションは
-ゼロからのスタートではなく、**思考の途中から再開** される。
+`/clear` を打てば新セッションはゼロからではなく、**思考の途中から再開** される。
+`/clear` を経由しない新規 chat / VS Code 再起動では `/tl` で前任を指名できる。
 
 ## 他の手段との比較
 
@@ -32,10 +32,10 @@ throughline install     # ~/.claude/settings.json に hook を登録
 |---|---|---|---|
 | **圧縮の軸** | コンテンツの **種類** (テキスト vs ツール I/O) | **新旧** (古い → 要約) | 無し |
 | **コーディング用途への適合** | 高 — ツール I/O こそ重い 80% | 中 — 残したい部分まで圧縮される | — |
-| **`/clear` 後の生存** | ✅ SQLite + `/tl` バトン | ホスト依存 | ❌ |
-| **誤継承リスク** | ゼロ (明示的な `/tl`) | 高 | — |
+| **`/clear` 後の生存** | ✅ SQLite + typed `/clear` / `/tl` バトン | ホスト依存 | ❌ |
+| **誤継承リスク** | 低 (typed `/clear` / `/tl` が前任を指名) | 高 | — |
 | **ランタイム依存** | **ゼロ** (Node 22.5+ 同梱の `node:sqlite`) | 多数 | — |
-| **マルチセッション トークン監視** | ✅ 実測 `message.usage`、`len/4` 推定なし | — | — |
+| **マルチセッション トークン監視** | ✅ Claude 実測 `message.usage`、Codex rollout `token_count` | — | — |
 
 <details>
 <summary><b>なぜこれが効くのか — 80% ツール I/O 問題</b></summary>
@@ -126,33 +126,34 @@ L3 に保存された `kind` 別 (ツール入力 / ツール出力 / hook 出
 
 ---
 
-## 引き継ぎ: `/clear` で自動、env で OFF、`/tl` で明示
+## 引き継ぎ: typed `/clear` / `/tl` が前任を指名、source-`clear` は補助
 
-Throughline 0.4.0 から引き継ぎは 2 経路:
+Throughline 0.4.1+ の引き継ぎは 2 経路です。主経路は typed `/clear` または
+`/tl` が書く baton で、`source='clear'` の auto path は `/clear` が
+UserPromptSubmit hook に届かない場合の補助です。
 
-### auto path (デフォルト): `/clear` で自動引き継ぎ
+### baton path (primary): typed `/clear` または `/tl`
 
-Claude Code 2.1.128 以降は `/clear` 直後の SessionStart hook に
-`source='clear'` が確実に乗ります。Throughline がこれを検出して、前セッションの
-メモリを新セッションに自動 merge します。**ユーザー操作不要** — `/clear`
-だけで新チャットが「途中から」再開されます。
+ユーザーが prompt に `/clear` または `/tl` を打つと、UserPromptSubmit hook が
+**そのセッションの** `session_id` を `handoff_batons` に書きます。次の
+SessionStart は 1 時間以内の baton を消費し、その前任を確定的に merge します。
+複数ウィンドウで「最新更新セッション」と「今 `/clear` したセッション」が違っても、
+指名された前任だけを引き継ぎます。
 
-`THROUGHLINE_DISABLE_AUTO_HANDOFF=1` を環境変数に立てると auto path を OFF にできます。
+### auto path (fallback): `source='clear'`
 
-### baton path (`/tl`): 明示意思マーカー
+baton が無く、SessionStart の `source='clear'` が届いた場合だけ、同 project の
+最新 Claude predecessor を選んで merge します。これは VS Code 拡張メニューなど、
+typed `/clear` が UserPromptSubmit hook に届かない経路のための補助です。
 
-次のいずれかのユーザー向け:
-
-- `THROUGHLINE_DISABLE_AUTO_HANDOFF=1` を立てている、**または**
-- `/clear` 経由しないで引き継ぎたい (新 chat / VSCode 再起動など)
-
-新セッションを開く前に `/tl` を打つと `UserPromptSubmit` hook が baton を書き、
-次の `SessionStart` (1 時間以内) が baton を消費して merge します。
-`source` 値関係なく発火します。
+`THROUGHLINE_DISABLE_AUTO_HANDOFF=1` はこの fallback path だけを OFF にします。
+typed `/clear` と `/tl` はユーザーの明示意思なので、この env に関係なく baton を
+書いて引き継ぎます。
 
 ```
-auto path:    Session A → /clear → Session B (A を auto-merge)
-baton path:   Session A → /tl → (新 chat / 再起動) → Session B (baton を消費して A を merge)
+typed /clear: Session A → /clear → Session B (A の baton を消費して merge)
+typed /tl:    Session A → /tl    → 新 chat / 再起動 → Session B (A の baton を消費して merge)
+fallback:     baton 無し + source='clear' → latest predecessor を merge
 ```
 
 ### 注入されるもの
@@ -214,8 +215,12 @@ throughline monitor --session <id-prefix>
 ```
 
 監視中は Claude transcript / Codex rollout をライブに読み、Stop hook の state
-snapshot はライブ usage が取れない場合の控えとして使います。これにより表示更新は
-Stop 完了待ちではなくなります。
+snapshot はライブ usage が取れない場合の控えとして使います。Codex については
+`~/.codex/sessions/**/rollout-*.jsonl` も直接 discovery するため、Stop hook が
+Throughline state をまだ書いていない現在セッションも表示できます。Codex は open turn
+中だけ `input_tokens + output_tokens` を表示し、`task_complete` 後は verified
+`input_tokens` のみに戻ります。表示 ID は `codex:01` ではなく、raw thread id の
+先頭 8 桁 (`019e085c` など) です。
 
 詳細仕様 (resize 追従、1M context 検出、ステイル隠し、Stop hook の非同期化など) は
 [英語版 README](README.md#multi-session-token-monitor) を参照してください。

package/README.md

@@ -250,7 +250,9 @@ reconnect, but controlled model-visible rollback smokes did not reproduce that
 path. `throughline trim --execute --host codex` now sends the guarded
 rollback + Throughline DB memory injection when app-server turn-count guards and
 injectable DB memory are available. Codex Stop hook auto-refresh also attempts
-the same live refresh when verified usage reaches the 90% threshold.
+the same live refresh when verified usage reaches the 80% threshold, which runs
+before Codex native auto-compact while staying above the monitor's 70% warning
+band.
 
 `throughline codex-host-primitive-audit` can inspect the installed Codex
 app-server schema read-only. On the current tested Codex CLI, it finds
@@ -508,7 +510,7 @@ Example output:
 ```
 [Throughline] 1 セッション
 ▶ Throughline       Claude 2ed5039c just now ██░░░░░░░░  205.1k /   1.0M  claude-opus-4-6
-  Throughline       Codex  codex:01 just now ██████░░░░  151.9k / 258.4k  gpt-5.5
+  Throughline       Codex  019e085c just now ██████░░░░  151.9k / 258.4k  gpt-5.5
 ```
 
 - **Claude token counts are accurate.** Read straight from the latest
@@ -517,13 +519,17 @@ Example output:
   (`input_tokens + cache_creation_input_tokens + cache_read_input_tokens`).
   No `length / 4` approximation.
 - **Codex token counts use the rollout `token_count` event when present.** The
-  Codex Stop hook writes `codex:<thread_id>` monitor state with the rollout
-  path. While the monitor is running it reads the live rollout every tick and
-  prefers the latest verified `token_count` sample. If a Codex rollout has no
-  token-count event, Throughline can show an explicit estimate with
-  `estimated: true` and the monitor marks it with `est`; it is not presented as
-  exact usage.
-- **Codex auto-refresh mutates at the verified 90% threshold.** The Codex Stop
+  monitor discovers live Codex rollouts directly from
+  `~/.codex/sessions/**/rollout-*.jsonl`, so a current Codex session can appear
+  even before the Codex Stop hook writes `codex:<thread_id>` monitor state.
+  While the monitor is running it reads the live rollout every tick and prefers
+  the latest verified `token_count` sample. During an open Codex turn, the
+  monitor overlays transient `output_tokens` on top of `input_tokens`; when
+  `task_complete` arrives it drops back to verified `input_tokens` only. If a
+  Codex rollout has no token-count event, Throughline can show an explicit
+  estimate with `estimated: true` and the monitor marks it with `est`; it is not
+  presented as exact usage.
+- **Codex auto-refresh mutates at the verified 80% threshold.** The Codex Stop
   hook captures DB memory, writes monitor state, and when verified usage reaches
   the threshold it attempts rollback + Throughline DB memory injection for the
   current thread.
@@ -531,11 +537,13 @@ Example output:
   transcript, falls back to string matching on `1M context`, and finally
   promotes to 1M if observed usage exceeds 200k.
 - **Multi-session view.** Each Claude Code or Codex session writes its own
-  state file (`~/.throughline/state/<session_id>.json`). Codex session ids are
-  stored as `codex:<thread_id>` in the JSON payload; filenames are URL-encoded
-  so the state directory remains portable. The monitor scans the directory every
-  second and displays one row per live session, sorted by last activity. The
-  most recent one is highlighted with `▶`.
+  state file (`~/.throughline/state/<session_id>.json`), and active Codex
+  rollouts are discovered directly from the Codex session directory. Codex
+  session ids are stored as `codex:<thread_id>` in JSON state, while the display
+  shows the raw first 8 thread-id characters (for example `019e085c`) to avoid
+  the ambiguous `codex:01` prefix slice. The monitor scans every second and
+  displays one row per live session, sorted by last activity. The most recent
+  one is highlighted with `▶`.
 - **Stale hiding.** Sessions that haven't been touched in 15 minutes drop out of
   the default view; files older than 24 hours are deleted entirely. This is the
   only time threshold in the system and is used solely for display hygiene — no

package/docs/PUBLIC_RELEASE_PLAN.md

@@ -119,7 +119,7 @@ schema v4 で PostToolUse (`capture-tool`) は廃止、L2/L3 は Stop 内で一
 | **npm 公開 (v0.3.24)** | 2026-05-02 v0.3.23 の補完: `.vscode/tasks.json` には現環境の絶対パスが書き込まれるため、**そもそも commit すべきではない**。`shouldRecommendGitignore` を [src/vscode-task.mjs](../src/vscode-task.mjs) に追加し、`ensureMonitorTaskFile` が created / merged / repaired を返すタイミングで「git リポジトリ内かつ `.gitignore` に `.vscode/tasks.json` 系エントリが無い」を判定。該当時に `<system-reminder>` で `.gitignore` 追加推奨を 1 度だけ stdout 通知 (`.throughline-gitignore-noted` marker で抑止)。否定パターン (`!.vscode/tasks.json`) はスキップ判定 = 推奨を出す。README Troubleshooting にも明示。配布物 (npm tarball) には絶対パスは入っていない (`files` フィールドが `.vscode/` を含まない、ソースに hard-coded path 無し) ことを再確認 |
 | **npm 公開 (v0.3.25): Claude-primary / Codex-sidecar groundwork** | `HandoffRecord` projection、`throughline handoff-preview`、`throughline_handoff` example、`codex-sidecar-diagnostics` / `codex-sidecar-dry-run` を追加。Claude Code hooks / slash command / transcript / baton / resume behavior は正本として維持し、Codex 対応は adapter / projection として足す |
 | **npm 公開 (v0.3.25): optional Codex-sidecar L1 summarization** | Claude primary の L2→L1 要約は、`codex-sidecar` が `summarize-l1` preset で configured の場合だけ sidecar を使う。disabled / unavailable / run failure では、ユーザー許可済み互換経路として既存 Claude Haiku 要約を維持する。Codex primary の L2→L1 backend は次フェーズ計画で Codex CLI 本線として扱う。Claude CLI smoke / test で Claude を呼ぶ場合は Haiku を使う |
-| **npm 公開 (v0.3.25): `/tl-trim` dry-run** | `throughline trim --dry-run`、`--preflight`、guarded `--execute`、`--host`、`--keep-recent`、`--all`、`--memo-stdin`、`--preview-max-chars`、`--codex-thread-id`、`THROUGHLINE_CODEX_THREAD_ID` / `CODEX_THREAD_ID`、`throughline codex-threads`、`throughline doctor --trim`、Claude slash command `/tl-trim` を追加。Codex app-server の rollback / inject primitive は live app-server 上で実測済み。2026-05-06 incident 後は一時 blocked としたが、2026-05-08 の controlled rollback model-visible smoke が app-server restart 境界と VS Code reload/reconnect 境界の両方で `not-reproduced` だったため、過剰 blocker は解除済み。`trim --execute --host codex` は明示実行で current-thread rollback + Throughline DB memory inject を送り、Codex Stop hook auto-refresh は verified usage 90% 以上で同じ guarded path を試行する。DB memory 不在、Codex thread identity 不在、rollout/app-server turn-count 不一致は mutation 前に拒否する。restore-safety / planned restore-safety / host primitive audit は diagnostics として表示する |
+| **npm 公開 (v0.3.25): `/tl-trim` dry-run** | `throughline trim --dry-run`、`--preflight`、guarded `--execute`、`--host`、`--keep-recent`、`--all`、`--memo-stdin`、`--preview-max-chars`、`--codex-thread-id`、`THROUGHLINE_CODEX_THREAD_ID` / `CODEX_THREAD_ID`、`throughline codex-threads`、`throughline doctor --trim`、Claude slash command `/tl-trim` を追加。Codex app-server の rollback / inject primitive は live app-server 上で実測済み。2026-05-06 incident 後は一時 blocked としたが、2026-05-08 の controlled rollback model-visible smoke が app-server restart 境界と VS Code reload/reconnect 境界の両方で `not-reproduced` だったため、過剰 blocker は解除済み。`trim --execute --host codex` は明示実行で current-thread rollback + Throughline DB memory inject を送り、Codex Stop hook auto-refresh は verified usage 80% 以上で同じ guarded path を試行する。DB memory 不在、Codex thread identity 不在、rollout/app-server turn-count 不一致は mutation 前に拒否する。restore-safety / planned restore-safety / host primitive audit は diagnostics として表示する |
 | **npm 公開 (v0.3.25): Codex primary capture** | `throughline codex-capture --codex-thread-id <id>` を追加。Codex rollout JSONL の active turns を `codex:<thread_id>` session として DB `bodies` に保存し、`function_call` / `function_call_output` を DB `details` の L3 tool input / output として保存する。`thread_rolled_back` 適用後の active thread だけを再構成し、rollback 済み tail は current L2/L3 に残さない。Codex thread id は明示指定または env 指定のみで、自動推測しない |
 | **npm 公開 (v0.3.25): Codex-primary L1 backend** | `summarizeToL1` に `hostMode` 分岐を追加。Claude primary は既存の `codex-sidecar` / Claude Haiku 互換経路を維持し、Codex primary は Codex CLI backend を使う。Codex CLI failure は `source = codex-cli` / `reason` 付き explicit error とし、Claude Haiku / `raw_l2` に silent fallback しない |
 | **npm 公開 (v0.3.25): Codex-primary L1 CLI** | `throughline codex-summarize --session codex:<thread_id>` を追加。captured Codex L2 が L2 window を超えた場合、最古の未要約 turn を Codex CLI backend で L1 skeleton に書く。Codex CLI failure は explicit error |
@@ -131,11 +131,12 @@ schema v4 で PostToolUse (`capture-tool`) は廃止、L2/L3 は Stop 内で一
 | **npm 公開 (v0.3.25): Codex VS Code restore smoke protocol** | `throughline codex-vscode-restore-smoke --prepare/--verify --codex-thread-id <id>` を追加。`--prepare` は hidden active-work marker memory を app-server へ注入し、VS Code reload / reconnect 後に marker を含まない prompt を送る二段階手順を出す。`--verify` は rollout を読み、prepare 後の marker-free smoke prompt、assistant の marker-only answer、user prompt への marker leak 不在を確認する。prepare は `THROUGHLINE_EXPERIMENTAL_CODEX_VSCODE_RESTORE_SMOKE=1` 必須。実 VS Code reload / reconnect marker proof は `TL_CODEX_VSCODE_RESTORE_46888202` で成功済み。ただしこれは hidden developer memory visibility 証明であり、rollback 済み user turn の非復活証明ではない |
 | **npm 公開 (v0.3.25): Codex VS Code rollback smoke verifier** | `throughline codex-vscode-rollback-smoke --verify --codex-thread-id <id>` を追加。rollout を read-only で読み、rollback event、rollback 済み user text、rollback 後 user turn、`restoreSafety.status = ok` を必須条件にする。`--after-vscode-restart` がある場合だけ `restartSafe: true` を返す。実 incident-shaped live rollback run では `thread_rolled_back` と injected memory は記録されたが、rollback 対象 user text が `compacted.replacement_history` に残り、後続 verifier では rollback 済み user text の再出現も観測した。後続分類で app-server response 上の retained text は `aggregatedOutput` に限定され、controlled rollback model-visible smoke は再現しなかったため、これは現在は diagnostic evidence として扱う |
 | **npm 公開 (v0.3.25): Codex primary doctor** | `throughline doctor --codex` を追加。現在 project の Codex thread env identity、rollout candidates、captured `codex:<thread_id>` DB sessions、context-refresh memory contract、new-thread handoff readiness、safe continuation status、host primitive audit status、次に使う capture / handoff / resume / audit command を表示する。doctor 自体は read-only で、Codex thread / DB / Claude settings を変更しない。`doctor --trim --host codex` も host primitive audit status を表示する |
-| **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 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 80% 以上で guarded rollback / inject を試行し、estimate usage では mutation しない。2026-05-09 以降は Codex native auto-compact より先に Throughline refresh を走らせつつ、70% warning よりは 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) |
+| **npm 公開 (v0.4.7): Codex monitor direct discovery + 80% auto-refresh** | 2026-05-09 Codex Stop hook auto-refresh の verified usage threshold を 90% から 80% に変更し、Codex native auto-compact より先に Throughline DB memory refresh を試行する。estimate usage / estimated context window では mutation しない。`throughline monitor` は `~/.throughline/state` に加えて `~/.codex/sessions/**/rollout-*.jsonl` を直接 discovery し、Throughline state が未生成の現在 Codex thread も表示する。既存 state がある場合は state の usage snapshot を保持しつつ discovered rollout path / mtime を合流する。Codex 表示 ID は `codex:01` ではなく raw thread id 先頭 8 桁 (`019e085c`) にした。Codex open turn の transient `output_tokens` は token count に overlay するが、モデル欄の `live+<tokens>` marker は表示しない |
 | **グローバル E2E 検証** | 2026-04-17 別ディレクトリから `throughline doctor` 全緑を確認 |
 
 ### ❌ 未完タスク
@@ -147,7 +148,7 @@ schema v4 で PostToolUse (`capture-tool`) は廃止、L2/L3 は Stop 内で一
 | **GitHub Actions 自動 publish** | `release` タグ push をトリガー（Phase 3+、Trusted Publishing 使用） |
 | **Claude Code プラグインマーケットプレース登録** | npm 公開の後継ステップ（Phase 3+） |
 | **turn-processor.test.mjs の 10 秒タイムアウト解消** | `main()` が stdin を待ち続けるためテストファイルがハングする既存の問題。実装動作は無影響、テスト個別 9/9 は pass |
-| **automatic context rollback / inject** | Codex Stop hook auto-refresh は verified usage 90% 以上で guarded rollback + Throughline DB memory inject を試行する。controlled rollback model-visible smoke で復活が未再現となったため、2026-05-06 incident 後の overbroad blocker は解除済み。estimate usage では実行しない |
+| **automatic context rollback / inject** | Codex Stop hook auto-refresh は verified usage 80% 以上で guarded rollback + Throughline DB memory inject を試行する。controlled rollback model-visible smoke で復活が未再現となったため、2026-05-06 incident 後の overbroad blocker は解除済み。estimate usage では実行しない |
 
 ---
 

package/docs/THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md

@@ -278,7 +278,7 @@ Codex 側 v0.3.25 の以下は本計画で **完全に無変更**:
 - `codex-capture` / `codex-summarize` / `codex-resume` (Codex primary L1/L2/L3 path)
 - `codex-resume --format handoff` (新規 Codex thread 用 prompt)
 - `trim --execute --host codex` / `--preflight --host codex` (app-server `thread/rollback` + `thread/inject_items`)
-- Codex Stop hook 90% auto-refresh
+- Codex Stop hook 80% auto-refresh
 - restore-safety / host primitive audit diagnostics
 - Codex skill ([codex/skills/throughline](../codex/skills/throughline)) の trim 機能 (= 機能自体は無変更、SKILL.md 内の `/tl-trim` 言及があれば 4 TODO で update)
 - [src/codex-app-server.mjs](../src/codex-app-server.mjs), [src/codex-rollout-memory.mjs](../src/codex-rollout-memory.mjs)

package/docs/THROUGHLINE_CODEX_FIRST_ROADMAP.md

@@ -28,7 +28,7 @@
 - Claude-primary の現行 L2 -> L1 要約は `codex-sidecar` が configured の場合に sidecar を優先し、使えない場合は Claude Haiku 経路に戻る。Codex-primary は Codex CLI backend 失敗を明示 error にし、Claude Haiku / raw L2 へ fallback しない。
 - Codex guarded trim は、Codex app-server の `thread/read` / `thread/resume` / `thread/rollback` / `thread/inject_items` を使う。明示 thread identity、rollout/app-server turn count guard、injectable memory がない場合は mutation 前に拒否する。
 - Claude `/rewind` 自動化はまだ有効化しない。
-- Codex automatic refresh mutation は再有効化済み。`90%` の verified usage threshold で rollback / Throughline DB memory inject を試行し、estimate usage では実行しない。
+- Codex automatic refresh mutation は再有効化済み。`80%` の verified usage threshold で rollback / Throughline DB memory inject を試行し、estimate usage では実行しない。Codex native auto-compact より先に Throughline refresh を走らせつつ、70% warning よりは mutation を遅らせる。
 
 ## 新セッション引き継ぎ
 
@@ -466,9 +466,9 @@ Phase 5 implementation status (2026-05-06):
   - 削減量の記録: `trim --dry-run --host codex` は rollout text がある場合に `contextReductionEstimate` を返す。2026-05-06 の現在 thread `019dfd62-9a9d-7211-bf91-89d8e3fc908e` では通常 keep-recent preview だと `capturedTurns = 14` / `keepRecent = 20` のため `rollbackTurns = 0`、推定削減量も 0 だった。旧 bare `$throughline` context refresh は `--all` を使っていたため、この keep-recent preview の 0 は「Codex で削減できない」という意味ではない。
   - historical live-only `$throughline` context refresh smoke: 同じ VSCode-origin thread `019dfd62-9a9d-7211-bf91-89d8e3fc908e` で `trim --dry-run --host codex --all --json` -> `trim --preflight --host codex --all --json` -> `trim --execute --host codex --all` を実行した。preflight は rollout/app-server turn count `20 / 20` match、execute は `rollbackSent = true`、`injectSent = true`、`injectedItems = 1`、`rollback candidate turns = 20`。直前見積もりは `rollbackEstimatedTokens = 179780`、`injectedMemoryEstimatedTokens = 2009`、`netEstimatedTokens = 177771`、`reductionPct = 99` (`chars / 4` heuristic)。これは live app-server smoke であり、restart-safe durability の証明ではない。
   - post-refresh confirmation: execute 後の次 user turn で `doctor --codex` は current thread と latest DB session の一致を維持し、latest DB session は `2026-05-06 22:41:10` へ更新された。`trim --dry-run --host codex --all --json` は `activeTurns = 2`、`rollbackEvents = 1`、`rolledBackTurns = 20` を返し、`codex-resume` は rollback 後の短い active work context を L2 として描画した。
-  - monitor adapter 修正: `throughline monitor` は Claude / Codex host-aware state を読む。Codex Stop hook は `codex:<thread_id>` monitor state を書き、Codex rollout path は Claude transcript 用 `transcriptPath` ではなく `rolloutPath` に保存する。rollout に `event_msg` / `token_count` がある場合は verified usage として表示し、無い場合だけ `estimated: true` / `source = codex-rollout-chars-div-4` の明示 estimate を使う。state filename は URL encode し、`codex:` session id を Windows でも保存可能にした。
+  - monitor adapter 修正: `throughline monitor` は Claude / Codex host-aware state を読む。Codex Stop hook は `codex:<thread_id>` monitor state を書き、Codex rollout path は Claude transcript 用 `transcriptPath` ではなく `rolloutPath` に保存する。2026-05-09 以降、monitor は `~/.throughline/state` だけでなく `~/.codex/sessions/**/rollout-*.jsonl` も直接 discovery するため、state 未生成の現在 Codex thread も表示できる。既存 state がある場合は usage snapshot を保持しつつ discovered rollout path / mtime を合流する。rollout に `event_msg` / `token_count` がある場合は verified usage として表示し、無い場合だけ `estimated: true` / `source = codex-rollout-chars-div-4` の明示 estimate を使う。state filename は URL encode し、`codex:` session id を Windows でも保存可能にした。表示 ID は `codex:` prefix を外した raw thread id 先頭 8 桁。
   - monitor doctor 修正: Codex Stop hook stdout は VSCode chat に必ず見えるとは限らないため、`doctor --codex` に `.vscode/tasks.json` の Throughline Monitor task 診断を追加した。登録済み / 未登録 / JSONC / parse error / broken absolute path と `runOn`、および初回作成後は `Developer: Reload Window` が必要という note を read-only で表示する。
-  - historical automatic refresh 実装: Codex Stop hook は capture / L1 summarize / monitor state 書き込み後、verified usage が verified context window の `90%` 以上なら automatic refresh を試行する経路を持っていた。2026-05-06 incident 後、この経路は blocker として扱い、monitor state / warning / diagnostics は残しても rollback + inject は送らない。
+  - historical automatic refresh 実装: Codex Stop hook は capture / L1 summarize / monitor state 書き込み後、verified usage が verified context window の `90%` 以上なら automatic refresh を試行する経路を持っていた。2026-05-06 incident 後、この経路は blocker として扱い、monitor state / warning / diagnostics は残しても rollback + inject は送らない状態にした。2026-05-08 unblock 後は guarded rollback / inject を再有効化し、2026-05-09 以降は Codex native auto-compact より先に Throughline refresh を走らせるため verified usage `80%` 以上を既定閾値にする。
 
 ## Phase 6: Claude Side Finalization
 

package/docs/THROUGHLINE_CODEX_MONITOR_IMPLEMENTATION_PLAN.md

@@ -2,6 +2,9 @@
 
 Status: implemented
 Date: 2026-05-06
+Amended: 2026-05-09 — monitor now also discovers Codex rollouts directly
+from `~/.codex/sessions/**/rollout-*.jsonl`, so Codex visibility no longer
+depends on the Stop hook writing a Throughline state file.
 
 この計画は、既存の Claude-primary monitor 経路を置き換えずに、
 `throughline monitor` へ Codex 対応を追加するためのもの。
@@ -24,6 +27,10 @@ Codex 対応では、既存 monitor contract の周辺に Codex adapter / projec
 Claude hooks、transcript parsing、slash command、baton、resume behavior は rename / 劣化
 させない。
 
+2026-05-09 以降は、Codex Stop hook が state を書く経路に加えて、
+monitor reader 自体が Codex rollout index を直接 discovery する。これにより、
+host が Stop hook をまだ dispatch していない現在 thread でも monitor に表示される。
+
 ## 非目的
 
 - Claude transcript usage parsing を置き換えない。
@@ -39,6 +46,8 @@ Monitor reader:
 
 - `throughline monitor` は `src/token-monitor.mjs` に dispatch される。
 - `~/.throughline/state/` の session state files を読む。
+- Codex については `~/.codex/sessions/**/rollout-*.jsonl` から現在 project の
+  rollout candidates も読む。`--all` または `--session` 時は全 project 候補を読む。
 - 現在の state file は主に次を持つ。
   `sessionId`, `projectPath`, `transcriptPath`, `pid`, `updatedAt`, optional `usage`
 - `state.usage` があれば monitor はそれをそのまま表示する。
@@ -50,6 +59,9 @@ Monitor reader:
 - `pid` は既存 state schema に残っているが、現行 stale 判定は `updatedAt` ベース。
   Codex Stop hook は短命 process なので、Codex の active 判定に hook process PID を
   意味づけない。
+- state file が無い Codex rollout candidate は、monitor 内で synthetic state として扱う。
+  既存 state がある場合は、state の `usage` snapshot を保持しつつ discovered
+  `rolloutPath` / `updatedAt` を合流する。
 
 Claude writer:
 
@@ -148,6 +160,8 @@ adapter 側に置く。
 - Claude state + real usage: 既存どおり表示。
 - Codex state + estimated usage: token bar を表示し、`est` marker を付ける。
 - Codex state + usage 無し: active session として表示し、token usage は未取得扱い。
+- Codex discovered rollout + state 無し: synthetic Codex state として表示し、live rollout
+  usage を読む。表示 ID は `codex:` prefix を外した raw thread id 先頭 8 桁にする。
 
 ### 5. VSCode monitor task provision を Codex にも接続する
 
@@ -181,6 +195,9 @@ Codex Stop hook でも、Claude hooks と同じく
 - [x] Codex context window が未検証の場合は `contextWindowEstimated: true` を保持する。
 - [x] `src/cli/codex-hook.mjs` で Codex Stop hook state writing を追加する。
 - [x] monitor session id は `codex:<thread_id>` にする。
+- [x] monitor が Codex rollout を直接 discovery し、state 未生成の current thread も表示する。
+- [x] discovered rollout と既存 Codex state を merge し、state の usage snapshot を保持する。
+- [x] Codex 表示 ID は `codex:` prefix を外した raw thread id 先頭 8 桁にする。
 - [x] Codex state の `pid` を active 判定に使わないことを test / docs で固定する。
 - [x] Codex state では `transcriptPath: null` とし、rollout path は `rolloutPath` に保存する。
 - [x] Codex Stop hook から `ensureMonitorTaskFile` を呼ぶ。
@@ -203,6 +220,8 @@ Codex Stop hook でも、Claude hooks と同じく
 ## 受け入れ条件
 
 - Codex Stop hook capture 後、`throughline monitor` に現在の Codex session が出る。
+- Codex Stop hook state が無くても、現在 project の Codex rollout があれば
+  `throughline monitor` に現在の Codex session が出る。
 - Claude monitor behavior は既存どおり。
 - Codex session は Codex と分かる。
 - Codex token usage が estimate の場合、estimate と分かる。

package/docs/THROUGHLINE_CODEX_TRIM_IMPLEMENTATION_PLAN.md

@@ -372,13 +372,13 @@ Phase 6 result (2026-05-06):
 - `thread/inject_items` に raw Responses API item `{ type: "message", role: "developer", content: [{ type: "input_text", text: "..." }] }` を渡し、次の `turn/start` で injected memory が model-visible になることを確認した。marker `TL_PHASE6_INJECT_OK` を正しく返した。
 - その後の Codex primary 実装で、`codex-resume` が描画する active-work developer message も実 Codex host で model-visible になることを確認した。marker `TL_CODEX_VISIBLE_REAL_20260506_C` が `item/agentMessage/delta` に出た。詳細な実測値は [THROUGHLINE_CODEX_FIRST_ROADMAP.md](THROUGHLINE_CODEX_FIRST_ROADMAP.md) の Phase 3 result を正とする。
 - さらに `thread/inject_items` 後にもう一度 `thread/resume` してから `turn/start` を呼ぶ smoke も追加し、実 Codex host で marker `TL_CODEX_RESUME_AFTER_INJECT_REAL_20260506` が `item/agentMessage/delta` に出ることを確認した。
-- Codex host primitive は live app-server 上では実測済み。ただし restart-safe durability は未証明。現在は明示 `--codex-thread-id` または env thread identity と rollout/app-server turn count guard が live mutation の最低条件であり、durable success は別分類で扱う。2026-05-06 incident 後はいったん Codex Stop hook 後の automatic refresh mutation を blocked としたが、2026-05-08 unblock 後は verified usage 90% 以上で guarded rollback / inject を試行する。
+- Codex host primitive は live app-server 上では実測済み。ただし restart-safe durability は未証明。現在は明示 `--codex-thread-id` または env thread identity と rollout/app-server turn count guard が live mutation の最低条件であり、durable success は別分類で扱う。2026-05-06 incident 後はいったん Codex Stop hook 後の automatic refresh mutation を blocked としたが、2026-05-08 unblock 後は guarded rollback / inject を試行する。2026-05-09 以降は Codex native auto-compact より先に Throughline refresh を走らせるため、verified usage 80% 以上を既定閾値にする。
 - Claude `/rewind conversation only` は手動 UX として扱う。外部ツールからの自動化 surface は未確認。Claude host の automatic rollback / inject は `manual-only`。
 - Phase 8 では dry-run / preflight を本線にしつつ、Codex だけ guarded execute を追加した。Claude は manual-only のまま扱う。
 
 完了条件:
 
-- [x] rollback trim を自動実装してよい host と、手動案内に留める host が判断できる。Codex は 2026-05-08 unblock 後、verified usage 90% 以上の Stop hook auto-refresh と明示 execute を許可する。Claude は manual-only。
+- [x] rollback trim を自動実装してよい host と、手動案内に留める host が判断できる。Codex は 2026-05-08 unblock 後、Stop hook auto-refresh と明示 execute を許可する。2026-05-09 以降の auto-refresh 既定閾値は verified usage 80%。Claude は manual-only。
 
 ## Phase 7: Trim Handoff Model
 

package/docs/THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md

@@ -19,7 +19,7 @@ model-visible input に入ることは controlled smoke で再現していませ
 run の retained text は risk evidence として残す一方、単独では mutation 前 blocker にしません。
 Codex current-thread trim は、明示 `--execute`、Throughline DB injectable memory、
 Codex thread identity、rollout/app-server turn-count guard を条件に実行します。Codex Stop hook
-auto-refresh は verified usage 90% 以上で同じ guarded path を試行し、estimate usage では実行しません。
+auto-refresh は verified usage 80% 以上で同じ guarded path を試行し、estimate usage では実行しません。
 
 最初のインシデント仮説に対する重要な訂正:
 
@@ -644,7 +644,7 @@ TODO:
   という記述を訂正する。
 - [x] hypothesis を compacted replacement-history restore に言及する形へ更新する。
 - [x] Codex Rewind-equivalent trim が complete だという roadmap claim を格下げする。
-- [x] Codex auto-refresh は verified usage 90% 以上で guarded rollback / inject を
+- [x] Codex auto-refresh は verified usage 80% 以上で guarded rollback / inject を
   実行する。estimate usage では実行しない。
 - [x] 新セッションが古い「Codex side complete」claim ではなく、この fix plan から
   再開できるように `CLAUDE.md` を更新する。

package/docs/throughline-rollback-context-trim-insight.md

@@ -263,7 +263,7 @@ Codex で考えられる流れ:
 9. ユーザーは同じ Codex thread で続行する。
 ```
 
-現行実装では、Codex Stop hook 後の 90% automatic refresh は guarded rollback / inject
+現行実装では、Codex Stop hook 後の 80% automatic refresh は guarded rollback / inject
 mutation を試行する。明示 CLI の `throughline trim --execute --host codex --codex-thread-id <id>`
 も env gate なしで実行する。明示 Codex thread identity、injectable Throughline DB memory、
 rollout/app-server turn count guard は live mutation の最低条件であり、durable success は

package/package.json

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

package/src/cli/codex-hook.test.mjs

@@ -121,7 +121,7 @@ test('codex-hook stop captures rollout using Codex stdin payload fields', async
   }
 });
 
-test('codex-hook stop runs auto refresh when verified usage reaches 90%', async () => {
+test('codex-hook stop runs auto refresh when verified usage reaches 80%', async () => {
   const codexHome = mkdtempSync(join(tmpdir(), 'tl-codex-hook-home-'));
   const project = mkdtempSync(join(tmpdir(), 'tl-codex-hook-project-'));
   const threadId = '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9';

package/src/codex-auto-refresh.mjs

@@ -2,7 +2,7 @@ import { runCodexTrimExecution } from './codex-app-server.mjs';
 import { buildCodexRolloutTrimSource } from './codex-rollout-memory.mjs';
 import { buildTrimPlan } from './trim-model.mjs';
 
-export const CODEX_AUTO_REFRESH_THRESHOLD = 0.9;
+export const CODEX_AUTO_REFRESH_THRESHOLD = 0.8;
 
 export function evaluateCodexAutoRefreshUsage(usage, { threshold = CODEX_AUTO_REFRESH_THRESHOLD } = {}) {
   if (!usage) {

package/src/codex-auto-refresh.test.mjs

@@ -7,10 +7,10 @@ import {
   runCodexAutoRefresh,
 } from './codex-auto-refresh.mjs';
 
-test('evaluateCodexAutoRefreshUsage: default threshold is 90%', () => {
-  assert.equal(CODEX_AUTO_REFRESH_THRESHOLD, 0.9);
+test('evaluateCodexAutoRefreshUsage: default threshold is 80%', () => {
+  assert.equal(CODEX_AUTO_REFRESH_THRESHOLD, 0.8);
   const below = evaluateCodexAutoRefreshUsage({
-    tokens: 232_559,
+    tokens: 206_719,
     contextWindowSize: 258_400,
     estimated: false,
     contextWindowEstimated: false,
@@ -19,7 +19,7 @@ test('evaluateCodexAutoRefreshUsage: default threshold is 90%', () => {
   assert.equal(below.reason, 'below_threshold');
 
   const atThreshold = evaluateCodexAutoRefreshUsage({
-    tokens: 232_560,
+    tokens: 206_720,
     contextWindowSize: 258_400,
     estimated: false,
     contextWindowEstimated: false,

package/src/codex-usage.mjs

@@ -18,6 +18,7 @@ export function readLatestCodexUsage(rolloutPath) {
   let latest = null;
   let model = 'codex';
   let provider = null;
+  let openTaskCount = 0;
   for (const line of raw.split('\n')) {
     if (!line.trim()) continue;
     let row;
@@ -39,24 +40,43 @@ export function readLatestCodexUsage(rolloutPath) {
       continue;
     }
 
-    if (row?.type !== 'event_msg' || payload?.type !== 'token_count') continue;
+    if (row?.type !== 'event_msg') continue;
+
+    if (payload?.type === 'task_started') {
+      openTaskCount++;
+      continue;
+    }
+
+    if (payload?.type === 'task_complete') {
+      openTaskCount = Math.max(0, openTaskCount - 1);
+      continue;
+    }
+
+    if (payload?.type !== 'token_count') continue;
     const info = payload.info ?? {};
     const last = info.last_token_usage ?? {};
-    const tokens = Number(last.input_tokens);
-    if (!Number.isFinite(tokens) || tokens < 0) continue;
+    const inputTokens = Number(last.input_tokens);
+    if (!Number.isFinite(inputTokens) || inputTokens < 0) continue;
+    const outputTokens = Number.isFinite(Number(last.output_tokens)) ? Number(last.output_tokens) : 0;
+    const transientOutputTokens = openTaskCount > 0 ? outputTokens : 0;
 
     const windowSize = Number(info.model_context_window);
     latest = {
-      tokens,
+      tokens: inputTokens + transientOutputTokens,
+      inputTokens,
       model: model === 'codex' && provider ? provider : model,
       contextWindowSize:
         Number.isFinite(windowSize) && windowSize > 0
           ? windowSize
           : DEFAULT_CODEX_CONTEXT_WINDOW_SIZE,
       contextWindowEstimated: !(Number.isFinite(windowSize) && windowSize > 0),
-      outputTokens: Number.isFinite(Number(last.output_tokens)) ? Number(last.output_tokens) : 0,
+      outputTokens,
+      transientOutputTokens,
+      liveTurn: openTaskCount > 0,
       estimated: false,
-      source: 'codex-rollout-token-count',
+      source: openTaskCount > 0
+        ? 'codex-rollout-token-count-live-turn'
+        : 'codex-rollout-token-count',
     };
   }
 

package/src/codex-usage.test.mjs

@@ -44,10 +44,13 @@ test('readLatestCodexUsage: reads verified Codex token_count event shape', () =>
 
     assert.deepEqual(readLatestCodexUsage(rollout), {
       tokens: 151914,
+      inputTokens: 151914,
       model: 'gpt-5.5',
       contextWindowSize: 258400,
       contextWindowEstimated: false,
       outputTokens: 60,
+      transientOutputTokens: 0,
+      liveTurn: false,
       estimated: false,
       source: 'codex-rollout-token-count',
     });
@@ -56,6 +59,86 @@ test('readLatestCodexUsage: reads verified Codex token_count event shape', () =>
   }
 });
 
+test('readLatestCodexUsage: during an open Codex turn overlays transient output tokens', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-codex-usage-'));
+  try {
+    const rollout = join(dir, 'rollout.jsonl');
+    writeFileSync(
+      rollout,
+      [
+        row('session_meta', { id: '019dfaba-thread', cwd: '/repo' }),
+        row('turn_context', { turn_id: '019dfaba-turn', model: 'gpt-5.5' }),
+        event('task_started'),
+        event('token_count', {
+          info: {
+            last_token_usage: {
+              input_tokens: 151914,
+              output_tokens: 1200,
+            },
+            model_context_window: 258400,
+          },
+        }),
+      ]
+        .map((r) => JSON.stringify(r))
+        .join('\n') + '\n',
+    );
+
+    const usage = readLatestCodexUsage(rollout);
+    assert.equal(usage.tokens, 153114);
+    assert.equal(usage.inputTokens, 151914);
+    assert.equal(usage.outputTokens, 1200);
+    assert.equal(usage.transientOutputTokens, 1200);
+    assert.equal(usage.liveTurn, true);
+    assert.equal(usage.source, 'codex-rollout-token-count-live-turn');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('readLatestCodexUsage: task_complete drops transient output overlay', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-codex-usage-'));
+  try {
+    const rollout = join(dir, 'rollout.jsonl');
+    writeFileSync(
+      rollout,
+      [
+        row('session_meta', { id: '019dfaba-thread', cwd: '/repo' }),
+        row('turn_context', { turn_id: '019dfaba-turn', model: 'gpt-5.5' }),
+        event('task_started'),
+        event('token_count', {
+          info: {
+            last_token_usage: {
+              input_tokens: 151914,
+              output_tokens: 1200,
+            },
+            model_context_window: 258400,
+          },
+        }),
+        event('task_complete'),
+        event('token_count', {
+          info: {
+            last_token_usage: {
+              input_tokens: 151914,
+              output_tokens: 1200,
+            },
+            model_context_window: 258400,
+          },
+        }),
+      ]
+        .map((r) => JSON.stringify(r))
+        .join('\n') + '\n',
+    );
+
+    const usage = readLatestCodexUsage(rollout);
+    assert.equal(usage.tokens, 151914);
+    assert.equal(usage.transientOutputTokens, 0);
+    assert.equal(usage.liveTurn, false);
+    assert.equal(usage.source, 'codex-rollout-token-count');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test('readLatestCodexUsage: falls back to model_provider when no turn_context model exists', () => {
   const dir = mkdtempSync(join(tmpdir(), 'tl-codex-usage-'));
   try {

package/src/token-monitor.mjs

@@ -25,6 +25,7 @@ import { statSync, existsSync, writeFileSync, mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { getStateDir, readAllSessionStates, snapshotStateMtimes, normalizeProjectPath, STALE_HIDE_MS } from './state-file.mjs';
 import { buildCodexMonitorUsage } from './codex-usage.mjs';
+import { listCodexThreadCandidates } from './codex-thread-index.mjs';
 import { readLatestUsage } from './transcript-usage.mjs';
 import { startSizeQuery } from './terminal-size.mjs';
 
@@ -290,7 +291,7 @@ export function resolveColumns() {
 
 function formatLine({ state, usage, isActive, now = Date.now() }) {
   const project = basename(state.projectPath || '?');
-  const shortId = state.sessionId.slice(0, 8);
+  const shortId = formatShortSessionId(state);
   const host = state.host === 'codex' ? 'Codex' : state.host === 'unknown' ? 'Unknown' : 'Claude';
   const tokens = usage?.tokens ?? 0;
   const max = usage?.contextWindowSize ?? 200_000;
@@ -334,6 +335,14 @@ function formatLine({ state, usage, isActive, now = Date.now() }) {
   return `${marker} ${projectCol} ${hostCol} ${idCol} ${agoCol} ${barCol} ${tokCol}  ${modelCol}${warn}`;
 }
 
+function formatShortSessionId(state) {
+  const sessionId = String(state?.sessionId ?? '');
+  if (state?.host === 'codex' && sessionId.startsWith('codex:')) {
+    return sessionId.slice('codex:'.length, 'codex:'.length + 8);
+  }
+  return sessionId.slice(0, 8);
+}
+
 function statFile(path) {
   if (!path || !existsSync(path)) return null;
   try {
@@ -372,6 +381,82 @@ function resolveMonitorUsage(state) {
   return state.usage ?? null;
 }
 
+let lastCodexDiscoveryError = null;
+
+function reportCodexDiscoveryError(err) {
+  const msg = err instanceof Error ? err.message : 'unknown error';
+  if (msg === lastCodexDiscoveryError) return;
+  lastCodexDiscoveryError = msg;
+  process.stderr.write(`[Throughline] codex discovery error: ${msg}\n`);
+}
+
+function codexDiscoveryOptions(args = {}, cwd = process.cwd()) {
+  const allProjects = Boolean(args.all || args.session);
+  return {
+    projectPath: cwd,
+    allProjects,
+    limit: allProjects ? 100 : 30,
+  };
+}
+
+function discoverCodexSessionStates(args = {}, cwd = process.cwd()) {
+  let candidates;
+  try {
+    candidates = listCodexThreadCandidates(codexDiscoveryOptions(args, cwd));
+  } catch (err) {
+    reportCodexDiscoveryError(err);
+    return [];
+  }
+
+  lastCodexDiscoveryError = null;
+  return candidates.map((candidate) => ({
+    sessionId: `codex:${candidate.id}`,
+    host: 'codex',
+    projectPath: normalizeProjectPath(candidate.cwd ?? cwd),
+    transcriptPath: null,
+    rolloutPath: candidate.rolloutPath,
+    pid: null,
+    updatedAt: codexCandidateUpdatedAt(candidate),
+    discoveredFrom: 'codex-rollout-discovery',
+  }));
+}
+
+function codexCandidateUpdatedAt(candidate) {
+  const mtime = Number(candidate?.mtimeMs);
+  if (Number.isFinite(mtime) && mtime > 0) return mtime;
+  const parsed = Date.parse(candidate?.updatedAt ?? '');
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function mergeCodexDiscoveredStates(states, discovered) {
+  const bySession = new Map();
+  for (const state of states) bySession.set(state.sessionId, state);
+
+  for (const state of discovered) {
+    const existing = bySession.get(state.sessionId);
+    if (!existing) {
+      bySession.set(state.sessionId, state);
+      continue;
+    }
+
+    bySession.set(state.sessionId, {
+      ...existing,
+      host: existing.host ?? state.host,
+      projectPath: existing.projectPath || state.projectPath,
+      rolloutPath: state.rolloutPath ?? existing.rolloutPath,
+      updatedAt: Math.max(Number(existing.updatedAt) || 0, Number(state.updatedAt) || 0),
+      discoveredFrom: state.discoveredFrom,
+    });
+  }
+
+  return Array.from(bySession.values());
+}
+
+function readMonitorStates(args = {}, cwd = process.cwd()) {
+  const states = readAllSessionStates();
+  return mergeCodexDiscoveredStates(states, discoverCodexSessionStates(args, cwd));
+}
+
 // --- フィルタ ---
 /**
  * セッション一覧に表示フィルタを適用する。
@@ -403,7 +488,7 @@ let lastRenderKey = '';
  * 注: state-file の mtime は Stop hook のタイミングで更新されるが、
  * transcript / rollout は実行中に太る。その live file 変化も render key に含める。
  */
-function computeRenderKey() {
+function computeRenderKey(args = {}, cwd = process.cwd()) {
   const parts = [];
   // state mtimes
   const mtimes = snapshotStateMtimes();
@@ -411,7 +496,7 @@ function computeRenderKey() {
   for (const name of names) parts.push(`s:${name}:${mtimes.get(name)}`);
   // live transcript / rollout sizes（state ファイルを読まずに直接 stat、IO 最小化）
   try {
-    const states = readAllSessionStates();
+    const states = readMonitorStates(args, cwd);
     for (const st of states) {
       for (const [kind, path] of [['t', st.transcriptPath], ['r', st.rolloutPath]]) {
         if (!path || !existsSync(path)) continue;
@@ -432,8 +517,8 @@ function computeRenderKey() {
 /**
  * 前回と比べてキーが変化していれば true。副作用として lastRenderKey を更新する。
  */
-function needsRerender() {
-  const key = computeRenderKey();
+function needsRerender(args = {}, cwd = process.cwd()) {
+  const key = computeRenderKey(args, cwd);
   if (key !== lastRenderKey) {
     lastRenderKey = key;
     return true;
@@ -448,7 +533,7 @@ function resetRenderKeyCache() {
 
 function renderFrame(args) {
   const now = Date.now();
-  const states = readAllSessionStates().map((state) => withLiveActivity(state, now));
+  const states = readMonitorStates(args).map((state) => withLiveActivity(state, now));
   const filtered = filterStates(states, args, process.cwd()).sort(
     (a, b) => b.updatedAt - a.updatedAt,
   );
@@ -662,7 +747,7 @@ export function main() {
       safeRenderFrame(args);
       return;
     }
-    if (needsRerender()) safeRenderFrame(args);
+    if (needsRerender(args)) safeRenderFrame(args);
     if (Date.now() - lastTimeAgoRefresh > TIME_AGO_REFRESH_MS) {
       lastTimeAgoRefresh = Date.now();
       safeRenderFrame(args);
@@ -738,6 +823,10 @@ export const _internal = {
   liveActivityMs,
   withLiveActivity,
   resolveMonitorUsage,
+  codexDiscoveryOptions,
+  discoverCodexSessionStates,
+  mergeCodexDiscoveredStates,
+  readMonitorStates,
 };
 
 // --- エントリポイント自動起動 ---

package/src/token-monitor.test.mjs

@@ -1,6 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
@@ -22,6 +22,8 @@ const {
   setMeasuredColumns,
   withLiveActivity,
   resolveMonitorUsage,
+  discoverCodexSessionStates,
+  mergeCodexDiscoveredStates,
 } = _internal;
 
 // state-file は projectPath を resolve + lowercase 正規化する。
@@ -244,6 +246,73 @@ test('resolveMonitorUsage: live Codex rollout overrides stale Stop snapshot', ()
   }
 });
 
+test('discoverCodexSessionStates: finds Codex rollout without a monitor state file', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-monitor-codex-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-monitor-codex-project-'));
+  const oldHome = process.env.CODEX_HOME;
+  try {
+    process.env.CODEX_HOME = home;
+    const threadId = '019e085c-d3b9-7b43-8445-0efe32416e3d';
+    const dir = join(home, 'sessions', '2026', '05', '09');
+    mkdirSync(dir, { recursive: true });
+    const rollout = join(dir, `rollout-2026-05-09T01-12-41-${threadId}.jsonl`);
+    writeFileSync(
+      rollout,
+      JSON.stringify({
+        type: 'session_meta',
+        payload: {
+          id: threadId,
+          cwd: project,
+          source: 'vscode',
+          cli_version: '0.129.0-alpha.15',
+        },
+      }) + '\n',
+    );
+
+    const states = discoverCodexSessionStates({ all: false, session: null }, project);
+
+    assert.equal(states.length, 1);
+    assert.equal(states[0].sessionId, `codex:${threadId}`);
+    assert.equal(states[0].host, 'codex');
+    assert.equal(states[0].projectPath, normalizeProjectPath(project));
+    assert.equal(states[0].rolloutPath, rollout);
+    assert.equal(states[0].discoveredFrom, 'codex-rollout-discovery');
+  } finally {
+    if (oldHome === undefined) delete process.env.CODEX_HOME;
+    else process.env.CODEX_HOME = oldHome;
+    rmSync(home, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('mergeCodexDiscoveredStates: discovered rollout updates an existing Codex state entry', () => {
+  const existing = {
+    sessionId: 'codex:thread-a',
+    host: 'codex',
+    projectPath: CWD_FOO,
+    transcriptPath: null,
+    rolloutPath: '/old/rollout.jsonl',
+    updatedAt: 100,
+    usage: { tokens: 1 },
+  };
+  const discovered = {
+    sessionId: 'codex:thread-a',
+    host: 'codex',
+    projectPath: CWD_FOO,
+    transcriptPath: null,
+    rolloutPath: '/new/rollout.jsonl',
+    updatedAt: 200,
+    discoveredFrom: 'codex-rollout-discovery',
+  };
+
+  const states = mergeCodexDiscoveredStates([existing], [discovered]);
+
+  assert.equal(states.length, 1);
+  assert.equal(states[0].rolloutPath, '/new/rollout.jsonl');
+  assert.equal(states[0].updatedAt, 200);
+  assert.deepEqual(states[0].usage, { tokens: 1 });
+});
+
 // ─── cellWidth ─────────────────────────────────────────────────────
 
 test('cellWidth: ASCII は 1 セル', () => {
@@ -451,6 +520,39 @@ test('formatLine: Codex estimated usage は host と est marker を表示する'
   assert.ok(out.includes('codex est win?'));
 });
 
+test('formatLine: Codex session id は host prefix を外して 8 桁表示する', () => {
+  const args = makeLineArgs(0.5);
+  args.state.host = 'codex';
+  args.state.sessionId = 'codex:019e085c-d3b9-7b43-8445-0efe32416e3d';
+
+  const out = stripColors(formatLine(args));
+
+  assert.ok(out.includes('019e085c'), `expected raw Codex short id in output: ${out}`);
+  assert.ok(!out.includes('codex:01'), `did not expect prefixed short id in output: ${out}`);
+});
+
+test('formatLine: Codex live turn usage は transient output marker を表示しない', () => {
+  const args = makeLineArgs(0.5);
+  args.state.host = 'codex';
+  args.usage = {
+    tokens: 101_200,
+    inputTokens: 100_000,
+    model: 'gpt-5.5',
+    contextWindowSize: 200_000,
+    contextWindowEstimated: false,
+    outputTokens: 1200,
+    transientOutputTokens: 1200,
+    liveTurn: true,
+    estimated: false,
+    source: 'codex-rollout-token-count-live-turn',
+  };
+  const out = stripColors(formatLine(args));
+  assert.ok(out.includes('Codex'));
+  assert.ok(out.includes('101.2k / 200.0k'));
+  assert.ok(out.includes('gpt-5.5'));
+  assert.ok(!out.includes('live+'));
+});
+
 test('formatLine: 70% 以上で "!" マーカーと弱めの文言', () => {
   const out = stripColors(formatLine(makeLineArgs(0.75)));
   assert.ok(out.includes('!'), 'should include ! marker');