aiterm-mcp 0.33.1 → 0.34.0

package/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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 +1617,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.33.1...HEAD
+[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.34.0...HEAD
+[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親には回答本文を自動配送し、それ以外の親の完了待ちは `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.34.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親には回答本文を公式受信キューへ自動配送する。それ以外の親は`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親には回答が自動で届く。それ以外の親:
 $ 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,15 @@ 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親への回答自動配送
+
+Codexから子を起動・通常dispatchした後は、別作業へ進むか親のturnを終了するだけでよい。Aitermが完了を観測し、加工前の回答を保存して、依頼元Codexの公式受信キューへ送る。親はidleになった後に回答を処理する。waiter、`pty_read`による回答回収、子への送信指示は不要。Desktop固有の接続を使わず、CLIでも同じ経路になる。子は全対応harnessから選べる。Claude等の親は既存のwaiter経路を使う。
+
+自動配送時はreceiptに`parent_delivery`が付き、`wait_process`／`wait_command`はnullになる。`pty_observe`の`parent_deliveries`で`waiting`、`ready`、`sending`、`submitted`、`failed`、`unknown`を確認できる。`submitted`はキューの受付済みであり、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入力を拒否するため、自動配送の親としては未対応。
+
+
 ### トークン削減
 
 - `pty_read` は既定で制御文字除去・連続重複圧縮・head+tail 折りたたみ（＋復元ヒント・メタ併記）をかける。

package/README.md

@@ -176,8 +176,8 @@ 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
+every send to an agent session is a non-blocking dispatch. Codex parents now receive the complete answer automatically; other parents use the
+`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.
@@ -187,7 +187,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.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.34.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 +227,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.
+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 Codex parents receive the answer automatically through the official input queue. Other parents use [`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.
 
 `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 +250,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 parents receive the answer automatically. For other parents:
 $ 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,7 +551,13 @@ 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 parents receive child answers automatically.** Launch or send a request, then continue other work or end the turn. Aiterm observes the child, saves the unabridged answer, and submits it to the requesting parent's official Codex input queue. The parent processes it when idle. No waiter, `pty_read`, child callback instructions, or Desktop-specific connection is needed. This covers all supported child harnesses; Claude and other parent hosts retain the waiter flow below.
+
+Automatic receipts include `parent_delivery` and set `wait_process` / `wait_command` to null. `pty_observe` exposes `parent_deliveries`: `waiting`, `ready`, `sending`, `submitted`, `failed`, or `unknown`. `submitted` means accepted by the queue, not read by the model. Aiterm retains the answer and resumes unsent work after an MCP restart. An interrupted submission becomes `unknown` and is not blindly retried.
+
+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 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).

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);
+}

package/dist/core.js

@@ -2387,11 +2387,14 @@ async function settlePublishedClaudeCompletionMarker(meta, marker) {
 /** agent harness の構造化 transcript から直近完了ターンの最終回答と相関情報を読む。 */
 export async function readAgentTranscriptResult(name, o = {}) {
     const meta = loadAgentMetadata(name);
+    if (o.completion && (o.completion.outcome !== "done" || o.completion.launch_id !== meta.launch_id || o.completion.session_id !== name)) {
+        throw new AitermError("回収対象の完了情報がagent launchと一致しません", 2);
+    }
     const operationId = o.operation_id == null ? null : validateOperationId(o.operation_id);
     if (operationId && meta.kind !== "claude") {
         throw new AitermError("operation_id付き回収はClaude agent sessionだけで使用できます", 2);
     }
-    if (meta.kind === "claude") {
+    if (meta.kind === "claude" && !o.completion) {
         let active = readClaudeOperationMarker(meta);
         if (active)
             active = await settlePublishedClaudeCompletionMarker(meta, active);
@@ -2407,10 +2410,13 @@ export async function readAgentTranscriptResult(name, o = {}) {
         throw new AitermError(`agent session '${name}' はまだターンが完了していません。agent_done 完了後に再取得してください。${agentWaitGuide(name)}`, 2);
     }
     const done = latestAgentDoneEvent(meta, operationId);
+    if (o.completion && meta.kind !== "codex" && (!done || done.turn_id !== o.completion.turn_id || done.operation_id !== o.completion.operation_id)) {
+        throw new AitermError("回収対象の完了情報が置換されました。別の回答は配送しません", 2);
+    }
     if (operationId && !done) {
         throw new AitermError(`operation ${operationId} はまだ完了していません。同じoperation_idで後から再取得してください。${agentWaitGuide(name)}`, 2);
     }
-    const turnId = done?.turn_id ?? null;
+    const turnId = o.completion?.turn_id ?? done?.turn_id ?? null;
     let text = "";
     if (meta.kind === "claude") {
         if (!done)
@@ -2421,7 +2427,7 @@ export async function readAgentTranscriptResult(name, o = {}) {
         text = cursorTranscriptText(meta, readTranscriptLines, transcriptUnavailable);
     }
     else if (meta.kind === "codex") {
-        text = codexTranscriptText(meta, turnId, readTranscriptLines, transcriptUnavailable);
+        text = codexTranscriptText(meta, turnId, readTranscriptLines, transcriptUnavailable, o.completion !== undefined);
     }
     else {
         if (!done)
@@ -2433,7 +2439,7 @@ export async function readAgentTranscriptResult(name, o = {}) {
     if (o.lines != null)
         text = text.split("\n").slice(-o.lines).join("\n");
     const rawChars = text.length;
-    const [body, outputMeta] = reduceOutput(text, name, true);
+    const [body, outputMeta] = o.raw ? [text, ""] : reduceOutput(text, name, true);
     const transcriptMeta = [
         "agent_transcript",
         `vendor=${meta.kind}`,
@@ -2568,6 +2574,10 @@ export function agentWaitLaunchForm(command) {
 }
 // dispatch / 起動時 prompt 送信後の共通案内。第一文で「待たない」を宣言し、待ち方は後段に置く。
 export function agentDispatchGuide(session, cursor) {
+    if (parentClientName === "codex-mcp-client") {
+        return "回答本文はAitermがこのCodex親へ自動配送する。wait起動・ポーリング・通常の回答回収は不要。" +
+            "親は作業を続けるかターンを終え、順番待ちから届く子の回答で続行する。";
+    }
     const cmd = `aiterm-wait --session ${session} --cursor ${cursor}`;
     return (`投げっぱなしでよい＝ここで待たない。親は自分の作業へ戻るか、このターンを終える。\n` +
         `完了通知: ${agentWaitLaunchForm(cmd)}。exit が完了通知（${AITERM_WAIT_OUTCOME_NOTE}）。\n` +
@@ -2575,6 +2585,8 @@ export function agentDispatchGuide(session, cursor) {
 }
 // 未完了 session へ触った時の共通案内。ここでも待つのは waiter プロセスであって親ではない。
 export function agentWaitGuide(session) {
+    if (parentClientName === "codex-mcp-client")
+        return "回答本文はこのCodex親へ自動配送される。親は作業を続けるかターンを終える。";
     const cmd = `aiterm-wait --session ${session ?? "<session_id>"} --cursor 0`;
     return `完了通知は ${agentWaitLaunchForm(cmd)} で受ける（親はここで待たない・polling 不要）。receipt の outcome=done を確認してから再取得する。`;
 }
@@ -2634,13 +2646,13 @@ export async function observeAgentDone(name, o = {}) {
     }
     const timeout = o.timeout ?? DEFAULT_AGENT_DONE_TIMEOUT;
     if (meta.kind === "codex" && meta.completion_route === "codex_transcript") {
-        return observeCodexDone(meta, timeout, o.cursor, detectAgentRateLimit);
+        return observeCodexDone(meta, timeout, o.cursor, detectAgentRateLimit, o.signal);
     }
     if (meta.kind === "cursor" && meta.completion_route === "cursor_transcript") {
-        return observeCursorDone(meta, timeout, o.cursor, detectAgentRateLimit);
+        return observeCursorDone(meta, timeout, o.cursor, detectAgentRateLimit, o.signal);
     }
     if ((meta.kind === "grok" || meta.kind === "composer") && meta.completion_route === "grok_transcript") {
-        return observeGrokDone(meta, timeout, o.cursor, detectAgentRateLimit);
+        return observeGrokDone(meta, timeout, o.cursor, detectAgentRateLimit, o.signal);
     }
     const metadataFile = agentMetadataPath(meta.aiterm_session, meta.launch_id);
     // 境界の優先順: dispatch receipt の event_cursor（起動順序に依存しない）→ operation相関
@@ -2671,6 +2683,7 @@ export async function observeAgentDone(name, o = {}) {
         error: apiError?.text ?? null,
     });
     for (;;) {
+        o.signal?.throwIfAborted();
         if (!fs.existsSync(metadataFile))
             return observation("closed");
         const size = safeStatSize(meta.event_file);
@@ -3103,6 +3116,9 @@ export async function sendInitialAgentPrompt(name, text, o = {}) {
     const promptText = meta.kind === "cursor" ? cursorPromptWithLineage(meta, text) : text;
     const startOffset = agentCompletionCursor(meta);
     try {
+        prepareSendText(promptText, { raw: false });
+        await o.before_send?.({ session_id: name, launch_id: meta.launch_id, vendor: meta.kind,
+            harness: agentHarness(meta.kind), event_cursor: startOffset, operation_id: null });
         if (meta.kind === "claude") {
             prepareSendText(text, { raw: false });
             reserveAnonymousClaudeTurn(meta);
@@ -3437,6 +3453,9 @@ export async function dispatchAgentTurn(name, text, o = {}) {
     const dispatchText = meta.kind === "cursor" && !meta.vendor_session_id
         ? `${subagentInstruction(meta)}\n\n${text}`
         : text;
+    prepareSendText(dispatchText, { raw: o.raw });
+    await o.before_send?.({ session_id: name, launch_id: meta.launch_id, vendor: meta.kind,
+        harness: agentHarness(meta.kind), event_cursor: startOffset, operation_id: operationId });
     if (meta.kind === "claude") {
         // durable／anonymousを分岐する前に同じsend preflightを通す。拒否されるpromptの
         // receipt／active markerだけを残して、来ないStopを待つ状態を作らない。
@@ -3517,7 +3536,7 @@ export async function steerAgentTurn(name, text) {
     sendKey(name, "Enter");
     return { ...receipt, delivery: "steered", pane_input_recovery: paneInputRecovery };
 }
-export async function runClaudeOperation({ session_id: name, action, operation_id: operationIdInput, text, }) {
+export async function runClaudeOperation({ session_id: name, action, operation_id: operationIdInput, text, before_send, }) {
     assertSessionName(name);
     if (action !== "issue" && action !== "recover") {
         throw new AitermError('action は "issue" または "recover" を指定してください', 2);
@@ -3532,7 +3551,7 @@ export async function runClaudeOperation({ session_id: name, action, operation_i
             throw new AitermError("claude_turn issueには空でないtextが必要です", 2);
         }
         // v0.16.0: issue は dispatch-only。完了通知は aiterm-wait --operation、回収は recover が担う。
-        dispatchReceipt = await dispatchAgentTurn(name, text, { operation_id: operationId });
+        dispatchReceipt = await dispatchAgentTurn(name, text, { operation_id: operationId, before_send });
     }
     else {
         if (text != null)
@@ -3873,7 +3892,7 @@ export function openAgent(kind, opts = {}) {
     }
     const driveHint = agentDone
         ? `TUI の描画には数秒かかる。少し置いてから pty_read(${sid}, screen:true) で画面を読み、` +
-            `turnはpty_send(${sid}, "...")で送る（自動で非ブロックdispatch＝投げっぱなしでよい・完了通知はaiterm-wait）。中断はpty_key(${sid}, "C-c")、` +
+            `turnはpty_send(${sid}, "...")で送る（自動で非ブロックdispatch。${parentClientName === "codex-mcp-client" ? "回答本文はCodex親へ自動配送する" : "完了通知はaiterm-wait"}）。中断はpty_key(${sid}, "C-c")、` +
             `Stopが来ない場合の解除はpty_close(${sid})を使う。`
         : `TUI の描画には数秒かかる。少し置いてから pty_read(${sid}, screen:true) で画面を読み、` +
             `pty_send(${sid}, "...") で入力・pty_key(${sid}, "Enter"/"Up"/"C-c" 等) で操作する（対話）。`;
@@ -3971,6 +3990,7 @@ export async function openAgentWithInitialPrompt(kind, opts = {}) {
         const initial = await sendInitialAgentPrompt(sid, prompt, {
             ready_timeout: opts.ready_timeout ?? undefined,
             trust_project: opts.trust_project,
+            before_send: opts.before_send,
         });
         return [sid, `${hint}\n${initial.text}`, initial.event_cursor, initial.submit_residue, initial.initial_prompt,
             { status: "ready", reason: "composer_ready" }];

package/dist/harnesses/codex.js

@@ -249,7 +249,7 @@ export function latestCodexCompletion(meta, readTranscriptLines) {
     }
     return latest;
 }
-export async function observeCodexDone(meta, timeout, requestedCursor, detectRateLimit) {
+export async function observeCodexDone(meta, timeout, requestedCursor, detectRateLimit, signal) {
     const metadataFile = agentMetadataPath(meta.aiterm_session, meta.launch_id);
     let transcript = codexRootTranscript(meta);
     const startOffset = requestedCursor ?? (transcript ? safeStatSize(transcript) : 0);
@@ -275,6 +275,7 @@ export async function observeCodexDone(meta, timeout, requestedCursor, detectRat
         error: null,
     });
     for (;;) {
+        signal?.throwIfAborted();
         if (!fs.existsSync(metadataFile))
             return observation("closed");
         transcript ??= codexRootTranscript(meta);
@@ -539,13 +540,42 @@ export function codexMoreReasoningChoice(screen) {
     return null;
 }
 // 回収対象turnの最終assistantメッセージをroot rollout transcriptから抽出する。
-export function codexTranscriptText(meta, turnId, readTranscriptLines, transcriptUnavailable) {
+export function codexTranscriptText(meta, turnId, readTranscriptLines, transcriptUnavailable, exactCompletion = false) {
     if (!meta.codex_home || !meta.vendor_session_id)
         transcriptUnavailable();
     const transcript = findLatestCodexTranscript(meta.codex_home, meta.vendor_session_id);
     if (!transcript)
         transcriptUnavailable();
     const lines = readTranscriptLines(transcript);
+    if (exactCompletion) {
+        // 同じturnの本文だけを使う。完了event内の本文と、turn ID付きoutput_textの両形式を扱う。
+        const matching = [];
+        for (const line of lines) {
+            let record;
+            try {
+                record = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const payload = record?.payload;
+            if (record?.type === "response_item" && payload?.type === "message" && payload?.role === "assistant"
+                && payload?.internal_chat_message_metadata_passthrough?.turn_id === turnId && Array.isArray(payload?.content)) {
+                for (const item of payload.content) {
+                    if (item?.type === "output_text" && typeof item.text === "string")
+                        matching.push(item.text);
+                }
+            }
+            if (record?.type === "event_msg" && payload?.type === "task_complete" && payload.turn_id === turnId) {
+                if (typeof payload.last_agent_message === "string")
+                    return payload.last_agent_message;
+                if (matching.length > 0)
+                    return matching.join("\n");
+                transcriptUnavailable();
+            }
+        }
+        transcriptUnavailable();
+    }
     const matching = [];
     let finalAnswer = "";
     for (const line of lines) {

package/dist/harnesses/cursor.js

@@ -183,7 +183,7 @@ export function latestCursorCompletion(meta, readTranscriptLines) {
         ? cursorCompletionEvent(meta, harnessSessionId, state.terminalRecord, `cursor:${state.userTurns}`)
         : null;
 }
-export async function observeCursorDone(meta, timeout, requestedCursor, detectRateLimit) {
+export async function observeCursorDone(meta, timeout, requestedCursor, detectRateLimit, signal) {
     const metadataFile = agentMetadataPath(meta.aiterm_session, meta.launch_id);
     let transcript = cursorTranscript(meta);
     const startBoundary = requestedCursor ?? (transcript ? cursorTranscriptState(transcript).userTurns : 0);
@@ -205,6 +205,7 @@ export async function observeCursorDone(meta, timeout, requestedCursor, detectRa
         error: null,
     });
     for (;;) {
+        signal?.throwIfAborted();
         if (!fs.existsSync(metadataFile))
             return observation("closed");
         transcript ??= cursorTranscript(meta);

package/dist/harnesses/grok.js

@@ -146,7 +146,7 @@ export function grokInitializationComplete(meta) {
     }
     return false;
 }
-export async function observeGrokDone(meta, timeout, requestedCursor, detectRateLimit) {
+export async function observeGrokDone(meta, timeout, requestedCursor, detectRateLimit, signal) {
     const metadataFile = agentMetadataPath(meta.aiterm_session, meta.launch_id);
     const transcript = grokEventsTranscript(meta);
     if (!transcript)
@@ -174,6 +174,7 @@ export async function observeGrokDone(meta, timeout, requestedCursor, detectRate
         error: ev?.done_status === "turn_error" ? ev.reason : null,
     });
     for (;;) {
+        signal?.throwIfAborted();
         if (!fs.existsSync(metadataFile))
             return observation("closed");
         if (fs.existsSync(transcript)) {

package/dist/index.js

@@ -15,19 +15,31 @@ import { z } from "zod";
 import * as core from "./core.js";
 import { runtimeErrorStoreDiagnostic } from "./runtime-error-store.js";
 import { createRequire } from "node:module";
+import { ParentDeliveryManager } from "./parent-delivery.js";
+import { codexParentFromRequest } from "./codex-parent-receiver.js";
 // package.json の version を実行時に読み、MCP initialize で配るサーバ版と一致させる。
 // createRequire を使うのは、import 属性 `with { type: "json" }` が Node 18.20+ 限定で
 // engines "node >=18"（18.0〜18.19）を SyntaxError で壊し、旧 `assert` 構文は逆に Node 22 で
 // 除去済み＝どちらの静的構文も 18〜22 全域を満たせないため（実行時 require が唯一全域で動く）。
 const pkg = createRequire(import.meta.url)("../package.json");
 const server = new McpServer({ name: "aiterm", version: pkg.version });
+let parentDelivery = null;
+async function deliveryForRequest(extra) {
+    const parent = codexParentFromRequest(server.server.getClientVersion()?.name, extra._meta);
+    if (!parent)
+        return null;
+    parentDelivery ??= new ParentDeliveryManager();
+    await parentDelivery.prepare(parent);
+    return parentDelivery.request(parent);
+}
 /**
  * dispatch 系の説明で共有する非ブロック規範。tool description は registerTool 時＝initialize 前に
  * 固定されるため親ホストを名指しできない（ホスト別の具体形は receipt 側が core.agentWaitLaunchForm で出す）。
  * ここでは「待つな」を断定形で先に置き、foreground 実行の禁止までを説明の側に含める。
  */
 const NON_BLOCKING_RULE = "dispatch した子は投げっぱなしでよい＝親はここで待たない。" +
-    "完了通知はreceiptの `wait_process.executable` と `wait_process.args` をそのまま親のターンを塞がない別プロセスAPIへ渡して受け、" +
+    "Codex親にはAitermが回答本文を自動配送する。parent_deliveryがある場合はwait起動も通常の回答回収も不要。親は作業を続けるかターンを終える。" +
+    "その他の親では、完了通知をreceiptの `wait_process.executable` と `wait_process.args` をそのまま親のターンを塞がない別プロセスAPIへ渡して受け、" +
     "PowerShell 7のStart-Processだけは `windows_start_process_argument_list` を単一文字列として渡す。" +
     `exit を完了通知として扱う（${core.AITERM_WAIT_OUTCOME_NOTE}。ポーリング不要）。` +
     "`wait_command` は人間向け互換表示でありprocess境界へ使わない。foreground実行で親のターンを塞がない。";
@@ -38,6 +50,11 @@ const waitProcessOutputSchema = z
     windows_start_process_argument_list: z.string().nullable(),
 })
     .nullable();
+const parentDeliveryOutputSchema = z.object({
+    delivery_id: z.string(), state: z.enum(["waiting", "ready", "sending", "submitted", "failed", "unknown"]),
+    child_outcome: z.enum(["done", "closed", "rate_limited", "error"]).nullable(),
+    child_turn_id: z.string().nullable(), queued_submission_id: z.string().nullable(), error_code: z.string().nullable(),
+});
 function ok(s) {
     return { content: [{ type: "text", text: s }] };
 }
@@ -116,7 +133,7 @@ server.registerTool("pty_send", {
         "agent session（launcher起動）への send は自動で dispatch になる: TUI の ready gate と submit 分離を通して即返り、" +
         "receipt の event_cursor を返す。" +
         NON_BLOCKING_RULE +
-        "結果回収は pty_read(agent_transcript:true)、Claude の durable turn は claude_turn を使う。" +
+        "自動配送以外の結果回収は pty_read(agent_transcript:true)、Claude の durable turn は claude_turn を使う。" +
         "force:true は非Claude agent sessionへの手動介入用の素送信。aiterm相関付きClaudeの承認UIはclaude_approvalを使う。",
     inputSchema: {
         session_id: z.string(),
@@ -149,6 +166,7 @@ server.registerTool("pty_send", {
         session_id: z.string(),
         event_cursor: z.number().int().nullable(),
         wait_process: waitProcessOutputSchema,
+        parent_delivery: parentDeliveryOutputSchema.optional(),
         launch_id: z.string().nullable(),
         vendor: z.enum(["claude", "codex", "grok", "composer", "cursor"]).nullable(),
         harness: z.enum(["claude-code", "codex-cli", "grok-cli", "cursor-cli"]).nullable(),
@@ -158,7 +176,8 @@ server.registerTool("pty_send", {
         // dispatch前に行った pane 入力の回復（"fg" / "fg_stopped" / "stty_raw"）。通常送信では省略（additive）。
         pane_input_recovery: z.array(z.string()).optional(),
     },
-}, async ({ session_id, text, enter, mark, force, rtk, raw, image }) => {
+}, async ({ session_id, text, enter, mark, force, rtk, raw, image }, extra) => {
+    let delivery = null;
     try {
         if (!force && core.isAgentSession(session_id)) {
             if (enter === false)
@@ -167,8 +186,9 @@ server.registerTool("pty_send", {
                 throw new Error("agent session への dispatch は mark:true と併用できません");
             if (rtk)
                 throw new Error("agent session への dispatch は rtk:true と併用できません");
-            const receipt = await core.dispatchAgentTurn(session_id, core.attachImages(text, image), { raw });
-            const waitProcess = core.agentWaitProcess(receipt.session_id, receipt.event_cursor);
+            delivery = await deliveryForRequest(extra);
+            const receipt = await core.dispatchAgentTurn(session_id, core.attachImages(text, image), { raw, before_send: delivery?.before_send });
+            const waitProcess = delivery ? null : core.agentWaitProcess(receipt.session_id, receipt.event_cursor);
             return {
                 content: [
                     {
@@ -184,6 +204,7 @@ server.registerTool("pty_send", {
                     session_id: receipt.session_id,
                     event_cursor: receipt.event_cursor,
                     wait_process: waitProcess,
+                    ...(delivery?.result() ? { parent_delivery: delivery.result() } : {}),
                     launch_id: receipt.launch_id,
                     vendor: receipt.vendor,
                     harness: receipt.harness,
@@ -212,6 +233,7 @@ server.registerTool("pty_send", {
         };
     }
     catch (e) {
+        delivery?.failed(e);
         return fail(e);
     }
 });
@@ -385,6 +407,7 @@ server.registerTool("pty_close", {
     },
 }, async ({ session_id }) => {
     try {
+        await parentDelivery?.beforeChange(session_id);
         const result = core.closeSessionResult(session_id);
         return {
             content: [{ type: "text", text: `closed ${session_id}` }],
@@ -437,13 +460,15 @@ server.registerTool("pty_observe", {
         pane_process: nativeProcessIdentitySchema.nullable(), harness_process: nativeProcessIdentitySchema.nullable(),
         process_identity: nativeProcessIdentitySchema.nullable(),
         token_hint: z.number().nullable(),
+        parent_deliveries: z.array(parentDeliveryOutputSchema).optional(),
         activity: z.object({ cursor: z.string().nullable(), output_changed: z.boolean().nullable(),
             cpu_seconds: z.number().nullable(), cpu_delta_seconds: z.number().nullable(), cpu_delta_complete: z.boolean().nullable(),
             background_cpu_seconds: z.number().nullable(), background_cpu_delta_seconds: z.number().nullable(), background_cpu_delta_complete: z.boolean().nullable() }),
     },
 }, async ({ session_id, cursor }) => {
     try {
-        const result = core.observeSession(session_id, cursor);
+        const observation = core.observeSession(session_id, cursor);
+        const result = { ...observation, ...(parentDelivery ? { parent_deliveries: parentDelivery.status(session_id) } : {}) };
         return { ...ok(JSON.stringify(result)), structuredContent: { ...result } };
     }
     catch (e) {
@@ -493,21 +518,27 @@ server.registerTool("claude_turn", {
         // issue時のみdispatch由来のsubmit座礁観測（additive）。true=composerに残存を確認（submit未成立の疑い）/
         // false=残存を観測せず（成立の保証ではない）/ recover等はnull。
         submit_residue: z.boolean().nullable(),
+        parent_delivery: parentDeliveryOutputSchema.optional(),
     },
-}, async ({ action, session_id, operation_id, text }) => {
+}, async ({ action, session_id, operation_id, text }, extra) => {
+    let delivery = null;
     try {
+        if (action === "issue")
+            delivery = await deliveryForRequest(extra);
         const result = await core.runClaudeOperation({
             action,
             session_id,
             operation_id,
             text: text ?? undefined,
+            before_send: delivery?.before_send,
         });
         return {
             content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: { ...result },
+            structuredContent: { ...result, ...(delivery?.result() ? { parent_delivery: delivery.result() } : {}) },
         };
     }
     catch (e) {
+        delivery?.failed(e);
         return fail(e);
     }
 });
@@ -613,12 +644,7 @@ const agentEffortDesc = (kind) => kind === "claude"
             : "Grok Build reasoning effort。利用可能値はCLI／modelのlive catalogに従う。省略時はCLI／model既定。";
 // 全launcher共通の完了受信ガイド。machine callerはreceiptのwait_processをそのまま別process APIへ渡す。
 // wait_commandは人間向け互換表示。文型は NON_BLOCKING_RULE と同じく「待たない」が先。
-const agentCompletionDesc = `起動して投げたら投げっぱなしでよい＝親はここで待たない。` +
-    `完了通知は起動応答またはpty_send dispatch receiptの wait_processを、親のターンを塞がない` +
-    `別プロセスAPIへexecutable／argsの境界を保ったまま渡して受ける` +
-    `（PowerShell 7のStart-Processはwindows_start_process_argument_listを使う）` +
-    `（${core.AITERM_WAIT_OUTCOME_NOTE}。ポーリング不要・foreground実行はしない）。` +
-    `wait_commandは人間向け互換表示。結果回収は pty_read(agent_transcript:true)。`;
+const agentCompletionDesc = NON_BLOCKING_RULE + "自動配送以外の結果回収は pty_read(agent_transcript:true)。";
 const agentEnvironmentDesc = `通常CLIと同じHOME・cwd・project/user/local設定・MCP・plugin・skill・permission/trustを共有する。` +
     `aitermは完了相関stateだけをlaunch単位で所有する。起動されたagentにはsub-agent自己認識、親session、` +
     `delegation depth/lineage、delegation_allowed=trueを注入し、必要な追加委譲は許可する。`;
@@ -627,14 +653,17 @@ const initialPromptDeliverySchema = z.object({
     reason: z.string(), turn_started: z.boolean().nullable(),
 });
 const agentStartupSchema = z.object({ status: z.enum(["ready", "not_checked", "blocked"]), reason: z.string() });
-async function launchAgent(kind, args) {
+async function launchAgent(kind, args, extra) {
     const supportsWriteScope = kind !== "claude";
     const { prompt, image, throughline_source_session, throughline_supplement_file, model, reasoning_effort, env_vars, cwd, session_name, launch_operation_id, write_scope, trust_project } = args;
+    let delivery = null;
     try {
         if (!supportsWriteScope && write_scope !== undefined) {
             throw new core.AitermError("claude-code harnessはwrite_scopeに対応していません。指定を外してください", 2);
         }
         const initialPrompt = image && image.length > 0 ? core.attachImages(prompt ?? "", image) : prompt ?? undefined;
+        if (initialPrompt || throughline_source_session)
+            delivery = await deliveryForRequest(extra);
         const [sid, hint, eventCursor, submitResidue, initialDelivery, startup] = await core.openAgentWithInitialPrompt(kind, {
             prompt: initialPrompt,
             throughline_source_session,
@@ -643,6 +672,7 @@ async function launchAgent(kind, args) {
             reasoning_effort: reasoning_effort ?? undefined,
             env_vars,
             trust_project,
+            before_send: delivery?.before_send,
             cwd: cwd ?? undefined,
             session_name: session_name ?? undefined,
             launch_operation_id: launch_operation_id ?? undefined,
@@ -655,8 +685,9 @@ async function launchAgent(kind, args) {
             session_id: sid,
             managed_completion: true,
             event_cursor: eventCursor,
-            wait_process: eventCursor === null ? null : core.agentWaitProcess(sid, eventCursor),
-            wait_command: eventCursor === null ? null : `aiterm-wait --session ${sid} --cursor ${eventCursor}`,
+            wait_process: eventCursor === null || delivery ? null : core.agentWaitProcess(sid, eventCursor),
+            wait_command: eventCursor === null || delivery ? null : `aiterm-wait --session ${sid} --cursor ${eventCursor}`,
+            ...(delivery?.result() ? { parent_delivery: delivery.result() } : {}),
             submit_residue: submitResidue,
             initial_prompt: initialDelivery,
             startup,
@@ -676,14 +707,16 @@ async function launchAgent(kind, args) {
         };
     }
     catch (e) {
+        delivery?.failed(e);
         if (e instanceof core.AgentLaunchPromptError) {
             return {
                 ...fail(e),
                 structuredContent: {
                     schema: "aiterm.agent-launch-result.v1", provider: kind, harness: core.agentHarness(kind),
                     session_id: e.session_id, managed_completion: true, event_cursor: e.event_cursor,
-                    wait_process: e.event_cursor === null ? null : core.agentWaitProcess(e.session_id, e.event_cursor),
-                    wait_command: e.event_cursor === null ? null : `aiterm-wait --session ${e.session_id} --cursor ${e.event_cursor}`,
+                    wait_process: e.event_cursor === null || delivery ? null : core.agentWaitProcess(e.session_id, e.event_cursor),
+                    wait_command: e.event_cursor === null || delivery ? null : `aiterm-wait --session ${e.session_id} --cursor ${e.event_cursor}`,
+                    ...(delivery?.result() ? { parent_delivery: delivery.result() } : {}),
                     submit_residue: null, initial_prompt: e.initial_prompt, startup: e.startup,
                 },
             };
@@ -750,12 +783,13 @@ function registerAgentTool(toolName, kind, desc) {
             event_cursor: z.number().int().nullable(),
             wait_process: waitProcessOutputSchema,
             wait_command: z.string().nullable(),
+            parent_delivery: parentDeliveryOutputSchema.optional(),
             // 初回prompt dispatch後のsubmit座礁観測（additive）。true=composerに残存を確認（submit未成立の疑い）/
             // false=残存を観測せず（submit成立の保証ではない）/ null=promptなし・判定不能。
             submit_residue: z.boolean().nullable(),
             ...writeScopeOutputSchema,
         },
-    }, async (args) => launchAgent(kind, args));
+    }, async (args, extra) => launchAgent(kind, args, extra));
 }
 server.registerTool("agent_launch", {
     description: "エージェントを単一の標準入口から永続sessionへ起動する。harnessはagent loop・認証・hook・transcriptを所有する実行基盤、" +
@@ -788,11 +822,12 @@ server.registerTool("agent_launch", {
         event_cursor: z.number().int().nullable(),
         wait_process: waitProcessOutputSchema,
         wait_command: z.string().nullable(),
+        parent_delivery: parentDeliveryOutputSchema.optional(),
         submit_residue: z.boolean().nullable(),
         write_scope: z.string().optional(),
         write_scope_enforcement: z.enum(["enforced_read_only", "declaration_only_unsupported"]).optional(),
     },
-}, async ({ harness, ...args }) => launchAgent(kindForHarness(harness), args));
+}, async ({ harness, ...args }, extra) => launchAgent(kindForHarness(harness), args, extra));
 registerAgentTool("claude_agent", "claude", "【旧互換alias。新規連携は agent_launch(harness=claude-code)】Claude Codeの対話エージェントTUIを永続端末に起動する。`claude -p`ではなく、" +
     "同じ利用者可視sessionへpty_sendで継続入力する。" +
     agentEnvironmentDesc +
@@ -824,7 +859,13 @@ async function main() {
     // そのホストの実際の起動形で名指しする（実測: claude-code は initialize → notifications/initialized
     // → tools/list の順で送るため、どの tool 呼び出しより先に確定する）。取れない時は汎用文へ落ちるだけ。
     server.server.oninitialized = () => {
-        core.setParentClient(server.server.getClientVersion()?.name ?? null);
+        const name = server.server.getClientVersion()?.name;
+        core.setParentClient(name ?? null);
+        if (name === "codex-mcp-client")
+            parentDelivery ??= new ParentDeliveryManager();
+    };
+    server.server.onclose = () => {
+        void parentDelivery?.close().catch(() => process.stderr.write("aiterm: PARENT_DELIVERY_CLOSE_FAILED\n"));
     };
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/parent-delivery.js

@@ -0,0 +1,382 @@
+// Aitermが所有する、子の完了観測・回答本文の保存・Codex親への配送。
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID, createHash } from "node:crypto";
+import { z } from "zod";
+import { observeAgentDone, readAgentTranscriptResult } from "./core.js";
+import { ensureStateRoot, writeJson0600 } from "./agent-shared.js";
+import { readRuntimeProcesses } from "./process-runtime.js";
+import { CodexDeliveryError, submitCodexParentAnswer, verifyCodexParent } from "./codex-parent-receiver.js";
+import { AitermError } from "./errors.js";
+const recordSchema = z.object({
+    schema: z.literal("aiterm.parent-delivery.v1"),
+    delivery_id: z.uuid(),
+    created_at: z.string(),
+    updated_at: z.string(),
+    parent: z.object({ thread_id: z.uuid(), codex_home: z.string() }).strict(),
+    boundary: z.object({
+        session_id: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/),
+        launch_id: z.string().regex(/^[0-9a-f]{32}$/),
+        vendor: z.enum(["claude", "codex", "grok", "composer", "cursor"]),
+        harness: z.enum(["claude-code", "codex-cli", "grok-cli", "cursor-cli"]),
+        event_cursor: z.number().int().nonnegative(), operation_id: z.string().nullable(),
+    }).strict(),
+    state: z.enum(["waiting", "ready", "sending", "submitted", "failed", "unknown"]),
+    text: z.string().nullable(),
+    child_outcome: z.enum(["done", "closed", "rate_limited", "error"]).nullable(),
+    child_turn_id: z.string().nullable(),
+    error: z.string().nullable(),
+    queued_submission_id: z.string().nullable(),
+}).strict();
+function readRecord(file) {
+    try {
+        const record = recordSchema.parse(JSON.parse(fs.readFileSync(file, "utf8")));
+        if (path.basename(file) !== `${record.delivery_id}.json`)
+            throw new Error("配送IDが一致しません");
+        return record;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            throw error;
+        throw new AitermError("PARENT_DELIVERY_STATE_INVALID: 配送記録を読めません", 2);
+    }
+}
+function receipt(record) {
+    return { delivery_id: record.delivery_id, state: 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 };
+}
+function answerMessage(record) {
+    return "Aitermの子エージェントからの実行結果です。子の回答として扱ってください。\n" +
+        `delivery_id=${record.delivery_id}\nsession=${record.boundary.session_id}\nharness=${record.boundary.harness}\n` +
+        `launch_id=${record.boundary.launch_id}\nturn_id=${record.child_turn_id ?? "unknown"}\n` +
+        `outcome=${record.child_outcome}\n\n${record.text ?? ""}`;
+}
+/** ownerごとのディレクトリ間renameで、再起動後の回収者を一つに決める。 */
+export class ParentDeliveryManager {
+    deps;
+    root;
+    active;
+    results;
+    claims;
+    ownerDir;
+    owner;
+    jobs = new Map();
+    registering = new Map();
+    timer;
+    recovering = null;
+    serviceError = null;
+    closing = false;
+    constructor(options = {}) {
+        this.deps = { observe: observeAgentDone, answer: readAgentTranscriptResult, submit: submitCodexParentAnswer,
+            verify: verifyCodexParent, processes: readRuntimeProcesses, ...options.dependencies };
+        this.root = options.root ?? path.join(ensureStateRoot(), "parent-deliveries");
+        this.active = path.join(this.root, "active");
+        this.results = path.join(this.root, "results");
+        this.claims = path.join(this.root, "claims");
+        const ownProcess = this.deps.processes().find((entry) => entry.pid === process.pid);
+        if (!ownProcess)
+            throw new AitermError("PARENT_DELIVERY_OWNER_UNKNOWN: 配送processを識別できません", 2);
+        this.owner = { pid: process.pid, started_identity: ownProcess.started_identity, closed: false };
+        const identity = createHash("sha256").update(ownProcess.started_identity).digest("hex").slice(0, 16);
+        this.ownerDir = path.join(this.active, `${process.pid}-${identity}-${randomUUID()}`);
+        fs.mkdirSync(this.ownerDir, { recursive: true, mode: 0o700 });
+        fs.mkdirSync(this.results, { recursive: true, mode: 0o700 });
+        fs.mkdirSync(this.claims, { recursive: true, mode: 0o700 });
+        writeJson0600(path.join(this.ownerDir, "owner.json"), this.owner);
+        // MCPの再接続と旧process終了の順序が前後しても、終了したownerの記録を回収する。
+        this.timer = setInterval(() => { void this.recover().catch((error) => this.reportServiceError(error)); }, 5_000);
+        this.timer.unref();
+        void this.recover().catch((error) => this.reportServiceError(error));
+    }
+    reportServiceError(error) {
+        this.serviceError = error instanceof Error ? error : new Error(String(error));
+        process.stderr.write("aiterm: PARENT_DELIVERY_STATE_UNAVAILABLE（配送状態を確認してください）\n");
+    }
+    async prepare(parent) {
+        if (this.closing)
+            throw new AitermError("PARENT_DELIVERY_CLOSED: MCP接続を終了しています", 2);
+        if (this.serviceError)
+            throw this.serviceError;
+        await this.recover();
+        await this.deps.verify(parent);
+    }
+    request(parent) {
+        let job = null;
+        return {
+            before_send: async (boundary) => {
+                const previous = this.registering.get(boundary.session_id) ?? Promise.resolve();
+                const registration = previous.then(async () => {
+                    await this.beforeChange(boundary.session_id, true);
+                    const now = new Date().toISOString();
+                    const record = { schema: "aiterm.parent-delivery.v1", delivery_id: randomUUID(),
+                        created_at: now, updated_at: now, parent, boundary, state: "waiting", text: null,
+                        child_outcome: null, child_turn_id: null, error: null, queued_submission_id: null };
+                    job = { record, file: path.join(this.ownerDir, `${record.delivery_id}.json`), controller: new AbortController() };
+                    this.save(job);
+                    // 記録を調べてから作るだけでは、別processが同時に同じ子を予約できる。
+                    // 同一filesystemのhard link作成で、回答をまだ保存していない依頼を一つに決める。
+                    try {
+                        fs.linkSync(job.file, path.join(this.claims, `${boundary.session_id}.json`));
+                    }
+                    catch (error) {
+                        fs.unlinkSync(job.file);
+                        job = null;
+                        if (error.code === "EEXIST") {
+                            throw new AitermError("PARENT_RESULT_PENDING: 同じ子の回答保存を別の依頼が所有しています", 2);
+                        }
+                        throw error;
+                    }
+                    this.jobs.set(record.delivery_id, job);
+                    this.watch(job);
+                });
+                this.registering.set(boundary.session_id, registration);
+                try {
+                    await registration;
+                }
+                finally {
+                    if (this.registering.get(boundary.session_id) === registration)
+                        this.registering.delete(boundary.session_id);
+                }
+            },
+            result: () => job ? receipt(job.record) : null,
+            failed: (error) => {
+                if (!job || job.record.state !== "waiting")
+                    return;
+                job.controller.abort();
+                job.record.state = "unknown";
+                job.record.error = `AGENT_DISPATCH_UNCONFIRMED: ${error instanceof Error ? error.message : String(error)}`;
+                this.finish(job);
+            },
+        };
+    }
+    save(job) {
+        job.record.updated_at = new Date().toISOString();
+        writeJson0600(job.file, job.record);
+    }
+    finish(job) {
+        this.releaseClaim(job);
+        this.save(job);
+        const destination = path.join(this.results, `${job.record.delivery_id}.json`);
+        if (job.file !== destination) {
+            fs.renameSync(job.file, destination);
+            job.file = destination;
+        }
+        this.jobs.delete(job.record.delivery_id);
+    }
+    releaseClaim(job) {
+        const file = path.join(this.claims, `${job.record.boundary.session_id}.json`);
+        try {
+            const claim = JSON.parse(fs.readFileSync(file, "utf8"));
+            // 回収済みrecordを復旧している間に始まった、次の依頼の予約は触らない。
+            if (claim.delivery_id === job.record.delivery_id)
+                fs.unlinkSync(file);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    watch(job) {
+        const boundary = job.record.boundary;
+        job.task = (async () => {
+            try {
+                const completion = await this.deps.observe(boundary.session_id, {
+                    cursor: boundary.event_cursor, operation_id: boundary.operation_id,
+                    timeout: Infinity, signal: job.controller.signal,
+                });
+                await this.capture(job, completion);
+            }
+            catch (error) {
+                if (job.controller.signal.aborted)
+                    return;
+                await this.captureFailure(job, error);
+            }
+        })().catch((error) => this.reportServiceError(error));
+    }
+    async capture(job, completion) {
+        if (job.capture)
+            return job.capture;
+        if (job.record.state !== "waiting")
+            return;
+        job.capture = (async () => {
+            if (completion.launch_id !== job.record.boundary.launch_id)
+                throw new AitermError("PARENT_DELIVERY_LAUNCH_CHANGED: 子のlaunchが置換されました", 2);
+            if (completion.outcome === "running" || completion.outcome === "timeout")
+                throw new AitermError("PARENT_DELIVERY_NOT_COMPLETED: 子の完了を確認できません", 2);
+            const record = job.record;
+            record.child_outcome = completion.outcome;
+            record.child_turn_id = completion.turn_id;
+            if (completion.outcome === "done") {
+                const answer = await this.deps.answer(record.boundary.session_id, { completion, operation_id: completion.operation_id, raw: true });
+                if (record.state !== "waiting")
+                    return;
+                record.text = answer.text;
+            }
+            else {
+                record.text = completion.error ?? completion.rate_limit ?? "子のセッションが閉じられたため、回答はありません。";
+            }
+            record.state = "ready";
+            this.save(job);
+            // 次の依頼へ進める時点は本文保存まで。親のキュー受付を待たせない。
+            job.delivery = this.deliver(job).catch((error) => this.reportServiceError(error));
+        })();
+        return job.capture;
+    }
+    async captureFailure(job, error) {
+        if (job.record.state !== "waiting")
+            throw error;
+        job.record.child_outcome = "error";
+        job.record.error = `AGENT_RESULT_UNAVAILABLE: ${error instanceof Error ? error.message : String(error)}`;
+        job.record.text = job.record.error;
+        job.record.state = "ready";
+        this.save(job);
+        await this.deliver(job);
+    }
+    async deliver(job) {
+        this.releaseClaim(job);
+        job.record.state = "sending";
+        this.save(job);
+        try {
+            const result = await this.deps.submit(job.record.parent, job.record.delivery_id, answerMessage(job.record));
+            job.record.queued_submission_id = result.queued_submission_id;
+            job.record.state = "submitted";
+        }
+        catch (error) {
+            job.record.state = error instanceof CodexDeliveryError && !error.outcome_unknown ? "failed" : "unknown";
+            job.record.error = error instanceof Error ? error.message : String(error);
+        }
+        this.finish(job);
+    }
+    /** 次の入力・closeより先に、既に完了した前の本文を確保する。 */
+    async beforeChange(sessionId, requireCaptured = false) {
+        for (const job of this.jobs.values()) {
+            if (job.record.boundary.session_id !== sessionId || job.record.state !== "waiting")
+                continue;
+            const boundary = job.record.boundary;
+            const completion = await this.deps.observe(sessionId, { cursor: boundary.event_cursor, operation_id: boundary.operation_id, timeout: 0 });
+            if (completion.outcome !== "running" && completion.outcome !== "timeout") {
+                await this.capture(job, completion);
+            }
+            if (requireCaptured && job.record.state === "waiting") {
+                throw new AitermError("PARENT_RESULT_PENDING: 前の依頼の完了と回答保存が済んでいません", 2);
+            }
+        }
+        // 別のMCP processが同じ子の回答を保存中なら、入力で記録を上書きしない。
+        if (requireCaptured && this.records().some((record) => record.boundary.session_id === sessionId && record.state === "waiting")) {
+            throw new AitermError("PARENT_RESULT_PENDING: 別の依頼の回答保存が済んでいません", 2);
+        }
+    }
+    files() {
+        const files = fs.readdirSync(this.results).filter((name) => name.endsWith(".json")).map((name) => path.join(this.results, name));
+        for (const owner of fs.readdirSync(this.active, { withFileTypes: true })) {
+            if (!owner.isDirectory())
+                continue;
+            const directory = path.join(this.active, owner.name);
+            files.push(...fs.readdirSync(directory).filter((name) => name !== "owner.json" && name.endsWith(".json")).map((name) => path.join(directory, name)));
+        }
+        return files;
+    }
+    records() {
+        const records = [];
+        for (const file of this.files()) {
+            try {
+                records.push(readRecord(file));
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+        }
+        return records;
+    }
+    status(sessionId) {
+        if (this.serviceError)
+            throw this.serviceError;
+        return this.records().filter((record) => record.boundary.session_id === sessionId)
+            .sort((a, b) => a.created_at.localeCompare(b.created_at)).map(receipt);
+    }
+    recover() {
+        if (this.recovering)
+            return this.recovering;
+        if (this.closing)
+            return Promise.resolve();
+        this.recovering = this.recoverOrphans().finally(() => { this.recovering = null; });
+        return this.recovering;
+    }
+    async recoverOrphans() {
+        const processes = this.deps.processes();
+        for (const directory of fs.readdirSync(this.active, { withFileTypes: true })) {
+            if (!directory.isDirectory())
+                continue;
+            const oldDir = path.join(this.active, directory.name);
+            if (oldDir === this.ownerDir)
+                continue;
+            let owner;
+            try {
+                owner = JSON.parse(fs.readFileSync(path.join(oldDir, "owner.json"), "utf8"));
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    continue;
+                throw new AitermError("PARENT_DELIVERY_OWNER_INVALID: 配送所有者の記録を読めません", 2);
+            }
+            if (!Number.isSafeInteger(owner.pid) || typeof owner.started_identity !== "string" || typeof owner.closed !== "boolean") {
+                throw new AitermError("PARENT_DELIVERY_OWNER_INVALID: 配送所有者の形式が不正です", 2);
+            }
+            if (!owner.closed && processes.some((entry) => entry.pid === owner.pid && entry.started_identity === owner.started_identity))
+                continue;
+            for (const name of fs.readdirSync(oldDir).filter((name) => name !== "owner.json" && name.endsWith(".json"))) {
+                const oldFile = path.join(oldDir, name);
+                const file = path.join(this.ownerDir, name);
+                // 元のpathが消えるrenameを使うため、同じ旧recordを二つのprocessで回収できない。
+                try {
+                    fs.renameSync(oldFile, file);
+                }
+                catch (error) {
+                    if (error.code === "ENOENT")
+                        continue;
+                    throw error;
+                }
+                const record = readRecord(file);
+                const job = { record, file, controller: new AbortController() };
+                this.jobs.set(record.delivery_id, job);
+                if (record.state === "sending") {
+                    record.state = "unknown";
+                    record.error = "PARENT_DELIVERY_INTERRUPTED: キュー送信中にMCP processが終了しました。自動再送はしていません";
+                    this.finish(job);
+                }
+                else if (record.state === "waiting" || record.state === "ready") {
+                    try {
+                        await this.deps.verify(record.parent);
+                        if (record.state === "waiting")
+                            this.watch(job);
+                        else
+                            job.delivery = this.deliver(job).catch((error) => this.reportServiceError(error));
+                    }
+                    catch (error) {
+                        record.state = "failed";
+                        record.error = error instanceof Error ? error.message : String(error);
+                        this.finish(job);
+                    }
+                }
+                else
+                    this.finish(job);
+            }
+        }
+    }
+    async close() {
+        this.closing = true;
+        clearInterval(this.timer);
+        await this.recovering;
+        await Promise.allSettled(this.registering.values());
+        const jobs = [...this.jobs.values()];
+        for (const job of jobs)
+            if (job.record.state === "waiting")
+                job.controller.abort();
+        await Promise.all(jobs.map((job) => job.task));
+        await Promise.all(jobs.map((job) => job.delivery));
+        this.owner.closed = true;
+        writeJson0600(path.join(this.ownerDir, "owner.json"), this.owner);
+    }
+}

package/dist/setup-integrations.js

@@ -71,6 +71,17 @@ export function configureIntegrations(home, registration, run = runSetupCommand,
                 mergeJsonMcp(file, client === "claude" ? { type: "stdio", ...registration } : registration);
             }
             else if (client === "codex") {
+                // 親threadがないsetupでは公式queue入口まで確認し、宛先は各dispatchで検証する。
+                let queueHelp;
+                try {
+                    queueHelp = run(executable, ["queue", "--help"]);
+                }
+                catch {
+                    throw new SetupError("codex_parent_delivery_unavailable", "Codexの公式受信キューを使えません。公式CLIを更新してください");
+                }
+                if (!queueHelp.includes("--thread") || !queueHelp.includes("--message")) {
+                    throw new SetupError("codex_parent_delivery_unavailable", "Codexの公式受信キューを確認できません。公式CLIを更新してください");
+                }
                 const servers = JSON.parse(run(executable, ["mcp", "list", "--json"]));
                 if (!Array.isArray(servers))
                     throw new SetupError("config_readback_failed", "CodexのMCP一覧形式を確認できません");

package/docs/00_overview.md

@@ -17,6 +17,10 @@ dotagentsは任意の工場統合を担うが、Aitermの製品正典や実行
 Grok／Composerのsandbox起動拒否については、[DESIGNの失敗と復旧](DESIGN.md#failure-and-recovery)に
 検出の所有と適用範囲、[RELEASEの公開後smoke](RELEASE.md#公開後smoke)に検証条件を置く。
 
+## 設計中
+
+- [子の回答を親へ自動配送する設計・実装計画](https://github.com/kitepon/aiterm-mcp/blob/main/docs/plan_parent-result-delivery.md): Claude Code／Codex親への本文配送。設計案であり、現行APIは未変更。
+
 ## 履歴と証拠
 
 - [`archive/`](https://github.com/kitepon/aiterm-mcp/tree/main/docs/archive): 完了・棄却・中断・失効・置換により現行制御から外れたsnapshot。

package/docs/DESIGN.md

@@ -47,14 +47,37 @@ harnessがagent loop、認証、hook、session、transcript、model catalogを
 project／user環境を置換せず、launch相関と完了回収に必要なstateだけを加える。
 Throughlineの補足記憶はpathを透過搬送するだけで、内容、project束縛、context予算はThroughlineが所有する。
 
-agent turnは常に非ブロックdispatchである。receiptの`event_cursor`がturn境界、`wait_process`が
-platform nativeな別process起動情報を返す。waiterは純readerで、親のforeground turnを塞がない。
+agent turnは常に非ブロックdispatchであり、receiptの`event_cursor`がturn境界になる。
+Codex親にはAitermのMCP processが完了を観測し、回答本文を公式受信キューへ自動配送する。
+それ以外の親には`wait_process`がplatform nativeな別process起動情報を返す。
+waiterは純readerで、親のforeground turnを塞がない。
 回答はharness所有transcriptから同じturnへ相関して回収し、欠落・曖昧・timeout時にpromptを再送しない。
 Grok／Composerの記録先はCLIと同じOS絶対パスへcwdを正規化して導出し、完了通知と回答で同じ関数を使う。
 `agent_steer`は実行中のCodex／Grok turnへ追加textを差し込み、idleなら送信せず状態を返す。
 Cursorのsubmitはadapterがextended keyboard protocolのEnterへ変換し、呼び出し側は通常のdispatchだけを使う。
 起動直後のClaude sessionへの初回dispatchは、他harnessと同じくTUIの入力受付を確認してから貼付とEnterを送る。
 
+### Codex親への自動配送
+
+`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になった後に処理される。
+`parent_delivery`が配送IDと状態を返し、自動配送時の`wait_process`／`wait_command`はnullになる。
+`pty_observe`の`parent_deliveries`で状態を確認できる。`submitted`はキュー受付済みを示し、modelの読了を意味しない。
+次の依頼へ進める前に前回の回答を保存し、harness所有記録を後の回答と取り違えない。
+
+配送記録と本文はAiterm stateの`parent-deliveries`へ保存する。ownerのPIDと開始識別子で生存を判定し、
+再接続後は終了したownerの記録だけを原子的に引き継ぐ。`waiting`は同じ境界から観測を再開し、
+`ready`は保存した本文を送る。送信中断は`unknown`として本文を残し、自動再送しない。
+受信口が明示拒否した場合は`failed`、子の異常終了はそのoutcomeを配送する。
+このstateは既存のPTY／harness stateと独立し、旧版は配送を再開しない。
+
 `trust_project:true`は対象projectの既知のworkspace、hooks、MCP初期同意を起動準備として進める意図である。
 promptなしでも入力受付とharness生存を確認して`startup.ready`を返す。指定なしのpromptなし起動は
 従来どおり`startup.not_checked`で返す。初手receiptは未要求・未送信・送信済み未確認・開始確認を分ける。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiterm-mcp",
-  "version": "0.33.1",
+  "version": "0.34.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": [