@swarmclawai/swarmclaw 1.2.0 → 1.2.2

package/src/lib/server/chat-execution/stream-agent-chat.ts

@@ -3,9 +3,10 @@ import { HumanMessage, AIMessage } from '@langchain/core/messages'
 import { createReactAgent } from '@langchain/langgraph/prebuilt'
 import { MemorySaver } from '@langchain/langgraph'
 import { DEFAULT_HEARTBEAT_INTERVAL_SEC } from '@/lib/runtime/heartbeat-defaults'
+import { getAgent } from '@/lib/server/agents/agent-repository'
 import { buildSessionTools } from '@/lib/server/session-tools'
 import { buildChatModel } from '@/lib/server/build-llm'
-import { loadSettings, loadAgents } from '@/lib/server/storage'
+import { loadSettings } from '@/lib/server/settings/settings-repository'
 import { getExtensionManager } from '@/lib/server/extensions'
 import {
   collectCapabilityAgentContext,
@@ -28,6 +29,7 @@ import {
   buildCredentialAwarenessSection,
 } from '@/lib/server/chat-execution/prompt-sections'
 
+import { log } from '@/lib/server/logger'
 import { logExecution } from '@/lib/server/execution-log'
 import { buildCurrentDateTimePromptContext } from '@/lib/server/prompt-runtime-context'
 import { expandExtensionIds } from '@/lib/server/tool-aliases'
@@ -40,6 +42,7 @@ import { routeTaskIntent } from '@/lib/server/capability-router'
 import { isDirectConnectorSession } from '@/lib/server/connectors/session-kind'
 import { resolveSessionToolPolicy } from '@/lib/server/tool-capability-policy'
 import { ToolLoopTracker } from '@/lib/server/tool-loop-detection'
+import { isHeartbeatSource } from '@/lib/server/runtime/heartbeat-source'
 import { isCurrentThreadRecallRequest } from '@/lib/server/memory/memory-policy'
 import {
   resolveEffectiveSessionMemoryScopeMode,
@@ -99,6 +102,8 @@ import {
   type MessageClassification,
 } from '@/lib/server/chat-execution/message-classifier'
 
+const TAG = 'stream-agent-chat'
+
 // LangGraph unhandledRejection handler has been moved to src/instrumentation.ts
 // to avoid re-registration on every HMR reload.
 
@@ -175,6 +180,8 @@ interface StreamAgentChatOpts {
   fallbackCredentialIds?: string[]
   signal?: AbortSignal
   promptMode?: PromptMode
+  /** Run source (e.g. 'heartbeat', 'chat', 'scheduler') — used for heartbeat-specific tuning. */
+  source?: string
 }
 
 export interface StreamAgentChatResult {
@@ -207,6 +214,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
 async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAgentChatResult> {
   const startTs = Date.now()
   const { session, message, imagePath, imageUrl, attachedFiles, apiKey, systemPrompt, extraSystemContext, write, history, fallbackCredentialIds, signal } = opts
+  const isHeartbeat = isHeartbeatSource(opts.source)
   const promptMode: PromptMode = opts.promptMode ?? resolvePromptMode(session)
   const isMinimalPrompt = promptMode === 'minimal'
   const isConnectorSession = isDirectConnectorSession(session)
@@ -221,13 +229,14 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   // fallbackCredentialIds is intentionally accepted for compatibility with caller signatures.
   void fallbackCredentialIds
 
+  const sessionAgent = session.agentId ? getAgent(session.agentId) : null
+
   // Resolve agent's thinking level for provider-native params
   let agentThinkingLevel: 'minimal' | 'low' | 'medium' | 'high' | undefined
   if (session.thinkingLevel) {
     agentThinkingLevel = session.thinkingLevel
-  } else if (session.agentId) {
-    const agentsForThinking = loadAgents()
-    agentThinkingLevel = agentsForThinking[session.agentId]?.thinkingLevel
+  } else if (sessionAgent) {
+    agentThinkingLevel = sessionAgent.thinkingLevel
   }
 
   const llm = buildChatModel({
@@ -313,9 +322,8 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   let agentResponseStyle: 'concise' | 'normal' | 'detailed' | null = null
   let agentResponseMaxChars: number | null = null
   const activeProjectContext = resolveActiveProjectContext(session)
-  if (session.agentId) {
-    const agents = loadAgents()
-    const agent = agents[session.agentId]
+  if (sessionAgent) {
+    const agent = sessionAgent
     isCoordinatorAgent = agent?.role === 'coordinator'
     agentDelegationEnabled = agent?.delegationEnabled === true
     agentDelegationTargetMode = agent?.delegationTargetMode === 'selected' ? 'selected' : 'all'
@@ -366,7 +374,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     const extensionContextParts = await collectCapabilityAgentContext(session, sessionExtensions, message, history)
     promptParts.push(...extensionContextParts)
   } catch (err: unknown) {
-    console.error('[stream-agent-chat] Capability context injection failed:', err instanceof Error ? err.message : String(err))
+    log.error(TAG, 'Capability context injection failed:', err instanceof Error ? err.message : String(err))
   }
 
   // Project context — full mode only
@@ -408,13 +416,15 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
 
   // Proactive memory recall — full mode only
   {
-    const agents = loadAgents()
-    const agentForMemory = session.agentId ? agents[session.agentId] : null
-    const memoryBlock = await buildProactiveMemorySection(
-      session, agentForMemory, message, activeProjectContext.projectRoot,
+    const memoryResult = await buildProactiveMemorySection(
+      session, sessionAgent, message, activeProjectContext.projectRoot,
       isMinimalPrompt, currentThreadRecallRequest,
     )
-    if (memoryBlock) promptParts.push(memoryBlock)
+    if (memoryResult.section) promptParts.push(memoryResult.section)
+    // Persist injection dedup counts so repeated memories are suppressed
+    if (Object.keys(memoryResult.injectedIds).length > 0) {
+      session.injectedMemoryIds = memoryResult.injectedIds
+    }
   }
 
   // Goal anchor — keeps the agent focused when context is long.
@@ -429,9 +439,26 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   const budget = isMinimalPrompt ? MINIMAL_PROMPT_BUDGET : DEFAULT_PROMPT_BUDGET
   const budgetResult = applyPromptBudget(promptParts, budget)
   if (budgetResult.truncated) {
-    console.warn(`[stream-agent-chat] Prompt truncated: ${budgetResult.originalChars} chars → ${budget.maxTotalChars} chars (mode=${promptMode})`)
+    log.warn(TAG, `Prompt truncated: ${budgetResult.originalChars} chars → ${budget.maxTotalChars} chars (mode=${promptMode})`)
   } else if (isOverWarningThreshold(budgetResult.originalChars, budget)) {
-    console.warn(`[stream-agent-chat] Prompt near budget: ${budgetResult.originalChars}/${budget.maxTotalChars} chars (mode=${promptMode})`)
+    log.warn(TAG, `Prompt near budget: ${budgetResult.originalChars}/${budget.maxTotalChars} chars (mode=${promptMode})`)
+  }
+  // Emit prompt section telemetry (no-op when perf disabled)
+  if (perf.isEnabled()) {
+    const sectionSizes: Record<string, number> = {}
+    for (let i = 0; i < rawPromptParts.length; i++) {
+      const part = rawPromptParts[i]
+      const headerMatch = part.match(/^##?\s+(.+?)[\n\r]/)
+      const label = headerMatch ? headerMatch[1].slice(0, 30) : `section_${i}`
+      sectionSizes[label] = (sectionSizes[label] || 0) + part.length
+    }
+    perf.start('prompt', 'budget', {
+      sessionId: session.id,
+      totalChars: budgetResult.originalChars,
+      budgetMax: budget.maxTotalChars,
+      truncated: budgetResult.truncated,
+      sections: sectionSizes,
+    })()
   }
   let prompt = budgetResult.prompt
 
@@ -443,6 +470,8 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     ...(typeof settings.toolLoopFrequencyWarn === 'number' && { toolFrequencyWarn: settings.toolLoopFrequencyWarn }),
     ...(typeof settings.toolLoopFrequencyCritical === 'number' && { toolFrequencyCritical: settings.toolLoopFrequencyCritical }),
     ...(typeof settings.toolLoopCircuitBreaker === 'number' && { circuitBreaker: settings.toolLoopCircuitBreaker }),
+    // Heartbeat runs are brief status checks — tighten thresholds significantly
+    ...(isHeartbeat && { toolFrequencyWarn: 8, toolFrequencyCritical: 15 }),
   })
   const emittedPreToolWarnings = new Set<string>()
   const recursionLimit = getAgentLoopRecursionLimit(runtime)
@@ -453,14 +482,14 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
 
   async function buildContentForFile(filePath: string): Promise<LangChainContentPart | string | null> {
     if (!fs.existsSync(filePath)) {
-      console.log(`[stream-agent-chat] FILE NOT FOUND: ${filePath}`)
+      log.info(TAG, `FILE NOT FOUND: ${filePath}`)
       return null
     }
     const name = filePath.split('/').pop() || 'file'
     if (IMAGE_EXTS.test(filePath)) {
       const buf = fs.readFileSync(filePath)
       if (buf.length === 0) {
-        console.warn(`[stream-agent-chat] Image file is empty: ${filePath}`)
+        log.warn(TAG, `Image file is empty: ${filePath}`)
         return `[Attached image: ${name} — file is empty]`
       }
       const data = buf.toString('base64')
@@ -587,8 +616,8 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
         summarize,
       })
       effectiveHistory = result.messages
-      console.log(
-        `[stream-agent-chat] Auto-compacted ${session.id}: ${recentHistory.length} → ${effectiveHistory.length} msgs` +
+      log.info(TAG,
+        `Auto-compacted ${session.id}: ${recentHistory.length} → ${effectiveHistory.length} msgs` +
         ` (prompt history ${promptHistoryTokens} tokens)` +
         (result.summaryAdded ? ' (LLM summary)' : ' (sliding window fallback)'),
       )
@@ -783,7 +812,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   // Init turn state and limits
   // -------------------------------------------------------------------------
   const state = new ChatTurnState()
-  const limits = new ContinuationLimits(isConnectorSession)
+  const limits = new ContinuationLimits(isConnectorSession, isHeartbeat)
   const routingDecision = routeTaskIntent(message, sessionExtensions, null)
   const explicitRequiredToolNames = getExplicitRequiredToolNames(message, sessionExtensions)
 
@@ -896,14 +925,18 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
           && !abortController.signal.aborted)
           || (isTransientProviderError && !abortController.signal.aborted)
 
-        const logLevel = abortController.signal.aborted ? 'warn' : 'error'
-        console[logLevel](`[stream-agent-chat] Error in streamEvents iteration=${iteration}`, {
+        const logPayload = {
           errName, errMsg, errStack,
           statusCode, retryAfterMs: extractedRetryAfterMs,
           isRecursionError, isContextOverflow, isTransientAbort,
           hasToolCalls: state.hasToolCalls, fullTextLen: state.fullText.length,
           parentAborted: abortController.signal.aborted,
-        })
+        }
+        if (abortController.signal.aborted) {
+          log.warn(TAG, `Error in streamEvents iteration=${iteration}`, logPayload)
+        } else {
+          log.error(TAG, `Error in streamEvents iteration=${iteration}`, logPayload)
+        }
 
         if (timers.requiredToolKickoffTimedOut && limits.canContinue('required_tool') && !abortController.signal.aborted) {
           const hadPartialOutput = state.fullText.length > iterationStartState.fullText.length || state.streamedToolEvents.length > iterationStartState.toolEventCount
@@ -1069,9 +1102,9 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
 
       if (!shouldContinue) break
 
-      // Reset tool loop tracker on loop_recovery so the agent gets a fresh frequency budget
+      // Partial reset on loop_recovery: clear frequency counts but preserve circuit breaker + repeat history
       if (shouldContinue === 'loop_recovery') {
-        loopTracker.reset()
+        loopTracker.resetFrequencyCounts()
       }
 
       const continuationAssistantText = shouldContinue === 'memory_write_followthrough'

package/src/lib/server/chatrooms/chatroom-memory-bridge.ts

@@ -5,6 +5,9 @@
  * can recall cross-context conversations (chatroom ↔ direct chat).
  */
 import type { Agent } from '@/types'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'chatroom-memory-bridge'
 
 /** Truncate text to a max length, collapsing whitespace */
 function truncate(text: string, max: number): string {
@@ -58,7 +61,7 @@ export async function persistChatroomInteractionMemory(params: {
     })
   } catch (err: unknown) {
     // Non-critical — log and continue
-    console.warn('[chatroom-memory-bridge] Failed to persist interaction memory:', err instanceof Error ? err.message : String(err))
+    log.warn(TAG, 'Failed to persist interaction memory:', err instanceof Error ? err.message : String(err))
   }
 }
 
@@ -126,9 +129,9 @@ export async function summarizeAndConsolidateChatroomMemories(params: {
       })
     } catch (llmErr: unknown) {
       // LLM summarization is best-effort
-      console.warn('[chatroom-memory-bridge] LLM summarization failed:', llmErr instanceof Error ? llmErr.message : String(llmErr))
+      log.warn(TAG, 'LLM summarization failed:', llmErr instanceof Error ? llmErr.message : String(llmErr))
     }
   } catch (err: unknown) {
-    console.warn('[chatroom-memory-bridge] Failed to consolidate memories:', err instanceof Error ? err.message : String(err))
+    log.warn(TAG, 'Failed to consolidate memories:', err instanceof Error ? err.message : String(err))
   }
 }

package/src/lib/server/chatrooms/chatroom-repository.ts

@@ -0,0 +1,32 @@
+import type { Chatroom } from '@/types'
+
+import {
+  loadChatroom as loadStoredChatroom,
+  loadChatrooms as loadStoredChatrooms,
+  saveChatrooms as saveStoredChatrooms,
+  upsertChatroom as upsertStoredChatroom,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const chatroomRepository = createRecordRepository<Chatroom>(
+  'chatrooms',
+  {
+    get(id) {
+      return loadStoredChatroom(id) as Chatroom | null
+    },
+    list() {
+      return loadStoredChatrooms() as Record<string, Chatroom>
+    },
+    upsert(id, value) {
+      upsertStoredChatroom(id, value as Chatroom)
+    },
+    replace(data) {
+      saveStoredChatrooms(data)
+    },
+  },
+)
+
+export const loadChatrooms = () => chatroomRepository.list()
+export const loadChatroom = (id: string) => chatroomRepository.get(id)
+export const saveChatrooms = (items: Record<string, Chatroom | Record<string, unknown>>) => chatroomRepository.replace(items as Record<string, Chatroom>)
+export const upsertChatroom = (id: string, value: Chatroom | Record<string, unknown>) => chatroomRepository.upsert(id, value as Chatroom)

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

@@ -1,7 +1,10 @@
+import { log } from '@/lib/server/logger'
 import crypto from 'node:crypto'
 import type { PlatformConnector, ConnectorInstance, InboundMessage, InboundMedia } from './types'
 import { resolveConnectorIngressReply } from './ingress-delivery'
 
+const TAG = 'bluebubbles'
+
 const DEFAULT_TIMEOUT_MS = 10_000
 const DEFAULT_WEBHOOK_PATH = '/api/connectors/{id}/webhook'
 
@@ -283,8 +286,8 @@ const bluebubbles: PlatformConnector = {
       throw new Error(`BlueBubbles ping failed (${pingRes.status})`)
     }
 
-    console.log(`[bluebubbles] Connected to ${serverUrl}`)
-    console.log(`[bluebubbles] Inbound webhook endpoint: ${DEFAULT_WEBHOOK_PATH.replace('{id}', connector.id)}`)
+    log.info(TAG, `Connected to ${serverUrl}`)
+    log.info(TAG, `Inbound webhook endpoint: ${DEFAULT_WEBHOOK_PATH.replace('{id}', connector.id)}`)
 
     return {
       connector,
@@ -302,7 +305,7 @@ const bluebubbles: PlatformConnector = {
         stopped = true
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         delete (globalThis as any)[handlerKey]
-        console.log(`[bluebubbles] Connector stopped`)
+        log.info(TAG, 'Connector stopped')
       },
     }
   },
@@ -351,7 +354,7 @@ async function sendBlueBubblesText(params: {
     // BlueBubbles may return empty body on success in some setups.
     const message = getErrorMessage(err)
     if (!message.toLowerCase().includes('json')) {
-      console.warn(`[bluebubbles] Unable to parse send response body: ${message}`)
+      log.warn(TAG, `Unable to parse send response body: ${message}`)
     }
     return {}
   }

package/src/lib/server/connectors/connector-inbound.ts

@@ -1,3 +1,4 @@
+import { log } from '@/lib/server/logger'
 import { genId } from '@/lib/id'
 import {
   loadConnectors,
@@ -95,6 +96,8 @@ import {
 } from '@/lib/server/runtime/session-run-manager'
 import type { ExecuteChatTurnResult } from '@/lib/server/chat-execution/chat-execution'
 
+const TAG = 'connector-inbound'
+
 type ConnectorSession = Session
 type CurrentChannelConnectorDelivery = {
   mode: 'text' | 'voice_note'
@@ -205,14 +208,14 @@ async function routeOrDebounceInbound(connector: Connector, msg: InboundMessage)
     clearTimeout(pending.timer)
     pending.timer = setTimeout(() => {
       void flushDebouncedInbound(debounceKey).catch((err: unknown) => {
-        console.warn(`[connector] Debounced inbound flush failed: ${errorMessage(err)}`)
+        log.warn(TAG, `Debounced inbound flush failed: ${errorMessage(err)}`)
       })
     }, policy.inboundDebounceMs)
     pending.timer.unref?.()
   } else {
     const timer = setTimeout(() => {
       void flushDebouncedInbound(debounceKey).catch((err: unknown) => {
-        console.warn(`[connector] Debounced inbound flush failed: ${errorMessage(err)}`)
+        log.warn(TAG, `Debounced inbound flush failed: ${errorMessage(err)}`)
       })
     }, policy.inboundDebounceMs)
     timer.unref?.()
@@ -756,7 +759,7 @@ async function routeMessageToChatroom(connector: Connector, msg: InboundMessage)
     } catch (err: unknown) {
       const errMsg = errorMessage(err)
       markProviderFailure(agent.provider, errMsg)
-      console.error(`[connector] Chatroom agent ${agent.name} error:`, errMsg)
+      log.error(TAG, `Chatroom agent ${agent.name} error:`, errMsg)
     }
   }
 
@@ -785,9 +788,9 @@ async function routeMessageToChatroom(connector: Connector, msg: InboundMessage)
             replyToMessageId: replyOptions.replyToMessageId,
             threadId: replyOptions.threadId,
           })
-          console.log(`[connector] Sent chatroom media to ${msg.platform}: ${path.basename(file.path)}`)
+          log.info(TAG, `Sent chatroom media to ${msg.platform}: ${path.basename(file.path)}`)
         } catch (err: unknown) {
-          console.error(`[connector] Failed to send chatroom media ${path.basename(file.path)}:`, errorMessage(err))
+          log.error(TAG, `Failed to send chatroom media ${path.basename(file.path)}:`, errorMessage(err))
         }
       }
     }
