@swarmclawai/swarmclaw 0.7.7 → 0.8.0

package/src/lib/server/approvals.ts

@@ -3,19 +3,28 @@ import { loadApprovals, upsertApproval, loadSessions, saveSessions, loadSettings
 import type { ApprovalRequest, ApprovalCategory, Message } from '@/types'
 import { notify } from './ws-hub'
 import { log } from './logger'
+import { requestHeartbeatNow } from './heartbeat-wake'
+import { enqueueSystemEvent } from './system-events'
+import { enqueueSessionRun } from './session-run-manager'
+import { buildApprovalMatchKey, buildApprovalMatchKeyFromRequest } from './approval-match'
+import { getPluginManager } from './plugins'
+import { addAllowedSender } from './connectors/pairing'
 
 const AUTO_APPROVABLE_CATEGORIES: ApprovalCategory[] = [
   'tool_access',
   'wallet_transfer',
+  'wallet_action',
   'plugin_scaffold',
   'plugin_install',
   'task_tool',
   'human_loop',
+  'connector_sender',
 ]
 const DEFAULT_APPROVAL_CONNECTOR_NOTIFY_DELAY_SEC = 300
 const MIN_APPROVAL_CONNECTOR_NOTIFY_DELAY_SEC = 30
 const MAX_APPROVAL_CONNECTOR_NOTIFY_DELAY_SEC = 86_400
 const APPROVAL_CONNECTOR_NOTIFY_RETRY_COOLDOWN_MS = 10 * 60 * 1000
+const RECENT_APPROVED_APPROVAL_REUSE_WINDOW_MS = 10 * 60 * 1000
 
 interface RunningConnectorSummary {
   id: string
@@ -37,6 +46,53 @@ function trimToString(value: unknown): string {
   return typeof value === 'string' ? value.trim() : ''
 }
 
+function normalizePluginList(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  return value
+    .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
+    .filter(Boolean)
+}
+
+function getApprovalTargetPlugins(request: ApprovalRequest): string[] {
+  return [
+    trimToString(request.data.pluginId),
+    trimToString(request.data.toolId),
+    trimToString(request.data.toolName),
+  ].filter(Boolean)
+}
+
+function getEnabledPluginsForApproval(request: ApprovalRequest): string[] {
+  const sessions = loadSessions()
+  const agents = loadAgents()
+  const sessionPlugins = request.sessionId ? normalizePluginList(sessions[request.sessionId]?.plugins) : []
+  const agentPlugins = request.agentId ? normalizePluginList(agents[request.agentId]?.plugins) : []
+  const targetPlugins = getApprovalTargetPlugins(request)
+  return Array.from(new Set([...sessionPlugins, ...agentPlugins, ...targetPlugins]))
+}
+
+function getApprovalGuidance(
+  request: ApprovalRequest,
+  phase: 'request' | 'resume' | 'connector_reminder',
+  approved?: boolean,
+): string[] {
+  const enabledPlugins = getEnabledPluginsForApproval(request)
+  if (enabledPlugins.length === 0) return []
+  return getPluginManager().collectApprovalGuidance(enabledPlugins, {
+    approval: request,
+    phase,
+    approved,
+  })
+}
+
+function appendGuidanceToLines(lines: string[], guidance: string[], label = 'Plugin guidance:'): string[] {
+  if (guidance.length === 0) return lines
+  lines.push(label)
+  for (const line of guidance) {
+    lines.push(`- ${line}`)
+  }
+  return lines
+}
+
 function clampApprovalConnectorNotifyDelaySec(value: unknown): number {
   const parsed = typeof value === 'number'
     ? value
@@ -64,6 +120,39 @@ function approvalsAreDisabled(): boolean {
   return loadSettings().approvalsEnabled === false
 }
 
+function canReuseApprovedDecision(category: ApprovalCategory, approval: ApprovalRequest, now: number): boolean {
+  if (category === 'tool_access') return true
+  return (now - approval.updatedAt) <= RECENT_APPROVED_APPROVAL_REUSE_WINDOW_MS
+}
+
+function findReusableApproval(params: {
+  category: ApprovalCategory
+  data: Record<string, unknown>
+  agentId?: string | null
+  sessionId?: string | null
+  taskId?: string | null
+}): ApprovalRequest | null {
+  const targetKey = buildApprovalMatchKey(params)
+  if (!targetKey) return null
+
+  const approvals = loadApprovals() as Record<string, ApprovalRequest>
+  const now = Date.now()
+  let recentApproved: ApprovalRequest | null = null
+
+  for (const approval of Object.values(approvals)) {
+    if (approval.category !== params.category) continue
+    if (buildApprovalMatchKeyFromRequest(approval) !== targetKey) continue
+    if (approval.status === 'pending') return approval
+    if (approval.status !== 'approved') continue
+    if (!canReuseApprovedDecision(params.category, approval, now)) continue
+    if (!recentApproved || approval.updatedAt > recentApproved.updatedAt) {
+      recentApproved = approval
+    }
+  }
+
+  return recentApproved
+}
+
 function getMessageSourceConnectorTarget(
   message: Record<string, unknown> | null | undefined,
   runningById: Map<string, RunningConnectorSummary>,
@@ -161,10 +250,12 @@ function buildApprovalConnectorReminderText(request: ApprovalRequest): string {
   if (description) lines.push(`Details: ${description.slice(0, 500)}`)
   lines.push(`Pending for about ${ageMin} minute${ageMin === 1 ? '' : 's'}.`)
   lines.push('Open the Approvals panel to approve or reject it.')
+  appendGuidanceToLines(lines, getApprovalGuidance(request, 'connector_reminder'), 'Agent guidance:')
   return lines.join('\n')
 }
 
 function buildApprovalChatMessage(request: ApprovalRequest): string {
+  const guidance = getApprovalGuidance(request, 'request')
   const targetId = getApprovalTargetId(request.data)
   switch (request.category) {
     case 'tool_access':
@@ -175,6 +266,7 @@ function buildApprovalChatMessage(request: ApprovalRequest): string {
         toolId: targetId || '',
         reason: trimToString(request.description),
         message: `Plugin access request sent to user for "${targetId || 'requested tool'}". Once granted, I'll automatically continue.`,
+        guidance: guidance.length > 0 ? guidance : undefined,
       })
     case 'plugin_scaffold':
       return JSON.stringify({
@@ -182,6 +274,7 @@ function buildApprovalChatMessage(request: ApprovalRequest): string {
         approvalId: request.id,
         filename: trimToString(request.data.filename),
         message: `I've submitted a request to create plugin "${trimToString(request.data.filename) || 'plugin.js'}". The user needs to approve it via the Approvals page or the approval card in chat. Once approved, the plugin file will be written automatically — no need to call this tool again.`,
+        guidance: guidance.length > 0 ? guidance : undefined,
       })
     case 'plugin_install':
       return JSON.stringify({
@@ -191,6 +284,7 @@ function buildApprovalChatMessage(request: ApprovalRequest): string {
         pluginId: trimToString(request.data.pluginId),
         reason: trimToString(request.description),
         message: `I'm requesting to install a new plugin${trimToString(request.data.url) ? ` from ${trimToString(request.data.url)}` : ''}. This will add new capabilities to the platform.`,
+        guidance: guidance.length > 0 ? guidance : undefined,
       })
     case 'wallet_transfer':
       return JSON.stringify({
@@ -200,7 +294,25 @@ function buildApprovalChatMessage(request: ApprovalRequest): string {
         toAddress: trimToString(request.data.toAddress),
         memo: trimToString(request.data.memo),
         message: `I'm requesting to send ${request.data.amountSol ?? 'funds'} to ${trimToString(request.data.toAddress) || 'the specified address'}. Please approve this transaction.`,
+        guidance: guidance.length > 0 ? guidance : undefined,
+      })
+    case 'wallet_action':
+      return JSON.stringify({
+        type: 'plugin_wallet_action_request',
+        approvalId: request.id,
+        action: trimToString(request.data.action),
+        chain: trimToString(request.data.chain),
+        network: trimToString(request.data.network),
+        summary: trimToString(request.data.summary),
+        message: trimToString(request.description) || `I'm requesting approval for wallet action "${trimToString(request.data.action) || request.title}".`,
+        guidance: guidance.length > 0 ? guidance : undefined,
       })
+    case 'connector_sender':
+      return [
+        `[Approval requested] ${request.title}`,
+        trimToString(request.description) || `Allow ${trimToString(request.data.senderName) || trimToString(request.data.senderId) || 'this sender'} on ${trimToString(request.data.connectorName) || 'the connector'}.`,
+        'Approve or reject this sender in the chat approval card or the Approvals panel.',
+      ].filter(Boolean).join('\n')
     default: {
       const lines = [
         `[Approval requested] ${request.title}`,
@@ -208,11 +320,92 @@ function buildApprovalChatMessage(request: ApprovalRequest): string {
       const description = trimToString(request.description)
       if (description) lines.push(`Details: ${description}`)
       lines.push('Approve or reject this request in the chat approval card or the Approvals panel.')
+      appendGuidanceToLines(lines, guidance)
       return lines.join('\n')
     }
   }
 }
 
+function buildApprovalDecisionResumeText(request: ApprovalRequest, approved: boolean): string {
+  const statusLabel = approved ? 'approved' : 'rejected'
+  const lines = [`[Approval ${statusLabel}] ${request.title}`]
+  const description = trimToString(request.description)
+  if (description) lines.push(`Details: ${description}`)
+  lines.push(`Approval id: ${request.id}`)
+  lines.push(approved
+    ? 'Continue the work that was blocked on this approval.'
+    : 'The requested action was rejected. Adjust the plan and continue safely.')
+  return lines.join('\n')
+}
+
+function buildApprovalDecisionResumeMessage(request: ApprovalRequest, approved: boolean): string {
+  const guidance = getApprovalGuidance(request, 'resume', approved)
+  const lines = [
+    'APPROVAL_DECISION_EVENT',
+    `Approval id: ${request.id}`,
+    `Category: ${request.category}`,
+    `Status: ${approved ? 'approved' : 'rejected'}`,
+    `Title: ${request.title}`,
+  ]
+  const description = trimToString(request.description)
+  if (description) lines.push(`Details: ${description}`)
+
+  const action = trimToString(request.data.action)
+  const chain = trimToString(request.data.chain)
+  const network = trimToString(request.data.network)
+  const summary = trimToString(request.data.summary)
+  if (action) lines.push(`Action: ${action}`)
+  if (chain) lines.push(`Chain: ${chain}`)
+  if (network) lines.push(`Network: ${network}`)
+  if (summary) lines.push(`Summary: ${summary}`)
+  if (request.category === 'wallet_action' || request.category === 'wallet_transfer') {
+    lines.push(`Approved payload: ${JSON.stringify(request.data)}`)
+  }
+
+  if (approved) {
+    lines.push('Resume the exact work that was blocked on this approval now.')
+    lines.push('Use this exact approvalId for the matching blocked tool action if the tool requires one.')
+    lines.push('If the exact blocked action still applies, execute it before doing more research or recomputing alternatives.')
+    lines.push('If tool evidence proves the approved action can no longer be executed as approved, request a fresh approval for the new exact action instead of reusing the old approvalId.')
+  } else {
+    lines.push('The requested action was rejected. Adjust the plan safely and continue without retrying the rejected action.')
+  }
+
+  appendGuidanceToLines(lines, guidance)
+  return lines.join('\n')
+}
+
+function wakeForApprovalDecision(request: ApprovalRequest, approved: boolean): void {
+  if (request.category === 'connector_sender') return
+  const reason = approved ? 'approval-approved' : 'approval-rejected'
+  if (request.sessionId) {
+    enqueueSystemEvent(
+      request.sessionId,
+      buildApprovalDecisionResumeText(request, approved),
+      `approval:${request.id}:${approved ? 'approved' : 'rejected'}`,
+    )
+    enqueueSessionRun({
+      sessionId: request.sessionId,
+      message: buildApprovalDecisionResumeMessage(request, approved),
+      internal: true,
+      source: 'approval-decision',
+      mode: 'collect',
+      dedupeKey: `approval-decision:${request.id}`,
+    })
+    return
+  }
+  if (request.agentId) {
+    requestHeartbeatNow({
+      agentId: request.agentId,
+      eventId: `approval:${request.id}:${approved ? 'approved' : 'rejected'}`,
+      reason,
+      source: `approval:${request.category}`,
+      resumeMessage: buildApprovalDecisionResumeText(request, approved),
+      detail: request.title || request.category,
+    })
+  }
+}
+
 function pushApprovalRequestMessage(request: ApprovalRequest): void {
   const sessionId = trimToString(request.sessionId)
   if (!sessionId) return
@@ -232,6 +425,7 @@ function pushApprovalRequestMessage(request: ApprovalRequest): void {
     text,
     time: Date.now(),
     kind: 'system',
+    ...(request.category === 'connector_sender' ? { historyExcluded: true } : {}),
   })
   session.lastActiveAt = Date.now()
   sessions[sessionId] = session
@@ -407,6 +601,14 @@ async function applyApprovedSideEffects(request: ApprovalRequest): Promise<void>
       }
     }
   }
+
+  if (request.category === 'connector_sender') {
+    const connectorId = trimToString(request.data.connectorId)
+    const senderId = trimToString(request.data.senderId)
+    if (connectorId && senderId) {
+      addAllowedSender(connectorId, senderId)
+    }
+  }
 }
 
 async function persistApprovalDecision(request: ApprovalRequest, approved: boolean): Promise<ApprovalRequest> {
@@ -444,6 +646,14 @@ export async function requestApprovalMaybeAutoApprove(params: {
   sessionId?: string | null
   taskId?: string | null
 }): Promise<ApprovalRequest> {
+  const reusable = findReusableApproval(params)
+  if (reusable) {
+    if (reusable.status === 'pending' && (approvalsAreDisabled() || isApprovalCategoryAutoApproved(reusable.category))) {
+      return persistApprovalDecision(reusable, true)
+    }
+    return reusable
+  }
+
   const request = requestApproval(params)
   if (!approvalsAreDisabled() && !isApprovalCategoryAutoApproved(request.category)) {
     pushApprovalRequestMessage(request)
@@ -457,7 +667,10 @@ export async function submitDecision(id: string, approved: boolean): Promise<voi
   const approvals = loadApprovals() as Record<string, ApprovalRequest>
   const request = approvals[id]
   if (!request) throw new Error('Approval request not found')
-  await persistApprovalDecision(request, approved)
+  if (request.status === (approved ? 'approved' : 'rejected')) return
+  if (request.status !== 'pending') return
+  const updated = await persistApprovalDecision(request, approved)
+  wakeForApprovalDecision(updated, approved)
 }
 
 export function listPendingApprovalsNeedingConnectorNotification(params?: {

package/src/lib/server/assistant-control.test.ts

@@ -0,0 +1,29 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import { shouldSuppressHiddenControlText, stripHiddenControlTokens } from './assistant-control'
+
+describe('assistant-control', () => {
+  it('suppresses pure hidden control replies', () => {
+    assert.equal(shouldSuppressHiddenControlText('NO_MESSAGE'), true)
+    assert.equal(shouldSuppressHiddenControlText('  HEARTBEAT_OK  '), true)
+    assert.equal(stripHiddenControlTokens('NO_MESSAGE'), '')
+  })
+
+  it('strips leaked control prefixes without suppressing real content', () => {
+    assert.equal(
+      stripHiddenControlTokens('NO_MESSAGEIt seems there was an error earlier on.'),
+      'It seems there was an error earlier on.',
+    )
+    assert.equal(
+      shouldSuppressHiddenControlText('NO_MESSAGEIt seems there was an error earlier on.'),
+      false,
+    )
+  })
+
+  it('removes standalone control-token lines from mixed content', () => {
+    assert.equal(
+      stripHiddenControlTokens('Working on it.\nNO_MESSAGE\nI found the issue.'),
+      'Working on it.\nI found the issue.',
+    )
+  })
+})

package/src/lib/server/assistant-control.ts

@@ -0,0 +1,23 @@
+const CONTROL_TOKEN_NAMES = ['NO_MESSAGE', 'HEARTBEAT_OK'] as const
+const CONTROL_TOKEN_PREFIX_RE = /^\s*(?:NO_MESSAGE|HEARTBEAT_OK)(?:(?=[\s.,:;!?()[\]{}"'`-]|$)|(?=[A-Z]))\s*/i
+const CONTROL_TOKEN_LINE_RE = /(^|\n)\s*(?:NO_MESSAGE|HEARTBEAT_OK)\s*(\n|$)/gi
+
+export function stripHiddenControlTokens(text: string): string {
+  let cleaned = String(text || '')
+  let previous = ''
+
+  while (cleaned !== previous) {
+    previous = cleaned
+    cleaned = cleaned.replace(CONTROL_TOKEN_PREFIX_RE, '')
+  }
+
+  cleaned = cleaned.replace(CONTROL_TOKEN_LINE_RE, '$1')
+  return cleaned.replace(/\n{3,}/g, '\n\n').trim()
+}
+
+export function shouldSuppressHiddenControlText(text: string): boolean {
+  const raw = String(text || '').trim()
+  if (!raw) return false
+  if (!CONTROL_TOKEN_NAMES.some((token) => raw.toUpperCase().includes(token))) return false
+  return stripHiddenControlTokens(raw).length === 0
+}

package/src/lib/server/build-llm.test.ts

@@ -41,4 +41,83 @@ describe('buildChatModel', () => {
     assert.equal(model.caller?.maxRetries, OPENAI_COMPAT_MODEL_MAX_RETRIES)
     assert.deepEqual(model.clientConfig?.defaultHeaders, { 'Content-Type': 'text/plain' })
   })
+
+  it('routes glm-5:cloud to Ollama Cloud and strips the transport suffix', () => {
+    const originalKey = process.env.OLLAMA_API_KEY
+    process.env.OLLAMA_API_KEY = 'ollama-cloud-test-key'
+
+    try {
+      const llm = buildChatModel({
+        provider: 'ollama',
+        model: 'glm-5:cloud',
+        apiKey: null,
+      })
+      const model = llm as ChatOpenAiInternals & {
+        model?: string
+        clientConfig?: { baseURL?: string }
+      }
+
+      assert.equal(llm instanceof ChatOpenAI, true)
+      assert.equal(model.model, 'glm-5')
+      assert.equal(model.clientConfig?.baseURL, 'https://ollama.com/v1')
+      assert.equal(model.timeout, OPENAI_COMPAT_MODEL_TIMEOUT_MS)
+      assert.equal(model.caller?.maxRetries, OPENAI_COMPAT_MODEL_MAX_RETRIES)
+    } finally {
+      if (originalKey === undefined) delete process.env.OLLAMA_API_KEY
+      else process.env.OLLAMA_API_KEY = originalKey
+    }
+  })
+
+  it('keeps glm-5:cloud on the local Ollama endpoint when no cloud key is available', () => {
+    const originalKey = process.env.OLLAMA_API_KEY
+    delete process.env.OLLAMA_API_KEY
+
+    try {
+      const llm = buildChatModel({
+        provider: 'ollama',
+        model: 'glm-5:cloud',
+        apiKey: null,
+      })
+      const model = llm as ChatOpenAiInternals & {
+        model?: string
+        clientConfig?: { baseURL?: string }
+      }
+
+      assert.equal(llm instanceof ChatOpenAI, true)
+      assert.equal(model.model, 'glm-5:cloud')
+      assert.equal(model.clientConfig?.baseURL, 'http://localhost:11434/v1')
+      assert.equal(model.timeout, OPENAI_COMPAT_MODEL_TIMEOUT_MS)
+      assert.equal(model.caller?.maxRetries, OPENAI_COMPAT_MODEL_MAX_RETRIES)
+    } finally {
+      if (originalKey === undefined) delete process.env.OLLAMA_API_KEY
+      else process.env.OLLAMA_API_KEY = originalKey
+    }
+  })
+
+  it('keeps an explicit local Ollama endpoint even when a cloud key exists', () => {
+    const originalKey = process.env.OLLAMA_API_KEY
+    process.env.OLLAMA_API_KEY = 'ollama-cloud-test-key'
+
+    try {
+      const llm = buildChatModel({
+        provider: 'ollama',
+        model: 'glm-5:cloud',
+        apiKey: null,
+        apiEndpoint: 'http://localhost:11434',
+      })
+      const model = llm as ChatOpenAiInternals & {
+        model?: string
+        clientConfig?: { baseURL?: string }
+      }
+
+      assert.equal(llm instanceof ChatOpenAI, true)
+      assert.equal(model.model, 'glm-5:cloud')
+      assert.equal(model.clientConfig?.baseURL, 'http://localhost:11434/v1')
+      assert.equal(model.timeout, OPENAI_COMPAT_MODEL_TIMEOUT_MS)
+      assert.equal(model.caller?.maxRetries, OPENAI_COMPAT_MODEL_MAX_RETRIES)
+    } finally {
+      if (originalKey === undefined) delete process.env.OLLAMA_API_KEY
+      else process.env.OLLAMA_API_KEY = originalKey
+    }
+  })
 })

package/src/lib/server/build-llm.ts

@@ -4,12 +4,18 @@ import { loadCredentials, decryptKey, loadAgents, loadSettings } from './storage
 import { getProviderList } from '../providers'
 import { normalizeOpenClawEndpoint } from '../openclaw-endpoint'
 import { NON_LANGGRAPH_PROVIDER_IDS } from '../provider-sets'
+import { resolveOllamaRuntimeConfig } from './ollama-runtime'
 
 const OLLAMA_CLOUD_URL = 'https://ollama.com/v1'
 const OLLAMA_LOCAL_URL = 'http://localhost:11434/v1'
 export const OPENAI_COMPAT_MODEL_TIMEOUT_MS = 180_000
 export const OPENAI_COMPAT_MODEL_MAX_RETRIES = 0
 
+function toOpenAiCompatibleBaseUrl(endpoint: string | null | undefined, fallback: string): string {
+  const normalized = (endpoint || fallback).replace(/\/+$/, '')
+  return normalized.endsWith('/v1') ? normalized : `${normalized}/v1`
+}
+
 /**
  * Build a LangChain chat model from provider config.
  * Uses the provider registry for endpoint defaults — no hardcoded provider list.
@@ -46,12 +52,16 @@ export function buildChatModel(opts: {
   }
 
   if (provider === 'ollama') {
-    const baseURL = apiKey && apiKey !== 'ollama'
+    const runtime = resolveOllamaRuntimeConfig({ model, apiKey, apiEndpoint })
+    if (runtime.useCloud && !runtime.apiKey) {
+      throw new Error('Ollama Cloud model requires an API key. Set OLLAMA_API_KEY or attach an Ollama credential.')
+    }
+    const baseURL = runtime.useCloud
       ? OLLAMA_CLOUD_URL
-      : (endpoint ? `${endpoint}/v1` : OLLAMA_LOCAL_URL)
+      : toOpenAiCompatibleBaseUrl(runtime.endpoint, OLLAMA_LOCAL_URL)
     return new ChatOpenAI({
-      model: model || 'qwen3.5',
-      apiKey: apiKey || 'ollama',
+      model: runtime.model || 'qwen3.5',
+      apiKey: runtime.useCloud ? runtime.apiKey || undefined : 'ollama',
       timeout: OPENAI_COMPAT_MODEL_TIMEOUT_MS,
       maxRetries: OPENAI_COMPAT_MODEL_MAX_RETRIES,
       configuration: { baseURL },

package/src/lib/server/canvas-content.test.ts

@@ -0,0 +1,32 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { normalizeCanvasDocument } from './canvas-content'
+
+describe('normalizeCanvasDocument', () => {
+  it('filters invalid metric rows and keeps valid metrics blocks', () => {
+    const result = normalizeCanvasDocument({
+      title: 'Smoke',
+      blocks: [
+        {
+          type: 'metrics',
+          items: [
+            { label: 'Healthy', value: 12, tone: 'positive' },
+            { label: '', value: 'skip-me' },
+            { value: 'missing-label' },
+          ],
+        },
+      ],
+    })
+
+    assert.ok(result)
+    assert.equal(result?.blocks.length, 1)
+    assert.deepEqual(result?.blocks[0], {
+      type: 'metrics',
+      items: [
+        { label: 'Healthy', value: '12', tone: 'positive', detail: undefined },
+      ],
+      title: undefined,
+    })
+  })
+})

package/src/lib/server/canvas-content.ts

@@ -0,0 +1,6 @@
+export {
+  isCanvasDocument,
+  normalizeCanvasContent,
+  normalizeCanvasDocument,
+  summarizeCanvasContent,
+} from '../canvas-content'

package/src/lib/server/capability-router.test.ts

@@ -19,3 +19,36 @@ test('routeTaskIntent keeps coding prompts prioritized over memory keywords', ()
   )
   assert.equal(decision.intent, 'coding')
 })
+
+test('routeTaskIntent keeps hybrid research-plus-media prompts in research intent', () => {
+  const decision = routeTaskIntent(
+    'Can you tell me more if there is any news related to the US-Iran war, and can you send me some screenshots and give me a summary and maybe send me a voice note about it?',
+    ['web_search', 'web_fetch', 'browser', 'manage_connectors'],
+    null,
+  )
+
+  assert.equal(decision.intent, 'research')
+  assert.deepEqual(decision.preferredTools, ['web_search', 'web_fetch', 'browser', 'connector_message_tool'])
+})
+
+test('routeTaskIntent treats direct voice-note delivery as outreach', () => {
+  const decision = routeTaskIntent(
+    'Send me a voice note over WhatsApp summarizing what changed.',
+    ['manage_connectors'],
+    null,
+  )
+
+  assert.equal(decision.intent, 'outreach')
+  assert.deepEqual(decision.preferredTools, ['connector_message_tool'])
+})
+
+test('routeTaskIntent treats keep-watching update requests as research even without explicit news keywords', () => {
+  const decision = routeTaskIntent(
+    'Tell me about the Iran war, keep watching for meaningful updates, and avoid duplicate reminders.',
+    ['web_search', 'manage_schedules'],
+    null,
+  )
+
+  assert.equal(decision.intent, 'research')
+  assert.deepEqual(decision.preferredTools, ['web_search', 'web_fetch'])
+})