aiterm-mcp 0.35.0 → 0.36.0

package/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.36.0] - 2026-09-13
+
+### 追加
+
+- macOSのCodex Desktop向けにSteerの選択導入を追加。`aiterm-setup`の対話選択または`--codex-steer enable`で、同じ公式App Serverへ回答を送り、実行中は同じターンへ反映、終了後は同じタスクを再開する。
+- 中継・POSIX起動処理をnpm packageへ同梱。公式App Serverの再ビルド、別配布、Pythonの追加導入は不要。公式バイナリのPID・Desktopとの親子関係・署名・通常環境を維持する。
+- `--codex-steer status|disable`で実効状態の確認と元の設定への復元を行う。ログイン時の設定は専用LaunchAgentで維持する。初回は`restart_required`と終了コード3を返し、Codexの完全再起動を必要とする。
+- Steerを選択した環境で接続できない時は明示エラーとし、queueへ自動退避しない。送信結果不明の回答は従来どおり保存し、自動再送しない。配送record schemaは維持し、Steer受付済みの`queued_submission_id`はnullとなる。
+- Steerを持たない旧版への巻き戻し前は`aiterm-setup --codex-steer disable`を実行する。Windows・LinuxのSteer選択は未対応を明示し、単品導入と通常のqueue配送は維持する。
+
+### 修正
+
+- 公開コマンドが配布物の検査前にbuildを行い、clean cloneからの公開で未生成の`dist/`を参照して失敗する問題を修正した。
+- 同一エラーの再発時に`product_version`を更新し、snapshotに最終実発生時の版を公開する。
+- runtime storeをv2へ移行する。旧v1の単発記録は版を保持し、複数回の旧集約は最終発生版を復元できないため`unknown`にする。読取りで状態JSONを書き戻さず、次のロック内更新でv2を保存する。
+- v2を保存したstoreは旧writerで開かない。consumerを先に更新し、旧プロセスを終了してから新writerへ切り替える。旧版へ戻す場合は製品のバックアップを使い、v2をv1に偽装しない。
+
+## [0.35.1] - 2026-09-10
+
+### Fixed
+
+- Claudeの起動時に、指定された作業ディレクトリの実体パスを記録する。macOSの`/var`やリンク経由のcwdでも、会話記録を使うAPIエラー検出が正しい保存場所を参照する。
+
 ## [0.35.0] - 2026-09-10
 
 ### Added
