@swarmclawai/swarmclaw 0.8.0 → 0.8.2

package/src/lib/runtime-loop.ts

@@ -22,7 +22,7 @@ export const CLAUDE_CODE_TIMEOUT_SEC_MAX = 7200
 export const CLI_PROCESS_TIMEOUT_SEC_MIN = 10
 export const CLI_PROCESS_TIMEOUT_SEC_MAX = 7200
 
-export const DEFAULT_AGENT_LOOP_RECURSION_LIMIT = 60
+export const DEFAULT_AGENT_LOOP_RECURSION_LIMIT = 120
 export const DEFAULT_ORCHESTRATOR_LOOP_RECURSION_LIMIT = 80
 export const DEFAULT_LEGACY_ORCHESTRATOR_MAX_TURNS = 16
 export const DEFAULT_ONGOING_LOOP_MAX_ITERATIONS = 250

package/src/lib/server/agent-thread-session.test.ts

@@ -133,4 +133,45 @@ describe('ensureAgentThreadSession', () => {
     assert.equal(output.threadSessionId, null)
     assert.equal(output.sessionCount, 0)
   })
+
+  it('propagates explicit OpenClaw gateway agent ids into the shortcut session', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const storage = storageMod.default || storageMod['module.exports'] || storageMod
+      const helperMod = await import('./src/lib/server/agent-thread-session.ts')
+      const ensureAgentThreadSession = helperMod.ensureAgentThreadSession
+        || helperMod.default?.ensureAgentThreadSession
+        || helperMod['module.exports']?.ensureAgentThreadSession
+
+      const now = Date.now()
+      storage.saveAgents({
+        oc: {
+          id: 'oc',
+          name: 'OpenClaw Ops',
+          description: 'OpenClaw-backed helper',
+          provider: 'openclaw',
+          model: 'default',
+          credentialId: null,
+          apiEndpoint: null,
+          gatewayProfileId: 'gateway-test',
+          fallbackCredentialIds: [],
+          openclawAgentId: 'main',
+          heartbeatEnabled: true,
+          heartbeatIntervalSec: 600,
+          createdAt: now,
+          updatedAt: now,
+          plugins: [],
+        },
+      })
+
+      const session = ensureAgentThreadSession('oc')
+      const sessions = storage.loadSessions()
+
+      console.log(JSON.stringify({
+        session: session ? sessions[session.id] : null,
+      }))
+    `)
+
+    assert.equal(output.session.openclawAgentId, 'main')
+  })
 })

package/src/lib/server/agent-thread-session.ts

@@ -18,6 +18,7 @@ function buildThreadSession(agent: Agent, sessionId: string, user: string, creat
   const baseSession: Session = {
     id: sessionId,
     name: agent.name,
+    openclawAgentId: agent.openclawAgentId || existing?.openclawAgentId || null,
     shortcutForAgentId: agent.id,
     cwd: existing?.cwd || WORKSPACE_DIR,
     user: existing?.user || user,

package/src/lib/server/chat-execution-advanced.test.ts

@@ -271,6 +271,13 @@ describe('requestedToolNamesFromMessage advanced', () => {
     assert.ok(result.includes('memory_tool'))
   })
 
+  it('extracts narrow memory tool names when explicitly requested', () => {
+    const result = requestedToolNamesFromMessage('Use `memory_search` first, then `memory_get`, and finish with `memory_store` if needed')
+    assert.ok(result.includes('memory_search'))
+    assert.ok(result.includes('memory_get'))
+    assert.ok(result.includes('memory_store'))
+  })
+
   it('extracts multiple tools from complex request', () => {
     const result = requestedToolNamesFromMessage('Use `web` to research, `browser` to screenshot, and `connector_message_tool` to send via Slack')
     assert.ok(result.includes('web'))

package/src/lib/server/chat-execution-eval-history.test.ts

@@ -0,0 +1,111 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import test from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-chat-eval-history-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        DATA_DIR: path.join(tempDir, 'data'),
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+        BROWSER_PROFILES_DIR: path.join(tempDir, 'browser-profiles'),
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+test('executeSessionChatTurn persists internal eval user turns for same-thread recall', () => {
+  const output = runWithTempDataDir(`
+    const storageMod = await import('./src/lib/server/storage.ts')
+    const storage = storageMod.default || storageMod['module.exports'] || storageMod
+    const providersMod = await import('./src/lib/providers/index.ts')
+    const execMod = await import('./src/lib/server/chat-execution.ts')
+    const executeSessionChatTurn = execMod.executeSessionChatTurn
+      || execMod.default?.executeSessionChatTurn
+      || execMod['module.exports']?.executeSessionChatTurn
+    const providers = providersMod.PROVIDERS
+      || providersMod.default?.PROVIDERS
+      || providersMod['module.exports']?.PROVIDERS
+
+    providers['test-provider'] = {
+      id: 'test-provider',
+      name: 'Test Provider',
+      models: ['unit'],
+      requiresApiKey: false,
+      requiresEndpoint: false,
+      handler: {
+        async streamChat({ session, message, loadHistory }) {
+          if (/what is project kodiak's code name\\??/i.test(message)) {
+            const history = loadHistory(session.id)
+            const remembered = history.find((entry) =>
+              entry?.role === 'user' && typeof entry.text === 'string' && entry.text.includes('code name Sunbird')
+            )
+            return remembered ? 'Project Kodiak\\'s code name is Sunbird.' : 'I cannot find the code name in the thread history.'
+          }
+          return 'Stored.'
+        },
+      },
+    }
+
+    const now = Date.now()
+    const sessions = storage.loadSessions()
+    sessions['eval-history'] = {
+      id: 'eval-history',
+      name: 'Eval History',
+      cwd: process.cwd(),
+      user: 'eval-runner',
+      provider: 'test-provider',
+      model: 'unit',
+      claudeSessionId: null,
+      messages: [],
+      createdAt: now,
+      lastActiveAt: now,
+      plugins: [],
+    }
+    storage.saveSessions(sessions)
+
+    await executeSessionChatTurn({
+      sessionId: 'eval-history',
+      message: 'Remember that Project Kodiak uses the code name Sunbird.',
+      internal: true,
+      source: 'eval',
+    })
+
+    const recall = await executeSessionChatTurn({
+      sessionId: 'eval-history',
+      message: 'What is Project Kodiak\\'s code name?',
+      internal: true,
+      source: 'eval',
+    })
+
+    const storedSession = storage.loadSessions()['eval-history']
+    console.log(JSON.stringify({
+      recallText: recall.text,
+      roles: storedSession.messages.map((entry) => entry.role),
+      texts: storedSession.messages.map((entry) => entry.text),
+    }))
+  `)
+
+  assert.match(String(output.recallText || ''), /Sunbird/)
+  assert.deepEqual(output.roles, ['user', 'assistant', 'user', 'assistant'])
+  assert.match(String(output.texts?.[0] || ''), /Project Kodiak uses the code name Sunbird/)
+})

package/src/lib/server/chat-execution.ts

@@ -109,6 +109,11 @@ export function shouldApplySessionFreshnessReset(source: string): boolean {
   return source !== 'eval'
 }
 
+function shouldPersistInboundUserMessage(internal: boolean, source: string): boolean {
+  if (!internal) return true
+  return source === 'eval'
+}
+
 function extractEventJson(line: string): SSEEvent | null {
   if (!line.startsWith('data: ')) return null
   try {
@@ -456,6 +461,10 @@ export function requestedToolNamesFromMessage(message: string): string[] {
     'monitor_tool',
     'plugin_creator_tool',
     'memory_tool',
+    'memory_search',
+    'memory_get',
+    'memory_store',
+    'memory_update',
     'wallet_tool',
     'http_request',
     'send_file',
@@ -856,6 +865,11 @@ function syncSessionFromAgent(sessionId: string): void {
       session.projectId = desiredProjectId
       changed = true
     }
+    const desiredOpenClawAgentId = agent.openclawAgentId ?? null
+    if ((session.openclawAgentId ?? null) !== desiredOpenClawAgentId) {
+      session.openclawAgentId = desiredOpenClawAgentId
+      changed = true
+    }
   }
 
   if (changed) {
@@ -1212,8 +1226,9 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
 
   const apiKey = resolveApiKeyForSession(sessionForRun, provider)
 
-  if (!internal) {
-    const linkAnalysis = await runLinkUnderstanding(message)
+  const shouldPersistUserMessage = shouldPersistInboundUserMessage(internal, source)
+  if (shouldPersistUserMessage) {
+    const linkAnalysis = !internal ? await runLinkUnderstanding(message) : []
     const nextUserMessage: Message = {
       role: 'user',
       text: message,
@@ -1234,9 +1249,11 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
     }
     session.lastActiveAt = Date.now()
     saveSessions(sessions)
-    try {
-      await getPluginManager().runHook('onMessage', { session, message: nextUserMessage }, { enabledIds: pluginsForRun })
-    } catch { /* onMessage hooks are non-critical */ }
+    if (!internal) {
+      try {
+        await getPluginManager().runHook('onMessage', { session, message: nextUserMessage }, { enabledIds: pluginsForRun })
+      } catch { /* onMessage hooks are non-critical */ }
+    }
   }
 
   const systemPrompt = buildAgentSystemPrompt(session)

package/src/lib/server/create-notification.test.ts

@@ -0,0 +1,94 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import type { AppNotification } from '@/types'
+import { createNotification } from './create-notification'
+
+describe('createNotification', () => {
+  it('coalesces repeated dedupKey events into one notification record', () => {
+    const store = new Map<string, AppNotification>()
+    const notifyTopics: string[] = []
+    const dispatched: string[] = []
+
+    const deps = {
+      now: (() => {
+        let current = 1_700_000_000_000
+        return () => {
+          current += 1_000
+          return current
+        }
+      })(),
+      save: (id: string, data: AppNotification) => {
+        store.set(id, data)
+      },
+      notifyTopic: (topic: string) => {
+        notifyTopics.push(topic)
+      },
+      dispatch: async (notification: AppNotification) => {
+        dispatched.push(notification.id)
+      },
+      findByDedupKey: (dedupKey: string) => {
+        for (const notification of store.values()) {
+          if (notification.dedupKey === dedupKey) return notification
+        }
+        return null
+      },
+      createId: (() => {
+        let seq = 0
+        return () => `notif_${++seq}`
+      })(),
+    }
+
+    const first = createNotification({
+      type: 'warning',
+      title: 'Provider unreachable',
+      message: 'Timeout',
+      dedupKey: 'provider-down:test',
+    }, deps)
+
+    const second = createNotification({
+      type: 'warning',
+      title: 'Provider unreachable',
+      message: 'Still timing out',
+      dedupKey: 'provider-down:test',
+    }, deps)
+
+    assert.equal(first.created, true)
+    assert.equal(second.created, false)
+    assert.equal(store.size, 1)
+    assert.equal(second.notification.id, first.notification.id)
+    assert.equal(second.notification.message, 'Still timing out')
+    assert.equal(second.notification.occurrenceCount, 2)
+    assert.equal(second.notification.read, false)
+    assert.deepEqual(notifyTopics, ['notifications', 'notifications'])
+    assert.deepEqual(dispatched, [first.notification.id])
+  })
+
+  it('can keep a notification in-app only without external dispatch', () => {
+    const store = new Map<string, AppNotification>()
+    const dispatched: string[] = []
+
+    const result = createNotification({
+      type: 'warning',
+      title: 'SwarmClaw health alert',
+      message: 'Connector recovered.',
+      dedupKey: 'health-alert:connector-recovered',
+      dispatchExternally: false,
+    }, {
+      now: () => 1_700_000_000_000,
+      save: (id: string, data: AppNotification) => {
+        store.set(id, data)
+      },
+      notifyTopic: () => {},
+      dispatch: async (notification: AppNotification) => {
+        dispatched.push(notification.id)
+      },
+      findByDedupKey: () => null,
+      createId: () => 'notif_health',
+    })
+
+    assert.equal(result.created, true)
+    assert.equal(store.get('notif_health')?.title, 'SwarmClaw health alert')
+    assert.deepEqual(dispatched, [])
+  })
+})

package/src/lib/server/create-notification.ts

@@ -1,13 +1,14 @@
 import { genId } from '@/lib/id'
-import { saveNotification, hasUnreadNotificationWithKey } from '@/lib/server/storage'
+import { upsertNotificationRecord } from '@/lib/notification-utils'
+import { findNotificationByDedupKey, saveNotification } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
 import { dispatchAlert } from '@/lib/server/alert-dispatch'
 import type { AppNotification } from '@/types'
 
 /**
- * Create and persist a notification, then push a WS invalidation.
- * If `dedupKey` is provided and an unread notification with the same key
- * already exists, returns `null` (no insert, no WS push).
+ * Create or refresh a notification, then push a WS invalidation.
+ * Repeated events with the same `dedupKey` update one notification record
+ * instead of creating a new row every time.
  */
 export function createNotification(opts: {
   type: AppNotification['type']
@@ -18,27 +19,32 @@ export function createNotification(opts: {
   entityType?: string
   entityId?: string
   dedupKey?: string
-}): AppNotification | null {
-  if (opts.dedupKey && hasUnreadNotificationWithKey(opts.dedupKey)) {
-    return null
-  }
+  dispatchExternally?: boolean
+}, deps: {
+  now?: () => number
+  save?: (id: string, data: AppNotification) => void
+  notifyTopic?: (topic: string) => void
+  dispatch?: (notification: AppNotification) => Promise<unknown>
+  findByDedupKey?: (dedupKey: string) => AppNotification | null
+  createId?: () => string
+} = {}): { notification: AppNotification; created: boolean } {
+  const now = deps.now?.() ?? Date.now()
+  const save = deps.save ?? saveNotification
+  const emit = deps.notifyTopic ?? notify
+  const sendAlert = deps.dispatch ?? dispatchAlert
+  const existing = opts.dedupKey
+    ? (deps.findByDedupKey ?? findNotificationByDedupKey)(opts.dedupKey)
+    : null
+
+  const { notification, created } = upsertNotificationRecord(existing, opts, {
+    now,
+    createId: deps.createId ?? (() => genId()),
+  })
 
-  const id = genId()
-  const notification: AppNotification = {
-    id,
-    type: opts.type,
-    title: opts.title,
-    message: opts.message,
-    actionLabel: opts.actionLabel,
-    actionUrl: opts.actionUrl,
-    entityType: opts.entityType,
-    entityId: opts.entityId,
-    dedupKey: opts.dedupKey,
-    read: false,
-    createdAt: Date.now(),
+  save(notification.id, notification)
+  emit('notifications')
+  if (created && opts.dispatchExternally !== false) {
+    sendAlert(notification).catch(() => {})
   }
-  saveNotification(id, notification)
-  notify('notifications')
-  dispatchAlert(notification).catch(() => {})
-  return notification
+  return { notification, created }
 }

package/src/lib/server/daemon-state.test.ts

@@ -0,0 +1,50 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import {
+  buildSessionHeartbeatHealthDedupKey,
+  shouldSuppressSyntheticAgentHealthAlert,
+  shouldSuppressSessionHeartbeatHealthAlert,
+} from './daemon-state'
+
+describe('daemon heartbeat health alerts', () => {
+  it('suppresses synthetic workbench and benchmark sessions', () => {
+    assert.equal(shouldSuppressSessionHeartbeatHealthAlert({
+      id: 'wb-123',
+      name: 'Workbench wb-123',
+      user: 'workbench',
+      shortcutForAgentId: null,
+    }), true)
+
+    assert.equal(shouldSuppressSessionHeartbeatHealthAlert({
+      id: 'agent-chat-cmp-1',
+      name: 'Assistant Benchmark seo_content',
+      user: 'default',
+      shortcutForAgentId: 'cmp-sc-2026-03-08t19-15-21-415z-seo_content-agent',
+    }), true)
+
+    assert.equal(shouldSuppressSessionHeartbeatHealthAlert({
+      id: 'agent-chat-real-1',
+      name: 'Molly',
+      user: 'default',
+      shortcutForAgentId: 'agent-real-1',
+    }), false)
+  })
+
+  it('builds stable per-session heartbeat dedup keys', () => {
+    assert.equal(
+      buildSessionHeartbeatHealthDedupKey('session-123', 'stale'),
+      'health-alert:session-heartbeat:stale:session-123',
+    )
+    assert.equal(
+      buildSessionHeartbeatHealthDedupKey('session-123', 'auto-disabled'),
+      'health-alert:session-heartbeat:auto-disabled:session-123',
+    )
+  })
+
+  it('suppresses synthetic benchmark agent health alerts', () => {
+    assert.equal(shouldSuppressSyntheticAgentHealthAlert('wb-wb-20260308190158-blog-outline'), true)
+    assert.equal(shouldSuppressSyntheticAgentHealthAlert('cmp-oc-2026-03-08t19-15-21-755z-agent'), true)
+    assert.equal(shouldSuppressSyntheticAgentHealthAlert('agent-real-123'), false)
+  })
+})