throughline 0.4.10 → 0.4.11

package/CHANGELOG.md

@@ -10,6 +10,19 @@ 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
@@ -139,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
 
@@ -296,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,20 +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 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
-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
@@ -344,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:
@@ -357,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:
@@ -487,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
@@ -496,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
@@ -538,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.
@@ -685,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 |
@@ -699,7 +723,7 @@ entry to the `tasks` array yourself:
 | `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 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 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_FIRST_ROADMAP.md

@@ -28,11 +28,11 @@
 - 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 と 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 を遅らせる。
+- 2026-05-10 update: Codex automatic current-thread refresh mutation は無効化する。live rollback / inject で token_count が一時的に落ちても同一 thread で戻る実測があるため、`UserPromptSubmit` / `PostToolUse` / `Stop` hooks は capture / monitor state write のみ行い、`codex_auto_refresh_disabled` で quiet にする。bare `$throughline` は `codex-handoff-start --execute` による app-server 新スレッド handoff とし、明示 `trim --execute --host codex` だけを診断用 current-thread rollback / inject path として残す。
 
 ## 新セッション引き継ぎ
 
-2026-05-08 時点では、Codex primary の capture / summarize / resume は実装・実測済み。Codex trim execute / auto-refresh は、controlled rollback model-visible smoke の clean result を受けて blocker を解除した。[THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md](THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md) の Phase 0-3 は実装済み。Phase 4 では Codex app-server の protocol / local store 調査、read-only app-server process restart smoke、local restore source audit、manual VS Code restart smoke protocol、実 VS Code reload / reconnect 後の hidden developer memory marker proof、rollback 非復活 verifier、controlled rollback model-visible smoke surface まで進んだ。incident-shaped live rollback run では `compacted.replacement_history` retention を診断したが、後続の risky restore inspection では app-server response 上の retained text は `aggregatedOutput` など quoted/tool-output field に限定され、direct user message / `replacement_history` の復活とは分離された。`throughline codex-host-primitive-audit` は diagnostic-only として残す。
+2026-05-08 時点では、Codex primary の capture / summarize / resume は実装・実測済み。Codex trim execute / auto-refresh は、controlled rollback model-visible smoke の clean result を受けて blocker を解除した。[THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md](THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md) の Phase 0-3 は実装済み。Phase 4 では Codex app-server の protocol / local store 調査、read-only app-server process restart smoke、local restore source audit、manual VS Code restart smoke protocol、実 VS Code reload / reconnect 後の hidden developer memory marker proof、rollback 非復活 verifier、controlled rollback model-visible smoke surface まで進んだ。incident-shaped live rollback run では `compacted.replacement_history` retention を診断したが、後続の risky restore inspection では app-server response 上の retained text は `aggregatedOutput` など quoted/tool-output field に限定され、direct user message / `replacement_history` の復活とは分離された。2026-05-10 の live token_count 実験では同一 thread refresh が持続削減にならない可能性が濃くなったため、auto-refresh は disabled、通常 `$throughline` は新スレッド handoff とする。`throughline codex-host-primitive-audit` は diagnostic-only として残す。
 
 Codex 側で実装済み / 診断可能なもの:
 
@@ -41,7 +41,7 @@ Codex 側で実装済み / 診断可能なもの:
 - `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 を診断し、必要なら 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` を補正する。
+- `trim --execute --host codex`: explicit diagnostic current-thread path として、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` を補正する。bare `$throughline` と hooks からは呼ばない。
 - `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 証明ではない。
@@ -271,7 +271,7 @@ Phase 3 implementation result (2026-05-06):
 - [x] `throughline codex-resume --format handoff` は current thread を mutate せず、新規 Codex thread に貼る短い handoff prompt を返す。handoff view は L2 件数 / 本文長 / detail refs を cap し、full active-work context は通常 text renderer に残す。
 - [x] `throughline codex-handoff-smoke --session codex:<thread_id>` は新規 thread handoff prompt を read-only に検査し、prompt size / required sections / mutation boundary / detail command dedupe を固定する。
 - [x] `throughline codex-handoff-model-smoke --session codex:<thread_id>` は明示 opt-in 時だけ `codex exec --ephemeral --ignore-user-config --ignore-rules --sandbox read-only` で handoff prompt の marker model smoke を行う。`--dry-run` は env なしで readiness / command boundary を監査し、`--print-prompt` で結合 prompt を出せる。`--memo-stdin` で Codex-primary current-work memo も同じ prompt に含める。structural handoff smoke が ready でなければ拒否し、current thread は mutate しない。
-- [x] `throughline codex-handoff-start --session codex:<thread_id>` は safe continuation の guided entrypoint として、structural smoke / model smoke dry-run / handoff render / optional live smoke / `--print-prompt` を read-only にまとめて表示する。`--memo-stdin` 時は replay 用コマンドにも `--memo-stdin` を伝播し、same memo を pipe する注意を出す。
+- [x] `throughline codex-handoff-start --session codex:<thread_id>` は safe continuation の guided entrypoint として、structural smoke / model smoke dry-run / handoff render / optional live smoke / `--print-prompt` をまとめて表示する。`--execute` では app-server `thread/start` + `thread/inject_items` で新 thread に developer memory を注入し、`--open-host auto|vscode|cli|none` で表示を開く。`--memo-stdin` 時は replay 用コマンドにも `--memo-stdin` を伝播し、same memo を pipe する注意を出す。
 - [x] `throughline codex-resume --format item-json` は Codex developer message item JSON を返す。
 - [x] `codex-resume` は explicit session を受け取れる。省略時は cwd の最新 `codex:%` session だけを対象にし、Claude session を混ぜない。
 - [x] `src/codex-handoff.test.mjs` / `src/codex-resume.test.mjs` で renderer と CLI shape を固定した。
@@ -440,7 +440,7 @@ Phase 5 implementation status (2026-05-06):
 - [x] `doctor --codex` は Claude settings を変更しない。Codex primary entrypoint の診断に限定する。
 - [x] 実セッションで `doctor --codex` -> `codex-capture` -> `codex-resume --format item-json` -> `doctor --codex` の local smoke を実施した。`codex-resume` は developer message item JSON を描画し、再診断で captured DB session が 1 件として表示された。
 - [x] 実セッションで `codex-visibility-smoke` を実施した。`THROUGHLINE_EXPERIMENTAL_CODEX_MODEL_VISIBLE_SMOKE=1` を必須にし、長い model turn に備えて `--request-timeout-ms 150000` / `--timeout-ms 180000` を使えるようにした。
-- [x] Codex primary の setup / install 手順は README に記録した。global install は Codex Stop hook と `$throughline` skill を自動登録する。2026-05-09 以降、bare `$throughline` は AI による診断 flow ではなく `trim --execute --host codex --all --json` を直接走らせる scripted current-thread refresh とする。diagnostics / dry-run / preflight / fresh-thread handoff は明示要求時だけ使う。
+- [x] Codex primary の setup / install 手順は README に記録した。global install は Codex hooks と `$throughline` skill を自動登録する。2026-05-10 以降、bare `$throughline` は `throughline codex-handoff-start --execute` による app-server 新スレッド handoff とする。hooks は capture / monitor state write だけを行い、current-thread rollback / inject は明示 `trim --execute --host codex` を要求された時だけ使う。
 - [x] `codex-summarize` を明示診断・運用 flow に追加した。Codex CLI backend を使い、Claude Haiku へ fallback しない。
 - [x] Codex primary の summarize / guarded execute まで含む end-to-end smoke を実施した。2026-05-07 correction では guarded execute を live app-server smoke としてのみ扱った。2026-05-08 unblock 後は、controlled rollback model-visible smoke の `not-reproduced` と current-thread live run の `execute-durable-verified` を合わせて、Codex current-thread trim 完了条件に含める。
   - `codex-capture`: `capturedTurns = 41`, `capturedRows = 75`, `capturedDetails = 2424`
@@ -460,7 +460,7 @@ Phase 5 implementation status (2026-05-06):
   - 追加確認: current VSCode-origin parent thread `019dfd38-c530-71c3-b7b8-180bdd3054bc` は hook shape 変更前に開始していたため、変更後の自然 Stop smoke としては不適格。assistant final 後に rollout は `task_complete` まで進んだが latest DB session は exec child のままだった。次に VSCode-origin を見る場合は、hook shape 変更後に新しく開始した Codex session で確認する。
   - 最終確認: 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 は明示要求時だけ使う。
+  - 2026-05-10 UX 修正: bare `$throughline` は `doctor --codex` / `trim --dry-run --all` / `trim --preflight --all` を AI に順番実行させる説明 surface でも、`trim --execute --host codex --all` を直接実行する current-thread refresh でもなく、`throughline codex-handoff-start --execute` による app-server 新スレッド handoff とする。current-thread rollback / inject は明示要求時だけ使う。
   - 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 で削減できない」という意味ではない。
@@ -468,8 +468,8 @@ Phase 5 implementation status (2026-05-06):
   - 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` に保存する。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 は送らない状態にした。2026-05-08 unblock 後は guarded rollback / inject を再有効化し、2026-05-09 以降は Codex native auto-compact より先に Throughline refresh を走らせるため verified usage `75%` 以上を既定閾値にする。
