aiterm-mcp 0.37.10 → 0.38.1

package/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.38.1] - 2026-09-22
+
+### 修正
+
+- Cursor親のhookへ渡るtool結果は本文だけで、`structuredContent`の`delivery_id`が落ちる。dispatchの本文へ`delivery_id`行を出し、hookがその行から会話へ束縛する。
+
+## [0.38.0] - 2026-09-22
+
+### 追加
+
+- Cursor親（`cursor-vscode`）へ子の回答を自動配送する。`aiterm-setup`が`~/.cursor/hooks.json`へ`afterMCPExecution`と`postToolUse`を追加し、作業中は次のツール返りへ`additional_context`で本文を差し込む。ターンを終える前にreceiptの`wait_process`を背景で起動すると、idle中の完了でも受け口が本文を出して起きる。hook未登録は送信前に`CURSOR_PARENT_HOOK_UNAVAILABLE`で止める。解除は`aiterm-setup --remove-cursor-parent-hooks`。Codex／Claude Codeの配送契約は変えない。
+
 ## [0.37.10] - 2026-09-21
 
 ### 修正
@@ -1732,7 +1744,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.37.10...HEAD
+[Unreleased]: https://github.com/kitepon/aiterm-mcp/compare/v0.38.1...HEAD
+[0.38.1]: https://github.com/kitepon/aiterm-mcp/compare/v0.38.0...v0.38.1
+[0.38.0]: https://github.com/kitepon/aiterm-mcp/compare/v0.37.10...v0.38.0
 [0.37.10]: https://github.com/kitepon/aiterm-mcp/compare/v0.37.9...v0.37.10
 [0.37.9]: https://github.com/kitepon/aiterm-mcp/compare/v0.37.8...v0.37.9
 [0.37.8]: https://github.com/kitepon/aiterm-mcp/compare/v0.37.7...v0.37.8

package/README.ja.md

