@swarmclawai/swarmclaw 1.2.0 → 1.2.2

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

@@ -1,3 +1,4 @@
+import { log } from '@/lib/server/logger'
 import { Client, GatewayIntentBits, Events, Partials, AttachmentBuilder } from 'discord.js'
 import fs from 'fs'
 import path from 'path'
@@ -8,6 +9,8 @@ import { deliverChunkedConnectorText } from './delivery'
 import { downloadInboundMediaToUpload, inferInboundMediaType } from './media'
 import { errorMessage } from '@/lib/shared-utils'
 
+const TAG = 'discord'
+
 function buildDiscordThreadTitle(params: {
   threadName?: string
   channelName?: string
@@ -89,7 +92,7 @@ async function hydrateDiscordThreadContext(message: any, inbound: InboundMessage
       }].filter((entry) => entry.text.trim().length > 0)
     }
   } catch (err: unknown) {
-    console.warn(`[discord] Thread context bootstrap failed: ${errorMessage(err)}`)
+    log.warn(TAG, `Thread context bootstrap failed: ${errorMessage(err)}`)
   }
 }
 
@@ -128,7 +131,7 @@ const discord: PlatformConnector = {
     }
 
     client.on(Events.MessageCreate, async (message) => {
-      console.log(`[discord] Message from ${message.author.username} in ${message.channel.type === 1 ? 'DM' : '#' + ('name' in message.channel ? (message.channel as any).name : message.channelId)}: ${message.content.slice(0, 80)}`)
+      log.info(TAG, `Message from ${message.author.username} in ${message.channel.type === 1 ? 'DM' : '#' + ('name' in message.channel ? (message.channel as any).name : message.channelId)}: ${message.content.slice(0, 80)}`)
       // Ignore bot messages
       if (message.author.bot) return
 
@@ -155,7 +158,7 @@ const discord: PlatformConnector = {
             }
           } catch (err: unknown) {
             const errMsg = errorMessage(err)
-            console.warn(`[discord] Media download failed (${attachment.name || 'file'}):`, errMsg)
+            log.warn(TAG, `Media download failed (${attachment.name || 'file'}):`, errMsg)
           }
         }
         media.push({
@@ -215,7 +218,7 @@ const discord: PlatformConnector = {
           },
         })
       } catch (err: any) {
-        console.error(`[discord] Error handling message:`, err.message)
+        log.error(TAG, 'Error handling message:', err.message)
         try {
           await message.reply('Sorry, I encountered an error processing your message.')
         } catch { /* ignore */ }
@@ -223,7 +226,7 @@ const discord: PlatformConnector = {
     })
 
     await client.login(botToken)
-    console.log(`[discord] Bot logged in as ${client.user?.tag}`)
+    log.info(TAG, `Bot logged in as ${client.user?.tag}`)
 
     const instance: ConnectorInstance = {
       connector,
@@ -284,7 +287,7 @@ const discord: PlatformConnector = {
       },
       async stop() {
         client.destroy()
-        console.log(`[discord] Bot disconnected`)
+        log.info(TAG, 'Bot disconnected')
       },
     }
 
@@ -293,7 +296,7 @@ const discord: PlatformConnector = {
       instance.onCrash?.('Discord session invalidated')
     })
     client.on('shardError', (error) => {
-      console.error(`[discord] Shard error:`, error.message)
+      log.error(TAG, 'Shard error:', error.message)
     })
 
     return instance

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