@@ -1634,7 +1657,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.35.0...HEAD
+[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.36.0...HEAD
+[0.36.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.35.1...v0.36.0
+[0.35.1]: https://github.com/kitepon/aiterm-mcp/compare/v0.35.0...v0.35.1
 [0.35.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.34.0...v0.35.0
 [0.34.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.33.1...v0.34.0
 [0.33.1]: https://github.com/kitepon/aiterm-mcp/compare/v0.33.0...v0.33.1

package/README.ja.md

@@ -40,11 +40,31 @@ WindowsはwingetでPowerShell 7・Git for Windows・psmux、macOSはHomebrewでt
 Ubuntu／Debianはsudoとaptでtmuxを準備する。必要な公式package managerと実行権限は事前に必要。
 他のLinuxでも既存tmuxを利用できるが、自動導入は`unsupported`で停止する。
 既存設定の他サーバーを保持し、JSON設定は変更前の`.aiterm-backup`を残す。
-結果の`status`は`ready`／`unsupported`／`failed`。未検出のAIは`not_detected`とし、全AI未検出は成功にしない。
+結果の`status`は`ready`／`unsupported`／`failed`／`restart_required`。未検出のAIは`not_detected`とし、全AI未検出は成功にしない。
 登録先はglobal packageのNodeとMCP入口の絶対パスで、npm一時cacheやsource checkoutは登録しない。
 更新後も同じ入口を実行し、MCP clientを再起動する。npm install自体はユーザー設定を変更しない。
 公開JSONは`schema: "aiterm.setup-result.v1"`、全体の`status`、端末の`backend`、
-AI別の`integrations`を持つ。失敗時は`reason_code`を付け、終了コードはreadyなら0、それ以外は2となる。
+AI別の`integrations`と選択機能の`codex_steer`を持つ。失敗時は`reason_code`を付け、終了コードはreadyなら0、再起動待ちは3、それ以外は2となる。
+
+
+### Codex DesktopへSteerを有効にする（macOS）
+
+対話実行の`aiterm-setup`で「Aiterm単品」と「Steer付き」を選べます。無人導入では明示します。
+
+```bash
+aiterm-setup --json --codex-steer enable
+```
+
+公式Codex Desktopに同梱されたApp Serverを使い、実行中の親には同じターンへ回答を送り、
+終了後に届いた回答でも同じタスクを自動再開します。App Serverの改造・再ビルド・別配布は不要です。
+Steerの初回設定後は`restart_required`（終了コード3）を返します。Codexを完全終了して再起動し、
+`aiterm-setup --codex-steer status`で`ready`を確認してください。接続できない時にキューへ自動退避しません。
+
+選択と復元情報は`~/.config/aiterm-mcp/codex-relay/`へ保存し、ユーザーLaunchAgentがログイン時にも
+起動設定を適用します。更新時の`aiterm-setup --json`は選択を維持して中継を更新します。
+解除・旧版への巻き戻し前は`aiterm-setup --codex-steer disable`を実行してCodexを再起動してください。
+SteerはmacOSのCodex Desktopと同梱CLI 0.154以上に対応します。Steer有効時の宛先は中継で起動したDesktopに限ります。
+Windows・LinuxのSteer付き導入は理由付き`unsupported`を返します。Aiterm単品は従来どおり利用できます。
 
 cloneもビルドも不要。どのクライアントでも公開パッケージを次のコマンドで起動する:
 
@@ -171,7 +191,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.35.0** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
+**状態:** 開発継続中 · 現行公開版 **v0.36.0** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
 
 ### 更新と巻き戻し
 
@@ -205,7 +225,7 @@ 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親は公式受信キュー、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`を完了正本に使う。`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を返さず失敗する。
 
 `agent_launch`・`pty_send`（agent dispatch）・`agent_steer`は任意の`image`（画像ファイルの絶対パスの配列。png/jpg/jpeg/gif/webp）を受ける。aitermが本文末尾へ添付行を付け、どのharnessも自分のfile読取toolでそのpathを画像として開く。呼出し側はharness別の添付手順を覚えない。不正なpathは送信前に拒否する。
 
@@ -518,9 +538,9 @@ SSH先がPowerShellの場合、`mark:true`は現在の標準`PS ...>`プロン
 
 Codex／Claude Codeから子を起動・通常dispatchした後は、別作業へ進むか親のturnを終了するだけでよい。Aitermが完了を観測し、加工前の回答を保存して親へ届ける。waiter、`pty_read`による回答回収、子への送信指示は不要。子は全対応harnessから選べる。
 
-自動配送時はreceiptに`parent_delivery`が付き、`wait_process`／`wait_command`はnullになる。`pty_observe`の`parent_deliveries`で`waiting`、`ready`、`sending`、`submitted`、`failed`、`unknown`を確認できる。`submitted`はCodexのキュー受付またはClaudeのhookへの本文出力を示し、modelの読了ではない。MCP再接続後は未送信の記録を再開し、送信中に接続が切れて結果が分からない場合は本文を保持して`unknown`とする。自動再送はしない。
+自動配送時はreceiptに`parent_delivery`が付き、`wait_process`／`wait_command`はnullになる。`pty_observe`の`parent_deliveries`で`waiting`、`ready`、`sending`、`submitted`、`failed`、`unknown`を確認できる。`submitted`はCodexの公式受信口での受付またはClaudeのhookへの本文出力を示し、modelの読了ではない。MCP再接続後は未送信の記録を再開し、送信中に接続が切れて結果が分からない場合は本文を保持して`unknown`とする。自動再送はしない。
 
-CodexにはMCPの`_meta.threadId`と公式`thread/queue` APIが必要で、Codex CLI 0.154.0で確認している。`aiterm-setup`はインストールされた公式queue入口を確認し、各dispatchでは実際の親threadの受入可否を確認する。Codexのnative sub-agentは外部からのqueue入力を拒否するため、自動配送の親としては未対応。
+単品導入のCodexにはMCPの`_meta.threadId`と公式`thread/queue` APIが必要で、Codex CLI 0.154.0で確認している。`aiterm-setup`はインストールされた公式queue入口を確認し、各dispatchでは実際の親threadの受入可否を確認する。Codexのnative sub-agentは外部からのqueue入力を拒否するため、自動配送の親としては未対応。
 
 Claude Codeは2.1.259以上の対話sessionに対応する。`aiterm-setup`が専用の`PreToolUse`、`PostToolUse`、`SessionEnd`を登録するため、Channelsの起動flagは不要。公式`asyncRewake` hookだけが裏で待ち、親はその間も次のturnへ進める。回答は`Stop hook feedback`として届く。hookのexit 2は親の再開信号であり、子の成功・失敗は本文の`outcome`で区別する。
 
@@ -528,6 +548,8 @@ Claude Codeは2.1.259以上の対話sessionに対応する。`aiterm-setup`が
 
 hookを持たない旧版へ戻す時は、install前に`aiterm-setup --remove-claude-parent-hooks`を実行する。Aiterm専用hookだけを解除し、他製品のhookと設定は保持する。
 
+Claudeをリンク経由の`cwd`から起動した場合も、実体パスに対応する会話記録を参照する。
+
 
 ### トークン削減
 

package/README.md

@@ -40,11 +40,31 @@ WindowsはwingetでPowerShell 7・Git for Windows・psmux、macOSはHomebrewでt
 Ubuntu／Debianはsudoとaptでtmuxを準備する。必要な公式package managerと実行権限は事前に必要。
 他のLinuxでも既存tmuxを利用できるが、自動導入は`unsupported`で停止する。
 既存設定の他サーバーを保持し、JSON設定は変更前の`.aiterm-backup`を残す。
-結果の`status`は`ready`／`unsupported`／`failed`。未検出のAIは`not_detected`とし、全AI未検出は成功にしない。
+結果の`status`は`ready`／`unsupported`／`failed`／`restart_required`。未検出のAIは`not_detected`とし、全AI未検出は成功にしない。
 登録先はglobal packageのNodeとMCP入口の絶対パスで、npm一時cacheやsource checkoutは登録しない。
 更新後も同じ入口を実行し、MCP clientを再起動する。npm install自体はユーザー設定を変更しない。
 公開JSONは`schema: "aiterm.setup-result.v1"`、全体の`status`、端末の`backend`、
-AI別の`integrations`を持つ。失敗時は`reason_code`を付け、終了コードはreadyなら0、それ以外は2となる。
+AI別の`integrations`と選択機能の`codex_steer`を持つ。失敗時は`reason_code`を付け、終了コードはreadyなら0、再起動待ちは3、それ以外は2となる。
+
+
+### Codex DesktopへSteerを有効にする（macOS）
+
+対話実行の`aiterm-setup`で「Aiterm単品」と「Steer付き」を選べます。無人導入では明示します。
+
+```bash
+aiterm-setup --json --codex-steer enable
+```
+
+公式Codex Desktopに同梱されたApp Serverを使い、実行中の親には同じターンへ回答を送り、
+終了後に届いた回答でも同じタスクを自動再開します。App Serverの改造・再ビルド・別配布は不要です。
+Steerの初回設定後は`restart_required`（終了コード3）を返します。Codexを完全終了して再起動し、
+`aiterm-setup --codex-steer status`で`ready`を確認してください。接続できない時にキューへ自動退避しません。
+
+選択と復元情報は`~/.config/aiterm-mcp/codex-relay/`へ保存し、ユーザーLaunchAgentがログイン時にも
+起動設定を適用します。更新時の`aiterm-setup --json`は選択を維持して中継を更新します。
+解除・旧版への巻き戻し前は`aiterm-setup --codex-steer disable`を実行してCodexを再起動してください。
+SteerはmacOSのCodex Desktopと同梱CLI 0.154以上に対応します。Steer有効時の宛先は中継で起動したDesktopに限ります。
+Windows・LinuxのSteer付き導入は理由付き`unsupported`を返します。Aiterm単品は従来どおり利用できます。
 
 No clone or build is required. Each client launches the published package with:
 
@@ -185,7 +205,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.35.0** · 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.36.0** · 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
 
@@ -225,7 +245,7 @@ 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親は公式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への送信は非ブロック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.
 
@@ -513,6 +533,8 @@ continue to use `claude_approval`.
 
 ### Local runtime error snapshot
 
+snapshotの`product_version`は各recordの最終実発生時の版を表す。store v2は旧v1を読み取り、単発記録の版を保持し、複数回の旧集約の版は`unknown`にする。読取りでは状態JSONを書き戻さず、次のロック内更新でv2を保存する。consumerを先に更新し、旧writerの終了後に新writerを使う。v2保存後の旧版への切替は、製品のバックアップ復元を伴う。
+
 `aiterm-runtime-errors snapshot` exposes a machine-readable, product-owned local snapshot for the dotagents factory adapter. Collection is fail-closed unless the canonical dotagents factory-reporter config is schema-exact, its host profile matches the executing OS, and it contains the JSON boolean `collection.enabled: true`; reporting fields are schema-validated but endpoints and credential files are never contacted, and the store performs no network I/O. The only accepted observations are three fixed codes owned by the core boundary (PTY dependency, persistence, and optional vendor launcher). Stored data is limited to fixed templates and aggregate metadata (SHA-256 fingerprint, count, first/last seen, status, and monotonic sequence); exceptions, stderr/stdout, stacks, prompts, terminal/transcript/event bodies, paths, and arbitrary context cannot enter the API. Persisted JSON is revalidated with exact top/record fields and a recomputed fingerprint before explicit DTO projection.
 
 Consumer flow is `aiterm-runtime-errors snapshot`, then `aiterm-runtime-errors ack --cursor N` after durable ingestion. Operators can use `resolve|reopen --fingerprint SHA256`. MCP collection and diagnostic reads run in timeout-bounded child processes, so a FIFO or stalled filesystem cannot block terminal work; child failure emits only the fixed store diagnostic. Store mutation uses a bounded bakery ticket queue: every waiter owns a never-reused ticket containing PID, process-start identity, and an owner token, so dead owners are removed by unique filename without fixed-path reclaim ABA. The queue deadline measures lack of progress by the same head owner, not total wait behind healthy predecessors; normal polling uses the native process-liveness check and validates process-start identity only when a blocker stalls. Worker deadlines use forced termination so a SIGTERM-ignoring child cannot mutate state after timeout. POSIX state is atomically replaced under `$XDG_STATE_HOME/aiterm-mcp/` (default `~/.local/state/aiterm-mcp/`) with owner/mode rechecked on every read. Windows native uses `%LOCALAPPDATA%\aiterm-mcp\`; each DACL is rebuilt and read back as one non-inherited FullControl ACE for the current SID. Windows path/DACL/timeout behavior is covered by pure tests in this change; no new Windows integration success is claimed.
@@ -551,9 +573,9 @@ For PowerShell over SSH, `mark:true` recognizes the current standard `PS ...>` p
 
 **Codex／Claude Code親には子の回答本文が自動で届く。** 子を起動・dispatchした後は、別作業へ進むか親のturnを終える。Aitermが完了を観測し、加工前の本文を保存して親へ渡す。waiter、`pty_read`による回答回収、子への返送指示は不要。子は全対応harnessから選べる。
 
-自動配送のreceiptには`parent_delivery`が付き、`wait_process`／`wait_command`はnullになる。`pty_observe`の`parent_deliveries`で`waiting`、`ready`、`sending`、`submitted`、`failed`、`unknown`を確認できる。`submitted`はCodexのキュー受付またはClaudeのhookへの本文出力を示し、modelの読了ではない。MCP再接続後は未送信の記録を再開し、出力中断で結果が分からない場合は本文を保持して`unknown`とする。自動再送はしない。
+自動配送のreceiptには`parent_delivery`が付き、`wait_process`／`wait_command`はnullになる。`pty_observe`の`parent_deliveries`で`waiting`、`ready`、`sending`、`submitted`、`failed`、`unknown`を確認できる。`submitted`はCodexの公式受信口での受付またはClaudeのhookへの本文出力を示し、modelの読了ではない。MCP再接続後は未送信の記録を再開し、出力中断で結果が分からない場合は本文を保持して`unknown`とする。自動再送はしない。
 
-Use a Codex runtime that supplies MCP `_meta.threadId` and the official `thread/queue` API (verified with Codex CLI 0.154.0). `aiterm-setup` checks the installed queue entry point; Aiterm verifies the requesting thread before each dispatch. Codex native sub-agents reject external queue input and cannot be automatic-delivery parents. Ordinary CLI and Desktop parents use the same supported route.
+For queue delivery, use a Codex runtime that supplies MCP `_meta.threadId` and the official `thread/queue` API (verified with Codex CLI 0.154.0). `aiterm-setup` checks the installed queue entry point; Aiterm verifies the requesting thread before each dispatch. Codex native sub-agents reject external queue input and cannot be automatic-delivery parents. This queue route applies when Desktop Steer is not enabled.
 
 Claude Codeは2.1.259以上の対話sessionに対応する。`aiterm-setup`が専用の`PreToolUse`、`PostToolUse`、`SessionEnd`を登録するため、Channelsの起動flagは不要。公式`asyncRewake` hookだけが裏で待ち、親はその間も次のturnへ進める。回答は`Stop hook feedback`として届く。hookのexit 2は親の再開信号であり、子の成功・失敗は本文の`outcome`で区別する。
 
@@ -561,6 +583,8 @@ Claude Codeは2.1.259以上の対話sessionに対応する。`aiterm-setup`が
 
 hookを持たない旧版へ戻す時は、install前に`aiterm-setup --remove-claude-parent-hooks`を実行する。Aiterm専用hookだけを解除し、他製品のhookと設定は保持する。
 
+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.

package/dist/codex-delivery-error.js

@@ -0,0 +1,10 @@
+import { AitermError } from "./errors.js";
+export class CodexDeliveryError extends AitermError {
+    delivery_code;
+    outcome_unknown;
+    constructor(delivery_code, message, outcome_unknown = false) {
+        super(`${delivery_code}: ${message}`, 2);
+        this.delivery_code = delivery_code;
+        this.outcome_unknown = outcome_unknown;
+    }
+}

package/dist/codex-parent-receiver.js

@@ -1,19 +1,13 @@
-// Codex親の公式受信キューへの接続。親threadのload／resumeやDesktop固有通信は行わない。
+// Codex親の配送。Steerを選択した環境は同じ公式App Server、それ以外は公式queueを使う。
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 import * as path from "node:path";
 import { resolveAgentBin } from "./agent-resolver.js";
 import { realCodexHome } from "./harnesses/codex.js";
-import { AitermError } from "./errors.js";
-export class CodexDeliveryError extends AitermError {
-    delivery_code;
-    outcome_unknown;
-    constructor(delivery_code, message, outcome_unknown = false) {
-        super(`${delivery_code}: ${message}`, 2);
-        this.delivery_code = delivery_code;
-        this.outcome_unknown = outcome_unknown;
-    }
-}
+import { CodexDeliveryError } from "./codex-delivery-error.js";
+import { readRelayConfig, parentRelaySocket } from "./codex-relay-config.js";
+import { withCodexRelay, verifyLoadedParent } from "./codex-relay-client.js";
+export { CodexDeliveryError } from "./codex-delivery-error.js";
 /** modelの引数ではなく、CodexがMCP要求へ付けるmetadataだけを宛先にする。 */
 export function codexParentFromRequest(clientName, metadata) {
     if (clientName !== "codex-mcp-client")
@@ -24,6 +18,12 @@ export function codexParentFromRequest(clientName, metadata) {
     }
     return { thread_id: threadId, codex_home: path.resolve(realCodexHome()) };
 }
+function relaySocket(runtime) {
+    if (runtime)
+        return runtime.socket_path ?? null;
+    const config = readRelayConfig();
+    return config?.enabled ? parentRelaySocket(config) : null;
+}
 async function withCodexReceiver(parent, action, runtime = {}) {
     const executable = runtime.executable ?? resolveAgentBin("codex");
     if (!executable)
@@ -108,6 +108,11 @@ async function withCodexReceiver(parent, action, runtime = {}) {
 }
 /** 子へ送る前に、同じstoreの宛先と公式キューの対応を確認する。本文は保存・表示しない。 */
 export async function verifyCodexParent(parent, runtime) {
+    const socket = relaySocket(runtime);
+    if (socket) {
+        await withCodexRelay(socket, request => verifyLoadedParent(request, parent.thread_id), runtime?.timeout_ms);
+        return;
+    }
     await withCodexReceiver(parent, async (request) => {
         const response = await request("thread/read", { threadId: parent.thread_id, includeTurns: false });
         if (response?.thread?.id !== parent.thread_id) {
@@ -121,6 +126,19 @@ export async function verifyCodexParent(parent, runtime) {
     }, runtime);
 }
 export async function submitCodexParentAnswer(parent, deliveryId, text, runtime) {
+    const socket = relaySocket(runtime);
+    if (socket) {
+        return withCodexRelay(socket, async (request) => {
+            await verifyLoadedParent(request, parent.thread_id);
+            // 公式の同一処理内で、実行中はSteer、終了済みなら開始する。本文は一度だけ送る。
+            const result = await request("turn/start", { threadId: parent.thread_id,
+                input: [{ type: "text", text, text_elements: [] }], clientUserMessageId: deliveryId });
+            if (typeof result?.turn?.id !== "string" || !result.turn.id) {
+                throw new CodexDeliveryError("CODEX_RECEIVER_INVALID_RESPONSE", "配送先turnの受付IDを確認できません", true);
+            }
+            return { queued_submission_id: null };
+        }, runtime?.timeout_ms);
+    }
     return withCodexReceiver(parent, async (request) => {
         const result = await request("thread/queue/add", {
             threadId: parent.thread_id,

package/dist/codex-relay-client.js

@@ -0,0 +1,110 @@
+import { createConnection } from "node:net";
+import WebSocket from "ws";
+import { CodexDeliveryError } from "./codex-delivery-error.js";
+import { verifyRelaySocket } from "./codex-relay-config.js";
+/** 公式受付へ追加接続する。Desktopへの承認要求や通知には応答しない。 */
+export async function withCodexRelay(socketPath, action, timeout = 15_000) {
+    try {
+        verifyRelaySocket(socketPath);
+    }
+    catch (error) {
+        if (error instanceof CodexDeliveryError)
+            throw error;
+        throw new CodexDeliveryError("CODEX_RELAY_UNAVAILABLE", "公式App Serverのsocketがありません。Codexを再起動してください");
+    }
+    const socket = new WebSocket("ws://localhost/rpc", {
+        createConnection: () => createConnection(socketPath), handshakeTimeout: timeout, perMessageDeflate: false,
+    });
+    let sequence = 0;
+    let failure = null;
+    const pending = new Map();
+    const fail = (message) => {
+        failure = message;
+        for (const item of pending.values()) {
+            clearTimeout(item.timer);
+            item.reject(new CodexDeliveryError("CODEX_RELAY_TRANSPORT_FAILED", message, item.writing));
+        }
+        pending.clear();
+    };
+    socket.on("error", () => fail("公式App Serverとの通信が失敗しました"));
+    socket.on("close", () => fail("公式App Serverとの接続が終了しました"));
+    socket.on("message", (data, binary) => {
+        let value;
+        try {
+            if (binary)
+                throw new Error();
+            value = JSON.parse(data.toString());
+        }
+        catch {
+            fail("公式App ServerのJSON応答を読めません");
+            return;
+        }
+        if (value?.method !== undefined)
+            return;
+        const item = pending.get(value?.id);
+        if (!item)
+            return;
+        clearTimeout(item.timer);
+        pending.delete(value.id);
+        if (value.error)
+            item.reject(new CodexDeliveryError("CODEX_RECEIVER_REJECTED", typeof value.error.message === "string" ? value.error.message : "公式受信口が要求を拒否しました"));
+        else if ("result" in value)
+            item.resolve(value.result);
+        else
+            item.reject(new CodexDeliveryError("CODEX_RECEIVER_INVALID_RESPONSE", "公式受信口の応答にresultがありません", item.writing));
+    });
+    const request = (method, params) => new Promise((resolve, reject) => {
+        if (failure || socket.readyState !== WebSocket.OPEN) {
+            reject(new CodexDeliveryError("CODEX_RELAY_UNAVAILABLE", failure ?? "接続が開いていません"));
+            return;
+        }
+        const id = ++sequence;
+        const writing = method === "turn/start";
+        const timer = setTimeout(() => {
+            pending.delete(id);
+            reject(new CodexDeliveryError("CODEX_RECEIVER_TIMEOUT", `${method}の応答を確認できません`, writing));
+        }, timeout);
+        pending.set(id, { resolve, reject, timer, writing });
+        socket.send(JSON.stringify({ id, method, params }), error => { if (error)
+            fail("公式App Serverへの送信に失敗しました"); });
+    });
+    try {
+        await new Promise((resolve, reject) => {
+            socket.once("open", resolve);
+            socket.once("error", () => reject(new CodexDeliveryError("CODEX_RELAY_UNAVAILABLE", "公式App Serverへ接続できません")));
+            socket.once("close", () => reject(new CodexDeliveryError("CODEX_RELAY_UNAVAILABLE", "公式App Serverが接続を閉じました")));
+        });
+        await request("initialize", { clientInfo: { name: "aiterm_parent_delivery", version: "1" } });
+        socket.send(JSON.stringify({ method: "initialized" }));
+        return await action(request);
+    }
+    finally {
+        for (const item of pending.values())
+            clearTimeout(item.timer);
+        pending.clear();
+        socket.terminate();
+    }
+}
+export async function verifyLoadedParent(request, threadId) {
+    let cursor = null;
+    do {
+        const result = await request("thread/loaded/list", { limit: 100, ...(cursor ? { cursor } : {}) });
+        if (!Array.isArray(result?.data))
+            throw new CodexDeliveryError("CODEX_RECEIVER_INVALID_RESPONSE", "実行中taskの一覧を確認できません");
+        if (result.data.includes(threadId)) {
+            const read = await request("thread/read", { threadId, includeTurns: false });
+            if (read?.thread?.id !== threadId)
+                throw new CodexDeliveryError("CODEX_PARENT_UNAVAILABLE", "親taskの識別が一致しません");
+            const subagent = read.thread.source?.subAgent;
+            if (subagent && typeof subagent === "object" && "thread_spawn" in subagent) {
+                throw new CodexDeliveryError("CODEX_PARENT_UNSUPPORTED", "Codexのnative sub-agentは外部processからの直接入力を受け付けません");
+            }
+            return;
+        }
+        const next = result.nextCursor ?? null;
+        if (next !== null && (typeof next !== "string" || next === cursor))
+            throw new CodexDeliveryError("CODEX_RECEIVER_INVALID_RESPONSE", "task一覧の続きが不正です");
+        cursor = next;
+    } while (cursor);
+    throw new CodexDeliveryError("CODEX_PARENT_UNAVAILABLE", "同じ公式App Serverに親taskがありません。別processでのresumeやqueueへの退避は行いません");
+}

package/dist/codex-relay-config.js

@@ -0,0 +1,66 @@
+// Aitermの選択設定と、同じ親processが所有する公式socketの識別。
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+import { z } from "zod";
+import { readRuntimeProcesses } from "./process-runtime.js";
+import { CodexDeliveryError } from "./codex-delivery-error.js";
+export const relayConfigSchema = z.object({
+    schema: z.literal("aiterm.codex-relay.v1"),
+    enabled: z.boolean(),
+    binary: z.string(), node: z.string(), launcher: z.string(), socket_root: z.string(),
+    previous_cli_path: z.string().nullable(),
+}).strict();
+export function relayConfigDirectory(home = process.env.HOME ?? homedir()) {
+    return path.join(home, ".config", "aiterm-mcp", "codex-relay");
+}
+export function readRelayConfig(directory = relayConfigDirectory()) {
+    const file = path.join(directory, "config.json");
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    try {
+        return relayConfigSchema.parse(JSON.parse(text));
+    }
+    catch {
+        throw new CodexDeliveryError("CODEX_RELAY_CONFIG_INVALID", "Steerの設定を読めません。aiterm-setup --codex-steer statusで確認してください");
+    }
+}
+export function prepareRelayDirectory(directory) {
+    if (!path.isAbsolute(directory))
+        throw new CodexDeliveryError("CODEX_RELAY_PATH_INVALID", "socketディレクトリが絶対pathではありません");
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const stat = fs.lstatSync(directory);
+    if (!stat.isDirectory() || stat.uid !== process.getuid?.() || (stat.mode & 0o777) !== 0o700) {
+        throw new CodexDeliveryError("CODEX_RELAY_PATH_INVALID", "socketディレクトリは本人所有の0700である必要があります");
+    }
+}
+export function verifyRelaySocket(socket) {
+    const directory = fs.lstatSync(path.dirname(socket));
+    const stat = fs.lstatSync(socket);
+    if (!directory.isDirectory() || directory.uid !== process.getuid?.() || (directory.mode & 0o777) !== 0o700
+        || !stat.isSocket() || stat.uid !== process.getuid?.() || (stat.mode & 0o777) !== 0o600) {
+        throw new CodexDeliveryError("CODEX_RELAY_PATH_INVALID", "本人所有の公式socketを確認できません");
+    }
+}
+export function parentRelaySocket(config, processes = readRuntimeProcesses(), pid = process.pid) {
+    const rows = new Map(processes.map(row => [row.pid, row]));
+    const seen = new Set();
+    let current = rows.get(pid)?.parent_pid;
+    while (current && !seen.has(current)) {
+        seen.add(current);
+        const socket = path.join(config.socket_root, `${current}.sock`);
+        if (fs.existsSync(socket)) {
+            verifyRelaySocket(socket);
+            return socket;
+        }
+        current = rows.get(current)?.parent_pid;
+    }
+    throw new CodexDeliveryError("CODEX_STEER_RESTART_REQUIRED", "Steerを有効にしたCodex Desktopの親接続がありません。aiterm-setupの結果を確認し、Codexを再起動してください");
+}

package/dist/codex-relay-launcher.js

@@ -0,0 +1,63 @@
+// POSIXのexecで公式CLIのPIDとDesktopからの親子関係を維持する。
+const quote = (text) => `'${text.replace(/'/g, `'"'"'`)}'`;
+export function codexRelayLauncher(options) {
+    return `#!/bin/sh
+binary=${quote(options.binary)}
+node=${quote(options.node)}
+relay=${quote(options.relay)}
+root=${quote(options.socket_root)}
+mode=root
+value=no
+for arg do
+  if [ "$value" = yes ]; then value=no; continue; fi
+  case "$arg" in
+    -c|--config|--enable|--disable|--listen) value=yes; continue ;;
+  esac
+  if [ "$mode" = root ]; then
+    case "$arg" in
+      --config=*|--enable=*|--disable=*|-c?*) ;;
+      app-server) mode=server ;;
+      *) mode=other; break ;;
+    esac
+  else
+    case "$arg" in
+      proxy|start|stop|status|generate-ts|generate-json-schema|--help|-h|--version|-V) mode=other; break ;;
+    esac
+  fi
+done
+if [ "$mode" != server ]; then exec "$binary" "$@"; fi
+
+# 引数を一巡させ、stdio指定だけを公式Unix受付へ変更する。
+remaining=$#
+value=no
+while [ "$remaining" -gt 0 ]; do
+  arg=$1
+  shift
+  remaining=$((remaining - 1))
+  if [ "$value" = yes ]; then
+    set -- "$@" "$arg"
+    value=no
+    continue
+  fi
+  case "$arg" in
+    -c|--config|--enable|--disable) value=yes; set -- "$@" "$arg" ;;
+    --stdio) ;;
+    --listen)
+      if [ "$remaining" -eq 0 ] || [ "$1" != stdio:// ]; then
+        echo 'aiterm-relay: stdio以外の接続指定は変更できません' >&2
+        exit 2
+      fi
+      shift
+      remaining=$((remaining - 1)) ;;
+    --listen=stdio://) ;;
+    --listen=*) echo 'aiterm-relay: stdio以外の接続指定は変更できません' >&2; exit 2 ;;
+    *) set -- "$@" "$arg" ;;
+  esac
+done
+"$node" "$relay" --prepare "$root" || exit $?
+socket="$root/$$.sock"
+exec 3<&0
+"$node" "$relay" "$socket" "$$" <&3 3<&- &
+exec "$binary" "$@" --listen "unix://$socket" </dev/null >/dev/null 3<&-
+`;
+}

package/dist/codex-relay-login.js

@@ -0,0 +1,47 @@
+// ユーザーのログイン時にもCodexの起動設定を適用する、Aiterm専用LaunchAgent。
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+import { spawnSync } from "node:child_process";
+import { SetupError } from "./setup-platform.js";
+const label = "dev.kitepon.aiterm-codex-relay";
+const xml = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+export function relayLoginPlist(launcher) {
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0"><dict><key>Label</key><string>${label}</string><key>ProgramArguments</key><array><string>/bin/launchctl</string><string>setenv</string><string>CODEX_CLI_PATH</string><string>${xml(launcher)}</string></array><key>RunAtLoad</key><true/></dict></plist>\n`;
+}
+function context(options) {
+    const directory = options.directory ?? path.join(process.env.HOME ?? homedir(), "Library", "LaunchAgents");
+    const uid = options.uid ?? process.getuid?.();
+    if (uid === undefined)
+        throw new SetupError("codex_steer_platform_unsupported", "LaunchAgentはmacOSだけで使用します");
+    const run = options.run ?? ((args) => {
+        const result = spawnSync("/bin/launchctl", args, { encoding: "utf8", timeout: 10_000 });
+        if (result.error)
+            throw new SetupError("codex_steer_login_failed", "ログイン時の起動設定を実行できません");
+        return result.status ?? -1;
+    });
+    return { directory, file: path.join(directory, `${label}.plist`), domain: `gui/${uid}`, service: `gui/${uid}/${label}`, run };
+}
+export function installRelayLogin(launcher, options = {}) {
+    const { directory, file, domain, service, run } = context(options);
+    const contents = relayLoginPlist(launcher);
+    if (fs.existsSync(file) && (fs.lstatSync(file).isSymbolicLink() || fs.readFileSync(file, "utf8") !== contents)) {
+        throw new SetupError("codex_steer_login_conflict", "同名のLaunchAgentが変更されています。所有外の設定は上書きしません");
+    }
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    if (!fs.existsSync(file))
+        fs.writeFileSync(file, contents, { mode: 0o600, flag: "wx" });
+    if (run(["print", service]) !== 0 && run(["bootstrap", domain, file]) !== 0)
+        throw new SetupError("codex_steer_login_failed", "ログイン時のSteer設定を登録できません");
+}
+export function removeRelayLogin(launcher, options = {}) {
+    const { file, service, run } = context(options);
+    if (!fs.existsSync(file))
+        return;
+    if (fs.lstatSync(file).isSymbolicLink() || fs.readFileSync(file, "utf8") !== relayLoginPlist(launcher)) {
+        throw new SetupError("codex_steer_login_conflict", "変更されたLaunchAgentは削除しません");
+    }
+    if (run(["print", service]) === 0 && run(["bootout", service]) !== 0)
+        throw new SetupError("codex_steer_login_failed", "ログイン時のSteer設定を解除できません");
+    fs.unlinkSync(file);
+}

package/dist/codex-stdio-relay.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+// DesktopのJSONLと公式App ServerのUnix WebSocketの中継。RPCの内容は変更しない。
+import { createConnection } from "node:net";
+import { createInterface } from "node:readline";
+import { setTimeout as delay } from "node:timers/promises";
+import { once } from "node:events";
+import { fileURLToPath } from "node:url";
+import WebSocket from "ws";
+import { prepareRelayDirectory } from "./codex-relay-config.js";
+export async function runCodexStdioRelay(socketPath, serverPid) {
+    let socket;
+    let ending = false;
+    let stopping;
+    function stopServer() {
+        return stopping ??= (async () => {
+            // 公式Unix受付は1回目でturn完了待ち、2回目で終了する。
+            for (let i = 0; i < 2; i++) {
+                if (process.ppid !== serverPid)
+                    return;
+                try {
+                    process.kill(serverPid, "SIGTERM");
+                }
+                catch (error) {
+                    if (error.code === "ESRCH")
+                        return;
+                    throw error;
+                }
+                if (i === 0)
+                    await delay(100);
+            }
+        })();
+    }
+    async function connectDuringStartup() {
+        const deadline = Date.now() + 15_000;
+        while (true) {
+            if (process.ppid !== serverPid)
+                throw new Error("公式App Serverが起動中に終了しました");
+            const candidate = new WebSocket("ws://localhost/rpc", {
+                createConnection: () => createConnection(socketPath), handshakeTimeout: 10_000, perMessageDeflate: false,
+            });
+            try {
+                await once(candidate, "open");
+                return candidate;
+            }
+            catch (error) {
+                candidate.on("error", () => { });
+                candidate.terminate();
+                // exec直後のsocket作成だけを待つ。送信済みRPCは再送しない。
+                if (!["ENOENT", "ECONNREFUSED"].includes(error.code ?? "") || Date.now() >= deadline)
+                    throw error;
+                await delay(25);
+            }
+        }
+    }
+    try {
+        socket = await connectDuringStartup();
+        const connected = socket;
+        connected.on("message", (data, binary) => {
+            if (binary) {
+                process.stderr.write("aiterm-relay: 予期しないバイナリ応答\n");
+                process.exitCode = 1;
+                void stopServer();
+                connected.terminate();
+                return;
+            }
+            if (!process.stdout.write(`${data.toString()}\n`))
+                connected.pause();
+        });
+        process.stdout.on("drain", () => connected.resume());
+        connected.on("error", () => {
+            process.stderr.write("aiterm-relay: 通信に失敗しました\n");
+            process.exitCode = 1;
+            void stopServer();
+        });
+        connected.on("close", () => {
+            if (!ending) {
+                process.stderr.write("aiterm-relay: 公式App Serverとの接続が終了しました\n");
+                process.exitCode = 1;
+            }
+            process.stdin.destroy();
+        });
+        process.stdout.on("error", () => { ending = true; void stopServer(); connected.terminate(); process.stdin.destroy(); });
+        const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });
+        for await (const line of lines) {
+            await new Promise((resolve, reject) => connected.send(line, error => error ? reject(error) : resolve()));
+        }
+        ending = true;
+        await stopServer();
+        connected.terminate();
+    }
+    catch (error) {
+        process.stderr.write(`aiterm-relay: 中継失敗: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+        await stopServer();
+        socket?.terminate();
+        process.stdin.destroy();
+    }
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    const [socket, pid] = process.argv.slice(2);
+    if (socket === "--prepare") {
+        try {
+            if (process.platform === "win32")
+                throw new Error("WindowsのAF_UNIX中継は未対応です");
+            if (!pid || Buffer.byteLength(`${pid}/9999999999.sock`) >= 104)
+                throw new Error("socketのpathが長すぎます");
+            prepareRelayDirectory(pid);
+        }
+        catch (error) {
+            process.stderr.write(`aiterm-relay: ${error instanceof Error ? error.message : String(error)}\n`);
+            process.exitCode = 2;
+        }
+    }
+    else if (!socket || !/^\d+$/.test(pid ?? "") || Number(pid) <= 1 || Number(pid) !== process.ppid) {
+        process.stderr.write("aiterm-relay: 親processの指定が不正です\n");
+        process.exitCode = 2;
+    }
+    else
+        await runCodexStdioRelay(socket, Number(pid));
+}

package/dist/harnesses/claude.js

@@ -224,6 +224,8 @@ export function claudeStartupAction(screen, trustProject) {
 // submit座礁観測のcomposer領域マーカー（ready判定と同じ記号を行頭基準で探す）。
 export const CLAUDE_COMPOSER_MARKER_RE = /^\s*❯/;
 export function createClaudeAgentMetadata(name, cwd, initialPrompt, launchOperationId, launchRequestDigest, lineageContext, model, effort) {
+    // Claude Codeはリンクを解決したcwdでproject slugを作る。起動時に固定し、記録の監視時に再解決しない。
+    const transcriptCwd = cwd === null ? null : fs.realpathSync(cwd);
     const launchId = randomBytes(16).toString("hex");
     const eventFile = agentEventPath(name, launchId);
     const resultFile = agentClaudeResultPath(name, launchId);
@@ -236,7 +238,7 @@ export function createClaudeAgentMetadata(name, cwd, initialPrompt, launchOperat
         launch_id: launchId,
         event_file: eventFile,
         created_at: new Date().toISOString(),
-        cwd,
+        cwd: transcriptCwd,
         vendor_session_id: randomUUID(),
         initial_prompt: initialPrompt,
         launch_operation_id: launchOperationId,

package/dist/parent-delivery.js

@@ -235,7 +235,7 @@ export class ParentDeliveryManager {
             }
             record.state = "ready";
             this.save(job);
-            // 次の依頼へ進める時点は本文保存まで。親のキュー受付を待たせない。
+            // 次の依頼へ進める時点は本文保存まで。親の受付を待たせない。
             job.delivery = this.deliver(job).catch((error) => this.reportServiceError(error));
         })();
         return job.capture;
@@ -368,7 +368,7 @@ export class ParentDeliveryManager {
                 this.jobs.set(record.delivery_id, job);
                 if (record.state === "sending") {
                     record.state = "unknown";
-                    record.error = "PARENT_DELIVERY_INTERRUPTED: キュー送信中にMCP processが終了しました。自動再送はしていません";
+                    record.error = "PARENT_DELIVERY_INTERRUPTED: 回答送信中にMCP processが終了しました。自動再送はしていません";
                     this.finish(job);
                 }
                 else if (record.state === "waiting" || record.state === "ready") {

package/dist/runtime-error-store.js

@@ -7,7 +7,7 @@ import { defaultRuntimeErrorPaths, windowsPrivateDaclCommand, expectedHostProfil
 export { defaultRuntimeErrorPaths, windowsPrivateDaclCommand, windowsPrivateDaclVerifyCommand } from "./runtime-error-os.js";
 import { fileURLToPath } from "node:url";
 const pkg = createRequire(import.meta.url)("../package.json");
-const STORE_SCHEMA = "aiterm-mcp.runtime-errors.v1";
+const STORE_SCHEMA = "aiterm-mcp.runtime-errors.v2";
 const STATE_SCHEMA = "1.0";
 const MAX_CONFIG_BYTES = 16 * 1024;
 const MAX_STORE_BYTES = 1024 * 1024;
@@ -241,9 +241,17 @@ export class RuntimeErrorStore {
                 return EMPTY_STATE();
             throw error;
         }
-        const state = validateState(JSON.parse(text), this.maxRecords);
+        const value = JSON.parse(text);
+        const legacy = isObject(value) && value.schema_version === "aiterm-mcp.runtime-errors.v1";
+        const state = validateState(legacy ? { ...value, schema_version: STORE_SCHEMA } : value, this.maxRecords);
         if (!state)
             throw new Error("runtime error store schema が不正です");
+        // 旧集約は初回版だけを保持した。複数回発生した記録の最終発生版は復元できない。
+        if (legacy)
+            for (const record of state.records) {
+                if (record.occurrence_count > 1)
+                    record.product_version = "unknown";
+            }
         return state;
     }
     applyWindowsDacl(target, kind) {
@@ -542,6 +550,7 @@ export class RuntimeErrorStore {
             const seen = this.now().toISOString();
             const sequence = state.cursor + 1;
             if (record) {
+                record.product_version = this.productVersion;
                 record.occurrence_count += 1;
                 record.last_seen = seen;
                 record.status = "open";

package/dist/setup-cli.js

@@ -3,6 +3,9 @@ import { runSetup } from "./setup.js";
 import { removeClaudeParentHooks } from "./setup-integrations.js";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { configureCodexSteer } from "./setup-codex-relay.js";
+import { readRelayConfig } from "./codex-relay-config.js";
 const args = process.argv.slice(2);
 if (args.length === 1 && args[0] === "--remove-claude-parent-hooks") {
     try {
@@ -15,14 +18,42 @@ if (args.length === 1 && args[0] === "--remove-claude-parent-hooks") {
     }
 }
 else if (args.length === 1 && ["--help", "-h"].includes(args[0])) {
-    process.stdout.write("使い方: aiterm-setup [--json | --remove-claude-parent-hooks]\n製品の依存準備、検出したAIへの登録、MCPと端末の実動作確認を行います。結果はJSONで返します。旧版へ戻す前の専用hook解除も、この入口で行います。\n");
-}
-else if (args.length > 1 || (args.length === 1 && args[0] !== "--json")) {
-    process.stderr.write("使い方: aiterm-setup [--json]\n");
-    process.exitCode = 2;
+    process.stdout.write("使い方: aiterm-setup [--json] [--codex-steer enable|disable|status]\n依存準備、AIへの登録、MCPと端末の実動作確認を行います。対話実行ではAiterm単品かCodex Desktop Steer付きかを選べます。SteerはmacOS対応で、初回はCodexの再起動が必要です。disableは元の起動設定へ戻し、statusは実際の接続を確認します。--jsonは対話せず、Steerの選択を維持します。\n旧版へ戻す前のClaude専用hook解除: --remove-claude-parent-hooks\n");
 }
 else {
-    const result = await runSetup();
-    process.stdout.write(`${JSON.stringify(result)}\n`);
-    process.exitCode = result.status === "ready" ? 0 : 2;
+    try {
+        let action;
+        let json = false;
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] === "--json" && !json)
+                json = true;
+            else if (args[i] === "--codex-steer" && !action && ["enable", "disable", "status"].includes(args[i + 1]))
+                action = args[++i];
+            else
+                throw new Error("使い方: aiterm-setup [--json] [--codex-steer enable|disable|status]");
+        }
+        const onlySteer = action === "disable" || action === "status";
+        if (!action && !json && process.stdin.isTTY && process.stderr.isTTY && process.platform === "darwin") {
+            const enabled = readRelayConfig()?.enabled ?? false;
+            const prompt = createInterface({ input: process.stdin, output: process.stderr });
+            try {
+                const answer = (await prompt.question(`導入方法: 1=Aiterm単品（公式キュー配送）、2=Codex DesktopへSteerと終了後再開を有効化 [${enabled ? "2" : "1"}]: `)).trim();
+                if (answer && !["1", "2"].includes(answer))
+                    throw new Error("導入方法は1または2で指定してください");
+                action = (answer || (enabled ? "2" : "1")) === "2" ? "enable" : "disable";
+            }
+            finally {
+                prompt.close();
+            }
+        }
+        const result = onlySteer
+            ? { schema: "aiterm.codex-steer-result.v1", ...await configureCodexSteer(action) }
+            : await runSetup({ codex_steer: action });
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        process.exitCode = ["ready", "disabled"].includes(result.status) ? 0 : result.status === "restart_required" ? 3 : 2;
+    }
+    catch (error) {
+        process.stderr.write(`aiterm-setup: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 2;
+    }
 }

package/dist/setup-codex-relay.js

@@ -0,0 +1,184 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { tmpdir } from "node:os";
+import { spawn, spawnSync } from "node:child_process";
+import { createInterface } from "node:readline";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+import { SetupError } from "./setup-platform.js";
+import { CodexDeliveryError } from "./codex-delivery-error.js";
+import { readRelayConfig, relayConfigDirectory, prepareRelayDirectory } from "./codex-relay-config.js";
+import { codexRelayLauncher } from "./codex-relay-launcher.js";
+import { withCodexRelay } from "./codex-relay-client.js";
+import { readRuntimeProcesses } from "./process-runtime.js";
+import { installRelayLogin, removeRelayLogin } from "./codex-relay-login.js";
+function command(executable, args) {
+    const result = spawnSync(executable, args, { encoding: "utf8", timeout: 15_000 });
+    if (result.error || result.status !== 0)
+        throw new SetupError("codex_steer_setup_failed", `${path.basename(executable)}を実行できません`);
+    return result.stdout.trim();
+}
+function getGui(key) {
+    const result = spawnSync("/bin/launchctl", ["getenv", key], { encoding: "utf8", timeout: 5_000 });
+    if (result.status === 1 && !result.stderr.trim())
+        return null;
+    if (result.error || result.status !== 0)
+        throw new SetupError("codex_steer_environment_unavailable", "GUIの起動設定を確認できません");
+    return result.stdout.trim() || null;
+}
+function findDesktopBinary() {
+    const search = spawnSync("/usr/bin/mdfind", ["kMDItemCFBundleIdentifier == 'com.openai.codex'"], { encoding: "utf8", timeout: 10_000 });
+    const candidates = [...new Set(["/Applications/Codex.app", "/Applications/ChatGPT.app", ...(search.status === 0 ? search.stdout.trim().split("\n") : [])])];
+    const found = candidates.filter(app => {
+        if (!app || !fs.existsSync(path.join(app, "Contents", "Resources", "codex")))
+            return false;
+        const result = spawnSync("/usr/libexec/PlistBuddy", ["-c", "Print:CFBundleIdentifier", path.join(app, "Contents", "Info.plist")], { encoding: "utf8", timeout: 5_000 });
+        return result.status === 0 && result.stdout.trim() === "com.openai.codex";
+    });
+    if (found.length !== 1)
+        throw new SetupError("codex_desktop_not_identified", "Codex Desktopのインストール先を一つに特定できません");
+    const binary = path.join(found[0], "Contents", "Resources", "codex");
+    command("/usr/bin/codesign", ["--verify", "--strict", binary]);
+    const version = command(binary, ["--version"]);
+    const match = /codex-cli (\d+)\.(\d+)\.(\d+)/.exec(version);
+    if (!match || (Number(match[1]) === 0 && Number(match[2]) < 154)) {
+        throw new SetupError("codex_version_unsupported", "SteerにはCodex CLI 0.154以上を同梱したCodex Desktopが必要です");
+    }
+    return binary;
+}
+/** 模擬HOMEで起動・initialize・終了を確認する。利用者の認証やtaskは使わない。 */
+export async function verifyRelayLauncher(launcher) {
+    const temporary = fs.mkdtempSync(path.join(tmpdir(), "aiterm-relay-setup-"));
+    fs.mkdirSync(path.join(temporary, ".codex"));
+    const child = spawn(launcher, ["-c", 'cli_auth_credentials_store="file"', "-c", 'mcp_oauth_credentials_store="file"', "app-server"], {
+        env: { ...process.env, HOME: temporary, CODEX_HOME: path.join(temporary, ".codex") }, stdio: ["pipe", "pipe", "ignore"],
+    });
+    const reader = createInterface({ input: child.stdout });
+    const exited = new Promise(resolve => child.once("close", resolve));
+    try {
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new SetupError("codex_relay_probe_failed", "中継経由の公式受付を確認できません")), 20_000);
+            const fail = () => { clearTimeout(timer); reject(new SetupError("codex_relay_probe_failed", "中継経由の公式起動に失敗しました")); };
+            child.once("error", fail);
+            child.once("close", fail);
+            child.stdin.once("error", fail);
+            reader.on("line", line => {
+                try {
+                    const value = JSON.parse(line);
+                    if (value.id !== 1 || value.method)
+                        return;
+                    clearTimeout(timer);
+                    if (!value.result || value.error)
+                        fail();
+                    else
+                        resolve();
+                }
+                catch {
+                    fail();
+                }
+            });
+            child.stdin.write(JSON.stringify({ id: 1, method: "initialize", params: { clientInfo: { name: "aiterm_setup", version: "1" } } }) + "\n");
+        });
+    }
+    finally {
+        child.stdin.end();
+        const timer = setTimeout(() => child.kill("SIGKILL"), 2_000);
+        const code = await exited;
+        clearTimeout(timer);
+        reader.close();
+        fs.rmSync(temporary, { recursive: true, force: true });
+        if (code !== 0)
+            throw new SetupError("codex_relay_probe_failed", "中継の終了を確認できません");
+    }
+}
+export async function liveRelay(config) {
+    if (!fs.existsSync(config.socket_root))
+        return false;
+    const processes = readRuntimeProcesses();
+    const rows = new Map(processes.map(row => [row.pid, row]));
+    const desktopPrefix = path.join(path.dirname(path.dirname(config.binary)), "MacOS") + path.sep;
+    for (const name of fs.readdirSync(config.socket_root).filter(name => /^\d+\.sock$/.test(name))) {
+        const server = rows.get(Number(name.slice(0, -5)));
+        const desktop = server && rows.get(server.parent_pid);
+        if (!server || !(server.command === config.binary || server.command.startsWith(config.binary + " "))
+            || !desktop?.command.startsWith(desktopPrefix))
+            continue;
+        try {
+            await withCodexRelay(path.join(config.socket_root, name), async (request) => { await request("thread/loaded/list", { limit: 1 }); }, 1_000);
+            return true;
+        }
+        catch (error) {
+            // 終了済みsocketだけをreadyの証拠から外す。権限・protocolエラーはそのまま返す。
+            if (!(error instanceof CodexDeliveryError) || error.delivery_code !== "CODEX_RELAY_UNAVAILABLE")
+                throw error;
+        }
+    }
+    return false;
+}
+function writeConfig(directory, config) {
+    const temporary = path.join(directory, `${randomUUID()}.tmp`);
+    fs.writeFileSync(temporary, JSON.stringify(config, null, 2) + "\n", { mode: 0o600, flag: "wx" });
+    fs.renameSync(temporary, path.join(directory, "config.json"));
+}
+export async function configureCodexSteer(action = "status", overrides = {}) {
+    const runtime = {
+        platform: process.platform, directory: relayConfigDirectory(), socket_root: `/tmp/aiterm-codex-${process.getuid?.() ?? 0}`,
+        node: process.execPath, relay: fileURLToPath(new URL("./codex-stdio-relay.js", import.meta.url)),
+        findBinary: findDesktopBinary, getGui,
+        setGui: (key, value) => { command("/bin/launchctl", value === null ? ["unsetenv", key] : ["setenv", key, value]); },
+        persist: installRelayLogin, unpersist: removeRelayLogin,
+        verify: verifyRelayLauncher, live: liveRelay, ...overrides,
+    };
+    if (runtime.platform !== "darwin") {
+        return action === "enable" ? { status: "unsupported", reason_code: "codex_steer_platform_unsupported" } : { status: "disabled" };
+    }
+    const previous = readRelayConfig(runtime.directory);
+    if (action === "status") {
+        if (!previous?.enabled)
+            return { status: "disabled" };
+        if (runtime.getGui("CODEX_CLI_PATH") !== previous.launcher)
+            return { status: "failed", reason_code: "codex_steer_configuration_changed" };
+        return await runtime.live(previous) ? { status: "ready" } : { status: "restart_required", reason_code: "codex_restart_required" };
+    }
+    if (action === "disable") {
+        if (!previous?.enabled)
+            return { status: "disabled" };
+        if (![previous.launcher, previous.previous_cli_path].includes(runtime.getGui("CODEX_CLI_PATH")))
+            throw new SetupError("codex_steer_configuration_changed", "起動設定が他から変更されています。所有外の値は上書きしません");
+        runtime.unpersist(previous.launcher);
+        runtime.setGui("CODEX_CLI_PATH", previous.previous_cli_path);
+        if (runtime.getGui("CODEX_CLI_PATH") !== previous.previous_cli_path)
+            throw new SetupError("codex_steer_readback_failed", "元の起動設定を確認できません");
+        writeConfig(runtime.directory, { ...previous, enabled: false });
+        return { status: "restart_required", reason_code: "codex_restart_required" };
+    }
+    for (const key of ["CODEX_APP_SERVER_WS_URL", "CODEX_APP_SERVER_USE_LOCAL_DAEMON", "CODEX_APP_SERVER_FORCE_CLI"]) {
+        if (runtime.getGui(key))
+            throw new SetupError("codex_steer_configuration_conflict", `${key}が設定されています。既存の接続設定は上書きしません`);
+    }
+    const binary = runtime.findBinary();
+    const current = runtime.getGui("CODEX_CLI_PATH");
+    if (previous?.enabled && ![previous.launcher, previous.previous_cli_path].includes(current))
+        throw new SetupError("codex_steer_configuration_changed", "起動設定が他から変更されています");
+    prepareRelayDirectory(runtime.directory);
+    const launcher = path.join(runtime.directory, "codex");
+    const config = { schema: "aiterm.codex-relay.v1", enabled: true, binary, node: runtime.node,
+        launcher, socket_root: runtime.socket_root, previous_cli_path: previous?.enabled ? previous.previous_cli_path : current };
+    const candidate = path.join(runtime.directory, `codex-${randomUUID()}`);
+    fs.writeFileSync(candidate, codexRelayLauncher({ ...config, relay: runtime.relay }), { mode: 0o700, flag: "wx" });
+    try {
+        await runtime.verify(candidate);
+        fs.renameSync(candidate, launcher);
+    }
+    finally {
+        if (fs.existsSync(candidate))
+            fs.unlinkSync(candidate);
+    }
+    // 起動設定の変更前に復元値を保存する。読戻し不一致を成功扱いしない。
+    writeConfig(runtime.directory, config);
+    runtime.persist(launcher);
+    runtime.setGui("CODEX_CLI_PATH", launcher);
+    if (runtime.getGui("CODEX_CLI_PATH") !== launcher)
+        throw new SetupError("codex_steer_readback_failed", "Steerの起動設定を確認できません");
+    return await runtime.live(config) ? { status: "ready" } : { status: "restart_required", reason_code: "codex_restart_required" };
+}

