clawmatrix 0.2.9 → 0.3.1

package/src/acp-proxy.ts

@@ -35,6 +35,13 @@ import type {
   ChatHistoryRequest,
   ChatHistoryResponse,
   ChatHistoryMessage,
+  AcpSetConfigRequest,
+  AcpSetConfigResponse,
+  AcpConfigOption,
+  AcpSubscribeRequest,
+  AcpSubscribeResponse,
+  AcpUnsubscribeRequest,
+  AcpSessionNotify,
 } from "./types.ts";
 import { TaskActivityBroadcaster } from "./task-activity.ts";
 
@@ -74,7 +81,7 @@ interface AgentDaemon {
   conn: ClientSideConnection;
   proc: { kill: () => void; exited: Promise<number> };
   /** Per-session stream callbacks keyed by ACP session ID */
-  streamCallbacks: Map<string, ((delta: string, event?: string) => void) | null>;
+  streamCallbacks: Map<string, ((delta: string, event?: string, data?: unknown) => void) | null>;
   lastActiveAt: number;
   idleTimer: ReturnType<typeof setTimeout>;
   /** Set to true when process has exited */
@@ -92,9 +99,11 @@ interface AcpSession {
   proc: { kill: () => void; exited: Promise<number> };
   lastActiveAt: number;
   from: string;                // owning nodeId
-  setStreamCallback: (cb: ((delta: string, event?: string) => void) | null) => void;
+  setStreamCallback: (cb: ((delta: string, event?: string, data?: unknown) => void) | null) => void;
   availableModes?: AcpModeInfo[];
   currentModeId?: string;
+  configOptions?: AcpConfigOption[];
+  slashCommands?: import("./types.ts").AcpSlashCommand[];
 }
 
 /** Session backed by local OpenClaw gateway (not a spawned ACP agent). */
@@ -153,11 +162,15 @@ export class AcpProxy {
   private warmPool = new Map<string, AcpSession[]>();
   // Track pending prewarm timers so they can be cancelled on dispose
   private prewarmTimers = new Set<ReturnType<typeof setTimeout>>();
+  // Track pending retry timers for sendResponse so they can be cancelled on destroy
+  private retryTimers = new Set<ReturnType<typeof setTimeout>>();
   private disposed = false;
   // Agent daemon pool: long-lived process per agent type, reused across sessions
   private daemons = new Map<string, AgentDaemon>();
   // In-flight daemon acquisition: prevents multiple concurrent spawns for same agent
   private daemonStarting = new Map<string, Promise<AgentDaemon>>();
+  // In-flight resume operations: prevents concurrent resumes for same acpSessionId
+  private resumeInFlight = new Map<string, Promise<AcpSession>>();
 
   constructor(config: ClawMatrixConfig, peerManager: PeerManager, openclawConfig?: Record<string, unknown>, gatewayInfo?: GatewayInfo) {
     this.config = config;
@@ -216,6 +229,100 @@ export class AcpProxy {
     }
   }
 
+  // ── Subscribe / observe (receiver side) ─────────────────────────
+
+  /** Handle acp_subscribe: register caller as observer and return history snapshot.
+   *
+   * `payload.sessionId` may be an ACP/OpenClaw session ID (from the list) or a
+   * ClawMatrix session ID. We resolve to the ClawMatrix session ID for watcher
+   * registration, while using the original ID for transcript lookup (disk files
+   * are named by ACP session ID).
+   */
+  async handleSubscribeRequest(frame: AcpSubscribeRequest): Promise<void> {
+    const { id, from, payload } = frame;
+    const { sessionId } = payload;
+
+    // Resolve to ClawMatrix session ID for watcher registration (reverse lookup by acpSessionId)
+    let watcherKey = sessionId;
+    if (!this.sessions.has(sessionId)) {
+      for (const [sid, s] of this.sessions) {
+        if (s.kind === "acp" && s.acpSessionId === sessionId) {
+          watcherKey = sid;
+          break;
+        }
+      }
+    }
+    this.addSessionWatcher(watcherKey, from);
+
+    try {
+      const transcriptPath = await this.findTranscriptPath(sessionId);
+      let history: import("./types.ts").ChatHistoryMessage[] = [];
+      if (transcriptPath) {
+        const content = await readFileText(transcriptPath);
+        const lines = content.split(/\r?\n/).filter((l: string) => l.trim());
+        history = normalizeTranscriptMessages(lines, 200);
+      }
+      this.peerManager.sendTo(from, {
+        type: "acp_subscribe_res",
+        id,
+        from: this.config.nodeId,
+        to: from,
+        timestamp: Date.now(),
+        payload: { success: true, history },
+      } satisfies AcpSubscribeResponse);
+    } catch (err) {
+      this.peerManager.sendTo(from, {
+        type: "acp_subscribe_res",
+        id,
+        from: this.config.nodeId,
+        to: from,
+        timestamp: Date.now(),
+        payload: { success: false, error: errorMessage(err) },
+      } satisfies AcpSubscribeResponse);
+    }
+  }
+
+  /** Handle acp_unsubscribe: remove caller from observer list. */
+  handleUnsubscribeRequest(frame: AcpUnsubscribeRequest): void {
+    const { from, payload } = frame;
+    // Resolve watcher key (same logic as subscribe)
+    let watcherKey = payload.sessionId;
+    if (!this.sessionWatchers.has(watcherKey)) {
+      for (const [sid, s] of this.sessions) {
+        if (s.kind === "acp" && s.acpSessionId === payload.sessionId) {
+          watcherKey = sid;
+          break;
+        }
+      }
+    }
+    const watchers = this.sessionWatchers.get(watcherKey);
+    if (watchers) {
+      watchers.delete(from);
+      if (watchers.size === 0) this.sessionWatchers.delete(watcherKey);
+    }
+  }
+
+  /** Broadcast acp_session_notify to all connected peers. */
+  private broadcastSessionNotify(
+    sessionId: string,
+    event: AcpSessionNotify["payload"]["event"],
+    title?: string,
+    updatedAt?: string,
+    agent?: string,
+  ): void {
+    const peers = this.peerManager.router.getAllPeers();
+    if (peers.length === 0) return;
+    const frame: AcpSessionNotify = {
+      type: "acp_session_notify",
+      from: this.config.nodeId,
+      timestamp: Date.now(),
+      payload: { sessionId, nodeId: this.config.nodeId, event, title, updatedAt, agent },
+    };
+    for (const peer of peers) {
+      this.peerManager.sendTo(peer.nodeId, { ...frame, to: peer.nodeId });
+    }
+  }
+
   // ── Requester side: send prompt ────────────────────────────────
 
   async prompt(
@@ -477,8 +584,14 @@ export class AcpProxy {
     const pending = this.pending.get(frame.id);
     if (!pending) return;
 
-    // Only accumulate non-thinking content for the final result
-    if (frame.payload.event !== "agent_thought_chunk") {
+    // Only accumulate agent text content for the final result.
+    // Skip events that produce markers/metadata (not actual response text).
+    const skipAccumulate = new Set([
+      "agent_thought_chunk", "tool_call", "tool_result", "plan",
+      "usage", "available_commands", "config_options",
+      "current_mode_update", "session_info_update",
+    ]);
+    if (!skipAccumulate.has(frame.payload.event ?? "")) {
       pending.accumulated += frame.payload.delta;
     }
     if (pending.onStream) {
@@ -608,9 +721,12 @@ export class AcpProxy {
                 agent: newSession.agent,
                 sessionId: newSession.sessionId,
                 acpSessionId: newSession.acpSessionId,
+                configOptions: newSession.configOptions,
+                availableModes: newSession.availableModes,
+                currentModeId: newSession.currentModeId,
               });
             }
-            if (mode === "oneshot" && task) {
+            if (mode === "oneshot") {
               this.returnToReusePool(newSession, cwd || process.cwd());
             }
           } else {
@@ -668,9 +784,12 @@ export class AcpProxy {
               agent: session.agent,
               sessionId: session.sessionId,
               acpSessionId: session.acpSessionId,
+              configOptions: session.configOptions,
+              availableModes: session.availableModes,
+              currentModeId: session.currentModeId,
             });
           }
-          if (mode === "oneshot" && task) {
+          if (mode === "oneshot") {
             this.returnToReusePool(session, cwd || process.cwd());
           }
         } else {
@@ -750,16 +869,19 @@ export class AcpProxy {
           cwd: "",
           agent: session.agent,
           updatedAt: new Date(session.lastActiveAt).toISOString(),
+          status: "active",
         });
       }
 
       // 2. Read persisted sessions directly from disk (no daemon spawn needed)
       const diskSessions = await this.readAllSessionStoresFromDisk();
       // Filter by agent if requested, and exclude already-tracked active sessions
-      const filteredDiskSessions = diskSessions.filter((s) => {
-        if (payload.agent && s.agent !== payload.agent) return false;
-        return !clawSessions.some((cs) => cs.sessionId === s.sessionId);
-      });
+      const filteredDiskSessions = diskSessions
+        .filter((s) => {
+          if (payload.agent && s.agent !== payload.agent) return false;
+          return !clawSessions.some((cs) => cs.sessionId === s.sessionId);
+        })
+        .map((s) => ({ ...s, status: "idle" as const }));
 
       this.peerManager.sendTo(from, {
         type: "acp_list_res", id, from: this.config.nodeId, to: from,
@@ -793,13 +915,28 @@ export class AcpProxy {
       }
 
       if (this.isAcpAgent(agent)) {
-        // Spawn a fresh ACP agent process and resume the session on it
+        // Deduplicate concurrent resumes for the same acpSessionId:
+        // if another request is already resuming this session, reuse its result.
+        const existingResume = this.resumeInFlight.get(acpSessionId);
         let session: AcpSession;
-        try {
-          session = await this.createSessionWithResume(agent, acpSessionId, cwd, from);
-        } catch (resumeErr) {
-          debug("acp", `Resume failed (${errorMessage(resumeErr)}), falling back to new session`);
-          session = await this.createSession(agent, cwd, from);
+        if (existingResume) {
+          debug("acp", `resume already in-flight for acpSessionId=${acpSessionId.slice(0, 8)}..., reusing`);
+          session = await existingResume;
+        } else {
+          const resumePromise = (async (): Promise<AcpSession> => {
+            try {
+              return await this.createSessionWithResume(agent, acpSessionId, cwd, from);
+            } catch (resumeErr) {
+              debug("acp", `Resume failed (${errorMessage(resumeErr)}), falling back to new session`);
+              return await this.createSession(agent, cwd, from);
+            }
+          })();
+          this.resumeInFlight.set(acpSessionId, resumePromise);
+          try {
+            session = await resumePromise;
+          } finally {
+            this.resumeInFlight.delete(acpSessionId);
+          }
         }
         this.sessions.set(session.sessionId, session);
         this.addSessionWatcher(session.sessionId, from);
@@ -854,11 +991,13 @@ export class AcpProxy {
       return;
     }
 
-    if (session.from !== from) {
+    // Allow cancel from session owner OR any session watcher (multi-device sync)
+    const watchers = this.sessionWatchers.get(payload.sessionId);
+    if (session.from !== from && !watchers?.has(from)) {
       this.peerManager.sendTo(from, {
         type: "acp_cancel_res", id, from: this.config.nodeId, to: from,
         timestamp: Date.now(),
-        payload: { success: false, error: "Not the session owner" },
+        payload: { success: false, error: "Not the session owner or watcher" },
       } satisfies AcpCancelResponse);
       return;
     }
@@ -960,6 +1099,100 @@ export class AcpProxy {
     } satisfies AcpGetModesResponse);
   }
 
+  // ── Config options (receiver side) ──────────────────────────────
+
+  /** Handle set config option request (receiver side): change model, thinking level, etc. */
+  async handleSetConfigRequest(frame: AcpSetConfigRequest): Promise<void> {
+    const { id, from, payload } = frame;
+    const session = this.sessions.get(payload.sessionId);
+
+    if (!session) {
+      this.peerManager.sendTo(from, {
+        type: "acp_set_config_res", id, from: this.config.nodeId, to: from,
+        timestamp: Date.now(),
+        payload: { success: false, error: "Session not found" },
+      } satisfies AcpSetConfigResponse);
+      return;
+    }
+
+    if (session.kind !== "acp") {
+      this.peerManager.sendTo(from, {
+        type: "acp_set_config_res", id, from: this.config.nodeId, to: from,
+        timestamp: Date.now(),
+        payload: { success: false, error: "Config options not supported for native sessions" },
+      } satisfies AcpSetConfigResponse);
+      return;
+    }
+
+    try {
+      const response = await session.conn.setSessionConfigOption({
+        sessionId: session.acpSessionId,
+        configId: payload.configId,
+        value: payload.value as string,
+      });
+      const configOptions = (response as Record<string, unknown>)?.configOptions as AcpConfigOption[] | undefined;
+      this.peerManager.sendTo(from, {
+        type: "acp_set_config_res", id, from: this.config.nodeId, to: from,
+        timestamp: Date.now(),
+        payload: { success: true, configOptions },
+      } satisfies AcpSetConfigResponse);
+    } catch (err) {
+      this.peerManager.sendTo(from, {
+        type: "acp_set_config_res", id, from: this.config.nodeId, to: from,
+        timestamp: Date.now(),
+        payload: { success: false, error: errorMessage(err) },
+      } satisfies AcpSetConfigResponse);
+    }
+  }
+
+  /** Handle set config option response (requester side). */
+  handleSetConfigResponse(frame: AcpSetConfigResponse): void {
+    const pending = this.pending.get(frame.id);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    this.pending.delete(frame.id);
+    pending.resolve(frame.payload as unknown as AcpTaskResponse["payload"]);
+  }
+
+  /** Set a config option on a remote session (requester side). */
+  setSessionConfig(
+    targetNodeId: string,
+    sessionId: string,
+    configId: string,
+    value: string | boolean,
+  ): Promise<AcpSetConfigResponse["payload"]> {
+    const id = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error("ACP set config request timed out"));
+      }, 15_000);
+
+      this.pending.set(id, {
+        resolve: resolve as (r: AcpTaskResponse["payload"]) => void,
+        reject,
+        timer,
+        targetNodeId,
+        accumulated: "",
+      });
+
+      const frame: AcpSetConfigRequest = {
+        type: "acp_set_config",
+        id,
+        from: this.config.nodeId,
+        to: targetNodeId,
+        timestamp: Date.now(),
+        payload: { sessionId, configId, value },
+      };
+
+      if (!this.peerManager.sendTo(targetNodeId, frame)) {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        reject(new Error(`Cannot reach node "${targetNodeId}"`));
+      }
+    });
+  }
+
   // ── Chat history (receiver side) ─────────────────────────────────
 
   /** Handle chat history request: read session transcript from disk and return normalized messages. */
