throughline 0.4.9 → 0.4.10

package/CHANGELOG.md

@@ -10,6 +10,20 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.4.10] — 2026-05-09
+
+### Fixed
+
+- Codex current-thread trim no longer refuses execution solely because the
+  rollout active turn count differs from the Codex app-server count. When
+  `thread/read` and `thread/resume` agree, Throughline now treats the mismatch
+  as diagnostics and adjusts `thread/rollback.numTurns` by the app-server delta.
+  For example, `expectedTurns = 6` and `readTurns = resumedTurns = 7` under
+  `--all` now sends `numTurns: 7`.
+- `trim --preflight --host codex` now reports the same rollback adjustment
+  preview instead of returning `preflight-refused` for this recoverable
+  mismatch.
+
 ## [0.4.9] — 2026-05-09
 
 ### Changed

package/README.md

@@ -252,8 +252,11 @@ Haiku path. This is an explicit compatibility mode, not silent auto-detection.
 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
-rollback + Throughline DB memory injection when app-server turn-count guards and
-injectable DB memory are available. Codex current-session auto-refresh is not a
+rollback + Throughline DB memory injection when injectable DB memory is
+available. If the Codex rollout and app-server turn counts differ, Throughline
+keeps the mismatch as diagnostics and, when `thread/read` and `thread/resume`
+agree, adjusts `thread/rollback.numTurns` from the app-server count. Codex
+current-session auto-refresh is not a
 token-monitor feature: the Codex `UserPromptSubmit` hook reads the current
 rollout `token_count` and, at the verified 75% threshold, injects a same-session
 instruction to run the installed `$throughline` workflow before answering. The
@@ -695,7 +698,7 @@ entry to the `tasks` array yourself:
 | `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 --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 --preflight --host codex`    | Read/resume the explicit Codex thread and preview any app-server-count rollback adjustment without rollback/inject |
 | `throughline trim --execute --host codex`      | Scripted Codex current-thread rollback + Throughline DB memory inject; this is what bare `$throughline` runs in Codex |
 | `throughline status`                           | Print DB statistics (sessions, skeletons, bodies, details)   |
 | `throughline --version`                        | Print the installed version                                  |

package/docs/THROUGHLINE_CODEX_DUAL_SUPPORT.md

@@ -33,7 +33,7 @@ Claude Code transcript と handoff behavior は守りつつ、Codex primary brid
 ## 優先順位
 
 1. Throughline を Codex primary で使えるようにする。Codex primary の L2 -> L1 backend は Codex CLI を本線にする。
-2. Codex で Claude Rewind 相当の context trim を完成させる。2026-05-08 時点では Codex current-thread trim execute / auto-refresh は再有効化済みで、DB memory と turn-count guard を必須にする。
+2. Codex で Claude Rewind 相当の context trim を完成させる。2026-05-09 時点では Codex current-thread trim execute / auto-refresh は再有効化済みで、DB memory を必須にし、turn-count mismatch は diagnostics と app-server count 由来の rollback `numTurns` 補正に使う。
 3. そのあと Claude 側の `/rewind` UX / 自動化 surface を詰める。
 
 Claude transcript handling の置き換えから始めないでください。Codex 対応は adapter / bridge / Codex primary entrypoint として追加します。

package/docs/THROUGHLINE_CODEX_FIRST_ROADMAP.md

@@ -26,7 +26,7 @@
 - 現行 Claude path は、Claude hooks、slash command、handoff baton、DB、resume context、L1 / L2 / L3 persistence で成立している。
 - 外部モデル的に呼ぶ主要箇所は L2 -> L1 要約。
 - 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 前に拒否する。
+- Codex guarded trim は、Codex app-server の `thread/read` / `thread/resume` / `thread/rollback` / `thread/inject_items` を使う。明示 thread identity と injectable memory がない場合は mutation 前に拒否する。rollout/app-server turn count mismatch は診断に残し、`thread/read` / `thread/resume` が同じ count を返す場合は app-server 側の差分で rollback `numTurns` を補正する。
 - Claude `/rewind` 自動化はまだ有効化しない。
 - Codex automatic refresh mutation は再有効化済み。`75%` の verified usage threshold で rollback / Throughline DB memory inject を試行し、estimate usage では実行しない。Codex native auto-compact より先に Throughline refresh を走らせつつ、70% warning よりは mutation を遅らせる。
 
@@ -40,8 +40,8 @@ Codex 側で実装済み / 診断可能なもの:
 - `codex-summarize`: Codex CLI backend で L2 -> L1 を書ける。Claude Haiku / raw L2 へ fallback しない。
 - `codex-resume`: L1 summary と active L2 context を Codex active-work context / fresh-thread handoff / developer message item として描画できる。
 - `trim --dry-run --host codex` / `doctor --trim --host codex`: rollback / inject plan、memory contract、context reduction estimate、diagnostics を表示する。fresh-thread handoff は代替継続 surface として残すが、current thread trim の代替ではない。
