@swarmclawai/swarmclaw 1.2.0 → 1.2.1

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

@@ -1,6 +1,9 @@
+import { log } from '@/lib/server/logger'
 import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
 import { resolveConnectorIngressReply } from './ingress-delivery'
 
+const TAG = 'googlechat'
+
 const googlechat: PlatformConnector = {
   async start(connector, botToken, onMessage): Promise<ConnectorInstance> {
     const pkg = 'googleapis'
@@ -29,11 +32,11 @@ const googlechat: PlatformConnector = {
     const handlerKey = `__swarmclaw_googlechat_handler_${connector.id}__`
     let stopped = false
 
-    console.log(`[googlechat] Bot authenticated via service account`)
+    log.info(TAG, 'Bot authenticated via service account')
     if (allowedSpaces) {
-      console.log(`[googlechat] Filtering to spaces: ${allowedSpaces.join(', ')}`)
+      log.info(TAG, `Filtering to spaces: ${allowedSpaces.join(', ')}`)
     }
-    console.log(`[googlechat] Inbound webhook endpoint: /api/connectors/${connector.id}/webhook`)
+    log.info(TAG, `Inbound webhook endpoint: /api/connectors/${connector.id}/webhook`)
 
     function cleanInboundText(raw: unknown): string {
       const txt = typeof raw === 'string' ? raw : ''
@@ -100,7 +103,7 @@ const googlechat: PlatformConnector = {
         stopped = true
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         delete (globalThis as any)[handlerKey]
-        console.log(`[googlechat] Bot disconnected`)
+        log.info(TAG, 'Bot disconnected')
       },
     }
   },

package/src/lib/server/connectors/inbound-audio-transcription.ts

@@ -1,3 +1,4 @@
+import { log } from '@/lib/server/logger'
 import fs from 'node:fs'
 import path from 'node:path'
 import { decryptKey, loadCredentials, loadSettings } from '../storage'
@@ -5,6 +6,8 @@ import { mimeFromPath } from './media'
 import type { InboundMessage, InboundMedia } from './types'
 import { errorMessage } from '@/lib/shared-utils'
 
+const TAG = 'audio-transcription'
+
 const PLACEHOLDER_TEXT = new Set([
   '',
   '(media message)',
@@ -250,11 +253,11 @@ export async function enrichInboundMessageWithAudioTranscript(params: {
     try {
       const transcript = (await attempt.run()).replace(/\s+/g, ' ').trim()
       if (!transcript) continue
-      console.log(`[connector] Inbound audio transcribed via ${attempt.provider}: ${path.basename(localPath)}`)
+      log.info(TAG, `Inbound audio transcribed via ${attempt.provider}: ${path.basename(localPath)}`)
       return { ...msg, text: transcript }
     } catch (err: unknown) {
       const reason = errorMessage(err)
-      console.warn(`[connector] Inbound audio transcription failed via ${attempt.provider}: ${reason}`)
+      log.warn(TAG, `Inbound audio transcription failed via ${attempt.provider}: ${reason}`)
     }
   }
 

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

@@ -1,9 +1,12 @@
+import { log } from '@/lib/server/logger'
 import fs from 'fs'
 import path from 'path'
 import { DATA_DIR } from '../data-dir'
 import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
 import { resolveConnectorIngressReply } from './ingress-delivery'
 
+const TAG = 'matrix'
+
 const matrix: PlatformConnector = {
   async start(connector, botToken, onMessage): Promise<ConnectorInstance> {
     const pkg = 'matrix-bot-sdk'
@@ -52,7 +55,7 @@ const matrix: PlatformConnector = {
         if (!reply) return
         await client.sendText(roomId, reply.visibleText)
       } catch (err: any) {
-        console.error(`[matrix] Error handling message:`, err.message)
+        log.error(TAG, 'Error handling message:', err.message)
         try {
           await client.sendText(roomId, 'Sorry, I encountered an error processing your message.')
         } catch { /* ignore */ }
@@ -60,7 +63,7 @@ const matrix: PlatformConnector = {
     })
 
     await client.start()
-    console.log(`[matrix] Bot connected to ${homeserverUrl}`)
+    log.info(TAG, `Bot connected to ${homeserverUrl}`)
 
     return {
       connector,
@@ -69,7 +72,7 @@ const matrix: PlatformConnector = {
       },
       async stop() {
         client.stop()
-        console.log(`[matrix] Bot disconnected`)
+        log.info(TAG, 'Bot disconnected')
       },
     }
   },

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

@@ -12,6 +12,9 @@ import {
   type GatewayFrame,
   type GatewayResponseFrame,
 } from '../gateway/protocol'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'openclaw'
 
 /**
  * OpenClaw gateway connector using the current WS protocol:
@@ -443,7 +446,7 @@ async function buildOutboundAttachments(options?: OutboundSendOptions): Promise<
       })
       return { attachments: [attachment], fallbackUrl: null }
     } catch (err) {
-      console.warn(`[openclaw] Failed to inline media URL, falling back to link send: ${getErrorMessage(err)}`)
+      log.warn(TAG, `Failed to inline media URL, falling back to link send: ${getErrorMessage(err)}`)
       return { attachments: [], fallbackUrl: mediaUrl }
     }
   }
@@ -705,8 +708,8 @@ const openclaw: PlatformConnector = {
         if (lastTickAtMs <= 0) return
         const delta = Date.now() - lastTickAtMs
         if (delta <= toleranceMs) return
-        console.error(
-          `[openclaw] Tick missed (${delta}ms > ${toleranceMs}ms), forcing reconnect`,
+        log.error(
+          TAG, `Tick missed (${delta}ms > ${toleranceMs}ms), forcing reconnect`,
         )
         try { ws.close(4000, 'tick missed') } catch { /* ignore */ }
       }, pollMs)
@@ -740,7 +743,7 @@ const openclaw: PlatformConnector = {
       const previous = historyErrorLogBySession.get(sessionKey) || 0
       if (now - previous < HISTORY_ERROR_LOG_INTERVAL_MS) return
       historyErrorLogBySession.set(sessionKey, now)
-      console.warn(`[openclaw] chat.history poll failed for "${sessionKey}": ${message}`)
+      log.warn(TAG, `chat.history poll failed for "${sessionKey}": ${message}`)
     }
 
     function cleanupSocket() {
@@ -764,7 +767,7 @@ const openclaw: PlatformConnector = {
       if (stopped) return
       const delay = Math.min(RECONNECT_BASE_MS * 2 ** reconnectAttempt, RECONNECT_MAX_MS)
       reconnectAttempt++
-      console.log(`[openclaw] Reconnecting in ${delay}ms (attempt ${reconnectAttempt})`)
+      log.info(TAG, `Reconnecting in ${delay}ms (attempt ${reconnectAttempt})`)
       clearReconnectTimer()
       reconnectTimer = setTimeout(() => connect(), delay)
     }
@@ -838,7 +841,7 @@ const openclaw: PlatformConnector = {
       const lowerReason = (reason || '').toLowerCase()
       if (!lowerReason.includes('device token mismatch')) return
       if (!identity.deviceToken) return
-      console.warn('[openclaw] Clearing stale stored device token after mismatch')
+      log.warn(TAG, 'Clearing stale stored device token after mismatch')
       persistIdentityToken(undefined)
     }
 
@@ -918,11 +921,11 @@ const openclaw: PlatformConnector = {
           }
           if (tickWatchdogEnabled) startTickWatchdog()
           startHistoryPoller()
-          console.log(`[openclaw] Connected + authenticated (${wsUrl})`)
+          log.info(TAG, `Connected + authenticated (${wsUrl})`)
         })
         .catch((err: unknown) => {
           clearConnectHelloTimer()
-          console.error(`[openclaw] Connect handshake failed: ${getErrorMessage(err)}`)
+          log.error(TAG, `Connect handshake failed: ${getErrorMessage(err)}`)
           try { ws?.close(1008, 'connect failed') } catch { /* ignore */ }
         })
     }
@@ -962,7 +965,7 @@ const openclaw: PlatformConnector = {
         await sendChat(inbound.channelId, reply.visibleText)
       } catch (err: unknown) {
         const message = getErrorMessage(err)
-        console.error('[openclaw] Error routing inbound chat event:', message)
+        log.error(TAG, 'Error routing inbound chat event:', message)
         await sendChat(inbound.channelId, `[Error] ${message}`)
       }
     }