@@ -1105,7 +1108,7 @@ If media sending fails, report the exact error and retry with a corrected path/t
         })
       } catch (err: unknown) {
         const errText = errorMessage(err)
-        console.error('[connector] queued follow-up delivery failed:', errText)
+        log.error(TAG, 'queued follow-up delivery failed:', errText)
         try {
           const { sendConnectorMessage } = await import('./connector-outbound')
           await sendConnectorMessage({
@@ -1120,7 +1123,7 @@ If media sending fails, report the exact error and retry with a corrected path/t
       }
     }).catch(async (err: unknown) => {
       const errText = errorMessage(err)
-      console.error('[connector] queued follow-up run failed:', errText)
+      log.error(TAG, 'queued follow-up run failed:', errText)
       try {
         const { sendConnectorMessage } = await import('./connector-outbound')
         await sendConnectorMessage({
@@ -1175,7 +1178,7 @@ If media sending fails, report the exact error and retry with a corrected path/t
     if (transcript) currentChannelDeliveryRef.current?.transcripts.push(transcript)
   }
   const hasTools = getEnabledCapabilityIds(session).length > 0 && session.provider !== 'claude-cli'
-  console.log(`[connector] Routing message to agent "${agent.name}" (${session.provider}/${session.model}), hasTools=${!!hasTools}`)
+  log.info(TAG, `Routing message to agent "${agent.name}" (${session.provider}/${session.model}), hasTools=${!!hasTools}`)
 
   if (hasTools) {
     try {
@@ -1269,10 +1272,10 @@ If media sending fails, report the exact error and retry with a corrected path/t
       // Use finalResponse for connectors — strips intermediate planning/tool-use text
       fullText = result.finalResponse || result.fullText
       mediaExtractionText = [result.fullText || '', ...toolMediaOutputs].filter(Boolean).join('\n\n')
-      console.log(`[connector] streamAgentChat returned ${result.fullText.length} chars total, ${fullText.length} chars final`)
+      log.info(TAG, `streamAgentChat returned ${result.fullText.length} chars total, ${fullText.length} chars final`)
     } catch (err: unknown) {
       const message = errorMessage(err)
-      console.error(`[connector] streamAgentChat error:`, message)
+      log.error(TAG, 'streamAgentChat error:', message)
       return `[Error] ${message}`
     }
   } else {
@@ -1324,7 +1327,7 @@ If media sending fails, report the exact error and retry with a corrected path/t
     } else {
       await maybeSendStatusReaction(connector, msg, 'silent')
     }
-    console.log(`[connector] Agent returned hidden control sentinel — suppressing outbound reply`)
+    log.info(TAG, 'Agent returned hidden control sentinel — suppressing outbound reply')
     logExecution(session.id, 'decision', 'Agent suppressed outbound (NO_MESSAGE)', {
       agentId: agent.id,
       detail: { platform: msg.platform, channelId: msg.channelId },
@@ -1375,7 +1378,7 @@ If media sending fails, report the exact error and retry with a corrected path/t
             replyToMessageId: replyOptions.replyToMessageId,
             threadId: replyOptions.threadId,
           })
-          console.log(`[connector] Sent media to ${msg.platform}: ${path.basename(file.path)}`)
+          log.info(TAG, `Sent media to ${msg.platform}: ${path.basename(file.path)}`)
           logExecution(session.id, 'outbound', 'Connector media sent', {
             agentId: agent.id,
             detail: {
@@ -1386,7 +1389,7 @@ If media sending fails, report the exact error and retry with a corrected path/t
             },
           })
         } catch (err: unknown) {
-          console.error(`[connector] Failed to send media ${path.basename(file.path)}:`, errorMessage(err))
+          log.error(TAG, `Failed to send media ${path.basename(file.path)}:`, errorMessage(err))
           logExecution(session.id, 'error', 'Connector media send failed', {
             agentId: agent.id,
             detail: {

package/src/lib/server/connectors/connector-lifecycle.ts

@@ -1,3 +1,4 @@
+import { log } from '@/lib/server/logger'
 import { genId } from '@/lib/id'
 import {
   loadConnectors, saveConnectors,
@@ -19,6 +20,8 @@ import {
 } from './reconnect-state'
 import { connectorRuntimeState, runningConnectors } from './runtime-state'
 
+const TAG = 'connector-lifecycle'
+
 const running = runningConnectors
 const {
   lastInboundChannelByConnector,
@@ -91,7 +94,7 @@ export async function getPlatform(platform: string) {
       }
     }
   } catch (err: unknown) {
-    console.warn(`[connector] Failed to check extensions for platform "${platform}":`, errorMessage(err))
+    log.warn(TAG, `Failed to check extensions for platform "${platform}":`, errorMessage(err))
   }
 
   throw new Error(`Unknown platform: ${platform}`)
@@ -184,7 +187,7 @@ async function _startConnectorImpl(connectorId: string): Promise<void> {
     const typedInstance = instance as ConnectorInstance
     if (!typedInstance.onCrash) {
       typedInstance.onCrash = (error: string) => {
-        console.warn(`[connector] onCrash fired for "${connector.name}" (${connectorId}): ${error}`)
+        log.warn(TAG, `onCrash fired for "${connector.name}" (${connectorId}): ${error}`)
         running.delete(connectorId)
         recordHealthEvent(connectorId, 'disconnected', `Crash callback: ${error}`)
 
@@ -217,7 +220,7 @@ async function _startConnectorImpl(connectorId: string): Promise<void> {
     clearReconnectState(connectorId)
     notify('connectors')
 
-    console.log(`[connector] Started ${connector.platform} connector: ${connector.name}`)
+    log.info(TAG, `Started ${connector.platform} connector: ${connector.name}`)
     logActivity({ entityType: 'connector', entityId: connectorId, action: 'started', actor: 'system', summary: `Connector "${connector.name}" (${connector.platform}) started` })
     recordHealthEvent(connectorId, 'started', `${connector.platform} connector "${connector.name}" started`)
   } catch (err: unknown) {
@@ -277,7 +280,7 @@ export async function stopConnector(
     notify('connectors')
   }
 
-  console.log(`[connector] Stopped connector: ${connectorId}`)
+  log.info(TAG, `Stopped connector: ${connectorId}`)
   logActivity({ entityType: 'connector', entityId: connectorId, action: 'stopped', actor: 'system', summary: `Connector stopped` })
   recordHealthEvent(connectorId, 'stopped', `Connector stopped`)
 }
@@ -340,10 +343,10 @@ export async function autoStartConnectors(): Promise<void> {
   for (const connector of Object.values(connectors) as Connector[]) {
     if (connector.isEnabled && !running.has(connector.id)) {
       try {
-        console.log(`[connector] Auto-starting ${connector.platform} connector: ${connector.name}`)
+        log.info(TAG, `Auto-starting ${connector.platform} connector: ${connector.name}`)
         await startConnector(connector.id)
       } catch (err: unknown) {
-        console.error(`[connector] Failed to auto-start ${connector.name}:`, err instanceof Error ? err.message : err)
+        log.error(TAG, `Failed to auto-start ${connector.name}:`, err instanceof Error ? err.message : err)
       }
     }
   }
@@ -434,14 +437,14 @@ export async function checkConnectorHealth(): Promise<void> {
     if (instance.isAlive()) {
       // Connector is healthy — clear any reconnect state
       if (connectorReconnectStateStore.has(id)) {
-        console.log(`[connector-health] Connector "${instance.connector.name}" recovered`)
+        log.info(TAG, `Connector "${instance.connector.name}" recovered`)
         clearReconnectState(id)
       }
       continue
     }
 
     // Connector is dead but still in the running Map
-    console.warn(`[connector-health] Connector "${instance.connector.name}" (${id}) isAlive=false — removing from running`)
+    log.warn(TAG, `Connector "${instance.connector.name}" (${id}) isAlive=false — removing from running`)
     recordHealthEvent(id, 'disconnected', `Connector "${instance.connector.name}" detected as dead (isAlive=false)`)
     notifyOrchestrators(`Connector ${instance.connector.name || id} status: disconnected`, `connector-status:${id}`)
 

package/src/lib/server/connectors/connector-outbound.ts

@@ -1,3 +1,4 @@
+import { log } from '@/lib/server/logger'
 import {
   loadConnectors,
   loadSession, upsertSession,
@@ -19,6 +20,8 @@ import { enqueueConnectorOutbox } from './outbox'
 import { connectorRuntimeState, runningConnectors } from './runtime-state'
 import { recordHealthEvent, startConnector } from './connector-lifecycle'
 
+const TAG = 'connector-outbound'
+
 const running = runningConnectors
 const { recentOutbound } = connectorRuntimeState
 const OUTBOUND_DEDUP_TTL_MS = 30_000
@@ -161,7 +164,7 @@ export async function sendConnectorMessage(params: {
 
   // Apply NO_MESSAGE filter at the delivery layer so all outbound paths respect it
   if ((suppressHiddenText || isNoMessage(sanitizedText)) && !params.imageUrl && !params.fileUrl && !params.mediaPath) {
-    console.log(`[connector] sendConnectorMessage: NO_MESSAGE — suppressing outbound send`)
+    log.info(TAG, 'sendConnectorMessage: NO_MESSAGE — suppressing outbound send')
     return { connectorId, platform: connector.platform, channelId: params.channelId, suppressed: true }
   }
 
@@ -178,7 +181,7 @@ export async function sendConnectorMessage(params: {
     text: sanitizedText,
     dedupeKey: params.dedupeKey,
   })) {
-    console.log(`[connector] sendConnectorMessage: duplicate suppressed for ${connectorId}:${channelId}`)
+    log.info(TAG, `sendConnectorMessage: duplicate suppressed for ${connectorId}:${channelId}`)
     return { connectorId, platform: connector.platform, channelId, suppressed: true }
   }
 
@@ -226,7 +229,7 @@ export async function sendConnectorMessage(params: {
   } catch (err: unknown) {
     if (!isRecoverableConnectorSendError(err)) throw err
     const errMsg = errorMessage(err)
-    console.warn(`[connector] Outbound send failed for ${connectorId}; attempting automatic restart`, { error: errMsg })
+    log.warn(TAG, `Outbound send failed for ${connectorId}; attempting automatic restart`, { error: errMsg })
     recordHealthEvent(connectorId, 'disconnected', `Outbound send failed: ${errMsg}`)
     await startConnector(connectorId)
     result = await sendThroughCurrentInstance()

package/src/lib/server/connectors/connector-repository.ts

@@ -0,0 +1,58 @@
+import type { Connector } from '@/types'
+
+import {
+  deleteStoredItem,
+  loadConnectorHealth as loadStoredConnectorHealth,
+  loadConnectors as loadStoredConnectors,
+  loadStoredItem,
+  saveConnectors as saveStoredConnectors,
+  upsertConnectorHealthEvent as upsertStoredConnectorHealthEvent,
+  upsertStoredItem,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const connectorRepository = createRecordRepository<Connector>(
+  'connectors',
+  {
+    get(id) {
+      return loadStoredItem('connectors', id) as Connector | null
+    },
+    list() {
+      return loadStoredConnectors() as Record<string, Connector>
+    },
+    upsert(id, value) {
+      upsertStoredItem('connectors', id, value)
+    },
+    replace(data) {
+      saveStoredConnectors(data)
+    },
+    patch(id, updater) {
+      const current = loadStoredItem('connectors', id) as Connector | null
+      const next = updater(current)
+      if (next === null) {
+        deleteStoredItem('connectors', id)
+        return null
+      }
+      upsertStoredItem('connectors', id, next)
+      return next
+    },
+    delete(id) {
+      deleteStoredItem('connectors', id)
+    },
+  },
+)
+
+export const loadConnectors = () => connectorRepository.list()
+export const loadConnector = (id: string) => connectorRepository.get(id)
+export const saveConnectors = (items: Record<string, Connector | Record<string, unknown>>) => connectorRepository.replace(items as Record<string, Connector>)
+export const upsertConnector = (id: string, value: Connector | Record<string, unknown>) => connectorRepository.upsert(id, value as Connector)
+export const patchConnector = (id: string, updater: (current: Connector | null) => Connector | null) => connectorRepository.patch(id, updater)
+export const deleteConnector = (id: string) => connectorRepository.delete(id)
+
+export function loadConnectorHealth() {
+  return loadStoredConnectorHealth()
+}
+
+export function upsertConnectorHealthEvent(id: string, value: Record<string, unknown>) {
+  upsertStoredConnectorHealthEvent(id, value)
+}