clawmatrix 0.3.1 → 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,
@@ -99,6 +100,7 @@ interface AcpSession {
   proc: { kill: () => void; exited: Promise<number> };
   lastActiveAt: number;
   from: string;                // owning nodeId
+  prompting: boolean;          // true while executing a prompt (busy state)
   setStreamCallback: (cb: ((delta: string, event?: string, data?: unknown) => void) | null) => void;
   availableModes?: AcpModeInfo[];
   currentModeId?: string;
@@ -114,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;
 }
 
@@ -165,12 +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;
@@ -194,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`). */
@@ -208,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 });
     }
   }
@@ -229,6 +252,171 @@ 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.
@@ -688,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);
@@ -705,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") {
@@ -731,12 +931,12 @@ export class AcpProxy {
             }
           } 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);
@@ -751,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);
@@ -769,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);
@@ -802,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);
@@ -825,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, {
@@ -836,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(),
@@ -860,26 +1103,42 @@ 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: "active",
+          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
+      // 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;
-          return !clawSessions.some((cs) => cs.sessionId === s.sessionId);
+          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 }));
 
@@ -904,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, {
@@ -946,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")
@@ -957,6 +1240,7 @@ export class AcpProxy {
           sessionKey: cwd,
           lastActiveAt: Date.now(),
           from,
+          prompting: false,
           abortController: null,
         };
         this.sessions.set(sessionId, nativeSession);
@@ -1475,6 +1759,7 @@ export class AcpProxy {
       proc: daemon.proc,
       lastActiveAt: Date.now(),
       from,
+      prompting: false,
       setStreamCallback: (cb) => {
         daemon.streamCallbacks.set(response.sessionId, cb);
       },
@@ -1829,6 +2114,7 @@ export class AcpProxy {
       proc,
       lastActiveAt: Date.now(),
       from,
+      prompting: false,
       setStreamCallback: (cb) => { streamCallback = cb; },
       availableModes,
       currentModeId: response.modes?.currentModeId,
@@ -1863,6 +2149,7 @@ 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 + session notify to all peers
@@ -1870,7 +2157,15 @@ export class AcpProxy {
     this.broadcastSessionNotify(session.sessionId, "created", undefined, new Date().toISOString(), session.agent);
 
     // Wire streaming to send acp_stream frames (to requester + all session watchers)
+    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,
@@ -1963,6 +2258,7 @@ export class AcpProxy {
       );
       throw err;
     } finally {
+      session.prompting = false;
       session.setStreamCallback(null);
     }
   }
@@ -1972,6 +2268,7 @@ 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);
@@ -2010,6 +2307,7 @@ 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);
 
       this.sendDoneMarker(requestId, from, session.sessionId);
@@ -2026,12 +2324,15 @@ export class AcpProxy {
       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;
     }
   }
@@ -2119,7 +2420,8 @@ export class AcpProxy {
 
   private destroySession(session: AnySession) {
     invalidateSessionListCache();
-    // Clean up watchers for this session
+    // 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
@@ -2423,6 +2725,9 @@ export class AcpProxy {
     }
     this.sessions.clear();
     this.sessionWatchers.clear();
+    // 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);
@@ -2557,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,
           });
         }
@@ -2620,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",
       });
     }
@@ -2696,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