@armadra/agent 0.6.8 → 0.7.0

package/dist/modes/acp/acp-events.d.ts

@@ -1,46 +1,82 @@
 /**
- * `ama --mode acp`：ama 的会话事件 → ACP `session/update`（docs/wave5-plan.md §5.6）。[W5-E]
+ * `ama --mode acp`：ama 的会话事件 → ACP `session/update`（docs/wave5-plan.md §5.6、docs/acp-plan.md §2.3）。
  *
- * | ama                                  | ACP                                                        |
- * | ------------------------------------ | ---------------------------------------------------------- |
- * | message_update text_delta            | agent_message_chunk                                        |
- * | message_update thinking_delta        | agent_thought_chunk                                        |
- * | message_update toolcall_end          | tool_call（pending，带 rawInput 与 locations）             |
- * | tool_execution_start / end           | tool_call_update（in_progress → completed / failed）       |
- * | todo_updated                         | plan                                                       |
- * | turn_end                             | usage_update（上下文用量、窗口、会话累计美元）             |
- * | permission_mode_changed              | current_mode_update                                        |
+ * | ama                                       | ACP                                                              |
+ * | ----------------------------------------- | ---------------------------------------------------------------- |
+ * | message_update text_delta                 | agent_message_chunk                                              |
+ * | message_update thinking_delta             | agent_thought_chunk                                              |
+ * | message_update toolcall_end               | tool_call（pending，带 name、rawInput 与 locations）             |
+ * | tool_execution_start（带 parent）         | tool_call（pending，title 带 codemode 前缀，`_meta.ama.parentToolCallId`） |
+ * | tool_execution_start                      | tool_call_update（in_progress）                                  |
+ * | permission_request（toolCallId 已公布）   | tool_call_update（pending）                                      |
+ * | permission_resolved（allow / allow_session）| tool_call_update（in_progress）                                |
+ * | tool_execution_end                        | tool_call_update（completed / failed，`[diff?, text]`，locations[].line） |
+ * | todo_updated                              | plan                                                             |
+ * | turn_end                                  | usage_update（上下文用量、窗口、会话累计美元）                   |
+ * | permission_mode_changed                   | current_mode_update + config_option_update                       |
+ * | model_changed / thinking_level_changed    | config_option_update                                             |
  *
- * 工具结果只回前 4 KB 文本（完整结果在 ama 会话里），codemode 内层调用（带 parentToolCallId）
- * 不单列。`session/load` 回放同一套映射（用户消息 → user_message_chunk）。
+ * 工具结果只回前 4 KB 文本（完整结果在 ama 会话里）；diff 只在实时事件里有（`fileChange` 不落盘）。
+ * `session/load` 回放同一套映射（用户消息 → user_message_chunk，工具结果带文本、无 diff）。
  */
 import type { AgentMessage } from "../../session/types.js";
 import type { AgentSession, SessionEvent } from "../../agent/types.js";
-import type { AcpSessionUpdate, AcpToolCallLocation, AcpToolKind } from "../../drivers/acp/types.js";
-export declare const TOOL_OUTPUT_LIMIT: number;
-export declare function toolKind(name: string): AcpToolKind;
-export declare function toolTitle(name: string, args: unknown): string;
-export declare function toolLocations(args: unknown, cwd: string): AcpToolCallLocation[] | undefined;
+import { type AcpAvailableCommand, type AcpSessionConfigOption, type AcpSessionUpdate } from "../../drivers/acp/types.js";
+export { TOOL_OUTPUT_LIMIT, toolKind, toolLocations, toolTitle } from "./acp-tool-text.js";
 export declare function permissionModes(currentModeId: string): {
     currentModeId: string;
     availableModes: {
         id: import("../../permissions/types.js").PermissionMode;
-        name: import("../../permissions/types.js").PermissionMode;
+        name: string;
+        description: string;
     }[];
 };
