@clawchatsai/connector 0.0.28 → 0.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawchatsai/connector",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "type": "module",
   "description": "ClawChats OpenClaw plugin — P2P tunnel + local API bridge",
   "main": "dist/index.js",

package/server.js

@@ -832,12 +832,14 @@ function handleGetThreads(req, res, params, query) {
       `SELECT COUNT(*) as c FROM threads WHERE id IN (${placeholders})`
     ).get(...matchingIds).c;
     threads = db.prepare(
-      `SELECT * FROM threads WHERE id IN (${placeholders}) ORDER BY pinned DESC, sort_order DESC, updated_at DESC LIMIT ? OFFSET ?`
+      `SELECT t.*, (SELECT MAX(m.timestamp) FROM messages m WHERE m.thread_id = t.id) as last_message_at
+       FROM threads t WHERE t.id IN (${placeholders}) ORDER BY t.pinned DESC, t.sort_order DESC, t.updated_at DESC LIMIT ? OFFSET ?`
     ).all(...matchingIds, limit, offset);
   } else {
     total = db.prepare('SELECT COUNT(*) as c FROM threads').get().c;
     threads = db.prepare(
-      'SELECT * FROM threads ORDER BY pinned DESC, sort_order DESC, updated_at DESC LIMIT ? OFFSET ?'
+      `SELECT t.*, (SELECT MAX(m.timestamp) FROM messages m WHERE m.thread_id = t.id) as last_message_at
+       FROM threads t ORDER BY t.pinned DESC, t.sort_order DESC, t.updated_at DESC LIMIT ? OFFSET ?`
     ).all(limit, offset);
   }
 
