aiterm-mcp 0.33.1 → 0.35.0

package/CHANGELOG.md

@@ -7,6 +7,36 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.35.0] - 2026-09-10
+
+### Added
+
+- Claude Code親への回答自動配送を追加した。公式`asyncRewake` hookが子の回答を受け取り、idle中の親も再開する。待機中も親は別作業と次のturnへ進める。
+- `aiterm-setup`がClaude Codeの専用hookを登録し、MCP要求とhookの実際の会話を照合する。親のwaiter・回答回収と子への返送指示は不要。
+- `/clear`等の会話終了後は未送信の旧回答を新しい会話へ出さず、本文を保持して配送失敗を明示する。hookの出力中断は結果不明とし、自動再送しない。
+
+### Fixed
+
+- Grok／Composerで追加メッセージが直ちに次turnを開始した場合も、完了したturnの回答を指定して回収する。最新turnの切替で前の回答の自動配送が失敗する競合を修正した。
+
+### Compatibility
+
+- Claude Code親は2.1.259以上の対話sessionと有効なcommand hookを必要とする。Claude Desktopチャット・Web・`agent_id`付きの会話（`--agent`起動とnative subagent）は対象外。起動時のChannels flagは不要。
+- Claude用配送記録を分け、旧版のCodex readerとの互換性を維持する。旧版へ戻す前に`aiterm-setup --remove-claude-parent-hooks`でAiterm専用hookだけを解除する。
+
+## [0.34.0] - 2026-09-10
+
+### Added
+
+- Codex親への子の回答自動配送を追加した。起動・通常dispatch・Claude durable turnの完了をAitermが観測し、回答本文を公式受信キューへ送る。親の待機コマンドと回答回収、子への送信指示は不要になった。
+- 配送IDと状態をreceipt／`pty_observe`へ追加した。再接続後は未送信の記録を再開し、送信結果が不明な場合は本文を保持して自動再送しない。
+- `aiterm-setup`はCodexの公式queue入口を確認する。各dispatchでMCP要求の親threadを確認し、未対応の受信口へ子を送らない。
+
+### Compatibility
+
+- Codex親は公式の`_meta.threadId`と`thread/queue` APIを提供する環境が必要。Codex CLI 0.154.0で確認した。native sub-agentを親とする外部queue入力はCodexの制約により未対応。
+- Claude等の親の既存waiter契約は維持する。旧版へ戻すと新しい配送記録は処理されないが、既存PTY／harness stateの形式は変わらない。
+
 ## [0.33.1] - 2026-09-09
 
 ### Fixed
