@swarmclawai/swarmclaw 0.5.2 → 0.6.0

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

@@ -0,0 +1,42 @@
+import { genId } from '@/lib/id'
+import { saveNotification, hasUnreadNotificationWithKey } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+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).
+ */
+export function createNotification(opts: {
+  type: AppNotification['type']
+  title: string
+  message?: string
+  actionLabel?: string
+  actionUrl?: string
+  entityType?: string
+  entityId?: string
+  dedupKey?: string
+}): AppNotification | null {
+  if (opts.dedupKey && hasUnreadNotificationWithKey(opts.dedupKey)) {
+    return null
+  }
+
+  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(),
+  }
+  saveNotification(id, notification)
+  notify('notifications')
+  return notification
+}

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

@@ -1,4 +1,4 @@
-import { loadQueue, loadSchedules, loadSessions, saveSessions, loadConnectors, saveConnectors, loadWebhookRetryQueue, upsertWebhookRetry, deleteWebhookRetry, loadWebhooks, loadAgents, appendWebhookLog } from './storage'
+import { loadQueue, loadSchedules, loadSessions, saveSessions, loadConnectors, saveConnectors, loadWebhookRetryQueue, upsertWebhookRetry, deleteWebhookRetry, loadWebhooks, loadAgents, appendWebhookLog, loadCredentials, decryptKey } from './storage'
 import { notify } from './ws-hub'
 import { processNext, cleanupFinishedTaskSessions, validateCompletedTasksQueue, recoverStalledRunningTasks } from './queue'
 import { startScheduler, stopScheduler } from './scheduler'
@@ -17,11 +17,15 @@ import { enqueueSessionRun } from './session-run-manager'
 import { WORKSPACE_DIR } from './data-dir'
 import { genId } from '@/lib/id'
 import type { WebhookRetryEntry } from '@/types'
+import { createNotification } from '@/lib/server/create-notification'
+import { pingProvider, OPENAI_COMPATIBLE_DEFAULTS } from '@/lib/server/provider-health'
 
 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 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
 const STALE_MIN_MS = 4 * 60 * 1000 // minimum 4 minutes regardless of interval
 const STALE_AUTO_DISABLE_MULTIPLIER = 16 // auto-disable after much longer sustained staleness
