@swarmclawai/swarmclaw 0.6.8 → 0.7.0

package/src/lib/server/task-quality-gate.test.ts

@@ -0,0 +1,44 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { normalizeTaskQualityGate } from './task-quality-gate.ts'
+
+test('normalizeTaskQualityGate uses defaults when unset', () => {
+  const gate = normalizeTaskQualityGate(undefined, undefined)
+  assert.equal(gate.enabled, true)
+  assert.equal(gate.minResultChars, 80)
+  assert.equal(gate.minEvidenceItems, 2)
+  assert.equal(gate.requireVerification, false)
+  assert.equal(gate.requireArtifact, false)
+  assert.equal(gate.requireReport, false)
+})
+
+test('normalizeTaskQualityGate respects app settings defaults', () => {
+  const gate = normalizeTaskQualityGate(null, {
+    taskQualityGateEnabled: false,
+    taskQualityGateMinResultChars: 120,
+    taskQualityGateMinEvidenceItems: 1,
+    taskQualityGateRequireVerification: true,
+  })
+  assert.equal(gate.enabled, false)
+  assert.equal(gate.minResultChars, 120)
+  assert.equal(gate.minEvidenceItems, 1)
+  assert.equal(gate.requireVerification, true)
+})
+
+test('normalizeTaskQualityGate allows per-task overrides on top of settings', () => {
+  const gate = normalizeTaskQualityGate({
+    enabled: true,
+    minResultChars: 64,
+    minEvidenceItems: 3,
+    requireArtifact: true,
+  }, {
+    taskQualityGateEnabled: false,
+    taskQualityGateMinResultChars: 120,
+    taskQualityGateMinEvidenceItems: 1,
+    taskQualityGateRequireArtifact: false,
+  })
+  assert.equal(gate.enabled, true)
+  assert.equal(gate.minResultChars, 64)
+  assert.equal(gate.minEvidenceItems, 3)
+  assert.equal(gate.requireArtifact, true)
+})

package/src/lib/server/task-quality-gate.ts

@@ -0,0 +1,67 @@
+import type { AppSettings, TaskQualityGateConfig } from '@/types'
+
+export interface NormalizedTaskQualityGate {
+  enabled: boolean
+  minResultChars: number
+  minEvidenceItems: number
+  requireVerification: boolean
+  requireArtifact: boolean
+  requireReport: boolean
+}
+
+export const DEFAULT_TASK_QUALITY_GATE: NormalizedTaskQualityGate = {
+  enabled: true,
+  minResultChars: 80,
+  minEvidenceItems: 2,
+  requireVerification: false,
+  requireArtifact: false,
+  requireReport: false,
+}
+
+function normalizeInt(value: unknown, fallback: number, min: number, max: number): number {
+  const parsed = typeof value === 'number'
+    ? value
+    : typeof value === 'string'
+      ? Number.parseInt(value, 10)
+      : Number.NaN
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.max(min, Math.min(max, Math.trunc(parsed)))
+}
+
+function normalizeBool(value: unknown, fallback: boolean): boolean {
+  if (typeof value === 'boolean') return value
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase()
+    if (['1', 'true', 'yes', 'on'].includes(normalized)) return true
+    if (['0', 'false', 'no', 'off'].includes(normalized)) return false
+  }
+  return fallback
+}
+
+function normalizeSettingsDefaults(settings?: AppSettings | Record<string, unknown> | null): NormalizedTaskQualityGate {
+  const raw = settings && typeof settings === 'object' ? settings as Record<string, unknown> : {}
+  return {
+    enabled: normalizeBool(raw.taskQualityGateEnabled, DEFAULT_TASK_QUALITY_GATE.enabled),
+    minResultChars: normalizeInt(raw.taskQualityGateMinResultChars, DEFAULT_TASK_QUALITY_GATE.minResultChars, 10, 2000),
+    minEvidenceItems: normalizeInt(raw.taskQualityGateMinEvidenceItems, DEFAULT_TASK_QUALITY_GATE.minEvidenceItems, 0, 8),
+    requireVerification: normalizeBool(raw.taskQualityGateRequireVerification, DEFAULT_TASK_QUALITY_GATE.requireVerification),
+    requireArtifact: normalizeBool(raw.taskQualityGateRequireArtifact, DEFAULT_TASK_QUALITY_GATE.requireArtifact),
+    requireReport: normalizeBool(raw.taskQualityGateRequireReport, DEFAULT_TASK_QUALITY_GATE.requireReport),
+  }
+}
+
+export function normalizeTaskQualityGate(
+  rawGate?: TaskQualityGateConfig | Record<string, unknown> | null,
+  settings?: AppSettings | Record<string, unknown> | null,
+): NormalizedTaskQualityGate {
+  const defaults = normalizeSettingsDefaults(settings)
+  const raw = rawGate && typeof rawGate === 'object' ? rawGate as Record<string, unknown> : {}
+  return {
+    enabled: normalizeBool(raw.enabled, defaults.enabled),
+    minResultChars: normalizeInt(raw.minResultChars, defaults.minResultChars, 10, 2000),
+    minEvidenceItems: normalizeInt(raw.minEvidenceItems, defaults.minEvidenceItems, 0, 8),
+    requireVerification: normalizeBool(raw.requireVerification, defaults.requireVerification),
+    requireArtifact: normalizeBool(raw.requireArtifact, defaults.requireArtifact),
+    requireReport: normalizeBool(raw.requireReport, defaults.requireReport),
+  }
+}

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