-- `trim --preflight --host codex`: rollout / app-server turn count guard を確認する。restore-safety diagnostics と planned rollback risk は報告するが、拒否条件ではない。
-- `trim --execute --host codex`: live app-server へ guarded rollback + Throughline DB memory inject を送る。env gate や host primitive audit gate は不要。DB memory が無い場合、または rollout/app-server turn count がずれる場合は mutation 前に拒否する。
+- `trim --preflight --host codex`: rollout / app-server turn count を診断し、必要なら app-server count 由来の rollback 数補正 preview を表示する。restore-safety diagnostics と planned rollback risk は報告するが、拒否条件ではない。
+- `trim --execute --host codex`: live app-server へ guarded rollback + Throughline DB memory inject を送る。env gate や host primitive audit gate は不要。DB memory が無い場合は mutation 前に拒否する。rollout/app-server turn count がずれる場合は、`thread/read` / `thread/resume` が一致していれば app-server count を正として rollback `numTurns` を補正する。
 - `codex-visibility-smoke`: injected active-work memory が次 model turn で model-visible になることを確認済み。
 - `codex-rollback-model-visible-smoke`: controlled two-phase smoke。`--prepare` は unique marker を含む user turn を開始して 1 turn rollback し、`--verify` は full marker を含まない prefix-only prompt で rollback 済み marker が model-visible かを測る。これは実 current thread を mutate するため明示 env 必須。live run では `--marker-file` を使い、full marker を同一 thread の chat/tool output に出さない。
 - `codex-restore-smoke`: fresh app-server process を複数回起動し、`thread/read` / `thread/resume` / paginated `thread/turns/list` turn count が rollout active turn count と一致し続けるかを read-only で確認できる。ただし proof scope は `app_server_process_restart_only` で、VS Code restart-safe 証明ではない。
@@ -318,7 +318,7 @@ TODO:
   - post-inject visibility check
 - [x] execute env gate を外せる条件を再検討した。
   - 2026-05-07 correction: live app-server smoke / post-inject visibility / worktree 非破壊性だけでは不十分だったため、一時的に `THROUGHLINE_EXPERIMENTAL_CODEX_TRIM_EXECUTE=1` gate を戻した。
-  - 2026-05-08 unblock: controlled rollback model-visible smoke が app-server restart 境界と VS Code reload/reconnect 境界の両方で `not-reproduced` だったため、env gate / host primitive audit gate / restore-safety-only blocker を解除した。現行 blocker は thread identity、Throughline DB injectable memory、rollout/app-server turn-count mismatch。
+  - 2026-05-08 unblock: controlled rollback model-visible smoke が app-server restart 境界と VS Code reload/reconnect 境界の両方で `not-reproduced` だったため、env gate / host primitive audit gate / restore-safety-only blocker を解除した。2026-05-09 update: rollout/app-server turn-count mismatch も blocker から外し、app-server `thread/read` / `thread/resume` が一致する場合は差分補正で rollback `numTurns` を決める。
 - [x] partial rollback の multi-turn harness を作る。
 - [x] rollback marker / injected memory が live `thread/resume` 後も効くか確認する。
 - [x] ローカルファイル変更が戻らないことを、実ファイル付き smoke で確認する。
@@ -328,7 +328,7 @@ TODO:
   - `throughline codex-restore-smoke --codex-thread-id <id>` は fresh app-server process を複数回起動し、rollout active turn count と `thread/read` / `thread/resume` / paginated `thread/turns/list` の一致を確認する。
   - proof scope は `app_server_process_restart_only`。VS Code restart / reconnect 越しの rollback / inject durability はまだ証明しない。
 - [x] failure mode を固定する。
-  - turn count mismatch
+  - turn count mismatch diagnostic / app-server-count rollback adjustment
   - inject visibility timeout
   - app-server unavailable
   - thread not found
@@ -344,10 +344,10 @@ TODO:
 Phase 4 implementation status (2026-05-07):
 
 - [x] `throughline trim --preflight --host codex --codex-thread-id <id>` は `thread/read` / `thread/resume` まで実行し、rollback / inject は送らない。
-- [x] historical: `throughline trim --execute --host codex --codex-thread-id <id>` は guarded execute を行う実装だった。2026-05-07 correction では env gate と host primitive audit gate を戻して一時 blocked にした。2026-05-08 unblock では controlled rollback model-visible smoke が再現しなかったため、env gate / host primitive audit gate / restore-safety-only blocker を外し、DB memory と rollout/app-server turn-count guard を残した。
-- [x] rollout source を使う場合、rollback 前に rollout active turn count と app-server `thread/read` / `thread/resume` turn count を照合する。不一致なら rollback / inject を送らず refuse する。
+- [x] historical: `throughline trim --execute --host codex --codex-thread-id <id>` は guarded execute を行う実装だった。2026-05-07 correction では env gate と host primitive audit gate を戻して一時 blocked にした。2026-05-08 unblock では controlled rollback model-visible smoke が再現しなかったため、env gate / host primitive audit gate / restore-safety-only blocker を外し、DB memory と rollout/app-server turn-count diagnostics を残した。
+- [x] rollout source を使う場合、rollback 前に rollout active turn count と app-server `thread/read` / `thread/resume` turn count を照合する。不一致でも refuse せず診断に残す。`readTurns === resumedTurns` なら planned rollback turns に `readTurns - expectedTurns` を足して `thread/rollback.numTurns` を送る。
 - [x] guarded execute は `thread/rollback` -> `thread/inject_items` -> post-inject `thread/read` polling の順に進む。`turn/start` は呼ばない。
-- [x] fake app-server harness で partial rollback、delayed inject visibility、mismatch refusal、mutation not sent preflight を固定した。
+- [x] fake app-server harness で partial rollback、delayed inject visibility、mismatch adjustment、mutation not sent preflight を固定した。
 - [x] `thread/resume` 後に injected memory が維持されることを、実 Codex host smoke として確認済み。
 - [x] 実 Codex host での next model turn visibility smoke は Phase 3 の `codex-visibility-smoke` で確認済み。active-work developer message が次の model turn の agent delta に反映された。
 - [x] 実 Codex host で `trim --preflight --host codex --codex-thread-id 019dfa40-1cc8-7d13-a110-16b09364fa6a --json` を実行し、guard が mutation 前に read / resume count を照合することを確認した。