-  - current-session trigger 修正: Codex auto-refresh を token-monitor の描画ループに置かず、Codex `UserPromptSubmit` / `PostToolUse` hooks が当該 session の rollout `token_count` を直接読んで verified 75% 以上なら `$throughline` workflow 実行指示を同じ user turn または tool loop 継続前の `additionalContext` として注入する。monitor は表示専用で、自動発火の判定元にしない。
+  - 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 以降は verified usage `75%` 以上を既定閾値にした。2026-05-10 の live token_count 実験後は、automatic refresh mutation を再び無効化する。
+  - current-session trigger 修正: Codex `UserPromptSubmit` / `PostToolUse` hooks は当該 session の rollout capture / monitor state write だけを行う。verified 75% 以上でも `$throughline` workflow 実行指示を `additionalContext` として注入しない。monitor は表示専用で、自動発火の判定元にしない。
 
 ## Phase 6: Claude Side Finalization
 
@@ -515,11 +515,11 @@ 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 がある `trim --execute` を塞がない。rollout/app-server turn-count mismatch は診断と app-server-count `numTurns` 補正に使う。
+Codex primary の capture / summarize / resume は完了扱い。Codex trim execute は明示診断用 current-thread path として残すが、auto-refresh は 2026-05-10 の live token_count 実験後に無効化済み。[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 は見つかっていない。通常 `$throughline` は新スレッド handoff prompt とし、current-thread rollback / inject は自動化しない。
 
 再開時は次を実施する:
 
-1. Codex trim execute / Stop hook auto-refresh の実運用 telemetry を見て、`execute-sent-live-only` / `execute-unverified` / `execute-durable-verified` の分類が期待どおりか確認する。
+1. Codex 新スレッド handoff UX を通常 `$throughline` surface として磨き、必要な場合だけ明示 `trim --execute --host codex` の telemetry を見る。
 2. VS Code restore path の追加実測を行い、`compacted.replacement_history` が rollback 済み user text の復元元として残る経路をさらに特定する。
 3. restore-safety / host primitive audit を blocker として再導入する場合は、controlled smoke で再現した具体的 evidence を先に記録する。
 4. その後に Claude `/rewind conversation only` の手動 UX 確認へ戻る。

package/docs/THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md

@@ -18,10 +18,15 @@ 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 mismatch は診断に残し、
-app-server `thread/read` / `thread/resume` が同じ count を返す場合は、その差分で rollback `numTurns`
-を補正します。Codex Stop hook
-auto-refresh は verified usage 75% 以上で同じ guarded path を試行し、estimate usage では実行しません。
+Codex thread identity を条件にした診断用 path として残します。rollout/app-server
+turn-count mismatch は診断に残し、app-server `thread/read` / `thread/resume` が同じ
+count を返す場合は、その差分で rollback `numTurns` を補正します。
+2026-05-10 update: live token_count 実験で、rollback / inject 後に token count が
+一時的に下がっても同一 thread で戻る挙動を確認したため、Codex automatic
+current-thread refresh は無効化します。`UserPromptSubmit` / `PostToolUse` / `Stop`
+hooks は capture / monitor state write のみ行い、`codex_auto_refresh_disabled` で
+quiet にします。bare `$throughline` は `codex-handoff-start --execute` による
+app-server 新スレッド handoff とします。
 
 最初のインシデント仮説に対する重要な訂正:
 
@@ -648,13 +653,11 @@ TODO:
   という記述を訂正する。
 - [x] hypothesis を compacted replacement-history restore に言及する形へ更新する。
 - [x] Codex Rewind-equivalent trim が complete だという roadmap claim を格下げする。
-- [x] Codex auto-refresh は verified usage 75% 以上で guarded rollback / inject を
-  実行する。estimate usage では実行しない。
-- [x] Codex 75% trigger は token-monitor 依存にしない。Codex `UserPromptSubmit`
-  / `PostToolUse` hooks が当該 session の rollout `token_count` を直接読み、
-  verified 75% 以上なら current session へ `$throughline` workflow 実行指示を
-  注入する。`PostToolUse` により、tool loop 中に閾値を超えた場合も次の継続前に
-  同じ判定を走らせる。
+- [x] Codex auto-refresh は無効化する。明示 `trim --execute --host codex` は
+  diagnostic current-thread rollback / inject として残す。
+- [x] Codex `UserPromptSubmit` / `PostToolUse` hooks は token-monitor 依存にせず
+  rollout capture / monitor state write だけを行う。verified 75% 以上でも current
+  session へ `$throughline` workflow 実行指示を注入しない。
 - [x] 新セッションが古い「Codex side complete」claim ではなく、この fix plan から
   再開できるように `CLAUDE.md` を更新する。
 
@@ -674,11 +677,11 @@ TODO:
 5. フェーズ 4: durable host behavior を調査し、製品仕様を決める。
 6. フェーズ 5: 挙動修正後に広範な docs を更新する。
 
-作業量や複雑さを理由に目標を下げない。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 / rollout-app-server turn-count mismatch は diagnostics として残すが、単独では execute / auto-refresh の blocker にしない。
-mutation 前 refusal は thread identity と Throughline DB injectable memory に限定する。
+作業量や複雑さを理由に目標を下げない。2026-05-10 時点の製品仕様は、
+通常 `$throughline` を新スレッド handoff prompt とし、Codex hooks は automatic
+current-thread mutation を行わないこと。明示 `trim --execute --host codex` は診断用
+current-thread rollback / inject として残す。restore-safety / host primitive audit /
+rollout-app-server turn-count mismatch は diagnostics として残す。
 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` を送る。例: