@swarmclawai/swarmclaw 0.6.6 → 0.6.7

package/src/lib/server/connectors/manager.ts

@@ -3,7 +3,9 @@ import {
   loadConnectors, saveConnectors, loadSessions, saveSessions,
   loadAgents, loadCredentials, decryptKey, loadSettings, loadSkills,
   loadChatrooms, saveChatrooms,
+  upsertConnectorHealthEvent,
 } from '../storage'
+import type { ConnectorHealthEventType } from '@/types'
 import { WORKSPACE_DIR } from '../data-dir'
 import { UPLOAD_DIR } from '../storage'
 import fs from 'fs'
@@ -24,6 +26,7 @@ import {
   resolveApiKey as resolveApiKeyHelper,
 } from '../chatroom-helpers'
 import { filterHealthyChatroomAgents } from '../chatroom-health'
+import { evaluateRoutingRules } from '../chatroom-routing'
 import { markProviderFailure, markProviderSuccess } from '../provider-health'
 import { getProvider } from '@/lib/providers'
 import type { Connector, MessageSource, Chatroom, ChatroomMessage } from '@/types'
@@ -276,6 +279,35 @@ const followupKey = '__swarmclaw_connector_followups__' as const
 const scheduledFollowups: Map<string, ScheduledConnectorFollowup> =
   g[followupKey] ?? (g[followupKey] = new Map<string, ScheduledConnectorFollowup>())
 
+/** Reconnect state per connector — tracks backoff and retry attempts for crash recovery */
+export interface ConnectorReconnectState {
+  attempts: number
+  lastAttemptAt: number
+  nextRetryAt: number
+  backoffMs: number
+  error: string
+}
+
+const reconnectStateKey = '__swarmclaw_connector_reconnect_state__' as const
+const reconnectState: Map<string, ConnectorReconnectState> =
+  g[reconnectStateKey] ?? (g[reconnectStateKey] = new Map<string, ConnectorReconnectState>())
+
+const RECONNECT_INITIAL_BACKOFF_MS = 1_000
+const RECONNECT_MAX_BACKOFF_MS = 5 * 60 * 1_000
+const RECONNECT_MAX_ATTEMPTS = 10
+
+/** Record a health event for a connector (persisted to connector_health collection) */
+function recordHealthEvent(connectorId: string, event: ConnectorHealthEventType, message?: string): void {
+  const id = genId()
+  upsertConnectorHealthEvent(id, {
+    id,
+    connectorId,
+    event,
+    message: message || undefined,
+    timestamp: new Date().toISOString(),
+  })
+}
+
 type RouteMessageHandler = (connector: Connector, msg: InboundMessage) => Promise<string>
 const routeHandlerKey = '__swarmclaw_connector_route_handler__' as const
 const routeMessageHandlerRef: { current: RouteMessageHandler } =
@@ -314,6 +346,7 @@ export async function getPlatform(platform: string) {
     case 'teams':     return (await import('./teams')).default
     case 'googlechat': return (await import('./googlechat')).default
     case 'matrix':    return (await import('./matrix')).default
+    case 'email':     return (await import('./email')).default
     default: throw new Error(`Unknown platform: ${platform}`)
   }
 }
@@ -691,7 +724,12 @@ async function routeMessageToChatroom(connector: Connector, msg: InboundMessage)
 
   // Parse mentions from the message text
   let mentions = parseMentions(msg.text || '', agents, chatroom.agentIds)
-  // Auto-address: if enabled and no explicit mentions, address all agents
+  // Routing rules: if no explicit mentions, evaluate keyword/capability rules
+  if (mentions.length === 0 && chatroom.routingRules?.length) {
+    const agentList = chatroom.agentIds.map((id) => agents[id]).filter(Boolean)
+    mentions = evaluateRoutingRules(msg.text || '', chatroom.routingRules, agentList)
+  }
+  // Auto-address: if enabled and still no mentions, address all agents
   if (chatroom.autoAddress && mentions.length === 0) {
     mentions = [...chatroom.agentIds]
   }
@@ -1313,7 +1351,7 @@ async function _startConnectorImpl(connectorId: string): Promise<void> {
     botToken = connector.config.password
   }
 
