@swarmclawai/swarmclaw 1.2.9 → 1.3.0

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 : []

package/src/lib/server/usage/cost-rollup.ts

@@ -0,0 +1,124 @@
+import type { Agent } from '@/types'
+import { patchAgent } from '@/lib/server/agents/agent-repository'
+import { logActivity } from '@/lib/server/activity/activity-log'
+import { notify } from '@/lib/server/ws-hub'
+import { log } from '@/lib/server/logger'
+
+const TAG = 'cost-rollup'
+
+const ONE_HOUR_MS = 60 * 60 * 1000
+
+function toWindowBoundaries(now: number) {
+  const d = new Date(now)
+  const dayStart = new Date(d)
+  dayStart.setUTCHours(0, 0, 0, 0)
+  const monthStart = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), 1))
+  return {
+    hourStartTs: now - ONE_HOUR_MS,
+    dayStartTs: dayStart.getTime(),
+    monthStartTs: monthStart.getTime(),
+  }
+}
+
+/**
+ * Push-based cost rollup: atomically increments the agent's persisted spend
+ * fields and checks budgets. Called immediately after each usage record is appended.
+ */
+export function rollupCostToAgent(agentId: string, costUsd: number): void {
+  if (!agentId || !Number.isFinite(costUsd) || costUsd <= 0) return
+
+  const now = Date.now()
+  const costCents = Math.round(costUsd * 100)
+  const { hourStartTs, dayStartTs, monthStartTs } = toWindowBoundaries(now)
+
+  const updated = patchAgent(agentId, (current) => {
+    if (!current) return null
+    const lastRollup = current.lastSpendRollupAt ?? 0
+    const lastBounds = toWindowBoundaries(lastRollup)
+
+    // Reset windows that have rolled over since last rollup
+    let hourly = current.spentHourlyCents ?? 0
+    let daily = current.spentDailyCents ?? 0
+    let monthly = current.spentMonthlyCents ?? 0
+
+    if (lastRollup < hourStartTs) hourly = 0
+    if (lastBounds.dayStartTs < dayStartTs) daily = 0
+    if (lastBounds.monthStartTs < monthStartTs) monthly = 0
+
+    return {
+      ...current,
+      spentHourlyCents: hourly + costCents,
+      spentDailyCents: daily + costCents,
+      spentMonthlyCents: monthly + costCents,
+      lastSpendRollupAt: now,
+    }
+  })
+
+  if (!updated) return
+
+  // Check budgets and enforce
+  checkAndEnforceBudget(updated)
+}
+
+/**
+ * Checks agent's persisted spend against configured budgets and logs
+ * activity entries when thresholds are hit.
+ */
+function checkAndEnforceBudget(agent: Agent): void {
+  const WARNING_RATIO = 0.8
+
+  const windows = [
+    { key: 'hourly' as const, budget: agent.hourlyBudget, spent: (agent.spentHourlyCents ?? 0) / 100 },
+    { key: 'daily' as const, budget: agent.dailyBudget, spent: (agent.spentDailyCents ?? 0) / 100 },
+    { key: 'monthly' as const, budget: agent.monthlyBudget, spent: (agent.spentMonthlyCents ?? 0) / 100 },
+  ]
+
+  for (const { key, budget, spent } of windows) {
+    if (!budget || !Number.isFinite(budget) || budget <= 0) continue
+    const ratio = spent / budget
+
+    if (ratio >= 1) {
+      log.warn(TAG, `Agent "${agent.name}" exceeded ${key} budget: $${spent.toFixed(4)} / $${budget.toFixed(2)}`)
+      logActivity({
+        entityType: 'budget',
+        entityId: agent.id,
+        action: 'budget_exceeded',
+        actor: 'system',
+        summary: `Agent "${agent.name}" exceeded ${key} budget: $${spent.toFixed(4)} / $${budget.toFixed(2)}`,
+        detail: { window: key, spent, budget, ratio },
+      })
+      notify('agents')
+    } else if (ratio >= WARNING_RATIO) {
+      logActivity({
+        entityType: 'budget',
+        entityId: agent.id,
+        action: 'budget_warning',
+        actor: 'system',
+        summary: `Agent "${agent.name}" nearing ${key} budget: $${spent.toFixed(4)} / $${budget.toFixed(2)} (${Math.round(ratio * 100)}%)`,
+        detail: { window: key, spent, budget, ratio },
+      })
+    }
+  }
+}
+
+/**
+ * Reset all agents' daily spend counters. Call at UTC midnight.
+ */
+export function resetDailySpends(agents: Record<string, Agent>): void {
+  for (const agent of Object.values(agents)) {
+    if ((agent.spentDailyCents ?? 0) > 0) {
+      patchAgent(agent.id, (current) => current ? { ...current, spentDailyCents: 0 } : null)
+    }
+  }
+}
+
+/**
+ * Reset all agents' monthly spend counters. Call at UTC month boundary.
+ */
+export function resetMonthlySpends(agents: Record<string, Agent>): void {
+  for (const agent of Object.values(agents)) {
+    if ((agent.spentMonthlyCents ?? 0) > 0) {
+      patchAgent(agent.id, (current) => current ? { ...current, spentMonthlyCents: 0 } : null)
+    }
+  }
+}

