@swarmclawai/swarmclaw 0.7.6 → 0.7.8

package/src/lib/server/session-tools/manage-tasks.test.ts

@@ -0,0 +1,114 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { describe, it } from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-task-tool-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        DATA_DIR: path.join(tempDir, 'data'),
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+describe('manage_tasks tool', () => {
+  it('inherits continuation context from continueFromTaskId', () => {
+    const output = runWithTempDataDir(`
+      import fs from 'node:fs'
+      import path from 'node:path'
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const crudMod = await import('./src/lib/server/session-tools/crud.ts')
+      const storage = storageMod.default || storageMod
+      const crud = crudMod.default || crudMod
+
+      const now = Date.now()
+      const workspaceDir = process.env.WORKSPACE_DIR
+      const projectDir = path.join(workspaceDir, 'projects', 'project-1')
+      fs.mkdirSync(projectDir, { recursive: true })
+
+      storage.saveAgents({
+        default: {
+          id: 'default',
+          name: 'Molly',
+          description: '',
+          systemPrompt: '',
+          provider: 'openai',
+          model: 'gpt-test',
+          createdAt: now,
+          updatedAt: now,
+        },
+        worker: {
+          id: 'worker',
+          name: 'Worker',
+          description: '',
+          systemPrompt: '',
+          provider: 'openai',
+          model: 'gpt-test',
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+
+      storage.saveTasks({
+        'task-source': {
+          id: 'task-source',
+          title: 'Source task',
+          description: 'Original work',
+          status: 'completed',
+          agentId: 'worker',
+          projectId: 'project-1',
+          cwd: projectDir,
+          sessionId: 'session-source',
+          codexResumeId: 'codex-thread-1',
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+
+      const tools = crud.buildCrudTools({
+        cwd: workspaceDir,
+        ctx: { sessionId: 'session-creator', agentId: 'default', platformAssignScope: 'all' },
+        hasPlugin: (name) => name === 'manage_tasks',
+      })
+      const tool = tools.find((entry) => entry.name === 'manage_tasks')
+      const raw = await tool.invoke({
+        action: 'create',
+        title: 'Follow-up task',
+        description: 'Continue the previous task with the next deliverable.',
+        status: 'backlog',
+        continueFromTaskId: 'task-source',
+      })
+
+      const tasks = storage.loadTasks()
+      const created = Object.values(tasks).find((entry) => entry.id !== 'task-source')
+      console.log(JSON.stringify({ raw, created }))
+    `)
+
+    assert.equal(output.created.projectId, 'project-1')
+    assert.equal(output.created.agentId, 'worker')
+    assert.equal(output.created.sessionId, 'session-source')
+    assert.equal(output.created.codexResumeId, 'codex-thread-1')
+    assert.deepEqual(output.created.blockedBy, ['task-source'])
+  })
+})

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