@@ -5,6 +5,9 @@ import type { Connector } from '@/types'
 import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
 import { resolveConnectorIngressReply } from './ingress-delivery'
 import { errorMessage } from '@/lib/shared-utils'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'email'
 
 interface EmailConfig {
   imapHost: string
@@ -79,7 +82,7 @@ const email: PlatformConnector = {
       try {
         await imap.connect()
         connected = true
-        console.log(`[email] IMAP connected to ${config.imapHost}`)
+        log.info(TAG, `IMAP connected to ${config.imapHost}`)
 
         // Get the current highest UID as highwater mark (don't process old messages)
         const lock = await imap.getMailboxLock(folder)
@@ -87,14 +90,14 @@ const email: PlatformConnector = {
           const status = await imap.status(folder, { uidNext: true })
           // uidNext is the next UID that will be assigned; current highest is uidNext - 1
           highwaterUid = typeof status.uidNext === 'number' ? status.uidNext - 1 : 0
-          console.log(`[email] Initial highwater UID: ${highwaterUid} in ${folder}`)
+          log.info(TAG, `Initial highwater UID: ${highwaterUid} in ${folder}`)
         } finally {
           lock.release()
         }
       } catch (err: unknown) {
         connected = false
         const msg = errorMessage(err)
-        console.error(`[email] IMAP connection failed: ${msg}`)
+        log.error(TAG, `IMAP connection failed: ${msg}`)
         throw err
       }
     }
@@ -107,7 +110,7 @@ const email: PlatformConnector = {
         lock = await imap.getMailboxLock(folder)
       } catch (err: unknown) {
         const msg = errorMessage(err)
-        console.error(`[email] Failed to acquire mailbox lock: ${msg}`)
+        log.error(TAG, `Failed to acquire mailbox lock: ${msg}`)
         connected = false
         return
       }
@@ -127,7 +130,7 @@ const email: PlatformConnector = {
             await processMessage(msg)
           } catch (err: unknown) {
             const errMsg = errorMessage(err)
-            console.error(`[email] Error processing message UID ${msg.uid}: ${errMsg}`)
+            log.error(TAG, `Error processing message UID ${msg.uid}: ${errMsg}`)
           }
           if (msg.uid > highwaterUid) {
             highwaterUid = msg.uid
@@ -137,7 +140,7 @@ const email: PlatformConnector = {
         const errMsg = errorMessage(err)
         // A fetch on an empty range can throw; that's normal
         if (!errMsg.includes('Nothing to fetch')) {
-          console.error(`[email] Poll error: ${errMsg}`)
+          log.error(TAG, `Poll error: ${errMsg}`)
         }
       } finally {
         lock.release()
@@ -154,7 +157,7 @@ const email: PlatformConnector = {
 
       // Filter by subject prefix if configured
       if (config.subjectPrefix && !subject.startsWith(config.subjectPrefix)) {
-        console.log(`[email] Skipping message from ${fromAddr} — subject "${subject}" doesn't match prefix "${config.subjectPrefix}"`)
+        log.info(TAG, `Skipping message from ${fromAddr} — subject "${subject}" doesn't match prefix "${config.subjectPrefix}"`)
         return
       }
 
@@ -166,11 +169,11 @@ const email: PlatformConnector = {
       }
 
       if (!bodyText.trim()) {
-        console.log(`[email] Skipping empty message from ${fromAddr}`)
+        log.info(TAG, `Skipping empty message from ${fromAddr}`)
         return
       }
 
-      console.log(`[email] New message from ${fromName} <${fromAddr}>: ${subject}`)
+      log.info(TAG, `New message from ${fromName} <${fromAddr}>: ${subject}`)
 
       // Use the sender's email as channelId
       const channelId = fromAddr
@@ -199,7 +202,7 @@ const email: PlatformConnector = {
         await sendReply(channelId, reply.visibleText)
       } catch (err: unknown) {
         const errMsg = errorMessage(err)
-        console.error(`[email] Error handling message from ${fromAddr}: ${errMsg}`)
+        log.error(TAG, `Error handling message from ${fromAddr}: ${errMsg}`)
       }
     }
 
@@ -222,7 +225,7 @@ const email: PlatformConnector = {
       }
 
       await smtp.sendMail(mailOptions)
-      console.log(`[email] Reply sent to ${to}`)
+      log.info(TAG, `Reply sent to ${to}`)
     }
 
     // Connect and start polling
@@ -231,11 +234,11 @@ const email: PlatformConnector = {
     pollTimer = setInterval(() => {
       pollForNewMessages().catch((err: unknown) => {
         const msg = errorMessage(err)
-        console.error(`[email] Poll interval error: ${msg}`)
+        log.error(TAG, `Poll interval error: ${msg}`)
       })
     }, pollMs)
 
-    console.log(`[email] Connector started — polling every ${config.pollIntervalSec || 60}s`)
+    log.info(TAG, `Connector started — polling every ${config.pollIntervalSec || 60}s`)
 
     return {
       connector,
@@ -259,7 +262,7 @@ const email: PlatformConnector = {
           // Connection may already be closed
         }
         connected = false
-        console.log(`[email] Connector stopped`)
+        log.info(TAG, `Connector stopped`)
       },
     }
   },

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.test.ts

@@ -0,0 +1,117 @@
+import assert from 'node:assert/strict'
+import { describe, it, before, after } from 'node:test'
+
+const originalEnv = {
+  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
+}
+
+let mod: typeof import('@/lib/server/connectors/runtime-state')
+
+before(async () => {
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  mod = await import('@/lib/server/connectors/runtime-state')
+})
+
+after(() => {
+  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
+  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
+})
+
+// ---------------------------------------------------------------------------
+// getConnectorRuntimeState
+// ---------------------------------------------------------------------------
+
+describe('getConnectorRuntimeState', () => {
+  it('returns object with all expected Map keys', () => {
+    const state = mod.getConnectorRuntimeState()
+    assert.ok(state.running instanceof Map)
+    assert.ok(state.lastInboundChannelByConnector instanceof Map)
+    assert.ok(state.lastInboundTimeByConnector instanceof Map)
+    assert.ok(state.locks instanceof Map)
+    assert.ok(state.generationCounter instanceof Map)
+    assert.ok(state.scheduledFollowups instanceof Map)
+    assert.ok(state.recentInboundByKey instanceof Map)
+    assert.ok(state.pendingInboundDebounce instanceof Map)
+    assert.ok(state.scheduledFollowupByDedupe instanceof Map)
+    assert.ok(state.reconnectStates instanceof Map)
+    assert.ok(state.recentOutbound instanceof Map)
+    assert.ok(state.routeMessageHandlerRef)
+    assert.equal(typeof state.routeMessageHandlerRef.current, 'function')
+  })
+
+  it('returns the same instance on repeated calls (singleton)', () => {
+    const a = mod.getConnectorRuntimeState()
+    const b = mod.getConnectorRuntimeState()
+    assert.equal(a, b)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// pruneConnectorTrackingState
+// ---------------------------------------------------------------------------
+
+describe('pruneConnectorTrackingState', () => {
+  it('removes stale entries and retains live ones', () => {
+    const state = mod.getConnectorRuntimeState()
+
+    // Seed tracking maps with stale + live IDs
+    state.lastInboundChannelByConnector.set('live-1', 'channel-a')
+    state.lastInboundChannelByConnector.set('stale-1', 'channel-b')
+    state.lastInboundTimeByConnector.set('live-1', Date.now())
+    state.lastInboundTimeByConnector.set('stale-2', Date.now())
+    state.generationCounter.set('live-1', 5)
+    state.generationCounter.set('stale-1', 3)
+
+    const liveIds = new Set(['live-1'])
+    const removed = mod.pruneConnectorTrackingState(liveIds)
+
+    // Verify stale entries are gone
+    assert.equal(state.lastInboundChannelByConnector.has('stale-1'), false)
+    assert.equal(state.lastInboundTimeByConnector.has('stale-2'), false)
+    assert.equal(state.generationCounter.has('stale-1'), false)
+
+    // Verify live entries are retained
+    assert.equal(state.lastInboundChannelByConnector.get('live-1'), 'channel-a')
+    assert.ok(state.lastInboundTimeByConnector.has('live-1'))
+    assert.equal(state.generationCounter.get('live-1'), 5)
+
+    // Removed count: stale-1 from channel + stale-2 from time + stale-1 from gen = 3
+    assert.equal(removed, 3)
+  })
+
+  it('removes all entries when liveIds is empty', () => {
+    const state = mod.getConnectorRuntimeState()
+
+    state.lastInboundChannelByConnector.set('a', 'ch')
+    state.lastInboundTimeByConnector.set('a', 1)
+    state.generationCounter.set('a', 1)
+
+    const removed = mod.pruneConnectorTrackingState(new Set())
+
+    assert.equal(state.lastInboundChannelByConnector.size, 0)
+    assert.equal(state.lastInboundTimeByConnector.size, 0)
+    assert.equal(state.generationCounter.size, 0)
+    assert.ok(removed >= 3)
+  })
+
+  it('returns 0 when all IDs are live', () => {
+    const state = mod.getConnectorRuntimeState()
+
+    // Clear first
+    state.lastInboundChannelByConnector.clear()
+    state.lastInboundTimeByConnector.clear()
+    state.generationCounter.clear()
+
+    state.lastInboundChannelByConnector.set('x', 'ch')
+    state.lastInboundTimeByConnector.set('x', 1)
+    state.generationCounter.set('x', 1)
+
+    const removed = mod.pruneConnectorTrackingState(new Set(['x']))
+    assert.equal(removed, 0)
+
+    // Entries still present
+    assert.equal(state.lastInboundChannelByConnector.has('x'), true)
+    assert.equal(state.lastInboundTimeByConnector.has('x'), true)
+    assert.equal(state.generationCounter.has('x'), true)
+  })
+})

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 }
 }