-  if (!botToken && connector.platform !== 'whatsapp' && connector.platform !== 'openclaw' && connector.platform !== 'signal') {
+  if (!botToken && connector.platform !== 'whatsapp' && connector.platform !== 'openclaw' && connector.platform !== 'signal' && connector.platform !== 'email') {
     throw new Error('No bot token configured')
   }
 
@@ -1340,14 +1378,17 @@ async function _startConnectorImpl(connectorId: string): Promise<void> {
     notify('connectors')
 
     console.log(`[connector] Started ${connector.platform} connector: ${connector.name}`)
+    recordHealthEvent(connectorId, 'started', `${connector.platform} connector "${connector.name}" started`)
   } catch (err: unknown) {
+    const errMsg = err instanceof Error ? err.message : String(err)
     connector.status = 'error'
     connector.isEnabled = false
-    connector.lastError = err instanceof Error ? err.message : String(err)
+    connector.lastError = errMsg
     connector.updatedAt = Date.now()
     connectors[connectorId] = connector
     saveConnectors(connectors)
     notify('connectors')
+    recordHealthEvent(connectorId, 'error', errMsg)
     throw err
   }
 }
@@ -1379,6 +1420,7 @@ export async function stopConnector(connectorId: string): Promise<void> {
   }
 
   console.log(`[connector] Stopped connector: ${connectorId}`)
+  recordHealthEvent(connectorId, 'stopped', `Connector stopped`)
 }
 
 /** Get the runtime status of a connector */
@@ -1659,3 +1701,117 @@ export function scheduleConnectorFollowUp(params: {
 
   return { followUpId, sendAt }
 }
+
+/**
+ * Check health of all running connectors via `isAlive()`.
+ * Dead connectors that are still enabled get automatic reconnection with exponential backoff.
+ * After RECONNECT_MAX_ATTEMPTS, the connector is marked as error and retries stop.
+ */
+export async function checkConnectorHealth(): Promise<void> {
+  const connectors = loadConnectors()
+  let connectorsDirty = false
+
+  for (const [id, instance] of running.entries()) {
+    // If the instance has no isAlive method, skip (e.g. OpenClaw, BlueBubbles)
+    if (typeof instance.isAlive !== 'function') continue
+
+    if (instance.isAlive()) {
+      // Connector is healthy — clear any reconnect state
+      if (reconnectState.has(id)) {
+        console.log(`[connector-health] Connector "${instance.connector.name}" recovered`)
+        reconnectState.delete(id)
+      }
+      continue
+    }
+
+    // Connector is dead but still in the running Map
+    console.warn(`[connector-health] Connector "${instance.connector.name}" (${id}) isAlive=false — removing from running`)
+    recordHealthEvent(id, 'disconnected', `Connector "${instance.connector.name}" detected as dead (isAlive=false)`)
+
+    // Clean up the dead instance
+    try { await instance.stop() } catch { /* ignore */ }
+    running.delete(id)
+
+    const connector = connectors[id] as Connector | undefined
+    if (!connector) continue
+
+    // If the connector is not enabled, don't attempt reconnect
+    if (!connector.isEnabled) {
+      reconnectState.delete(id)
+      continue
+    }
+
+    // Attempt reconnect with backoff
+    const state = reconnectState.get(id) ?? {
+      attempts: 0,
+      lastAttemptAt: 0,
+      nextRetryAt: 0,
+      backoffMs: RECONNECT_INITIAL_BACKOFF_MS,
+      error: '',
+    }
+
+    // Check if we've exceeded max attempts
+    if (state.attempts >= RECONNECT_MAX_ATTEMPTS) {
+      console.warn(`[connector-health] Connector "${connector.name}" exceeded ${RECONNECT_MAX_ATTEMPTS} reconnect attempts — marking as error`)
+      connector.status = 'error'
+      connector.lastError = `Auto-reconnect gave up after ${RECONNECT_MAX_ATTEMPTS} attempts: ${state.error}`
+      connector.updatedAt = Date.now()
+      connectors[id] = connector
+      connectorsDirty = true
+      reconnectState.delete(id)
+      notify('connectors')
+      continue
+    }
+
+    const now = Date.now()
+
+    // Check if enough time has passed for the next retry
+    if (now < state.nextRetryAt) {
+      // Not yet time to retry — keep state and skip
+      continue
+    }
+
+    state.attempts += 1
+    state.lastAttemptAt = now
+    reconnectState.set(id, state)
+
+    try {
+      console.log(`[connector-health] Reconnecting "${connector.name}" (attempt ${state.attempts}/${RECONNECT_MAX_ATTEMPTS})`)
+      await startConnector(id)
+      // Success — clear reconnect state
+      reconnectState.delete(id)
+      console.log(`[connector-health] Connector "${connector.name}" reconnected successfully`)
+      recordHealthEvent(id, 'reconnected', `Connector "${connector.name}" reconnected after ${state.attempts} attempt(s)`)
+    } catch (err: unknown) {
+      const errorMsg = err instanceof Error ? err.message : String(err)
+      state.error = errorMsg
+      state.backoffMs = Math.min(RECONNECT_MAX_BACKOFF_MS, RECONNECT_INITIAL_BACKOFF_MS * (2 ** state.attempts))
+      state.nextRetryAt = now + state.backoffMs
+      reconnectState.set(id, state)
+      console.warn(`[connector-health] Reconnect failed for "${connector.name}" (attempt ${state.attempts}/${RECONNECT_MAX_ATTEMPTS}): ${errorMsg}. Next retry at ${new Date(state.nextRetryAt).toISOString()}`)
+    }
+  }
+
+  if (connectorsDirty) {
+    saveConnectors(connectors)
+  }
+
+  // Purge reconnect state for connectors that no longer exist
+  for (const id of reconnectState.keys()) {
+    if (!connectors[id]) reconnectState.delete(id)
+  }
+}
+
+/** Get the reconnect state for a specific connector (null if not in reconnect cycle) */
+export function getReconnectState(connectorId: string): ConnectorReconnectState | null {
+  return reconnectState.get(connectorId) ?? null
+}
+
+/** Get all reconnect states (for dashboard/API) */
+export function getAllReconnectStates(): Record<string, ConnectorReconnectState> {
+  const result: Record<string, ConnectorReconnectState> = {}
+  for (const [id, state] of reconnectState.entries()) {
+    result[id] = { ...state }
+  }
+  return result
+}

package/src/lib/server/connectors/openclaw.ts

@@ -1185,6 +1185,9 @@ const openclaw: PlatformConnector = {
           throw err
         }
       },