-/** 一个会话的事件映射器（记住模型发出的工具调用，供权限请求关联 toolCallId）。 */
+/** 一个会话的事件映射器（记住已公布的工具调用，供权限请求关联 toolCallId 与状态）。 */
 export declare class AcpEventMapper {
     private readonly cwd;
     private readonly emit;
     private readonly session;
-    /** 模型已发出、尚未执行完的工具调用。 */
+    /** 会话的配置项与命令表（{@link announce} 与配置变化时取；[ACP-D] 填实际内容）。 */
+    protected readonly extras: () => {
+        configOptions: AcpSessionConfigOption[];
+        commands: AcpAvailableCommand[];
+    };
+    /** 模型已发出、尚未执行完的工具调用（按工具名 + 参数匹配的后备）。 */
     private readonly pendingCalls;
-    constructor(cwd: string, emit: (update: AcpSessionUpdate) => void, session: () => AgentSession);
-    /** 权限请求对应的工具调用 id（按工具名与参数匹配最近一个）。 */
+    /** 已经以 `tool_call` 公布、尚未结束的调用：id → title（含 codemode 内层）。 */
+    private readonly published;
+    /** 挂起的权限请求：requestId → 已公布的 toolCallId。 */
+    private readonly permissionCalls;
+    /**
+     * ama 的工具调用 id → 线上 toolCallId。ACP 要求 id 在会话内唯一，上游给的 id 却可能在后续回合重复
+     * （假模型、个别兼容接口的兜底 id）；重复时加 `#n` 后缀，之后的开始 / 结束 / 审批都按最近一次映射。
+     */
+    private readonly wireIds;
+    private readonly usedWireIds;
+    /** 上次 `session_info_update` 带出的标题。 */
+    private lastTitle;
+    constructor(cwd: string, emit: (update: AcpSessionUpdate) => void, session: () => AgentSession, 
+    /** 会话的配置项与命令表（{@link announce} 与配置变化时取；[ACP-D] 填实际内容）。 */
+    extras?: () => {
+        configOptions: AcpSessionConfigOption[];
+        commands: AcpAvailableCommand[];
+    });
+    /** 会话 new / load / resume 的响应发出后由服务端调：`available_commands_update` 与 `config_option_update`。 */
+    announce(): void;
+    /** 回合结束后由服务端调：`session_info_update`（标题与上次不同才带 title）。 */
+    emitSessionInfo(title: string | null, updatedAt: string): void;
+    /** 权限请求对应的工具调用 id（按工具名与参数匹配最近一个；有 `context.toolCallId` 时不需要）。 */
     toolCallIdFor(toolName: string, input: unknown): string | undefined;
+    /** 已公布且未结束的工具调用的标题（codemode 内层带前缀）；未公布返回 undefined。 */
+    titleFor(toolCallId: string): string | undefined;
+    /** ama 的工具调用 id 在线上用的 toolCallId（没公布过的原样返回）。 */
+    wireId(toolCallId: string): string;
+    private claimWireId;
     onEvent(event: SessionEvent): void;
     emitUsage(): void;
-    /** `session/load`：按消息回放历史。 */
+    /** `session/load`：按消息回放历史（工具结果带前 4 KB 文本；diff 不落盘，回放没有）。 */
     replay(messages: readonly AgentMessage[]): void;
+    private status;
+    /** 公布一次工具调用（pending）；`parentToolCallId` 给了即 codemode 内层调用。返回 title。 */
     private emitToolCall;
 }

package/dist/modes/acp/acp-events.js

