@clawchatsai/connector 0.0.28 → 0.0.29

package/package.json

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

package/server.js

@@ -368,6 +368,13 @@ function migrate(db) {
   `);
   db.exec('CREATE INDEX IF NOT EXISTS idx_unread_thread ON unread_messages(thread_id)');
 
+  // Migration: add type column for segment model (text/tool/thinking)
+  try {
+    db.exec("ALTER TABLE messages ADD COLUMN type TEXT DEFAULT 'text'");
+  } catch (e) {
+    // Column already exists — ignore
+  }
+
   // FTS5 table — CREATE VIRTUAL TABLE doesn't support IF NOT EXISTS in all versions,
   // so check if it exists first
   const hasFts = db.prepare(
@@ -832,12 +839,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);
   }
 
@@ -2224,14 +2233,14 @@ class GatewayClient {
     this.maxReconnectDelay = 30000;
     this.browserClients = new Map(); // Map<WebSocket, { activeWorkspace, activeThreadId }>
     this.streamState = new Map(); // Map<sessionKey, { state, buffer, threadId }>
-    this.activityLogs = new Map(); // Map<runId, { sessionKey, steps, startTime }>
+    this.runState = new Map(); // Map<runId, { sessionKey, seqCounter, currentTextSegmentId, startTime }>
 
-    // Clean up stale activity logs every 5 minutes (runs that never completed)
+    // Clean up stale run states every 5 minutes (runs that never completed)
     setInterval(() => {
       const cutoff = Date.now() - 10 * 60 * 1000; // 10 minutes
-      for (const [runId, log] of this.activityLogs) {
-        if (log.startTime < cutoff) {
-          this.activityLogs.delete(runId);
+      for (const [runId, run] of this.runState) {
+        if (run.startTime < cutoff) {
+          this.runState.delete(runId);
         }
       }
     }, 5 * 60 * 1000);
@@ -2311,17 +2320,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);
 
@@ -2356,9 +2354,10 @@ class GatewayClient {
       this.streamState.delete(sessionKey);
     }
 
-    // Save assistant messages on final
+    // Save assistant messages on final (use segment seq position if available)
     if (state === 'final') {
-      this.saveAssistantMessage(sessionKey, message, seq);
+      const run = this.findRunBySessionKey(sessionKey);
+      this.saveAssistantMessage(sessionKey, message, seq, run?.finalSeq);
     }
 
     // Save error markers
@@ -2367,7 +2366,7 @@ class GatewayClient {
     }
   }
 
-  saveAssistantMessage(sessionKey, message, seq) {
+  saveAssistantMessage(sessionKey, message, seq, segmentSeq) {
     const parsed = parseSessionKey(sessionKey);
     if (!parsed) return; // Non-ClawChats session key, silently ignore
 
@@ -2400,13 +2399,16 @@ class GatewayClient {
     const now = Date.now();
     const messageId = seq != null ? `gw-${parsed.threadId}-${seq}` : `gw-${parsed.threadId}-${now}`;
 
+    // Use segment seq for correct ordering after tool segments
+    const msgSeq = segmentSeq != null ? segmentSeq : (seq != null ? seq : null);
+
     // Upsert message: INSERT OR REPLACE (same seq → same messageId → update content)
     try {
       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);
+        INSERT INTO messages (id, thread_id, role, type, content, status, seq, timestamp, created_at)
+        VALUES (?, ?, 'assistant', 'text', ?, 'sent', ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET content = excluded.content, seq = excluded.seq, timestamp = excluded.timestamp
+      `).run(messageId, parsed.threadId, content, msgSeq, now, now);
 
       // Update thread updated_at
       db.prepare('UPDATE threads SET updated_at = ? WHERE id = ?').run(now, parsed.threadId);
