@swarmclawai/swarmclaw 1.2.0 → 1.2.2

package/src/lib/server/ws-hub.ts

@@ -2,6 +2,9 @@ import { WebSocketServer, WebSocket } from 'ws'
 import type { IncomingMessage } from 'http'
 import { validateAccessKey } from './storage'
 import { AUTH_COOKIE_NAME, getCookieValue } from '@/lib/auth'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'ws-hub'
 
 interface WsClient {
   ws: WebSocket
@@ -67,10 +70,10 @@ export function initWsServer() {
   })
 
   wss.on('error', (err) => {
-    console.error('[ws-hub] WebSocket server error:', err.message)
+    log.error(TAG, 'WebSocket server error:', err.message)
   })
 
-  console.log(`[ws-hub] WebSocket server listening on port ${port}`)
+  log.info(TAG, `WebSocket server listening on port ${port}`)
 }
 
 export function closeWsServer(): Promise<void> {

package/src/lib/strip-internal-metadata.test.ts

@@ -1,4 +1,5 @@
-import { describe, it, expect } from 'vitest'
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
 import { stripInternalJson, stripLoopDetectionMessages, stripAllInternalMetadata } from './strip-internal-metadata'
 
 // ---------------------------------------------------------------------------
@@ -8,37 +9,37 @@ import { stripInternalJson, stripLoopDetectionMessages, stripAllInternalMetadata
 describe('stripInternalJson', () => {
   it('removes single-line classification JSON', () => {
     const input = '{ "isDeliverableTask": true, "quality_score": 0.8, "isBroadGoal": false }'
-    expect(stripInternalJson(input).trim()).toBe('')
+    assert.equal(stripInternalJson(input).trim(), '')
   })
 
   it('removes classification JSON embedded in surrounding text', () => {
     const input = 'Here is the answer.\n{ "isDeliverableTask": true, "confidence": 0.9 }\nMore text follows.'
     const result = stripInternalJson(input)
-    expect(result).toContain('Here is the answer.')
-    expect(result).toContain('More text follows.')
-    expect(result).not.toContain('isDeliverableTask')
+    assert.match(result, /Here is the answer\./)
+    assert.match(result, /More text follows\./)
+    assert.doesNotMatch(result, /isDeliverableTask/)
   })
 
   it('preserves legitimate JSON that does not contain internal keys', () => {
     const input = 'The config is { "name": "test", "port": 3000 }'
-    expect(stripInternalJson(input)).toBe(input)
+    assert.equal(stripInternalJson(input), input)
   })
 
   it('preserves JSON with nested objects if no internal keys', () => {
     const input = '{ "user": { "name": "alice" } }'
-    expect(stripInternalJson(input)).toBe(input)
+    assert.equal(stripInternalJson(input), input)
   })
 
   it('removes JSON with nested objects when internal keys are present', () => {
     const input = '{ "walletIntent": "send", "details": { "amount": 100 } }'
-    expect(stripInternalJson(input).trim()).toBe('')
+    assert.equal(stripInternalJson(input).trim(), '')
   })
 
   it('handles multiple JSON blocks, only removing internal ones', () => {
     const input = '{ "isDeliverableTask": true } some text { "foo": "bar" }'
     const result = stripInternalJson(input)
-    expect(result).not.toContain('isDeliverableTask')
-    expect(result).toContain('{ "foo": "bar" }')
+    assert.doesNotMatch(result, /isDeliverableTask/)
+    assert.match(result, /\{ "foo": "bar" \}/)
   })
 })
 
@@ -49,70 +50,110 @@ describe('stripInternalJson', () => {
 describe('stripLoopDetectionMessages', () => {
   it('strips tool frequency "called N times" messages', () => {
     const input = 'Tool "shell" called 30 times this turn. Excessive repetition — wrap up with available results.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips tool frequency "would be called" messages', () => {
     const input = 'Tool "shell" would be called 31 times this turn. Excessive repetition — wrap up with available results.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips "nearing overuse" messages', () => {
     const input = 'Tool "read" is nearing overuse (15 calls this turn). Consider whether another call is needed.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
-  it('strips generic repeat "has been called" messages', () => {
-    const input = 'Tool "search" has been called 12 times with the same input. This appears to be a stuck loop.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+  it('strips generic repeat "You called" messages', () => {
+    const input = 'You called "browser" 6 times with identical input. Input: "{"action":"screenshot"}" — State your blocker or deliver what you have.'
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
+  })
+
+  it('strips generic repeat "You called" warning messages', () => {
+    const input = 'You called "search" 4 times with identical input. Input: "query" — Try a fundamentally different approach or deliver partial results.'
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips "would repeat the same input" messages', () => {
-    const input = 'Tool "search" would repeat the same input 12 times. Blocking before it becomes a stuck loop.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    const input = '"search" would repeat the same input 12 times. Input: "query" — State your blocker or deliver what you have.'
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips "is about to repeat the same input" messages', () => {
-    const input = 'Tool "search" is about to repeat the same input 6 times. Consider a different approach.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    const input = '"search" is about to repeat the same input 6 times. Input: "query" — Try a different approach.'
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips circuit breaker messages', () => {
     const input = 'Circuit breaker: "shell" called 20 times with identical input. Halting to prevent runaway.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips circuit breaker preview messages', () => {
     const input = 'Circuit breaker: "shell" would be called 20 times with identical input. Halting before another runaway call.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips polling stall messages', () => {
     const input = 'Polling stall: "status_check" returned identical output 8 times consecutively. The polled resource is not changing.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips ping-pong "are alternating" messages', () => {
     const input = 'Ping-pong: "read" and "write" are alternating with identical results (5 cycles). Breaking the loop.'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('strips ping-pong "may be stuck" messages', () => {
     const input = 'Ping-pong: "read" and "write" may be stuck in an alternating loop (3 cycles).'
-    expect(stripLoopDetectionMessages(input).trim()).toBe('')
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
+  })
+
+  it('strips output stagnation messages', () => {
+    const input = 'Output stagnation: last 8 tool calls all produced identical output. The approach is not working — try something fundamentally different or report the blocker.'
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
+  })
+
+  it('strips output stagnation warning messages', () => {
+    const input = 'Output stagnation: 6 of the last 8 tool calls produced identical output. Your tools may not be making progress.'
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
+  })
+
+  it('strips error convergence messages', () => {
+    const input = 'Error convergence: 5 of the last 6 tool calls returned errors. Stop retrying and report the underlying issue (likely an infrastructure or configuration problem).'
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
+  })
+
+  it('strips error convergence warning messages', () => {
+    const input = 'Error convergence: 4 of the last 6 tool calls returned errors. You may be hitting a systemic issue — consider a different approach or report the blocker.'
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
+  })
+
+  it('strips messages wrapped in [Error: ...] brackets', () => {
+    const input = '[Error: You called "browser" 6 times with identical input. Input: "{"action":"screenshot"}" — State your blocker or deliver what you have.]'
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
+  })
+
+  it('strips [Error: ...] wrapped tool frequency messages', () => {
+    const input = '[Error: Tool "shell" called 30 times this turn. Excessive repetition — wrap up with available results.]'
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
+  })
+
+  it('strips [Error: ...] wrapped output stagnation messages', () => {
+    const input = '[Error: Output stagnation: last 8 tool calls all produced identical output.]'
+    assert.equal(stripLoopDetectionMessages(input).trim(), '')
   })
 
   it('preserves normal text that mentions tools', () => {
     const input = 'I used the shell tool to run the command.'
-    expect(stripLoopDetectionMessages(input)).toBe(input)
+    assert.equal(stripLoopDetectionMessages(input), input)
   })
 
   it('strips loop message embedded in surrounding text', () => {
     const input = 'Working on it.\nTool "shell" called 30 times this turn. Excessive repetition — wrap up with available results.\nHere are the results.'
     const result = stripLoopDetectionMessages(input)
-    expect(result).toContain('Working on it.')
-    expect(result).toContain('Here are the results.')
-    expect(result).not.toContain('called 30 times')
+    assert.match(result, /Working on it\./)
+    assert.match(result, /Here are the results\./)
+    assert.doesNotMatch(result, /called 30 times/)
   })
 })
 
@@ -129,32 +170,32 @@ describe('stripAllInternalMetadata', () => {
       'The answer is 42.',
     ].join('\n')
     const result = stripAllInternalMetadata(input)
-    expect(result).not.toContain('isDeliverableTask')
-    expect(result).not.toContain('called 30 times')
-    expect(result).toContain('Here is my analysis.')
-    expect(result).toContain('The answer is 42.')
+    assert.doesNotMatch(result, /isDeliverableTask/)
+    assert.doesNotMatch(result, /called 30 times/)
+    assert.match(result, /Here is my analysis\./)
+    assert.match(result, /The answer is 42\./)
   })
 
   it('collapses excessive newlines after stripping', () => {
     const input = 'Hello.\n\n\n\n{ "isDeliverableTask": true }\n\n\n\nWorld.'
     const result = stripAllInternalMetadata(input)
-    expect(result).not.toMatch(/\n{3,}/)
+    assert.doesNotMatch(result, /\n{3,}/)
   })
 
   it('returns empty string for purely internal content', () => {
     const input = '{ "isDeliverableTask": true, "quality_score": 0.9 }'
-    expect(stripAllInternalMetadata(input)).toBe('')
+    assert.equal(stripAllInternalMetadata(input), '')
   })
 
   it('leaves normal messages untouched', () => {
     const input = 'Here is a normal response with no internal metadata.'
-    expect(stripAllInternalMetadata(input)).toBe(input)
+    assert.equal(stripAllInternalMetadata(input), input)
   })
 
   it('preserves code blocks with JSON that happen to have similar-looking keys', () => {
     // JSON in code blocks uses real braces, so the regex will match the block.
     // But since 'name' and 'age' are not internal keys, it should be preserved.
     const input = 'Result: { "name": "Alice", "age": 30 }'
-    expect(stripAllInternalMetadata(input)).toBe(input)
+    assert.equal(stripAllInternalMetadata(input), input)
   })
 })

package/src/lib/strip-internal-metadata.ts

@@ -43,35 +43,49 @@ export function stripInternalJson(text: string): string {
  * - Tool "X" called N times ...
  * - Tool "X" would be called N times ...
  * - Tool "X" is nearing overuse ...
- * - Tool "X" has been called N times with the same input ...
- * - Tool "X" would repeat the same input N times ...
- * - Tool "X" is about to repeat the same input N times ...
+ * - You called "X" N times with identical input ...
+ * - "X" would repeat the same input N times ...
+ * - "X" is about to repeat the same input N times ...
  * - Circuit breaker: "X" called N times ...
  * - Circuit breaker: "X" would be called N times ...
  * - Polling stall: "X" returned identical output N times ...
  * - Ping-pong: "X" and "Y" are alternating ...
  * - Ping-pong: "X" and "Y" may be stuck ...
+ * - Output stagnation: last N / N of the last N ...
+ * - Error convergence: N of the last N ...
  */
 const LOOP_DETECTION_RE = new RegExp(
   [
     // Tool frequency: called / would be called / nearing overuse
     String.raw`Tool "[^"]*" (?:called|would be called) \d+ times[^\n]*`,
     String.raw`Tool "[^"]*" is nearing overuse[^\n]*`,
-    // Generic repeat: has been called / would repeat / is about to repeat
-    String.raw`Tool "[^"]*" (?:has been called|would repeat the same input|is about to repeat the same input) \d+ times[^\n]*`,
+    // Generic repeat: "You called" (post-call) / "X" would repeat / is about to repeat (preview)
+    String.raw`You called "[^"]*" \d+ times[^\n]*`,
+    String.raw`"[^"]*" (?:would repeat the same input|is about to repeat the same input) \d+ times[^\n]*`,
     // Circuit breaker
     String.raw`Circuit breaker: "[^"]*" (?:called|would be called) \d+ times[^\n]*`,
     // Polling stall
     String.raw`Polling stall: "[^"]*" returned identical output \d+ times[^\n]*`,
     // Ping-pong
     String.raw`Ping-pong: "[^"]*" and "[^"]*" (?:are alternating|may be stuck)[^\n]*`,
+    // Output stagnation
+    String.raw`Output stagnation:[^\n]*`,
+    // Error convergence
+    String.raw`Error convergence:[^\n]*`,
   ].join('|'),
   'g',
 )
 
+/**
+ * Matches loop detection messages wrapped in `[Error: ...]` brackets
+ * (from the err SSE event handler in use-chat-store.ts).
+ */
+const LOOP_DETECTION_WRAPPED_RE = /\[Error: (?:Tool "[^"]*" (?:called|would be called) \d+ times|Tool "[^"]*" is nearing overuse|You called "[^"]*" \d+ times|"[^"]*" (?:would repeat the same input|is about to repeat the same input) \d+ times|Circuit breaker: "[^"]*" (?:called|would be called) \d+ times|Polling stall: "[^"]*" returned identical output \d+ times|Ping-pong: "[^"]*" and "[^"]*" (?:are alternating|may be stuck)|Output stagnation:|Error convergence:)[^\]]*\]/g
+
 /** Remove loop detection messages that the LLM echoed from tool error results. */
 export function stripLoopDetectionMessages(text: string): string {
-  return text.replace(LOOP_DETECTION_RE, '')
+  // Strip [Error: ...] wrapped versions first, before the inner regex eats the content
+  return text.replace(LOOP_DETECTION_WRAPPED_RE, '').replace(LOOP_DETECTION_RE, '')
 }
 
 // ---------------------------------------------------------------------------

package/src/stores/use-approval-store.ts

@@ -76,7 +76,13 @@ export const useApprovalStore = create<ApprovalState>((set) => ({
       for (const [id, a] of Object.entries(s.approvals)) {
         if (a.expiresAtMs > now && !s.resolvedIds.has(id)) next[id] = a
       }
-      return { approvals: next }
+      // Prune resolvedIds for IDs no longer in the approval set
+      const liveIds = new Set(Object.keys(next))
+      const nextResolved = new Set<string>()
+      for (const id of s.resolvedIds) {
+        if (liveIds.has(id)) nextResolved.add(id)
+      }
+      return { approvals: next, resolvedIds: nextResolved }
     })
   },
 

package/src/stores/use-chat-store.test.ts

@@ -196,6 +196,60 @@ describe('useChatStore control-token hygiene', () => {
     assert.equal(assistantMessage?.clientRenderId, state.assistantRenderId)
   })
 
+  it('marks the session idle locally as soon as a direct stream finishes', async () => {
+    const session = makeSession({ active: true, currentRunId: 'run-1' } as Partial<Session>)
+    useAppStore.setState({
+      agents: { 'agent-1': makeAgent() },
+      sessions: { [session.id]: session },
+      currentAgentId: 'agent-1',
+    })
+    useChatStore.setState({
+      messages: [],
+      pendingFiles: [],
+      replyingTo: null,
+      toolEvents: [],
+      streamText: '',
+      displayText: '',
+      streaming: false,
+      streamingSessionId: null,
+      streamSource: null,
+      assistantRenderId: null,
+      streamPhase: 'thinking',
+      streamToolName: '',
+      thinkingText: '',
+      thinkingStartTime: 0,
+      queuedMessages: [],
+      agentStatus: null,
+      lastUsage: null,
+      hasMoreMessages: false,
+      loadingMore: false,
+      totalMessages: 0,
+    })
+
+    global.fetch = (async (input: RequestInfo | URL) => {
+      const url = String(input)
+      if (url === '/api/chats/session-1/chat') {
+        return sseResponse([
+          { t: 'r', text: 'Done' },
+          { t: 'done' },
+        ])
+      }
+      if (url === '/api/chats/session-1') {
+        return new Response(JSON.stringify({ ...session, active: false, currentRunId: null }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        })
+      }
+      throw new Error(`Unexpected fetch: ${url}`)
+    }) as unknown as typeof fetch
+
+    await useChatStore.getState().sendMessage('Hello', { sessionId: 'session-1' })
+
+    const refreshedSession = useAppStore.getState().sessions['session-1']
+    assert.equal(refreshedSession?.active, false)
+    assert.equal(refreshedSession?.currentRunId, null)
+  })
+
   it('replaces optimistic queued items with the backend queue snapshot', async () => {
     const session = makeSession()
     useAppStore.setState({

package/src/stores/use-chat-store.ts

@@ -10,6 +10,7 @@ import {
   removeQueuedSessionMessage,
 } from '@/lib/chat/chats'
 import { mergeCompletedAssistantMessage, reconcileClientMessageMetadata } from '@/lib/chat/chat-streaming-state'
+import { createAssistantRenderId } from '@/lib/chat/assistant-render-id'
 import { stripAllInternalMetadata } from '@/lib/strip-internal-metadata'
 import {
   clearQueuedMessagesForSession,
@@ -152,10 +153,6 @@ function stripHiddenControlTokens(text: string): string {
   return cleaned.replace(/\n{3,}/g, '\n\n').trim()
 }
 
-function nextAssistantRenderId(): string {
-  return `assistant-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`
-}
-
 function reconcileMessagesForState(
   nextMessages: Message[],
   currentMessages: Message[],
@@ -184,6 +181,17 @@ function syncSessionQueueState(sessionId: string, params: {
   })
 }
 
+function markSessionRunIdle(sessionId: string): void {
+  const appState = useAppStore.getState()
+  const session = appState.sessions[sessionId]
+  if (!session) return
+  appState.updateSessionInStore({
+    ...session,
+    active: false,
+    currentRunId: null,
+  })
+}
+
 export const useChatStore = create<ChatState>((set, get) => ({
   streaming: false,
   streamingSessionId: null,
@@ -239,6 +247,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
         s.queuedMessages,
         sessionId,
         snapshotToQueuedMessages(snapshot),
+        { activeRunId: snapshot.activeRunId },
       )
       // Clear "sending" items whose text has already appeared in chat messages
       const messages = s.messages
@@ -285,6 +294,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
           removeQueuedMessageById(s.queuedMessages, optimistic.runId),
           sessionId,
           snapshotToQueuedMessages(response.snapshot),
+          { activeRunId: response.snapshot.activeRunId },
         ),
       }))
       syncSessionQueueState(sessionId, {
@@ -314,6 +324,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
         s.queuedMessages,
         sessionId,
         snapshotToQueuedMessages(response.snapshot),
+        { activeRunId: response.snapshot.activeRunId },
       ),
     }))
     syncSessionQueueState(sessionId, {
@@ -331,6 +342,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
         s.queuedMessages,
         sessionId,
         snapshotToQueuedMessages(response.snapshot),
+        { activeRunId: response.snapshot.activeRunId },
       ),
     }))
     syncSessionQueueState(sessionId, {
@@ -388,7 +400,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
       attachedFiles,
       ...(replyToId ? { replyToId } : {}),
     }
-    const assistantRenderId = nextAssistantRenderId()
+    const assistantRenderId = createAssistantRenderId()
     set((s) => ({
       streaming: true,
       streamingSessionId: sessionId,
@@ -418,7 +430,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
     let toolCallCounter = 0
     let soundFiredStart = false
     const shouldIgnoreTransientError = (msg: string) =>
-      /cancelled by steer mode|stopped by user/i.test(msg || '')
+      /cancelled by steer mode|stopped by user|stream timed out/i.test(msg || '')
 
     try { await streamChat(sessionId, text, imagePath, imageUrl, (event: SSEEvent) => {
       // Forward events to voice conversation handler if active
@@ -603,6 +615,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
         thinkingText: '',
         thinkingStartTime: 0,
       }))
+      markSessionRunIdle(sessionId)
       if (get().ttsEnabled && !get().voiceConversationActive) speak(visibleFinalText)
     } else {
       set({
@@ -617,6 +630,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
         thinkingText: '',
         thinkingStartTime: 0,
       })
+      markSessionRunIdle(sessionId)
     }
 
     void useAppStore.getState().refreshSession(sessionId)
@@ -635,6 +649,7 @@ export const useChatStore = create<ChatState>((set, get) => ({
           thinkingText: '',
           thinkingStartTime: 0,
         })
+        markSessionRunIdle(sessionId)
       }
     }
   },
@@ -860,6 +875,11 @@ export const useChatStore = create<ChatState>((set, get) => ({
       displayText: '',
       streamPhase: 'thinking' as const,
       streamToolName: '',
+      thinkingText: '',
+      thinkingStartTime: 0,
+      toolEvents: [],
+      agentStatus: null,
     })
+    if (sessionId) markSessionRunIdle(sessionId)
   },
 }))

package/src/types/index.ts

@@ -452,6 +452,8 @@ export interface Session {
   theme?: string
   avatar?: string
   canvasContent?: CanvasContent
+  /** Tracks how many times each memory ID has been injected via proactive recall in this session. */
+  injectedMemoryIds?: Record<string, number>
 }
 
 export type Sessions = Record<string, Session>
@@ -1545,6 +1547,7 @@ export interface MemoryEntry {
   lastAccessedAt?: number
   contentHash?: string
   reinforcementCount?: number
+  abstract?: string | null
   createdAt: number
   updatedAt: number
 }
@@ -2147,6 +2150,9 @@ export interface SessionRunRecord {
   recoveredFromRestart?: boolean
   recoveredFromRunId?: string
   recoveryPayload?: SessionRunRecoveryPayload
+  totalInputTokens?: number
+  totalOutputTokens?: number
+  estimatedCost?: number
 }
 
 export interface SessionQueuedTurn {