@@ -48,3 +48,81 @@ test('validateTaskCompletion still enforces stricter minimum for implementation
   assert.equal(validation.ok, false)
   assert.ok(validation.reasons.some((reason) => reason.includes('Result summary is too short')))
 })
+
+test('validateTaskCompletion fails implementation task with unfinished next-step language', () => {
+  const validation = validateTaskCompletion({
+    title: 'Build weather dashboard',
+    description: 'Implement dashboard and run dev server.',
+    result: 'I prepared an outline. Next I will run the server once access is granted.',
+    error: null,
+  } as Partial<BoardTask>)
+
+  assert.equal(validation.ok, false)
+  assert.ok(validation.reasons.some((reason) => reason.includes('unfinished work')))
+})
+
+test('validateTaskCompletion fails implementation task that requests shell access', () => {
+  const validation = validateTaskCompletion({
+    title: 'Create blog and run server',
+    description: 'Create markdown blog and serve it.',
+    result: 'I created the blog file at data/workspace/blog/swarmclaw-blog.md, but I need access to the shell to proceed. Once the access is granted, I will finish setup.',
+    error: null,
+  } as Partial<BoardTask>)
+
+  assert.equal(validation.ok, false)
+  assert.ok(validation.reasons.some((reason) => reason.includes('unfinished work')))
+})
+
+test('validateTaskCompletion fails untitled tasks with empty metadata', () => {
+  const validation = validateTaskCompletion({
+    title: 'Untitled Task',
+    description: '',
+    result: 'Could you provide more information about what you need?',
+    error: null,
+  } as Partial<BoardTask>)
+
+  assert.equal(validation.ok, false)
+  assert.ok(validation.reasons.some((reason) => reason.includes('metadata is too vague')))
+})
+
+test('validateTaskCompletion enforces explicit quality gate evidence requirements', () => {
+  const validation = validateTaskCompletion({
+    title: 'Ship API migration summary',
+    description: 'Summarize the migration outcome.',
+    result: 'Migration summary completed successfully with no extra artifacts included.',
+    qualityGate: {
+      enabled: true,
+      minResultChars: 20,
+      minEvidenceItems: 2,
+      requireArtifact: true,
+    },
+    error: null,
+  } as Partial<BoardTask>)
+
+  assert.equal(validation.ok, false)
+  assert.ok(validation.reasons.some((reason) => reason.includes('insufficient completion evidence')))
+  assert.ok(validation.reasons.some((reason) => reason.includes('artifact evidence is required')))
+})
+
+test('validateTaskCompletion passes explicit quality gate when evidence checks are met', () => {
+  const validation = validateTaskCompletion({
+    title: 'Ship API migration summary',
+    description: 'Summarize the migration outcome.',
+    result: 'Ran npm test and tests passed. Updated src/api/migrate.ts. Uploaded evidence: sandbox:/api/uploads/migration-proof.png.',
+    artifacts: [{
+      url: 'sandbox:/api/uploads/migration-proof.png',
+      type: 'image',
+      filename: 'migration-proof.png',
+    }],
+    qualityGate: {
+      enabled: true,
+      minResultChars: 20,
+      minEvidenceItems: 2,
+      requireArtifact: true,
+      requireVerification: true,
+    },
+    error: null,
+  } as Partial<BoardTask>)
+
+  assert.equal(validation.ok, true)
+})

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

@@ -1,5 +1,6 @@
 import type { BoardTask } from '@/types'
 import type { TaskReportArtifact } from './task-reports'
