@swarmclawai/swarmclaw 0.8.2 → 0.8.3

package/src/lib/api-client.ts

@@ -5,6 +5,7 @@ const ACCESS_KEY_STORAGE = 'sc_access_key'
 const DEFAULT_API_TIMEOUT_MS = 12_000
 const DEFAULT_GET_RETRIES = 2
 const RETRY_DELAY_BASE_MS = 300
+const inflightGetRequests = new Map<string, Promise<unknown>>()
 
 export function getStoredAccessKey(): string {
   return safeStorageGet(ACCESS_KEY_STORAGE) || ''
@@ -27,6 +28,10 @@ function isAbortError(err: unknown): boolean {
   return (err as { name?: string }).name === 'AbortError'
 }
 
+function buildInflightGetKey(path: string, key: string): string {
+  return `${key}::${path}`
+}
+
 export async function api<T = unknown>(
   method: string,
   path: string,
@@ -47,42 +52,60 @@ export async function api<T = unknown>(
   }
   if (body) requestInit.body = JSON.stringify(body)
 
-  for (let attempt = 0; attempt <= retries; attempt++) {
-    try {
-      const r = await fetchWithTimeout('/api' + path, requestInit, timeoutMs)
+  const runRequest = async (): Promise<T> => {
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        const r = await fetchWithTimeout('/api' + path, requestInit, timeoutMs)
 
-      if (r.status === 401) {
-        // Clear stored key on auth failure, redirect to login
-        clearStoredAccessKey()
-        if (typeof window !== 'undefined') {
-          window.dispatchEvent(new Event('sc_auth_required'))
+        if (r.status === 401) {
+          // Clear stored key on auth failure, redirect to login
+          clearStoredAccessKey()
+          if (typeof window !== 'undefined') {
+            window.dispatchEvent(new Event('sc_auth_required'))
+          }
+          throw new Error('Unauthorized — invalid access key')
         }
-        throw new Error('Unauthorized — invalid access key')
-      }
 
-      const ct = r.headers.get('content-type') || ''
+        const ct = r.headers.get('content-type') || ''
 
-      if (!r.ok) {
-        if (ct.includes('json')) {
-          const payload = await r.json().catch(() => null) as { error?: unknown; message?: unknown } | null
-          const msg =
-            (typeof payload?.error === 'string' && payload.error.trim())
-            || (typeof payload?.message === 'string' && payload.message.trim())
-            || `Request failed (${r.status})`
-          throw new Error(msg)
+        if (!r.ok) {
+          if (ct.includes('json')) {
+            const payload = await r.json().catch(() => null) as { error?: unknown; message?: unknown } | null
+            const msg =
+              (typeof payload?.error === 'string' && payload.error.trim())
+              || (typeof payload?.message === 'string' && payload.message.trim())
+              || `Request failed (${r.status})`
+            throw new Error(msg)
+          }
+          const text = (await r.text().catch(() => '')).trim()
+          throw new Error(text || `Request failed (${r.status})`)
         }
-        const text = (await r.text().catch(() => '')).trim()
-        throw new Error(text || `Request failed (${r.status})`)
-      }
 
-      if (ct.includes('json')) return r.json() as Promise<T>
-      return r.text() as unknown as T
-    } catch (err) {
-      const isLastAttempt = attempt >= retries
-      const retryable = isAbortError(err) || (err instanceof TypeError && !String(err.message || '').includes('Unauthorized'))
-      if (isLastAttempt || !retryable) throw err
-      await sleep(RETRY_DELAY_BASE_MS * (attempt + 1))
+        if (ct.includes('json')) return r.json() as Promise<T>
+        return r.text() as unknown as T
+      } catch (err) {
+        const isLastAttempt = attempt >= retries
+        const retryable = isAbortError(err) || (err instanceof TypeError && !String(err.message || '').includes('Unauthorized'))
+        if (isLastAttempt || !retryable) throw err
+        await sleep(RETRY_DELAY_BASE_MS * (attempt + 1))
+      }
     }
+    throw new Error('Request failed')
   }
-  throw new Error('Request failed')
+
+  if (upperMethod !== 'GET') {
+    return runRequest()
+  }
+
+  const inflightKey = buildInflightGetKey(path, key)
+  const existing = inflightGetRequests.get(inflightKey)
+  if (existing) return existing as Promise<T>
+
+  const requestPromise = runRequest().finally(() => {
+    if (inflightGetRequests.get(inflightKey) === requestPromise) {
+      inflightGetRequests.delete(inflightKey)
+    }
+  })
+  inflightGetRequests.set(inflightKey, requestPromise)
+  return requestPromise
 }

package/src/lib/chats.ts

@@ -8,6 +8,9 @@ export const fetchChats = () => api<Sessions>('GET', '/chats')
 /** @deprecated Use fetchChats */
 export const fetchSessions = fetchChats
 
+export const fetchChat = (id: string) =>
+  api<Session>('GET', `/chats/${id}`)
+
 export const createChat = (
   name: string,
   cwd: string,

package/src/lib/runtime-env.test.ts

@@ -0,0 +1,28 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { isDevelopmentLikeRuntime, isProductionRuntime } from './runtime-env'
+
+describe('runtime env helpers', () => {
+  it('treats missing NODE_ENV as development-like', () => {
+    const previousNodeEnv = process.env.NODE_ENV
+    delete process.env.NODE_ENV
+
+    assert.equal(isDevelopmentLikeRuntime(), true)
+    assert.equal(isProductionRuntime(), false)
+
+    if (previousNodeEnv === undefined) delete process.env.NODE_ENV
+    else process.env.NODE_ENV = previousNodeEnv
+  })
+
+  it('detects explicit production mode', () => {
+    const previousNodeEnv = process.env.NODE_ENV
+    process.env.NODE_ENV = 'production'
+
+    assert.equal(isDevelopmentLikeRuntime(), false)
+    assert.equal(isProductionRuntime(), true)
+
+    if (previousNodeEnv === undefined) delete process.env.NODE_ENV
+    else process.env.NODE_ENV = previousNodeEnv
+  })
+})

package/src/lib/runtime-env.ts

@@ -0,0 +1,13 @@
+function normalizedNodeEnv(): string {
+  return typeof process.env.NODE_ENV === 'string'
+    ? process.env.NODE_ENV.trim().toLowerCase()
+    : ''
+}
+
+export function isProductionRuntime(): boolean {
+  return normalizedNodeEnv() === 'production'
+}
+
+export function isDevelopmentLikeRuntime(): boolean {
+  return !isProductionRuntime()
+}

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

@@ -1362,7 +1362,7 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
   }
 
   // Periodic partial save so a browser refresh doesn't lose the in-flight response.
-  const PARTIAL_SAVE_INTERVAL_MS = 2000
+  const PARTIAL_SAVE_INTERVAL_MS = 3500
   const partialSaveTimer = setInterval(() => {
     persistStreamingAssistantArtifact()
   }, PARTIAL_SAVE_INTERVAL_MS)

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

@@ -990,8 +990,10 @@ function resolveDirectSession(params: {
   session.name = sessionKey
   session.agentId = agent.id
   session.plugins = Array.isArray(session.plugins) ? session.plugins : (agent.plugins || agent.tools || [])
-  if (!session.provider) session.provider = defaultProvider
-  if (!session.model) session.model = defaultModel
+  // Always sync provider/model from agent defaults so connector sessions
+  // track agent config changes (e.g. model renamed from glm-5 to glm-5:cloud).
+  session.provider = defaultProvider
+  session.model = defaultModel
   if (session.credentialId === undefined) session.credentialId = agent.credentialId || null
   if (!Array.isArray(session.fallbackCredentialIds) && Array.isArray(agent.fallbackCredentialIds)) {
     session.fallbackCredentialIds = [...agent.fallbackCredentialIds]

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

@@ -3,6 +3,7 @@ import { describe, it } from 'node:test'
 
 import {
   buildSessionHeartbeatHealthDedupKey,
+  isDaemonBackgroundServicesEnabled,
   shouldSuppressSyntheticAgentHealthAlert,
   shouldSuppressSessionHeartbeatHealthAlert,
 } from './daemon-state'
@@ -47,4 +48,26 @@ describe('daemon heartbeat health alerts', () => {
     assert.equal(shouldSuppressSyntheticAgentHealthAlert('cmp-oc-2026-03-08t19-15-21-755z-agent'), true)
     assert.equal(shouldSuppressSyntheticAgentHealthAlert('agent-real-123'), false)
   })
+
+  it('respects daemon background service overrides', () => {
+    const previousNodeEnv = process.env.NODE_ENV
+    const previousFlag = process.env.SWARMCLAW_DAEMON_BACKGROUND_SERVICES
+
+    process.env.NODE_ENV = 'development'
+    process.env.SWARMCLAW_DAEMON_BACKGROUND_SERVICES = 'true'
+    assert.equal(isDaemonBackgroundServicesEnabled(), true)
+
+    process.env.SWARMCLAW_DAEMON_BACKGROUND_SERVICES = 'false'
+    assert.equal(isDaemonBackgroundServicesEnabled(), false)
+
+    process.env.NODE_ENV = 'production'
+    process.env.SWARMCLAW_DAEMON_BACKGROUND_SERVICES = 'true'
+    assert.equal(isDaemonBackgroundServicesEnabled(), true)
+
+    if (previousNodeEnv === undefined) delete process.env.NODE_ENV
+    else process.env.NODE_ENV = previousNodeEnv
+
+    if (previousFlag === undefined) delete process.env.SWARMCLAW_DAEMON_BACKGROUND_SERVICES
+    else process.env.SWARMCLAW_DAEMON_BACKGROUND_SERVICES = previousFlag
+  })
 })

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

@@ -1,6 +1,6 @@
 import { loadQueue, loadSchedules, loadSessions, saveSessions, loadConnectors, saveConnectors, loadWebhookRetryQueue, upsertWebhookRetry, deleteWebhookRetry, loadWebhooks, loadAgents, loadSettings, appendWebhookLog, loadCredentials, decryptKey } from './storage'
 import { notify } from './ws-hub'
-import { processNext, cleanupFinishedTaskSessions, validateCompletedTasksQueue, recoverStalledRunningTasks } from './queue'
+import { processNext, cleanupFinishedTaskSessions, validateCompletedTasksQueue, recoverStalledRunningTasks, resumeQueue } from './queue'
 import { startScheduler, stopScheduler } from './scheduler'
 import { sweepOrphanedBrowsers, getActiveBrowserCount } from './session-tools'
 import {
@@ -24,6 +24,7 @@ import { enqueueSessionRun } from './session-run-manager'
 import { WORKSPACE_DIR } from './data-dir'
 import { DEFAULT_HEARTBEAT_INTERVAL_SEC } from '@/lib/heartbeat-defaults'
 import { genId } from '@/lib/id'
+import { isProductionRuntime } from '@/lib/runtime-env'
 import path from 'node:path'
 import type { Session, WebhookRetryEntry } from '@/types'
 import { createNotification } from '@/lib/server/create-notification'
@@ -40,7 +41,7 @@ const QUEUE_CHECK_INTERVAL = 30_000 // 30 seconds
 const BROWSER_SWEEP_INTERVAL = 60_000 // 60 seconds
 const BROWSER_MAX_AGE = 10 * 60 * 1000 // 10 minutes idle = orphaned
 const HEALTH_CHECK_INTERVAL = 120_000 // 2 minutes
-const CONNECTOR_HEALTH_CHECK_INTERVAL = 5_000 // 5 seconds
+const CONNECTOR_HEALTH_CHECK_INTERVAL = 15_000 // 15 seconds
 const MEMORY_CONSOLIDATION_INTERVAL = 6 * 3600_000 // 6 hours
 const MEMORY_CONSOLIDATION_INITIAL_DELAY = 60_000 // 1 minute after daemon start
 const STALE_MULTIPLIER = 4 // session is stale after N × heartbeat interval
@@ -62,7 +63,11 @@ function parseBoolish(value: unknown, fallback: boolean): boolean {
 }
 
 function daemonAutostartEnvEnabled(): boolean {
-  return parseBoolish(process.env.SWARMCLAW_DAEMON_AUTOSTART, true)
+  return parseBoolish(process.env.SWARMCLAW_DAEMON_AUTOSTART, isProductionRuntime())
+}
+
+export function isDaemonBackgroundServicesEnabled(): boolean {
+  return parseBoolish(process.env.SWARMCLAW_DAEMON_BACKGROUND_SERVICES, true)
 }
 
 function parseHeartbeatIntervalSec(value: unknown, fallback = DEFAULT_HEARTBEAT_INTERVAL_SEC): number {
@@ -186,11 +191,9 @@ export function startDaemon(options?: { source?: string; manualStart?: boolean }
     // (for example health monitor) were introduced in newer code.
     startQueueProcessor()
     startBrowserSweep()
-    startHealthMonitor()
-    startConnectorHealthMonitor()
     startHeartbeatService()
     startMemoryConsolidation()
-    startEvalScheduler()
+    syncDaemonBackgroundServices()
     return
   }
   ds.running = true
@@ -201,14 +204,13 @@ export function startDaemon(options?: { source?: string; manualStart?: boolean }
     validateCompletedTasksQueue()
     cleanupFinishedTaskSessions()
     recoverStaleDelegationJobs()
+    resumeQueue()
     startScheduler()
     startQueueProcessor()
     startBrowserSweep()
-    startHealthMonitor()
-    startConnectorHealthMonitor()
     startHeartbeatService()
     startMemoryConsolidation()
-    startEvalScheduler()
+    syncDaemonBackgroundServices()
   } catch (err: unknown) {
     ds.running = false
     notify('daemon')
@@ -216,10 +218,12 @@ export function startDaemon(options?: { source?: string; manualStart?: boolean }
     throw err
   }
 
-  // Auto-start enabled connectors
-  autoStartConnectors().catch((err: unknown) => {
-    console.error('[daemon] Error auto-starting connectors:', err instanceof Error ? err.message : String(err))
-  })
+  if (isDaemonBackgroundServicesEnabled()) {
+    // Auto-start enabled connectors only when the full background stack is enabled.
+    autoStartConnectors().catch((err: unknown) => {
+      console.error('[daemon] Error auto-starting connectors:', err instanceof Error ? err.message : String(err))
+    })
+  }
 }
 
 export function stopDaemon(options?: { source?: string; manualStop?: boolean }) {
@@ -272,6 +276,7 @@ function startQueueProcessor() {
       await processNext()
       ds.lastProcessedAt = Date.now()
     }
+    if (!isDaemonBackgroundServicesEnabled()) return
     // OpenClaw gateway lifecycle: lazy connect when openclaw agents exist, disconnect when none remain
     try {
       if (hasOpenClawAgents()) {
@@ -901,6 +906,18 @@ function stopHealthMonitor() {
   }
 }
 
+function syncDaemonBackgroundServices() {
+  if (isDaemonBackgroundServicesEnabled()) {
+    startHealthMonitor()
+    startConnectorHealthMonitor()
+    startEvalScheduler()
+    return
+  }
+  stopHealthMonitor()
+  stopConnectorHealthMonitor()
+  stopEvalScheduler()
+}
+
 function startConnectorHealthMonitor() {
   if (ds.connectorHealthIntervalId) return
 
@@ -1038,13 +1055,11 @@ function refreshDaemonTimersForHotReload() {
   if (ds.healthIntervalId) {
     clearInterval(ds.healthIntervalId)
     ds.healthIntervalId = null
-    startHealthMonitor()
   }
 
   if (ds.connectorHealthIntervalId) {
     clearInterval(ds.connectorHealthIntervalId)
     ds.connectorHealthIntervalId = null
-    startConnectorHealthMonitor()
   }
 
   if (ds.memoryConsolidationTimeoutId || ds.memoryConsolidationIntervalId) {
@@ -1054,8 +1069,9 @@ function refreshDaemonTimersForHotReload() {
 
   if (ds.evalSchedulerIntervalId) {
     stopEvalScheduler()
-    startEvalScheduler()
   }
+
+  syncDaemonBackgroundServices()
 }
 
 // In dev/HMR, the daemon state survives on globalThis while interval callbacks keep
@@ -1095,6 +1111,8 @@ export function getDaemonStatus() {
     running: ds.running,
     schedulerActive: ds.running,
     autostartEnabled: daemonAutostartEnvEnabled(),
+    backgroundServicesEnabled: isDaemonBackgroundServicesEnabled(),
+    reducedMode: !isDaemonBackgroundServicesEnabled(),
     manualStopRequested: ds.manualStopRequested,
     queueLength: queue.length,
     lastProcessed: ds.lastProcessedAt,

package/src/lib/server/heartbeat-service.ts

@@ -16,12 +16,21 @@ import { buildMainLoopHeartbeatPrompt, isMainSession } from './main-agent-loop'
 import { ensureAgentThreadSession } from './agent-thread-session'
 import { isAgentDisabled } from './agent-availability'
 
-const HEARTBEAT_TICK_MS = 5_000
+const HEARTBEAT_TICK_MS = 60_000
+const MAX_CONCURRENT_HEARTBEATS = 5
+const BACKOFF_BASE_MS = 10_000
+const BACKOFF_MAX_MS = 5 * 60_000
+
+interface FailureRecord {
+  count: number
+  lastFailedAt: number
+}
 
 interface HeartbeatState {
   timer: ReturnType<typeof setInterval> | null
   running: boolean
   lastBySession: Map<string, number>
+  failures: Map<string, FailureRecord>
 }
 
 const globalKey = '__swarmclaw_heartbeat_service__' as const
@@ -30,6 +39,7 @@ const state: HeartbeatState = globalScope[globalKey] ?? (globalScope[globalKey]
   timer: null,
   running: false,
   lastBySession: new Map<string, number>(),
+  failures: new Map<string, FailureRecord>(),
 })
 
 function parseIntBounded(value: unknown, fallback: number, min: number, max: number): number {
@@ -355,6 +365,13 @@ function shouldRunHeartbeats(settings: Record<string, any>): boolean {
   return loopMode === 'ongoing'
 }
 
+function isBackedOff(sessionId: string, now: number): boolean {
+  const record = state.failures.get(sessionId)
+  if (!record || record.count === 0) return false
+  const backoffMs = Math.min(BACKOFF_BASE_MS * Math.pow(2, record.count - 1), BACKOFF_MAX_MS)
+  return now < record.lastFailedAt + backoffMs
+}
+
 async function tickHeartbeats() {
   const settings = loadSettings()
   const globalOngoing = shouldRunHeartbeats(settings)
@@ -366,12 +383,23 @@ async function tickHeartbeats() {
   }
 
   const agents = loadAgents()
-  for (const agent of Object.values(agents) as any[]) {
-    if (!agent?.id || agent.heartbeatEnabled !== true || isAgentDisabled(agent)) continue
+  const hbAgents = (Object.values(agents) as any[]).filter(
+    (a) => a?.id && a.heartbeatEnabled === true && !isAgentDisabled(a),
+  )
+  for (const agent of hbAgents) {
     ensureAgentThreadSession(String(agent.id))
   }
+  const hasScopedAgents = hbAgents.length > 0
+
+  // Short-circuit: if no agents have heartbeat enabled and global loop mode is
+  // bounded, skip the expensive loadSessions() — nothing will be eligible.
+  if (!hasScopedAgents && !globalOngoing) {
+    // Prune any stale tracking entries
+    if (state.lastBySession.size > 0) state.lastBySession.clear()
+    return
+  }
+
   const sessions = loadSessions()
-  const hasScopedAgents = Object.values(agents).some((a: any) => a?.heartbeatEnabled === true && !isAgentDisabled(a))
 
   // Prune tracked sessions that no longer exist or have heartbeat disabled
   for (const trackedId of state.lastBySession.keys()) {
@@ -386,7 +414,11 @@ async function tickHeartbeats() {
     }
   }
 
+  let enqueued = 0
+
   for (const session of Object.values(sessions) as any[]) {
+    if (enqueued >= MAX_CONCURRENT_HEARTBEATS) break
+
     if (!session?.id) continue
     if (session.sessionType && session.sessionType !== 'human') continue
 
@@ -406,6 +438,8 @@ async function tickHeartbeats() {
     const cfg = heartbeatConfigForSession(session, settings, agents)
     if (!cfg.enabled) continue
 
+    if (isBackedOff(session.id, now)) continue
+
     // For sessions with explicit opt-in, use a shorter idle threshold (just intervalSec * 2).
     // For inherited/global heartbeats, keep the 180s minimum to avoid noisy auto-fire.
     const defaultIdleSec = explicitOptIn
@@ -461,11 +495,20 @@ async function tickHeartbeats() {
       },
     })
 
-    // Set timestamp AFTER successful enqueue so a busy session retries next tick
+    enqueued++
     state.lastBySession.set(session.id, now)
 
-    enqueue.promise.catch((err) => {
-      log.warn('heartbeat', `Heartbeat run failed for session ${session.id}`, err?.message || String(err))
+    const sid = session.id as string
+    enqueue.promise.then(() => {
+      state.failures.delete(sid)
+    }).catch((err: unknown) => {
+      const prev = state.failures.get(sid)
+      state.failures.set(sid, {
+        count: (prev?.count ?? 0) + 1,
+        lastFailedAt: Date.now(),
+      })
+      const msg = err instanceof Error ? err.message : String(err)
+      log.warn('heartbeat', `Heartbeat run failed for session ${sid}`, msg)
     })
   }
 }
@@ -475,11 +518,20 @@ async function tickHeartbeats() {
  * doesn't cause every session to fire a heartbeat immediately on the first tick.
  */
 function seedLastActive() {
+  const agents = loadAgents()
+  const hbAgentIds = new Set(
+    (Object.values(agents) as Record<string, unknown>[])
+      .filter((a) => a?.heartbeatEnabled === true && !isAgentDisabled(a))
+      .map((a) => String(a.id)),
+  )
   const sessions = loadSessions()
   for (const session of Object.values(sessions) as any[]) {
     if (!session?.id) continue
+    // Only seed sessions that are actually heartbeat-eligible
+    const eligible = session.heartbeatEnabled === true
+      || (session.agentId && hbAgentIds.has(session.agentId))
+    if (!eligible) continue
     if (typeof session.lastActiveAt === 'number' && session.lastActiveAt > 0) {
-      // Only seed entries we don't already have (preserves HMR state)
       if (!state.lastBySession.has(session.id)) {
         state.lastBySession.set(session.id, session.lastActiveAt)
       }
@@ -515,6 +567,7 @@ export function stopHeartbeatService() {
 export function restartHeartbeatService() {
   stopHeartbeatService()
   state.lastBySession.clear()
+  state.failures.clear()
   startHeartbeatService()
 }
 

package/src/lib/server/plugins.ts

@@ -638,6 +638,17 @@ interface LoadedPlugin {
   isBuiltin?: boolean
 }
 
+function createPluginRequire(): NodeRequire | null {
+  try {
+    return createRequire(path.join(process.cwd(), 'package.json'))
+  } catch (err: unknown) {
+    log.warn('plugins', 'createRequire failed; external plugins disabled', {
+      error: err instanceof Error ? err.message : String(err),
+    })
+    return null
+  }
+}
+
 export interface ExternalPluginToolEntry {
   pluginId: string
   pluginName: string
@@ -1000,15 +1011,7 @@ class PluginManager {
     try {
       this.ensurePluginDirs()
       const files = fs.readdirSync(PLUGINS_DIR).filter(f => f.endsWith('.js') || f.endsWith('.mjs'))
-      
-      let dynamicRequire: NodeRequire | null = null
-      try {
-        dynamicRequire = createRequire(path.join(process.cwd(), 'package.json'))
-      } catch (err: unknown) {
-        log.warn('plugins', 'createRequire failed; external plugins disabled', {
-          error: err instanceof Error ? err.message : String(err),
-        })
-      }
+      const dynamicRequire = createPluginRequire()
 
       if (dynamicRequire) {
         for (const file of files) {

package/src/lib/server/queue.ts

@@ -1967,7 +1967,7 @@ export function recoverStalledRunningTasks(): { recovered: number; deadLettered:
       const recoveredAt = Date.now()
       task.status = 'queued'
       task.queuedAt = task.queuedAt || recoveredAt
-      task.retryScheduledAt = null
+      task.retryScheduledAt = Date.now() + 30_000
       task.updatedAt = recoveredAt
       task.error = 'Recovered inconsistent running state (missing startedAt); requeued.'
       if (!task.comments) task.comments = []
@@ -1994,6 +1994,7 @@ export function recoverStalledRunningTasks(): { recovered: number; deadLettered:
     disableSessionHeartbeat(task.sessionId)
     changed = true
     if (state === 'retry') {
+      task.retryScheduledAt = Date.now() + 30_000
       pushQueueUnique(queue, task.id)
       recovered++
       pushMainLoopEventToMainSessions({
@@ -2020,8 +2021,12 @@ export function recoverStalledRunningTasks(): { recovered: number; deadLettered:
   return { recovered, deadLettered }
 }
 
+let _resumeQueueCalled = false
+
 /** Resume any queued tasks on server boot */
 export function resumeQueue() {
+  if (_resumeQueueCalled) return
+  _resumeQueueCalled = true
   // Check for tasks stuck in 'queued' status but not in the queue array
   const tasks = loadTasks()
   const queue = loadQueue()