@swarmclawai/swarmclaw 1.2.0 → 1.2.1

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

@@ -1,5 +1,5 @@
 import makeWASocket, {
-  useMultiFileAuthState,
+  useMultiFileAuthState as createMultiFileAuthState,
   DisconnectReason,
   fetchLatestBaileysVersion,
   normalizeMessageContent,
@@ -22,6 +22,9 @@ import { getWhatsAppApprovedSenderIds } from './pairing'
 
 import { DATA_DIR } from '../data-dir'
 import { loadConnectors, loadSettings } from '../storage'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'whatsapp'
 
 const AUTH_DIR = path.join(DATA_DIR, 'whatsapp-auth')
 const INBOUND_DEDUPE_TTL_MS = 2 * 60 * 1000
@@ -210,7 +213,7 @@ function transcodeToWhatsAppVoiceNote(params: {
     })
     if ((result.status ?? 1) !== 0 || !fs.existsSync(outputPath)) {
       const stderr = (result.stderr || '').trim()
-      console.warn(`[whatsapp] Failed to transcode voice note to opus/ogg${stderr ? `: ${stderr}` : ''}`)
+      log.warn(TAG, `Failed to transcode voice note to opus/ogg${stderr ? `: ${stderr}` : ''}`)
       return null
     }
     return {
@@ -396,7 +399,7 @@ export function clearAuthDir(connectorId: string): void {
   const authDir = path.join(AUTH_DIR, connectorId)
   if (fs.existsSync(authDir)) {
     fs.rmSync(authDir, { recursive: true, force: true })
-    console.log(`[whatsapp] Cleared auth state for connector ${connectorId}`)
+    log.info(TAG, `Cleared auth state for connector ${connectorId}`)
   }
 }
 
@@ -406,7 +409,7 @@ const whatsapp: PlatformConnector = {
     const authDir = path.join(AUTH_DIR, connector.id)
     if (!fs.existsSync(authDir)) fs.mkdirSync(authDir, { recursive: true })
 
-    const { state, saveCreds } = await useMultiFileAuthState(authDir)
+    const { state, saveCreds } = await createMultiFileAuthState(authDir)
     const { version } = await fetchLatestBaileysVersion()
 
     let sock: ReturnType<typeof makeWASocket> | null = null
@@ -463,7 +466,7 @@ const whatsapp: PlatformConnector = {
               sent = await sock.sendMessage(channelId, { image: buf, caption, mimetype: mime })
             } catch (err: unknown) {
               const errMsg = errorMessage(err)
-              console.warn(`[whatsapp] Image send failed (${errMsg}); retrying as document: ${fName}`)
+              log.warn(TAG, `Image send failed (${errMsg}); retrying as document: ${fName}`)
               sent = await sock.sendMessage(channelId, { document: buf, fileName: fName, mimetype: mime, caption })
             }
           } else if (isAudioMime(mime)) {
@@ -523,7 +526,7 @@ const whatsapp: PlatformConnector = {
         clearReconnectTimer()
         try { sock?.end(undefined) } catch { /* ignore */ }
         sock = null
-        console.log(`[whatsapp] Stopped connector: ${connector.name}`)
+        log.info(TAG, `Stopped connector: ${connector.name}`)
       },
     }
 
@@ -545,7 +548,7 @@ const whatsapp: PlatformConnector = {
 
       const gen = ++socketGen // Capture generation for stale detection
       connectionState = 'connecting'
-      console.log(`[whatsapp] Starting socket gen=${gen} for ${connector.name} (hasCreds=${instance.hasCredentials})`)
+      log.info(TAG, `Starting socket gen=${gen} for ${connector.name} (hasCreds=${instance.hasCredentials})`)
 
       sock = makeWASocket({
         version,
@@ -564,10 +567,10 @@ const whatsapp: PlatformConnector = {
 
         const { connection, lastDisconnect, qr } = update
         if (typeof connection === 'string' && connection) connectionState = connection
-        console.log(`[whatsapp] Connection update gen=${gen}: connection=${connection}, hasQR=${!!qr}`)
+        log.info(TAG, `Connection update gen=${gen}: connection=${connection}, hasQR=${!!qr}`)
 
         if (qr) {
-          console.log(`[whatsapp] QR code generated for ${connector.name}`)
+          log.info(TAG, `QR code generated for ${connector.name}`)
           try {
             instance.qrDataUrl = await QRCode.toDataURL(qr, {
               width: 280,
@@ -575,17 +578,17 @@ const whatsapp: PlatformConnector = {
               color: { dark: '#000000', light: '#ffffff' },
             })
           } catch (err) {
-            console.error('[whatsapp] Failed to generate QR data URL:', err)
+            log.error(TAG, 'Failed to generate QR data URL:', err)
           }
         }
         if (connection === 'close') {
           instance.qrDataUrl = null
           const reason = (lastDisconnect?.error as any)?.output?.statusCode
-          console.log(`[whatsapp] Connection closed: reason=${reason} stopped=${stopped}`)
+          log.info(TAG, `Connection closed: reason=${reason} stopped=${stopped}`)
 
           if (reason === DisconnectReason.loggedOut) {
             // Session invalidated — clear auth and restart to get fresh QR
-            console.log(`[whatsapp] Logged out — clearing auth and restarting for fresh QR`)
+            log.info(TAG, `Logged out — clearing auth and restarting for fresh QR`)
             instance.authenticated = false
             instance.hasCredentials = false
             clearAuthDir(connector.id)
@@ -597,38 +600,38 @@ const whatsapp: PlatformConnector = {
           } else if (reason === 440) {
             // Conflict — another session replaced this one. Do NOT reconnect
             // (reconnecting would create a ping-pong loop with the other session)
-            console.log(`[whatsapp] Session conflict (replaced by another connection) — stopping`)
+            log.info(TAG, `Session conflict (replaced by another connection) — stopping`)
             instance.authenticated = false
             instance.onCrash?.('Session conflict — replaced by another connection')
           } else if (!stopped) {
-            console.log(`[whatsapp] Reconnecting in 3s...`)
+            log.info(TAG, `Reconnecting in 3s...`)
             scheduleReconnect(3000)
           } else {
-            console.log(`[whatsapp] Disconnected permanently`)
+            log.info(TAG, `Disconnected permanently`)
           }
         } else if (connection === 'open') {
           instance.authenticated = true
           instance.hasCredentials = true
           instance.qrDataUrl = null
-          console.log(`[whatsapp] Connected as ${sock?.user?.id}`)
+          log.info(TAG, `Connected as ${sock?.user?.id}`)
         }
       })
 
       sock.ev.on('messages.upsert', async (upsert) => {
         const { messages, type } = upsert
-        console.log(`[whatsapp] messages.upsert gen=${gen}: type=${type}, count=${messages.length}`)
+        log.info(TAG, `messages.upsert gen=${gen}: type=${type}, count=${messages.length}`)
 
         if (gen !== socketGen) {
-          console.log(`[whatsapp] Ignoring stale socket event (gen=${gen}, current=${socketGen})`)
+          log.info(TAG, `Ignoring stale socket event (gen=${gen}, current=${socketGen})`)
           return
         }
         if (type !== 'notify') {
-          console.log(`[whatsapp] Ignoring non-notify upsert type: ${type}`)
+          log.info(TAG, `Ignoring non-notify upsert type: ${type}`)
           return
         }
 
         for (const msg of messages) {
-          console.log(`[whatsapp] Processing message: fromMe=${msg.key.fromMe}, jid=${msg.key.remoteJid}, hasConversation=${!!msg.message?.conversation}, hasExtended=${!!msg.message?.extendedTextMessage}`)
+          log.info(TAG, `Processing message: fromMe=${msg.key.fromMe}, jid=${msg.key.remoteJid}, hasConversation=${!!msg.message?.conversation}, hasExtended=${!!msg.message?.extendedTextMessage}`)
 
           if (msg.key.remoteJid === 'status@broadcast') continue
 
@@ -637,7 +640,7 @@ const whatsapp: PlatformConnector = {
             const now = Date.now()
             const seenAt = seenInboundMessageIds.get(msgId)
             if (typeof seenAt === 'number' && now - seenAt <= INBOUND_DEDUPE_TTL_MS) {
-              console.log(`[whatsapp] Skipping duplicate inbound message id: ${msgId}`)
+              log.info(TAG, `Skipping duplicate inbound message id: ${msgId}`)
               continue
             }
             seenInboundMessageIds.set(msgId, now)
@@ -650,7 +653,7 @@ const whatsapp: PlatformConnector = {
 
           // Skip messages sent by the bot itself (tracked by ID to prevent infinite loops)
           if (msg.key.id && sentMessageIds.has(msg.key.id)) {
-            console.log(`[whatsapp] Skipping own bot reply: ${msg.key.id}`)
+            log.info(TAG, `Skipping own bot reply: ${msg.key.id}`)
             sentMessageIds.delete(msg.key.id) // Clean up
             continue
           }
@@ -662,7 +665,7 @@ const whatsapp: PlatformConnector = {
           const myPhoneNum = sock?.user?.id?.split(':')[0] || ''
           const myLid = sock?.user?.lid?.split(':')[0] || ''
           const isSelfChat = (remoteNum === myPhoneNum) || (remoteHost === 'lid' && (myLid ? remoteNum === myLid : true))
-          console.log(`[whatsapp] Self-chat check: remote=${remoteNum}@${remoteHost}, myPhone=${myPhoneNum}, myLid=${myLid}, isSelf=${isSelfChat}`)
+          log.info(TAG, `Self-chat check: remote=${remoteNum}@${remoteHost}, myPhone=${myPhoneNum}, myLid=${myLid}, isSelf=${isSelfChat}`)
           if (msg.key.fromMe && !isSelfChat) continue
 
           const jid = msg.key.remoteJid || ''
@@ -676,9 +679,9 @@ const whatsapp: PlatformConnector = {
           // Self-chat always passes the filter (it's the bot's own account)
           if (allowedJids?.length && !isSelfChat) {
             const matched = isWhatsAppInboundAllowed({ allowedJids, msg, isSelfChat })
-            console.log(`[whatsapp] JID filter: candidates=${collectWhatsAppAddressCandidates(msg).join(',')}, allowedJids=${allowedJids.join(',')}, matched=${matched}`)
+            log.info(TAG, `JID filter: candidates=${collectWhatsAppAddressCandidates(msg).join(',')}, allowedJids=${allowedJids.join(',')}, matched=${matched}`)
             if (!matched) {
-              console.log(`[whatsapp] Skipping message from non-allowed JID: ${jid}`)
+              log.info(TAG, `Skipping message from non-allowed JID: ${jid}`)
               continue
             }
           }
@@ -712,7 +715,7 @@ const whatsapp: PlatformConnector = {
               })
               media.push(saved)
             } catch (err: any) {
-              console.error(`[whatsapp] Failed to decode media: ${err?.message || String(err)}`)
+              log.error(TAG, `Failed to decode media: ${err?.message || String(err)}`)
               media.push({
                 type: mediaCandidate.kind,
                 fileName: mediaCandidate.payload?.fileName || undefined,
@@ -736,7 +739,7 @@ const whatsapp: PlatformConnector = {
             }) || undefined
           }
 
-          console.log(`[whatsapp] Message from ${inbound.senderName} (${jid}): ${inbound.text.slice(0, 80)}`)
+          log.info(TAG, `Message from ${inbound.senderName} (${jid}): ${inbound.text.slice(0, 80)}`)
 
           try {
             const reply = await resolveConnectorIngressReply(onMessage, inbound)
@@ -758,10 +761,10 @@ const whatsapp: PlatformConnector = {
                 state: 'sent',
               })
             } catch (recordErr: unknown) {
-              console.warn(`[whatsapp] Delivery recording failed (response already sent):`, errorMessage(recordErr))
+              log.warn(TAG, 'Delivery recording failed (response already sent):', errorMessage(recordErr))
             }
           } catch (err: unknown) {
-            console.error(`[whatsapp] Error handling message:`, errorMessage(err))
+            log.error(TAG, 'Error handling message:', errorMessage(err))
             try {
               await sock!.sendMessage(jid, { text: 'Sorry, I encountered an error processing your message.' })
             } catch { /* ignore */ }

package/src/lib/server/embeddings.ts

@@ -1,5 +1,8 @@
 import { loadSettings, loadCredentials, decryptKey } from './storage'
 import { hmrSingleton } from '@/lib/shared-utils'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'embeddings'
 
 interface PipelineState {
   instance: unknown
@@ -62,7 +65,7 @@ export async function getEmbedding(text: string): Promise<number[] | null> {
       return await ollamaEmbed(text, model, settings.embeddingEndpoint)
     }
   } catch (err: unknown) {
-    console.error(`[embeddings] Error computing embedding:`, err instanceof Error ? err.message : String(err))
+    log.error(TAG, 'Error computing embedding:', err instanceof Error ? err.message : String(err))
   }
 
   return null

package/src/lib/server/link-understanding.ts

@@ -1,6 +1,9 @@
 import * as cheerio from 'cheerio'
 import { dedup } from '@/lib/shared-utils'
 import { truncate } from './session-tools/context'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'link-understanding'
 
 const BARE_LINK_RE = /https?:\/\/\S+/gi
 
@@ -48,7 +51,7 @@ export async function runLinkUnderstanding(message: string): Promise<string[]> {
       }
     } catch (err) {
       // Fail silently for link understanding — don't block the main run
-      console.error(`Link understanding failed for ${url}:`, err)
+      log.error(TAG, `Link understanding failed for ${url}:`, err)
     }
   }
 

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

@@ -0,0 +1,59 @@
+/**
+ * Generates concise abstracts (~100 tokens) for memory entries.
+ * Inspired by OpenViking's L0/L1/L2 tiered context representations.
+ *
+ * Used in proactive recall to inject summaries instead of truncated raw content,
+ * reducing token waste and preserving semantic meaning.
+ */
+import { HumanMessage } from '@langchain/core/messages'
+
+const ABSTRACT_TIMEOUT_MS = 15_000
+
+/**
+ * Generate a short abstract (~100 tokens) summarizing memory content.
+ * Falls back to a truncated prefix if LLM generation fails or is unavailable.
+ */
+export async function generateAbstract(content: string, title?: string): Promise<string | null> {
+  if (!content || content.length <= 200) return null
+
+  try {
+    const { buildLLM } = await import('@/lib/server/build-llm')
+    const { llm } = await buildLLM()
+
+    const prompt = [
+      'Summarize the following memory entry in 1-2 concise sentences (max ~100 tokens).',
+      'Preserve the key facts, decisions, or conclusions. Do not add commentary.',
+      title ? `Title: ${title}` : '',
+      `Content: ${content.slice(0, 2000)}`,
+    ].filter(Boolean).join('\n')
+
+    const response = await Promise.race([
+      llm.invoke([new HumanMessage(prompt)]),
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error('abstract-timeout')), ABSTRACT_TIMEOUT_MS),
+      ),
+    ])
+
+    const text = extractText(response.content)
+    return text || fallbackAbstract(content)
+  } catch {
+    return fallbackAbstract(content)
+  }
+}
+
+function fallbackAbstract(content: string): string {
+  return content.slice(0, 150) + (content.length > 150 ? '...' : '')
+}
+
+function extractText(content: unknown): string {
+  if (typeof content === 'string') return content.trim()
+  if (Array.isArray(content)) {
+    for (const part of content) {
+      if (typeof part === 'string') return part.trim()
+      if (part && typeof part === 'object' && 'text' in part && typeof part.text === 'string') {
+        return part.text.trim()
+      }
+    }
+  }
+  return ''
+}

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

@@ -5,6 +5,7 @@ import { createHash } from 'crypto'
 import { genId } from '@/lib/id'
 import type { MemoryEntry, FileReference, MemoryImage, MemoryReference } from '@/types'
 import { getEmbedding, cosineSimilarity, serializeEmbedding, deserializeEmbedding } from '@/lib/server/embeddings'
+import { hmrSingleton } from '@/lib/shared-utils'
 import { applyMMR } from '@/lib/server/mmr'
 import { calculateTemporalDecayMultiplier, isDecayExempt } from '@/lib/server/memory/temporal-decay'
 import { loadSettings } from '@/lib/server/storage'
@@ -17,9 +18,13 @@ import {
 } from '@/lib/server/memory/memory-graph'
 import { isWorkingMemoryCategory } from '@/lib/server/memory/memory-tiers'
 
+import { generateAbstract } from '@/lib/server/memory/memory-abstract'
 import { DATA_DIR, MEMORY_IMAGES_DIR, WORKSPACE_DIR } from '@/lib/server/data-dir'
 import { safeJsonParse } from '@/lib/server/json-utils'
 import { tryResolvePathWithinBaseDir } from '@/lib/server/path-utils'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'memory-db'
 
 const DB_PATH = path.join(DATA_DIR, 'memory.db')
 const IMAGES_DIR = MEMORY_IMAGES_DIR
@@ -207,19 +212,28 @@ function shouldSkipSearchQuery(input: string): boolean {
 }
 
 // Simple cache for query embeddings to avoid blocking
-const embeddingCache = new Map<string, number[]>()
+const EMBEDDING_CACHE_MAX = 100
+const EMBEDDING_CACHE_EVICT_TO = 80
+const embeddingCache = hmrSingleton('__swarmclaw_memory_embedding_cache__', () => new Map<string, number[]>())
+
+function evictEmbeddingCache(): void {
+  if (embeddingCache.size <= EMBEDDING_CACHE_MAX) return
+  const excess = embeddingCache.size - EMBEDDING_CACHE_EVICT_TO
+  const iter = embeddingCache.keys()
+  for (let i = 0; i < excess; i++) {
+    const k = iter.next().value
+    if (k !== undefined) embeddingCache.delete(k)
+  }
+}
 
 function getEmbeddingSync(query: string): number[] | null {
   const cached = embeddingCache.get(query)
   if (cached) return cached
+  // Evict before async call to bound growth regardless of resolution
+  evictEmbeddingCache()
   // Kick off async computation for next time
   getEmbedding(query).then((emb) => {
     if (emb) embeddingCache.set(query, emb)
-    // Evict old entries
-    if (embeddingCache.size > 100) {
-      const firstKey = embeddingCache.keys().next().value
-      if (firstKey) embeddingCache.delete(firstKey)
-    }
   }).catch(() => { /* ok */ })
   return null
 }
@@ -524,6 +538,7 @@ function initDb() {
     'lastAccessedAt INTEGER DEFAULT 0',
     'contentHash TEXT',
     'reinforcementCount INTEGER DEFAULT 0',
+    'abstract TEXT',
   ]) {
     try { db.exec(`ALTER TABLE memories ADD COLUMN ${col}`) } catch { /* already exists */ }
   }
@@ -612,7 +627,7 @@ function initDb() {
       migrated++
     }
     if (migrated > 0) {
-      console.log(`[memory-db] Migrated ${migrated} legacy memory row(s) to graph schema`)
+      log.info(TAG, `Migrated ${migrated} legacy memory row(s) to graph schema`)
     }
   })
   migrateLegacyRows()
@@ -632,7 +647,7 @@ function initDb() {
       })
       tx()
     }
-    console.log(`[memory-db] Backfilled contentHash for ${backfillRows.length} memory row(s)`)
+    log.info(TAG, `Backfilled contentHash for ${backfillRows.length} memory row(s)`)
   }
 
   // Fresh installs now start with an empty memory graph.