@@ -1025,7 +1028,7 @@ const openclaw: PlatformConnector = {
             ) {
               historyPollingUnsupported = true
               clearHistoryPollTimer()
-              console.warn('[openclaw] chat.history is unavailable; disabling history polling fallback')
+              log.warn(TAG, 'chat.history is unavailable; disabling history polling fallback')
               return
             }
             maybeLogHistoryError(sessionKey, message)
@@ -1059,18 +1062,18 @@ const openclaw: PlatformConnector = {
     function connect() {
       if (stopped) return
       cleanupSocket()
-      console.log(`[openclaw] Connecting to ${wsUrl}`)
+      log.info(TAG, `Connecting to ${wsUrl}`)
       ws = new WebSocket(wsUrl)
 
       ws.onopen = () => {
-        console.log(`[openclaw] Socket open: ${wsUrl}`)
+        log.info(TAG, `Socket open: ${wsUrl}`)
         connectSent = false
         connected = false
         lastTickAtMs = 0
         clearConnectHelloTimer()
         connectHelloTimer = setTimeout(() => {
           if (stopped || connected) return
-          console.warn(`[openclaw] Connect handshake timed out after ${CONNECT_HELLO_TIMEOUT_MS}ms`)
+          log.warn(TAG, `Connect handshake timed out after ${CONNECT_HELLO_TIMEOUT_MS}ms`)
           try { ws?.close(4001, 'connect timeout') } catch { /* ignore */ }
         }, CONNECT_HELLO_TIMEOUT_MS)
         connectHelloTimer.unref?.()
@@ -1080,7 +1083,7 @@ const openclaw: PlatformConnector = {
       ws.onmessage = (event) => {
         const frame = parseGatewayFrame(event.data)
         if (!frame) {
-          console.warn('[openclaw] Ignoring malformed gateway frame')
+          log.warn(TAG, 'Ignoring malformed gateway frame')
           return
         }
 
@@ -1124,14 +1127,14 @@ const openclaw: PlatformConnector = {
 
       ws.onclose = (event) => {
         const reason = event.reason || 'none'
-        console.log(`[openclaw] Disconnected (code=${event.code}, reason=${reason})`)
+        log.info(TAG, `Disconnected (code=${event.code}, reason=${reason})`)
         clearStaleTokenIfNeeded(reason)
         cleanupSocket()
         if (!stopped) scheduleReconnect()
       }
 
       ws.onerror = () => {
-        console.error('[openclaw] WebSocket error')
+        log.error(TAG, 'WebSocket error')
       }
     }
 
@@ -1189,7 +1192,7 @@ const openclaw: PlatformConnector = {
       async stop() {
         stopped = true
         cleanupSocket()
-        console.log('[openclaw] Connector stopped')
+        log.info(TAG, 'Connector stopped')
       },
     }
   },

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

@@ -6,6 +6,9 @@ import {
 } from '../storage'
 import { notify } from '../ws-hub'
 import { errorMessage, hmrSingleton } from '@/lib/shared-utils'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'connector-outbox'
 
 
 export type ConnectorOutboxStatus =
@@ -151,7 +154,7 @@ function scheduleTimer(delayMs: number): void {
     outboxState.timer = null
     outboxState.dueAt = null
     void runConnectorOutboxNow().catch((err: unknown) => {
-      console.warn(`[connector-outbox] Worker tick failed: ${errorMessage(err)}`)
+      log.warn(TAG, `Worker tick failed: ${errorMessage(err)}`)
     })
   }, Math.max(0, delayMs))
   outboxState.timer.unref?.()

package/src/lib/server/connectors/runtime-state.ts

@@ -66,4 +66,23 @@ export const connectorRuntimeState = getConnectorRuntimeState()
 
 export const runningConnectors = connectorRuntimeState.running
 
+/**
+ * Remove tracking entries for connectors that no longer exist in storage.
+ * Called periodically by the daemon health sweep.
+ */
+export function pruneConnectorTrackingState(liveConnectorIds: Set<string>): number {
+  const st = getConnectorRuntimeState()
+  let removed = 0
+  for (const id of st.lastInboundChannelByConnector.keys()) {
+    if (!liveConnectorIds.has(id)) { st.lastInboundChannelByConnector.delete(id); removed++ }
+  }
+  for (const id of st.lastInboundTimeByConnector.keys()) {
+    if (!liveConnectorIds.has(id)) { st.lastInboundTimeByConnector.delete(id); removed++ }
+  }
+  for (const id of st.generationCounter.keys()) {
+    if (!liveConnectorIds.has(id)) { st.generationCounter.delete(id); removed++ }
+  }
+  return removed
+}
+
 export type ConnectorThreadSession = Session

package/src/lib/server/connectors/session-consolidation.ts

@@ -2,10 +2,13 @@
  * One-time migration: backfill allKnownPeerIds on existing connector sessions.
  * Populates the field from existing senderId, senderIdAlt, channelId, channelIdAlt, peerKey.
  */
+import { log } from '@/lib/server/logger'
 import { loadSessions, loadSettings, saveSettings, upsertStoredItem } from '../storage'
 import type { Session } from '@/types'
 import { isDirectConnectorSession } from './session-kind'
 
+const TAG = 'session-consolidation'
+
 const ALL_KNOWN_PEER_IDS_MIGRATION_FLAG = '_migration_allKnownPeerIds'
 const THREAD_CONNECTOR_MIRROR_CLEANUP_FLAG = '_migration_pruneThreadConnectorMirrors'
 
@@ -43,7 +46,7 @@ export function backfillAllKnownPeerIds(): { migrated: number; skipped: boolean
   updated[ALL_KNOWN_PEER_IDS_MIGRATION_FLAG] = true
   saveSettings(updated)
   if (migrated > 0) {
-    console.log(`[session-consolidation] Backfilled allKnownPeerIds on ${migrated} sessions`)
+    log.info(TAG, `Backfilled allKnownPeerIds on ${migrated} sessions`)
   }
   return { migrated, skipped: false }
 }
@@ -81,7 +84,7 @@ export function pruneThreadConnectorMirrors(): { cleanedSessions: number; remove
   updated[THREAD_CONNECTOR_MIRROR_CLEANUP_FLAG] = true
   saveSettings(updated)
   if (removedMessages > 0) {
-    console.log(`[session-consolidation] Pruned ${removedMessages} mirrored connector message(s) from ${cleanedSessions} main session(s)`)
+    log.info(TAG, `Pruned ${removedMessages} mirrored connector message(s) from ${cleanedSessions} main session(s)`)
   }
   return { cleanedSessions, removedMessages, skipped: false }
 }

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

@@ -1,9 +1,12 @@
+import { log } from '@/lib/server/logger'
 import { spawn, execSync } from 'child_process'
 import type { ChildProcess } from 'child_process'
 import type { Connector } from '@/types'
 import type { PlatformConnector, ConnectorInstance, InboundMessage, ConnectorIngressResult } from './types'
 import { resolveConnectorIngressReply } from './ingress-delivery'
 
+const TAG = 'signal'
+
 const signal: PlatformConnector = {
   async start(connector, _botToken, onMessage): Promise<ConnectorInstance> {
     const phoneNumber = connector.config.phoneNumber
@@ -43,16 +46,16 @@ const signal: PlatformConnector = {
 
       daemonProc.stderr?.on('data', (chunk: Buffer) => {
         const msg = chunk.toString().trim()
-        if (msg) console.error(`[signal] stderr: ${msg}`)
+        if (msg) log.error(TAG, `stderr: ${msg}`)
       })
 
       daemonProc.on('exit', (code) => {
         if (!stopped) {
-          console.error(`[signal] daemon exited unexpectedly with code ${code}`)
+          log.error(TAG, `daemon exited unexpectedly with code ${code}`)
         }
       })
 
-      console.log(`[signal] Daemon started in stdio mode for ${phoneNumber}`)
+      log.info(TAG, `Daemon started in stdio mode for ${phoneNumber}`)
     } else if (mode === 'http') {
       // Poll the signal-cli REST API for incoming messages
       const pollInterval = 2000
@@ -74,7 +77,7 @@ const signal: PlatformConnector = {
       }
 
       pollTimer = setInterval(poll, pollInterval)
-      console.log(`[signal] Polling ${httpUrl} for ${phoneNumber} every ${pollInterval}ms`)
+      log.info(TAG, `Polling ${httpUrl} for ${phoneNumber} every ${pollInterval}ms`)
     } else {
       throw new Error(`Unknown signalCliMode: ${mode}. Use 'stdio' or 'http'.`)
     }
@@ -119,7 +122,7 @@ const signal: PlatformConnector = {
           daemonProc.kill('SIGTERM')
           daemonProc = null
         }
-        console.log(`[signal] Connector stopped for ${phoneNumber}`)
+        log.info(TAG, `Connector stopped for ${phoneNumber}`)
       },
     }
   },
@@ -177,7 +180,7 @@ export async function handleSignalEvent(
       )
     }
   } catch (err: any) {
-    console.error(`[signal] Error handling message:`, err.message)
+    log.error(TAG, 'Error handling message:', err.message)
   }
 }
 

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

