@swarmclawai/swarmclaw 1.2.0 → 1.2.2

package/src/app/api/system/status/route.ts

@@ -0,0 +1,11 @@
+import { NextResponse } from 'next/server'
+import { getDaemonHealthSummary } from '@/lib/server/runtime/daemon-state'
+import packageJson from '../../../../../package.json'
+
+export async function GET() {
+  const summary = getDaemonHealthSummary()
+  return NextResponse.json({
+    ...summary,
+    version: packageJson.version,
+  })
+}

package/src/app/api/upload/route.ts

@@ -3,6 +3,9 @@ import fs from 'fs'
 import path from 'path'
 import { genId } from '@/lib/id'
 import { UPLOAD_DIR } from '@/lib/server/storage'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'api-upload'
 
 export async function POST(req: Request) {
   const filename = req.headers.get('x-filename') || 'image.png'
@@ -12,7 +15,7 @@ export async function POST(req: Request) {
 
   if (!fs.existsSync(UPLOAD_DIR)) fs.mkdirSync(UPLOAD_DIR, { recursive: true })
   fs.writeFileSync(filePath, buf)
-  console.log(`[upload] saved ${buf.length} bytes to ${filePath}`)
+  log.info(TAG, `saved ${buf.length} bytes to ${filePath}`)
 
   return NextResponse.json({ path: filePath, size: buf.length, url: `/api/uploads/${name}` })
 }

package/src/cli/index.js

@@ -730,6 +730,13 @@ const COMMAND_GROUPS = [
       cmd('delete-many', 'DELETE', '/uploads', 'Delete uploads by filter/body (filenames, olderThanDays, category, or all)', { expectsJsonBody: true }),
     ],
   },
