throughline 0.4.9 → 0.4.11

package/CHANGELOG.md

@@ -10,6 +10,33 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+### Changed
+
+- Disabled Codex automatic current-thread refresh from `UserPromptSubmit`,
+  `PostToolUse`, and `Stop` hooks. The hooks now capture rollout memory and
+  monitor state, then return `codex_auto_refresh_disabled` without injecting
+  `$throughline` or sending rollback/inject. The lower-level auto-refresh helper
+  is also default-disabled.
+- Changed the Codex `$throughline` skill back to a new-thread handoff flow:
+  bare `$throughline` now runs `throughline codex-handoff-start --execute`,
+  which creates a new Codex app-server thread, injects developer handoff memory,
+  and opens the selected host. Explicit `throughline trim --execute --host codex`
+  remains available as a diagnostic current-thread rollback / inject command.
+
+## [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
@@ -125,10 +152,13 @@ shipped to npm but were not individually tagged on GitHub.
 
 - Changed the installed Codex `$throughline` skill so bare `$throughline` runs
   the scripted current-thread refresh directly:
-  `throughline trim --execute --host codex --all --json`. Doctor, dry-run,
+  `throughline trim --execute --host codex --all`. Doctor, dry-run,
   preflight, restore-safety analysis, host primitive audit, and fresh-thread
   handoff remain available only when explicitly requested instead of being the
   normal skill path.
+- Changed Codex auto-refresh hook instructions to avoid `--json` on execute so
+  the full trim plan / memory preview is not reintroduced as tool output after
+  rollback.
 
 ## [0.4.2] — 2026-05-09
 
@@ -282,12 +312,14 @@ shipped to npm but were not individually tagged on GitHub.
   `--print-prompt` can include the combined prompt for audit. Live model smoke
   requires `THROUGHLINE_EXPERIMENTAL_CODEX_HANDOFF_MODEL_SMOKE=1` and does not
   mutate the current Codex thread.
-- `throughline codex-handoff-start`, a guided read-only fresh-thread start plan
+- `throughline codex-handoff-start`, a guided fresh-thread start plan
   for Codex handoff. It reports the structural smoke command, model-smoke dry-run
   boundary, handoff render command, optional live model smoke command, and can
   include the handoff prompt with `--print-prompt`. When `--memo-stdin` is used,
   the replay commands include `--memo-stdin` and the output reminds callers to
-  pipe the same memo.
+  pipe the same memo. With `--execute`, it starts a new app-server thread,
+  injects developer handoff memory with `thread/inject_items`, and opens it
+  through `--open-host auto|vscode|cli|none`.
 - `throughline doctor --codex`, a read-only Codex-primary diagnostic that shows
   current thread env identity, rollout candidates for the cwd, captured
   `codex:<thread_id>` DB sessions, context refresh blockage, new-thread

package/README.ja.md

@@ -26,11 +26,16 @@ throughline install     # hook / Codex skill / VS Code monitor task を登録
 `/clear` を打てば新セッションはゼロからではなく、**思考の途中から再開** される。
 `/clear` を経由しない新規 chat / VS Code 再起動では `/tl` で前任を指名できる。
 
+<details>
+<summary><b>Codex も併用する場合</b> Codex hooks も登録される — クリックで詳細</summary>
+
 Codex では `UserPromptSubmit` / `PostToolUse` / `Stop` hook と `$throughline`
 skill も登録する。75% 自動発火は token-monitor 依存ではなく、当該 Codex
 セッションの rollout `token_count` を hook が読み、prompt 送信時または tool loop
 途中の閾値到達時に同じセッションへ `$throughline` 実行指示を注入する。
 
+</details>
+
 ## 他の手段との比較
 
 | | Throughline | MemGPT / SummaryBufferMemory | 素の Claude Code |