package/src/lib/server/usage/usage-repository.ts

@@ -8,6 +8,7 @@ import {
   saveUsage as saveStoredUsage,
 } from '@/lib/server/storage'
 import { perf } from '@/lib/server/runtime/perf'
+import { rollupCostToAgent } from './cost-rollup'
 
 export function loadUsage(): Record<string, UsageRecord[]> {
   return perf.measureSync('repository', 'usage.list', () => loadStoredUsage())
@@ -19,6 +20,11 @@ export function saveUsage(data: Record<string, UsageRecord[]>): void {
 
 export function appendUsage(sessionId: string, record: unknown): void {
   perf.measureSync('repository', 'usage.append', () => appendStoredUsage(sessionId, record), { sessionId })
+  // Push-based cost rollup: update persisted spend fields and check budgets
+  const rec = record as Partial<UsageRecord>
+  if (rec.agentId && typeof rec.estimatedCost === 'number' && rec.estimatedCost > 0) {
+    rollupCostToAgent(rec.agentId, rec.estimatedCost)
+  }
 }
 
 export function getUsageSpendSince(minTimestamp: number): number {

package/src/lib/validation/schemas.ts

@@ -1,6 +1,4 @@
 import { z } from 'zod'
-import type { ProtocolStepDefinition } from '@/types'
-import { validateStepDag, validateStepRefs } from '@/lib/server/protocols/step-dag-validation'
 
 const OllamaModeSchema = z.enum(['local', 'cloud']).nullable().optional().default(null)
 
@@ -424,7 +422,9 @@ export const ProtocolRunCreateSchema = z.object({
   entryStepId: z.string().nullable().optional().default(null),
 })
 
-export const ProtocolTemplateUpsertSchema = z.object({
+/** Base protocol template schema without server-side DAG validation.
+ *  Use ProtocolTemplateUpsertSchema from '@/lib/validation/server-schemas' for full server-side validation. */
+export const ProtocolTemplateUpsertBaseSchema = z.object({
   name: z.string().min(1, 'A template name is required'),
   description: z.string().min(1, 'A template description is required'),
   singleAgentAllowed: z.boolean().optional().default(true),
@@ -433,33 +433,6 @@ export const ProtocolTemplateUpsertSchema = z.object({
   defaultPhases: z.array(ProtocolPhaseDefinitionSchema).optional().default([]),
   steps: z.array(ProtocolStepDefinitionSchema).optional().default([]),
   entryStepId: z.string().nullable().optional().default(null),
-}).superRefine((value, ctx) => {
-  if (value.defaultPhases.length === 0 && value.steps.length === 0) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: ['steps'],
-      message: 'Provide at least one phase or one step.',
-    })
-  }
-  if (value.steps.length > 0) {
-    const steps = value.steps as ProtocolStepDefinition[]
-    const dagResult = validateStepDag(steps)
-    if (!dagResult.valid) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ['steps'],
-        message: `Cycle detected in step dependencies: ${dagResult.cycle?.join(' → ')}`,
-      })
-    }
-    const invalidRefs = validateStepRefs(steps)
-    for (const ref of invalidRefs) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ['steps'],
-        message: `Step references unknown step ID: "${ref}"`,
-      })
-    }
-  }
 })
 
 export const ProtocolRunActionSchema = z.object({

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

@@ -0,0 +1,35 @@
+import { z } from 'zod'
+import type { ProtocolStepDefinition } from '@/types'
+import { validateStepDag, validateStepRefs } from '@/lib/server/protocols/step-dag-validation'
+import { ProtocolTemplateUpsertBaseSchema } from './schemas'
+
+/** Full protocol template upsert schema with server-side DAG validation.
+ *  For client-side use (without server deps), use ProtocolTemplateUpsertBaseSchema from './schemas'. */
+export const ProtocolTemplateUpsertSchema = ProtocolTemplateUpsertBaseSchema.superRefine((value, ctx) => {
+  if (value.defaultPhases.length === 0 && value.steps.length === 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['steps'],
+      message: 'Provide at least one phase or one step.',
+    })
+  }
+  if (value.steps.length > 0) {
+    const steps = value.steps as ProtocolStepDefinition[]
+    const dagResult = validateStepDag(steps)
+    if (!dagResult.valid) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['steps'],
+        message: `Cycle detected in step dependencies: ${dagResult.cycle?.join(' → ')}`,
+      })
+    }
+    const invalidRefs = validateStepRefs(steps)
+    for (const ref of invalidRefs) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['steps'],
+        message: `Step references unknown step ID: "${ref}"`,
+      })
+    }
+  }
+})

package/src/types/agent.ts

