@swarmclawai/swarmclaw 1.2.9 → 1.3.1

package/src/lib/server/connectors/swarmdock-tasks.ts

@@ -2,23 +2,14 @@ import { genId } from '@/lib/id'
 import { loadTasks, saveTasks } from '@/lib/server/tasks/task-repository'
 import { logActivity } from '@/lib/server/activity/activity-log'
 import type { BoardTask } from '@/types/task'
-
-interface SwarmDockTask {
-  id: string
-  requesterId: string
-  title: string
-  description: string
-  skillRequirements: string[]
-  budgetMax: string
-  deadline: string | null
-}
+import type { Task } from '@swarmdock/shared'
 
 /**
  * Create a SwarmClaw BoardTask from a SwarmDock task assignment.
  * Uses `externalSource` to link back to the SwarmDock task (same pattern as GitHub issue import).
  */
 export async function createBoardTaskFromAssignment(
-  task: SwarmDockTask,
+  task: Task,
   agentId: string,
   connectorId: string,
   apiUrl: string,
@@ -100,6 +91,14 @@ export async function updateBoardTaskFromEvent(
       boardTask.status = 'failed'
       boardTask.checkoutRunId = null
       break
+    case 'task.review':
+      // Work submitted, awaiting requester review on SwarmDock
+      if (boardTask.externalSource) boardTask.externalSource.state = 'review'
+      break
+    case 'task.disputed':
+      // Task disputed on SwarmDock
+      if (boardTask.externalSource) boardTask.externalSource.state = 'disputed'
+      break
   }
 
   boardTask.updatedAt = now

package/src/lib/server/connectors/swarmdock.ts

@@ -5,29 +5,10 @@ import type { Connector, InboundMessage } from '@/types/connector'
 import type { PlatformConnector, ConnectorInstance } from '@/lib/server/connectors/types'
 import { createBoardTaskFromAssignment, updateBoardTaskFromEvent, findBoardTaskBySwarmdockId } from './swarmdock-tasks'
 import { shouldAutoBid, submitAutoBid } from './swarmdock-bidding'
-import type { TaskSubmitInput } from '@swarmdock/shared'
+import type { Task, SSEEvent, TaskSubmitInput } from '@swarmdock/shared'
 
 const TAG = 'swarmdock'
 
-// SDK types inlined until @swarmdock/sdk is built and linked
-interface SwarmDockTask {
-  id: string
-  requesterId: string
-  assigneeId: string | null
-  title: string
-  description: string
-  skillRequirements: string[]
-  budgetMax: string
-  status: string
-  deadline: string | null
-}
-
-interface SwarmDockSSEEvent {
-  type: string
-  data: Record<string, unknown>
-  timestamp: string
-}
-
 interface SwarmDockConfig {
   apiUrl: string
   walletAddress: string
@@ -35,6 +16,7 @@ interface SwarmDockConfig {
   skills: string
   autoDiscover: boolean
   maxBudget: string
+  paymentPrivateKey?: string
 }
 
 function parseConfig(connector: Connector): SwarmDockConfig {
@@ -46,10 +28,11 @@ function parseConfig(connector: Connector): SwarmDockConfig {
     skills: c.skills || '',
     autoDiscover: c.autoDiscover === 'true',
     maxBudget: c.maxBudget || '0',
+    paymentPrivateKey: c.paymentPrivateKey || undefined,
   }
 }
 
-function buildTaskPrompt(task: SwarmDockTask): string {
+function buildTaskPrompt(task: Task): string {
   const lines: string[] = [
     `# SwarmDock Task: ${task.title}`,
     '',
@@ -63,6 +46,17 @@ function buildTaskPrompt(task: SwarmDockTask): string {
   return lines.join('\n')
 }
 
+export function generateExamplePrompts(skillId: string): string[] {
+  const name = skillId.replace(/-/g, ' ')
+  return [
+    `Perform a ${name} task`,
+    `Help me with ${name}`,
+    `I need ${name} work done`,
+    `Complete a ${name} assignment`,
+    `Handle a ${name} request`,
+  ]
+}
+
 function formatUsdc(microUnits: string): string {
   const cents = BigInt(microUnits)
   const dollars = Number(cents) / 1_000_000
@@ -73,11 +67,13 @@ export async function submitSwarmdockTaskResult(
   client: { tasks: { submit: (taskId: string, input: TaskSubmitInput) => Promise<unknown> } },
   swarmdockTaskId: string,
   text: string,
+  notes?: string,
 ): Promise<void> {
   const payload: TaskSubmitInput = {
     artifacts: [{ type: 'text/markdown', content: text }],
     files: [],
   }
+  if (notes) payload.notes = notes
   await client.tasks.submit(swarmdockTaskId, payload)
 }
 
@@ -94,11 +90,15 @@ const swarmdock: PlatformConnector = {
     if (!privateKey) throw new Error('SwarmDock connector requires an Ed25519 private key credential')
     if (!config.walletAddress) throw new Error('SwarmDock connector requires a Base L2 wallet address in config')
 
-    // Dynamic import of the SDK (must be built and linked first)
+    // Dynamic import of the SDK
     let SwarmDockClient: typeof import('@swarmdock/sdk').SwarmDockClient
+    let ConflictError: typeof import('@swarmdock/sdk').ConflictError
+    let AuthenticationError: typeof import('@swarmdock/sdk').AuthenticationError
     try {
       const sdk = await import('@swarmdock/sdk')
       SwarmDockClient = sdk.SwarmDockClient
+      ConflictError = sdk.ConflictError
+      AuthenticationError = sdk.AuthenticationError
     } catch {
       throw new Error('SwarmDock SDK (@swarmdock/sdk) is not installed. Run: npm install @swarmdock/sdk')
     }
@@ -106,6 +106,9 @@ const swarmdock: PlatformConnector = {
     const client = new SwarmDockClient({
       baseUrl: config.apiUrl,
       privateKey,
+      ...(config.paymentPrivateKey?.startsWith('0x')
+        ? { paymentPrivateKey: config.paymentPrivateKey as `0x${string}` }
+        : {}),
     })
 
     // Register agent on SwarmDock (Ed25519 challenge-response)
@@ -119,36 +122,49 @@ const swarmdock: PlatformConnector = {
         description: `${skillId} capability`,
         category: skillId,
         basePrice: '1000000', // $1.00 default
+        inputModes: ['text'],
+        outputModes: ['text'],
+        examplePrompts: generateExamplePrompts(skillId),
       }))
 
     log.info(TAG, `Registering agent "${connector.name}" on SwarmDock at ${config.apiUrl}`)
-    const registration = await client.register({
-      displayName: connector.name,
-      description: config.agentDescription,
-      framework: 'swarmclaw',
-      walletAddress: config.walletAddress,
-      skills: skillList,
-    })
-    log.info(TAG, `Registered as ${registration.agent.did} (trust level ${registration.agent.trustLevel})`)
-
-    logActivity({
-      entityType: 'connector',
-      entityId: connectorId,
-      action: 'swarmdock-registered',
-      actor: 'system',
-      summary: `Agent "${connector.name}" registered on SwarmDock as ${registration.agent.did}`,
-    })
+    try {
+      const registration = await client.register({
+        displayName: connector.name,
+        description: config.agentDescription,
+        framework: 'swarmclaw',
+        walletAddress: config.walletAddress,
+        skills: skillList,
+      })
+      log.info(TAG, `Registered as ${registration.agent.did} (trust level ${registration.agent.trustLevel})`)
+
+      logActivity({
+        entityType: 'connector',
+        entityId: connectorId,
+        action: 'swarmdock-registered',
+        actor: 'system',
+        summary: `Agent "${connector.name}" registered on SwarmDock as ${registration.agent.did}`,
+      })
+    } catch (err) {
+      if (err instanceof ConflictError) {
+        log.info(TAG, `Agent already registered, authenticating`)
+        await client.authenticate()
+      } else {
+        throw err
+      }
+    }
 
     // Set up SSE event stream
     let alive = true
 
-    const handleSSEEvent = async (event: SwarmDockSSEEvent) => {
+    const handleSSEEvent = async (event: SSEEvent) => {
       if (!alive) return
       try {
         switch (event.type) {
-          case 'task.created': {
+          case 'task.created':
+          case 'task.invited': {
             if (!config.autoDiscover) break
-            const task = event.data as unknown as SwarmDockTask
+            const task = event.data as unknown as Task
             if (shouldAutoBid(task, config)) {
               await submitAutoBid(client, task.id, config)
               logActivity({
@@ -163,7 +179,7 @@ const swarmdock: PlatformConnector = {
           }
 
           case 'task.assigned': {
-            const task = event.data as unknown as SwarmDockTask
+            const task = event.data as unknown as Task
             if (!task.assigneeId) break
 
             // Signal work started on SwarmDock
@@ -195,6 +211,27 @@ const swarmdock: PlatformConnector = {
             break
           }
 
+          case 'task.review': {
+            const taskId = (event.data as Record<string, string>).taskId
+            if (taskId) await updateBoardTaskFromEvent(taskId, 'task.review')
+            break
+          }
+
+          case 'task.disputed': {
+            const taskId = (event.data as Record<string, string>).taskId
+            if (taskId) {
+              await updateBoardTaskFromEvent(taskId, 'task.disputed')
+              logActivity({
+                entityType: 'connector',
+                entityId: connectorId,
+                action: 'incident',
+                actor: 'system',
+                summary: `SwarmDock task ${taskId} disputed`,
+              })
+            }
+            break
+          }
+
           case 'payment.released': {
             const data = event.data as Record<string, string>
             logActivity({
@@ -206,6 +243,32 @@ const swarmdock: PlatformConnector = {
             })
             break
           }
+
+          case 'escrow.releasing':
+          case 'escrow.refunding': {
+            const data = event.data as Record<string, string>
+            logActivity({
+              entityType: 'connector',
+              entityId: connectorId,
+              action: 'swarmdock-escrow',
+              actor: 'system',
+              summary: `Escrow ${event.type.split('.')[1]} for task ${data.taskId}`,
+            })
+            break
+          }
+
+          case 'escrow.release_failed':
+          case 'escrow.refund_failed': {
+            const data = event.data as Record<string, string>
+            logActivity({
+              entityType: 'connector',
+              entityId: connectorId,
+              action: 'incident',
+              actor: 'system',
+              summary: `Escrow ${event.type.replace('escrow.', '')} for task ${data.taskId}`,
+            })
+            break
+          }
         }
       } catch (err) {
         log.error(TAG, `Error handling SSE event ${event.type}: ${err instanceof Error ? err.message : String(err)}`)
@@ -220,7 +283,12 @@ const swarmdock: PlatformConnector = {
         await client.heartbeat()
         log.debug(TAG, 'SwarmDock token refreshed')
       } catch (err) {
-        log.error(TAG, `SwarmDock heartbeat failed: ${err instanceof Error ? err.message : String(err)}`)
+        if (err instanceof AuthenticationError) {
+          log.warn(TAG, 'SwarmDock token expired, re-authenticating')
+          try { await client.authenticate() } catch {}
+        } else {
+          log.error(TAG, `SwarmDock heartbeat failed: ${err instanceof Error ? err.message : String(err)}`)
+        }
       }
     }, 23 * 60 * 60 * 1000)
 

package/src/lib/server/execution-brief.ts

@@ -12,6 +12,7 @@ import { getSession } from '@/lib/server/sessions/session-repository'
 import { loadSessionWorkingState } from '@/lib/server/working-state/service'
 import { ensureRunContext } from '@/lib/server/run-context'
 import { cleanText, cleanMultiline } from '@/lib/server/text-normalization'
+import { resolveEffectiveGoal, getGoalChain, formatGoalChainForBrief } from '@/lib/server/goals/goal-service'
 
 const MAX_PLAN_ITEMS = 8
 const MAX_FACTS = 8
@@ -224,8 +225,25 @@ export function buildExecutionBriefContextBlock(
     || brief.evidenceRefs.length > 0,
   )
   if (!hasContent && brief.status === 'idle') return ''
+  // Resolve goal chain for the session's agent/task/project context
+  let goalBlock = ''
+  if (brief.sessionId) {
+    const session = getSession(brief.sessionId)
+    if (session) {
+      const goal = resolveEffectiveGoal({
+        agentId: session.agentId || null,
+        projectId: session.projectId || null,
+      })
+      if (goal) {
+        const chain = getGoalChain(goal.id)
+        goalBlock = formatGoalChainForBrief(chain)
+      }
+    }
+  }
+
   const sections = [
     options?.title || '## Execution Brief',
+    goalBlock,
     brief.parentContext ? `Parent context:\n${brief.parentContext}` : '',
     brief.objective ? `Objective: ${brief.objective}` : '',
     brief.summary ? `Summary: ${brief.summary}` : '',

package/src/lib/server/goals/goal-repository.ts

@@ -0,0 +1,19 @@
+import type { Goal } from '@/types'
+import { loadGoals, loadGoal, upsertGoal, deleteGoalItem } from '@/lib/server/storage'
+import { perf } from '@/lib/server/runtime/perf'
+
+export function listGoals(): Record<string, Goal> {
+  return perf.measureSync('repository', 'goals.list', () => loadGoals()) as Record<string, Goal>
+}
+
+export function getGoal(id: string): Goal | null {
+  return perf.measureSync('repository', 'goals.get', () => loadGoal(id)) as Goal | null
+}
+
+export function saveGoal(id: string, goal: Goal): void {
+  perf.measureSync('repository', 'goals.upsert', () => upsertGoal(id, goal), { id })
+}
+
+export function removeGoal(id: string): void {
+  perf.measureSync('repository', 'goals.delete', () => deleteGoalItem(id), { id })
+}

package/src/lib/server/goals/goal-service.ts

@@ -0,0 +1,143 @@
+import type { Goal, GoalLevel } from '@/types'
+import { genId } from '@/lib/id'
+import { listGoals, getGoal, saveGoal, removeGoal } from './goal-repository'
+import { logActivity } from '@/lib/server/activity/activity-log'
+import { notify } from '@/lib/server/ws-hub'
+
+export function getAllGoals(): Goal[] {
+  return Object.values(listGoals())
+}
+
+export function getGoalById(id: string): Goal | null {
+  return getGoal(id)
+}
+
+export function createGoal(input: {
+  title: string
+  description?: string
+  level: GoalLevel
+  parentGoalId?: string | null
+  projectId?: string | null
+  agentId?: string | null
+  taskId?: string | null
+  objective: string
+  constraints?: string[]
+  successMetric?: string | null
+  budgetUsd?: number | null
+  deadlineAt?: number | null
+}): Goal {
+  const id = genId()
+  const now = Date.now()
+  const goal: Goal = {
+    id,
+    title: input.title,
+    description: input.description,
+    level: input.level,
+    parentGoalId: input.parentGoalId ?? null,
+    projectId: input.projectId ?? null,
+    agentId: input.agentId ?? null,
+    taskId: input.taskId ?? null,
+    objective: input.objective,
+    constraints: input.constraints ?? [],
+    successMetric: input.successMetric ?? null,
+    budgetUsd: input.budgetUsd ?? null,
+    deadlineAt: input.deadlineAt ?? null,
+    status: 'active',
+    createdAt: now,
+    updatedAt: now,
+  }
+  saveGoal(id, goal)
+  logActivity({ entityType: 'task', entityId: id, action: 'created', actor: 'user', summary: `Goal created: "${goal.title}" (${goal.level})` })
+  notify('goals')
+  return goal
+}
+
+export function updateGoal(id: string, updates: Partial<Omit<Goal, 'id' | 'createdAt'>>): Goal | null {
+  const existing = getGoal(id)
+  if (!existing) return null
+  const updated: Goal = {
+    ...existing,
+    ...updates,
+    id,
+    createdAt: existing.createdAt,
+    updatedAt: Date.now(),
+  }
+  saveGoal(id, updated)
+  logActivity({ entityType: 'task', entityId: id, action: 'updated', actor: 'user', summary: `Goal updated: "${updated.title}"` })
+  notify('goals')
+  return updated
+}
+
+export function deleteGoal(id: string): boolean {
+  const existing = getGoal(id)
+  if (!existing) return false
+  removeGoal(id)
+  logActivity({ entityType: 'task', entityId: id, action: 'deleted', actor: 'user', summary: `Goal deleted: "${existing.title}"` })
+  notify('goals')
+  return true
+}
+
+/**
+ * Walk the goal hierarchy to build a "why chain" from a specific goal up to the organization root.
+ * Returns goals in order from most specific to most general.
+ */
+export function getGoalChain(goalId: string): Goal[] {
+  const chain: Goal[] = []
+  const visited = new Set<string>()
+  let currentId: string | null | undefined = goalId
+  while (currentId && !visited.has(currentId)) {
+    visited.add(currentId)
+    const goal = getGoal(currentId)
+    if (!goal) break
+    chain.push(goal)
+    currentId = goal.parentGoalId
+  }
+  return chain
+}
+
+/**
+ * Resolve the effective goal for a given context by walking the hierarchy:
+ * task goal → agent goal → project goal → organization default.
+ */
+export function resolveEffectiveGoal(context: {
+  taskId?: string | null
+  agentId?: string | null
+  projectId?: string | null
+}): Goal | null {
+  const goals = getAllGoals().filter((g) => g.status === 'active')
+
+  // 1. Task-level goal
+  if (context.taskId) {
+    const taskGoal = goals.find((g) => g.taskId === context.taskId)
+    if (taskGoal) return taskGoal
+  }
+
+  // 2. Agent-level goal
+  if (context.agentId) {
+    const agentGoal = goals.find((g) => g.level === 'agent' && g.agentId === context.agentId)
+    if (agentGoal) return agentGoal
+  }
+
+  // 3. Project-level goal
+  if (context.projectId) {
+    const projectGoal = goals.find((g) => g.level === 'project' && g.projectId === context.projectId)
+    if (projectGoal) return projectGoal
+  }
+
+  // 4. Organization default
+  const orgGoal = goals.find((g) => g.level === 'organization')
+  return orgGoal ?? null
+}
+
+/**
+ * Format a goal chain as a concise text block for injection into agent execution briefs.
+ */
+export function formatGoalChainForBrief(chain: Goal[]): string {
+  if (chain.length === 0) return ''
+  const lines = chain.map((g, i) => {
+    const indent = '  '.repeat(i)
+    const label = g.level.charAt(0).toUpperCase() + g.level.slice(1)
+    return `${indent}${label}: ${g.title} — ${g.objective}`
+  })
+  return `Goal alignment:\n${lines.join('\n')}`
+}

package/src/lib/server/storage-normalization.ts

@@ -507,6 +507,11 @@ function normalizeStoredRecordInner(
       agent.delegationEnabled = false
       agent.heartbeatEnabled = false
     }
+    // Persisted spend rollup defaults
+    if (typeof agent.spentMonthlyCents !== 'number') agent.spentMonthlyCents = 0
+    if (typeof agent.spentDailyCents !== 'number') agent.spentDailyCents = 0
+    if (typeof agent.spentHourlyCents !== 'number') agent.spentHourlyCents = 0
+    if (typeof agent.lastSpendRollupAt !== 'number') agent.lastSpendRollupAt = 0
     // Org chart normalization
     if (agent.orgChart && typeof agent.orgChart === 'object' && !Array.isArray(agent.orgChart)) {
       const oc = agent.orgChart as Record<string, unknown>

package/src/lib/server/storage.ts

@@ -157,6 +157,7 @@ const COLLECTIONS = [
   'daemon_status',
   'wallets',
   'wallet_transactions',
+  'goals',
 ] as const
 
 export type StorageCollection = (typeof COLLECTIONS)[number]
@@ -168,6 +169,10 @@ for (const table of COLLECTIONS) {
 // Index for efficient protocol_run_events queries by runId
 db.exec(`CREATE INDEX IF NOT EXISTS idx_protocol_run_events_runid ON protocol_run_events (json_extract(data, '$.runId'))`)
 
+// Indexes for efficient activity log queries
+db.exec(`CREATE INDEX IF NOT EXISTS idx_activity_timestamp ON activity (json_extract(data, '$.timestamp'))`)
+db.exec(`CREATE INDEX IF NOT EXISTS idx_activity_entity ON activity (json_extract(data, '$.entityType'), json_extract(data, '$.entityId'))`)
+
 // Singleton tables (single row)
 db.exec(`CREATE TABLE IF NOT EXISTS settings (id INTEGER PRIMARY KEY CHECK (id = 1), data TEXT NOT NULL)`)
 db.exec(`CREATE TABLE IF NOT EXISTS queue (id INTEGER PRIMARY KEY CHECK (id = 1), data TEXT NOT NULL)`)
@@ -1465,6 +1470,51 @@ export function logActivity(entry: {
   notify('activity')
 }
 
+/** Paginated activity query using SQL WHERE + LIMIT/OFFSET instead of loading the full collection. */
+export function queryActivity(filters: {
+  entityType?: string
+  entityId?: string
+  actor?: string
+  action?: string
+  since?: number
+  limit?: number
+  offset?: number
+}): unknown[] {
+  const conditions: string[] = []
+  const params: unknown[] = []
+
+  if (filters.entityType) {
+    conditions.push(`json_extract(data, '$.entityType') = ?`)
+    params.push(filters.entityType)
+  }
+  if (filters.entityId) {
+    conditions.push(`json_extract(data, '$.entityId') = ?`)
+    params.push(filters.entityId)
+  }
+  if (filters.actor) {
+    conditions.push(`json_extract(data, '$.actor') = ?`)
+    params.push(filters.actor)
+  }
+  if (filters.action) {
+    conditions.push(`json_extract(data, '$.action') = ?`)
+    params.push(filters.action)
+  }
+  if (typeof filters.since === 'number' && Number.isFinite(filters.since)) {
+    conditions.push(`json_extract(data, '$.timestamp') >= ?`)
+    params.push(filters.since)
+  }
+
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : ''
+  const limit = Math.min(200, Math.max(1, filters.limit ?? 50))
+  const offset = Math.max(0, filters.offset ?? 0)
+
+  const sql = `SELECT data FROM activity ${where} ORDER BY json_extract(data, '$.timestamp') DESC LIMIT ? OFFSET ?`
+  params.push(limit, offset)
+
+  const rows = db.prepare(sql).all(...params) as Array<{ data: string }>
+  return rows.map((r) => JSON.parse(r.data))
+}
+
 // --- Webhook Retry Queue ---
 const webhookRetryQueueStore = createCollectionStore('webhook_retry_queue')
 export const loadWebhookRetryQueue = webhookRetryQueueStore.load
@@ -1586,6 +1636,13 @@ export const loadWalletTransaction = walletTransactionsStore.loadItem
 export const upsertWalletTransaction = walletTransactionsStore.upsert
 export const deleteWalletTransaction = walletTransactionsStore.deleteItem
 
+// --- Goals ---
+const goalsStore = createCollectionStore('goals')
+export const loadGoals = goalsStore.load
+export const loadGoal = goalsStore.loadItem
+export const upsertGoal = goalsStore.upsert
+export const deleteGoalItem = goalsStore.deleteItem
+
 export function getSessionMessages(sessionId: string): Message[] {
   const session = loadSession(sessionId)
   return Array.isArray(session?.messages) ? session.messages : []