@@ -7,6 +7,9 @@ import { resolveConnectorIngressReply } from './ingress-delivery'
 import { deliverChunkedConnectorText } from './delivery'
 import { downloadInboundMediaToUpload, inferInboundMediaType, mimeFromPath, isImageMime } from './media'
 import { dedup, errorMessage } from '@/lib/shared-utils'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'slack'
 
 function normalizeSlackEmoji(input: string): string {
   const raw = input.trim().replace(/^:|:$/g, '')
@@ -99,7 +102,7 @@ async function hydrateSlackThreadContext(params: {
     params.inbound.threadPersonaLabel = params.inbound.threadTitle
     params.inbound.threadHistory = history.length ? history : undefined
   } catch (err: unknown) {
-    console.warn(`[slack] Thread context bootstrap failed: ${errorMessage(err)}`)
+    log.warn(TAG, `Thread context bootstrap failed: ${errorMessage(err)}`)
   }
 }
 
@@ -141,7 +144,7 @@ const slack: PlatformConnector = {
         throw new Error('Auth test returned empty — the bot token may be revoked or the app uninstalled')
       }
       botUserId = auth.user_id as string
-      console.log(`[slack] Authenticated as @${auth.user} in workspace "${auth.team}"`)
+      log.info(TAG, `Authenticated as @${auth.user} in workspace "${auth.team}"`)
     } catch (err: any) {
       const hint = err.code === 'slack_webapi_platform_error'
         ? '. Check that your Bot Token (xoxb-...) is correct and the app is installed to the workspace.'
@@ -159,7 +162,7 @@ const slack: PlatformConnector = {
 
     // Catch global errors so they don't become unhandled rejections
     app.error(async (error) => {
-      console.error(`[slack] App error:`, error)
+      log.error(TAG, 'App error:', error)
     })
 
     // Optional: restrict to specific channels
@@ -177,7 +180,7 @@ const slack: PlatformConnector = {
       const channelId = msg.channel
       if (allowedChannels && !allowedChannels.includes(channelId)) return
 
-      console.log(`[slack] Message in ${channelId} from ${msg.user}: ${(msg.text || '').slice(0, 80)}`)
+      log.info(TAG, `Message in ${channelId} from ${msg.user}: ${(msg.text || '').slice(0, 80)}`)
 
       // Get user info for display name
       let senderName = msg.user || 'unknown'
@@ -213,7 +216,7 @@ const slack: PlatformConnector = {
                 continue
               }
             } catch (err: any) {
-              console.warn(`[slack] Media download failed (${f?.name || 'file'}):`, err?.message || String(err))
+              log.warn(TAG, `Media download failed (${f?.name || 'file'}):`, err?.message || String(err))
             }
           }
           media.push({
@@ -262,7 +265,7 @@ const slack: PlatformConnector = {
           },
         })
       } catch (err: any) {
-        console.error(`[slack] Error handling message:`, err.message)
+        log.error(TAG, 'Error handling message:', err.message)
         try {
           await say('Sorry, I encountered an error processing your message.')
         } catch { /* ignore */ }
@@ -320,12 +323,12 @@ const slack: PlatformConnector = {
           },
         })
       } catch (err: any) {
-        console.error(`[slack] Error handling mention:`, err.message)
+        log.error(TAG, 'Error handling mention:', err.message)
       }
     })
 
     await app.start()
