@swarmclawai/swarmclaw 0.6.7 → 0.6.8

package/src/lib/server/storage.ts

@@ -153,6 +153,8 @@ const COLLECTIONS = [
   'wallet_balance_history',
   'moderation_logs',
   'connector_health',
+  'souls',
+  'benchmarks',
 ] as const
 
 for (const table of COLLECTIONS) {
@@ -624,6 +626,16 @@ export function saveSchedules(s: Record<string, any>) {
   saveCollection('schedules', s)
 }
 
+// --- Souls ---
+export const loadSouls = () => loadCollection('souls')
+export const saveSouls = (s: Parameters<typeof saveCollection>[1]) => saveCollection('souls', s)
+export const deleteSoul = (id: string) => deleteCollectionItem('souls', id)
+
+// --- Benchmarks ---
+export const loadBenchmarks = () => loadCollection('benchmarks')
+export const saveBenchmarks = (b: Parameters<typeof saveCollection>[1]) => saveCollection('benchmarks', b)
+export const deleteBenchmark = (id: string) => deleteCollectionItem('benchmarks', id)
+
 // --- Tasks ---
 export function loadTasks(): Record<string, any> {
   return loadCollection('tasks')

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

@@ -59,6 +59,7 @@ function buildToolCapabilityLines(enabledTools: string[], opts?: { platformAssig
   if (enabledTools.includes('manage_agents')) lines.push('- I can create and configure other agents (`manage_agents`) — spin up specialists when a task calls for it.')
   if (enabledTools.includes('manage_tasks')) lines.push('- I can manage tasks (`manage_tasks`) — create plans, track progress, and stay organized over time.')
   if (enabledTools.includes('manage_schedules')) lines.push('- I can set up schedules (`manage_schedules`) for recurring work or future follow-ups.')
+  if (enabledTools.includes('schedule_wake')) lines.push('- I can set a conversational timer (`schedule_wake`) to remind myself to check back on something later in this chat.')
   if (enabledTools.includes('manage_documents')) lines.push('- I can store and search documents (`manage_documents`) for long-term knowledge and reference.')
   if (enabledTools.includes('manage_webhooks')) lines.push('- I can register webhooks (`manage_webhooks`) so external events can trigger my work automatically.')
   if (enabledTools.includes('manage_skills')) lines.push('- I can manage reusable skills (`manage_skills`) — building blocks I can learn and apply.')
@@ -77,12 +78,36 @@ function buildToolCapabilityLines(enabledTools: string[], opts?: { platformAssig
   return lines
 }
 
+/** Detect whether a user message is a broad, high-level goal that benefits from decomposition. */
+function isBroadGoal(text: string): boolean {
+  if (text.length < 50) return false
+  // Messages with code fences, file paths, or numbered steps are already structured
+  if (/```/.test(text)) return false
+  if (/\/(src|lib|app|pages|components|api)\//.test(text)) return false
+  if (/^\s*\d+[.)]\s/m.test(text)) return false
+  // Short direct questions aren't broad goals
+  if (text.length < 80 && text.endsWith('?')) return false
+  return true
+}
+
+const GOAL_DECOMPOSITION_BLOCK = [
+  '## Goal Decomposition',
+  'When you receive a broad, open-ended goal:',
+  '1. Break it into 3-7 concrete, sequentially-executable subtasks before taking action.',
+  '2. If manage_tasks is available, create a task for each subtask to track progress.',
+  '3. Output your plan in a [MAIN_LOOP_PLAN] JSON line: {"steps":["step1","step2",...],"current_step":"step1"}',
+  '4. Execute the first subtask immediately — do not stop after planning.',
+  '5. After each subtask, update progress and move to the next.',
+].join('\n')
+
 function buildAgenticExecutionPolicy(opts: {
   enabledTools: string[]
   loopMode: 'bounded' | 'ongoing'
   heartbeatPrompt: string
   heartbeatIntervalSec: number
   platformAssignScope?: 'self' | 'all'
+  userMessage?: string
+  hasExistingPlan?: boolean
 }) {
   const hasTooling = opts.enabledTools.length > 0
   const toolLines = buildToolCapabilityLines(opts.enabledTools, { platformAssignScope: opts.platformAssignScope })
@@ -192,6 +217,8 @@ function buildAgenticExecutionPolicy(opts: {
       ? `Expected heartbeat cadence is roughly every ${opts.heartbeatIntervalSec} seconds while ongoing work is active.`
       : '',
     toolLines.length ? 'What I can do:\n' + toolLines.join('\n') : '',
+    // Inject goal decomposition instructions for broad goals without existing plans
+    (opts.userMessage && !opts.hasExistingPlan && isBroadGoal(opts.userMessage)) ? GOAL_DECOMPOSITION_BLOCK : '',
   ].filter(Boolean).join('\n')
 }
 
@@ -204,6 +231,7 @@ export interface StreamAgentChatResult {
 }
 
 export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<StreamAgentChatResult> {
+  const startTs = Date.now()
   const { session, message, imagePath, attachedFiles, apiKey, systemPrompt, write, history, fallbackCredentialIds, signal } = opts
   const sessionToolsWithImplicitProcess = Array.from(new Set([
     ...(session.tools || []),
@@ -385,15 +413,17 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
         '- When I learn something that corrects old knowledge, update or remove the old memory',
       ].join('\n'))
 
-      // Pre-compaction memory flush: nudge agent to persist learnings when conversation is long
+      // Pre-compaction memory flush & Personality Evolution: nudge agent to reflect when conversation is long
       const msgCount = history.filter(m => m.role === 'user' || m.role === 'assistant').length
       if (msgCount > 20) {
+        const canEditSelf = (session.tools || []).includes('manage_agents')
         stateModifierParts.push([
-          '## Memory Flush Reminder',
-          'This conversation is getting long and I might lose older context soon. I should save anything',
-          'important I\'ve learned, decided, or discovered to my memory now — things I\'d want to recall',
-          'in future conversations. Only what matters, not every detail. If there\'s nothing worth saving, carry on.',
-        ].join('\n'))
+          '## Reflection & Consolidation Reminder',
+          'This conversation is getting long and I might lose older context soon.',
+          '1. **Memory:** I should save anything important I\'ve learned, decided, or discovered to my memory now. Only what matters, not every detail.',
+          canEditSelf ? `2. **Personality Evolution:** I should reflect on this conversation. Have my boundaries, tone, or relationship with the user evolved? If so, I MUST use \`manage_agents\` (action: update, id: "${session.agentId}") to update my \`soul\` field with these new learnings.` : '',
+          'If there\'s nothing worth saving or updating, carry on.',
+        ].filter(Boolean).join('\n'))
       }
     } catch {
       // If memory context fails to load, continue without blocking the run.
@@ -449,7 +479,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
       'web_search', 'web_fetch', 'browser', 'memory',
       'claude_code', 'codex_cli', 'opencode_cli',
       'sandbox', 'create_document', 'create_spreadsheet', 'http_request', 'git', 'wallet',
-      'manage_agents', 'manage_tasks', 'manage_schedules', 'manage_skills',
+      'manage_agents', 'manage_tasks', 'manage_schedules', 'schedule_wake', 'manage_skills',
       'manage_documents', 'manage_webhooks', 'manage_connectors', 'manage_sessions', 'manage_secrets',
     ]
     const disabled = allToolIds.filter((t) => !enabledSet.has(t))
@@ -475,6 +505,9 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     )
   }
 
+  // Check for existing plan in mainLoopState to skip decomposition injection
+  const hasExistingPlan = Array.isArray(session.mainLoopState?.planSteps) && session.mainLoopState.planSteps.length > 0
+
   stateModifierParts.push(
     buildAgenticExecutionPolicy({
       enabledTools: sessionToolsWithImplicitProcess,
@@ -482,10 +515,12 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
       heartbeatPrompt,
       heartbeatIntervalSec,
       platformAssignScope: agentPlatformAssignScope,
+      userMessage: message,
+      hasExistingPlan,
     }),
   )
 
-  const stateModifier = stateModifierParts.join('\n\n')
+  let stateModifier = stateModifierParts.join('\n\n')
 
   const { tools, cleanup } = await buildSessionTools(session.cwd, sessionToolsWithImplicitProcess, {
     agentId: session.agentId,
@@ -613,6 +648,19 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     // Context manager failure — continue with full history
   }
 
+  // Context degradation warning: prepend warning to system prompt when nearing limits
+  try {
+    const { getContextDegradationWarning, estimateTokens: estTokens } = await import('./context-manager')
+    const sysTokens = estTokens(stateModifier)
+    const warning = getContextDegradationWarning(effectiveHistory, sysTokens, session.provider, session.model)
+    if (warning) {
+      stateModifierParts.unshift(warning)
+      stateModifier = stateModifierParts.join('\n\n')
+    }
+  } catch {
+    // Warning failure is non-critical
+  }
+
   // Apply context-clear boundary: slice from most recent context-clear marker
   let contextStart = 0
   for (let i = effectiveHistory.length - 1; i >= 0; i--) {
@@ -836,6 +884,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
       totalTokens,
       estimatedCost: cost,
       timestamp: Date.now(),
+      durationMs: Date.now() - startTs,
     }
     appendUsage(session.id, usageRecord)
     // Send usage metadata to client

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

@@ -53,6 +53,7 @@ const TOOL_DESCRIPTORS: Record<string, ToolDescriptor> = {
   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'] },

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/tool-definitions.ts

@@ -31,6 +31,7 @@ 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: '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' },

package/src/lib/validation/schemas.ts

@@ -14,6 +14,7 @@ export const AgentCreateSchema = z.object({
   capabilities: z.array(z.string()).optional().default([]),
   thinkingLevel: z.string().optional(),
   soul: z.string().optional(),
+  autoRecovery: z.boolean().optional().default(false),
 })
 
 export const ConnectorCreateSchema = z.object({

package/src/lib/view-routes.ts

@@ -9,6 +9,7 @@ export const VIEW_TO_PATH: Record<AppView, string> = {
   schedules: '/schedules',
   memory: '/memory',
   tasks: '/tasks',
+  approvals: '/approvals',
   secrets: '/secrets',
   providers: '/providers',
   skills: '/skills',

package/src/types/index.ts

@@ -75,6 +75,8 @@ export interface Session {
   heartbeatIntervalSec?: number | null
   heartbeatTarget?: 'last' | 'none' | string | null
   lastAutoMemoryAt?: number | null
+  lastHeartbeatText?: string | null
+  lastHeartbeatSentAt?: number | null
   mainLoopState?: {
     goal?: string | null
     goalContract?: GoalContract | null
@@ -102,6 +104,8 @@ export interface Session {
       note: string
       status?: 'idle' | 'progress' | 'blocked' | 'ok'
     }>
+    missionTokens?: number
+    missionCostUsd?: number
     followupChainCount?: number
     metaMissCount?: number
     workingMemoryNotes?: string[]
@@ -116,6 +120,11 @@ export interface Session {
   queuedCount?: number
   currentRunId?: string | null
   conversationTone?: string
+  emoji?: string
+  creature?: string
+  vibe?: string
+  theme?: string
+  avatar?: string
   canvasContent?: string | null
 }
 
@@ -148,6 +157,7 @@ export interface UsageRecord {
   totalTokens: number
   estimatedCost: number
   timestamp: number
+  durationMs?: number
 }
 
 // --- Plugin System ---
@@ -155,15 +165,27 @@ export interface UsageRecord {
 export interface PluginHooks {
   beforeAgentStart?: (ctx: { session: Session; message: string }) => Promise<void> | void
   afterAgentComplete?: (ctx: { session: Session; response: string }) => Promise<void> | void
-  beforeToolExec?: (ctx: { toolName: string; input: any }) => Promise<any> | any
-  afterToolExec?: (ctx: { toolName: string; input: any; output: string }) => Promise<void> | void
+  beforeToolExec?: (ctx: { toolName: string; input: Record<string, unknown> | null }) => Promise<Record<string, unknown> | void> | Record<string, unknown> | void
+  afterToolExec?: (ctx: { toolName: string; input: Record<string, unknown> | null; output: string }) => Promise<void> | void
   onMessage?: (ctx: { session: Session; message: Message }) => Promise<void> | void
+
+  // Orchestration & Swarm Hooks
+  onTaskComplete?: (ctx: { taskId: string; result: unknown }) => Promise<void> | void
+  onAgentDelegation?: (ctx: { sourceAgentId: string; targetAgentId: string; task: string }) => Promise<void> | void
+}
+
+export interface PluginToolDef {
+  name: string
+  description: string
+  parameters: Record<string, unknown>
+  execute: (args: Record<string, unknown>, ctx: { session: Session; message: string }) => Promise<string | object> | string | object
 }
 
 export interface Plugin {
   name: string
   description?: string
   hooks: PluginHooks
+  tools?: PluginToolDef[]
 }
 
 export interface PluginMeta {
@@ -233,6 +255,11 @@ export interface Agent {
   name: string
   description: string
   soul?: string
+  emoji?: string
+  creature?: string
+  vibe?: string
+  theme?: string
+  avatar?: string
   systemPrompt: string
   provider: ProviderType
   model: string
@@ -273,9 +300,12 @@ export interface Agent {
   openclawAllowedSkills?: string[]
   walletId?: string | null
   monthlyBudget?: number | null
+  autoRecovery?: boolean
+
   budgetAction?: 'warn' | 'block'
   /** Runtime-enriched: current month's spend. Populated by GET /api/agents when monthlyBudget is set. */
   monthlySpend?: number
+  maxFollowupChain?: number
   createdAt: number
   updatedAt: number
 }
@@ -408,7 +438,7 @@ export interface MemoryEntry {
 }
 
 export type SessionType = 'human' | 'orchestrated'
-export type AppView = 'home' | 'agents' | 'chatrooms' | 'schedules' | 'memory' | 'tasks' | 'secrets' | 'providers' | 'skills' | 'connectors' | 'webhooks' | 'mcp_servers' | 'knowledge' | 'plugins' | 'usage' | 'wallets' | 'runs' | 'logs' | 'settings' | 'projects' | 'activity'
+export type AppView = 'home' | 'agents' | 'chatrooms' | 'schedules' | 'memory' | 'tasks' | 'approvals' | 'secrets' | 'providers' | 'skills' | 'connectors' | 'webhooks' | 'mcp_servers' | 'knowledge' | 'plugins' | 'usage' | 'wallets' | 'runs' | 'logs' | 'settings' | 'projects' | 'activity'
 
 // --- Chatrooms ---
 
@@ -581,6 +611,7 @@ export interface AppSettings {
   legacyOrchestratorMaxTurns?: number
   ongoingLoopMaxIterations?: number
   ongoingLoopMaxRuntimeMinutes?: number
+  maxFollowupChain?: number
   shellCommandTimeoutSec?: number
   claudeCodeTimeoutSec?: number
   cliProcessTimeoutSec?: number