@@ -88,6 +88,8 @@ export interface Agent {
   monthlyBudget?: number | null
   dailyBudget?: number | null
   hourlyBudget?: number | null
+  /** Reference to a Goal in the goal hierarchy. */
+  goalId?: string | null
   autoRecovery?: boolean
   proactiveMemory?: boolean
   /** Auto-refresh a reviewed skill draft from meaningful chat turns for this agent. */
@@ -152,6 +154,14 @@ export interface Agent {
   dailySpend?: number
   /** Runtime-enriched: trailing 1-hour spend. Populated by GET /api/agents when hourlyBudget is set. */
   hourlySpend?: number
+  /** Persisted: accumulated spend in current monthly window (USD). Updated on each usage event. */
+  spentMonthlyCents?: number
+  /** Persisted: accumulated spend in current daily window (USD). Updated on each usage event. */
+  spentDailyCents?: number
+  /** Persisted: accumulated spend in current hourly window (USD). Updated on each usage event. */
+  spentHourlyCents?: number
+  /** Timestamp of last spend rollup; used to detect window resets. */
+  lastSpendRollupAt?: number
   maxFollowupChain?: number
 
   // Orchestrator Mode

package/src/types/app-settings.ts

@@ -148,6 +148,12 @@ export interface AppSettings {
   toolLoopCircuitBreaker?: number
   // Per-extension settings (keyed by extensionId)
   extensionSettings?: Record<string, Record<string, unknown>>
+  // Approval policies — opt-in governance gates for sensitive operations
+  approvalPolicies?: {
+    requireApprovalForAgentCreate?: boolean
+    requireApprovalForBudgetChange?: boolean
+    requireApprovalForDelegationEnable?: boolean
+  }
 }
 
 export interface EstopState {

package/src/types/approval.ts

@@ -7,6 +7,9 @@ export type ApprovalCategory =
   | 'task_tool'
   | 'human_loop'
   | 'connector_sender'
+  | 'agent_create'
+  | 'budget_change'
+  | 'delegation_enable'
 
 export interface ApprovalRequest {
   id: string

package/src/types/goal.ts

@@ -0,0 +1,30 @@
+export type GoalLevel = 'organization' | 'team' | 'project' | 'agent' | 'task'
+
+export type GoalStatus = 'active' | 'achieved' | 'abandoned'
+
+export interface Goal {
+  id: string
+  title: string
+  description?: string
+  level: GoalLevel
+  parentGoalId?: string | null
+  /** Link to a project (for project-level goals). */
+  projectId?: string | null
+  /** Link to an agent (for agent-level goals). */
+  agentId?: string | null
+  /** Link to a task (for task-level goals). */
+  taskId?: string | null
+  /** The concrete objective this goal achieves. */
+  objective: string
+  /** Constraints or guardrails on how the goal should be pursued. */
+  constraints?: string[]
+  /** How success is measured. */
+  successMetric?: string | null
+  /** Optional budget cap for this goal (USD). */
+  budgetUsd?: number | null
+  /** Optional deadline. */
+  deadlineAt?: number | null
+  status: GoalStatus
+  createdAt: number
+  updatedAt: number
+}

package/src/types/index.ts

@@ -13,4 +13,5 @@ export * from './skill'
 export * from './run'
 export * from './approval'
 export * from './misc'
+export * from './goal'
 export * from './swarmdock'

package/src/types/misc.ts

@@ -126,9 +126,9 @@ export interface Chatroom {
 
 export interface ActivityEntry {
   id: string
-  entityType: 'agent' | 'task' | 'connector' | 'session' | 'webhook' | 'schedule' | 'delegation' | 'swarm' | 'chatroom' | 'coordination'
+  entityType: 'agent' | 'task' | 'connector' | 'session' | 'webhook' | 'schedule' | 'delegation' | 'swarm' | 'chatroom' | 'coordination' | 'approval' | 'settings' | 'budget' | 'credential'
   entityId: string
-  action: 'created' | 'updated' | 'deleted' | 'started' | 'stopped' | 'queued' | 'completed' | 'failed' | 'archived' | 'restored' | 'approved' | 'rejected' | 'delegated' | 'queried' | 'spawned' | 'timeout' | 'cancelled' | 'incident' | 'running' | 'claimed'
+  action: 'created' | 'updated' | 'deleted' | 'started' | 'stopped' | 'queued' | 'completed' | 'failed' | 'archived' | 'restored' | 'approved' | 'rejected' | 'delegated' | 'queried' | 'spawned' | 'timeout' | 'cancelled' | 'incident' | 'running' | 'claimed' | 'configured' | 'budget_exceeded' | 'budget_warning'
   actor: 'user' | 'agent' | 'system' | 'daemon'
   actorId?: string
   summary: string

package/src/types/task.ts

@@ -35,6 +35,8 @@ export interface BoardTask {
   rootTaskId?: string | null
   projectId?: string
   goalContract?: GoalContract | null
+  /** Reference to a Goal in the goal hierarchy. Takes precedence over goalContract when set. */
+  goalId?: string | null
   cwd?: string | null
   file?: string | null
   sessionId?: string | null