@@ -642,9 +657,9 @@ function initDb() {
     insert: db.prepare(`
       INSERT INTO memories (
         id, agentId, sessionId, category, title, content, metadata, embedding,
-        "references", filePaths, image, imagePath, linkedMemoryIds, pinned, sharedWith, contentHash, createdAt, updatedAt
+        "references", filePaths, image, imagePath, linkedMemoryIds, pinned, sharedWith, contentHash, abstract, createdAt, updatedAt
       )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `),
     update: db.prepare(`
       UPDATE memories
@@ -748,6 +763,7 @@ function initDb() {
       lastAccessedAt: typeof row.lastAccessedAt === 'number' ? row.lastAccessedAt : 0,
       contentHash: typeof row.contentHash === 'string' ? row.contentHash : undefined,
       reinforcementCount: typeof row.reinforcementCount === 'number' ? row.reinforcementCount : 0,
+      abstract: typeof row.abstract === 'string' ? row.abstract : null,
       createdAt: typeof row.createdAt === 'number' ? row.createdAt : Date.now(),
       updatedAt: typeof row.updatedAt === 'number' ? row.updatedAt : Date.now(),
     }
@@ -819,6 +835,7 @@ function initDb() {
         pinned,
         sharedWith,
         contentHash,
+        null, // abstract computed async
         now, now,
       )
       // Compute embedding in background (fire-and-forget)
@@ -829,7 +846,16 @@ function initDb() {
             serializeEmbedding(emb), id,
           )
         }
-      }).catch((err: unknown) => { console.warn(`[memory-db] Embedding generation failed for memory ${id}:`, err instanceof Error ? err.message : String(err)) })
+      }).catch((err: unknown) => { log.warn(TAG, `Embedding generation failed for memory ${id}:`, err instanceof Error ? err.message : String(err)) })
+
+      // Generate abstract for long content in background (fire-and-forget)
+      if (content.length > 200) {
+        generateAbstract(content, title).then((abstract) => {
+          if (abstract) {
+            db.prepare(`UPDATE memories SET abstract = ? WHERE id = ?`).run(abstract, id)
+          }
+        }).catch(() => { /* non-critical */ })
+      }
 
       // Keep memory links bidirectional by default.
       if (linkedMemoryIds.length) this.link(id, linkedMemoryIds, true)
@@ -1086,7 +1112,7 @@ function initDb() {
           })
         }
       } catch (err: unknown) {
-        console.warn('[memory-db] Vector search failed, falling back to FTS:', err instanceof Error ? err.message : String(err))
+        log.warn(TAG, 'Vector search failed, falling back to FTS:', err instanceof Error ? err.message : String(err))
       }
 
       // Merge: deduplicate by id
@@ -1146,8 +1172,8 @@ function initDb() {
 
       const elapsed = Date.now() - startedAt
       if (elapsed > 1200) {
-        console.warn(
-          `[memory-db] Slow search ${elapsed}ms (scope=${scopeMode}, rerank=${rerankMode}, rawLen=${String(query || '').length}, fts="${ftsQuery.slice(0, 180)}")`,
+        log.warn(TAG,
+          `Slow search ${elapsed}ms (scope=${scopeMode}, rerank=${rerankMode}, rawLen=${String(query || '').length}, fts="${ftsQuery.slice(0, 180)}")`,
         )
       }
       return out

package/src/lib/server/missions/mission-service.ts

@@ -1,3 +1,4 @@
+import { log } from '@/lib/server/logger'
 import { genId } from '@/lib/id'
 import type {
   ApprovalRequest,
@@ -50,6 +51,8 @@ import { errorMessage, hmrSingleton } from '@/lib/shared-utils'
 import { getSessionQueueSnapshot, listRuns } from '@/lib/server/runtime/session-run-manager'
 import { notify } from '@/lib/server/ws-hub'
 
+const TAG = 'mission-service'
+
 function now(): number {
   return Date.now()
 }
@@ -1146,7 +1149,7 @@ export function requestMissionTick(
   })
   queueMicrotask(() => {
     void runMissionTick(missionId, trigger).catch((err: unknown) => {
-      console.warn(`[missions] mission tick failed for ${missionId}: ${errorMessage(err)}`)
+      log.warn(TAG, `mission tick failed for ${missionId}: ${errorMessage(err)}`)
     })
   })
   return mission
@@ -1570,7 +1573,7 @@ export async function resolveMissionForTurn(params: {
       session: params.session,
     }, params.generateText ? { generateText: params.generateText } : undefined)
   } catch (err: unknown) {
-    console.warn(`[missions] resolveMissionForTurn failed for ${params.session.id}: ${errorMessage(err)}`)
+    log.warn(TAG, `resolveMissionForTurn failed for ${params.session.id}: ${errorMessage(err)}`)
     return null
   }
 
@@ -1649,7 +1652,7 @@ export async function applyMissionOutcomeForTurn(params: {
       linkedTaskSummaries: taskSummaries,
     }, params.generateText ? { generateText: params.generateText } : undefined)
   } catch (err: unknown) {
-    console.warn(`[missions] applyMissionOutcomeForTurn failed for ${params.session.id}: ${errorMessage(err)}`)
+    log.warn(TAG, `applyMissionOutcomeForTurn failed for ${params.session.id}: ${errorMessage(err)}`)
     return mission
   }
   if (!decision) return mission

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/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/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-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 {