@@ -137,6 +142,28 @@ Throughline 0.4.1+ の引き継ぎは 2 経路です。主経路は typed `/clea
 `/tl` が書く baton で、`source='clear'` の auto path は `/clear` が
 UserPromptSubmit hook に届かない場合の補助です。
 
+```mermaid
+flowchart LR
+    U["ユーザーが入力<br/>/clear または /tl"] -->|UserPromptSubmit| W["writeBaton<br/>(session_id + TTL 1h)"]
+    W --> B[("handoff_batons<br/>SQLite")]
+    M["VS Code メニュー<br/>clear"] -->|UserPromptSubmit に届かない| X["baton 無し"]
+    NS["次の SessionStart"] --> C{"baton<br/>あり?"}
+    B -.-> C
+    X -.-> C
+    C -->|あり| P1["baton path<br/>(主経路)<br/>指名された前任を merge"]
+    C -->|無し / source='clear'| P2["auto path<br/>(補助)<br/>findLatestClaudePredecessor"]
+    C -->|無し / source!='clear'| P3["新規セッション<br/>merge 無し"]
+    P1 --> INJ["L1 + L2 + L3 references を注入"]
+    P2 --> INJ
+
+    classDef primary fill:#7c5cff,stroke:#1a1f2e,color:#fff
+    classDef fallback fill:#3aa0ff,stroke:#1a1f2e,color:#fff
+    classDef neutral fill:#4a5568,stroke:#1a1f2e,color:#fff
+    class P1 primary
+    class P2 fallback
+    class P3,INJ neutral
+```
+
 ### baton path (primary): typed `/clear` または `/tl`
 
 ユーザーが prompt に `/clear` または `/tl` を打つと、UserPromptSubmit hook が

package/README.md

@@ -27,6 +27,9 @@ type `/clear` — the new session resumes mid-thought instead of starting from
 zero. (For non-`/clear` boundaries such as a brand-new chat or a VSCode
 restart, type `/tl` first to mark the predecessor.)
 
+<details>
+<summary><b>Also using Codex?</b> Global install registers Codex hooks too — click for details.</summary>
+
 Global install also registers Codex `UserPromptSubmit`, `PostToolUse`, and
 `Stop` hooks in `~/.codex/hooks.json` and enables both
 `[features].codex_hooks = true` and `[features].hooks = true` in
@@ -34,13 +37,16 @@ Global install also registers Codex `UserPromptSubmit`, `PostToolUse`, and
 `bin/throughline.mjs` through an absolute Node path, so Codex App Server PATH
 differences do not hide the command. They are registered synchronously
 (`async: false`), matching the Codex hook behavior verified in Caveat. Existing
-non-Throughline Codex hooks are preserved. The prompt and tool-loop hooks read
-the current rollout `token_count` themselves and inject `$throughline` at the
-verified 75% threshold; token-monitor is display-only and is never the trigger
-source. It also installs a global `$throughline` Codex skill. Bare
-`$throughline` runs the scripted current-thread rollback + Throughline DB memory
-injection directly; ask explicitly for status, resume, summarize, diagnostics,
-or fresh-thread handoff when you want those read-only surfaces instead.
+non-Throughline Codex hooks are preserved. The prompt and tool-loop hooks capture
+rollout memory and write monitor state, but they do not inject `$throughline` at
+usage thresholds; token-monitor is display-only and is never an auto-refresh
+trigger. It also installs a global `$throughline` Codex skill. Bare
+`$throughline` starts a new Codex thread through app-server, injects Throughline
+DB handoff memory as a developer item, and opens that thread in the selected
+host; ask explicitly for current-thread rollback diagnostics when you want the
+guarded `trim --execute --host codex` surface.
+
+</details>
 
 ## How it compares
 
@@ -154,6 +160,28 @@ primary route**; the source-`clear` auto path is the fallback for cases where
 the user's `/clear` does not reach the `UserPromptSubmit` hook (for example
 the VSCode extension's menu-driven `/clear`).
 
+```mermaid
+flowchart LR
+    U["User types<br/>/clear or /tl"] -->|UserPromptSubmit| W["writeBaton<br/>(session_id + TTL 1h)"]
+    W --> B[("handoff_batons<br/>SQLite")]
+    M["VSCode menu<br/>clear"] -->|no UserPromptSubmit| X["no baton"]
+    NS["Next SessionStart"] --> C{"baton<br/>present?"}
+    B -.-> C
+    X -.-> C
+    C -->|yes| P1["baton path<br/>(primary)<br/>merge that exact predecessor"]
+    C -->|no, source='clear'| P2["auto path<br/>(fallback)<br/>findLatestClaudePredecessor"]
+    C -->|no, source!='clear'| P3["fresh session<br/>no merge"]
+    P1 --> INJ["inject L1 + L2 + L3 refs"]
+    P2 --> INJ
+
+    classDef primary fill:#7c5cff,stroke:#1a1f2e,color:#fff
+    classDef fallback fill:#3aa0ff,stroke:#1a1f2e,color:#fff
+    classDef neutral fill:#4a5568,stroke:#1a1f2e,color:#fff
+    class P1 primary
+    class P2 fallback
+    class P3,INJ neutral
+```
+
 ### baton path (primary): typed `/clear` or `/tl` → deterministic inheritance
 
 When the user types `/clear` or `/tl` in the prompt, the `UserPromptSubmit`
@@ -223,6 +251,7 @@ throughline codex-summarize --session codex:<thread-id> --json
 throughline codex-resume --session codex:<thread-id>
 throughline codex-resume --session codex:<thread-id> --format handoff
 throughline codex-handoff-start --session codex:<thread-id>
+throughline codex-handoff-start --session codex:<thread-id> --execute --open-host vscode
 throughline codex-handoff-smoke --session codex:<thread-id>
 throughline codex-handoff-model-smoke --session codex:<thread-id> --dry-run --json
 THROUGHLINE_EXPERIMENTAL_CODEX_HANDOFF_MODEL_SMOKE=1 \
@@ -248,17 +277,14 @@ summarization. When `codex-sidecar` is configured for `summarize-l1`,
 Throughline can use it for that step; otherwise it keeps the existing Claude
 Haiku path. This is an explicit compatibility mode, not silent auto-detection.
 
-**Codex rollback / inject is enabled.** The 2026-05-06 incident initially
-looked like a rolled-back user prompt could reappear after VS Code restart /
-reconnect, but controlled model-visible rollback smokes did not reproduce that
-path. `throughline trim --execute --host codex` now sends the guarded
-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
-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
-Codex Stop hook still attempts the guarded live refresh when it naturally fires,
-so non-monitor users get the same threshold behavior.
+**Codex current-thread rollback / inject is explicit-only.** The 2026-05-06
+incident initially looked like a rolled-back user prompt could reappear after
+VS Code restart / reconnect, and later live experiments showed token usage can
+drop briefly and then return in the same thread. For that reason, Codex hooks do
+not perform automatic current-thread refresh. `throughline trim --execute --host
+codex` remains available as an explicit diagnostic current-thread path when
+injectable DB memory is available. Bare `$throughline` instead starts a new
+thread with the handoff prompt, matching the safer Claude-style handoff model.
 
 `throughline codex-host-primitive-audit` can inspect the installed Codex
 app-server schema read-only. On the current tested Codex CLI, it finds
@@ -341,6 +367,7 @@ throughline codex-capture --codex-thread-id <id> --json
 throughline codex-summarize --session codex:<id> --json
 throughline codex-resume --session codex:<id> --format handoff
 throughline codex-handoff-start --session codex:<id>
+throughline codex-handoff-start --session codex:<id> --print-prompt
 throughline codex-handoff-smoke --session codex:<id> --json
 throughline codex-handoff-model-smoke --session codex:<id> --dry-run --json
 # optional model smoke; uses codex exec --ephemeral --sandbox read-only:
@@ -354,7 +381,7 @@ throughline trim --dry-run --host codex --codex-thread-id <id>
 throughline trim --dry-run --host codex --codex-thread-id <id> --preview-max-chars 4000
 throughline trim --preflight --host codex --codex-thread-id <id>
 CODEX_THREAD_ID=<id> throughline trim --preflight --host codex
-throughline trim --execute --host codex --all --json
+throughline trim --execute --host codex --all
 # read-only app-server process restart smoke; not full VS Code restart-safe proof:
 # THROUGHLINE_EXPERIMENTAL_CODEX_RESTORE_SMOKE=1 throughline codex-restore-smoke --codex-thread-id <id> --json
 # read-only local restore source inventory; not full VS Code restart-safe proof:
@@ -484,7 +511,9 @@ trim. The guided entrypoint is
 structural smoke, model-smoke dry-run boundary, handoff render command, optional
 live model smoke, and can include the prompt with `--print-prompt`. With
 `--memo-stdin`, it also propagates `--memo-stdin` into the replay commands and
-reminds you to pipe the same memo when using them separately. The
+reminds you to pipe the same memo when using them separately. Add `--execute`
+to create a new Codex app-server thread, inject the handoff memory as a
+developer item, and open it with `--open-host auto|vscode|cli|none`. The
 individual commands remain available: validate the fresh-thread handoff with
 `throughline codex-handoff-smoke --session codex:<thread-id>`, optionally audit
 the model-smoke boundary with
@@ -493,7 +522,7 @@ render it with `throughline codex-resume --session codex:<thread-id> --format ha
 then start a new Codex thread with that context. This does not mutate the current
 thread. `trim --execute --host codex` is the current-thread mutation path and
 still requires explicit execution, injectable Throughline DB memory, and
