@swarmclawai/swarmclaw 0.5.3 → 0.6.2

package/src/lib/server/session-tools/web.ts

@@ -9,6 +9,58 @@ import { spawnSync } from 'child_process'
 import { safePath, truncate, MAX_OUTPUT, findBinaryOnPath } from './context'
 import { getSearchProvider } from './search-providers'
 
+// ---------------------------------------------------------------------------
+// Search result compression — summarize verbose results before injecting into context
+// ---------------------------------------------------------------------------
+
+async function compressSearchResults(
+  results: Array<{ title?: string; url?: string; snippet?: string }>,
+  query: string,
+  bctx: ToolBuildContext,
+): Promise<string | null> {
+  const session = bctx.resolveCurrentSession?.()
+  if (!session?.provider || !session?.model) return null
+
+  const { getProvider } = await import('@/lib/providers')
+  const { loadCredentials, decryptKey } = await import('../storage')
+  const providerEntry = getProvider(session.provider)
+  if (!providerEntry?.handler?.streamChat) return null
+
+  // Resolve API key
+  let apiKey: string | undefined
+  if (session.credentialId) {
+    const creds = loadCredentials()
+    const cred = creds[session.credentialId]
+    if (cred) apiKey = decryptKey(cred)
+  }
+
+  const systemPrompt = 'You are a search result summarizer. Condense search results into a concise reference. Keep key facts, URLs, and data points. Remove filler and redundancy. Output plain text, not JSON.'
+  const message = `Query: "${query}"\n\nResults:\n${JSON.stringify(results, null, 1)}\n\nSummarize these results concisely.`
+
+  let compressed = ''
+  await providerEntry.handler.streamChat({
+    session: { ...session, messages: [] },
+    message,
+    apiKey,
+    systemPrompt,
+    write: (raw: string) => {
+      // Extract text data from SSE lines
+      const lines = raw.split('\n').filter(Boolean)
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue
+        try {
+          const ev = JSON.parse(line.slice(6))
+          if (ev.t === 'd' && ev.text) compressed += ev.text
+        } catch { /* skip */ }
+      }
+    },
+    active: new Map(),
+    loadHistory: () => [],
+  })
+
+  return compressed.trim() || null
+}
+
 // ---------------------------------------------------------------------------
 // Global registry of active browser instances for cleanup sweeps
 // ---------------------------------------------------------------------------
@@ -70,9 +122,18 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
             const settings = loadSettings()
             const provider = await getSearchProvider(settings)
             const results = await provider.search(query, limit)
-            return results.length > 0
-              ? JSON.stringify(results, null, 2)
-              : 'No results found.'
+            if (results.length === 0) return 'No results found.'
+            const raw = JSON.stringify(results, null, 2)
+            // Compress search results if they exceed 2000 chars
+            if (raw.length > 2000) {
+              try {
+                const compressed = await compressSearchResults(results, query, bctx)
+                if (compressed) return compressed
+              } catch {
+                // Compression failed — fall through to raw results
+              }
+            }
+            return raw
           } catch (err: unknown) {
             return `Error searching web: ${err instanceof Error ? err.message : String(err)}`
           }
@@ -284,6 +345,49 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
       return JSON.stringify(result)
     }
 