-    console.log(`[slack] Bot connected (socket mode)`)
+    log.info(TAG, 'Bot connected (socket mode)')
 
     let appStopped = false
 
@@ -423,14 +426,14 @@ const slack: PlatformConnector = {
       async stop() {
         appStopped = true
         await app.stop()
-        console.log(`[slack] Bot disconnected`)
+        log.info(TAG, 'Bot disconnected')
       },
     }
 
     // Bolt emits 'error' on unrecoverable failures (auth revoked, socket closed permanently)
     app.error(async (error) => {
       const errMsg = error.original?.message || error.message || String(error)
-      console.error(`[slack] App error:`, errMsg)
+      log.error(TAG, 'App error:', errMsg)
       if (appStopped) return
       appStopped = true
       instance.onCrash?.(`Slack error: ${errMsg}`)

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

@@ -1,6 +1,9 @@
+import { log } from '@/lib/server/logger'
 import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
 import { resolveConnectorIngressReply } from './ingress-delivery'
 
+const TAG = 'teams'
+
 const teams: PlatformConnector = {
   async start(connector, botToken, onMessage): Promise<ConnectorInstance> {
     const pkg = 'botbuilder'
@@ -15,7 +18,7 @@ const teams: PlatformConnector = {
     })
 
     adapter.onTurnError = async (_context: unknown, error: Error) => {
-      console.error(`[teams] Turn error:`, error.message)
+      log.error(TAG, 'Turn error:', error.message)
     }
 
     // Store conversation references for proactive messaging
@@ -49,7 +52,7 @@ const teams: PlatformConnector = {
           if (!reply) return
           await context.sendActivity(reply.visibleText)
         } catch (err: any) {
-          console.error(`[teams] Error handling message:`, err.message)
+          log.error(TAG, 'Error handling message:', err.message)
           try {
             await context.sendActivity('Sorry, I encountered an error processing your message.')
           } catch { /* ignore */ }
@@ -61,8 +64,8 @@ const teams: PlatformConnector = {
     const handlerKey = `__swarmclaw_teams_handler_${connector.id}__`
     ;(globalThis as any)[handlerKey] = processActivity
 
-    console.log(`[teams] Bot registered (appId: ${appId})`)
-    console.log(`[teams] Configure your bot's messaging endpoint to POST to /api/connectors/${connector.id}/webhook`)
+    log.info(TAG, `Bot registered (appId: ${appId})`)
+    log.info(TAG, `Configure your bot's messaging endpoint to POST to /api/connectors/${connector.id}/webhook`)
 
     return {
       connector,
@@ -85,7 +88,7 @@ const teams: PlatformConnector = {
         stopped = true
         delete (globalThis as any)[handlerKey]
         conversationReferences.clear()
-        console.log(`[teams] Bot disconnected`)
+        log.info(TAG, 'Bot disconnected')
       },
     }
   },

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

@@ -7,6 +7,9 @@ import { resolveConnectorIngressReply } from './ingress-delivery'
 import { deliverChunkedConnectorText } from './delivery'
 import { downloadInboundMediaToUpload, inferInboundMediaType, mimeFromPath, isImageMime, isAudioMime } from './media'
 import { errorMessage } from '@/lib/shared-utils'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'telegram'
 
 const telegram: PlatformConnector = {
   async start(connector, botToken, onMessage): Promise<ConnectorInstance> {
@@ -20,23 +23,23 @@ const telegram: PlatformConnector = {
 
     // Log all errors
     bot.catch((err) => {
-      console.error(`[telegram] Bot error:`, err.message || err)
+      log.error(TAG, 'Bot error:', err.message || err)
     })
 
     // Delete any existing webhook so long polling works
     await bot.api.deleteWebhook().catch((err) => {
-      console.error('[telegram] Failed to delete webhook:', err.message)
+      log.error(TAG, 'Failed to delete webhook:', err.message)
     })
 
     // Log all incoming updates for debugging
     bot.use(async (ctx, next) => {
-      console.log(`[telegram] Update received: chat=${ctx.chat?.id}, from=${ctx.from?.first_name}, hasText=${!!ctx.message?.text}`)
+      log.info(TAG, `Update received: chat=${ctx.chat?.id}, from=${ctx.from?.first_name}, hasText=${!!ctx.message?.text}`)
       await next()
     })
 
     // Handle /start command (required for new conversations)
     bot.command('start', async (ctx) => {
-      console.log(`[telegram] /start from ${ctx.from?.first_name} (chat=${ctx.chat.id})`)
+      log.info(TAG, `/start from ${ctx.from?.first_name} (chat=${ctx.chat.id})`)
       await ctx.reply('Hello! I\'m ready to chat. Send me a message.')
     })
 
@@ -51,15 +54,15 @@ const telegram: PlatformConnector = {
       // that appear as short bracketed strings like [rr], [e], [read] etc.
       const hasMedia = raw.photo || raw.video || raw.audio || raw.voice || raw.document || raw.animation
       if (!hasMedia && /^\[.{1,5}\]$/.test(text.trim())) {
-        console.log(`[telegram] Ignoring system event from ${ctx.from.first_name}: ${text}`)
+        log.info(TAG, `Ignoring system event from ${ctx.from.first_name}: ${text}`)
         return
       }
 
-      console.log(`[telegram] Message from ${ctx.from.first_name} (chat=${chatId}): ${String(text).slice(0, 80)}`)
+      log.info(TAG, `Message from ${ctx.from.first_name} (chat=${chatId}): ${String(text).slice(0, 80)}`)
 
       // Filter by allowed chats if configured
       if (allowedChats && !allowedChats.includes(chatId)) {
-        console.log(`[telegram] Skipping — chat ${chatId} not in allowed list: ${allowedChats.join(',')}`)
+        log.info(TAG, `Skipping — chat ${chatId} not in allowed list: ${allowedChats.join(',')}`)
         return
       }
 
@@ -125,7 +128,7 @@ const telegram: PlatformConnector = {
           })
           if (stored) media.push(stored)
         } catch (err: any) {
-          console.warn(`[telegram] Failed to fetch media ${m.fileId}:`, err?.message || String(err))
+          log.warn(TAG, `Failed to fetch media ${m.fileId}:`, err?.message || String(err))
           media.push({
             type: m.type,
             fileName: m.fileName,
@@ -175,7 +178,7 @@ const telegram: PlatformConnector = {
           },
         })
       } catch (err: any) {
-        console.error(`[telegram] Error handling message:`, err.message)
+        log.error(TAG, 'Error handling message:', err.message)
         try {
           await ctx.reply('Sorry, I encountered an error processing your message.')
         } catch { /* ignore */ }
@@ -268,7 +271,7 @@ const telegram: PlatformConnector = {
       async stop() {
         botRunning = false
         await bot.stop()
-        console.log(`[telegram] Bot stopped`)
+        log.info(TAG, 'Bot stopped')
       },
     }
 
@@ -277,12 +280,12 @@ const telegram: PlatformConnector = {
       allowed_updates: ['message', 'edited_message'],
       onStart: (botInfo) => {
         botUsername = botInfo.username || ''
-        console.log(`[telegram] Bot started as @${botInfo.username} — polling for updates`)
+        log.info(TAG, `Bot started as @${botInfo.username} — polling for updates`)
       },
     }).catch((err: unknown) => {
       botRunning = false
       const errMsg = errorMessage(err)
-      console.error(`[telegram] Polling stopped with error:`, errMsg)
+      log.error(TAG, 'Polling stopped with error:', errMsg)
       instance.onCrash?.(`Polling stopped: ${errMsg}`)
     })