@@ -1604,7 +1634,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.33.1...HEAD
+[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.35.0...HEAD
+[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
 [0.33.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.32.0...v0.33.0
 [0.32.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.31.2...v0.32.0

package/README.ja.md

@@ -163,7 +163,7 @@ v0.20では、待たずに一度だけ観測する
 `running`（exit 5）で返すようにしました。v0.19系では相関済みClaude approval中継を追加し、
 複数行shell配送を維持し、native Windowsのfactory diagnosticsを拡張しました。
 v0.16/0.17以来、親エージェントはaiterm上で一切ブロックしません:
-agent session への send は常に非ブロック dispatch になり、完了待ちは `aiterm-wait` 一本
+agent session への send は常に非ブロック dispatch になり、Codex／Claude Code親には回答本文を自動配送し、それ以外の親の完了待ちは `aiterm-wait`
 （exit code が receipt の outcome を映す: 0=done / 3=timeout=未完了 /
 4=closed / 5=running=待たない観測）、初回 prompt 付き
 launch は structured receipt にコピペ可能な `wait_command` を含む。factory diagnostics と local
@@ -171,7 +171,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.33.1** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
+**状態:** 開発継続中 · 現行公開版 **v0.35.0** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
 
 ### 更新と巻き戻し
 
@@ -205,7 +205,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`を返し、完了通知は`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親は公式受信キュー、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は送信前に拒否する。
 
@@ -225,6 +225,7 @@ agent_launch({ harness: "codex-cli", session_name: "codex1", cwd: "/repo",
                                     → { session_id: "codex1", … }   # Codex が永続端末で稼働開始
 pty_read("codex1", { screen: true })   → 何をしているか読む（トークン削減）
 pty_send("codex1", "also fix the imports it broke")   # 非ブロックdispatch＝event_cursor入りreceipt
+# Codex／Claude Code親には回答が自動で届く。それ以外の親:
 $ aiterm-wait --session codex1 --cursor <event_cursor>   # exit 0=done / 3=timeout(未完了) / 4=closed / 7=error(APIエラー等でturn打ち切り)。回収は pty_read(agent_transcript:true)
                                     → 操舵し、Codex の次の入力境界で返る
 ```
@@ -513,6 +514,21 @@ SSH先がPowerShellの場合、`mark:true`は現在の標準`PS ...>`プロン
 
 `pty_read({ wait: true })`は通常PTYを、process終了／`mark:true` sentinel／`until`一致／shell復帰を伴う出力静止／timeoutの5層で判定する。agent sessionは第6の正確な層を使い、Codexは通常rollout、Grokは通常session event、Claudeはlaunch相関Stop event、Cursorは通常agent transcriptの`turn_ended`を`aiterm-wait --cursor`が観測する。親はブロックもポーリングもしない。
 
+### Codex／Claude Code親への回答自動配送
+
+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`とする。自動再送はしない。
+
+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`で区別する。
+
+`/clear`などで会話を終了すると未送信の旧回答の配送を止め、本文は保存する。受信hookの上限は24時間で、終了や出力失敗を成功扱いしない。hookが無効な場合は送信前に明示errorにし、waiterへ黙って切り替えない。Claude Desktopのチャット、Web、`agent_id`付きの会話（`--agent`起動とnative subagent）はこの受信契約に含めない。
+
+hookを持たない旧版へ戻す時は、install前に`aiterm-setup --remove-claude-parent-hooks`を実行する。Aiterm専用hookだけを解除し、他製品のhookと設定は保持する。
+
+
 ### トークン削減
 
 - `pty_read` は既定で制御文字除去・連続重複圧縮・head+tail 折りたたみ（＋復元ヒント・メタ併記）をかける。

package/README.md

@@ -176,18 +176,16 @@ a non-blocking `aiterm-wait --timeout 0` observation (`running`, exit 5) from a
 wait. The v0.19 line added the correlated Claude approval relay,
 preserved multiline shell delivery, and extended factory diagnostics on native
 Windows. As of v0.16/0.17 a parent agent never blocks on aiterm:
-every send to an agent session is a non-blocking dispatch, completion is one
-universal `aiterm-wait` waiter whose exit codes mirror the receipt outcome
-(`0`=done / `3`=timeout, not finished / `4`=closed / `5`=running for a
-zero-time observation), and a launch with an
-initial prompt returns a ready-made `wait_command` in its structured receipt.
+agent sessionへの送信は非ブロックdispatchであり、Codex／Claude Code親には回答本文を自動配送する。
+それ以外の親はreceiptのprocess起動情報で`aiterm-wait`を実行する。
+終了コードは`0`=done、`3`=timeout、`4`=closed、待機しない照会の`5`=runningを表す。
 Factory diagnostics and the local runtime-error store collect only when
 canonical dotagents config explicitly sets `collection.enabled: true`;
 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.33.1** · runs on Linux · WSL2 · macOS · native Windows (tmux on POSIX, the tmux-CLI-compatible [psmux](https://github.com/psmux/psmux) on native Windows — no WSL required) · MIT · see the [CHANGELOG](CHANGELOG.md).
+**Status:** actively maintained · current public release **v0.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).
 
 ### Update and rollback
 
@@ -227,7 +225,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`.
 
-The human-readable launch text is accompanied by an `aiterm.agent-launch-result.v1` structured receipt containing the canonical `harness`; the old `provider` field remains for compatibility. The same `harness` is carried by agent dispatch, `aiterm-wait`, `agent_configure`, and agent rows in `pty_list`, while their old vendor/provider/agent fields remain compatibility fields. Codex completion comes from its normal durable rollout transcript, Grok CLI from its normal session events, Claude Code from a launch-specific Stop hook settings addition, and Cursor from its normal agent transcript's terminal `turn_ended` record. Sending to any agent session is a non-blocking **dispatch** — the call returns immediately with an opaque, harness-specific integer `event_cursor`, and completion arrives via [`aiterm-wait`](#completion-push-for-parent-agents-aiterm-wait). The Cursor adapter translates submit into the current CLI's extended keyboard protocol. If submitted text remains in Cursor's composer, its dispatch fails instead of returning a successful receipt.
+起動結果には正規`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にする。
 
 `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.
 
@@ -250,6 +248,7 @@ agent_launch({ harness: "codex-cli", session_name: "codex1", cwd: "/repo",
 pty_read("codex1", { screen: true })   → read what it's doing (token-reduced)
 pty_send("codex1", "also fix the imports it broke")
                                     → non-blocking dispatch; receipt carries event_cursor
+# Codex／Claude Code親には回答が自動で届く。それ以外の親:
 $ aiterm-wait --session codex1 --cursor <event_cursor>   # never in the parent's foreground; exit 0=done, 3=timeout (not done), 4=closed, 7=error (turn aborted by an API error)
 pty_read("codex1", { agent_transcript: true })           → collect the full answer
 ```
@@ -550,11 +549,23 @@ For PowerShell over SSH, `mark:true` recognizes the current standard `PS ...>` p
 
 ### Completion push for parent agents (`aiterm-wait`)
 
-As of v0.16 a parent agent **never blocks** on aiterm — there is no wait parameter anywhere (v0.17 makes the waiter's exit codes mirror its outcome). The whole flow is dispatch + one universal waiter:
+**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`とする。自動再送はしない。
+
+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.
+
+Claude Codeは2.1.259以上の対話sessionに対応する。`aiterm-setup`が専用の`PreToolUse`、`PostToolUse`、`SessionEnd`を登録するため、Channelsの起動flagは不要。公式`asyncRewake` hookだけが裏で待ち、親はその間も次のturnへ進める。回答は`Stop hook feedback`として届く。hookのexit 2は親の再開信号であり、子の成功・失敗は本文の`outcome`で区別する。
+
+`/clear`等の会話終了後は未送信の旧回答を送らず、本文を保存する。受信hookの上限は24時間。hookの終了・出力失敗・無効化を成功扱いせず、別の待機経路へ黙って切り替えない。Claude Desktopのチャット、Web、`agent_id`付きの会話（`--agent`起動とnative subagent）はこの受信契約に含めない。
+
+hookを持たない旧版へ戻す時は、install前に`aiterm-setup --remove-claude-parent-hooks`を実行する。Aiterm専用hookだけを解除し、他製品のhookと設定は保持する。
+
+**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.
 2. Pass the receipt's `wait_process.executable` and `wait_process.args` unchanged to a true argv process API. PowerShell 7's `Start-Process` is the exception because it joins `-ArgumentList` arrays; pass `windows_start_process_argument_list` as its one ready-made argument string instead. This invokes the bundled waiter through the exact Node runtime that is already running aiterm, including on native Windows where npm's human-facing bin is a PowerShell script shim and install paths may contain spaces. `wait_command` remains a compatibility display string for humans. The waiter observes the harness-owned completion source, plus Claude's additive launch hook, as a **pure reader** and exits with a one-line `aiterm.agent-wait-result.v1` receipt. **Exit ≠ done**: the receipt's `outcome` is authoritative (`0` = `done`, `3` = `timeout`, `4` = `closed`, `1` = error).
-3. **The parent never runs the waiter in its own foreground.** Waiting is correct — but the waiter is a separate process, not the parent's turn. A harness that re-invokes its agent when a background task exits (Claude Code) runs the waiter **in the background** and gets woken with zero polling. So that this is not left to interpretation, aiterm reads `clientInfo.name` from the MCP `initialize` handshake and its receipts name the concrete invocation for the detected host — for Claude Code, literally `Bash(command: "aiterm-wait …", run_in_background: true)`. Unknown or undeclared hosts get the generic "start it as a process that does not block the parent's turn" wording; nothing else about the contract changes. Every receipt leads with the same rule: dispatch and let go, then go do something else or end the turn.
+3. **親自身のforegroundでwaiterを実行しない。** receiptのprocess起動情報を、そのhostが持つバックグラウンドprocess APIへ渡す。親は別作業へ進むかturnを終え、process終了の通知で続行する。
 4. Collect the result exactly as before: `pty_read(agent_transcript: true)`, or `claude_turn recover` for durable Claude operations. The waiter carries the signal, never the payload.
 
 **If your host has no completion push** (no mechanism that re-invokes the agent when a background process exits), `--timeout 0` is a one-shot check instead of a wait: it scans the event file once and returns `running` (exit `5`) when the turn is still in flight, `done` (exit `0`) when it finished, `closed` (exit `4`) when the session is gone. It is deliberately absent from the receipts and tool descriptions — a host that *does* get pushed should be woken, not poll. An unknown session name is an error, never `running`, so a typo cannot masquerade as a child that is still working.

package/dist/claude-parent-hook.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+// Claude Codeが直接起動する公式hook。MCP stdioとは別processで本文をstderrへ返す。
+import { prepareClaudeHookRequest, runClaudeResultHook, closeClaudeParentSession } from "./claude-parent-receiver.js";
+async function main() {
+    let input = "";
+    process.stdin.setEncoding("utf8");
+    for await (const chunk of process.stdin)
+        input += chunk;
+    const event = JSON.parse(input);
+    switch (event.hook_event_name) {
+        case "PreToolUse":
+            prepareClaudeHookRequest(event);
+            break;
+        case "PostToolUse":
+            process.exitCode = await runClaudeResultHook(event, text => new Promise((resolve, reject) => {
+                process.stderr.write(text, error => error ? reject(error) : resolve());
+            }));
+            break;
+        case "SessionEnd":
+            closeClaudeParentSession(event);
+            break;
+        default: throw new Error("CLAUDE_PARENT_HOOK_EVENT_INVALID: 未対応のhookです");
+    }
+}
+main().catch(error => {
+    process.stderr.write(`${error instanceof Error ? error.message : "CLAUDE_PARENT_HOOK_FAILED"}\n`);
+    process.exitCode = 2;
+});

package/dist/claude-parent-receiver.js

@@ -0,0 +1,214 @@
+// Claude Codeの公式hookを受信口にする。待機processはharnessが所有し、親のturnを止めない。
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { z } from "zod";
+import { ensureStateRoot, writeJson0600 } from "./agent-shared.js";
+import { readRuntimeProcesses } from "./process-runtime.js";
+import { AitermError } from "./errors.js";
+const requestId = z.string().regex(/^[A-Za-z0-9_-]{1,160}$/);
+const invocationSchema = z.object({
+    request_id: requestId, session_id: z.uuid(), agent_id: z.string().nullable(),
+    parent_pid: z.number().int().positive(), parent_started_identity: z.string(),
+}).strict();
+export const claudeParentSchema = z.object({
+    kind: z.literal("claude"), request_id: requestId, session_id: z.uuid(), hook_root: z.string(),
+}).strict();
+export class ClaudeDeliveryError 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;
+    }
+}
+function defaultRoot() { return path.join(ensureStateRoot(), "claude-parent-hooks"); }
+function processIdentity(pid) { return readRuntimeProcesses().find(entry => entry.pid === pid)?.started_identity; }
+function directory(parent) { return path.join(parent.hook_root, parent.request_id); }
+function readInvocation(parent) {
+    let value;
+    try {
+        value = invocationSchema.parse(JSON.parse(fs.readFileSync(path.join(directory(parent), "request.json"), "utf8")));
+    }
+    catch {
+        throw new ClaudeDeliveryError("CLAUDE_PARENT_HOOK_UNAVAILABLE", "親のhook記録がありません。aiterm-setupを実行し、Claude Codeのhookを有効にしてください");
+    }
+    if (value.request_id !== parent.request_id || value.session_id !== parent.session_id) {
+        throw new ClaudeDeliveryError("CLAUDE_PARENT_SESSION_MISMATCH", "要求とhookの会話が一致しません");
+    }
+    return value;
+}
+function assertOpen(parent) {
+    if (fs.existsSync(path.join(directory(parent), "closed.json"))) {
+        throw new ClaudeDeliveryError("CLAUDE_PARENT_SESSION_CLOSED", "依頼元の会話は終了しました。回答を別の会話へ送っていません");
+    }
+}
+export function prepareClaudeHookRequest(input, root = defaultRoot()) {
+    const event = z.object({ session_id: z.uuid(), tool_use_id: requestId, agent_id: z.string().optional() }).parse(input);
+    const identity = processIdentity(process.ppid);
+    if (!identity)
+        throw new ClaudeDeliveryError("CLAUDE_PARENT_PROCESS_UNAVAILABLE", "hookを起動した親processを確認できません");
+    const dir = path.join(root, event.tool_use_id);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    writeJson0600(path.join(dir, "request.json"), {
+        request_id: event.tool_use_id, session_id: event.session_id, agent_id: event.agent_id ?? null,
+        parent_pid: process.ppid, parent_started_identity: identity,
+    });
+}
+/** 起動時envのsession IDは/clearで古くなるため、実際のPreToolUseとの相関だけを使う。 */
+export function claudeParentFromRequest(clientName, metadata, root = defaultRoot()) {
+    if (clientName !== "claude-code")
+        return null;
+    const parsed = requestId.safeParse(metadata?.["claudecode/toolUseId"]);
+    if (!parsed.success)
+        throw new ClaudeDeliveryError("CLAUDE_PARENT_ID_UNAVAILABLE", "MCP要求にtoolUseIdがありません。対応するClaude Codeへ更新してください");
+    let invocation;
+    try {
+        invocation = invocationSchema.parse(JSON.parse(fs.readFileSync(path.join(root, parsed.data, "request.json"), "utf8")));
+    }
+    catch {
+        throw new ClaudeDeliveryError("CLAUDE_PARENT_HOOK_UNAVAILABLE", "親のPreToolUse hookを確認できません。aiterm-setupを実行し、hookを有効にしてください");
+    }
+    const parent = { kind: "claude", request_id: parsed.data, session_id: invocation.session_id, hook_root: root };
+    verifyClaudeParent(parent);
+    return parent;
+}
+export function verifyClaudeParent(parent) {
+    const invocation = readInvocation(parent);
+    if (invocation.agent_id)
+        throw new ClaudeDeliveryError("CLAUDE_PARENT_SUBAGENT_UNSUPPORTED", "agent_id付きのClaude会話（--agent起動またはnative subagent）への自動配送には対応していません");
+    assertOpen(parent);
+}
+export function bindClaudeParentDelivery(parent, deliveryId) {
+    verifyClaudeParent(parent);
+    writeJson0600(path.join(directory(parent), "delivery.json"), { delivery_id: z.uuid().parse(deliveryId) });
+}
+/** SessionEndはその時点の依頼だけを終了する。同じ会話をresumeした新規依頼は別requestになる。 */
+export function closeClaudeParentSession(input, root = defaultRoot()) {
+    const { session_id } = z.object({ session_id: z.uuid() }).parse(input);
+    if (!fs.existsSync(root))
+        return;
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const file = path.join(root, entry.name, "request.json");
+        if (!fs.existsSync(file))
+            continue;
+        const invocation = invocationSchema.parse(JSON.parse(fs.readFileSync(file, "utf8")));
+        if (invocation.session_id === session_id)
+            writeJson0600(path.join(root, entry.name, "closed.json"), { session_id });
+    }
+}
+// filesystemの通知を先に登録してから状態を読む。producerの終了は低頻度のprocess照合でも検出する。
+function waitForFileState(dir, inspect) {
+    return new Promise((resolve, reject) => {
+        let finished = false;
+        let timer;
+        const watcher = fs.watch(dir, () => check());
+        const finish = (error, value) => {
+            if (finished)
+                return;
+            finished = true;
+            watcher.close();
+            if (timer)
+                clearInterval(timer);
+            if (error)
+                reject(error);
+            else
+                resolve(value);
+        };
+        const check = () => {
+            if (finished)
+                return;
+            try {
+                const value = inspect();
+                if (value !== undefined)
+                    finish(null, value);
+            }
+            catch (error) {
+                finish(error);
+            }
+        };
+        watcher.on("error", error => finish(error));
+        timer = setInterval(check, 5000);
+        check();
+    });
+}
+function assertParentAlive(invocation) {
+    if (processIdentity(invocation.parent_pid) !== invocation.parent_started_identity) {
+        throw new ClaudeDeliveryError("CLAUDE_PARENT_PROCESS_CLOSED", "依頼元のClaude processは終了しました。回答は保存したままです");
+    }
+}
+export async function submitClaudeParentAnswer(parent, deliveryId, text) {
+    const invocation = readInvocation(parent);
+    const dir = directory(parent);
+    // 会話終了でも確定本文を失わない。終了判定より先に保存する。
+    writeJson0600(path.join(dir, "answer.json"), { delivery_id: deliveryId, text });
+    await waitForFileState(dir, () => {
+        const emitted = path.join(dir, "emitted.json");
+        if (fs.existsSync(emitted)) {
+            const value = JSON.parse(fs.readFileSync(emitted, "utf8"));
+            if (value.delivery_id !== deliveryId)
+                throw new ClaudeDeliveryError("CLAUDE_PARENT_DELIVERY_MISMATCH", "hookの配送IDが一致しません", true);
+            return true;
+        }
+        assertOpen(parent);
+        const failed = path.join(dir, "failed.json");
+        if (fs.existsSync(failed)) {
+            const value = JSON.parse(fs.readFileSync(failed, "utf8"));
+            throw new ClaudeDeliveryError("CLAUDE_PARENT_HOOK_FAILED", "親へのhook出力が失敗しました。回答は保存したままです", value.outcome_unknown === true);
+        }
+        const hookFile = path.join(dir, "hook.json");
+        if (fs.existsSync(hookFile)) {
+            const hook = z.object({ pid: z.number().int().positive(), started_identity: z.string() }).parse(JSON.parse(fs.readFileSync(hookFile, "utf8")));
+            if (processIdentity(hook.pid) !== hook.started_identity) {
+                throw new ClaudeDeliveryError("CLAUDE_PARENT_HOOK_CLOSED", "親の受信hookが終了しました。自動再送はしていません", fs.existsSync(path.join(dir, "sending.json")));
+            }
+        }
+        assertParentAlive(invocation);
+        return undefined;
+    });
+    return { queued_submission_id: null };
+}
+export async function runClaudeResultHook(input, emit, root = defaultRoot()) {
+    const event = z.object({ session_id: z.uuid(), tool_use_id: requestId }).parse(input);
+    const parent = { kind: "claude", request_id: event.tool_use_id, session_id: event.session_id, hook_root: root };
+    const invocation = readInvocation(parent);
+    const dir = directory(parent);
+    const binding = path.join(dir, "delivery.json");
+    if (!fs.existsSync(binding)) {
+        fs.rmSync(dir, { recursive: true });
+        return 0;
+    }
+    const deliveryId = z.uuid().parse(JSON.parse(fs.readFileSync(binding, "utf8")).delivery_id);
+    const identity = processIdentity(process.pid);
+    if (!identity)
+        throw new ClaudeDeliveryError("CLAUDE_PARENT_HOOK_UNAVAILABLE", "受信hookのprocessを確認できません");
+    writeJson0600(path.join(dir, "hook.json"), { pid: process.pid, started_identity: identity });
+    try {
+        const answer = await waitForFileState(dir, () => {
+            if (fs.existsSync(path.join(dir, "closed.json")))
+                return null;
+            assertParentAlive(invocation);
+            const file = path.join(dir, "answer.json");
+            if (!fs.existsSync(file))
+                return undefined;
+            const value = z.object({ delivery_id: z.uuid(), text: z.string() }).strict().parse(JSON.parse(fs.readFileSync(file, "utf8")));
+            if (value.delivery_id !== deliveryId)
+                throw new ClaudeDeliveryError("CLAUDE_PARENT_DELIVERY_MISMATCH", "保存された回答の配送IDが一致しません");
+            return value;
+        });
+        if (!answer)
+            return 0;
+        assertOpen(parent);
+        writeJson0600(path.join(dir, "sending.json"), { delivery_id: deliveryId });
+        await emit(answer.text);
+        writeJson0600(path.join(dir, "emitted.json"), { delivery_id: deliveryId });
+        // Claudeが定めるasyncRewakeの再開信号。子の成功/失敗は本文のoutcomeで区別する。
+        return 2;
+    }
+    catch (error) {
+        writeJson0600(path.join(dir, "failed.json"), { outcome_unknown: fs.existsSync(path.join(dir, "sending.json")) });
+        throw error;
+    }
+}

package/dist/codex-parent-receiver.js

@@ -0,0 +1,135 @@
+// Codex親の公式受信キューへの接続。親threadのload／resumeやDesktop固有通信は行わない。
+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;
+    }
+}
+/** modelの引数ではなく、CodexがMCP要求へ付けるmetadataだけを宛先にする。 */
+export function codexParentFromRequest(clientName, metadata) {
+    if (clientName !== "codex-mcp-client")
+        return null;
+    const threadId = metadata?.threadId;
+    if (typeof threadId !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(threadId)) {
+        throw new CodexDeliveryError("CODEX_PARENT_ID_UNAVAILABLE", "MCP要求に親のthreadIdがありません。対応するCodexへ更新してください");
+    }
+    return { thread_id: threadId, codex_home: path.resolve(realCodexHome()) };
+}
+async function withCodexReceiver(parent, action, runtime = {}) {
+    const executable = runtime.executable ?? resolveAgentBin("codex");
+    if (!executable)
+        throw new CodexDeliveryError("CODEX_RECEIVER_UNAVAILABLE", "Codexの実行ファイルを確認できません");
+    const child = spawn(executable, runtime.args ?? ["app-server", "--listen", "stdio://"], {
+        stdio: ["pipe", "pipe", "ignore"],
+        env: { ...process.env, CODEX_HOME: parent.codex_home },
+        windowsHide: true,
+    });
+    const pending = new Map();
+    let sequence = 0;
+    let stopped = false;
+    let transportError = null;
+    const failTransport = (message) => {
+        transportError = message;
+        for (const item of pending.values()) {
+            clearTimeout(item.timer);
+            item.reject(new CodexDeliveryError("CODEX_RECEIVER_TRANSPORT_FAILED", message, item.method === "thread/queue/add"));
+        }
+        pending.clear();
+    };
+    child.on("error", (error) => failTransport(`Codexを起動できません（${error.code ?? "unknown"}）`));
+    child.stdin.on("error", (error) => failTransport(`Codexへの書込みに失敗しました（${error.code ?? "unknown"}）`));
+    const exited = new Promise((resolve) => child.once("close", (code, signal) => {
+        if (!stopped)
+            failTransport(`Codexの接続が終了しました（exit=${code}, signal=${signal}）`);
+        resolve();
+    }));
+    const reader = createInterface({ input: child.stdout });
+    reader.on("line", (line) => {
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            failTransport("Codexが不正なJSON応答を返しました");
+            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.method === "thread/queue/add"));
+    });
+    const request = (method, params) => new Promise((resolve, reject) => {
+        if (transportError) {
+            reject(new CodexDeliveryError("CODEX_RECEIVER_TRANSPORT_FAILED", transportError));
+            return;
+        }
+        const id = ++sequence;
+        const timer = setTimeout(() => {
+            pending.delete(id);
+            reject(new CodexDeliveryError("CODEX_RECEIVER_TIMEOUT", `${method}の応答を確認できません`, method === "thread/queue/add"));
+        }, runtime.timeout_ms ?? 15_000);
+        pending.set(id, { resolve, reject, timer, method });
+        child.stdin.write(JSON.stringify({ id, method, params }) + "\n");
+    });
+    try {
+        await request("initialize", { clientInfo: { name: "aiterm_parent_delivery", version: "1" }, capabilities: { experimentalApi: true } });
+        child.stdin.write(JSON.stringify({ method: "initialized" }) + "\n");
+        return await action(request);
+    }
+    finally {
+        stopped = true;
+        for (const item of pending.values())
+            clearTimeout(item.timer);
+        pending.clear();
+        child.stdin.end();
+        // stdio終了を公式processへ伝える。終了しない外部processだけを明示的に停止する。
+        const terminate = setTimeout(() => child.kill("SIGKILL"), 2_000);
+        await exited;
+        clearTimeout(terminate);
+        reader.close();
+    }
+}
+/** 子へ送る前に、同じstoreの宛先と公式キューの対応を確認する。本文は保存・表示しない。 */
+export async function verifyCodexParent(parent, runtime) {
+    await withCodexReceiver(parent, async (request) => {
+        const response = await request("thread/read", { threadId: parent.thread_id, includeTurns: false });
+        if (response?.thread?.id !== parent.thread_id) {
+            throw new CodexDeliveryError("CODEX_PARENT_UNAVAILABLE", "同じCodex環境で親threadを確認できません");
+        }
+        const subagent = response.thread.source?.subAgent;
+        if (subagent && typeof subagent === "object" && "thread_spawn" in subagent) {
+            throw new CodexDeliveryError("CODEX_PARENT_UNSUPPORTED", "Codexのnative sub-agentは外部processからのキュー入力を受け付けません");
+        }
+        await request("thread/queue/list", { threadId: parent.thread_id, limit: 1 });
+    }, runtime);
+}
+export async function submitCodexParentAnswer(parent, deliveryId, text, runtime) {
+    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);
+}