+    // Best-effort cookie/consent banner dismissal after navigation
+    const dismissCookieBanners = async (
+      mcpCall: (toolName: string, args: Record<string, unknown>) => Promise<string>,
+    ) => {
+      // Wait briefly for consent overlays to appear
+      await new Promise((r) => setTimeout(r, 1500))
+      const js = `
+        (() => {
+          const sel = [
+            // Common "Reject" / "Reject all" / "Decline" buttons
+            'button[id*="reject" i]', 'button[class*="reject" i]',
+            'a[id*="reject" i]', 'a[class*="reject" i]',
+            '[data-testid*="reject" i]', '[data-action="reject"]',
+            // OneTrust
+            '#onetrust-reject-all-handler',
+            // Cookiebot
+            '#CybotCookiebotDialogBodyButtonDecline',
+            // Didomi
+            '#didomi-notice-disagree-button',
+            // Quantcast / IAB TCF
+            '.qc-cmp2-summary-buttons button:first-child',
+            'button.sp_choice_type_12',
+            // Generic patterns
+            'button[aria-label*="reject" i]', 'button[aria-label*="decline" i]',
+            'button[aria-label*="deny" i]', 'button[aria-label*="refuse" i]',
+          ];
+          for (const s of sel) {
+            const el = document.querySelector(s);
+            if (el && el.offsetParent !== null) { el.click(); return 'dismissed:' + s; }
+          }
+          // Fallback: find buttons by visible text
+          const btns = [...document.querySelectorAll('button, a[role="button"], [class*="cookie"] button, [class*="consent"] button, [id*="cookie"] button')];
+          const rejectRe = /^(reject|reject all|decline|deny|refuse|no,? thanks|only necessary|necessary only)$/i;
+          for (const b of btns) {
+            const txt = (b.textContent || '').trim();
+            if (rejectRe.test(txt) && b.offsetParent !== null) { b.click(); return 'dismissed:text=' + txt; }
+          }
+          return 'none';
+        })()
+      `
+      await mcpCall('browser_evaluate', { expression: js })
+    }
+
     // Action-to-MCP tool mapping
     const MCP_TOOL_MAP: Record<string, string> = {
       navigate: 'browser_navigate',
@@ -315,7 +419,14 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
             const saveTo = typeof params.saveTo === 'string' && params.saveTo.trim()
               ? params.saveTo.trim()
               : undefined
-            return await callMcpTool(mcpTool, args, { saveTo })
+            const result = await callMcpTool(mcpTool, args, { saveTo })
+
+            // After navigation, attempt to dismiss cookie consent banners
+            if (action === 'navigate') {
+              try { await dismissCookieBanners(callMcpTool) } catch { /* best-effort */ }
+            }
+
+            return result
           } catch (err: unknown) {
             return `Error: ${err instanceof Error ? err.message : String(err)}`
           }

package/src/lib/server/storage.ts

