aiterm-mcp 0.39.1 → 0.40.1

package/CHANGELOG.md

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.40.1] - 2026-09-27
+
+### 修正
+
+- Cursorの送信前hookがpromptを拒否した時に、`pty_send`が成功receiptを返していた。Cursorはpromptを捨てて入力欄を空に戻すため、入力欄の残留検査では見分けられず、親は来ない完了を待ち続けた。起動時promptは理由の無い`submitted_unconfirmed`になっていた。拒否の表示（`Hook blocked with message:`）を見分け、起動時promptは`initial_prompt=failed`、`pty_send`はエラーとし、どちらも`USER_HOOK_BLOCKED`とhookの出力を返す。確認時間より後の拒否は、完了待ちが`outcome=error`で返す。`pty_observe`は`blocked`／`user_hook_blocked`を返す。
+- Cursorの送信前hookが3秒の確認時間より長く動くと、拒否されても起動時promptは理由の無い`submitted_unconfirmed`で返っていた。Windowsではhookごとの起動が遅く、数本続くと3秒を超える。hookの実行中の画面（「Working」だけで`ctrl+c to stop`が無い）が続く間は、最長60秒まで結果を待つ。
+
+## [0.40.0] - 2026-09-27
+
+### 変更（互換性なし）
+
+- `agent_steer`を廃止し、agent sessionへの送信を`pty_send`に一本化する。子のturnが実行中かどうかは呼び出し側に選ばせず、Aitermが送る時点の画面で見て、実行中なら現在のturnへ差し込み（`mode=agent_steer`）、それ以外は新しいturnとしてdispatchする（`mode=agent_dispatch`）。これまでは状態を知らない呼び出し側が入口を選ぶ必要があり、idleの子への`agent_steer`は何も送らず`idle`を返し、実行中の子への`pty_send`はCodex／Grok／Cursorで入力受付を30秒待って失敗、Claude Codeでは来ない完了を待つ新しいturnとして記録していた。差し込みでは新しい`event_cursor`と回答配送を作らず、完了は元の依頼へ1回だけ届く。公開toolは17になる。
+- Claude Codeは、Aitermが送ったturnの印（Stop hookで消える）が残っている時だけ実行中と数える。Stop hookの実行中は画面が実行中の表示のままなので、回答直後に送った文を差し込みと取り違え、誰も完了を待たない新しいturnにしていた。
+
 ## [0.39.1] - 2026-09-26
 
 ### 修正