-rollout/app-server turn-count agreement.
+explicit Codex thread identity.
 Human-readable dry-run output truncates the inline memory preview for scanability;
 the full text remains in `--json` as `memoryPreview.text`, and for Codex the
 fresh-thread continuation can be guided with `codex-handoff-start` or rendered
@@ -535,13 +564,11 @@ Example output:
   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 is driven by the current Codex session, not the monitor.**
-  The Codex `UserPromptSubmit` and `PostToolUse` hooks capture rollout memory
-  and, when verified usage reaches 75%, inject a current-session `$throughline`
-  instruction before the assistant answers or continues a tool loop. The Codex
-  Stop hook also captures DB memory, writes monitor state, and attempts guarded
-  rollback + Throughline DB memory injection when it naturally fires above the
-  threshold.
+- **Codex auto-refresh is disabled.** The Codex `UserPromptSubmit` and
+  `PostToolUse` hooks capture rollout memory and write monitor state, but they
+  do not inject `$throughline` instructions. The Codex Stop hook also captures
+  DB memory, writes monitor state, and stays quiet instead of sending rollback +
+  injection above a threshold.
 - **1M-context detection** is automatic. It checks the `[1m]` suffix in the
   transcript, falls back to string matching on `1M context`, and finally
   promotes to 1M if observed usage exceeds 200k.