+      isAlive() {
+        return !stopped && connected && !!ws && ws.readyState === WebSocket.OPEN
+      },
       async stop() {
         stopped = true
         cleanupSocket()

package/src/lib/server/connectors/slack.ts

@@ -193,8 +193,13 @@ const slack: PlatformConnector = {
     await app.start()
     console.log(`[slack] Bot connected (socket mode)`)
 
+    let appStopped = false
+
     return {
       connector,
+      isAlive() {
+        return !appStopped && !!app.client
+      },
       async sendMessage(channelId, text, options) {
         const webClient = app.client
 
@@ -248,6 +253,7 @@ const slack: PlatformConnector = {
         return { messageId: lastTs }
       },
       async stop() {
+        appStopped = true
         await app.stop()
         console.log(`[slack] Bot disconnected`)
       },

package/src/lib/server/connectors/telegram.ts

@@ -40,8 +40,18 @@ const telegram: PlatformConnector = {
     bot.on('message', async (ctx) => {
       if (!ctx.message || !ctx.from || !ctx.chat) return
       const chatId = String(ctx.chat.id)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       const raw = ctx.message as any
       const text = raw.text || raw.caption || ''
+
+      // Filter out Telegram service/system messages (read receipts, reactions, etc.)
+      // that appear as short bracketed strings like [rr], [e], [read] etc.
+      const hasMedia = raw.photo || raw.video || raw.audio || raw.voice || raw.document || raw.animation
+      if (!hasMedia && /^\[.{1,5}\]$/.test(text.trim())) {
+        console.log(`[telegram] Ignoring system event from ${ctx.from.first_name}: ${text}`)
+        return
+      }
+
       console.log(`[telegram] Message from ${ctx.from.first_name} (chat=${chatId}): ${String(text).slice(0, 80)}`)
 
       // Filter by allowed chats if configured
@@ -157,6 +167,9 @@ const telegram: PlatformConnector = {
       }
     })
 
+    // Track whether the bot is actively polling
+    let botRunning = true
+
     // Start polling — not awaited (runs in background)
     bot.start({
       allowed_updates: ['message', 'edited_message'],
@@ -164,11 +177,15 @@ const telegram: PlatformConnector = {
         console.log(`[telegram] Bot started as @${botInfo.username} — polling for updates`)
       },
     }).catch((err) => {
+      botRunning = false
       console.error(`[telegram] Polling stopped with error:`, err.message || err)
     })
 
     return {
       connector,
+      isAlive() {
+        return botRunning
+      },
       async sendMessage(channelId, text, options) {
         const chatId = channelId
         const caption = options?.caption || text || undefined
@@ -221,6 +238,7 @@ const telegram: PlatformConnector = {
         return { messageId: lastId }
       },
       async stop() {
+        botRunning = false
         await bot.stop()
         console.log(`[telegram] Bot stopped`)
       },

package/src/lib/server/connectors/types.ts

@@ -62,6 +62,8 @@ export interface ConnectorInstance {
   deleteMessage?: (channelId: string, messageId: string) => Promise<void>
   /** Rich messaging: pin a message */
   pinMessage?: (channelId: string, messageId: string) => Promise<void>
+  /** Health check: returns true if the underlying connection is alive */
+  isAlive?: () => boolean
 }
 
 /** Platform-specific connector implementation */

package/src/lib/server/connectors/whatsapp.ts

@@ -66,6 +66,15 @@ const whatsapp: PlatformConnector = {
       qrDataUrl: null,
       authenticated: false,
       hasCredentials: hasStoredCreds(authDir),
+      isAlive() {
+        if (stopped || !sock) return false
+        // Check the underlying WebSocket connection state
+        const ws = sock.ws
+        if (!ws) return false
+        // If authenticated, the connection is alive
+        // If we have a socket but not yet authenticated (QR phase), still considered alive
+        return !stopped
+      },
       async sendMessage(channelId, text, options) {
         if (!sock) throw new Error('WhatsApp connector is not connected')
         const normalizedText = formatTextForWhatsApp(text || '')

package/src/lib/server/cost.ts

@@ -29,3 +29,73 @@ export function estimateCost(model: string, inputTokens: number, outputTokens: n
 export function getModelCosts(): Record<string, [number, number]> {
   return { ...MODEL_COSTS }
 }
+
+// --- Agent Monthly Budget ---
+
+import { loadUsage, loadSessions } from './storage'
+import type { Agent, UsageRecord } from '@/types'
+
+/**
+ * Sum the estimated cost for an agent in the current calendar month.
+ * Usage records are keyed by sessionId; we resolve agentId through sessions.
+ */
+export function getAgentMonthlySpend(agentId: string): number {
+  const sessions = loadSessions()
+  // Build a set of sessionIds linked to this agent
+  const agentSessionIds = new Set<string>()
+  for (const [sid, session] of Object.entries(sessions)) {
+    if (session?.agentId === agentId) agentSessionIds.add(sid)
+  }
+  if (agentSessionIds.size === 0) return 0
+
+  const now = new Date()
+  const monthStart = new Date(now.getFullYear(), now.getMonth(), 1).getTime()
+
+  const usage = loadUsage()
+  let total = 0
+  for (const sid of agentSessionIds) {
+    const records = usage[sid]
+    if (!Array.isArray(records)) continue
+    for (const record of records) {
+      const r = record as UsageRecord
+      if (typeof r.timestamp !== 'number' || r.timestamp < monthStart) continue
+      if (typeof r.estimatedCost === 'number' && Number.isFinite(r.estimatedCost) && r.estimatedCost > 0) {
+        total += r.estimatedCost
+      }
+    }
+  }
+  return total
+}
+
+export interface BudgetCheckResult {
+  ok: boolean
+  spend: number
+  budget: number
+  message?: string
+}
+
+/**
+ * Check whether an agent is within its monthly budget.
+ * Returns ok: true if no budget is set or spend is under the cap.
+ */
+export function checkBudget(agent: Agent): BudgetCheckResult {
+  const budget = typeof agent.monthlyBudget === 'number' && Number.isFinite(agent.monthlyBudget) && agent.monthlyBudget > 0
+    ? agent.monthlyBudget
+    : 0
+
+  if (budget <= 0) {
+    return { ok: true, spend: 0, budget: 0 }
+  }
+
+  const spend = getAgentMonthlySpend(agent.id)
+  if (spend >= budget) {
+    return {
+      ok: false,
+      spend,
+      budget,
+      message: `Agent "${agent.name}" has reached its monthly budget: $${spend.toFixed(4)} spent of $${budget.toFixed(2)} cap.`,
+    }
+  }
+
+  return { ok: true, spend, budget }
+}

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

@@ -1,6 +1,7 @@
 import { genId } from '@/lib/id'
 import { saveNotification, hasUnreadNotificationWithKey } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
+import { dispatchAlert } from '@/lib/server/alert-dispatch'
 import type { AppNotification } from '@/types'
 
 /**
@@ -38,5 +39,6 @@ export function createNotification(opts: {
   }
   saveNotification(id, notification)
   notify('notifications')
+  dispatchAlert(notification).catch(() => {})
   return notification
 }

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

@@ -10,6 +10,7 @@ import {
   sendConnectorMessage,
   startConnector,
   getConnectorStatus,
+  checkConnectorHealth,
 } from './connectors/manager'
 import { startHeartbeatService, stopHeartbeatService, getHeartbeatServiceStatus } from './heartbeat-service'
 import { hasOpenClawAgents, ensureGatewayConnected, disconnectGateway, getGateway } from './openclaw-gateway'
@@ -82,6 +83,10 @@ const ds: {
   /** Session IDs we've already alerted as stale (alert-once semantics). */
   staleSessionIds: Set<string>
   connectorRestartState: Map<string, { lastAttemptAt: number; failCount: number; wakeAttempts: number }>
+  /** OpenClaw gateway agent IDs currently considered down. */
+  openclawDownAgentIds: Set<string>
+  /** Per-agent auto-repair state for OpenClaw gateways. */
+  openclawRepairState: Map<string, { attempts: number; lastAttemptAt: number; cooldownUntil: number }>
   manualStopRequested: boolean
   running: boolean
   lastProcessedAt: number | null
@@ -94,6 +99,8 @@ const ds: {
   memoryConsolidationIntervalId: null,
   staleSessionIds: new Set<string>(),
   connectorRestartState: new Map<string, { lastAttemptAt: number; failCount: number; wakeAttempts: number }>(),
+  openclawDownAgentIds: new Set<string>(),
+  openclawRepairState: new Map<string, { attempts: number; lastAttemptAt: number; cooldownUntil: number }>(),
   manualStopRequested: false,
   running: false,
   lastProcessedAt: null,
@@ -102,6 +109,8 @@ const ds: {
 // Backfill fields for hot-reloaded daemon state objects from older code versions.
 if (!ds.staleSessionIds) ds.staleSessionIds = new Set<string>()
 if (!ds.connectorRestartState) ds.connectorRestartState = new Map<string, { lastAttemptAt: number; failCount: number; wakeAttempts: number }>()
+if (!ds.openclawDownAgentIds) ds.openclawDownAgentIds = new Set<string>()
+if (!ds.openclawRepairState) ds.openclawRepairState = new Map<string, { attempts: number; lastAttemptAt: number; cooldownUntil: number }>()
 // Migrate from old issueLastAlertAt map if present (HMR across code versions)
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 if ((ds as any).issueLastAlertAt) delete (ds as any).issueLastAlertAt
@@ -247,6 +256,13 @@ async function sendHealthAlert(text: string) {
 }
 
 async function runConnectorHealthChecks(now: number) {
+  // First, check isAlive() on running instances and attempt reconnection for dead ones
+  try {
+    await checkConnectorHealth()
+  } catch (err: unknown) {
+    console.error('[health] Connector isAlive check failed:', err instanceof Error ? err.message : String(err))
+  }
+
   const connectors = loadConnectors()
   for (const connector of Object.values(connectors) as Record<string, unknown>[]) {
     if (!connector?.id || typeof connector.id !== 'string') continue
@@ -533,6 +549,107 @@ async function runProviderHealthChecks() {
   }
 }
 
+const OPENCLAW_REPAIR_MAX_ATTEMPTS = 3
+const OPENCLAW_REPAIR_COOLDOWN_MS = 300_000 // 5 minutes
+
+async function runOpenClawGatewayHealthChecks() {
+  const agents = loadAgents()
+  const credentials = loadCredentials()
+
+  // Build deduplicated OpenClaw agent tuples
+  const seen = new Set<string>()
+  const tuples: { agentId: string; endpoint: string; credentialId: string; credentialName: string }[] = []
+
+  for (const agent of Object.values(agents) as Record<string, unknown>[]) {
+    if (!agent?.id || typeof agent.id !== 'string') continue
+    if (agent.provider !== 'openclaw') continue
+
+    const key = `openclaw:${agent.id}`
+    if (seen.has(key)) continue
+    seen.add(key)
+
+    const credentialId = typeof agent.credentialId === 'string' ? agent.credentialId : ''
+    const endpoint = typeof agent.apiEndpoint === 'string' ? agent.apiEndpoint : ''
+    const cred = credentialId ? (credentials[credentialId] as Record<string, unknown> | undefined) : undefined
+    const credName = typeof cred?.name === 'string' ? cred.name : 'openclaw'
+
+    tuples.push({ agentId: agent.id, endpoint, credentialId, credentialName: credName })
+  }
+
+  if (!tuples.length) return
+
+  const { probeOpenClawHealth } = await import('./openclaw-health')
+
+  for (const tuple of tuples) {
+    let token: string | undefined
+    if (tuple.credentialId) {
+      const cred = credentials[tuple.credentialId] as Record<string, unknown> | undefined
+      if (cred?.encryptedKey && typeof cred.encryptedKey === 'string') {
+        try { token = decryptKey(cred.encryptedKey) } catch { continue }
+      }
+    }
+
+    const result = await probeOpenClawHealth({
+      endpoint: tuple.endpoint || undefined,
+      token,
+      timeoutMs: 10_000,
+    })
+
+    const now = Date.now()
+
+    if (result.ok) {
+      // Recovered
+      if (ds.openclawDownAgentIds.has(tuple.agentId)) {
+        ds.openclawDownAgentIds.delete(tuple.agentId)
+        ds.openclawRepairState.delete(tuple.agentId)
+        createNotification({
+          type: 'success',
+          title: 'OpenClaw gateway recovered',
+          message: `Gateway for ${tuple.credentialName} is reachable again.`,
+          dedupKey: `openclaw-gw-down:${tuple.agentId}`,
+        })
+      }
+      continue
+    }
+
+    // Unhealthy
+    const repair = ds.openclawRepairState.get(tuple.agentId) || { attempts: 0, lastAttemptAt: 0, cooldownUntil: 0 }
+
+    // In cooldown — skip
+    if (repair.cooldownUntil > now) continue
+
+    // Cooldown expired — reset
+    if (repair.cooldownUntil > 0 && repair.cooldownUntil <= now) {
+      repair.attempts = 0
+      repair.cooldownUntil = 0
+    }
+
+    ds.openclawDownAgentIds.add(tuple.agentId)
+
+    if (repair.attempts < OPENCLAW_REPAIR_MAX_ATTEMPTS) {
+      try {
+        const { runOpenClawDoctor } = await import('./openclaw-doctor')
+        await runOpenClawDoctor({ fix: true })
+      } catch (err: unknown) {
+        console.warn('[daemon] openclaw doctor --fix failed:', err instanceof Error ? err.message : String(err))
+      }
+      repair.attempts += 1
+      repair.lastAttemptAt = now
+    } else {
+      repair.cooldownUntil = now + OPENCLAW_REPAIR_COOLDOWN_MS
+    }
+
+    ds.openclawRepairState.set(tuple.agentId, repair)
+
+    createNotification({
+      type: 'error',
+      title: `OpenClaw gateway unreachable: ${tuple.credentialName}`,
+      message: result.error || 'Health check failed',
+      dedupKey: `openclaw-gw-down:${tuple.agentId}`,
+    })
+  }
+}
+
 async function runHealthChecks() {
   // Continuously keep the completed queue honest.
   validateCompletedTasksQueue()
@@ -601,6 +718,13 @@ async function runHealthChecks() {
     console.error('[daemon] Provider health check failed:', err instanceof Error ? err.message : String(err))
   }
 
+  // OpenClaw gateway health checks + auto-repair
+  try {
+    await runOpenClawGatewayHealthChecks()
+  } catch (err: unknown) {
+    console.error('[daemon] OpenClaw gateway health check failed:', err instanceof Error ? err.message : String(err))
+  }
+
   // Process webhook retry queue
   try {
     await processWebhookRetries()