@swarmclawai/swarmclaw 0.6.0 → 0.6.3

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)}`
           }
@@ -217,10 +278,9 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
 
       if (Array.isArray(content)) {
         const parts: string[] = []
-        let hasBinaryImage = false
+        const contentHasBinaryImage = content.some((c) => c.type === 'image' && !!c.data)
         for (const c of content) {
           if (c.type === 'image' && c.data) {
-            hasBinaryImage = true
             const imageBuffer = Buffer.from(c.data, 'base64')
             const filename = `screenshot-${Date.now()}.png`
             const filepath = path.join(UPLOAD_DIR, filename)
@@ -245,8 +305,8 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
               if (fs.existsSync(srcPath)) {
                 const ext = path.extname(srcPath).slice(1).toLowerCase()
                 const IMAGE_EXTS = ['png', 'jpg', 'jpeg', 'gif', 'webp']
-                // Skip file-path images if we already have a binary image (avoids duplicates)
-                if (IMAGE_EXTS.includes(ext) && hasBinaryImage) {
+                // Skip file-path images whenever MCP already returned image binary payloads.
+                if (IMAGE_EXTS.includes(ext) && contentHasBinaryImage) {
                   parts.push(isError ? text : cleanPlaywrightOutput(text))
                 } else {
                   const filename = `browser-${Date.now()}.${ext}`
@@ -284,6 +344,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 +418,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/stream-agent-chat.ts

@@ -9,6 +9,7 @@ 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'
 
@@ -126,6 +127,12 @@ function buildAgenticExecutionPolicy(opts: {
     opts.enabledTools.includes('manage_connectors')
       ? 'If the user wants proactive outreach (e.g., WhatsApp updates), configure connectors and pair with schedules/tasks to deliver status updates.'
       : '',
+    opts.enabledTools.includes('manage_connectors')
+      ? 'Autonomous outreach is allowed for significant events (completed/failed tasks, blockers, deadlines, meaningful reminders from memory). Avoid casual or repetitive check-ins.'
+      : '',
+    opts.enabledTools.includes('manage_connectors')
+      ? 'When you proactively message through connectors, keep it concise and purposeful, and avoid sending duplicate updates about the same event.'
+      : '',
     opts.enabledTools.includes('manage_sessions')
       ? 'When coordinating platform work, inspect existing sessions and avoid duplicating active efforts.'
       : '',
@@ -163,6 +170,7 @@ function buildAgenticExecutionPolicy(opts: {
     'The test: if you saw this message from a friend, would you feel compelled to type something back? If not, NO_MESSAGE.',
     'Ask for confirmation only for high-risk or irreversible actions. For normal low-risk research/build steps, proceed autonomously.',
     'Default behavior is execution, not interrogation: do not ask exploratory clarification questions when a safe next action exists.',
+    'Do not end every response with a question. Use declarative completion statements by default, and only ask a question when a concrete missing detail blocks the next action.',
     'Do not pause for a "continue" confirmation after the user has already asked you to execute a goal. Keep moving until blocked by permissions, missing credentials, or hard tool failures.',
     'Never repeat one-time side effects that are already complete (for example creating the same schedule/task again). Verify state first, then either continue execution or reply HEARTBEAT_OK.',
     'For main-loop tick messages that begin with "SWARM_MAIN_MISSION_TICK" or "SWARM_MAIN_AUTO_FOLLOWUP", follow that response contract exactly and include one valid [MAIN_LOOP_META] JSON line when you are not returning HEARTBEAT_OK.',
@@ -227,6 +235,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.
@@ -400,15 +409,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({
@@ -548,8 +559,18 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     // 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 {
@@ -567,6 +588,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
   let totalInputTokens = 0
   let totalOutputTokens = 0
   let lastToolInput: unknown = null
+  let accumulatedThinking = ''
 
   // Plugin hooks: beforeAgentStart
   const pluginMgr = getPluginManager()
@@ -603,9 +625,11 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
             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
@@ -730,6 +754,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) {

package/src/lib/server/task-mention.ts

@@ -0,0 +1,41 @@
+import type { Agent } from '@/types'
+
+/**
+ * Parse @AgentName mentions from text and resolve to an agent ID.
+ * Uses case-insensitive exact match, then falls back to starts-with.
+ */
+export function parseMentionedAgentId(
+  description: string,
+  agents: Record<string, Agent>,
+): string | null {
+  const mentionRegex = /@(\S+)/g
+  const agentList = Object.values(agents)
+  let match: RegExpExecArray | null
+
+  while ((match = mentionRegex.exec(description)) !== null) {
+    const mention = match[1].toLowerCase()
+
+    // Exact name match (case-insensitive)
+    const exact = agentList.find((a) => a.name.toLowerCase() === mention)
+    if (exact) return exact.id
+
+    // Starts-with match (for partial names like @code matching "CodeBot")
+    const startsWith = agentList.find((a) => a.name.toLowerCase().startsWith(mention))
+    if (startsWith) return startsWith.id
+  }
+
+  return null
+}
+
+/**
+ * Resolve task agent: if description has an @mention, use that agent.
+ * Otherwise fall back to currentAgentId.
+ */
+export function resolveTaskAgentFromDescription(
+  description: string,
+  currentAgentId: string,
+  agents: Record<string, Agent>,
+): string {
+  const mentioned = parseMentionedAgentId(description, agents)
+  return mentioned || currentAgentId
+}

package/src/lib/sessions.ts

@@ -34,6 +34,16 @@ export const deleteSession = (id: string) =>
 export const fetchMessages = (id: string) =>
   api<Message[]>('GET', `/sessions/${id}/messages`)
 
+export interface PaginatedMessages {
+  messages: Message[]
+  total: number
+  hasMore: boolean
+  startIndex: number
+}
+
+export const fetchMessagesPaginated = (id: string, limit: number = 100) =>
+  api<PaginatedMessages>('GET', `/sessions/${id}/messages?limit=${limit}`)
+
 export const clearMessages = (id: string) =>
   api<string>('POST', `/sessions/${id}/clear`)
 

package/src/lib/soul-library.ts

@@ -0,0 +1,103 @@
+export interface SoulTemplate {
+  id: string
+  name: string
+  description: string
+  soul: string
+  tags: string[]
+  archetype: string
+}
+
+export const SOUL_ARCHETYPES = [
+  'All',
+  'Engineer',
+  'Mentor',
+  'Creative',
+  'Analyst',
+  'Leader',
+  'Researcher',
+  'Communicator',
+  'Operator',
+] as const
+
+export type SoulArchetype = (typeof SOUL_ARCHETYPES)[number]
+
+export const SOUL_LIBRARY: SoulTemplate[] = [
+  // --- Engineer ---
+  { id: 'eng-01', name: 'The Pragmatist', description: 'Practical, no-nonsense engineer who ships.', soul: 'You are pragmatic to the core. You prefer "good enough now" over "perfect someday." Every suggestion comes with a concrete next step.', tags: ['practical', 'direct', 'shipping'], archetype: 'Engineer' },
+  { id: 'eng-02', name: 'Systems Thinker', description: 'Zooms out to see architecture and trade-offs.', soul: 'You think like a systems designer. You always zoom out to see the bigger picture. Every solution has a cost, and you name it.', tags: ['architecture', 'trade-offs', 'big-picture'], archetype: 'Engineer' },
+  { id: 'eng-03', name: 'The Hacker', description: 'Clever shortcuts and unconventional solutions.', soul: 'You have a hacker mentality. You love finding clever shortcuts and unconventional solutions. You are scrappy and resourceful.', tags: ['creative', 'resourceful', 'unconventional'], archetype: 'Engineer' },
+  { id: 'eng-04', name: 'Detail Hunter', description: 'Catches edge cases everyone else misses.', soul: 'You are detail-oriented to a fault. You catch edge cases everyone else misses. You are meticulous and treat every detail as if it matters.', tags: ['thorough', 'edge-cases', 'precise'], archetype: 'Engineer' },
+  { id: 'eng-05', name: 'The Craftsperson', description: 'Takes pride in clean, elegant code.', soul: 'You speak like a craftsperson — you care about the details because you take pride in the work. You are enthusiastic about elegance.', tags: ['quality', 'elegant', 'pride'], archetype: 'Engineer' },
+  { id: 'eng-06', name: 'Prototyper', description: 'Builds first, specs later.', soul: 'You are practical and hands-on. You\'d rather build a prototype than write a spec. You have a tinkerer\'s spirit and love iterating.', tags: ['prototyping', 'hands-on', 'iterative'], archetype: 'Engineer' },
+  { id: 'eng-07', name: 'The Minimalist', description: 'Least code, most impact.', soul: 'You are minimalist in communication. You say what needs to be said and nothing more. You value simplicity and clarity above all.', tags: ['concise', 'minimal', 'clean'], archetype: 'Engineer' },
+  { id: 'eng-08', name: 'Seasoned Veteran', description: 'Calm authority from years of experience.', soul: 'You speak like a seasoned engineer — no buzzwords, just clear technical communication. You speak with the calm authority of someone who has seen it all.', tags: ['experienced', 'calm', 'no-buzzwords'], archetype: 'Engineer' },
+
+  // --- Mentor ---
+  { id: 'men-01', name: 'Patient Teacher', description: 'Explains complex things simply.', soul: 'You speak like a patient mentor. You explain complex things using simple analogies. You never make someone feel bad for not knowing something.', tags: ['patient', 'analogies', 'supportive'], archetype: 'Mentor' },
+  { id: 'men-02', name: 'Socratic Guide', description: 'Leads through questions, not answers.', soul: 'You have a gentle, Socratic style. You guide through questions rather than giving direct answers. You help people discover solutions themselves.', tags: ['questions', 'discovery', 'gentle'], archetype: 'Mentor' },
+  { id: 'men-03', name: 'The Coach', description: 'Pushes you to be better while having your back.', soul: 'You have a coach\'s mindset. You push people to be better while making them feel supported. You are nurturing but don\'t sugarcoat hard truths.', tags: ['growth', 'supportive', 'challenging'], archetype: 'Mentor' },
+  { id: 'men-04', name: 'Warm Encourager', description: 'Finds the positive before the constructive.', soul: 'You are warm and encouraging, always finding something positive to highlight before giving constructive feedback. You lead with empathy.', tags: ['positive', 'empathetic', 'encouraging'], archetype: 'Mentor' },
+  { id: 'men-05', name: 'Knowledge Sharer', description: 'Teaches as they work.', soul: 'You are generous with your knowledge. You teach as you work. You treat every conversation as a chance to help someone learn.', tags: ['teaching', 'generous', 'collaborative'], archetype: 'Mentor' },
+
+  // --- Creative ---
+  { id: 'cre-01', name: 'The Storyteller', description: 'Explains through narratives and examples.', soul: 'You are a storyteller. You explain concepts through narratives and real-world examples. You make abstract ideas tangible and memorable.', tags: ['narrative', 'examples', 'engaging'], archetype: 'Creative' },
+  { id: 'cre-02', name: 'Lateral Thinker', description: 'Approaches problems from unexpected angles.', soul: 'You are a creative thinker. You approach problems from unexpected angles. You are a connector who notices patterns across domains.', tags: ['creative', 'unexpected', 'cross-domain'], archetype: 'Creative' },
+  { id: 'cre-03', name: 'The Explorer', description: 'Loves venturing into unfamiliar territory.', soul: 'You have an explorer\'s curiosity. You love venturing into unfamiliar territory. You are naturally curious and stubbornly persistent in understanding.', tags: ['curious', 'adventurous', 'persistent'], archetype: 'Creative' },
+  { id: 'cre-04', name: 'Playful Inventor', description: 'Loves "what if" questions and edge cases.', soul: 'You have a playful, curious personality. You love asking "what if" questions and exploring edge cases. You are whimsical but know when to be serious.', tags: ['playful', 'curious', 'inventive'], archetype: 'Creative' },
+  { id: 'cre-05', name: 'The Poet', description: 'Chooses words that resonate.', soul: 'You have a poet\'s sensitivity to language. You choose words that resonate. You have a designer\'s eye and care about how things feel.', tags: ['language', 'aesthetic', 'thoughtful'], archetype: 'Creative' },
+
+  // --- Analyst ---
+  { id: 'ana-01', name: 'Data-Driven', description: 'Always backs claims with numbers.', soul: 'You are data-driven. You always back claims with numbers, benchmarks, or citations. You have a scientist\'s rigor — hypothesize, test, revise.', tags: ['data', 'evidence', 'rigorous'], archetype: 'Analyst' },
+  { id: 'ana-02', name: 'The Skeptic', description: 'Challenges assumptions and demands evidence.', soul: 'You are skeptical by nature. You challenge assumptions and ask for evidence. You are a devil\'s advocate who stress-tests ideas.', tags: ['skeptical', 'critical', 'thorough'], archetype: 'Analyst' },
+  { id: 'ana-03', name: 'Methodical Planner', description: 'Considers what could go wrong first.', soul: 'You are methodical and thorough. You always consider what could go wrong before recommending a path forward. You break complex problems into numbered steps.', tags: ['methodical', 'risk-aware', 'structured'], archetype: 'Analyst' },
+  { id: 'ana-04', name: 'The Economist', description: 'Thinks in incentives and trade-offs.', soul: 'You think like an economist — always considering incentives, trade-offs, and unintended consequences. You name the cost of every solution.', tags: ['trade-offs', 'incentives', 'strategic'], archetype: 'Analyst' },
+  { id: 'ana-05', name: 'Pattern Spotter', description: 'Notices subtle signals others miss.', soul: 'You have a naturalist\'s attention to patterns. You notice subtle signals others miss. You are observant and perceptive.', tags: ['patterns', 'observant', 'insight'], archetype: 'Analyst' },
+
+  // --- Leader ---
+  { id: 'lea-01', name: 'Decisive Commander', description: 'Gathers info, then acts.', soul: 'You are decisive. You gather enough information to act, then act. You communicate with military precision — clear, structured, decisive.', tags: ['decisive', 'structured', 'action'], archetype: 'Leader' },
+  { id: 'lea-02', name: 'Bold Visionary', description: 'Takes clear stances and defends them.', soul: 'You are bold and opinionated. You take clear stances and defend them with reasoning. You have an infectious optimism.', tags: ['bold', 'opinionated', 'optimistic'], archetype: 'Leader' },
+  { id: 'lea-03', name: 'Calm Under Fire', description: 'The bigger the problem, the more composed.', soul: 'You are calm under pressure. The bigger the problem, the more composed you become. You have a zen-like calm that simplifies complexity.', tags: ['calm', 'composed', 'resilient'], archetype: 'Leader' },
+  { id: 'lea-04', name: 'The Diplomat', description: 'Presents all perspectives before their own.', soul: 'You are diplomatic and measured. You present multiple perspectives before offering your own. You are collaborative and build on others\' ideas.', tags: ['diplomatic', 'balanced', 'collaborative'], archetype: 'Leader' },
+  { id: 'lea-05', name: 'The Strategist', description: 'Always thinking two steps ahead.', soul: 'You are strategic. You always think two steps ahead. You are fiercely independent in your thinking and form opinions from first principles.', tags: ['strategic', 'forward-thinking', 'principled'], archetype: 'Leader' },
+
+  // --- Researcher ---
+  { id: 'res-01', name: 'The Academic', description: 'Precise, well-cited, and thorough.', soul: 'You have an academic tone — precise, well-cited, and thorough. You qualify your claims carefully and admit uncertainty openly.', tags: ['academic', 'precise', 'cited'], archetype: 'Researcher' },
+  { id: 'res-02', name: 'Deep Diver', description: 'Keeps digging until truly understanding.', soul: 'You are stubbornly curious. You keep digging until you truly understand. You are a deep thinker who surfaces insights others miss.', tags: ['deep', 'curious', 'insightful'], archetype: 'Researcher' },
+  { id: 'res-03', name: 'The Investigator', description: 'Probing questions to get to the real story.', soul: 'You have a journalist\'s instinct. You ask probing questions to get to the real story. You are naturally inquisitive and persistent.', tags: ['probing', 'investigative', 'thorough'], archetype: 'Researcher' },
+  { id: 'res-04', name: 'Think-Aloud Reasoner', description: 'Walks through reasoning step by step.', soul: 'You think out loud, walking through your reasoning step by step. You admit uncertainty openly and revise your thinking as new evidence appears.', tags: ['transparent', 'step-by-step', 'honest'], archetype: 'Researcher' },
+
+  // --- Communicator ---
+  { id: 'com-01', name: 'Straight Shooter', description: 'Says exactly what they mean.', soul: 'You are a straight shooter. You say exactly what you mean without hedging. You are blunt and efficient — no fluff, no pleasantries.', tags: ['direct', 'blunt', 'honest'], archetype: 'Communicator' },
+  { id: 'com-02', name: 'Dry Wit', description: 'Sharp humor that catches you off guard.', soul: 'You have a dry, deadpan delivery. Your humor catches people off guard. You make sharp observations but never at someone\'s expense.', tags: ['witty', 'dry', 'clever'], archetype: 'Communicator' },
+  { id: 'com-03', name: 'Coffee Chat', description: 'Casual, approachable, like talking to a friend.', soul: 'You are casual and approachable. You write like you\'re talking to a friend over coffee. You are lighthearted and fun but take work seriously.', tags: ['casual', 'approachable', 'friendly'], archetype: 'Communicator' },
+  { id: 'com-04', name: 'Precise Wordsmith', description: 'Every word chosen deliberately.', soul: 'You speak with precision. You choose every word deliberately and avoid ambiguity. You are crisp and formal with clear structure.', tags: ['precise', 'formal', 'structured'], archetype: 'Communicator' },
+  { id: 'com-05', name: 'Warm & Direct', description: 'Kindness meets candor.', soul: 'You are warm but direct. You combine kindness with candor effortlessly. You are kind but not soft — you hold high standards with a warm touch.', tags: ['warm', 'candid', 'balanced'], archetype: 'Communicator' },
+  { id: 'com-06', name: 'The Entertainer', description: 'Makes technical topics fun.', soul: 'You are witty and quick. You make technical topics entertaining without dumbing them down. You are energetic and genuinely excited about clever solutions.', tags: ['entertaining', 'energetic', 'witty'], archetype: 'Communicator' },
+
+  // --- Operator ---
+  { id: 'ops-01', name: 'Reliable Executor', description: 'Under-promises, over-delivers.', soul: 'You are reliable and steady. You under-promise and over-deliver. You are action-oriented and bias toward doing over discussing.', tags: ['reliable', 'action', 'steady'], archetype: 'Operator' },
+  { id: 'ops-02', name: 'The Adapter', description: 'Matches style to the situation.', soul: 'You are adaptable. You match your communication style to what the situation needs. You are efficient and no-nonsense but make time for the human side.', tags: ['adaptable', 'flexible', 'situational'], archetype: 'Operator' },
+  { id: 'ops-03', name: 'Problem Solver', description: 'Sees obstacles as puzzles to crack.', soul: 'You are a problem solver at heart. You see obstacles as puzzles to crack. You make the most of whatever you have and never give up easily.', tags: ['problem-solving', 'persistent', 'resourceful'], archetype: 'Operator' },
+  { id: 'ops-04', name: 'Gardener', description: 'Nurtures ideas and lets them grow.', soul: 'You have a gardener\'s patience. You nurture ideas and let them grow. You are gently persistent — you don\'t give up easily but never push too hard.', tags: ['patient', 'nurturing', 'organic'], archetype: 'Operator' },
+  { id: 'ops-05', name: 'Quiet Confidence', description: 'Nothing to prove, everything to offer.', soul: 'You communicate with quiet confidence. You prefer showing over telling. You speak with the easy confidence of someone who has nothing to prove.', tags: ['confident', 'understated', 'authentic'], archetype: 'Operator' },
+]
+
+/** Search souls by query text and optional archetype filter. */
+export function searchSouls(query: string, archetype?: string): SoulTemplate[] {
+  const q = query.toLowerCase().trim()
+  let results = SOUL_LIBRARY
+
+  if (archetype && archetype !== 'All') {
+    results = results.filter((s) => s.archetype === archetype)
+  }
+
+  if (!q) return results
+
+  return results.filter(
+    (s) =>
+      s.name.toLowerCase().includes(q) ||
+      s.description.toLowerCase().includes(q) ||
+      s.tags.some((t) => t.includes(q)) ||
+      s.soul.toLowerCase().includes(q),
+  )
+}

package/src/lib/task-dedupe.ts

@@ -0,0 +1,26 @@
+import { createHash } from 'crypto'
+import type { BoardTask } from '@/types'
+
+/** SHA-256 fingerprint from title + agentId, first 16 hex chars. */
+export function computeTaskFingerprint(title: string, agentId: string): string {
+  const input = `${title.trim().toLowerCase()}::${agentId}`
+  return createHash('sha256').update(input).digest('hex').slice(0, 16)
+}
+
+const TERMINAL_STATUSES = new Set(['completed', 'archived', 'failed'])
+
+/** Find an existing non-terminal task with the same fingerprint. */
+export function findDuplicateTask(
+  tasks: Record<string, BoardTask>,
+  candidate: { fingerprint: string },
+): BoardTask | null {
+  for (const task of Object.values(tasks)) {
+    if (
+      task.fingerprint === candidate.fingerprint &&
+      !TERMINAL_STATUSES.has(task.status)
+    ) {
+      return task
+    }
+  }
+  return null
+}

package/src/lib/tool-definitions.ts

@@ -22,6 +22,8 @@ export const AVAILABLE_TOOLS: ToolDefinition[] = [
   { id: 'sandbox', label: 'Sandbox', description: 'Run JS/TS/Python code in an isolated Deno sandbox' },
   { id: 'create_document', label: 'Create Document', description: 'Render markdown to PDF, HTML, or image' },
   { id: 'create_spreadsheet', label: 'Create Spreadsheet', description: 'Create Excel or CSV files from structured data' },
+  { id: 'http_request', label: 'HTTP Request', description: 'Make HTTP API calls (GET, POST, PUT, DELETE, etc.)' },
+  { id: 'git', label: 'Git', description: 'Run structured git operations (status, commit, push, diff, etc.)' },
 ]
 
 export const PLATFORM_TOOLS: ToolDefinition[] = [

package/src/lib/tts.ts

@@ -10,7 +10,7 @@ export function initAudioContext() {
   ensureContext()
 }
 
-export async function speak(text: string) {
+export async function speak(text: string, voiceId?: string | null) {
   if (currentSource) {
     try { currentSource.stop() } catch { /* noop */ }
     currentSource = null
@@ -21,7 +21,7 @@ export async function speak(text: string) {
   const res = await fetch('/api/tts', {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ text: text.slice(0, 2000) }),
+    body: JSON.stringify({ text: text.slice(0, 2000), ...(voiceId ? { voiceId } : {}) }),
   })
   if (!res.ok) return
 

package/src/stores/use-app-store.ts

@@ -98,6 +98,8 @@ interface AppState {
   setTaskSheetOpen: (open: boolean) => void
   editingTaskId: string | null
   setEditingTaskId: (id: string | null) => void
+  taskSheetViewOnly: boolean
+  setTaskSheetViewOnly: (v: boolean) => void
 
   // Provider configs (custom providers)
   providerConfigs: ProviderConfig[]
@@ -460,9 +462,11 @@ export const useAppStore = create<AppState>((set, get) => ({
     get().loadTasks(show)
   },
   taskSheetOpen: false,
-  setTaskSheetOpen: (open) => set({ taskSheetOpen: open }),
+  setTaskSheetOpen: (open) => set({ taskSheetOpen: open, ...(open ? {} : { taskSheetViewOnly: false }) }),
   editingTaskId: null,
   setEditingTaskId: (id) => set({ editingTaskId: id }),
+  taskSheetViewOnly: false,
+  setTaskSheetViewOnly: (v) => set({ taskSheetViewOnly: v }),
 
   // Provider configs (custom providers)
   providerConfigs: [],