@@ -2488,295 +2490,245 @@ class GatewayClient {
     const { runId, stream, data, sessionKey } = payload;
     if (!runId) return;
 
-    // Initialize log if needed
-    if (!this.activityLogs.has(runId)) {
-      this.activityLogs.set(runId, { sessionKey, steps: [], startTime: Date.now() });
+    // Initialize run state if needed
+    if (!this.runState.has(runId)) {
+      this.runState.set(runId, { sessionKey, seqCounter: 0, startTime: Date.now() });
     }
-    const log = this.activityLogs.get(runId);
+    const run = this.runState.get(runId);
+
+    const parsed = parseSessionKey(sessionKey);
+    if (!parsed) return;
+
+    // Verify workspace/thread still exist
+    const ws = getWorkspaces();
+    if (!ws.workspaces[parsed.workspace]) return;
+    const db = getDb(parsed.workspace);
+    const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(parsed.threadId);
+    if (!thread) return;
 
     if (stream === 'assistant') {
-      // 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 = {
-            type: 'assistant',
-            timestamp: Date.now(),
-            text: text,
-            _sealed: false
-          };
-          log._currentAssistantSegment = currentSegment;
-          log.steps.push(currentSegment);
-        } else {
-          currentSegment.text = text;
-        }
+      if (!text) return;
+
+      if (!run.currentTextSegmentId) {
+        // Start a new text segment — broadcast only, saved when sealed or discarded on lifecycle.end
+        run.seqCounter++;
+        run.currentTextSegmentId = `seg-${parsed.threadId}-${runId}-${run.seqCounter}`;
+        run.currentTextContent = text;
+        run.currentTextSeq = run.seqCounter;
+        run.currentTextTimestamp = Date.now();
+      } else {
+        // Accumulate text for this segment
+        run.currentTextContent = text;
+      }
+
+      // Broadcast segment update for live display (throttled ~150ms)
+      const now = Date.now();
+      if (!run.lastTextBroadcast || now - run.lastTextBroadcast >= 150) {
+        run.lastTextBroadcast = now;
+        this.broadcastSegmentUpdate(parsed, runId, {
+          id: run.currentTextSegmentId,
+          type: 'text',
+          seq: run.currentTextSeq,
+          content: run.currentTextContent
+        });
       }
-      // 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;
+
+      if (!run.thinkingSegmentId) {
+        run.seqCounter++;
+        const segId = `seg-${parsed.threadId}-${runId}-${run.seqCounter}`;
+        run.thinkingSegmentId = segId;
+        run.thinkingSeq = run.seqCounter;
+        const now = Date.now();
+        try {
+          db.prepare(`
+            INSERT INTO messages (id, thread_id, role, type, content, status, seq, timestamp, created_at)
+            VALUES (?, ?, 'assistant', 'thinking', ?, 'sent', ?, ?, ?)
+          `).run(segId, parsed.threadId, thinkingText, run.seqCounter, now, now);
+        } catch (e) {
+          console.error('Failed to save thinking segment:', e.message);
+        }
       } else {
-        log.steps.push({
-          type: 'thinking',
-          timestamp: Date.now(),
-          text: thinkingText
-        });
+        try {
+          db.prepare('UPDATE messages SET content = ? WHERE id = ?').run(thinkingText, run.thinkingSegmentId);
+        } catch (e) {
+          console.error('Failed to update thinking segment:', e.message);
+        }
       }
-      // Broadcast to browser for live display (throttled — thinking events come fast)
+
+      // Broadcast (throttled ~300ms)
       const now = Date.now();
-      if (!log._lastThinkingBroadcast || now - log._lastThinkingBroadcast >= 300) {
-        log._lastThinkingBroadcast = now;
-        this.broadcastActivityUpdate(runId, log);
+      if (!run.lastThinkingBroadcast || now - run.lastThinkingBroadcast >= 300) {
+        run.lastThinkingBroadcast = now;
+        this.broadcastSegmentUpdate(parsed, runId, {
+          id: run.thinkingSegmentId,
+          type: 'thinking',
+          seq: run.thinkingSeq,
+          content: thinkingText
+        });
       }
+      return;
     }
 
     if (stream === 'tool') {
-      // 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);
+      // Seal and save any current text segment (intermediate narration before this tool call)
+      if (run.currentTextSegmentId && run.currentTextContent?.trim()) {
+        const segId = run.currentTextSegmentId;
+        const content = run.currentTextContent;
+        const seq = run.currentTextSeq;
+        const ts = run.currentTextTimestamp || Date.now();
+        try {
+          db.prepare(`
+            INSERT OR REPLACE INTO messages (id, thread_id, role, type, content, status, seq, timestamp, created_at)
+            VALUES (?, ?, 'assistant', 'text', ?, 'sent', ?, ?, ?)
+          `).run(segId, parsed.threadId, content, seq, ts, ts);
+        } catch (e) {
+          console.error('Failed to save sealed text segment:', e.message);
+        }
       }
-
-      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
-      };
-
-      // On result phase, update the existing start step or add new
-      if (data?.phase === 'result') {
-        const existing = log.steps.findLast(s => s.toolCallId === data.toolCallId && (s.phase === 'start' || s.phase === 'running'));
-        if (existing) {
-          existing.phase = 'done';
-          existing.resultMeta = data?.meta;
-          existing.isError = data?.isError || false;
-          existing.durationMs = Date.now() - existing.timestamp;
-        } else {
-          step.phase = 'done';
-          log.steps.push(step);
+      run.currentTextSegmentId = null;
+      run.currentTextContent = null;
+      run.currentTextSeq = null;
+
+      if (!run.toolSegmentMap) run.toolSegmentMap = new Map();
+      if (!run.toolSeqMap) run.toolSeqMap = new Map();
+      if (!run.toolStartTimes) run.toolStartTimes = new Map();
+
+      const toolCallId = data?.toolCallId;
+      const phase = data?.phase || 'start';
+
+      if (phase === 'result') {
+        const existingId = run.toolSegmentMap.get(toolCallId);
+        if (existingId) {
+          const durationMs = run.toolStartTimes.get(toolCallId) ? Date.now() - run.toolStartTimes.get(toolCallId) : null;
+          const metadata = {
+            name: data?.name || 'unknown',
+            status: 'done',
+            meta: data?.meta || '',
+            isError: data?.isError || false,
+            durationMs
+          };
+          try {
+            db.prepare('UPDATE messages SET metadata = ? WHERE id = ?').run(JSON.stringify(metadata), existingId);
+          } catch (e) {
+            console.error('Failed to update tool segment result:', e.message);
+          }
+          this.broadcastSegmentUpdate(parsed, runId, {
+            id: existingId,
+            type: 'tool',
+            seq: run.toolSeqMap.get(toolCallId),
+            metadata
+          });
         }
-      } 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';
+      } else if (phase === 'update') {
+        const existingId = run.toolSegmentMap.get(toolCallId);
+        if (existingId) {
+          const metadata = {
+            name: data?.name || 'unknown',
+            status: 'running',
+            meta: data?.meta || ''
+          };
+          try {
+            db.prepare('UPDATE messages SET metadata = ? WHERE id = ?').run(JSON.stringify(metadata), existingId);
+          } catch (e) {
+            console.error('Failed to update tool segment:', e.message);
+          }
+          this.broadcastSegmentUpdate(parsed, runId, {
+            id: existingId,
+            type: 'tool',
+            seq: run.toolSeqMap.get(toolCallId),
+            metadata
+          });
         }
-        // If no existing step found, silently ignore the orphaned update
       } else {
-        log.steps.push(step);
+        // phase === 'start': insert new tool segment
+        run.seqCounter++;
+        const segId = `seg-${parsed.threadId}-${runId}-${run.seqCounter}`;
+        const now = Date.now();
+        const metadata = {
+          name: data?.name || 'unknown',
+          status: 'running',
+          meta: data?.meta || ''
+        };
+        try {
+          db.prepare(`
+            INSERT INTO messages (id, thread_id, role, type, content, status, metadata, seq, timestamp, created_at)
+            VALUES (?, ?, 'assistant', 'tool', '', 'sent', ?, ?, ?, ?)
+          `).run(segId, parsed.threadId, JSON.stringify(metadata), run.seqCounter, now, now);
+        } catch (e) {
+          console.error('Failed to save tool segment:', e.message);
+        }
+        run.toolSegmentMap.set(toolCallId, segId);
+        run.toolSeqMap.set(toolCallId, run.seqCounter);
+        run.toolStartTimes.set(toolCallId, now);
+        this.broadcastSegmentUpdate(parsed, runId, {
+          id: segId,
+          type: 'tool',
+          seq: run.seqCounter,
+          metadata
+        });
       }
-
-      // Forward to browser for real-time display
-      this.broadcastActivityUpdate(runId, log);
+      return;
     }
 
     if (stream === 'lifecycle') {
       if (data?.phase === 'end' || data?.phase === 'error') {
-        // Seal any remaining assistant segment
-        if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) {
-          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);
+        // Broadcast final text content one last time for live display
+        // Do NOT save to DB — handleChatEvent.final saves the authoritative final text
+        if (run.currentTextSegmentId) {
+          this.broadcastSegmentUpdate(parsed, runId, {
+            id: run.currentTextSegmentId,
+            type: 'text',
+            seq: run.currentTextSeq,
+            content: run.currentTextContent || ''
+          });
+          // Store seq for handleChatEvent.final to position final message correctly
+          run.finalSeq = run.currentTextSeq;
+          run.currentTextSegmentId = null;
+          run.currentTextContent = null;
+        } else {
+          // No active text segment — final seq is next position
+          run.finalSeq = run.seqCounter + 1;
         }
 
-        log.steps.push({ type: 'lifecycle', timestamp: Date.now(), phase: data.phase });
+        // Broadcast segments-complete
+        this.broadcastToBrowsers(JSON.stringify({
+          type: 'clawchats',
+          event: 'segments-complete',
+          workspace: parsed.workspace,
+          threadId: parsed.threadId,
+          runId
+        }));
 
-        // Finalize: save to message metadata
-        this.finalizeActivityLog(runId, log);
+        // Keep run state briefly for handleChatEvent.final to read finalSeq
+        setTimeout(() => this.runState.delete(runId), 30000);
       }
     }
   }
 
