aiterm-mcp 0.33.0 → 0.34.0

package/CHANGELOG.md

@@ -7,6 +7,25 @@ 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
+
+- macOS・Linux上のAitermからSSH先のPowerShellへ`pty_send(mark:true)`するとPOSIXの`printf`を送っていた不具合を修理した。現在のPowerShell promptで方言を判定し、成功・失敗の完了マーカーを生成する。古いpromptや入力途中の行は使わない。
+
 ## [0.33.0] - 2026-09-09
 
 ### Added
@@ -1598,7 +1617,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.0...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
 [0.31.2]: https://github.com/kitepon/aiterm-mcp/compare/v0.31.1...v0.31.2

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.0** · 動作対象は 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 の次の入力境界で返る
 ```
@@ -509,8 +510,19 @@ handoff contextを前置きできる。この任意経路は`throughline >= 0.9.
 
 ### 完了検出（5 層）
 
+SSH先がPowerShellの場合、`mark:true`は現在の標準`PS ...>`プロンプトから方言を判定する。Aiterm自身がmacOS・Linux上でもPowerShell構文を送り、過去の出力に残ったプロンプトは判定に使わない。
+
 `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.0** · runs on Linux · WSL2 · macOS · native Windows (tmux on POSIX, the tmux-CLI-compatible [psmux](https://github.com/psmux/psmux) on native Windows — no WSL required) · MIT · see the [CHANGELOG](CHANGELOG.md).
+**Status:** actively maintained · current public release **v0.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
 ```
@@ -544,11 +545,19 @@ When an agent's answer is longer than the on-screen tail (pane height ≈ 24 lin
 
 ### Completion detection (5 layers)
 
+For PowerShell over SSH, `mark:true` recognizes the current standard `PS ...>` prompt and emits PowerShell syntax even when Aiterm runs on macOS or Linux. A prompt left in earlier output is not used to select the syntax.
+
 `pty_read({ wait: true })` decides "is the command done?" via five layers: process exit / a `mark:true` sentinel / an `until` match / output quiescence with shell return / timeout. `mark` emits the shell's exit status on POSIX shells and `0` (success) or `1` (failure) on PowerShell; fish/csh/tcsh are rejected before send because they do not share either status syntax. When `mark` or `until` is active, that requested evidence takes precedence and a momentarily quiet shell cannot complete the read as quiescent. Agent sessions add a sixth exact layer: Codex observes normal rollout `task_complete`; Grok/Composer observe normal session `turn_ended`; Claude observes its additive launch-correlated Stop event; Cursor observes `turn_ended(status:"success")` in the launch-bound normal agent transcript. `aiterm-wait --cursor` performs that harness-specific observation without the parent blocking or polling. Pre-send readiness failures are MCP errors, and late completion remains recoverable without resending.
 
 ### 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

@@ -16,7 +16,7 @@ import * as rtk from "./rtk.js";
 import { paneTokenHint } from "./harnesses/pane-tokens.js";
 import { readRuntimeProcesses, processSubtree, processIdentity, backgroundProcesses } from "./process-runtime.js";
 import { AitermError, telemetryOwnedFailure, ownTelemetryFailure } from "./errors.js";
-import { isWin, SOCKDIR, tmuxCommand, sendPsmuxPayload, loadPtyBufferChunk, pasteBufferBaseArgs, TMUX_EMPTY_CONFIG, attachCommand, normalizePaneCommand, appendMarkSentinel, settlePaneLog, paneCwdArgument, sessionEnvironmentLaunch, } from "./tmux-runtime.js";
+import { isWin, SOCKDIR, tmuxCommand, sendPsmuxPayload, loadPtyBufferChunk, pasteBufferBaseArgs, TMUX_EMPTY_CONFIG, attachCommand, normalizePaneCommand, appendMarkSentinel, markShellCommand, settlePaneLog, paneCwdArgument, sessionEnvironmentLaunch, } from "./tmux-runtime.js";
 import { sleep, currentUid, runtimeStateBase, safeStatSize, readFileRange, writeJson0600, createEmpty0600, shq, LAUNCH_ID_RE, AGENT_DONE_POLL_MS, AGENT_EVENT_MAX_BYTES, assertSessionName, agentsDir, agentEventPath, agentMetadataPath, writeAgentMetadata, AGENT_EVENT_TAIL_BYTES, agentLabel, agentHarness, subagentInstruction, agentLineageFields, } from "./agent-shared.js";
 import { GROK_MODEL_DEFAULTS, realGrokHome, resolveAndValidateGrokAuth, assertGrokModelAvailable, grokEventsTranscript, latestGrokCompletion, observeGrokDone, buildGrokAgentCmd, grokLaunchNote, grokEnvTokens, grokTuiReady, grokTuiBusy, grokPaneObservation, grokStartupAction, grokLaunchBlockingDialog, assertGrokSandboxNotRejected, GROK_COMPOSER_MARKER_RE, grokFooterHasConfiguration, grokTranscriptText, createGrokAgentMetadata, } from "./harnesses/grok.js";
 import { bindCodexTranscriptSession, latestCodexCompletion, observeCodexDone, buildCodexAgentCmd, codexLaunchNote, codexTuiReady, codexPaneObservation, codexApprovalDialog, codexStartupAction, CODEX_COMPOSER_MARKER_RE, codexModelChoice, codexEffortChoice, codexMoreReasoningChoice, codexTranscriptText, createCodexAgentMetadata, } from "./harnesses/codex.js";
@@ -235,12 +235,9 @@ export async function ensureAgentOwnsPaneInput(name, kind) {
 }
 function paneCurrentCommandForMark(name) {
     const foreground = paneCurrentCommand(name);
-    if (!isWin || foreground === "powershell" || foreground === "pwsh")
+    if ((!isWin && foreground !== "ssh") || foreground === "powershell" || foreground === "pwsh")
         return foreground;
-    // psmuxはnew-session直後だけpane_current_commandへ起動元shellを返すことがある。
-    // 現在の末尾画面にPowerShell promptが描画済みなら、mark構文はその実効shellへ合わせる。
-    const screen = captureScreen(name, 4).replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, "");
-    return /(?:^|\n)PS [^\r\n]*>\s*$/m.test(screen) ? "pwsh" : foreground;
+    return markShellCommand(foreground, captureScreen(name, 4));
 }
 function pasteBufferSupportsNoSanitizeFlag() {
     const listed = tmux("list-commands");
@@ -2390,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);
@@ -2410,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)
@@ -2424,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)
@@ -2436,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}`,
@@ -2571,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` +
@@ -2578,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 を確認してから再取得する。`;
 }
@@ -2637,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相関
@@ -2674,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);
@@ -3106,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);
@@ -3440,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を待つ状態を作らない。
@@ -3520,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);
@@ -3535,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)
@@ -3876,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" 等) で操作する（対話）。`;
@@ -3974,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)) {