throughline 0.4.7 → 0.4.8

package/CHANGELOG.md

@@ -10,6 +10,19 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.4.8] — 2026-05-09
+
+### Changed
+
+- Codex install now registers `UserPromptSubmit` and `PostToolUse` hooks in
+  addition to the Stop hook. These hooks read the current Codex rollout
+  `token_count` directly and, at the verified 80% threshold, inject a
+  current-session `$throughline` instruction before the assistant answers or
+  continues a tool loop. This keeps automatic refresh independent of
+  token-monitor and available to users who never run the monitor.
+- `throughline install` now enables both `[features].codex_hooks = true` and
+  `[features].hooks = true` for Codex hook compatibility.
+
 ## [0.4.7] — 2026-05-09
 
 ### Changed

package/README.ja.md

@@ -26,6 +26,11 @@ throughline install     # hook / Codex skill / VS Code monitor task を登録
 `/clear` を打てば新セッションはゼロからではなく、**思考の途中から再開** される。
 `/clear` を経由しない新規 chat / VS Code 再起動では `/tl` で前任を指名できる。
 
+Codex では `UserPromptSubmit` / `PostToolUse` / `Stop` hook と `$throughline`
+skill も登録する。80% 自動発火は token-monitor 依存ではなく、当該 Codex
+セッションの rollout `token_count` を hook が読み、prompt 送信時または tool loop
+途中の閾値到達時に同じセッションへ `$throughline` 実行指示を注入する。
+
 ## 他の手段との比較
 
 | | Throughline | MemGPT / SummaryBufferMemory | 素の Claude Code |
@@ -231,7 +236,7 @@ Throughline state をまだ書いていない現在セッションも表示で
 
 | コマンド | 役割 |
 | --- | --- |
-| `throughline install` | hook / Codex skill を登録し、VS Code 配下なら現プロジェクトの monitor task も配置 |
+| `throughline install` | hook / Codex UserPromptSubmit・PostToolUse・Stop hook / Codex skill を登録し、VS Code 配下なら現プロジェクトの monitor task も配置 |
 | `throughline install --project` | 現リポジトリの `.claude/settings.json` だけに hook を登録 |
 | `throughline uninstall` | hook を削除 |
 | `throughline monitor` | マルチセッション監視を起動 |

package/README.md

@@ -27,16 +27,20 @@ type `/clear` — the new session resumes mid-thought instead of starting from
 zero. (For non-`/clear` boundaries such as a brand-new chat or a VSCode
 restart, type `/tl` first to mark the predecessor.)
 
-Global install also registers a Codex Stop hook in `~/.codex/hooks.json` and
-enables `[features].codex_hooks = true` in `~/.codex/config.toml`. The Codex
-hook invokes the installed `bin/throughline.mjs` through an absolute Node path,
-so Codex App Server PATH differences do not hide the command. It is registered
-synchronously (`async: false`), matching the Codex hook behavior verified in
-Caveat. Existing non-Throughline Codex hooks are preserved. 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.
+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
+`~/.codex/config.toml`. The Codex hooks invoke the installed
+`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 80% 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.
 
 ## How it compares
 
@@ -249,10 +253,12 @@ 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 Stop hook auto-refresh also attempts
-the same live refresh when verified usage reaches the 80% threshold, which runs
-before Codex native auto-compact while staying above the monitor's 70% warning
-band.
+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 80% 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.
 
 `throughline codex-host-primitive-audit` can inspect the installed Codex
 app-server schema read-only. On the current tested Codex CLI, it finds
@@ -529,10 +535,13 @@ 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 mutates at the verified 80% threshold.** The Codex Stop
-  hook captures DB memory, writes monitor state, and when verified usage reaches
-  the threshold it attempts rollback + Throughline DB memory injection for the
-  current thread.
+- **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 80%, 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.
 - **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.
@@ -598,7 +607,7 @@ monitor appears in a dedicated terminal panel the next time you open that
 folder.
 
 **How it works.** `ensureMonitorTaskFile` is called from `throughline install`
-and from **all three hooks (SessionStart, UserPromptSubmit, Stop)**. Whichever
+and from **all three Claude hooks (SessionStart, UserPromptSubmit, Stop)**. Whichever
 one fires first in your environment creates the file; the rest are idempotent
 no-ops. Once per project it inspects `.vscode/tasks.json`:
 
@@ -658,7 +667,7 @@ entry to the `tasks` array yourself:
 
 | Command                                        | What it does                                                 |
 | ---------------------------------------------- | ------------------------------------------------------------ |
-| `throughline install`                          | Register Claude user hooks/slash commands, the global Codex Stop hook, the global `$throughline` Codex skill, and the current VS Code monitor task when applicable |
+| `throughline install`                          | Register Claude user hooks/slash commands, the global Codex UserPromptSubmit/PostToolUse/Stop hooks, the global `$throughline` Codex skill, and the current VS Code monitor task when applicable |
 | `throughline install --project`                | Register Claude hooks/slash commands in this repo only       |
 | `throughline uninstall`                        | Remove Throughline-managed Claude hooks/slash commands, only the Throughline-managed Codex hook, and the `$throughline` Codex skill |
 | `throughline monitor [--all] [--session <id>]` | Run the multi-session token monitor                          |

package/bin/throughline.mjs

@@ -11,6 +11,8 @@
  *   throughline detail <時刻> # L2+L3 詳細取得 (Claude が Bash 経由で呼ぶ想定)
  *   throughline handoff-preview # Codex-facing throughline_handoff JSON preview
  *   throughline codex-capture # Capture active Codex rollout turns into Throughline DB
+ *   throughline codex-hook user-prompt-submit # Codex current-session auto-refresh prompt hook
+ *   throughline codex-hook post-tool-use # Codex current-session auto-refresh tool-loop hook
  *   throughline codex-hook stop # Codex native Stop hook (capture + L1 summarize)
  *   throughline codex-summarize # Summarize captured Codex L2 turns into L1 via Codex CLI
  *   throughline codex-resume # Render Codex active-work context from DB
@@ -149,8 +151,17 @@ Usage:
   throughline handoff-preview   Print Codex-facing throughline_handoff JSON
   throughline codex-capture     Capture active Codex rollout turns into DB
                               (requires --codex-thread-id or env thread id)
-  throughline codex-hook stop   Codex native Stop hook: capture rollout and
-                              summarize old L2 turns into L1 via Codex CLI
+  throughline codex-hook user-prompt-submit
+                              Codex UserPromptSubmit hook: capture rollout and,
+                              at 80%, inject current-session $throughline
+                              instruction from verified rollout token_count
+  throughline codex-hook post-tool-use
+                              Codex PostToolUse hook: during tool loops, capture
+                              rollout and inject the same 80% $throughline
+                              instruction from verified rollout token_count
+  throughline codex-hook stop   Codex native Stop hook: capture rollout,
+                              summarize old L2 turns into L1, and run guarded
+                              auto-refresh when verified usage reaches 80%
   throughline codex-summarize   Summarize captured Codex L2 into L1 via Codex CLI
                               (requires a codex:<thread-id> session)
   throughline codex-resume      Render Codex active-work context from DB
@@ -243,6 +254,8 @@ Hook subcommands (called by Claude Code / Codex):
   throughline session-start   SessionStart hook
   throughline process-turn    Stop hook
   throughline prompt-submit   UserPromptSubmit hook (/tl & /clear baton writer)
+  throughline codex-hook user-prompt-submit Codex current-session refresh prompt hook
+  throughline codex-hook post-tool-use Codex current-session refresh tool-loop hook
   throughline codex-hook stop Codex Stop hook
 `);
 }