package/dist/setup.js

@@ -8,6 +8,8 @@ import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
 import { prepareBackend, runSetupCommand, SetupError } from "./setup-platform.js";
 import { configureIntegrations } from "./setup-integrations.js";
+import { configureCodexSteer } from "./setup-codex-relay.js";
+import { readRelayConfig } from "./codex-relay-config.js";
 export function globalRegistration(run = runSetupCommand) {
     const root = run(process.platform === "win32" ? "npm.cmd" : "npm", ["root", "-g"]).trim();
     if (!isAbsolute(root) || /[\r\n]/u.test(root))
@@ -75,6 +77,18 @@ export async function runSetup(options = {}) {
         }
         else
             result.status = "ready";
+        if (result.status === "ready") {
+            stage = "codex_steer";
+            result.codex_steer = await (options.steer ?? configureCodexSteer)(options.codex_steer ?? (readRelayConfig()?.enabled ? "enable" : "status"));
+            if (["failed", "unsupported", "restart_required"].includes(result.codex_steer.status)) {
+                result.status = result.codex_steer.status;
+                result.reason_code = result.codex_steer.reason_code;
+            }
+            if (result.codex_steer.status === "restart_required")
+                progress("起動設定を保存しました。Codexを完全終了して再起動し、aiterm-setup --codex-steer statusで確認してください");
+            if (result.codex_steer.status === "unsupported")
+                progress("このOSのCodex Desktop Steerは未対応です。Aiterm単品の導入・利用は可能です");
+        }
     }
     catch (error) {
         const code = error instanceof SetupError ? error.code : `${stage}_failed`;

package/docs/DESIGN.md

@@ -48,7 +48,7 @@ project／user環境を置換せず、launch相関と完了回収に必要なsta
 Throughlineの補足記憶はpathを透過搬送するだけで、内容、project束縛、context予算はThroughlineが所有する。
 
 agent turnは常に非ブロックdispatchであり、receiptの`event_cursor`がturn境界になる。
-Codex親にはAitermのMCP processが完了を観測し、回答本文を公式受信キューへ自動配送する。
+Codex親にはAitermのMCP processが完了を観測し、選択設定に応じて公式Steerまたはqueueへ本文を自動配送する。
 Claude Code親は公式の非同期hookで本文を受け取り、待機中も新しいturnへ進める。
 それ以外の親には`wait_process`がplatform nativeな別process起動情報を返す。
 waiterは純readerで、親のforeground turnを塞がない。
@@ -64,15 +64,30 @@ Cursorのsubmitはadapterがextended keyboard protocolのEnterへ変換し、呼
 
 `src/parent-delivery.ts`が依頼の送信前に宛先と完了境界を保存し、完了観測、加工前の回答保存、配送を所有する。
 宛先はCodexのMCP handshakeと各要求の`_meta.threadId`から取得する。modelが指定したIDや環境変数で代用しない。
-`src/codex-parent-receiver.ts`は同じ`CODEX_HOME`の公式app-serverへstdioで接続し、`thread/read`と
-`thread/queue/list`で宛先を確認した後、`thread/queue/add`へ本文をJSONで渡す。
-親のload／resume、Desktop固有通信、子への送信指示、別daemonは使わない。
-setupは公式`queue`入口を確認し、各dispatchでは実際の親threadの受入可否を確認する。
-native sub-agentを親にした外部queue入力はCodex自身が拒否するため、子への送信前に明示errorにする。
-
-通常結果は親の実行中turnを中断せず、親がidleになった後に処理される。
+単品導入の`src/codex-parent-receiver.ts`は同じ`CODEX_HOME`の公式app-serverへstdioで接続し、
+`thread/read`と`thread/queue/list`で宛先を確認してから`thread/queue/add`へ本文をJSONで渡す。
+Steerを選択したmacOS Desktopでは、MCP processの祖先にある公式App Serverの本人所有socketへ接続する。
+`thread/loaded/list`と`thread/read`で同じ親を確認し、公式`turn/start`へ一度だけ送る。
+公式の`start_or_steer_turn`が実行中なら同じturnへ追加入力し、終了後なら同じtaskの次turnを開始する。
+状態を読んでから送信方法を選ぶraceや再送は作らない。model・権限のoverrideも渡さない。
+親のload／resumeは行わず、接続不能・未load・native sub-agentは明示errorにする。
+Steer設定がある場合にqueueへ自動退避することはない。
+
+`aiterm-setup`の`--codex-steer enable|disable|status`が選択導入を所有する。
+設定とPOSIX launcherは`~/.config/aiterm-mcp/codex-relay/`、一時socketは`/tmp/aiterm-codex-<uid>/`へ置く。
+launcherはNodeのstdio中継を起動してから公式CLIへ同じPIDでexecし、Desktopとの親子関係・署名・通常環境を保つ。
+Python・独自App Server・認証情報のコピーは使わない。中継はRPCと承認応答を透過搬送し、追加clientは承認へ応答しない。
+stdio EOFは公式の2段階終了へ伝える。受付開始待ちはexec直後だけに限定し、送信済みRPCは再送しない。
+macOSのユーザーLaunchAgentはログイン時に同じ起動設定を適用する。解除は専用LaunchAgentを停止・削除し、
+保存した元の`CODEX_CLI_PATH`へ戻す。他から変更された設定は上書きしない。
+`status=ready`は公式binary・Desktopの直接子・同じsocketのRPC応答を確認した場合だけ返す。
+初回の設定保存後は`restart_required`であり、Desktopの完全終了・再起動を要する。
+Linux/WindowsのSteer選択は`unsupported`とする。通常の単品導入・queue配送は両OSで維持する。
+
+単品導入のqueue配送は親の実行中turnを中断せず、親がidleになった後に処理される。
 `parent_delivery`が配送IDと状態を返し、自動配送時の`wait_process`／`wait_command`はnullになる。
-`pty_observe`の`parent_deliveries`で状態を確認できる。`submitted`はキュー受付済みを示し、modelの読了を意味しない。
+`pty_observe`の`parent_deliveries`で状態を確認できる。`submitted`は公式受信口の受付済みを示し、modelの読了を意味しない。
+Steer配送の`queued_submission_id`はnullである。既存の配送record schemaは維持する。
 次の依頼へ進める前に前回の回答を保存し、harness所有記録を後の回答と取り違えない。
 
 Codexの配送記録と本文はAiterm stateの`parent-deliveries`へ保存する。ownerのPIDと開始識別子で生存を判定し、
@@ -111,6 +126,9 @@ Claude Desktopのチャット、Web、`agent_id`付きの会話（`--agent`で
 この受信契約の対象に含めない。
 対応対象は公式command hookとMCP metadataを提供するClaude Codeの対話sessionである。
 
+Claudeの起動metadataには指定cwdの実体パスを保存する。Claude Codeが実体パスから作るproject slugと
+APIエラー監視の参照先を一致させ、監視中のリンク変更で保存場所を取り違えない。
+
 `trust_project:true`は対象projectの既知のworkspace、hooks、MCP初期同意を起動準備として進める意図である。
 promptなしでも入力受付とharness生存を確認して`startup.ready`を返す。指定なしのpromptなし起動は
 従来どおり`startup.not_checked`で返す。初手receiptは未要求・未送信・送信済み未確認・開始確認を分ける。

package/docs/RELEASE.md

@@ -35,6 +35,13 @@ Aitermのreleaseはこのrepositoryが所有する。`.github/workflows/product-
 
 ## 公開後smoke
 
+Codex Steerを変更した場合は、公式バイナリを指定した`test/codex-relay-official.test.mjs`で
+実行中Steer・終了後再開・承認応答・stdio終了を先に確認する。公開packageの
+`aiterm-setup --json --codex-steer enable`で選択導入し、`restart_required`なら人がDesktopを完全再起動する。
+再起動後の`aiterm-setup --codex-steer status`が`ready`であることと、通常の親からの子の回答配送を確認する。
+socketがあるだけで成功とせず、公式binaryとDesktopの直接の子であることまで確認する。
+Linux/Windowsの単品導入と、未対応のSteer選択が理由付きで停止することもCIで確認する。
+
 setupを変更した場合は、公開packageのglobal install後に`aiterm-setup --json`を実行し、
 端末実行と検出した各AIの登録結果を確認する。初回と再実行は一時設定領域でも試験し、所有外の設定保持を確かめる。
 WindowsのGrokパス変更ではスラッシュ区切りcwdで起動し、同じturnの完了通知と回答回収を確認する。
@@ -62,6 +69,10 @@ aiterm-setup --json
 
 巻き戻しは既知の正常版を指定する。
 
+Steerを持たない旧版へ戻す時は、install前に`aiterm-setup --codex-steer disable`を実行する。
+専用LaunchAgentの解除と元のGUI起動設定の復元を確認し、MCP clientを再起動する。
+回答record schemaは従来と共通であり、Steer送信済みrecordの`queued_submission_id`はnullとなる。
+
 Claude親配送hookのない旧版へ戻す場合は、旧版のinstall前に`aiterm-setup --remove-claude-parent-hooks`を
 実行する。Aiterm専用の3 hookだけを解除し、他製品のhookと設定を保持する。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiterm-mcp",
-  "version": "0.35.0",
+  "version": "0.36.0",
   "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": [
@@ -69,15 +69,17 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "ws": "8.21.3",
     "zod": "^4.4.3"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
+    "@types/ws": "^8.18.1",
     "parse-srcset": "1.0.2",
     "parse5": "^7.3.0",
     "remark-gfm": "^4.0.1",
     "remark-parse": "^11.0.0",
-    "unified": "^11.0.5",
-    "typescript": "^6.0.3"
+    "typescript": "^6.0.3",
+    "unified": "^11.0.5"
   }
 }