-  broadcastActivityUpdate(runId, log) {
-    const parsed = log.sessionKey ? parseSessionKey(log.sessionKey) : null;
-    if (!parsed) return;
+  findRunBySessionKey(sessionKey) {
+    for (const [, run] of this.runState.entries()) {
+      if (run.sessionKey === sessionKey) return run;
+    }
+    return null;
+  }
 
+  broadcastSegmentUpdate(parsed, runId, segment) {
     this.broadcastToBrowsers(JSON.stringify({
       type: 'clawchats',
-      event: 'agent-activity',
+      event: 'segment-update',
       workspace: parsed.workspace,
       threadId: parsed.threadId,
       runId,
-      steps: log.steps,
-      summary: this.generateActivitySummary(log.steps)
+      segment
     }));
   }
 
-  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 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);
-  }
-
-  fetchToolCallsFromHistory(sessionKey, parsed, db, log, runId) {
-    const reqId = `activity-hist-${runId}`;
-
-    const timeout = setTimeout(() => {
-      // Timeout: save what we have (even if empty)
-      this._pendingActivityCallbacks?.delete(reqId);
-      this.saveActivityToMessage(parsed, db, log, runId);
-    }, 5000);
-
-    // Register callback for when the gateway responds
-    if (!this._pendingActivityCallbacks) this._pendingActivityCallbacks = new Map();
-    this._pendingActivityCallbacks.set(reqId, (payload) => {
-      clearTimeout(timeout);
-
-      // 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
-          }
-        }
-      }
-
-      this.saveActivityToMessage(parsed, db, log, runId);
-      this.broadcastActivityUpdate(runId, log);
-    });
-
-    // Request session history from gateway
-    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;
-    // 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 '';
-  }
-
-  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);
-      }
-
-      this.activityLogs.delete(runId);
-    }, 1000); // 1s delay — must happen after message-saved (which fires on chat:final)
-  }
-
   generateActivitySummary(steps) {
     const toolSteps = steps.filter(s => s.type === 'tool' && s.phase !== 'result' && s.phase !== 'update');
     const hasThinking = steps.some(s => s.type === 'thinking' && s.text);
@@ -3596,11 +3548,11 @@ export function createApp(config = {}) {
       this.browserClients = new Map();
       this._externalBroadcastTargets = [];
       this.streamState = new Map();
-      this.activityLogs = new Map();
+      this.runState = new Map(); // Map<runId, { sessionKey, seqCounter, currentTextSegmentId, startTime }>
       setInterval(() => {
         const cutoff = Date.now() - 10 * 60 * 1000;
-        for (const [runId, log] of this.activityLogs) {
-          if (log.startTime < cutoff) this.activityLogs.delete(runId);
+        for (const [runId, run] of this.runState) {
+          if (run.startTime < cutoff) this.runState.delete(runId);
         }
       }, 5 * 60 * 1000);
     }
@@ -3632,11 +3584,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);
@@ -3654,11 +3601,11 @@ export function createApp(config = {}) {
         return;
       }
       if (state === 'final' || state === 'aborted' || state === 'error') this.streamState.delete(sessionKey);
-      if (state === 'final') this.saveAssistantMessage(sessionKey, message, seq);
+      if (state === 'final') { const run = this.findRunBySessionKey(sessionKey); this.saveAssistantMessage(sessionKey, message, seq, run?.finalSeq); }
       if (state === 'error') this.saveErrorMarker(sessionKey, message);
     }
 
