@swarmclawai/swarmclaw 0.2.0

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

@@ -0,0 +1,122 @@
+import fs from 'fs'
+import path from 'path'
+import type { BoardTask } from '@/types'
+
+import { DATA_DIR } from './data-dir'
+
+const REPORTS_DIR = path.join(DATA_DIR, 'task-reports')
+const MAX_REPORT_BODY = 6_000
+
+const COMMAND_HINT = /\b(npm|pnpm|yarn|bun|node|npx|pytest|vitest|jest|playwright|go test|cargo test|deno test|python|pip|uv|docker|git)\b/i
+const FILE_HINT = /\b([\w./-]+\.(ts|tsx|js|jsx|mjs|cjs|json|md|css|scss|html|yml|yaml|sh|py|go|rs|java|kt|swift|rb|php|sql))\b/i
+const VERIFICATION_HINT = /\b(test|tests|passed|failed|failing|lint|typecheck|build|verified|verification)\b/i
+
+export interface TaskReportEvidence {
+  changedFiles: string[]
+  commandsRun: string[]
+  verification: string[]
+  hasEvidence: boolean
+}
+
+export interface TaskReportArtifact {
+  absolutePath: string
+  relativePath: string
+  evidence: TaskReportEvidence
+}
+
+function normalizeLine(value: string): string {
+  return value.replace(/\s+/g, ' ').trim()
+}
+
+function toLines(value: string): string[] {
+  return value
+    .split(/\r?\n/)
+    .map((line) => normalizeLine(line.replace(/^[-*]\s+/, '')))
+    .filter(Boolean)
+}
+
+function uniqueTop(values: string[], limit = 8): string[] {
+  const out: string[] = []
+  const seen = new Set<string>()
+  for (const value of values) {
+    const key = value.toLowerCase()
+    if (seen.has(key)) continue
+    seen.add(key)
+    out.push(value)
+    if (out.length >= limit) break
+  }
+  return out
+}
+
+function extractEvidence(result: string): TaskReportEvidence {
+  const lines = toLines(result)
+  const changedFiles = uniqueTop(lines.filter((line) => FILE_HINT.test(line)))
+  const commandsRun = uniqueTop(lines.filter((line) => COMMAND_HINT.test(line)))
+  const verification = uniqueTop(lines.filter((line) => VERIFICATION_HINT.test(line)))
+
+  return {
+    changedFiles,
+    commandsRun,
+    verification,
+    hasEvidence: changedFiles.length > 0 || commandsRun.length > 0 || verification.length > 0,
+  }
+}
+
+function bullets(title: string, values: string[]): string[] {
+  if (!values.length) return [`## ${title}`, '- Not provided', '']
+  return [`## ${title}`, ...values.map((value) => `- ${value}`), '']
+}
+
+export function ensureTaskCompletionReport(task: Partial<BoardTask>): TaskReportArtifact | null {
+  const id = typeof task.id === 'string' ? task.id.trim() : ''
+  if (!id) return null
+
+  const title = typeof task.title === 'string' && task.title.trim() ? task.title.trim() : 'Untitled Task'
+  const description = typeof task.description === 'string' ? task.description.trim() : ''
+  const result = typeof task.result === 'string' ? task.result.trim() : ''
+  const evidence = extractEvidence(result)
+
+  const reportPath = path.join(REPORTS_DIR, `${id}.md`)
+  const relativePath = path.relative(process.cwd(), reportPath)
+  const reportLines: string[] = [
+    `# Task ${id}: ${title}`,
+    '',
+    `- Status: ${task.status || 'unknown'}`,
+    `- Agent: ${task.agentId || 'unassigned'}`,
+    `- Session: ${task.sessionId || 'none'}`,
+    '',
+  ]
+
+  if (description) {
+    reportLines.push('## Description')
+    reportLines.push(description)
+    reportLines.push('')
+  }
+
+  if (result) {
+    reportLines.push('## Result Summary')
+    reportLines.push(result.slice(0, MAX_REPORT_BODY))
+    reportLines.push('')
+  } else {
+    reportLines.push('## Result Summary')
+    reportLines.push('No result summary provided.')
+    reportLines.push('')
+  }
+
+  reportLines.push(...bullets('Changed Files', evidence.changedFiles))
+  reportLines.push(...bullets('Commands Run', evidence.commandsRun))
+  reportLines.push(...bullets('Verification', evidence.verification))
+
+  const content = `${reportLines.join('\n').trim()}\n`
+  fs.mkdirSync(REPORTS_DIR, { recursive: true })
+  const current = fs.existsSync(reportPath) ? fs.readFileSync(reportPath, 'utf8') : null
+  if (current !== content) {
+    fs.writeFileSync(reportPath, content, 'utf8')
+  }
+
+  return {
+    absolutePath: reportPath,
+    relativePath,
+    evidence,
+  }
+}

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