@@ -1778,7 +1792,9 @@ prototype (preserved under `prototype/python/` as the porting source and referen
   `ubuntu-latest` for Node 18/20/22, publishing to npm on `v*` tags with
   provenance.
 
-[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.39.1...HEAD
+[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.40.1...HEAD
+[0.40.1]: https://github.com/kitepon/aiterm-mcp/compare/v0.40.0...v0.40.1
+[0.40.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.39.1...v0.40.0
 [0.39.1]: https://github.com/kitepon/aiterm-mcp/compare/v0.39.0...v0.39.1
 [0.39.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.38.2...v0.39.0
 [0.38.2]: https://github.com/kitepon/aiterm-mcp/compare/v0.38.1...v0.38.2

package/README.ja.md

@@ -143,7 +143,7 @@ diagnostics、recovery、update、releaseを所有します。このREADMEと[
 
 **言葉でなく実測で:** 記録済み203テストのベンチマークでは、`pty_read` はコンテキストに載るトークンを生ログの **約 7.1 分の 1** に減らす。しかも pass/fail の判定は畳んでも残る。→ [組み込みシェルツールとの使い分け](#組み込みシェルツールとの使い分け)
 
-18ツール: 7つのPTYツール、正規のagent起動入口`agent_launch`、実行中のClaude／Codex／Grok／Cursorを誘導する`agent_steer`、移行用の旧4alias、`agent_configure`、`agent_approval`、`claude_turn`、`claude_approval`、`diagnostics`。backendはPOSIXのtmux／Windows nativeのpsmuxなので、MCPサーバやAIクライアントが再起動してもsessionは生き残る。
+17ツール: 7つのPTYツール、正規のagent起動入口`agent_launch`、移行用の旧4alias、`agent_configure`、`agent_approval`、`claude_turn`、`claude_approval`、`diagnostics`。backendはPOSIXのtmux／Windows nativeのpsmuxなので、MCPサーバやAIクライアントが再起動してもsessionは生き残る。
 
 **v0.28.0では実行基盤harnessとmodelを分離した。** harnessはagent loop・認証・hook・session・transcriptを所有し、modelはその上で選ぶ。Cursor Agent CLIでGPT／Claude／Grokを選んでも完了契約はCursor方式のまま。Composerは別harnessではなく、`harness:"grok-cli", model:"grok-composer-2.5-fast"`で表す。旧4起動ツールは同じ実装へ流れる互換alias。
 
@@ -202,7 +202,7 @@ runtime-error store は canonical dotagents config の `collection.enabled: true
 場合だけ収集し、既定OFF、network送信は行いません。tag起点CIのnpm provenance（OIDC Trusted
 Publishing）で公開し、GitHub Release が Official MCP Registry を再登録します。
 
-**状態:** 開発継続中 · 現行公開版 **v0.39.1** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
+**状態:** 開発継続中 · 現行公開版 **v0.40.1** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
 
 ### 更新と巻き戻し
 
@@ -248,9 +248,9 @@ pty_read(id, { wait: true })       → 削減済みの出力を読む（完了
 
 同じprimitiveが別エージェントのTUIを宿す。`agent_launch`の`harness`はagent loop・認証・hook・session・transcriptを所有する実行基盤、`model`は独立した選択。起動processは直接CLIと同じproject/user環境を使い、通常config、MCP、plugin、skill、permission、trust、memory、historyをcopy・filter・置換しない。
 
-`aiterm.agent-launch-result.v1`は正規`harness`を返し、旧`provider`は互換fieldとして残す。同じ`harness`はagent dispatch、`aiterm-wait`、`agent_configure`、`pty_list`のagent行にも載り、旧vendor／provider／agent fieldは互換用に残る。Codexは通常rollout、Grok CLIは通常session event、Claudeはlaunch固有Stop hook、Cursorは通常agent transcript末尾の`turn_ended`を完了正本に使う。`pty_send`は非ブロックdispatchで、vendor別完了境界を表すopaqueな整数`event_cursor`を返す。Codex親は選択に応じて公式Steerまたは受信キュー、Claude Code親は公式非同期hookで回答本文を自動受信する。それ以外の親は`aiterm-wait`を親のターンを塞がない別processで受ける。Cursorのsubmitキーはadapterが現行CLIのextended keyboard protocolへ変換する。送信textがCursorのcomposerへ残った場合は成功receiptを返さず失敗する。
+`aiterm.agent-launch-result.v1`は正規`harness`を返し、旧`provider`は互換fieldとして残す。同じ`harness`はagent dispatch、`aiterm-wait`、`agent_configure`、`pty_list`のagent行にも載り、旧vendor／provider／agent fieldは互換用に残る。Codexは通常rollout、Grok CLIは通常session event、Claudeはlaunch固有Stop hook、Cursorは通常agent transcript末尾の`turn_ended`を完了正本に使う。agent sessionへの送信は`pty_send`だけで行い、子の状態はAitermが送る時点の画面で見て振り分ける。子のturnが実行中なら各harness標準の操作で現在のturnへ差し込み（`mode=agent_steer`）、完了は差し込み後の作業の終わりに元の依頼へ1回だけ届く。新しい`event_cursor`と配送は作らない。それ以外は非ブロックdispatch（`mode=agent_dispatch`）で、vendor別完了境界を表すopaqueな整数`event_cursor`を返す。Codex親は選択に応じて公式Steerまたは受信キュー、Claude Code親は公式非同期hookで回答本文を自動受信する。それ以外の親は`aiterm-wait`を親のターンを塞がない別processで受ける。Cursorのsubmitキーはadapterが現行CLIのextended keyboard protocolへ変換する。送信textがCursorのcomposerへ残った場合は成功receiptを返さず失敗する。
 
-`agent_launch`・`pty_send`（agent dispatch）・`agent_steer`は任意の`image`（画像ファイルの絶対パスの配列。png/jpg/jpeg/gif/webp）を受ける。aitermが本文末尾へ添付行を付け、どのharnessも自分のfile読取toolでそのpathを画像として開く。呼出し側はharness別の添付手順を覚えない。不正なpathは送信前に拒否する。
+`agent_launch`・`pty_send`（agent session宛て）は任意の`image`（画像ファイルの絶対パスの配列。png/jpg/jpeg/gif/webp）を受ける。aitermが本文末尾へ添付行を付け、どのharnessも自分のfile読取toolでそのpathを画像として開く。呼出し側はharness別の添付手順を覚えない。不正なpathは送信前に拒否する。
 
 `agent_launch`は任意の`write_scope`も受ける。Codex／Grokのread-onlyは`--sandbox read-only`、Cursorは公式`--mode ask`で実効化する。path説明は同等CLI引数がないためdeclaration-only。
 
@@ -258,6 +258,8 @@ Grok／Composerの無人起動は公式`--trust`で指定された作業フォ
 
 Grok／Composerで終了済みターンのweekly-limitパネルが残っている場合、次の通常`pty_send`が`Shift+X`で一度閉じ、入力受付を確認して今回の本文を送る。同じsessionと会話を保ち、receiptの`pane_input_recovery`に`grok_rate_limit_dialog_dismissed`を記録する。ターン未終了・harness不在は`GROK_RATE_LIMIT_RECOVERY_BLOCKED`、解除後の入力受付失敗は`GROK_RATE_LIMIT_RECOVERY_FAILED`となり、本文は未送信。上限の継続は`rate_limited`として返し、過去promptは再送しない。Grokの上限観測には現在の画面だけを使う。
 
+Cursorの送信前hook（`beforeSubmitPrompt`と、互換読込するClaude Codeの`UserPromptSubmit`）がpromptを拒否すると、Cursorはpromptを捨て、turnも完了も起きない。Aitermはこの拒否の表示を見分け、起動時promptは`initial_prompt=failed`、`pty_send`は成功receiptを返さず、どちらも`USER_HOOK_BLOCKED`とhookの出力を返す。確認時間（3秒）より後の拒否は、完了待ちが`outcome=error`（`aiterm-wait`はexit 7）で返す。
+
 Grok／Composerがread-only sandboxの適用を拒否した場合、prompt送信時に`GROK_SANDBOX_STARTUP_FAILED`とCLIの原因を返す。例えばhookのパスにシンボリックリンクがあるとGrok CLIは起動を拒否する。設定の管理元で原因を修正し、対象sessionを`pty_close`して起動し直す。Aitermはsandboxを解除したりhookをコピーしたりしない。
 
 この判定はGrok専用アダプターが所有し、同じCLIを使うComposerにも適用する。初回prompt付きの`agent_launch`と通常の`pty_send`で、入力受付待ち中に拒否を検出すると未送信のエラーを返す。promptなし・`trust_project`指定なしの起動応答は入力受付を保証しない。`trust_project:true`では入力受付まで確認し、`startup.status`を返す。Grokのprivacy notice起動設定も同アダプターが所有する。実装の責務分担は[DESIGN](docs/DESIGN.md#failure-and-recovery)を参照。
@@ -403,7 +405,7 @@ MCP クライアントが aiterm を stdio 越しにプログラムから駆動
 
 ```mermaid
 flowchart LR
-    AI["AI / MCP client<br/>(the orchestrator)"] -->|"pty_send · pty_observe · agent_launch · agent_steer · agent_configure · agent_approval · claude_turn · claude_approval<br/>旧launcher alias · diagnostics"| S["aiterm-mcp<br/>stdio MCP · 18 tools"]
+    AI["AI / MCP client<br/>(the orchestrator)"] -->|"pty_send · pty_observe · agent_launch · agent_configure · agent_approval · claude_turn · claude_approval<br/>旧launcher alias · diagnostics"| S["aiterm-mcp<br/>stdio MCP · 17 tools"]
     S -->|"pty_read<br/>token-reduced"| AI
     S -->|"tmux / psmux<br/>send · capture"| P["persistent PTYs<br/>再起動を跨ぐ"]
     P -->|"ssh · docker · repl"| R["nested<br/>remote · container · REPL"]
@@ -512,7 +514,7 @@ Claudeの相関済み承認は既存の`claude_approval`を使う。
 | ツール | 役割 | 主な引数 |
 | --- | --- | --- |
 | `pty_open` | 端末を1個開き`session_id`を返す | `name?`, `shell?`, `env_vars?` |
-| `pty_send` | テキストを送る。agent sessionでは非ブロックdispatchとして`event_cursor`を返す | `session_id`, `text`, `enter=true`, `mark`, `force`, `rtk`, `raw` |
+| `pty_send` | テキストを送る。agent sessionでは子のturnが実行中なら現在のturnへ差し込み（`agent_steer`）、それ以外は非ブロックdispatchとして`event_cursor`を返す（`agent_dispatch`）。差し込みでGrokが待ち行列へ入れない時とCursorの入力欄に残った時は失敗する | `session_id`, `text`, `enter=true`, `mark`, `force`, `rtk`, `raw` |
 | `pty_read` | 出力を削減して読む（既定は増分） | `session_id`, `wait`, `until`, `until_regex`, `timeout`, `screen`, `full`, `lines`, `line_range`, `raw`, `rtk`, `agent_transcript`, `operation_id` |
 | `pty_key` | 制御キーを送る | `session_id`, `key`（`C-c`/`Enter`/`Up`…） |
 | `pty_close` | 冪等に閉じ、`closed` / `already_closed`を返す | `session_id` |
@@ -520,7 +522,6 @@ Claudeの相関済み承認は既存の`claude_approval`を使う。
 | `pty_observe` | pane／harnessの生存、native process identity、状態と活動 | `session_id`, `cursor?` |
 | `agent_launch` | harnessとmodelを別軸で選ぶ正規agent起動入口 | `harness`, `prompt?`, `model?`, `reasoning_effort?`, `cwd?`, `write_scope?`, `trust_project?`, `env_vars?`, `throughline_source_session?`, `throughline_supplement_file?` |
 | `agent_approval` | Codexの現在の承認を検査し、単発許可・拒否を送る | `action`, `session_id`, `approval_choice?`, `observed_prompt_digest?` |
-| `agent_steer` | 実行中のClaude／Codex／Grok／Cursor turnへ、各harness標準の操作でtextを差し込む。差し込み後の作業の完了は1回だけ届く。idleなら送信せず`idle`を返す。Grokが待ち行列へ入れない時とCursorの入力欄に残った時は`steered`を返さず失敗する | `session_id`, `text` |
 | `claude_agent` / `codex_agent` / `grok_agent` / `composer_agent` | deprecated互換alias | 旧launcher引数 |
 | `agent_configure` | 起動中のClaude／Codex／Grok／Composer／Cursorを再起動せずmodel／effort変更 | `session_id`, `model?`, `reasoning_effort?` |
 | `claude_turn` | 相関済みClaude operationをdispatch（issue）または回収（recover） | `action`, `session_id`, `operation_id`, `text?` |
@@ -594,7 +595,7 @@ agent_launch({ "harness": "codex-cli", "remote": { "host": "rabbit" }, "cwd": "/
 - `remote`は`host`、`user`、`port`、`identity_file`、`passphrase`または`passphrase_env`、`ssh_options`（`Key=Value`）を受け取る。`host`だけなら`~/.ssh/config`の接続名として使う。Aitermは接続先を保存・管理しない。どこへどの鍵で入るかは呼び出し側が持つ。
 - 平文の`passphrase`は呼び出したAIの会話記録に残る。ssh-agentか`passphrase_env`（環境変数名）を推奨する。受け取ったパスフレーズはMCP processのメモリにだけ置き、`SSH_ASKPASS`でsshへ渡す。状態ファイルやログには書かない。
 - 現地には`aiterm-mcp`、tmux（Windowsはpsmux）、使うharnessのCLIが要る。接続先のshell（POSIX系、PowerShell、cmd）は最初の接続で見分ける。POSIX系ではログインshellからPATHだけを受け取るので、`~/.local/bin`、Homebrew、nvmなどに置いたCLIも使える。WindowsはユーザーのPATHのまま`aiterm-mcp`を起動する。
-- 以後の`pty_send`、`pty_read`、`pty_close`、`pty_observe`、`agent_steer`などにも同じ`remote`を付ける。session名は現地のもので、この端末の同名sessionとは別に扱う。
+- 以後の`pty_send`、`pty_read`、`pty_close`、`pty_observe`などにも同じ`remote`を付ける。session名は現地のもので、この端末の同名sessionとは別に扱う。
 - Codex／Claude Code／Cursor親には、この端末の子と同じく回答本文が自動で届く。完了は`ssh <host> aiterm-wait`で観測し、SSHが切れても同じcursorでつなぎ直す。それ以外の親には、sshを使う`wait_process`を返す。
 - 同じ接続先への呼び出しはControlMasterで1本のSSHに相乗りする。`remote`付きの`image`添付と`claude_turn issue`は未対応。
 

package/README.md

@@ -145,7 +145,7 @@ Aiterm and is not a runtime dependency.
 
 **Measured, not claimed:** in the recorded 203-test benchmark, a `pty_read` puts **~7.1× fewer tokens** in your context than the raw log — and the pass/fail verdict survives the fold. → [When to reach for it vs. the built-in shell](#when-to-reach-for-it-vs-the-built-in-shell)
 
-Eighteen tools: seven **PTY tools** — `pty_open` / `pty_send` / `pty_read` / `pty_key` / `pty_close` / `pty_list` / `pty_observe` — to open, drive, read, and observe one persistent terminal; one canonical **agent launcher**, `agent_launch`, which selects `claude-code`, `codex-cli`, `grok-cli`, or `cursor-cli` as the execution harness; `agent_steer` for an active Claude, Codex, Grok, or Cursor turn; four deprecated launcher aliases kept for migration; `agent_configure`; `agent_approval`; `claude_turn`; `claude_approval`; and `diagnostics`. The backend is **tmux on POSIX and psmux on native Windows**, so sessions survive even if the MCP server or the AI client restarts.
+Seventeen tools: seven **PTY tools** — `pty_open` / `pty_send` / `pty_read` / `pty_key` / `pty_close` / `pty_list` / `pty_observe` — to open, drive, read, and observe one persistent terminal; one canonical **agent launcher**, `agent_launch`, which selects `claude-code`, `codex-cli`, `grok-cli`, or `cursor-cli` as the execution harness; four deprecated launcher aliases kept for migration; `agent_configure`; `agent_approval`; `claude_turn`; `claude_approval`; and `diagnostics`. The backend is **tmux on POSIX and psmux on native Windows**, so sessions survive even if the MCP server or the AI client restarts.
 
 **v0.28.0 separates the execution harness from the model.** The harness owns the agent loop, authentication, hooks, session, and transcript; `model` is what that harness runs. Cursor Agent CLI can therefore select GPT, Claude, or Grok without changing the completion contract from Cursor hooks to another harness's. Grok Composer is a Grok CLI model preset, not another harness: use `harness: "grok-cli", model: "grok-composer-2.5-fast"`. The old four launcher tools are thin compatibility aliases over the same implementation.
 
@@ -216,7 +216,7 @@ collection is off by default and performs no network I/O. It ships via
 tag-triggered CI with npm provenance (OIDC Trusted Publishing); the GitHub
 Release re-registers the Official MCP Registry entry.
 
-**Status:** actively maintained · current public release **v0.39.1** · runs on Linux · WSL2 · macOS · native Windows (tmux on POSIX, the tmux-CLI-compatible [psmux](https://github.com/psmux/psmux) on native Windows — no WSL required) · MIT · see the [CHANGELOG](CHANGELOG.md).
+**Status:** actively maintained · current public release **v0.40.1** · runs on Linux · WSL2 · macOS · native Windows (tmux on POSIX, the tmux-CLI-compatible [psmux](https://github.com/psmux/psmux) on native Windows — no WSL required) · MIT · see the [CHANGELOG](CHANGELOG.md).
 
 ### Update and rollback
 
@@ -269,9 +269,9 @@ pty_read(id, { wait: true })       → read the token-reduced output, completion
 
 The same primitive hosts another agent's TUI. `agent_launch` starts a selected execution harness inside a fresh persistent terminal and returns a `session_id`. `harness` names the component that owns the agent loop, authentication, hooks, session, and transcript; `model` remains an independent choice. The launched process sees the same project and user environment as a direct CLI invocation: normal configuration, MCPs, plugins, skills, permissions, trust decisions, memory, and history are not copied, filtered, or replaced. Aiterm adds only completion correlation and a non-user sub-agent context containing `role=subagent`, the parent session, delegation depth, lineage, and `delegation_allowed=true`.
 
-起動結果には正規`harness`を含む`aiterm.agent-launch-result.v1`が付き、旧`provider`は互換fieldとして残る。同じ`harness`はagent dispatch、`aiterm-wait`、`agent_configure`、`pty_list`にも載る。Codexは通常rollout、Grokは通常session event、Claudeはlaunch固有Stop hook、Cursorは通常agent transcriptの`turn_ended`を完了正本に使う。agentへの送信は非ブロックdispatchで、harnessごとの完了境界を表す整数`event_cursor`を返す。Codex親は選択に応じて公式Steerまたはqueue、Claude Code親は公式非同期hookで本文を自動受信する。他の親は[`aiterm-wait`](#completion-push-for-parent-agents-aiterm-wait)を使う。CursorのsubmitはadapterがCLIのextended keyboard protocolへ変換し、送信本文がcomposerへ残る場合は明示errorにする。
+起動結果には正規`harness`を含む`aiterm.agent-launch-result.v1`が付き、旧`provider`は互換fieldとして残る。同じ`harness`はagent dispatch、`aiterm-wait`、`agent_configure`、`pty_list`にも載る。Codexは通常rollout、Grokは通常session event、Claudeはlaunch固有Stop hook、Cursorは通常agent transcriptの`turn_ended`を完了正本に使う。agentへの送信は`pty_send`だけで行い、Aitermが送る時点で子の状態を見て振り分ける。実行中のturnへは差し込み（`mode=agent_steer`、新しい`event_cursor`と配送は作らない）、それ以外は非ブロックdispatch（`mode=agent_dispatch`）で、harnessごとの完了境界を表す整数`event_cursor`を返す。Codex親は選択に応じて公式Steerまたはqueue、Claude Code親は公式非同期hookで本文を自動受信する。他の親は[`aiterm-wait`](#completion-push-for-parent-agents-aiterm-wait)を使う。CursorのsubmitはadapterがCLIのextended keyboard protocolへ変換し、送信本文がcomposerへ残る場合は明示errorにする。
 
-`agent_launch`, `pty_send` (agent dispatch), and `agent_steer` accept an optional `image`: an array of absolute paths to image files (png/jpg/jpeg/gif/webp). Aiterm appends an attachment block to the prompt, and every harness opens the path with its own file-reading tool and sees the image; the caller never learns harness-specific attachment tricks. Invalid paths are rejected before anything is sent.
+`agent_launch` and `pty_send` (to an agent session) accept an optional `image`: an array of absolute paths to image files (png/jpg/jpeg/gif/webp). Aiterm appends an attachment block to the prompt, and every harness opens the path with its own file-reading tool and sees the image; the caller never learns harness-specific attachment tricks. Invalid paths are rejected before anything is sent.
 
 `agent_launch` accepts an optional `write_scope`: either `"read-only"` or a human-readable description of writable paths. Codex/Grok use `--sandbox read-only`; Cursor uses its official read-only `--mode ask`. A path description remains declaration-only because these CLI launch surfaces provide no equivalent path allowlist flag.
 
@@ -279,6 +279,8 @@ Grok／Composerの無人起動は公式`--trust`で指定された作業フォ
 
 Grok／Composerで終了済みターンのweekly-limitパネルが残っている場合、次の通常`pty_send`が`Shift+X`で一度閉じ、入力受付を確認して今回の本文を送る。同じsessionと会話を保ち、receiptの`pane_input_recovery`に`grok_rate_limit_dialog_dismissed`を記録する。ターン未終了・harness不在は`GROK_RATE_LIMIT_RECOVERY_BLOCKED`、解除後の入力受付失敗は`GROK_RATE_LIMIT_RECOVERY_FAILED`となり、本文は未送信。上限の継続は`rate_limited`として返し、過去promptは再送しない。Grokの上限観測には現在の画面だけを使う。
 
+When a Cursor pre-submit hook (`beforeSubmitPrompt`, or a Claude Code `UserPromptSubmit` hook that Cursor loads for compatibility) rejects the prompt, Cursor drops it and no turn or completion follows. Aiterm recognizes the rejection: an initial prompt returns `initial_prompt=failed`, and `pty_send` returns an error instead of a success receipt, both with `USER_HOOK_BLOCKED` and the hook's output. A rejection that comes after the 3-second start check is reported by the completion wait as `outcome=error` (`aiterm-wait` exit 7).
+
 Grok／Composerがread-only sandboxの適用を拒否した場合、prompt送信時に`GROK_SANDBOX_STARTUP_FAILED`とCLIの原因を返す。hookパスのシンボリックリンクなど、CLIが示した原因を設定の管理元で修正し、対象sessionを`pty_close`して起動し直す。Aitermはsandboxを解除したりhookをコピーしたりしない。
 
 この判定はGrok専用アダプターが所有し、同じCLIを使うComposerにも適用する。初回prompt付きの`agent_launch`と通常の`pty_send`で、入力受付待ち中に拒否を検出すると未送信のエラーを返す。promptなし・`trust_project`指定なしの起動応答は入力受付を保証しない。`trust_project:true`では入力受付まで確認し、`startup.status`を返す。Grokのprivacy notice起動設定も同アダプターが所有する。実装の責務分担は[DESIGN](docs/DESIGN.md#failure-and-recovery)を参照。
@@ -391,7 +393,7 @@ The only edits to the captures above are the two `⋮` lines (a long head/tail r
 `aiterm-setup --json`が`ready`になったら、利用するMCP clientを再起動して接続を確認する。Claude Codeの場合:
 
 ```bash
-/mcp        # aiterm should show as connected, exposing 18 tools
+/mcp        # aiterm should show as connected, exposing 17 tools
 ```
 
 Your first session — four calls, one persistent terminal:
@@ -432,7 +434,7 @@ The terminal is real and shared, so a human *can* jump in ([A human can watch](#
 
 ```mermaid
 flowchart LR
-    AI["AI / MCP client<br/>(the orchestrator)"] -->|"pty_send · pty_observe · agent_launch · agent_steer · agent_configure · agent_approval · claude_turn · claude_approval<br/>legacy launcher aliases · diagnostics"| S["aiterm-mcp<br/>stdio MCP · 18 tools"]
+    AI["AI / MCP client<br/>(the orchestrator)"] -->|"pty_send · pty_observe · agent_launch · agent_configure · agent_approval · claude_turn · claude_approval<br/>legacy launcher aliases · diagnostics"| S["aiterm-mcp<br/>stdio MCP · 17 tools"]
     S -->|"pty_read<br/>token-reduced"| AI
     S -->|"tmux / psmux<br/>send · capture"| P["persistent PTYs<br/>survive restarts"]
     P -->|"ssh · docker · repl"| R["nested<br/>remote · container · REPL"]
@@ -545,7 +547,7 @@ continue to use `claude_approval`.
 | Tool | Role | Key args |
 | --- | --- | --- |
 | `pty_open` | Open one terminal and return a `session_id` | `name?`, `shell?`, `env_vars?` |
-| `pty_send` | Send text; on an agent session this is a non-blocking **dispatch** returning an `event_cursor` | `session_id`, `text`, `enter=true`, `mark`, `force`, `rtk`, `raw` |
+| `pty_send` | Send text. On an agent session Aiterm picks the route when it sends: if the child's turn is running, it steers the text into that turn (`agent_steer`); otherwise it is a non-blocking **dispatch** returning an `event_cursor` (`agent_dispatch`). Steering fails when Grok does not queue the text or Cursor leaves it in the composer | `session_id`, `text`, `enter=true`, `mark`, `force`, `rtk`, `raw` |
 | `pty_read` | Read output, token-reduced (incremental by default) | `session_id`, `wait`, `until`, `until_regex`, `timeout`, `screen`, `full`, `lines`, `line_range`, `raw`, `rtk`, `agent_transcript`, `operation_id` |
 | `pty_key` | Send a control key | `session_id`, `key` (`C-c`/`Enter`/`Up`…) |
 | `pty_close` | Close idempotently; return `closed` / `already_closed` | `session_id` |
@@ -553,7 +555,6 @@ continue to use `claude_approval`.
 | `pty_observe` | Pane/harness liveness, native process identity, state, and activity | `session_id`, `cursor?` |
 | `agent_launch` | Canonical agent launch; harness and model are independent | `harness`, `prompt?`, `model?`, `reasoning_effort?`, `cwd?`, `write_scope?`, `trust_project?`, `env_vars?`, `throughline_source_session?`, `throughline_supplement_file?` |
 | `agent_approval` | Inspect a Codex approval and submit a one-time approval or denial | `action`, `session_id`, `approval_choice?`, `observed_prompt_digest?` |
-| `agent_steer` | Inject text into the active Claude, Codex, Grok, or Cursor turn with each harness's own steering control, so the steered work still ends in one completion; return `idle` without sending when no turn is active, and fail instead of returning `steered` when Grok does not queue the text or Cursor leaves it in the composer | `session_id`, `text` |
 | `claude_agent` / `codex_agent` / `grok_agent` / `composer_agent` | Deprecated compatibility aliases | legacy launcher arguments |
 | `agent_configure` | Change model/effort in a running Claude, Codex, Grok, Composer, or Cursor session without restarting it | `session_id`, `model?`, `reasoning_effort?` |
 | `claude_turn` | Issue (dispatch-only) or recover one correlated Claude operation | `action`, `session_id`, `operation_id`, `text?` |
@@ -620,7 +621,7 @@ Claudeをリンク経由の`cwd`から起動した場合も、実体パスに対
 
 **For other parent hosts**, dispatch and start the receipt's waiter in a separate process:
 
-1. Launch the child with `agent_launch({ harness: ... })`; every launch shares the normal project/user environment and adds only completion correlation plus lineage. Send a turn with plain `pty_send` (or `claude_turn issue` for durable Claude operations). The call returns immediately with an `event_cursor` in its structured receipt.
+1. Launch the child with `agent_launch({ harness: ... })`; every launch shares the normal project/user environment and adds only completion correlation plus lineage. Send a turn with plain `pty_send` (or `claude_turn issue` for durable Claude operations). The call returns immediately with an `event_cursor` in its structured receipt. If the child is still working when you send, Aiterm steers the text into the running turn instead (`mode: "agent_steer"`); the original request's completion then covers it, so no new cursor or delivery is created.
 2. Pass the receipt's `wait_process.executable` and `wait_process.args` unchanged to a true argv process API. PowerShell 7's `Start-Process` is the exception because it joins `-ArgumentList` arrays; pass `windows_start_process_argument_list` as its one ready-made argument string instead. This invokes the bundled waiter through the exact Node runtime that is already running aiterm, including on native Windows where npm's human-facing bin is a PowerShell script shim and install paths may contain spaces. `wait_command` remains a compatibility display string for humans. The waiter observes the harness-owned completion source, plus Claude's additive launch hook, as a **pure reader** and exits with a one-line `aiterm.agent-wait-result.v1` receipt. **Exit ≠ done**: the receipt's `outcome` is authoritative (`0` = `done`, `3` = `timeout`, `4` = `closed`, `1` = error).
 3. **親自身のforegroundでwaiterを実行しない。** receiptのprocess起動情報を、そのhostが持つバックグラウンドprocess APIへ渡す。親は別作業へ進むかturnを終え、process終了の通知で続行する。
 4. Collect the result exactly as before: `pty_read(agent_transcript: true)`, or `claude_turn recover` for durable Claude operations. The waiter carries the signal, never the payload.
@@ -640,7 +641,7 @@ agent_launch({ "harness": "codex-cli", "remote": { "host": "rabbit" }, "cwd": "/
 - `remote` takes `host`, `user`, `port`, `identity_file`, `passphrase` or `passphrase_env`, and `ssh_options` (`Key=Value`). A bare `host` is used as an `~/.ssh/config` alias. Aiterm does not store or manage destinations; the caller owns where to connect and with which key.
 - A plain `passphrase` stays in the calling AI's conversation log. Prefer ssh-agent or `passphrase_env` (an environment variable name). A received passphrase lives only in the MCP process memory and reaches ssh through `SSH_ASKPASS`; it is never written to state files or logs.
 - The remote machine needs `aiterm-mcp`, tmux (psmux on Windows), and the harness CLI. The remote shell family (POSIX, PowerShell, or cmd) is detected on first contact. On POSIX machines Aiterm takes only PATH from the login shell, so CLIs under `~/.local/bin`, Homebrew, or nvm are found; on Windows it starts `aiterm-mcp` with the user's PATH as is.
-- Pass the same `remote` to later `pty_send`, `pty_read`, `pty_close`, `pty_observe`, `agent_steer`, and so on. Session names belong to the remote machine and never collide with local sessions of the same name.
+- Pass the same `remote` to later `pty_send`, `pty_read`, `pty_close`, `pty_observe`, and so on. Session names belong to the remote machine and never collide with local sessions of the same name.
 - Codex, Claude Code, and Cursor parents receive the answer automatically, as with a local child. Completion is observed with `ssh <host> aiterm-wait`, reconnecting at the same cursor if SSH drops. Other parents get an ssh-based `wait_process`.
 - Calls to the same destination share one SSH connection through ControlMaster. `image` attachments and `claude_turn issue` are not yet supported with `remote`.
 

package/dist/core.js

@@ -21,7 +21,7 @@ import { sleep, currentUid, runtimeStateBase, safeStatSize, readFileRange, write
 import { GROK_MODEL_DEFAULTS, realGrokHome, resolveAndValidateGrokAuth, assertGrokModelAvailable, grokEventsTranscript, latestGrokCompletion, observeGrokDone, buildGrokAgentCmd, grokLaunchNote, grokEnvTokens, grokTuiReady, grokTuiBusy, grokPaneObservation, grokRateLimitDialog, grokStartupAction, grokLaunchBlockingDialog, assertGrokSandboxNotRejected, GROK_COMPOSER_MARKER_RE, grokFooterHasConfiguration, grokTranscriptText, createGrokAgentMetadata, } from "./harnesses/grok.js";
 import { bindCodexTranscriptSession, latestCodexCompletion, observeCodexDone, buildCodexAgentCmd, codexLaunchNote, codexTuiReady, codexPaneObservation, codexRateLimitModelSwitchDialog, codexApprovalDialog, codexStartupAction, CODEX_COMPOSER_MARKER_RE, codexModelChoice, codexEffortChoice, codexMoreReasoningChoice, codexTranscriptText, createCodexAgentMetadata, } from "./harnesses/codex.js";
 import { OPERATION_ID_RE, CLAUDE_RESULT_MAX_BYTES, CLAUDE_EFFORTS, agentManagedClaudeSettingsPath, agentClaudeResultPath, agentClaudeOperationPath, agentClaudeApprovalReceiptPath, agentClaudeDispatchReceiptPath, validateOperationId, readClaudeResultText, assertClaudeAuthenticationReady, buildClaudeAgentCmd, claudeLaunchNote, claudeTuiReady, claudePaneObservation, claudeStartupAction, claudeLoginMethodMenu, CLAUDE_COMPOSER_MARKER_RE, createClaudeAgentMetadata, claudeSessionTranscriptPath, claudeApiErrorFromLine, } from "./harnesses/claude.js";
-import { bindCursorTranscriptSession, cursorTurnBoundary, latestCursorCompletion, observeCursorDone, cursorTranscriptText, assertCursorAuthenticationReady, assertCursorModelAvailable, buildCursorAgentCmd, cursorAgentArgv, cursorPwshLaunchLine, cursorPromptWithLineage, createCursorAgentMetadata, cursorLaunchNote, cursorEffortNavigation, cursorTuiReady, cursorPaneObservation, cursorUsageLimit, CURSOR_SUBMIT_SEQUENCE, CURSOR_COMPOSER_CONTENT_MARKER_RE, validateCursorModelEffort, } from "./harnesses/cursor.js";
+import { bindCursorTranscriptSession, cursorTurnBoundary, latestCursorCompletion, observeCursorDone, cursorTranscriptText, assertCursorAuthenticationReady, assertCursorModelAvailable, buildCursorAgentCmd, cursorAgentArgv, cursorPwshLaunchLine, cursorPromptWithLineage, createCursorAgentMetadata, cursorLaunchNote, cursorEffortNavigation, cursorTuiReady, cursorPaneObservation, cursorPromptHooksRunning, cursorUsageLimit, CURSOR_SUBMIT_SEQUENCE, CURSOR_COMPOSER_CONTENT_MARKER_RE, validateCursorModelEffort, } from "./harnesses/cursor.js";
 import { resolveAgentBin, resolveThroughlineBin, runThroughlineHandoffContext, isWindowsNativeExecutable, agentBinForPaneShell, resolveWinPaneShell } from "./agent-resolver.js";
 export { AitermError } from "./errors.js";
 export { tmuxSpawnEnv } from "./tmux-runtime.js";
@@ -2669,7 +2669,7 @@ export async function observeAgentDone(name, o = {}) {
         return observeCodexDone(meta, timeout, o.cursor, detectAgentRateLimit, o.signal);
     }
     if (meta.kind === "cursor" && meta.completion_route === "cursor_transcript") {
-        return observeCursorDone(meta, timeout, o.cursor, detectAgentRateLimit, o.signal);
+        return observeCursorDone(meta, timeout, o.cursor, detectAgentRateLimit, (session) => captureScreen(session, 0), o.signal);
     }
     if ((meta.kind === "grok" || meta.kind === "composer") && meta.completion_route === "grok_transcript") {
         return observeGrokDone(meta, timeout, o.cursor, detectAgentRateLimit, o.signal);
@@ -3213,8 +3213,10 @@ export async function sendInitialAgentPrompt(name, text, o = {}) {
     }
     let delivery = { status: "submitted_unconfirmed", reason: "start_unconfirmed", turn_started: null };
     const deadline = performance.now() + 3000;
+    const hookDeadline = performance.now() + CURSOR_PROMPT_HOOK_WAIT_MS;
+    let screen = "";
     do {
-        const screen = captureScreen(name, AGENT_TUI_READY_LINES);
+        screen = captureScreen(name, AGENT_TUI_READY_LINES);
         const state = meta.kind === "grok" || meta.kind === "composer" ? grokPaneObservation(screen)
             : meta.kind === "codex" ? codexPaneObservation(screen)
                 : meta.kind === "claude" ? claudePaneObservation(screen) : cursorPaneObservation(screen);
@@ -3226,6 +3228,11 @@ export async function sendInitialAgentPrompt(name, text, o = {}) {
             delivery = { status: "started", reason: "approval_required", turn_started: true };
             break;
         }
+        if (state.state === "blocked" && state.reason === "user_hook_blocked") {
+            setInitialDelivery(meta, { status: "submitted_unconfirmed", reason: "user_hook_blocked", turn_started: false }, startOffset);
+            setInitialPromptState(meta, "failed");
+            throw new AitermError(userHookBlockedMessage(`initial_prompt=failed vendor=${meta.kind} harness=${agentHarness(meta.kind)}`, "起動時prompt", state.detail), 2);
+        }
         const completed = await observeAgentDone(name, { cursor: startOffset, timeout: 0 });
         if (completed.outcome === "done") {
             delivery = { status: "started", reason: "turn_completed", turn_started: true };
@@ -3236,7 +3243,7 @@ export async function sendInitialAgentPrompt(name, text, o = {}) {
             break;
         }
         await sleep(100);
-    } while (performance.now() < deadline);
+    } while (performance.now() < deadline || (meta.kind === "cursor" && performance.now() < hookDeadline && cursorPromptHooksRunning(screen)));
     setInitialDelivery(meta, delivery, startOffset);
     return {
         text: `initial_prompt=pending vendor=${meta.kind} event_cursor=${startOffset} harness=${agentHarness(meta.kind)}\n` +
@@ -3510,6 +3517,32 @@ export function attachImages(text, images) {
     const body = text.trim().length > 0 ? text : "添付画像を確認してください。";
     return `${body}\n\n${lines.join("\n")}\n添付画像は上のファイルを読んで確認する。`;
 }
+function userHookBlockedMessage(head, what, detail) {
+    return `${head}\nUSER_HOOK_BLOCKED: 利用者のhookが${what}を拒否したため、turnは始まっていません。完了通知も来ません。` +
+        `hookを直すか外してから送り直してください。hookの出力: ${detail ?? "(不明)"}`;
+}
+const CURSOR_START_CONFIRM_MS = 3000;
+// 送信前hookが動いている間は、確認時間を過ぎても結果を待つ。Windowsではhookごとの起動が遅く、数本続くと3秒を超える
+// （fox実測 2026-09-27）。上限は利用者のhookに付く最長のtimeout（60秒）に合わせる。
+const CURSOR_PROMPT_HOOK_WAIT_MS = 60_000;
+// Cursorは送信前hookの実行中も「Working」だけを出し、拒否されると入力欄を空に戻す。入力欄の残留検査では
+// 拒否を見分けられず、成功receiptを返すと親は来ない完了を待ち続ける。turnの開始か拒否の表示を確かめる。
+// hookが上限を過ぎてから拒否した時は、完了待ち（observeCursorDone）がoutcome=errorで返す。
+async function assertCursorPromptNotHookBlocked(name) {
+    const deadline = performance.now() + CURSOR_START_CONFIRM_MS;
+    const hookDeadline = performance.now() + CURSOR_PROMPT_HOOK_WAIT_MS;
+    let screen = "";
+    do {
+        screen = captureScreen(name, AGENT_TUI_READY_LINES);
+        const state = cursorPaneObservation(screen);
+        if (state.state === "busy")
+            return;
+        if (state.state === "blocked" && state.reason === "user_hook_blocked") {
+            throw new AitermError(userHookBlockedMessage(`vendor=cursor session=${name}`, "送信した文", state.detail), 2);
+        }
+        await sleep(100);
+    } while (performance.now() < deadline || (performance.now() < hookDeadline && cursorPromptHooksRunning(screen)));
+}
 export async function dispatchAgentTurn(name, text, o = {}) {
     assertSessionName(name);
     const meta = loadAgentMetadata(name);
@@ -3528,7 +3561,7 @@ export async function dispatchAgentTurn(name, text, o = {}) {
     const claudeColdStart = meta.kind === "claude"
         && agentCompletionCursor(meta) === 0
         && readClaudeOperationMarker(meta) === null;
-    const paneInputRecovery = await ensureAgentOwnsPaneInput(name, meta.kind);
+    const paneInputRecovery = o.pane_input_recovery ?? await ensureAgentOwnsPaneInput(name, meta.kind);
     let codexRateLimitModelSwitch = false;
     const limitDialog = meta.kind === "grok" || meta.kind === "composer"
         ? grokRateLimitDialog(captureScreen(name, 0)) : null;
@@ -3608,6 +3641,8 @@ export async function dispatchAgentTurn(name, text, o = {}) {
     // 陽性観測した場合だけ同じEnterを一度再送し、再検査後も残る時は失敗として返す。
     residue = await retryCursorSubmitIfResidue(name, meta.kind, dispatchText, residue);
     assertAgentSubmitDelivered(name, meta.kind, residue);
+    if (meta.kind === "cursor")
+        await assertCursorPromptNotHookBlocked(name);
     return {
         schema: "aiterm.agent-dispatch.v1",
         session_id: meta.aiterm_session,
@@ -3640,6 +3675,26 @@ async function waitSteerScreen(name, predicate) {
 export function __testSteerQueued(kind, screen) {
     return kind === "cursor" ? cursorSteerQueued(screen) : grokSteerQueued(screen);
 }
+/**
+ * agent sessionへの唯一の送信口。呼び出し側は子の状態を知らないまま呼び、Aitermがこの時点の画面で振り分ける。
+ * 実行中なら現在のturnへ差し込み（steer）、そうでなければ新しいturnとしてdispatchする。
+ * 振り分けを呼び出し側へ任せると、状態を見てから呼ぶまでの間に子のturnが変わり、選んだ入口が外れる。
+ */
+export async function sendAgentMessage(name, text, o = {}) {
+    assertSessionName(name);
+    const meta = loadAgentMetadata(name);
+    // 前面回復は busy 判定より先（bash 前面のままだと画面の実行中マーカーを読んでも打鍵が届かない）。
+    const paneInputRecovery = await ensureAgentOwnsPaneInput(name, meta.kind);
+    let running = isAgentTuiBusy(meta.kind, captureScreen(name, AGENT_TUI_READY_LINES));
+    // Claude CodeはStop hookの実行中も実行中の表示を続ける。Aitermのturnの印はStopで消えるので、
+    // 印が無ければturnは終わっている。ここで差し込むと新しいturnとして始まり、誰もその完了を待たない。
+    if (meta.kind === "claude" && readClaudeOperationMarker(meta) === null)
+        running = false;
+    if (running) {
+        return steerRunningTurn(name, meta, text, { raw: o.raw, pane_input_recovery: paneInputRecovery });
+    }
+    return dispatchAgentTurn(name, text, { raw: o.raw, before_send: o.before_send, pane_input_recovery: paneInputRecovery });
+}
 /**
  * 実行中turnへ追加の指示を渡す。各harnessの標準操作だけを使い、完了境界は1つに保つ。
  * - Codex: 次のtool呼出し後に同じturnへ入る（rolloutのturn_idが同じ）。
@@ -3648,28 +3703,22 @@ export function __testSteerQueued(kind, screen) {
  * - Grok: 待ち行列へ入れた後に「send now」を押す。旧turnは`cancelled`（trigger=send_now）で閉じ、
  *   新turnが作業を継ぐ。完了判定はこの継ぎ目を完了と数えない（grokCompletionEvent）。
  */
-export async function steerAgentTurn(name, text) {
-    assertSessionName(name);
-    const meta = loadAgentMetadata(name);
+async function steerRunningTurn(name, meta, text, o) {
     const receipt = {
         schema: "aiterm.agent-steer.v1",
         session_id: meta.aiterm_session,
         launch_id: meta.launch_id,
         vendor: meta.kind,
         harness: agentHarness(meta.kind),
+        pane_input_recovery: o.pane_input_recovery,
     };
-    // 前面回復は busy 判定より先（bash 前面のままだと画面の実行中マーカーを読んでも打鍵が届かない）。
-    const paneInputRecovery = await ensureAgentOwnsPaneInput(name, meta.kind);
-    if (!isAgentTuiBusy(meta.kind, captureScreen(name, AGENT_TUI_READY_LINES))) {
-        return { ...receipt, delivery: "idle", pane_input_recovery: paneInputRecovery };
-    }
-    prepareSendText(text, { raw: false });
+    prepareSendText(text, { raw: o.raw });
     // Claudeのoperation相関は変えない。差し込みは実行中turnの一部であり、新しいturnを予約しない。
     const preserveAgentOperation = meta.kind === "claude";
     send(name, text, {
         enter: false,
         force: true,
-        raw: false,
+        raw: o.raw,
         mark: false,
         rtk: false,
         preserveAgentOperation,
@@ -3693,7 +3742,8 @@ export async function steerAgentTurn(name, text) {
         const label = meta.kind === "cursor" ? "Cursor" : "Grok";
         if (!await waitSteerScreen(name, queued)) {
             throw new AitermError(`STEER_NOT_QUEUED vendor=${meta.kind} session=${name}\n` +
-                `差し込む文が${label}の待ち行列へ入ったことを確認できません。pty_read(screen:true)で入力欄を確かめてください。`, 2);
+                `差し込む文が${label}の待ち行列へ入ったことを確認できません。子のturnが送る直前に終わっていた時は、` +
+                `文は新しいturnとして始まっており、その完了は通知されません。再送する前にpty_read(screen:true)で確かめてください。`, 2);
         }
         sendKey(name, "Enter");
         if (!await waitSteerScreen(name, screen => !queued(screen))) {
@@ -3711,7 +3761,7 @@ export async function steerAgentTurn(name, text) {
                 "差し込む文がCursorの入力欄に残っており、実行中のturnへ渡せませんでした。", 2);
         }
     }
-    return { ...receipt, delivery: "steered", pane_input_recovery: paneInputRecovery };
+    return receipt;
 }
 export async function runClaudeOperation({ session_id: name, action, operation_id: operationIdInput, text, before_send, }) {
     assertSessionName(name);

package/dist/harnesses/cursor.js

@@ -183,13 +183,13 @@ export function latestCursorCompletion(meta, readTranscriptLines) {
         ? cursorCompletionEvent(meta, harnessSessionId, state.terminalRecord, `cursor:${state.userTurns}`)
         : null;
 }
-export async function observeCursorDone(meta, timeout, requestedCursor, detectRateLimit, signal) {
+export async function observeCursorDone(meta, timeout, requestedCursor, detectRateLimit, readScreen, signal) {
     const metadataFile = agentMetadataPath(meta.aiterm_session, meta.launch_id);
     let transcript = cursorTranscript(meta);
     const startBoundary = requestedCursor ?? (transcript ? cursorTranscriptState(transcript).userTurns : 0);
     let malformedEvents = 0;
     const deadline = performance.now() + timeout * 1000;
-    const observation = (outcome, ev = null, rateLimit = null) => ({
+    const observation = (outcome, ev = null, rateLimit = null, error = null) => ({
         schema: "aiterm.agent-wait-result.v1",
         session_id: meta.aiterm_session,
         launch_id: meta.launch_id,
@@ -202,7 +202,7 @@ export async function observeCursorDone(meta, timeout, requestedCursor, detectRa
         malformed_events: malformedEvents,
         at: ev?.at ?? null,
         rate_limit: rateLimit,
-        error: null,
+        error,
     });
     for (;;) {
         signal?.throwIfAborted();
@@ -222,6 +222,10 @@ export async function observeCursorDone(meta, timeout, requestedCursor, detectRa
         const limited = detectRateLimit(meta.kind, meta.aiterm_session);
         if (limited)
             return observation("rate_limited", null, limited);
+        // 拒否されたpromptのturnは始まらず、完了も来ない。拒否の表示は数秒で消えるので、見えている間に終わらせる。
+        const hookBlocked = cursorHookBlocked(readScreen(meta.aiterm_session));
+        if (hookBlocked)
+            return observation("error", null, null, `USER_HOOK_BLOCKED: ${hookBlocked.message}`);
         if (performance.now() >= deadline)
             return observation(timeout === 0 ? "running" : "timeout");
         await sleep(AGENT_DONE_POLL_MS);
@@ -452,10 +456,44 @@ export function cursorUsageLimit(screen) {
     }
     return { message: [`${heading[1]}.`, ...detail].join(" ") };
 }
+// Cursor Agentはpromptを送る前のhook（beforeSubmitPromptと、互換読込したClaude CodeのUserPromptSubmit）が
+// 拒否すると、promptを捨てて入力欄を空に戻し、その下に「Hook blocked with message:」を数秒だけ出す。turnは始まらず、
+// transcriptにもuser turnは残らない（v2026.09.26、Windows実機採取 2026-09-27）。
+const CURSOR_HOOK_BLOCKED_RE = /^[ \t]*Hook blocked with message:[ \t]*(.*)$/gim;
+const CURSOR_HOOK_BLOCKED_MESSAGE_LIMIT = 600;
+export function cursorHookBlocked(screen) {
+    const clean = screen.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "");
+    const hit = [...clean.matchAll(CURSOR_HOOK_BLOCKED_RE)].at(-1);
+    if (!hit)
+        return null;
+    const after = clean.slice(hit.index + hit[0].length);
+    // 拒否の後に新しいturnが動いている画面は、古い表示の名残として数えない。
+    if (/ctrl\+c to stop/i.test(after) || CURSOR_FOLLOWUP_MARKER_RE.test(after))
+        return null;
+    const lines = [hit[1].trim()];
+    for (const line of after.split("\n").slice(1)) {
+        if (!line.trim())
+            break;
+        lines.push(line.trim());
+    }
+    // hookを動かしたNode自身の警告は拒否の理由ではない。
+    const message = lines.filter(line => line && !/ExperimentalWarning|--trace-warnings|^any time$/.test(line)).join(" ");
+    return { message: (message || "(hookは理由を出していません)").slice(0, CURSOR_HOOK_BLOCKED_MESSAGE_LIMIT) };
+}
+// 送信前hookの実行中、Cursorは入力欄の上に「Working」の回転表示だけを出し、入力欄はまだ「Plan, search, build anything」の
+// ままで「ctrl+c to stop」も無い（v2026.09.26、Windows実機採取 2026-09-27）。turnはまだ始まっておらず、hookが拒否すればここで終わる。
+const CURSOR_SPINNER_WORKING_RE = /^[ \t]*[⠀-⣿]+[ \t]+Working\b/m;
+export function cursorPromptHooksRunning(screen) {
+    const tail = screen.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").split("\n").slice(-32).join("\n");
+    return CURSOR_SPINNER_WORKING_RE.test(tail) && CURSOR_START_PROMPT_MARKER_RE.test(tail) && !/ctrl\+c to stop/i.test(tail);
+}
 export function cursorPaneObservation(screen) {
     const tail = screen.split("\n").slice(-32).join("\n");
     if (cursorUsageLimit(tail))
         return { state: "blocked", reason: "rate_limited" };
+    const hookBlocked = cursorHookBlocked(tail);
+    if (hookBlocked)
+        return { state: "blocked", reason: "user_hook_blocked", detail: hookBlocked.message };
     if (/ctrl\+c to stop/i.test(tail))
         return { state: "busy", reason: "turn_running" };
     if (cursorTuiReady(tail))

package/dist/harnesses/grok.js

@@ -84,7 +84,7 @@ export function grokCompletionEvent(meta, record) {
         record?.type !== "turn_ended" ||
         (record?.outcome !== "completed" && record?.outcome !== "cancelled" && record?.outcome !== "error"))
         return null;
-    // agent_steerの「send now」は旧turnを閉じて同じ作業を新turnで続ける継ぎ目であり、完了ではない
+    // 実行中turnへの差し込み（pty_send）の「send now」は旧turnを閉じて同じ作業を新turnで続ける継ぎ目であり、完了ではない
     // （実測 grok 1.0.41: outcome=cancelled, cancellation_context.trigger=send_now の直後にturn_started）。
     if (record.outcome === "cancelled" && record.cancellation_context?.trigger === "send_now")
         return null;

package/dist/index.js

@@ -187,15 +187,18 @@ async function sendRemote(target, args, extra) {
         throw new core.AitermError("REMOTE_IMAGE_UNSUPPORTED: 別端末への画像添付には未対応です", 2);
     const key = deliveryKey(args.session_id, target);
     const delivery = args.force ? null : await deliveryForRequest(extra, true);
-    // 前の依頼の回答を確保してから次を送る。送った後では取り消せない。
+    // 終わった依頼の回答は送る前に保存する。実行中の依頼は残る。現地が差し込みを選べばその依頼が回答を受け取る。
     if (delivery)
-        await remoteParentDelivery.beforeChange(key, true);
+        await remoteParentDelivery.beforeChange(key);
     const result = await callRemoteTool(target, "pty_send", args);
     const structured = result.structuredContent;
     if (result.isError || !structured || structured.mode !== "agent_dispatch") {
         return { content: [...result.content, remoteNote(target, result)], ...(structured ? { structuredContent: structured } : {}), ...(result.isError ? { isError: true } : {}) };
     }
     try {
+        // 現地がdispatchを選んだのは子がidleだった時なので、前の依頼はもう保存できる。残っていれば登録しない。
+        if (delivery)
+            await remoteParentDelivery.beforeChange(key, true);
         if (delivery && structured.event_cursor !== null)
             await registerRemoteDelivery(delivery, target, structured.session_id, structured.event_cursor);
     }
@@ -248,7 +251,10 @@ registerRemoteAwareTool("pty_open", {
 });
 registerRemoteAwareTool("pty_send", {
     description: "セッションへテキストを送る。通常PTYへは送信のみ（出力は pty_read で取得）。" +
-        "agent session（launcher起動）への send は自動で dispatch になる: TUI の ready gate と submit 分離を通して即返り、" +
+        "agent session（launcher起動）への送信はこのtoolだけで行い、子の状態はAitermが送る時点で見て振り分ける。" +
+        "子のturnが実行中なら各harness標準の操作で現在のturnへ差し込み（mode=agent_steer）、完了は差し込み後の作業の終わりに" +
+        "元の依頼への1回だけ届く。新しいevent_cursorと配送は作らない。" +
+        "それ以外は新しいturnとしてdispatchし（mode=agent_dispatch）、TUI の ready gate と submit 分離を通して即返り、" +
         "receipt の event_cursor を返す。" +
         NON_BLOCKING_RULE +
         "自動配送以外の結果回収は pty_read(agent_transcript:true)、Claude の durable turn は claude_turn を使う。" +
@@ -280,7 +286,7 @@ registerRemoteAwareTool("pty_send", {
     },
     outputSchema: {
         schema: z.literal("aiterm.pty-send-result.v1"),
-        mode: z.enum(["sent", "agent_dispatch"]),
+        mode: z.enum(["sent", "agent_dispatch", "agent_steer"]),
         session_id: z.string(),
         event_cursor: z.number().int().nullable(),
         wait_process: waitProcessOutputSchema,
@@ -305,7 +311,30 @@ registerRemoteAwareTool("pty_send", {
             if (rtk)
                 throw new Error("agent session への dispatch は rtk:true と併用できません");
             delivery = await deliveryForRequest(extra);
-            const receipt = await core.dispatchAgentTurn(session_id, core.attachImages(text, image), { raw, before_send: delivery?.before_send });
+            const receipt = await core.sendAgentMessage(session_id, core.attachImages(text, image), { raw, before_send: delivery?.before_send });
+            if (receipt.schema === "aiterm.agent-steer.v1") {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `実行中のturnへ差し込んだ（harness=${receipt.harness}, vendor=${receipt.vendor}）。` +
+                                "完了は差し込み後の作業の終わりに、元の依頼への通知として1回だけ届く。",
+                        },
+                    ],
+                    structuredContent: {
+                        schema: "aiterm.pty-send-result.v1",
+                        mode: "agent_steer",
+                        session_id: receipt.session_id,
+                        event_cursor: null,
+                        wait_process: null,
+                        launch_id: receipt.launch_id,
+                        vendor: receipt.vendor,
+                        harness: receipt.harness,
+                        submit_residue: null,
+                        pane_input_recovery: receipt.pane_input_recovery,
+                    },
+                };
+            }
             const waited = completionWait(delivery, receipt.session_id, receipt.event_cursor);
             return {
                 content: [
@@ -356,35 +385,6 @@ registerRemoteAwareTool("pty_send", {
         return fail(e);
     }
 });
-registerRemoteAwareTool("agent_steer", {
-    description: "実行中のClaude／Codex／Grok／Cursor agentへ追加メッセージを差し込み、現在のターンを誘導する。" +
-        "完了は差し込み後の作業の終わりに1回だけ届く。独立した次ターンを始める用途ではなく、idle時は文字を送らずdelivery=idleを返す。" +
-        "Grokが待ち行列へ入れない時とCursorの入力欄に残った時は、steeredを返さずエラーにする。",
-    inputSchema: {
-        session_id: z.string(),
-        text: z.string().describe("現在のターンへ追加する文字列。UTF-8で最大64KiB"),
-        image: z.array(z.string()).optional().describe("添付する画像ファイルの絶対パス（png/jpg/jpeg/gif/webp）"),
-    },
-    outputSchema: {
-        schema: z.literal("aiterm.agent-steer.v1"),
-        session_id: z.string(),
-        launch_id: z.string(),
-        vendor: z.enum(["claude", "codex", "grok", "composer", "cursor"]),
-        harness: z.enum(["claude-code", "codex-cli", "grok-cli", "cursor-cli"]),
-        delivery: z.enum(["steered", "idle"]),
-    },
-}, async ({ session_id, text, image }) => {
-    try {
-        const receipt = await core.steerAgentTurn(session_id, core.attachImages(text, image));
-        return {
-            content: [{ type: "text", text: `${receipt.delivery} ${receipt.session_id}` }],
-            structuredContent: receipt,
-        };
-    }
-    catch (e) {
-        return fail(e);
-    }
-});
 registerRemoteAwareTool("pty_read", {
     description: "セッションの出力をトークン削減して読む（既定は前回読取位置からの増分）。" +
         "削減: 制御文字除去 / 反復圧縮 / head+tail 折りたたみ＋復元ヒント＋メタ併記。" +

package/docs/DESIGN.md

@@ -64,7 +64,11 @@ waiterは純readerで、親のforeground turnを塞がない。
 Grok／Composerの記録先はCLIと同じOS絶対パスへcwdを正規化して導出し、完了通知と回答で同じ関数を使う。
 配送用のGrok回答は`turn_ended.ts`から同じturnの`turn_started.turn_number`を取得し、
 `chat_history.jsonl`の`user.prompt_index`と相関する。次turnが既に始まっていても対象回答だけを回収する。
-`agent_steer`は実行中のturnへ追加textを差し込み、idleなら送信せず状態を返す。完了境界は差し込み後も1つに保つ。
+agent sessionへの送信口は`pty_send`だけとする。子の状態は呼び出し側に選ばせず、Aitermが送る時点の画面で振り分ける。
+状態を見てから呼ぶまでの間に子のturnが変わるため、呼び出し側が入口を選ぶ形では外れる。
+実行中なら現在のturnへ追加textを差し込み、新しい完了境界と配送は作らない。完了境界は差し込み後も1つに保つ。
+Claude CodeはStop hookの実行中も実行中の表示を続けるため、Aitermのturnの印（Stopで消える）が無ければ実行中と数えない。
+それ以外は新しいturnとしてdispatchする。
 CodexとClaude Codeは次のtool境界で同じturnへ取り込む。Cursorは「follow-ups」枠へ入った文を「enter steer」で現在turnへ移し、`turn_ended`は最後に1回書く。
 Grokは待ち行列へ入れた後に「send now」を押す。旧turnは`cancelled`（`cancellation_context.trigger=send_now`）で閉じ、
 新turnが作業を継ぐので、完了判定はこの継ぎ目を完了と数えない。Grokが待ち行列へ入れない時とCursorの入力欄に本文が残る時は`steered`を返さない。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiterm-mcp",
-  "version": "0.39.1",
+  "version": "0.40.1",
   "mcpName": "io.github.kitepon/aiterm-mcp",
   "description": "Persistent terminal MCP with one harness-based launcher for Claude Code, Codex CLI, Grok CLI, and Cursor Agent CLI, plus durable PTYs for SSH, containers, and REPLs.",
   "keywords": [