@swarmclawai/swarmclaw 0.3.1 → 0.4.5

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

@@ -5,29 +5,9 @@ import path from 'path'
 import * as cheerio from 'cheerio'
 import { UPLOAD_DIR } from '../storage'
 import type { ToolBuildContext } from './context'
-import { safePath, truncate, MAX_OUTPUT } from './context'
-
-// ---------------------------------------------------------------------------
-// DuckDuckGo redirect-URL decoder
-// ---------------------------------------------------------------------------
-
-function decodeDuckDuckGoUrl(rawUrl: string): string {
-  if (!rawUrl) return rawUrl
-  try {
-    const url = rawUrl.startsWith('http')
-      ? new URL(rawUrl)
-      : new URL(rawUrl, 'https://duckduckgo.com')
-    const uddg = url.searchParams.get('uddg')
-    if (uddg) return decodeURIComponent(uddg)
-    return url.toString()
-  } catch {
-    const fromQuery = rawUrl.match(/[?&]uddg=([^&]+)/)?.[1]
-    if (fromQuery) {
-      try { return decodeURIComponent(fromQuery) } catch { /* noop */ }
-    }
-    return rawUrl
-  }
-}
+import { spawnSync } from 'child_process'
+import { safePath, truncate, MAX_OUTPUT, findBinaryOnPath } from './context'
+import { getSearchProvider } from './search-providers'
 
 // ---------------------------------------------------------------------------
 // Global registry of active browser instances for cleanup sweeps
