aiterm-mcp 0.34.0 → 0.35.1

package/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.35.1] - 2026-09-10
+
+### Fixed
+
+- Claudeの起動時に、指定された作業ディレクトリの実体パスを記録する。macOSの`/var`やリンク経由のcwdでも、会話記録を使うAPIエラー検出が正しい保存場所を参照する。
+
+## [0.35.0] - 2026-09-10
+
+### Added
+
+- Claude Code親への回答自動配送を追加した。公式`asyncRewake` hookが子の回答を受け取り、idle中の親も再開する。待機中も親は別作業と次のturnへ進める。
+- `aiterm-setup`がClaude Codeの専用hookを登録し、MCP要求とhookの実際の会話を照合する。親のwaiter・回答回収と子への返送指示は不要。
+- `/clear`等の会話終了後は未送信の旧回答を新しい会話へ出さず、本文を保持して配送失敗を明示する。hookの出力中断は結果不明とし、自動再送しない。
+
+### Fixed
+
+- Grok／Composerで追加メッセージが直ちに次turnを開始した場合も、完了したturnの回答を指定して回収する。最新turnの切替で前の回答の自動配送が失敗する競合を修正した。
+
+### Compatibility
+
+- Claude Code親は2.1.259以上の対話sessionと有効なcommand hookを必要とする。Claude Desktopチャット・Web・`agent_id`付きの会話（`--agent`起動とnative subagent）は対象外。起動時のChannels flagは不要。
+- Claude用配送記録を分け、旧版のCodex readerとの互換性を維持する。旧版へ戻す前に`aiterm-setup --remove-claude-parent-hooks`でAiterm専用hookだけを解除する。
+
 ## [0.34.0] - 2026-09-10
 
 ### Added
