@swarmclawai/swarmclaw 0.6.7 → 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,22 +43,41 @@ 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'] },
+  schedule_wake: { categories: ['platform'], concreteTools: ['schedule_wake'] },
   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/server/tool-retry.ts

@@ -0,0 +1,62 @@
+/**
+ * Structured retry with exponential backoff for transient tool failures.
+ */
+
+export interface RetryOptions {
+  maxAttempts?: number
+  backoffMs?: number
+  retryable?: RegExp[]
+}
+
+const DEFAULT_RETRYABLE: RegExp[] = [
+  /timeout/i,
+  /ECONNRESET/i,
+  /ENOTFOUND/i,
+  /429/,
+  /503/,
+  /rate.?limit/i,
+]
+
+const DEFAULT_MAX_ATTEMPTS = 3
+const DEFAULT_BACKOFF_MS = 2000
+
+function isRetryableError(error: string, patterns: RegExp[]): boolean {
+  return patterns.some((p) => p.test(error))
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+/**
+ * Wraps a tool handler function with retry logic for transient failures.
+ * The wrapped function must return a string (tool output).
+ * Retries only when the returned string matches a retryable pattern
+ * (tool handlers typically return error strings rather than throwing).
+ */
+export async function withRetry<TArgs>(
+  fn: (args: TArgs) => Promise<string>,
+  args: TArgs,
+  opts?: RetryOptions,
+): Promise<string> {
+  const maxAttempts = opts?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS
+  const backoffMs = opts?.backoffMs ?? DEFAULT_BACKOFF_MS
+  const retryable = opts?.retryable ?? DEFAULT_RETRYABLE
+
+  let lastResult = ''
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    lastResult = await fn(args)
+
+    // Only retry if the result looks like a retryable error
+    if (attempt < maxAttempts && isRetryableError(lastResult, retryable)) {
+      const delay = backoffMs * Math.pow(2, attempt - 1)
+      console.warn(
+        `[tool-retry] Attempt ${attempt}/${maxAttempts} matched retryable pattern, retrying in ${delay}ms`,
+      )
+      await sleep(delay)
+      continue
+    }
+    return lastResult
+  }
+  return lastResult
+}

package/src/lib/server/transcript-repair.ts

@@ -0,0 +1,72 @@
+import type { Message } from '@/types'
+
+/**
+ * Repairs a conversation transcript by ensuring that tool events remain associated
+ * with their parent assistant messages during pruning or manipulation.
+ * 
+ * In SwarmClaw, toolEvents are nested within the Message object, so "orphaning"
+ * is less of a structural risk than in OpenClaw, but we still need to ensure
+ * consistency during context management.
+ */
+export function repairTranscriptConsistency(messages: Message[]): Message[] {
+  // SwarmClaw specific: ensure that 'system' messages like [Context Summary]
+  // are preserved correctly and that nested toolEvents are valid.
+  return messages.map(m => {
+    if (m.role === 'assistant' && m.toolEvents) {
+      // Filter out empty or malformed tool events that might cause LLM confusion
+      const validTools = m.toolEvents.filter(t => t.name && t.input)
+      if (validTools.length !== m.toolEvents.length) {
+        return { ...m, toolEvents: validTools }
+      }
+    }
+    return m
+  })
+}
+
+/**
+ * Checks for and repairs common transcript issues that cause LLM provider errors.
+ * (e.g. consecutive user messages, trailing assistant messages without text).
+ */
+export function finalProviderTranscriptSanityCheck(messages: Message[]): Message[] {
+  if (messages.length === 0) return []
+
+  const out: Message[] = []
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i]
+    
+    // 1. Skip messages marked as suppressed
+    if (m.suppressed) continue
+
+    // 2. Prevent consecutive messages of same role (some providers are strict)
+    const prev = out.at(-1)
+    if (prev && prev.role === m.role) {
+      if (m.role === 'user') {
+        // Merge consecutive user messages
+        prev.text = `${prev.text}\n\n${m.text}`
+        if (m.imagePath) prev.imagePath = m.imagePath
+        if (m.imageUrl) prev.imageUrl = m.imageUrl
+        continue
+      } else {
+        // Assistant consecutive? Keep the one with tool events or the longer one
+        const mTools = m.toolEvents?.length || 0
+        const pTools = prev.toolEvents?.length || 0
+        if (mTools > pTools || m.text.length > prev.text.length) {
+          out[out.length - 1] = m
+        }
+        continue
+      }
+    }
+
+    out.push(m)
+  }
+
+  // 3. Ensure the transcript doesn't end with an empty assistant message
+  if (out.length > 0 && out.at(-1)?.role === 'assistant') {
+    const last = out.at(-1)!
+    if (!last.text.trim() && (!last.toolEvents || last.toolEvents.length === 0)) {
+      out.pop()
+    }
+  }
+
+  return out
+}

package/src/lib/setup-defaults.ts

@@ -157,6 +157,7 @@ export const STARTER_AGENT_TOOLS = [
   'manage_agents',
   'manage_tasks',
   'manage_schedules',
+  'schedule_wake',
   'manage_skills',
   'manage_connectors',
   'manage_sessions',

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>) =>