@swarmclawai/swarmclaw 0.6.4 → 0.6.7

package/src/lib/server/cost.ts

@@ -29,3 +29,73 @@ export function estimateCost(model: string, inputTokens: number, outputTokens: n
 export function getModelCosts(): Record<string, [number, number]> {
   return { ...MODEL_COSTS }
 }
+
+// --- Agent Monthly Budget ---
+
+import { loadUsage, loadSessions } from './storage'
+import type { Agent, UsageRecord } from '@/types'
+
+/**
+ * Sum the estimated cost for an agent in the current calendar month.
+ * Usage records are keyed by sessionId; we resolve agentId through sessions.
+ */
+export function getAgentMonthlySpend(agentId: string): number {
+  const sessions = loadSessions()
+  // Build a set of sessionIds linked to this agent
+  const agentSessionIds = new Set<string>()
+  for (const [sid, session] of Object.entries(sessions)) {
+    if (session?.agentId === agentId) agentSessionIds.add(sid)
+  }
+  if (agentSessionIds.size === 0) return 0
+
+  const now = new Date()
+  const monthStart = new Date(now.getFullYear(), now.getMonth(), 1).getTime()
+
+  const usage = loadUsage()
+  let total = 0
+  for (const sid of agentSessionIds) {
+    const records = usage[sid]
+    if (!Array.isArray(records)) continue
+    for (const record of records) {
+      const r = record as UsageRecord
+      if (typeof r.timestamp !== 'number' || r.timestamp < monthStart) continue
+      if (typeof r.estimatedCost === 'number' && Number.isFinite(r.estimatedCost) && r.estimatedCost > 0) {
+        total += r.estimatedCost
+      }
+    }
+  }
+  return total
+}
+
+export interface BudgetCheckResult {
+  ok: boolean
+  spend: number
+  budget: number
+  message?: string
+}
+
+/**
+ * Check whether an agent is within its monthly budget.
+ * Returns ok: true if no budget is set or spend is under the cap.
+ */
+export function checkBudget(agent: Agent): BudgetCheckResult {
+  const budget = typeof agent.monthlyBudget === 'number' && Number.isFinite(agent.monthlyBudget) && agent.monthlyBudget > 0
+    ? agent.monthlyBudget
+    : 0
+
+  if (budget <= 0) {
+    return { ok: true, spend: 0, budget: 0 }
+  }
+
+  const spend = getAgentMonthlySpend(agent.id)
+  if (spend >= budget) {
+    return {
+      ok: false,
+      spend,
+      budget,
+      message: `Agent "${agent.name}" has reached its monthly budget: $${spend.toFixed(4)} spent of $${budget.toFixed(2)} cap.`,
+    }
+  }
+
+  return { ok: true, spend, budget }
+}

package/src/lib/server/create-notification.ts

@@ -1,6 +1,7 @@
 import { genId } from '@/lib/id'
 import { saveNotification, hasUnreadNotificationWithKey } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
+import { dispatchAlert } from '@/lib/server/alert-dispatch'
 import type { AppNotification } from '@/types'
 
 /**
@@ -38,5 +39,6 @@ export function createNotification(opts: {
   }
   saveNotification(id, notification)
   notify('notifications')
+  dispatchAlert(notification).catch(() => {})
   return notification
 }

package/src/lib/server/daemon-state.ts

@@ -10,6 +10,7 @@ import {
   sendConnectorMessage,
   startConnector,
   getConnectorStatus,
+  checkConnectorHealth,
 } from './connectors/manager'
 import { startHeartbeatService, stopHeartbeatService, getHeartbeatServiceStatus } from './heartbeat-service'
 import { hasOpenClawAgents, ensureGatewayConnected, disconnectGateway, getGateway } from './openclaw-gateway'
@@ -82,6 +83,10 @@ const ds: {
   /** Session IDs we've already alerted as stale (alert-once semantics). */
   staleSessionIds: Set<string>
   connectorRestartState: Map<string, { lastAttemptAt: number; failCount: number; wakeAttempts: number }>
+  /** OpenClaw gateway agent IDs currently considered down. */
+  openclawDownAgentIds: Set<string>
+  /** Per-agent auto-repair state for OpenClaw gateways. */
+  openclawRepairState: Map<string, { attempts: number; lastAttemptAt: number; cooldownUntil: number }>
   manualStopRequested: boolean
   running: boolean
   lastProcessedAt: number | null
@@ -94,6 +99,8 @@ const ds: {
   memoryConsolidationIntervalId: null,
   staleSessionIds: new Set<string>(),
   connectorRestartState: new Map<string, { lastAttemptAt: number; failCount: number; wakeAttempts: number }>(),
+  openclawDownAgentIds: new Set<string>(),
+  openclawRepairState: new Map<string, { attempts: number; lastAttemptAt: number; cooldownUntil: number }>(),
   manualStopRequested: false,
   running: false,
   lastProcessedAt: null,
@@ -102,6 +109,8 @@ const ds: {
 // Backfill fields for hot-reloaded daemon state objects from older code versions.
 if (!ds.staleSessionIds) ds.staleSessionIds = new Set<string>()
 if (!ds.connectorRestartState) ds.connectorRestartState = new Map<string, { lastAttemptAt: number; failCount: number; wakeAttempts: number }>()
+if (!ds.openclawDownAgentIds) ds.openclawDownAgentIds = new Set<string>()
+if (!ds.openclawRepairState) ds.openclawRepairState = new Map<string, { attempts: number; lastAttemptAt: number; cooldownUntil: number }>()
 // Migrate from old issueLastAlertAt map if present (HMR across code versions)
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 if ((ds as any).issueLastAlertAt) delete (ds as any).issueLastAlertAt
@@ -247,6 +256,13 @@ async function sendHealthAlert(text: string) {
 }
 
 async function runConnectorHealthChecks(now: number) {
+  // First, check isAlive() on running instances and attempt reconnection for dead ones
+  try {
+    await checkConnectorHealth()
+  } catch (err: unknown) {
+    console.error('[health] Connector isAlive check failed:', err instanceof Error ? err.message : String(err))
+  }
+
   const connectors = loadConnectors()
   for (const connector of Object.values(connectors) as Record<string, unknown>[]) {
     if (!connector?.id || typeof connector.id !== 'string') continue
@@ -533,6 +549,107 @@ async function runProviderHealthChecks() {
   }
 }
 
+const OPENCLAW_REPAIR_MAX_ATTEMPTS = 3
+const OPENCLAW_REPAIR_COOLDOWN_MS = 300_000 // 5 minutes
+
+async function runOpenClawGatewayHealthChecks() {
+  const agents = loadAgents()
+  const credentials = loadCredentials()
+
+  // Build deduplicated OpenClaw agent tuples
+  const seen = new Set<string>()
+  const tuples: { agentId: string; endpoint: string; credentialId: string; credentialName: string }[] = []
+
+  for (const agent of Object.values(agents) as Record<string, unknown>[]) {
+    if (!agent?.id || typeof agent.id !== 'string') continue
+    if (agent.provider !== 'openclaw') continue
+
+    const key = `openclaw:${agent.id}`
+    if (seen.has(key)) continue
+    seen.add(key)
+
+    const credentialId = typeof agent.credentialId === 'string' ? agent.credentialId : ''
+    const endpoint = typeof agent.apiEndpoint === 'string' ? agent.apiEndpoint : ''
+    const cred = credentialId ? (credentials[credentialId] as Record<string, unknown> | undefined) : undefined
+    const credName = typeof cred?.name === 'string' ? cred.name : 'openclaw'
+
+    tuples.push({ agentId: agent.id, endpoint, credentialId, credentialName: credName })
+  }
+
+  if (!tuples.length) return
+
+  const { probeOpenClawHealth } = await import('./openclaw-health')
+
+  for (const tuple of tuples) {
+    let token: string | undefined
+    if (tuple.credentialId) {
+      const cred = credentials[tuple.credentialId] as Record<string, unknown> | undefined
+      if (cred?.encryptedKey && typeof cred.encryptedKey === 'string') {
+        try { token = decryptKey(cred.encryptedKey) } catch { continue }
+      }
+    }
+
+    const result = await probeOpenClawHealth({
+      endpoint: tuple.endpoint || undefined,
+      token,
+      timeoutMs: 10_000,
+    })
+
+    const now = Date.now()
+
+    if (result.ok) {
+      // Recovered
+      if (ds.openclawDownAgentIds.has(tuple.agentId)) {
+        ds.openclawDownAgentIds.delete(tuple.agentId)
+        ds.openclawRepairState.delete(tuple.agentId)
+        createNotification({
+          type: 'success',
+          title: 'OpenClaw gateway recovered',
+          message: `Gateway for ${tuple.credentialName} is reachable again.`,
+          dedupKey: `openclaw-gw-down:${tuple.agentId}`,
+        })
+      }
+      continue
+    }
+
+    // Unhealthy
+    const repair = ds.openclawRepairState.get(tuple.agentId) || { attempts: 0, lastAttemptAt: 0, cooldownUntil: 0 }
+
+    // In cooldown — skip
+    if (repair.cooldownUntil > now) continue
+
+    // Cooldown expired — reset
+    if (repair.cooldownUntil > 0 && repair.cooldownUntil <= now) {
+      repair.attempts = 0
+      repair.cooldownUntil = 0
+    }
+
+    ds.openclawDownAgentIds.add(tuple.agentId)
+
+    if (repair.attempts < OPENCLAW_REPAIR_MAX_ATTEMPTS) {
+      try {
+        const { runOpenClawDoctor } = await import('./openclaw-doctor')
+        await runOpenClawDoctor({ fix: true })
+      } catch (err: unknown) {
+        console.warn('[daemon] openclaw doctor --fix failed:', err instanceof Error ? err.message : String(err))
+      }
+      repair.attempts += 1
+      repair.lastAttemptAt = now
+    } else {
+      repair.cooldownUntil = now + OPENCLAW_REPAIR_COOLDOWN_MS
+    }
+
+    ds.openclawRepairState.set(tuple.agentId, repair)
+
+    createNotification({
+      type: 'error',
+      title: `OpenClaw gateway unreachable: ${tuple.credentialName}`,
+      message: result.error || 'Health check failed',
+      dedupKey: `openclaw-gw-down:${tuple.agentId}`,
+    })
+  }
+}
+
 async function runHealthChecks() {
   // Continuously keep the completed queue honest.
   validateCompletedTasksQueue()
@@ -601,6 +718,13 @@ async function runHealthChecks() {
     console.error('[daemon] Provider health check failed:', err instanceof Error ? err.message : String(err))
   }
 
+  // OpenClaw gateway health checks + auto-repair
+  try {
+    await runOpenClawGatewayHealthChecks()
+  } catch (err: unknown) {
+    console.error('[daemon] OpenClaw gateway health check failed:', err instanceof Error ? err.message : String(err))
+  }
+
   // Process webhook retry queue
   try {
     await processWebhookRetries()

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

@@ -0,0 +1,115 @@
+import type { BoardTask } from '@/types'
+
+interface DagResult {
+  valid: boolean
+  cycle?: string[]
+}
+
+/**
+ * Validate that adding `proposedBlockedBy` to `taskId` would not create a cycle
+ * in the task dependency graph. Uses DFS to check if `taskId` is reachable from
+ * any of its proposed blockers (which would mean a cycle).
+ */
+export function validateDag(
+  tasks: Record<string, BoardTask>,
+  taskId: string,
+  proposedBlockedBy: string[],
+): DagResult {
+  // Build adjacency: task -> tasks it is blocked by (its dependencies)
+  // We temporarily add the proposed edges: taskId is blocked by proposedBlockedBy
+  // A cycle exists if we can reach taskId by following blockedBy edges from any
+  // of the proposed blockers.
+
+  // DFS from each proposed blocker, following existing blockedBy edges.
+  // If we reach taskId, we have a cycle.
+  for (const startId of proposedBlockedBy) {
+    if (startId === taskId) {
+      return { valid: false, cycle: [taskId, taskId] }
+    }
+
+    const visited = new Set<string>()
+    const path: string[] = []
+    const found = dfs(tasks, startId, taskId, visited, path)
+    if (found) {
+      // path contains the route from startId to taskId
+      // The full cycle is: taskId -> startId -> ... -> taskId
+      return { valid: false, cycle: [taskId, ...path] }
+    }
+  }
+
+  return { valid: true }
+}
+
+/**
+ * DFS through the blockedBy graph starting from `current`, looking for `target`.
+ * Returns true if target is found, and populates `path` with the route.
+ */
+function dfs(
+  tasks: Record<string, BoardTask>,
+  current: string,
+  target: string,
+  visited: Set<string>,
+  path: string[],
+): boolean {
+  if (visited.has(current)) return false
+  visited.add(current)
+  path.push(current)
+
+  const task = tasks[current]
+  if (!task) {
+    path.pop()
+    return false
+  }
+
+  const blockers = Array.isArray(task.blockedBy) ? task.blockedBy : []
+  for (const blockerId of blockers) {
+    if (blockerId === target) {
+      path.push(blockerId)
+      return true
+    }
+    if (dfs(tasks, blockerId, target, visited, path)) {
+      return true
+    }
+  }
+
+  path.pop()
+  return false
+}
+
+/**
+ * After a task completes, find all tasks that were blocked by it and check
+ * if all their blockers are now done. If so, auto-queue them.
+ * Returns the IDs of tasks that were unblocked.
+ */
+export function cascadeUnblock(
+  tasks: Record<string, BoardTask>,
+  completedTaskId: string,
+): string[] {
+  const completedTask = tasks[completedTaskId]
+  if (!completedTask || completedTask.status !== 'completed') return []
+
+  const unblocked: string[] = []
+  const blockedIds = Array.isArray(completedTask.blocks) ? completedTask.blocks : []
+
+  for (const blockedId of blockedIds) {
+    const blocked = tasks[blockedId]
+    if (!blocked) continue
+    // Only auto-queue tasks that are in backlog (waiting on dependencies)
+    if (blocked.status !== 'backlog') continue
+
+    const deps = Array.isArray(blocked.blockedBy) ? blocked.blockedBy : []
+    const allDone = deps.every((depId) => {
+      const dep = tasks[depId]
+      return dep?.status === 'completed'
+    })
+
+    if (allDone) {
+      blocked.status = 'queued'
+      blocked.queuedAt = Date.now()
+      blocked.updatedAt = Date.now()
+      unblocked.push(blockedId)
+    }
+  }
+
+  return unblocked
+}

package/src/lib/server/memory-db.ts

@@ -1192,21 +1192,26 @@ export function addKnowledge(params: {
   agentIds?: string[]
   createdByAgentId?: string | null
   createdBySessionId?: string | null
+  source?: string
+  sourceUrl?: string
 }): MemoryEntry {
   const db = getMemoryDb()
+  const metadata: Record<string, unknown> = {
+    tags: params.tags || [],
+    scope: params.scope || 'global',
+    agentIds: params.scope === 'agent' ? (params.agentIds || []) : [],
+    createdByAgentId: params.createdByAgentId || null,
+    createdBySessionId: params.createdBySessionId || null,
+  }
+  if (params.source) metadata.source = params.source
+  if (params.sourceUrl) metadata.sourceUrl = params.sourceUrl
   return db.add({
     agentId: null,
     sessionId: null,
     category: 'knowledge',
     title: params.title,
     content: params.content,
-    metadata: {
-      tags: params.tags || [],
-      scope: params.scope || 'global',
-      agentIds: params.scope === 'agent' ? (params.agentIds || []) : [],
-      createdByAgentId: params.createdByAgentId || null,
-      createdBySessionId: params.createdBySessionId || null,
-    },
+    metadata,
   })
 }
 

package/src/lib/server/openclaw-doctor.ts

@@ -0,0 +1,48 @@
+import { execFile } from 'child_process'
+import { promisify } from 'util'
+import * as path from 'path'
+import * as os from 'os'
+import { loadSettings } from './storage'
+
+const execFileAsync = promisify(execFile)
+
+export interface DoctorResult {
+  ok: boolean
+  output: string
+  fixed: boolean
+}
+
+function resolveWorkspacePath(override?: string): string {
+  if (override) return override
+  const settings = loadSettings()
+  if (typeof settings.openclawWorkspacePath === 'string' && settings.openclawWorkspacePath.trim()) {
+    return settings.openclawWorkspacePath.trim()
+  }
+  return path.join(os.homedir(), '.openclaw', 'workspace')
+}
+
+export async function runOpenClawDoctor(opts?: { fix?: boolean; workspace?: string }): Promise<DoctorResult> {
+  const workspace = resolveWorkspacePath(opts?.workspace)
+  const args = ['doctor']
+  if (opts?.fix) args.push('--fix')
+
+  try {
+    const { stdout, stderr } = await execFileAsync('openclaw', args, {
+      cwd: workspace,
+      timeout: 30_000,
+      maxBuffer: 256 * 1024,
+    })
+    return {
+      ok: true,
+      output: (stdout + stderr).trim(),
+      fixed: !!opts?.fix,
+    }
+  } catch (err: unknown) {
+    const execErr = err as { code?: number; stdout?: string; stderr?: string; message?: string }
+    return {
+      ok: false,
+      output: ((execErr.stdout || '') + (execErr.stderr || '') || execErr.message || String(err)).trim(),
+      fixed: false,
+    }
+  }
+}

package/src/lib/server/orchestrator-lg.ts

@@ -124,7 +124,12 @@ async function executeSubTaskViaCli(agent: Agent, task: string, parentSessionId:
   }
   ss(sessions)
 
-  const result = await callProvider(agent, agent.systemPrompt, [{ role: 'user', text: task }])
+  // Build system prompt with identity
+  const subPromptParts: string[] = []
+  subPromptParts.push(`## My Identity\nMy name is ${agent.name}.${agent.description ? ' ' + agent.description : ''} I should always refer to myself by this name.`)
+  if (agent.soul) subPromptParts.push(agent.soul)
+  if (agent.systemPrompt) subPromptParts.push(agent.systemPrompt)
+  const result = await callProvider(agent, subPromptParts.join('\n\n'), [{ role: 'user', text: task }])
 
   const s2 = ls()
   if (s2[childId]) {
@@ -348,9 +353,14 @@ export async function executeLangGraphOrchestrator(
     apiKey: engine.apiKey,
     apiEndpoint: engine.apiEndpoint,
   })
-  // Build system message: [userPrompt] \n\n [soul] \n\n [systemPrompt] \n\n [orchestrator context]
+  // Build system message: [identity] \n\n [userPrompt] \n\n [soul] \n\n [systemPrompt] \n\n [orchestrator context]
   const settings = loadSettings()
   const promptParts: string[] = []
+  // Identity block
+  const orchIdentity = [`## My Identity`, `My name is ${orchestrator.name}.`]
+  if (orchestrator.description) orchIdentity.push(orchestrator.description)
+  orchIdentity.push('I should always refer to myself by this name.')
+  promptParts.push(orchIdentity.join(' '))
   if (settings.userPrompt) promptParts.push(settings.userPrompt)
   promptParts.push(buildCurrentDateTimePromptContext())
   if (orchestrator.soul) promptParts.push(orchestrator.soul)

package/src/lib/server/orchestrator.ts

@@ -296,7 +296,12 @@ async function executeSubTask(
   saveSessions(sessions)
 
   const history = [{ role: 'user', text: task }]
-  const result = await callProvider(agent, agent.systemPrompt, history)
+  // Build system prompt with identity so the agent knows who it is
+  const promptParts: string[] = []
+  promptParts.push(`## My Identity\nMy name is ${agent.name}.${agent.description ? ' ' + agent.description : ''} I should always refer to myself by this name.`)
+  if (agent.soul) promptParts.push(agent.soul)
+  if (agent.systemPrompt) promptParts.push(agent.systemPrompt)
+  const result = await callProvider(agent, promptParts.join('\n\n'), history)
 
   childSession.messages.push({ role: 'user', text: task, time: Date.now() })
   childSession.messages.push({ role: 'assistant', text: result, time: Date.now() })