@swarmclawai/swarmclaw 1.2.6 → 1.2.8

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

@@ -31,6 +31,7 @@ export const MessageClassificationSchema = z.object({
   taskIntent: TaskIntentSchema,
   isDeliverableTask: z.boolean(),
   isBroadGoal: z.boolean(),
+  isLightweightDirectChat: z.boolean().optional().default(false),
   walletIntent: z.enum(['none', 'read_only', 'transactional']),
   hasHumanSignals: z.boolean(),
   hasSignificantEvent: z.boolean(),
@@ -47,6 +48,7 @@ export interface MessageClassification {
   taskIntent: MessageTaskIntent
   isDeliverableTask: boolean
   isBroadGoal: boolean
+  isLightweightDirectChat?: boolean
   walletIntent: 'none' | 'read_only' | 'transactional'
   hasHumanSignals: boolean
   hasSignificantEvent: boolean
@@ -102,6 +104,7 @@ function buildClassificationPrompt(message: string, recentHistory: string): stri
     '- taskIntent: The primary execution intent. Use exactly one of: "coding", "research", "browsing", "outreach", "scheduling", or "general". Choose "coding" for repo/code/build/debug/edit tasks. Choose "research" for gathering current info or synthesizing sources. Choose "browsing" for page navigation, rendered-page inspection, form work, or literal browser workflows. Choose "outreach" for sending/sharing/delivering updates to an external channel. Choose "scheduling" for reminders, recurring work, monitoring, or follow-up scheduling. Choose "general" when none of the above clearly fits.',
     '- isDeliverableTask (bool): The user wants a concrete artifact produced — a document, report, plan, proposal, landing page, dashboard, HTML file, markdown file, brief, copy, screenshots, or similar deliverable. NOT simple Q&A, code fixes, or single-command tasks.',
     '- isBroadGoal (bool): The message describes a broad, multi-step goal (50+ chars, no code blocks, no file paths, no numbered lists). Short questions ending with "?" are NOT broad goals.',
+    '- isLightweightDirectChat (bool): This is a low-signal direct chat turn that should get a natural lightweight reply, such as a greeting, acknowledgment, check-in, or simple social/direct question that does NOT require research, file work, planning, delegation, or tool execution.',
     '- walletIntent: "none" if no crypto/wallet/trading context. "read_only" if mentioning wallet/crypto but only for checking balances, viewing transactions, or research. "transactional" if the user wants to swap, trade, buy, sell, mint, claim, deposit, withdraw, bridge, or execute a transaction.',
     '- hasHumanSignals (bool): The message contains personal signals — preferences ("I prefer", "call me"), relationships ("my wife", "my partner", "my kid"), life events ("birthday", "wedding", "promotion", "moving", "graduation", "hospital"), or personal disclosures.',
     '- hasSignificantEvent (bool): The message mentions a notable life/work event or milestone (birthday, anniversary, wedding, graduation, promotion, new job, relocation, illness, funeral, travel, house, deadline, launch).',
@@ -115,13 +118,14 @@ function buildClassificationPrompt(message: string, recentHistory: string): stri
     '',
     'Rules:',
     '- Be conservative. When unsure, default to false/none/empty.',
+    '- Mark isLightweightDirectChat true only when a short natural reply is enough and escalating into planning, delegation, or tool execution would be unnecessary.',
     '- A message can be both a deliverable task AND a broad goal.',
     '- "walletIntent" should be "transactional" only if the user wants to execute a state-changing action, not just discuss crypto.',
     '- For "explicitToolRequests", only include tools the user explicitly mentions by name or clear synonym. Do not infer tool needs from the task type.',
     '- Prefer the most execution-relevant taskIntent. Example: "research this and send me a voice note" is "research", not "outreach".',
     '',
     'Output shape:',
-    '{"taskIntent":"coding|research|browsing|outreach|scheduling|general","isDeliverableTask":bool,"isBroadGoal":bool,"walletIntent":"none|read_only|transactional","hasHumanSignals":bool,"hasSignificantEvent":bool,"isResearchSynthesis":bool,"workType":"coding|research|writing|review|operations|general","wantsScreenshots":bool,"wantsOutboundDelivery":bool,"wantsVoiceDelivery":bool,"explicitToolRequests":[],"confidence":0.0-1.0}',
+    '{"taskIntent":"coding|research|browsing|outreach|scheduling|general","isDeliverableTask":bool,"isBroadGoal":bool,"isLightweightDirectChat":bool,"walletIntent":"none|read_only|transactional","hasHumanSignals":bool,"hasSignificantEvent":bool,"isResearchSynthesis":bool,"workType":"coding|research|writing|review|operations|general","wantsScreenshots":bool,"wantsOutboundDelivery":bool,"wantsVoiceDelivery":bool,"explicitToolRequests":[],"confidence":0.0-1.0}',
     '',
     recentHistory ? `Recent context:\n${recentHistory}\n` : '',
     `User message: ${JSON.stringify(message)}`,
@@ -276,6 +280,7 @@ export function toMessageSemanticsSummary(classification: MessageClassification
     isDeliverableTask: classification.isDeliverableTask,
     isBroadGoal: classification.isBroadGoal,
     isResearchSynthesis: classification.isResearchSynthesis,
+    isLightweightDirectChat: classification.isLightweightDirectChat === true,
     hasHumanSignals: classification.hasHumanSignals,
     hasSignificantEvent: classification.hasSignificantEvent,
     wantsScreenshots: classification.wantsScreenshots === true,
@@ -324,3 +329,8 @@ export function isResearchSynthesis(classification: MessageClassification | null
   void routingIntent
   return classification?.isResearchSynthesis === true
 }
+
+export function isLightweightDirectChat(classification: MessageClassification | null, message?: string): boolean {
+  void message
+  return classification?.isLightweightDirectChat === true
+}

package/src/lib/server/chat-execution/prompt-builder.test.ts

@@ -26,4 +26,32 @@ describe('buildAgenticExecutionPolicy', () => {
     assert.ok(prompt.includes('use the concrete tool now'))
     assert.ok(prompt.includes('prefer the direct `manage_*` tool'))
   })
+
+  it('adds lightweight direct-chat guidance when classification marks the turn as lightweight', () => {
+    const prompt = buildAgenticExecutionPolicy({
+      enabledExtensions: ['memory', 'files', 'delegate'],
+      loopMode: 'bounded',
+      heartbeatPrompt: 'HEARTBEAT',
+      heartbeatIntervalSec: 120,
+      userMessage: 'Hello',
+      history: [],
+      classification: {
+        taskIntent: 'general',
+        isDeliverableTask: false,
+        isBroadGoal: false,
+        isLightweightDirectChat: true,
+        walletIntent: 'none',
+        hasHumanSignals: false,
+        hasSignificantEvent: false,
+        isResearchSynthesis: false,
+        workType: 'general',
+        explicitToolRequests: [],
+        confidence: 0.98,
+      },
+    })
+
+    assert.ok(prompt.includes('## Lightweight Chat'))
+    assert.ok(prompt.includes('Reply naturally and briefly.'))
+    assert.ok(prompt.includes('prefer 1-3 short sentences'))
+  })
 })

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

@@ -75,7 +75,6 @@ function buildExtensionCapabilityLines(enabledExtensions: string[], opts?: { del
 
 const DISPLAY_TOOL_ALIASES: Record<string, string[]> = {
   files: ['send_file'],
-  shell: ['sandbox_exec', 'sandbox_list_runtimes'],
 }
 
 function buildExactToolNameList(enabledExtensions: string[]): string[] {
@@ -158,6 +157,7 @@ export function buildToolDisciplineLines(enabledExtensions: string[]): string[]
     ...(researchSearchTools.length || researchFetchTools.length ? [...researchSearchTools, ...researchFetchTools] : []),
     ...httpTools,
     ...(uniqueTools.includes('shell') ? ['shell'] : []),
+    ...(uniqueTools.includes('execute') ? ['execute'] : []),
     ...(uniqueTools.includes('browser') ? ['browser'] : []),
   ]))
   if (alternateResearchTools.length >= 2) {
@@ -330,6 +330,7 @@ export function buildAgenticExecutionPolicy(opts: {
   const hasManageSessions = opts.enabledExtensions.some((toolId) => (canonicalizeExtensionId(toolId) || toolId) === 'manage_sessions')
   const hasManageTasks = opts.enabledExtensions.some((toolId) => (canonicalizeExtensionId(toolId) || toolId) === 'manage_tasks')
   const hasManageSkills = opts.enabledExtensions.some((toolId) => (canonicalizeExtensionId(toolId) || toolId) === 'manage_skills')
+  const lightweightDirectChat = opts.classification?.isLightweightDirectChat === true && !opts.isDirectConnectorSession
   const hasDelegationTools = opts.enabledExtensions.some((toolId) => {
     const canonical = canonicalizeExtensionId(toolId) || toolId
     return canonical === 'delegate' || canonical === 'spawn_subagent'
@@ -359,6 +360,15 @@ export function buildAgenticExecutionPolicy(opts: {
       : 'Loop: BOUNDED — execute multiple steps but finish within recursion budget.',
   )
 
+  if (lightweightDirectChat) {
+    parts.push(
+      '## Lightweight Chat',
+      'This turn is a lightweight direct chat. Reply naturally and briefly.',
+      'Do not delegate, create tasks, outline a workflow, or narrate tools unless the user adds a concrete task that actually requires that escalation.',
+      'For greetings, acknowledgements, and simple social questions, a short human-sounding answer is sufficient.',
+    )
+  }
+
   if (hasTooling) {
     parts.push(
       '## Routing Matrix',
@@ -444,6 +454,9 @@ export function buildAgenticExecutionPolicy(opts: {
     ]),
     'Keep responses concise. Bullet points over prose. After file operations, confirm the result briefly (path and status) without echoing the full file contents.',
     'Do not end every reply with a question. Only ask when a specific missing detail blocks progress. When a task is done, state the result and stop.',
+    ...(lightweightDirectChat
+      ? ['For this turn, prefer 1-3 short sentences over bullets, planning, or process narration.']
+      : []),
     opts.responseStyle === 'concise'
       ? `IMPORTANT: Be extremely concise.${opts.responseMaxChars ? ` Keep responses under ${opts.responseMaxChars} characters.` : ' Target under 500 characters.'} Lead with the answer, skip preamble.`
       : opts.responseStyle === 'detailed'

package/src/lib/server/chat-execution/prompt-mode.test.ts

@@ -0,0 +1,24 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { resolvePromptMode } from '@/lib/server/chat-execution/prompt-mode'
+
+describe('resolvePromptMode', () => {
+  it('returns full for root sessions by default', () => {
+    assert.equal(resolvePromptMode({ id: 'root' } as never), 'full')
+  })
+
+  it('prefers minimal mode for lightweight direct-chat turns', () => {
+    assert.equal(
+      resolvePromptMode({ id: 'root' } as never, { preferMinimalPrompt: true }),
+      'minimal',
+    )
+  })
+
+  it('keeps delegated child sessions in minimal mode', () => {
+    assert.equal(
+      resolvePromptMode({ id: 'child', parentSessionId: 'parent' } as never, { preferMinimalPrompt: false }),
+      'minimal',
+    )
+  })
+})

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

@@ -20,7 +20,11 @@ export type PromptMode = 'full' | 'minimal' | 'none'
  *   proactive memory, thinking guidance
  * - `none` — reserved for bare identity (light heartbeat path)
  */
-export function resolvePromptMode(session: Session): PromptMode {
+export function resolvePromptMode(
+  session: Session,
+  options?: { preferMinimalPrompt?: boolean },
+): PromptMode {
   if (session.parentSessionId) return 'minimal'
+  if (options?.preferMinimalPrompt) return 'minimal'
   return 'full'
 }

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

@@ -65,14 +65,13 @@ const streamContinuationSource = _readSibling('stream-continuation.ts')
 const streamSources = `${streamAgentChatSource}\n${streamContinuationSource}`
 
 describe('buildToolDisciplineLines', () => {
-  it('lists exact callable tool names for extension families like sandbox and browser', () => {
+  it('lists exact callable tool names for legacy sandbox aliases and browser', () => {
     const lines = buildToolAvailabilityLines(['sandbox', 'browser', 'manage_schedules'])
 
     assert.equal(lines[0], 'Tool names are case-sensitive. Call tools exactly as listed.')
     assert.ok(lines.includes('- `browser`'))
+    assert.ok(lines.includes('- `execute`'))
     assert.ok(lines.includes('- `manage_schedules`'))
-    assert.ok(lines.includes('- `sandbox_exec`'))
-    assert.ok(lines.includes('- `sandbox_list_runtimes`'))
   })
 
   it('tells the agent to use direct platform tools when manage_platform is absent', () => {
@@ -1033,7 +1032,7 @@ describe('shouldForceDeliverableFollowthrough', () => {
           { name: 'web', input: '{"action":"fetch","url":"https://example.com/topic"}', output: '<html>topic</html>' },
         ],
         history: [
-          { role: 'user', text: 'Research 3 topics, take screenshots, write markdown and PDF files, then build a site for each topic.' },
+          { role: 'user', text: 'Research 3 topics, take screenshots, write markdown and PDF files, then build a site for each topic.', time: Date.now() },
         ],
       }),
       true,
@@ -1275,6 +1274,7 @@ describe('parseClassificationResponse', () => {
 
 describe('message classifier adapter functions', () => {
   const deliverableClassification: MessageClassification = {
+    taskIntent: 'general',
     isDeliverableTask: true,
     isBroadGoal: true,
     walletIntent: 'none',
@@ -1286,6 +1286,7 @@ describe('message classifier adapter functions', () => {
   }
 
   const walletClassification: MessageClassification = {
+    taskIntent: 'general',
     isDeliverableTask: false,
     isBroadGoal: false,
     walletIntent: 'transactional',
@@ -1297,6 +1298,7 @@ describe('message classifier adapter functions', () => {
   }
 
   const humanSignalClassification: MessageClassification = {
+    taskIntent: 'general',
     isDeliverableTask: false,
     isBroadGoal: false,
     walletIntent: 'none',

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

@@ -190,6 +190,7 @@ interface StreamAgentChatOpts {
   fallbackCredentialIds?: string[]
   signal?: AbortSignal
   promptMode?: PromptMode
+  classification?: MessageClassification | null
   /** Run source (e.g. 'heartbeat', 'chat', 'scheduler') — used for heartbeat-specific tuning. */
   source?: string
 }
@@ -223,10 +224,23 @@ 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, executionBrief, extraSystemContext, write, history, fallbackCredentialIds, signal } = opts
+  const {
+    session,
+    message,
+    imagePath,
+    imageUrl,
+    attachedFiles,
+    apiKey,
+    systemPrompt,
+    executionBrief,
+    extraSystemContext,
+    write,
+    history,
+    fallbackCredentialIds,
+    signal,
+    classification: providedClassification,
+  } = opts
   const isHeartbeat = isHeartbeatSource(opts.source)
-  const promptMode: PromptMode = opts.promptMode ?? resolvePromptMode(session)
-  const isMinimalPrompt = promptMode === 'minimal'
   const isConnectorSession = isDirectConnectorSession(session)
   const rawExtensions = getEnabledCapabilityIds(session)
   const hasShellCapability = rawExtensions.some((toolId) => ['shell', 'execute_command'].includes(String(toolId)))
@@ -241,6 +255,23 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
 
   const sessionAgent = session.agentId ? getAgent(session.agentId) : null
 
+  const classificationPromise = providedClassification !== undefined
+    ? Promise.resolve(providedClassification)
+    : classifyMessage({
+        sessionId: session.id,
+        agentId: session.agentId,
+        message,
+        history,
+      }).catch(() => null as MessageClassification | null)
+  const classification = await classificationPromise
+  const lightweightDirectChat = classification?.isLightweightDirectChat === true
+    && !isConnectorSession
+    && !isHeartbeat
+  const promptMode: PromptMode = opts.promptMode ?? resolvePromptMode(session, {
+    preferMinimalPrompt: lightweightDirectChat,
+  })
+  const isMinimalPrompt = promptMode === 'minimal'
+
   // Resolve agent's thinking level for provider-native params
   let agentThinkingLevel: 'minimal' | 'low' | 'medium' | 'high' | undefined
   if (session.thinkingLevel) {
@@ -248,6 +279,9 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   } else if (sessionAgent) {
     agentThinkingLevel = sessionAgent.thinkingLevel
   }
+  if (lightweightDirectChat) {
+    agentThinkingLevel = 'minimal'
+  }
 
   const llm = buildChatModel({
     provider: session.provider,
@@ -296,16 +330,6 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     return Math.max(0, Math.min(3600, Math.trunc(parsed)))
   })()
 
-  // -------------------------------------------------------------------------
-  // Start message classification in the background (LLM-based, ~200-800ms)
-  // -------------------------------------------------------------------------
-  const classificationPromise = classifyMessage({
-    sessionId: session.id,
-    agentId: session.agentId,
-    message,
-    history,
-  }).catch(() => null as MessageClassification | null)
-
   // -------------------------------------------------------------------------
   // System prompt assembly (stays inline — many async calls + local state)
   // -------------------------------------------------------------------------
@@ -426,8 +450,6 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   const suggestionsBlock = buildSuggestionsSection(settings.suggestionsEnabled, isMinimalPrompt)
   if (suggestionsBlock) promptParts.push(suggestionsBlock)
 
-  // Await classification before building the agentic execution policy
-  const classification = await classificationPromise
   const delegationAdvisory = sessionAgent && agentDelegationEnabled
     ? resolveDelegationAdvisory({
         currentAgent: sessionAgent,
@@ -1138,7 +1160,14 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
       }
 
       // Async LLM-based incomplete-action check: catches "I'll run the deployment:" with no tool calls
-      if (!shouldContinue && outcome && !state.hasToolCalls && state.fullText.trim().length > 0 && state.fullText.trim().length < 500) {
+      if (
+        !shouldContinue
+        && outcome
+        && !state.hasToolCalls
+        && classification?.isLightweightDirectChat !== true
+        && state.fullText.trim().length > 0
+        && state.fullText.trim().length < 500
+      ) {
         const completeness = await evaluateResponseCompleteness({
           sessionId: session.id,
           agentId: session.agentId,

package/src/lib/server/chatrooms/chatroom-routing.test.ts

@@ -16,6 +16,8 @@ const agents: Record<string, Agent> = {
     model: 'gpt-test',
     systemPrompt: '',
     capabilities: ['deploy', 'infrastructure'],
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
   },
   design: {
     id: 'design',
@@ -25,6 +27,8 @@ const agents: Record<string, Agent> = {
     model: 'gpt-test',
     systemPrompt: '',
     capabilities: ['design', 'ui'],
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
   },
 }
 

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

@@ -217,8 +217,8 @@ const discord: PlatformConnector = {
             return String(sent.id || '')
           },
         })
-      } catch (err: any) {
-        log.error(TAG, 'Error handling message:', err.message)
+      } catch (err: unknown) {
+        log.error(TAG, 'Error handling message:', errorMessage(err))
         try {
           await message.reply('Sorry, I encountered an error processing your message.')
         } catch { /* ignore */ }

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

@@ -4,6 +4,7 @@ import path from 'path'
 import { DATA_DIR } from '../data-dir'
 import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
 import { resolveConnectorIngressReply } from './ingress-delivery'
+import { errorMessage } from '@/lib/shared-utils'
 
 const TAG = 'matrix'
 
@@ -54,8 +55,8 @@ const matrix: PlatformConnector = {
         const reply = await resolveConnectorIngressReply(onMessage, inbound)
         if (!reply) return
         await client.sendText(roomId, reply.visibleText)
-      } catch (err: any) {
-        log.error(TAG, 'Error handling message:', err.message)
+      } catch (err: unknown) {
+        log.error(TAG, 'Error handling message:', errorMessage(err))
         try {
           await client.sendText(roomId, 'Sorry, I encountered an error processing your message.')
         } catch { /* ignore */ }

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

@@ -4,6 +4,7 @@ import type { ChildProcess } from 'child_process'
 import type { Connector } from '@/types'
 import type { PlatformConnector, ConnectorInstance, InboundMessage, ConnectorIngressResult } from './types'
 import { resolveConnectorIngressReply } from './ingress-delivery'
+import { errorMessage } from '@/lib/shared-utils'
 
 const TAG = 'signal'
 
@@ -107,8 +108,8 @@ const signal: PlatformConnector = {
               `${cliPath} -u ${phoneNumber} send -m ${JSON.stringify(text)} ${channelId}`,
               { timeout: 15_000 },
             )
-          } catch (err: any) {
-            throw new Error(`Signal send failed: ${err.message}`)
+          } catch (err: unknown) {
+            throw new Error(`Signal send failed: ${errorMessage(err)}`)
           }
         }
       },
@@ -179,8 +180,8 @@ export async function handleSignalEvent(
         { timeout: 15_000 },
       )
     }
-  } catch (err: any) {
-    log.error(TAG, 'Error handling message:', err.message)
+  } catch (err: unknown) {
+    log.error(TAG, 'Error handling message:', errorMessage(err))
   }
 }
 

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

@@ -145,11 +145,12 @@ const slack: PlatformConnector = {
       }
       botUserId = auth.user_id as string
       log.info(TAG, `Authenticated as @${auth.user} in workspace "${auth.team}"`)
-    } catch (err: any) {
-      const hint = err.code === 'slack_webapi_platform_error'
+    } catch (err: unknown) {
+      const hint = (err instanceof Error && 'code' in err) ? (err as { code: string }).code : undefined
+      const suffix = hint === 'slack_webapi_platform_error'
         ? '. Check that your Bot Token (xoxb-...) is correct and the app is installed to the workspace.'
         : ''
-      throw new Error(`Slack auth failed: ${err.message}${hint}`)
+      throw new Error(`Slack auth failed: ${errorMessage(err)}${suffix}`)
     }
 
     const app = new App({
@@ -215,8 +216,8 @@ const slack: PlatformConnector = {
                 media.push(stored)
                 continue
               }
-            } catch (err: any) {
-              log.warn(TAG, `Media download failed (${f?.name || 'file'}):`, err?.message || String(err))
+            } catch (err: unknown) {
+              log.warn(TAG, `Media download failed (${f?.name || 'file'}):`, errorMessage(err))
             }
           }
           media.push({
@@ -264,8 +265,8 @@ const slack: PlatformConnector = {
             return sent.ts || undefined
           },
         })
-      } catch (err: any) {
-        log.error(TAG, 'Error handling message:', err.message)
+      } catch (err: unknown) {
+        log.error(TAG, 'Error handling message:', errorMessage(err))
         try {
           await say('Sorry, I encountered an error processing your message.')
         } catch { /* ignore */ }
@@ -322,8 +323,8 @@ const slack: PlatformConnector = {
             return sent.ts || undefined
           },
         })
-      } catch (err: any) {
-        log.error(TAG, 'Error handling mention:', err.message)
+      } catch (err: unknown) {
+        log.error(TAG, 'Error handling mention:', errorMessage(err))
       }
     })
 

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

@@ -1,6 +1,7 @@
 import { log } from '@/lib/server/logger'
 import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
 import { resolveConnectorIngressReply } from './ingress-delivery'
+import { errorMessage } from '@/lib/shared-utils'
 
 const TAG = 'teams'
 
@@ -51,8 +52,8 @@ const teams: PlatformConnector = {
           const reply = await resolveConnectorIngressReply(onMessage, inbound)
           if (!reply) return
           await context.sendActivity(reply.visibleText)
-        } catch (err: any) {
-          log.error(TAG, 'Error handling message:', err.message)
+        } catch (err: unknown) {
+          log.error(TAG, 'Error handling message:', errorMessage(err))
           try {
             await context.sendActivity('Sorry, I encountered an error processing your message.')
           } catch { /* ignore */ }

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

@@ -127,8 +127,8 @@ const telegram: PlatformConnector = {
             mimeType: m.mimeType,
           })
           if (stored) media.push(stored)
-        } catch (err: any) {
-          log.warn(TAG, `Failed to fetch media ${m.fileId}:`, err?.message || String(err))
+        } catch (err: unknown) {
+          log.warn(TAG, `Failed to fetch media ${m.fileId}:`, errorMessage(err))
           media.push({
             type: m.type,
             fileName: m.fileName,
@@ -177,8 +177,8 @@ const telegram: PlatformConnector = {
             return String(sent.message_id)
           },
         })
-      } catch (err: any) {
-        log.error(TAG, 'Error handling message:', err.message)
+      } catch (err: unknown) {
+        log.error(TAG, 'Error handling message:', errorMessage(err))
         try {
           await ctx.reply('Sorry, I encountered an error processing your message.')
         } catch { /* ignore */ }

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

@@ -714,8 +714,8 @@ const whatsapp: PlatformConnector = {
                 fileName: mediaCandidate.payload?.fileName || undefined,
               })
               media.push(saved)
-            } catch (err: any) {
-              log.error(TAG, `Failed to decode media: ${err?.message || String(err)}`)
+            } catch (err: unknown) {
+              log.error(TAG, `Failed to decode media: ${errorMessage(err)}`)
               media.push({
                 type: mediaCandidate.kind,
                 fileName: mediaCandidate.payload?.fileName || undefined,

package/src/lib/server/daemon/controller.ts

@@ -25,6 +25,7 @@ import type {
 } from '@/lib/server/daemon/types'
 import { DATA_DIR } from '@/lib/server/data-dir'
 import { loadEstopState } from '@/lib/server/runtime/estop'
+import { getDaemonStatus } from '@/lib/server/runtime/daemon-state/core'
 import { daemonAutostartEnvEnabled } from '@/lib/server/runtime/daemon-policy'
 import {
   releaseRuntimeLock,
@@ -344,6 +345,12 @@ export async function ensureDaemonProcessRunning(
   source: string,
   opts?: { manualStart?: boolean },
 ): Promise<boolean> {
+  // In dev mode, the daemon may already be running in-process (same Next.js server)
+  // without a daemon-admin.json file. Check in-process state first to avoid spawning
+  // a subprocess that fails to acquire the already-held lease.
+  const inProcessStatus = getDaemonStatus()
+  if (inProcessStatus.running) return false
+
   const manualStart = opts?.manualStart === true
   const record = loadDaemonStatusRecord()
   if (loadEstopState().level !== 'none') return false

package/src/lib/server/gateways/gateway-profile-service.ts

@@ -4,6 +4,7 @@ import { genId } from '@/lib/id'
 import { normalizeOpenClawEndpoint } from '@/lib/openclaw/openclaw-endpoint'
 import { listAgents, saveAgentMany } from '@/lib/server/agents/agent-repository'
 import { getGatewayProfiles } from '@/lib/server/agents/agent-runtime-config'
+import { deleteCredentialRecord } from '@/lib/server/credentials/credential-service'
 import {
   loadGatewayProfile,
   loadGatewayProfiles,
@@ -161,7 +162,9 @@ export function updateGatewayProfile(id: string, input: Record<string, unknown>)
 
 export function deleteGatewayProfileAndDetachAgents(id: string): boolean {
   const gateways = loadGatewayProfiles()
-  if (!gateways[id]) return false
+  const deleted = gateways[id]
+  if (!deleted) return false
+  const orphanCredentialId = deleted.credentialId || null
   delete gateways[id]
   saveGatewayProfiles(gateways)
 
@@ -195,6 +198,21 @@ export function deleteGatewayProfileAndDetachAgents(id: string): boolean {
   }
 
   if (changed.length > 0) saveAgentMany(changed)
+
+  // Clean up orphaned credential if no other gateway or agent references it
+  if (orphanCredentialId) {
+    const stillReferencedByGateway = Object.values(gateways).some(
+      (gw) => gw && gw.credentialId === orphanCredentialId,
+    )
+    const stillReferencedByAgent = !stillReferencedByGateway && Object.values(agents).some(
+      (a) => a.credentialId === orphanCredentialId
+        || (Array.isArray(a.fallbackCredentialIds) && a.fallbackCredentialIds.includes(orphanCredentialId)),
+    )
+    if (!stillReferencedByGateway && !stillReferencedByAgent) {
+      deleteCredentialRecord(orphanCredentialId)
+    }
+  }
+
   notify('gateways')
   return true
 }

package/src/lib/server/messages/message-repository.test.ts

@@ -0,0 +1,70 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
+
+test('appendMessage notifies both generic and per-session message topics', () => {
+  const output = runWithTempDataDir<{
+    genericTopics: string[]
+    sessionTopics: string[]
+  }>(`
+    const { WebSocket } = await import('ws')
+    const storageMod = await import('@/lib/server/storage')
+    const repoMod = await import('@/lib/server/messages/message-repository')
+    const storage = storageMod.default || storageMod
+    const repo = repoMod.default || repoMod
+
+    storage.saveSessions({
+      'sess-notify': {
+        id: 'sess-notify',
+        name: 'Notify Session',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'tester',
+        provider: 'openai',
+        model: 'gpt-5',
+        claudeSessionId: null,
+        codexThreadId: null,
+        opencodeSessionId: null,
+        delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null },
+        messages: [],
+        createdAt: Date.now(),
+        lastActiveAt: Date.now(),
+      },
+    })
+
+    const genericPayloads = []
+    const sessionPayloads = []
+    globalThis.__swarmclaw_ws__ = {
+      wss: null,
+      clients: new Set([
+        {
+          ws: {
+            readyState: WebSocket.OPEN,
+            send(payload) { genericPayloads.push(JSON.parse(payload)) },
+          },
+          topics: new Set(['messages']),
+        },
+        {
+          ws: {
+            readyState: WebSocket.OPEN,
+            send(payload) { sessionPayloads.push(JSON.parse(payload)) },
+          },
+          topics: new Set(['messages:sess-notify']),
+        },
+      ]),
+    }
+
+    repo.appendMessage('sess-notify', {
+      role: 'user',
+      text: 'hello',
+      time: 1,
+    })
+
+    console.log(JSON.stringify({
+      genericTopics: genericPayloads.map((payload) => payload.topic),
+      sessionTopics: sessionPayloads.map((payload) => payload.topic),
+    }))
+  `, { prefix: 'swarmclaw-message-repo-notify-' })
+
+  assert.deepEqual(output.genericTopics, ['messages'])
+  assert.deepEqual(output.sessionTopics, ['messages:sess-notify'])
+})