@@ -1,89 +1,80 @@
 /**
- * `ama --mode acp`：ama 的会话事件 → ACP `session/update`（docs/wave5-plan.md §5.6）。[W5-E]
+ * `ama --mode acp`：ama 的会话事件 → ACP `session/update`（docs/wave5-plan.md §5.6、docs/acp-plan.md §2.3）。
  *
- * | ama                                  | ACP                                                        |
- * | ------------------------------------ | ---------------------------------------------------------- |
- * | message_update text_delta            | agent_message_chunk                                        |
- * | message_update thinking_delta        | agent_thought_chunk                                        |
- * | message_update toolcall_end          | tool_call（pending，带 rawInput 与 locations）             |
- * | tool_execution_start / end           | tool_call_update（in_progress → completed / failed）       |
- * | todo_updated                         | plan                                                       |
- * | turn_end                             | usage_update（上下文用量、窗口、会话累计美元）             |
- * | permission_mode_changed              | current_mode_update                                        |
+ * | ama                                       | ACP                                                              |
+ * | ----------------------------------------- | ---------------------------------------------------------------- |
+ * | message_update text_delta                 | agent_message_chunk                                              |
+ * | message_update thinking_delta             | agent_thought_chunk                                              |
+ * | message_update toolcall_end               | tool_call（pending，带 name、rawInput 与 locations）             |
+ * | tool_execution_start（带 parent）         | tool_call（pending，title 带 codemode 前缀，`_meta.ama.parentToolCallId`） |
+ * | tool_execution_start                      | tool_call_update（in_progress）                                  |
+ * | permission_request（toolCallId 已公布）   | tool_call_update（pending）                                      |
+ * | permission_resolved（allow / allow_session）| tool_call_update（in_progress）                                |
+ * | tool_execution_end                        | tool_call_update（completed / failed，`[diff?, text]`，locations[].line） |
+ * | todo_updated                              | plan                                                             |
+ * | turn_end                                  | usage_update（上下文用量、窗口、会话累计美元）                   |
+ * | permission_mode_changed                   | current_mode_update + config_option_update                       |
+ * | model_changed / thinking_level_changed    | config_option_update                                             |
  *
- * 工具结果只回前 4 KB 文本（完整结果在 ama 会话里），codemode 内层调用（带 parentToolCallId）
- * 不单列。`session/load` 回放同一套映射（用户消息 → user_message_chunk）。
+ * 工具结果只回前 4 KB 文本（完整结果在 ama 会话里）；diff 只在实时事件里有（`fileChange` 不落盘）。
+ * `session/load` 回放同一套映射（用户消息 → user_message_chunk，工具结果带文本、无 diff）。
  */
-import { isAbsolute, resolve } from "node:path";
+import { ACP_META_KEY, } from "../../drivers/acp/types.js";
 import { PERMISSION_MODES_STRICT_FIRST } from "../../permissions/types.js";
-import { oneLine } from "../../drivers/turn.js";
-import { msg } from "../../i18n/index.js";
-export const TOOL_OUTPUT_LIMIT = 4 * 1024;
-const KINDS = {
-    read: "read",
-    write: "edit",
-    edit: "edit",
-    bash: "execute",
-    grep: "search",
-    glob: "search",
-    ls: "search",
-    find: "search",
-    web_fetch: "fetch",
-    web_search: "fetch",
-    todo: "think",
-};
-export function toolKind(name) {
-    return KINDS[name] ?? "other";
-}
-function argOf(args, ...keys) {
-    if (args === null || typeof args !== "object")
-        return undefined;
-    for (const key of keys) {
-        const value = args[key];
-        if (typeof value === "string" && value !== "")
-            return value;
-    }
-    return undefined;
-}
-export function toolTitle(name, args) {
-    const detail = argOf(args, "command") ??
-        argOf(args, "path", "file_path", "filePath") ??
-        argOf(args, "pattern", "query", "url", "prompt");
-    return detail === undefined ? name : `${name}: ${oneLine(detail, 100)}`;
-}
-export function toolLocations(args, cwd) {
-    const path = argOf(args, "path", "file_path", "filePath");
-    if (path === undefined)
-        return undefined;
-    return [{ path: isAbsolute(path) ? path : resolve(cwd, path) }];
-}
-function resultText(result) {
-    const text = typeof result.content === "string"
-        ? result.content
-        : result.content.map((b) => (b.type === "text" ? b.text : `[${b.type}]`)).join("");
-    return text.length > TOOL_OUTPUT_LIMIT
-        ? `${text.slice(0, TOOL_OUTPUT_LIMIT)}\n${msg().print.acp.truncated(text.length)}`
-        : text;
-}
+import { PERMISSION_MODE_INFO, permissionModeLabel } from "../../permissions/modes.js";
+import { resultContent, resultText, toolKind, toolLocations, toolTitle } from "./acp-tool-text.js";
+export { TOOL_OUTPUT_LIMIT, toolKind, toolLocations, toolTitle } from "./acp-tool-text.js";
 export function permissionModes(currentModeId) {
     return {
         currentModeId,
-        availableModes: PERMISSION_MODES_STRICT_FIRST.map((id) => ({ id, name: id })),
+        availableModes: PERMISSION_MODES_STRICT_FIRST.map((id) => ({
+            id,
+            name: permissionModeLabel(id),
+            description: PERMISSION_MODE_INFO[id].description,
+        })),
     };
 }
