clawmatrix 0.2.11 → 0.4.0

package/src/acp-proxy.ts

@@ -12,7 +12,8 @@ import { spawnProcess, readFileText, readFileHead, readFileTail } from "./compat
 import { debug } from "./debug.ts";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { readdir, access } from "node:fs/promises";
+import { readdir, access, open as fsOpen, stat as fsStat, unlink, writeFile as fsWriteFile } from "node:fs/promises";
+import { watch as fsWatch, type FSWatcher } from "node:fs";
 import type {
   AcpTaskRequest,
   AcpTaskResponse,
@@ -35,6 +36,13 @@ import type {
   ChatHistoryRequest,
   ChatHistoryResponse,
   ChatHistoryMessage,
+  AcpSetConfigRequest,
+  AcpSetConfigResponse,
+  AcpConfigOption,
+  AcpSubscribeRequest,
+  AcpSubscribeResponse,
+  AcpUnsubscribeRequest,
+  AcpSessionNotify,
 } from "./types.ts";
 import { TaskActivityBroadcaster } from "./task-activity.ts";
 
@@ -74,7 +82,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 +100,12 @@ interface AcpSession {
   proc: { kill: () => void; exited: Promise<number> };
   lastActiveAt: number;
   from: string;                // owning nodeId
-  setStreamCallback: (cb: ((delta: string, event?: string) => void) | null) => void;
+  prompting: boolean;          // true while executing a prompt (busy state)
+  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). */
@@ -105,6 +116,7 @@ interface NativeSession {
   sessionKey: string;          // OpenClaw session key (e.g. "agent:main:cron:xxx")
   lastActiveAt: number;
   from: string;
+  prompting: boolean;          // true while executing a prompt (busy state)
   abortController: AbortController | null;
 }
 
@@ -156,10 +168,16 @@ export class AcpProxy {
   // Track pending retry timers for sendResponse so they can be cancelled on destroy
   private retryTimers = new Set<ReturnType<typeof setTimeout>>();
   private disposed = false;
+  // Transcript file watchers: watch transcript files for external changes (terminal Claude Code)
+  private transcriptWatchers = new Map<string, { watcher: FSWatcher; path: string; offset: number; lineBuffer: string; reading: boolean; idleTimer: ReturnType<typeof setTimeout> | null; hadActivity: boolean }>();
   // 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>>();
+  // Sessions explicitly closed by users — excluded from disk session list
+  private closedSessionIds = new Set<string>();
 
   constructor(config: ClawMatrixConfig, peerManager: PeerManager, openclawConfig?: Record<string, unknown>, gatewayInfo?: GatewayInfo) {
     this.config = config;
@@ -183,12 +201,27 @@ export class AcpProxy {
   // ── Multi-device sync helpers ──────────────────────────────────
 
   private addSessionWatcher(sessionId: string, nodeId: string) {
+    // A mobile device typically watches one session at a time.
+    // Remove from any other session this node was watching to prevent cross-talk.
+    for (const [otherId, otherWatchers] of this.sessionWatchers) {
+      if (otherId !== sessionId && otherWatchers.has(nodeId)) {
+        otherWatchers.delete(nodeId);
+        debug("acp", `addSessionWatcher: removed ${nodeId} from old session ${otherId.slice(0, 8)}`);
+        if (otherWatchers.size === 0) {
+          this.sessionWatchers.delete(otherId);
+          this.stopTranscriptWatcher(otherId);
+        }
+      }
+    }
+
     let watchers = this.sessionWatchers.get(sessionId);
     if (!watchers) {
       watchers = new Set();
       this.sessionWatchers.set(sessionId, watchers);
     }
+    const isNew = !watchers.has(nodeId);
     watchers.add(nodeId);
+    debug("acp", `addSessionWatcher: sessionId=${sessionId.slice(0, 8)} nodeId=${nodeId} isNew=${isNew} total=${watchers.size} all=[${[...watchers].join(",")}]`);
   }
 
   /** Send a frame to all session watchers except the specified node (usually the original `from`). */
@@ -197,6 +230,7 @@ export class AcpProxy {
     if (!watchers) return;
     for (const nodeId of watchers) {
       if (nodeId === exclude) continue;
+      debug("acp", `sendToOtherWatchers: sessionId=${sessionId.slice(0, 8)} → ${nodeId} (type=${frame.type})`);
       this.peerManager.sendTo(nodeId, { ...frame, to: nodeId });
     }
   }
@@ -218,6 +252,265 @@ export class AcpProxy {
     }
   }
 
+  // ── Transcript file watcher (for external Claude Code sessions) ──
+
+  /** Start watching a transcript file for new content and forward to session watchers. */
+  private async startTranscriptWatcher(sessionId: string, acpSessionId: string) {
+    // Don't start duplicate watchers
+    if (this.transcriptWatchers.has(sessionId)) return;
+
+    const transcriptPath = await this.findTranscriptPath(acpSessionId);
+    if (!transcriptPath) {
+      debug("acp", `transcript watcher: no transcript found for ${acpSessionId.slice(0, 8)}`);
+      return;
+    }
+
+    // Start from end of file (only forward NEW content)
+    let offset: number;
+    try {
+      const s = await fsStat(transcriptPath);
+      offset = s.size;
+    } catch {
+      return;
+    }
+
+    debug("acp", `transcript watcher: started for sessionId=${sessionId.slice(0, 8)} path=${transcriptPath} offset=${offset}`);
+
+    const state = { watcher: null as unknown as FSWatcher, path: transcriptPath, offset, lineBuffer: "", reading: false, idleTimer: null as ReturnType<typeof setTimeout> | null, hadActivity: false };
+
+    // Use fs.watch (kqueue on macOS) for near-instant file change detection
+    try {
+      state.watcher = fsWatch(transcriptPath, () => {
+        this.readTranscriptChanges(sessionId, state);
+      });
+      // Handle watcher errors gracefully (e.g., file deleted)
+      state.watcher.on("error", () => {
+        this.stopTranscriptWatcher(sessionId);
+      });
+    } catch {
+      debug("acp", `transcript watcher: fs.watch failed for ${transcriptPath}, skipping`);
+      return;
+    }
+
+    this.transcriptWatchers.set(sessionId, state);
+  }
+
+  /** Stop watching a transcript file. */
+  private stopTranscriptWatcher(sessionId: string) {
+    const entry = this.transcriptWatchers.get(sessionId);
+    if (!entry) return;
+    try { entry.watcher.close(); } catch { /* best effort */ }
+    if (entry.idleTimer) clearTimeout(entry.idleTimer);
+    this.transcriptWatchers.delete(sessionId);
+    debug("acp", `transcript watcher: stopped for sessionId=${sessionId.slice(0, 8)}`);
+  }
+
+  /** Read new bytes from transcript file and forward as stream events. */
+  private async readTranscriptChanges(sessionId: string, state: { path: string; offset: number; lineBuffer: string; reading: boolean; idleTimer: ReturnType<typeof setTimeout> | null; hadActivity: boolean }) {
+    // Prevent concurrent reads (fs.watch can fire multiple times rapidly)
+    if (state.reading) return;
+    state.reading = true;
+
+    try {
+      // Skip if session is prompting through ACP (stream callback handles it)
+      const session = this.sessions.get(sessionId);
+      if (session?.prompting) return;
+
+      // Skip if no watchers
+      const watchers = this.sessionWatchers.get(sessionId);
+      if (!watchers || watchers.size === 0) {
+        this.stopTranscriptWatcher(sessionId);
+        return;
+      }
+
+      const s = await fsStat(state.path);
+      if (s.size <= state.offset) return; // No new data
+
+      // Read new bytes from the file
+      const bytesToRead = s.size - state.offset;
+      const fh = await fsOpen(state.path, "r");
+      try {
+        const buf = Buffer.alloc(Math.min(bytesToRead, 256 * 1024)); // Cap at 256KB per read
+        const { bytesRead } = await fh.read(buf, 0, buf.length, state.offset);
+        if (bytesRead === 0) return;
+        state.offset += bytesRead;
+
+        // Append to line buffer and extract complete lines
+        state.lineBuffer += buf.toString("utf8", 0, bytesRead);
+        const lines = state.lineBuffer.split("\n");
+        state.lineBuffer = lines.pop()!; // Keep incomplete last line in buffer
+
+        let forwarded = false;
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          this.forwardTranscriptLine(sessionId, trimmed);
+          forwarded = true;
+        }
+
+        // After forwarding content, reset the idle timer.
+        // When transcript goes idle for 3s after activity, send transcript_idle
+        // so iOS can re-fetch full history for clean rendering.
+        if (forwarded) {
+          state.hadActivity = true;
+          if (state.idleTimer) clearTimeout(state.idleTimer);
+          state.idleTimer = setTimeout(() => {
+            if (!state.hadActivity) return;
+            state.hadActivity = false;
+            debug("acp", `transcript watcher: idle after activity, sending transcript_idle for ${sessionId.slice(0, 8)}`);
+            this.broadcastTranscriptEvent(sessionId, "", "transcript_idle");
+          }, 3000);
+        }
+      } finally {
+        await fh.close();
+      }
+    } catch (err) {
+      debug("acp", `transcript watcher: read error for ${sessionId.slice(0, 8)}: ${errorMessage(err)}`);
+    } finally {
+      state.reading = false;
+    }
+  }
+
+  /** Parse a single JSONL line and forward as acp_stream frames to watchers.
+   *  Uses the same normalizeTranscriptMessages logic for consistent rendering. */
+  private forwardTranscriptLine(sessionId: string, line: string) {
+    // Reuse the shared normalizer for consistent output with chat history
+    const messages = normalizeTranscriptMessages([line], 10);
+    for (const msg of messages) {
+      if (msg.role === "user") {
+        this.broadcastTranscriptEvent(sessionId, msg.text, "user_message");
+      } else if (msg.role === "assistant") {
+        if (msg.thinking) {
+          this.broadcastTranscriptEvent(sessionId, msg.thinking, "agent_thought_chunk");
+        }
+        if (msg.text) {
+          this.broadcastTranscriptEvent(sessionId, msg.text, "agent_message_chunk");
+        }
+      } else if (msg.role === "tool") {
+        if (msg.toolName) {
+          this.broadcastTranscriptEvent(sessionId, `\n[tool_call: ${msg.toolName}]\n`, "tool_call");
+        }
+        if (msg.toolResult) {
+          this.broadcastTranscriptEvent(sessionId, msg.toolResult, "tool_result");
+        }
+      }
+    }
+  }
+
+  /** Send a transcript event to all watchers of a session. */
+  private broadcastTranscriptEvent(sessionId: string, delta: string, event: string) {
+    const watchers = this.sessionWatchers.get(sessionId);
+    if (!watchers) return;
+
+    const frame: AcpStreamChunk = {
+      type: "acp_stream",
+      id: `transcript-${Date.now()}`,
+      from: this.config.nodeId,
+      to: "",
+      timestamp: Date.now(),
+      payload: { delta, event, done: false, sessionId },
+    };
+
+    for (const nodeId of watchers) {
+      this.peerManager.sendTo(nodeId, { ...frame, to: nodeId });
+    }
+    debug("acp", `transcript watcher: broadcast event=${event} delta=${delta.slice(0, 40)} to ${watchers.size} watchers`);
+  }
+
+  // ── 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(
@@ -479,8 +772,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) {
@@ -577,15 +876,27 @@ export class AcpProxy {
     debug("acp", `handleRequest: id=${id} from=${from} agent=${agent} mode=${mode} sessionId=${sessionId ?? "(new)"} acpSessionId=${resumeAcpSessionId ?? "(none)"}`);
 
     try {
-      if (sessionId) {
+      // Resolve sessionId: if absent but resumeAcpSessionId is provided, look up by acpSessionId
+      let resolvedSessionId = sessionId;
+      if (!resolvedSessionId && resumeAcpSessionId) {
+        for (const [sid, s] of this.sessions) {
+          if (s.kind === "acp" && s.acpSessionId === resumeAcpSessionId) {
+            resolvedSessionId = sid;
+            debug("acp", `Resolved sessionId from acpSessionId: ${resumeAcpSessionId.slice(0, 8)} → ${sid.slice(0, 8)}`);
+            break;
+          }
+        }
+      }
+
+      if (resolvedSessionId) {
         // Follow-up on existing session
-        const session = this.sessions.get(sessionId);
+        const session = this.sessions.get(resolvedSessionId);
         if (!session) {
           // Session expired or process restarted – try to resume
           if (this.isAcpAgent(agent)) {
             let newSession: AcpSession;
             if (resumeAcpSessionId) {
-              debug("acp", `Session "${sessionId}" not found, resuming via acpSessionId "${resumeAcpSessionId.slice(0, 8)}..."`);
+              debug("acp", `Session "${resolvedSessionId}" not found, resuming via acpSessionId "${resumeAcpSessionId.slice(0, 8)}..."`);
               const effectiveCwd = cwd || process.cwd();
               try {
                 newSession = await this.createSessionWithResume(agent, resumeAcpSessionId, effectiveCwd, from);
@@ -594,7 +905,7 @@ export class AcpProxy {
                 newSession = await this.createSession(agent, cwd, from);
               }
             } else {
-              debug("acp", `Session "${sessionId}" not found, creating new session as fallback`);
+              debug("acp", `Session "${resolvedSessionId}" not found, creating new session as fallback`);
               newSession = await this.createSession(agent, cwd, from);
             }
             if (mode === "persistent") {
@@ -610,19 +921,22 @@ 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 {
             // Re-create native session
-            debug("acp", `Native session "${sessionId}" not found, re-creating with key from cwd`);
-            const sessionKey = cwd ?? sessionId;
+            debug("acp", `Native session "${resolvedSessionId}" not found, re-creating with key from cwd`);
+            const sessionKey = cwd ?? resolvedSessionId;
             const newId = `native-${crypto.randomUUID()}`;
             const nativeSession: NativeSession = {
               kind: "native", sessionId: newId, agent, sessionKey,
-              lastActiveAt: Date.now(), from, abortController: null,
+              lastActiveAt: Date.now(), from, prompting: false, abortController: null,
             };
             if (mode === "persistent") {
               this.sessions.set(newId, nativeSession);
@@ -637,7 +951,7 @@ export class AcpProxy {
           return;
         }
         // Track this node as a session watcher for multi-device sync
-        this.addSessionWatcher(sessionId, from);
+        this.addSessionWatcher(resolvedSessionId, from);
         session.lastActiveAt = Date.now();
         if (session.kind === "native") {
           await this.runNativePrompt(id, from, session, task);
@@ -655,8 +969,20 @@ export class AcpProxy {
         }
 
         if (this.isAcpAgent(agent)) {
-          // Create new ACP session
-          const session = await this.createSession(agent, cwd, from);
+          // Resume existing ACP session if acpSessionId is provided, otherwise create new
+          let session: AcpSession;
+          if (resumeAcpSessionId) {
+            debug("acp", `No sessionId but acpSessionId=${resumeAcpSessionId.slice(0, 8)} provided, attempting resume`);
+            const effectiveCwd = cwd || process.cwd();
+            try {
+              session = await this.createSessionWithResume(agent, resumeAcpSessionId, effectiveCwd, from);
+            } catch (resumeErr) {
+              debug("acp", `Resume failed (${errorMessage(resumeErr)}), falling back to new session`);
+              session = await this.createSession(agent, cwd, from);
+            }
+          } else {
+            session = await this.createSession(agent, cwd, from);
+          }
           if (mode === "persistent") {
             this.sessions.set(session.sessionId, session);
             this.addSessionWatcher(session.sessionId, from);
@@ -670,9 +996,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 {
@@ -685,7 +1014,7 @@ export class AcpProxy {
           const newId = `native-${crypto.randomUUID()}`;
           const nativeSession: NativeSession = {
             kind: "native", sessionId: newId, agent, sessionKey,
-            lastActiveAt: Date.now(), from, abortController: null,
+            lastActiveAt: Date.now(), from, prompting: false, abortController: null,
           };
           if (mode === "persistent") {
             this.sessions.set(newId, nativeSession);
@@ -708,7 +1037,19 @@ export class AcpProxy {
 
   async handleClose(frame: AcpCloseRequest): Promise<void> {
     const { id, from, payload } = frame;
-    const session = this.sessions.get(payload.sessionId);
+
+    // Resolve session: direct lookup, then reverse lookup by acpSessionId
+    let resolvedId = payload.sessionId;
+    let session = this.sessions.get(resolvedId);
+    if (!session) {
+      for (const [sid, s] of this.sessions) {
+        if (s.kind === "acp" && s.acpSessionId === payload.sessionId) {
+          resolvedId = sid;
+          session = s;
+          break;
+        }
+      }
+    }
 
     if (!session) {
       this.peerManager.sendTo(from, {
@@ -719,18 +1060,37 @@ export class AcpProxy {
       return;
     }
 
-    if (session.from !== from) {
+    // Allow close from session owner or any watcher (multi-device sync)
+    const watchers = this.sessionWatchers.get(resolvedId);
+    if (session.from !== from && !watchers?.has(from)) {
       this.peerManager.sendTo(from, {
         type: "acp_close_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 AcpCloseResponse);
       return;
     }
 
-    this.sessions.delete(payload.sessionId);
+    this.sessions.delete(resolvedId);
     this.destroySession(session);
 
+    // Mark session as closed so it won't reappear from disk scan
+    const acpSid = session.kind === "acp" ? session.acpSessionId : undefined;
+    if (acpSid) this.closedSessionIds.add(acpSid);
+    this.closedSessionIds.add(resolvedId);
+
+    // Physical deletion: only OpenClaw sessions can be safely deleted from disk.
+    // Claude Code and Codex don't expose a deleteSession API, and their index files
+    // (history.jsonl, SQLite DB, session_index.jsonl) would still reference deleted
+    // transcripts, breaking their own UI/CLI. Both have open GitHub issues requesting
+    // delete support (CC: #25304/#26904/#13514, Codex: #13018/#8784).
+    // For now, rely on the in-memory closedSessionIds set to hide them from list.
+    // TODO: enable physical deletion when these agents add delete APIs
+    // const deleteId = acpSid ?? resolvedId;
+    // deleteSessionFromDisk(deleteId).catch((err) => {
+    //   debug("acp", `deleteSessionFromDisk failed for ${deleteId.slice(0, 8)}: ${errorMessage(err)}`);
+    // });
+
     this.peerManager.sendTo(from, {
       type: "acp_close_res", id, from: this.config.nodeId, to: from,
       timestamp: Date.now(),
@@ -743,25 +1103,44 @@ export class AcpProxy {
     const { id, from, payload } = frame;
 
     try {
-      // 1. ClawMatrix-managed active sessions
+      // 1. Read persisted sessions from disk first (they have full metadata)
+      const diskSessions = await this.readAllSessionStoresFromDisk();
+      // Index disk sessions by sessionId for quick lookup
+      const diskSessionMap = new Map<string, AcpSessionInfo>();
+      for (const ds of diskSessions) {
+        if (ds.sessionId) diskSessionMap.set(ds.sessionId, ds);
+      }
+
+      // 2. ClawMatrix-managed active sessions — merge with disk metadata
       const clawSessions: AcpSessionInfo[] = [];
+      const activeAcpSessionIds = new Set<string>();
       for (const [, session] of this.sessions) {
         if (payload.agent && session.agent !== payload.agent) continue;
+        const acpSid = session.kind === "acp" ? session.acpSessionId : undefined;
+        if (acpSid) activeAcpSessionIds.add(acpSid);
+        // Look up disk metadata for this active session (by ACP session ID)
+        const diskInfo = acpSid ? diskSessionMap.get(acpSid) : undefined;
         clawSessions.push({
-          sessionId: session.sessionId,
-          cwd: "",
+          sessionId: acpSid ?? session.sessionId,
+          cwd: diskInfo?.cwd ?? "",
+          title: diskInfo?.title,
+          description: diskInfo?.description,
           agent: session.agent,
           updatedAt: new Date(session.lastActiveAt).toISOString(),
+          status: session.prompting ? "busy" : "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);
-      });
+      // 3. Filter disk sessions: exclude already-tracked active sessions and explicitly closed ones
+      const filteredDiskSessions = diskSessions
+        .filter((s) => {
+          if (payload.agent && s.agent !== payload.agent) return false;
+          if (clawSessions.some((cs) => cs.sessionId === s.sessionId)) return false;
+          if (activeAcpSessionIds.has(s.sessionId)) return false;
+          if (this.closedSessionIds.has(s.sessionId)) return false;
+          return true;
+        })
+        .map((s) => ({ ...s, status: "idle" as const }));
 
       this.peerManager.sendTo(from, {
         type: "acp_list_res", id, from: this.config.nodeId, to: from,
@@ -784,6 +1163,28 @@ export class AcpProxy {
     const cwd = payload.cwd || process.cwd();
 
     try {
+      // If the session is already active in memory (by ClawMatrix ID or ACP session ID),
+      // just add the caller as a watcher and return the existing session ID.
+      // This avoids spawning a duplicate process and ensures stream forwarding works.
+      debug("acp", `resume: looking for acpSessionId=${acpSessionId.slice(0, 8)} in ${this.sessions.size} active sessions: [${[...this.sessions].map(([sid, s]) => `${sid.slice(0, 8)}(${s.kind === "acp" ? "acp:" + s.acpSessionId.slice(0, 8) : "native"} prompting=${s.prompting})`).join(", ")}]`);
+      for (const [sid, s] of this.sessions) {
+        const isMatch = sid === acpSessionId || (s.kind === "acp" && s.acpSessionId === acpSessionId);
+        if (isMatch) {
+          debug("acp", `resume: session already active (${sid}), adding watcher ${from}`);
+          this.addSessionWatcher(sid, from);
+          this.peerManager.sendTo(from, {
+            type: "acp_resume_res", id, from: this.config.nodeId, to: from,
+            timestamp: Date.now(),
+            payload: { success: true, sessionId: sid },
+          } satisfies AcpResumeResponse);
+          s.lastActiveAt = Date.now();
+          // Start transcript watcher for external activity (terminal Claude Code)
+          const acpSidForWatch = s.kind === "acp" ? s.acpSessionId : acpSessionId;
+          this.startTranscriptWatcher(sid, acpSidForWatch).catch(() => {});
+          return;
+        }
+      }
+
       // Enforce concurrent session limit
       if (this.maxSessions > 0 && this.sessions.size >= this.maxSessions) {
         this.peerManager.sendTo(from, {
@@ -795,13 +1196,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);
@@ -811,6 +1227,8 @@ export class AcpProxy {
           timestamp: Date.now(),
           payload: { success: true, sessionId: session.sessionId },
         } satisfies AcpResumeResponse);
+        // Start transcript watcher for external activity (terminal Claude Code)
+        this.startTranscriptWatcher(session.sessionId, session.acpSessionId).catch(() => {});
       } else {
         // Native OpenClaw session — no process to spawn, just record the session key
         // cwd contains the OpenClaw session key (e.g. "agent:main:clawmatrix-handoff:xxx")
@@ -822,6 +1240,7 @@ export class AcpProxy {
           sessionKey: cwd,
           lastActiveAt: Date.now(),
           from,
+          prompting: false,
           abortController: null,
         };
         this.sessions.set(sessionId, nativeSession);
@@ -856,11 +1275,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;
     }
@@ -962,6 +1383,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. */
@@ -1151,7 +1666,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;
@@ -1233,6 +1748,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",
@@ -1243,12 +1759,13 @@ export class AcpProxy {
       proc: daemon.proc,
       lastActiveAt: Date.now(),
       from,
+      prompting: false,
       setStreamCallback: (cb) => {
         daemon.streamCallbacks.set(response.sessionId, cb);
       },
       availableModes,
       currentModeId: response.modes?.currentModeId,
-
+      configOptions,
     };
 
     return session;
@@ -1278,11 +1795,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;
     }
 
@@ -1389,7 +1912,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}`);
@@ -1445,15 +1968,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 });
           }
         },
       }),
@@ -1468,15 +2044,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;
@@ -1496,9 +2086,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,10 +2114,11 @@ export class AcpProxy {
       proc,
       lastActiveAt: Date.now(),
       from,
+      prompting: false,
       setStreamCallback: (cb) => { streamCallback = cb; },
       availableModes,
       currentModeId: response.modes?.currentModeId,
-
+      configOptions: response.configOptions,
     };
 
     this.monitorProcess(session);
@@ -1558,20 +2149,30 @@ export class AcpProxy {
 
   private async runPrompt(requestId: string, from: string, session: AcpSession, task: string, images?: import("./types.ts").ImageContent[]): Promise<void> {
     debug("acp", `runPrompt: reqId=${requestId} session=${session.sessionId} agent=${session.agent} task=${task.slice(0, 80)}...`);
+    session.prompting = true;
     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) => {
+    const watchers = this.sessionWatchers.get(session.sessionId);
+    debug("acp", `runPrompt: wiring stream callback. sessionId=${session.sessionId.slice(0, 8)} from=${from} watchers=[${watchers ? [...watchers].join(",") : "none"}]`);
+    let streamChunkCount = 0;
+    session.setStreamCallback((delta, event, data) => {
+      streamChunkCount++;
+      if (streamChunkCount <= 3 || streamChunkCount % 50 === 0) {
+        debug("acp", `stream chunk #${streamChunkCount}: event=${event ?? "text"} delta=${delta.slice(0, 40)} sessionId=${session.sessionId.slice(0, 8)}`);
+      }
+      session.lastActiveAt = Date.now();
       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);
@@ -1603,25 +2204,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,
@@ -1631,9 +2240,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,
@@ -1641,6 +2258,7 @@ export class AcpProxy {
       );
       throw err;
     } finally {
+      session.prompting = false;
       session.setStreamCallback(null);
     }
   }
@@ -1650,8 +2268,10 @@ export class AcpProxy {
     if (!this.gatewayInfo) throw new Error("Gateway info not available for native session");
 
     debug("acp", `runNativePrompt: reqId=${requestId} session=${session.sessionId} key=${session.sessionKey} task=${task.slice(0, 80)}...`);
+    session.prompting = true;
     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();
@@ -1687,19 +2307,10 @@ export class AcpProxy {
       }
 
       // Stream SSE response as acp_stream frames (to requester + watchers)
+      session.lastActiveAt = Date.now();
       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,
@@ -1711,13 +2322,17 @@ 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) {
+      // Always send done marker on error so clients don't hang
+      this.sendDoneMarker(requestId, from, session.sessionId);
       this.taskActivity.broadcast(
         requestId, "acp", "failed", session.agent, promptStartedAt,
         errorMessage(err),
       );
       throw err;
     } finally {
+      session.prompting = false;
       session.abortController = null;
     }
   }
@@ -1787,7 +2402,7 @@ export class AcpProxy {
       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 };
+        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`);
       }
@@ -1805,6 +2420,9 @@ export class AcpProxy {
 
   private destroySession(session: AnySession) {
     invalidateSessionListCache();
+    // Clean up transcript watcher and session watchers
+    this.stopTranscriptWatcher(session.sessionId);
+    this.sessionWatchers.delete(session.sessionId);
     if (session.kind === "acp") {
       // Clean up daemon stream callback
       const daemon = this.findDaemonByConn(session);
@@ -2017,6 +2635,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 = {
@@ -2070,6 +2702,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;
@@ -2090,8 +2725,9 @@ export class AcpProxy {
     }
     this.sessions.clear();
     this.sessionWatchers.clear();
-
-    this.disposed = true;
+    // Stop all transcript watchers
+    for (const [sid] of this.transcriptWatchers) this.stopTranscriptWatcher(sid);
+    this.transcriptWatchers.clear();
 
     // Cancel pending retry timers
     for (const timer of this.retryTimers) clearTimeout(timer);
@@ -2124,6 +2760,7 @@ export class AcpProxy {
     }
     this.daemons.clear();
     this.daemonStarting.clear();
+    this.resumeInFlight.clear();
   }
 }
 
@@ -2225,22 +2862,29 @@ async function fetchSessionListFromDisk(): Promise<AcpSessionInfo[]> {
         const content = await readFileText(storePath);
         const entries: Record<string, { sessionId?: string; updatedAt?: number; displayName?: string; subject?: string; label?: string; acp?: { agent?: string } }> = JSON.parse(content);
         const agent = agentId;
-        // Read all transcripts in parallel instead of sequentially
+        // Read all transcripts in parallel (first message + mtime)
         const entryList = Object.entries(entries).filter(([, e]) => e.sessionId);
         const transcriptResults = await Promise.all(
-          entryList.map(([, entry]) => {
+          entryList.map(async ([, entry]) => {
             const transcriptPath = join(sessionsDir, `${entry.sessionId!}.jsonl`);
-            return readFirstUserMessageFromTranscript(transcriptPath);
+            const [firstMsg, fileStat] = await Promise.all([
+              readFirstUserMessageFromTranscript(transcriptPath),
+              fsStat(transcriptPath).catch(() => null),
+            ]);
+            return { firstMsg, mtimeMs: fileStat?.mtimeMs ?? null };
           }),
         );
         for (let i = 0; i < entryList.length; i++) {
           const [key, entry] = entryList[i]!;
+          const { firstMsg, mtimeMs } = transcriptResults[i]!;
+          const storeTs = entry.updatedAt ?? 0;
+          const effectiveTs = mtimeMs && mtimeMs > storeTs ? mtimeMs : storeTs;
           results.push({
             sessionId: entry.sessionId!,
             cwd: key,
             title: entry.displayName ?? entry.subject ?? entry.label ?? undefined,
-            description: transcriptResults[i] ?? undefined,
-            updatedAt: entry.updatedAt ? new Date(entry.updatedAt).toISOString() : undefined,
+            description: firstMsg ?? undefined,
+            updatedAt: effectiveTs ? new Date(effectiveTs).toISOString() : undefined,
             agent,
           });
         }
@@ -2288,14 +2932,41 @@ async function fetchSessionListFromDisk(): Promise<AcpSessionInfo[]> {
 
     const ccResults: AcpSessionInfo[] = [];
     const existingIds = new Set(results.map((r) => r.sessionId));
+    // Stat transcript files in parallel to get more accurate mtime
+    const claudeProjectsDir = join(homedir(), ".claude", "projects");
+    let projectDirs: string[] = [];
+    try { projectDirs = await readdir(claudeProjectsDir); } catch { /* no projects dir */ }
+
+    const pendingEntries: { sessionId: string; info: { title: string; updatedAt: number; cwd: string } }[] = [];
     for (const [sessionId, info] of sessions) {
       if (!info.title || info.title.startsWith("/")) continue;
       if (existingIds.has(sessionId)) continue;
+      pendingEntries.push({ sessionId, info });
+    }
+
+    // For each session, try to find its transcript file and stat it
+    const mtimeResults = await Promise.all(
+      pendingEntries.map(async ({ sessionId }) => {
+        for (const dir of projectDirs) {
+          try {
+            const s = await fsStat(join(claudeProjectsDir, dir, `${sessionId}.jsonl`));
+            return s.mtimeMs;
+          } catch { /* not in this project dir */ }
+        }
+        return null;
+      }),
+    );
+
+    for (let i = 0; i < pendingEntries.length; i++) {
+      const { sessionId, info } = pendingEntries[i]!;
+      const mtime = mtimeResults[i];
+      // Use the more recent of history timestamp and transcript file mtime
+      const effectiveUpdatedAt = mtime && mtime > info.updatedAt ? mtime : info.updatedAt;
       ccResults.push({
         sessionId,
         cwd: info.cwd,
         title: info.title,
-        updatedAt: info.updatedAt ? new Date(info.updatedAt).toISOString() : undefined,
+        updatedAt: effectiveUpdatedAt ? new Date(effectiveUpdatedAt).toISOString() : undefined,
         agent: "claude",
       });
     }
@@ -2364,6 +3035,52 @@ async function fetchSessionListFromDisk(): Promise<AcpSessionInfo[]> {
   return results;
 }
 
+// ── Physical session deletion ──────────────────────────────────────
+
+/**
+ * Delete a session's files from disk (only for agents we fully control).
+ *
+ * Claude Code and Codex have their own index files (history.jsonl, SQLite DB,
+ * session_index.jsonl) that still reference sessions — deleting transcript
+ * files without cleaning those indexes would break their own UI/CLI.
+ * Since they don't expose a deleteSession API, we only physically delete
+ * OpenClaw-managed session files where we control both the store and transcripts.
+ *
+ * For Claude Code and Codex, sessions are hidden via the in-memory
+ * closedSessionIds set (which filters them from list responses).
+ */
+async function deleteSessionFromDisk(sessionId: string): Promise<void> {
+  const stateDir = process.env.OPENCLAW_STATE_DIR ?? join(homedir(), ".openclaw");
+
+  // OpenClaw agent session stores: remove entry from sessions.json + delete transcript
+  const agentsDir = join(stateDir, "agents");
+  try {
+    const agentIds = await readdir(agentsDir);
+    for (const agentId of agentIds) {
+      const sessionsDir = join(agentsDir, agentId, "sessions");
+      const storePath = join(sessionsDir, "sessions.json");
+      try {
+        const content = await readFileText(storePath);
+        const entries: Record<string, Record<string, unknown>> = JSON.parse(content);
+        let modified = false;
+        for (const [key, entry] of Object.entries(entries)) {
+          if ((entry as { sessionId?: string }).sessionId === sessionId) {
+            delete entries[key];
+            modified = true;
+          }
+        }
+        if (modified) {
+          await fsWriteFile(storePath, JSON.stringify(entries, null, 2), "utf-8");
+        }
+        await unlink(join(sessionsDir, `${sessionId}.jsonl`)).catch(() => {});
+      } catch { /* store unreadable */ }
+    }
+  } catch { /* no agents directory */ }
+
+  invalidateSessionListCache();
+  debug("acp", `deleteSessionFromDisk: cleaned up OpenClaw files for ${sessionId.slice(0, 8)}`);
+}
+
 // ── Transcript normalization ───────────────────────────────────────
 // Mirrors the OpenClaw web dashboard pipeline:
 //   Server: readSessionMessages → stripEnvelopeFromMessages → sanitizeChatHistoryMessages
@@ -2536,6 +3253,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);
@@ -2614,7 +3337,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]!;