@@ -682,7 +709,7 @@ entry to the `tasks` array yourself:
 | `throughline codex-summarize --session codex:<id>` | Summarize captured Codex L2 into L1 with the Codex CLI backend |
 | `throughline codex-resume --session codex:<id>` | Render Codex active-work context from a captured Codex session |
 | `throughline codex-resume --session codex:<id> --format handoff` | Render a concise fresh-thread handoff prompt without mutating the current thread |
-| `throughline codex-handoff-start --session codex:<id>` | Guided read-only start plan for moving the handoff prompt into a new Codex thread; use `--print-prompt` to include the prompt and `--memo-stdin` to carry a current-work memo |
+| `throughline codex-handoff-start --session codex:<id>` | Guided start plan for moving handoff memory into a new Codex thread; add `--execute` to create the thread through app-server, inject developer memory, and open it with `--open-host auto\|vscode\|cli\|none`; use `--print-prompt` to include the prompt and `--memo-stdin` to carry a current-work memo |
 | `throughline codex-handoff-smoke --session codex:<id>` | Read-only validation that the fresh-thread handoff prompt is pasteable before starting a new thread |
 | `throughline codex-handoff-model-smoke --session codex:<id>` | Experimental marker smoke for the handoff prompt. `--dry-run` checks readiness / command boundary without starting Codex exec; `--memo-stdin` carries a current-work memo; live `codex exec --ephemeral --sandbox read-only` requires explicit env opt-in |
 | `throughline codex-visibility-smoke --session codex:<id>` | Experimental Codex app-server marker smoke; injects memory and starts a model turn |