@@ -1617,7 +1640,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.34.0...HEAD
+[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.35.1...HEAD
+[0.35.1]: https://github.com/kitepon/aiterm-mcp/compare/v0.35.0...v0.35.1
+[0.35.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.34.0...v0.35.0
 [0.34.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.33.1...v0.34.0
 [0.33.1]: https://github.com/kitepon/aiterm-mcp/compare/v0.33.0...v0.33.1
 [0.33.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.32.0...v0.33.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 になり、Codex親には回答本文を自動配送し、それ以外の親の完了待ちは `aiterm-wait`
+agent session への send は常に非ブロック dispatch になり、Codex／Claude Code親には回答本文を自動配送し、それ以外の親の完了待ちは `aiterm-wait`
 （exit code が receipt の outcome を映す: 0=done / 3=timeout=未完了 /
 4=closed / 5=running=待たない観測）、初回 prompt 付き
 launch は structured receipt にコピペ可能な `wait_command` を含む。factory diagnostics と local
@@ -171,7 +171,7 @@ runtime-error store は canonical dotagents config の `collection.enabled: true
 場合だけ収集し、既定OFF、network送信は行いません。tag起点CIのnpm provenance（OIDC Trusted
 Publishing）で公開し、GitHub Release が Official MCP Registry を再登録します。
 
-**状態:** 開発継続中 · 現行公開版 **v0.34.0** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
+**状態:** 開発継続中 · 現行公開版 **v0.35.1** · 動作対象は 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`を返し、Codex親には回答本文を公式受信キューへ自動配送する。それ以外の親は`aiterm-wait`を親のターンを塞がない別processで受ける。Cursorのsubmitキーはadapterが現行CLIのextended keyboard protocolへ変換する。送信textがCursorのcomposerへ残った場合は成功receiptを返さず失敗する。
+`aiterm.agent-launch-result.v1`は正規`harness`を返し、旧`provider`は互換fieldとして残す。同じ`harness`はagent dispatch、`aiterm-wait`、`agent_configure`、`pty_list`のagent行にも載り、旧vendor／provider／agent fieldは互換用に残る。Codexは通常rollout、Grok CLIは通常session event、Claudeはlaunch固有Stop hook、Cursorは通常agent transcript末尾の`turn_ended`を完了正本に使う。`pty_send`は非ブロックdispatchで、vendor別完了境界を表すopaqueな整数`event_cursor`を返す。Codex親は公式受信キュー、Claude Code親は公式非同期hookで回答本文を自動受信する。それ以外の親は`aiterm-wait`を親のターンを塞がない別processで受ける。Cursorのsubmitキーはadapterが現行CLIのextended keyboard protocolへ変換する。送信textがCursorのcomposerへ残った場合は成功receiptを返さず失敗する。
 
 `agent_launch`・`pty_send`（agent dispatch）・`agent_steer`は任意の`image`（画像ファイルの絶対パスの配列。png/jpg/jpeg/gif/webp）を受ける。aitermが本文末尾へ添付行を付け、どのharnessも自分のfile読取toolでそのpathを画像として開く。呼出し側はharness別の添付手順を覚えない。不正なpathは送信前に拒否する。
 
@@ -225,7 +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親には回答が自動で届く。それ以外の親:
+# Codex／Claude Code親には回答が自動で届く。それ以外の親:
 $ aiterm-wait --session codex1 --cursor <event_cursor>   # exit 0=done / 3=timeout(未完了) / 4=closed / 7=error(APIエラー等でturn打ち切り)。回収は pty_read(agent_transcript:true)
                                     → 操舵し、Codex の次の入力境界で返る
 ```
@@ -514,14 +514,22 @@ 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／Claude Code親への回答自動配送
 
-Codexから子を起動・通常dispatchした後は、別作業へ進むか親のturnを終了するだけでよい。Aitermが完了を観測し、加工前の回答を保存して、依頼元Codexの公式受信キューへ送る。親はidleになった後に回答を処理する。waiter、`pty_read`による回答回収、子への送信指示は不要。Desktop固有の接続を使わず、CLIでも同じ経路になる。子は全対応harnessから選べる。Claude等の親は既存のwaiter経路を使う。
+Codex／Claude Codeから子を起動・通常dispatchした後は、別作業へ進むか親のturnを終了するだけでよい。Aitermが完了を観測し、加工前の回答を保存して親へ届ける。waiter、`pty_read`による回答回収、子への送信指示は不要。子は全対応harnessから選べる。
 
-自動配送時はreceiptに`parent_delivery`が付き、`wait_process`／`wait_command`はnullになる。`pty_observe`の`parent_deliveries`で`waiting`、`ready`、`sending`、`submitted`、`failed`、`unknown`を確認できる。`submitted`はキューの受付済みであり、modelの読了ではない。MCP再接続後は未送信の記録を再開し、送信中に接続が切れて結果が分からない場合は本文を保持して`unknown`とする。自動再送はしない。
+自動配送時はreceiptに`parent_delivery`が付き、`wait_process`／`wait_command`はnullになる。`pty_observe`の`parent_deliveries`で`waiting`、`ready`、`sending`、`submitted`、`failed`、`unknown`を確認できる。`submitted`はCodexのキュー受付またはClaudeのhookへの本文出力を示し、modelの読了ではない。MCP再接続後は未送信の記録を再開し、送信中に接続が切れて結果が分からない場合は本文を保持して`unknown`とする。自動再送はしない。
 
 CodexにはMCPの`_meta.threadId`と公式`thread/queue` APIが必要で、Codex CLI 0.154.0で確認している。`aiterm-setup`はインストールされた公式queue入口を確認し、各dispatchでは実際の親threadの受入可否を確認する。Codexのnative sub-agentは外部からのqueue入力を拒否するため、自動配送の親としては未対応。
 
+Claude Codeは2.1.259以上の対話sessionに対応する。`aiterm-setup`が専用の`PreToolUse`、`PostToolUse`、`SessionEnd`を登録するため、Channelsの起動flagは不要。公式`asyncRewake` hookだけが裏で待ち、親はその間も次のturnへ進める。回答は`Stop hook feedback`として届く。hookのexit 2は親の再開信号であり、子の成功・失敗は本文の`outcome`で区別する。
+
+`/clear`などで会話を終了すると未送信の旧回答の配送を止め、本文は保存する。受信hookの上限は24時間で、終了や出力失敗を成功扱いしない。hookが無効な場合は送信前に明示errorにし、waiterへ黙って切り替えない。Claude Desktopのチャット、Web、`agent_id`付きの会話（`--agent`起動とnative subagent）はこの受信契約に含めない。
+
+hookを持たない旧版へ戻す時は、install前に`aiterm-setup --remove-claude-parent-hooks`を実行する。Aiterm専用hookだけを解除し、他製品のhookと設定は保持する。
+
+Claudeをリンク経由の`cwd`から起動した場合も、実体パスに対応する会話記録を参照する。
+
 
 ### トークン削減
 

package/README.md

@@ -176,18 +176,16 @@ a non-blocking `aiterm-wait --timeout 0` observation (`running`, exit 5) from a
 wait. The v0.19 line added the correlated Claude approval relay,
 preserved multiline shell delivery, and extended factory diagnostics on native
 Windows. As of v0.16/0.17 a parent agent never blocks on aiterm:
-every send to an agent session is a non-blocking dispatch. 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.
+agent sessionへの送信は非ブロックdispatchであり、Codex／Claude Code親には回答本文を自動配送する。
+それ以外の親はreceiptのprocess起動情報で`aiterm-wait`を実行する。
+終了コードは`0`=done、`3`=timeout、`4`=closed、待機しない照会の`5`=runningを表す。
 Factory diagnostics and the local runtime-error store collect only when
 canonical dotagents config explicitly sets `collection.enabled: true`;
 collection is off by default and performs no network I/O. It ships via
 tag-triggered CI with npm provenance (OIDC Trusted Publishing); the GitHub
 Release re-registers the Official MCP Registry entry.
 
-**Status:** actively maintained · current public release **v0.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).
+**Status:** actively maintained · current public release **v0.35.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).
 
 ### Update and rollback
 
@@ -227,7 +225,7 @@ pty_read(id, { wait: true })       → read the token-reduced output, completion
 
 The same primitive hosts another agent's TUI. `agent_launch` starts a selected execution harness inside a fresh persistent terminal and returns a `session_id`. `harness` names the component that owns the agent loop, authentication, hooks, session, and transcript; `model` remains an independent choice. The launched process sees the same project and user environment as a direct CLI invocation: normal configuration, MCPs, plugins, skills, permissions, trust decisions, memory, and history are not copied, filtered, or replaced. Aiterm adds only completion correlation and a non-user sub-agent context containing `role=subagent`, the parent session, delegation depth, lineage, and `delegation_allowed=true`.
 
-The human-readable launch text is accompanied by an `aiterm.agent-launch-result.v1` structured receipt containing the canonical `harness`; the old `provider` field remains for compatibility. The same `harness` is carried by agent dispatch, `aiterm-wait`, `agent_configure`, and agent rows in `pty_list`, while their old vendor/provider/agent fields remain compatibility fields. Codex completion comes from its normal durable rollout transcript, Grok CLI from its normal session events, Claude Code from a launch-specific Stop hook settings addition, and Cursor from its normal agent transcript's terminal `turn_ended` record. Sending to any agent session is a non-blocking **dispatch** — the call returns immediately with an opaque, harness-specific integer `event_cursor`, and 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.
+起動結果には正規`harness`を含む`aiterm.agent-launch-result.v1`が付き、旧`provider`は互換fieldとして残る。同じ`harness`はagent dispatch、`aiterm-wait`、`agent_configure`、`pty_list`にも載る。Codexは通常rollout、Grokは通常session event、Claudeはlaunch固有Stop hook、Cursorは通常agent transcriptの`turn_ended`を完了正本に使う。agentへの送信は非ブロックdispatchで、harnessごとの完了境界を表す整数`event_cursor`を返す。Codex親は公式queue、Claude Code親は公式非同期hookで本文を自動受信する。他の親は[`aiterm-wait`](#completion-push-for-parent-agents-aiterm-wait)を使う。CursorのsubmitはadapterがCLIのextended keyboard protocolへ変換し、送信本文がcomposerへ残る場合は明示errorにする。
 
 `agent_launch`, `pty_send` (agent dispatch), and `agent_steer` accept an optional `image`: an array of absolute paths to image files (png/jpg/jpeg/gif/webp). Aiterm appends an attachment block to the prompt, and every harness opens the path with its own file-reading tool and sees the image; the caller never learns harness-specific attachment tricks. Invalid paths are rejected before anything is sent.
 
@@ -250,7 +248,7 @@ agent_launch({ harness: "codex-cli", session_name: "codex1", cwd: "/repo",
 pty_read("codex1", { screen: true })   → read what it's doing (token-reduced)
 pty_send("codex1", "also fix the imports it broke")
                                     → non-blocking dispatch; receipt carries event_cursor
-# Codex parents receive the answer automatically. For other parents:
+# Codex／Claude Code親には回答が自動で届く。それ以外の親:
 $ aiterm-wait --session codex1 --cursor <event_cursor>   # never in the parent's foreground; exit 0=done, 3=timeout (not done), 4=closed, 7=error (turn aborted by an API error)
 pty_read("codex1", { agent_transcript: true })           → collect the full answer
 ```
@@ -551,17 +549,25 @@ For PowerShell over SSH, `mark:true` recognizes the current standard `PS ...>` p
 
 ### Completion push for parent agents (`aiterm-wait`)
 
-**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.
+**Codex／Claude Code親には子の回答本文が自動で届く。** 子を起動・dispatchした後は、別作業へ進むか親のturnを終える。Aitermが完了を観測し、加工前の本文を保存して親へ渡す。waiter、`pty_read`による回答回収、子への返送指示は不要。子は全対応harnessから選べる。
 
-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.
+自動配送のreceiptには`parent_delivery`が付き、`wait_process`／`wait_command`はnullになる。`pty_observe`の`parent_deliveries`で`waiting`、`ready`、`sending`、`submitted`、`failed`、`unknown`を確認できる。`submitted`はCodexのキュー受付またはClaudeのhookへの本文出力を示し、modelの読了ではない。MCP再接続後は未送信の記録を再開し、出力中断で結果が分からない場合は本文を保持して`unknown`とする。自動再送はしない。
 
 Use a Codex runtime that supplies MCP `_meta.threadId` and the official `thread/queue` API (verified with Codex CLI 0.154.0). `aiterm-setup` checks the installed queue entry point; Aiterm verifies the requesting thread before each dispatch. Codex native sub-agents reject external queue input and cannot be automatic-delivery parents. Ordinary CLI and Desktop parents use the same supported route.
 
+Claude Codeは2.1.259以上の対話sessionに対応する。`aiterm-setup`が専用の`PreToolUse`、`PostToolUse`、`SessionEnd`を登録するため、Channelsの起動flagは不要。公式`asyncRewake` hookだけが裏で待ち、親はその間も次のturnへ進める。回答は`Stop hook feedback`として届く。hookのexit 2は親の再開信号であり、子の成功・失敗は本文の`outcome`で区別する。
+
+`/clear`等の会話終了後は未送信の旧回答を送らず、本文を保存する。受信hookの上限は24時間。hookの終了・出力失敗・無効化を成功扱いせず、別の待機経路へ黙って切り替えない。Claude Desktopのチャット、Web、`agent_id`付きの会話（`--agent`起動とnative subagent）はこの受信契約に含めない。
+
+hookを持たない旧版へ戻す時は、install前に`aiterm-setup --remove-claude-parent-hooks`を実行する。Aiterm専用hookだけを解除し、他製品のhookと設定は保持する。
+
+Claudeをリンク経由の`cwd`から起動した場合も、実体パスに対応する会話記録を参照する。
+
 **For other parent hosts**, dispatch and start the receipt's waiter in a separate process:
 
 1. Launch the child with `agent_launch({ harness: ... })`; every launch shares the normal project/user environment and adds only completion correlation plus lineage. Send a turn with plain `pty_send` (or `claude_turn issue` for durable Claude operations). The call returns immediately with an `event_cursor` in its structured receipt.
 2. Pass the receipt's `wait_process.executable` and `wait_process.args` unchanged to a true argv process API. PowerShell 7's `Start-Process` is the exception because it joins `-ArgumentList` arrays; pass `windows_start_process_argument_list` as its one ready-made argument string instead. This invokes the bundled waiter through the exact Node runtime that is already running aiterm, including on native Windows where npm's human-facing bin is a PowerShell script shim and install paths may contain spaces. `wait_command` remains a compatibility display string for humans. The waiter observes the harness-owned completion source, plus Claude's additive launch hook, as a **pure reader** and exits with a one-line `aiterm.agent-wait-result.v1` receipt. **Exit ≠ done**: the receipt's `outcome` is authoritative (`0` = `done`, `3` = `timeout`, `4` = `closed`, `1` = error).
-3. **The parent never runs the waiter in its own foreground.** Waiting is correct — but the waiter is a separate process, not the parent's turn. A harness that re-invokes its agent when a background task exits (Claude Code) runs the waiter **in the background** and gets woken with zero polling. So that this is not left to interpretation, aiterm reads `clientInfo.name` from the MCP `initialize` handshake and its receipts name the concrete invocation for the detected host — for Claude Code, literally `Bash(command: "aiterm-wait …", run_in_background: true)`. Unknown or undeclared hosts get the generic "start it as a process that does not block the parent's turn" wording; nothing else about the contract changes. Every receipt leads with the same rule: dispatch and let go, then go do something else or end the turn.
+3. **親自身のforegroundでwaiterを実行しない。** receiptのprocess起動情報を、そのhostが持つバックグラウンドprocess APIへ渡す。親は別作業へ進むかturnを終え、process終了の通知で続行する。
 4. Collect the result exactly as before: `pty_read(agent_transcript: true)`, or `claude_turn recover` for durable Claude operations. The waiter carries the signal, never the payload.
 
 **If your host has no completion push** (no mechanism that re-invokes the agent when a background process exits), `--timeout 0` is a one-shot check instead of a wait: it scans the event file once and returns `running` (exit `5`) when the turn is still in flight, `done` (exit `0`) when it finished, `closed` (exit `4`) when the session is gone. It is deliberately absent from the receipts and tool descriptions — a host that *does* get pushed should be woken, not poll. An unknown session name is an error, never `running`, so a typo cannot masquerade as a child that is still working.

package/dist/claude-parent-hook.js

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

package/dist/claude-parent-receiver.js

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

package/dist/core.js

@@ -2410,7 +2410,8 @@ 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)) {
+    if (o.completion && meta.kind !== "codex" && meta.kind !== "grok" && meta.kind !== "composer"
+        && (!done || done.turn_id !== o.completion.turn_id || done.operation_id !== o.completion.operation_id)) {
         throw new AitermError("回収対象の完了情報が置換されました。別の回答は配送しません", 2);
     }
     if (operationId && !done) {
@@ -2430,9 +2431,9 @@ export async function readAgentTranscriptResult(name, o = {}) {
         text = codexTranscriptText(meta, turnId, readTranscriptLines, transcriptUnavailable, o.completion !== undefined);
     }
     else {
-        if (!done)
+        if (!done && !o.completion)
             transcriptUnavailable();
-        text = grokTranscriptText(meta, readTranscriptLines, transcriptUnavailable);
+        text = grokTranscriptText(meta, readTranscriptLines, transcriptUnavailable, o.completion?.turn_id);
     }
     if (!text.trim())
         transcriptNotFound(meta.kind);
@@ -2557,9 +2558,11 @@ export function agentWaitProcess(session, cursor, runtime = {}) {
             : null,
     };
 }
-// 親ホストの識別（MCP initialize の clientInfo.name）。完了待ちコマンドを「親のターンを塞がない
-// 起動形」で名指しするためだけに使う。分からない時は汎用文へ落ち、機能は一切変えない。
+// 親ホストの識別（MCP initialize の clientInfo.name）。配送の可否はMCP入口が検証し、ここは案内だけを作る。
 let parentClientName = null;
+function autoDeliveryParent() {
+    return parentClientName === "codex-mcp-client" ? "Codex" : parentClientName === "claude-code" ? "Claude Code" : null;
+}
 export function setParentClient(name) {
     const trimmed = typeof name === "string" ? name.trim() : "";
     parentClientName = trimmed === "" ? null : trimmed;
@@ -2574,8 +2577,9 @@ export function agentWaitLaunchForm(command) {
 }
 // dispatch / 起動時 prompt 送信後の共通案内。第一文で「待たない」を宣言し、待ち方は後段に置く。
 export function agentDispatchGuide(session, cursor) {
-    if (parentClientName === "codex-mcp-client") {
-        return "回答本文はAitermがこのCodex親へ自動配送する。wait起動・ポーリング・通常の回答回収は不要。" +
+    const parent = autoDeliveryParent();
+    if (parent) {
+        return `回答本文はAitermがこの${parent}親へ自動配送する。wait起動・ポーリング・通常の回答回収は不要。` +
             "親は作業を続けるかターンを終え、順番待ちから届く子の回答で続行する。";
     }
     const cmd = `aiterm-wait --session ${session} --cursor ${cursor}`;
@@ -2585,8 +2589,9 @@ export function agentDispatchGuide(session, cursor) {
 }
 // 未完了 session へ触った時の共通案内。ここでも待つのは waiter プロセスであって親ではない。
 export function agentWaitGuide(session) {
-    if (parentClientName === "codex-mcp-client")
-        return "回答本文はこのCodex親へ自動配送される。親は作業を続けるかターンを終える。";
+    const parent = autoDeliveryParent();
+    if (parent)
+        return `回答本文はこの${parent}親へ自動配送される。親は作業を続けるかターンを終える。`;
     const cmd = `aiterm-wait --session ${session ?? "<session_id>"} --cursor 0`;
     return `完了通知は ${agentWaitLaunchForm(cmd)} で受ける（親はここで待たない・polling 不要）。receipt の outcome=done を確認してから再取得する。`;
 }
@@ -3892,7 +3897,7 @@ export function openAgent(kind, opts = {}) {
     }
     const driveHint = agentDone
         ? `TUI の描画には数秒かかる。少し置いてから pty_read(${sid}, screen:true) で画面を読み、` +
-            `turnはpty_send(${sid}, "...")で送る（自動で非ブロックdispatch。${parentClientName === "codex-mcp-client" ? "回答本文はCodex親へ自動配送する" : "完了通知はaiterm-wait"}）。中断はpty_key(${sid}, "C-c")、` +
+            `turnはpty_send(${sid}, "...")で送る（自動で非ブロックdispatch。${autoDeliveryParent() ? `回答本文は${autoDeliveryParent()}親へ自動配送する` : "完了通知は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" 等) で操作する（対話）。`;

package/dist/harnesses/claude.js

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

package/dist/harnesses/grok.js

@@ -342,8 +342,8 @@ export function grokFooterHasConfiguration(screen, model, effort) {
         return modelLabel !== null || effort !== null;
     });
 }
-// 最後のuser発話以降に確定した最後のassistantメッセージをchat_history.jsonlから抽出する。
-export function grokTranscriptText(meta, readTranscriptLines, transcriptUnavailable) {
+// 配送では完了eventのturn_numberと履歴のprompt_indexを相関する。通常照会は直近の実user発話を読む。
+export function grokTranscriptText(meta, readTranscriptLines, transcriptUnavailable, completedTurnId) {
     const directory = grokSessionDirectory(meta);
     if (!directory)
         transcriptUnavailable();
@@ -364,8 +364,38 @@ export function grokTranscriptText(meta, readTranscriptLines, transcriptUnavaila
             // 外部 transcript の壊れた1行は残りの完結行を読む妨げにしない。
         }
     }
+    let end = records.length;
+    if (completedTurnId !== undefined) {
+        let activePrompt = null;
+        let completedPrompt = null;
+        for (const line of readTranscriptLines(path.join(directory, "events.jsonl"))) {
+            if (!line.trim())
+                continue;
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (event.type === "turn_started")
+                activePrompt = Number.isSafeInteger(event.turn_number) && event.turn_number >= 0 ? event.turn_number : null;
+            else if (completedTurnId !== null && grokCompletionEvent(meta, event)?.turn_id === completedTurnId) {
+                completedPrompt = activePrompt;
+                break;
+            }
+        }
+        const starts = records.flatMap((record, index) => record.type === "user" && !("synthetic_reason" in record)
+            && completedPrompt !== null && record.prompt_index === completedPrompt ? [index] : []);
+        if (starts.length !== 1)
+            throw new AitermError("GROK_TRANSCRIPT_TURN_UNAVAILABLE: 完了turnと回答の相関を確認できません。別turnの回答は使いません", 2);
+        lastUser = starts[0];
+        const next = records.findIndex((record, index) => index > lastUser && record.type === "user" && !("synthetic_reason" in record));
+        if (next >= 0)
+            end = next;
+    }
     const replies = records
-        .slice(lastUser + 1)
+        .slice(lastUser + 1, end)
         .filter((record) => record?.type === "assistant" && typeof record?.content === "string")
         .map((record) => record.content.trim())
         .filter(Boolean);

package/dist/index.js

@@ -17,6 +17,7 @@ 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";
+import { claudeParentFromRequest } from "./claude-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 で
@@ -25,10 +26,11 @@ 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);
+    const clientName = server.server.getClientVersion()?.name;
+    const parent = codexParentFromRequest(clientName, extra._meta) ?? claudeParentFromRequest(clientName, extra._meta);
     if (!parent)
         return null;
-    parentDelivery ??= new ParentDeliveryManager();
+    parentDelivery ??= new ParentDeliveryManager({ parent_kind: clientName === "claude-code" ? "claude" : undefined });
     await parentDelivery.prepare(parent);
     return parentDelivery.request(parent);
 }
@@ -38,7 +40,7 @@ async function deliveryForRequest(extra) {
  * ここでは「待つな」を断定形で先に置き、foreground 実行の禁止までを説明の側に含める。
  */
 const NON_BLOCKING_RULE = "dispatch した子は投げっぱなしでよい＝親はここで待たない。" +
-    "Codex親にはAitermが回答本文を自動配送する。parent_deliveryがある場合はwait起動も通常の回答回収も不要。親は作業を続けるかターンを終える。" +
+    "Codex親とClaude Code親には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}。ポーリング不要）。` +
@@ -861,8 +863,8 @@ async function main() {
     server.server.oninitialized = () => {
         const name = server.server.getClientVersion()?.name;
         core.setParentClient(name ?? null);
-        if (name === "codex-mcp-client")
-            parentDelivery ??= new ParentDeliveryManager();
+        if (name === "codex-mcp-client" || name === "claude-code")
+            parentDelivery ??= new ParentDeliveryManager({ parent_kind: name === "claude-code" ? "claude" : undefined });
     };
     server.server.onclose = () => {
         void parentDelivery?.close().catch(() => process.stderr.write("aiterm: PARENT_DELIVERY_CLOSE_FAILED\n"));

package/dist/parent-delivery.js

@@ -1,4 +1,4 @@
-// Aitermが所有する、子の完了観測・回答本文の保存・Codex親への配送。
+// Aitermが所有する、子の完了観測・回答本文の保存・親への配送。
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { randomUUID, createHash } from "node:crypto";
@@ -7,13 +7,14 @@ 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 { claudeParentSchema, ClaudeDeliveryError, bindClaudeParentDelivery, submitClaudeParentAnswer, verifyClaudeParent } from "./claude-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(),
+    parent: z.union([z.object({ thread_id: z.uuid(), codex_home: z.string() }).strict(), claudeParentSchema]),
     boundary: z.object({
         session_id: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/),
         launch_id: z.string().regex(/^[0-9a-f]{32}$/),
@@ -28,6 +29,16 @@ const recordSchema = z.object({
     error: z.string().nullable(),
     queued_submission_id: z.string().nullable(),
 }).strict();
+const isClaude = (parent) => "kind" in parent && parent.kind === "claude";
+async function verifyParent(parent) {
+    if (isClaude(parent))
+        verifyClaudeParent(parent);
+    else
+        await verifyCodexParent(parent);
+}
+async function submitParentAnswer(parent, deliveryId, text) {
+    return isClaude(parent) ? submitClaudeParentAnswer(parent, deliveryId, text) : submitCodexParentAnswer(parent, deliveryId, text);
+}
 function readRecord(file) {
     try {
         const record = recordSchema.parse(JSON.parse(fs.readFileSync(file, "utf8")));
@@ -56,6 +67,7 @@ function answerMessage(record) {
 export class ParentDeliveryManager {
     deps;
     root;
+    recordRoots;
     active;
     results;
     claims;
@@ -68,12 +80,15 @@ export class ParentDeliveryManager {
     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.deps = { observe: observeAgentDone, answer: readAgentTranscriptResult, submit: submitParentAnswer,
+            verify: verifyParent, processes: readRuntimeProcesses, ...options.dependencies };
+        const stateRoot = ensureStateRoot();
+        this.root = options.root ?? path.join(stateRoot, options.parent_kind === "claude" ? "claude-parent-deliveries" : "parent-deliveries");
+        // 旧版のCodex readerへ未知のparentを渡さない。公開照会と子の予約だけは両方で共有する。
+        this.recordRoots = options.root ? [options.root] : [path.join(stateRoot, "parent-deliveries"), path.join(stateRoot, "claude-parent-deliveries")];
         this.active = path.join(this.root, "active");
         this.results = path.join(this.root, "results");
-        this.claims = path.join(this.root, "claims");
+        this.claims = path.join(options.root ?? path.join(stateRoot, "parent-deliveries"), "claims");
         const ownProcess = this.deps.processes().find((entry) => entry.pid === process.pid);
         if (!ownProcess)
             throw new AitermError("PARENT_DELIVERY_OWNER_UNKNOWN: 配送processを識別できません", 2);
@@ -127,6 +142,8 @@ export class ParentDeliveryManager {
                         }
                         throw error;
                     }
+                    if (isClaude(parent))
+                        bindClaudeParentDelivery(parent, record.delivery_id);
                     this.jobs.set(record.delivery_id, job);
                     this.watch(job);
                 });
@@ -243,7 +260,7 @@ export class ParentDeliveryManager {
             job.record.state = "submitted";
         }
         catch (error) {
-            job.record.state = error instanceof CodexDeliveryError && !error.outcome_unknown ? "failed" : "unknown";
+            job.record.state = (error instanceof CodexDeliveryError || error instanceof ClaudeDeliveryError) && !error.outcome_unknown ? "failed" : "unknown";
             job.record.error = error instanceof Error ? error.message : String(error);
         }
         this.finish(job);
@@ -268,12 +285,20 @@ export class ParentDeliveryManager {
         }
     }
     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())
+        const files = [];
+        for (const root of this.recordRoots) {
+            const results = path.join(root, "results");
+            if (fs.existsSync(results))
+                files.push(...fs.readdirSync(results).filter((name) => name.endsWith(".json")).map((name) => path.join(results, name)));
+            const active = path.join(root, "active");
+            if (!fs.existsSync(active))
                 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)));
+            for (const owner of fs.readdirSync(active, { withFileTypes: true })) {
+                if (!owner.isDirectory())
+                    continue;
+                const directory = path.join(active, owner.name);
+                files.push(...fs.readdirSync(directory).filter((name) => name !== "owner.json" && name.endsWith(".json")).map((name) => path.join(directory, name)));
+            }
         }
         return files;
     }
@@ -348,11 +373,12 @@ export class ParentDeliveryManager {
                 }
                 else if (record.state === "waiting" || record.state === "ready") {
                     try {
-                        await this.deps.verify(record.parent);
                         if (record.state === "waiting")
                             this.watch(job);
-                        else
+                        else {
+                            await this.deps.verify(record.parent);
                             job.delivery = this.deliver(job).catch((error) => this.reportServiceError(error));
+                        }
                     }
                     catch (error) {
                         record.state = "failed";

package/dist/setup-cli.js

@@ -1,8 +1,21 @@
 #!/usr/bin/env node
 import { runSetup } from "./setup.js";
+import { removeClaudeParentHooks } from "./setup-integrations.js";
+import { homedir } from "node:os";
+import { join } from "node:path";
 const args = process.argv.slice(2);
-if (args.length === 1 && ["--help", "-h"].includes(args[0])) {
-    process.stdout.write("使い方: aiterm-setup [--json]\n製品の依存準備、検出したAIへの登録、MCPと端末の実動作確認を行います。結果はJSONで返します。\n");
+if (args.length === 1 && args[0] === "--remove-claude-parent-hooks") {
+    try {
+        const status = removeClaudeParentHooks(join(process.env.CLAUDE_CONFIG_DIR ?? join(process.env.HOME ?? homedir(), ".claude"), "settings.json"));
+        process.stdout.write(`${JSON.stringify({ schema: "aiterm.claude-parent-hooks-remove-result.v1", status })}\n`);
+    }
+    catch (error) {
+        process.stderr.write(`aiterm-setup: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 2;
+    }
+}
+else if (args.length === 1 && ["--help", "-h"].includes(args[0])) {
+    process.stdout.write("使い方: aiterm-setup [--json | --remove-claude-parent-hooks]\n製品の依存準備、検出したAIへの登録、MCPと端末の実動作確認を行います。結果はJSONで返します。旧版へ戻す前の専用hook解除も、この入口で行います。\n");
 }
 else if (args.length > 1 || (args.length === 1 && args[0] !== "--json")) {
     process.stderr.write("使い方: aiterm-setup [--json]\n");

package/dist/setup-integrations.js

@@ -56,6 +56,106 @@ export function mergeJsonMcp(file, registration) {
     }
     return "configured";
 }
+export function claudeParentHookEntries(registration) {
+    const command = { type: "command", command: registration.command, args: [join(dirname(registration.args[0]), "claude-parent-hook.js")] };
+    const matcher = "^mcp__aiterm__(agent_launch|claude_agent|codex_agent|grok_agent|composer_agent|pty_send|claude_turn)$";
+    return {
+        PreToolUse: [{ matcher, hooks: [{ ...command, timeout: 15 }] }],
+        PostToolUse: [{ matcher, hooks: [{ ...command, asyncRewake: true, timeout: 86400 }] }],
+        SessionEnd: [{ hooks: [{ ...command, timeout: 15 }] }],
+    };
+}
+export function mergeClaudeParentHooks(file, registration) {
+    const target = existsSync(file) ? realpathSync(file) : file;
+    let current = {};
+    if (existsSync(target)) {
+        try {
+            current = JSON.parse(readFileSync(target, "utf8"));
+        }
+        catch {
+            throw new SetupError("config_invalid", "Claudeのhook設定JSONを読めません");
+        }
+    }
+    if (!record(current) || (current.hooks !== undefined && !record(current.hooks))) {
+        throw new SetupError("config_invalid", "Claudeのhooks設定はobjectである必要があります");
+    }
+    if (current.disableAllHooks === true)
+        throw new SetupError("claude_parent_hooks_disabled", "Claudeのhookが無効です。disableAllHooksをfalseに変更してからsetupしてください");
+    const hooks = { ...current.hooks };
+    for (const [event, additions] of Object.entries(claudeParentHookEntries(registration))) {
+        const previous = hooks[event] ?? [];
+        if (!Array.isArray(previous) || previous.some(group => !record(group) || !Array.isArray(group.hooks))) {
+            throw new SetupError("config_invalid", `Claudeの${event} hook形式を読めません`);
+        }
+        // 他製品のhookとmatcherはそのまま保ち、当製品の専用entryだけを更新する。
+        const retained = previous.map(group => ({ ...group, hooks: group.hooks.filter(hook => !isClaudeParentHook(hook))
+        })).filter(group => group.hooks.length > 0);
+        hooks[event] = [...retained, ...additions];
+    }
+    const next = { ...current, hooks };
+    if (isDeepStrictEqual(current, next))
+        return "unchanged";
+    mkdirSync(dirname(target), { recursive: true });
+    const temporary = `${target}.aiterm-${randomUUID()}`;
+    try {
+        writeFileSync(temporary, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+        if (existsSync(target))
+            copyFileSync(target, `${target}.aiterm-backup`);
+        renameSync(temporary, target);
+    }
+    finally {
+        if (existsSync(temporary))
+            unlinkSync(temporary);
+    }
+    if (!isDeepStrictEqual(JSON.parse(readFileSync(target, "utf8")), next)) {
+        throw new SetupError("config_readback_failed", "Claudeのhook登録の読戻しが一致しません");
+    }
+    return "configured";
+}
+function isClaudeParentHook(hook) {
+    return record(hook) && hook.type === "command" && Array.isArray(hook.args)
+        && typeof hook.args[0] === "string" && /[/\\]claude-parent-hook\.js$/.test(hook.args[0]);
+}
+/** hookを持たない旧版へ戻す前に、当製品の登録だけを除く。 */
+export function removeClaudeParentHooks(file) {
+    if (!existsSync(file))
+        return "unchanged";
+    const target = realpathSync(file);
+    const current = JSON.parse(readFileSync(target, "utf8"));
+    if (!record(current) || (current.hooks !== undefined && !record(current.hooks))) {
+        throw new SetupError("config_invalid", "Claudeのhook設定を読めません");
+    }
+    if (current.hooks === undefined)
+        return "unchanged";
+    const hooks = { ...current.hooks };
+    for (const event of ["PreToolUse", "PostToolUse", "SessionEnd"]) {
+        if (hooks[event] === undefined)
+            continue;
+        if (!Array.isArray(hooks[event]))
+            throw new SetupError("config_invalid", "Claudeのhook設定を読めません");
+        hooks[event] = hooks[event].map(group => {
+            if (!record(group) || !Array.isArray(group.hooks))
+                throw new SetupError("config_invalid", "Claudeのhook設定を読めません");
+            return { ...group, hooks: group.hooks.filter(hook => !isClaudeParentHook(hook)) };
+        }).filter(group => group.hooks.length > 0);
+    }
+    const next = { ...current, hooks };
+    if (isDeepStrictEqual(current, next))
+        return "unchanged";
+    const temporary = `${target}.aiterm-${randomUUID()}`;
+    try {
+        writeFileSync(temporary, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+        copyFileSync(target, `${target}.aiterm-backup`);
+        renameSync(temporary, target);
+    }
+    finally {
+        if (existsSync(temporary))
+            unlinkSync(temporary);
+    }
+    if (!isDeepStrictEqual(JSON.parse(readFileSync(target, "utf8")), next))
+        throw new SetupError("config_readback_failed", "Claude hook解除の読戻しが一致しません");
+    return "removed";
+}
 export function configureIntegrations(home, registration, run = runSetupCommand, resolveClient = resolveAgentBin) {
     const results = {};
     for (const client of ["claude", "codex", "grok", "cursor"]) {
@@ -69,6 +169,13 @@ export function configureIntegrations(home, registration, run = runSetupCommand,
                 const file = client === "cursor" ? join(home, ".cursor", "mcp.json")
                     : process.env.CLAUDE_CONFIG_DIR ? join(process.env.CLAUDE_CONFIG_DIR, ".claude.json") : join(home, ".claude.json");
                 mergeJsonMcp(file, client === "claude" ? { type: "stdio", ...registration } : registration);
+                if (client === "claude") {
+                    const version = /\b(\d+)\.(\d+)\.(\d+)\b/.exec(run(executable, ["--version"]));
+                    if (!version || Number(version[1]) < 2 || (Number(version[1]) === 2 && (Number(version[2]) < 1 || (Number(version[2]) === 1 && Number(version[3]) < 259)))) {
+                        throw new SetupError("claude_parent_delivery_unavailable", "自動配送にはClaude Code 2.1.259以上が必要です。公式CLIを更新してください");
+                    }
+                    mergeClaudeParentHooks(join(process.env.CLAUDE_CONFIG_DIR ?? join(home, ".claude"), "settings.json"), registration);
+                }
             }
             else if (client === "codex") {
                 // 親threadがないsetupでは公式queue入口まで確認し、宛先は各dispatchで検証する。

package/docs/00_overview.md

@@ -17,9 +17,8 @@ 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は未変更。
+Codex親への回答の自動配送は[DESIGN](DESIGN.md#codex親への自動配送)に、対応範囲と失敗時の状態を置く。
+Claude Code親の非同期hookによる受信は[DESIGN](DESIGN.md#claude-code親への自動配送)を参照する。
 
 ## 履歴と証拠
 

package/docs/DESIGN.md

@@ -49,10 +49,13 @@ Throughlineの補足記憶はpathを透過搬送するだけで、内容、proje
 
 agent turnは常に非ブロックdispatchであり、receiptの`event_cursor`がturn境界になる。
 Codex親にはAitermのMCP processが完了を観測し、回答本文を公式受信キューへ自動配送する。
+Claude Code親は公式の非同期hookで本文を受け取り、待機中も新しいturnへ進める。
 それ以外の親には`wait_process`がplatform nativeな別process起動情報を返す。
 waiterは純readerで、親のforeground turnを塞がない。
 回答はharness所有transcriptから同じturnへ相関して回収し、欠落・曖昧・timeout時にpromptを再送しない。
 Grok／Composerの記録先はCLIと同じOS絶対パスへcwdを正規化して導出し、完了通知と回答で同じ関数を使う。
+配送用のGrok回答は`turn_ended.ts`から同じturnの`turn_started.turn_number`を取得し、
+`chat_history.jsonl`の`user.prompt_index`と相関する。次turnが既に始まっていても対象回答だけを回収する。
 `agent_steer`は実行中のCodex／Grok turnへ追加textを差し込み、idleなら送信せず状態を返す。
 Cursorのsubmitはadapterがextended keyboard protocolのEnterへ変換し、呼び出し側は通常のdispatchだけを使う。
 起動直後のClaude sessionへの初回dispatchは、他harnessと同じくTUIの入力受付を確認してから貼付とEnterを送る。
@@ -72,12 +75,45 @@ native sub-agentを親にした外部queue入力はCodex自身が拒否するた
 `pty_observe`の`parent_deliveries`で状態を確認できる。`submitted`はキュー受付済みを示し、modelの読了を意味しない。
 次の依頼へ進める前に前回の回答を保存し、harness所有記録を後の回答と取り違えない。
 
-配送記録と本文はAiterm stateの`parent-deliveries`へ保存する。ownerのPIDと開始識別子で生存を判定し、
+Codexの配送記録と本文はAiterm stateの`parent-deliveries`へ保存する。ownerのPIDと開始識別子で生存を判定し、
 再接続後は終了したownerの記録だけを原子的に引き継ぐ。`waiting`は同じ境界から観測を再開し、
 `ready`は保存した本文を送る。送信中断は`unknown`として本文を残し、自動再送しない。
 受信口が明示拒否した場合は`failed`、子の異常終了はそのoutcomeを配送する。
 このstateは既存のPTY／harness stateと独立し、旧版は配送を再開しない。
 
+### Claude Code親への自動配送
+
+`aiterm-setup`はClaude Code 2.1.259以上を確認し、ユーザー設定へAiterm専用の`PreToolUse`、
+`PostToolUse`、`SessionEnd`を追加する。他製品のhookと設定は保持し、`disableAllHooks`の解除は行わない。
+hookはNodeの実行ファイルと引数配列で直接起動し、shellやWindowsのnpm shimを介さない。
+
+`PreToolUse`の`tool_use_id`／`session_id`とMCP要求の`_meta["claudecode/toolUseId"]`を照合する。
+起動時のsession環境変数は`/clear`で古くなるため宛先に使わない。hookがない場合と`agent_id`付きの会話は
+子への送信前に明示errorにする。親がIDや待機方法を引数で指定する必要はない。
+
+本文の保存と同じ子への連続依頼の制御は`parent-delivery.ts`を共有する。Claude用記録は
+`claude-parent-deliveries`へ分け、旧版のCodex readerに未知のparentを読ませない。
+子の予約は既存の`parent-deliveries/claims`で共有し、親の種類をまたぐ並行送信を防ぐ。
+hookとの受け渡しはAiterm stateの`claude-parent-hooks`へ置く。
+
+`PostToolUse`は`asyncRewake:true`で待機し、保存済み本文をstderrへ出してexit 2を返す。
+exit 2はClaudeが規定する再開信号であり、子の成功・失敗は本文の`outcome`で区別する。
+親は待機中も別作業や次のturnへ進める。Claudeの画面では`Stop hook feedback`として届く。
+`submitted`はhookへの本文出力を確認した状態であり、modelの読了を示さない。
+hook出力の切断・中断は`failed`または`unknown`とし、本文を残して自動再送しない。
+
+`SessionEnd`はその会話の未送信の依頼を終了させる。`/clear`後の新しい会話へ古い回答を出さず、
+確定本文は保存する。受信hookのtimeoutは24時間であり、timeoutとprocess終了は配送失敗として観測する。
+CLIを終了した後に自動再開するdaemon、Channelsの有効化flag、子の返送コマンドは使わない。
+hookを持たない旧版へ戻す時は、install前に`aiterm-setup --remove-claude-parent-hooks`で専用hookだけを解除する。
+
+Claude Desktopのチャット、Web、`agent_id`付きの会話（`--agent`で選んだ主会話とnative subagent）は
+この受信契約の対象に含めない。
+対応対象は公式command hookとMCP metadataを提供するClaude Codeの対話sessionである。
+
+Claudeの起動metadataには指定cwdの実体パスを保存する。Claude Codeが実体パスから作るproject slugと
+APIエラー監視の参照先を一致させ、監視中のリンク変更で保存場所を取り違えない。
+
 `trust_project:true`は対象projectの既知のworkspace、hooks、MCP初期同意を起動準備として進める意図である。
 promptなしでも入力受付とharness生存を確認して`startup.ready`を返す。指定なしのpromptなし起動は
 従来どおり`startup.not_checked`で返す。初手receiptは未要求・未送信・送信済み未確認・開始確認を分ける。

package/docs/RELEASE.md

@@ -39,6 +39,10 @@ setupを変更した場合は、公開packageのglobal install後に`aiterm-setu
 端末実行と検出した各AIの登録結果を確認する。初回と再実行は一時設定領域でも試験し、所有外の設定保持を確かめる。
 WindowsのGrokパス変更ではスラッシュ区切りcwdで起動し、同じturnの完了通知と回答回収を確認する。
 
+親への自動配送を変更した場合は、通常HOMEの親から子を起動し、親がwaiter・回収を呼ばずに
+初手と同じ子への追加依頼の回答を受け取ることを確認する。Claudeではhook待機中に別のturnへ進めること、
+`/clear`後に未送信の旧回答が届かず、Aitermに本文が保存されることも確認する。
+
 公式npm packageを隔離またはglobal installし、変更に触れたharnessの起動、non-blocking dispatch、wait outcome、
 transcript回収、`pty_close`後の残骸ゼロを確認する。
 
@@ -58,6 +62,9 @@ aiterm-setup --json
 
 巻き戻しは既知の正常版を指定する。
 
+Claude親配送hookのない旧版へ戻す場合は、旧版のinstall前に`aiterm-setup --remove-claude-parent-hooks`を
+実行する。Aiterm専用の3 hookだけを解除し、他製品のhookと設定を保持する。
+
 ```bash
 npm install -g "aiterm-mcp@<known-good-version>"
 ```

package/package.json

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