aiterm-mcp 0.37.4 → 0.37.5

package/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.37.5] - 2026-09-19
+
+### 修正
+
+- Codex親へのSteer相当の配送を、公式キューと同期hookへ変更する。ツール実行後または回答終了直前に同じターンへ追加し、終了後は公式キューで同じ会話を再開する。終了後の再開には約10秒かかる場合がある。
+- 選択導入は専用hookだけを公式APIで承認・読戻しし、その後に旧中継の起動差し替えを解除する。Codexの通常起動はAitermのNodeとmoduleに依存しない。
+- 利用者自身のキュー入力は保持する。並行hookの取得を一つに制限し、取り出し中断・出力失敗は本文を保存して`unknown`として照会できる。
+
 ## [0.37.4] - 2026-09-19
 
 ### 修正
@@ -1692,7 +1700,8 @@ 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.37.4...HEAD
+[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.37.5...HEAD
+[0.37.5]: https://github.com/kitepon/aiterm-mcp/compare/v0.37.4...v0.37.5
 [0.37.4]: https://github.com/kitepon/aiterm-mcp/compare/v0.37.3...v0.37.4
 [0.37.3]: https://github.com/kitepon/aiterm-mcp/compare/v0.37.2...v0.37.3
 [0.37.2]: https://github.com/kitepon/aiterm-mcp/compare/v0.37.1...v0.37.2

package/README.ja.md

@@ -42,7 +42,7 @@ Ubuntu／Debianはsudoとaptでtmuxを準備する。必要な公式package mana
 既存設定の他サーバーを保持し、JSON設定は変更前の`.aiterm-backup`を残す。
 結果の`status`は`ready`／`unsupported`／`failed`／`restart_required`。未検出のAIは`not_detected`とし、全AI未検出は成功にしない。
 登録先はglobal packageのNodeとMCP入口の絶対パスで、npm一時cacheやsource checkoutは登録しない。
-HomebrewのNodeは更新後も有効な`opt`のパスをMCP登録とCodex中継に使う。旧版の登録でNode更新後に起動できなくなった場合も、更新後の`aiterm-setup --json`で修復できる。
+HomebrewのNodeは更新後も有効な`opt`のパスをMCP登録とCodexのhookに使う。旧版の登録でNode更新後に起動できなくなった場合も、更新後の`aiterm-setup --json`で修復できる。
 更新後も同じ入口を実行し、MCP clientを再起動する。npm install自体はユーザー設定を変更しない。
 公開JSONは`schema: "aiterm.setup-result.v1"`、全体の`status`、端末の`backend`、
 AI別の`integrations`と選択機能の`codex_steer`を持つ。失敗時は`reason_code`を付け、終了コードはreadyなら0、再起動待ちは3、それ以外は2となる。
@@ -56,22 +56,24 @@ AI別の`integrations`と選択機能の`codex_steer`を持つ。失敗時は`re
 aiterm-setup --json --codex-steer enable
 ```
 
-公式Codex Desktopに同梱されたApp Serverを使い、実行中の親には同じターンへ回答を送り、
-終了後に届いた回答でも同じタスクを自動再開します。App Serverの改造・再ビルド・別配布は不要です。
-新しいlauncherを設定した場合は`restart_required`（終了コード3）を返します。Codexを完全終了して再起動し、
-`aiterm-setup --codex-steer status`で`ready`を確認してください。接続できない時にキューへ自動退避しません。
-
-選択と復元情報は`~/.config/aiterm-mcp/codex-relay/`へ保存します。macOSはユーザーLaunchAgent、
-Windowsはユーザー環境変数`CODEX_CLI_PATH`で起動設定を維持します。更新時の`aiterm-setup --json`は選択を維持して中継を更新します。
-解除・旧版への巻き戻し前は`aiterm-setup --codex-steer disable`を実行してCodexを再起動してください。
-SteerはmacOS・Windowsの公式Codex Desktopと同梱CLI 0.154以上に対応します。Steer有効時の宛先は中継で起動したDesktopに限ります。
-Windowsでは公式Desktopが展開した実行ファイルを照合し、認証付きのローカル接続へ中継します。
-Windowsの仮想AppDataからの起動にも対応し、中継へ実際の保存先を引き継ぎます。
-Aitermのpackageがlauncher・中継・設定・親への配送を含み、gpt-connectorやdotagentsの導入は不要です。
-両OSで公式CodexをDesktopの直接の子として保ち、中継は公式Codexの子として動きます。
-有効化時は元の起動設定を保存してAitermのlauncherを設定し、解除時に元へ戻します。選択後に他から変更された値は上書きしません。
-WindowsのDesktop更新後はsetupを再実行してください。
-LinuxのSteer付き導入は理由付き`unsupported`を返します。Aiterm単品は従来どおり利用できます。
+公式キューと公式hookを使い、実行中の親には同じターンの次の推論へ回答を渡し、終了後は同じ会話を自動再開します。
+Codexの起動プログラムと通常のstdio通信は変更しません。hookの実行ファイルが失われてもCodexの起動・応答は継続します。
+終了後の再開は公式キューの監視周期に従い、約10秒かかる場合があります。
+
+`aiterm-setup`は`CODEX_HOME/hooks.json`へ専用の`PostToolUse`と`Stop`を追加し、公式APIでその2件だけを承認・読戻しします。
+他のhookや承認は保持します。選択と配送の所有記録は`~/.config/aiterm-mcp/codex-parent-hooks/`へ保存します。
+既存の中継は新しいhookの確認後に解除し、保存していた`CODEX_CLI_PATH`を復元します。macOSの専用LaunchAgentも解除します。
+移行前から動いているCodexがあれば`restart_required`（終了コード3）を返します。完全終了・再起動後に
+`aiterm-setup --codex-steer status`で`ready`を確認してください。旧設定は移行を実行するまで維持します。
+
+hookはAiterm自身の配送記録と本文が一致する回答だけを取り出し、利用者がキューに入れた入力は保持します。
+取り出し中断や出力失敗は`parent_deliveries`に`unknown`と`CODEX_HOOK_DELIVERY_UNCONFIRMED`で現れ、本文を保存します。
+自動再送はしません。長い回答はCodexの公式hook処理で抜粋と全文ファイルへの参照になる場合があります。
+
+解除・hook未対応の旧版への巻き戻し前は`aiterm-setup --codex-steer disable`を実行してCodexを再起動してください。
+macOS・Windowsの公式Codex Desktopと、公式キュー・hookに対応する同梱CLIを対象にします。
+WindowsのDesktop更新後はsetupを再実行してください。LinuxのSteer付き導入は理由付き`unsupported`を返します。
+Aiterm単品の公式キュー配送は従来どおり利用できます。
 
 cloneもビルドも不要。どのクライアントでも公開パッケージを次のコマンドで起動する:
 
@@ -198,7 +200,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.37.4** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
+**状態:** 開発継続中 · 現行公開版 **v0.37.5** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
 
 ### 更新と巻き戻し
 

package/README.md

@@ -42,7 +42,7 @@ Ubuntu／Debianはsudoとaptでtmuxを準備する。必要な公式package mana
 既存設定の他サーバーを保持し、JSON設定は変更前の`.aiterm-backup`を残す。
 結果の`status`は`ready`／`unsupported`／`failed`／`restart_required`。未検出のAIは`not_detected`とし、全AI未検出は成功にしない。
 登録先はglobal packageのNodeとMCP入口の絶対パスで、npm一時cacheやsource checkoutは登録しない。
-HomebrewのNodeは更新後も有効な`opt`のパスをMCP登録とCodex中継に使う。旧版の登録でNode更新後に起動できなくなった場合も、更新後の`aiterm-setup --json`で修復できる。
+HomebrewのNodeは更新後も有効な`opt`のパスをMCP登録とCodexのhookに使う。旧版の登録でNode更新後に起動できなくなった場合も、更新後の`aiterm-setup --json`で修復できる。
 更新後も同じ入口を実行し、MCP clientを再起動する。npm install自体はユーザー設定を変更しない。
 公開JSONは`schema: "aiterm.setup-result.v1"`、全体の`status`、端末の`backend`、
 AI別の`integrations`と選択機能の`codex_steer`を持つ。失敗時は`reason_code`を付け、終了コードはreadyなら0、再起動待ちは3、それ以外は2となる。
@@ -56,22 +56,24 @@ AI別の`integrations`と選択機能の`codex_steer`を持つ。失敗時は`re
 aiterm-setup --json --codex-steer enable
 ```
 
-公式Codex Desktopに同梱されたApp Serverを使い、実行中の親には同じターンへ回答を送り、
-終了後に届いた回答でも同じタスクを自動再開します。App Serverの改造・再ビルド・別配布は不要です。
-新しいlauncherを設定した場合は`restart_required`（終了コード3）を返します。Codexを完全終了して再起動し、
-`aiterm-setup --codex-steer status`で`ready`を確認してください。接続できない時にキューへ自動退避しません。
-
-選択と復元情報は`~/.config/aiterm-mcp/codex-relay/`へ保存します。macOSはユーザーLaunchAgent、
-Windowsはユーザー環境変数`CODEX_CLI_PATH`で起動設定を維持します。更新時の`aiterm-setup --json`は選択を維持して中継を更新します。
-解除・旧版への巻き戻し前は`aiterm-setup --codex-steer disable`を実行してCodexを再起動してください。
-SteerはmacOS・Windowsの公式Codex Desktopと同梱CLI 0.154以上に対応します。Steer有効時の宛先は中継で起動したDesktopに限ります。
-Windowsでは公式Desktopが展開した実行ファイルを照合し、認証付きのローカル接続へ中継します。
-Windowsの仮想AppDataからの起動にも対応し、中継へ実際の保存先を引き継ぎます。
-Aitermのpackageがlauncher・中継・設定・親への配送を含み、gpt-connectorやdotagentsの導入は不要です。
-両OSで公式CodexをDesktopの直接の子として保ち、中継は公式Codexの子として動きます。
-有効化時は元の起動設定を保存してAitermのlauncherを設定し、解除時に元へ戻します。選択後に他から変更された値は上書きしません。
-WindowsのDesktop更新後はsetupを再実行してください。
-LinuxのSteer付き導入は理由付き`unsupported`を返します。Aiterm単品は従来どおり利用できます。
+公式キューと公式hookを使い、実行中の親には同じターンの次の推論へ回答を渡し、終了後は同じ会話を自動再開します。
+Codexの起動プログラムと通常のstdio通信は変更しません。hookの実行ファイルが失われてもCodexの起動・応答は継続します。
+終了後の再開は公式キューの監視周期に従い、約10秒かかる場合があります。
+
+`aiterm-setup`は`CODEX_HOME/hooks.json`へ専用の`PostToolUse`と`Stop`を追加し、公式APIでその2件だけを承認・読戻しします。
+他のhookや承認は保持します。選択と配送の所有記録は`~/.config/aiterm-mcp/codex-parent-hooks/`へ保存します。
+既存の中継は新しいhookの確認後に解除し、保存していた`CODEX_CLI_PATH`を復元します。macOSの専用LaunchAgentも解除します。
+移行前から動いているCodexがあれば`restart_required`（終了コード3）を返します。完全終了・再起動後に
+`aiterm-setup --codex-steer status`で`ready`を確認してください。旧設定は移行を実行するまで維持します。
+
+hookはAiterm自身の配送記録と本文が一致する回答だけを取り出し、利用者がキューに入れた入力は保持します。
+取り出し中断や出力失敗は`parent_deliveries`に`unknown`と`CODEX_HOOK_DELIVERY_UNCONFIRMED`で現れ、本文を保存します。
+自動再送はしません。長い回答はCodexの公式hook処理で抜粋と全文ファイルへの参照になる場合があります。
+
+解除・hook未対応の旧版への巻き戻し前は`aiterm-setup --codex-steer disable`を実行してCodexを再起動してください。
+macOS・Windowsの公式Codex Desktopと、公式キュー・hookに対応する同梱CLIを対象にします。
+WindowsのDesktop更新後はsetupを再実行してください。LinuxのSteer付き導入は理由付き`unsupported`を返します。
+Aiterm単品の公式キュー配送は従来どおり利用できます。
 
 No clone or build is required. Each client launches the published package with:
 
@@ -212,7 +214,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.37.4** · 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.37.5** · 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
 
@@ -583,7 +585,7 @@ For PowerShell over SSH, `mark:true` recognizes the current standard `PS ...>` p
 
 自動配送の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`とする。自動再送はしない。
 
-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.
+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. Steer相当の選択時も公式キューへ投入し、専用hookが同一ターンへ取り込みます。
 
 Claude Codeは2.1.259以上の対話sessionに対応する。`aiterm-setup`が専用の`PreToolUse`、`PostToolUse`、`SessionEnd`を登録するため、Channelsの起動flagは不要。公式`asyncRewake` hookだけが裏で待ち、親はその間も次のturnへ進める。回答は`Stop hook feedback`として届く。hookのexit 2は親の再開信号であり、子の成功・失敗は本文の`outcome`で区別する。
 

package/dist/codex-hook-state.js

@@ -0,0 +1,126 @@
+// Codexの設定領域にはhook登録だけを置き、配送の所有情報はAitermが保持する。
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { z } from "zod";
+import { relayConfigDirectory } from "./codex-relay-config.js";
+import { CodexDeliveryError } from "./codex-delivery-error.js";
+import { readRuntimeProcesses } from "./process-runtime.js";
+const processSchema = z.object({ pid: z.number().int(), started_identity: z.string() });
+export const codexHookConfigSchema = z.object({
+    schema: z.literal("aiterm.codex-parent-hooks.v1"), enabled: z.boolean(),
+    codex_home: z.string(), binary: z.string(), command: z.string(), node: z.string(), hook: z.string(),
+    stale_processes: z.array(processSchema),
+}).strict();
+export function codexHookDirectory() { return path.join(path.dirname(relayConfigDirectory()), "codex-parent-hooks"); }
+export function writeHookJson(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        fs.writeFileSync(temporary, JSON.stringify(value) + "\n", { flag: "wx", mode: 0o600 });
+        fs.renameSync(temporary, file);
+    }
+    finally {
+        if (fs.existsSync(temporary))
+            fs.unlinkSync(temporary);
+    }
+}
+export function readCodexHookConfig(directory = codexHookDirectory()) {
+    try {
+        return codexHookConfigSchema.parse(JSON.parse(fs.readFileSync(path.join(directory, "config.json"), "utf8")));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw new CodexDeliveryError("CODEX_HOOK_CONFIG_INVALID", "AitermのCodex hook設定を読めません");
+    }
+}
+export function codexInputDirectory(root, home, thread) {
+    z.uuid().parse(thread);
+    const hash = createHash("sha256").update(fs.realpathSync(home)).digest("hex");
+    return path.join(root, "inputs", hash, thread);
+}
+export const hookInputSchema = z.object({
+    delivery_id: z.uuid(), thread_id: z.uuid(), text_sha256: z.string(),
+}).strict();
+export function answerDigest(text) { return createHash("sha256").update(text).digest("hex"); }
+export function registerCodexHookInput(home, thread, id, text, root = codexHookDirectory()) {
+    const input = hookInputSchema.parse({ delivery_id: id, thread_id: thread, text_sha256: answerDigest(text) });
+    const directory = codexInputDirectory(root, home, thread);
+    fs.mkdirSync(path.join(directory, "pending"), { recursive: true, mode: 0o700 });
+    // 一つの配送IDを別の本文で再使用しない。送信前の所有記録は再送の指示にはしない。
+    fs.writeFileSync(path.join(directory, "pending", `${id}.json`), JSON.stringify(input) + "\n", { flag: "wx", mode: 0o600 });
+}
+export function finishCodexHookSubmission(home, thread, id, root) {
+    const directory = codexInputDirectory(root, home, thread);
+    const file = path.join(directory, "settled", `${id}.json`);
+    writeHookJson(file, { delivery_id: id });
+    if (!fs.existsSync(path.join(directory, "pending", `${id}.json`)))
+        fs.rmSync(file, { force: true });
+}
+export function codexHookDeliveryState(home, thread, id, root = codexHookDirectory()) {
+    if (!fs.existsSync(path.join(root, "inputs")))
+        return null;
+    let value;
+    try {
+        value = JSON.parse(fs.readFileSync(path.join(codexInputDirectory(root, home, thread), "claims", `${z.uuid().parse(id)}.json`), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    // 所有権のlinkだけを作った段階では、公式キューからまだ削除していない。
+    if (hookInputSchema.safeParse(value).success)
+        return null;
+    if (value.state === "unknown")
+        return "unknown";
+    if (value.state === "deleting")
+        return readRuntimeProcesses().some(row => row.pid === value.pid && row.started_identity === value.started_identity) ? "sending" : "unknown";
+    if (["emitted", "not_in_queue"].includes(value.state))
+        return null;
+    throw new CodexDeliveryError("CODEX_HOOK_STATE_INVALID", "hookの配送状態を読めません");
+}
+export function ownedCodexHooks(response, command, file) {
+    const rows = response?.data;
+    if (!Array.isArray(rows) || rows.length !== 1 || !Array.isArray(rows[0]?.hooks) || rows[0]?.errors?.length) {
+        throw new CodexDeliveryError("CODEX_HOOK_UNAVAILABLE", "公式APIでCodexのhook設定を読めません");
+    }
+    const source = fs.realpathSync(file);
+    const owned = rows[0].hooks.filter((hook) => hook.command === command && hook.sourcePath === source);
+    for (const event of ["postToolUse", "stop"]) {
+        const matches = owned.filter((hook) => hook.eventName === event);
+        if (matches.length !== 1 || matches[0].async || matches[0].handlerType !== "command") {
+            throw new CodexDeliveryError("CODEX_HOOK_UNAVAILABLE", "Aitermの同期hook登録を確認できません");
+        }
+    }
+    if (owned.length !== 2)
+        throw new CodexDeliveryError("CODEX_HOOK_UNAVAILABLE", "Aitermのhook登録が重複しています");
+    return owned;
+}
+export function assertCodexHooksReady(response, command, file) {
+    if (ownedCodexHooks(response, command, file).some(hook => !hook.enabled || !["trusted", "managed"].includes(hook.trustStatus))) {
+        throw new CodexDeliveryError("CODEX_HOOK_UNTRUSTED", "AitermのCodex hookが無効または未承認です。aiterm-setupを実行してください");
+    }
+}
+export function assertCodexHookParentCurrent(config, rows, pid = process.pid) {
+    try {
+        fs.accessSync(config.node, fs.constants.X_OK);
+        fs.accessSync(config.hook, fs.constants.R_OK);
+    }
+    catch {
+        throw new CodexDeliveryError("CODEX_HOOK_RUNTIME_UNAVAILABLE", "Codex親hookの実行ファイルを確認できません。aiterm-setupを実行してください");
+    }
+    if (!config.stale_processes.length)
+        return;
+    const processes = new Map((rows ?? readRuntimeProcesses()).map(row => [row.pid, row]));
+    const seen = new Set();
+    let current = processes.get(pid);
+    while (current && !seen.has(current.pid)) {
+        seen.add(current.pid);
+        if (config.stale_processes.some(stale => stale.pid === current.pid && stale.started_identity === current.started_identity)) {
+            throw new CodexDeliveryError("CODEX_STEER_RESTART_REQUIRED", "親のCodexはhookの導入前から動いています。完全終了して再起動してください");
+        }
+        current = processes.get(current.parent_pid);
+    }
+}

package/dist/codex-parent-hook.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+// stdoutはCodexの公式hook出力だけに使う。失敗をStop継続のexit 2に変換しない。
+import { runCodexResultHook } from "./codex-parent-hooks.js";
+let input = "";
+try {
+    for await (const chunk of process.stdin)
+        input += chunk;
+    await runCodexResultHook(JSON.parse(input), value => new Promise((resolve, reject) => {
+        process.stdout.write(JSON.stringify(value) + "\n", error => error ? reject(error) : resolve());
+    }), { directory: process.argv[2] });
+}
+catch (error) {
+    process.stderr.write(`CODEX_PARENT_HOOK_FAILED: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+}