@@ -419,7 +419,7 @@ TODO:
 - [x] Codex trim / setup まで含む command surface を決める。
   - `throughline trim --host codex`
   - `throughline trim --preflight --host codex --codex-thread-id <id>`
-  - `throughline trim --execute --host codex --codex-thread-id <id>` (DB memory と rollout/app-server turn-count guard がそろう場合に current-thread rollback / inject を実行)
+  - `throughline trim --execute --host codex --codex-thread-id <id>` (DB memory がある場合に current-thread rollback / inject を実行し、rollout/app-server turn-count mismatch は診断と `numTurns` 補正に使う)
   - `doctor --codex` / `codex-capture` / `codex-summarize` / `codex-resume --memo-stdin` / `codex-visibility-smoke`
 - [x] Codex primary の doctor を追加または拡張する。
 - [x] Codex primary の setup / install 手順を追加する。
@@ -461,7 +461,7 @@ Phase 5 implementation status (2026-05-06):
   - 最終確認: hook shape 変更後に新しく開始した VSCode-origin Codex session で 1 turn 完了後、`throughline doctor --codex` を実行した。`current Codex thread` は `019dfd62-9a9d-7211-bf91-89d8e3fc908e`、`latest DB session` は `codex:019dfd62-9a9d-7211-bf91-89d8e3fc908e` で一致し、`Codex hooks feature: enabled`、`Codex Stop hook: registered`、command は `/usr/bin/node /home/kite/projects/Throughline/bin/throughline.mjs codex-hook stop`、`async: false`、`timeoutSec: 300` だった。VSCode-origin の自然 Stop hook による DB capture も解決済みとして扱う。
   - historical 2026-05-07 correction: 以下の Codex trim smoke は live app-server primitive の履歴として残す。ただし 2026-05-06 incident 後、restart / reconnect 越しの durable context trim 成功とは一時的に扱わず、`$throughline` / Codex Stop hook の automatic mutation を止めていた。
   - 2026-05-09 UX 修正: bare `$throughline` は `doctor --codex` / `trim --dry-run --all` / `trim --preflight --all` を AI に順番実行させる説明 surface ではなく、`throughline trim --execute --host codex --all --json` を直接実行する scripted current-thread refresh に戻す。注入 memory は L2 最新 20 full bodies + L1 older summaries + L3 references only。diagnostics / dry-run / preflight / fresh-thread handoff は明示要求時だけ使う。
