aiterm-mcp 0.33.0 → 0.34.0

package/dist/index.js

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

package/dist/parent-delivery.js

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