@@ -20,6 +20,7 @@ const DB_PATH = IS_BUILD_BOOTSTRAP ? ':memory:' : path.join(DATA_DIR, 'swarmclaw
 const db = new Database(DB_PATH)
 if (!IS_BUILD_BOOTSTRAP) {
   db.pragma('journal_mode = WAL')
+  db.pragma('busy_timeout = 5000')
 }
 db.pragma('foreign_keys = ON')
 
@@ -52,6 +53,7 @@ const COLLECTIONS = [
   'activity',
   'webhook_retry_queue',
   'notifications',
+  'chatrooms',
 ] as const
 
 for (const table of COLLECTIONS) {
@@ -284,35 +286,37 @@ if (!IS_BUILD_BOOTSTRAP) {
       description: 'A general-purpose AI assistant',
       provider: 'claude-cli',
       model: '',
-      systemPrompt: `You are the default SwarmClaw assistant. SwarmClaw is a self-hosted AI agent orchestration dashboard.
-
-Help users get started with the platform:
-- **Agents**: Create specialized AI agents (Agents tab → "+"). Each agent has a provider, model, system prompt, and optional tools (shell, files, web search, browser). Use "Generate with AI" to scaffold agents from a description.
-- **Orchestrators**: Toggle "Orchestrator" when creating an agent to let it delegate tasks to other agents. Orchestrators coordinate multi-agent workflows automatically.
-- **Providers**: Configure LLM backends in Settings → Providers. Built-in providers: Claude Code CLI, OpenAI Codex CLI, OpenCode CLI, Anthropic, OpenAI, Google Gemini, DeepSeek, Groq, Together AI, Mistral AI, xAI (Grok), Fireworks AI, Ollama (local or cloud), and OpenClaw. You can also add custom OpenAI-compatible endpoints.
-- **Tasks**: Use the Task Board to create, assign, and track work items. Agents can be assigned to tasks and will execute them autonomously.
-- **Schedules**: Set up cron-based schedules to run agents or tasks on a recurring basis (Schedules tab).
-- **Skills**: Create reusable skill files (markdown instructions) in the Skills tab and attach them to agents to specialize their behavior.
-- **Connectors**: Bridge agents to Discord, Slack, Telegram, or WhatsApp so they can respond in chat platforms.
-- **Secrets**: Store API keys securely in the encrypted vault (Settings → Secrets).
-
-## Platform Tools
-
-You have access to platform management tools. Here's how to use them:
-
-- **manage_agents**: List, create, update, or delete agents. Use action "list" to see all agents, "create" with a JSON data payload to add new ones.
-- **manage_tasks**: Create and manage task board items. Set "agentId" to assign a task to an agent, "status" to track progress (backlog → queued → running → completed/failed). Use action "create" with data like \`{"title": "...", "description": "...", "agentId": "...", "status": "backlog"}\`.
-- **manage_schedules**: Create recurring or one-time scheduled jobs. Set "scheduleType" to "cron", "interval", or "once". Provide "taskPrompt" for what the agent should do and "agentId" for who runs it.
-- **manage_skills**: List, create, or update reusable skill definitions that can be attached to agents.
-- **manage_documents**: Upload/index/search long-lived docs (PDFs, markdown, notes) for retrieval.
-- **manage_webhooks**: Register external webhook endpoints that trigger agent runs.
-- **manage_connectors**: Manage chat platform bridges (Discord, Slack, Telegram, WhatsApp).
-- **manage_sessions**: Session-level operations. Use \`sessions_tool\` to list sessions, send inter-session messages, spawn new agent sessions, and inspect status/history.
-- **manage_secrets**: Store and retrieve encrypted service tokens/API credentials for durable reuse.
-- **memory_tool**: Store and retrieve long-term memories. Use "store" to save knowledge, "search" to find relevant memories.
-
-Be concise and helpful. When users ask how to do something, guide them to the specific UI location and explain the steps.`,
-      soul: '',
+      systemPrompt: `You are the SwarmClaw assistant. SwarmClaw is a self-hosted AI agent orchestration dashboard.
+
+## Platform
+
+- **Agents** — Create specialized AI agents (Agents tab → "+") with a provider, model, system prompt, and tools. "Generate with AI" scaffolds agents from a description. Toggle "Orchestrator" to let an agent delegate work to others.
+- **Providers** — Configure LLM backends in Settings → Providers: Claude Code CLI, OpenAI Codex CLI, OpenCode CLI, Anthropic, OpenAI, Google Gemini, DeepSeek, Groq, Together AI, Mistral AI, xAI (Grok), Fireworks AI, Ollama, OpenClaw, or custom OpenAI-compatible endpoints.
+- **Tasks** — The Task Board tracks work items. Assign agents and they'll execute autonomously.
+- **Schedules** — Cron-based recurring jobs that run agents or tasks automatically.
+- **Skills** — Reusable markdown instruction files you attach to agents to specialize them.
+- **Connectors** — Bridge agents to Discord, Slack, Telegram, or WhatsApp.
+- **Secrets** — Encrypted vault for API keys (Settings → Secrets).
+
+## Tools
+
+Use your platform management tools proactively:
+
+- **manage_agents**: List, create, update, or delete agents.
+- **manage_tasks**: Create and manage task board items. Set status (backlog → queued → running → completed/failed) and assign agents.
+- **manage_schedules**: Create recurring or one-time scheduled jobs with cron expressions or intervals.
+- **manage_skills**: Manage reusable skill definitions.
+- **manage_documents**: Upload, index, and search long-lived documents.
+- **manage_webhooks**: Register webhook endpoints that trigger agent runs.
+- **manage_connectors**: Manage chat platform bridges.
+- **manage_sessions**: List chats, send inter-chat messages, spawn new agent chats.
+- **manage_secrets**: Store and retrieve encrypted credentials.
+- **memory_tool**: Store and retrieve long-term knowledge.`,
+      soul: `You're a knowledgeable, friendly guide who's genuinely enthusiastic about helping people build agent workflows. You adapt your tone to match the conversation — casual when exploring, precise when debugging, encouraging when learning.
+
+You have opinions about good agent design. You suggest creative approaches, warn about common pitfalls, and get excited when someone gets something cool working. You're not a manual — you're a collaborator.
+
+Be concise but not curt. Warmth doesn't require verbosity. When someone asks "how do I...?", give them the direct steps. Offer to do things rather than just explaining — if someone wants an agent created, create it. Use your tools when actions speak louder than words. If you don't know something, say so honestly.`,
       isOrchestrator: false,
       tools: defaultStarterTools,
       heartbeatEnabled: true,
@@ -691,6 +695,15 @@ export function saveConnectors(c: Record<string, any>) {
   saveCollection('connectors', c)
 }
 
+// --- Chatrooms ---
+export function loadChatrooms(): Record<string, any> {
+  return loadCollection('chatrooms')
+}
+
+export function saveChatrooms(c: Record<string, any>) {
+  saveCollection('chatrooms', c)
+}
+
 // --- Documents ---
 export function loadDocuments(): Record<string, any> {
   return loadCollection('documents')
@@ -789,6 +802,17 @@ export function deleteNotification(id: string) {
   deleteCollectionItem('notifications', id)
 }
 
+export function hasUnreadNotificationWithKey(dedupKey: string): boolean {
+  const raw = getCollectionRawCache('notifications')
+  for (const json of raw.values()) {
+    try {
+      const n = JSON.parse(json) as Record<string, unknown>
+      if (n.dedupKey === dedupKey && n.read !== true) return true
+    } catch { /* skip malformed */ }
+  }
+  return false
+}
+
 export function markNotificationRead(id: string) {
   const raw = getCollectionRawCache('notifications')
   const json = raw.get(id)

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

@@ -9,9 +9,24 @@ import { getPluginManager } from './plugins'
 import { loadRuntimeSettings, getAgentLoopRecursionLimit } from './runtime-settings'
 import { getMemoryDb } from './memory-db'
 import { logExecution } from './execution-log'
+import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
 import type { Session, Message, UsageRecord } from '@/types'
 import { extractSuggestions } from './suggestions'
 
+/** Extract a breadcrumb title from notable tool completions (task/schedule/agent creation). */
+function extractBreadcrumbTitle(toolName: string, input: unknown, output: string | undefined): string | null {
+  if (!input || typeof input !== 'object') return null
+  const inp = input as Record<string, unknown>
+  const action = typeof inp.action === 'string' ? inp.action : ''
+  if (toolName === 'manage_tasks') {
+    if (action === 'create') return `Created task: ${inp.title || 'Untitled'}`
+    if (output && /status.*completed|completed.*successfully/i.test(output)) return `Completed task: ${inp.title || inp.taskId || 'unknown'}`
+  }
+  if (toolName === 'manage_schedules' && action === 'create') return `Created schedule: ${inp.name || 'Untitled'}`
+  if (toolName === 'manage_agents' && action === 'create') return `Created agent: ${inp.name || 'Untitled'}`
+  return null
+}
+
 interface StreamAgentChatOpts {
   session: Session
   message: string
@@ -25,7 +40,7 @@ interface StreamAgentChatOpts {
   signal?: AbortSignal
 }
 
-function buildToolCapabilityLines(enabledTools: string[]): string[] {
+function buildToolCapabilityLines(enabledTools: string[], opts?: { platformAssignScope?: 'self' | 'all' }): string[] {
   const lines: string[] = []
   if (enabledTools.includes('shell')) lines.push('- Shell execution is available (`execute_command`). Use it for running servers, installing deps, running scripts, git commands, build/test steps, and any single or chained shell commands. Supports background mode for long-running processes like dev servers.')
   if (enabledTools.includes('process')) lines.push('- Process control is available (`process_tool`) for long-running commands (poll/log/write/kill).')
@@ -52,9 +67,12 @@ function buildToolCapabilityLines(enabledTools: string[]): string[] {
   // Context tools are available to any session with tools (not just manage_sessions)
   if (enabledTools.length > 0) {
     lines.push('- Context management is available (`context_status`, `context_summarize`). Use `context_status` to check token usage and `context_summarize` to compact conversation history when approaching limits.')
-    lines.push('- Agent delegation is available (`delegate_to_agent`). Use it to assign tasks to other agents based on their capabilities.')
+    if (opts?.platformAssignScope === 'all') {
+      lines.push('- Agent delegation is available (`delegate_to_agent`). Use it to assign tasks to other agents based on their capabilities.')
+    }
   }
   if (enabledTools.includes('manage_secrets')) lines.push('- Secret management is available (`manage_secrets`) for durable encrypted credentials and API tokens.')
+  if (enabledTools.includes('manage_chatrooms')) lines.push('- Chatroom management is available (`manage_chatrooms`) for multi-agent collaborative chatrooms with @mention-based interactions.')
   return lines
 }
 
@@ -63,9 +81,10 @@ function buildAgenticExecutionPolicy(opts: {
   loopMode: 'bounded' | 'ongoing'
   heartbeatPrompt: string
   heartbeatIntervalSec: number
+  platformAssignScope?: 'self' | 'all'
 }) {
   const hasTooling = opts.enabledTools.length > 0
-  const toolLines = buildToolCapabilityLines(opts.enabledTools)
+  const toolLines = buildToolCapabilityLines(opts.enabledTools, { platformAssignScope: opts.platformAssignScope })
   const delegationOrder = [
     opts.enabledTools.includes('claude_code') ? '`delegate_to_claude_code`' : null,
     opts.enabledTools.includes('codex_cli') ? '`delegate_to_codex_cli`' : null,
@@ -209,6 +228,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     stateModifierParts.push(systemPrompt!.trim())
   } else {
     if (settings.userPrompt) stateModifierParts.push(settings.userPrompt)
+    stateModifierParts.push(buildCurrentDateTimePromptContext())
   }
 
   // Load agent context when a full prompt was not already composed by the route layer.
@@ -260,57 +280,92 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
           .map((h) => h.text),
       ].join('\n')
 
-      const relevantLookup = memDb.searchWithLinked(memoryQuerySeed, session.agentId, 1, 10, 14)
-      const relevant = relevantLookup.entries.slice(0, 6)
-      const recent = memDb.list(session.agentId, 12).slice(0, 6)
-
       const seen = new Set<string>()
-      const formatMemoryLine = (m: any) => {
+      const formatMemoryLine = (m: { category?: string; title?: string; content?: string; pinned?: boolean }) => {
         const category = String(m.category || 'note')
         const title = String(m.title || 'Untitled').replace(/\s+/g, ' ').trim()
         const snippet = String(m.content || '').replace(/\s+/g, ' ').trim().slice(0, 220)
-        return `- [${category}] ${title}: ${snippet}`
+        const pin = m.pinned ? ' [pinned]' : ''
+        return `- [${category}]${pin} ${title}: ${snippet}`
       }
 
+      // Pinned memories always appear first
+      const pinned = memDb.listPinned(session.agentId, 5)
+      const pinnedLines = pinned
+        .filter((m) => { if (!m?.id || seen.has(m.id)) return false; seen.add(m.id); return true })
+        .map(formatMemoryLine)
+
+      // Reduce relevant slice by pinned count to keep total context bounded
+      const relevantSlice = Math.max(2, 6 - pinnedLines.length)
+      const relevantLookup = memDb.searchWithLinked(memoryQuerySeed, session.agentId, 1, 10, 14)
+      const relevant = relevantLookup.entries.slice(0, relevantSlice)
+      const recent = memDb.list(session.agentId, 12).slice(0, 6)
+
       const relevantLines = relevant
-        .filter((m) => {
-          if (!m?.id || seen.has(m.id)) return false
-          seen.add(m.id)
-          return true
-        })
+        .filter((m) => { if (!m?.id || seen.has(m.id)) return false; seen.add(m.id); return true })
         .map(formatMemoryLine)
 
       const recentLines = recent
-        .filter((m) => {
-          if (!m?.id || seen.has(m.id)) return false
-          seen.add(m.id)
-          return true
-        })
+        .filter((m) => { if (!m?.id || seen.has(m.id)) return false; seen.add(m.id); return true })
         .map(formatMemoryLine)
 
       const memorySections: string[] = []
+      if (pinnedLines.length) {
+        memorySections.push(
+          ['## Pinned Memories', 'Always-loaded memories marked as important.', ...pinnedLines].join('\n'),
+        )
+      }
       if (relevantLines.length) {
         memorySections.push(
-          [
-            '## Relevant Memory Hits',
-            'These memories were retrieved by relevance for the current objective.',
-            ...relevantLines,
-          ].join('\n'),
+          ['## Relevant Memory Hits', 'These memories were retrieved by relevance for the current objective.', ...relevantLines].join('\n'),
         )
       }
       if (recentLines.length) {
         memorySections.push(
-          [
-            '## Recent Memory Notes',
-            'Recent durable notes that may still apply.',
-            ...recentLines,
-          ].join('\n'),
+          ['## Recent Memory Notes', 'Recent durable notes that may still apply.', ...recentLines].join('\n'),
         )
       }
 
       if (memorySections.length) {
         stateModifierParts.push(memorySections.join('\n\n'))
       }
+
+      // Memory Policy — always injected when memory tool is available
+      stateModifierParts.push([
+        '## Memory Policy',
+        'You have long-term memory. Use it proactively — do not wait to be asked.',
+        '',
+        '**Store memories for:**',
+        '- User preferences, corrections, or explicit "remember this" requests',
+        '- Key decisions or outcomes from complex tasks',
+        '- Discovered facts about projects, codebases, or environments',
+        '- Errors encountered and their solutions',
+        '- Relationship context (who is who, team dynamics)',
+        '- Important configuration details or environment specifics',
+        '',
+        '**Do NOT store:**',
+        '- Trivial acknowledgments or small talk',
+        '- Temporary in-progress work (use category "working" for ephemeral notes)',
+        '- Information already in your system prompt',
+        '- Exact duplicates of memories you already have',
+        '',
+        '**Best practices:**',
+        '- Use descriptive titles ("User prefers dark mode" not "Note 1")',
+        '- Use categories: preference, fact, learning, project, identity, decision',
+        '- Search memory before storing to avoid duplicates',
+        '- When correcting old knowledge, update or delete the old memory',
+      ].join('\n'))
+
+      // Pre-compaction memory flush: nudge agent to persist learnings when conversation is long
+      const msgCount = history.filter(m => m.role === 'user' || m.role === 'assistant').length
+      if (msgCount > 20) {
+        stateModifierParts.push([
+          '## Memory Flush Reminder',
+          'This conversation is getting long. Before context is trimmed, store any important',
+          'learnings, decisions, or facts as memories now. Only store what is significant and durable —',
+          'skip trivial details. If nothing needs storing, continue normally.',
+        ].join('\n'))
+      }
     } catch {
       // If memory context fails to load, continue without blocking the run.
     }
@@ -347,15 +402,17 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     }
   }
 
-  stateModifierParts.push(
-    [
-      '## Follow-up Suggestions',
-      'At the end of every response, include a <suggestions> block with exactly 3 short',
-      'follow-up prompts the user might want to send next, as a JSON array. Keep each under 60 chars.',
-      'Make them contextual to what you just said. Example:',
-      '<suggestions>["Set up a Discord connector", "Create a research agent", "Show the task board"]</suggestions>',
-    ].join('\n'),
-  )
+  if (settings.suggestionsEnabled !== false) {
+    stateModifierParts.push(
+      [
+        '## Follow-up Suggestions',
+        'At the end of every response, include a <suggestions> block with exactly 3 short',
+        'follow-up prompts the user might want to send next, as a JSON array. Keep each under 60 chars.',
+        'Make them contextual to what you just said. Example:',
+        '<suggestions>["Set up a Discord connector", "Create a research agent", "Show the task board"]</suggestions>',
+      ].join('\n'),
+    )
+  }
 
   stateModifierParts.push(
     buildAgenticExecutionPolicy({
@@ -363,6 +420,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
       loopMode: runtime.loopMode,
       heartbeatPrompt,
       heartbeatIntervalSec,
+      platformAssignScope: agentPlatformAssignScope,
     }),
   )
 
@@ -463,24 +521,49 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
   // Auto-compaction: prune old history if approaching context window limit
   let effectiveHistory = history
   try {
-    const { shouldAutoCompact, consolidateToMemory, slidingWindowCompact, estimateTokens } = await import('./context-manager')
+    const { shouldAutoCompact, llmCompact, estimateTokens } = await import('./context-manager')
     const systemPromptTokens = estimateTokens(stateModifier)
     if (shouldAutoCompact(history, systemPromptTokens, session.provider, session.model)) {
-      // Consolidate important old messages to memory before pruning
-      const oldMessages = history.slice(0, -10)
-      if (oldMessages.length > 0 && session.agentId) {
-        consolidateToMemory(oldMessages, session.agentId, session.id)
+      const summarize = async (prompt: string): Promise<string> => {
+        const response = await llm.invoke([new HumanMessage(prompt)])
+        if (typeof response.content === 'string') return response.content
+        if (Array.isArray(response.content)) {
+          return response.content
+            .map((b: Record<string, unknown>) => (typeof b.text === 'string' ? b.text : ''))
+            .join('')
+        }
+        return ''
       }
-      // Keep last 10 messages via sliding window
-      effectiveHistory = slidingWindowCompact(history, 10)
-      console.log(`[stream-agent-chat] Auto-compacted session ${session.id}: ${history.length} → ${effectiveHistory.length} messages`)
+      const result = await llmCompact({
+        messages: history,
+        provider: session.provider,
+        model: session.model,
+        agentId: session.agentId || null,
+        sessionId: session.id,
+        summarize,
+      })
+      effectiveHistory = result.messages
+      console.log(
+        `[stream-agent-chat] Auto-compacted ${session.id}: ${history.length} → ${effectiveHistory.length} msgs` +
+        (result.summaryAdded ? ' (LLM summary)' : ' (sliding window fallback)'),
+      )
     }
   } catch {
-    // If context manager fails, continue with full history
+    // Context manager failure — continue with full history
   }
 
+  // Apply context-clear boundary: slice from most recent context-clear marker
+  let contextStart = 0
+  for (let i = effectiveHistory.length - 1; i >= 0; i--) {
+    if (effectiveHistory[i].kind === 'context-clear') {
+      contextStart = i + 1
+      break
+    }
+  }
+  const postClearHistory = effectiveHistory.slice(contextStart)
+
   const langchainMessages: Array<HumanMessage | AIMessage> = []
-  for (const m of effectiveHistory.slice(-20)) {
+  for (const m of postClearHistory.slice(-20)) {
     if (m.role === 'user') {
       langchainMessages.push(new HumanMessage({ content: await buildLangChainContent(m.text, m.imagePath, m.attachedFiles) }))
     } else {
@@ -497,6 +580,8 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
   let hasToolCalls = false
   let totalInputTokens = 0
   let totalOutputTokens = 0
+  let lastToolInput: unknown = null
+  let accumulatedThinking = ''
 
   // Plugin hooks: beforeAgentStart
   const pluginMgr = getPluginManager()
@@ -529,15 +614,29 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
         const chunk = event.data?.chunk
         if (chunk?.content) {
           // content can be string or array of content blocks
-          const text = typeof chunk.content === 'string'
-            ? chunk.content
-            : Array.isArray(chunk.content)
-              ? chunk.content.map((c: any) => c.text || '').join('')
-              : ''
-          if (text) {
-            fullText += text
-            lastSegment += text
-            write(`data: ${JSON.stringify({ t: 'd', text })}\n\n`)
+          if (Array.isArray(chunk.content)) {
+            for (const block of chunk.content) {
+              // Anthropic extended thinking blocks
+              if (block.type === 'thinking' && block.thinking) {
+                accumulatedThinking += block.thinking
+                write(`data: ${JSON.stringify({ t: 'thinking', text: block.thinking })}\n\n`)
+              // OpenClaw [[thinking]] prefix convention
+              } else if (typeof block.text === 'string' && block.text.startsWith('[[thinking]]')) {
+                accumulatedThinking += block.text.slice(12)
+                write(`data: ${JSON.stringify({ t: 'thinking', text: block.text.slice(12) })}\n\n`)
+              } else if (block.text) {
+                fullText += block.text
+                lastSegment += block.text
+                write(`data: ${JSON.stringify({ t: 'd', text: block.text })}\n\n`)
+              }
+            }
+          } else {
+            const text = typeof chunk.content === 'string' ? chunk.content : ''
+            if (text) {
+              fullText += text
+              lastSegment += text
+              write(`data: ${JSON.stringify({ t: 'd', text })}\n\n`)
+            }
           }
         }
       } else if (kind === 'on_llm_end') {
@@ -554,6 +653,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
         lastSegment = ''
         const toolName = event.name || 'unknown'
         const input = event.data?.input
+        lastToolInput = input
         // Plugin hooks: beforeToolExec
         await pluginMgr.runHook('beforeToolExec', { toolName, input })
         const inputStr = typeof input === 'string' ? input : JSON.stringify(input)
@@ -576,6 +676,23 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
             : JSON.stringify(output)
         // Plugin hooks: afterToolExec
         await pluginMgr.runHook('afterToolExec', { toolName, input: null, output: outputStr })
+        // Event-driven memory breadcrumbs
+        if (session.agentId && (session.tools || []).includes('memory')) {
+          try {
+            const breadcrumbTitle = extractBreadcrumbTitle(toolName, lastToolInput, outputStr)
+            if (breadcrumbTitle) {
+              const memDb = getMemoryDb()
+              memDb.add({
+                agentId: session.agentId,
+                sessionId: session.id,
+                category: 'breadcrumb',
+                title: breadcrumbTitle,
+                content: '',
+              })
+            }
+          } catch { /* breadcrumbs are best-effort */ }
+        }
+        lastToolInput = null
         logExecution(session.id, 'tool_result', `${toolName} returned`, {
           agentId: session.agentId,
           detail: { toolName, output: outputStr?.slice(0, 4000), error: /^(Error:|error:)/i.test((outputStr || '').trim()) || undefined },
@@ -617,6 +734,12 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     if (signal) signal.removeEventListener('abort', abortFromSignal)
   }
 
+  // Skip post-stream work if the client disconnected mid-stream
+  if (signal?.aborted) {
+    await cleanup()
+    return { fullText, finalResponse: fullText }
+  }
+
   // Extract LLM-generated suggestions from the response and strip the tag
   const extracted = extractSuggestions(fullText)
   fullText = extracted.clean
@@ -624,6 +747,11 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     write(`data: ${JSON.stringify({ t: 'md', text: JSON.stringify({ suggestions: extracted.suggestions }) })}\n\n`)
   }
 
+  // Emit full thinking text as metadata so the client can persist it
+  if (accumulatedThinking) {
+    write(`data: ${JSON.stringify({ t: 'md', text: JSON.stringify({ thinking: accumulatedThinking }) })}\n\n`)
+  }
+
   // Track cost
   const totalTokens = totalInputTokens + totalOutputTokens
   if (totalTokens > 0) {