@swarmclawai/swarmclaw 0.4.5 → 0.5.0

package/src/lib/personality-parser.ts

@@ -0,0 +1,97 @@
+import type { PersonalityDraft } from '@/types'
+
+// --- IDENTITY.md ---
+
+export function parseIdentityMd(content: string): PersonalityDraft['identity'] {
+  const result: PersonalityDraft['identity'] = {}
+  const lines = content.split('\n')
+  for (const line of lines) {
+    const match = line.match(/^\s*-\s*(.+?):\s*(.+)$/)
+    if (!match) continue
+    const key = match[1].trim().toLowerCase()
+    const value = match[2].trim()
+    if (key === 'name') result.name = value
+    else if (key === 'creature' || key === 'species' || key === 'type') result.creature = value
+    else if (key === 'vibe' || key === 'personality') result.vibe = value
+    else if (key === 'emoji' || key === 'icon') result.emoji = value
+  }
+  return result
+}
+
+export function serializeIdentityMd(draft: PersonalityDraft['identity']): string {
+  const lines: string[] = ['# Identity', '']
+  if (draft.name) lines.push(`- Name: ${draft.name}`)
+  if (draft.creature) lines.push(`- Creature: ${draft.creature}`)
+  if (draft.vibe) lines.push(`- Vibe: ${draft.vibe}`)
+  if (draft.emoji) lines.push(`- Emoji: ${draft.emoji}`)
+  return lines.join('\n') + '\n'
+}
+
+// --- USER.md ---
+
+export function parseUserMd(content: string): PersonalityDraft['user'] {
+  const result: PersonalityDraft['user'] = {}
+  const contextIdx = content.indexOf('## Context')
+  const headerPart = contextIdx >= 0 ? content.slice(0, contextIdx) : content
+  const contextPart = contextIdx >= 0 ? content.slice(contextIdx + '## Context'.length).trim() : ''
+
+  const lines = headerPart.split('\n')
+  for (const line of lines) {
+    const match = line.match(/^\s*-\s*(.+?):\s*(.+)$/)
+    if (!match) continue
+    const key = match[1].trim().toLowerCase()
+    const value = match[2].trim()
+    if (key === 'name') result.name = value
+    else if (key === 'call them' || key === 'nickname') result.callThem = value
+    else if (key === 'pronouns') result.pronouns = value
+    else if (key === 'timezone') result.timezone = value
+    else if (key === 'notes') result.notes = value
+  }
+
+  if (contextPart) result.context = contextPart
+
+  return result
+}
+
+export function serializeUserMd(draft: PersonalityDraft['user']): string {
+  const lines: string[] = ['# User', '']
+  if (draft.name) lines.push(`- Name: ${draft.name}`)
+  if (draft.callThem) lines.push(`- Call them: ${draft.callThem}`)
+  if (draft.pronouns) lines.push(`- Pronouns: ${draft.pronouns}`)
+  if (draft.timezone) lines.push(`- Timezone: ${draft.timezone}`)
+  if (draft.notes) lines.push(`- Notes: ${draft.notes}`)
+  if (draft.context) {
+    lines.push('', '## Context', '', draft.context)
+  }
+  return lines.join('\n') + '\n'
+}
+
+// --- SOUL.md ---
+
+export function parseSoulMd(content: string): PersonalityDraft['soul'] {
+  const result: PersonalityDraft['soul'] = {}
+  const sections = content.split(/^##\s+/m)
+
+  for (const section of sections) {
+    const nlIdx = section.indexOf('\n')
+    if (nlIdx < 0) continue
+    const heading = section.slice(0, nlIdx).trim().toLowerCase()
+    const body = section.slice(nlIdx + 1).trim()
+
+    if (heading.startsWith('core truth')) result.coreTruths = body
+    else if (heading.startsWith('boundar')) result.boundaries = body
+    else if (heading.startsWith('vibe')) result.vibe = body
+    else if (heading.startsWith('continuity')) result.continuity = body
+  }
+
+  return result
+}
+
+export function serializeSoulMd(draft: PersonalityDraft['soul']): string {
+  const lines: string[] = ['# Soul', '']
+  if (draft.coreTruths) lines.push('## Core Truths', '', draft.coreTruths, '')
+  if (draft.boundaries) lines.push('## Boundaries', '', draft.boundaries, '')
+  if (draft.vibe) lines.push('## Vibe', '', draft.vibe, '')
+  if (draft.continuity) lines.push('## Continuity', '', draft.continuity, '')
+  return lines.join('\n')
+}

package/src/lib/providers/openclaw.ts

@@ -65,6 +65,7 @@ function tryLoadIdentityFile(filePath: string): DeviceIdentity | null {
 function loadOrCreateDeviceIdentity(): DeviceIdentity {
   // 0. Check shared device token for cross-synced identity
   try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
     const { getSharedDeviceToken } = require('../server/openclaw-sync')
     const sharedToken = getSharedDeviceToken()
     if (sharedToken) {
@@ -344,8 +345,22 @@ export function streamOpenClawChat({ session, message, imagePath, apiKey, write,
             for (const p of payloads) {
               const text = typeof p.text === 'string' ? p.text.trimEnd() : ''
               if (text) {
-                fullResponse += text
-                write(`data: ${JSON.stringify({ t: 'd', text })}\n\n`)
+                // Detect [[trace]], [[tool]], [[tool-result]], [[meta]] prefixes
+                const traceMatch = text.match(/^\[\[(thinking|tool|tool-result|trace|meta)\]\]/)
+                if (traceMatch) {
+                  const traceType = traceMatch[1]
+                  const traceContent = text.slice(traceMatch[0].length)
+                  if (traceType === 'meta') {
+                    write(`data: ${JSON.stringify({ t: 'md', text: traceContent })}\n\n`)
+                  } else {
+                    // Include as text (client-side will parse trace markers)
+                    fullResponse += text
+                    write(`data: ${JSON.stringify({ t: 'd', text })}\n\n`)
+                  }
+                } else {
+                  fullResponse += text
+                  write(`data: ${JSON.stringify({ t: 'd', text })}\n\n`)
+                }
               }
             }
             if (!fullResponse && msg.payload?.summary) {

package/src/lib/runtime-loop.ts

@@ -11,5 +11,5 @@ export const DEFAULT_ONGOING_LOOP_MAX_RUNTIME_MINUTES = 60
 
 // Tool/process timeouts
 export const DEFAULT_SHELL_COMMAND_TIMEOUT_SEC = 30
-export const DEFAULT_CLAUDE_CODE_TIMEOUT_SEC = 120
-export const DEFAULT_CLI_PROCESS_TIMEOUT_SEC = 300
+export const DEFAULT_CLAUDE_CODE_TIMEOUT_SEC = 1800
+export const DEFAULT_CLI_PROCESS_TIMEOUT_SEC = 1800

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

@@ -343,13 +343,27 @@ function resolveApiKeyForSession(session: SessionWithCredentials, provider: Prov
 
 function classifyHeartbeatResponse(text: string, ackMaxChars: number): 'suppress' | 'strip' | 'keep' {
   const trimmed = text.trim()
-  if (trimmed === 'HEARTBEAT_OK') return 'suppress'
-  const stripped = trimmed.replace(/HEARTBEAT_OK/gi, '').trim()
+  if (trimmed === 'HEARTBEAT_OK' || trimmed === 'NO_MESSAGE') return 'suppress'
+  const stripped = trimmed.replace(/HEARTBEAT_OK/gi, '').replace(/NO_MESSAGE/gi, '').trim()
   if (!stripped) return 'suppress'
   if (stripped.length <= ackMaxChars) return 'suppress'
   return stripped.length < trimmed.length ? 'strip' : 'keep'
 }
 
+function estimateConversationTone(text: string): string {
+  const t = text || ''
+  // Technical: code blocks, function signatures, technical terms
+  if (/```/.test(t) || /\b(function|const|let|var|import|export|class|interface|async|await|return)\b/.test(t)) return 'technical'
+  if (/\b(error|bug|debug|stack trace|exception|null|undefined|TypeError)\b/i.test(t)) return 'technical'
+  // Empathetic: emotional/supportive language
+  if (/\b(understand|feel|sorry|empathize|appreciate|grateful|tough|difficult|challenging)\b/i.test(t)) return 'empathetic'
+  // Formal: academic/business language
+  if (/\b(furthermore|regarding|consequently|therefore|henceforth|pursuant|accordingly|notwithstanding)\b/i.test(t)) return 'formal'
+  // Casual: contractions, exclamations, informal language
+  if (/\b(gonna|wanna|gotta|yeah|hey|awesome|cool|lol|btw|tbh)\b/i.test(t) || /!{2,}/.test(t)) return 'casual'
+  return 'neutral'
+}
+
 const AUTO_MEMORY_MIN_INTERVAL_MS = 45 * 60 * 1000
 
 function normalizeMemoryText(value: string): string {
@@ -816,6 +830,26 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
   const finalText = (fullResponse || '').trim() || (!internal && errorMessage ? `Error: ${errorMessage}` : '')
   const textForPersistence = stripMainLoopMetaForPersistence(finalText, internal)
 
+  // Emit status SSE event from [MAIN_LOOP_META] if present
+  if (internal && finalText) {
+    const metaMatch = finalText.match(/\[MAIN_LOOP_META\]\s*(\{[^\n]*\})/i)
+    if (metaMatch) {
+      try {
+        const meta = JSON.parse(metaMatch[1])
+        const statusPayload: Record<string, string | undefined> = {}
+        if (meta.goal) statusPayload.goal = String(meta.goal)
+        if (meta.status) statusPayload.status = String(meta.status)
+        if (meta.summary) statusPayload.summary = String(meta.summary)
+        if (meta.next_action) statusPayload.nextAction = String(meta.next_action)
+        if (Object.keys(statusPayload).length > 0) {
+          emit({ t: 'status', text: JSON.stringify(statusPayload) })
+        }
+      } catch {
+        // ignore malformed meta JSON
+      }
+    }
+  }
+
   // HEARTBEAT_OK suppression
   const heartbeatConfig = input.heartbeatConfig
   let heartbeatClassification: 'suppress' | 'strip' | 'keep' | null = null
@@ -875,6 +909,14 @@ export async function executeSessionChatTurn(input: ExecuteChatTurnInput): Promi
       })
       changed = true
 
+      // Conversation tone detection
+      if (!internal) {
+        const tone = estimateConversationTone(persistedText)
+        if (tone !== current.conversationTone) {
+          current.conversationTone = tone
+        }
+      }
+
       // Target routing for non-suppressed heartbeat alerts
       if (isHeartbeatRun && heartbeatConfig?.target && heartbeatConfig.target !== 'none' && heartbeatConfig.showAlerts !== false) {
         try {

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

@@ -1,6 +1,8 @@
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
 import bluebubbles from './bluebubbles.ts'
+import type { Connector } from '@/types'
+import type { InboundMessage } from './types'
 
 type FetchCall = {
   url: string
@@ -10,7 +12,7 @@ type FetchCall = {
 type MockResponse = {
   ok: boolean
   status: number
-  json: () => Promise<any>
+  json: () => Promise<unknown>
   text: () => Promise<string>
 }
 
@@ -37,6 +39,7 @@ function textResponse(status: number, text: string): MockResponse {
 const originalFetch = globalThis.fetch
 
 test.afterEach(() => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   ;(globalThis as any).fetch = originalFetch
 })
 
@@ -47,14 +50,15 @@ test('bluebubbles connector processes inbound webhook payloads and sends replies
     jsonResponse(200, { data: { guid: 'msg-1' } }), // send reply
   ]
 
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   ;(globalThis as any).fetch = async (url: string, init?: RequestInit) => {
     calls.push({ url: String(url), init })
     const next = queue.shift()
     assert.ok(next, 'unexpected fetch call')
-    return next as any
+    return next
   }
 
-  const received: any[] = []
+  const received: InboundMessage[] = []
   const connector = {
     id: 'bb-1',
     name: 'BlueBubbles Test',
@@ -68,7 +72,7 @@ test('bluebubbles connector processes inbound webhook payloads and sends replies
     status: 'running',
     createdAt: Date.now(),
     updatedAt: Date.now(),
-  } as any
+  } as unknown as Connector
 
   const instance = await bluebubbles.start(connector, 'pw-test', async (msg) => {
     received.push(msg)
@@ -76,8 +80,10 @@ test('bluebubbles connector processes inbound webhook payloads and sends replies
   })
 
   try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const handler = (globalThis as any).__swarmclaw_bluebubbles_handler_bb_1__
     assert.equal(typeof handler, 'undefined', 'sanity: wrong handler key should be undefined')
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const validHandler = (globalThis as any)[`__swarmclaw_bluebubbles_handler_${connector.id}__`]
     assert.equal(typeof validHandler, 'function')
 
@@ -116,11 +122,12 @@ test('bluebubbles connector supports array-wrapped webhook payload and NO_MESSAG
     jsonResponse(200, { ok: true }), // ping
   ]
 
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   ;(globalThis as any).fetch = async (url: string, init?: RequestInit) => {
     calls.push({ url: String(url), init })
     const next = queue.shift()
     assert.ok(next, 'unexpected fetch call')
-    return next as any
+    return next
   }
 
   const connector = {
@@ -136,11 +143,12 @@ test('bluebubbles connector supports array-wrapped webhook payload and NO_MESSAG
     status: 'running',
     createdAt: Date.now(),
     updatedAt: Date.now(),
-  } as any
+  } as unknown as Connector
 
   const instance = await bluebubbles.start(connector, 'pw-test', async () => 'NO_MESSAGE')
 
   try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const handler = (globalThis as any)[`__swarmclaw_bluebubbles_handler_${connector.id}__`]
     assert.equal(typeof handler, 'function')
 
@@ -171,11 +179,12 @@ test('bluebubbles sendMessage posts to message/text endpoint', async () => {
     textResponse(200, ''), // send
   ]
 
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   ;(globalThis as any).fetch = async (url: string, init?: RequestInit) => {
     calls.push({ url: String(url), init })
     const next = queue.shift()
     assert.ok(next, 'unexpected fetch call')
-    return next as any
+    return next
   }
 
   const connector = {
@@ -191,7 +200,7 @@ test('bluebubbles sendMessage posts to message/text endpoint', async () => {
     status: 'running',
     createdAt: Date.now(),
     updatedAt: Date.now(),
-  } as any
+  } as unknown as Connector
 
   const instance = await bluebubbles.start(connector, 'pw-test', async () => 'ok')
 

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

@@ -274,6 +274,7 @@ const bluebubbles: PlatformConnector = {
     }
 
     const handlerKey = `__swarmclaw_bluebubbles_handler_${connector.id}__`
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ;(globalThis as any)[handlerKey] = processWebhookEvent
 
     const pingUrl = resolveRequestUrl(serverUrl, '/api/v1/ping', password)
@@ -299,6 +300,7 @@ const bluebubbles: PlatformConnector = {
       },
       async stop() {
         stopped = true
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         delete (globalThis as any)[handlerKey]
         console.log(`[bluebubbles] Connector stopped`)
       },
@@ -341,8 +343,9 @@ async function sendBlueBubblesText(params: {
   }
 
   try {
-    const body = await res.json() as any
-    const id = body?.data?.guid || body?.guid || body?.data?.id || body?.id
+    const body = await res.json() as Record<string, unknown>
+    const data = body?.data && typeof body.data === 'object' ? body.data as Record<string, unknown> : null
+    const id = data?.guid || body?.guid || data?.id || body?.id
     return { messageId: typeof id === 'string' ? id : undefined }
   } catch (err) {
     // BlueBubbles may return empty body on success in some setups.

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

@@ -7,7 +7,7 @@ const googlechat: PlatformConnector = {
     const { google } = await import(/* webpackIgnore: true */ pkg)
 
     // Parse service account credentials from botToken
-    let credentials: any
+    let credentials: Record<string, unknown>
     try {
       credentials = JSON.parse(botToken)
     } catch {
@@ -41,28 +41,30 @@ const googlechat: PlatformConnector = {
       return txt.replace(/<users\/[^>]+>/g, '').trim()
     }
 
-    async function processWebhookEvent(event: any): Promise<Record<string, unknown>> {
+    async function processWebhookEvent(event: Record<string, unknown>): Promise<Record<string, unknown>> {
       if (stopped) throw new Error('Connector is stopped')
 
-      const msg = event?.message
+      const msg = event?.message as Record<string, unknown> | undefined
       if (!msg) return {}
 
-      const spaceName: string = msg?.space?.name || event?.space?.name || ''
+      const msgSpace = msg?.space as Record<string, unknown> | undefined
+      const eventSpace = event?.space as Record<string, unknown> | undefined
+      const spaceName: string = (msgSpace?.name as string) || (eventSpace?.name as string) || ''
       if (allowedSpaces && !allowedSpaces.some((s) => spaceName.includes(s))) {
         return {}
       }
 
-      const rawText = msg?.argumentText || msg?.text || ''
+      const rawText = (msg?.argumentText as string) || (msg?.text as string) || ''
       const text = cleanInboundText(rawText)
       if (!text) return {}
 
-      const sender = msg?.sender || event?.user || {}
-      const senderName = sender?.displayName || sender?.name || 'Google Chat User'
-      const senderId = sender?.name || ''
+      const sender = (msg?.sender || event?.user || {}) as Record<string, unknown>
+      const senderName = (sender?.displayName as string) || (sender?.name as string) || 'Google Chat User'
+      const senderId = (sender?.name as string) || ''
       const inbound: InboundMessage = {
         platform: 'googlechat',
-        channelId: spaceName || (msg?.thread?.name || 'space:unknown'),
-        channelName: msg?.space?.displayName || spaceName || 'Google Chat',
+        channelId: spaceName || ((msg?.thread as Record<string, unknown>)?.name as string) || 'space:unknown',
+        channelName: (msgSpace?.displayName as string) || spaceName || 'Google Chat',
         senderId,
         senderName,
         text,
@@ -73,6 +75,7 @@ const googlechat: PlatformConnector = {
       return { text: response }
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ;(globalThis as any)[handlerKey] = processWebhookEvent
 
     return {
@@ -95,6 +98,7 @@ const googlechat: PlatformConnector = {
       },
       async stop() {
         stopped = true
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         delete (globalThis as any)[handlerKey]
         console.log(`[googlechat] Bot disconnected`)
       },

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

@@ -33,18 +33,25 @@ export function isNoMessage(text: string): boolean {
  *  Stored on globalThis to survive HMR reloads in dev mode —
  *  prevents duplicate sockets fighting for the same WhatsApp session. */
 const globalKey = '__swarmclaw_running_connectors__' as const
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const g = globalThis as any
 const running: Map<string, ConnectorInstance> =
-  (globalThis as any)[globalKey] ?? ((globalThis as any)[globalKey] = new Map<string, ConnectorInstance>())
+  g[globalKey] ?? (g[globalKey] = new Map<string, ConnectorInstance>())
 
 /** Most recent inbound channel per connector (used for proactive replies/default outbound target) */
 const lastInboundKey = '__swarmclaw_connector_last_inbound__' as const
 const lastInboundChannelByConnector: Map<string, string> =
-  (globalThis as any)[lastInboundKey] ?? ((globalThis as any)[lastInboundKey] = new Map<string, string>())
+  g[lastInboundKey] ?? (g[lastInboundKey] = new Map<string, string>())
+
+/** Last inbound message timestamp per connector (for presence indicators) */
+const lastInboundTimeKey = '__swarmclaw_connector_last_inbound_time__' as const
+const lastInboundTimeByConnector: Map<string, number> =
+  g[lastInboundTimeKey] ?? (g[lastInboundTimeKey] = new Map<string, number>())
 
 /** Per-connector lock to prevent concurrent start/stop operations */
 const lockKey = '__swarmclaw_connector_locks__' as const
 const locks: Map<string, Promise<void>> =
-  (globalThis as any)[lockKey] ?? ((globalThis as any)[lockKey] = new Map<string, Promise<void>>())
+  g[lockKey] ?? (g[lockKey] = new Map<string, Promise<void>>())
 
 /** Get platform implementation lazily */
 export async function getPlatform(platform: string) {
@@ -117,14 +124,16 @@ function parseConnectorCommand(text: string): ParsedConnectorCommand | null {
   }
 }
 
-function pushSessionMessage(session: any, role: 'user' | 'assistant', text: string): void {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function pushSessionMessage(session: Record<string, any>, role: 'user' | 'assistant', text: string): void {
   if (!text.trim()) return
   if (!Array.isArray(session.messages)) session.messages = []
   session.messages.push({ role, text: text.trim(), time: Date.now() })
   session.lastActiveAt = Date.now()
 }
 
-function persistSession(session: any): void {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function persistSession(session: Record<string, any>): void {
   const sessions = loadSessions()
   sessions[session.id] = session
   saveSessions(sessions)
@@ -278,7 +287,8 @@ function enforceInboundAccessPolicy(connector: Connector, msg: InboundMessage):
 async function handleConnectorCommand(params: {
   command: ParsedConnectorCommand
   connector: Connector
-  session: any
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  session: Record<string, any>
   msg: InboundMessage
   agentName: string
 }): Promise<string> {
@@ -303,8 +313,8 @@ async function handleConnectorCommand(params: {
 
   if (command.name === 'status') {
     const all = Array.isArray(session.messages) ? session.messages : []
-    const userCount = all.filter((m: any) => m?.role === 'user').length
-    const assistantCount = all.filter((m: any) => m?.role === 'assistant').length
+    const userCount = all.filter((m: { role?: string }) => m?.role === 'user').length
+    const assistantCount = all.filter((m: { role?: string }) => m?.role === 'assistant').length
     const toolsCount = Array.isArray(session.tools) ? session.tools.length : 0
     const statusText = [
       `Status for ${connector.platform} / ${connector.name}:`,
@@ -399,6 +409,7 @@ async function routeMessage(connector: Connector, msg: InboundMessage): Promise<
   if (msg?.channelId) {
     lastInboundChannelByConnector.set(connector.id, msg.channelId)
   }
+  lastInboundTimeByConnector.set(connector.id, Date.now())
 
   const agents = loadAgents()
   const effectiveAgentId = msg.agentIdOverride || connector.agentId
@@ -408,6 +419,7 @@ async function routeMessage(connector: Connector, msg: InboundMessage): Promise<
   // Log connector trigger
   const triggerSessionKey = `connector:${connector.id}:${msg.channelId}`
   const allSessions = loadSessions()
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const existingSession = Object.values(allSessions).find((s: any) => s.name === triggerSessionKey)
   if (existingSession) {
     logExecution(existingSession.id, 'trigger', `${msg.platform} message from ${msg.senderName}`, {
@@ -437,6 +449,7 @@ async function routeMessage(connector: Connector, msg: InboundMessage): Promise<
   // Find or create a session keyed by platform + channel
   const sessionKey = `connector:${connector.id}:${msg.channelId}`
   const sessions = loadSessions()
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   let session = Object.values(sessions).find((s: any) => s.name === sessionKey)
   if (!session) {
     const id = genId()
@@ -586,9 +599,10 @@ The test: would a thoughtful friend feel compelled to type something back? If no
       // Use finalResponse for connectors — strips intermediate planning/tool-use text
       fullText = result.finalResponse
       console.log(`[connector] streamAgentChat returned ${result.fullText.length} chars total, ${fullText.length} chars final`)
-    } catch (err: any) {
-      console.error(`[connector] streamAgentChat error:`, err.message || err)
-      return `[Error] ${err.message}`
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err)
+      console.error(`[connector] streamAgentChat error:`, message)
+      return `[Error] ${message}`
     }
   } else {
     // Use the provider directly
@@ -726,10 +740,10 @@ async function _startConnectorImpl(connectorId: string): Promise<void> {
     notify('connectors')
 
     console.log(`[connector] Started ${connector.platform} connector: ${connector.name}`)
-  } catch (err: any) {
+  } catch (err: unknown) {
     connector.status = 'error'
     connector.isEnabled = false
-    connector.lastError = err.message
+    connector.lastError = err instanceof Error ? err.message : String(err)
     connector.updatedAt = Date.now()
     connectors[connectorId] = connector
     saveConnectors(connectors)
@@ -818,8 +832,8 @@ export async function autoStartConnectors(): Promise<void> {
       try {
         console.log(`[connector] Auto-starting ${connector.platform} connector: ${connector.name}`)
         await startConnector(connector.id)
-      } catch (err: any) {
-        console.error(`[connector] Failed to auto-start ${connector.name}:`, err.message)
+      } catch (err: unknown) {
+        console.error(`[connector] Failed to auto-start ${connector.name}:`, err instanceof Error ? err.message : err)
       }
     }
   }
@@ -878,6 +892,14 @@ export function getConnectorRecentChannelId(connectorId: string): string | null
   return lastInboundChannelByConnector.get(connectorId) || null
 }
 
+/** Get presence info for a connector */
+export function getConnectorPresence(connectorId: string): { lastMessageAt: number | null; channelId: string | null } {
+  return {
+    lastMessageAt: lastInboundTimeByConnector.get(connectorId) ?? null,
+    channelId: lastInboundChannelByConnector.get(connectorId) ?? null,
+  }
+}
+
 /** Get a running connector instance (internal use for rich messaging). */
 export function getRunningInstance(connectorId: string): ConnectorInstance | undefined {
   return running.get(connectorId)

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

@@ -830,6 +830,7 @@ const openclaw: PlatformConnector = {
       // Cross-sync device token for provider identity resolution
       if (normalized) {
         try {
+          // eslint-disable-next-line @typescript-eslint/no-require-imports
           const { setSharedDeviceToken } = require('../openclaw-sync')
           setSharedDeviceToken(normalized)
         } catch { /* openclaw-sync not available */ }

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

@@ -12,6 +12,7 @@ import {
   getConnectorStatus,
 } from './connectors/manager'
 import { startHeartbeatService, stopHeartbeatService, getHeartbeatServiceStatus } from './heartbeat-service'
+import { hasOpenClawAgents, ensureGatewayConnected, disconnectGateway, getGateway } from './openclaw-gateway'
 
 const QUEUE_CHECK_INTERVAL = 30_000 // 30 seconds
 const BROWSER_SWEEP_INTERVAL = 60_000 // 60 seconds
@@ -179,6 +180,16 @@ function startQueueProcessor() {
       await processNext()
       ds.lastProcessedAt = Date.now()
     }
+    // OpenClaw gateway lifecycle: lazy connect when openclaw agents exist, disconnect when none remain
+    try {
+      if (hasOpenClawAgents()) {
+        if (!getGateway()?.connected) {
+          await ensureGatewayConnected()
+        }
+      } else if (getGateway()?.connected) {
+        disconnectGateway()
+      }
+    } catch { /* gateway errors are non-fatal */ }
   }, QUEUE_CHECK_INTERVAL)
 }
 

package/src/lib/server/main-agent-loop.ts

@@ -4,14 +4,13 @@ import type { GoalContract, MessageToolEvent } from '@/types'
 import { loadSessions, saveSessions, loadAgents, saveAgents, loadTasks, saveTasks } from './storage'
 import { log } from './logger'
 import { getMemoryDb } from './memory-db'
+import { isProtectedMainSession } from './main-session'
 import {
   mergeGoalContracts,
   parseGoalContractFromText,
   parseMainLoopPlan,
   parseMainLoopReview,
 } from './autonomy-contract'
-
-const MAIN_SESSION_NAME = '__main__'
 const MAX_PENDING_EVENTS = 40
 const MAX_TIMELINE_EVENTS = 80
 const EVENT_TTL_MS = 7 * 24 * 60 * 60 * 1000
@@ -669,7 +668,7 @@ function buildFollowupPrompt(state: MainLoopState, opts?: { hasMemoryTool?: bool
 }
 
 export function isMainSession(session: any): boolean {
-  return session?.name === MAIN_SESSION_NAME
+  return isProtectedMainSession(session)
 }
 
 export function buildMainLoopHeartbeatPrompt(session: any, fallbackPrompt: string): string {

package/src/lib/server/main-session.ts

@@ -0,0 +1,21 @@
+const MAIN_SESSION_NAME = '__main__'
+
+export function isProtectedMainSession(session: any): boolean {
+  if (!session || typeof session !== 'object') return false
+  if (session.mainSession === true) return true
+
+  const name = typeof session.name === 'string' ? session.name.trim() : ''
+  if (name === MAIN_SESSION_NAME) return true
+
+  const id = typeof session.id === 'string' ? session.id.trim() : ''
+  if (id.startsWith('main-')) return true
+
+  return false
+}
+
+export function ensureMainSessionFlag(session: any): void {
+  if (!session || typeof session !== 'object') return
+  if (isProtectedMainSession(session)) {
+    session.mainSession = true
+  }
+}