@@ -86,48 +66,10 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
         async ({ query, maxResults }) => {
           try {
             const limit = Math.min(maxResults || 5, 10)
-            const url = `https://duckduckgo.com/html/?q=${encodeURIComponent(query)}`
-            const res = await fetch(url, {
-              headers: { 'User-Agent': 'Mozilla/5.0 (compatible; SwarmClaw/1.0)' },
-              signal: AbortSignal.timeout(15000),
-            })
-            if (!res.ok) {
-              return `Error searching web: HTTP ${res.status} ${res.statusText}`
-            }
-            const html = await res.text()
-            const $ = cheerio.load(html)
-            const results: { title: string; url: string; snippet: string }[] = []
-
-            // Primary parser: DuckDuckGo result cards
-            $('.result').each((_i, el) => {
-              if (results.length >= limit) return false
-              const link = $(el).find('a.result__a').first()
-              const rawHref = link.attr('href') || ''
-              const title = link.text().replace(/\s+/g, ' ').trim()
-              if (!rawHref || !title) return
-              const snippet = $(el).find('.result__snippet').first().text().replace(/\s+/g, ' ').trim()
-              results.push({
-                title,
-                url: decodeDuckDuckGoUrl(rawHref),
-                snippet,
-              })
-            })
-
-            // Fallback parser: any result__a anchors
-            if (results.length === 0) {
-              $('a.result__a').each((_i, el) => {
-                if (results.length >= limit) return false
-                const rawHref = $(el).attr('href') || ''
-                const title = $(el).text().replace(/\s+/g, ' ').trim()
-                if (!rawHref || !title) return
-                results.push({
-                  title,
-                  url: decodeDuckDuckGoUrl(rawHref),
-                  snippet: '',
-                })
-              })
-            }
-
+            const { loadSettings } = await import('../storage')
+            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.'
@@ -137,7 +79,7 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
         },
         {
           name: 'web_search',
-          description: 'Search the web using DuckDuckGo. Returns an array of results with title, url, and snippet.',
+          description: 'Search the web. Returns an array of results with title, url, and snippet.',
           schema: z.object({
             query: z.string().describe('Search query'),
             maxResults: z.number().optional().describe('Maximum results to return (default 5, max 10)'),
@@ -404,5 +346,44 @@ export function buildWebTools(bctx: ToolBuildContext): StructuredToolInterface[]
     )
   }
 
+  // ---- openclaw_browser (CLI passthrough) -----------------------------------
+
+  if (bctx.hasTool('browser') || bctx.hasTool('openclaw_browser')) {
+    const openclawPath = findBinaryOnPath('openclaw') || findBinaryOnPath('clawdbot')
+    if (openclawPath) {
+      tools.push(
+        tool(
+          async ({ command, args: cmdArgs }) => {
+            try {
+              const spawnArgs = ['browser', command, '--json']
+              if (cmdArgs) spawnArgs.push(...cmdArgs.split(/\s+/).filter(Boolean))
+              const result = spawnSync(openclawPath, spawnArgs, {
+                encoding: 'utf-8',
+                timeout: 60_000,
+                maxBuffer: MAX_OUTPUT,
+              })
+              const stdout = (result.stdout || '').trim()
+              const stderr = (result.stderr || '').trim()
+              if (result.status !== 0) {
+                return `Error (exit ${result.status}): ${stderr || stdout || 'unknown error'}`
+              }
+              return truncate(stdout || '(no output)', MAX_OUTPUT)
+            } catch (err: any) {
+              return `Error: ${err.message}`
+            }
+          },
+          {
+            name: 'openclaw_browser',
+            description: 'Control a browser through the OpenClaw CLI. Requires openclaw/clawdbot CLI on PATH. Passes through to `openclaw browser <command> --json`.',
+            schema: z.object({
+              command: z.string().describe('Browser command (navigate, screenshot, click, type, evaluate, etc.)'),
+              args: z.string().optional().describe('Additional arguments as a space-separated string'),
+            }),
+          },
+        ),
+      )
+    }
+  }
+
   return tools
 }

package/src/lib/server/storage-mcp.test.ts

@@ -33,8 +33,15 @@ function loadMcpServers(): Record<string, any> {
 }
 
 function saveMcpServers(m: Record<string, any>) {
+  const existingRows = db.prepare(`SELECT id FROM ${TABLE}`).all() as { id: string }[]
+  const nextIds = new Set(Object.keys(m))
+  const toDelete = existingRows.map((r) => r.id).filter((id) => !nextIds.has(id))
   const upsert = db.prepare(`INSERT OR REPLACE INTO ${TABLE} (id, data) VALUES (?, ?)`)
+  const del = db.prepare(`DELETE FROM ${TABLE} WHERE id = ?`)
   const transaction = db.transaction(() => {
+    for (const id of toDelete) {
+      del.run(id)
+    }
     for (const [id, val] of Object.entries(m)) {
       upsert.run(id, JSON.stringify(val))
     }
@@ -75,8 +82,10 @@ describe('MCP server storage', () => {
   })
 
   it('loadMcpServers returns all saved configs', () => {
-    // srv-1 already exists from previous test
-    saveMcpServers({ 'srv-2': { id: 'srv-2', name: 'Second' } })
+    saveMcpServers({
+      'srv-1': { id: 'srv-1', name: 'First' },
+      'srv-2': { id: 'srv-2', name: 'Second' },
+    })
 
     const all = loadMcpServers()
     assert.ok('srv-1' in all)
@@ -102,6 +111,20 @@ describe('MCP server storage', () => {
     assert.equal(count, 1)
   })
 
+  it('saveMcpServers removes records omitted from the next save payload', () => {
+    saveMcpServers({
+      'srv-a': { id: 'srv-a', name: 'A' },
+      'srv-b': { id: 'srv-b', name: 'B' },
+    })
+    saveMcpServers({
+      'srv-b': { id: 'srv-b', name: 'B2' },
+    })
+
+    const all = loadMcpServers()
+    assert.equal('srv-a' in all, false)
+    assert.equal(all['srv-b'].name, 'B2')
+  })
+
   it('deleteMcpServer removes the record', () => {
     saveMcpServers({ 'srv-d': { id: 'srv-d', name: 'ToDelete' } })
     deleteMcpServer('srv-d')

package/src/lib/server/storage.ts

@@ -4,11 +4,11 @@ import crypto from 'crypto'
 import os from 'os'
 import Database from 'better-sqlite3'
 
-import { DATA_DIR } from './data-dir'
-export const UPLOAD_DIR = path.join(os.tmpdir(), 'swarmclaw-uploads')
+import { DATA_DIR, WORKSPACE_DIR } from './data-dir'
+export const UPLOAD_DIR = path.join(DATA_DIR, 'uploads')
 
 // Ensure directories exist
-for (const dir of [DATA_DIR, UPLOAD_DIR]) {
+for (const dir of [DATA_DIR, UPLOAD_DIR, WORKSPACE_DIR]) {
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
 }
 
@@ -43,6 +43,7 @@ const COLLECTIONS = [
   'model_overrides',
   'mcp_servers',
   'webhook_logs',
+  'projects',
 ] as const
 
 for (const table of COLLECTIONS) {
@@ -65,8 +66,8 @@ function readCollectionRaw(table: string): Map<string, string> {
 }
 
 function getCollectionRawCache(table: string): Map<string, string> {
-  const cached = collectionCache.get(table)
-  if (cached) return cached
+  // Always reload from SQLite so concurrent Next.js workers/processes
+  // observe each other's writes immediately.
   const loaded = readCollectionRaw(table)
   collectionCache.set(table, loaded)
   return loaded
@@ -87,26 +88,43 @@ function loadCollection(table: string): Record<string, any> {
 
 function saveCollection(table: string, data: Record<string, any>) {
   const current = getCollectionRawCache(table)
+  const next = new Map<string, string>()
   const toUpsert: Array<[string, string]> = []
+  const toDelete: string[] = []
 
   for (const [id, val] of Object.entries(data)) {
     const serialized = JSON.stringify(val)
     if (typeof serialized !== 'string') continue
+    next.set(id, serialized)
     if (current.get(id) !== serialized) {
       toUpsert.push([id, serialized])
     }
-    current.set(id, serialized)
   }
 
-  if (!toUpsert.length) return
+  for (const id of current.keys()) {
+    if (!next.has(id)) toDelete.push(id)
+  }
+
+  if (!toUpsert.length && !toDelete.length) return
 
   const transaction = db.transaction(() => {
+    if (toDelete.length) {
+      const del = db.prepare(`DELETE FROM ${table} WHERE id = ?`)
+      for (const id of toDelete) del.run(id)
+    }
     const upsert = db.prepare(`INSERT OR REPLACE INTO ${table} (id, data) VALUES (?, ?)`)
     for (const [id, serialized] of toUpsert) {
       upsert.run(id, serialized)
     }
   })
   transaction()
+
+  for (const id of toDelete) {
+    current.delete(id)
+  }
+  for (const [id, serialized] of next.entries()) {
+    current.set(id, serialized)
+  }
 }
 
 function deleteCollectionItem(table: string, id: string) {
@@ -559,6 +577,17 @@ export function saveModelOverrides(m: Record<string, string[]>) {
   saveCollection('model_overrides', m)
 }
 
+// --- Projects ---
+export function loadProjects(): Record<string, any> {
+  return loadCollection('projects')
+}
+
+export function saveProjects(s: Record<string, any>) {
+  saveCollection('projects', s)
+}
+
+export function deleteProject(id: string) { deleteCollectionItem('projects', id) }
+
 // --- Skills ---
 export function loadSkills(): Record<string, any> {
   return loadCollection('skills')

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

@@ -15,6 +15,7 @@ interface StreamAgentChatOpts {
   session: Session
   message: string
   imagePath?: string
+  attachedFiles?: string[]
   apiKey: string | null
   systemPrompt?: string
   write: (data: string) => void
@@ -38,6 +39,7 @@ function buildToolCapabilityLines(enabledTools: string[]): string[] {
   if (enabledTools.includes('codex_cli')) lines.push('- Codex delegation is available (`delegate_to_codex_cli`) for deep coding/refactor tasks. Resume IDs may be returned via `[delegate_meta]`.')
   if (enabledTools.includes('opencode_cli')) lines.push('- OpenCode delegation is available (`delegate_to_opencode_cli`) for deep coding/refactor tasks. Resume IDs may be returned via `[delegate_meta]`.')
   if (enabledTools.includes('memory')) lines.push('- Long-term memory is available (`memory_tool`) to store and recall durable context.')
+  if (enabledTools.includes('sandbox')) lines.push('- Sandboxed code execution is available (`sandbox_exec`). Write and run JS/TS (Deno) or Python scripts in an isolated environment. Output includes stdout, stderr, and any files created as downloadable artifacts.')
   if (enabledTools.includes('manage_agents')) lines.push('- Agent management is available (`manage_agents`) to create or adjust specialist agents.')
   if (enabledTools.includes('manage_tasks')) lines.push('- Task management is available (`manage_tasks`) to create and track execution plans.')
   if (enabledTools.includes('manage_schedules')) lines.push('- Schedule management is available (`manage_schedules`) for recurring/ongoing runs.')
@@ -162,15 +164,24 @@ export interface StreamAgentChatResult {
 }
 
 export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<StreamAgentChatResult> {
-  const { session, message, imagePath, apiKey, systemPrompt, write, history, fallbackCredentialIds, signal } = opts
+  const { session, message, imagePath, attachedFiles, apiKey, systemPrompt, write, history, fallbackCredentialIds, signal } = opts
 
   // fallbackCredentialIds is intentionally accepted for compatibility with caller signatures.
   void fallbackCredentialIds
+
+  // Resolve agent's thinking level for provider-native params
+  let agentThinkingLevel: 'minimal' | 'low' | 'medium' | 'high' | undefined
+  if (session.agentId) {
+    const agentsForThinking = loadAgents()
+    agentThinkingLevel = agentsForThinking[session.agentId]?.thinkingLevel
+  }
+
   const llm = buildChatModel({
     provider: session.provider,
     model: session.model,
     apiKey,
     apiEndpoint: session.apiEndpoint,
+    thinkingLevel: agentThinkingLevel,
   })
 
   // Build stateModifier
@@ -226,6 +237,17 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     stateModifierParts.push('You are a capable AI assistant with tool access. Be execution-oriented and outcome-focused.')
   }
 
+  // Thinking level guidance (applies to all providers via system prompt)
+  if (agentThinkingLevel) {
+    const thinkingGuidance: Record<string, string> = {
+      minimal: 'Be direct and concise. Skip extended analysis.',
+      low: 'Keep reasoning brief. Focus on key conclusions.',
+      medium: 'Provide moderate depth of analysis and reasoning.',
+      high: 'Think deeply and thoroughly. Show detailed reasoning.',
+    }
+    stateModifierParts.push(`## Reasoning Depth\n${thinkingGuidance[agentThinkingLevel]}`)
+  }
+
   if ((session.tools || []).includes('memory') && session.agentId) {
     try {
       const memDb = getMemoryDb()
@@ -310,7 +332,6 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     const allToolIds = [
       'shell', 'files', 'edit_file', 'process', 'web_search', 'web_fetch', 'browser', 'memory',
       'claude_code', 'codex_cli', 'opencode_cli',
-      'orchestrator',
       'manage_agents', 'manage_tasks', 'manage_schedules', 'manage_skills',
       'manage_documents', 'manage_webhooks', 'manage_connectors', 'manage_sessions', 'manage_secrets',
     ]
@@ -318,13 +339,9 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     const mcpDisabled = agentMcpDisabledTools ?? []
     const allDisabled = [...disabled, ...mcpDisabled]
     if (allDisabled.length > 0) {
-      const delegateNote = disabled.includes('orchestrator')
-        ? '\n\nIMPORTANT: The `delegate_to_agent` tool requires the `orchestrator` capability to be enabled. You must request access to `orchestrator` before you can delegate work to other agents.'
-        : ''
       stateModifierParts.push(
         `## Disabled Tools\nThe following tools exist but are not enabled for you: ${allDisabled.join(', ')}.\n` +
-        'If you need one of these to complete a task, use the `request_tool_access` tool to ask the user for permission.' +
-        delegateNote,
+        'If you need one of these to complete a task, use the `request_tool_access` tool to ask the user for permission.',
       )
     }
   }
@@ -354,25 +371,82 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
   const IMAGE_EXTS = /\.(png|jpg|jpeg|gif|webp|bmp)$/i
   const TEXT_EXTS = /\.(txt|md|csv|json|xml|html|js|ts|tsx|jsx|py|go|rs|java|c|cpp|h|yml|yaml|toml|env|log|sh|sql|css|scss)$/i
 
-  function buildLangChainContent(text: string, filePath?: string): any {
-    if (!filePath || !fs.existsSync(filePath)) return text
+  async function buildContentForFile(filePath: string): Promise<{ type: string; [k: string]: any } | string | null> {
+    if (!fs.existsSync(filePath)) {
+      console.log(`[stream-agent-chat] FILE NOT FOUND: ${filePath}`)
+      return null
+    }
+    const name = filePath.split('/').pop() || 'file'
     if (IMAGE_EXTS.test(filePath)) {
-      const data = fs.readFileSync(filePath).toString('base64')
+      const buf = fs.readFileSync(filePath)
+      if (buf.length === 0) {
+        console.warn(`[stream-agent-chat] Image file is empty: ${filePath}`)
+        return `[Attached image: ${name} — file is empty]`
+      }
+      const data = buf.toString('base64')
       const ext = filePath.split('.').pop()?.toLowerCase() || 'png'
-      const mimeType = ext === 'jpg' ? 'image/jpeg' : `image/${ext}`
-      return [
-        { type: 'image_url', image_url: { url: `data:${mimeType};base64,${data}` } },
-        { type: 'text', text },
-      ]
+      // Detect actual MIME from magic bytes (fall back to extension-based)
+      let mimeType = ext === 'jpg' ? 'image/jpeg' : `image/${ext}`
+      if (buf[0] === 0xFF && buf[1] === 0xD8) mimeType = 'image/jpeg'
+      else if (buf[0] === 0x89 && buf[1] === 0x50) mimeType = 'image/png'
+      else if (buf[0] === 0x47 && buf[1] === 0x49) mimeType = 'image/gif'
+      else if (buf[0] === 0x52 && buf[1] === 0x49) mimeType = 'image/webp'
+      return { type: 'image_url', image_url: { url: `data:${mimeType};base64,${data}`, detail: 'auto' } }
+    }
+    if (filePath.endsWith('.pdf')) {
+      try {
+        // @ts-ignore — pdf-parse types
+        const pdfParse = (await import(/* webpackIgnore: true */ 'pdf-parse')).default
+        const buf = fs.readFileSync(filePath)
+        const result = await pdfParse(buf)
+        const pdfText = (result.text || '').trim()
+        if (!pdfText) return `[Attached PDF: ${name} — no extractable text]`
+        // Truncate very large PDFs to avoid token limits
+        const maxChars = 100_000
+        const truncated = pdfText.length > maxChars ? pdfText.slice(0, maxChars) + '\n\n[... truncated]' : pdfText
+        return `[Attached PDF: ${name} (${result.numpages} pages)]\n\n${truncated}`
+      } catch {
+        return `[Attached PDF: ${name} — could not extract text]`
+      }
     }
-    if (TEXT_EXTS.test(filePath) || filePath.endsWith('.pdf')) {
+    if (TEXT_EXTS.test(filePath)) {
       try {
         const fileContent = fs.readFileSync(filePath, 'utf-8')
-        const name = filePath.split('/').pop() || 'file'
-        return `[Attached file: ${name}]\n\n${fileContent}\n\n${text}`
-      } catch { return text }
+        return `[Attached file: ${name}]\n\n${fileContent}`
+      } catch { return `[Attached file: ${name} — read error]` }
     }
-    return `[Attached file: ${filePath.split('/').pop()}]\n\n${text}`
+    return `[Attached file: ${name}]`
+  }
+
+  async function buildLangChainContent(text: string, filePath?: string, extraFiles?: string[]): Promise<any> {
+    const filePaths: string[] = []
+    if (filePath) filePaths.push(filePath)
+    if (extraFiles?.length) {
+      for (const f of extraFiles) {
+        if (f && !filePaths.includes(f)) filePaths.push(f)
+      }
+    }
+    if (!filePaths.length) return text
+
+    const parts: any[] = []
+    const textParts: string[] = []
+    for (const fp of filePaths) {
+      const content = await buildContentForFile(fp)
+      if (!content) continue
+      if (typeof content === 'string') {
+        textParts.push(content)
+      } else {
+        parts.push(content)
+      }
+    }
+
+    const combinedText = textParts.length
+      ? `${textParts.join('\n\n')}\n\n${text}`
+      : text
+
+    if (parts.length === 0) return combinedText
+    parts.push({ type: 'text', text: combinedText })
+    return parts
   }
 
   // Auto-compaction: prune old history if approaching context window limit
@@ -397,14 +471,15 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
   const langchainMessages: Array<HumanMessage | AIMessage> = []
   for (const m of effectiveHistory.slice(-20)) {
     if (m.role === 'user') {
-      langchainMessages.push(new HumanMessage({ content: buildLangChainContent(m.text, m.imagePath) }))
+      langchainMessages.push(new HumanMessage({ content: await buildLangChainContent(m.text, m.imagePath, m.attachedFiles) }))
     } else {
       langchainMessages.push(new AIMessage({ content: m.text }))
     }
   }
 
   // Add current message
-  langchainMessages.push(new HumanMessage({ content: buildLangChainContent(message, imagePath) }))
+  const currentContent = await buildLangChainContent(message, imagePath, attachedFiles)
+  langchainMessages.push(new HumanMessage({ content: currentContent }))
 
   let fullText = ''
   let lastSegment = ''
@@ -557,6 +632,15 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
   // Plugin hooks: afterAgentComplete
   await pluginMgr.runHook('afterAgentComplete', { session, response: fullText })
 
+  // OpenClaw auto-sync: push memory if enabled
+  try {
+    const { loadSyncConfig, pushMemoryToOpenClaw } = await import('./openclaw-sync')
+    const syncConfig = loadSyncConfig()
+    if (syncConfig.autoSyncMemory) {
+      pushMemoryToOpenClaw(session.agentId || undefined)
+    }
+  } catch { /* OpenClaw sync not available — ignore */ }
+
   // Clean up browser and other session resources
   await cleanup()
 

package/src/lib/server/task-result.test.ts

@@ -0,0 +1,44 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { extractTaskResult } from './task-result'
+
+describe('extractTaskResult', () => {
+  it('limits artifact extraction to messages from the current run window', () => {
+    const session = {
+      messages: [
+        {
+          role: 'assistant',
+          time: 1_000,
+          text: 'old run artifact: /api/uploads/wiki-old.png',
+        },
+        {
+          role: 'assistant',
+          time: 2_000,
+          text: 'new run artifact: /api/uploads/wiki-new.png',
+        },
+      ],
+    }
+
+    const result = extractTaskResult(session, 'done', { sinceTime: 1_500 })
+    assert.deepEqual(result.artifacts.map((a) => a.url), ['/api/uploads/wiki-new.png'])
+  })
+
+  it('excludes messages without timestamps when sinceTime is provided', () => {
+    const session = {
+      messages: [
+        {
+          role: 'assistant',
+          text: 'undated artifact: /api/uploads/undated.png',
+        },
+        {
+          role: 'assistant',
+          time: 5_000,
+          text: 'dated artifact: /api/uploads/dated.png',
+        },
+      ],
+    }
+
+    const result = extractTaskResult(session, 'done', { sinceTime: 4_000 })
+    assert.deepEqual(result.artifacts.map((a) => a.url), ['/api/uploads/dated.png'])
+  })
+})

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

@@ -43,6 +43,7 @@ function classifyArtifact(filename: string): Artifact['type'] {
 interface MessageLike {
   role?: string
   text?: string
+  time?: number
   imageUrl?: string
   imagePath?: string
   toolEvents?: Array<{ name?: string; output?: string }>
@@ -52,6 +53,10 @@ interface SessionLike {
   messages?: MessageLike[]
 }
 
+interface ExtractTaskResultOptions {
+  sinceTime?: number | null
+}
+
 // ---------------------------------------------------------------------------
 // Core extraction
 // ---------------------------------------------------------------------------
@@ -64,9 +69,13 @@ interface SessionLike {
 export function extractTaskResult(
   session: SessionLike | null | undefined,
   rawResultText: string | null | undefined,
+  options?: ExtractTaskResultOptions,
 ): TaskResult {
   const seen = new Set<string>()
   const artifacts: Artifact[] = []
+  const sinceTime = typeof options?.sinceTime === 'number' && Number.isFinite(options.sinceTime)
+    ? options.sinceTime
+    : null
 
   function addUrl(raw: string) {
     const url = stripSandbox(raw)
@@ -79,6 +88,11 @@ export function extractTaskResult(
   // Walk session messages to collect all artifact URLs
   if (Array.isArray(session?.messages)) {
     for (const msg of session.messages) {
+      if (sinceTime !== null) {
+        const msgTime = typeof msg.time === 'number' && Number.isFinite(msg.time) ? msg.time : null
+        if (msgTime === null || msgTime < sinceTime) continue
+      }
+
       // Explicit image fields
       if (msg.imageUrl) addUrl(msg.imageUrl)
       if (msg.imagePath) {

package/src/lib/server/task-validation.test.ts

@@ -25,3 +25,26 @@ test('validateTaskCompletion accepts screenshot delivery tasks with upload artif
 
   assert.equal(validation.ok, true)
 })
+
+test('validateTaskCompletion accepts concise non-implementation result summaries', () => {
+  const validation = validateTaskCompletion({
+    title: 'Answer greeting',
+    description: 'Respond to a basic hello prompt.',
+    result: 'Hello! How can I help you today?',
+    error: null,
+  } as Partial<BoardTask>)
+
+  assert.equal(validation.ok, true)
+})
+
+test('validateTaskCompletion still enforces stricter minimum for implementation tasks', () => {
+  const validation = validateTaskCompletion({
+    title: 'Fix retry bug',
+    description: 'Implement queue retry fixes and verify.',
+    result: 'Patched queue retry bug.',
+    error: null,
+  } as Partial<BoardTask>)
+
+  assert.equal(validation.ok, false)
+  assert.ok(validation.reasons.some((reason) => reason.includes('Result summary is too short')))
+})

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

@@ -11,7 +11,8 @@ interface TaskCompletionValidationOptions {
   report?: TaskReportArtifact | null
 }
 
-const MIN_RESULT_CHARS = 40
+const MIN_RESULT_CHARS_IMPLEMENTATION = 40
+const MIN_RESULT_CHARS_GENERIC = 20
 
 const WEAK_RESULT_PATTERNS: RegExp[] = [
   /what can i help you with/i,
@@ -45,12 +46,14 @@ export function validateTaskCompletion(
   const result = normalizeText(task.result)
   const error = normalizeText(task.error)
   const report = options.report || null
+  const implementationTask = IMPLEMENTATION_HINT.test(title) || IMPLEMENTATION_HINT.test(description)
 
   if (error) reasons.push('Task has a non-empty error field.')
 
   if (!result) reasons.push('Result summary is empty.')
   else {
-    if (result.length < MIN_RESULT_CHARS) reasons.push(`Result summary is too short (${result.length} chars).`)
+    const minChars = implementationTask ? MIN_RESULT_CHARS_IMPLEMENTATION : MIN_RESULT_CHARS_GENERIC
+    if (result.length < minChars) reasons.push(`Result summary is too short (${result.length} chars; min ${minChars}).`)
     if (WEAK_RESULT_PATTERNS.some((rx) => rx.test(result))) {
       reasons.push('Result contains placeholder/planning language instead of completion evidence.')
     }
@@ -58,7 +61,6 @@ export function validateTaskCompletion(
 
   // If task description/title suggests implementation work, require concrete evidence in
   // the result summary OR task report.
-  const implementationTask = IMPLEMENTATION_HINT.test(title) || IMPLEMENTATION_HINT.test(description)
   const hasResultEvidence = EXECUTION_EVIDENCE.test(result)
   const hasReportEvidence = report?.evidence.hasEvidence === true
   if (implementationTask && !hasResultEvidence && !hasReportEvidence) {