package/dist/codex-parent-hooks.js

@@ -0,0 +1,112 @@
+// 親の同期hookだけが、公式キューのAiterm回答を同じターンの入力へ移す。
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { z } from "zod";
+import { realCodexHome } from "./harnesses/codex.js";
+import { withCodexReceiver } from "./codex-parent-receiver.js";
+import { CodexDeliveryError } from "./codex-delivery-error.js";
+import { readRuntimeProcesses } from "./process-runtime.js";
+import { answerDigest, codexHookDirectory, codexInputDirectory, hookInputSchema, readCodexHookConfig, writeHookJson } from "./codex-hook-state.js";
+export async function runCodexResultHook(input, emit, options = {}) {
+    const event = z.object({ session_id: z.uuid(), turn_id: z.string().min(1),
+        hook_event_name: z.enum(["PostToolUse", "Stop"]) }).parse(input);
+    const root = options.directory ?? codexHookDirectory();
+    const config = readCodexHookConfig(root);
+    if (!config?.enabled) {
+        await emit({});
+        return;
+    }
+    const home = options.codex_home ?? realCodexHome();
+    if (fs.realpathSync(home) !== fs.realpathSync(config.codex_home)) {
+        throw new CodexDeliveryError("CODEX_HOOK_HOME_MISMATCH", "hookと配送設定のCodex環境が一致しません");
+    }
+    const directory = codexInputDirectory(root, home, event.session_id);
+    const pending = path.join(directory, "pending");
+    if (!fs.existsSync(pending) || !fs.readdirSync(pending).length) {
+        await emit({});
+        return;
+    }
+    const claims = path.join(directory, "claims");
+    fs.mkdirSync(claims, { recursive: true, mode: 0o700 });
+    const taken = [];
+    const identity = readRuntimeProcesses().find(row => row.pid === process.pid);
+    if (!identity)
+        throw new CodexDeliveryError("CODEX_HOOK_PROCESS_UNAVAILABLE", "受信hookのprocessを確認できません");
+    try {
+        await withCodexReceiver({ thread_id: event.session_id, codex_home: home }, async (request) => {
+            // 削除でoffsetが動くため、全ページを読んでから取り出す。
+            const entries = [];
+            let cursor = null;
+            do {
+                const page = await request("thread/queue/list", { threadId: event.session_id, cursor, limit: 100 });
+                if (!Array.isArray(page?.data) || !(page.nextCursor === null || typeof page.nextCursor === "string")) {
+                    throw new CodexDeliveryError("CODEX_HOOK_QUEUE_INVALID", "公式キューの一覧応答を認識できません");
+                }
+                entries.push(...page.data);
+                cursor = page.nextCursor;
+            } while (cursor);
+            const queued = new Set(entries.map(entry => entry.clientUserMessageId));
+            // 送信processが終了し、キューに残っていない所有記録を消す。投入中は触らない。
+            for (const name of fs.readdirSync(pending)) {
+                const ack = path.join(directory, "settled", name);
+                if (name.endsWith(".json") && !queued.has(name.slice(0, -5)) && fs.existsSync(ack)) {
+                    fs.rmSync(path.join(pending, name), { force: true });
+                    fs.rmSync(ack, { force: true });
+                }
+            }
+            for (const entry of entries) {
+                const id = z.uuid().safeParse(entry.clientUserMessageId);
+                if (!id.success)
+                    continue;
+                const source = path.join(pending, `${id.data}.json`);
+                let owner;
+                try {
+                    owner = hookInputSchema.parse(JSON.parse(fs.readFileSync(source, "utf8")));
+                }
+                catch (error) {
+                    if (error.code === "ENOENT")
+                        continue;
+                    throw error;
+                }
+                const text = entry.input?.length === 1 && entry.input[0].type === "text" ? entry.input[0].text : undefined;
+                if (owner.delivery_id !== id.data || owner.thread_id !== event.session_id || typeof text !== "string" || answerDigest(text) !== owner.text_sha256) {
+                    throw new CodexDeliveryError("CODEX_HOOK_INPUT_CHANGED", "Aitermの配送記録とキュー本文が一致しません。取り出していません");
+                }
+                const file = path.join(claims, `${id.data}.json`);
+                // 同時hookが同じ回答を取り出すことを防ぎ、中断したclaimは自動再送しない。
+                try {
+                    fs.linkSync(source, file);
+                    fs.unlinkSync(source);
+                }
+                catch (error) {
+                    if (["ENOENT", "EEXIST"].includes(error.code ?? ""))
+                        continue;
+                    throw error;
+                }
+                fs.rmSync(path.join(directory, "settled", `${id.data}.json`), { force: true });
+                const item = { file, delivery_id: id.data, text };
+                taken.push(item);
+                writeHookJson(file, { ...owner, text, state: "deleting", turn_id: event.turn_id, queued_submission_id: entry.id,
+                    pid: identity.pid, started_identity: identity.started_identity });
+                const result = await request("thread/queue/delete", { threadId: event.session_id, queuedSubmissionId: entry.id });
+                if (typeof result?.deleted !== "boolean")
+                    throw new CodexDeliveryError("CODEX_HOOK_QUEUE_INVALID", "キュー削除の結果を確認できません", true);
+                if (!result.deleted) {
+                    writeHookJson(file, { ...owner, state: "not_in_queue", turn_id: event.turn_id });
+                    taken.pop();
+                }
+            }
+        }, options.runtime ?? { executable: config.binary, timeout_ms: 5_000 });
+        const text = taken.map(item => item.text).join("\n\n");
+        await emit(!taken.length ? {} : event.hook_event_name === "Stop"
+            ? { decision: "block", reason: text }
+            : { hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: text } });
+        for (const item of taken)
+            writeHookJson(item.file, { delivery_id: item.delivery_id, state: "emitted", turn_id: event.turn_id, text: item.text });
+    }
+    catch (error) {
+        for (const item of taken)
+            writeHookJson(item.file, { delivery_id: item.delivery_id, state: "unknown", turn_id: event.turn_id, text: item.text });
+        throw error;
+    }
+}