@@ -1149,7 +1382,7 @@ export class AcpProxy {
   }
 
   private async spawnDaemon(agent: string, cwd: string): Promise<AgentDaemon> {
-    const streamCallbacks = new Map<string, ((delta: string, event?: string) => void) | null>();
+    const streamCallbacks = new Map<string, ((delta: string, event?: string, data?: unknown) => void) | null>();
 
     const { conn, proc } = await this.spawnAndInit(agent, cwd, "spawnDaemon", (params) => {
       const acpSessionId = (params as unknown as { sessionId?: string }).sessionId;
@@ -1231,6 +1464,7 @@ export class AcpProxy {
     const availableModes: AcpModeInfo[] | undefined = response.modes?.availableModes?.map(
       (m) => ({ id: m.id, name: m.name, description: m.description ?? undefined }),
     );
+    const configOptions = (response as Record<string, unknown>).configOptions as AcpConfigOption[] | undefined;
 
     const session: AcpSession = {
       kind: "acp",
@@ -1246,6 +1480,7 @@ export class AcpProxy {
       },
       availableModes,
       currentModeId: response.modes?.currentModeId,
+      configOptions,
     };
 
     return session;
@@ -1275,11 +1510,17 @@ export class AcpProxy {
 
   /** Return a completed oneshot session to the reuse pool instead of destroying it. */
   private returnToReusePool(session: AcpSession, cwd: string) {
-    // Daemon-backed sessions don't need reuse pool — the daemon stays alive
+    // Daemon-backed sessions don't need reuse pool — the daemon stays alive.
+    // But we must close the ACP session on the daemon to prevent accumulation.
     const daemon = this.findDaemonByConn(session);
     if (daemon) {
       daemon.streamCallbacks.delete(session.acpSessionId);
-      debug("acp", `daemon-backed oneshot done: agent=${session.agent} (daemon stays alive)`);
+      // Close the ACP session on the daemon connection (best-effort, don't block).
+      // Uses unstable_closeSession per ACP SDK — session/close is still experimental.
+      daemon.conn.unstable_closeSession({ sessionId: session.acpSessionId }).catch((err) => {
+        debug("acp", `daemon closeSession failed for ${session.acpSessionId}: ${errorMessage(err)}`);
+      });
+      debug("acp", `daemon-backed oneshot done: agent=${session.agent} (session closed, daemon stays alive)`);
       return;
     }
 
@@ -1386,7 +1627,7 @@ export class AcpProxy {
     agent: string,
     cwd: string,
     label: string,
-    resolveStreamCb: (params: SessionNotification) => ((delta: string, event?: string) => void) | null | undefined,
+    resolveStreamCb: (params: SessionNotification) => ((delta: string, event?: string, data?: unknown) => void) | null | undefined,
   ): Promise<{ conn: ClientSideConnection; proc: { kill: () => void; exited: Promise<number> } }> {
     const cmd = this.resolveCommand(agent);
     debug("acp", `${label}: spawning ${cmd.join(" ")} in ${cwd}`);
@@ -1442,15 +1683,68 @@ export class AcpProxy {
               cb?.(content.text, updateType);
             }
           } else if (updateType === "tool_call") {
-            const toolName = (update as { title?: string }).title
-              || (update as { toolCallId?: string }).toolCallId
-              || "unknown";
-            cb?.(`\n[tool_call: ${toolName}]\n`, updateType);
+            const title = (update as { title?: string }).title;
+            const toolCallId = (update as { toolCallId?: string }).toolCallId;
+            const kind = (update as { kind?: string }).kind;
+            const toolName = title || toolCallId || "unknown";
+            cb?.(`\n[tool_call: ${toolName}]\n`, updateType, { title, toolCallId, kind });
           } else if (updateType === "tool_call_update") {
             const status = (update as { status?: string }).status;
+            // Extract tool output content from completed tool calls
+            const contentBlocks = (update as { content?: Array<{ type?: string; text?: string; content?: Array<{ type?: string; text?: string }> }> }).content;
+            let toolOutput = "";
+            if (contentBlocks) {
+              for (const block of contentBlocks) {
+                if (block.type === "content" && Array.isArray(block.content)) {
+                  // Nested content block (e.g. from tool call content wrapper)
+                  for (const inner of block.content) {
+                    if (inner.type === "text" && inner.text) toolOutput += inner.text;
+                  }
+                } else if (block.type === "text" && block.text) {
+                  toolOutput += block.text;
+                } else if (typeof block.text === "string") {
+                  toolOutput += block.text;
+                }
+              }
+            }
+            // Strip Codex terminal output metadata prefix
+            toolOutput = stripCodexTerminalMeta(toolOutput);
             if (status === "completed" || status === "error") {
-              cb?.("", "tool_result");
+              cb?.(toolOutput, "tool_result");
+            }
+          } else if (updateType === "plan") {
+            // Forward execution plan with structured data
+            const entries = (update as { entries?: Array<{ content?: string; status?: string; priority?: string }> }).entries;
+            if (entries && entries.length > 0) {
+              const planText = entries.map((e) => `[${e.status ?? "pending"}] ${e.content ?? ""}`).join("\n");
+              cb?.(`\n[plan]\n${planText}\n`, "plan", entries);
             }
+          } else if (updateType === "current_mode_update") {
+            const modeId = (update as { modeId?: string }).modeId;
+            if (modeId) cb?.("", "current_mode_update", { modeId });
+          } else if (updateType === "session_info_update") {
+            const title = (update as { title?: string }).title;
+            if (title) {
+              cb?.("", "session_info_update", { title });
+              // Broadcast title update so observers can refresh session list
+              const acpSid = params.sessionId;
+              for (const s of this.sessions.values()) {
+                if (s.kind === "acp" && s.acpSessionId === acpSid) {
+                  this.broadcastSessionNotify(s.sessionId, "updated", title, new Date().toISOString(), s.agent);
+                  break;
+                }
+              }
+            }
+          } else if (updateType === "available_commands_update") {
+            const commands = (update as { commands?: Array<{ name?: string; description?: string; input?: { hint?: string } }> }).commands;
+            if (commands) cb?.("", "available_commands", commands);
+          } else if (updateType === "config_option_update") {
+            const options = (update as { configOptions?: unknown[] }).configOptions;
+            if (options) cb?.("", "config_options", options);
+          } else if (updateType === "usage_update") {
+            // Forward token usage stats
+            const { inputTokens, outputTokens, totalTokens, cacheReadTokens, cacheWriteTokens } = update as Record<string, unknown>;
+            cb?.("", "usage", { inputTokens, outputTokens, totalTokens, cacheReadTokens, cacheWriteTokens });
           }
         },
       }),
@@ -1465,15 +1759,29 @@ export class AcpProxy {
     });
 
     try {
-      await Promise.race([
+      const initResponse = await Promise.race([
         conn.initialize({
           protocolVersion: 1,
           clientInfo: { name: "ClawMatrix", version: "0.1.0" },
-          clientCapabilities: {},
+          clientCapabilities: {
+            prompt: { image: true },
+          },
         }),
         initTimeout,
         earlyExitPromise as Promise<never>,
       ]);
+
+      // Handle agents that require authentication (e.g. Codex with ChatGPT login)
+      const authMethods = (initResponse as Record<string, unknown>)?.authMethods as Array<{ id: string }> | undefined;
+      if (authMethods && authMethods.length > 0) {
+        // Auto-authenticate with the first available method (typically OAuth/API key already in env)
+        try {
+          await conn.authenticate({ method: authMethods[0]!.id });
+          debug("acp", `[${agent}] authenticated with method "${authMethods[0]!.id}"`);
+        } catch (authErr) {
+          debug("acp", `[${agent}] authentication failed: ${errorMessage(authErr)} (continuing without auth)`);
+        }
+      }
     } catch (err) {
       if (!earlyExit) proc.kill();
       throw err;
@@ -1493,9 +1801,9 @@ export class AcpProxy {
     cwd: string,
     from: string,
     label: string,
-    sessionFactory: (conn: ClientSideConnection, cwd: string) => Promise<{ sessionId: string; modes?: { availableModes?: Array<{ id: string; name: string; description?: string }>; currentModeId?: string } }>,
+    sessionFactory: (conn: ClientSideConnection, cwd: string) => Promise<{ sessionId: string; modes?: { availableModes?: Array<{ id: string; name: string; description?: string }>; currentModeId?: string }; configOptions?: AcpConfigOption[] }>,
   ): Promise<AcpSession> {
-    let streamCallback: ((delta: string, event?: string) => void) | null = null;
+    let streamCallback: ((delta: string, event?: string, data?: unknown) => void) | null = null;
 
     const { conn, proc } = await this.spawnAndInit(agent, cwd, label, () => streamCallback);
 
@@ -1524,6 +1832,7 @@ export class AcpProxy {
       setStreamCallback: (cb) => { streamCallback = cb; },
       availableModes,
       currentModeId: response.modes?.currentModeId,
+      configOptions: response.configOptions,
     };
 
     this.monitorProcess(session);
@@ -1556,18 +1865,19 @@ export class AcpProxy {
     debug("acp", `runPrompt: reqId=${requestId} session=${session.sessionId} agent=${session.agent} task=${task.slice(0, 80)}...`);
     const promptStartedAt = Date.now();
 
-    // Broadcast task started to mobile nodes
+    // Broadcast task started to mobile nodes + session notify to all peers
     this.taskActivity.broadcast(requestId, "acp", "started", session.agent, promptStartedAt, task.slice(0, 100));
+    this.broadcastSessionNotify(session.sessionId, "created", undefined, new Date().toISOString(), session.agent);
 
     // Wire streaming to send acp_stream frames (to requester + all session watchers)
-    session.setStreamCallback((delta, event) => {
+    session.setStreamCallback((delta, event, data) => {
       const streamFrame: AcpStreamChunk = {
         type: "acp_stream",
         id: requestId,
         from: this.config.nodeId,
         to: from,
         timestamp: Date.now(),
-        payload: { delta, event, done: false, sessionId: session.sessionId },
+        payload: { delta, event, done: false, sessionId: session.sessionId, data },
       };
       this.peerManager.sendTo(from, streamFrame);
       this.sendToOtherWatchers(session.sessionId, from, streamFrame);
@@ -1599,25 +1909,33 @@ export class AcpProxy {
           promptParts.push({ type: "image", data: img.data, mimeType: img.mediaType });
         }
       }
-      const promptResponse = await session.conn.prompt({
-        sessionId: session.acpSessionId,
-        prompt: promptParts as any,
+      // Race prompt against connection close to detect unexpected agent crashes.
+      // Suppress the rejection on the losing branch to avoid unhandled promise rejection.
+      let cancelConnWatch: (() => void) | undefined;
+      const connClosed = new Promise<never>((_, reject) => {
+        const onClose = () => reject(new Error("ACP agent connection closed unexpectedly during prompt"));
+        session.conn.closed.then(onClose, onClose);
+        cancelConnWatch = () => {
+          // Swallow the eventual rejection so it doesn't become unhandled
+          session.conn.closed.catch(() => {});
+        };
       });
+      connClosed.catch(() => {}); // prevent unhandled rejection on the race loser
+      const promptResponse = await Promise.race([
+        session.conn.prompt({
+          sessionId: session.acpSessionId,
+          prompt: promptParts as any,
+        }),
+        connClosed,
+      ]);
+      cancelConnWatch?.();
 
-      // Send done marker to requester + watchers
-      const doneFrame: AcpStreamChunk = {
-        type: "acp_stream",
-        id: requestId,
-        from: this.config.nodeId,
-        to: from,
-        timestamp: Date.now(),
-        payload: { delta: "", done: true, sessionId: session.sessionId },
-      };
-      this.peerManager.sendTo(from, doneFrame);
-      this.sendToOtherWatchers(session.sessionId, from, doneFrame);
+      // Send done marker BEFORE response to guarantee ordering for clients
+      this.sendDoneMarker(requestId, from, session.sessionId);
 
+      const isCancelled = promptResponse.stopReason === "cancelled";
       const responsePayload: AcpTaskResponse["payload"] = {
-        success: true,
+        success: !isCancelled,
         nodeId: this.config.nodeId,
         agent: session.agent,
         sessionId: this.sessions.has(session.sessionId) ? session.sessionId : undefined,
@@ -1627,9 +1945,17 @@ export class AcpProxy {
       this.sendResponse(requestId, from, responsePayload);
       this.sendResponseToOtherWatchers(requestId, session.sessionId, from, responsePayload);
 
-      // Broadcast task completed
-      this.taskActivity.broadcast(requestId, "acp", "completed", session.agent, promptStartedAt);
+      // Broadcast task completed (or cancelled)
+      this.taskActivity.broadcast(
+        requestId, "acp", isCancelled ? "failed" : "completed", session.agent, promptStartedAt,
+        isCancelled ? "已取消" : undefined,
+      );
+      if (!isCancelled) {
+        this.broadcastSessionNotify(session.sessionId, "completed", undefined, new Date().toISOString(), session.agent);
+      }
     } catch (err) {
+      // Always send done marker on error so clients don't hang
+      this.sendDoneMarker(requestId, from, session.sessionId);
       // Broadcast task failed
       this.taskActivity.broadcast(
         requestId, "acp", "failed", session.agent, promptStartedAt,
@@ -1648,6 +1974,7 @@ export class AcpProxy {
     debug("acp", `runNativePrompt: reqId=${requestId} session=${session.sessionId} key=${session.sessionKey} task=${task.slice(0, 80)}...`);
     const promptStartedAt = Date.now();
     this.taskActivity.broadcast(requestId, "acp", "started", session.agent, promptStartedAt, task.slice(0, 100));
+    this.broadcastSessionNotify(session.sessionId, "created", undefined, new Date().toISOString(), session.agent);
 
     const { port, authHeader } = this.gatewayInfo;
     const abortController = new AbortController();
@@ -1685,17 +2012,7 @@ export class AcpProxy {
       // Stream SSE response as acp_stream frames (to requester + watchers)
       const result = await this.streamGatewaySSE(res, requestId, from, session.sessionId);
 
-      // Send done marker to requester + watchers
-      const doneFrame: AcpStreamChunk = {
-        type: "acp_stream",
-        id: requestId,
-        from: this.config.nodeId,
-        to: from,
-        timestamp: Date.now(),
-        payload: { delta: "", done: true, sessionId: session.sessionId },
-      };
-      this.peerManager.sendTo(from, doneFrame);
-      this.sendToOtherWatchers(session.sessionId, from, doneFrame);
+      this.sendDoneMarker(requestId, from, session.sessionId);
 
       const responsePayload: AcpTaskResponse["payload"] = {
         success: true,
@@ -1707,6 +2024,7 @@ export class AcpProxy {
       this.sendResponse(requestId, from, responsePayload);
       this.sendResponseToOtherWatchers(requestId, session.sessionId, from, responsePayload);
       this.taskActivity.broadcast(requestId, "acp", "completed", session.agent, promptStartedAt);
+      this.broadcastSessionNotify(session.sessionId, "completed", undefined, new Date().toISOString(), session.agent);
     } catch (err) {
       this.taskActivity.broadcast(
         requestId, "acp", "failed", session.agent, promptStartedAt,
@@ -1777,9 +2095,21 @@ export class AcpProxy {
     cwd: string,
     from: string,
   ): Promise<AcpSession> {
-    return this.spawnAndConnect(agent, cwd, from, "createSessionWithResume", (conn) =>
-      conn.unstable_resumeSession({ sessionId: acpSessionId, cwd }),
-    );
+    return this.spawnAndConnect(agent, cwd, from, "createSessionWithResume", async (conn, effectiveCwd) => {
+      // Try session/load first (supported by Codex, Claude Code, and most ACP agents).
+      // It restores conversation history and replays it via notifications.
+      try {
+        const loadResp = await conn.loadSession({ sessionId: acpSessionId, cwd: effectiveCwd, mcpServers: [] });
+        debug("acp", `loadSession succeeded for ${agent} (acpSessionId=${acpSessionId.slice(0, 8)}...)`);
+        return { sessionId: acpSessionId, modes: loadResp.modes, configOptions: (loadResp as Record<string, unknown>).configOptions as AcpConfigOption[] | undefined };
+      } catch (loadErr) {
+        debug("acp", `loadSession failed for ${agent}: ${errorMessage(loadErr)}, trying session/resume`);
+      }
+
+      // Fallback to session/resume (unstable, supported by Claude Code).
+      // Resumes without replaying history — faster but less widely supported.
+      return conn.unstable_resumeSession({ sessionId: acpSessionId, cwd: effectiveCwd });
+    });
   }
 
   /** Read all session stores from disk (OpenClaw + Claude Code). */
@@ -1789,6 +2119,8 @@ export class AcpProxy {
 
   private destroySession(session: AnySession) {
     invalidateSessionListCache();
+    // Clean up watchers for this session
+    this.sessionWatchers.delete(session.sessionId);
     if (session.kind === "acp") {
       // Clean up daemon stream callback
       const daemon = this.findDaemonByConn(session);
@@ -2001,6 +2333,20 @@ export class AcpProxy {
     });
   }
 
+  /** Send a done marker to requester + all session watchers. */
+  private sendDoneMarker(requestId: string, to: string, sessionId: string) {
+    const doneFrame: AcpStreamChunk = {
+      type: "acp_stream",
+      id: requestId,
+      from: this.config.nodeId,
+      to,
+      timestamp: Date.now(),
+      payload: { delta: "", done: true, sessionId },
+    };
+    this.peerManager.sendTo(to, doneFrame);
+    this.sendToOtherWatchers(sessionId, to, doneFrame);
+  }
+
   private sendResponse(id: string, to: string, payload: AcpTaskResponse["payload"]) {
     debug("acp", `sendResponse: id=${id} to=${to} success=${payload.success} error=${payload.error ?? "(none)"}`);
     const frame = {
@@ -2020,11 +2366,14 @@ export class AcpProxy {
       const retryDelays = [2_000, 5_000, 10_000];
       let attempt = 0;
       const retry = () => {
-        if (attempt >= retryDelays.length) {
-          console.error(`[clawmatrix:acp] Failed to deliver acp_res to ${to} after ${retryDelays.length} retries`);
+        if (this.disposed || attempt >= retryDelays.length) {
+          if (!this.disposed) {
+            console.error(`[clawmatrix:acp] Failed to deliver acp_res to ${to} after ${retryDelays.length} retries`);
+          }
           return;
         }
-        setTimeout(() => {
+        const timer = setTimeout(() => {
+          this.retryTimers.delete(timer);
           frame.timestamp = Date.now();
           if (this.peerManager.sendTo(to, frame)) {
             debug("acp", `acp_res to ${to} delivered on retry ${attempt + 1}`);
@@ -2033,6 +2382,7 @@ export class AcpProxy {
             retry();
           }
         }, retryDelays[attempt]);
+        this.retryTimers.add(timer);
       };
       retry();
     }
@@ -2050,6 +2400,9 @@ export class AcpProxy {
   }
 
   destroy() {
+    // Set disposed first to prevent new timers/prewarms from being scheduled during teardown
+    this.disposed = true;
+
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = null;
@@ -2071,7 +2424,9 @@ export class AcpProxy {
     this.sessions.clear();
     this.sessionWatchers.clear();
 
-    this.disposed = true;
+    // Cancel pending retry timers
+    for (const timer of this.retryTimers) clearTimeout(timer);
+    this.retryTimers.clear();
 
     // Cancel pending prewarm timers
     for (const timer of this.prewarmTimers) clearTimeout(timer);
@@ -2100,6 +2455,7 @@ export class AcpProxy {
     }
     this.daemons.clear();
     this.daemonStarting.clear();
+    this.resumeInFlight.clear();
   }
 }
 
@@ -2512,6 +2868,12 @@ function stripThinkingTags(text: string): string {
     .trim();
 }
 
+/** Strip Codex terminal output metadata (Chunk ID, Wall time, etc.) from tool results. */
+const CODEX_TERMINAL_META_RE = /^Chunk ID: [^\n]*\nWall time: [^\n]*\nProcess exited with code \d+\n(?:Original token count: [^\n]*\n)?Output:\n/;
+function stripCodexTerminalMeta(text: string): string {
+  return text.replace(CODEX_TERMINAL_META_RE, "");
+}
+
 /** Check if text is a silent reply (NO_REPLY). */
 function isSilentReply(text: string): boolean {
   return /^\s*NO_REPLY\s*$/.test(text);
@@ -2590,7 +2952,8 @@ function normalizeTranscriptMessages(lines: string[], limit: number): ChatHistor
           : typeof msg.toolName === "string" ? msg.toolName
           : typeof msg.tool_name === "string" ? msg.tool_name
           : inlineResults[0]?.name;
-        const resultText = inlineResults.length > 0 ? inlineResults.map((r) => r.text).join("\n") : text;
+        const rawResultText = inlineResults.length > 0 ? inlineResults.map((r) => r.text).join("\n") : text;
+        const resultText = stripCodexTerminalMeta(rawResultText);
 
         if (raw.length > 0) {
           const prev = raw[raw.length - 1]!;