@swarmclawai/swarmclaw 1.1.8 → 1.2.0

package/src/components/org-chart/mini-chat-bubble.tsx

@@ -8,6 +8,7 @@ import { useWs } from '@/hooks/use-ws'
 import { api } from '@/lib/app/api-client'
 import { fetchMessages } from '@/lib/chat/chats'
 import { streamChat } from '@/lib/chat/chat'
+import { hmrSingleton } from '@/lib/shared-utils'
 import type { Agent, Message, Session, SSEEvent } from '@/types'
 import { INTERNAL_KEY_RE, stripAllInternalMetadata } from '@/lib/strip-internal-metadata'
 
@@ -19,6 +20,9 @@ interface Props {
 
 const BUBBLE_W = 320
 
+/** Client-side cache: agentId → sessionId, avoids redundant POST on reopen */
+const sessionCache = hmrSingleton('miniChatBubble_sessionCache', () => new Map<string, string>())
+
 const UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i
 
 /** Filter status text that looks like raw IDs or data dumps */
@@ -39,30 +43,57 @@ export function MiniChatBubble({ agent, onClose, onToolActivity }: Props) {
   const [streamText, setStreamText] = useState('')
   const [inputValue, setInputValue] = useState('')
   const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
   const scrollRef = useRef<HTMLDivElement>(null)
   const inputRef = useRef<HTMLInputElement>(null)
+  const cancelledRef = useRef(false)
 
   // Initialize: get or create thread session, load messages
-  useEffect(() => {
-    let cancelled = false
-    async function init() {
-      try {
-        const session = await api<Session>('POST', `/agents/${agent.id}/thread`)
-        if (cancelled) return
-        setSessionId(session.id)
+  const init = useCallback(async () => {
+    setError(null)
+    setLoading(true)
+    try {
+      const cachedSid = sessionCache.get(agent.id)
+      if (cachedSid) {
+        // Try cached session first — skip POST entirely
+        try {
+          const msgs = await fetchMessages(cachedSid)
+          if (cancelledRef.current) return
+          setSessionId(cachedSid)
+          setMessages(msgs)
+          return
+        } catch {
+          // Cached session gone — clear and fall through to POST
+          sessionCache.delete(agent.id)
+        }
+      }
+
+      const session = await api<Session>('POST', `/agents/${agent.id}/thread`)
+      if (cancelledRef.current) return
+      setSessionId(session.id)
+      sessionCache.set(agent.id, session.id)
+
+      // Use messages from POST response if present, otherwise fetch
+      if (Array.isArray(session.messages) && session.messages.length > 0) {
+        setMessages(session.messages as Message[])
+      } else {
         const msgs = await fetchMessages(session.id)
-        if (cancelled) return
+        if (cancelledRef.current) return
         setMessages(msgs)
-      } catch {
-        // Agent may not be available
-      } finally {
-        if (!cancelled) setLoading(false)
       }
+    } catch {
+      if (!cancelledRef.current) setError('Could not connect to agent')
+    } finally {
+      if (!cancelledRef.current) setLoading(false)
     }
-    init()
-    return () => { cancelled = true }
   }, [agent.id])
 
+  useEffect(() => {
+    cancelledRef.current = false
+    init()
+    return () => { cancelledRef.current = true }
+  }, [init])
+
   // Real-time message refresh via WebSocket (mirrors main ChatArea pattern)
   const refreshMessages = useCallback(async () => {
     if (!sessionId || streaming) return
@@ -188,7 +219,18 @@ export function MiniChatBubble({ agent, onClose, onToolActivity }: Props) {
         {loading && (
           <div className="text-[11px] text-text-3/50 text-center py-8">Loading...</div>
         )}
-        {!loading && visibleMessages.length === 0 && !streaming && (
+        {!loading && error && (
+          <div className="text-center py-8 space-y-2">
+            <div className="text-[11px] text-red-400/70">{error}</div>
+            <button
+              onClick={() => { init() }}
+              className="text-[11px] text-accent-bright/70 hover:text-accent-bright cursor-pointer border-none bg-transparent underline"
+            >
+              Retry
+            </button>
+          </div>
+        )}
+        {!loading && !error && visibleMessages.length === 0 && !streaming && (
           <div className="text-[11px] text-text-3/40 text-center py-8">
             Start a conversation with {agent.name}
           </div>
@@ -228,7 +270,7 @@ export function MiniChatBubble({ agent, onClose, onToolActivity }: Props) {
           onChange={(e) => setInputValue(e.target.value)}
           onKeyDown={(e) => { if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); send() } }}
           placeholder="Type a message..."
-          disabled={loading || !sessionId}
+          disabled={loading || !!error || !sessionId}
           className="flex-1 text-[12px] bg-white/[0.04] border border-white/[0.06] rounded-[6px] px-2.5 py-1.5 text-text placeholder:text-text-3/30 outline-none focus:border-accent-bright/30 transition-colors disabled:opacity-40"
         />
         {streaming ? (

package/src/components/shared/command-palette.tsx

@@ -17,6 +17,33 @@ interface CommandItem {
 
 export function CommandPalette() {
   const [open, setOpen] = useState(false)
+
+  // Register keyboard shortcut (always mounted)
+  useEffect(() => {
+    const handler = (e: KeyboardEvent) => {
+      if ((e.metaKey || e.ctrlKey) && e.key === 'k') {
+        e.preventDefault()
+        setOpen((v) => !v)
+      }
+    }
+    window.addEventListener('keydown', handler)
+    return () => window.removeEventListener('keydown', handler)
+  }, [])
+
+  // Also listen for custom event
+  useEffect(() => {
+    const handler = () => setOpen(true)
+    window.addEventListener('swarmclaw:open-search', handler)
+    return () => window.removeEventListener('swarmclaw:open-search', handler)
+  }, [])
+
+  if (!open) return null
+
+  return <CommandPaletteInner setOpen={setOpen} />
+}
+
+/** Inner component — only mounted when palette is open, so store subscriptions are gated. */
+function CommandPaletteInner({ setOpen }: { setOpen: (v: boolean) => void }) {
   const [query, setQuery] = useState('')
   const [selectedIndex, setSelectedIndex] = useState(0)
   const inputRef = useRef<HTMLInputElement>(null)
@@ -39,31 +66,21 @@ export function CommandPalette() {
         detail: { tabId, sectionId },
       }))
     }, 80)
-  }, [navigateTo])
+  }, [navigateTo, setOpen])
 
-  // Register keyboard shortcut
+  // Close on Escape
   useEffect(() => {
     const handler = (e: KeyboardEvent) => {
-      if ((e.metaKey || e.ctrlKey) && e.key === 'k') {
-        e.preventDefault()
-        setOpen((v) => !v)
-      }
-      if (e.key === 'Escape' && open) {
-        setOpen(false)
-      }
+      if (e.key === 'Escape') setOpen(false)
     }
     window.addEventListener('keydown', handler)
     return () => window.removeEventListener('keydown', handler)
-  }, [open])
+  }, [setOpen])
 
-  // Focus input when opened
+  // Focus input when mounted
   useEffect(() => {
-    if (open) {
-      setQuery('')
-      setSelectedIndex(0)
-      setTimeout(() => inputRef.current?.focus(), 50)
-    }
-  }, [open])
+    setTimeout(() => inputRef.current?.focus(), 50)
+  }, [])
 
   const items = useMemo<CommandItem[]>(() => {
     const result: CommandItem[] = []
@@ -177,7 +194,7 @@ export function CommandPalette() {
     }
 
     return result
-  }, [agents, currentUser, navigateTo, openSettingsSection, sessions, setCurrentAgent, setEditingTaskId, setTaskSheetOpen, tasks])
+  }, [agents, currentUser, navigateTo, openSettingsSection, sessions, setCurrentAgent, setEditingTaskId, setOpen, setTaskSheetOpen, tasks])
 
   const filtered = useMemo(() => {
     if (!query.trim()) return items.slice(0, 20)
@@ -214,8 +231,6 @@ export function CommandPalette() {
     el?.scrollIntoView({ block: 'nearest' })
   }, [selectedIndex])
 
-  if (!open) return null
-
   const categoryLabel = { agent: 'Agents', chat: 'Chats', task: 'Tasks', nav: 'Navigation', setting: 'Settings' } as const
   const categoryIcon = {
     agent: (

package/src/components/shared/notification-center.tsx

@@ -53,8 +53,8 @@ export function NotificationCenter({
   align?: 'left' | 'right'
   direction?: 'up' | 'down'
 }) {
-  const now = useNow()
   const [open, setOpen] = useState(false)
+  const now = useNow({ enabled: open })
   const panelRef = useRef<HTMLDivElement>(null)
   const buttonRef = useRef<HTMLButtonElement>(null)
   const [panelStyle, setPanelStyle] = useState<CSSProperties>({

package/src/hooks/use-app-bootstrap.ts

@@ -8,6 +8,7 @@ import { isDevelopmentLikeRuntime } from '@/lib/runtime/runtime-env'
 import { useWs } from '@/hooks/use-ws'
 import { useMountedRef } from '@/hooks/use-mounted-ref'
 import { resolveSetupDone } from '@/hooks/setup-done-detection'
+import { setIfChanged } from '@/stores/set-if-changed'
 import type { Agent } from '@/types'
 
 const AUTH_CHECK_TIMEOUT_MS = isDevelopmentLikeRuntime() ? 20_000 : 8_000
@@ -155,7 +156,7 @@ export function useAppBootstrap() {
           retries: 0,
         })
         if (cancelled) return
-        useAppStore.setState({ agents })
+        setIfChanged(useAppStore.setState, 'agents', agents)
 
         const { currentAgentId, appSettings } = useAppStore.getState()
         const targetId = (currentAgentId && agents[currentAgentId])

package/src/instrumentation.ts

@@ -49,6 +49,33 @@ export async function register() {
     if (!shutdownState.registered) {
       process.on('SIGTERM', () => { void shutdown('SIGTERM') })
       process.on('SIGINT', () => { void shutdown('SIGINT') })
+
+      // Gracefully handle EPIPE errors from child processes (e.g. Playwright MCP proxy)
+      // that occur during dev server restarts when stdio pipes break
+      process.on('uncaughtException', (err: NodeJS.ErrnoException) => {
+        if (err.code === 'EPIPE') {
+          console.warn('[instrumentation] Ignoring EPIPE (expected during dev server restart)')
+          return
+        }
+        console.error('[instrumentation] Uncaught exception:', err)
+        process.exit(1)
+      })
+
+      // LangGraph's streamEvents leaves dangling internal promises when the
+      // for-await loop exits early. Suppress expected LangGraph rejections;
+      // log all others so they're not silently dropped.
+      process.on('unhandledRejection', (err: unknown) => {
+        if (
+          err && typeof err === 'object'
+          && ('pregelTaskId' in err
+            || (err instanceof Error && (err.name === 'AbortError' || err.name === 'GraphRecursionError'))
+            || (err as Record<string, unknown>).lc_error_code === 'GRAPH_RECURSION_LIMIT')
+        ) {
+          return
+        }
+        console.error('[instrumentation] Unhandled rejection:', err)
+      })
+
       shutdownState.registered = true
     }
   }

package/src/lib/providers/anthropic.ts

@@ -4,17 +4,17 @@ import type { StreamChatOptions } from './index'
 import { PROVIDER_DEFAULTS, IMAGE_EXTS, TEXT_EXTS, ANTHROPIC_MAX_TOKENS, MAX_HISTORY_MESSAGES, writeSSE } from './provider-defaults'
 import { resolveImagePath } from '@/lib/server/resolve-image'
 
-function fileToContentBlocks(filePath: string): Array<Record<string, unknown>> {
+async function fileToContentBlocks(filePath: string): Promise<Array<Record<string, unknown>>> {
   if (!filePath || !fs.existsSync(filePath)) return []
   if (IMAGE_EXTS.test(filePath)) {
-    const data = fs.readFileSync(filePath).toString('base64')
+    const data = (await fs.promises.readFile(filePath)).toString('base64')
     const ext = filePath.split('.').pop()?.toLowerCase() || 'png'
     const mediaType = ext === 'jpg' ? 'image/jpeg' : `image/${ext}`
     return [{ type: 'image', source: { type: 'base64', media_type: mediaType, data } }]
   }
   if (TEXT_EXTS.test(filePath) || filePath.endsWith('.pdf')) {
     try {
-      const text = fs.readFileSync(filePath, 'utf-8')
+      const text = await fs.promises.readFile(filePath, 'utf-8')
       const name = filePath.split('/').pop() || 'file'
       return [{ type: 'text', text: `[Attached file: ${name}]\n\n${text}` }]
     } catch { return [] }
@@ -23,8 +23,8 @@ function fileToContentBlocks(filePath: string): Array<Record<string, unknown>> {
 }
 
 export function streamAnthropicChat({ session, message, imagePath, apiKey, systemPrompt, write, active, loadHistory, onUsage, signal }: StreamChatOptions): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const messages = buildMessages(session, message, imagePath, loadHistory)
+  return new Promise(async (resolve, reject) => {
+    const messages = await buildMessages(session, message, imagePath, loadHistory)
     const model = session.model || 'claude-sonnet-4-6'
     let usageInput = 0
     let usageOutput = 0
@@ -59,6 +59,7 @@ export function streamAnthropicChat({ session, message, imagePath, apiKey, syste
       hostname: PROVIDER_DEFAULTS.anthropic,
       path: '/v1/messages',
       method: 'POST',
+      timeout: 60_000,
       headers: {
         'x-api-key': apiKey || '',
         'anthropic-version': '2023-06-01',
@@ -122,6 +123,11 @@ export function streamAnthropicChat({ session, message, imagePath, apiKey, syste
     apiReqRef = apiReq
     active.set(session.id, { kill: () => { abortController.aborted = true; apiReq.destroy() } })
 
+    apiReq.on('timeout', () => {
+      console.error(`[${session.id}] anthropic request timed out after 60s`)
+      apiReq.destroy(new Error('Request timed out after 60s'))
+    })
+
     apiReq.on('error', (e) => {
       console.error(`[${session.id}] anthropic request error:`, e.message)
       writeSSE(write, 'err', e.message)
@@ -133,7 +139,7 @@ export function streamAnthropicChat({ session, message, imagePath, apiKey, syste
   })
 }
 
-function buildMessages(session: Record<string, unknown> & { id: string }, message: string, imagePath: string | undefined, loadHistory: (id: string) => Record<string, unknown>[]) {
+async function buildMessages(session: Record<string, unknown> & { id: string }, message: string, imagePath: string | undefined, loadHistory: (id: string) => Record<string, unknown>[]) {
   const msgs: Array<{ role: string; content: unknown }> = []
 
   if (loadHistory) {
@@ -141,7 +147,7 @@ function buildMessages(session: Record<string, unknown> & { id: string }, messag
     for (const m of history) {
       const histImagePath = resolveImagePath(m.imagePath as string | undefined, m.imageUrl as string | undefined)
       if (m.role === 'user' && histImagePath) {
-        const blocks = fileToContentBlocks(histImagePath)
+        const blocks = await fileToContentBlocks(histImagePath)
         msgs.push({ role: 'user', content: [...blocks, { type: 'text', text: m.text }] })
       } else {
         msgs.push({ role: m.role as string, content: m.text })
@@ -150,7 +156,7 @@ function buildMessages(session: Record<string, unknown> & { id: string }, messag
   }
 
   if (imagePath) {
-    const blocks = fileToContentBlocks(imagePath)
+    const blocks = await fileToContentBlocks(imagePath)
     msgs.push({ role: 'user', content: [...blocks, { type: 'text', text: message }] })
   } else {
     msgs.push({ role: 'user', content: message })

package/src/lib/providers/openai.ts

@@ -7,7 +7,7 @@ async function fileToContentParts(filePath: string): Promise<Array<Record<string
   if (!filePath || !fs.existsSync(filePath)) return []
   const name = filePath.split('/').pop() || 'file'
   if (IMAGE_EXTS.test(filePath)) {
-    const buf = fs.readFileSync(filePath)
+    const buf = await fs.promises.readFile(filePath)
     if (buf.length === 0) return [{ type: 'text', text: `[Attached image: ${name} — file is empty]` }]
     const data = buf.toString('base64')
     const ext = filePath.split('.').pop()?.toLowerCase() || 'png'
@@ -22,7 +22,7 @@ async function fileToContentParts(filePath: string): Promise<Array<Record<string
     try {
       // @ts-ignore — pdf-parse types
       const pdfParse = (await import(/* webpackIgnore: true */ 'pdf-parse')).default
-      const buf = fs.readFileSync(filePath)
+      const buf = await fs.promises.readFile(filePath)
       const result = await pdfParse(buf)
       const pdfText = (result.text || '').trim()
       if (!pdfText) return [{ type: 'text', text: `[Attached PDF: ${name} — no extractable text]` }]
@@ -34,7 +34,7 @@ async function fileToContentParts(filePath: string): Promise<Array<Record<string
   }
   if (TEXT_EXTS.test(filePath)) {
     try {
-      const text = fs.readFileSync(filePath, 'utf-8')
+      const text = await fs.promises.readFile(filePath, 'utf-8')
       return [{ type: 'text', text: `[Attached file: ${name}]\n\n${text}` }]
     } catch { return [] }
   }

package/src/lib/server/agents/agent-thread-session.ts

@@ -3,7 +3,7 @@ import type { Agent, Session } from '@/types'
 import { applyResolvedRoute, resolvePrimaryAgentRoute } from '@/lib/server/agents/agent-runtime-config'
 import { isAgentDisabled } from '@/lib/server/agents/agent-availability'
 import { WORKSPACE_DIR } from '@/lib/server/data-dir'
-import { loadAgents, loadSessions, upsertAgent, upsertStoredItem } from '@/lib/server/storage'
+import { loadAgents, loadSession, loadSessions, upsertAgent, upsertStoredItem } from '@/lib/server/storage'
 import { getEnabledCapabilitySelection } from '@/lib/capability-selection'
 
 function buildEmptyDelegateResumeIds(): NonNullable<Session['delegateResumeIds']> {
@@ -107,27 +107,33 @@ function shouldHealAgentCredentialId(agent: Agent, session: Session): boolean {
   return session.provider === agent.provider
 }
 
-export function ensureAgentThreadSession(agentId: string, user = 'default'): Session | null {
-  const agents = loadAgents()
-  const agent = agents[agentId] as Agent | undefined
+export function ensureAgentThreadSession(agentId: string, user = 'default', preloadedAgent?: Agent): Session | null {
+  const agent = preloadedAgent ?? (loadAgents()[agentId] as Agent | undefined)
   if (!agent) return null
 
-  const sessions = loadSessions()
   const now = Date.now()
-  const disabled = isAgentDisabled(agent)
 
+  // Fast path: agent already has a threadSessionId — single-row lookup
   const existingId = typeof agent.threadSessionId === 'string' ? agent.threadSessionId : ''
-  if (existingId && sessions[existingId]) {
-    const session = buildThreadSession(agent, existingId, user, now, sessions[existingId] as Session)
-    if (shouldHealAgentCredentialId(agent, session)) {
-      agent.credentialId = session.credentialId ?? null
-      agent.updatedAt = now
-      upsertAgent(agentId, agent)
+  if (existingId) {
+    const existing = loadSession(existingId)
+    if (existing) {
+      const session = buildThreadSession(agent, existingId, user, now, existing)
+      if (shouldHealAgentCredentialId(agent, session)) {
+        agent.credentialId = session.credentialId ?? null
+        agent.updatedAt = now
+        upsertAgent(agentId, agent)
+      }
+      upsertStoredItem('sessions', existingId, session)
+      return session
     }
-    upsertStoredItem('sessions', existingId, session)
-    return session
+    // Session was deleted — fall through to legacy search / creation
   }
 
+  // Legacy search: full table scan only when threadSessionId is missing or stale
+  const sessions = loadSessions()
+  const disabled = isAgentDisabled(agent)
+
   const legacySession = Object.values(sessions).find((session) => (
     (session.shortcutForAgentId === agentId || session.name === `agent-thread:${agentId}`)
     && session.user === user

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

@@ -339,10 +339,10 @@ function checkCoordinatorDelegation(ctx: ContinuationContext): ContinuationDecis
   // Skip if already delegated
   const delegationTools = ['spawn_subagent', 'manage_protocols']
   if (delegationTools.some(t => ctx.state.usedToolNames.has(t))) return null
-  // Only nudge if coordinator made 3+ direct substantial tool calls
+  // Only nudge if coordinator made 2+ direct substantial tool calls
   const directTools = ['files', 'edit_file', 'shell', 'web']
   const directCallCount = directTools.filter(t => ctx.state.usedToolNames.has(t)).length
-  if (directCallCount < 3) return null
+  if (directCallCount < 2) return null
   ctx.limits.increment('coordinator_delegation_nudge')
   writeStatus(ctx, { coordinatorDelegationNudge: true })
   return { type: 'coordinator_delegation_nudge', requiredToolReminderNames: [] }

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

@@ -13,6 +13,7 @@ import crypto from 'node:crypto'
 import { HumanMessage } from '@langchain/core/messages'
 import { z } from 'zod'
 import { buildLLM } from '@/lib/server/build-llm'
+import { hmrSingleton } from '@/lib/shared-utils'
 import type { Message } from '@/types'
 
 // ---------------------------------------------------------------------------
@@ -37,7 +38,7 @@ export type MessageClassification = z.infer<typeof MessageClassificationSchema>
 // ---------------------------------------------------------------------------
 
 const MAX_CACHE_SIZE = 200
-const classificationCache = new Map<string, MessageClassification>()
+const classificationCache = hmrSingleton('__swarmclaw_classification_cache__', () => new Map<string, MessageClassification>())
 
 function cacheKey(message: string): string {
   return crypto.createHash('sha256').update(message).digest('hex')

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

@@ -99,24 +99,8 @@ import {
   type MessageClassification,
 } from '@/lib/server/chat-execution/message-classifier'
 
-// LangGraph's streamEvents leaves dangling internal promises when the for-await
-// loop exits early (break on tool loop detection, execution boundary, etc.).
-// These promises may later reject with GraphRecursionError or AbortError.
-// Register a permanent handler to prevent process crashes from these expected
-// background rejections.  Only LangGraph-specific errors (identified by
-// pregelTaskId or lc_error_code) are suppressed; all other rejections propagate
-// normally.
-process.on('unhandledRejection', (err: unknown) => {
-  if (
-    err && typeof err === 'object'
-    && ('pregelTaskId' in err
-      || (err instanceof Error && (err.name === 'AbortError' || err.name === 'GraphRecursionError'))
-      || (err as Record<string, unknown>).lc_error_code === 'GRAPH_RECURSION_LIMIT')
-  ) {
-    // Silently suppress — expected background rejection from LangGraph
-    return
-  }
-})
+// LangGraph unhandledRejection handler has been moved to src/instrumentation.ts
+// to avoid re-registration on every HMR reload.
 
 // Re-export continuation functions so existing consumers don't need to change imports
 export {
@@ -912,7 +896,8 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
           && !abortController.signal.aborted)
           || (isTransientProviderError && !abortController.signal.aborted)
 
-        console.error(`[stream-agent-chat] Error in streamEvents iteration=${iteration}`, {
+        const logLevel = abortController.signal.aborted ? 'warn' : 'error'
+        console[logLevel](`[stream-agent-chat] Error in streamEvents iteration=${iteration}`, {
           errName, errMsg, errStack,
           statusCode, retryAfterMs: extractedRetryAfterMs,
           isRecursionError, isContextOverflow, isTransientAbort,

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

@@ -820,9 +820,10 @@ export function buildContinuationPrompt(params: {
 
     case 'coordinator_delegation_nudge':
       return [
-        'You have specialist workers available but have been using tools directly for substantial work.',
-        'Consider delegating the remaining work via `spawn_subagent` to the appropriate worker.',
-        'Direct tool use is fine for quick validation, but substantial work should go to specialists.',
+        'IMPORTANT: You have specialist workers available but you have been doing substantial work directly with tools.',
+        'You MUST delegate the remaining work via `spawn_subagent` to the appropriate specialist worker NOW.',
+        'As a coordinator, your job is to orchestrate — not to do the work yourself. Direct tool use is only for quick lookups and validation.',
+        'Review the workers listed in your system prompt and delegate immediately.',
       ].join('\n')
 
     case 'loop_recovery': {

package/src/lib/server/llm-response-cache.ts

@@ -1,4 +1,5 @@
 import crypto from 'node:crypto'
+import { hmrSingleton } from '@/lib/shared-utils'
 import type { AppSettings, Message } from '@/types'
 
 export interface LlmResponseCacheConfig {
@@ -48,7 +49,7 @@ const MAX_TTL_SEC = 7 * 24 * 3600
 const MIN_ENTRIES = 1
 const MAX_ENTRIES = 20_000
 
-const responseCache = new Map<string, LlmResponseCacheEntry>()
+const responseCache = hmrSingleton('__swarmclaw_llm_response_cache__', () => new Map<string, LlmResponseCacheEntry>())
 
 function normalizeText(value: unknown): string {
   return typeof value === 'string' ? value.replace(/\s+/g, ' ').trim() : ''

package/src/lib/server/playwright-proxy.mjs

@@ -39,9 +39,17 @@ const child = cliPath
       env: sanitizePlaywrightEnv(process.env),
     })
 
-// Forward stdin → child
-process.stdin.on('data', (chunk) => child.stdin.write(chunk))
-process.stdin.on('end', () => child.stdin.end())
+// Graceful EPIPE handling — dev server restarts break stdio pipes
+function safeWrite(stream, chunk) {
+  try { stream.write(chunk) } catch { /* EPIPE during restart, ignore */ }
+}
+
+process.stdin.on('data', (chunk) => safeWrite(child.stdin, chunk))
+process.stdin.on('end', () => { try { child.stdin.end() } catch { /* ignore */ } })
+child.stdin.on('error', (err) => {
+  if (err.code === 'EPIPE' || err.code === 'ERR_STREAM_DESTROYED') return
+  process.stderr.write(`Proxy child stdin error: ${err.message}\n`)
+})
 
 // Parse MCP Content-Length framed messages from child stdout, intercept screenshots
 let buf = ''
@@ -84,10 +92,21 @@ child.stdout.on('data', (chunk) => {
       output = body
     }
     const frame = `Content-Length: ${Buffer.byteLength(output)}\r\n\r\n${output}`
-    process.stdout.write(frame)
+    safeWrite(process.stdout, frame)
   }
 })
+child.stdout.on('error', (err) => {
+  if (err.code === 'EPIPE' || err.code === 'ERR_STREAM_DESTROYED') return
+  process.stderr.write(`Proxy child stdout error: ${err.message}\n`)
+})
 
-child.stderr.on('data', (chunk) => process.stderr.write(chunk))
+child.stderr.on('data', (chunk) => safeWrite(process.stderr, chunk))
+child.stderr.on('error', () => { /* ignore stderr errors */ })
 child.on('close', (code) => process.exit(code || 0))
-child.on('error', (err) => { process.stderr.write(`Proxy error: ${err.message}\n`); process.exit(1) })
+child.on('error', (err) => { safeWrite(process.stderr, `Proxy error: ${err.message}\n`); process.exit(1) })
+
+// Handle parent stdout/stderr EPIPE (broken pipe when dev server restarts)
+process.stdout.on('error', (err) => {
+  if (err.code === 'EPIPE') { child.kill(); process.exit(0) }
+})
+process.stderr.on('error', () => { /* ignore */ })

package/src/lib/server/runtime/run-ledger.ts

@@ -4,6 +4,7 @@ import {
   deleteStoredItem,
   loadRuntimeRun,
   loadRuntimeRunEvents,
+  loadRuntimeRunEventsByRunId,
   loadRuntimeRuns,
   patchRuntimeRun,
   upsertRuntimeRun,
@@ -96,10 +97,9 @@ export function appendPersistedRunEvent(input: {
 
 export function listPersistedRunEvents(runId: string, limit = 1000): RunEventRecord[] {
   const safeLimit = Math.max(1, Math.min(5000, Math.trunc(limit)))
-  return Object.values(loadRuntimeRunEvents())
-    .filter((event) => event.runId === runId)
-    .sort((left, right) => left.timestamp - right.timestamp)
-    .slice(-safeLimit)
+  // Query filtered at SQL level to avoid full-table scan
+  const events = loadRuntimeRunEventsByRunId(runId)
+  return events.slice(-safeLimit)
 }
 
 export function loadRecoverableStaleRuns(): SessionRunRecord[] {

package/src/lib/server/runtime/scheduler.ts

@@ -10,10 +10,13 @@ import { prepareScheduledTaskRun } from '@/lib/server/tasks/task-lifecycle'
 import { ensureAgentThreadSession } from '@/lib/server/agents/agent-thread-session'
 import { ensureMissionForTask, noteScheduleMissionTriggered } from '@/lib/server/missions/mission-service'
 import { hasActiveProtocolRunForSchedule, launchProtocolRunForSchedule } from '@/lib/server/protocols/protocol-service'
+import { hmrSingleton } from '@/lib/shared-utils'
 import type { Schedule } from '@/types'
 
 const TICK_INTERVAL = 60_000 // 60 seconds
-let intervalId: ReturnType<typeof setInterval> | null = null
+const schedulerState = hmrSingleton('__swarmclaw_scheduler_state__', () => ({
+  intervalId: null as ReturnType<typeof setInterval> | null,
+}))
 
 interface ScheduleTaskLike {
   status?: string
@@ -41,19 +44,19 @@ function shouldLaunchScheduleProtocol(schedule: Schedule): boolean {
 }
 
 export function startScheduler() {
-  if (intervalId) return
+  if (schedulerState.intervalId) return
   console.log('[scheduler] Starting scheduler engine (60s tick)')
 
   // Compute initial nextRunAt for cron schedules missing it
   computeNextRuns()
 
-  intervalId = setInterval(tick, TICK_INTERVAL)
+  schedulerState.intervalId = setInterval(tick, TICK_INTERVAL)
 }
 
 export function stopScheduler() {
-  if (intervalId) {
-    clearInterval(intervalId)
-    intervalId = null
+  if (schedulerState.intervalId) {
+    clearInterval(schedulerState.intervalId)
+    schedulerState.intervalId = null
     console.log('[scheduler] Stopped scheduler engine')
   }
 }