package/dist/codex-parent-receiver.js

@@ -1,4 +1,4 @@
-// Codex親の配送。Steerを選択した環境は同じ公式App Server、それ以外は公式queueを使う。
+// Codex親の配送は公式queueを使う。旧中継の選択はsetupで移行するまで維持する。
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 import * as path from "node:path";
@@ -7,6 +7,7 @@ import { realCodexHome } from "./harnesses/codex.js";
 import { CodexDeliveryError } from "./codex-delivery-error.js";
 import { readRelayConfig, parentRelaySocket } from "./codex-relay-config.js";
 import { withCodexRelay, verifyLoadedParent } from "./codex-relay-client.js";
+import { finishCodexHookSubmission, assertCodexHookParentCurrent, assertCodexHooksReady, codexHookDirectory, readCodexHookConfig, registerCodexHookInput } from "./codex-hook-state.js";
 export { CodexDeliveryError } from "./codex-delivery-error.js";
 /** modelの引数ではなく、CodexがMCP要求へ付けるmetadataだけを宛先にする。 */
 export function codexParentFromRequest(clientName, metadata) {
@@ -21,11 +22,14 @@ export function codexParentFromRequest(clientName, metadata) {
 function relaySocket(runtime) {
     if (runtime)
         return runtime.socket_path ?? null;
+    if (readCodexHookConfig()?.enabled)
+        return null;
     const config = readRelayConfig();
     return config?.enabled ? parentRelaySocket(config) : null;
 }
-async function withCodexReceiver(parent, action, runtime = {}) {
-    const executable = runtime.executable ?? resolveAgentBin("codex");
+export async function withCodexReceiver(parent, action, runtime = {}) {
+    const config = runtime.executable ? null : readCodexHookConfig();
+    const executable = runtime.executable ?? (config?.enabled ? config.binary : null) ?? resolveAgentBin("codex");
     if (!executable)
         throw new CodexDeliveryError("CODEX_RECEIVER_UNAVAILABLE", "Codexの実行ファイルを確認できません");
     const child = spawn(executable, runtime.args ?? ["app-server", "--listen", "stdio://"], {
@@ -123,6 +127,11 @@ export async function verifyCodexParent(parent, runtime) {
             throw new CodexDeliveryError("CODEX_PARENT_UNSUPPORTED", "Codexのnative sub-agentは外部processからのキュー入力を受け付けません");
         }
         await request("thread/queue/list", { threadId: parent.thread_id, limit: 1 });
+        const config = runtime ? (runtime.hook_directory ? readCodexHookConfig(runtime.hook_directory) : null) : readCodexHookConfig();
+        if (config?.enabled) {
+            assertCodexHookParentCurrent(config);
+            assertCodexHooksReady(await request("hooks/list", { cwds: [response.thread.cwd] }), config.command, path.join(parent.codex_home, "hooks.json"));
+        }
     }, runtime);
 }
 export async function submitCodexParentAnswer(parent, deliveryId, text, runtime) {
@@ -139,15 +148,25 @@ export async function submitCodexParentAnswer(parent, deliveryId, text, runtime)
             return { queued_submission_id: null };
         }, runtime?.timeout_ms);
     }
-    return withCodexReceiver(parent, async (request) => {
-        const result = await request("thread/queue/add", {
-            threadId: parent.thread_id,
-            input: [{ type: "text", text, text_elements: [] }],
-            clientUserMessageId: deliveryId,
-        });
-        if (typeof result?.queuedSubmission?.id !== "string") {
-            throw new CodexDeliveryError("CODEX_RECEIVER_INVALID_RESPONSE", "キューの受付IDを確認できません", true);
-        }
-        return { queued_submission_id: result.queuedSubmission.id };
-    }, runtime);
+    const root = runtime ? runtime.hook_directory : codexHookDirectory();
+    const hook = root && readCodexHookConfig(root)?.enabled;
+    if (hook)
+        registerCodexHookInput(parent.codex_home, parent.thread_id, deliveryId, text, root);
+    try {
+        return await withCodexReceiver(parent, async (request) => {
+            const result = await request("thread/queue/add", {
+                threadId: parent.thread_id,
+                input: [{ type: "text", text, text_elements: [] }],
+                clientUserMessageId: deliveryId,
+            });
+            if (typeof result?.queuedSubmission?.id !== "string") {
+                throw new CodexDeliveryError("CODEX_RECEIVER_INVALID_RESPONSE", "キューの受付IDを確認できません", true);
+            }
+            return { queued_submission_id: result.queuedSubmission.id };
+        }, runtime);
+    }
+    finally {
+        if (hook)
+            finishCodexHookSubmission(parent.codex_home, parent.thread_id, deliveryId, root);
+    }
 }