@@ -202,7 +202,7 @@ runtime-error store は canonical dotagents config の `collection.enabled: true
 場合だけ収集し、既定OFF、network送信は行いません。tag起点CIのnpm provenance（OIDC Trusted
 Publishing）で公開し、GitHub Release が Official MCP Registry を再登録します。
 
-**状態:** 開発継続中 · 現行公開版 **v0.37.10** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
+**状態:** 開発継続中 · 現行公開版 **v0.38.1** · 動作対象は Linux · WSL2 · macOS · Windows ネイティブ · MIT · [変更履歴](CHANGELOG.md)。
 
 ### 更新と巻き戻し
 
@@ -550,11 +550,11 @@ SSH先がPowerShellの場合、`mark:true`は現在の標準`PS ...>`プロン
 
 `pty_read({ wait: true })`は通常PTYを、process終了／`mark:true` sentinel／`until`一致／shell復帰を伴う出力静止／timeoutの5層で判定する。agent sessionは第6の正確な層を使い、Codexは通常rollout、Grokは通常session event、Claudeはlaunch相関Stop event、Cursorは通常agent transcriptの`turn_ended`を`aiterm-wait --cursor`が観測する。親はブロックもポーリングもしない。
 
-### Codex／Claude Code親への回答自動配送
+### Codex／Claude Code／Cursor親への回答自動配送
 
 Codex／Claude Codeから子を起動・通常dispatchした後は、別作業へ進むか親のturnを終了するだけでよい。Aitermが完了を観測し、加工前の回答を保存して親へ届ける。waiter、`pty_read`による回答回収、子への送信指示は不要。子は全対応harnessから選べる。
 
-自動配送時はreceiptに`parent_delivery`が付き、`wait_process`／`wait_command`はnullになる。`pty_observe`の`parent_deliveries`で`waiting`、`ready`、`sending`、`submitted`、`failed`、`unknown`を確認できる。`submitted`はCodexの公式受信口での受付またはClaudeのhookへの本文出力を示し、modelの読了ではない。MCP再接続後は未送信の記録を再開し、送信中に接続が切れて結果が分からない場合は本文を保持して`unknown`とする。自動再送はしない。
+Codex／Claude Codeの自動配送では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入力を拒否するため、自動配送の親としては未対応。
 
@@ -564,6 +564,8 @@ Claude Codeは2.1.259以上の対話sessionに対応する。`aiterm-setup`が
 
 hookを持たない旧版へ戻す時は、install前に`aiterm-setup --remove-claude-parent-hooks`を実行する。Aiterm専用hookだけを解除し、他製品のhookと設定は保持する。
 
+Cursor親（`clientInfo.name`が`cursor-vscode`）も同じ完了観測と本文保存を使う。`aiterm-setup`が`~/.cursor/hooks.json`へ`afterMCPExecution`と`postToolUse`を追加し、他製品のhookと順序は保持する。hookが無い場合は子への送信前に`CURSOR_PARENT_HOOK_UNAVAILABLE`で止める。作業を続けていれば次のツール返りへ`additional_context`で本文が差し込まれ、ターンを終える前にreceiptの`wait_process`を背景で起動しておけばidle中の完了でも起きられる。`wait_command`はnull。`submitted`はhookまたは受け口が本文を受け取った状態であり、modelの読了ではない。24時間以内に受け取りが無ければ`failed`とし、本文は残して自動再送しない。解除は`aiterm-setup --remove-cursor-parent-hooks`。Cursor Cloud Agent／Background Agentはこの受信契約に含めない。
+
 Claudeをリンク経由の`cwd`から起動した場合も、実体パスに対応する会話記録を参照する。
 
 

package/README.md

@@ -216,7 +216,7 @@ collection is off by default and performs no network I/O. It ships via
 tag-triggered CI with npm provenance (OIDC Trusted Publishing); the GitHub
 Release re-registers the Official MCP Registry entry.
 
-**Status:** actively maintained · current public release **v0.37.10** · 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.38.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
 
@@ -587,9 +587,9 @@ For PowerShell over SSH, `mark:true` recognizes the current standard `PS ...>` p
 
 ### Completion push for parent agents (`aiterm-wait`)
 
-**Codex／Claude Code親には子の回答本文が自動で届く。** 子を起動・dispatchした後は、別作業へ進むか親のturnを終える。Aitermが完了を観測し、加工前の本文を保存して親へ渡す。waiter、`pty_read`による回答回収、子への返送指示は不要。子は全対応harnessから選べる。
+**Codex／Claude Code／Cursor親には子の回答本文が自動で届く。** Codex／Claude Codeでは、子を起動・dispatchした後は別作業へ進むか親のturnを終える。Aitermが完了を観測し、加工前の本文を保存して親へ渡す。waiter、`pty_read`による回答回収、子への返送指示は不要。子は全対応harnessから選べる。
 
-自動配送のreceiptには`parent_delivery`が付き、`wait_process`／`wait_command`はnullになる。`pty_observe`の`parent_deliveries`で`waiting`、`ready`、`sending`、`submitted`、`failed`、`unknown`を確認できる。`submitted`はCodexの公式受信口での受付またはClaudeのhookへの本文出力を示し、modelの読了ではない。MCP再接続後は未送信の記録を再開し、出力中断で結果が分からない場合は本文を保持して`unknown`とする。自動再送はしない。
+Codex／Claude Codeの自動配送ではreceiptに`parent_delivery`が付き、`wait_process`／`wait_command`はnullになる。`pty_observe`の`parent_deliveries`で`waiting`、`ready`、`sending`、`submitted`、`failed`、`unknown`を確認できる。`submitted`はCodexの公式受信口での受付またはClaudeのhookへの本文出力を示し、modelの読了ではない。MCP再接続後は未送信の記録を再開し、出力中断で結果が分からない場合は本文を保持して`unknown`とする。自動再送はしない。
 
 For queue delivery, use a Codex runtime that supplies MCP `_meta.threadId` and the official `thread/queue` API (verified with Codex CLI 0.154.0). `aiterm-setup` checks the installed queue entry point; Aiterm verifies the requesting thread before each dispatch. Codex native sub-agents reject external queue input and cannot be automatic-delivery parents. Steer相当の選択時も公式キューへ投入し、専用hookが同一ターンへ取り込みます。
 
@@ -599,6 +599,8 @@ Claude Codeは2.1.259以上の対話sessionに対応する。`aiterm-setup`が
 
 hookを持たない旧版へ戻す時は、install前に`aiterm-setup --remove-claude-parent-hooks`を実行する。Aiterm専用hookだけを解除し、他製品のhookと設定は保持する。
 
+Cursor parents (`clientInfo.name` of `cursor-vscode`) use the same completion capture. `aiterm-setup` adds `afterMCPExecution` and `postToolUse` to `~/.cursor/hooks.json` and keeps every other hook and its position. A missing registration fails the dispatch with `CURSOR_PARENT_HOOK_UNAVAILABLE` before the child is sent. While the parent keeps calling tools, the answer is injected through `additional_context` on the next tool result. If the parent ends the turn, start the receipt `wait_process` in the background first; that receiver exits when the answer arrives. `wait_command` is null. `submitted` means the hook or the receiver claimed the text, not that the model has read it. No claim within 24 hours is `failed`, the text is kept, and nothing is resent. Remove only Aiterm's entries with `aiterm-setup --remove-cursor-parent-hooks`. Cursor Cloud Agents and Background Agents are outside this contract.
+
 Claudeをリンク経由の`cwd`から起動した場合も、実体パスに対応する会話記録を参照する。
 
 **For other parent hosts**, dispatch and start the receipt's waiter in a separate process:

package/dist/agent-shared.js

@@ -113,6 +113,46 @@ export function ensureStateRoot() {
 export function agentsDir() {
     return path.join(ensureStateRoot(), "agents");
 }
+/** directory内の状態変化を待つ。inspectが値を返した時点でresolveする。timeoutMsを省くと期限なし。 */
+export function waitForFileState(dir, inspect, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        let finished = false;
+        let timer;
+        let timeout;
+        const watcher = fs.watch(dir, () => check());
+        const finish = (error, value) => {
+            if (finished)
+                return;
+            finished = true;
+            watcher.close();
+            if (timer)
+                clearInterval(timer);
+            if (timeout)
+                clearTimeout(timeout);
+            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);
+        if (timeoutMs !== undefined)
+            timeout = setTimeout(() => finish(new Error("WAIT_FOR_FILE_TIMEOUT")), timeoutMs);
+        check();
+    });
+}
 export function agentEventPath(name, launchId) {
     assertSessionName(name);
     if (!LAUNCH_ID_RE.test(launchId))

package/dist/claude-parent-receiver.js

@@ -2,7 +2,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { z } from "zod";
-import { ensureStateRoot, writeJson0600 } from "./agent-shared.js";
+import { ensureStateRoot, waitForFileState, 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}$/);
@@ -99,41 +99,6 @@ export function closeClaudeParentSession(input, root = defaultRoot()) {
             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は終了しました。回答は保存したままです");

package/dist/core.js

@@ -2556,7 +2556,13 @@ export function agentWaitProcess(session, cursor, runtime = {}) {
 // 親ホストの識別（MCP initialize の clientInfo.name）。配送の可否はMCP入口が検証し、ここは案内だけを作る。
 let parentClientName = null;
 function autoDeliveryParent() {
-    return parentClientName === "codex-mcp-client" ? "Codex" : parentClientName === "claude-code" ? "Claude Code" : null;
+    if (parentClientName === "codex-mcp-client")
+        return "Codex";
+    if (parentClientName === "claude-code")
+        return "Claude Code";
+    if (parentClientName === "cursor-vscode" || parentClientName?.startsWith("cursor-vscode "))
+        return "Cursor";
+    return null;
 }
 export function setParentClient(name) {
     const trimmed = typeof name === "string" ? name.trim() : "";
@@ -2573,6 +2579,11 @@ export function agentWaitLaunchForm(command) {
 // dispatch / 起動時 prompt 送信後の共通案内。第一文で「待たない」を宣言し、待ち方は後段に置く。
 export function agentDispatchGuide(session, cursor) {
     const parent = autoDeliveryParent();
+    if (parent === "Cursor") {
+        return "回答はこの会話へ自動で届く。作業を続ければ次のツール返りに差し込まれる。" +
+            "ターンを終える前にreceiptのwait_processを背景（block_until_ms: 0）で起動しておけば、idle中に完了しても起きられる。" +
+            "ポーリング・pty_read(agent_transcript:true)は不要。";
+    }
     if (parent) {
         return `回答本文はAitermがこの${parent}親へ自動配送する。wait起動・ポーリング・通常の回答回収は不要。` +
             "親は作業を続けるかターンを終え、順番待ちから届く子の回答で続行する。";
@@ -2585,6 +2596,8 @@ export function agentDispatchGuide(session, cursor) {
 // 未完了 session へ触った時の共通案内。ここでも待つのは waiter プロセスであって親ではない。
 export function agentWaitGuide(session) {
     const parent = autoDeliveryParent();
+    if (parent === "Cursor")
+        return "回答はこの会話へ届く。完了通知はreceiptのwait_processを背景で起動して受ける。ポーリングは不要。";
     if (parent)
         return `回答本文はこの${parent}親へ自動配送される。親は作業を続けるかターンを終える。`;
     const cmd = `aiterm-wait --session ${session ?? "<session_id>"} --cursor 0`;

package/dist/cursor-parent-hook.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+// Cursorが起動する公式hook。MCP stdioとは別processで、差し込み文をstdoutのJSONへ返す。
+import { fileURLToPath } from "node:url";
+import * as fs from "node:fs";
+import { handleCursorHook } from "./cursor-parent-receiver.js";
+async function main() {
+    let input = "";
+    process.stdin.setEncoding("utf8");
+    for await (const chunk of process.stdin)
+        input += chunk;
+    const result = await handleCursorHook(input.length > 0 ? input : "{}");
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+}
+function isDirectExecution() {
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    try {
+        const self = fileURLToPath(import.meta.url);
+        const a = fs.realpathSync(entry);
+        const b = fs.realpathSync(self);
+        if (a === b)
+            return true;
+        return process.platform === "win32" && a.toLowerCase() === b.toLowerCase();
+    }
+    catch {
+        return false;
+    }
+}
+if (isDirectExecution()) {
+    main().catch(error => {
+        process.stderr.write(`${error instanceof Error ? error.message : "CURSOR_PARENT_HOOK_FAILED"}\n`);
+        process.exitCode = 2;
+    });
+}

package/dist/cursor-parent-receive.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+// Cursor親がidleのとき、背景で起動して回答本文の到着を待つ受け口。
+import { fileURLToPath } from "node:url";
+import * as fs from "node:fs";
+import { cursorHookRoot, receiveCursorAnswer } from "./cursor-parent-receiver.js";
+import { windowsStartProcessArgumentList } from "./core.js";
+export function cursorReceiveProcess(deliveryId, executable = process.execPath) {
+    const args = [fileURLToPath(import.meta.url), "--delivery", deliveryId];
+    return {
+        executable,
+        args,
+        windows_start_process_argument_list: process.platform === "win32" ? windowsStartProcessArgumentList(args) : null,
+    };
+}
+function emit(value) {
+    process.stdout.write(JSON.stringify(value) + "\n");
+}
+export async function main(argv) {
+    if (argv.length !== 2 || argv[0] !== "--delivery" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(argv[1])) {
+        emit({ ok: false, code: "CURSOR_PARENT_RECEIVE_USAGE", message: "usage: cursor-parent-receive --delivery <uuid>" });
+        return 1;
+    }
+    const result = await receiveCursorAnswer(cursorHookRoot(), argv[1]);
+    if (result.outcome === "timeout") {
+        emit({ delivery_id: argv[1], outcome: "timeout" });
+        return 3;
+    }
+    if (result.outcome === "delivered_by_hook") {
+        emit({ delivery_id: argv[1], outcome: "delivered_by_hook" });
+        return 0;
+    }
+    emit({ delivery_id: argv[1], outcome: "delivered", text: result.text });
+    return 0;
+}
+function isDirectExecution() {
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    try {
+        const self = fileURLToPath(import.meta.url);
+        const a = fs.realpathSync(entry);
+        const b = fs.realpathSync(self);
+        if (a === b)
+            return true;
+        return process.platform === "win32" && a.toLowerCase() === b.toLowerCase();
+    }
+    catch {
+        return false;
+    }
+}
+if (isDirectExecution()) {
+    main(process.argv.slice(2)).then(code => { process.exitCode = code; }).catch(error => {
+        emit({ ok: false, code: "CURSOR_PARENT_RECEIVE_FAILED", message: error instanceof Error ? error.message : "cursor-parent-receive: operation failed" });
+        process.exitCode = 1;
+    });
+}

package/dist/cursor-parent-receiver.js

@@ -0,0 +1,255 @@
+// Cursor親の受信口。会話への差し込みはCursor公式hookのadditional_context、idle時の起床は受け口processが担う。
+import * as fs from "node:fs";
+import { homedir } from "node:os";
+import * as path from "node:path";
+import { z } from "zod";
+import { ensureStateRoot, waitForFileState, writeJson0600 } from "./agent-shared.js";
+import { AitermError } from "./errors.js";
+export const cursorParentSchema = z.object({
+    kind: z.literal("cursor"),
+    hook_root: z.string(),
+}).strict();
+const deliveryIdSchema = z.string().uuid();
+const dispatchTools = new Set([
+    "agent_launch", "claude_agent", "codex_agent", "grok_agent", "composer_agent", "pty_send", "claude_turn",
+]);
+export class CursorDeliveryError 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;
+    }
+}
+export function isCursorMcpClient(clientName) {
+    if (clientName === undefined)
+        return false;
+    return clientName === "cursor-vscode" || clientName.startsWith("cursor-vscode ");
+}
+export function cursorHookRoot(state = ensureStateRoot()) {
+    return path.join(state, "cursor-parent-hooks");
+}
+export function cursorHooksFile(home = process.env.HOME ?? homedir()) {
+    return path.join(process.env.CURSOR_HOME ?? path.join(home, ".cursor"), "hooks.json");
+}
+export function cursorParentHooksRegistered(document) {
+    if (document === null || typeof document !== "object" || Array.isArray(document))
+        return false;
+    const hooks = document.hooks;
+    if (hooks === null || typeof hooks !== "object" || Array.isArray(hooks))
+        return false;
+    const owns = (event) => {
+        const list = hooks[event];
+        return Array.isArray(list) && list.some(entry => {
+            if (entry === null || typeof entry !== "object")
+                return false;
+            const command = entry.command;
+            return typeof command === "string" && command.includes("cursor-parent-hook.js");
+        });
+    };
+    return owns("postToolUse") && owns("afterMCPExecution");
+}
+export function verifyCursorParent(parent, hooksFile = cursorHooksFile()) {
+    cursorParentSchema.parse(parent);
+    let document;
+    try {
+        document = JSON.parse(fs.readFileSync(hooksFile, "utf8"));
+    }
+    catch {
+        throw new CursorDeliveryError("CURSOR_PARENT_HOOK_UNAVAILABLE", "Cursorのhookが登録されていません。aiterm-setupを実行してください");
+    }
+    if (!cursorParentHooksRegistered(document)) {
+        throw new CursorDeliveryError("CURSOR_PARENT_HOOK_UNAVAILABLE", "Cursorのhookが登録されていません。aiterm-setupを実行してください");
+    }
+}
+export function cursorParentFromRequest(clientName, options = {}) {
+    if (!isCursorMcpClient(clientName))
+        return null;
+    const parent = { kind: "cursor", hook_root: options.hookRoot ?? cursorHookRoot() };
+    verifyCursorParent(parent, options.hooksFile);
+    return parent;
+}
+function deliveryDir(parent, deliveryId) {
+    return path.join(parent.hook_root, "deliveries", deliveryIdSchema.parse(deliveryId));
+}
+export function prepareCursorDelivery(parent, deliveryId) {
+    cursorParentSchema.parse(parent);
+    fs.mkdirSync(deliveryDir(parent, deliveryId), { recursive: true, mode: 0o700 });
+}
+export async function submitCursorParentAnswer(parent, deliveryId, text, timeoutMs = 86_400_000) {
+    const dir = deliveryDir(parent, deliveryId);
+    writeJson0600(path.join(dir, "answer.json"), { delivery_id: deliveryId, text });
+    try {
+        await waitForFileState(dir, () => fs.existsSync(path.join(dir, "claim.json")) ? true : undefined, timeoutMs);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "WAIT_FOR_FILE_TIMEOUT") {
+            throw new CursorDeliveryError("CURSOR_PARENT_DELIVERY_UNCLAIMED", "Cursor親が時間内に回答を受け取りませんでした。回答は保存したままです");
+        }
+        throw error;
+    }
+    return { queued_submission_id: null };
+}
+function conversationId(value) {
+    if (typeof value !== "string" || value.length === 0 || value.length > 200)
+        return null;
+    if (value.includes("/") || value.includes("\\") || value.includes(".."))
+        return null;
+    return value;
+}
+function parseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function deliveryIdFromResult(value, depth = 0) {
+    if (depth > 3 || value === null || value === undefined)
+        return null;
+    const parsed = typeof value === "string" ? parseJson(value) : value;
+    if (parsed === null || typeof parsed !== "object")
+        return null;
+    const record = parsed;
+    const structured = record.structuredContent;
+    const carrier = structured !== null && typeof structured === "object" ? structured : record;
+    const parentDelivery = carrier.parent_delivery;
+    if (parentDelivery !== null && typeof parentDelivery === "object") {
+        const id = parentDelivery.delivery_id;
+        if (typeof id === "string" && deliveryIdSchema.safeParse(id).success)
+            return id;
+    }
+    if (depth === 0 && Array.isArray(record.content)) {
+        for (const entry of record.content) {
+            if (entry !== null && typeof entry === "object" && entry.type === "text") {
+                const text = entry.text;
+                if (typeof text === "string") {
+                    const id = deliveryIdFromResult(text, depth + 1) ?? deliveryIdInText(text);
+                    if (id)
+                        return id;
+                }
+            }
+        }
+    }
+    return null;
+}
+function deliveryIdInText(text) {
+    for (const line of text.split("\n")) {
+        const match = /^delivery_id=([0-9a-f-]{36})$/i.exec(line.trim());
+        if (match && deliveryIdSchema.safeParse(match[1]).success)
+            return match[1];
+    }
+    return null;
+}
+function toolBaseName(name) {
+    const tail = name.split(/[:.]/).pop() ?? name;
+    return tail.replace(/^mcp__aiterm__/, "");
+}
+function claim(dir, channel) {
+    try {
+        fs.writeFileSync(path.join(dir, "claim.json"), JSON.stringify({ channel, at: new Date().toISOString() }), { flag: "wx", mode: 0o600 });
+        return true;
+    }
+    catch (error) {
+        if (error.code === "EEXIST")
+            return false;
+        throw error;
+    }
+}
+function bind(hookRoot, deliveryId, conv) {
+    const dir = path.join(hookRoot, "deliveries", deliveryId);
+    if (!fs.existsSync(dir))
+        return;
+    const bindFile = path.join(dir, "bind.json");
+    if (!fs.existsSync(bindFile)) {
+        writeJson0600(bindFile, { conversation_id: conv, created_at: new Date().toISOString() });
+    }
+    const indexDir = path.join(hookRoot, "conversations", conv);
+    fs.mkdirSync(indexDir, { recursive: true, mode: 0o700 });
+    const index = path.join(indexDir, deliveryId);
+    if (!fs.existsSync(index))
+        fs.writeFileSync(index, "", { mode: 0o600 });
+}
+function inject(hookRoot, conv) {
+    const indexDir = path.join(hookRoot, "conversations", conv);
+    if (!fs.existsSync(indexDir))
+        return [];
+    const pending = fs.readdirSync(indexDir).flatMap(deliveryId => {
+        const dir = path.join(hookRoot, "deliveries", deliveryId);
+        const answerFile = path.join(dir, "answer.json");
+        const bindFile = path.join(dir, "bind.json");
+        if (!fs.existsSync(answerFile) || !fs.existsSync(bindFile))
+            return [];
+        const answer = z.object({ delivery_id: z.string(), text: z.string() }).parse(JSON.parse(fs.readFileSync(answerFile, "utf8")));
+        const bound = z.object({ conversation_id: z.string(), created_at: z.string() }).parse(JSON.parse(fs.readFileSync(bindFile, "utf8")));
+        if (answer.delivery_id !== deliveryId || bound.conversation_id !== conv)
+            return [];
+        return [{ deliveryId, dir, created_at: bound.created_at, text: answer.text }];
+    }).sort((a, b) => a.created_at.localeCompare(b.created_at));
+    const texts = [];
+    for (const item of pending) {
+        const index = path.join(indexDir, item.deliveryId);
+        if (!claim(item.dir, "hook")) {
+            if (fs.existsSync(path.join(item.dir, "claim.json")))
+                fs.rmSync(index, { force: true });
+            continue;
+        }
+        texts.push(item.text);
+        fs.rmSync(index, { force: true });
+    }
+    return texts;
+}
+export async function handleCursorHook(raw, hookRoot = cursorHookRoot()) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+    if (parsed === null || typeof parsed !== "object")
+        return {};
+    const event = parsed;
+    const name = event.hook_event_name;
+    if (name !== "afterMCPExecution" && name !== "postToolUse" && name !== "postToolUseFailure")
+        return {};
+    const conv = conversationId(event.conversation_id);
+    if (!conv)
+        return {};
+    const toolName = typeof event.tool_name === "string" ? event.tool_name : "";
+    if (dispatchTools.has(toolBaseName(toolName))) {
+        const payload = name === "afterMCPExecution" ? event.result_json : event.tool_output;
+        const deliveryId = deliveryIdFromResult(payload);
+        if (deliveryId)
+            bind(hookRoot, deliveryId, conv);
+    }
+    if (name === "postToolUse" || name === "postToolUseFailure") {
+        const texts = inject(hookRoot, conv);
+        if (texts.length > 0)
+            return { additional_context: texts.join("\n\n") };
+    }
+    return {};
+}
+export async function receiveCursorAnswer(hookRoot, deliveryId, timeoutMs = 86_400_000) {
+    const id = deliveryIdSchema.parse(deliveryId);
+    const dir = path.join(hookRoot, "deliveries", id);
+    if (!fs.existsSync(dir))
+        throw new CursorDeliveryError("CURSOR_PARENT_DELIVERY_UNKNOWN", "Cursor配送の記録がありません");
+    const answerFile = path.join(dir, "answer.json");
+    try {
+        await waitForFileState(dir, () => fs.existsSync(answerFile) ? true : undefined, timeoutMs);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "WAIT_FOR_FILE_TIMEOUT")
+            return { outcome: "timeout" };
+        throw error;
+    }
+    const answer = z.object({ delivery_id: z.string(), text: z.string() }).parse(JSON.parse(fs.readFileSync(answerFile, "utf8")));
+    if (answer.delivery_id !== id)
+        throw new CursorDeliveryError("CURSOR_PARENT_DELIVERY_MISMATCH", "保存された回答の配送IDが一致しません");
+    if (!claim(dir, "receiver"))
+        return { outcome: "delivered_by_hook" };
+    return { outcome: "delivered", text: answer.text };
+}

package/dist/index.js

@@ -18,6 +18,7 @@ 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";
+import { cursorParentFromRequest, isCursorMcpClient } from "./cursor-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,15 +26,33 @@ import { claudeParentFromRequest } from "./claude-parent-receiver.js";
 const pkg = createRequire(import.meta.url)("../package.json");
 const server = new McpServer({ name: "aiterm", version: pkg.version });
 let parentDelivery = null;
+function deliveryParentKind(clientName) {
+    if (clientName === "claude-code")
+        return "claude";
+    if (isCursorMcpClient(clientName))
+        return "cursor";
+    return undefined;
+}
 async function deliveryForRequest(extra) {
     const clientName = server.server.getClientVersion()?.name;
-    const parent = codexParentFromRequest(clientName, extra._meta) ?? claudeParentFromRequest(clientName, extra._meta);
+    const parent = codexParentFromRequest(clientName, extra._meta) ?? claudeParentFromRequest(clientName, extra._meta) ?? cursorParentFromRequest(clientName);
     if (!parent)
         return null;
-    parentDelivery ??= new ParentDeliveryManager({ parent_kind: clientName === "claude-code" ? "claude" : undefined });
+    parentDelivery ??= new ParentDeliveryManager({ parent_kind: deliveryParentKind(clientName) });
     await parentDelivery.prepare(parent);
     return parentDelivery.request(parent);
 }
+function deliveryIdLine(delivery) {
+    const id = delivery?.result()?.delivery_id;
+    return id ? `\ndelivery_id=${id}` : "";
+}
+function completionWait(delivery, session, eventCursor) {
+    if (eventCursor === null)
+        return { wait_process: null, wait_command: null };
+    if (delivery)
+        return { wait_process: delivery.wait_process(), wait_command: null };
+    return { wait_process: core.agentWaitProcess(session, eventCursor), wait_command: `aiterm-wait --session ${session} --cursor ${eventCursor}` };
+}
 /**
  * dispatch 系の説明で共有する非ブロック規範。tool description は registerTool 時＝initialize 前に
  * 固定されるため親ホストを名指しできない（ホスト別の具体形は receipt 側が core.agentWaitLaunchForm で出す）。
@@ -41,6 +60,7 @@ async function deliveryForRequest(extra) {
  */
 const NON_BLOCKING_RULE = "dispatch した子は投げっぱなしでよい＝親はここで待たない。" +
     "Codex親とClaude Code親にはAitermが回答本文を自動配送する。parent_deliveryがある場合はwait起動も通常の回答回収も不要。親は作業を続けるかターンを終える。" +
+    "Cursor親にはparent_deliveryとwait_processが付く。作業を続ければ次のツール返りに回答が差し込まれ、ターンを終える前にwait_processを背景で起動するとidle中の完了でも起きられる。ポーリングとpty_read(agent_transcript:true)は不要。" +
     "その他の親では、完了通知をreceiptの `wait_process.executable` と `wait_process.args` をそのまま親のターンを塞がない別プロセスAPIへ渡して受け、" +
     "PowerShell 7のStart-Processだけは `windows_start_process_argument_list` を単一文字列として渡す。" +
     `exit を完了通知として扱う（${core.AITERM_WAIT_OUTCOME_NOTE}。ポーリング不要）。` +
@@ -190,14 +210,15 @@ server.registerTool("pty_send", {
                 throw new Error("agent session への dispatch は rtk:true と併用できません");
             delivery = await deliveryForRequest(extra);
             const receipt = await core.dispatchAgentTurn(session_id, core.attachImages(text, image), { raw, before_send: delivery?.before_send });
-            const waitProcess = delivery ? null : core.agentWaitProcess(receipt.session_id, receipt.event_cursor);
+            const waited = completionWait(delivery, receipt.session_id, receipt.event_cursor);
             return {
                 content: [
                     {
                         type: "text",
                         text: `dispatchした（harness=${receipt.harness}, vendor=${receipt.vendor}）。\n` +
                             core.agentDispatchGuide(receipt.session_id, receipt.event_cursor) +
-                            core.agentSubmitResidueWarning(receipt.session_id, receipt.submit_residue),
+                            core.agentSubmitResidueWarning(receipt.session_id, receipt.submit_residue) +
+                            deliveryIdLine(delivery),
                     },
                 ],
                 structuredContent: {
@@ -205,7 +226,7 @@ server.registerTool("pty_send", {
                     mode: "agent_dispatch",
                     session_id: receipt.session_id,
                     event_cursor: receipt.event_cursor,
-                    wait_process: waitProcess,
+                    wait_process: waited.wait_process,
                     ...(delivery?.result() ? { parent_delivery: delivery.result() } : {}),
                     launch_id: receipt.launch_id,
                     vendor: receipt.vendor,
@@ -687,8 +708,7 @@ async function launchAgent(kind, args, extra) {
             session_id: sid,
             managed_completion: true,
             event_cursor: eventCursor,
-            wait_process: eventCursor === null || delivery ? null : core.agentWaitProcess(sid, eventCursor),
-            wait_command: eventCursor === null || delivery ? null : `aiterm-wait --session ${sid} --cursor ${eventCursor}`,
+            ...completionWait(delivery, sid, eventCursor),
             ...(delivery?.result() ? { parent_delivery: delivery.result() } : {}),
             submit_residue: submitResidue,
             initial_prompt: initialDelivery,
@@ -703,7 +723,7 @@ async function launchAgent(kind, args, extra) {
                 : {}),
         };
         return {
-            content: [{ type: "text", text: `session_id: ${sid}\n${hint}` }],
+            content: [{ type: "text", text: `session_id: ${sid}\n${hint}${deliveryIdLine(delivery)}` }],
             structuredContent: structured,
             ...(initialDelivery.status === "submitted_unconfirmed" ? { isError: true } : {}),
         };
@@ -716,8 +736,7 @@ async function launchAgent(kind, args, extra) {
                 structuredContent: {
                     schema: "aiterm.agent-launch-result.v1", provider: kind, harness: core.agentHarness(kind),
                     session_id: e.session_id, managed_completion: true, event_cursor: e.event_cursor,
-                    wait_process: e.event_cursor === null || delivery ? null : core.agentWaitProcess(e.session_id, e.event_cursor),
-                    wait_command: e.event_cursor === null || delivery ? null : `aiterm-wait --session ${e.session_id} --cursor ${e.event_cursor}`,
+                    ...completionWait(delivery, e.session_id, e.event_cursor),
                     ...(delivery?.result() ? { parent_delivery: delivery.result() } : {}),
                     submit_residue: null, initial_prompt: e.initial_prompt, startup: e.startup,
                 },
@@ -863,8 +882,9 @@ async function main() {
     server.server.oninitialized = () => {
         const name = server.server.getClientVersion()?.name;
         core.setParentClient(name ?? null);
-        if (name === "codex-mcp-client" || name === "claude-code")
-            parentDelivery ??= new ParentDeliveryManager({ parent_kind: name === "claude-code" ? "claude" : undefined });
+        if (name === "codex-mcp-client" || name === "claude-code" || isCursorMcpClient(name)) {
+            parentDelivery ??= new ParentDeliveryManager({ parent_kind: deliveryParentKind(name) });
+        }
     };
     server.server.onclose = () => {
         void parentDelivery?.close().catch(() => process.stderr.write("aiterm: PARENT_DELIVERY_CLOSE_FAILED\n"));

package/dist/parent-delivery.js

@@ -8,6 +8,8 @@ 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 { cursorParentSchema, CursorDeliveryError, prepareCursorDelivery, submitCursorParentAnswer, verifyCursorParent } from "./cursor-parent-receiver.js";
+import { cursorReceiveProcess } from "./cursor-parent-receive.js";
 import { AitermError } from "./errors.js";
 import { codexHookDeliveryState } from "./codex-hook-state.js";
 const recordSchema = z.object({
@@ -15,7 +17,7 @@ const recordSchema = z.object({
     delivery_id: z.uuid(),
     created_at: z.string(),
     updated_at: z.string(),
-    parent: z.union([z.object({ thread_id: z.uuid(), codex_home: z.string() }).strict(), claudeParentSchema]),
+    parent: z.union([z.object({ thread_id: z.uuid(), codex_home: z.string() }).strict(), claudeParentSchema, cursorParentSchema]),
     boundary: z.object({
         session_id: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/),
         launch_id: z.string().regex(/^[0-9a-f]{32}$/),
@@ -31,14 +33,22 @@ const recordSchema = z.object({
     queued_submission_id: z.string().nullable(),
 }).strict();
 const isClaude = (parent) => "kind" in parent && parent.kind === "claude";
+const isCursor = (parent) => "kind" in parent && parent.kind === "cursor";
+const isCodex = (parent) => !isClaude(parent) && !isCursor(parent);
 async function verifyParent(parent) {
     if (isClaude(parent))
         verifyClaudeParent(parent);
+    else if (isCursor(parent))
+        verifyCursorParent(parent);
     else
         await verifyCodexParent(parent);
 }
 async function submitParentAnswer(parent, deliveryId, text) {
-    return isClaude(parent) ? submitClaudeParentAnswer(parent, deliveryId, text) : submitCodexParentAnswer(parent, deliveryId, text);
+    if (isClaude(parent))
+        return submitClaudeParentAnswer(parent, deliveryId, text);
+    if (isCursor(parent))
+        return submitCursorParentAnswer(parent, deliveryId, text);
+    return submitCodexParentAnswer(parent, deliveryId, text);
 }
 function readRecord(file) {
     try {
@@ -54,7 +64,7 @@ function readRecord(file) {
     }
 }
 function receipt(record) {
-    const hookState = !isClaude(record.parent) && record.state === "submitted"
+    const hookState = isCodex(record.parent) && record.state === "submitted"
         ? codexHookDeliveryState(record.parent.codex_home, record.parent.thread_id, record.delivery_id) : null;
     return { delivery_id: record.delivery_id, state: hookState ?? record.state, child_outcome: record.child_outcome,
         child_turn_id: record.child_turn_id, queued_submission_id: record.queued_submission_id,
@@ -87,9 +97,15 @@ export class ParentDeliveryManager {
         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")];
+        const directory = options.parent_kind === "claude" ? "claude-parent-deliveries"
+            : options.parent_kind === "cursor" ? "cursor-parent-deliveries" : "parent-deliveries";
+        this.root = options.root ?? path.join(stateRoot, directory);
+        // 旧版のCodex／Claude readerへ未知のparentを渡さない。公開照会と子の予約だけは保存場所を横断する。
+        this.recordRoots = options.root ? [options.root] : [
+            path.join(stateRoot, "parent-deliveries"),
+            path.join(stateRoot, "claude-parent-deliveries"),
+            path.join(stateRoot, "cursor-parent-deliveries"),
+        ];
         this.active = path.join(this.root, "active");
         this.results = path.join(this.root, "results");
         this.claims = path.join(options.root ?? path.join(stateRoot, "parent-deliveries"), "claims");
@@ -148,6 +164,17 @@ export class ParentDeliveryManager {
                     }
                     if (isClaude(parent))
                         bindClaudeParentDelivery(parent, record.delivery_id);
+                    if (isCursor(parent)) {
+                        try {
+                            prepareCursorDelivery(parent, record.delivery_id);
+                        }
+                        catch (error) {
+                            this.releaseClaim(job);
+                            fs.unlinkSync(job.file);
+                            job = null;
+                            throw error;
+                        }
+                    }
                     this.jobs.set(record.delivery_id, job);
                     this.watch(job);
                 });
@@ -161,6 +188,7 @@ export class ParentDeliveryManager {
                 }
             },
             result: () => job ? receipt(job.record) : null,
+            wait_process: () => job && isCursor(parent) ? cursorReceiveProcess(job.record.delivery_id) : null,
             failed: (error) => {
                 if (!job || job.record.state !== "waiting")
                     return;
@@ -264,7 +292,8 @@ export class ParentDeliveryManager {
             job.record.state = "submitted";
         }
         catch (error) {
-            job.record.state = (error instanceof CodexDeliveryError || error instanceof ClaudeDeliveryError) && !error.outcome_unknown ? "failed" : "unknown";
+            const known = error instanceof CodexDeliveryError || error instanceof ClaudeDeliveryError || error instanceof CursorDeliveryError;
+            job.record.state = known && !error.outcome_unknown ? "failed" : "unknown";
             job.record.error = error instanceof Error ? error.message : String(error);
         }
         this.finish(job);

package/dist/setup-cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { runSetup } from "./setup.js";
-import { removeClaudeParentHooks } from "./setup-integrations.js";
+import { removeClaudeParentHooks, removeCursorParentHooks } from "./setup-integrations.js";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { createInterface } from "node:readline/promises";
@@ -16,8 +16,18 @@ if (args.length === 1 && args[0] === "--remove-claude-parent-hooks") {
         process.exitCode = 2;
     }
 }
+else if (args.length === 1 && args[0] === "--remove-cursor-parent-hooks") {
+    try {
+        const status = removeCursorParentHooks(join(process.env.CURSOR_HOME ?? join(process.env.HOME ?? homedir(), ".cursor"), "hooks.json"));
+        process.stdout.write(`${JSON.stringify({ schema: "aiterm.cursor-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] [--codex-steer enable|disable|status]\n依存準備、AIへの登録、MCPと端末の実動作確認を行います。対話実行ではAiterm単品かCodex Desktop Steer付きかを選べます。SteerはmacOS・Windows対応で、初回はCodexの再起動が必要です。disableは専用hookを解除し、statusは公式hookの登録・承認と再起動の必要性を確認します。旧中継はhook導入後に解除します。--jsonは対話せず、Steerの選択を維持します。\n旧版へ戻す前のClaude専用hook解除: --remove-claude-parent-hooks\n");
+    process.stdout.write("使い方: aiterm-setup [--json] [--codex-steer enable|disable|status]\n依存準備、AIへの登録、MCPと端末の実動作確認を行います。対話実行ではAiterm単品かCodex Desktop Steer付きかを選べます。SteerはmacOS・Windows対応で、初回はCodexの再起動が必要です。disableは専用hookを解除し、statusは公式hookの登録・承認と再起動の必要性を確認します。旧中継はhook導入後に解除します。--jsonは対話せず、Steerの選択を維持します。\n旧版へ戻す前のClaude専用hook解除: --remove-claude-parent-hooks\n旧版へ戻す前のCursor専用hook解除: --remove-cursor-parent-hooks\n");
 }
 else {
     try {

package/dist/setup-integrations.js

@@ -156,6 +156,116 @@ export function removeClaudeParentHooks(file) {
         throw new SetupError("config_readback_failed", "Claude hook解除の読戻しが一致しません");
     return "removed";
 }
+function shellQuote(value) {
+    if (process.platform === "win32")
+        return `'${value.replace(/'/g, "''")}'`;
+    return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+export function cursorParentHookCommand(registration) {
+    const script = join(dirname(registration.args[0]), "cursor-parent-hook.js");
+    const command = `${shellQuote(registration.command)} ${shellQuote(script)}`;
+    return process.platform === "win32" ? `& ${command}` : command;
+}
+function ownsCursorParentHook(hook) {
+    return record(hook) && typeof hook.command === "string" && hook.command.includes("cursor-parent-hook.js");
+}
+export function mergeCursorParentHooks(file, registration) {
+    const target = existsSync(file) ? realpathSync(file) : file;
+    let current = { version: 1, hooks: {} };
+    if (existsSync(target)) {
+        try {
+            current = JSON.parse(readFileSync(target, "utf8"));
+        }
+        catch {
+            throw new SetupError("config_invalid", "Cursorのhook設定JSONを読めません");
+        }
+    }
+    else {
+        try {
+            if (lstatSync(file).isSymbolicLink())
+                throw new SetupError("config_invalid", "Cursorのhooks設定symlinkの参照先がありません");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    if (!record(current) || (current.hooks !== undefined && !record(current.hooks))) {
+        throw new SetupError("config_invalid", "Cursorのhooks設定はobjectである必要があります");
+    }
+    const hooks = { ...current.hooks };
+    const entry = { command: cursorParentHookCommand(registration), timeout: 15 };
+    for (const event of ["afterMCPExecution", "postToolUse"]) {
+        const previous = hooks[event] ?? [];
+        if (!Array.isArray(previous))
+            throw new SetupError("config_invalid", `Cursorの${event} hook形式を読めません`);
+        const retained = previous.filter(hook => !ownsCursorParentHook(hook));
+        const owned = previous.filter(hook => ownsCursorParentHook(hook));
+        if (owned.length === 1 && isDeepStrictEqual(owned[0], entry) && retained.length + 1 === previous.length)
+            continue;
+        const index = previous.findIndex(hook => ownsCursorParentHook(hook));
+        hooks[event] = index < 0 ? [...retained, entry] : previous.map((hook, i) => i === index ? entry : hook).filter((hook, i) => i === index || !ownsCursorParentHook(hook));
+    }
+    const next = { ...current, version: current.version ?? 1, 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", "Cursorのhook登録の読戻しが一致しません");
+    }
+    return "configured";
+}
+export function removeCursorParentHooks(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", "Cursorのhook設定を読めません");
+    }
+    if (current.hooks === undefined)
+        return "unchanged";
+    const hooks = { ...current.hooks };
+    for (const event of ["afterMCPExecution", "postToolUse"]) {
+        if (hooks[event] === undefined)
+            continue;
+        if (!Array.isArray(hooks[event]))
+            throw new SetupError("config_invalid", "Cursorのhook設定を読めません");
+        const retained = hooks[event].filter(hook => !ownsCursorParentHook(hook));
+        if (retained.length)
+            hooks[event] = retained;
+        else
+            delete hooks[event];
+    }
+    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", "Cursor hook解除の読戻しが一致しません");
+    }
+    return "removed";
+}
 export function configureIntegrations(home, registration, run = runSetupCommand, resolveClient = resolveAgentBin) {
     const results = {};
     for (const client of ["claude", "codex", "grok", "cursor"]) {
@@ -169,6 +279,8 @@ 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 === "cursor")
+                    mergeCursorParentHooks(join(home, ".cursor", "hooks.json"), 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)))) {

package/docs/DESIGN.md

@@ -151,6 +151,25 @@ Claude Desktopのチャット、Web、`agent_id`付きの会話（`--agent`で
 Claudeの起動metadataには指定cwdの実体パスを保存する。Claude Codeが実体パスから作るproject slugと
 APIエラー監視の参照先を一致させ、監視中のリンク変更で保存場所を取り違えない。
 
+### Cursor親への自動配送
+
+`aiterm-setup`は`~/.cursor/hooks.json`へAiterm専用の`afterMCPExecution`と`postToolUse`を追加する。
+他製品のhookと順序は保持し、`command`に`cursor-parent-hook.js`を含むentryだけを更新する。
+親の識別はMCP `initialize`の`clientInfo.name`が`cursor-vscode`（またはその後ろに空白を挟む派生名）であることだけで、
+会話IDはMCPの`_meta`に来ない。hook未登録は子への送信前に`CURSOR_PARENT_HOOK_UNAVAILABLE`で止め、waiterへ切り替えない。
+
+`afterMCPExecution`またはdispatch toolの`postToolUse`が、tool返りの`parent_delivery.delivery_id`とhook入力の
+`conversation_id`を結ぶ。`delivery_id`は`structuredContent`か、`content`のtextをJSONとして読んだ中から取る。
+完了観測と本文保存は`parent-delivery.ts`が所有し、記録は`cursor-parent-deliveries`へ分ける。子の予約`claims`は共有する。
+
+親が次のツールを呼ぶと`postToolUse`が未受領の本文を`additional_context`で会話へ差し込む。
+親がターンを終えている場合は、receiptの`wait_process`で起動した`cursor-parent-receive`が本文をstdoutへ出して終了する。
+`wait_command`はnull。受け取りは`claim.json`の排他作成で一つに決め、hookと受け口の両方へ本文を出さない。
+`submitted`はどちらかがclaimした状態であり、modelの読了ではない。24時間以内にclaimが無ければ`failed`とし、
+本文は残して自動再送しない。Cursor Cloud Agent／Background Agentはこの受信契約に含めない。
+
+hookを外す時は`aiterm-setup --remove-cursor-parent-hooks`で専用entryだけを解除する。
+
 `trust_project:true`は対象projectの既知のworkspace、hooks、MCP初期同意を起動準備として進める意図である。
 promptなしでも入力受付とharness生存を確認して`startup.ready`を返す。指定なしのpromptなし起動は
 従来どおり`startup.not_checked`で返す。初手receiptは未要求・未送信・送信済み未確認・開始確認を分ける。

package/package.json

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