@@ -0,0 +1,161 @@
+import { z } from 'zod'
+
+// ---------------------------------------------------------------------------
+// Zod schemas for structured task result extraction
+// ---------------------------------------------------------------------------
+
+export const ArtifactSchema = z.object({
+  url: z.string(),
+  type: z.enum(['image', 'video', 'pdf', 'file']),
+  filename: z.string(),
+})
+
+export const TaskResultSchema = z.object({
+  summary: z.string(),
+  artifacts: z.array(ArtifactSchema),
+})
+
+export type Artifact = z.infer<typeof ArtifactSchema>
+export type TaskResult = z.infer<typeof TaskResultSchema>
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const SANDBOX_RE = /^sandbox:/
+const UPLOAD_URL_RE = /(?:sandbox:)?\/api\/uploads\/[^\s)"'>\]]+/gi
+
+function stripSandbox(url: string): string {
+  return url.replace(SANDBOX_RE, '')
+}
+
+function classifyArtifact(filename: string): Artifact['type'] {
+  if (/\.(png|jpe?g|gif|webp|svg|bmp|ico)$/i.test(filename)) return 'image'
+  if (/\.(mp4|webm|mov|avi)$/i.test(filename)) return 'video'
+  if (/\.pdf$/i.test(filename)) return 'pdf'
+  return 'file'
+}
+
+// ---------------------------------------------------------------------------
+// Session message types (loose to avoid coupling to full types)
+// ---------------------------------------------------------------------------
+
+interface MessageLike {
+  role?: string
+  text?: string
+  imageUrl?: string
+  imagePath?: string
+  toolEvents?: Array<{ name?: string; output?: string }>
+}
+
+interface SessionLike {
+  messages?: MessageLike[]
+}
+
+// ---------------------------------------------------------------------------
+// Core extraction
+// ---------------------------------------------------------------------------
+
+/**
+ * Walk a session's messages and extract all artifacts + a clean summary.
+ * Replaces the old regex-based `extractLatestUploadUrl` and
+ * `summarizeScheduleTaskResult` with a single Zod-validated pass.
+ */
+export function extractTaskResult(
+  session: SessionLike | null | undefined,
+  rawResultText: string | null | undefined,
+): TaskResult {
+  const seen = new Set<string>()
+  const artifacts: Artifact[] = []
+
+  function addUrl(raw: string) {
+    const url = stripSandbox(raw)
+    if (seen.has(url)) return
+    seen.add(url)
+    const filename = url.split('/').pop()?.split('?')[0] || 'file'
+    artifacts.push({ url, type: classifyArtifact(filename), filename })
+  }
+
+  // Walk session messages to collect all artifact URLs
+  if (Array.isArray(session?.messages)) {
+    for (const msg of session.messages) {
+      // Explicit image fields
+      if (msg.imageUrl) addUrl(msg.imageUrl)
+      if (msg.imagePath) {
+        const basename = String(msg.imagePath).split('/').pop()
+        if (basename) addUrl(`/api/uploads/${basename}`)
+      }
+
+      // Scan message text
+      const text = typeof msg.text === 'string' ? msg.text : ''
+      for (const m of text.matchAll(UPLOAD_URL_RE)) addUrl(m[0])
+
+      // Scan tool event outputs
+      if (Array.isArray(msg.toolEvents)) {
+        for (const ev of msg.toolEvents) {
+          const output = typeof ev.output === 'string' ? ev.output : ''
+          for (const m of output.matchAll(UPLOAD_URL_RE)) addUrl(m[0])
+        }
+      }
+    }
+  }
+
+  // Clean summary: strip sandbox: prefixes from the raw text
+  const summary = (typeof rawResultText === 'string' ? rawResultText.trim() : '')
+    .replace(/sandbox:\/api\/uploads\//g, '/api/uploads/')
+
+  return TaskResultSchema.parse({ summary, artifacts })
+}
+
+// ---------------------------------------------------------------------------
+// Formatting helpers for thread / main-chat messages
+// ---------------------------------------------------------------------------
+
+/**
+ * Build the markdown body for a task result notification.
+ * Uses the same markdown patterns the chat bubble renderer already handles:
+ *   - `![alt](url)` for images and videos → rendered as <img> / <video>
+ *   - `[filename](url)` for PDFs and other files → rendered as download link
+ */
+export function formatResultBody(result: TaskResult): string {
+  const parts: string[] = []
+
+  if (result.summary) {
+    // Remove any existing markdown image/link references to artifacts
+    // we'll re-add them properly below
+    let clean = result.summary
+    for (const a of result.artifacts) {
+      // Remove ![...](url) and [...](url) patterns for this artifact
+      clean = clean
+        .replace(new RegExp(`!\\[[^\\]]*\\]\\(${escapeRegex(a.url)}\\)`, 'g'), '')
+        .replace(new RegExp(`\\[[^\\]]*\\]\\(${escapeRegex(a.url)}\\)`, 'g'), '')
+    }
+    clean = clean.replace(/\n{3,}/g, '\n\n').trim()
+    if (clean) parts.push(clean)
+  }
+
+  // Add artifacts with proper markdown for each type
+  for (const artifact of result.artifacts) {
+    switch (artifact.type) {
+      case 'image':
+        parts.push(`![${artifact.filename}](${artifact.url})`)
+        break
+      case 'video':
+        // Markdown img with video extension → chat renderer uses <video>
+        parts.push(`![${artifact.filename}](${artifact.url})`)
+        break
+      case 'pdf':
+        parts.push(`[${artifact.filename}](${artifact.url})`)
+        break
+      case 'file':
+        parts.push(`[${artifact.filename}](${artifact.url})`)
+        break
+    }
+  }
+
+  return parts.join('\n\n')
+}
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}

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