@@ -73,6 +77,8 @@ const ds: {
   queueIntervalId: ReturnType<typeof setInterval> | null
   browserSweepId: ReturnType<typeof setInterval> | null
   healthIntervalId: ReturnType<typeof setInterval> | null
+  memoryConsolidationTimeoutId: ReturnType<typeof setTimeout> | null
+  memoryConsolidationIntervalId: ReturnType<typeof setInterval> | null
   /** Session IDs we've already alerted as stale (alert-once semantics). */
   staleSessionIds: Set<string>
   connectorRestartState: Map<string, { lastAttemptAt: number; failCount: number; wakeAttempts: number }>
@@ -84,6 +90,8 @@ const ds: {
   queueIntervalId: null,
   browserSweepId: null,
   healthIntervalId: null,
+  memoryConsolidationTimeoutId: null,
+  memoryConsolidationIntervalId: null,
   staleSessionIds: new Set<string>(),
   connectorRestartState: new Map<string, { lastAttemptAt: number; failCount: number; wakeAttempts: number }>(),
   manualStopRequested: false,
@@ -99,6 +107,8 @@ if (!ds.connectorRestartState) ds.connectorRestartState = new Map<string, { last
 if ((ds as any).issueLastAlertAt) delete (ds as any).issueLastAlertAt
 if (ds.healthIntervalId === undefined) ds.healthIntervalId = null
 if (ds.manualStopRequested === undefined) ds.manualStopRequested = false
+if (ds.memoryConsolidationTimeoutId === undefined) ds.memoryConsolidationTimeoutId = null
+if (ds.memoryConsolidationIntervalId === undefined) ds.memoryConsolidationIntervalId = null
 
 export function ensureDaemonStarted(source = 'unknown'): boolean {
   if (ds.running) return false
@@ -120,23 +130,32 @@ export function startDaemon(options?: { source?: string; manualStart?: boolean }
     startBrowserSweep()
     startHealthMonitor()
     startHeartbeatService()
+    startMemoryConsolidation()
     return
   }
   ds.running = true
   notify('daemon')
   console.log(`[daemon] Starting daemon (source=${source}, scheduler + queue processor + heartbeat)`)
 
-  validateCompletedTasksQueue()
-  cleanupFinishedTaskSessions()
-  startScheduler()
-  startQueueProcessor()
-  startBrowserSweep()
-  startHealthMonitor()
-  startHeartbeatService()
+  try {
+    validateCompletedTasksQueue()
+    cleanupFinishedTaskSessions()
+    startScheduler()
+    startQueueProcessor()
+    startBrowserSweep()
+    startHealthMonitor()
+    startHeartbeatService()
+    startMemoryConsolidation()
+  } catch (err: unknown) {
+    ds.running = false
+    notify('daemon')
+    console.error('[daemon] Failed to start:', err instanceof Error ? err.message : String(err))
+    throw err
+  }
 
   // Auto-start enabled connectors
-  autoStartConnectors().catch((err) => {
-    console.error('[daemon] Error auto-starting connectors:', err.message)
+  autoStartConnectors().catch((err: unknown) => {
+    console.error('[daemon] Error auto-starting connectors:', err instanceof Error ? err.message : String(err))
   })
 }
 
@@ -153,6 +172,7 @@ export function stopDaemon(options?: { source?: string; manualStop?: boolean })
   stopBrowserSweep()
   stopHealthMonitor()
   stopHeartbeatService()
+  stopMemoryConsolidation()
   stopAllConnectors().catch(() => {})
 }
 
@@ -254,6 +274,14 @@ async function runConnectorHealthChecks(now: number) {
       connectors[connector.id] = connector
       saveConnectors(connectors)
       ds.connectorRestartState.delete(connector.id)
+      createNotification({
+        type: 'error',
+        title: `Connector "${connector.name}" failed`,
+        message: `Auto-restart gave up after ${MAX_WAKE_ATTEMPTS} consecutive failures.`,
+        dedupKey: `connector-gave-up:${connector.id}`,
+        entityType: 'connector',
+        entityId: connector.id,
+      })
       continue
     }
 
@@ -263,6 +291,18 @@ async function runConnectorHealthChecks(now: number) {
     )
     if ((now - current.lastAttemptAt) < backoffMs) continue
 
+    // Notify on first detection of a down connector
+    if (current.wakeAttempts === 0) {
+      createNotification({
+        type: 'warning',
+        title: `Connector "${connector.name}" is down`,
+        message: 'Auto-restart in progress.',
+        dedupKey: `connector-down:${connector.id}`,
+        entityType: 'connector',
+        entityId: connector.id,
+      })
+    }
+
     current.lastAttemptAt = now
     ds.connectorRestartState.set(connector.id, current)
     try {
@@ -277,6 +317,11 @@ async function runConnectorHealthChecks(now: number) {
       console.warn(`[health] Connector auto-restart failed for ${connector.name} (attempt ${current.wakeAttempts}/${MAX_WAKE_ATTEMPTS}): ${message}`)
     }
   }
+
+  // Purge restart state for connectors that no longer exist in storage
+  for (const id of ds.connectorRestartState.keys()) {
+    if (!connectors[id]) ds.connectorRestartState.delete(id)
+  }
 }
 
 async function processWebhookRetries() {
@@ -421,6 +466,73 @@ async function processWebhookRetries() {
   }
 }
 
+async function runProviderHealthChecks() {
+  const agents = loadAgents()
+  const credentials = loadCredentials()
+
+  // Build deduplicated set of { provider, credentialId, apiEndpoint } tuples
+  const seen = new Set<string>()
+  const tuples: { provider: string; credentialId: string; apiEndpoint: string; agentId: string; credentialName: string }[] = []
+
+  for (const agent of Object.values(agents) as Record<string, unknown>[]) {
+    if (!agent?.id || typeof agent.id !== 'string') continue
+    const provider = typeof agent.provider === 'string' ? agent.provider : ''
+    if (!provider || ['claude-cli', 'codex-cli', 'opencode-cli'].includes(provider)) continue
+
+    const credentialId = typeof agent.credentialId === 'string' ? agent.credentialId : ''
+    const apiEndpoint = typeof agent.apiEndpoint === 'string' ? agent.apiEndpoint : ''
+
+    // For OpenClaw, scope per agent (each may have a different gateway)
+    const key = provider === 'openclaw'
+      ? `openclaw:${agent.id}`
+      : `${provider}:${credentialId || 'no-cred'}:${apiEndpoint}`
+    if (seen.has(key)) continue
+    seen.add(key)
+
+    const cred = credentialId ? (credentials[credentialId] as Record<string, unknown> | undefined) : undefined
+    const credName = typeof cred?.name === 'string' ? cred.name : provider
+
+    tuples.push({
+      provider,
+      credentialId,
+      apiEndpoint,
+      agentId: agent.id,
+      credentialName: credName,
+    })
+  }
+
+  for (const tuple of tuples) {
+    let apiKey: string | undefined
+    if (tuple.credentialId) {
+      const cred = credentials[tuple.credentialId] as Record<string, unknown> | undefined
+      if (cred?.encryptedKey && typeof cred.encryptedKey === 'string') {
+        try { apiKey = decryptKey(cred.encryptedKey) } catch { /* skip undecryptable */ continue }
+      }
+    }
+
+    const endpoint = tuple.apiEndpoint || OPENAI_COMPATIBLE_DEFAULTS[tuple.provider]?.defaultEndpoint || undefined
+    const result = await pingProvider(tuple.provider, apiKey, endpoint)
+
+    if (!result.ok) {
+      const dedupKey = tuple.provider === 'openclaw'
+        ? `openclaw-down:${tuple.agentId}`
+        : `provider-down:${tuple.credentialId || tuple.provider}`
+
+      const entityType = tuple.credentialId ? 'credential' : undefined
+      const entityId = tuple.credentialId || undefined
+
+      createNotification({
+        type: 'warning',
+        title: `Provider unreachable: ${tuple.credentialName}`,
+        message: result.message,
+        dedupKey,
+        entityType,
+        entityId,
+      })
+    }
+  }
+}
+
 async function runHealthChecks() {
   // Continuously keep the completed queue honest.
   validateCompletedTasksQueue()
@@ -482,6 +594,13 @@ async function runHealthChecks() {
 
   await runConnectorHealthChecks(now)
 
+  // Provider reachability checks
+  try {
+    await runProviderHealthChecks()
+  } catch (err: unknown) {
+    console.error('[daemon] Provider health check failed:', err instanceof Error ? err.message : String(err))
+  }
+
   // Process webhook retry queue
   try {
     await processWebhookRetries()
@@ -506,6 +625,42 @@ function stopHealthMonitor() {
   }
 }
 
+function runConsolidationTick() {
+  import('./memory-consolidation').then(({ runDailyConsolidation }) =>
+    runDailyConsolidation().then((stats) => {
+      if (stats.digests > 0 || stats.pruned > 0 || stats.deduped > 0) {
+        console.log(`[daemon] Memory consolidation: ${stats.digests} digest(s), ${stats.pruned} pruned, ${stats.deduped} deduped`)
+      }
+      if (stats.errors.length > 0) {
+        console.warn(`[daemon] Memory consolidation errors: ${stats.errors.join('; ')}`)
+      }
+    }),
+  ).catch((err: unknown) => {
+    console.error('[daemon] Memory consolidation failed:', err instanceof Error ? err.message : String(err))
+  })
+}
+
+function startMemoryConsolidation() {
+  if (ds.memoryConsolidationTimeoutId || ds.memoryConsolidationIntervalId) return
+  // Deferred first run, then repeat on interval
+  ds.memoryConsolidationTimeoutId = setTimeout(() => {
+    ds.memoryConsolidationTimeoutId = null
+    runConsolidationTick()
+    ds.memoryConsolidationIntervalId = setInterval(runConsolidationTick, MEMORY_CONSOLIDATION_INTERVAL)
+  }, MEMORY_CONSOLIDATION_INITIAL_DELAY)
+}
+
+function stopMemoryConsolidation() {
+  if (ds.memoryConsolidationTimeoutId) {
+    clearTimeout(ds.memoryConsolidationTimeoutId)
+    ds.memoryConsolidationTimeoutId = null
+  }
+  if (ds.memoryConsolidationIntervalId) {
+    clearInterval(ds.memoryConsolidationIntervalId)
+    ds.memoryConsolidationIntervalId = null
+  }
+}
+
 export async function runDaemonHealthCheckNow() {
   await runHealthChecks()
 }

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

@@ -55,6 +55,7 @@ function getDb(): Database.Database {
   if (_db) return _db
   _db = new Database(DB_PATH)
   _db.pragma('journal_mode = WAL')
+  _db.pragma('busy_timeout = 5000')
   _db.exec(`
     CREATE TABLE IF NOT EXISTS execution_logs (
       id         TEXT PRIMARY KEY,

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

@@ -5,6 +5,7 @@ import { enqueueSessionRun, getSessionRunState } from './session-run-manager'
 import { log } from './logger'
 import { buildMainLoopHeartbeatPrompt, getMainLoopStateForSession, isMainSession } from './main-agent-loop'
 import { WORKSPACE_DIR } from './data-dir'
+import { drainSystemEvents } from './system-events'
 
 const HEARTBEAT_TICK_MS = 5_000
 
@@ -131,9 +132,28 @@ function readHeartbeatFile(session: any): string {
   return ''
 }
 
+/** Detect HEARTBEAT.md files that contain only skeleton structure (headers, empty list items) but no real content. */
+export function isHeartbeatContentEffectivelyEmpty(content: string | undefined | null): boolean {
+  if (!content || typeof content !== 'string') return true
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    if (/^#+(\s|$)/.test(trimmed)) continue                           // ATX headers
+    if (/^[-*+]\s*(\[[\sXx]?\]\s*)?$/.test(trimmed)) continue        // empty list items / checkboxes
+    return false  // real content found
+  }
+  return true
+}
+
 function buildAgentHeartbeatPrompt(session: any, agent: any, fallbackPrompt: string, heartbeatFileContent: string): string {
   if (!agent) return fallbackPrompt
 
+  // Drain system events accumulated since last heartbeat
+  const events = drainSystemEvents(session.id)
+  const eventBlock = events.length > 0
+    ? events.map((e) => `- [${new Date(e.timestamp).toISOString()}] ${e.text}`).join('\n')
+    : ''
+
   // Dynamic goal (agent-set) takes priority over static system prompt
   const dynamicGoal = agent.heartbeatGoal || ''
   const dynamicNextAction = agent.heartbeatNextAction || ''
@@ -146,17 +166,21 @@ function buildAgentHeartbeatPrompt(session: any, agent: any, fallbackPrompt: str
     .map((m: any) => `[${m.role}]: ${(m.text || '').slice(0, 200)}`)
     .join('\n')
 
+  // Don't inject effectively-empty HEARTBEAT.md content
+  const effectiveFileContent = isHeartbeatContentEffectivelyEmpty(heartbeatFileContent) ? '' : heartbeatFileContent
+
   return [
     'AGENT_HEARTBEAT_TICK',
     `Time: ${new Date().toISOString()}`,
     `Agent: ${agent.name}`,
     description ? `Description: ${description}` : '',
+    eventBlock ? `Events since last heartbeat:\n${eventBlock}` : '',
     dynamicGoal
       ? `Current goal (self-set): ${dynamicGoal}`
       : goalSummary ? `System prompt (initial goal):\n${goalSummary}` : '',
     dynamicNextAction ? `Planned next action: ${dynamicNextAction}` : '',
     soul ? `Persona: ${soul.slice(0, 300)}` : '',
-    heartbeatFileContent ? `\nHEARTBEAT.md contents:\n${heartbeatFileContent.slice(0, 2000)}` : '',
+    effectiveFileContent ? `\nHEARTBEAT.md contents:\n${effectiveFileContent.slice(0, 2000)}` : '',
     recentContext ? `Recent conversation:\n${recentContext}` : '',
     fallbackPrompt !== DEFAULT_HEARTBEAT_PROMPT ? `\nAgent instructions:\n${fallbackPrompt}` : '',
     '',
@@ -330,9 +354,12 @@ async function tickHeartbeats() {
     if (isMainSession(session)) {
       const loopState = getMainLoopStateForSession(session.id)
       if (loopState?.paused) continue
-      const loopStatus = loopState?.status || 'idle'
-      const pendingEvents = loopState?.pendingEvents?.length || 0
-      if ((loopStatus === 'ok' || loopStatus === 'idle') && pendingEvents === 0) continue
+      // Only suppress idle main sessions when heartbeat is inherited (not explicitly enabled)
+      if (!explicitOptIn) {
+        const loopStatus = loopState?.status || 'idle'
+        const pendingEvents = loopState?.pendingEvents?.length || 0
+        if ((loopStatus === 'ok' || loopStatus === 'idle') && pendingEvents === 0) continue
+      }
     }
 
     const last = state.lastBySession.get(session.id) || 0
@@ -345,7 +372,8 @@ async function tickHeartbeats() {
     if (isMainSession(session)) {
       heartbeatMessage = buildMainLoopHeartbeatPrompt(session, cfg.prompt)
     } else {
-      const heartbeatFileContent = readHeartbeatFile(session)
+      const rawHeartbeatFileContent = readHeartbeatFile(session)
+      const heartbeatFileContent = isHeartbeatContentEffectivelyEmpty(rawHeartbeatFileContent) ? '' : rawHeartbeatFileContent
       const hasGoal = !!(agent?.heartbeatGoal || agent?.description || agent?.systemPrompt || agent?.soul)
       const hasCustomPrompt = cfg.prompt !== DEFAULT_HEARTBEAT_PROMPT
       // Skip heartbeat only if there's truly nothing to drive it:
@@ -422,6 +450,13 @@ export function stopHeartbeatService() {
   }
 }
 
+/** Clear tracked state and restart the heartbeat timer. Call when heartbeat config changes. */
+export function restartHeartbeatService() {
+  stopHeartbeatService()
+  state.lastBySession.clear()
+  startHeartbeatService()
+}
+
 export function getHeartbeatServiceStatus() {
   return {
     running: state.running,

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

@@ -0,0 +1,110 @@
+/**
+ * On-demand heartbeat wake — triggers an immediate heartbeat for an agent/session.
+ * Requests are debounced with a 250ms coalesce window to batch rapid-fire events.
+ */
+
+import { loadSessions, loadAgents, loadSettings } from './storage'
+import { enqueueSessionRun } from './session-run-manager'
+import { log } from './logger'
+
+interface WakeRequest {
+  agentId?: string
+  sessionId?: string
+  reason?: string
+}
+
+const COALESCE_MS = 250
+
+const globalKey = '__swarmclaw_heartbeat_wake__' as const
+const globalScope = globalThis as typeof globalThis & {
+  [globalKey]?: { pending: Map<string, WakeRequest>; timer: ReturnType<typeof setTimeout> | null }
+}
+const state = globalScope[globalKey] ?? (globalScope[globalKey] = {
+  pending: new Map(),
+  timer: null,
+})
+
+function flushWakes(): void {
+  state.timer = null
+  const wakes = new Map(state.pending)
+  state.pending.clear()
+
+  const sessions = loadSessions()
+  const agents = loadAgents()
+  const settings = loadSettings()
+
+  for (const [_key, wake] of wakes) {
+    try {
+      let sessionId = wake.sessionId
+
+      // If only agentId provided, find the agent's most recently active session
+      if (!sessionId && wake.agentId) {
+        let bestSession: { id: string; lastActiveAt: number } | null = null
+        for (const s of Object.values(sessions) as Array<Record<string, unknown>>) {
+          if (s.agentId !== wake.agentId) continue
+          const lastActive = typeof s.lastActiveAt === 'number' ? s.lastActiveAt : 0
+          if (!bestSession || lastActive > bestSession.lastActiveAt) {
+            bestSession = { id: s.id as string, lastActiveAt: lastActive }
+          }
+        }
+        sessionId = bestSession?.id
+      }
+
+      if (!sessionId) continue
+
+      const session = sessions[sessionId] as Record<string, unknown> | undefined
+      if (!session) continue
+
+      const agentId = (session.agentId || wake.agentId) as string | undefined
+      const agent = agentId ? agents[agentId] : null
+
+      // Build a minimal heartbeat prompt for the wake
+      const reason = wake.reason || 'on-demand'
+      const prompt = [
+        'AGENT_HEARTBEAT_WAKE',
+        `Time: ${new Date().toISOString()}`,
+        agent ? `Agent: ${(agent as Record<string, unknown>).name}` : '',
+        `Wake reason: ${reason}`,
+        '',
+        'An event has occurred that may require your attention.',
+        'Review and take appropriate action, or reply HEARTBEAT_OK if nothing is needed.',
+      ].filter(Boolean).join('\n')
+
+      // Resolve heartbeat model from agent/settings
+      const heartbeatModel =
+        (agent as Record<string, unknown> | null)?.heartbeatModel as string | undefined
+        || settings.heartbeatModel as string | undefined
+        || undefined
+
+      enqueueSessionRun({
+        sessionId,
+        message: prompt,
+        internal: true,
+        source: 'heartbeat-wake',
+        mode: 'collect',
+        dedupeKey: `heartbeat-wake:${sessionId}`,
+        modelOverride: heartbeatModel,
+        heartbeatConfig: {
+          ackMaxChars: 300,
+          showOk: false,
+          showAlerts: true,
+          target: null,
+        },
+      })
+
+      log.info('heartbeat-wake', `Wake fired for session ${sessionId} (reason: ${reason})`)
+    } catch (err: unknown) {
+      log.warn('heartbeat-wake', `Wake failed: ${err instanceof Error ? err.message : String(err)}`)
+    }
+  }
+}
+
+/** Queue a heartbeat wake. Multiple rapid calls are coalesced into a single flush. */
+export function requestHeartbeatNow(opts: WakeRequest): void {
+  const key = opts.agentId || opts.sessionId || 'unknown'
+  state.pending.set(key, opts)
+
+  if (!state.timer) {
+    state.timer = setTimeout(flushWakes, COALESCE_MS)
+  }
+}

package/src/lib/server/langgraph-checkpoint.ts

@@ -19,6 +19,7 @@ const DB_PATH = path.join(DATA_DIR, 'swarmclaw.db')
 function getDb(): Database.Database {
   const db = new Database(DB_PATH)
   db.pragma('journal_mode = WAL')
+  db.pragma('busy_timeout = 5000')
   return db
 }
 

package/src/lib/server/memory-consolidation.ts

@@ -0,0 +1,92 @@
+import { getMemoryDb } from './memory-db'
+import { HumanMessage } from '@langchain/core/messages'
+
+/**
+ * Produce daily digests per agent and prune stale entries.
+ * Only fires when an agent has >5 non-breadcrumb memories in the past 24h
+ * and no digest for today already exists.
+ */
+export async function runDailyConsolidation(): Promise<{
+  digests: number
+  pruned: number
+  deduped: number
+  errors: string[]
+}> {
+  const memDb = getMemoryDb()
+  const counts = memDb.countsByAgent()
+  const today = new Date().toISOString().slice(0, 10) // YYYY-MM-DD
+  const digestTitle = `Daily digest: ${today}`
+  const cutoff24h = Date.now() - 24 * 3600_000
+  const errors: string[] = []
+  let digestsCreated = 0
+
+  for (const agentKey of Object.keys(counts)) {
+    if (agentKey === '_global') continue
+    const agentId = agentKey
+
+    try {
+      // Check if digest already exists for today
+      const existing = memDb.search(digestTitle, agentId)
+      if (existing.some((m) => m.category === 'daily_digest' && m.title === digestTitle)) continue
+
+      // Fetch recent memories (exclude breadcrumbs and digests)
+      const recent = memDb.getByAgent(agentId, 100)
+      const candidates = recent.filter((m) => {
+        if (m.category === 'breadcrumb' || m.category === 'daily_digest') return false
+        return (m.createdAt || m.updatedAt || 0) >= cutoff24h
+      })
+
+      if (candidates.length < 5) continue
+
+      // Build summarization prompt
+      const memoryLines = candidates.slice(0, 30).map((m) => {
+        const content = (m.content || '').slice(0, 300)
+        return `- [${m.category}] ${m.title}: ${content}`
+      })
+
+      const prompt = [
+        'Summarize the following memory entries from the last 24 hours into a concise daily digest.',
+        'Focus on key decisions, discoveries, and outcomes. Skip trivial or redundant entries.',
+        'Format as 3-7 bullet points. Be concise.',
+        '',
+        ...memoryLines,
+      ].join('\n')
+
+      // Use the configured LangGraph (utility) provider
+      const { buildLLM } = await import('./build-llm')
+      const { llm } = await buildLLM()
+
+      const response = await llm.invoke([new HumanMessage(prompt)])
+      const digestContent = typeof response.content === 'string'
+        ? response.content
+        : Array.isArray(response.content)
+          ? response.content.map((b) => ('text' in b && typeof b.text === 'string' ? b.text : '')).join('')
+          : ''
+
+      if (!digestContent.trim()) continue
+
+      const linkedMemoryIds = candidates.slice(0, 10).map((m) => m.id)
+      memDb.add({
+        agentId,
+        sessionId: null,
+        category: 'daily_digest',
+        title: digestTitle,
+        content: digestContent.trim(),
+        linkedMemoryIds,
+      })
+      digestsCreated++
+    } catch (err: unknown) {
+      errors.push(`Agent ${agentId}: ${err instanceof Error ? err.message : String(err)}`)
+    }
+  }
+
+  // Run maintenance: dedupe + prune stale working entries
+  const maintenance = memDb.maintain({ dedupe: true, pruneWorking: true, ttlHours: 24 })
+
+  return {
+    digests: digestsCreated,
+    pruned: maintenance.pruned,
+    deduped: maintenance.deduped,
+    errors,
+  }
+}