package/docs/PUBLIC_RELEASE_PLAN.md

@@ -137,6 +137,7 @@ schema v4 で PostToolUse (`capture-tool`) は廃止、L2/L3 は Stop 内で一
 | **npm 公開 (v0.4.0): /clear auto-handoff + memo / save-inflight / /tl-trim retire** | 2026-05-08 Claude Code 2.1.128 で `source='clear'` が reliable になったため、`/clear` で自動引継ぎがデフォルト ON になる auto path を追加。`THROUGHLINE_DISABLE_AUTO_HANDOFF=1` で OFF にできる。`/tl` slash command は明示意思マーカーへ簡素化 (memo 4 項目入力廃止、`save-inflight` CLI 削除、`/tl-trim` slash command 廃止、`updateBatonMemo` 関数削除、`handoff_batons.memo_text` を schema v8 で drop)。注入は L1 + L2 + L3 references のみに簡素化し、memo / 中断直前 thinking セクションを削除。Codex 側 trim path は維持。詳細は [CHANGELOG.md](../CHANGELOG.md) と [THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md](THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md) |
 | **npm 公開 (v0.4.1): typed `/clear` も baton を書く + 2 経路の優先順位入れ替え** | 2026-05-09 `/clear` を UserPromptSubmit hook で検出した時点で当該セッションの `session_id` を `handoff_batons` に書き込み、次 SessionStart が確定的にそのセッションを引き継ぐ。これで multi-window で「最新更新セッション ≠ /clear したセッション」になるシナリオで `findLatestClaudePredecessor` heuristic が誤った前任を選ぶ問題を解消。2 経路の優先順位を **baton path = primary、auto path = fallback** に変更 (auto path は VSCode 拡張メニュー由来など UserPromptSubmit に届かない経路のフォールバック)。`THROUGHLINE_DISABLE_AUTO_HANDOFF=1` は fallback path のみに作用するようになった (typed `/clear` / `/tl` は env と無関係に発火する)。あわせて `.vscode/tasks.json` を git 追跡から外し (gitignore)、`ensureMonitorTaskFile` が hook 発火ごとに絶対パスを書き換える挙動による別環境での dirty diff を解消。`src/prompt-submit.test.mjs` を新設し、`isClearCommand` / `isBatonCommand` 判定 14 件と subprocess+DB 実体テスト 3 件を追加。詳細は [CHANGELOG.md](../CHANGELOG.md) |
 | **npm 公開 (v0.4.7): Codex monitor direct discovery + 80% auto-refresh** | 2026-05-09 Codex Stop hook auto-refresh の verified usage threshold を 90% から 80% に変更し、Codex native auto-compact より先に Throughline DB memory refresh を試行する。estimate usage / estimated context window では mutation しない。`throughline monitor` は `~/.throughline/state` に加えて `~/.codex/sessions/**/rollout-*.jsonl` を直接 discovery し、Throughline state が未生成の現在 Codex thread も表示する。既存 state がある場合は state の usage snapshot を保持しつつ discovered rollout path / mtime を合流する。Codex 表示 ID は `codex:01` ではなく raw thread id 先頭 8 桁 (`019e085c`) にした。Codex open turn の transient `output_tokens` は token count に overlay するが、モデル欄の `live+<tokens>` marker は表示しない |
+| **未リリース: Codex current-session 80% trigger** | Codex 自動発火を token-monitor に依存させず、global install が Codex `UserPromptSubmit` / `PostToolUse` hooks も登録する。hook は当該 Codex session の rollout `token_count` を直接読み、verified 80% 以上なら同じ user turn または tool loop 継続前に `$throughline` workflow 実行指示を `additionalContext` で注入する。Stop hook の guarded auto-refresh は残す。`~/.codex/config.toml` は旧 `codex_hooks = true` に加えて現行 `hooks = true` も有効化する |
 | **グローバル E2E 検証** | 2026-04-17 別ディレクトリから `throughline doctor` 全緑を確認 |
 
 ### ❌ 未完タスク

package/docs/THROUGHLINE_CODEX_FIRST_ROADMAP.md

@@ -469,6 +469,7 @@ Phase 5 implementation status (2026-05-06):
   - 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 `80%` 以上を既定閾値にする。
+  - current-session trigger 修正: Codex auto-refresh を token-monitor の描画ループに置かず、Codex `UserPromptSubmit` / `PostToolUse` hooks が当該 session の rollout `token_count` を直接読んで verified 80% 以上なら `$throughline` workflow 実行指示を同じ user turn または tool loop 継続前の `additionalContext` として注入する。monitor は表示専用で、自動発火の判定元にしない。
 
 ## Phase 6: Claude Side Finalization
 

package/docs/THROUGHLINE_CODEX_TRIM_ROLLBACK_FIX_PLAN.md

@@ -646,6 +646,11 @@ TODO:
 - [x] Codex Rewind-equivalent trim が complete だという roadmap claim を格下げする。
 - [x] Codex auto-refresh は verified usage 80% 以上で guarded rollback / inject を
   実行する。estimate usage では実行しない。
+- [x] Codex 80% trigger は token-monitor 依存にしない。Codex `UserPromptSubmit`
+  / `PostToolUse` hooks が当該 session の rollout `token_count` を直接読み、
+  verified 80% 以上なら current session へ `$throughline` workflow 実行指示を
+  注入する。`PostToolUse` により、tool loop 中に閾値を超えた場合も次の継続前に
+  同じ判定を走らせる。
 - [x] 新セッションが古い「Codex side complete」claim ではなく、この fix plan から
   再開できるように `CLAUDE.md` を更新する。
 

package/package.json

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

package/src/cli/codex-hook.mjs

@@ -31,7 +31,9 @@ function parseArgs(argv) {
   }
 
   if (!out.event) out.event = 'stop';
-  if (out.event !== 'stop') throw new Error(`unknown Codex hook event: ${out.event}`);
+  if (!['stop', 'user-prompt-submit', 'post-tool-use'].includes(out.event)) {
+    throw new Error(`unknown Codex hook event: ${out.event}`);
+  }
   return out;
 }
 
@@ -69,7 +71,39 @@ function suppressExperimentalWarnings() {
   });
 }
 