@@ -0,0 +1,27 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { validateTaskCompletion } from './task-validation.ts'
+import type { BoardTask } from '@/types'
+
+test('validateTaskCompletion fails screenshot delivery tasks without artifact evidence', () => {
+  const validation = validateTaskCompletion({
+    title: 'Take screenshot and send it every minute',
+    description: 'Schedule a screenshot capture and deliver it to the user.',
+    result: 'Existing schedule verified for taking screenshots every minute. Waiting for next run.',
+    error: null,
+  } as Partial<BoardTask>)
+
+  assert.equal(validation.ok, false)
+  assert.ok(validation.reasons.some((reason) => reason.includes('Screenshot delivery task is missing artifact evidence')))
+})
+
+test('validateTaskCompletion accepts screenshot delivery tasks with upload artifact evidence', () => {
+  const validation = validateTaskCompletion({
+    title: 'Take screenshot and send it',
+    description: 'Capture Wikipedia and return the file to the user.',
+    result: 'Captured and sent screenshot successfully: sandbox:/api/uploads/1234-wikipedia.png',
+    error: null,
+  } as Partial<BoardTask>)
+
+  assert.equal(validation.ok, true)
+})

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

@@ -0,0 +1,90 @@
+import type { BoardTask } from '@/types'
+import type { TaskReportArtifact } from './task-reports'
+
+export interface TaskCompletionValidation {
+  ok: boolean
+  reasons: string[]
+  checkedAt: number
+}
+
+interface TaskCompletionValidationOptions {
+  report?: TaskReportArtifact | null
+}
+
+const MIN_RESULT_CHARS = 40
+
+const WEAK_RESULT_PATTERNS: RegExp[] = [
+  /what can i help you with/i,
+  /waiting for approval/i,
+  /now let me write/i,
+  /what'?s the play/i,
+  /\bthe plan covers\b/i,
+  /now update the agent/i,
+  /\bzero typescript errors\b/i,
+]
+
+const IMPLEMENTATION_HINT = /\b(add|build|create|fix|implement|integrat|refactor|update|write)\b/i
+const EXECUTION_EVIDENCE = /\b(changed|updated|added|modified|files?|commands?|tests?|build|lint|typecheck|verified|report)\b/i
+const SCREENSHOT_HINT = /\b(screenshot|screen shot|snapshot|capture)\b/i
+const DELIVERY_HINT = /\b(send|deliver|return|share|upload|post|message)\b/i
+const SCREENSHOT_ARTIFACT_HINT = /(?:sandbox:)?\/api\/uploads\/[^\s)\]]+|https?:\/\/[^\s)\]]+\.(?:png|jpe?g|webp|gif|pdf)\b/i
+const SENT_SCREENSHOT_HINT = /\b(sent|shared|uploaded|returned)\b[^.]*\b(screenshot|snapshot|image)\b/i
+
+function normalizeText(value: unknown): string {
+  if (typeof value !== 'string') return ''
+  return value.replace(/\s+/g, ' ').trim()
+}
+
+export function validateTaskCompletion(
+  task: Partial<BoardTask>,
+  options: TaskCompletionValidationOptions = {},
+): TaskCompletionValidation {
+  const reasons: string[] = []
+  const title = normalizeText(task.title)
+  const description = normalizeText(task.description)
+  const result = normalizeText(task.result)
+  const error = normalizeText(task.error)
+  const report = options.report || null
+
+  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).`)
+    if (WEAK_RESULT_PATTERNS.some((rx) => rx.test(result))) {
+      reasons.push('Result contains placeholder/planning language instead of completion evidence.')
+    }
+  }
+
+  // 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) {
+    if (report?.relativePath) {
+      reasons.push(`Implementation task is missing concrete execution evidence in result or ${report.relativePath}.`)
+    } else {
+      reasons.push('Implementation task is missing concrete execution evidence in result.')
+    }
+  }
+
+  const screenshotTask = SCREENSHOT_HINT.test(title) || SCREENSHOT_HINT.test(description)
+  const screenshotDeliveryTask = screenshotTask && (DELIVERY_HINT.test(title) || DELIVERY_HINT.test(description))
+  if (screenshotDeliveryTask) {
+    const hasScreenshotArtifact = SCREENSHOT_ARTIFACT_HINT.test(result) || SENT_SCREENSHOT_HINT.test(result)
+    if (!hasScreenshotArtifact) {
+      reasons.push('Screenshot delivery task is missing artifact evidence (upload link or explicit sent screenshot confirmation).')
+    }
+  }
+
+  return {
+    ok: reasons.length === 0,
+    reasons,
+    checkedAt: Date.now(),
+  }
+}
+
+export function formatValidationFailure(reasons: string[]): string {
+  return `Completion validation failed: ${reasons.join(' ')}`
+}

package/src/lib/server/tool-capability-policy.test.ts

@@ -0,0 +1,58 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import {
+  resolveConcreteToolPolicyBlock,
+  resolveSessionToolPolicy,
+} from './tool-capability-policy.ts'
+
+test('capability policy permissive mode allows non-blocked tools', () => {
+  const decision = resolveSessionToolPolicy(['shell', 'web_search'], { capabilityPolicyMode: 'permissive' })
+  assert.deepEqual(decision.enabledTools, ['shell', 'web_search'])
+  assert.equal(decision.blockedTools.length, 0)
+})
+
+test('capability policy balanced mode blocks destructive delete_file', () => {
+  const decision = resolveSessionToolPolicy(['files', 'delete_file'], { capabilityPolicyMode: 'balanced' })
+  assert.deepEqual(decision.enabledTools, ['files'])
+  assert.equal(decision.blockedTools.length, 1)
+  assert.equal(decision.blockedTools[0].tool, 'delete_file')
+})
+
+test('capability policy strict mode blocks execution/platform families', () => {
+  const decision = resolveSessionToolPolicy(
+    ['shell', 'manage_tasks', 'web_search', 'memory'],
+    { capabilityPolicyMode: 'strict' },
+  )
+  assert.deepEqual(decision.enabledTools, ['web_search', 'memory'])
+  assert.equal(decision.blockedTools.some((entry) => entry.tool === 'shell'), true)
+  assert.equal(decision.blockedTools.some((entry) => entry.tool === 'manage_tasks'), true)
+})
+
+test('capability policy respects explicit allow overrides', () => {
+  const decision = resolveSessionToolPolicy(
+    ['shell', 'web_search'],
+    {
+      capabilityPolicyMode: 'strict',
+      capabilityAllowedTools: ['shell'],
+    },
+  )
+  assert.deepEqual(decision.enabledTools, ['shell', 'web_search'])
+})
+
+test('concrete tool checks inherit blocked family rules', () => {
+  const decision = resolveSessionToolPolicy(
+    ['claude_code', 'codex_cli'],
+    {
+      safetyBlockedTools: ['delegate_to_codex_cli'],
+    },
+  )
+
+  assert.equal(
+    resolveConcreteToolPolicyBlock('delegate_to_codex_cli', decision, { safetyBlockedTools: ['delegate_to_codex_cli'] }),
+    'blocked by safety policy',
+  )
+  assert.equal(
+    resolveConcreteToolPolicyBlock('delegate_to_claude_code', decision, { safetyBlockedTools: ['delegate_to_codex_cli'] }),
+    null,
+  )
+})