@swarmclawai/swarmclaw 1.2.0 → 1.2.2

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

@@ -8,6 +8,9 @@ import { getGatewayProfile, getGatewayProfiles, resolvePrimaryAgentRoute } from
 import { isAgentDisabled } from '@/lib/server/agents/agent-availability'
 import { errorMessage, hmrSingleton, jitteredBackoff } from '@/lib/shared-utils'
 import type { Agent } from '@/types'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'openclaw-gateway'
 
 // --- Types ---
 
@@ -165,7 +168,7 @@ export class OpenClawGateway {
     try {
       const result = await wsConnect(this.wsUrl, this.token, true, 15_000)
       if (!result.ok || !result.ws) {
-        console.error('[openclaw-gateway] Connect failed:', result.message)
+        log.error(TAG, 'Connect failed:', result.message)
         this.scheduleReconnect()
         return false
       }
@@ -173,7 +176,7 @@ export class OpenClawGateway {
       this.ws = result.ws
       this._connected = true
       this.consecutiveFailures = 0
-      console.log('[openclaw-gateway] Connected to gateway')
+      log.info(TAG, 'Connected to gateway')
 
       this.ws.on('message', (data) => {
         try {
@@ -195,7 +198,7 @@ export class OpenClawGateway {
 
       return true
     } catch (err: unknown) {
-      console.error('[openclaw-gateway] Connect error:', errorMessage(err))
+      log.error(TAG, 'Connect error:', errorMessage(err))
       this.scheduleReconnect()
       return false
     }
@@ -213,7 +216,7 @@ export class OpenClawGateway {
       this.ws = null
     }
     this._connected = false
-    console.log('[openclaw-gateway] Disconnected')
+    log.info(TAG, 'Disconnected')
   }
 
   private scheduleReconnect() {
@@ -228,7 +231,7 @@ export class OpenClawGateway {
       this.doConnect().catch(() => {})
     }, delay)
     if (this.consecutiveFailures === 1 || this.consecutiveFailures % 5 === 0) {
-      console.log(`[openclaw-gateway] ${this.consecutiveFailures} consecutive failure${this.consecutiveFailures > 1 ? 's' : ''}, next retry in ${Math.round(delay / 1000)}s`)
+      log.info(TAG, `${this.consecutiveFailures} consecutive failure${this.consecutiveFailures > 1 ? 's' : ''}, next retry in ${Math.round(delay / 1000)}s`)
     }
   }
 

package/src/lib/server/persistence/repository-utils.ts

@@ -0,0 +1,154 @@
+import { perf } from '@/lib/server/runtime/perf'
+
+export interface RecordRepository<
+  T,
+  ListOptions = void,
+  UpsertValue = T | Record<string, unknown>,
+> {
+  get(id: string, options?: ListOptions): T | null
+  getMany(ids: string[], options?: ListOptions): Record<string, T>
+  list(options?: ListOptions): Record<string, T>
+  upsert(id: string, value: UpsertValue): void
+  upsertMany(entries: Array<[string, UpsertValue]>): void
+  patch(id: string, updater: (current: T | null) => T | null, options?: ListOptions): T | null
+  replace(data: Record<string, UpsertValue>): void
+  delete(id: string): void
+}
+
+interface RecordRepositoryOps<
+  T,
+  ListOptions = void,
+  UpsertValue = T | Record<string, unknown>,
+> {
+  get(id: string, options?: ListOptions): T | null
+  list(options?: ListOptions): Record<string, T>
+  upsert(id: string, value: UpsertValue): void
+  upsertMany?: (entries: Array<[string, UpsertValue]>) => void
+  patch?: (id: string, updater: (current: T | null) => T | null) => T | null
+  replace?: (data: Record<string, UpsertValue>) => void
+  delete?: (id: string) => void
+}
+
+export interface SingletonRepository<
+  T,
+  SaveValue = T | Record<string, unknown>,
+> {
+  get(): T
+  save(value: SaveValue): void
+  patch(updater: (current: T) => SaveValue): T
+}
+
+interface SingletonRepositoryOps<
+  T,
+  SaveValue = T | Record<string, unknown>,
+> {
+  get(): T
+  save(value: SaveValue): void
+}
+
+function uniqueIds(ids: string[]): string[] {
+  const out: string[] = []
+  const seen = new Set<string>()
+  for (const id of ids) {
+    const normalized = typeof id === 'string' ? id.trim() : ''
+    if (!normalized || seen.has(normalized)) continue
+    seen.add(normalized)
+    out.push(normalized)
+  }
+  return out
+}
+
+export function createRecordRepository<
+  T,
+  ListOptions = void,
+  UpsertValue = T | Record<string, unknown>,
+>(
+  name: string,
+  ops: RecordRepositoryOps<T, ListOptions, UpsertValue>,
+): RecordRepository<T, ListOptions, UpsertValue> {
+  return {
+    get(id, options) {
+      return perf.measureSync('repository', `${name}.get`, () => ops.get(id, options), { id })
+    },
+    getMany(ids, options) {
+      return perf.measureSync('repository', `${name}.getMany`, () => {
+        const result: Record<string, T> = {}
+        for (const id of uniqueIds(ids)) {
+          const item = ops.get(id, options)
+          if (item) result[id] = item
+        }
+        return result
+      }, { count: ids.length })
+    },
+    list(options) {
+      return perf.measureSync('repository', `${name}.list`, () => ops.list(options))
+    },
+    upsert(id, value) {
+      perf.measureSync('repository', `${name}.upsert`, () => ops.upsert(id, value), { id })
+    },
+    upsertMany(entries) {
+      perf.measureSync('repository', `${name}.upsertMany`, () => {
+        if (ops.upsertMany) {
+          ops.upsertMany(entries)
+          return
+        }
+        for (const [id, value] of entries) ops.upsert(id, value)
+      }, { count: entries.length })
+    },
+    patch(id, updater, options) {
+      return perf.measureSync('repository', `${name}.patch`, () => {
+        if (ops.patch) return ops.patch(id, updater)
+        const current = ops.get(id, options)
+        const next = updater(current)
+        if (next === null) {
+          if (!ops.delete) return null
+          ops.delete(id)
+          return null
+        }
+        ops.upsert(id, next as UpsertValue)
+        return next
+      }, { id })
+    },
+    replace(data) {
+      perf.measureSync('repository', `${name}.replace`, () => {
+        if (ops.replace) {
+          ops.replace(data)
+          return
+        }
+        const entries = Object.entries(data)
+        if (ops.upsertMany) ops.upsertMany(entries)
+        else for (const [id, value] of entries) ops.upsert(id, value)
+      }, { count: Object.keys(data).length })
+    },
+    delete(id) {
+      perf.measureSync('repository', `${name}.delete`, () => {
+        if (!ops.delete) return
+        ops.delete(id)
+      }, { id })
+    },
+  }
+}
+
+export function createSingletonRepository<
+  T,
+  SaveValue = T | Record<string, unknown>,
+>(
+  name: string,
+  ops: SingletonRepositoryOps<T, SaveValue>,
+): SingletonRepository<T, SaveValue> {
+  return {
+    get() {
+      return perf.measureSync('repository', `${name}.get`, () => ops.get())
+    },
+    save(value) {
+      perf.measureSync('repository', `${name}.save`, () => ops.save(value))
+    },
+    patch(updater) {
+      return perf.measureSync('repository', `${name}.patch`, () => {
+        const next = updater(ops.get())
+        ops.save(next)
+        return ops.get()
+      })
+    },
+  }
+}

package/src/lib/server/persistence/storage-context.ts

@@ -0,0 +1,51 @@
+import { withTransaction } from '@/lib/server/storage'
+
+import { agentRepository } from '@/lib/server/agents/agent-repository'
+import { approvalRepository } from '@/lib/server/approvals/approval-repository'
+import { chatroomRepository } from '@/lib/server/chatrooms/chatroom-repository'
+import { connectorRepository } from '@/lib/server/connectors/connector-repository'
+import { missionEventRepository, missionRepository } from '@/lib/server/missions/mission-repository'
+import { projectRepository } from '@/lib/server/projects/project-repository'
+import { scheduleRepository } from '@/lib/server/schedules/schedule-repository'
+import { sessionRepository } from '@/lib/server/sessions/session-repository'
+import { settingsRepository } from '@/lib/server/settings/settings-repository'
+import { taskRepository } from '@/lib/server/tasks/task-repository'
+import { runEventRepository, runRepository } from '@/lib/server/runtime/run-repository'
+
+export interface StorageTxContext {
+  agents: typeof agentRepository
+  approvals: typeof approvalRepository
+  chatrooms: typeof chatroomRepository
+  connectors: typeof connectorRepository
+  missions: typeof missionRepository
+  missionEvents: typeof missionEventRepository
+  projects: typeof projectRepository
+  runs: typeof runRepository
+  runEvents: typeof runEventRepository
+  schedules: typeof scheduleRepository
+  sessions: typeof sessionRepository
+  settings: typeof settingsRepository
+  tasks: typeof taskRepository
+}
+
+export function createStorageTxContext(): StorageTxContext {
+  return {
+    agents: agentRepository,
+    approvals: approvalRepository,
+    chatrooms: chatroomRepository,
+    connectors: connectorRepository,
+    missions: missionRepository,
+    missionEvents: missionEventRepository,
+    projects: projectRepository,
+    runs: runRepository,
+    runEvents: runEventRepository,
+    schedules: scheduleRepository,
+    sessions: sessionRepository,
+    settings: settingsRepository,
+    tasks: taskRepository,
+  }
+}
+
+export function withStorageTx<T>(fn: (ctx: StorageTxContext) => T): T {
+  return withTransaction(() => fn(createStorageTxContext()))
+}

package/src/lib/server/persistence/transaction.ts

@@ -0,0 +1 @@
+export { withTransaction } from '@/lib/server/storage'

package/src/lib/server/project-utils.ts

@@ -93,6 +93,8 @@ export interface ProjectResourceSummary {
   openTaskCount: number
   queuedTaskCount: number
   runningTaskCount: number
+  failedTaskCount: number
+  staleTaskCount: number
   activeScheduleCount: number
   secretCount: number
   skillCount: number
@@ -118,6 +120,15 @@ export function summarizeProjectResources(projectId: string): ProjectResourceSum
   const openTasks = tasks
     .filter((task) => ['backlog', 'queued', 'running'].includes(String(task.status || '').toLowerCase()))
     .sort(byUpdatedDesc)
+  const failedTasks = tasks.filter((task) => String(task.status || '').toLowerCase() === 'failed')
+  const now = Date.now()
+  const staleDays = 3 * 24 * 60 * 60 * 1000
+  const staleTasks = tasks.filter((task) => {
+    const status = String(task.status || '').toLowerCase()
+    if (['completed', 'cancelled', 'archived'].includes(status)) return false
+    const lastUpdate = Number(task.updatedAt || task.createdAt || 0)
+    return lastUpdate > 0 && (now - lastUpdate) > staleDays
+  })
   const activeSchedules = schedules
     .filter((schedule) => String(schedule.status || '').toLowerCase() === 'active')
     .sort(byUpdatedDesc)
@@ -129,6 +140,8 @@ export function summarizeProjectResources(projectId: string): ProjectResourceSum
     openTaskCount: openTasks.length,
     queuedTaskCount: openTasks.filter((task) => task.status === 'queued').length,
     runningTaskCount: openTasks.filter((task) => task.status === 'running').length,
+    failedTaskCount: failedTasks.length,
+    staleTaskCount: staleTasks.length,
     activeScheduleCount: activeSchedules.length,
     secretCount: secrets.length,
     skillCount: skills.length,

package/src/lib/server/projects/project-repository.ts

@@ -0,0 +1,36 @@
+import type { Project } from '@/types'
+
+import {
+  deleteProject as deleteStoredProject,
+  loadProjects as loadStoredProjects,
+  saveProjects as saveStoredProjects,
+  upsertStoredItem,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const projectRepository = createRecordRepository<Project>(
+  'projects',
+  {
+    get(id) {
+      return (loadStoredProjects() as Record<string, Project>)[id] || null
+    },
+    list() {
+      return loadStoredProjects() as Record<string, Project>
+    },
+    upsert(id, value) {
+      upsertStoredItem('projects', id, value)
+    },
+    replace(data) {
+      saveStoredProjects(data)
+    },
+    delete(id) {
+      deleteStoredProject(id)
+    },
+  },
+)
+
+export const loadProjects = () => projectRepository.list()
+export const loadProject = (id: string) => projectRepository.get(id)
+export const saveProjects = (items: Record<string, Project | Record<string, unknown>>) => projectRepository.replace(items as Record<string, Project>)
+export const upsertProject = (id: string, value: Project | Record<string, unknown>) => projectRepository.upsert(id, value as Project)
+export const deleteProject = (id: string) => projectRepository.delete(id)

package/src/lib/server/projects/project-service.ts

@@ -0,0 +1,79 @@
+import type { Agent, BoardTask, Project, Schedule, Skill, StoredSecret } from '@/types'
+
+import {
+  deleteProject as deleteStoredProject,
+  loadAgents,
+  loadProjects,
+  loadSchedules,
+  loadSecrets,
+  loadSkills,
+  loadTasks,
+  saveAgents,
+  saveProjects,
+  saveSchedules,
+  saveSecrets,
+  saveSkills,
+  saveTasks,
+} from '@/lib/server/storage'
+import { ensureProjectWorkspace, normalizeProjectPatchInput } from '@/lib/server/project-utils'
+import { notify } from '@/lib/server/ws-hub'
+
+type ProjectLinkedRecord = {
+  projectId?: string
+}
+
+function clearProjectId<T extends ProjectLinkedRecord>(
+  projectId: string,
+  load: () => Record<string, T>,
+  save: (items: Record<string, T>) => void,
+  topic: string,
+): void {
+  const items = load()
+  let changed = false
+  for (const item of Object.values(items)) {
+    if (item.projectId !== projectId) continue
+    item.projectId = undefined
+    changed = true
+  }
+  if (!changed) return
+  save(items)
+  notify(topic)
+}
+
+export function getProject(id: string): Project | null {
+  return loadProjects()[id] || null
+}
+
+export function updateProject(id: string, input: Record<string, unknown>): Project | null {
+  const projects = loadProjects()
+  const existing = projects[id]
+  if (!existing) return null
+
+  const patch = normalizeProjectPatchInput(input)
+  const nextProject: Project = {
+    ...existing,
+    ...patch,
+    id,
+    updatedAt: Date.now(),
+  }
+  projects[id] = nextProject
+  saveProjects(projects)
+  ensureProjectWorkspace(id, nextProject.name)
+  notify('projects')
+  return nextProject
+}
+
+export function deleteProjectAndDetachReferences(id: string): boolean {
+  if (!getProject(id)) return false
+
+  deleteStoredProject(id)
+  notify('projects')
+
+  clearProjectId<Agent>(id, loadAgents, saveAgents, 'agents')
+  clearProjectId<BoardTask>(id, loadTasks, saveTasks, 'tasks')
+  clearProjectId<Schedule>(id, loadSchedules, saveSchedules, 'schedules')
+  clearProjectId<Skill>(id, loadSkills, saveSkills, 'skills')
+  clearProjectId<StoredSecret>(id, loadSecrets, saveSecrets, 'secrets')
+
+  return true
+}

package/src/lib/server/protocols/protocol-agent-turn.ts

@@ -4,7 +4,10 @@
  */
 import { HumanMessage } from '@langchain/core/messages'
 import { z } from 'zod'
+import { log } from '@/lib/server/logger'
 import { genId } from '@/lib/id'
+
+const TAG = 'protocol-agent-turn'
 import type {
   Agent,
   Chatroom,
@@ -230,7 +233,7 @@ export async function defaultExecuteAgentTurn(params: {
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
     if (attempt > 0) {
       const delay = BASE_DELAY_MS * Math.pow(2, attempt - 1)
-      console.warn(`[protocols] retrying agent turn for ${params.agentId} (attempt ${attempt + 1}/${MAX_RETRIES + 1}, waiting ${delay}ms)`)
+      log.warn(TAG, `retrying agent turn for ${params.agentId} (attempt ${attempt + 1}/${MAX_RETRIES + 1}, waiting ${delay}ms)`)
       await new Promise((resolve) => setTimeout(resolve, delay))
     }
     try {
@@ -271,7 +274,7 @@ export async function defaultExecuteAgentTurn(params: {
       const msg = errorMessage(err)
       const isRetryable = /\b(401|429|5\d{2}|timeout|ECONNR|ETIMEDOUT|ENOTFOUND|socket hang up|fetch failed)\b/i.test(msg)
       if (!isRetryable || attempt >= MAX_RETRIES) throw err
-      console.warn(`[protocols] transient LLM error for agent ${params.agentId}: ${msg}`)
+      log.warn(TAG, `transient LLM error for agent ${params.agentId}: ${msg}`)
     }
   }
   throw lastError

package/src/lib/server/protocols/protocol-normalization.test.ts

@@ -3,13 +3,15 @@ import { after, before, describe, it } from 'node:test'
 
 let mod: typeof import('@/lib/server/protocols/protocol-normalization')
 
+const savedBuildMode = process.env.SWARMCLAW_BUILD_MODE
 before(async () => {
   process.env.SWARMCLAW_BUILD_MODE = '1'
   mod = await import('@/lib/server/protocols/protocol-normalization')
 })
 
 after(() => {
-  delete process.env.SWARMCLAW_BUILD_MODE
+  if (savedBuildMode === undefined) delete process.env.SWARMCLAW_BUILD_MODE
+  else process.env.SWARMCLAW_BUILD_MODE = savedBuildMode
 })
 
 describe('protocol-normalization', () => {
@@ -26,8 +28,8 @@ describe('protocol-normalization', () => {
     })
 
     it('artifact_exists with artifactKind', () => {
-      const result = mod.normalizeCondition({ type: 'artifact_exists', artifactKind: 'report' })
-      assert.deepEqual(result, { type: 'artifact_exists', artifactKind: 'report' })
+      const result = mod.normalizeCondition({ type: 'artifact_exists', artifactKind: 'summary' })
+      assert.deepEqual(result, { type: 'artifact_exists', artifactKind: 'summary' })
     })
 
     it('artifact_exists without artifactKind', () => {
@@ -53,7 +55,7 @@ describe('protocol-normalization', () => {
         type: 'all',
         conditions: [
           { type: 'summary_exists' },
-          { type: 'artifact_exists', artifactKind: 'doc' },
+          { type: 'artifact_exists', artifactKind: 'notes' },
         ],
       })
       assert.equal(result!.type, 'all')

package/src/lib/server/protocols/protocol-run-lifecycle.ts

@@ -2,7 +2,10 @@
  * Protocol run lifecycle: create/run/action, scheduling/recovery, launch helpers.
  * Groups G10 + G18 + G19 from protocol-service.ts
  */
+import { log } from '@/lib/server/logger'
 import { genId } from '@/lib/id'
+
+const TAG = 'protocol-run-lifecycle'
 import type {
   ProtocolRun,
   ProtocolRunConfig,
@@ -58,7 +61,7 @@ export function requestProtocolRunExecution(runId: string, deps?: ProtocolRunDep
   setTimeout(() => {
     void runProtocolRun(normalizedId, deps)
       .catch((err: unknown) => {
-        console.warn(`[protocols] execution failed for ${normalizedId}: ${errorMessage(err)}`)
+        log.warn(TAG, `execution failed for ${normalizedId}: ${errorMessage(err)}`)
       })
       .finally(() => {
         protocolExecutionState.pendingRunIds.delete(normalizedId)
@@ -300,7 +303,7 @@ export function createProtocolRun(input: CreateProtocolRunInput, deps?: Protocol
 export async function runProtocolRun(runId: string, deps?: ProtocolRunDeps): Promise<ProtocolRun | null> {
   const release = acquireProtocolLease(runId)
   if (!release) {
-    console.warn(`[protocols] could not acquire lease for run ${runId}, another execution may be active`)
+    log.warn(TAG, `could not acquire lease for run ${runId}, another execution may be active`)
     return loadProtocolRunById(runId)
   }
   try {

package/src/lib/server/protocols/protocol-step-helpers.ts

@@ -4,7 +4,10 @@
  */
 import { z } from 'zod'
 import { HumanMessage } from '@langchain/core/messages'
+import { log } from '@/lib/server/logger'
 import { genId } from '@/lib/id'
+
+const TAG = 'protocol-step-helpers'
 import type {
   ProtocolBranchCase,
   ProtocolConditionDefinition,
@@ -161,7 +164,7 @@ export function syncProtocolParentFromChildRun(runOrId: ProtocolRun | string, de
   const subflowState = parent.subflowState?.[child.parentStepId]
   if (subflowState && subflowState.childRunId === child.id) {
     if (typeof subflowMod.syncSubflowParentFromChildRun !== 'function') {
-      console.warn('[protocol] syncSubflowParentFromChildRun not available (circular dep not yet resolved), skipping subflow sync')
+      log.warn(TAG, 'syncSubflowParentFromChildRun not available (circular dep not yet resolved), skipping subflow sync')
       return parent
     }
     return subflowMod.syncSubflowParentFromChildRun(child, parent, subflowState, deps)

package/src/lib/server/provider-health.ts

@@ -14,15 +14,32 @@ interface ProviderHealthState {
 const states: Map<string, ProviderHealthState> =
   hmrSingleton('__swarmclaw_provider_health__', () => new Map<string, ProviderHealthState>())
 
+const CLI_CHECK_CACHE_MAX = 100
 const cliCheckCache = new Map<string, { at: number; ok: boolean }>()
 const delegateReadyCache = new Map<string, { at: number; ok: boolean }>()
 const CLI_CHECK_TTL_MS = 30_000
 const isWindows = process.platform === 'win32'
 
+function pruneTTLCache(cache: Map<string, { at: number }>, ttlMs: number, maxSize: number): void {
+  const now = Date.now()
+  for (const [k, v] of cache) {
+    if (now - v.at > ttlMs) cache.delete(k)
+  }
+  if (cache.size > maxSize) {
+    const excess = cache.size - maxSize
+    const iter = cache.keys()
+    for (let i = 0; i < excess; i++) {
+      const k = iter.next().value
+      if (k !== undefined) cache.delete(k)
+    }
+  }
+}
+
 function commandExists(binary: string): boolean {
   const now = Date.now()
   const cached = cliCheckCache.get(binary)
   if (cached && now - cached.at < CLI_CHECK_TTL_MS) return cached.ok
+  pruneTTLCache(cliCheckCache, CLI_CHECK_TTL_MS, CLI_CHECK_CACHE_MAX)
   const probe = isWindows
     ? spawnSync('where', [binary], { timeout: 2000, stdio: 'pipe' })
     : spawnSync('/bin/zsh', ['-lc', `command -v ${binary} >/dev/null 2>&1`], { timeout: 2000 })
@@ -108,6 +125,7 @@ function delegateToolReady(delegateTool: DelegateTool): boolean {
   const now = Date.now()
   const cached = delegateReadyCache.get(delegateTool)
   if (cached && now - cached.at < CLI_CHECK_TTL_MS) return cached.ok
+  pruneTTLCache(delegateReadyCache, CLI_CHECK_TTL_MS, CLI_CHECK_CACHE_MAX)
 
   const binary = delegateBinary(delegateTool)
   let ok = commandExists(binary)

package/src/lib/server/query-expansion.ts

@@ -1,5 +1,8 @@
 import { loadAgents, loadSettings, loadCredentials, decryptKey } from './storage'
 import { getProvider } from '../providers'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'query-expansion'
 
 /**
  * Expands a single user query into multiple semantic search variants
@@ -58,7 +61,7 @@ Format your response as a simple newline-separated list. No numbering, no bullet
       return [query, ...variants.slice(0, 3)]
     }
   } catch (err) {
-    console.error('[query-expansion] Failed to expand query:', err)
+    log.error(TAG, 'Failed to expand query:', err)
   }
 
   return [query]

package/src/lib/server/runtime/alert-dispatch.ts

@@ -1,6 +1,9 @@
-import { loadSettings } from '@/lib/server/storage'
+import { loadSettings } from '@/lib/server/settings/settings-repository'
 import type { AppNotification } from '@/types'
 import { errorMessage } from '@/lib/shared-utils'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'alert-dispatch'
 
 /** In-memory rate limiter: dedupKey → last dispatch timestamp */
 const recentDispatches = new Map<string, number>()
@@ -23,11 +26,9 @@ export async function dispatchAlert(notification: AppNotification): Promise<void
   if (lastSent && now - lastSent < DEDUP_WINDOW_MS) return
   recentDispatches.set(dedupKey, now)
 
-  // Prune stale entries periodically
-  if (recentDispatches.size > 200) {
-    for (const [key, ts] of recentDispatches) {
-      if (now - ts > DEDUP_WINDOW_MS) recentDispatches.delete(key)
-    }
+  // Prune stale entries on every write to bound growth
+  for (const [key, ts] of recentDispatches) {
+    if (now - ts > DEDUP_WINDOW_MS) recentDispatches.delete(key)
   }
 
   const webhookType = settings.alertWebhookType || 'custom'
@@ -60,6 +61,6 @@ export async function dispatchAlert(notification: AppNotification): Promise<void
       signal: AbortSignal.timeout(5000),
     })
   } catch (err: unknown) {
-    console.warn('[alert-dispatch] Webhook delivery failed:', errorMessage(err))
+    log.warn(TAG, 'Webhook delivery failed:', errorMessage(err))
   }
 }

package/src/lib/server/runtime/daemon-policy.ts

@@ -1,5 +1,5 @@
 import { DEFAULT_HEARTBEAT_INTERVAL_SEC } from '@/lib/runtime/heartbeat-defaults'
-import { loadSettings } from '@/lib/server/storage'
+import { loadSettings } from '@/lib/server/settings/settings-repository'
 import type { Session } from '@/types'
 
 const SYNTHETIC_HEALTH_SESSION_USERS = new Set(['workbench', 'comparison-bench'])