+  {
+    name: 'system-status',
+    description: 'Lightweight system health summary',
+    commands: [
+      cmd('get', 'GET', '/system/status', 'Get system health summary (safe for external monitors)'),
+    ],
+  },
   {
     name: 'usage',
     description: 'Usage and cost summary',

package/src/cli/spec.js

@@ -496,6 +496,7 @@ const COMMAND_GROUPS = {
     description: 'System and version endpoints',
     commands: {
       ip: { description: 'Get local bind IP/port', method: 'GET', path: '/ip' },
+      status: { description: 'Get lightweight system health summary (safe for external monitors)', method: 'GET', path: '/system/status' },
       usage: { description: 'Get usage summary', method: 'GET', path: '/usage' },
       version: { description: 'Get local/remote git version info', method: 'GET', path: '/version' },
       update: { description: 'Update to latest stable release tag (fallback: main)', method: 'POST', path: '/version/update' },

package/src/components/agents/agent-files-editor.tsx

@@ -1,6 +1,6 @@
 'use client'
 
-import { useCallback, useEffect, useState } from 'react'
+import { useEffect, useState } from 'react'
 import { api } from '@/lib/app/api-client'
 import { errorMessage } from '@/lib/shared-utils'
 import { PersonalityBuilder } from './personality-builder'
@@ -8,6 +8,14 @@ import { PersonalityBuilder } from './personality-builder'
 const FILES = ['SOUL.md', 'IDENTITY.md', 'USER.md', 'TOOLS.md', 'HEARTBEAT.md', 'MEMORY.md', 'AGENTS.md'] as const
 const GUIDED_FILES = new Set(['SOUL.md', 'IDENTITY.md', 'USER.md'])
 
+function makeInitialFiles(): Record<string, FileState> {
+  const initial: Record<string, FileState> = {}
+  for (const f of FILES) {
+    initial[f] = { content: '', original: '', loading: true, saving: false }
+  }
+  return initial
+}
+
 interface FileState {
   content: string
   original: string
@@ -22,45 +30,49 @@ interface Props {
 
 export function AgentFilesEditor({ agentId }: Props) {
   const [activeTab, setActiveTab] = useState<string>(FILES[0])
-  const [files, setFiles] = useState<Record<string, FileState>>({})
+  const [files, setFiles] = useState<Record<string, FileState>>(makeInitialFiles)
   const [guidedMode, setGuidedMode] = useState(false)
 
-  const loadFiles = useCallback(async () => {
-    const initial: Record<string, FileState> = {}
-    for (const f of FILES) {
-      initial[f] = { content: '', original: '', loading: true, saving: false }
-    }
-    setFiles(initial)
+  // Reset to loading state when agentId changes
+  const [prevAgentId, setPrevAgentId] = useState(agentId)
+  if (agentId !== prevAgentId) {
+    setPrevAgentId(agentId)
+    setFiles(makeInitialFiles())
+  }
 
-    try {
-      const result = await api<Record<string, { content: string; error?: string }>>('GET', `/openclaw/agent-files?agentId=${agentId}`)
-      setFiles((prev) => {
-        const next = { ...prev }
-        for (const [name, data] of Object.entries(result)) {
-          next[name] = {
-            content: data.content,
-            original: data.content,
-            loading: false,
-            saving: false,
-            error: data.error,
+  useEffect(() => {
+    let cancelled = false
+    api<Record<string, { content: string; error?: string }>>('GET', `/openclaw/agent-files?agentId=${agentId}`)
+      .then((result) => {
+        if (cancelled) return
+        setFiles((prev) => {
+          const next = { ...prev }
+          for (const [name, data] of Object.entries(result)) {
+            next[name] = {
+              content: data.content,
+              original: data.content,
+              loading: false,
+              saving: false,
+              error: data.error,
+            }
           }
-        }
-        return next
+          return next
+        })
       })
-    } catch (err: unknown) {
-      const message = errorMessage(err)
-      setFiles((prev) => {
-        const next = { ...prev }
-        for (const f of FILES) {
-          next[f] = { ...next[f], loading: false, error: message }
-        }
-        return next
+      .catch((err: unknown) => {
+        if (cancelled) return
+        const message = errorMessage(err)
+        setFiles((prev) => {
+          const next = { ...prev }
+          for (const f of FILES) {
+            next[f] = { ...next[f], loading: false, error: message }
+          }
+          return next
+        })
       })
-    }
+    return () => { cancelled = true }
   }, [agentId])
 
-  useEffect(() => { loadFiles() }, [loadFiles])
-
   const handleContentChange = (filename: string, content: string) => {
     setFiles((prev) => ({
       ...prev,

package/src/components/agents/personality-builder.tsx

@@ -1,8 +1,7 @@
 'use client'
 
-import { useEffect, useMemo, useState } from 'react'
+import { useMemo, useState } from 'react'
 import type { PersonalityDraft } from '@/types'
-import { api } from '@/lib/app/api-client'
 import {
   parseIdentityMd, serializeIdentityMd,
   parseUserMd, serializeUserMd,
@@ -19,12 +18,12 @@ interface Props {
 const inputClass = 'w-full px-3 py-2 rounded-[10px] border border-white/[0.06] bg-black/20 text-[13px] text-text outline-none placeholder:text-text-3/40 focus:border-white/[0.12] transition-colors'
 const labelClass = 'block text-[11px] font-600 uppercase tracking-wider text-text-3/50 mb-1'
 
-export function PersonalityBuilder({ agentId: _agentId, fileType, content, onSave }: Props) {
+export function PersonalityBuilder({ fileType, content, onSave }: Props) {
   const [draft, setDraft] = useState<Record<string, string>>({})
   const [initialDraft, setInitialDraft] = useState<Record<string, string>>({})
   const [saveState, setSaveState] = useState<'idle' | 'saved'>('idle')
 
-  useEffect(() => {
+  const parsedContent = useMemo(() => {
     let parsed: Record<string, string> = {}
     if (fileType === 'IDENTITY.md') {
       const p = parseIdentityMd(content)
@@ -36,11 +35,18 @@ export function PersonalityBuilder({ agentId: _agentId, fileType, content, onSav
       const p = parseSoulMd(content)
       parsed = { coreTruths: p.coreTruths || '', boundaries: p.boundaries || '', vibe: p.vibe || '', continuity: p.continuity || '' }
     }
-    setDraft(parsed)
-    setInitialDraft(parsed)
-    setSaveState('idle')
+    return parsed
   }, [content, fileType])
 
+  // Reset form when content/fileType changes (render-time state adjustment)
+  const [syncKey, setSyncKey] = useState({ content, fileType })
+  if (content !== syncKey.content || fileType !== syncKey.fileType) {
+    setSyncKey({ content, fileType })
+    setDraft(parsedContent)
+    setInitialDraft(parsedContent)
+    setSaveState('idle')
+  }
+
   const isDirty = useMemo(() => {
     return Object.keys(draft).some((k) => draft[k] !== (initialDraft[k] ?? ''))
   }, [draft, initialDraft])

package/src/components/agents/trash-list.tsx

@@ -12,7 +12,7 @@ export function TrashList() {
   const loadAgents = useAppStore((s) => s.loadAgents)
   const [confirmPermanent, setConfirmPermanent] = useState<Agent | null>(null)
 
-  useEffect(() => { loadTrashedAgents() }, [])  
+  useEffect(() => { loadTrashedAgents() }, [loadTrashedAgents])
 
   const handleRestore = async (id: string) => {
     await api('POST', '/agents/trash', { id })

package/src/components/chat/chat-area.tsx

@@ -27,6 +27,7 @@ import { ConfirmDialog } from '@/components/shared/confirm-dialog'
 import { speak } from '@/lib/tts'
 import { api } from '@/lib/app/api-client'
 import { messagesDiffer } from '@/lib/chat/chat-streaming-state'
+import { createAssistantRenderId } from '@/lib/chat/assistant-render-id'
 import { getSessionLastMessage } from '@/lib/chat/session-summary'
 import { getEnabledCapabilityIds, getEnabledToolIds } from '@/lib/capability-selection'
 
@@ -71,6 +72,36 @@ export function ChatArea() {
   const setPreviewContent = useChatStore((s) => s.setPreviewContent)
   const isDesktop = useMediaQuery('(min-width: 768px)')
 
+  const markSessionLocallyIdle = useCallback((targetSessionId: string) => {
+    const appState = useAppStore.getState()
+    const existing = appState.sessions[targetSessionId]
+    if (!existing) return
+    appState.updateSessionInStore({
+      ...existing,
+      active: false,
+      currentRunId: null,
+    })
+  }, [])
+
+  const startServerStreamingPlaceholder = useCallback((targetSessionId: string, phase: 'queued' | 'thinking' | 'connecting' = 'thinking') => {
+    useChatStore.setState((state) => {
+      const sameServerStream = state.streaming
+        && state.streamSource === 'server'
+        && state.streamingSessionId === targetSessionId
+
+      return {
+        streaming: true,
+        streamingSessionId: targetSessionId,
+        streamSource: 'server',
+        streamPhase: sameServerStream ? state.streamPhase : phase,
+        streamText: '',
+        displayText: '',
+        assistantRenderId: sameServerStream && state.assistantRenderId ? state.assistantRenderId : createAssistantRenderId(),
+        thinkingStartTime: sameServerStream && state.thinkingStartTime > 0 ? state.thinkingStartTime : Date.now(),
+      }
+    })
+  }, [])
+
   const currentAgent = useAppStore((s) => {
     const agentId = session?.agentId
     return agentId ? s.agents[agentId] ?? null : null
@@ -178,14 +209,12 @@ export function ChatArea() {
     })
 
     const sessionAtLoad = useAppStore.getState().sessions[requestedSessionId]
-    if (sessionAtLoad?.active) {
-      useChatStore.setState({ streaming: true, streamingSessionId: requestedSessionId, streamSource: 'server', streamText: '' })
-    }
+    if (sessionAtLoad?.active) startServerStreamingPlaceholder(requestedSessionId)
 
     return () => {
       cancelled = true
     }
-  }, [loadQueuedMessages, refreshSession, sessionId, setDevServer, setMessages])
+  }, [loadQueuedMessages, refreshSession, sessionId, setDevServer, setMessages, startServerStreamingPlaceholder])
 
   useEffect(() => {
     if (!sessionId || messagesLoading) return
@@ -195,9 +224,7 @@ export function ChatArea() {
       void refreshSession(requestedSessionId).then(() => {
         if (cancelled || selectActiveSessionId(useAppStore.getState()) !== requestedSessionId) return
         const refreshed = useAppStore.getState().sessions[requestedSessionId]
-        if (refreshed?.active) {
-          useChatStore.setState({ streaming: true, streamingSessionId: requestedSessionId, streamSource: 'server', streamText: '' })
-        }
+        if (refreshed?.active) startServerStreamingPlaceholder(requestedSessionId)
       }).catch((err) => console.error('Failed to refresh session:', err))
 
       void devServer(requestedSessionId, 'status').then((r) => {
@@ -213,7 +240,7 @@ export function ChatArea() {
       cancelled = true
       window.clearTimeout(timer)
     }
-  }, [messagesLoading, refreshSession, sessionId, setDevServer])
+  }, [messagesLoading, refreshSession, sessionId, setDevServer, startServerStreamingPlaceholder])
 
   useEffect(() => {
     if (!sessionId || messagesLoading) return
@@ -292,19 +319,12 @@ export function ChatArea() {
         && !chatState.streaming
         && chatState.streamingSessionId !== sessionId
       ) {
-        useChatStore.setState({
-          streaming: true,
-          streamingSessionId: sessionId,
-          streamSource: 'server',
-          streamPhase: 'thinking',
-          streamText: '',
-          thinkingStartTime: Date.now(),
-        })
+        startServerStreamingPlaceholder(sessionId)
       }
     } catch (err) {
       console.error('Failed to refresh queue:', err)
     }
-  }, [loadQueuedMessages, sessionId])
+  }, [loadQueuedMessages, sessionId, startServerStreamingPlaceholder])
 
   // Subscribe to WS messages for this session — always subscribe when session exists,
   // only enable fallback polling when actively needed
@@ -316,7 +336,7 @@ export function ChatArea() {
   useWs(
     sessionId ? 'runs' : '',
     refreshQueue,
-    sessionId && (isServerActive || queuedCount > 0) ? 10_000 : undefined,
+    sessionId && (isServerActive || queuedCount > 0) ? 2_500 : undefined,
   )
 
   // Listen for stream-end signal from the server — clears streaming state
@@ -325,11 +345,12 @@ export function ChatArea() {
     if (!sessionId) return
     const state = useChatStore.getState()
     if (state.streamSource === 'server' && state.streamingSessionId === sessionId) {
-      useChatStore.setState({ streaming: false, streamingSessionId: null, streamSource: null, streamText: '', displayText: '', streamPhase: 'thinking', streamToolName: '', thinkingText: '', thinkingStartTime: 0 })
+      markSessionLocallyIdle(sessionId)
+      useChatStore.setState({ streaming: false, streamingSessionId: null, streamSource: null, streamText: '', displayText: '', assistantRenderId: null, streamPhase: 'thinking', streamToolName: '', thinkingText: '', thinkingStartTime: 0 })
       void refreshMessages()
       void refreshSession(sessionId)
     }
-  }, [sessionId, refreshMessages, refreshSession])
+  }, [markSessionLocallyIdle, sessionId, refreshMessages, refreshSession])
   useWs(sessionId ? `stream-end:${sessionId}` : '', handleStreamEnd)
 
   // Keep the local typing indicator aligned with the server's active state
@@ -338,7 +359,7 @@ export function ChatArea() {
     const state = useChatStore.getState()
     if (isServerActive) {
       if (!state.streaming && !state.streamText) {
-        useChatStore.setState({ streaming: true, streamingSessionId: sessionId, streamSource: 'server', streamText: '' })
+        startServerStreamingPlaceholder(sessionId)
       }
       return
     }
@@ -349,9 +370,10 @@ export function ChatArea() {
     ) {
       // Server finished — clear all streaming state and fetch final messages
       fetchMessages(sessionId).then(setMessages).catch(() => {})
-      useChatStore.setState({ streaming: false, streamingSessionId: null, streamSource: null, streamText: '', displayText: '', streamPhase: 'thinking', streamToolName: '', thinkingText: '', thinkingStartTime: 0 })
+      markSessionLocallyIdle(sessionId)
+      useChatStore.setState({ streaming: false, streamingSessionId: null, streamSource: null, streamText: '', displayText: '', assistantRenderId: null, streamPhase: 'thinking', streamToolName: '', thinkingText: '', thinkingStartTime: 0 })
     }
-  }, [isServerActive, sessionId, setMessages])
+  }, [isServerActive, markSessionLocallyIdle, sessionId, setMessages, startServerStreamingPlaceholder])
 
   // Poll browser status while session has browser tools
   const hasBrowserTool = getEnabledToolIds(session).includes('browser')

package/src/components/chat/message-bubble.test.ts

@@ -37,6 +37,41 @@ describe('MessageBubble', () => {
     assert.doesNotMatch(html, /streaming-cursor/)
   })
 
+  it('falls back to persisted streaming content when the live stream payload is temporarily empty', async () => {
+    const messageBubbleModule = await import('./message-bubble') as Record<string, unknown>
+    const MessageBubble = (
+      messageBubbleModule.MessageBubble
+      || (messageBubbleModule.default as { MessageBubble?: unknown } | undefined)?.MessageBubble
+      || (messageBubbleModule['module.exports'] as { MessageBubble?: unknown } | undefined)?.MessageBubble
+    ) as typeof import('./message-bubble').MessageBubble | undefined
+    assert.ok(MessageBubble)
+
+    const html = renderToStaticMarkup(
+      React.createElement(MessageBubble, {
+        message: {
+          role: 'assistant',
+          text: 'Recovered persisted partial text',
+          time: Date.now(),
+          kind: 'chat',
+          streaming: true,
+        },
+        assistantName: 'Hal2k-3',
+        agentName: 'Hal2k-3',
+        liveStream: {
+          active: true,
+          phase: 'responding',
+          toolName: '',
+          text: '',
+          thinking: '',
+          toolEvents: [],
+        },
+      }),
+    )
+
+    assert.match(html, /Recovered persisted partial text/)
+    assert.match(html, /streaming-cursor/)
+  })
+
   it('renders upload-linked screenshots inline without duplicating them at the bottom', async () => {
     const messageBubbleModule = await import('./message-bubble') as Record<string, unknown>
     const MessageBubble = (

package/src/components/chat/message-bubble.tsx

@@ -367,12 +367,14 @@ export const MessageBubble = memo(function MessageBubble({ message, assistantNam
   const toolEvents = message.toolEvents ?? emptyToolEvents
   const toolEventsForMedia = useMemo(
     () => (liveStreamActive
-      ? liveToolEvents.map((event) => ({
-          name: event.name,
-          input: event.input,
-          output: event.output,
-          error: event.status === 'error' || undefined,
-        }))
+      ? (liveToolEvents.length > 0
+          ? liveToolEvents.map((event) => ({
+              name: event.name,
+              input: event.input,
+              output: event.output,
+              error: event.status === 'error' || undefined,
+            }))
+          : toolEvents)
       : toolEvents),
     [liveStreamActive, liveToolEvents, toolEvents],
   )
@@ -383,7 +385,15 @@ export const MessageBubble = memo(function MessageBubble({ message, assistantNam
   )
   const displayToolEvents = useMemo(
     () => (liveStreamActive
-      ? liveToolEvents.filter((ev) => ev.name !== 'send_file' || ev.status === 'error')
+      ? (liveToolEvents.length > 0
+          ? liveToolEvents.filter((ev) => ev.name !== 'send_file' || ev.status === 'error')
+          : persistedToolEvents.map((ev, i) => ({
+              id: ev.toolCallId || `${message.time}-${ev.name}-${i}`,
+              name: ev.name,
+              input: ev.input,
+              output: ev.output,
+              status: ev.error ? 'error' as const : 'done' as const,
+            })))
       : persistedToolEvents.map((ev, i) => ({
           id: ev.toolCallId || `${message.time}-${ev.name}-${i}`,
           name: ev.name,
@@ -418,11 +428,12 @@ export const MessageBubble = memo(function MessageBubble({ message, assistantNam
   const effectiveThinking = !isUser
     ? (liveStreamActive ? (liveStream?.thinking?.trim() ? liveStream.thinking : undefined) : message.thinking)
     : undefined
-  const sourceText = liveStreamActive ? (liveStream?.text || '') : message.text
+
+  const sourceText = liveStreamActive ? (liveStream?.text || message.text || '') : message.text
   const connectorDeliveryTranscript = !isUser && message.kind === 'connector-delivery'
     ? (message.source?.deliveryTranscript?.trim() || '')
     : ''
-  const copySourceText = connectorDeliveryTranscript || (liveStreamActive ? (liveStream?.text || '') : message.text)
+  const copySourceText = connectorDeliveryTranscript || (liveStreamActive ? (liveStream?.text || message.text || '') : message.text)
 
   // Extract ALL media from ALL tool events for inline display after the message text.
   // Covers send_file, browser screenshots, file tool outputs — everything.

package/src/components/chat/message-list.tsx

@@ -100,13 +100,6 @@ const LiveStreamBubble = memo(function LiveStreamBubble(props: LiveStreamBubbleP
   return <MessageBubble {...props} liveStream={liveStream} />
 })
 
-interface LastMessageMomentOverlayProps {
-  messages: Message[]
-  sessionId: string | null
-  agentId?: string | null
-  streaming: boolean
-  children: (momentOverlay: React.ReactNode, currentMoment: { kind: string } | null) => React.ReactNode
-}
 
 function useLastMessageMoment(messages: Message[], sessionId: string | null, agentId: string | null | undefined, streaming: boolean) {
   type MomentType = { kind: 'heartbeat' } | { kind: 'tool'; key: string; name: string; input: string }
@@ -117,31 +110,24 @@ function useLastMessageMoment(messages: Message[], sessionId: string | null, age
     setCurrentMoment({ kind: 'heartbeat' })
   })
 
-  const prevToolKeyRef = useRef<string | null>(null)
-  const seededMomentSessionRef = useRef<string | null>(null)
-
-  useEffect(() => {
-    if (!sessionId) {
-      seededMomentSessionRef.current = null
-      prevToolKeyRef.current = null
-      setCurrentMoment(null)
-      return
-    }
-
-    if (seededMomentSessionRef.current === sessionId) return
-    seededMomentSessionRef.current = sessionId
-    prevToolKeyRef.current = getLatestAssistantToolMoment(messages)?.key || null
-    setCurrentMoment(null)
-  }, [messages, sessionId])
-
-  useEffect(() => {
-    if (!sessionId || seededMomentSessionRef.current !== sessionId) return
+  const [trackedSessionId, setTrackedSessionId] = useState<string | null>(null)
+  const [trackedToolKey, setTrackedToolKey] = useState<string | null>(null)
+
+  // Render-time: respond to sessionId/messages changes (avoids set-state-in-effect)
+  if (sessionId !== trackedSessionId) {
+    setTrackedSessionId(sessionId)
+    const initialKey = sessionId
+      ? getLatestAssistantToolMoment(messages)?.key || null
+      : null
+    setTrackedToolKey(initialKey)
+    if (currentMoment !== null) setCurrentMoment(null)
+  } else if (sessionId) {
     const moment = getLatestAssistantToolMoment(messages)
-    if (!moment) return
-    if (moment.key === prevToolKeyRef.current) return
-    prevToolKeyRef.current = moment.key
-    setCurrentMoment({ kind: 'tool', key: moment.key, name: moment.name, input: moment.input })
-  }, [messages, sessionId])
+    if (moment && moment.key !== trackedToolKey) {
+      setTrackedToolKey(moment.key)
+      setCurrentMoment({ kind: 'tool', key: moment.key, name: moment.name, input: moment.input })
+    }
+  }
 
   const momentOverlay = useMemo(() => {
     if (streaming || !currentMoment) return null
@@ -161,13 +147,6 @@ function useLastMessageMoment(messages: Message[], sessionId: string | null, age
   return { currentMoment, momentOverlay }
 }
 
-interface Props {
-  messages: Message[]
-  streaming: boolean
-  connectorFilter?: string | null
-  loading?: boolean
-}
-
 interface LiveThinkingLaneProps {
   show: boolean
   assistantName?: string
@@ -195,6 +174,13 @@ const LiveThinkingLane = memo(function LiveThinkingLane({
   )
 })
 
+interface Props {
+  messages: Message[]
+  streaming: boolean
+  connectorFilter?: string | null
+  loading?: boolean
+}
+
 export function MessageList({ messages, streaming, connectorFilter = null, loading = false }: Props) {
   const scrollRef = useRef<HTMLDivElement>(null)
   const [showScrollToBottom, setShowScrollToBottom] = useState(false)
@@ -202,6 +188,7 @@ export function MessageList({ messages, streaming, connectorFilter = null, loadi
   const snapUntilRef = useRef(0)
   const prevSessionIdRef = useRef<string | null>(null)
   const assistantRenderId = useChatStore((s) => s.assistantRenderId)
+  const thinkingStartTime = useChatStore((s) => s.thinkingStartTime)
   const hasLiveArtifacts = useChatStore(selectHasLiveArtifacts)
   const setMessages = useChatStore((s) => s.setMessages)
   const retryLastMessage = useChatStore((s) => s.retryLastMessage)
@@ -232,7 +219,7 @@ export function MessageList({ messages, streaming, connectorFilter = null, loadi
   const showGatewayOverlay = isOpenClaw && gatewayStatus === 'disconnected'
 
   // Moment overlay for last assistant message (heartbeat or tool events)
-  const { currentMoment, momentOverlay: lastMomentOverlay } = useLastMessageMoment(messages, sessionId, agent?.id, streaming)
+  const { momentOverlay: lastMomentOverlay } = useLastMessageMoment(messages, sessionId, agent?.id, streaming)
 
   // Unread count tracking
   const unreadRef = useRef(0)
@@ -311,13 +298,46 @@ export function MessageList({ messages, streaming, connectorFilter = null, loadi
     return dedupeMessagesForDisplay(displayedMessages)
   }, [messages, showAlerts, showOk])
 
+  const latestPersistedStreamingMessage = useMemo(() => {
+    for (let i = baseDisplayedMessages.length - 1; i >= 0; i -= 1) {
+      const candidate = baseDisplayedMessages[i]
+      if (candidate.role === 'assistant' && candidate.streaming === true) {
+        return candidate
+      }
+    }
+    return null
+  }, [baseDisplayedMessages])
+
+  const currentRunHasCompletedAssistant = useMemo(
+    () => (
+      streaming
+      && thinkingStartTime > 0
+      && baseDisplayedMessages.some((message) => (
+        message.role === 'assistant'
+        && message.streaming !== true
+        && message.kind !== 'system'
+        && message.kind !== 'heartbeat'
+        && typeof message.time === 'number'
+        && message.time >= thinkingStartTime
+      ))
+    ),
+    [baseDisplayedMessages, streaming, thinkingStartTime],
+  )
+
+  const showLiveStreamRow = streaming
+    && !!assistantRenderId
+    && !currentRunHasCompletedAssistant
+    && (hasLiveArtifacts || !!latestPersistedStreamingMessage)
+
   const streamingAwareMessages = useMemo(() => (
     buildStreamingAwareMessageList(baseDisplayedMessages, {
       localStreaming: streaming,
       hasLiveArtifacts,
       assistantRenderId,
+      showLiveRow: showLiveStreamRow,
+      syntheticAssistant: latestPersistedStreamingMessage,
     })
-  ), [assistantRenderId, baseDisplayedMessages, hasLiveArtifacts, streaming])
+  ), [assistantRenderId, baseDisplayedMessages, hasLiveArtifacts, latestPersistedStreamingMessage, showLiveStreamRow, streaming])
 
   const filteredMessages = useMemo(() => {
     let nextMessages = bookmarkFilter
@@ -637,7 +657,7 @@ export function MessageList({ messages, streaming, connectorFilter = null, loadi
   }, [searchOpen])
 
   return (
-    <div className="relative flex-1 min-h-0 min-w-0 flex flex-col overflow-hidden" data-testid="message-list">
+    <div className="relative flex-1 min-h-0 min-w-0 flex flex-col overflow-hidden isolate" data-testid="message-list">
       <div className="shrink-0 px-4 md:px-12 lg:px-16 pt-3">
         <div className="flex flex-wrap items-center gap-2 rounded-[14px] border border-white/[0.06] bg-surface/55 px-3 py-2 backdrop-blur-sm">
           <button
@@ -867,7 +887,7 @@ export function MessageList({ messages, streaming, connectorFilter = null, loadi
           {transcriptNodes}
           <ApprovalCards agentId={agent?.id} />
           <LiveThinkingLane
-            show={streaming && !hasLiveArtifacts && !hasVisiblePersistedStreamingMessage}
+            show={streaming && !showLiveStreamRow && !hasLiveArtifacts && !hasVisiblePersistedStreamingMessage}
             assistantName={assistantName}
             agentAvatarSeed={agent?.avatarSeed}
             agentAvatarUrl={agent?.avatarUrl}