@swarmclawai/swarmclaw 0.7.3 → 0.7.4

package/src/lib/server/chatroom-session-persistence.test.ts

@@ -0,0 +1,87 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { describe, it } from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-chatroom-session-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        DATA_DIR: path.join(tempDir, 'data'),
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+describe('chatroom synthetic session persistence', () => {
+  it('reuses stored synthetic sessions and preserves delegate resume state', () => {
+    const output = runWithTempDataDir(`
+      const helpersMod = await import('./src/lib/server/chatroom-helpers.ts')
+      const helpers = helpersMod.default || helpersMod
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const storage = storageMod.default || storageMod
+      const now = Date.now()
+      const agent = {
+        id: 'default',
+        name: 'Molly',
+        description: '',
+        systemPrompt: '',
+        provider: 'openai',
+        model: 'gpt-4o',
+        createdAt: now,
+        updatedAt: now,
+        plugins: ['delegate'],
+      }
+
+      const first = helpers.ensureSyntheticSession(agent, 'room-1')
+      helpers.appendSyntheticSessionMessage(first.id, 'user', 'first prompt')
+
+      const sessions = storage.loadSessions()
+      sessions[first.id].delegateResumeIds = {
+        claudeCode: null,
+        codex: 'resume-123',
+        opencode: null,
+        gemini: null,
+      }
+      storage.saveSessions(sessions)
+
+      const second = helpers.ensureSyntheticSession({ ...agent, model: 'gpt-4.1' }, 'room-1')
+      console.log(JSON.stringify({
+        sessionId: second.id,
+        cwd: second.cwd,
+        model: second.model,
+        messageCount: second.messages.length,
+        firstMessage: second.messages[0]?.text || '',
+        delegateResumeIds: second.delegateResumeIds,
+        plugins: second.plugins || [],
+      }))
+    `)
+
+    assert.equal(output.sessionId, 'chatroom-room-1-default')
+    assert.match(String(output.cwd), /chatrooms[\/\\]room-1$/)
+    assert.equal(output.model, 'gpt-4.1')
+    assert.equal(output.messageCount, 1)
+    assert.equal(output.firstMessage, 'first prompt')
+    assert.equal(output.delegateResumeIds?.codex, 'resume-123')
+    assert.deepEqual(output.plugins, ['delegate'])
+  })
+})

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