-  - memory contract 修正: Codex guarded trim でも注入 memory は元の `/tl` 思想を正とする。古い turn は L1 summaries、直近 20 turn は L2 full bodies、L3 は reference only で、L3 bodies / tool payloads は注入しない。rollout source は rollback candidate / app-server turn count guard の根拠であり、Throughline DB memory がある場合に rollout active work preview を注入 memory として使わない。DB memory が無い execute は rollout preview を注入せず、mutation 前に拒否する。
+  - memory contract 修正: Codex guarded trim でも注入 memory は元の `/tl` 思想を正とする。古い turn は L1 summaries、直近 20 turn は L2 full bodies、L3 は reference only で、L3 bodies / tool payloads は注入しない。rollout source は rollback candidate と app-server turn-count 補正の根拠であり、Throughline DB memory がある場合に rollout active work preview を注入 memory として使わない。DB memory が無い execute は rollout preview を注入せず、mutation 前に拒否する。
   - doctor visibility 修正: `doctor --codex` は旧 context refresh readiness として rollback source、inject memory source、memory contract、L1 summaries / recent L2 bodies / L3 references-only count、heuristic reduction estimate を表示していた。実 thread `019dfd62-9a9d-7211-bf91-89d8e3fc908e` では live readiness として `context refresh: ready`、`rollback source: codex-rollout`、`inject memory source: throughline-db`、`memory contract: older L1 + latest 20 L2 full bodies + L3 references only` を確認した。ただし incident 後は restart-safe readiness ではない。
   - 削減量の記録: `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 の証明ではない。
@@ -515,7 +515,7 @@ TODO:
 
 ## 次の作業
 
-Codex primary の capture / summarize / resume は完了扱い。Codex trim execute / auto-refresh も 2026-05-08 の controlled rollback model-visible smoke 後に再有効化済み。[THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md](THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md) の Phase 0-4、read-only app-server process restart smoke、local restore source audit、host primitive audit、manual VS Code restore smoke protocol、実 VS Code reload / reconnect marker proof、rollback 非復活 verifier、controlled rollback model-visible smoke surface は実装済み。incident-shaped live rollback run は `restoreSafety.status = risk` で、`compacted.replacement_history` retention と rollback 済み text match を診断上は観測した。後続の app-server response 分類では retained text が `aggregatedOutput` の引用に限定され、direct user message / model-visible reproduction とは分けて扱う。host primitive audit でも current-thread rollback non-resurrection primitive は見つかっていないが、これは diagnostic-only で、DB memory と rollout/app-server turn-count guard がそろう `trim --execute` を塞がない。
+Codex primary の capture / summarize / resume は完了扱い。Codex trim execute / auto-refresh も 2026-05-08 の controlled rollback model-visible smoke 後に再有効化済み。[THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md](THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md) の Phase 0-4、read-only app-server process restart smoke、local restore source audit、host primitive audit、manual VS Code restore smoke protocol、実 VS Code reload / reconnect marker proof、rollback 非復活 verifier、controlled rollback model-visible smoke surface は実装済み。incident-shaped live rollback run は `restoreSafety.status = risk` で、`compacted.replacement_history` retention と rollback 済み text match を診断上は観測した。後続の app-server response 分類では retained text が `aggregatedOutput` の引用に限定され、direct user message / model-visible reproduction とは分けて扱う。host primitive audit でも current-thread rollback non-resurrection primitive は見つかっていないが、これは diagnostic-only で、DB memory がある `trim --execute` を塞がない。rollout/app-server turn-count mismatch は診断と app-server-count `numTurns` 補正に使う。
 
 再開時は次を実施する:
 

package/docs/THROUGHLINE_CODEX_TRIM_IMPLEMENTATION_PLAN.md

@@ -45,7 +45,7 @@ rollback trim は最終的な理想に近いが、host primitive の実測が必
 - Claude hooks、slash command、transcript parsing、handoff baton、SessionStart resume behavior を Codex 用に置き換えない。
 - Claude-facing field / command / DB semantics を rename しない。
 - Codex 対応は adapter / projection として足す。
-- `thread/rollback` / `thread/inject_items` は live host primitive として実測済み。2026-05-06 incident 後に Codex guarded execute / auto-refresh は一時停止したが、2026-05-08 の controlled rollback model-visible smoke が再現しなかったため、過剰 blocker は解除済み。現在は [THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md](THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md) を優先し、DB memory と rollout/app-server turn-count guard を必須にする。Claude `/rewind` 自動化はまだ有効化しない。
+- `thread/rollback` / `thread/inject_items` は live host primitive として実測済み。2026-05-06 incident 後に Codex guarded execute / auto-refresh は一時停止したが、2026-05-08 の controlled rollback model-visible smoke が再現しなかったため、過剰 blocker は解除済み。現在は [THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md](THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md) を優先し、DB memory を必須にする。rollout/app-server turn-count mismatch は診断と app-server count 由来の rollback `numTurns` 補正に使う。Claude `/rewind` 自動化はまだ有効化しない。
 - fallback や silent recovery で失敗を隠さない。互換モードは条件と理由を明示する。
 
 ## 運用ルール
@@ -372,7 +372,7 @@ 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 後は guarded rollback / inject を試行する。2026-05-09 以降は Codex native auto-compact より先に Throughline refresh を走らせるため、verified usage 75% 以上を既定閾値にする。
+- Codex host primitive は live app-server 上では実測済み。ただし restart-safe durability は未証明。現在は明示 `--codex-thread-id` または env thread identity と Throughline DB memory が live mutation の最低条件であり、rollout/app-server turn-count mismatch は診断と rollback `numTurns` 補正に使う。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 75% 以上を既定閾値にする。
 - Claude `/rewind conversation only` は手動 UX として扱う。外部ツールからの自動化 surface は未確認。Claude host の automatic rollback / inject は `manual-only`。
 - Phase 8 では dry-run / preflight を本線にしつつ、Codex だけ guarded execute を追加した。Claude は manual-only のまま扱う。
 
@@ -386,7 +386,7 @@ Phase 6 result (2026-05-06):
 
 TODO:
 
-- [x] host identity model を整理する。Claude `session_id`、Codex `thread_id`、`project_path`、origin session / thread references の対応表を作る。Codex は `thread_id` と rollout JSONL を app-server で扱い、明示 identity と turn count guard がある場合だけ guarded execute へ進む。
+- [x] host identity model を整理する。Claude `session_id`、Codex `thread_id`、`project_path`、origin session / thread references の対応表を作る。Codex は `thread_id` と rollout JSONL を app-server で扱い、明示 identity と Throughline DB memory がある場合に guarded execute へ進む。turn count mismatch は診断と app-server count 由来の rollback `numTurns` 補正に使う。
 - [x] current session / thread の captured turn count を記録または導出する方法を決める。
 - [x] rollback 可能な最大 turn 数を計算する。
 - [x] keep-recent の既定値を決める。
@@ -428,7 +428,7 @@ TODO:
 - [x] 実行前に captured turns / keep turns / injected memory summary を表示する。
 - [x] Codex dry-run では `--codex-thread-id` を受け取り、Claude / Throughline の `session_id` と Codex `thread_id` を混同しない形で plan に残す。
 - [x] Codex non-dry-run の最初の統合として `--preflight` を追加する。これは app-server の initialize / read / resume だけを実行し、rollback / inject は送らない。
-- [x] Codex の guarded execution として `--execute` を追加する。ただし `--host codex`、明示または env の Codex thread identity、rollout/app-server turn count guard を必須にし、実行後に model turn は開始しない。
+- [x] Codex の guarded execution として `--execute` を追加する。ただし `--host codex`、明示または env の Codex thread identity、Throughline DB memory を必須にし、実行後に model turn は開始しない。rollout/app-server turn-count mismatch は診断と rollback `numTurns` 補正に使う。
 - [ ] 自動 rollback 対応 host では、実行後に resume / injected memory が restart / reconnect 後も有効か検証する。Codex は Phase 6 spike、2026-05-06 guarded execute smoke、post-inject resume visibility smoke で live app-server 上の rollback/inject と injected memory visibility だけを確認した。2026-05-06 incident 後、これは restart-safe durability の完了条件を満たさない。
 - [x] `doctor` に trim 関連診断を追加する。
 
@@ -436,11 +436,11 @@ Phase 8 partial implementation result (2026-05-06):
 
 - `throughline trim --dry-run [--host claude|codex|unknown] [--keep-recent N] [--all] [--session <id>] [--codex-thread-id <id>] [--json]` を追加。
 - `throughline trim --dry-run --memo-stdin` を追加。`/tl` が解決した「L1/L2 はあるが今やっている作業として認識されない」問題を `/tl-trim` でも再発させないため、current-work memo を curated memory preview の先頭に入れる。
-- non-dry-run `throughline trim` は Claude / unknown host では automatic rollback / inject 未対応として exit 1 で明示拒否する。Codex host には `--execute` 経路が実装済み。2026-05-06 incident 後はいったん拒否したが、2026-05-08 unblock 後は明示 `--execute`、Codex thread identity、Throughline DB memory、rollout/app-server turn-count guard がそろえば mutation へ進む。
+- non-dry-run `throughline trim` は Claude / unknown host では automatic rollback / inject 未対応として exit 1 で明示拒否する。Codex host には `--execute` 経路が実装済み。2026-05-06 incident 後はいったん拒否したが、2026-05-08 unblock 後は明示 `--execute`、Codex thread identity、Throughline DB memory がそろえば mutation へ進む。2026-05-09 以降は rollout/app-server turn-count mismatch を refuse せず、app-server count 由来で rollback `numTurns` を補正する。
 - `src/codex-app-server.mjs` を追加し、newline JSON framing、initialize / read / resume / rollback / inject / turn-start request builder、server line parser をテストで固定した。Codex guarded execute はこの helper を通り、model turn は開始しない。
 - `--codex-thread-id` の明示入力を最優先で信頼する。明示入力が無い場合のみ、`THROUGHLINE_CODEX_THREAD_ID` / `CODEX_THREAD_ID` を current-thread identity signal として使う。最新 rollout 推測による automatic trim は行わない。
 - `throughline trim --preflight --host codex --codex-thread-id <id> [--json]` を追加した。これは `thread/read` と `thread/resume` が対象 thread に届くことを確認し、`rollbackRequestPreview` を返すが、`thread/rollback` / `thread/inject_items` は送らない。
-- `codex-rollout` source の場合、preflight は rollout 側 active turn count と app-server `thread/read` / `thread/resume` の turn count を突き合わせる。不一致または app-server count 不明なら `preflight-refused` として止まり、rollback / inject は送らない。
+- `codex-rollout` source の場合、preflight は rollout 側 active turn count と app-server `thread/read` / `thread/resume` の turn count を突き合わせる。不一致でも `preflight-refused` にはせず、`readTurns === resumedTurns` なら app-server count 由来の rollback `numTurns` 補正 preview を返す。preflight なので rollback / inject は送らない。
 - 同日、検証 thread `019dfaba-f87e-7f41-a144-d5ca7c6dd7f9` に実 app-server preflight を当て、`readTurns: 1` / `resumedTurns: 1` / `rollbackSent: false` / `injectSent: false` を確認した。
 - `throughline trim --execute --host codex --codex-thread-id <id> [--json]` を追加した。2026-05-06 incident 後は既定で拒否し、2026-05-07 追加修正では host primitive audit gate も置いた。2026-05-08 unblock 後はこの env gate / host primitive audit gate を外し、app-server の `thread/read`、`thread/resume`、`thread/rollback`、`thread/inject_items`、確認用 `thread/read` へ進む。host primitive audit と restore-safety は diagnostic-only。
 - 実 app-server smoke では `thread/inject_items` の直後に返る turn 配列が、注入 item の可視化より早い場合があると分かった。その後の current-thread live run で、現行 Codex host の developer memory injection は item-level で、即時 `thread/read` の turn count を増やさない場合があることも確認した。そのため `--execute` は `thread/inject_items` の応答に turn list があればその turn count を期待値とし、応答に turn list がなければ rollback 後 turn count を期待値として post-inject `thread/read` を短く poll する。`postInjectVisibilityCheck` は `match` / `timeout` / `unchecked` を記録する。CLI 外側の status は `executed` ではなく、live mutation だけなら `execute-sent-live-only`、timeout や durable evidence 不足なら `execute-unverified`、rollout に新 rollback marker と active-work memory injection が観測された場合は `execute-durable-verified` とする。restore-safety は durable mutation evidence とは別の diagnostic として表示する。exit 0 は `execute-durable-verified` に限る。

package/docs/THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md

@@ -18,7 +18,9 @@ quoted/tool-output field に残り得ることは確認済みですが、それ
 model-visible input に入ることは controlled smoke で再現していません。incident-shaped
 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
+Codex thread identity を条件に実行します。rollout/app-server turn-count mismatch は診断に残し、
+app-server `thread/read` / `thread/resume` が同じ count を返す場合は、その差分で rollback `numTurns`
+を補正します。Codex Stop hook
 auto-refresh は verified usage 75% 以上で同じ guarded path を試行し、estimate usage では実行しません。
 
 最初のインシデント仮説に対する重要な訂正:
@@ -293,7 +295,8 @@ TODO:
     repair contract が blocked の場合は拒否していた。
   - 2026-05-08 unblock: host primitive audit は diagnostic-only に変更した。
     現行 Codex CLI に same-thread repair primitive が無い事実は表示するが、
-    DB memory と rollout/app-server turn-count guard がそろう execute を塞がない。
+    DB memory がある execute を塞がない。rollout/app-server turn-count mismatch は
+    診断と app-server count 由来の rollback `numTurns` 補正に使う。
   - `~/.codex/state_5.sqlite` の `threads` table は rollout path / metadata を持つが、
     turn bodies は持たない。turn body の主根拠は rollout JSONL 側である可能性が
     高いが、VS Code extension restore source は別途未確定。
@@ -624,8 +627,9 @@ TODO:
     mutation 前 blocker にはしない。
 - [x] 明示 `trim --execute --host codex` の製品判断を固定する。
   - 判断: 明示 `--execute` で実行する。env opt-in と host primitive audit gate は外す。
-    DB memory が無い場合、または rollout/app-server turn count guard が合わない場合は
-    mutation 前に拒否する。実行後は `execute-sent-live-only` /
+    DB memory が無い場合は mutation 前に拒否する。rollout/app-server turn count がずれる場合は
+    refusal ではなく診断に残し、app-server count を正として rollback `numTurns` を補正する。
+    実行後は `execute-sent-live-only` /
     `execute-unverified` / `execute-durable-verified` で結果を分ける。
 
 受け入れ条件:
@@ -673,5 +677,9 @@ TODO:
 作業量や複雑さを理由に目標を下げない。2026-05-08 時点の製品仕様は、
 同一 Codex thread で guarded rollback + Throughline DB memory inject を実行し、
 rollout 上の新 rollback event と injected active-work memory で durable evidence を確認すること。
-restore-safety / host primitive audit は diagnostics として残すが、単独では execute / auto-refresh の blocker にしない。
-mutation 前 refusal は thread identity、Throughline DB injectable memory、rollout/app-server turn-count mismatch に限定する。
+restore-safety / host primitive audit / rollout-app-server turn-count mismatch は diagnostics として残すが、単独では execute / auto-refresh の blocker にしない。
+mutation 前 refusal は thread identity と Throughline DB injectable memory に限定する。
+2026-05-09 update: rollout/app-server turn-count mismatch は mutation 前 refusal から外した。
+app-server `thread/read` / `thread/resume` が同じ count を返す場合、planned rollback turns に
+`readTurns - expectedTurns` を足して `thread/rollback.numTurns` を送る。例:
+`expectedTurns = 6` / `readTurns = resumedTurns = 7` / `--all` なら `numTurns = 7`。

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

@@ -15,11 +15,13 @@
 
 この文書は「rollback は欠けていた delete primitive かもしれない」という洞察を残すもの。実装時は、未検証の host primitive を本線仕様にせず、次フェーズ計画 [THROUGHLINE_CODEX_FIRST_ROADMAP.md](THROUGHLINE_CODEX_FIRST_ROADMAP.md) の Codex Rewind 互換 Phase で実測してから本線 UX に進む。
 
-2026-05-06 update: Codex app-server の `thread/rollback` / `thread/inject_items` は live host primitive として実測済み。Throughline CLI には明示 `--codex-thread-id` または `THROUGHLINE_CODEX_THREAD_ID` / `CODEX_THREAD_ID` による current-thread identity、rollout/app-server turn count guard、guarded execute が入った。
+2026-05-06 update: Codex app-server の `thread/rollback` / `thread/inject_items` は live host primitive として実測済み。Throughline CLI には明示 `--codex-thread-id` または `THROUGHLINE_CODEX_THREAD_ID` / `CODEX_THREAD_ID` による current-thread identity、rollout/app-server turn count diagnostics、guarded execute が入った。
 
 2026-05-07 correction: VS Code restart / reconnect 後に rollback 済み user prompt が復活したように見える incident が起きたため、Codex rollback / inject は restart-safe な context trim primitive としていったん未証明へ戻した。特に `compacted.replacement_history` など、live app-server read/resume 以外の restore source を検証するまで、`$throughline` と Codex Stop hook auto-refresh は mutation を自動実行しない方針にした。Claude `/rewind` 自動化はまだ有効化しない。
 
-2026-05-08 unblock: その後の切り分けで、incident thread の retained text は app-server response 上では `aggregatedOutput` など quoted/tool-output field に分類され、controlled rollback model-visible smoke は app-server restart 境界と VS Code reload/reconnect 境界の両方で `not-reproduced` だった。これを受け、Codex `trim --execute --host codex` と Stop hook auto-refresh の過剰 blocker は解除する。`compacted.replacement_history` retention、restore-safety risk、host primitive audit は引き続き diagnostics だが、単独では mutation 前 refusal にしない。DB memory 不在と rollout/app-server turn-count 不一致は引き続き mutation 前 blocker。
+2026-05-08 unblock: その後の切り分けで、incident thread の retained text は app-server response 上では `aggregatedOutput` など quoted/tool-output field に分類され、controlled rollback model-visible smoke は app-server restart 境界と VS Code reload/reconnect 境界の両方で `not-reproduced` だった。これを受け、Codex `trim --execute --host codex` と Stop hook auto-refresh の過剰 blocker は解除する。`compacted.replacement_history` retention、restore-safety risk、host primitive audit は引き続き diagnostics だが、単独では mutation 前 refusal にしない。DB memory 不在は引き続き mutation 前 blocker。
+
+2026-05-09 update: rollout/app-server turn-count 不一致も mutation 前 blocker から外した。app-server `thread/read` / `thread/resume` が同じ count を返す場合、planned rollback turns に `readTurns - expectedTurns` を足して `thread/rollback.numTurns` を送る。`expectedTurns = 6` / `readTurns = resumedTurns = 7` / `--all` なら `numTurns = 7`。
 
 2026-05-09 skill UX: bare `$throughline` は diagnostics / dry-run / preflight を AI に順番実行させる surface ではなく、`throughline trim --execute --host codex --all --json` を直接走らせる scripted current-thread refresh とする。目的は rollback と、Throughline DB の L2 最新 20 full bodies + older L1 summaries + L3 references-only memory injection のみ。doctor / dry-run / preflight / fresh-thread handoff / restore-safety / host primitive audit は明示診断用であり、通常 `$throughline` の前段にはしない。
 
@@ -265,8 +267,8 @@ Codex で考えられる流れ:
 
 現行実装では、Codex Stop hook 後の 75% 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 は
+も env gate なしで実行する。明示 Codex thread identity と injectable Throughline DB memory
+は live mutation の最低条件であり、rollout/app-server turn-count mismatch は診断と app-server count 由来の rollback `numTurns` 補正に使う。durable success は
 post-execute rollout evidence で `execute-durable-verified` として別判定する。
 
 重要な考え:

package/package.json

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

package/src/cli/trim.mjs

@@ -366,15 +366,6 @@ async function runPreflight(parsed, plan) {
     expectedTurns: expectedCodexAppServerTurns(plan),
     command,
   });
-  const turnCountStatus = preflight.turnCountCheck?.status;
-  if (turnCountStatus === 'mismatch' || turnCountStatus === 'unknown') {
-    return {
-      status: 'preflight-refused',
-      reason: preflight.turnCountCheck.reason,
-      plan,
-      preflight,
-    };
-  }
 
   return {
     status: 'preflight-ready',

package/src/codex-app-server.mjs

@@ -209,6 +209,48 @@ export function buildThreadRollbackRequest({ id, threadId, numTurns }) {
   };
 }
 
+export function resolveRollbackTurnsForAppServer({
+  plannedRollbackTurns,
+  expectedTurns = null,
+  readTurns = null,
+  resumedTurns = null,
+} = {}) {
+  if (!Number.isInteger(plannedRollbackTurns) || plannedRollbackTurns < 1) {
+    throw new Error('resolveRollbackTurnsForAppServer: plannedRollbackTurns must be an integer >= 1');
+  }
+  assertOptionalTurnCount(expectedTurns, 'resolveRollbackTurnsForAppServer: expectedTurns');
+
+  const result = {
+    plannedRollbackTurns,
+    requestedRollbackTurns: plannedRollbackTurns,
+    adjustment: 0,
+    basis: 'planned',
+    reason: 'using_planned_rollback_turns',
+  };
+
+  if (
+    Number.isInteger(expectedTurns) &&
+    Number.isInteger(readTurns) &&
+    Number.isInteger(resumedTurns) &&
+    readTurns === resumedTurns &&
+    readTurns !== expectedTurns
+  ) {
+    const adjustment = readTurns - expectedTurns;
+    const adjustedTurns = plannedRollbackTurns + adjustment;
+    if (adjustedTurns >= 1) {
+      return {
+        plannedRollbackTurns,
+        requestedRollbackTurns: Math.min(adjustedTurns, readTurns),
+        adjustment,
+        basis: 'app_server_turn_count',
+        reason: 'adjusted_by_app_server_turn_delta',
+      };
+    }
+  }
+
+  return result;
+}
+
 export function buildThreadInjectItemsRequest({ id, threadId, items }) {
   assertRequestId(id, 'buildThreadInjectItemsRequest');
   assertNonEmptyString(threadId, 'buildThreadInjectItemsRequest: threadId');
@@ -313,6 +355,12 @@ export async function runCodexTrimPreflight({
     );
     const readTurns = countTurns(beforeRead);
     const resumedTurns = countTurns(resumed);
+    const rollbackResolution = resolveRollbackTurnsForAppServer({
+      plannedRollbackTurns: rollbackTurns,
+      expectedTurns,
+      readTurns,
+      resumedTurns,
+    });
 
     return {
       status: 'preflight-ready',
@@ -321,6 +369,8 @@ export async function runCodexTrimPreflight({
       injectSent: false,
       readTurns,
       resumedTurns,
+      rollbackRequestedTurns: rollbackResolution.requestedRollbackTurns,
+      rollbackResolution,
       turnCountCheck: compareTurnCounts({
         expectedTurns,
         readTurns,
@@ -329,7 +379,7 @@ export async function runCodexTrimPreflight({
       rollbackRequestPreview: buildThreadRollbackRequest({
         id: 'rollback-preview',
         threadId,
-        numTurns: rollbackTurns,
+        numTurns: rollbackResolution.requestedRollbackTurns,
       }),
       notifications: [...new Set(client.notifications)],
       stderr: client.stderr,
@@ -964,27 +1014,17 @@ export async function runCodexTrimExecution({
       readTurns,
       resumedTurns,
     });
-    if (turnCountCheck.status === 'mismatch' || turnCountCheck.status === 'unknown') {
-      return {
-        status: 'refused',
-        reason: 'codex_rollout_app_server_turn_mismatch',
-        threadId,
-        rollbackSent: false,
-        injectSent: false,
-        injectedItems: 0,
-        readTurns,
-        resumedTurns,
-        rollbackRequestedTurns: rollbackTurns,
-        turnCountCheck,
-        notifications: [...new Set(client.notifications)],
-        stderr: client.stderr,
-      };
-    }
+    const rollbackResolution = resolveRollbackTurnsForAppServer({
+      plannedRollbackTurns: rollbackTurns,
+      expectedTurns,
+      readTurns,
+      resumedTurns,
+    });
     const rollback = await client.request(
       buildThreadRollbackRequest({
         id: randomUUID(),
         threadId,
-        numTurns: rollbackTurns,
+        numTurns: rollbackResolution.requestedRollbackTurns,
       }),
     );
     const inject = await client.request(
@@ -1016,7 +1056,8 @@ export async function runCodexTrimExecution({
       injectedItems: 1,
       readTurns,
       resumedTurns,
-      rollbackRequestedTurns: rollbackTurns,
+      rollbackRequestedTurns: rollbackResolution.requestedRollbackTurns,
+      rollbackResolution,
       rollbackResultTurns,
       injectResultTurns,
       afterTurns: postInjectRead.turns,

package/src/codex-app-server.test.mjs

@@ -19,6 +19,7 @@ import {
   compareTurnCounts,
   encodeAppServerMessage,
   parseAppServerLine,
+  resolveRollbackTurnsForAppServer,
   runCodexModelVisibilitySmoke,
   runCodexRollbackModelVisiblePrepare,
   runCodexRollbackModelVisibleVerify,
@@ -203,6 +204,50 @@ test('compareTurnCounts: rejects invalid expected turn count', () => {
   );
 });
 
+test('resolveRollbackTurnsForAppServer adjusts planned rollback by app-server turn delta', () => {
+  assert.deepEqual(
+    resolveRollbackTurnsForAppServer({
+      plannedRollbackTurns: 6,
+      expectedTurns: 6,
+      readTurns: 7,
+      resumedTurns: 7,
+    }),
+    {
+      plannedRollbackTurns: 6,
+      requestedRollbackTurns: 7,
+      adjustment: 1,
+      basis: 'app_server_turn_count',
+      reason: 'adjusted_by_app_server_turn_delta',
+    },
+  );
+
+  assert.deepEqual(
+    resolveRollbackTurnsForAppServer({
+      plannedRollbackTurns: 2,
+      expectedTurns: 22,
+      readTurns: 21,
+      resumedTurns: 21,
+    }),
+    {
+      plannedRollbackTurns: 2,
+      requestedRollbackTurns: 1,
+      adjustment: -1,
+      basis: 'app_server_turn_count',
+      reason: 'adjusted_by_app_server_turn_delta',
+    },
+  );
+
+  assert.equal(
+    resolveRollbackTurnsForAppServer({
+      plannedRollbackTurns: 6,
+      expectedTurns: 6,
+      readTurns: 7,
+      resumedTurns: 8,
+    }).requestedRollbackTurns,
+    6,
+  );
+});
+
 test('summarizeAppServerStderr: compacts repeated unknown-turn item warnings', () => {
   const stderr = [
     '2026-05-06T00:00:00Z  WARN codex_app_server_protocol::protocol::thread_history: dropping turn-scoped item for unknown turn id `turn-a` item_id="call_1"',

package/src/trim-cli.test.mjs

@@ -137,6 +137,7 @@ rl.on('line', (line) => {
       send({ id: msg.id, error: { code: -32000, message: 'mutation must not be called' } });
       return;
     }
+    appendFileSync(log, 'ROLLBACK_TURNS:' + msg.params.numTurns + '\\n');
     turns = turns.slice(0, Math.max(0, turns.length - msg.params.numTurns));
     appendRollout({ type: 'event_msg', payload: { type: 'thread_rolled_back', num_turns: msg.params.numTurns } });
     send({ id: msg.id, result: { thread: { id: threadId, turns } } });
@@ -843,7 +844,7 @@ test('trim CLI preflight proceeds when compacted history already retains target
   }
 });
 
-test('trim CLI execute refuses before rollback when rollout and app-server turn counts differ', async () => {
+test('trim CLI execute adjusts rollback turns from app-server count when counts differ', async () => {
   const home = makeTempHome();
   const codexHome = makeTempHome();
   const project = makeTempProject();
@@ -853,12 +854,12 @@ test('trim CLI execute refuses before rollback when rollout and app-server turn
     writeCodexRollout(codexHome, {
       project,
       threadId,
-      turnCount: 22,
+      turnCount: 6,
     });
     const { script, log } = makeFakeCodexAppServer(project, {
       allowMutation: true,
       threadId,
-      turnCount: 21,
+      turnCount: 7,
     });
     const result = runTrim(
       home,
@@ -868,8 +869,7 @@ test('trim CLI execute refuses before rollback when rollout and app-server turn
         'codex',
         '--codex-thread-id',
         threadId,
-        '--keep-recent',
-        '20',
+        '--all',
         '--execute',
         '--codex-app-server-bin',
         script,
@@ -881,17 +881,25 @@ test('trim CLI execute refuses before rollback when rollout and app-server turn
 
     assert.equal(result.status, 1);
     const payload = JSON.parse(result.stdout);
-    assert.equal(payload.status, 'execute-refused');
-    assert.equal(payload.reason, 'codex_rollout_app_server_turn_mismatch');
-    assert.equal(payload.execution.rollbackSent, false);
-    assert.equal(payload.execution.injectSent, false);
+    assert.notEqual(payload.status, 'execute-refused');
+    assert.equal(payload.execution.rollbackSent, true);
+    assert.equal(payload.execution.injectSent, true);
+    assert.equal(payload.execution.rollbackRequestedTurns, 7);
     assert.equal(payload.execution.turnCountCheck.status, 'mismatch');
+    assert.deepEqual(payload.execution.rollbackResolution, {
+      plannedRollbackTurns: 6,
+      requestedRollbackTurns: 7,
+      adjustment: 1,
+      basis: 'app_server_turn_count',
+      reason: 'adjusted_by_app_server_turn_delta',
+    });
 
     const calledMethods = readFileSync(log, 'utf8');
     assert.match(calledMethods, /thread\/read/);
     assert.match(calledMethods, /thread\/resume/);
-    assert.doesNotMatch(calledMethods, /thread\/rollback/);
-    assert.doesNotMatch(calledMethods, /thread\/inject_items/);
+    assert.match(calledMethods, /thread\/rollback/);
+    assert.match(calledMethods, /ROLLBACK_TURNS:7/);
+    assert.match(calledMethods, /thread\/inject_items/);
   } finally {
     rmSync(project, { recursive: true, force: true });
     rmSync(home, { recursive: true, force: true });