@@ -695,8 +722,8 @@ 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 --execute --host codex`      | Scripted Codex current-thread rollback + Throughline DB memory inject; this is what bare `$throughline` runs in Codex |
+| `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`      | Explicit diagnostic Codex current-thread rollback + Throughline DB memory inject; bare `$throughline` does not run this automatically |
 | `throughline status`                           | Print DB statistics (sessions, skeletons, bodies, details)   |
 | `throughline --version`                        | Print the installed version                                  |
 

package/bin/throughline.mjs

@@ -182,10 +182,12 @@ Usage:
                               Use --memo-stdin to prepend current-work memo.
                               Live smoke requires THROUGHLINE_EXPERIMENTAL_CODEX_HANDOFF_MODEL_SMOKE=1
   throughline codex-handoff-start
-                              Guided read-only fresh-thread handoff start plan:
+                              Fresh-thread Codex handoff start plan:
                               structural smoke, model-smoke dry-run boundary,
                               render command, optional --print-prompt, and
-                              --memo-stdin replay guidance
+                              --memo-stdin replay guidance. Use --execute to
+                              create a new app-server thread, inject handoff
+                              memory, and open it with --open-host auto|vscode|cli|none
   throughline codex-visibility-smoke
                               Experimental: inject Codex active-work memory and
                               start a marker-check model turn. Requires

package/codex/skills/throughline/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: throughline
-description: Use when the user asks to use Throughline from Codex, continue or restore Throughline memory, run Codex trim/rewind/rollback, inject remembered context, summarize a captured Codex session, or check whether the Throughline Codex Stop hook captured the current session. Hide long Throughline command details behind this workflow.
+description: Use when the user asks to use Throughline from Codex, continue or restore Throughline memory, prepare a new Codex thread handoff, summarize a captured Codex session, or check whether the Throughline Codex Stop hook captured the current session. Hide long Throughline command details behind this workflow.
 ---
 
 # Throughline
@@ -8,10 +8,11 @@ description: Use when the user asks to use Throughline from Codex, continue or r
 Use this skill to operate Throughline from Codex without making the user type long
 commands.
 
-If the user invokes `$throughline` by itself, treat that as a request to run the
-scripted current-thread refresh now. The normal path is not an AI planning
-exercise: it rolls back the current Codex thread and injects Throughline DB
-memory using the original `/tl` contract.
+If the user invokes `$throughline` by itself, treat that as a request to prepare
+a fresh Codex thread handoff from the current Throughline memory. The normal
+path is not a current-thread trim/rollback path: it starts a new Codex thread
+through app-server, injects the handoff memory as a developer item, and opens
+that thread in the selected host.
 
 ## Core Rule
 
@@ -19,10 +20,10 @@ Do not ask the user for a Codex thread id when the current environment can
 provide it. Prefer the current `CODEX_THREAD_ID` / `THROUGHLINE_CODEX_THREAD_ID`
 identity.
 
-For bare `$throughline`, do not run doctor / dry-run / handoff / preflight first
-and do not ask for confirmation. Execute the script command directly. If it
+For bare `$throughline`, do not run doctor / dry-run / preflight first and do
+not ask for confirmation. Execute the handoff-start command directly. If it
 fails, report the error plainly instead of silently falling back to another
-memory source or a fresh-thread handoff.
+memory source or current-thread rollback.
 
 ## Common Requests
 
@@ -31,13 +32,12 @@ memory source or a fresh-thread handoff.
 Run:
 
 ```bash