+import { normalizeTaskQualityGate } from './task-quality-gate'
 
 export interface TaskCompletionValidation {
   ok: boolean
@@ -9,6 +10,7 @@ export interface TaskCompletionValidation {
 
 interface TaskCompletionValidationOptions {
   report?: TaskReportArtifact | null
+  settings?: Record<string, unknown> | null
 }
 
 const MIN_RESULT_CHARS_IMPLEMENTATION = 40
@@ -24,8 +26,26 @@ const WEAK_RESULT_PATTERNS: RegExp[] = [
   /\bzero typescript errors\b/i,
 ]
 
+const INCOMPLETE_RESULT_PATTERNS: RegExp[] = [
+  /\b(?:next|then)\s*,?\s*i\s+(?:will|can|am going to)\b/i,
+  /\b(?:i(?:'| a)?ll|let me)\s+(?:start|begin|proceed|continue)\b/i,
+  /\b(?:once|when|after)\s+(?:the\s+)?(?:access|approval|permission)\s+(?:is|has been)\s+granted\b/i,
+  /\bneed (?:more )?(?:details|information|context)\b/i,
+  /\b(?:i|we)\s+(?:need|require)\s+(?:access|approval|permission)\b/i,
+  /\brequested\s+(?:access|approval|permission)\b/i,
+  /\bneed access to (?:the )?(?:shell|terminal|command line)\b/i,
+  /\battempted to\b[^.]{0,120}\b(?:but|however)\b/i,
+  /\bcould you provide\b/i,
+  /\blet me know once\b/i,
+  /\bthere (?:aren't|are not) any specific details\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 EXECUTION_ACTION_HINT = /\b(changed|updated|added|modified|implemented|refactored|fixed|ran|executed|verified)\b/i
+const COMMAND_EVIDENCE_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_PATH_EVIDENCE_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|txt)\b/i
+const ARTIFACT_EVIDENCE_HINT = /(?:sandbox:)?\/api\/uploads\/[^\s)\]]+|https?:\/\/[^\s)\]]+\.(?:png|jpe?g|webp|gif|pdf|zip)\b/i
+const VERIFICATION_EVIDENCE_HINT = /\b(test|tests|lint|typecheck|build)\b[^.]{0,40}\b(pass(?:ed)?|fail(?:ed)?|ok|success)\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
@@ -46,9 +66,14 @@ export function validateTaskCompletion(
   const result = normalizeText(task.result)
   const error = normalizeText(task.error)
   const report = options.report || null
+  const hasExplicitQualityGate = !!task.qualityGate && typeof task.qualityGate === 'object'
+  const qualityGate = normalizeTaskQualityGate(task.qualityGate || null, options.settings || null)
   const implementationTask = IMPLEMENTATION_HINT.test(title) || IMPLEMENTATION_HINT.test(description)
 
   if (error) reasons.push('Task has a non-empty error field.')
+  if (/^untitled task$/i.test(title) && !description) {
+    reasons.push('Task metadata is too vague (untitled title with empty description).')
+  }
 
   if (!result) reasons.push('Result summary is empty.')
   else {
@@ -57,11 +82,20 @@ export function validateTaskCompletion(
     if (WEAK_RESULT_PATTERNS.some((rx) => rx.test(result))) {
       reasons.push('Result contains placeholder/planning language instead of completion evidence.')
     }
+    if (INCOMPLETE_RESULT_PATTERNS.some((rx) => rx.test(result))) {
+      reasons.push('Result indicates unfinished work or missing inputs instead of completed execution.')
+    }
   }
 
   // If task description/title suggests implementation work, require concrete evidence in
   // the result summary OR task report.
-  const hasResultEvidence = EXECUTION_EVIDENCE.test(result)
+  const hasResultEvidence = (
+    COMMAND_EVIDENCE_HINT.test(result)
+    || ARTIFACT_EVIDENCE_HINT.test(result)
+    || VERIFICATION_EVIDENCE_HINT.test(result)
+    || (EXECUTION_ACTION_HINT.test(result)
+      && (/\b(command|test|lint|typecheck|build|file|artifact)\b/i.test(result) || FILE_PATH_EVIDENCE_HINT.test(result)))
+  )
   const hasReportEvidence = report?.evidence.hasEvidence === true
   if (implementationTask && !hasResultEvidence && !hasReportEvidence) {
     if (report?.relativePath) {
@@ -80,6 +114,37 @@ export function validateTaskCompletion(
     }
   }
 
+  if (qualityGate.enabled && (implementationTask || hasExplicitQualityGate)) {
+    if (result && result.length < qualityGate.minResultChars) {
+      reasons.push(`Quality gate: result summary is shorter than required minimum (${result.length} chars; min ${qualityGate.minResultChars}).`)
+    }
+
+    const hasCommandEvidence = COMMAND_EVIDENCE_HINT.test(result) || (report?.evidence.commandsRun.length || 0) > 0
+    const hasFileEvidence = FILE_PATH_EVIDENCE_HINT.test(result) || (report?.evidence.changedFiles.length || 0) > 0
+    const hasVerificationEvidence = VERIFICATION_EVIDENCE_HINT.test(result) || (report?.evidence.verification.length || 0) > 0
+    const hasArtifactEvidence = ARTIFACT_EVIDENCE_HINT.test(result) || ((task.artifacts?.length || 0) > 0)
+
+    const evidenceSignals = [
+      hasCommandEvidence,
+      hasFileEvidence,
+      hasVerificationEvidence,
+      hasArtifactEvidence,
+    ].filter(Boolean).length
+
+    if (evidenceSignals < qualityGate.minEvidenceItems) {
+      reasons.push(`Quality gate: insufficient completion evidence (${evidenceSignals}/${qualityGate.minEvidenceItems} required evidence signals).`)
+    }
+    if (qualityGate.requireVerification && !hasVerificationEvidence) {
+      reasons.push('Quality gate: verification evidence is required (tests/lint/build/check output missing).')
+    }
+    if (qualityGate.requireArtifact && !hasArtifactEvidence) {
+      reasons.push('Quality gate: artifact evidence is required (artifact URL/upload or structured artifacts list missing).')
+    }
+    if (qualityGate.requireReport && !report?.relativePath) {
+      reasons.push('Quality gate: task completion report is required but missing.')
+    }
+  }
+
   return {
     ok: reasons.length === 0,
     reasons,

package/src/lib/server/tool-aliases.ts

@@ -0,0 +1,68 @@
+const TOOL_ALIAS_GROUPS: string[][] = [
+  ['shell', 'execute_command', 'process_tool', 'process'],
+  ['files', 'read_file', 'write_file', 'list_files', 'copy_file', 'move_file', 'delete_file', 'send_file'],
+  ['edit_file'],
+  ['web', 'web_search', 'web_fetch'],
+  ['browser', 'openclaw_browser'],
+  ['delegate', 'claude_code', 'codex_cli', 'opencode_cli', 'delegate_to_claude_code', 'delegate_to_codex_cli', 'delegate_to_opencode_cli'],
+  ['manage_platform', 'manage_agents', 'manage_tasks', 'manage_schedules', 'manage_skills', 'manage_documents', 'manage_webhooks', 'manage_secrets', 'manage_sessions'],
+  ['manage_connectors', 'connectors', 'connector_message_tool'],
+  ['manage_chatrooms', 'chatroom'],
+  ['spawn_subagent', 'subagent', 'delegate_to_agent'],
+  ['manage_sessions', 'session_info', 'sessions_tool', 'whoami_tool', 'search_history_tool'],
+  ['schedule_wake', 'schedule'],
+  ['http_request', 'http'],
+  ['memory', 'memory_tool'],
+  ['sandbox', 'sandbox_exec', 'sandbox_list_runtimes'],
+  ['wallet', 'wallet_tool'],
+  ['monitor', 'monitor_tool'],
+  ['sample_ui', 'show_plugin_card'],
+  ['context_mgmt', 'context_status', 'context_summarize'],
+  ['openclaw_workspace'],
+  ['openclaw_nodes'],
+]
+
+const TOOL_ALIAS_MAP = (() => {
+  const map = new Map<string, Set<string>>()
+  for (const group of TOOL_ALIAS_GROUPS) {
+    const normalized = group.map((tool) => tool.trim().toLowerCase()).filter(Boolean)
+    for (const tool of normalized) {
+      const current = map.get(tool) || new Set<string>()
+      for (const alias of normalized) current.add(alias)
+      map.set(tool, current)
+    }
+  }
+  return map
+})()
+
+export function normalizeToolId(value: unknown): string {
+  return typeof value === 'string' ? value.trim().toLowerCase() : ''
+}
+
+export function expandToolIds(values: string[] | null | undefined): string[] {
+  if (!Array.isArray(values) || values.length === 0) return []
+  const expanded = new Set<string>()
+  const queue: string[] = values
+    .map((tool) => normalizeToolId(tool))
+    .filter(Boolean)
+
+  while (queue.length > 0) {
+    const next = queue.shift()!
+    if (expanded.has(next)) continue
+    expanded.add(next)
+    const aliases = TOOL_ALIAS_MAP.get(next)
+    if (!aliases) continue
+    for (const alias of aliases) {
+      if (!expanded.has(alias)) queue.push(alias)
+    }
+  }
+
+  return Array.from(expanded)
+}
+
+export function toolIdMatches(enabledTools: string[] | null | undefined, toolId: string): boolean {
+  const normalized = normalizeToolId(toolId)
+  if (!normalized) return false
+  return expandToolIds(enabledTools).includes(normalized)
+}
+

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

@@ -32,9 +32,9 @@ interface ToolDescriptor {
 }
 
 const TOOL_DESCRIPTORS: Record<string, ToolDescriptor> = {
-  shell: { categories: ['execution'], concreteTools: ['execute_command'] },
-  process: { categories: ['execution'], concreteTools: ['process_tool'] },
-  files: { categories: ['filesystem'], concreteTools: ['read_file', 'write_file', 'list_files', 'send_file'] },
+  shell: { categories: ['execution'], concreteTools: ['shell', 'execute_command'] },
+  process: { categories: ['execution'], concreteTools: ['process', 'process_tool'] },
+  files: { categories: ['filesystem'], concreteTools: ['files', 'read_file', 'write_file', 'list_files', 'send_file'] },
   read_file: { categories: ['filesystem'], concreteTools: ['read_file'] },
   write_file: { categories: ['filesystem'], concreteTools: ['write_file'] },
   list_files: { categories: ['filesystem'], concreteTools: ['list_files'] },
@@ -43,13 +43,24 @@ const TOOL_DESCRIPTORS: Record<string, ToolDescriptor> = {
   move_file: { categories: ['filesystem'], concreteTools: ['move_file'] },
   edit_file: { categories: ['filesystem'], concreteTools: ['edit_file'] },
   delete_file: { categories: ['filesystem'], concreteTools: ['delete_file'], destructive: true },
+  web: { categories: ['network'], concreteTools: ['web', 'web_search', 'web_fetch'] },
   web_search: { categories: ['network'], concreteTools: ['web_search'] },
   web_fetch: { categories: ['network'], concreteTools: ['web_fetch'] },
-  browser: { categories: ['browser', 'network'], concreteTools: ['browser'] },
+  browser: { categories: ['browser', 'network'], concreteTools: ['browser', 'openclaw_browser'] },
+  delegate: { categories: ['delegation', 'execution'], concreteTools: ['delegate', 'delegate_to_claude_code', 'delegate_to_codex_cli', 'delegate_to_opencode_cli'] },
   claude_code: { categories: ['delegation', 'execution'], concreteTools: ['delegate_to_claude_code'] },
   codex_cli: { categories: ['delegation', 'execution'], concreteTools: ['delegate_to_codex_cli'] },
   opencode_cli: { categories: ['delegation', 'execution'], concreteTools: ['delegate_to_opencode_cli'] },
-  memory: { categories: ['memory'], concreteTools: ['memory_tool', 'context_status', 'context_summarize'] },
+  memory: { categories: ['memory'], concreteTools: ['memory', 'memory_tool', 'context_status', 'context_summarize'] },
+  sandbox: { categories: ['execution', 'filesystem'], concreteTools: ['sandbox', 'sandbox_exec', 'sandbox_list_runtimes', 'openclaw_sandbox'] },
+  git: { categories: ['execution', 'filesystem'], concreteTools: ['git'] },
+  http_request: { categories: ['network'], concreteTools: ['http_request'] },
+  canvas: { categories: ['filesystem'], concreteTools: ['canvas'] },
+  wallet: { categories: ['outbound'], concreteTools: ['wallet', 'wallet_tool'] },
+  monitor: { categories: ['execution'], concreteTools: ['monitor', 'monitor_tool'] },
+  openclaw_workspace: { categories: ['filesystem', 'platform'], concreteTools: ['openclaw_workspace'] },
+  openclaw_nodes: { categories: ['platform'], concreteTools: ['openclaw_nodes'] },
+  manage_platform: { categories: ['platform'], concreteTools: ['manage_platform', 'manage_agents', 'manage_tasks', 'manage_schedules', 'manage_skills', 'manage_documents', 'manage_webhooks', 'manage_connectors', 'manage_sessions', 'manage_secrets'] },
   manage_agents: { categories: ['platform'], concreteTools: ['manage_agents'] },
   manage_tasks: { categories: ['platform'], concreteTools: ['manage_tasks'] },
   manage_schedules: { categories: ['platform'], concreteTools: ['manage_schedules'] },
@@ -57,9 +68,16 @@ const TOOL_DESCRIPTORS: Record<string, ToolDescriptor> = {
   manage_skills: { categories: ['platform'], concreteTools: ['manage_skills'] },
   manage_documents: { categories: ['platform'], concreteTools: ['manage_documents'] },
   manage_webhooks: { categories: ['platform', 'network'], concreteTools: ['manage_webhooks'] },
+  connectors: { categories: ['platform', 'outbound'], concreteTools: ['connectors', 'connector_message_tool'] },
   manage_connectors: { categories: ['platform', 'outbound'], concreteTools: ['manage_connectors', 'connector_message_tool'] },
+  session_info: { categories: ['platform'], concreteTools: ['session_info', 'sessions_tool', 'search_history_tool', 'whoami_tool'] },
   manage_sessions: { categories: ['platform'], concreteTools: ['manage_sessions', 'sessions_tool', 'search_history_tool', 'whoami_tool'] },
   manage_secrets: { categories: ['platform'], concreteTools: ['manage_secrets'] },
+  manage_chatrooms: { categories: ['platform'], concreteTools: ['manage_chatrooms', 'chatroom'] },
+  spawn_subagent: { categories: ['delegation', 'platform'], concreteTools: ['spawn_subagent', 'delegate_to_agent'] },
+  context_mgmt: { categories: ['memory'], concreteTools: ['context_mgmt', 'context_status', 'context_summarize'] },
+  plugin_creator: { categories: ['filesystem', 'execution'], concreteTools: ['plugin_creator', 'plugin_creator_tool'] },
+  sample_ui: { categories: ['platform'], concreteTools: ['sample_ui', 'show_plugin_card'] },
 }
 
 const CONCRETE_TOOL_TO_SESSION_TOOL = new Map<string, string>()

package/src/lib/tasks.ts

@@ -4,7 +4,13 @@ import type { BoardTask } from '../types'
 export const fetchTasks = (includeArchived = false) =>
   api<Record<string, BoardTask>>('GET', `/tasks${includeArchived ? '?includeArchived=true' : ''}`)
 
-export const createTask = (data: { title: string; description: string; agentId: string; status?: string }) =>
+export const createTask = (data: {
+  title: string
+  description: string
+  agentId: string
+  status?: string
+  qualityGate?: BoardTask['qualityGate']
+}) =>
   api<BoardTask>('POST', '/tasks', data)
 
 export const updateTask = (id: string, data: Partial<BoardTask>) =>

package/src/lib/tool-definitions.ts

@@ -4,40 +4,39 @@ export interface ToolDefinition {
   description: string
 }
 
+/** 
+ * Standard dynamic tools. 
+ * Many granular tools (read_file, write_file, etc.) are now unified under 'files'.
+ */
 export const AVAILABLE_TOOLS: ToolDefinition[] = [
-  { id: 'shell', label: 'Shell', description: 'Execute commands in the working directory' },
-  { id: 'files', label: 'Files', description: 'Read, write, list, move, copy, and send files' },
-  { id: 'copy_file', label: 'Copy File', description: 'Copy files within the working directory' },
-  { id: 'move_file', label: 'Move File', description: 'Move/rename files within the working directory' },
-  { id: 'delete_file', label: 'Delete File', description: 'Delete files/directories (disabled by default)' },
-  { id: 'edit_file', label: 'Edit File', description: 'Search-and-replace editing within files' },
-  { id: 'process', label: 'Process', description: 'Monitor and control long-running shell commands' },
-  { id: 'web_search', label: 'Web Search', description: 'Search the web via DuckDuckGo' },
-  { id: 'web_fetch', label: 'Web Fetch', description: 'Fetch and extract text from URLs' },
-  { id: 'claude_code', label: 'Claude Code', description: 'Delegate complex tasks to Claude Code CLI' },
-  { id: 'codex_cli', label: 'Codex CLI', description: 'Delegate complex tasks to OpenAI Codex CLI' },
-  { id: 'opencode_cli', label: 'OpenCode CLI', description: 'Delegate complex tasks to OpenCode CLI' },
+  { id: 'shell', label: 'Shell', description: 'Execute commands in the working directory and manage background processes' },
+  { id: 'files', label: 'Files', description: 'Complete file management: read, write, list, move, copy, delete, and send' },
+  { id: 'edit_file', label: 'Edit File', description: 'Surgical search-and-replace within files' },
+  { id: 'web', label: 'Web', description: 'Search the web via DuckDuckGo and fetch text from URLs' },
+  { id: 'delegate', label: 'Delegate', description: 'Delegate complex tasks to specialized backends (Claude Code, Codex, OpenCode)' },
   { id: 'browser', label: 'Browser', description: 'Playwright — browse, scrape, interact with web pages' },
   { id: 'memory', label: 'Memory', description: 'Store and retrieve long-term memories across conversations' },
-  { id: 'sandbox', label: 'Sandbox', description: 'Run JS/TS/Python code in an isolated Deno sandbox' },
+  { id: 'sandbox', label: 'Sandbox', description: 'Secure isolated code execution for JS, TS, and Python' },
   { id: 'create_document', label: 'Create Document', description: 'Render markdown to PDF, HTML, or image' },
   { id: 'create_spreadsheet', label: 'Create Spreadsheet', description: 'Create Excel or CSV files from structured data' },
-  { id: 'http_request', label: 'HTTP Request', description: 'Make HTTP API calls (GET, POST, PUT, DELETE, etc.)' },
+  { id: 'http_request', label: 'HTTP Request', description: 'Make direct HTTP API calls with custom methods, headers, and bodies' },
   { id: 'git', label: 'Git', description: 'Run structured git operations (status, commit, push, diff, etc.)' },
   { id: 'wallet', label: 'Wallet', description: 'Manage agent crypto wallet — check balance, send SOL, view transactions' },
+  { id: 'monitor', label: 'Monitor', description: 'System observability: check resource usage, watch logs, and ping endpoints' },
+  { id: 'plugin_creator', label: 'Plugin Creator', description: 'Design, write, and test custom SwarmClaw plugins dynamically' },
+  { id: 'sample_ui', label: 'Sample UI', description: 'Demonstration of dynamic UI injection into Sidebar and Chat Header' },
 ]
 
+/**
+ * Platform capability tools.
+ * Granular CRUD tools are now unified under 'manage_platform'.
+ */
 export const PLATFORM_TOOLS: ToolDefinition[] = [
-  { id: 'manage_agents', label: 'Agents', description: 'Create, edit, and delete agents' },
-  { id: 'manage_tasks', label: 'Tasks', description: 'Create, edit, and delete tasks' },
-  { id: 'manage_schedules', label: 'Schedules', description: 'Create, edit, and delete schedules' },
+  { id: 'manage_platform', label: 'Platform', description: 'Unified management of agents, tasks, schedules, skills, documents, and secrets' },
+  { id: 'manage_connectors', label: 'Connectors', description: 'Manage chat platform bridges and send outbound messages' },
+  { id: 'manage_chatrooms', label: 'Chatrooms', description: 'Manage SwarmClaw routing rules and multi-agent chatrooms' },
+  { id: 'delegate_to_agent', label: 'Assign Agent', description: 'Delegate a task to another specific agent' },
   { id: 'schedule_wake', label: 'Reminders', description: 'Schedule a proactive wake event in the current chat' },
-  { id: 'manage_skills', label: 'Skills', description: 'Create, edit, and delete skills' },
-  { id: 'manage_documents', label: 'Documents', description: 'Upload, search, and delete indexed documents' },
-  { id: 'manage_webhooks', label: 'Webhooks', description: 'Register webhooks that trigger agent workflows' },
-  { id: 'manage_connectors', label: 'Connectors', description: 'Create, edit, and delete connectors' },
-  { id: 'manage_sessions', label: 'Chats', description: 'List chats, send messages, and spawn agent work' },
-  { id: 'manage_secrets', label: 'Secrets', description: 'Store and retrieve encrypted service secrets' },
 ]
 
 export const ALL_TOOLS: ToolDefinition[] = [...AVAILABLE_TOOLS, ...PLATFORM_TOOLS]
@@ -46,3 +45,4 @@ export const ALL_TOOLS: ToolDefinition[] = [...AVAILABLE_TOOLS, ...PLATFORM_TOOL
 export const TOOL_LABELS: Record<string, string> = Object.fromEntries(
   ALL_TOOLS.map((t) => [t.id, t.label]),
 )
+

package/src/lib/validation/schemas.ts

@@ -15,6 +15,10 @@ export const AgentCreateSchema = z.object({
   thinkingLevel: z.string().optional(),
   soul: z.string().optional(),
   autoRecovery: z.boolean().optional().default(false),
+  monthlyBudget: z.number().positive().nullable().optional().default(null),
+  dailyBudget: z.number().positive().nullable().optional().default(null),
+  hourlyBudget: z.number().positive().nullable().optional().default(null),
+  budgetAction: z.enum(['warn', 'block']).optional().default('warn'),
 })
 
 export const ConnectorCreateSchema = z.object({
@@ -46,6 +50,14 @@ export const TaskCreateSchema = z.object({
   retryBackoffSec: z.number().optional(),
   priority: z.enum(['low', 'medium', 'high', 'critical']).optional(),
   dueAt: z.number().nullable().optional(),
+  qualityGate: z.object({
+    enabled: z.boolean().optional(),
+    minResultChars: z.number().optional(),
+    minEvidenceItems: z.number().optional(),
+    requireVerification: z.boolean().optional(),
+    requireArtifact: z.boolean().optional(),
+    requireReport: z.boolean().optional(),
+  }).nullable().optional(),
 })
 
 export const ChatroomCreateSchema = z.object({

package/src/lib/view-routes.ts

@@ -1,31 +1,9 @@
 import type { AppView } from '@/types'
+import { VIEW_ROUTE_PATHS } from '../../view-route-paths'
 
 export const DEFAULT_VIEW: AppView = 'home'
 
-export const VIEW_TO_PATH: Record<AppView, string> = {
-  home: '/',
-  agents: '/agents',
-  chatrooms: '/chatrooms',
-  schedules: '/schedules',
-  memory: '/memory',
-  tasks: '/tasks',
-  approvals: '/approvals',
-  secrets: '/secrets',
-  providers: '/providers',
-  skills: '/skills',
-  connectors: '/connectors',
-  webhooks: '/webhooks',
-  mcp_servers: '/mcp-servers',
-  knowledge: '/knowledge',
-  plugins: '/plugins',
-  usage: '/usage',
-  wallets: '/wallets',
-  runs: '/runs',
-  logs: '/logs',
-  settings: '/settings',
-  projects: '/projects',
-  activity: '/activity',
-}
+export const VIEW_TO_PATH: Record<AppView, string> = VIEW_ROUTE_PATHS
 
 const entries = Object.entries(VIEW_TO_PATH) as [AppView, string][]
 export const PATH_TO_VIEW: Record<string, AppView> = Object.fromEntries(

package/src/stores/use-app-store.ts

@@ -1,7 +1,7 @@
 'use client'
 
 import { create } from 'zustand'
-import type { Sessions, Session, NetworkInfo, Directory, ProviderInfo, Credentials, Agent, Schedule, AppView, BoardTask, AppSettings, OrchestratorSecret, ProviderConfig, Skill, Connector, Webhook, McpServerConfig, PluginMeta, Project, FleetFilter, ActivityEntry, AppNotification } from '../types'
+import type { Sessions, Session, NetworkInfo, Directory, ProviderInfo, Credentials, Agent, Schedule, AppView, BoardTask, AppSettings, OrchestratorSecret, ProviderConfig, Skill, Connector, Webhook, McpServerConfig, PluginMeta, Project, FleetFilter, ActivityEntry, AppNotification, ApprovalRequest } from '../types'
 import { fetchSessions, fetchDirs, fetchProviders, fetchCredentials } from '../lib/sessions'
 import { fetchAgents } from '../lib/agents'
 import { fetchSchedules } from '../lib/schedules'
@@ -198,6 +198,11 @@ interface AppState {
   lastReadTimestamps: Record<string, number>
   markChatRead: (id: string) => void
 
+  // Approvals
+  approvals: Record<string, ApprovalRequest>
+  loadApprovals: () => Promise<void>
+  submitApprovalDecision: (id: string, approved: boolean) => Promise<void>
+
   // Notifications
   notifications: AppNotification[]
   unreadNotificationCount: number
@@ -643,6 +648,23 @@ export const useAppStore = create<AppState>((set, get) => ({
     safeStorageSet('sc_last_read', JSON.stringify(ts))
   },
 
+  // Approvals
+  approvals: {},
+  loadApprovals: async () => {
+    try {
+      const list = await api<ApprovalRequest[]>('GET', '/approvals')
+      const approvals: Record<string, ApprovalRequest> = {}
+      for (const a of list) approvals[a.id] = a
+      set({ approvals })
+    } catch { /* ignore */ }
+  },
+  submitApprovalDecision: async (id, approved) => {
+    try {
+      await api('POST', '/approvals', { id, approved })
+      await get().loadApprovals()
+    } catch { /* ignore */ }
+  },
+
   // Notifications
   notifications: [],
   unreadNotificationCount: 0,