@swarmclawai/swarmclaw 1.2.8 → 1.3.0

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

@@ -0,0 +1,127 @@
+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
+}
+
+/**
+ * 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,
+  agentId: string,
+  connectorId: string,
+  apiUrl: string,
+): Promise<string> {
+  const tasks = loadTasks() as Record<string, BoardTask>
+  const id = genId()
+  const now = Date.now()
+
+  const boardTask: BoardTask = {
+    id,
+    title: task.title,
+    description: task.description,
+    status: 'running',
+    agentId,
+    createdAt: now,
+    updatedAt: now,
+    startedAt: now,
+    lastActivityAt: now,
+    sourceType: 'import',
+    externalSource: {
+      source: 'swarmdock',
+      id: task.id,
+      state: 'in_progress',
+      url: `${apiUrl}/tasks/${task.id}`,
+    },
+    tags: task.skillRequirements,
+    objective: task.description,
+    followupConnectorId: connectorId,
+  }
+
+  if (task.deadline) {
+    boardTask.dueAt = new Date(task.deadline).getTime()
+  }
+
+  tasks[id] = boardTask
+  saveTasks(tasks)
+
+  logActivity({
+    entityType: 'task',
+    entityId: id,
+    action: 'created',
+    actor: 'system',
+    summary: `SwarmDock task assigned: "${task.title}"`,
+  })
+
+  return id
+}
+
+/**
+ * Update a SwarmClaw BoardTask based on a SwarmDock SSE event.
+ */
+export async function updateBoardTaskFromEvent(
+  swarmdockTaskId: string,
+  eventType: string,
+): Promise<void> {
+  const tasks = loadTasks() as Record<string, BoardTask>
+  const boardTask = Object.values(tasks).find(
+    (t) => t.externalSource?.source === 'swarmdock' && t.externalSource.id === swarmdockTaskId,
+  )
+  if (!boardTask) return
+
+  const now = Date.now()
+
+  switch (eventType) {
+    case 'task.completed':
+      boardTask.status = 'completed'
+      boardTask.completedAt = now
+      boardTask.checkoutRunId = null
+      break
+    case 'task.submitted':
+      // Results submitted, waiting for approval on SwarmDock
+      if (boardTask.externalSource) boardTask.externalSource.state = 'review'
+      break
+    case 'task.cancelled':
+      boardTask.status = 'cancelled'
+      boardTask.checkoutRunId = null
+      break
+    case 'task.failed':
+      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
+  boardTask.lastActivityAt = now
+  saveTasks(tasks)
+}
+
+/**
+ * Find a SwarmClaw BoardTask ID by its SwarmDock task ID.
+ */
+export function findBoardTaskBySwarmdockId(swarmdockTaskId: string): string | null {
+  const tasks = loadTasks() as Record<string, BoardTask>
+  const task = Object.values(tasks).find(
+    (t) => t.externalSource?.source === 'swarmdock' && t.externalSource.id === swarmdockTaskId,
+  )
+  return task?.id || null
+}

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

@@ -0,0 +1,285 @@
+import { log } from '@/lib/server/logger'
+import { hmrSingleton } from '@/lib/shared-utils'
+import { logActivity } from '@/lib/server/activity/activity-log'
+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'
+
+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
+  agentDescription: string
+  skills: string
+  autoDiscover: boolean
+  maxBudget: string
+  paymentPrivateKey?: string
+}
+
+function parseConfig(connector: Connector): SwarmDockConfig {
+  const c = connector.config || {}
+  return {
+    apiUrl: c.apiUrl || 'https://api.swarmdock.ai',
+    walletAddress: c.walletAddress || '',
+    agentDescription: c.agentDescription || connector.name || '',
+    skills: c.skills || '',
+    autoDiscover: c.autoDiscover === 'true',
+    maxBudget: c.maxBudget || '0',
+    paymentPrivateKey: c.paymentPrivateKey || undefined,
+  }
+}
+
+function buildTaskPrompt(task: SwarmDockTask): string {
+  const lines: string[] = [
+    `# SwarmDock Task: ${task.title}`,
+    '',
+    task.description,
+    '',
+    `**Required Skills:** ${task.skillRequirements.join(', ')}`,
+    `**Budget:** ${formatUsdc(task.budgetMax)}`,
+  ]
+  if (task.deadline) lines.push(`**Deadline:** ${task.deadline}`)
+  lines.push('', 'Complete this task and provide your deliverables. Your response will be submitted as the task result on the SwarmDock marketplace.')
+  return lines.join('\n')
+}
+
+function formatUsdc(microUnits: string): string {
+  const cents = BigInt(microUnits)
+  const dollars = Number(cents) / 1_000_000
+  return `$${dollars.toFixed(2)} USDC`
+}
+
+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)
+}
+
+/** Runtime state: maps SwarmDock task IDs → SwarmClaw BoardTask IDs */
+const taskIdMap = hmrSingleton('__swarmclaw_swarmdock_task_map__', () => new Map<string, string>())
+
+const swarmdock: PlatformConnector = {
+  async start(connector, _botToken, onMessage): Promise<ConnectorInstance> {
+    const config = parseConfig(connector)
+    const connectorId = connector.id
+    const agentId = connector.agentId || ''
+    const privateKey = _botToken || ''
+
+    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)
+    let SwarmDockClient: typeof import('@swarmdock/sdk').SwarmDockClient
+    try {
+      const sdk = await import('@swarmdock/sdk')
+      SwarmDockClient = sdk.SwarmDockClient
+    } catch {
+      throw new Error('SwarmDock SDK (@swarmdock/sdk) is not installed. Run: npm install @swarmdock/sdk')
+    }
+
+    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)
+    const skillList = config.skills
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean)
+      .map((skillId) => ({
+        skillId,
+        skillName: skillId.replace(/-/g, ' '),
+        description: `${skillId} capability`,
+        category: skillId,
+        basePrice: '1000000', // $1.00 default
+        inputModes: ['text'],
+        outputModes: ['text'],
+      }))
+
+    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}`,
+    })
+
+    // Set up SSE event stream
+    let alive = true
+
+    const handleSSEEvent = async (event: SwarmDockSSEEvent) => {
+      if (!alive) return
+      try {
+        switch (event.type) {
+          case 'task.created': {
+            if (!config.autoDiscover) break
+            const task = event.data as unknown as SwarmDockTask
+            if (shouldAutoBid(task, config)) {
+              await submitAutoBid(client, task.id, config)
+              logActivity({
+                entityType: 'connector',
+                entityId: connectorId,
+                action: 'swarmdock-bid',
+                actor: 'system',
+                summary: `Auto-bid on SwarmDock task: "${task.title}"`,
+              })
+            }
+            break
+          }
+
+          case 'task.assigned': {
+            const task = event.data as unknown as SwarmDockTask
+            if (!task.assigneeId) break
+
+            // Signal work started on SwarmDock
+            try { await client.tasks.start(task.id) } catch {}
+
+            // Create a BoardTask in SwarmClaw
+            const boardTaskId = await createBoardTaskFromAssignment(task, agentId, connectorId, config.apiUrl)
+            taskIdMap.set(task.id, boardTaskId)
+
+            // Dispatch as inbound message to the assigned agent
+            const inbound: InboundMessage = {
+              platform: 'swarmdock',
+              channelId: `swarmdock-task:${task.id}`,
+              channelName: `SwarmDock: ${task.title}`,
+              senderId: task.requesterId,
+              senderName: `SwarmDock Requester`,
+              text: buildTaskPrompt(task),
+              messageId: task.id,
+            }
+            await onMessage(inbound)
+            break
+          }
+
+          case 'task.completed':
+          case 'task.cancelled':
+          case 'task.failed': {
+            const taskId = (event.data as Record<string, string>).taskId
+            if (taskId) await updateBoardTaskFromEvent(taskId, event.type)
+            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({
+              entityType: 'connector',
+              entityId: connectorId,
+              action: 'swarmdock-payment',
+              actor: 'system',
+              summary: `Payment received: ${formatUsdc(data.amount || '0')} for task ${data.taskId}`,
+            })
+            break
+          }
+        }
+      } catch (err) {
+        log.error(TAG, `Error handling SSE event ${event.type}: ${err instanceof Error ? err.message : String(err)}`)
+      }
+    }
+
+    client.events.subscribe(handleSSEEvent as (event: unknown) => void)
+
+    // Token refresh heartbeat (23h, token lasts 24h)
+    const heartbeatInterval = setInterval(async () => {
+      try {
+        await client.heartbeat()
+        log.debug(TAG, 'SwarmDock token refreshed')
+      } catch (err) {
+        log.error(TAG, `SwarmDock heartbeat failed: ${err instanceof Error ? err.message : String(err)}`)
+      }
+    }, 23 * 60 * 60 * 1000)
+
+    return {
+      connector,
+
+      stop: async () => {
+        alive = false
+        clearInterval(heartbeatInterval)
+        client.events.unsubscribe()
+        log.info(TAG, 'SwarmDock connector stopped')
+      },
+
+      sendMessage: async (channelId: string, text: string) => {
+        // channelId format: "swarmdock-task:{taskId}"
+        const swarmdockTaskId = channelId.replace('swarmdock-task:', '')
+        if (!swarmdockTaskId) return
+
+        await submitSwarmdockTaskResult(client, swarmdockTaskId, text)
+        log.info(TAG, `Submitted results for SwarmDock task ${swarmdockTaskId}`)
+
+        if (findBoardTaskBySwarmdockId(swarmdockTaskId)) {
+          await updateBoardTaskFromEvent(swarmdockTaskId, 'task.submitted')
+        }
+
+        return { messageId: swarmdockTaskId }
+      },
+    }
+  },
+}
+
+export default swarmdock

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

@@ -2,7 +2,7 @@ import assert from 'node:assert/strict'
 import { test } from 'node:test'
 
 import { buildExecutionBrief, buildExecutionBriefContextBlock, serializeExecutionBriefForDelegation } from './execution-brief'
-import type { Mission, Session, SessionWorkingState } from '@/types'
+import type { Session, SessionWorkingState } from '@/types'
 
 test('buildExecutionBrief prefers working state and folds in mission and run-context fallback data', () => {
   const session = {
@@ -31,25 +31,8 @@ test('buildExecutionBrief prefers working state and folds in mission and run-con
     },
   } satisfies Partial<Session> as Session
 
-  const mission = {
-    id: 'm1',
-    source: 'chat',
-    objective: 'Ship the release fix',
-    status: 'active',
-    phase: 'executing',
-    currentStep: 'Verify staging auth',
-    successCriteria: ['Restore staging deploys'],
-    waitState: {
-      kind: 'approval',
-      reason: 'Waiting for deploy approval.',
-    },
-    createdAt: 1,
-    updatedAt: 1,
-  } satisfies Partial<Mission> as Mission
-
   const workingState = {
     sessionId: 's1',
-    missionId: 'm1',
     objective: 'Ship the release fix safely',
     summary: 'Auth mismatch isolated to staging.',
     constraints: ['Do not change the API'],
@@ -79,7 +62,7 @@ test('buildExecutionBrief prefers working state and folds in mission and run-con
     updatedAt: 1,
   } satisfies SessionWorkingState
 
-  const brief = buildExecutionBrief({ session, mission, workingState })
+  const brief = buildExecutionBrief({ session, workingState })
 
   assert.equal(brief.objective, 'Ship the release fix safely')
   assert.equal(brief.summary, 'Auth mismatch isolated to staging.')
@@ -87,11 +70,9 @@ test('buildExecutionBrief prefers working state and folds in mission and run-con
   assert.equal(brief.nextAction, 'Request deploy approval')
   assert.equal(brief.plan[0]?.text, 'Request deploy approval')
   assert.equal(brief.blockers[0], 'Deploy approval is pending. | next: Request deploy approval')
-  assert.ok(brief.blockers.some((entry) => /waiting for deploy approval/i.test(entry)))
   assert.ok(brief.facts.some((entry) => /auth mismatch isolated to staging/i.test(entry)))
   assert.ok(brief.artifacts.some((entry) => /deploy\.log/i.test(entry)))
   assert.equal(brief.parentContext, 'Parent asked for a contained fix.')
-  assert.equal(brief.missionPhase, 'executing')
 })
 
 test('buildExecutionBriefContextBlock renders a single canonical state block', () => {
@@ -139,7 +120,6 @@ test('buildExecutionBriefContextBlock renders a single canonical state block', (
 test('serializeExecutionBriefForDelegation creates a bounded handoff summary', () => {
   const text = serializeExecutionBriefForDelegation({
     sessionId: 's3',
-    missionId: 'm3',
     objective: 'Repair the deployment pipeline',
     summary: 'The regression is isolated to the release job.',
     status: 'blocked',
@@ -153,9 +133,6 @@ test('serializeExecutionBriefForDelegation creates a bounded handoff summary', (
     artifacts: ['/tmp/project/release.log'],
     constraints: ['Keep the current release shape.'],
     successCriteria: ['Production deploy completes'],
-    missionStatus: 'active',
-    missionPhase: 'executing',
-    waitState: null,
     evidenceRefs: [],
     parentContext: 'Parent is waiting on a concise status update.',
   })

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

@@ -2,7 +2,6 @@ import type {
   EvidenceRef,
   ExecutionBrief,
   ExecutionBriefPlanStep,
-  Mission,
   Session,
   SessionWorkingState,
   WorkingPlanStep,
@@ -13,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
@@ -75,14 +75,8 @@ function dedupePlan(steps: ExecutionBriefPlanStep[]): ExecutionBriefPlanStep[] {
   return out
 }
 
-function inferStatus(mission: Mission | null | undefined, workingState: SessionWorkingState | null): WorkingStateStatus {
+function inferStatus(workingState: SessionWorkingState | null): WorkingStateStatus {
   if (workingState?.status) return workingState.status
-  if (!mission) return 'idle'
-  if (mission.status === 'completed') return 'completed'
-  if (mission.status === 'waiting') return 'waiting'
-  if (mission.status === 'failed' || mission.phase === 'failed') return 'blocked'
-  if (mission.waitState) return 'waiting'
-  if (mission.phase === 'executing' || mission.phase === 'dispatching' || mission.phase === 'verifying') return 'progress'
   return 'idle'
 }
 
@@ -121,15 +115,14 @@ function buildFacts(workingState: SessionWorkingState | null, session: Session |
   return uniqueStrings([...activeFacts, ...runContextFacts], MAX_FACTS, 240)
 }
 
-function buildBlockers(workingState: SessionWorkingState | null, mission: Mission | null | undefined, session: Session | null): string[] {
+function buildBlockers(workingState: SessionWorkingState | null, session: Session | null): string[] {
   const activeBlockers = workingState
     ? workingState.blockers
       .filter((blocker) => blocker.status === 'active')
       .map((blocker) => blocker.nextAction ? `${blocker.summary} | next: ${blocker.nextAction}` : blocker.summary)
     : []
-  const missionBlockers = mission?.waitState?.reason ? [cleanText(mission.waitState.reason, 280)] : []
   const runContextBlockers = session?.runContext ? ensureRunContext(session.runContext).blockers : []
-  return uniqueStrings([...activeBlockers, ...missionBlockers, ...runContextBlockers], MAX_BLOCKERS, 280)
+  return uniqueStrings([...activeBlockers, ...runContextBlockers], MAX_BLOCKERS, 280)
 }
 
 function buildArtifacts(workingState: SessionWorkingState | null): string[] {
@@ -147,8 +140,8 @@ function buildConstraints(workingState: SessionWorkingState | null, session: Ses
   return uniqueStrings([...(workingConstraints || []), ...(runContext?.constraints || [])], 10, 220)
 }
 
-function buildSuccessCriteria(workingState: SessionWorkingState | null, mission: Mission | null | undefined): string[] {
-  return uniqueStrings([...(workingState?.successCriteria || []), ...(mission?.successCriteria || [])], 10, 220)
+function buildSuccessCriteria(workingState: SessionWorkingState | null): string[] {
+  return uniqueStrings([...(workingState?.successCriteria || [])], 10, 220)
 }
 
 function buildEvidenceRefs(workingState: SessionWorkingState | null): EvidenceRef[] {
@@ -161,49 +154,40 @@ function buildEvidenceRefs(workingState: SessionWorkingState | null): EvidenceRe
 export function buildExecutionBrief(params: {
   sessionId?: string | null
   session?: Session | null
-  mission?: Mission | null
+  mission?: null
   workingState?: SessionWorkingState | null
 }): ExecutionBrief {
   const session = params.session
     || (params.sessionId ? getSession(params.sessionId) || null : null)
-  const mission = params.mission || null
   const workingState = params.workingState
-    || (session?.id ? loadSessionWorkingState(session.id, { mission }) : null)
+    || (session?.id ? loadSessionWorkingState(session.id) : null)
   const runContext = session?.runContext ? ensureRunContext(session.runContext) : null
   const plan = buildPlan(workingState, session)
   const nextAction = cleanText(
     workingState?.nextAction
-      || mission?.currentStep
       || plan.find((step) => step.status === 'active')?.text,
     240,
   ) || null
 
   return {
     sessionId: session?.id || params.sessionId || null,
-    missionId: mission?.id || workingState?.missionId || null,
     objective: cleanMultiline(
       workingState?.objective
-        || mission?.objective
         || runContext?.objective,
       900,
     ) || null,
     summary: cleanMultiline(
-      workingState?.summary
-        || mission?.verifierSummary
-        || mission?.plannerSummary,
+      workingState?.summary,
       700,
     ) || null,
-    status: inferStatus(mission, workingState),
+    status: inferStatus(workingState),
     nextAction,
     plan,
-    blockers: buildBlockers(workingState, mission, session),
+    blockers: buildBlockers(workingState, session),
     facts: buildFacts(workingState, session),
     artifacts: buildArtifacts(workingState),
     constraints: buildConstraints(workingState, session),
-    successCriteria: buildSuccessCriteria(workingState, mission),
-    missionStatus: mission?.status || null,
-    missionPhase: mission?.phase || null,
-    waitState: mission?.waitState || null,
+    successCriteria: buildSuccessCriteria(workingState),
     evidenceRefs: buildEvidenceRefs(workingState),
     parentContext: cleanMultiline(runContext?.parentContext, 900) || null,
   }
@@ -238,21 +222,32 @@ export function buildExecutionBriefContextBlock(
     || brief.artifacts.length > 0
     || brief.constraints.length > 0
     || brief.successCriteria.length > 0
-    || brief.evidenceRefs.length > 0
-    || brief.missionStatus
-    || brief.missionPhase
-    || brief.waitState?.reason,
+    || 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}` : '',
     `Status: ${brief.status}`,
-    brief.missionStatus ? `Mission status: ${brief.missionStatus}` : '',
-    brief.missionPhase ? `Mission phase: ${brief.missionPhase}` : '',
-    brief.waitState?.reason ? `Waiting reason: ${cleanText(brief.waitState.reason, 280)}` : '',
     brief.nextAction ? `Next action: ${brief.nextAction}` : '',
     brief.successCriteria.length > 0 ? `Success criteria: ${brief.successCriteria.join(' | ')}` : '',
     brief.constraints.length > 0 ? `Constraints: ${brief.constraints.join(' | ')}` : '',

package/src/lib/server/execution-engine/task-attempt.ts

@@ -238,7 +238,6 @@ export function enqueueTaskAttemptExecution(
   const run: SessionRunRecord = {
     id: executionId,
     sessionId: input.sessionId,
-    missionId: input.task.missionId || null,
     kind: 'task_attempt',
     ownerType: 'task',
     ownerId: input.task.id,

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 })
+}