package/dist/parent-delivery.js

@@ -9,6 +9,7 @@ import { readRuntimeProcesses } from "./process-runtime.js";
 import { CodexDeliveryError, submitCodexParentAnswer, verifyCodexParent } from "./codex-parent-receiver.js";
 import { claudeParentSchema, ClaudeDeliveryError, bindClaudeParentDelivery, submitClaudeParentAnswer, verifyClaudeParent } from "./claude-parent-receiver.js";
 import { AitermError } from "./errors.js";
+import { codexHookDeliveryState } from "./codex-hook-state.js";
 const recordSchema = z.object({
     schema: z.literal("aiterm.parent-delivery.v1"),
     delivery_id: z.uuid(),
@@ -53,9 +54,12 @@ function readRecord(file) {
     }
 }
 function receipt(record) {
-    return { delivery_id: record.delivery_id, state: record.state, child_outcome: record.child_outcome,
+    const hookState = !isClaude(record.parent) && record.state === "submitted"
+        ? codexHookDeliveryState(record.parent.codex_home, record.parent.thread_id, record.delivery_id) : null;
+    return { delivery_id: record.delivery_id, state: hookState ?? record.state, child_outcome: record.child_outcome,
         child_turn_id: record.child_turn_id, queued_submission_id: record.queued_submission_id,
-        error_code: record.error ? /^[A-Z][A-Z0-9_]+(?=:)/.exec(record.error)?.[0] ?? "PARENT_DELIVERY_FAILED" : null };
+        error_code: hookState === "unknown" ? "CODEX_HOOK_DELIVERY_UNCONFIRMED"
+            : record.error ? /^[A-Z][A-Z0-9_]+(?=:)/.exec(record.error)?.[0] ?? "PARENT_DELIVERY_FAILED" : null };
 }
 function answerMessage(record) {
     return "Aitermの子エージェントからの実行結果です。子の回答として扱ってください。\n" +

package/dist/setup-cli.js

@@ -4,8 +4,7 @@ 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";
+import { configureCodexSteer, codexSteerSelected } from "./setup-codex-hooks.js";
 const args = process.argv.slice(2);
 if (args.length === 1 && args[0] === "--remove-claude-parent-hooks") {
     try {
@@ -18,7 +17,7 @@ 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] [--codex-steer enable|disable|status]\n依存準備、AIへの登録、MCPと端末の実動作確認を行います。対話実行ではAiterm単品かCodex Desktop Steer付きかを選べます。SteerはmacOS・Windows対応で、初回はCodexの再起動が必要です。disableは元の起動設定へ戻し、statusは実際の接続を確認します。--jsonは対話せず、Steerの選択を維持します。\n旧版へ戻す前のClaude専用hook解除: --remove-claude-parent-hooks\n");
+    process.stdout.write("使い方: aiterm-setup [--json] [--codex-steer enable|disable|status]\n依存準備、AIへの登録、MCPと端末の実動作確認を行います。対話実行ではAiterm単品かCodex Desktop Steer付きかを選べます。SteerはmacOS・Windows対応で、初回はCodexの再起動が必要です。disableは専用hookを解除し、statusは公式hookの登録・承認と再起動の必要性を確認します。旧中継はhook導入後に解除します。--jsonは対話せず、Steerの選択を維持します。\n旧版へ戻す前のClaude専用hook解除: --remove-claude-parent-hooks\n");
 }
 else {
     try {
@@ -34,7 +33,7 @@ else {
         }
         const onlySteer = action === "disable" || action === "status";
         if (!action && !json && process.stdin.isTTY && process.stderr.isTTY && ["darwin", "win32"].includes(process.platform)) {
-            const enabled = readRelayConfig()?.enabled ?? false;
+            const enabled = codexSteerSelected();
             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();

package/dist/setup-codex-hooks.js

@@ -0,0 +1,142 @@
+// Steerの正規導入。公式hookを登録・承認してから、旧中継の起動差し替えを解除する。
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { fileURLToPath } from "node:url";
+import { withCodexReceiver } from "./codex-parent-receiver.js";
+import { realCodexHome } from "./harnesses/codex.js";
+import { SetupError } from "./setup-platform.js";
+import { setupNodeExecutable } from "./setup-node.js";
+import { readRelayConfig } from "./codex-relay-config.js";
+import { configureCodexSteer as configureLegacyRelay, findDesktopBinary } from "./setup-codex-relay.js";
+import { findWindowsCodexBinary } from "./windows-codex-setup.js";
+import { readRuntimeProcesses } from "./process-runtime.js";
+import { resolveWindowsPowerShell7 } from "./windows-powershell.js";
+import { quotePowerShell } from "./windows-codex-state.js";
+import { assertCodexHooksReady, codexHookDirectory, ownedCodexHooks, readCodexHookConfig, writeHookJson } from "./codex-hook-state.js";
+export function codexSteerSelected() { return readCodexHookConfig()?.enabled === true || readRelayConfig()?.enabled === true; }
+export function codexHookCommand(node, hook, directory, platform = process.platform) {
+    if (platform === "win32") {
+        const script = `& ${[node, hook, directory].map(quotePowerShell).join(" ")}; exit $LASTEXITCODE`;
+        return `"${resolveWindowsPowerShell7()}" -NoLogo -NoProfile -NonInteractive -EncodedCommand ${Buffer.from(script, "utf16le").toString("base64")}`;
+    }
+    return [node, hook, directory].map(value => "'" + value.replace(/'/g, "'\"'\"'") + "'").join(" ");
+}
+export function mergeCodexParentHooks(file, command, previousCommand) {
+    if (!fs.existsSync(file)) {
+        try {
+            if (fs.lstatSync(file).isSymbolicLink())
+                throw new SetupError("codex_hook_config_invalid", "hook設定symlinkの参照先がありません");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    const target = fs.existsSync(file) ? fs.realpathSync(file) : file;
+    let current = {};
+    if (fs.existsSync(target)) {
+        try {
+            current = JSON.parse(fs.readFileSync(target, "utf8"));
+        }
+        catch {
+            throw new SetupError("codex_hook_config_invalid", "Codexのhook設定JSONを読めません");
+        }
+    }
+    const object = (value) => value && typeof value === "object" && !Array.isArray(value);
+    if (!object(current) || (current.hooks !== undefined && !object(current.hooks)))
+        throw new SetupError("codex_hook_config_invalid", "Codexのhooks設定を読めません");
+    const hooks = { ...current.hooks };
+    for (const event of ["PostToolUse", "Stop"]) {
+        const groups = hooks[event] ?? [];
+        if (!Array.isArray(groups) || groups.some(group => !object(group) || !Array.isArray(group.hooks)))
+            throw new SetupError("codex_hook_config_invalid", `${event}のhook設定を読めません`);
+        hooks[event] = groups.map(group => ({ ...group, hooks: group.hooks.filter((hook) => !(hook?.type === "command" && ((command !== null && hook.command === command) || (previousCommand && hook.command === previousCommand)))) })).filter(group => group.hooks.length);
+        if (command !== null)
+            hooks[event].push({ ...(event === "PostToolUse" ? { matcher: ".*" } : {}),
+                hooks: [{ type: "command", command, timeout: 20, ...(event === "PostToolUse" ? { additionalContextLimit: 0 } : {}) }] });
+        if (!hooks[event].length)
+            delete hooks[event];
+    }
+    const next = { ...current, hooks };
+    if (isDeepStrictEqual(current, next))
+        return false;
+    if (fs.existsSync(target))
+        fs.copyFileSync(target, `${target}.aiterm-backup`);
+    writeHookJson(target, next);
+    if (!isDeepStrictEqual(JSON.parse(fs.readFileSync(target, "utf8")), next))
+        throw new SetupError("codex_hook_readback_failed", "Codex hookの読戻しが一致しません");
+    return true;
+}
+export async function verifyCodexHookRegistration(config, approve) {
+    fs.accessSync(config.node, fs.constants.X_OK);
+    fs.accessSync(config.hook, fs.constants.R_OK);
+    const file = path.join(config.codex_home, "hooks.json");
+    await withCodexReceiver({ thread_id: "00000000-0000-4000-8000-000000000000", codex_home: config.codex_home }, async (request) => {
+        const list = () => request("hooks/list", { cwds: [config.codex_home] });
+        const hooks = ownedCodexHooks(await list(), config.command, file);
+        if (approve) {
+            const edits = hooks.filter(hook => !hook.enabled || hook.trustStatus !== "trusted").flatMap(hook => {
+                if (typeof hook.key !== "string" || typeof hook.currentHash !== "string")
+                    throw new SetupError("codex_hook_schema_unknown", "公式hookの承認情報を認識できません");
+                const key = `hooks.state.${JSON.stringify(hook.key)}`;
+                return [
+                    { keyPath: `${key}.trusted_hash`, value: hook.currentHash, mergeStrategy: "replace" },
+                    { keyPath: `${key}.enabled`, value: true, mergeStrategy: "replace" },
+                ];
+            });
+            if (edits.length)
+                await request("config/batchWrite", { edits, filePath: path.join(config.codex_home, "config.toml") });
+        }
+        assertCodexHooksReady(await list(), config.command, file);
+    }, { executable: config.binary });
+}
+export async function configureCodexSteer(action = "status", overrides = {}) {
+    const runtime = { platform: process.platform, directory: codexHookDirectory(), codex_home: realCodexHome(),
+        node: process.execPath, hook: fileURLToPath(new URL("./codex-parent-hook.js", import.meta.url)),
+        findBinary: process.platform === "win32" ? findWindowsCodexBinary : findDesktopBinary,
+        processes: readRuntimeProcesses, legacy: readRelayConfig,
+        disableLegacy: () => configureLegacyRelay("disable"), verify: verifyCodexHookRegistration, ...overrides };
+    const previous = readCodexHookConfig(runtime.directory);
+    const legacy = runtime.legacy();
+    const file = path.join(action === "disable" && previous ? previous.codex_home : runtime.codex_home, "hooks.json");
+    const save = (config) => writeHookJson(path.join(runtime.directory, "config.json"), config);
+    const needsRestart = (config) => runtime.processes().some(process => config.stale_processes.some(stale => stale.pid === process.pid && stale.started_identity === process.started_identity));
+    if (action === "status") {
+        if (!previous?.enabled)
+            return legacy?.enabled ? { status: "failed", reason_code: "codex_steer_migration_required" } : { status: "disabled" };
+        await runtime.verify(previous, false);
+        return legacy?.enabled || needsRestart(previous) ? { status: "restart_required", reason_code: "codex_restart_required" } : { status: "ready" };
+    }
+    if (action === "disable") {
+        if (previous?.enabled) {
+            mergeCodexParentHooks(file, null, previous.command);
+            save({ ...previous, enabled: false });
+        }
+        if (legacy?.enabled)
+            return runtime.disableLegacy();
+        return previous?.enabled ? { status: "restart_required", reason_code: "codex_restart_required" } : { status: "disabled" };
+    }
+    if (!["darwin", "win32"].includes(runtime.platform))
+        return { status: "unsupported", reason_code: "codex_steer_platform_unsupported" };
+    if (previous?.enabled && fs.realpathSync(previous.codex_home) !== fs.realpathSync(runtime.codex_home))
+        throw new SetupError("codex_steer_configuration_conflict", "別のCODEX_HOMEでSteerが有効です。先に既存の選択を解除してください");
+    const node = setupNodeExecutable(runtime.node);
+    fs.accessSync(node, fs.constants.X_OK);
+    fs.accessSync(runtime.hook, fs.constants.R_OK);
+    const binary = runtime.findBinary();
+    const command = codexHookCommand(node, runtime.hook, runtime.directory, runtime.platform);
+    const changed = mergeCodexParentHooks(file, command, previous?.command);
+    const stale = !previous?.enabled || changed || legacy?.enabled
+        ? runtime.processes().filter(row => row.executable === binary || row.command.startsWith(binary + " "))
+            .map(({ pid, started_identity }) => ({ pid, started_identity }))
+        : previous.stale_processes;
+    const config = { schema: "aiterm.codex-parent-hooks.v1", enabled: true,
+        codex_home: runtime.codex_home, binary, command, node, hook: runtime.hook, stale_processes: stale };
+    await runtime.verify(config, true);
+    // 解除が中断しても、次のenableで移行を続行できるよう所有情報を先に保存する。
+    save(config);
+    if (legacy?.enabled)
+        await runtime.disableLegacy();
+    return needsRestart(config) ? { status: "restart_required", reason_code: "codex_restart_required" } : { status: "ready" };
+}

package/dist/setup-codex-relay.js

@@ -29,7 +29,7 @@ function getGui(key) {
         throw new SetupError("codex_steer_environment_unavailable", "GUIの起動設定を確認できません");
     return result.stdout.trim() || null;
 }
-function findDesktopBinary() {
+export 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 => {

package/dist/setup.js

@@ -8,8 +8,7 @@ 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";
+import { configureCodexSteer, codexSteerSelected } from "./setup-codex-hooks.js";
 import { setupNodeExecutable } from "./setup-node.js";
 export function globalRegistration(run = runSetupCommand) {
     const root = run(process.platform === "win32" ? "npm.cmd" : "npm", ["root", "-g"]).trim();
@@ -80,7 +79,7 @@ export async function runSetup(options = {}) {
             result.status = "ready";
         if (result.status === "ready") {
             stage = "codex_steer";
-            result.codex_steer = await (options.steer ?? configureCodexSteer)(options.codex_steer ?? (readRelayConfig()?.enabled ? "enable" : "status"));
+            result.codex_steer = await (options.steer ?? configureCodexSteer)(options.codex_steer ?? (codexSteerSelected() ? "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;

package/docs/DESIGN.md

@@ -68,49 +68,39 @@ Cursorのsubmitはadapterがextended keyboard protocolのEnterへ変換し、呼
 宛先は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で渡す。
-Steerを選択したmacOS・Windows Desktopでは、MCP processの祖先にある公式App Serverの本人専用接続へ接続する。
-`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`が選択導入を所有する。
-MCP登録とmacOSの中継launcherへ保存するNodeの起動先は`src/setup-node.ts`が決める。
-HomebrewのCellar実体は同じformulaの`opt/<formula>/bin/node`へ変換し、実行できることを確認する。
-`node@22`等のformulaを維持し、GUIのPATH探索や別のNodeへの自動切替は行わない。
-Homebrew以外の起動先は変更しない。既存の版別パスは`aiterm-setup --json`で再生成する。
-設定と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の完全終了・再起動を要する。
-引数の解釈、JSONL中継、設定の有効化・競合・復元は両OSで共通の処理を使う。
-Windows標準の.NET Frameworkでlauncherを作り、`CreateProcessW`の親process属性と継承handle一覧で、
-公式CLIをDesktopの直接の子、中継Nodeを公式CLIの直接の子として起動する。
-launcherは終了監視だけを担い、JSON-RPCを通さない。Windowsには同一PIDでのexecがないためPIDは変わるが、
-公式binary、起動元との直接の親子関係、通常の環境とstdioは維持する。
-MSIXの仮想AppDataはnative子へ同じ論理パスを渡しても見えない場合があるため、準備processが
-自身の`realpathSync.native`を起動計画へ返し、後続の中継Nodeはその実体を起動する。
-解決は起動時に行い、設定時の保存先で固定しない。
-公式Desktopが展開した4実行ファイルを配布元のSHA-256と照合し、AitermがCodexをコピー・再配布しない。
-公式CLIの認証付きloopback WebSocketを使い、本人専用ACLのtokenと接続記録をAitermのsessions下へ置く。
-Windowsのprocess情報はprocess-runtimeが所有し、接続はPID・開始時刻・実行ファイル・token引数で照合する。
-MCP processの祖先から親を選び、同じloaded taskへ送る。開始時刻は小数桁の表記差を正規化して比較する。
-stdio EOFで自分が起動した公式serverを停止し、接続記録を削除する。native launcherはJob Objectで
-所有するprocessだけを終了し、公式serverの終了確認後に戻る。
-両OSとも有効化前に元の起動設定を保存し、Aitermのlauncherを設定する。解除は元の値へ戻す。
-旧Windows版で既存launcherを共有した設定は読取り可能だが、次のenableでAitermのlauncherへ移行する。
-起動・配送・設定・診断は他製品のコード、設定、コマンドへ依存しない。
-LinuxのSteer選択はunsupportedとする。通常の単品導入・queue配送は全対応OSで維持する。
-
-単品導入のqueue配送は親の実行中turnを中断せず、親がidleになった後に処理される。
-`parent_delivery`が配送IDと状態を返し、自動配送時の`wait_process`／`wait_command`はnullになる。
-`pty_observe`の`parent_deliveries`で状態を確認できる。`submitted`は公式受信口の受付済みを示し、modelの読了を意味しない。
-Steer配送の`queued_submission_id`はnullである。既存の配送record schemaは維持する。
+Steerを選択したmacOS・Windowsでも配送の入口は公式キューとする。
+`src/codex-parent-hooks.ts`の同期`PostToolUse`がAitermの回答を同じターンの文脈へ渡し、
+`Stop`が最終応答の生成中に届いた回答で同じターンを継続する。
+取り込まれていない回答は公式キューに残り、親がidleになった時に通常配送される。終了後の再開には約10秒かかる場合がある。
+親を別processでload／resumeせず、modelや権限のoverrideを渡さない。native sub-agentは自動配送の親にしない。
+
+`src/codex-hook-state.ts`は同じCodex home・thread・配送UUID・本文hashへの所有記録を保持する。
+キューの全ページを読んでから所有分を取り出し、他の利用者入力には触れない。
+同時hookの取得は本人専用ディレクトリ内の排他的hard linkで一つに決め、公式の削除結果がtrueの本文だけを出力する。
+削除中はprocess開始識別子を記録する。中断と出力失敗は`unknown`で本文を残し、自動再送しない。
+`parent_deliveries`はその状態と`CODEX_HOOK_DELIVERY_UNCONFIRMED`を表示する。
+`emitted`はhookへの出力完了でありmodelの読了ではない。公式キューが先に通常配送した入力の所有記録は次のhookで整理する。
+
+`aiterm-setup --codex-steer enable|disable|status`は`src/setup-codex-hooks.ts`が所有する。
+`CODEX_HOME/hooks.json`の他の登録を保持し、専用の同期hookを追加する。
+公式`hooks/list`から得た2件のkeyとhashだけを公式`config/batchWrite`で承認し、再読して有効・承認済みであることを確認する。
+承認省略flagを恒久設定へ書かない。利用者の別hookを承認しない。
+選択と配送の所有記録は`~/.config/aiterm-mcp/codex-parent-hooks/`に置く。
+Nodeは`src/setup-node.ts`でHomebrewの同じformulaの`opt`へ正規化し、更新で消えるCellar実体を保存しない。
+
+新規の起動差し替えは作らない。旧中継の設定は新しいhookの確認後に従来の解除処理で復元する。
+macOSの専用LaunchAgent、Windowsのユーザー環境変数、所有外の値の保持は旧adapterが担う。
+旧中継の互換読取りと移行用コードは残し、setupを実行するまでは旧設定の配送を維持する。
+移行が中断した場合は保存済みの所有情報を使って次のsetupで継続し、未完了をreadyにしない。
+有効化前から動いている公式processのPIDと開始識別子を保存し、それが残っている間はrestart_requiredとする。
+`ready`は公式APIによるhook登録・承認の読戻しと、更新前processの終了を確認した状態である。
+Codexの通常起動はAitermのNode、module、socketに依存しない。
+Windowsでは公式Desktopが展開した実行ファイルを照合して配送用の公式APIへ接続する。Desktop更新後はsetupで再検出する。
+LinuxのSteer選択はunsupportedとし、単品のキュー配送は全対応OSで維持する。
+
+`parent_delivery`は配送IDと状態を返し、自動配送時の`wait_process`／`wait_command`はnullとなる。
+`submitted`は公式キューの受付またはhook出力の完了を示す。キューIDはSteer相当の選択時も保持する。
+長いStop継続入力はCodex自身のhook処理で抜粋と全文ファイルへの参照になる場合がある。
 次の依頼へ進める前に前回の回答を保存し、harness所有記録を後の回答と取り違えない。
 
 Codexの配送記録と本文はAiterm stateの`parent-deliveries`へ保存する。ownerのPIDと開始識別子で生存を判定し、

package/docs/RELEASE.md

@@ -35,19 +35,18 @@ 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`であることと、通常の親からの子の回答配送を確認する。
-接続があるだけで成功とせず、公式binaryとDesktopの親子関係まで確認する。
-Windowsは`AITERM_TEST_CODEX_BINARY`に公式Desktopの実行fileを指定し、
-`test/windows-codex.test.mjs`で単独launcher、ACL、親識別、元の起動設定の保存と解除も確認する。
-同じ環境変数で`test/codex-relay-official.test.mjs`の実行中Steer・終了後再開・承認中継・EOFを確認できる。
-Windowsの中継起動を変更した場合は、公式Desktopが入った端末で`AITERM_TEST_CODEX_PACKAGE`に
-そのpackage family名を指定し、`test/windows-codex-msix.test.mjs`も実行する。公式の
-`Invoke-CommandInDesktopPackage`で仮想AppDataからのinitialize・EOFを確認し、稼働中Desktopや
-ユーザー設定は変更しない。packageと公式binaryを指定しないCIではこの実機試験をskipする。
-Linuxの未対応Steer選択が理由付きで停止することもCIで確認する。
+Codex Steerを変更した場合は、公式バイナリを指定した`test/codex-parent-hooks-official.test.mjs`で
+通常stdio起動、公式hookの個別承認、同一ターン配送、終了後再開、hook消失、終了との競合、利用者キューの保持を確認する。
+`AITERM_TEST_CODEX_BINARY`に公式Desktopの同梱実行ファイルを指定し、一時HOMEと模擬モデルで実行する。
+試験は実認証と稼働中Desktopの設定を使わない。指定のないCIではこの実機試験をskipする。
+公開packageの`aiterm-setup --json --codex-steer enable`で選択導入し、`restart_required`ならDesktopを完全再起動する。
+再起動後に`aiterm-setup --codex-steer status`が`ready`となり、通常の親が同じターンで子の回答を受け取ることを確認する。
+アプリ内ツールと通常起動も確認し、公式バイナリの隔離試験だけでDesktop統合を完了扱いしない。
+
+旧中継の移行を変更した場合は`test/setup-codex-relay.test.mjs`と`test/windows-codex.test.mjs`で
+元の起動設定・専用LaunchAgent・ユーザー環境変数の復元と、所有外の値の保持を確認する。
+新しいhookの読戻し失敗では旧設定を解除しないこと、解除中断では再実行で移行を完了できることも確認する。
+新方式の登録と配送stateは`test/setup-codex-hooks.test.mjs`と`test/codex-parent-hooks.test.mjs`が検証する。
 
 setupを変更した場合は、公開packageのglobal install後に`aiterm-setup --json`を実行し、
 端末実行と検出した各AIの登録結果を確認する。初回と再実行は一時設定領域でも試験し、所有外の設定保持を確かめる。
@@ -76,10 +75,10 @@ aiterm-setup --json
 
 巻き戻しは既知の正常版を指定する。
 
-Steerを持たない旧版へ戻す時は、install前に`aiterm-setup --codex-steer disable`を実行する。
-macOSは専用LaunchAgentの解除、Windowsは元のユーザー環境変数の復元を確認し、MCP clientを再起動する。
+新しいCodex親hookを持たない旧版へ戻す時は、install前に`aiterm-setup --codex-steer disable`を実行する。
+専用hookの解除を確認し、Codexを完全再起動する。旧中継が残っている場合は、macOSの専用LaunchAgentとWindowsのユーザー環境変数も復元する。
 互換launcherを共有していた場合はAitermのSteer選択だけを解除し、所有外の起動設定を保持する。
-回答record schemaは従来と共通であり、Steer送信済みrecordの`queued_submission_id`はnullとなる。
+回答record schemaは従来と共通であり、新方式のSteer相当配送も`queued_submission_id`を保持する。
 
 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.37.4",
+  "version": "0.37.5",
   "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": [