@@ -2228,9 +2230,19 @@ class GatewayClient {
 
     // Clean up stale activity logs every 5 minutes (runs that never completed)
     setInterval(() => {
-      const cutoff = Date.now() - 10 * 60 * 1000; // 10 minutes
+      const cutoff = Date.now() - 10 * 60 * 1000;
       for (const [runId, log] of this.activityLogs) {
         if (log.startTime < cutoff) {
+          if (log._messageId) {
+            const db = getDb(log._parsed?.workspace);
+            if (db) {
+              db.prepare(`
+                UPDATE messages SET content = '[Response interrupted]',
+                metadata = json_remove(metadata, '$.pending')
+                WHERE id = ? AND content = ''
+              `).run(log._messageId);
+            }
+          }
           this.activityLogs.delete(runId);
         }
       }
@@ -2311,17 +2323,6 @@ class GatewayClient {
       this.broadcastGatewayStatus(true);
     }
 
-    // Handle activity log history responses
-    if (msg.type === 'res' && msg.id && this._pendingActivityCallbacks?.has(msg.id)) {
-      const callback = this._pendingActivityCallbacks.get(msg.id);
-      this._pendingActivityCallbacks.delete(msg.id);
-      if (msg.ok) {
-        callback(msg.payload);
-      } else {
-        callback(null);
-      }
-    }
-
     // Forward all messages to browser clients
     this.broadcastToBrowsers(data);
 
@@ -2369,9 +2370,8 @@ class GatewayClient {
 
   saveAssistantMessage(sessionKey, message, seq) {
     const parsed = parseSessionKey(sessionKey);
-    if (!parsed) return; // Non-ClawChats session key, silently ignore
+    if (!parsed) return;
 
-    // Guard: verify workspace still exists
     const ws = getWorkspaces();
     if (!ws.workspaces[parsed.workspace]) {
       console.log(`Ignoring response for deleted workspace: ${parsed.workspace}`);
@@ -2380,49 +2380,66 @@ class GatewayClient {
 
     const db = getDb(parsed.workspace);
 
-    // Guard: verify thread still exists
     const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(parsed.threadId);
     if (!thread) {
       console.log(`Ignoring response for deleted thread: ${parsed.threadId}`);
       return;
     }
 
-    // Extract content
     const content = extractContent(message);
-
-    // Guard: skip empty content
     if (!content || !content.trim()) {
       console.log(`Skipping empty assistant response for thread ${parsed.threadId}`);
       return;
     }
 
-    // Deterministic message ID from seq (deduplicates tool-call loops)
     const now = Date.now();
-    const messageId = seq != null ? `gw-${parsed.threadId}-${seq}` : `gw-${parsed.threadId}-${now}`;
 
-    // Upsert message: INSERT OR REPLACE (same seq → same messageId → update content)
-    try {
+    // Check for pending activity message
+    const pendingMsg = db.prepare(`
+      SELECT id, metadata FROM messages
+      WHERE thread_id = ? AND role = 'assistant'
+      AND json_extract(metadata, '$.pending') = 1
+      ORDER BY timestamp DESC LIMIT 1
+    `).get(parsed.threadId);
+
+    let messageId;
+
+    if (pendingMsg) {
+      // Merge final content into existing activity row
+      const metadata = pendingMsg.metadata ? JSON.parse(pendingMsg.metadata) : {};
+      delete metadata.pending;
+
+      // Clean up: remove last assistant narration (it's the final reply text)
+      if (metadata.activityLog) {
+        const lastAssistantIdx = metadata.activityLog.findLastIndex(s => s.type === 'assistant');
+        if (lastAssistantIdx >= 0) metadata.activityLog.splice(lastAssistantIdx, 1);
+        metadata.activitySummary = this.generateActivitySummary(metadata.activityLog);
+      }
+
+      db.prepare('UPDATE messages SET content = ?, metadata = ?, timestamp = ? WHERE id = ?')
+        .run(content, JSON.stringify(metadata), now, pendingMsg.id);
+
+      messageId = pendingMsg.id;
+    } else {
+      // No pending activity — normal INSERT (simple responses, no tools)
+      messageId = seq != null ? `gw-${parsed.threadId}-${seq}` : `gw-${parsed.threadId}-${now}`;
       db.prepare(`
         INSERT INTO messages (id, thread_id, role, content, status, timestamp, created_at)
         VALUES (?, ?, 'assistant', ?, 'sent', ?, ?)
         ON CONFLICT(id) DO UPDATE SET content = excluded.content, timestamp = excluded.timestamp
       `).run(messageId, parsed.threadId, content, now, now);
+    }
 
-      // Update thread updated_at
+    // Thread timestamp + unreads + broadcast (same for both paths)
+    try {
       db.prepare('UPDATE threads SET updated_at = ? WHERE id = ?').run(now, parsed.threadId);
-
-      // Always mark as unread server-side. The browser client is responsible
-      // for sending read receipts (active-thread) to clear unreads — same
-      // pattern as Slack/Discord. Server doesn't track viewport state.
       db.prepare('INSERT OR IGNORE INTO unread_messages (thread_id, message_id, created_at) VALUES (?, ?, ?)').run(parsed.threadId, messageId, now);
       syncThreadUnreadCount(db, parsed.threadId);
 
-      // Get thread title and unread info for notification
       const threadInfo = db.prepare('SELECT title FROM threads WHERE id = ?').get(parsed.threadId);
       const unreadCount = db.prepare('SELECT COUNT(*) as c FROM unread_messages WHERE thread_id = ?').get(parsed.threadId).c;
       const preview = content.length > 120 ? content.substring(0, 120) + '...' : content;
 
-      // Broadcast message-saved for active thread reload
       this.broadcastToBrowsers(JSON.stringify({
         type: 'clawchats',
         event: 'message-saved',
@@ -2435,7 +2452,6 @@ class GatewayClient {
         unreadCount
       }));
 
-      // Always broadcast unread-update — browser sends read receipts to clear
       const workspaceUnreadTotal = db.prepare('SELECT COALESCE(SUM(unread_count), 0) as total FROM threads').get().total;
       this.broadcastToBrowsers(JSON.stringify({
         type: 'clawchats',
@@ -2451,7 +2467,7 @@ class GatewayClient {
         timestamp: now
       }));
 
-      console.log(`Saved assistant message to ${parsed.workspace}/${parsed.threadId} (seq: ${seq})`);
+      console.log(`Saved assistant message to ${parsed.workspace}/${parsed.threadId} (${pendingMsg ? 'merged into pending' : 'seq: ' + seq})`);
     } catch (e) {
       console.error(`Failed to save assistant message:`, e.message);
     }
@@ -2498,8 +2514,6 @@ class GatewayClient {
       // Capture intermediate text turns (narration between tool calls)
       const text = data?.text || '';
       if (text) {
-        // Update or create the current assistant text segment
-        // Each new assistant segment starts after a tool call
         let currentSegment = log._currentAssistantSegment;
         if (!currentSegment || currentSegment._sealed) {
           currentSegment = {
@@ -2515,15 +2529,11 @@ class GatewayClient {
         }
       }
       // Don't broadcast on every assistant delta — too noisy
-      // We'll broadcast when a tool starts (which seals the current segment)
       return;
     }
 
     if (stream === 'thinking') {
-      // Reasoning/thinking text from the model (requires reasoningLevel: "stream")
       const thinkingText = data?.text || '';
-      const delta = data?.delta || '';
-      // Update or create thinking step — we keep a single thinking step that accumulates
       let thinkingStep = log.steps.find(s => s.type === 'thinking');
       if (thinkingStep) {
         thinkingStep.text = thinkingText;
@@ -2534,11 +2544,12 @@ class GatewayClient {
           text: thinkingText
         });
       }
-      // Broadcast to browser for live display (throttled — thinking events come fast)
+      // Always write to DB; throttle broadcasts to every 300ms
+      this._writeActivityToDb(runId, log);
       const now = Date.now();
       if (!log._lastThinkingBroadcast || now - log._lastThinkingBroadcast >= 300) {
         log._lastThinkingBroadcast = now;
-        this.broadcastActivityUpdate(runId, log);
+        this._broadcastActivityUpdate(runId, log);
       }
     }
 
@@ -2546,8 +2557,6 @@ class GatewayClient {
       // Seal any current assistant text segment (narration before this tool call)
       if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) {
         log._currentAssistantSegment._sealed = true;
-        // Broadcast the narration + upcoming tool
-        this.broadcastActivityUpdate(runId, log);
       }
 
       const step = {
@@ -2573,21 +2582,18 @@ class GatewayClient {
           log.steps.push(step);
         }
       } else if (data?.phase === 'update') {
-        // Merge update events into the existing step — don't create new entries
         const existing = log.steps.findLast(s => s.toolCallId === data.toolCallId);
         if (existing) {
-          // Update meta if the update carries new info
           if (data?.meta) existing.resultMeta = data.meta;
           if (data?.isError) existing.isError = true;
           existing.phase = 'running';
         }
-        // If no existing step found, silently ignore the orphaned update
       } else {
         log.steps.push(step);
       }
 
-      // Forward to browser for real-time display
-      this.broadcastActivityUpdate(runId, log);
+      this._writeActivityToDb(runId, log);
+      this._broadcastActivityUpdate(runId, log);
     }
 
     if (stream === 'lifecycle') {
@@ -2597,184 +2603,85 @@ class GatewayClient {
           log._currentAssistantSegment._sealed = true;
         }
         // Remove the final assistant segment — that's the actual response, not narration
-        // The last assistant segment is the final reply text, which is displayed as the message itself
         const lastAssistantIdx = log.steps.findLastIndex(s => s.type === 'assistant');
         if (lastAssistantIdx >= 0) {
           log.steps.splice(lastAssistantIdx, 1);
         }
 
-        log.steps.push({ type: 'lifecycle', timestamp: Date.now(), phase: data.phase });
-
-        // Finalize: save to message metadata
-        this.finalizeActivityLog(runId, log);
+        // Write final state to DB, then clean up
+        this._writeActivityToDb(runId, log);
+        this.activityLogs.delete(runId);
+        return;
       }
     }
   }
 
-  broadcastActivityUpdate(runId, log) {
-    const parsed = log.sessionKey ? parseSessionKey(log.sessionKey) : null;
-    if (!parsed) return;
-
-    this.broadcastToBrowsers(JSON.stringify({
-      type: 'clawchats',
-      event: 'agent-activity',
-      workspace: parsed.workspace,
-      threadId: parsed.threadId,
-      runId,
-      steps: log.steps,
-      summary: this.generateActivitySummary(log.steps)
-    }));
-  }
-
-  finalizeActivityLog(runId, log) {
-    const parsed = log.sessionKey ? parseSessionKey(log.sessionKey) : null;
+  _writeActivityToDb(runId, log) {
+    if (!log._parsed) {
+      log._parsed = parseSessionKey(log.sessionKey);
+    }
+    const parsed = log._parsed;
     if (!parsed) return;
 
     const db = getDb(parsed.workspace);
     if (!db) return;
 
-    const hasToolSteps = log.steps.some(s => s.type === 'tool');
-
-    // If we got no tool events (e.g., webchat session where we're not a registered recipient),
-    // try to extract tool calls from the session history via Gateway API
-    if (!hasToolSteps && this.ws && this.ws.readyState === 1 /* OPEN */) {
-      this.fetchToolCallsFromHistory(log.sessionKey, parsed, db, log, runId);
-      return;
-    }
-
-    // Save activity log to message metadata (delay to ensure final message is saved first)
-    this.saveActivityToMessage(parsed, db, log, runId);
-  }
+    const cleanSteps = log.steps.map(s => { const c = {...s}; delete c._sealed; return c; });
+    const summary = this.generateActivitySummary(log.steps);
+    const now = Date.now();
 
-  fetchToolCallsFromHistory(sessionKey, parsed, db, log, runId) {
-    const reqId = `activity-hist-${runId}`;
+    if (!log._messageId) {
+      // First write — INSERT the assistant message row
+      const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(parsed.threadId);
+      if (!thread) return;
 
-    const timeout = setTimeout(() => {
-      // Timeout: save what we have (even if empty)
-      this._pendingActivityCallbacks?.delete(reqId);
-      this.saveActivityToMessage(parsed, db, log, runId);
-    }, 5000);
+      const messageId = `gw-activity-${runId}`;
+      const metadata = { activityLog: cleanSteps, activitySummary: summary, pending: true };
 
-    // Register callback for when the gateway responds
-    if (!this._pendingActivityCallbacks) this._pendingActivityCallbacks = new Map();
-    this._pendingActivityCallbacks.set(reqId, (payload) => {
-      clearTimeout(timeout);
+      db.prepare(`
+        INSERT INTO messages (id, thread_id, role, content, status, metadata, timestamp, created_at)
+        VALUES (?, ?, 'assistant', '', 'sent', ?, ?, ?)
+      `).run(messageId, parsed.threadId, JSON.stringify(metadata), now, now);
 
-      // Extract tool calls and narration from the last assistant message in history
-      if (payload?.messages) {
-        for (let i = payload.messages.length - 1; i >= 0; i--) {
-          const m = payload.messages[i];
-          if (m.role === 'assistant' && Array.isArray(m.content)) {
-            let hasToolUse = false;
-            for (const block of m.content) {
-              if (block.type === 'text' && block.text?.trim() && hasToolUse) {
-                // Text after a tool_use = intermediate narration (not the first text which is part of the response)
-                // Actually, text BEFORE a tool_use is narration too
-              }
-              if (block.type === 'text' && block.text?.trim()) {
-                // We'll collect all text blocks, then trim the last one (that's the actual response)
-                log.steps.push({
-                  type: 'assistant',
-                  timestamp: Date.now(),
-                  text: block.text.trim()
-                });
-              }
-              if (block.type === 'tool_use') {
-                hasToolUse = true;
-                log.steps.push({
-                  type: 'tool',
-                  timestamp: Date.now(),
-                  name: block.name || 'unknown',
-                  phase: 'done',
-                  toolCallId: block.id,
-                  meta: this.extractToolMeta(block),
-                  isError: false
-                });
-              }
-            }
-            // Remove the last assistant text — that's the final response, not narration
-            if (hasToolUse) {
-              const lastAssistantIdx = log.steps.findLastIndex(s => s.type === 'assistant');
-              if (lastAssistantIdx >= 0) {
-                log.steps.splice(lastAssistantIdx, 1);
-              }
-            } else {
-              // No tool calls — remove all assistant narration (nothing interesting to show)
-              log.steps = log.steps.filter(s => s.type !== 'assistant');
-            }
-            break; // Only process the last assistant message
-          }
-        }
-      }
+      log._messageId = messageId;
 
-      this.saveActivityToMessage(parsed, db, log, runId);
-      this.broadcastActivityUpdate(runId, log);
-    });
+      // First event — broadcast message-saved so browser creates the message element
+      this.broadcastToBrowsers(JSON.stringify({
+        type: 'clawchats',
+        event: 'message-saved',
+        threadId: parsed.threadId,
+        workspace: parsed.workspace,
+        messageId,
+        timestamp: now
+      }));
+    } else {
+      // Subsequent writes — UPDATE metadata on existing row
+      const existing = db.prepare('SELECT metadata FROM messages WHERE id = ?').get(log._messageId);
+      const metadata = existing?.metadata ? JSON.parse(existing.metadata) : {};
+      metadata.activityLog = cleanSteps;
+      metadata.activitySummary = summary;
+      metadata.pending = true;
 
-    // Request session history from gateway
-    this.ws.send(JSON.stringify({
-      type: 'req',
-      id: reqId,
-      method: 'sessions.history',
-      params: { key: sessionKey, limit: 3, includeTools: true }
-    }));
+      db.prepare('UPDATE messages SET metadata = ? WHERE id = ?')
+        .run(JSON.stringify(metadata), log._messageId);
+    }
   }
 
-  extractToolMeta(toolUseBlock) {
-    if (!toolUseBlock.input) return '';
-    const input = toolUseBlock.input;
-    // Generate a brief description from the tool input
-    if (input.query) return input.query;
-    if (input.command) return input.command.substring(0, 80);
-    if (input.file_path || input.path) return input.file_path || input.path;
-    if (input.url) return input.url;
-    if (input.text) return input.text.substring(0, 60);
-    return '';
-  }
+  _broadcastActivityUpdate(runId, log) {
+    const parsed = log._parsed;
+    if (!parsed || !log._messageId) return;
 
-  saveActivityToMessage(parsed, db, log, runId) {
-    // Delay to ensure the assistant message is saved first (from handleChatEvent final)
-    setTimeout(() => {
-      try {
-        const msg = db.prepare(
-          'SELECT id, metadata FROM messages WHERE thread_id = ? AND role = ? ORDER BY timestamp DESC LIMIT 1'
-        ).get(parsed.threadId, 'assistant');
-
-        if (msg) {
-          const toolSteps = log.steps.filter(s => s.type === 'tool' && s.phase !== 'update');
-          const thinkingSteps = log.steps.filter(s => s.type === 'thinking');
-          const narrativeSteps = log.steps.filter(s => s.type === 'assistant' && s.text?.trim());
-          // Only save if we have meaningful activity
-          if (toolSteps.length > 0 || thinkingSteps.length > 0 || narrativeSteps.length > 0) {
-            const metadata = msg.metadata ? JSON.parse(msg.metadata) : {};
-            // Clean internal fields before persisting
-            metadata.activityLog = log.steps.map(s => {
-              const clean = { ...s };
-              delete clean._sealed;
-              return clean;
-            });
-            metadata.activitySummary = this.generateActivitySummary(log.steps);
-            db.prepare('UPDATE messages SET metadata = ? WHERE id = ?')
-              .run(JSON.stringify(metadata), msg.id);
-
-            console.log(`[ActivityLog] Saved ${toolSteps.length} tool steps for message ${msg.id}`);
-
-            // Notify browsers to re-render this message with activity data
-            this.broadcastToBrowsers(JSON.stringify({
-              type: 'clawchats',
-              event: 'activity-saved',
-              workspace: parsed.workspace,
-              threadId: parsed.threadId,
-              messageId: msg.id
-            }));
-          }
-        }
-      } catch (e) {
-        console.error('Failed to save activity log:', e.message);
-      }
+    const cleanSteps = log.steps.map(s => { const c = {...s}; delete c._sealed; return c; });
 
-      this.activityLogs.delete(runId);
-    }, 1000); // 1s delay — must happen after message-saved (which fires on chat:final)
+    this.broadcastToBrowsers(JSON.stringify({
+      type: 'clawchats',
+      event: 'activity-updated',
+      workspace: parsed.workspace,
+      threadId: parsed.threadId,
+      messageId: log._messageId,
+      activityLog: cleanSteps,
+      activitySummary: this.generateActivitySummary(log.steps)
+    }));
   }
 
   generateActivitySummary(steps) {
@@ -3600,7 +3507,19 @@ export function createApp(config = {}) {
       setInterval(() => {
         const cutoff = Date.now() - 10 * 60 * 1000;
         for (const [runId, log] of this.activityLogs) {
-          if (log.startTime < cutoff) this.activityLogs.delete(runId);
+          if (log.startTime < cutoff) {
+            if (log._messageId) {
+              const db = _getDb(log._parsed?.workspace);
+              if (db) {
+                db.prepare(`
+                  UPDATE messages SET content = '[Response interrupted]',
+                  metadata = json_remove(metadata, '$.pending')
+                  WHERE id = ? AND content = ''
+                `).run(log._messageId);
+              }
+            }
+            this.activityLogs.delete(runId);
+          }
         }
       }, 5 * 60 * 1000);
     }
@@ -3632,11 +3551,6 @@ export function createApp(config = {}) {
         return;
       }
       if (msg.type === 'res' && msg.payload?.type === 'hello-ok') { console.log('Gateway handshake complete'); this.connected = true; this.broadcastGatewayStatus(true); }
-      if (msg.type === 'res' && msg.id && this._pendingActivityCallbacks?.has(msg.id)) {
-        const callback = this._pendingActivityCallbacks.get(msg.id);
-        this._pendingActivityCallbacks.delete(msg.id);
-        if (msg.ok) callback(msg.payload); else callback(null);
-      }
       this.broadcastToBrowsers(data);
       if (msg.type === 'event' && msg.event === 'chat' && msg.payload) this.handleChatEvent(msg.payload);
       if (msg.type === 'event' && msg.event === 'agent' && msg.payload) this.handleAgentEvent(msg.payload);
@@ -3669,11 +3583,37 @@ export function createApp(config = {}) {
       const content = extractContent(message);
       if (!content || !content.trim()) { console.log(`Skipping empty assistant response for thread ${parsed.threadId}`); return; }
       const now = Date.now();
-      const messageId = seq != null ? `gw-${parsed.threadId}-${seq}` : `gw-${parsed.threadId}-${now}`;
-      try {
+
+      // Check for pending activity message
+      const pendingMsg = db.prepare(`
+        SELECT id, metadata FROM messages
+        WHERE thread_id = ? AND role = 'assistant'
+        AND json_extract(metadata, '$.pending') = 1
+        ORDER BY timestamp DESC LIMIT 1
+      `).get(parsed.threadId);
+
+      let messageId;
+
+      if (pendingMsg) {
+        // Merge final content into existing activity row
+        const metadata = pendingMsg.metadata ? JSON.parse(pendingMsg.metadata) : {};
+        delete metadata.pending;
+        if (metadata.activityLog) {
+          const lastAssistantIdx = metadata.activityLog.findLastIndex(s => s.type === 'assistant');
+          if (lastAssistantIdx >= 0) metadata.activityLog.splice(lastAssistantIdx, 1);
+          metadata.activitySummary = this.generateActivitySummary(metadata.activityLog);
+        }
+        db.prepare('UPDATE messages SET content = ?, metadata = ?, timestamp = ? WHERE id = ?')
+          .run(content, JSON.stringify(metadata), now, pendingMsg.id);
+        messageId = pendingMsg.id;
+      } else {
+        // No pending activity — normal INSERT (simple responses, no tools)
+        messageId = seq != null ? `gw-${parsed.threadId}-${seq}` : `gw-${parsed.threadId}-${now}`;
         db.prepare(`INSERT INTO messages (id, thread_id, role, content, status, timestamp, created_at) VALUES (?, ?, 'assistant', ?, 'sent', ?, ?) ON CONFLICT(id) DO UPDATE SET content = excluded.content, timestamp = excluded.timestamp`).run(messageId, parsed.threadId, content, now, now);
+      }
+
+      try {
         db.prepare('UPDATE threads SET updated_at = ? WHERE id = ?').run(now, parsed.threadId);
-        // Always mark as unread — browser sends read receipts to clear
         db.prepare('INSERT OR IGNORE INTO unread_messages (thread_id, message_id, created_at) VALUES (?, ?, ?)').run(parsed.threadId, messageId, now);
         syncThreadUnreadCount(db, parsed.threadId);
         const threadInfo = db.prepare('SELECT title FROM threads WHERE id = ?').get(parsed.threadId);
@@ -3682,7 +3622,7 @@ export function createApp(config = {}) {
         this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'message-saved', threadId: parsed.threadId, workspace: parsed.workspace, messageId, timestamp: now, title: threadInfo?.title || 'Chat', preview, unreadCount }));
         const workspaceUnreadTotal = db.prepare('SELECT COALESCE(SUM(unread_count), 0) as total FROM threads').get().total;
         this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'unread-update', workspace: parsed.workspace, threadId: parsed.threadId, messageId, action: 'new', unreadCount, workspaceUnreadTotal, title: threadInfo?.title || 'Chat', preview, timestamp: now }));
-        console.log(`Saved assistant message to ${parsed.workspace}/${parsed.threadId} (seq: ${seq})`);
+        console.log(`Saved assistant message to ${parsed.workspace}/${parsed.threadId} (${pendingMsg ? 'merged into pending' : 'seq: ' + seq})`);
       } catch (e) { console.error(`Failed to save assistant message:`, e.message); }
     }
 
@@ -3726,14 +3666,15 @@ export function createApp(config = {}) {
         let thinkingStep = log.steps.find(s => s.type === 'thinking');
         if (thinkingStep) { thinkingStep.text = thinkingText; }
         else { log.steps.push({ type: 'thinking', timestamp: Date.now(), text: thinkingText }); }
+        this._writeActivityToDb(runId, log);
         const now = Date.now();
         if (!log._lastThinkingBroadcast || now - log._lastThinkingBroadcast >= 300) {
           log._lastThinkingBroadcast = now;
-          this.broadcastActivityUpdate(runId, log);
+          this._broadcastActivityUpdate(runId, log);
         }
       }
       if (stream === 'tool') {
-        if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) { log._currentAssistantSegment._sealed = true; this.broadcastActivityUpdate(runId, log); }
+        if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) { log._currentAssistantSegment._sealed = true; }
         const step = { type: 'tool', timestamp: Date.now(), name: data?.name || 'unknown', phase: data?.phase || 'start', toolCallId: data?.toolCallId, meta: data?.meta, isError: data?.isError || false };
         if (data?.phase === 'result') {
           const existing = log.steps.findLast(s => s.toolCallId === data.toolCallId && (s.phase === 'start' || s.phase === 'running'));
@@ -3743,93 +3684,84 @@ export function createApp(config = {}) {
           const existing = log.steps.findLast(s => s.toolCallId === data.toolCallId);
           if (existing) { if (data?.meta) existing.resultMeta = data.meta; if (data?.isError) existing.isError = true; existing.phase = 'running'; }
         } else { log.steps.push(step); }
-        this.broadcastActivityUpdate(runId, log);
+        this._writeActivityToDb(runId, log);
+        this._broadcastActivityUpdate(runId, log);
       }
       if (stream === 'lifecycle') {
         if (data?.phase === 'end' || data?.phase === 'error') {
           if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) log._currentAssistantSegment._sealed = true;
           const lastAssistantIdx = log.steps.findLastIndex(s => s.type === 'assistant');
           if (lastAssistantIdx >= 0) log.steps.splice(lastAssistantIdx, 1);
-          log.steps.push({ type: 'lifecycle', timestamp: Date.now(), phase: data.phase });
-          this.finalizeActivityLog(runId, log);
+          this._writeActivityToDb(runId, log);
+          this.activityLogs.delete(runId);
+          return;
         }
       }
     }
 
-    broadcastActivityUpdate(runId, log) {
-      const parsed = log.sessionKey ? parseSessionKey(log.sessionKey) : null;
+    _writeActivityToDb(runId, log) {
+      if (!log._parsed) {
+        log._parsed = parseSessionKey(log.sessionKey);
+      }
+      const parsed = log._parsed;
       if (!parsed) return;
-      this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'agent-activity', workspace: parsed.workspace, threadId: parsed.threadId, runId, steps: log.steps, summary: this.generateActivitySummary(log.steps) }));
-    }
 
-    finalizeActivityLog(runId, log) {
-      const parsed = log.sessionKey ? parseSessionKey(log.sessionKey) : null;
-      if (!parsed) return;
       const db = _getDb(parsed.workspace);
       if (!db) return;
-      const hasToolSteps = log.steps.some(s => s.type === 'tool');
-      if (!hasToolSteps && this.ws && this.ws.readyState === 1) { this.fetchToolCallsFromHistory(log.sessionKey, parsed, db, log, runId); return; }
-      this.saveActivityToMessage(parsed, db, log, runId);
-    }
-
-    fetchToolCallsFromHistory(sessionKey, parsed, db, log, runId) {
-      const reqId = `activity-hist-${runId}`;
-      const timeout = setTimeout(() => { this._pendingActivityCallbacks?.delete(reqId); this.saveActivityToMessage(parsed, db, log, runId); }, 5000);
-      if (!this._pendingActivityCallbacks) this._pendingActivityCallbacks = new Map();
-      this._pendingActivityCallbacks.set(reqId, (payload) => {
-        clearTimeout(timeout);
-        if (payload?.messages) {
-          for (let i = payload.messages.length - 1; i >= 0; i--) {
-            const m = payload.messages[i];
-            if (m.role === 'assistant' && Array.isArray(m.content)) {
-              let hasToolUse = false;
-              for (const block of m.content) {
-                if (block.type === 'text' && block.text?.trim()) log.steps.push({ type: 'assistant', timestamp: Date.now(), text: block.text.trim() });
-                if (block.type === 'tool_use') { hasToolUse = true; log.steps.push({ type: 'tool', timestamp: Date.now(), name: block.name || 'unknown', phase: 'done', toolCallId: block.id, meta: this.extractToolMeta(block), isError: false }); }
-              }
-              if (hasToolUse) { const lastAssistantIdx = log.steps.findLastIndex(s => s.type === 'assistant'); if (lastAssistantIdx >= 0) log.steps.splice(lastAssistantIdx, 1); }
-              else log.steps = log.steps.filter(s => s.type !== 'assistant');
-              break;
-            }
-          }
-        }
-        this.saveActivityToMessage(parsed, db, log, runId);
-        this.broadcastActivityUpdate(runId, log);
-      });
-      this.ws.send(JSON.stringify({ type: 'req', id: reqId, method: 'sessions.history', params: { key: sessionKey, limit: 3, includeTools: true } }));
-    }
 
-    extractToolMeta(toolUseBlock) {
-      if (!toolUseBlock.input) return '';
-      const input = toolUseBlock.input;
-      if (input.query) return input.query;
-      if (input.command) return input.command.substring(0, 80);
-      if (input.file_path || input.path) return input.file_path || input.path;
-      if (input.url) return input.url;
-      if (input.text) return input.text.substring(0, 60);
-      return '';
+      const cleanSteps = log.steps.map(s => { const c = {...s}; delete c._sealed; return c; });
+      const summary = this.generateActivitySummary(log.steps);
+      const now = Date.now();
+
+      if (!log._messageId) {
+        const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(parsed.threadId);
+        if (!thread) return;
+
+        const messageId = `gw-activity-${runId}`;
+        const metadata = { activityLog: cleanSteps, activitySummary: summary, pending: true };
+
+        db.prepare(`
+          INSERT INTO messages (id, thread_id, role, content, status, metadata, timestamp, created_at)
+          VALUES (?, ?, 'assistant', '', 'sent', ?, ?, ?)
+        `).run(messageId, parsed.threadId, JSON.stringify(metadata), now, now);
+
+        log._messageId = messageId;
+
+        this.broadcastToBrowsers(JSON.stringify({
+          type: 'clawchats',
+          event: 'message-saved',
+          threadId: parsed.threadId,
+          workspace: parsed.workspace,
+          messageId,
+          timestamp: now
+        }));
+      } else {
+        const existing = db.prepare('SELECT metadata FROM messages WHERE id = ?').get(log._messageId);
+        const metadata = existing?.metadata ? JSON.parse(existing.metadata) : {};
+        metadata.activityLog = cleanSteps;
+        metadata.activitySummary = summary;
+        metadata.pending = true;
+
+        db.prepare('UPDATE messages SET metadata = ? WHERE id = ?')
+          .run(JSON.stringify(metadata), log._messageId);
+      }
     }
 
-    saveActivityToMessage(parsed, db, log, runId) {
-      setTimeout(() => {
-        try {
-          const msg = db.prepare('SELECT id, metadata FROM messages WHERE thread_id = ? AND role = ? ORDER BY timestamp DESC LIMIT 1').get(parsed.threadId, 'assistant');
-          if (msg) {
-            const toolSteps = log.steps.filter(s => s.type === 'tool' && s.phase !== 'update');
-            const thinkingSteps = log.steps.filter(s => s.type === 'thinking');
-            const narrativeSteps = log.steps.filter(s => s.type === 'assistant' && s.text?.trim());
-            if (toolSteps.length > 0 || thinkingSteps.length > 0 || narrativeSteps.length > 0) {
-              const metadata = msg.metadata ? JSON.parse(msg.metadata) : {};
-              metadata.activityLog = log.steps.map(s => { const clean = { ...s }; delete clean._sealed; return clean; });
-              metadata.activitySummary = this.generateActivitySummary(log.steps);
-              db.prepare('UPDATE messages SET metadata = ? WHERE id = ?').run(JSON.stringify(metadata), msg.id);
-              console.log(`[ActivityLog] Saved ${toolSteps.length} tool steps for message ${msg.id}`);
-              this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'activity-saved', workspace: parsed.workspace, threadId: parsed.threadId, messageId: msg.id }));
-            }
-          }
-        } catch (e) { console.error('Failed to save activity log:', e.message); }
-        this.activityLogs.delete(runId);
-      }, 1000);
+    _broadcastActivityUpdate(runId, log) {
+      const parsed = log._parsed;
+      if (!parsed || !log._messageId) return;
+
+      const cleanSteps = log.steps.map(s => { const c = {...s}; delete c._sealed; return c; });
+
+      this.broadcastToBrowsers(JSON.stringify({
+        type: 'clawchats',
+        event: 'activity-updated',
+        workspace: parsed.workspace,
+        threadId: parsed.threadId,
+        messageId: log._messageId,
+        activityLog: cleanSteps,
+        activitySummary: this.generateActivitySummary(log.steps)
+      }));
     }
 
     generateActivitySummary(steps) {