@swarmclawai/swarmclaw 0.6.0 → 0.6.2

package/src/lib/server/mime.ts

@@ -0,0 +1,51 @@
+export const MIME_TYPES: Record<string, string> = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.svg': 'image/svg+xml',
+  '.bmp': 'image/bmp',
+  '.ico': 'image/x-icon',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+  '.mov': 'video/quicktime',
+  '.avi': 'video/x-msvideo',
+  '.mkv': 'video/x-matroska',
+  '.pdf': 'application/pdf',
+  '.json': 'application/json',
+  '.csv': 'text/csv',
+  '.txt': 'text/plain',
+  '.html': 'text/html',
+  '.xml': 'application/xml',
+  '.zip': 'application/zip',
+  '.tar': 'application/x-tar',
+  '.gz': 'application/gzip',
+  '.doc': 'application/msword',
+  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  '.xls': 'application/vnd.ms-excel',
+  '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  '.ppt': 'application/vnd.ms-powerpoint',
+  '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.ogg': 'audio/ogg',
+}
+
+const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp', '.ico'])
+const VIDEO_EXTS = new Set(['.mp4', '.webm', '.mov', '.avi', '.mkv'])
+const AUDIO_EXTS = new Set(['.mp3', '.wav', '.ogg'])
+const DOCUMENT_EXTS = new Set(['.pdf', '.json', '.csv', '.txt', '.html', '.xml', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx'])
+const ARCHIVE_EXTS = new Set(['.zip', '.tar', '.gz'])
+
+export type FileCategory = 'image' | 'video' | 'audio' | 'document' | 'archive' | 'other'
+
+export function getFileCategory(ext: string): FileCategory {
+  const lower = ext.toLowerCase()
+  if (IMAGE_EXTS.has(lower)) return 'image'
+  if (VIDEO_EXTS.has(lower)) return 'video'
+  if (AUDIO_EXTS.has(lower)) return 'audio'
+  if (DOCUMENT_EXTS.has(lower)) return 'document'
+  if (ARCHIVE_EXTS.has(lower)) return 'archive'
+  return 'other'
+}

package/src/lib/server/openclaw-gateway.ts

@@ -160,8 +160,8 @@ export class OpenClawGateway {
       this.doConnect().catch(() => {})
     }, this.reconnectDelay)
     this.reconnectDelay = Math.min(this.reconnectDelay * 2, maxDelay)
-    if (this.consecutiveFailures % 5 === 0) {
-      console.log(`[openclaw-gateway] ${this.consecutiveFailures} consecutive failures, next retry in ${Math.round(this.reconnectDelay / 1000)}s`)
+    if (this.consecutiveFailures === 1 || this.consecutiveFailures % 5 === 0) {
+      console.log(`[openclaw-gateway] ${this.consecutiveFailures} consecutive failure${this.consecutiveFailures > 1 ? 's' : ''}, next retry in ${Math.round(this.reconnectDelay / 1000)}s`)
     }
   }
 

package/src/lib/server/orchestrator-lg.ts

@@ -11,6 +11,7 @@ import { buildChatModel } from './build-llm'
 import { getCheckpointSaver } from './langgraph-checkpoint'
 import { notify } from './ws-hub'
 import { pushMainLoopEventToMainSessions } from './main-agent-loop'
+import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
 import { genId } from '@/lib/id'
 import { NON_LANGGRAPH_PROVIDER_IDS } from '@/lib/provider-sets'
 import type { Agent, TaskComment, MessageToolEvent } from '@/types'
@@ -351,6 +352,7 @@ export async function executeLangGraphOrchestrator(
   const settings = loadSettings()
   const promptParts: string[] = []
   if (settings.userPrompt) promptParts.push(settings.userPrompt)
+  promptParts.push(buildCurrentDateTimePromptContext())
   if (orchestrator.soul) promptParts.push(orchestrator.soul)
   if (orchestrator.systemPrompt) promptParts.push(orchestrator.systemPrompt)
   // Inject dynamic skills

package/src/lib/server/orchestrator.ts

@@ -6,6 +6,7 @@ import {
 import { WORKSPACE_DIR } from './data-dir'
 import { loadRuntimeSettings, getLegacyOrchestratorMaxTurns } from './runtime-settings'
 import { getMemoryDb } from './memory-db'
+import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
 import { getProvider } from '../providers'
 import type { Agent } from '@/types'
 
@@ -109,6 +110,7 @@ async function executeOrchestratorLegacy(
   const settings = loadSettings()
   const promptParts: string[] = []
   if (settings.userPrompt) promptParts.push(settings.userPrompt)
+  promptParts.push(buildCurrentDateTimePromptContext())
   if (orchestrator.soul) promptParts.push(orchestrator.soul)
   if (orchestrator.systemPrompt) promptParts.push(orchestrator.systemPrompt)
   if (orchestrator.skillIds?.length) {
@@ -308,8 +310,8 @@ async function executeSubTask(
 
 export async function callProvider(
   agent: Agent,
-  systemPrompt: string,
-  history: { role: string; text: string }[],
+  systemPrompt?: string,
+  history: { role: string; text: string }[] = [],
 ): Promise<string> {
   const provider = getProvider(agent.provider)
   if (!provider) throw new Error(`Unknown provider: ${agent.provider}`)
@@ -346,6 +348,7 @@ export async function callProvider(
     session: mockSession,
     message: history[history.length - 1].text,
     apiKey,
+    systemPrompt,
     write: (data: string) => {
       // Parse SSE data to extract text
       if (data.startsWith('data: ')) {

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

@@ -7,9 +7,8 @@
 import { spawn } from 'child_process'
 import fs from 'fs'
 import path from 'path'
-import os from 'os'
 
-const UPLOAD_DIR = process.env.SWARMCLAW_UPLOAD_DIR || path.join(os.tmpdir(), 'swarmclaw-uploads')
+const UPLOAD_DIR = process.env.SWARMCLAW_UPLOAD_DIR || path.join(process.env.DATA_DIR || path.join(process.cwd(), 'data'), 'uploads')
 if (!fs.existsSync(UPLOAD_DIR)) fs.mkdirSync(UPLOAD_DIR, { recursive: true })
 
 const child = spawn('npx', ['@playwright/mcp@latest'], {
@@ -47,7 +46,7 @@ child.stdout.on('data', (chunk) => {
             fs.writeFileSync(path.join(UPLOAD_DIR, filename), Buffer.from(block.data, 'base64'))
             newContent.push({
               type: 'text',
-              text: `Screenshot saved. Show it to the user with this markdown: ![Screenshot](/api/uploads/${filename})`,
+              text: `Screenshot saved to /api/uploads/${filename} — it is already displayed inline above (do not repeat it with markdown).`,
             })
             newContent.push(block) // keep image so Claude can see it
           } else {

package/src/lib/server/prompt-runtime-context.ts

@@ -0,0 +1,53 @@
+function resolveLocalTimezone(): string {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC'
+  } catch {
+    return 'UTC'
+  }
+}
+
+function formatDateTimeInTimezone(date: Date, timezone: string): string | null {
+  try {
+    return new Intl.DateTimeFormat('en-US', {
+      weekday: 'long',
+      year: 'numeric',
+      month: 'long',
+      day: 'numeric',
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit',
+      hour12: false,
+      timeZone: timezone,
+      timeZoneName: 'short',
+    }).format(date)
+  } catch {
+    return null
+  }
+}
+
+export function buildCurrentDateTimePromptContext(preferredTimezone?: string | null): string {
+  const now = new Date()
+  const utcIso = now.toISOString()
+  const utcFormatted = formatDateTimeInTimezone(now, 'UTC') || utcIso
+  const localTimezone = resolveLocalTimezone()
+  const requestedTimezone = (preferredTimezone || '').trim()
+  const chosenTimezone = requestedTimezone || localTimezone
+  const chosenFormatted = formatDateTimeInTimezone(now, chosenTimezone)
+
+  const lines = [
+    '## Runtime Date/Time Context',
+    `- Current timestamp (UTC): ${utcIso}`,
+    `- Current date/time (UTC): ${utcFormatted}`,
+  ]
+
+  if (chosenFormatted) {
+    lines.push(`- Current date/time (${chosenTimezone}): ${chosenFormatted}`)
+  } else if (requestedTimezone) {
+    lines.push(`- Requested timezone "${requestedTimezone}" could not be resolved. Use UTC time above.`)
+  }
+
+  lines.push('- Treat these as authoritative for terms like "today", "yesterday", "tomorrow", and "recent".')
+  lines.push('- For time-sensitive answers, use explicit dates (for example, "March 2, 2026").')
+
+  return lines.join('\n')
+}

package/src/lib/server/queue.ts

@@ -13,13 +13,13 @@ import { isProtectedMainSession } from './main-session'
 import type { Agent, BoardTask, Message } from '@/types'
 
 // HMR-safe: pin processing flag to globalThis so hot reloads don't reset it
-const _queueState = ((globalThis as Record<string, unknown>).__swarmclaw_queue__ ??= { processing: false }) as { processing: boolean }
+const _queueState = ((globalThis as Record<string, unknown>).__swarmclaw_queue__ ??= { processing: false, pendingKick: false }) as { processing: boolean; pendingKick: boolean }
 
 interface SessionMessageLike {
   role?: string
   text?: string
   time?: number
-  kind?: 'chat' | 'heartbeat' | 'system'
+  kind?: 'chat' | 'heartbeat' | 'system' | 'context-clear'
   toolEvents?: Array<{ name?: string; output?: string }>
 }
 
@@ -280,19 +280,44 @@ function notifyAgentThreadTaskResult(task: BoardTask): void {
     changed = true
   }
 
-  // 2. If delegated, push to delegating agent's thread
+  // 2. If delegated, push to delegating agent's thread AND active chat sessions
   const delegatedBy = (task as unknown as Record<string, unknown>).delegatedByAgentId
   if (typeof delegatedBy === 'string' && delegatedBy !== task.agentId) {
     const delegator = agents[delegatedBy]
+    const agentName = agent?.name || task.agentId
+    const delegationBody = buildResultBlock(`Delegated task ${statusLabel}: **${taskLink}** (by ${agentName})`)
+
+    // Push to delegating agent's thread
     if (delegator?.threadSessionId && sessions[delegator.threadSessionId]) {
       const thread = sessions[delegator.threadSessionId]
       if (!Array.isArray(thread.messages)) thread.messages = []
-      const agentName = agent?.name || task.agentId
-      const body = buildResultBlock(`Delegated task ${statusLabel}: **${taskLink}** (by ${agentName})`)
-      thread.messages.push(buildMsg(body))
+      thread.messages.push(buildMsg(delegationBody))
       thread.lastActiveAt = now
       changed = true
     }
+
+    // Push to delegating agent's active user-facing chat sessions
+    // so the result is visible in the chat the user is looking at
+    if (delegator) {
+      for (const session of Object.values(sessions)) {
+        if (!session || session.agentId !== delegatedBy) continue
+        // Skip thread sessions and orchestrated/subagent sessions
+        if (session.id === delegator.threadSessionId) continue
+        if (session.sessionType === 'orchestrated') continue
+        // Only push to recently-active sessions (within last 30 minutes)
+        const lastActive = typeof session.lastActiveAt === 'number' ? session.lastActiveAt : 0
+        if (now - lastActive > 30 * 60_000) continue
+        if (!Array.isArray(session.messages)) session.messages = []
+        // Avoid duplicate push
+        const lastMsg = session.messages.at(-1)
+        if (lastMsg?.text === delegationBody && typeof lastMsg?.time === 'number' && now - lastMsg.time < 30_000) continue
+        session.messages.push(buildMsg(delegationBody))
+        session.lastActiveAt = now
+        changed = true
+        // Notify the specific session's message topic for real-time UI update
+        notify(`messages:${session.id}`)
+      }
+    }
   }
 
   if (changed) saveSessions(sessions)
@@ -331,6 +356,10 @@ export function enqueueTask(taskId: string) {
     text: `Task queued: "${task.title}" (${task.id})`,
   })
 
+  // If processNext is already running, mark a pending kick so it re-enters after finishing
+  if (_queueState.processing) {
+    _queueState.pendingKick = true
+  }
   // Delay before kicking worker so UI shows the queued state
   setTimeout(() => processNext(), 2000)
 }
@@ -619,10 +648,21 @@ export async function processNext() {
       // Save initial assistant message so user sees context when opening the session
       const sessions = loadSessions()
       if (sessions[sessionId]) {
+        const isDelegation = (task as unknown as Record<string, unknown>).sourceType === 'delegation'
+        let initialText: string
+        if (isDelegation) {
+          const delegatorId = (task as unknown as Record<string, unknown>).delegatedByAgentId as string | undefined
+          const delegator = delegatorId ? agents[delegatorId] : null
+          const prefix = `[delegation-source:${delegatorId || ''}:${delegator?.name || 'Agent'}:${delegator?.avatarSeed || ''}]`
+          initialText = `${prefix}\nDelegated by **${delegator?.name || 'another agent'}** | [${task.title}](#task:${task.id})\n\n${task.description || ''}\n\nWorking directory: \`${taskCwd}\`\n\nI'll begin working on this now.`
+        } else {
+          initialText = `Starting task: **${task.title}**\n\n${task.description || ''}\n\nWorking directory: \`${taskCwd}\`\n\nI'll begin working on this now.`
+        }
         sessions[sessionId].messages.push({
           role: 'assistant',
-          text: `Starting task: **${task.title}**\n\n${task.description || ''}\n\nWorking directory: \`${taskCwd}\`\n\nI'll begin working on this now.`,
+          text: initialText,
           time: Date.now(),
+          ...(isDelegation ? { kind: 'system' as const } : {}),
         })
         saveSessions(sessions)
       }
@@ -807,6 +847,11 @@ export async function processNext() {
     }
   } finally {
     _queueState.processing = false
+    // If tasks were enqueued while we were processing, kick another round
+    if (_queueState.pendingKick) {
+      _queueState.pendingKick = false
+      setTimeout(() => processNext(), 500)
+    }
   }
 }
 

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

@@ -0,0 +1,67 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import { loadSessions, saveSessions } from '../storage'
+import { notify } from '../ws-hub'
+import type { ToolBuildContext } from './context'
+
+export function buildCanvasTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  const { ctx, hasTool } = bctx
+  if (!hasTool('canvas')) return []
+
+  return [
+    tool(
+      async ({ action, content }) => {
+        try {
+          const sessionId = ctx?.sessionId
+          if (!sessionId) return 'Error: no active session for canvas.'
+
+          const sessions = loadSessions()
+          const session = sessions[sessionId]
+          if (!session) return 'Error: session not found.'
+
+          if (action === 'present') {
+            if (!content) return 'Error: content is required for present action.'
+            ;(session as Record<string, unknown>).canvasContent = content
+            session.lastActiveAt = Date.now()
+            sessions[sessionId] = session
+            saveSessions(sessions)
+            notify(`canvas:${sessionId}`)
+            return JSON.stringify({ ok: true, action: 'present', contentLength: content.length })
+          }
+
+          if (action === 'hide') {
+            ;(session as Record<string, unknown>).canvasContent = null
+            session.lastActiveAt = Date.now()
+            sessions[sessionId] = session
+            saveSessions(sessions)
+            notify(`canvas:${sessionId}`)
+            return JSON.stringify({ ok: true, action: 'hide' })
+          }
+
+          if (action === 'snapshot') {
+            const current = (session as Record<string, unknown>).canvasContent
+            return JSON.stringify({
+              ok: true,
+              action: 'snapshot',
+              hasContent: !!current,
+              contentLength: typeof current === 'string' ? current.length : 0,
+              preview: typeof current === 'string' ? current.slice(0, 500) : null,
+            })
+          }
+
+          return `Unknown canvas action "${action}". Valid: present, hide, snapshot`
+        } catch (err: unknown) {
+          return `Error: ${err instanceof Error ? err.message : String(err)}`
+        }
+      },
+      {
+        name: 'canvas',
+        description: 'Present live HTML/CSS/JS content to the user in an interactive canvas panel. Use "present" to show content, "hide" to dismiss, "snapshot" to check current state. The canvas renders in a sandboxed iframe alongside the chat.',
+        schema: z.object({
+          action: z.enum(['present', 'hide', 'snapshot']).describe('Canvas action to perform'),
+          content: z.string().optional().describe('HTML content to render (required for "present"). Can include inline CSS and JS.'),
+        }),
+      },
+    ),
+  ]
+}

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

@@ -1,8 +1,21 @@
 import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
-import { loadConnectors, loadSettings } from '../storage'
+import path from 'path'
+import fs from 'fs'
+import { loadConnectors, loadSettings, UPLOAD_DIR } from '../storage'
 import type { ToolBuildContext } from './context'
 
+/** Resolve /api/uploads/filename URLs to actual disk paths */
+function resolveUploadUrl(url: string | undefined): { mediaPath: string; mimeType?: string } | null {
+  if (!url) return null
+  const match = url.match(/^\/api\/uploads\/([^?#]+)/)
+  if (!match) return null
+  const safeName = match[1].replace(/[^a-zA-Z0-9._-]/g, '')
+  const filePath = path.join(UPLOAD_DIR, safeName)
+  if (!fs.existsSync(filePath)) return null
+  return { mediaPath: filePath }
+}
+
 export function buildConnectorTools(bctx: ToolBuildContext): StructuredToolInterface[] {
   const tools: StructuredToolInterface[] = []
   const { ctx, hasTool } = bctx
@@ -32,6 +45,29 @@ export function buildConnectorTools(bctx: ToolBuildContext): StructuredToolInter
               return JSON.stringify(running)
             }
 
+            if (action === 'start') {
+              if (!connectorId) {
+                // If no ID given, list available connectors to start
+                const allConnectors = loadConnectors()
+                const stopped = Object.values(allConnectors)
+                  .filter((c) => !platform || c.platform === platform)
+                  .filter((c) => !running.find((r) => r.id === c.id))
+                  .map((c) => ({ id: c.id, name: c.name, platform: c.platform }))
+                if (!stopped.length) return 'All connectors are already running.'
+                return `Error: connectorId is required. Stopped connectors available to start: ${JSON.stringify(stopped)}`
+              }
+              const { startConnector: doStart } = await import('../connectors/manager')
+              await doStart(connectorId)
+              return JSON.stringify({ status: 'started', connectorId })
+            }
+
+            if (action === 'stop') {
+              if (!connectorId) return 'Error: connectorId is required for stop action.'
+              const { stopConnector: doStop } = await import('../connectors/manager')
+              await doStop(connectorId)
+              return JSON.stringify({ status: 'stopped', connectorId })
+            }
+
             if (action === 'send') {
               const settings = loadSettings()
               if (settings.safetyRequireApprovalForOutbound === true && approved !== true) {
@@ -41,7 +77,15 @@ export function buildConnectorTools(bctx: ToolBuildContext): StructuredToolInter
               const hasMedia = !!imageUrl?.trim() || !!fileUrl?.trim()
               if (!hasText && !hasMedia) return 'Error: message or media URL is required for send action.'
               if (!running.length) {
-                return `Error: no running connectors${platform ? ` for platform "${platform}"` : ''}.`
+                // Check for configured-but-not-running connectors to give actionable feedback
+                const allConnectors = loadConnectors()
+                const configured = Object.values(allConnectors)
+                  .filter((c) => !platform || c.platform === platform)
+                  .map((c) => ({ id: c.id, name: c.name, platform: c.platform, agentId: c.agentId || null }))
+                if (configured.length) {
+                  return `Error: no running connectors${platform ? ` for platform "${platform}"` : ''}, but ${configured.length} configured connector(s) found: ${JSON.stringify(configured)}. These connectors exist but are not currently started. Ask the user if they'd like you to start one (use action "start" with the connectorId), then retry the send.`
+                }
+                return `Error: no running connectors${platform ? ` for platform "${platform}"` : ''}. No connectors are configured for this platform either — the user needs to set one up in the Connectors panel first.`
               }
 
               const selected = connectorId
@@ -75,19 +119,49 @@ export function buildConnectorTools(bctx: ToolBuildContext): StructuredToolInter
                 if (allowed.length) channelId = allowed[0]
               }
               if (!channelId) {
-                return `Error: no target recipient configured. Provide "to", or set connector config "outboundJid"/"allowedJids"/"outboundTarget"/"allowFrom".`
+                // Collect any known numbers/targets from config to help the agent suggest them
+                const knownTargets: string[] = []
+                const jids = connector.config?.allowedJids?.split(',').map((s: string) => s.trim()).filter(Boolean) || []
+                const from = connector.config?.allowFrom?.split(',').map((s: string) => s.trim()).filter(Boolean) || []
+                const outJid = connector.config?.outboundJid?.trim()
+                const outTarget = connector.config?.outboundTarget?.trim()
+                if (outJid) knownTargets.push(outJid)
+                if (outTarget) knownTargets.push(outTarget)
+                knownTargets.push(...jids, ...from)
+                const unique = [...new Set(knownTargets)]
+                if (unique.length) {
+                  return `Error: no default outbound target is set, but the connector has ${unique.length} configured number(s)/target(s): ${JSON.stringify(unique)}. Ask the user which one to send to, then re-call with the "to" parameter set to their choice.`
+                }
+                return `Error: no target recipient configured and no known contacts on this connector. Ask the user for the recipient number/ID, then re-call with the "to" parameter. They can also configure "allowedJids" or "outboundJid" in the connector settings.`
               }
               if (connector.platform === 'whatsapp') {
                 channelId = normalizeWhatsAppTarget(channelId)
               }
 
+              // Resolve /api/uploads/ URLs to actual disk paths so connectors can read the files
+              let resolvedMediaPath = mediaPath?.trim() || undefined
+              let resolvedImageUrl = imageUrl?.trim() || undefined
+              let resolvedFileUrl = fileUrl?.trim() || undefined
+              if (!resolvedMediaPath) {
+                const fromImage = resolveUploadUrl(resolvedImageUrl)
+                if (fromImage) {
+                  resolvedMediaPath = fromImage.mediaPath
+                  resolvedImageUrl = undefined
+                }
+                const fromFile = resolveUploadUrl(resolvedFileUrl)
+                if (fromFile) {
+                  resolvedMediaPath = fromFile.mediaPath
+                  resolvedFileUrl = undefined
+                }
+              }
+
               const sent = await sendConnectorMessage({
                 connectorId: selected.id,
                 channelId,
                 text: message?.trim() || '',
-                imageUrl: imageUrl?.trim() || undefined,
-                fileUrl: fileUrl?.trim() || undefined,
-                mediaPath: mediaPath?.trim() || undefined,
+                imageUrl: resolvedImageUrl,
+                fileUrl: resolvedFileUrl,
+                mediaPath: resolvedMediaPath,
                 mimeType: mimeType?.trim() || undefined,
                 fileName: fileName?.trim() || undefined,
                 caption: caption?.trim() || undefined,
@@ -140,16 +214,16 @@ export function buildConnectorTools(bctx: ToolBuildContext): StructuredToolInter
               }
             }
 
-            return 'Unknown action. Use list_running, list_targets, or send.'
+            return 'Unknown action. Use list_running, list_targets, start, stop, or send.'
           } catch (err: unknown) {
             return `Error: ${err instanceof Error ? err.message : String(err)}`
           }
         },
         {
           name: 'connector_message_tool',
-          description: 'Send proactive outbound messages and perform rich messaging actions through running connectors. Supports listing running connectors/targets, sending text/media, and rich messaging (react, edit, delete, pin). For rich actions: connectorId + message (as messageId) required; caption carries emoji for react or new text for edit.',
+          description: 'Manage and send messages through chat platform connectors (WhatsApp, Telegram, Slack, Discord, etc.). Use "start"/"stop" to manage connector lifecycle, "list_running"/"list_targets" to discover available connectors and recipients, "send" to deliver messages, and rich actions (react, edit, delete, pin) for message management. When a send fails because no connector is running, check if one is configured and offer to start it. When no target is set, list available configured numbers and ask the user which to send to.',
           schema: z.object({
-            action: z.enum(['list_running', 'list_targets', 'send', 'message_react', 'message_edit', 'message_delete', 'message_pin']).describe('connector messaging action'),
+            action: z.enum(['list_running', 'list_targets', 'start', 'stop', 'send', 'message_react', 'message_edit', 'message_delete', 'message_pin']).describe('connector messaging action'),
             connectorId: z.string().optional().describe('Optional connector id. Defaults to the first running connector (or first for selected platform).'),
             platform: z.string().optional().describe('Optional platform filter (whatsapp, telegram, slack, discord, bluebubbles, etc.).'),
             to: z.string().optional().describe('Target channel id / recipient. For WhatsApp, phone number or full JID.'),

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

@@ -20,6 +20,8 @@ import {
 } from '../storage'
 import { resolveScheduleName } from '@/lib/schedule-name'
 import { findDuplicateSchedule, type ScheduleLike } from '@/lib/schedule-dedupe'
+import { computeTaskFingerprint, findDuplicateTask } from '@/lib/task-dedupe'
+import { resolveTaskAgentFromDescription } from '@/lib/server/task-mention'
 import type { ToolBuildContext } from './context'
 import { safePath, findBinaryOnPath } from './context'
 
@@ -115,6 +117,7 @@ const RESOURCE_DEFAULTS: Record<string, (parsed: any) => any> = {
     queuedAt: null,
     startedAt: null,
     completedAt: null,
+    priority: ['low', 'medium', 'high', 'critical'].includes(p.priority) ? p.priority : undefined,
     ...p,
   }),
   manage_schedules: (p) => {
@@ -342,6 +345,24 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                   })
                 }
               }
+              // @mention agent resolution for tasks
+              if (toolKey === 'manage_tasks' && parsed.description) {
+                const agents = loadAgents()
+                parsed.agentId = resolveTaskAgentFromDescription(
+                  parsed.description,
+                  parsed.agentId || ctx?.agentId || '',
+                  agents,
+                )
+              }
+              // Task dedup
+              if (toolKey === 'manage_tasks') {
+                const fp = computeTaskFingerprint(parsed.title || 'Untitled Task', parsed.agentId || ctx?.agentId || '')
+                parsed.fingerprint = fp
+                const dupe = findDuplicateTask(all as Record<string, import('@/types').BoardTask>, { fingerprint: fp })
+                if (dupe) {
+                  return JSON.stringify({ ...dupe, deduplicated: true })
+                }
+              }
               const newId = genId()
               const entry = {
                 id: newId,

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

@@ -634,6 +634,69 @@ export function buildDelegateTools(bctx: ToolBuildContext): StructuredToolInterf
     }
   }
 
+  // check_delegation_status: lets agents check on tasks they delegated
+  if (ctx?.platformAssignScope === 'all' && ctx?.agentId) {
+    tools.push(
+      tool(
+        async ({ taskId }) => {
+          try {
+            const tasks = loadTasks()
+            const task = tasks[taskId] as Record<string, unknown> | undefined
+            if (!task) return `Error: Task "${taskId}" not found.`
+
+            const status = task.status as string || 'unknown'
+            const result = typeof task.result === 'string' ? task.result : null
+            const error = typeof task.error === 'string' ? task.error : null
+            const agentId = task.agentId as string || ''
+            const agents = loadAgents()
+            const agent = agents[agentId]
+            const startedAt = typeof task.startedAt === 'number' ? task.startedAt : null
+            const completedAt = typeof task.completedAt === 'number' ? task.completedAt : null
+
+            const info: Record<string, unknown> = {
+              taskId,
+              status,
+              agentId,
+              agentName: agent?.name || agentId,
+              agentAvatarSeed: agent?.avatarSeed || null,
+              title: task.title || '',
+            }
+
+            if (startedAt) info.startedAt = new Date(startedAt).toISOString()
+            if (completedAt) info.completedAt = new Date(completedAt).toISOString()
+            if (startedAt && !completedAt && status === 'running') {
+              info.runningForSeconds = Math.round((Date.now() - startedAt) / 1000)
+            }
+            if (result) info.result = result.slice(0, 4000)
+            if (error) info.error = error.slice(0, 1000)
+
+            // Include latest comments for context
+            const comments = Array.isArray(task.comments) ? task.comments as Array<{ text: string; author: string; createdAt: number }> : []
+            if (comments.length > 0) {
+              const latest = comments.slice(-3).map((c) => ({
+                author: c.author,
+                text: (c.text || '').slice(0, 500),
+                time: new Date(c.createdAt).toISOString(),
+              }))
+              info.latestComments = latest
+            }
+
+            return JSON.stringify(info)
+          } catch (err: unknown) {
+            return `Error checking task: ${err instanceof Error ? err.message : String(err)}`
+          }
+        },
+        {
+          name: 'check_delegation_status',
+          description: 'Check the status and result of a delegated task. Use this after delegate_to_agent to monitor progress. Returns status (todo/queued/running/completed/failed), result if completed, and latest comments.',
+          schema: z.object({
+            taskId: z.string().describe('The task ID returned by delegate_to_agent'),
+          }),
+        },
+      ),
+    )
+  }
+
   // delegate_to_agent: requires "Assign to Other Agents" (platformAssignScope: 'all')
   if (ctx?.platformAssignScope === 'all' && ctx?.agentId) {
     tools.push(
@@ -698,9 +761,10 @@ export function buildDelegateTools(bctx: ToolBuildContext): StructuredToolInterf
               taskId,
               agentId: resolvedId,
               agentName: target.name,
+              agentAvatarSeed: target.avatarSeed || null,
               message: startImmediately
-                ? `Task delegated to ${target.name} and queued for immediate execution. Task ID: ${taskId}.`
-                : `Task delegated to ${target.name}. Task ID: ${taskId}. Status: todo. Ask the user if they want to start it now — call again with startImmediately: true to queue it.`,
+                ? `Task delegated to ${target.name} and queued for immediate execution. Task ID: ${taskId}. Use check_delegation_status to monitor progress.`
+                : `Task delegated to ${target.name}. Task ID: ${taskId}. Status: todo (not auto-started). Use delegate_to_agent with startImmediately: true to queue it.`,
             })
           } catch (err: unknown) {
             return `Error delegating task: ${err instanceof Error ? err.message : String(err)}`
@@ -708,12 +772,12 @@ export function buildDelegateTools(bctx: ToolBuildContext): StructuredToolInterf
         },
         {
           name: 'delegate_to_agent',
-          description: 'Delegate a task to another agent. Creates a task on the task board. By default the task goes to "todo" status. Set startImmediately=true to queue it for execution right away. Ask the user to confirm before starting immediately.',
+          description: 'Delegate a task to another agent. Creates a task on the task board and queues it for immediate execution by default. Set startImmediately=false if you want the task to go to "todo" status instead.',
           schema: z.object({
             agentId: z.string().describe('ID or name of the target agent to delegate to'),
             task: z.string().describe('What the target agent should do'),
             description: z.string().optional().describe('Optional longer description of the task'),
-            startImmediately: z.boolean().optional().default(false).describe('If true, queue the task for immediate execution instead of putting it in todo'),
+            startImmediately: z.boolean().optional().default(true).describe('If true (default), queue the task for immediate execution. Set false to put in todo for manual start.'),
           }),
         },
       ),