-/** 一个会话的事件映射器（记住模型发出的工具调用，供权限请求关联 toolCallId）。 */
+/** 一个会话的事件映射器（记住已公布的工具调用，供权限请求关联 toolCallId 与状态）。 */
 export class AcpEventMapper {
     cwd;
     emit;
     session;
-    /** 模型已发出、尚未执行完的工具调用。 */
+    extras;
+    /** 模型已发出、尚未执行完的工具调用（按工具名 + 参数匹配的后备）。 */
     pendingCalls = [];
-    constructor(cwd, emit, session) {
+    /** 已经以 `tool_call` 公布、尚未结束的调用：id → title（含 codemode 内层）。 */
+    published = new Map();
+    /** 挂起的权限请求：requestId → 已公布的 toolCallId。 */
+    permissionCalls = new Map();
+    /**
+     * ama 的工具调用 id → 线上 toolCallId。ACP 要求 id 在会话内唯一，上游给的 id 却可能在后续回合重复
+     * （假模型、个别兼容接口的兜底 id）；重复时加 `#n` 后缀，之后的开始 / 结束 / 审批都按最近一次映射。
+     */
+    wireIds = new Map();
+    usedWireIds = new Set();
+    /** 上次 `session_info_update` 带出的标题。 */
+    lastTitle = null;
+    constructor(cwd, emit, session, 
+    /** 会话的配置项与命令表（{@link announce} 与配置变化时取；[ACP-D] 填实际内容）。 */
+    extras = () => ({ configOptions: [], commands: [] })) {
         this.cwd = cwd;
         this.emit = emit;
         this.session = session;
+        this.extras = extras;
+    }
+    /** 会话 new / load / resume 的响应发出后由服务端调：`available_commands_update` 与 `config_option_update`。 */
+    announce() {
+        const { configOptions, commands } = this.extras();
+        this.emit({ sessionUpdate: "available_commands_update", availableCommands: commands });
+        this.emit({ sessionUpdate: "config_option_update", configOptions });
     }
-    /** 权限请求对应的工具调用 id（按工具名与参数匹配最近一个）。 */
+    /** 回合结束后由服务端调：`session_info_update`（标题与上次不同才带 title）。 */
+    emitSessionInfo(title, updatedAt) {
+        const changed = title !== this.lastTitle;
+        this.lastTitle = title;
+        this.emit({ sessionUpdate: "session_info_update", ...(changed ? { title } : {}), updatedAt });
+    }
+    /** 权限请求对应的工具调用 id（按工具名与参数匹配最近一个；有 `context.toolCallId` 时不需要）。 */
     toolCallIdFor(toolName, input) {
         const args = JSON.stringify(input ?? null);
         for (let i = this.pendingCalls.length - 1; i >= 0; i--) {
@@ -93,6 +84,22 @@ export class AcpEventMapper {
         }
         return undefined;
     }
+    /** 已公布且未结束的工具调用的标题（codemode 内层带前缀）；未公布返回 undefined。 */
+    titleFor(toolCallId) {
+        return this.published.get(this.wireId(toolCallId));
+    }
+    /** ama 的工具调用 id 在线上用的 toolCallId（没公布过的原样返回）。 */
+    wireId(toolCallId) {
+        return this.wireIds.get(toolCallId) ?? toolCallId;
+    }
+    claimWireId(toolCallId) {
+        let wire = toolCallId;
+        for (let n = 2; this.usedWireIds.has(wire); n++)
+            wire = `${toolCallId}#${n}`;
+        this.usedWireIds.add(wire);
+        this.wireIds.set(toolCallId, wire);
+        return wire;
+    }
     onEvent(event) {
         switch (event.type) {
             case "message_update": {
@@ -109,38 +116,68 @@ export class AcpEventMapper {
                     });
                 else if (e.type === "toolcall_end") {
                     const call = e.toolCall;
+                    const wire = this.claimWireId(call.id);
                     this.pendingCalls.push({
-                        id: call.id,
+                        id: wire,
                         name: call.name,
                         args: JSON.stringify(call.arguments),
                     });
-                    this.emitToolCall(call.id, call.name, call.arguments, "pending");
+                    this.published.set(wire, this.emitToolCall(wire, call.name, call.arguments));
                 }
                 return;
             }
-            case "tool_execution_start":
-                if (event.parentToolCallId !== undefined)
-                    return;
-                this.emit({
-                    sessionUpdate: "tool_call_update",
-                    toolCallId: event.toolCallId,
-                    status: "in_progress",
-                });
+            case "tool_execution_start": {
+                let wire;
+                if (event.parentToolCallId !== undefined) {
+                    wire = this.claimWireId(event.toolCallId);
+                    const title = this.emitToolCall(wire, event.toolName, event.args, this.wireId(event.parentToolCallId));
+                    this.published.set(wire, title);
+                }
+                else
+                    wire = this.wireId(event.toolCallId);
+                this.status(wire, "in_progress");
                 return;
+            }
             case "tool_execution_end": {
-                if (event.parentToolCallId !== undefined)
-                    return;
-                const at = this.pendingCalls.findIndex((c) => c.id === event.toolCallId);
+                const wire = this.wireId(event.toolCallId);
+                const at = this.pendingCalls.findIndex((c) => c.id === wire);
                 if (at >= 0)
                     this.pendingCalls.splice(at, 1);
+                this.published.delete(wire);
+                const { content, locations } = resultContent(event.result);
                 this.emit({
                     sessionUpdate: "tool_call_update",
-                    toolCallId: event.toolCallId,
+                    toolCallId: wire,
                     status: event.isError ? "failed" : "completed",
-                    content: [{ type: "content", content: { type: "text", text: resultText(event.result) } }],
+                    content,
+                    ...(locations !== undefined ? { locations } : {}),
                 });
                 return;
             }
+            case "permission_request": {
+                // 只认本会话已公布的调用：子 Agent / 外部 Agent 的请求（depth、origin）的 id 不在本会话的列表里
+                const context = event.context;
+                if (context?.toolCallId === undefined)
+                    return;
+                if ((context.depth ?? 0) > 0 || context.origin !== undefined)
+                    return;
+                const id = this.wireId(context.toolCallId);
+                if (!this.published.has(id))
+                    return;
+                this.permissionCalls.set(event.requestId, id);
+                this.status(id, "pending");
+                return;
+            }
+            case "permission_resolved": {
+                const id = this.permissionCalls.get(event.requestId);
+                if (id === undefined)
+                    return;
+                this.permissionCalls.delete(event.requestId);
+                // 拒绝时由随后的 tool_execution_end（failed）收口
+                if (event.decision !== "deny" && this.published.has(id))
+                    this.status(id, "in_progress");
+                return;
+            }
             case "todo_updated":
                 this.emit({
                     sessionUpdate: "plan",
@@ -155,7 +192,19 @@ export class AcpEventMapper {
                 this.emitUsage();
                 return;
             case "permission_mode_changed":
+                // 只认 configOptions 的客户端（Zed）看 mode 配置项，只认 modes 的看 current_mode_update
                 this.emit({ sessionUpdate: "current_mode_update", currentModeId: event.mode });
+                this.emit({
+                    sessionUpdate: "config_option_update",
+                    configOptions: this.extras().configOptions,
+                });
+                return;
+            case "model_changed":
+            case "thinking_level_changed":
+                this.emit({
+                    sessionUpdate: "config_option_update",
+                    configOptions: this.extras().configOptions,
+                });
                 return;
             default:
                 return;
@@ -172,8 +221,13 @@ export class AcpEventMapper {
             ...(stats.cost !== undefined ? { cost: { amount: stats.cost, currency: "USD" } } : {}),
         });
     }
-    /** `session/load`：按消息回放历史。 */
+    /** `session/load`：按消息回放历史（工具结果带前 4 KB 文本；diff 不落盘，回放没有）。 */
     replay(messages) {
+        // 回放从头编号（客户端会重建整条线程）；有调用在跑时沿用现有映射，免得和实时更新对不上
+        if (this.published.size === 0) {
+            this.wireIds.clear();
+            this.usedWireIds.clear();
+        }
         for (const message of messages) {
             if (!("role" in message))
                 continue;
@@ -194,29 +248,41 @@ export class AcpEventMapper {
                             content: { type: "text", text: block.thinking },
                         });
                     else if (block.type === "toolCall")
-                        this.emitToolCall(block.id, block.name, block.arguments, "pending");
+                        this.emitToolCall(this.claimWireId(block.id), block.name, block.arguments);
                 }
             }
             else if (message.role === "toolResult") {
                 this.emit({
                     sessionUpdate: "tool_call_update",
-                    toolCallId: message.toolCallId,
+                    toolCallId: this.wireId(message.toolCallId),
                     status: message.isError ? "failed" : "completed",
+                    content: [
+                        { type: "content", content: { type: "text", text: resultText(message.content) } },
+                    ],
                 });
             }
         }
     }
-    emitToolCall(id, name, args, status) {
+    status(toolCallId, status) {
+        this.emit({ sessionUpdate: "tool_call_update", toolCallId, status });
+    }
+    /** 公布一次工具调用（pending）；`parentToolCallId` 给了即 codemode 内层调用。返回 title。 */
+    emitToolCall(id, name, args, parentToolCallId) {
         const locations = toolLocations(args, this.cwd);
+        const title = toolTitle(name, args, parentToolCallId !== undefined);
+        const meta = parentToolCallId !== undefined ? { parentToolCallId } : undefined;
         this.emit({
             sessionUpdate: "tool_call",
             toolCallId: id,
-            title: toolTitle(name, args),
+            name,
+            title,
             kind: toolKind(name),
-            status,
+            status: "pending",
             rawInput: args,
             ...(locations !== undefined ? { locations } : {}),
+            ...(meta !== undefined ? { _meta: { [ACP_META_KEY]: meta } } : {}),
         });
+        return title;
     }
 }
 function contentOf(content) {

package/dist/modes/acp/acp-mode.d.ts

@@ -3,15 +3,26 @@
  *
  * - stdin / stdout 是 ACP（JSON-RPC 2.0 over NDJSON），不发 hello（ACP 由客户端 `initialize` 起头）；
  *   诊断与宿主通知写 stderr。
+ * - 连接（JSON-RPC 对等端 + 协商结果）由 `createAcpConnection` 建，服务端只处理消息。
  * - 审批：挂 {@link AcpServer.broker} 为 UI broker，ama 的审批请求以 `session/request_permission`
  *   交给客户端。
- * - 退出语义同 rpc：stdin 关闭 → 撤下审批、等在途请求与已开始的运行结束 → 退出 0；
- *   SIGINT / SIGTERM → abort 后退出 130 / 143。
+ * - 退出语义同 rpc：stdin 关闭 → 撤下审批、排队的提示回 cancelled、等已开始的运行结束、释放全部
+ *   会话（前台会话由 Runtime.dispose 收尾）→ 退出 0；SIGINT / SIGTERM → abort 后退出 130 / 143。
  */
 import type { ModeContext } from "../../cli/deps.js";
 import type { Runtime } from "../../cli/runtime.js";
+import { type AcpConnection } from "./acp-connection.js";
+import { AcpServer } from "./acp-server.js";
 export interface AcpModeOptions {
     stdin?: NodeJS.ReadableStream;
     stdout?: NodeJS.WritableStream;
+    /**
+     * [ACP-A] 认证门交接：沿用门控建好的连接（可能已 `initialize`），不再新建；服务端建好后同步交给
+     * `attach`，门控此后把请求与通知都转给它。
+     */
+    handover?: {
+        connection: AcpConnection;
+        attach(server: AcpServer): void;
+    };
 }
 export declare function runAcpMode(runtime: Runtime, context: ModeContext, options?: AcpModeOptions): Promise<number>;

package/dist/modes/acp/acp-mode.js

@@ -3,18 +3,36 @@
  *
  * - stdin / stdout 是 ACP（JSON-RPC 2.0 over NDJSON），不发 hello（ACP 由客户端 `initialize` 起头）；
  *   诊断与宿主通知写 stderr。
+ * - 连接（JSON-RPC 对等端 + 协商结果）由 `createAcpConnection` 建，服务端只处理消息。
  * - 审批：挂 {@link AcpServer.broker} 为 UI broker，ama 的审批请求以 `session/request_permission`
  *   交给客户端。
- * - 退出语义同 rpc：stdin 关闭 → 撤下审批、等在途请求与已开始的运行结束 → 退出 0；
- *   SIGINT / SIGTERM → abort 后退出 130 / 143。
+ * - 退出语义同 rpc：stdin 关闭 → 撤下审批、排队的提示回 cancelled、等已开始的运行结束、释放全部
+ *   会话（前台会话由 Runtime.dispose 收尾）→ 退出 0；SIGINT / SIGTERM → abort 后退出 130 / 143。
  */
 import { ExitCode } from "../../cli/exit-codes.js";
 import { onTerminationSignals } from "../shared.js";
+import { createAcpConnection } from "./acp-connection.js";
 import { AcpServer } from "./acp-server.js";
+import { RpcError } from "../../drivers/jsonrpc.js";
+import { RPC_ERRORS } from "../../drivers/acp/types.js";
 export async function runAcpMode(runtime, context, options = {}) {
     const stdin = options.stdin ?? process.stdin;
     const stdout = options.stdout ?? process.stdout;
-    const server = new AcpServer(runtime, { input: stdin, output: stdout }, (message) => context.io.stderr(`ama: ${message}\n`));
+    const log = (message) => context.io.stderr(`ama: ${message}\n`);
+    // 连接先建（handlers 转给服务端）；JsonRpcPeer 的读取是异步的，构造完服务端之前不会有消息到达。
+    const target = {};
+    const connection = options.handover?.connection ??
+        createAcpConnection({ input: stdin, output: stdout }, log, {
+            onRequest: async (method, params, ctx) => {
+                if (target.server === undefined)
+                    throw new RpcError(RPC_ERRORS.internalError, method);
+                return target.server.handle(method, (params ?? {}), ctx);
+            },
+            onNotification: (method, params) => target.server?.handleNotification(method, params),
+        });
+    const server = new AcpServer(runtime, connection, log);
+    target.server = server;
+    options.handover?.attach(server);
     runtime.approvals.setUiBroker(server.broker);
     runtime.notifier.set((message, level) => context.io.stderr(`ama: [${level}] ${message}\n`));
     return new Promise((resolve) => {
@@ -26,13 +44,10 @@ export async function runAcpMode(runtime, context, options = {}) {
             offSignals();
             stdin.pause?.();
             runtime.approvals.setUiBroker(undefined);
-            const session = server.session();
-            if (abort)
-                await session.abort().catch(() => undefined);
-            await session.waitForIdle().catch(() => undefined);
+            // 全部会话：排队的回 cancelled，等在跑的结束（信号时先 abort），兄弟会话依次 dispose
+            await server.dispose(abort);
             await server.peer.flush();
             server.peer.close();
-            server.dispose();
             runtime.notifier.set(undefined);
             resolve(code);
         };