@@ -20,7 +20,7 @@ import {
   parseMentions,
   compactChatroomMessages,
   buildChatroomSystemPrompt,
-  buildSyntheticSession,
+  ensureSyntheticSession,
   buildAgentSystemPromptForChatroom,
   buildHistoryForAgent,
   resolveApiKey as resolveApiKeyHelper,
@@ -31,7 +31,7 @@ import { markProviderFailure, markProviderSuccess } from '../provider-health'
 import { syncSessionArchiveMemory } from '../session-archive-memory'
 import { buildIdentityContinuityContext } from '../identity-continuity'
 import { getProvider } from '@/lib/providers'
-import type { Connector, MessageSource, Chatroom, ChatroomMessage, Session } from '@/types'
+import type { Agent, Connector, MessageSource, Chatroom, ChatroomMessage, Session } from '@/types'
 import type { ConnectorInstance, InboundMessage, InboundMedia } from './types'
 import {
   addAllowedSender,
@@ -258,30 +258,41 @@ 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 g = globalThis as typeof globalThis & Record<string, unknown>
+
+function getOrInitGlobalValue<T>(key: string, factory: () => T): T {
+  const existing = g[key]
+  if (existing !== undefined) return existing as T
+  const created = factory()
+  g[key] = created
+  return created
+}
+
+type ConnectorSession = Session
+type ConnectorAgent = Agent
+
 const running: Map<string, ConnectorInstance> =
-  g[globalKey] ?? (g[globalKey] = new Map<string, ConnectorInstance>())
+  getOrInitGlobalValue(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> =
-  g[lastInboundKey] ?? (g[lastInboundKey] = new Map<string, string>())
+  getOrInitGlobalValue(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>())
+  getOrInitGlobalValue(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>> =
-  g[lockKey] ?? (g[lockKey] = new Map<string, Promise<void>>())
+  getOrInitGlobalValue(lockKey, () => new Map<string, Promise<void>>())
 
 /** Generation counter per connector — used to detect stale lifecycle events after restart */
 const genCounterKey = '__swarmclaw_connector_gen__' as const
 const generationCounter: Map<string, number> =
-  g[genCounterKey] ?? (g[genCounterKey] = new Map<string, number>())
+  getOrInitGlobalValue(genCounterKey, () => new Map<string, number>())
 
 type ScheduledConnectorFollowup = {
   id: string
@@ -294,11 +305,11 @@ type ScheduledConnectorFollowup = {
 
 const followupKey = '__swarmclaw_connector_followups__' as const
 const scheduledFollowups: Map<string, ScheduledConnectorFollowup> =
-  g[followupKey] ?? (g[followupKey] = new Map<string, ScheduledConnectorFollowup>())
+  getOrInitGlobalValue(followupKey, () => new Map<string, ScheduledConnectorFollowup>())
 
 const inboundDedupeKey = '__swarmclaw_connector_inbound_dedupe__' as const
 const recentInboundByKey: Map<string, number> =
-  g[inboundDedupeKey] ?? (g[inboundDedupeKey] = new Map<string, number>())
+  getOrInitGlobalValue(inboundDedupeKey, () => new Map<string, number>())
 
 type DebouncedInboundEntry = {
   connector: Connector
@@ -308,11 +319,11 @@ type DebouncedInboundEntry = {
 
 const inboundDebounceKey = '__swarmclaw_connector_inbound_debounce__' as const
 const pendingInboundDebounce: Map<string, DebouncedInboundEntry> =
-  g[inboundDebounceKey] ?? (g[inboundDebounceKey] = new Map<string, DebouncedInboundEntry>())
+  getOrInitGlobalValue(inboundDebounceKey, () => new Map<string, DebouncedInboundEntry>())
 
 const followupDedupeKey = '__swarmclaw_connector_followup_dedupe__' as const
 const scheduledFollowupByDedupe: Map<string, { id: string; sendAt: number }> =
-  g[followupDedupeKey] ?? (g[followupDedupeKey] = new Map<string, { id: string; sendAt: number }>())
+  getOrInitGlobalValue(followupDedupeKey, () => new Map<string, { id: string; sendAt: number }>())
 
 /** Reconnect state per connector — tracks backoff and retry attempts for crash recovery */
 export interface ConnectorReconnectState {
@@ -325,7 +336,7 @@ export interface ConnectorReconnectState {
 
 const reconnectStateKey = '__swarmclaw_connector_reconnect_state__' as const
 const reconnectState: Map<string, ConnectorReconnectState> =
-  g[reconnectStateKey] ?? (g[reconnectStateKey] = new Map<string, ConnectorReconnectState>())
+  getOrInitGlobalValue(reconnectStateKey, () => new Map<string, ConnectorReconnectState>())
 
 const RECONNECT_INITIAL_BACKOFF_MS = 1_000
 const RECONNECT_MAX_BACKOFF_MS = 5 * 60 * 1_000
@@ -371,11 +382,10 @@ function rememberRecentInbound(key: string, now = Date.now(), ttlMs = 120_000):
   return true
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function findDirectSessionForInbound(connector: Connector, msg: InboundMessage): Record<string, any> | null {
+function findDirectSessionForInbound(connector: Connector, msg: InboundMessage): ConnectorSession | null {
   if (connector.chatroomId) return null
   const effectiveAgentId = msg.agentIdOverride || connector.agentId
-  const sessions = Object.values(loadSessions()) as Array<Record<string, any>>
+  const sessions = Object.values(loadSessions() as Record<string, ConnectorSession>)
   const candidates = sessions.filter((session) =>
     session?.agentId === effectiveAgentId
       && session?.connectorContext?.connectorId === connector.id
@@ -431,7 +441,7 @@ function startConnectorTypingLoop(connector: Connector, msg: InboundMessage): ((
 type RouteMessageHandler = (connector: Connector, msg: InboundMessage) => Promise<string>
 const routeHandlerKey = '__swarmclaw_connector_route_handler__' as const
 const routeMessageHandlerRef: { current: RouteMessageHandler } =
-  g[routeHandlerKey] ?? (g[routeHandlerKey] = { current: async () => '[Error] Connector router unavailable.' })
+  getOrInitGlobalValue(routeHandlerKey, () => ({ current: async () => '[Error] Connector router unavailable.' }))
 
 async function flushDebouncedInbound(key: string): Promise<void> {
   const entry = pendingInboundDebounce.get(key)
@@ -625,15 +635,13 @@ function parseConnectorCommand(text: string): ParsedConnectorCommand | null {
   }
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function persistSessionRecord(session: Record<string, any>): void {
+function persistSessionRecord(session: ConnectorSession): void {
   const sessions = loadSessions()
   sessions[session.id] = session
   saveSessions(sessions)
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function updateSessionConnectorContext(session: Record<string, any>, connector: Connector, msg: InboundMessage, sessionKey: string): void {
+function updateSessionConnectorContext(session: ConnectorSession, connector: Connector, msg: InboundMessage, sessionKey: string): void {
   const policy = resolveConnectorSessionPolicy(connector, msg, session)
   session.connectorContext = {
     ...(session.connectorContext || {}),
@@ -665,7 +673,7 @@ function updateSessionConnectorContext(session: Record<string, any>, connector:
   }
 }
 
-function describeSessionControls(session: Record<string, any>, connector: Connector, msg: InboundMessage): string {
+function describeSessionControls(session: ConnectorSession, connector: Connector, msg: InboundMessage): string {
   const policy = resolveConnectorSessionPolicy(connector, msg, session)
   const context = session.connectorContext || {}
   const sessionAgeSec = Math.max(0, Math.round((Date.now() - (session.createdAt || Date.now())) / 1000))
@@ -699,7 +707,7 @@ function normalizeSessionSettingKey(raw: string): string {
   return raw.trim().toLowerCase().replace(/[_-]+/g, '')
 }
 
-function applySessionSetting(session: Record<string, any>, keyRaw: string, valueRaw: string, msg: InboundMessage): string {
+function applySessionSetting(session: ConnectorSession, keyRaw: string, valueRaw: string, msg: InboundMessage): string {
   const key = normalizeSessionSettingKey(keyRaw)
   const value = valueRaw.trim()
   const asInt = () => {
@@ -709,32 +717,38 @@ function applySessionSetting(session: Record<string, any>, keyRaw: string, value
     }
     return parsed
   }
+  const asEnum = <T extends string>(allowed: readonly T[], label: string): T | null => {
+    if (!value) return null
+    const normalized = value.toLowerCase()
+    if ((allowed as readonly string[]).includes(normalized)) return normalized as T
+    throw new Error(`Invalid ${label}. Use one of: ${allowed.join(', ')}.`)
+  }
 
   switch (key) {
     case 'think':
     case 'thinkinglevel':
-      session.connectorThinkLevel = value || null
+      session.connectorThinkLevel = asEnum(['minimal', 'low', 'medium', 'high'] as const, '/think level')
       return `Connector thinking level set to ${session.connectorThinkLevel || 'inherit'}.`
     case 'reply':
     case 'replymode':
-      session.connectorReplyMode = value || null
+      session.connectorReplyMode = asEnum(['off', 'first', 'all'] as const, 'reply mode')
       return `Reply mode set to ${session.connectorReplyMode || 'inherit'}.`
     case 'scope':
     case 'sessionscope':
-      session.connectorSessionScope = value || null
+      session.connectorSessionScope = asEnum(['main', 'channel', 'peer', 'channel-peer', 'thread'] as const, 'session scope')
       return `Session scope set to ${session.connectorSessionScope || 'inherit'}.`
     case 'thread':
     case 'threadbinding':
-      session.connectorThreadBinding = value || null
+      session.connectorThreadBinding = asEnum(['off', 'prefer', 'strict'] as const, 'thread binding')
       if (!value) {
         session.connectorContext = { ...(session.connectorContext || {}), threadId: null }
-      } else if (value === 'strict' && msg.threadId) {
+      } else if (session.connectorThreadBinding === 'strict' && msg.threadId) {
         session.connectorContext = { ...(session.connectorContext || {}), threadId: msg.threadId }
       }
       return `Thread binding set to ${session.connectorThreadBinding || 'inherit'}.`
     case 'group':
     case 'grouppolicy':
-      session.connectorGroupPolicy = value || null
+      session.connectorGroupPolicy = asEnum(['open', 'mention', 'reply-or-mention', 'disabled'] as const, 'group policy')
       return `Group policy set to ${session.connectorGroupPolicy || 'inherit'}.`
     case 'idle':
     case 'idletimeout':
@@ -775,10 +789,15 @@ function applySessionSetting(session: Record<string, any>, keyRaw: string, value
     case 'model':
       session.model = value
       return `Model set to ${session.model}.`
-    case 'provider':
-      session.provider = value
-      session.apiEndpoint = getProvider(value)?.defaultEndpoint || session.apiEndpoint || null
+    case 'provider': {
+      const provider = getProvider(value)
+      if (!provider) {
+        throw new Error(`Unknown provider "${value}".`)
+      }
+      session.provider = provider.id as Session['provider']
+      session.apiEndpoint = provider.defaultEndpoint || session.apiEndpoint || null
       return `Provider set to ${session.provider}.`
+    }
     default:
       throw new Error(`Unknown session setting "${keyRaw}".`)
   }
@@ -787,7 +806,7 @@ function applySessionSetting(session: Record<string, any>, keyRaw: string, value
 function evaluateGroupPolicy(params: {
   connector: Connector
   msg: InboundMessage
-  session?: Record<string, any> | null
+  session?: ConnectorSession | null
   aliases: string[]
 }): { allowed: boolean; reason: string } {
   const { connector, msg, session, aliases } = params
@@ -804,11 +823,11 @@ function evaluateGroupPolicy(params: {
   return { allowed, reason: allowed ? (mentioned ? 'mentioned' : 'reply') : 'reply_or_mention_required' }
 }
 
-function applyConnectorRuntimeDefaults(session: Record<string, any>, defaults: {
-  provider: string
+function applyConnectorRuntimeDefaults(session: ConnectorSession, defaults: {
+  provider: Session['provider']
   model: string
   apiEndpoint: string | null
-  thinkingLevel: string | null
+  thinkingLevel: Session['connectorThinkLevel']
 }): void {
   session.provider = defaults.provider
   session.model = defaults.model
@@ -819,12 +838,12 @@ function applyConnectorRuntimeDefaults(session: Record<string, any>, defaults: {
 function resolveDirectSession(params: {
   connector: Connector
   msg: InboundMessage
-  agent: Record<string, any>
-}): { session: Record<string, any>; sessionKey: string; wasCreated: boolean; staleReason?: string | null; clearedMessages?: number } {
+  agent: ConnectorAgent
+}): { session: ConnectorSession; sessionKey: string; wasCreated: boolean; staleReason?: string | null; clearedMessages?: number } {
   const { connector, msg, agent } = params
   const policySeed = resolveConnectorSessionPolicy(connector, msg)
   const providerInfo = policySeed.providerOverride ? getProvider(policySeed.providerOverride) : null
-  const defaultProvider = policySeed.providerOverride || (agent.provider === 'claude-cli' ? 'anthropic' : agent.provider)
+  const defaultProvider: Session['provider'] = providerInfo?.id || (agent.provider === 'claude-cli' ? 'anthropic' : agent.provider)
   const defaultModel = policySeed.modelOverride || agent.model
   const defaultApiEndpoint = agent.apiEndpoint || providerInfo?.defaultEndpoint || null
   const runtimeDefaults = {
@@ -840,7 +859,7 @@ function resolveDirectSession(params: {
     policy: policySeed,
   })
   const sessions = loadSessions()
-  let session = Object.values(sessions).find((item: any) => item?.name === sessionKey) as Record<string, any> | undefined
+  let session = Object.values(sessions as Record<string, ConnectorSession>).find((item) => item?.name === sessionKey)
   let wasCreated = false
   if (!session) {
     const id = genId()
@@ -892,8 +911,8 @@ function resolveDirectSession(params: {
   const staleness = getConnectorSessionStaleness(session, policy)
   let clearedMessages = 0
   if (staleness.stale) {
-    try { syncSessionArchiveMemory(session as any, { agent }) } catch { /* archive sync is best-effort */ }
-    clearedMessages = resetConnectorSessionRuntime(session as any, staleness.reason || 'session_refresh')
+    try { syncSessionArchiveMemory(session, { agent }) } catch { /* archive sync is best-effort */ }
+    clearedMessages = resetConnectorSessionRuntime(session, staleness.reason || 'session_refresh')
     applyConnectorRuntimeDefaults(session, {
       ...runtimeDefaults,
       thinkingLevel: policySeed.thinkingLevel || session.connectorThinkLevel || null,
@@ -911,16 +930,14 @@ function resolveDirectSession(params: {
   }
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function pushSessionMessage(session: Record<string, any>, role: 'user' | 'assistant', text: string): void {
+function pushSessionMessage(session: ConnectorSession, 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()
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function persistSession(session: Record<string, any>): void {
+function persistSession(session: ConnectorSession): void {
   const sessions = loadSessions()
   sessions[session.id] = session
   saveSessions(sessions)
@@ -1074,8 +1091,7 @@ function enforceInboundAccessPolicy(connector: Connector, msg: InboundMessage):
 async function handleConnectorCommand(params: {
   command: ParsedConnectorCommand
   connector: Connector
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  session: Record<string, any>
+  session: ConnectorSession
   msg: InboundMessage
   agentName: string
 }): Promise<string> {
@@ -1128,12 +1144,13 @@ async function handleConnectorCommand(params: {
   }
 
   if (command.name === 'new' || command.name === 'reset') {
-    try { syncSessionArchiveMemory(session as any, { agent: loadAgents()[session.agentId] }) } catch { /* best effort */ }
-    const cleared = resetConnectorSessionRuntime(session as any, 'manual_reset')
+    const agent = session.agentId ? (loadAgents() as Record<string, ConnectorAgent>)[session.agentId] : undefined
+    try { syncSessionArchiveMemory(session, { agent }) } catch { /* best effort */ }
+    const cleared = resetConnectorSessionRuntime(session, 'manual_reset')
     const policy = resolveConnectorSessionPolicy(connector, msg, session)
     const providerInfo = policy.providerOverride ? getProvider(policy.providerOverride) : null
     applyConnectorRuntimeDefaults(session, {
-      provider: policy.providerOverride || session.provider,
+      provider: providerInfo?.id || session.provider,
       model: policy.modelOverride || session.model,
       apiEndpoint: providerInfo?.defaultEndpoint || session.apiEndpoint || null,
       thinkingLevel: policy.thinkingLevel || session.connectorThinkLevel || null,
@@ -1173,7 +1190,7 @@ async function handleConnectorCommand(params: {
 
   if (command.name === 'think') {
     const requested = command.args.trim().toLowerCase()
-    const allowed = new Set(['minimal', 'low', 'medium', 'high'])
+    const allowed = new Set(['minimal', 'low', 'medium', 'high'] as const)
     if (!requested) {
       const policy = resolveConnectorSessionPolicy(connector, msg, session)
       const current = typeof policy.thinkingLevel === 'string' && allowed.has(policy.thinkingLevel)
@@ -1185,7 +1202,12 @@ async function handleConnectorCommand(params: {
       persistSession(session)
       return text
     }
-    if (!allowed.has(requested)) {
+    if (
+      requested !== 'minimal'
+      && requested !== 'low'
+      && requested !== 'medium'
+      && requested !== 'high'
+    ) {
       const text = 'Invalid /think level. Use one of: minimal, low, medium, high.'
       pushSessionMessage(session, 'user', inboundText)
       pushSessionMessage(session, 'assistant', text)
@@ -1222,12 +1244,13 @@ async function handleConnectorCommand(params: {
       return text
     }
     if (parts[0].toLowerCase() === 'reset') {
-      try { syncSessionArchiveMemory(session as any, { agent: loadAgents()[session.agentId] }) } catch { /* best effort */ }
-      const cleared = resetConnectorSessionRuntime(session as any, 'manual_reset')
+      const agent = session.agentId ? (loadAgents() as Record<string, ConnectorAgent>)[session.agentId] : undefined
+      try { syncSessionArchiveMemory(session, { agent }) } catch { /* best effort */ }
+      const cleared = resetConnectorSessionRuntime(session, 'manual_reset')
       const policy = resolveConnectorSessionPolicy(connector, msg, session)
       const providerInfo = policy.providerOverride ? getProvider(policy.providerOverride) : null
       applyConnectorRuntimeDefaults(session, {
-        provider: policy.providerOverride || session.provider,
+        provider: providerInfo?.id || session.provider,
         model: policy.modelOverride || session.model,
         apiEndpoint: providerInfo?.defaultEndpoint || session.apiEndpoint || null,
         thinkingLevel: policy.thinkingLevel || session.connectorThinkLevel || null,
@@ -1402,7 +1425,7 @@ async function routeMessageToChatroom(connector: Connector, msg: InboundMessage)
       continue
     }
 
-    const syntheticSession = buildSyntheticSession(agent, chatroomId)
+    const syntheticSession = ensureSyntheticSession(agent, chatroomId)
     const agentSystemPrompt = buildAgentSystemPromptForChatroom(agent)
     const chatroomContext = buildChatroomSystemPrompt(freshChatroom, agents, agent.id)
     const fullSystemPrompt = [agentSystemPrompt, chatroomContext, threadContextBlock].filter(Boolean).join('\n\n')
@@ -2255,12 +2278,17 @@ export async function recordConnectorOutboundDelivery(params: {
     for (let i = history.length - 1; i >= 0; i -= 1) {
       const entry = history[i]
       if (entry?.role !== 'assistant') continue
-      const source = entry?.source || {}
+      const source: Partial<MessageSource> = entry?.source || {}
       if (source.connectorId !== connector.id) continue
       if (source.channelId !== params.inbound.channelId) continue
       if (!source.messageId && params.messageId) {
         entry.source = {
-          ...source,
+          platform: source.platform || connector.platform,
+          connectorId: source.connectorId || connector.id,
+          connectorName: source.connectorName || connector.name,
+          channelId: source.channelId || params.inbound.channelId,
+          senderId: source.senderId,
+          senderName: source.senderName,
           messageId: params.messageId,
           replyToMessageId: source.replyToMessageId || params.inbound.messageId,
           threadId: source.threadId || params.inbound.threadId,
@@ -2456,7 +2484,7 @@ export async function sendConnectorMessage(params: {
       for (let i = history.length - 1; i >= 0; i -= 1) {
         const entry = history[i]
         if (entry?.role !== 'assistant') continue
-        const source = entry?.source || {}
+        const source: Partial<MessageSource> = entry?.source || {}
         if (source.connectorId !== connectorId) continue
         if (source.channelId !== channelId) continue
         if (!source.messageId && result?.messageId) {

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

@@ -284,7 +284,7 @@ const slack: PlatformConnector = {
     })
 
     // Handle @mentions
-    app.event('app_mention', async ({ event, say, client }) => {
+    app.event('app_mention', async ({ event, client }) => {
       if (allowedChannels && !allowedChannels.includes(event.channel)) return
 
       let senderName = event.user || 'unknown'

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

@@ -16,6 +16,7 @@ import { startHeartbeatService, stopHeartbeatService, getHeartbeatServiceStatus
 import { hasOpenClawAgents, ensureGatewayConnected, disconnectGateway, getGateway } from './openclaw-gateway'
 import { enqueueSessionRun } from './session-run-manager'
 import { WORKSPACE_DIR } from './data-dir'
+import { DEFAULT_HEARTBEAT_INTERVAL_SEC } from '@/lib/heartbeat-defaults'
 import { genId } from '@/lib/id'
 import path from 'node:path'
 import type { WebhookRetryEntry } from '@/types'
@@ -57,7 +58,7 @@ function daemonAutostartEnvEnabled(): boolean {
   return parseBoolish(process.env.SWARMCLAW_DAEMON_AUTOSTART, true)
 }
 
-function parseHeartbeatIntervalSec(value: unknown, fallback = 120): number {
+function parseHeartbeatIntervalSec(value: unknown, fallback = DEFAULT_HEARTBEAT_INTERVAL_SEC): number {
   const parsed = typeof value === 'number'
     ? value
     : typeof value === 'string'
@@ -735,7 +736,7 @@ async function runHealthChecks() {
 
     const sessionId = session.id
     const sessionLabel = String(session.name || sessionId)
-    const intervalSec = parseHeartbeatIntervalSec(session.heartbeatIntervalSec, 120)
+    const intervalSec = parseHeartbeatIntervalSec(session.heartbeatIntervalSec, DEFAULT_HEARTBEAT_INTERVAL_SEC)
     if (intervalSec <= 0) continue
     const staleAfter = Math.max(intervalSec * STALE_MULTIPLIER * 1000, STALE_MIN_MS)
     const lastActive = typeof session.lastActiveAt === 'number' ? session.lastActiveAt : 0

package/src/lib/server/eval/agent-regression.test.ts

@@ -0,0 +1,47 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import { AGENT_REGRESSION_SCENARIOS, resolveRegressionApprovalSettings, scoreAssertions } from './agent-regression'
+
+describe('agent regression helpers', () => {
+  it('maps approval modes onto deterministic platform settings', () => {
+    assert.deepEqual(resolveRegressionApprovalSettings('manual'), {
+      approvalsEnabled: true,
+      approvalAutoApproveCategories: [],
+    })
+    assert.deepEqual(resolveRegressionApprovalSettings('auto'), {
+      approvalsEnabled: true,
+      approvalAutoApproveCategories: ['tool_access'],
+    })
+    assert.deepEqual(resolveRegressionApprovalSettings('off'), {
+      approvalsEnabled: false,
+      approvalAutoApproveCategories: [],
+    })
+  })
+
+  it('scores scenarios from assertion weights instead of prose', () => {
+    const scored = scoreAssertions([
+      { name: 'artifact exists', passed: true, weight: 2 },
+      { name: 'exact token preserved', passed: false, weight: 3 },
+      { name: 'delegate used', passed: true },
+    ])
+
+    assert.deepEqual(scored, {
+      score: 3,
+      maxScore: 6,
+      status: 'failed',
+    })
+  })
+
+  it('includes the extended signup, secrets, email, and human-verification scenarios', () => {
+    const ids = AGENT_REGRESSION_SCENARIOS.map((scenario) => scenario.id)
+    assert.deepEqual(ids, [
+      'approval-resume',
+      'delegate-literal-artifact',
+      'schedule-script',
+      'open-ended-iteration',
+      'mock-signup-secret-email',
+      'human-verified-signup',
+      'research-build-deploy',
+    ])
+  })
+})