-    saveAssistantMessage(sessionKey, message, seq) {
+    saveAssistantMessage(sessionKey, message, seq, segmentSeq) {
       const parsed = parseSessionKey(sessionKey);
       if (!parsed) return;
       const ws = _getWorkspaces();
@@ -3670,8 +3617,9 @@ export function createApp(config = {}) {
       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}`;
+      const msgSeq = segmentSeq != null ? segmentSeq : (seq != null ? seq : null);
       try {
-        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);
+        db.prepare('INSERT INTO messages (id, thread_id, role, type, content, status, seq, timestamp, created_at) VALUES (?, ?, \'assistant\', \'text\', ?, \'sent\', ?, ?, ?) ON CONFLICT(id) DO UPDATE SET content = excluded.content, seq = excluded.seq, timestamp = excluded.timestamp').run(messageId, parsed.threadId, content, msgSeq, now, now);
         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);
@@ -3707,129 +3655,114 @@ export function createApp(config = {}) {
     handleAgentEvent(payload) {
       const { runId, stream, data, sessionKey } = payload;
       if (!runId) return;
-      if (!this.activityLogs.has(runId)) this.activityLogs.set(runId, { sessionKey, steps: [], startTime: Date.now() });
-      const log = this.activityLogs.get(runId);
+      if (!this.runState.has(runId)) this.runState.set(runId, { sessionKey, seqCounter: 0, startTime: Date.now() });
+      const run = this.runState.get(runId);
+      const parsed = parseSessionKey(sessionKey);
+      if (!parsed) return;
+      const wsData = _getWorkspaces();
+      if (!wsData.workspaces[parsed.workspace]) return;
+      const db = _getDb(parsed.workspace);
+      const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(parsed.threadId);
+      if (!thread) return;
+
       if (stream === 'assistant') {
         const text = data?.text || '';
-        if (text) {
-          let currentSegment = log._currentAssistantSegment;
-          if (!currentSegment || currentSegment._sealed) {
-            currentSegment = { type: 'assistant', timestamp: Date.now(), text, _sealed: false };
-            log._currentAssistantSegment = currentSegment;
-            log.steps.push(currentSegment);
-          } else { currentSegment.text = text; }
+        if (!text) return;
+        if (!run.currentTextSegmentId) {
+          run.seqCounter++;
+          run.currentTextSegmentId = `seg-${parsed.threadId}-${runId}-${run.seqCounter}`;
+          run.currentTextContent = text;
+          run.currentTextSeq = run.seqCounter;
+          run.currentTextTimestamp = Date.now();
+        } else { run.currentTextContent = text; }
+        const now = Date.now();
+        if (!run.lastTextBroadcast || now - run.lastTextBroadcast >= 150) {
+          run.lastTextBroadcast = now;
+          this.broadcastSegmentUpdate(parsed, runId, { id: run.currentTextSegmentId, type: 'text', seq: run.currentTextSeq, content: run.currentTextContent });
         }
         return;
       }
+
       if (stream === 'thinking') {
         const thinkingText = data?.text || '';
-        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 }); }
+        if (!run.thinkingSegmentId) {
+          run.seqCounter++;
+          const segId = `seg-${parsed.threadId}-${runId}-${run.seqCounter}`;
+          run.thinkingSegmentId = segId;
+          run.thinkingSeq = run.seqCounter;
+          const now = Date.now();
+          try { db.prepare('INSERT INTO messages (id, thread_id, role, type, content, status, seq, timestamp, created_at) VALUES (?, ?, \'assistant\', \'thinking\', ?, \'sent\', ?, ?, ?)').run(segId, parsed.threadId, thinkingText, run.seqCounter, now, now); } catch (e) { console.error('Failed to save thinking segment:', e.message); }
+        } else {
+          try { db.prepare('UPDATE messages SET content = ? WHERE id = ?').run(thinkingText, run.thinkingSegmentId); } catch (e) { console.error('Failed to update thinking segment:', e.message); }
+        }
         const now = Date.now();
-        if (!log._lastThinkingBroadcast || now - log._lastThinkingBroadcast >= 300) {
-          log._lastThinkingBroadcast = now;
-          this.broadcastActivityUpdate(runId, log);
+        if (!run.lastThinkingBroadcast || now - run.lastThinkingBroadcast >= 300) {
+          run.lastThinkingBroadcast = now;
+          this.broadcastSegmentUpdate(parsed, runId, { id: run.thinkingSegmentId, type: 'thinking', seq: run.thinkingSeq, content: thinkingText });
         }
+        return;
       }
+
       if (stream === 'tool') {
-        if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) { log._currentAssistantSegment._sealed = true; this.broadcastActivityUpdate(runId, log); }
-        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'));
-          if (existing) { existing.phase = 'done'; existing.resultMeta = data?.meta; existing.isError = data?.isError || false; existing.durationMs = Date.now() - existing.timestamp; }
-          else { step.phase = 'done'; log.steps.push(step); }
-        } else if (data?.phase === 'update') {
-          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);
+        if (run.currentTextSegmentId && run.currentTextContent?.trim()) {
+          const { currentTextSegmentId: segId, currentTextContent: content, currentTextSeq: seq, currentTextTimestamp: ts = Date.now() } = run;
+          try { db.prepare('INSERT OR REPLACE INTO messages (id, thread_id, role, type, content, status, seq, timestamp, created_at) VALUES (?, ?, \'assistant\', \'text\', ?, \'sent\', ?, ?, ?)').run(segId, parsed.threadId, content, seq, ts, ts); } catch (e) { console.error('Failed to save sealed text segment:', e.message); }
+        }
+        run.currentTextSegmentId = null; run.currentTextContent = null; run.currentTextSeq = null;
+        if (!run.toolSegmentMap) run.toolSegmentMap = new Map();
+        if (!run.toolSeqMap) run.toolSeqMap = new Map();
+        if (!run.toolStartTimes) run.toolStartTimes = new Map();
+        const toolCallId = data?.toolCallId;
+        const phase = data?.phase || 'start';
+        if (phase === 'result') {
+          const existingId = run.toolSegmentMap.get(toolCallId);
+          if (existingId) {
+            const durationMs = run.toolStartTimes.get(toolCallId) ? Date.now() - run.toolStartTimes.get(toolCallId) : null;
+            const metadata = { name: data?.name || 'unknown', status: 'done', meta: data?.meta || '', isError: data?.isError || false, durationMs };
+            try { db.prepare('UPDATE messages SET metadata = ? WHERE id = ?').run(JSON.stringify(metadata), existingId); } catch (e) { console.error('Failed to update tool segment result:', e.message); }
+            this.broadcastSegmentUpdate(parsed, runId, { id: existingId, type: 'tool', seq: run.toolSeqMap.get(toolCallId), metadata });
+          }
+        } else if (phase === 'update') {
+          const existingId = run.toolSegmentMap.get(toolCallId);
+          if (existingId) {
+            const metadata = { name: data?.name || 'unknown', status: 'running', meta: data?.meta || '' };
+            try { db.prepare('UPDATE messages SET metadata = ? WHERE id = ?').run(JSON.stringify(metadata), existingId); } catch (e) { console.error('Failed to update tool segment:', e.message); }
+            this.broadcastSegmentUpdate(parsed, runId, { id: existingId, type: 'tool', seq: run.toolSeqMap.get(toolCallId), metadata });
+          }
+        } else {
+          run.seqCounter++;
+          const segId = `seg-${parsed.threadId}-${runId}-${run.seqCounter}`;
+          const now = Date.now();
+          const metadata = { name: data?.name || 'unknown', status: 'running', meta: data?.meta || '' };
+          try { db.prepare('INSERT INTO messages (id, thread_id, role, type, content, status, metadata, seq, timestamp, created_at) VALUES (?, ?, \'assistant\', \'tool\', \'\', \'sent\', ?, ?, ?, ?)').run(segId, parsed.threadId, JSON.stringify(metadata), run.seqCounter, now, now); } catch (e) { console.error('Failed to save tool segment:', e.message); }
+          run.toolSegmentMap.set(toolCallId, segId); run.toolSeqMap.set(toolCallId, run.seqCounter); run.toolStartTimes.set(toolCallId, now);
+          this.broadcastSegmentUpdate(parsed, runId, { id: segId, type: 'tool', seq: run.seqCounter, metadata });
+        }
+        return;
       }
+
       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);
+          if (run.currentTextSegmentId) {
+            this.broadcastSegmentUpdate(parsed, runId, { id: run.currentTextSegmentId, type: 'text', seq: run.currentTextSeq, content: run.currentTextContent || '' });
+            run.finalSeq = run.currentTextSeq;
+            run.currentTextSegmentId = null; run.currentTextContent = null;
+          } else { run.finalSeq = run.seqCounter + 1; }
+          this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'segments-complete', workspace: parsed.workspace, threadId: parsed.threadId, runId }));
+          setTimeout(() => this.runState.delete(runId), 30000);
         }
       }
     }
 
-    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;
-      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 '';
+    findRunBySessionKey(sessionKey) {
+      for (const [, run] of this.runState.entries()) {
+        if (run.sessionKey === sessionKey) return run;
+      }
+      return null;
     }
 
-    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);
+    broadcastSegmentUpdate(parsed, runId, segment) {
+      this.broadcastToBrowsers(JSON.stringify({ type: 'clawchats', event: 'segment-update', workspace: parsed.workspace, threadId: parsed.threadId, runId, segment }));
     }
 
     generateActivitySummary(steps) {