-throughline trim --execute --host codex --all --json
+throughline codex-handoff-start --execute
 ```
 
-This is the scripted Codex context-refresh flow. It mutates the current Codex
-thread by sending rollback + Throughline DB memory injection. Report only the
-execution status, whether rollback / inject were sent, whether durable evidence
-was observed, and the selected memory session.
+This is the Codex new-thread continuation flow. It does not mutate the current
+Codex thread. Report the new thread id, open status, and any manual resume
+command if the host could not be opened automatically.
 
 The injected memory must preserve the original `/tl` memory contract:
 
@@ -80,11 +80,11 @@ If the user wants to continue in a fresh Codex thread instead of mutating the
 current thread, use:
 
 ```bash
-throughline codex-handoff-start --session codex:<current-thread-id> --print-prompt
+throughline codex-handoff-start --session codex:<current-thread-id> --execute
 ```
 
-If the user gave a current-work memo, pipe it with `--memo-stdin`. This is
-read-only and does not mutate the current thread.
+If the user gave a current-work memo, pipe it with `--memo-stdin`. This starts a
+new thread and does not mutate the current thread.
 
 ### "summarize"
 
@@ -99,18 +99,17 @@ back to Claude Haiku.
 
 ### "trim" / "rewind" / "rollback" / "context cleanup"
 
-Default to the same scripted execute flow as bare `$throughline` when the user
-asks to trim, rewind, rollback, clean up context, or use Throughline memory.
+Default to the same fresh-thread handoff flow as bare `$throughline` when the
+user asks to trim, rewind, rollback, clean up context, or use Throughline
+memory, unless they explicitly ask to mutate the current Codex thread.
 
 Execute:
 
 ```bash
-throughline trim --execute --host codex --all --json
+throughline codex-handoff-start --execute
 ```
 
-Report only the essential outcome. Do not introduce fresh-thread handoff,
-restore-safety analysis, host primitive audit, or dry-run planning unless the
-user explicitly asks for those diagnostics.
+Report only the essential outcome, especially the new thread id and open status.
 
 Preview:
 
@@ -121,7 +120,7 @@ throughline trim --dry-run --host codex
 Safe new-thread continuation:
 
 ```bash
-throughline codex-handoff-start --session codex:<current-thread-id> --json
+throughline codex-handoff-start --session codex:<current-thread-id> --execute --json
 ```
 
 Report the context reduction estimate from the dry-run when present:
@@ -146,17 +145,19 @@ Execute path:
 throughline trim --execute --host codex --all
 ```
 
-This is the same command used by bare `$throughline`.
+This is an explicit current-thread rollback / inject diagnostic path. Do not use
+it for bare `$throughline`.
 
 ## User-Facing Explanation
 
 Explain the behavior simply:
 
 - normal Codex turn end: Stop hook captures DB memory and writes monitor state
-- `$throughline` / context refresh: one script command mutates the current Codex
-  thread by rollback + memory inject
-- injected memory is L2 latest 20 full bodies + older L1 summaries + L3
+- `$throughline` / context handoff: one script command builds new-thread
+  handoff memory from Throughline DB, injects it into a new Codex thread as a
+  developer item, and opens that thread
+- handoff memory is L2 latest 20 full bodies + older L1 summaries + L3
   references only
-- diagnostics such as doctor, dry-run, preflight, fresh-thread handoff, restore
-  safety, and host primitive audit are optional tools, not the normal
+- diagnostics such as doctor, dry-run, preflight, current-thread rollback,
+  restore safety, and host primitive audit are optional tools, not the normal
   `$throughline` path

package/codex/skills/throughline/agents/openai.yaml

@@ -1,7 +1,7 @@
 interface:
   display_name: "Throughline"
-  short_description: "Operate Throughline memory, Codex capture, resume, and trim"
-  default_prompt: "Use $throughline to run the scripted current-thread rollback + Throughline memory inject, or explicitly ask for status, resume, summarize, diagnostics, or fresh-thread handoff."
+  short_description: "Operate Throughline memory, Codex capture, resume, and handoff"
+  default_prompt: "Use $throughline to start a new Codex thread with Throughline handoff memory, or explicitly ask for status, resume, summarize, diagnostics, or current-thread rollback."
 
 policy:
   allow_implicit_invocation: true

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 として追加します。