@@ -42,7 +42,8 @@ async function executeMemoryAction(input: any, ctx: any) {
       ? ctx.id
       : null
   const currentSession = ctx && typeof ctx === 'object' && Array.isArray(ctx.messages) ? ctx : null
-  const rawScope = typeof scope === 'string' ? scope : 'auto'
+  const configuredScope = typeof ctx?.memoryScopeMode === 'string' ? ctx.memoryScopeMode : 'auto'
+  const rawScope = typeof scope === 'string' ? scope : configuredScope
   const scopeMode = normalizeMemoryScopeMode(rawScope === 'shared' ? 'global' : rawScope)
   const rerankMode = rerank === 'semantic' || rerank === 'lexical' ? rerank : 'balanced'
   
@@ -50,7 +51,11 @@ async function executeMemoryAction(input: any, ctx: any) {
     mode: scopeMode,
     agentId: currentAgentId,
     sessionId: (typeof scopeSessionId === 'string' && scopeSessionId.trim()) ? scopeSessionId.trim() : currentSessionId,
-    projectRoot: (typeof projectRoot === 'string' && projectRoot.trim()) ? projectRoot.trim() : ((project && typeof project === 'object' && 'rootPath' in project && typeof (project as Record<string, unknown>).rootPath === 'string') ? (project as Record<string, unknown>).rootPath as string : null),
+    projectRoot: (typeof projectRoot === 'string' && projectRoot.trim())
+      ? projectRoot.trim()
+      : ((project && typeof project === 'object' && 'rootPath' in project && typeof (project as Record<string, unknown>).rootPath === 'string')
+          ? (project as Record<string, unknown>).rootPath as string
+          : (typeof ctx?.projectRoot === 'string' && ctx.projectRoot.trim() ? ctx.projectRoot.trim() : null)),
   }
   
   const filterScope = (rows: MemoryEntry[]) => filterMemoriesByScope(rows, scopeFilter)
@@ -80,12 +85,19 @@ async function executeMemoryAction(input: any, ctx: any) {
     if (imagePath && fs.existsSync(imagePath)) {
       storedImage = await storeMemoryImageAsset(imagePath, genId(6))
     }
+    const metadata = n.metadata && typeof n.metadata === 'object' && !Array.isArray(n.metadata)
+      ? { ...(n.metadata as Record<string, unknown>) }
+      : {}
+    if (scopeMode === 'project' && scopeFilter.projectRoot && !metadata.projectRoot) {
+      metadata.projectRoot = scopeFilter.projectRoot
+    }
     const entry = memDb.add({
       agentId: scopeMode === 'global' ? null : currentAgentId,
       sessionId: ctx?.sessionId || null,
       category: category || 'note',
       title: key,
       content: value || '',
+      metadata,
       references: Array.isArray(references) ? references : [],
       filePaths: filePaths as any,
       imagePath: storedImage?.path || undefined,

package/src/lib/server/session-tools/platform-access.test.ts

@@ -0,0 +1,58 @@
+import assert from 'node:assert/strict'
+import { afterEach, describe, it } from 'node:test'
+import type { ToolBuildContext } from './context'
+import { buildPlatformTools } from './platform'
+import { loadSettings, saveSettings } from '../storage'
+
+const originalSettings = loadSettings()
+
+afterEach(() => {
+  saveSettings(originalSettings)
+})
+
+function buildTestContext(hasPlugin: (name: string) => boolean): ToolBuildContext {
+  return {
+    cwd: process.cwd(),
+    ctx: undefined,
+    hasPlugin,
+    hasTool: hasPlugin,
+    cleanupFns: [],
+    commandTimeoutMs: 1_000,
+    claudeTimeoutMs: 1_000,
+    cliProcessTimeoutMs: 1_000,
+    persistDelegateResumeId: () => {},
+    readStoredDelegateResumeId: () => null,
+    resolveCurrentSession: () => null,
+    activePlugins: ['manage_platform'],
+  }
+}
+
+describe('buildPlatformTools', () => {
+  it('blocks task resources when task management is disabled', async () => {
+    saveSettings({
+      ...originalSettings,
+      taskManagementEnabled: false,
+      projectManagementEnabled: true,
+    })
+
+    const [toolEntry] = buildPlatformTools(buildTestContext((name) => name === 'manage_platform'))
+    assert.ok(toolEntry)
+
+    const result = await toolEntry.invoke({ resource: 'tasks', action: 'list' })
+    assert.match(String(result), /task management is disabled/i)
+  })
+
+  it('allows project resources through manage_platform when project management is enabled', async () => {
+    saveSettings({
+      ...originalSettings,
+      taskManagementEnabled: true,
+      projectManagementEnabled: true,
+    })
+
+    const [toolEntry] = buildPlatformTools(buildTestContext((name) => name === 'manage_platform'))
+    assert.ok(toolEntry)
+
+    const result = await toolEntry.invoke({ resource: 'projects', action: 'list' })
+    assert.doesNotMatch(String(result), /unknown resource|disabled/i)
+  })
+})

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

@@ -2,9 +2,13 @@ import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import { buildCrudTools } from './crud'
 import type { ToolBuildContext } from './context'
-import type { Plugin, PluginHooks } from '@/types'
+import type { Plugin, PluginHooks, Session } from '@/types'
 import { getPluginManager } from '../plugins'
 import { normalizeToolInputArgs } from './normalize-tool-args'
+import { loadSettings } from '../storage'
+import { resolveSessionToolPolicy } from '../tool-capability-policy'
+import { loadRuntimeSettings } from '../runtime-settings'
+import { expandPluginIds } from '../tool-aliases'
 
 function parsePlatformData(value: unknown): Record<string, unknown> | null {
   if (!value) return null
@@ -39,6 +43,7 @@ function normalizePlatformResourceName(value: unknown): string | undefined {
   if (!normalized) return undefined
   const singularMap: Record<string, string> = {
     agent: 'agents',
+    project: 'projects',
     task: 'tasks',
     backlog_task: 'tasks',
     'backlog-task': 'tasks',
@@ -144,33 +149,69 @@ function uniqueStrings(values: Array<string | undefined>): string[] {
   return [...new Set(values.filter((value): value is string => Boolean(value)))]
 }
 
+function resolvePlatformResourceAccess(toolId: string, bctx: ToolBuildContext): { allowed: boolean; reason: string | null } {
+  if (bctx.hasPlugin(toolId)) return { allowed: true, reason: null }
+  if (!bctx.hasPlugin('manage_platform')) return { allowed: false, reason: null }
+  const settings = loadSettings()
+  const decision = resolveSessionToolPolicy(['manage_platform', toolId], settings)
+  const allowed = decision.enabledPlugins.includes(toolId)
+  const blocked = decision.blockedPlugins.find((entry) => entry.tool === toolId)
+  return { allowed, reason: blocked?.reason || null }
+}
+
+function buildPlatformContextFromSession(session: Session): ToolBuildContext {
+  const runtime = loadRuntimeSettings()
+  const sessionPlugins = Array.isArray(session.plugins) ? session.plugins : []
+  const legacyTools = Array.isArray(session.tools) ? session.tools : []
+  const activePlugins = expandPluginIds([...sessionPlugins, ...legacyTools, 'manage_platform'])
+  const activePluginSet = new Set(activePlugins)
+  const hasPlugin = (name: string) => activePluginSet.has(name)
+
+  return {
+    cwd: session.cwd || process.cwd(),
+    ctx: {
+      sessionId: session.id,
+      agentId: session.agentId ?? null,
+    },
+    hasPlugin,
+    hasTool: hasPlugin,
+    cleanupFns: [],
+    commandTimeoutMs: runtime.shellCommandTimeoutMs,
+    claudeTimeoutMs: runtime.claudeCodeTimeoutMs,
+    cliProcessTimeoutMs: runtime.cliProcessTimeoutMs,
+    persistDelegateResumeId: () => {},
+    readStoredDelegateResumeId: () => null,
+    resolveCurrentSession: () => session,
+    activePlugins,
+  }
+}
+
 /**
  * Unified Platform Execution Logic
  */
-async function executePlatformAction(args: any, bctx: any) {
+async function executePlatformAction(args: any, bctx: ToolBuildContext) {
   const normalized = normalizePlatformActionArgs((args ?? {}) as Record<string, unknown>)
   const { resource, action, id, data } = normalized
+  const resourceName = typeof resource === 'string' ? resource : ''
   
   // We reuse the existing CRUD tool logic but expose it via a single tool
   const crudTools = buildCrudTools({
     ...bctx,
-    hasPlugin: (id: string) => [
-      'manage_agents',
-      'manage_tasks',
-      'manage_schedules',
-      'manage_skills',
-      'manage_documents',
-      'manage_secrets',
-      'manage_connectors',
-      'manage_sessions'
-    ].includes(id)
+    hasPlugin: (toolId: string) => resolvePlatformResourceAccess(toolId, bctx).allowed,
   })
 
-  const targetToolName = `manage_${resource}`
+  const targetToolName = `manage_${resourceName}`
   const targetTool = crudTools.find(t => t.name === targetToolName)
   
   if (!targetTool) {
-    return `Error: Unknown resource type "${resource}". Valid resources: agents, tasks, schedules, skills, documents, secrets, connectors, sessions.`
+    const knownResources = ['agents', 'projects', 'tasks', 'schedules', 'skills', 'documents', 'secrets', 'connectors', 'sessions']
+    if (resourceName && knownResources.includes(resourceName)) {
+      const toolId = `manage_${resourceName}`
+      const access = resolvePlatformResourceAccess(toolId, bctx)
+      const suffix = access.reason ? ` (${access.reason})` : ''
+      return `Error: Resource "${resourceName}" is disabled by app settings or capability policy in this chat${suffix}.`
+    }
+    return `Error: Unknown resource type "${resourceName || resource}". Valid resources: ${knownResources.join(', ')}.`
   }
 
   // Forward to the specific CRUD tool implementation
@@ -182,10 +223,10 @@ async function executePlatformAction(args: any, bctx: any) {
  */
 const PlatformPlugin: Plugin = {
   name: 'Core Platform',
-  description: 'Unified management of agents, tasks, schedules, skills, documents, and secrets.',
+  description: 'Unified management of agents, projects, tasks, schedules, skills, documents, and secrets.',
   hooks: {
-    getCapabilityDescription: () => 'I can create and configure other agents (`manage_agents`), manage tasks (`manage_tasks`), set up schedules (`manage_schedules`), store and search documents (`manage_documents`), register webhooks (`manage_webhooks`), manage reusable skills (`manage_skills`), and store encrypted secrets (`manage_secrets`).',
-    getOperatingGuidance: () => ['Create/update tasks for long-lived goals to track progress.', 'Use schedules for follow-ups. Check existing schedules before creating new ones.', 'Inspect existing chats before creating duplicates.'],
+    getCapabilityDescription: () => 'I can manage durable execution context across agents, projects, tasks, schedules, documents, skills, webhooks, connectors, sessions, and encrypted secrets.',
+    getOperatingGuidance: () => ['Use projects to hold longer-lived goals, objectives, and credential requirements.', 'Create/update tasks for long-lived goals to track progress.', 'Use schedules for follow-ups and heartbeat-style check-ins. Check existing schedules before creating new ones.', 'Inspect existing chats before creating duplicates.'],
   } as PluginHooks,
   tools: [
     {
@@ -194,14 +235,14 @@ const PlatformPlugin: Plugin = {
       parameters: {
         type: 'object',
         properties: {
-          resource: { type: 'string', enum: ['agents', 'tasks', 'schedules', 'skills', 'documents', 'secrets', 'connectors', 'sessions'] },
+          resource: { type: 'string', enum: ['agents', 'projects', 'tasks', 'schedules', 'skills', 'documents', 'secrets', 'connectors', 'sessions'] },
           action: { type: 'string', enum: ['list', 'get', 'create', 'update', 'delete'] },
           id: { type: 'string' },
           data: { type: 'string' }
         },
         required: ['resource', 'action']
       },
-      execute: async (args, context) => executePlatformAction(args, { ...context.session, ctx: context.session })
+      execute: async (args, context) => executePlatformAction(args, buildPlatformContextFromSession(context.session))
     }
   ]
 }

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

@@ -0,0 +1,17 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import { inferWebActionFromArgs } from './web'
+
+describe('inferWebActionFromArgs', () => {
+  it('defaults to search when only query text is provided', () => {
+    assert.equal(inferWebActionFromArgs({ query: 'latest US-Iran news' }), 'search')
+  })
+
+  it('defaults to fetch when the url is an absolute http url', () => {
+    assert.equal(inferWebActionFromArgs({ url: 'https://example.com/article' }), 'fetch')
+  })
+
+  it('preserves an explicit action when present', () => {
+    assert.equal(inferWebActionFromArgs({ action: 'search', url: 'https://example.com/article' }), 'search')
+  })
+})

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

@@ -159,13 +159,30 @@ export function cleanupSessionBrowser(sessionId: string): void {
 export function getActiveBrowserCount(): number { return activeBrowsers.size }
 export function hasActiveBrowser(sessionId: string): boolean { return activeBrowsers.has(sessionId) }
 
+export function inferWebActionFromArgs(params: {
+  action?: string
+  query?: string
+  url?: string
+}): 'search' | 'fetch' | undefined {
+  if (params.action === 'search' || params.action === 'fetch') return params.action
+  if (typeof params.url === 'string' && /^https?:\/\//i.test(params.url.trim())) return 'fetch'
+  if (typeof params.query === 'string' && params.query.trim()) return 'search'
+  if (typeof params.url === 'string' && params.url.trim()) return 'search'
+  return undefined
+}
+
 /**
  * Unified Web Execution Logic
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 async function executeWebAction(args: Record<string, unknown>, bctx: any) {
   const normalized = normalizeToolInputArgs(args)
-  const { action, query, url, maxResults } = normalized as { action: string; query?: string; url?: string; maxResults?: number }
+  const { query, url, maxResults } = normalized as { query?: string; url?: string; maxResults?: number }
+  const action = inferWebActionFromArgs({
+    action: (normalized as { action?: string }).action,
+    query,
+    url,
+  })
   try {
     if (action === 'search') {
       const searchQuery = query || url
@@ -650,12 +667,141 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
     }
 
     const dismissCookieBanners = async (mcpCall: (toolName: string, args: Record<string, unknown>) => Promise<string>) => {
-      await new Promise((r) => setTimeout(r, 1500))
+      await new Promise((r) => setTimeout(r, 1200))
       const js = `() => {
-        const sel = ['button[id*="reject" i]', 'button[class*="reject" i]', 'a[id*="reject" i]', 'a[class*="reject" i]', '#onetrust-reject-all-handler', '#CybotCookiebotDialogBodyButtonDecline', '#didomi-notice-disagree-button', '.qc-cmp2-summary-buttons button:first-child', 'button.sp_choice_type_12'];
-        for (const s of sel) { const el = document.querySelector(s); if (el && el.offsetParent !== null) { el.click(); return 'dismissed:' + s; } }
-        const btns = [...document.querySelectorAll('button, a[role="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; } }
+        const docs = [document];
+        const roots = [document];
+        const seenRoots = new Set([document]);
+        const pushRoot = (root) => {
+          if (!root || seenRoots.has(root)) return;
+          seenRoots.add(root);
+          roots.push(root);
+        };
+        const collectFrames = (doc) => {
+          try {
+            const frames = doc.querySelectorAll('iframe');
+            for (const frame of frames) {
+              try {
+                const child = frame.contentDocument || frame.contentWindow?.document;
+                if (child && !docs.includes(child)) {
+                  docs.push(child);
+                  pushRoot(child);
+                }
+              } catch {}
+            }
+          } catch {}
+        };
+        const collectShadowRoots = () => {
+          for (const root of [...roots]) {
+            try {
+              const all = root.querySelectorAll('*');
+              for (const el of all) {
+                if (el.shadowRoot) pushRoot(el.shadowRoot);
+              }
+            } catch {}
+          }
+        };
+        collectFrames(document);
+        collectShadowRoots();
+        const allRoots = [...new Set([...docs, ...roots])];
+        const visible = (el) => {
+          if (!el) return false;
+          const style = window.getComputedStyle(el);
+          if (!style || style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
+          const rect = el.getBoundingClientRect();
+          return rect.width > 0 && rect.height > 0;
+        };
+        const normalizedText = (value) => String(value || '').replace(/\\s+/g, ' ').trim();
+        const candidateSelectors = [
+          '#onetrust-reject-all-handler',
+          '#CybotCookiebotDialogBodyButtonDecline',
+          '#didomi-notice-disagree-button',
+          '.qc-cmp2-summary-buttons button:first-child',
+          'button.sp_choice_type_12',
+          'button[id*="reject" i]',
+          'button[class*="reject" i]',
+          'button[id*="decline" i]',
+          'button[class*="decline" i]',
+          'button[id*="consent" i]',
+          'button[class*="consent" i]',
+          'a[id*="reject" i]',
+          'a[class*="reject" i]',
+          'a[id*="decline" i]',
+          'a[class*="decline" i]'
+        ];
+        for (const root of allRoots) {
+          for (const selector of candidateSelectors) {
+            try {
+              const el = root.querySelector(selector);
+              if (el && visible(el)) {
+                el.click();
+                return 'clicked:' + selector;
+              }
+            } catch {}
+          }
+        }
+        const buttonSelector = 'button, a[role="button"], [role="button"], input[type="button"], input[type="submit"]';
+        const rejectRe = /^(reject|reject all|decline|decline all|deny|deny all|refuse|no,? thanks|only necessary|necessary only|use necessary cookies only)$/i;
+        const acceptRe = /^(accept|accept all|allow all|agree|i agree|okay|ok|got it|continue|consent)$/i;
+        const closeRe = /^(close|dismiss|skip|not now|x|×)$/i;
+        const clickMatching = (matcher, label) => {
+          for (const root of allRoots) {
+            let buttons = [];
+            try { buttons = [...root.querySelectorAll(buttonSelector)]; } catch {}
+            for (const button of buttons) {
+              const txt = normalizedText(button.textContent || button.getAttribute?.('aria-label') || button.getAttribute?.('value'));
+              if (!txt || !matcher.test(txt) || !visible(button)) continue;
+              try {
+                button.click();
+                return label + ':' + txt.slice(0, 80);
+              } catch {}
+            }
+          }
+          return null;
+        };
+        const clicked = clickMatching(rejectRe, 'reject') || clickMatching(acceptRe, 'accept') || clickMatching(closeRe, 'close');
+        if (clicked) return clicked;
+        const overlaySelectors = [
+          '#onetrust-banner-sdk',
+          '#onetrust-consent-sdk',
+          '#CybotCookiebotDialog',
+          '.didomi-popup-container',
+          '.fc-consent-root',
+          '[id*="cookie" i]',
+          '[class*="cookie" i]',
+          '[id*="consent" i]',
+          '[class*="consent" i]',
+          '[id*="privacy" i]',
+          '[class*="privacy" i]',
+          '[id*="sp_message" i]',
+          '[class*="sp_message" i]'
+        ];
+        const hidden = [];
+        for (const root of allRoots) {
+          for (const selector of overlaySelectors) {
+            let nodes = [];
+            try { nodes = [...root.querySelectorAll(selector)]; } catch {}
+            for (const node of nodes) {
+              if (!visible(node)) continue;
+              const text = normalizedText(node.textContent).toLowerCase();
+              const attrs = normalizedText(node.id + ' ' + node.className).toLowerCase();
+              if (!text.includes('cookie') && !text.includes('consent') && !text.includes('privacy') && !attrs.includes('cookie') && !attrs.includes('consent') && !attrs.includes('privacy') && !attrs.includes('onetrust') && !attrs.includes('didomi') && !attrs.includes('sp_message')) continue;
+              try {
+                node.style.setProperty('display', 'none', 'important');
+                node.style.setProperty('visibility', 'hidden', 'important');
+                node.style.setProperty('pointer-events', 'none', 'important');
+                hidden.push(selector);
+              } catch {}
+            }
+          }
+        }
+        if (hidden.length) {
+          try {
+            document.documentElement.style.removeProperty('overflow');
+            document.body.style.removeProperty('overflow');
+          } catch {}
+          return 'hidden:' + hidden[0];
+        }
         return 'none';
       }`
       await mcpCall('browser_evaluate', { function: js })
@@ -1139,6 +1285,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
               } catch {
                 await new Promise((r) => setTimeout(r, 1200))
               }
+              try { await dismissCookieBanners(callMcpTool) } catch { /* ignore */ }
             }
 
             let result = await callMcpTool(mcpTool, args, { saveTo: typeof params.saveTo === 'string' ? params.saveTo : undefined })

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

@@ -2,7 +2,7 @@ import assert from 'node:assert/strict'
 import fs from 'node:fs'
 import path from 'node:path'
 import { describe, it } from 'node:test'
-import { buildToolDisciplineLines, looksLikeOpenEndedDeliverableTask } from './stream-agent-chat'
+import { buildToolDisciplineLines, getExplicitRequiredToolNames, looksLikeOpenEndedDeliverableTask } from './stream-agent-chat'
 
 const streamAgentChatSource = fs.readFileSync(path.join(path.dirname(new URL(import.meta.url).pathname), 'stream-agent-chat.ts'), 'utf-8')
 
@@ -27,19 +27,44 @@ describe('buildToolDisciplineLines', () => {
   })
 
   it('warns browser tasks to use literal urls and the supported form schema', () => {
-    const lines = buildToolDisciplineLines(['browser', 'http_request', 'email', 'ask_human'])
+    const lines = buildToolDisciplineLines(['web_search', 'web_fetch', 'browser', 'manage_connectors', 'http_request', 'email', 'ask_human'])
 
     assert.ok(lines.some((line) => line.includes('Do not invent placeholder URLs')))
     assert.ok(lines.some((line) => line.includes('A shorthand `form` object keyed by input id/name also works')))
+    assert.ok(lines.some((line) => line.includes('For current events, breaking news, or "latest" requests, start with `web_search`')))
+    assert.ok(lines.some((line) => line.includes('Use `browser` when the user asks for screenshots')))
+    assert.ok(lines.some((line) => line.includes('do not capture screenshots') && line.includes('`browser`')))
+    assert.ok(lines.some((line) => line.includes('connector_message_tool') && line.includes('list_running')))
+    assert.ok(lines.some((line) => line.includes('connector/channel setup is missing')))
+    assert.ok(lines.some((line) => line.includes('capture the artifact first with `browser`') && line.includes('`connector_message_tool`')))
     assert.ok(lines.some((line) => line.includes('Keep JSON request bodies as raw JSON strings')))
     assert.ok(lines.some((line) => line.includes('{"action":"send","to":"user@example.com","subject":"...","body":"..."}')))
     assert.ok(lines.some((line) => line.includes('do not guess or keep re-submitting blank forms')))
   })
 
+  it('requires research, browser, and connector tools for hybrid news delivery requests', () => {
+    const required = getExplicitRequiredToolNames(
+      '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'],
+    )
+
+    assert.deepEqual(required, ['web_search', 'browser', 'connector_message_tool'])
+  })
+
+  it('requires connector delivery for explicit channel requests', () => {
+    const required = getExplicitRequiredToolNames(
+      'Research the latest launch news, take a screenshot, and send it to me over Slack.',
+      ['web_search', 'browser', 'manage_connectors'],
+    )
+
+    assert.deepEqual(required, ['web_search', 'browser', 'connector_message_tool'])
+  })
+
   it('tells the agent that named enabled tools are completion requirements', () => {
     assert.ok(streamAgentChatSource.includes('If a task explicitly names an enabled tool, use that tool before declaring success.'))
     assert.ok(streamAgentChatSource.includes('collect required human input through the tool'))
     assert.ok(streamAgentChatSource.includes('You have not yet completed the required explicit tool step(s):'))
+    assert.ok(streamAgentChatSource.includes('do not replace screenshot requests with text-only summaries'))
     assert.ok(streamAgentChatSource.includes('[Loop Budget Reached]'))
   })
 })