-export async function runCodexStopHook({
+export function codexContextOutput(text, eventName = 'UserPromptSubmit') {
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: eventName,
+      additionalContext: text,
+    },
+  });
+}
+
+function renderAutoRefreshContext({ usage, decision, threadId, eventName = 'UserPromptSubmit' }) {
+  const tokens = Number(usage?.tokens);
+  const contextWindowSize = Number(usage?.contextWindowSize);
+  const ratio = Number(decision?.ratio);
+  const percent = Number.isFinite(ratio) ? `${(ratio * 100).toFixed(1)}%` : 'unknown';
+  const timing =
+    eventName === 'PostToolUse'
+      ? 'Before continuing the current tool loop, run the installed $throughline workflow now.'
+      : 'Before answering the user prompt, run the installed $throughline workflow now.';
+  return [
+    '[throughline] Codex context refresh threshold reached for this current session.',
+    `Thread: ${threadId}`,
+    `Usage: ${Number.isFinite(tokens) ? tokens : 'unknown'} / ${Number.isFinite(contextWindowSize) ? contextWindowSize : 'unknown'} (${percent}); threshold ${(decision.threshold * 100).toFixed(0)}%.`,
+    '',
+    timing,
+    'Execute exactly:',
+    'throughline trim --execute --host codex --all --json',
+    '',
+    'Report only the execution status, whether rollback/inject were sent, durable evidence if present, and the selected memory session; then continue from the refreshed context.',
+    'This trigger was computed from the current Codex rollout token_count, not from token-monitor output.',
+  ].join('\n');
+}
+
+async function captureCodexHookSession({
   args = {},
   payload = {},
   env = process.env,
@@ -77,7 +111,7 @@ export async function runCodexStopHook({
   writeMonitorState = null,
   ensureMonitorTask = null,
   buildMonitorUsage = null,
-  runAutoRefresh = null,
+  summarize = true,
 } = {}) {
   const [
     { getDb },
@@ -87,7 +121,6 @@ export async function runCodexStopHook({
     { writeSessionState },
     { ensureMonitorTaskFile },
     { buildCodexMonitorUsage },
-    { runCodexAutoRefresh },
   ] = await Promise.all([
     import('../db.mjs'),
     import('../codex-capture.mjs'),
@@ -96,7 +129,6 @@ export async function runCodexStopHook({
     import('../state-file.mjs'),
     import('../vscode-task.mjs'),
     import('../codex-usage.mjs'),
-    import('../codex-auto-refresh.mjs'),
   ]);
   const actualDb = db ?? getDb();
   const identity = resolveCodexHookThreadIdentity({ args, payload, env, resolveCodexThreadIdentity });
@@ -105,8 +137,14 @@ export async function runCodexStopHook({
     return {
       status: 'skipped',
       reason: 'codex_thread_id_not_available',
+      db: actualDb,
+      identity,
+      projectPath: null,
+      codexHome: null,
       captured: null,
       summarized: null,
+      monitorState: null,
+      usage: null,
     };
   }
 
@@ -136,9 +174,14 @@ export async function runCodexStopHook({
     return {
       status: 'skipped',
       reason: captured.reason ?? 'codex_capture_not_available',
-      codexThreadIdSource: identity.codexThreadIdSource,
+      db: actualDb,
+      identity,
+      projectPath,
+      codexHome,
       captured,
       summarized: null,
+      monitorState: null,
+      usage: null,
     };
   }
 
@@ -161,23 +204,73 @@ export async function runCodexStopHook({
     process.stderr.write(`[codex-hook:monitor-state] ${msg}\n`);
   }
 
-  const summarized = summarizeCodexSession(actualDb, {
-    sessionId: captured.sessionId,
-    projectPath: captured.projectPath ?? projectPath,
-    max: 1,
-    env,
-  });
+  const summarized = summarize
+    ? summarizeCodexSession(actualDb, {
+        sessionId: captured.sessionId,
+        projectPath: captured.projectPath ?? projectPath,
+        max: 1,
+        env,
+      })
+    : null;
+
+  return {
+    status: 'ok',
+    reason: 'codex_rollout_captured',
+    db: actualDb,
+    identity,
+    projectPath,
+    codexHome,
+    captured,
+    summarized,
+    monitorState,
+    usage,
+  };
+}
+
+export async function runCodexStopHook({
+  args = {},
+  payload = {},
+  env = process.env,
+  db = null,
+  writeMonitorState = null,
+  ensureMonitorTask = null,
+  buildMonitorUsage = null,
+  runAutoRefresh = null,
+} = {}) {
+  const [{ runCodexAutoRefresh }, capturedState] = await Promise.all([
+    import('../codex-auto-refresh.mjs'),
+    captureCodexHookSession({
+      args,
+      payload,
+      env,
+      db,
+      writeMonitorState,
+      ensureMonitorTask,
+      buildMonitorUsage,
+      summarize: true,
+    }),
+  ]);
+
+  if (capturedState.status !== 'ok') {
+    return {
+      status: capturedState.status,
+      reason: capturedState.reason,
+      codexThreadIdSource: capturedState.identity?.codexThreadIdSource,
+      captured: capturedState.captured,
+      summarized: capturedState.summarized,
+    };
+  }
 
   let autoRefresh = null;
   try {
     autoRefresh = await (runAutoRefresh ?? runCodexAutoRefresh)({
-      db: actualDb,
-      threadId: identity.codexThreadId,
-      codexThreadIdSource: identity.codexThreadIdSource,
-      codexHome,
-      projectPath: captured.projectPath ?? projectPath,
-      sessionId: captured.sessionId,
-      usage,
+      db: capturedState.db,
+      threadId: capturedState.identity.codexThreadId,
+      codexThreadIdSource: capturedState.identity.codexThreadIdSource,
+      codexHome: capturedState.codexHome,
+      projectPath: capturedState.captured.projectPath ?? capturedState.projectPath,
+      sessionId: capturedState.captured.sessionId,
+      usage: capturedState.usage,
       command: env.THROUGHLINE_CODEX_APP_SERVER_BIN ?? process.env.THROUGHLINE_CODEX_APP_SERVER_BIN ?? 'codex',
     });
   } catch (err) {
@@ -193,14 +286,129 @@ export async function runCodexStopHook({
   return {
     status: 'ok',
     reason: 'codex_rollout_captured',
-    codexThreadIdSource: identity.codexThreadIdSource,
-    captured,
-    summarized,
-    monitorState,
+    codexThreadIdSource: capturedState.identity.codexThreadIdSource,
+    captured: capturedState.captured,
+    summarized: capturedState.summarized,
+    monitorState: capturedState.monitorState,
     autoRefresh,
   };
 }
 
+export async function runCodexUserPromptSubmitHook({
+  args = {},
+  payload = {},
+  env = process.env,
+  db = null,
+  writeMonitorState = null,
+  ensureMonitorTask = null,
+  buildMonitorUsage = null,
+} = {}) {
+  return runCodexContextRefreshInstructionHook({
+    eventName: 'UserPromptSubmit',
+    args,
+    payload,
+    env,
+    db,
+    writeMonitorState,
+    ensureMonitorTask,
+    buildMonitorUsage,
+  });
+}
+
+export async function runCodexPostToolUseHook({
+  args = {},
+  payload = {},
+  env = process.env,
+  db = null,
+  writeMonitorState = null,
+  ensureMonitorTask = null,
+  buildMonitorUsage = null,
+} = {}) {
+  return runCodexContextRefreshInstructionHook({
+    eventName: 'PostToolUse',
+    args,
+    payload,
+    env,
+    db,
+    writeMonitorState,
+    ensureMonitorTask,
+    buildMonitorUsage,
+  });
+}
+
+async function runCodexContextRefreshInstructionHook({
+  eventName,
+  args = {},
+  payload = {},
+  env = process.env,
+  db = null,
+  writeMonitorState = null,
+  ensureMonitorTask = null,
+  buildMonitorUsage = null,
+} = {}) {
+  const [{ evaluateCodexAutoRefreshUsage }, capturedState] = await Promise.all([
+    import('../codex-auto-refresh.mjs'),
+    captureCodexHookSession({
+      args,
+      payload,
+      env,
+      db,
+      writeMonitorState,
+      ensureMonitorTask,
+      buildMonitorUsage,
+      summarize: false,
+    }),
+  ]);
+
+  if (capturedState.status !== 'ok') {
+    return {
+      status: capturedState.status,
+      reason: capturedState.reason,
+      codexThreadIdSource: capturedState.identity?.codexThreadIdSource,
+      captured: capturedState.captured,
+      monitorState: capturedState.monitorState,
+      autoRefreshPrompt: null,
+    };
+  }
+
+  const decision = evaluateCodexAutoRefreshUsage(capturedState.usage);
+  if (!decision.shouldRefresh) {
+    return {
+      status: 'ok',
+      reason: 'codex_rollout_captured',
+      codexThreadIdSource: capturedState.identity.codexThreadIdSource,
+      captured: capturedState.captured,
+      monitorState: capturedState.monitorState,
+      autoRefreshPrompt: {
+        status: 'skipped',
+        reason: decision.reason,
+        decision,
+      },
+    };
+  }
+
+  const context = renderAutoRefreshContext({
+    usage: capturedState.usage,
+    decision,
+    threadId: capturedState.identity.codexThreadId,
+    eventName,
+  });
+  return {
+    status: 'ok',
+    reason: 'codex_rollout_captured',
+    codexThreadIdSource: capturedState.identity.codexThreadIdSource,
+    captured: capturedState.captured,
+    monitorState: capturedState.monitorState,
+    autoRefreshPrompt: {
+      status: 'ready',
+      reason: 'threshold_reached',
+      decision,
+      context,
+      output: codexContextOutput(context, eventName),
+    },
+  };
+}
+
 export async function run(argv = []) {
   suppressExperimentalWarnings();
   let parsed;
@@ -215,12 +423,31 @@ export async function run(argv = []) {
   }
 
   try {
-    const result = await runCodexStopHook({
-      args: parsed,
-      payload,
-      env: process.env,
-    });
-    if (parsed.json) process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    let result;
+    if (parsed.event === 'user-prompt-submit') {
+      result = await runCodexUserPromptSubmitHook({
+        args: parsed,
+        payload,
+        env: process.env,
+      });
+    } else if (parsed.event === 'post-tool-use') {
+      result = await runCodexPostToolUseHook({
+        args: parsed,
+        payload,
+        env: process.env,
+      });
+    } else {
+      result = await runCodexStopHook({
+        args: parsed,
+        payload,
+        env: process.env,
+      });
+    }
+    if (parsed.json) {
+      process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    } else if (result.autoRefreshPrompt?.output) {
+      process.stdout.write(result.autoRefreshPrompt.output + '\n');
+    }
     process.exit(result.status === 'ok' || result.status === 'skipped' ? 0 : 1);
   } catch (err) {
     const msg = err instanceof Error ? err.message : 'unknown';
@@ -248,8 +475,10 @@ export async function run(argv = []) {
 
 export const _internal = {
   codexHomeFromTranscriptPath,
+  codexContextOutput,
   parseArgs,
   parsePayload,
+  renderAutoRefreshContext,
   resolveCodexHookThreadIdentity,
 };
 

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

@@ -5,7 +5,12 @@ import { join } from 'node:path';
 import { test } from 'node:test';
 import { DatabaseSync } from 'node:sqlite';
 
-import { runCodexStopHook, _internal } from './codex-hook.mjs';
+import {
+  runCodexPostToolUseHook,
+  runCodexStopHook,
+  runCodexUserPromptSubmitHook,
+  _internal,
+} from './codex-hook.mjs';
 
 function makeDb() {
   const db = new DatabaseSync(':memory:');
@@ -182,6 +187,160 @@ test('codex-hook stop runs auto refresh when verified usage reaches 80%', async
   }
 });
 
+test('codex-hook user-prompt-submit injects current-session throughline instruction at 80%', async () => {
+  const codexHome = mkdtempSync(join(tmpdir(), 'tl-codex-hook-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-hook-project-'));
+  const threadId = '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9';
+  const db = makeDb();
+  let monitorState = null;
+  try {
+    const rolloutPath = writeRollout(codexHome, {
+      id: threadId,
+      cwd: project,
+      events: [
+        event('user_message', { message: 'hook request' }),
+        event('task_started'),
+        turnContext({ model: 'gpt-5.5', cwd: project }),
+        event('agent_message', { message: 'hook answer' }),
+        event('task_complete'),
+        tokenCountEvent({
+          inputTokens: 240_000,
+          outputTokens: 67,
+          contextWindow: 258400,
+        }),
+      ],
+    });
+
+    const result = await runCodexUserPromptSubmitHook({
+      payload: {
+        session_id: threadId,
+        transcript_path: rolloutPath,
+        cwd: project,
+        prompt: 'next user prompt',
+      },
+      env: {},
+      db,
+      ensureMonitorTask: () => {},
+      writeMonitorState: (state) => {
+        monitorState = state;
+      },
+    });
+
+    assert.equal(result.status, 'ok');
+    assert.equal(result.autoRefreshPrompt.status, 'ready');
+    assert.equal(result.autoRefreshPrompt.reason, 'threshold_reached');
+    assert.match(result.autoRefreshPrompt.context, /Before answering the user prompt/);
+    assert.match(result.autoRefreshPrompt.context, /throughline trim --execute --host codex --all --json/);
+    assert.match(result.autoRefreshPrompt.context, /current Codex rollout token_count/);
+    const output = JSON.parse(result.autoRefreshPrompt.output);
+    assert.equal(output.hookSpecificOutput.hookEventName, 'UserPromptSubmit');
+    assert.match(output.hookSpecificOutput.additionalContext, /installed \$throughline workflow/);
+    assert.equal(result.captured.sessionId, `codex:${threadId}`);
+    assert.equal(monitorState.sessionId, `codex:${threadId}`);
+  } finally {
+    db.close();
+    rmSync(codexHome, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('codex-hook user-prompt-submit stays quiet below 80%', async () => {
+  const codexHome = mkdtempSync(join(tmpdir(), 'tl-codex-hook-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-hook-project-'));
+  const threadId = '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9';
+  const db = makeDb();
+  try {
+    const rolloutPath = writeRollout(codexHome, {
+      id: threadId,
+      cwd: project,
+      events: [
+        event('user_message', { message: 'hook request' }),
+        event('task_started'),
+        event('agent_message', { message: 'hook answer' }),
+        event('task_complete'),
+        tokenCountEvent({
+          inputTokens: 12345,
+          outputTokens: 67,
+          contextWindow: 258400,
+        }),
+      ],
+    });
+
+    const result = await runCodexUserPromptSubmitHook({
+      payload: {
+        session_id: threadId,
+        transcript_path: rolloutPath,
+        cwd: project,
+        prompt: 'next user prompt',
+      },
+      env: {},
+      db,
+      ensureMonitorTask: () => {},
+      writeMonitorState: () => {},
+    });
+
+    assert.equal(result.status, 'ok');
+    assert.equal(result.autoRefreshPrompt.status, 'skipped');
+    assert.equal(result.autoRefreshPrompt.reason, 'below_threshold');
+    assert.equal(result.autoRefreshPrompt.output, undefined);
+  } finally {
+    db.close();
+    rmSync(codexHome, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('codex-hook post-tool-use injects current-session throughline instruction at 80%', async () => {
+  const codexHome = mkdtempSync(join(tmpdir(), 'tl-codex-hook-home-'));
+  const project = mkdtempSync(join(tmpdir(), 'tl-codex-hook-project-'));
+  const threadId = '019dfaba-f87e-7f41-a144-d5ca7c6dd7f9';
+  const db = makeDb();
+  try {
+    const rolloutPath = writeRollout(codexHome, {
+      id: threadId,
+      cwd: project,
+      events: [
+        event('user_message', { message: 'hook request' }),
+        event('task_started'),
+        turnContext({ model: 'gpt-5.5', cwd: project }),
+        event('agent_message', { message: 'hook answer' }),
+        tokenCountEvent({
+          inputTokens: 240_000,
+          outputTokens: 67,
+          contextWindow: 258400,
+        }),
+      ],
+    });
+
+    const result = await runCodexPostToolUseHook({
+      payload: {
+        session_id: threadId,
+        transcript_path: rolloutPath,
+        cwd: project,
+        hook_event_name: 'PostToolUse',
+        tool_name: 'exec_command',
+      },
+      env: {},
+      db,
+      ensureMonitorTask: () => {},
+      writeMonitorState: () => {},
+    });
+
+    assert.equal(result.status, 'ok');
+    assert.equal(result.autoRefreshPrompt.status, 'ready');
+    assert.equal(result.autoRefreshPrompt.reason, 'threshold_reached');
+    assert.match(result.autoRefreshPrompt.context, /Before continuing the current tool loop/);
+    assert.match(result.autoRefreshPrompt.context, /throughline trim --execute --host codex --all --json/);
+    const output = JSON.parse(result.autoRefreshPrompt.output);
+    assert.equal(output.hookSpecificOutput.hookEventName, 'PostToolUse');
+    assert.match(output.hookSpecificOutput.additionalContext, /installed \$throughline workflow/);
+  } finally {
+    db.close();
+    rmSync(codexHome, { recursive: true, force: true });
+    rmSync(project, { recursive: true, force: true });
+  }
+});
+
 test('codex-hook stop reports camelCase payload thread id source', async () => {
   const codexHome = mkdtempSync(join(tmpdir(), 'tl-codex-hook-home-'));
   const project = mkdtempSync(join(tmpdir(), 'tl-codex-hook-project-'));
@@ -241,6 +400,14 @@ test('codexHomeFromTranscriptPath infers CODEX_HOME from rollout path', () => {
   assert.equal(_internal.codexHomeFromTranscriptPath(path), '/tmp/codex-home');
 });
 
+test('parseArgs: accepts user-prompt-submit Codex hook event', () => {
+  assert.equal(_internal.parseArgs(['user-prompt-submit']).event, 'user-prompt-submit');
+});
+
+test('parseArgs: accepts post-tool-use Codex hook event', () => {
+  assert.equal(_internal.parseArgs(['post-tool-use']).event, 'post-tool-use');
+});
+
 function writeRollout(home, { id, cwd, events }) {
   const dir = join(home, 'sessions', '2026', '05', '06');
   mkdirSync(dir, { recursive: true });

package/src/cli/doctor.mjs

@@ -28,7 +28,14 @@ import { resolveCodexThreadIdentity } from '../codex-thread-identity.mjs';
 import { defaultCodexHome, listCodexThreadCandidates } from '../codex-thread-index.mjs';
 import { getDb } from '../db.mjs';
 import { detectJsoncFeatures, findMonitorTaskIndex, isMonitorTaskBroken } from '../vscode-task.mjs';
-import { buildCodexStopHookCommand, isThroughlineCodexStopCommand } from './install.mjs';
+import {
+  buildCodexPostToolUseHookCommand,
+  buildCodexStopHookCommand,
+  buildCodexUserPromptSubmitHookCommand,
+  isThroughlineCodexHookCommand,
+  isThroughlineCodexPostToolUseCommand,
+  isThroughlineCodexStopCommand,
+} from './install.mjs';
 
 const GREEN = '\x1b[32m✓\x1b[0m';
 const RED = '\x1b[31m✗\x1b[0m';
@@ -393,20 +400,33 @@ function countCapturedCodexSessions(db, projectPath) {
 function readCodexHookDiagnosis(codexHome) {
   const hooksPath = join(codexHome, 'hooks.json');
   const configPath = join(codexHome, 'config.toml');
-  const expectedCommand = buildCodexStopHookCommand();
+  const expectedStopCommand = buildCodexStopHookCommand();
+  const expectedPromptCommand = buildCodexUserPromptSubmitHookCommand();
+  const expectedPostToolUseCommand = buildCodexPostToolUseHookCommand();
   const out = {
     hooksPath,
     configPath,
-    expectedCommand,
+    expectedStopCommand,
+    expectedPromptCommand,
+    expectedPostToolUseCommand,
     hooksReadable: false,
     featureEnabled: false,
+    codexHooksFeatureEnabled: false,
+    hooksFeatureEnabled: false,
+    managedPromptHooks: [],
+    legacyManagedPromptHooks: [],
+    managedPostToolUseHooks: [],
+    legacyManagedPostToolUseHooks: [],
     managedStopHooks: [],
     legacyManagedStopHooks: [],
   };
 
   if (existsSync(configPath)) {
     try {
-      out.featureEnabled = /^\s*codex_hooks\s*=\s*true\s*$/m.test(readFileSync(configPath, 'utf8'));
+      const config = readFileSync(configPath, 'utf8');
+      out.codexHooksFeatureEnabled = /^\s*codex_hooks\s*=\s*true\s*$/m.test(config);
+      out.hooksFeatureEnabled = /^\s*hooks\s*=\s*true\s*$/m.test(config);
+      out.featureEnabled = out.codexHooksFeatureEnabled || out.hooksFeatureEnabled;
     } catch {
       out.featureEnabled = false;
     }
@@ -421,9 +441,17 @@ function readCodexHookDiagnosis(codexHome) {
   }
 
   out.hooksReadable = true;
+  const promptHooks = (parsed.hooks?.UserPromptSubmit ?? []).flatMap(group => group.hooks ?? []);
+  const postToolUseHooks = (parsed.hooks?.PostToolUse ?? []).flatMap(group => group.hooks ?? []);
   const stopHooks = (parsed.hooks?.Stop ?? []).flatMap(group => group.hooks ?? []);
+  out.managedPromptHooks = promptHooks.filter(h => isThroughlineCodexHookCommand(h.command));
+  out.legacyManagedPromptHooks = out.managedPromptHooks.filter(h => h.command !== expectedPromptCommand);
+  out.managedPostToolUseHooks = postToolUseHooks.filter(h => isThroughlineCodexPostToolUseCommand(h.command));
+  out.legacyManagedPostToolUseHooks = out.managedPostToolUseHooks.filter(
+    h => h.command !== expectedPostToolUseCommand,
+  );
   out.managedStopHooks = stopHooks.filter(h => isThroughlineCodexStopCommand(h.command));
-  out.legacyManagedStopHooks = out.managedStopHooks.filter(h => h.command !== expectedCommand);
+  out.legacyManagedStopHooks = out.managedStopHooks.filter(h => h.command !== expectedStopCommand);
   return out;
 }
 
@@ -456,6 +484,32 @@ function runCodexDiagnosis({
   console.log(`  project:               ${cwd}`);
   console.log(`  CODEX_HOME:            ${codexHome}`);
   console.log(`  Codex hooks feature:   ${hookDiagnosis.featureEnabled ? 'enabled' : 'not enabled'}`);
+  console.log(`  Codex UserPrompt hook: ${
+    hookDiagnosis.managedPromptHooks.length === 0
+      ? 'not registered'
+      : hookDiagnosis.legacyManagedPromptHooks.length > 0
+        ? 'legacy command needs reinstall'
+        : 'registered'
+  }`);
+  if (hookDiagnosis.managedPromptHooks.length > 0) {
+    const h = hookDiagnosis.managedPromptHooks[0];
+    console.log(`    command:             ${h.command}`);
+    console.log(`    async:               ${h.async === false ? 'false' : String(h.async)}`);
+    console.log(`    timeoutSec:          ${h.timeoutSec ?? '(default)'}`);
+  }
+  console.log(`  Codex PostTool hook:   ${
+    hookDiagnosis.managedPostToolUseHooks.length === 0
+      ? 'not registered'
+      : hookDiagnosis.legacyManagedPostToolUseHooks.length > 0
+        ? 'legacy command needs reinstall'
+        : 'registered'
+  }`);
+  if (hookDiagnosis.managedPostToolUseHooks.length > 0) {
+    const h = hookDiagnosis.managedPostToolUseHooks[0];
+    console.log(`    command:             ${h.command}`);
+    console.log(`    async:               ${h.async === false ? 'false' : String(h.async)}`);
+    console.log(`    timeoutSec:          ${h.timeoutSec ?? '(default)'}`);
+  }
   console.log(`  Codex Stop hook:       ${
     hookDiagnosis.managedStopHooks.length === 0
       ? 'not registered'

package/src/cli/doctor.test.mjs

@@ -155,6 +155,8 @@ test('runCodexDiagnosis: reports env thread and captured DB session', () => {
 
     assert.match(output, /\[Codex primary\]/);
     assert.match(output, /Codex hooks feature:\s+not enabled/);
+    assert.match(output, /Codex UserPrompt hook:\s+not registered/);
+    assert.match(output, /Codex PostTool hook:\s+not registered/);
     assert.match(output, /Codex Stop hook:\s+not registered/);
     assert.match(output, /VSCode monitor task:\s+not registered/);
     assert.match(output, /created by the next VSCode hook event/);
@@ -328,7 +330,7 @@ test('buildCodexContextRefreshDiagnosis keeps ready label when restore safety is
   }
 });
 
-test('readCodexHookDiagnosis detects legacy bare Throughline Codex Stop hook', () => {
+test('readCodexHookDiagnosis detects Codex prompt and Stop hooks', () => {
   const codexHome = mkdtempSync(join(tmpdir(), 'tl-doctor-codex-home-'));
   try {
     mkdirSync(join(codexHome), { recursive: true });
@@ -337,6 +339,30 @@ test('readCodexHookDiagnosis detects legacy bare Throughline Codex Stop hook', (
       JSON.stringify(
         {
           hooks: {
+            UserPromptSubmit: [
+              {
+                hooks: [
+                  {
+                    type: 'command',
+                    command: '/usr/bin/node /pkg/bin/throughline.mjs codex-hook user-prompt-submit',
+                    timeoutSec: 30,
+                    async: false,
+                  },
+                ],
+              },
+            ],
+            PostToolUse: [
+              {
+                hooks: [
+                  {
+                    type: 'command',
+                    command: '/usr/bin/node /pkg/bin/throughline.mjs codex-hook post-tool-use',
+                    timeoutSec: 30,
+                    async: false,
+                  },
+                ],
+              },
+            ],
             Stop: [
               {
                 hooks: [
@@ -355,10 +381,16 @@ test('readCodexHookDiagnosis detects legacy bare Throughline Codex Stop hook', (
         2,
       ) + '\n',
     );
-    writeFileSync(join(codexHome, 'config.toml'), '[features]\ncodex_hooks = true\n');
+    writeFileSync(join(codexHome, 'config.toml'), '[features]\ncodex_hooks = true\nhooks = true\n');
 
     const diagnosis = readCodexHookDiagnosis(codexHome);
     assert.equal(diagnosis.featureEnabled, true);
+    assert.equal(diagnosis.codexHooksFeatureEnabled, true);
+    assert.equal(diagnosis.hooksFeatureEnabled, true);
+    assert.equal(diagnosis.managedPromptHooks.length, 1);
+    assert.equal(diagnosis.legacyManagedPromptHooks.length, 1);
+    assert.equal(diagnosis.managedPostToolUseHooks.length, 1);
+    assert.equal(diagnosis.legacyManagedPostToolUseHooks.length, 1);
     assert.equal(diagnosis.managedStopHooks.length, 1);
     assert.equal(diagnosis.legacyManagedStopHooks.length, 1);
   } finally {

package/src/cli/help.test.mjs

@@ -9,6 +9,8 @@ const REPO_ROOT = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
 const BIN_PATH = join(REPO_ROOT, 'bin/throughline.mjs');
 const CODEX_HELP_COMMANDS = [
   'throughline codex-capture',
+  'throughline codex-hook user-prompt-submit',
+  'throughline codex-hook post-tool-use',
   'throughline codex-hook stop',
   'throughline codex-summarize',
   'throughline codex-resume',

package/src/cli/install.mjs

@@ -54,6 +54,8 @@ const SC_HOOKS = {
 
 const CODEX_COMMANDS = [
   'throughline codex-hook stop',
+  'throughline codex-hook user-prompt-submit',
+  'throughline codex-hook post-tool-use',
 ];
 
 function quoteCommandPath(p) {
@@ -67,6 +69,36 @@ export function buildCodexStopHookCommand({
   return `${quoteCommandPath(nodePath)} ${quoteCommandPath(cliScriptPath)} codex-hook stop`;
 }
 
+export function buildCodexUserPromptSubmitHookCommand({
+  nodePath = process.execPath,
+  cliScriptPath = join(PACKAGE_ROOT, 'bin', 'throughline.mjs'),
+} = {}) {
+  return `${quoteCommandPath(nodePath)} ${quoteCommandPath(cliScriptPath)} codex-hook user-prompt-submit`;
+}
+
+export function buildCodexPostToolUseHookCommand({
+  nodePath = process.execPath,
+  cliScriptPath = join(PACKAGE_ROOT, 'bin', 'throughline.mjs'),
+} = {}) {
+  return `${quoteCommandPath(nodePath)} ${quoteCommandPath(cliScriptPath)} codex-hook post-tool-use`;
+}
+
+export function isThroughlineCodexHookCommand(command) {
+  if (typeof command !== 'string') return false;
+  const normalized = command.replace(/["']/g, '');
+  return (
+    normalized === 'throughline codex-hook stop' ||
+    normalized === 'throughline codex-hook user-prompt-submit' ||
+    normalized === 'throughline codex-hook post-tool-use' ||
+    normalized.includes('throughline codex-hook stop') ||
+    normalized.includes('throughline codex-hook user-prompt-submit') ||
+    normalized.includes('throughline codex-hook post-tool-use') ||
+    normalized.includes('throughline.mjs codex-hook stop') ||
+    normalized.includes('throughline.mjs codex-hook user-prompt-submit') ||
+    normalized.includes('throughline.mjs codex-hook post-tool-use')
+  );
+}
+
 export function isThroughlineCodexStopCommand(command) {
   if (typeof command !== 'string') return false;
   const normalized = command.replace(/["']/g, '');
@@ -77,8 +109,40 @@ export function isThroughlineCodexStopCommand(command) {
   );
 }
 
+export function isThroughlineCodexPostToolUseCommand(command) {
+  if (typeof command !== 'string') return false;
+  const normalized = command.replace(/["']/g, '');
+  return (
+    normalized === 'throughline codex-hook post-tool-use' ||
+    normalized.includes('throughline codex-hook post-tool-use') ||
+    normalized.includes('throughline.mjs codex-hook post-tool-use')
+  );
+}
+
 function createCodexHooks() {
   return {
+    UserPromptSubmit: {
+      hooks: [
+        {
+          type: 'command',
+          command: buildCodexUserPromptSubmitHookCommand(),
+          timeoutSec: 30,
+          async: false,
+          statusMessage: null,
+        },
+      ],
+    },
+    PostToolUse: {
+      hooks: [
+        {
+          type: 'command',
+          command: buildCodexPostToolUseHookCommand(),
+          timeoutSec: 30,
+          async: false,
+          statusMessage: null,
+        },
+      ],
+    },
     Stop: {
       hooks: [
         {
@@ -253,11 +317,19 @@ function ensureCodexHooksFeature(configPath) {
   const existing = existsSync(configPath) ? readFileSync(configPath, 'utf8') : '';
   const lines = existing.split(/\r?\n/);
   const sectionStart = lines.findIndex((line) => line.trim() === '[features]');
+  const ensureFeatureLine = (featureLines, name) => {
+    const idx = featureLines.findIndex((line) => new RegExp(`^\\s*${name}\\s*=`).test(line));
+    if (idx === -1) {
+      featureLines.push(`${name} = true`);
+    } else {
+      featureLines[idx] = `${name} = true`;
+    }
+  };
   let updated;
 
   if (sectionStart === -1) {
     const prefix = existing.trimEnd();
-    updated = `${prefix}${prefix ? '\n\n' : ''}[features]\ncodex_hooks = true\n`;
+    updated = `${prefix}${prefix ? '\n\n' : ''}[features]\ncodex_hooks = true\nhooks = true\n`;
   } else {
     let sectionEnd = lines.length;
     for (let i = sectionStart + 1; i < lines.length; i++) {
@@ -267,14 +339,10 @@ function ensureCodexHooksFeature(configPath) {
       }
     }
 
-    const codexHooksLine = lines
-      .slice(sectionStart + 1, sectionEnd)
-      .findIndex((line) => /^\s*codex_hooks\s*=/.test(line));
-    if (codexHooksLine === -1) {
-      lines.splice(sectionStart + 1, 0, 'codex_hooks = true');
-    } else {
-      lines[sectionStart + 1 + codexHooksLine] = 'codex_hooks = true';
-    }
+    const featureLines = lines.slice(sectionStart + 1, sectionEnd);
+    ensureFeatureLine(featureLines, 'codex_hooks');
+    ensureFeatureLine(featureLines, 'hooks');
+    lines.splice(sectionStart + 1, sectionEnd - sectionStart - 1, ...featureLines);
     updated = lines.join('\n').replace(/\n*$/, '\n');
   }
 
@@ -294,7 +362,7 @@ function installCodexHooks() {
     const list = existingHooks[key] ?? [];
     const preserved = [];
     for (const group of list) {
-      const hooks = (group.hooks ?? []).filter(h => !isThroughlineCodexStopCommand(h.command));
+      const hooks = (group.hooks ?? []).filter(h => !isThroughlineCodexHookCommand(h.command));
       if (hooks.length > 0) preserved.push({ ...group, hooks });
     }
     existingHooks[key] = [entry, ...preserved];
@@ -323,7 +391,7 @@ function uninstallCodexHooks() {
         const hooks = (group.hooks ?? []).filter((hook) => {
           const shouldRemove =
             CODEX_COMMANDS.includes(hook.command) ||
-            isThroughlineCodexStopCommand(hook.command);
+            isThroughlineCodexHookCommand(hook.command);
           if (shouldRemove) removed++;
           return !shouldRemove;
         });
@@ -422,7 +490,9 @@ export async function run(args = []) {
   console.log('  Stop             → throughline process-turn   (L1 要約 + L2 本文保存 + L3 詳細保存)');
   console.log('  UserPromptSubmit → throughline prompt-submit  (/tl & /clear バトン書き込み)');
   if (codex) {
-    console.log(`  Codex Stop       → ${buildCodexStopHookCommand()} (Codex rollout capture + L1 要約)`);
+    console.log(`  Codex UserPromptSubmit → ${buildCodexUserPromptSubmitHookCommand()} (80% 到達時に current session へ $throughline 指示を注入)`);
+    console.log(`  Codex PostToolUse      → ${buildCodexPostToolUseHookCommand()} (tool loop 中も 80% 到達時に $throughline 指示を注入)`);
+    console.log(`  Codex Stop             → ${buildCodexStopHookCommand()} (Codex rollout capture + L1 要約)`);
   }
   console.log('');
   if (installedCommands.length > 0) {

package/src/cli/install.test.mjs

@@ -4,7 +4,13 @@ import { mkdtempSync, rmSync, existsSync, readFileSync, writeFileSync, mkdirSync
 import { tmpdir, homedir } from 'node:os';
 import { join } from 'node:path';
 
-import { buildCodexStopHookCommand, run, resolveThroughlineOnPath } from './install.mjs';
+import {
+  buildCodexPostToolUseHookCommand,
+  buildCodexStopHookCommand,
+  buildCodexUserPromptSubmitHookCommand,
+  run,
+  resolveThroughlineOnPath,
+} from './install.mjs';
 
 function makeTempHome() {
   const dir = mkdtempSync(join(tmpdir(), 'tl-install-test-'));
@@ -94,7 +100,7 @@ test('project install copies commands to cwd/.claude/commands/', async () => {
   }
 });
 
-test('global install registers Codex Stop hook and enables codex_hooks feature', async () => {
+test('global install registers Codex session hooks and enables hooks features', async () => {
   const home = makeTempHome();
   if (home.resolved !== home.dir) {
     home.restore();
@@ -104,15 +110,30 @@ test('global install registers Codex Stop hook and enables codex_hooks feature',
   try {
     await run([]);
     const hooks = JSON.parse(readFileSync(join(home.dir, '.codex', 'hooks.json'), 'utf8'));
-    const expectedCommand = buildCodexStopHookCommand();
+    const expectedStopCommand = buildCodexStopHookCommand();
+    const expectedPromptCommand = buildCodexUserPromptSubmitHookCommand();
+    const expectedPostToolUseCommand = buildCodexPostToolUseHookCommand();
     const codexHook = hooks.hooks.Stop
       .flatMap(g => g.hooks ?? [])
-      .find(h => h.command === expectedCommand);
+      .find(h => h.command === expectedStopCommand);
     assert.ok(codexHook, 'Codex Stop should have absolute throughline.mjs codex-hook stop');
     assert.equal(codexHook.async, false, 'Codex Stop hook should be synchronous for Codex');
     assert.equal(codexHook.timeoutSec, 300, 'Codex Stop hook should allow summarizer time');
+    const promptHook = hooks.hooks.UserPromptSubmit
+      .flatMap(g => g.hooks ?? [])
+      .find(h => h.command === expectedPromptCommand);
+    assert.ok(promptHook, 'Codex UserPromptSubmit should have absolute throughline.mjs codex-hook user-prompt-submit');
+    assert.equal(promptHook.async, false, 'Codex UserPromptSubmit hook should be synchronous for context injection');
+    assert.equal(promptHook.timeoutSec, 30, 'Codex UserPromptSubmit hook should be short');
+    const postToolUseHook = hooks.hooks.PostToolUse
+      .flatMap(g => g.hooks ?? [])
+      .find(h => h.command === expectedPostToolUseCommand);
+    assert.ok(postToolUseHook, 'Codex PostToolUse should have absolute throughline.mjs codex-hook post-tool-use');
+    assert.equal(postToolUseHook.async, false, 'Codex PostToolUse hook should be synchronous for context injection');
+    assert.equal(postToolUseHook.timeoutSec, 30, 'Codex PostToolUse hook should be short');
     const config = readFileSync(join(home.dir, '.codex', 'config.toml'), 'utf8');
     assert.match(config, /^\[features\]\ncodex_hooks = true/m);
+    assert.match(config, /^hooks = true/m);
   } finally {
     unsilence();
     home.restore();
@@ -215,21 +236,30 @@ test('global install preserves existing Codex hooks and is idempotent', async ()
     await run([]);
     await run([]);
     const hooks = JSON.parse(readFileSync(join(home.dir, '.codex', 'hooks.json'), 'utf8'));
-    const commands = hooks.hooks.Stop.flatMap(g => g.hooks ?? []).map(h => h.command);
-    const expectedCommand = buildCodexStopHookCommand();
-    assert.ok(commands.includes('/usr/bin/node /home/kite/.npm-global/bin/caveat codex-hook stop'));
-    assert.equal(commands.filter(c => c === expectedCommand).length, 1);
-    assert.ok(!commands.includes('throughline codex-hook stop'));
+    const stopCommands = hooks.hooks.Stop.flatMap(g => g.hooks ?? []).map(h => h.command);
+    const promptCommands = hooks.hooks.UserPromptSubmit.flatMap(g => g.hooks ?? []).map(h => h.command);
+    const postToolUseCommands = hooks.hooks.PostToolUse.flatMap(g => g.hooks ?? []).map(h => h.command);
+    const expectedStopCommand = buildCodexStopHookCommand();
+    const expectedPromptCommand = buildCodexUserPromptSubmitHookCommand();
+    const expectedPostToolUseCommand = buildCodexPostToolUseHookCommand();
+    assert.ok(stopCommands.includes('/usr/bin/node /home/kite/.npm-global/bin/caveat codex-hook stop'));
+    assert.equal(stopCommands.filter(c => c === expectedStopCommand).length, 1);
+    assert.equal(promptCommands.filter(c => c === expectedPromptCommand).length, 1);
+    assert.equal(postToolUseCommands.filter(c => c === expectedPostToolUseCommand).length, 1);
+    assert.ok(!stopCommands.includes('throughline codex-hook stop'));
+    assert.ok(!promptCommands.includes('throughline codex-hook user-prompt-submit'));
+    assert.ok(!postToolUseCommands.includes('throughline codex-hook post-tool-use'));
     const config = readFileSync(join(home.dir, '.codex', 'config.toml'), 'utf8');
     assert.match(config, /other = true/);
     assert.match(config, /codex_hooks = true/);
+    assert.match(config, /hooks = true/);
   } finally {
     unsilence();
     home.restore();
   }
 });
 
-test('global install updates existing Throughline Codex Stop hook shape', async () => {
+test('global install updates existing Throughline Codex hook shapes', async () => {
   const home = makeTempHome();
   if (home.resolved !== home.dir) {
     home.restore();
@@ -241,6 +271,32 @@ test('global install updates existing Throughline Codex Stop hook shape', async
     JSON.stringify(
       {
         hooks: {
+          UserPromptSubmit: [
+            {
+              hooks: [
+                {
+                  type: 'command',
+                  command: 'throughline codex-hook user-prompt-submit',
+                  timeoutSec: 300,
+                  async: true,
+                  statusMessage: null,
+                },
+              ],
+            },
+          ],
+          PostToolUse: [
+            {
+              hooks: [
+                {
+                  type: 'command',
+                  command: 'throughline codex-hook post-tool-use',
+                  timeoutSec: 300,
+                  async: true,
+                  statusMessage: null,
+                },
+              ],
+            },
+          ],
           Stop: [
             {
               hooks: [
@@ -264,17 +320,39 @@ test('global install updates existing Throughline Codex Stop hook shape', async
   try {
     await run([]);
     const hooks = JSON.parse(readFileSync(join(home.dir, '.codex', 'hooks.json'), 'utf8'));
-    const expectedCommand = buildCodexStopHookCommand();
+    const expectedStopCommand = buildCodexStopHookCommand();
+    const expectedPromptCommand = buildCodexUserPromptSubmitHookCommand();
+    const expectedPostToolUseCommand = buildCodexPostToolUseHookCommand();
     const codexHooks = hooks.hooks.Stop
       .flatMap(g => g.hooks ?? [])
-      .filter(h => h.command === expectedCommand);
+      .filter(h => h.command === expectedStopCommand);
     assert.equal(codexHooks.length, 1);
     assert.equal(codexHooks[0].async, false);
     assert.equal(codexHooks[0].timeoutSec, 300);
+    const promptHooks = hooks.hooks.UserPromptSubmit
+      .flatMap(g => g.hooks ?? [])
+      .filter(h => h.command === expectedPromptCommand);
+    assert.equal(promptHooks.length, 1);
+    assert.equal(promptHooks[0].async, false);
+    assert.equal(promptHooks[0].timeoutSec, 30);
+    const postToolUseHooks = hooks.hooks.PostToolUse
+      .flatMap(g => g.hooks ?? [])
+      .filter(h => h.command === expectedPostToolUseCommand);
+    assert.equal(postToolUseHooks.length, 1);
+    assert.equal(postToolUseHooks[0].async, false);
+    assert.equal(postToolUseHooks[0].timeoutSec, 30);
     assert.equal(
       hooks.hooks.Stop.flatMap(g => g.hooks ?? []).filter(h => h.command === 'throughline codex-hook stop').length,
       0,
     );
+    assert.equal(
+      hooks.hooks.UserPromptSubmit.flatMap(g => g.hooks ?? []).filter(h => h.command === 'throughline codex-hook user-prompt-submit').length,
+      0,
+    );
+    assert.equal(
+      hooks.hooks.PostToolUse.flatMap(g => g.hooks ?? []).filter(h => h.command === 'throughline codex-hook post-tool-use').length,
+      0,
+    );
   } finally {
     unsilence();
     home.restore();
@@ -330,10 +408,16 @@ test('global uninstall removes only Throughline-managed Codex hook', async () =>
 
     await run(['--uninstall']);
     const after = JSON.parse(readFileSync(hooksPath, 'utf8'));
-    const commands = after.hooks.Stop.flatMap(g => g.hooks ?? []).map(h => h.command);
-    assert.ok(commands.includes('/usr/bin/node /home/kite/.npm-global/bin/caveat codex-hook stop'));
-    assert.ok(!commands.includes('throughline codex-hook stop'));
-    assert.ok(!commands.some(c => c.includes('throughline.mjs codex-hook stop')));
+    const stopCommands = after.hooks.Stop.flatMap(g => g.hooks ?? []).map(h => h.command);
+    const promptCommands = after.hooks.UserPromptSubmit?.flatMap(g => g.hooks ?? []).map(h => h.command) ?? [];
+    const postToolUseCommands = after.hooks.PostToolUse?.flatMap(g => g.hooks ?? []).map(h => h.command) ?? [];
+    assert.ok(stopCommands.includes('/usr/bin/node /home/kite/.npm-global/bin/caveat codex-hook stop'));
+    assert.ok(!stopCommands.includes('throughline codex-hook stop'));
+    assert.ok(!stopCommands.some(c => c.includes('throughline.mjs codex-hook stop')));
+    assert.ok(!promptCommands.includes('throughline codex-hook user-prompt-submit'));
+    assert.ok(!promptCommands.some(c => c.includes('throughline.mjs codex-hook user-prompt-submit')));
+    assert.ok(!postToolUseCommands.includes('throughline codex-hook post-tool-use'));
+    assert.ok(!postToolUseCommands.some(c => c.includes('throughline.mjs codex-hook post-tool-use')));
   } finally {
     unsilence();
     home.restore();