@swarmclawai/swarmclaw 1.5.47 → 1.5.49

package/src/lib/server/missions/mission-service.ts

@@ -0,0 +1,299 @@
+import crypto from 'crypto'
+import type { Mission, MissionBudget, MissionReportSchedule, MissionStatus } from '@/types'
+import { DEFAULT_MISSION_WARN_FRACTIONS } from '@/types'
+import { hmrSingleton } from '@/lib/shared-utils'
+import { log } from '@/lib/server/logger'
+import {
+  appendMissionEvent,
+  appendMissionMilestone,
+  getMission,
+  listMissions,
+  patchMission,
+  upsertMission,
+} from './mission-repository'
+
+const TAG = 'mission-service'
+
+interface MissionRuntimeCache {
+  sessionToMission: Map<string, string>
+  hydratedAt: number
+}
+
+const runtime = hmrSingleton<MissionRuntimeCache>('mission_runtime_state', () => ({
+  sessionToMission: new Map(),
+  hydratedAt: 0,
+}))
+
+function hydrateSessionMap(force = false): void {
+  const now = Date.now()
+  if (!force && now - runtime.hydratedAt < 30_000) return
+  const missions = listMissions()
+  const next = new Map<string, string>()
+  for (const m of missions) {
+    if (m.status === 'running' || m.status === 'paused') {
+      if (m.rootSessionId) next.set(m.rootSessionId, m.id)
+    }
+  }
+  runtime.sessionToMission = next
+  runtime.hydratedAt = now
+}
+
+export function getMissionIdForSession(sessionId: string): string | null {
+  if (!sessionId) return null
+  hydrateSessionMap(false)
+  return runtime.sessionToMission.get(sessionId) ?? null
+}
+
+export function trackSessionMissionMapping(sessionId: string, missionId: string | null): void {
+  if (!sessionId) return
+  if (missionId) runtime.sessionToMission.set(sessionId, missionId)
+  else runtime.sessionToMission.delete(sessionId)
+}
+
+export interface CreateMissionInput {
+  title: string
+  goal: string
+  successCriteria?: string[]
+  rootSessionId: string
+  agentIds?: string[]
+  budget?: Partial<MissionBudget>
+  reportSchedule?: MissionReportSchedule | null
+  reportConnectorIds?: string[]
+}
+
+function newMissionId(): string {
+  return `mi_${crypto.randomBytes(8).toString('hex')}`
+}
+
+function sanitizeBudget(input: Partial<MissionBudget> = {}): MissionBudget {
+  const pick = (v: unknown): number | null => (typeof v === 'number' && Number.isFinite(v) ? v : null)
+  const warn = Array.isArray(input.warnAtFractions) && input.warnAtFractions.length
+    ? input.warnAtFractions.filter((f) => typeof f === 'number' && f > 0 && f < 1)
+    : DEFAULT_MISSION_WARN_FRACTIONS
+  return {
+    maxUsd: pick(input.maxUsd),
+    maxTokens: pick(input.maxTokens),
+    maxToolCalls: pick(input.maxToolCalls),
+    maxWallclockSec: pick(input.maxWallclockSec),
+    maxTurns: pick(input.maxTurns),
+    warnAtFractions: warn.length ? warn : DEFAULT_MISSION_WARN_FRACTIONS,
+  }
+}
+
+export function createMission(input: CreateMissionInput): Mission {
+  const now = Date.now()
+  const mission: Mission = {
+    id: newMissionId(),
+    title: input.title.trim(),
+    goal: input.goal.trim(),
+    successCriteria: (input.successCriteria ?? []).map((s) => s.trim()).filter(Boolean),
+    rootSessionId: input.rootSessionId,
+    agentIds: input.agentIds ?? [],
+    status: 'draft',
+    budget: sanitizeBudget(input.budget),
+    usage: {
+      usdSpent: 0,
+      tokensUsed: 0,
+      toolCallsUsed: 0,
+      turnsRun: 0,
+      wallclockMsElapsed: 0,
+      startedAt: null,
+      lastUpdatedAt: now,
+      warnFractionsHit: [],
+    },
+    milestones: [],
+    reportSchedule: input.reportSchedule ?? null,
+    reportConnectorIds: input.reportConnectorIds ?? [],
+    createdAt: now,
+    updatedAt: now,
+  }
+  upsertMission(mission)
+  log.info(TAG, `Created mission ${mission.id} (goal: ${mission.goal.slice(0, 80)})`)
+  return mission
+}
+
+function applyStatusTransition(
+  id: string,
+  next: MissionStatus,
+  opts: { reason?: string; milestoneSummary?: string; endReason?: string } = {},
+): Mission | null {
+  const updated = patchMission(id, (current) => {
+    if (!current) return null
+    const patch: Mission = { ...current, status: next }
+    if (next === 'running' && !current.usage.startedAt) {
+      patch.usage = { ...current.usage, startedAt: Date.now(), lastUpdatedAt: Date.now() }
+      patch.startedAt = patch.startedAt ?? Date.now()
+    }
+    if (next === 'completed' || next === 'failed' || next === 'cancelled' || next === 'budget_exhausted') {
+      patch.endedAt = Date.now()
+      patch.endReason = opts.endReason ?? opts.reason ?? null
+    }
+    return patch
+  })
+  if (!updated) return null
+  if (opts.milestoneSummary) {
+    appendMissionMilestone(id, {
+      kind: mapStatusToMilestoneKind(next),
+      summary: opts.milestoneSummary,
+    })
+  }
+  trackSessionMissionMapping(
+    updated.rootSessionId,
+    next === 'running' || next === 'paused' ? id : null,
+  )
+  return getMission(id)
+}
+
+function mapStatusToMilestoneKind(
+  status: MissionStatus,
+): 'started' | 'paused' | 'resumed' | 'completed' | 'failed' | 'cancelled' | 'budget_hit' {
+  switch (status) {
+    case 'running': return 'started'
+    case 'paused': return 'paused'
+    case 'completed': return 'completed'
+    case 'failed': return 'failed'
+    case 'cancelled': return 'cancelled'
+    case 'budget_exhausted': return 'budget_hit'
+    default: return 'started'
+  }
+}
+
+export function startMission(id: string): Mission | null {
+  const current = getMission(id)
+  if (!current) return null
+  if (current.status === 'running') return current
+  const next = current.status === 'paused' ? 'running' : 'running'
+  const summary = current.status === 'paused' ? 'Mission resumed' : 'Mission started'
+  const updated = applyStatusTransition(id, next, { milestoneSummary: summary })
+  if (updated && current.status === 'paused') {
+    appendMissionMilestone(id, { kind: 'resumed', summary: 'Mission resumed' })
+  }
+  return updated
+}
+
+export function pauseMission(id: string, reason?: string): Mission | null {
+  const current = getMission(id)
+  if (!current || current.status !== 'running') return current
+  return applyStatusTransition(id, 'paused', {
+    reason,
+    milestoneSummary: reason ?? 'Mission paused',
+  })
+}
+
+export function cancelMission(id: string, reason?: string): Mission | null {
+  const current = getMission(id)
+  if (!current) return null
+  if (current.status === 'completed' || current.status === 'cancelled') return current
+  return applyStatusTransition(id, 'cancelled', {
+    endReason: reason,
+    milestoneSummary: reason ?? 'Mission cancelled',
+  })
+}
+
+export function completeMission(id: string, summary?: string): Mission | null {
+  const current = getMission(id)
+  if (!current) return null
+  if (current.status === 'completed') return current
+  return applyStatusTransition(id, 'completed', {
+    endReason: summary,
+    milestoneSummary: summary ?? 'Mission complete',
+  })
+}
+
+export function failMission(id: string, reason: string): Mission | null {
+  const current = getMission(id)
+  if (!current) return null
+  if (current.status === 'failed') return current
+  return applyStatusTransition(id, 'failed', {
+    endReason: reason,
+    milestoneSummary: reason,
+  })
+}
+
+export function markBudgetExhausted(id: string, reason: string): Mission | null {
+  const current = getMission(id)
+  if (!current) return null
+  if (current.status === 'budget_exhausted' || current.status === 'completed') return current
+  appendMissionEvent(id, 'budget_exhausted', { reason })
+  return applyStatusTransition(id, 'budget_exhausted', {
+    endReason: reason,
+    milestoneSummary: reason,
+  })
+}
+
+export interface BudgetVerdict {
+  allow: boolean
+  reason?: string
+  hitCap?: 'usd' | 'tokens' | 'toolCalls' | 'wallclock' | 'turns'
+  warningFraction?: number
+}
+
+export function evaluateMissionBudget(mission: Mission, at: number = Date.now()): BudgetVerdict {
+  const { budget, usage } = mission
+  if (budget.maxUsd != null && usage.usdSpent >= budget.maxUsd) {
+    return { allow: false, hitCap: 'usd', reason: `USD budget exhausted (${usage.usdSpent.toFixed(4)} >= ${budget.maxUsd})` }
+  }
+  if (budget.maxTokens != null && usage.tokensUsed >= budget.maxTokens) {
+    return { allow: false, hitCap: 'tokens', reason: `Token budget exhausted (${usage.tokensUsed} >= ${budget.maxTokens})` }
+  }
+  if (budget.maxToolCalls != null && usage.toolCallsUsed >= budget.maxToolCalls) {
+    return { allow: false, hitCap: 'toolCalls', reason: `Tool-call budget exhausted (${usage.toolCallsUsed} >= ${budget.maxToolCalls})` }
+  }
+  if (budget.maxTurns != null && usage.turnsRun >= budget.maxTurns) {
+    return { allow: false, hitCap: 'turns', reason: `Max turns reached (${usage.turnsRun} >= ${budget.maxTurns})` }
+  }
+  if (budget.maxWallclockSec != null && usage.startedAt != null) {
+    const elapsedSec = (at - usage.startedAt) / 1000
+    if (elapsedSec >= budget.maxWallclockSec) {
+      return { allow: false, hitCap: 'wallclock', reason: `Wallclock budget exhausted (${Math.round(elapsedSec)}s >= ${budget.maxWallclockSec}s)` }
+    }
+  }
+  // Warn thresholds, highest unfired fraction first
+  const unfired = (budget.warnAtFractions ?? [])
+    .filter((f) => !usage.warnFractionsHit.includes(f))
+    .sort((a, b) => b - a)
+  for (const fraction of unfired) {
+    const tripped = (
+      (budget.maxUsd != null && usage.usdSpent >= budget.maxUsd * fraction)
+      || (budget.maxTokens != null && usage.tokensUsed >= budget.maxTokens * fraction)
+      || (budget.maxTurns != null && usage.turnsRun >= budget.maxTurns * fraction)
+      || (
+        budget.maxWallclockSec != null && usage.startedAt != null
+        && (at - usage.startedAt) / 1000 >= budget.maxWallclockSec * fraction
+      )
+    )
+    if (tripped) return { allow: true, warningFraction: fraction }
+  }
+  return { allow: true }
+}
+
+export function recordTurnUsage(
+  missionId: string,
+  delta: { usdDelta?: number; tokensDelta?: number; toolCallsDelta?: number; turnsDelta?: number },
+): Mission | null {
+  let firedWarn: number | null = null
+  const result = patchMission(missionId, (current) => {
+    if (!current) return null
+    const now = Date.now()
+    const nextUsage = { ...current.usage }
+    if (typeof delta.usdDelta === 'number' && Number.isFinite(delta.usdDelta)) nextUsage.usdSpent += delta.usdDelta
+    if (typeof delta.tokensDelta === 'number' && Number.isFinite(delta.tokensDelta)) nextUsage.tokensUsed += delta.tokensDelta
+    if (typeof delta.toolCallsDelta === 'number' && Number.isFinite(delta.toolCallsDelta)) nextUsage.toolCallsUsed += delta.toolCallsDelta
+    if (typeof delta.turnsDelta === 'number' && Number.isFinite(delta.turnsDelta)) nextUsage.turnsRun += delta.turnsDelta
+    if (nextUsage.startedAt) nextUsage.wallclockMsElapsed = now - nextUsage.startedAt
+    nextUsage.lastUpdatedAt = now
+    const verdict = evaluateMissionBudget({ ...current, usage: nextUsage }, now)
+    if (verdict.warningFraction != null) {
+      firedWarn = verdict.warningFraction
+      nextUsage.warnFractionsHit = [...nextUsage.warnFractionsHit, verdict.warningFraction]
+    }
+    return { ...current, usage: nextUsage }
+  })
+  if (result && firedWarn != null) {
+    appendMissionMilestone(missionId, {
+      kind: 'budget_warn',
+      summary: `Budget ${Math.round(firedWarn * 100)}% reached`,
+    })
+  }
+  return result
+}

package/src/lib/server/runtime/heartbeat-service.ts

@@ -31,6 +31,7 @@ import { logExecution } from '@/lib/server/execution-log'
 import { createNotification } from '@/lib/server/create-notification'
 import { WORKER_ONLY_PROVIDER_IDS } from '@/lib/provider-sets'
 import { buildSwarmFeedHeartbeatGuidance } from '@/lib/server/swarmfeed-runtime'
+import { runMissionScheduler } from '@/lib/server/missions/mission-scheduler'
 
 const HEARTBEAT_TICK_MS = 60_000
 const MAX_CONCURRENT_HEARTBEATS = 1
@@ -576,6 +577,10 @@ export async function tickHeartbeats() {
   const globalOngoing = shouldRunHeartbeats(settings)
 
   const now = Date.now()
+  // Mission scheduler runs every tick, independent of heartbeat active window,
+  // so wallclock budgets and periodic reports still fire overnight.
+  try { runMissionScheduler() } catch (error) { log.warn('heartbeat', 'mission scheduler tick failed', error) }
+
   const nowDate = new Date(now)
   if (!inActiveWindow(nowDate, settings.heartbeatActiveStart, settings.heartbeatActiveEnd, settings.heartbeatTimezone)) {
     return

package/src/lib/server/runtime/session-run-manager/enqueue.ts

@@ -8,6 +8,7 @@ import { getEnabledToolIds } from '@/lib/capability-selection'
 import { isAllEstopEngaged, isAutonomyEstopEngaged } from '@/lib/server/runtime/estop'
 import { isRestartRecoverableSource } from '@/lib/server/runtime/run-ledger'
 import { getActiveSessionProcess } from '@/lib/server/runtime/runtime-state'
+import { checkMissionBudgetForSession } from '@/lib/server/missions/mission-budget-hook'
 
 import { cancelPendingForSession } from './cancellation'
 import {
@@ -49,6 +50,7 @@ const LONG_TOOL_NAMES: ReadonlySet<string> = new Set(['claude_code', 'codex_cli'
 type SessionToolConfig = {
   tools?: string[] | null
   extensions?: string[] | null
+  missionId?: string | null
 }
 
 function computeEffectiveRunTimeoutMs(
@@ -114,6 +116,13 @@ export function enqueueSessionRun(
   if (isAutonomyEstopEngaged() && isAutonomyManagedEnqueue(source, internal)) {
     throw new Error(`Autonomy estop is engaged. New ${source} runs are paused.`)
   }
+  if (isAutonomyManagedEnqueue(source, internal)) {
+    const sessionForMission = getSession(input.sessionId) as SessionToolConfig | null
+    const missionVerdict = checkMissionBudgetForSession(sessionForMission?.missionId ?? null)
+    if (!missionVerdict.allow) {
+      throw new Error(`Mission halted: ${missionVerdict.reason ?? 'budget exhausted'}`)
+    }
+  }
   const executionKey = typeof input.executionGroupKey === 'string' && input.executionGroupKey.trim()
     ? input.executionGroupKey.trim()
     : executionKeyForSession(input.sessionId)

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

@@ -355,6 +355,135 @@ function normalizeStoredMissionEventRecord(value: unknown): unknown {
   return event
 }
 
+// --- Agent Mission normalizers (autonomous goal-driven runs, v1.5.49+) ---
+
+const VALID_AGENT_MISSION_STATUSES = new Set([
+  'draft',
+  'running',
+  'paused',
+  'completed',
+  'failed',
+  'cancelled',
+  'budget_exhausted',
+])
+
+const VALID_AGENT_MISSION_REPORT_FORMATS = new Set(['markdown', 'slack', 'discord', 'email', 'audio'])
+
+function normalizeFiniteNumber(value: unknown): number | null {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return null
+  return value
+}
+
+function normalizeNonNegativeNumber(value: unknown, fallback: number): number {
+  const n = normalizeFiniteNumber(value)
+  if (n == null || n < 0) return fallback
+  return n
+}
+
+function normalizeStoredAgentMissionRecord(value: unknown): unknown {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return value
+  const mission = value as StoredObject
+
+  const status = typeof mission.status === 'string' ? mission.status.trim().toLowerCase() : ''
+  mission.status = VALID_AGENT_MISSION_STATUSES.has(status) ? status : 'draft'
+
+  mission.successCriteria = normalizeStoredStringArray(mission.successCriteria, 64)
+  mission.agentIds = normalizeStoredStringArray(mission.agentIds, 32)
+  mission.reportConnectorIds = normalizeStoredStringArray(mission.reportConnectorIds, 16)
+
+  const budget = mission.budget && typeof mission.budget === 'object' && !Array.isArray(mission.budget)
+    ? mission.budget as StoredObject
+    : {}
+  budget.maxUsd = normalizeFiniteNumber(budget.maxUsd)
+  budget.maxTokens = normalizeFiniteNumber(budget.maxTokens)
+  budget.maxToolCalls = normalizeFiniteNumber(budget.maxToolCalls)
+  budget.maxWallclockSec = normalizeFiniteNumber(budget.maxWallclockSec)
+  budget.maxTurns = normalizeFiniteNumber(budget.maxTurns)
+  if (!Array.isArray(budget.warnAtFractions)) {
+    budget.warnAtFractions = [0.5, 0.8, 0.95]
+  } else {
+    budget.warnAtFractions = (budget.warnAtFractions as unknown[])
+      .map((entry) => normalizeFiniteNumber(entry))
+      .filter((entry): entry is number => entry != null && entry > 0 && entry < 1)
+    if ((budget.warnAtFractions as number[]).length === 0) {
+      budget.warnAtFractions = [0.5, 0.8, 0.95]
+    }
+  }
+  mission.budget = budget
+
+  const usage = mission.usage && typeof mission.usage === 'object' && !Array.isArray(mission.usage)
+    ? mission.usage as StoredObject
+    : {}
+  usage.usdSpent = normalizeNonNegativeNumber(usage.usdSpent, 0)
+  usage.tokensUsed = normalizeNonNegativeNumber(usage.tokensUsed, 0)
+  usage.toolCallsUsed = normalizeNonNegativeNumber(usage.toolCallsUsed, 0)
+  usage.turnsRun = normalizeNonNegativeNumber(usage.turnsRun, 0)
+  usage.wallclockMsElapsed = normalizeNonNegativeNumber(usage.wallclockMsElapsed, 0)
+  usage.startedAt = normalizeFiniteNumber(usage.startedAt)
+  usage.lastUpdatedAt = normalizeNonNegativeNumber(usage.lastUpdatedAt, 0)
+  if (!Array.isArray(usage.warnFractionsHit)) {
+    usage.warnFractionsHit = []
+  } else {
+    usage.warnFractionsHit = (usage.warnFractionsHit as unknown[])
+      .map((entry) => normalizeFiniteNumber(entry))
+      .filter((entry): entry is number => entry != null)
+  }
+  mission.usage = usage
+
+  if (!Array.isArray(mission.milestones)) mission.milestones = []
+  // Cap the stored tail so missions don't balloon
+  if ((mission.milestones as unknown[]).length > 200) {
+    mission.milestones = (mission.milestones as unknown[]).slice(-200)
+  }
+
+  const reportSchedule = mission.reportSchedule
+    && typeof mission.reportSchedule === 'object'
+    && !Array.isArray(mission.reportSchedule)
+    ? mission.reportSchedule as StoredObject
+    : null
+  if (reportSchedule) {
+    const format = typeof reportSchedule.format === 'string' ? reportSchedule.format.trim().toLowerCase() : ''
+    reportSchedule.format = VALID_AGENT_MISSION_REPORT_FORMATS.has(format) ? format : 'markdown'
+    reportSchedule.intervalSec = normalizeNonNegativeNumber(reportSchedule.intervalSec, 3600)
+    reportSchedule.enabled = reportSchedule.enabled !== false
+    reportSchedule.lastReportAt = normalizeFiniteNumber(reportSchedule.lastReportAt)
+    mission.reportSchedule = reportSchedule
+  } else if (mission.reportSchedule !== undefined) {
+    mission.reportSchedule = null
+  }
+
+  if (typeof mission.createdAt !== 'number') mission.createdAt = Date.now()
+  if (typeof mission.updatedAt !== 'number') mission.updatedAt = mission.createdAt as number
+  if (mission.startedAt === undefined) mission.startedAt = null
+  if (mission.endedAt === undefined) mission.endedAt = null
+  if (mission.endReason === undefined) mission.endReason = null
+
+  return mission
+}
+
+function normalizeStoredMissionReportRecord(value: unknown): unknown {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return value
+  const report = value as StoredObject
+  const format = typeof report.format === 'string' ? report.format.trim().toLowerCase() : ''
+  report.format = VALID_AGENT_MISSION_REPORT_FORMATS.has(format) ? format : 'markdown'
+  if (!Array.isArray(report.highlights)) report.highlights = []
+  if (!Array.isArray(report.deliveredTo)) report.deliveredTo = []
+  if (typeof report.body !== 'string') report.body = ''
+  if (typeof report.title !== 'string') report.title = 'Mission report'
+  return report
+}
+
+function normalizeStoredAgentMissionEventRecord(value: unknown): unknown {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return value
+  const event = value as StoredObject
+  if (!event.payload || typeof event.payload !== 'object' || Array.isArray(event.payload)) {
+    event.payload = {}
+  }
+  if (typeof event.kind !== 'string' || !event.kind.trim()) event.kind = 'unknown'
+  if (typeof event.at !== 'number' || !Number.isFinite(event.at)) event.at = Date.now()
+  return event
+}
+
 // --- Delegation job normalizer ---
 
 function normalizeStoredDelegationJobRecord(value: unknown): unknown {
@@ -428,7 +557,7 @@ export function normalizeStoredRecord(
   value: unknown,
   loadItem: CollectionItemLoader,
 ): NormalizationResult {
-  // Tables with no normalization — early exit
+  // Tables with no normalization, early exit.
   if (
     table !== 'agents' && table !== 'tasks' && table !== 'missions'
     && table !== 'mission_events' && table !== 'delegation_jobs'
@@ -436,6 +565,9 @@ export function normalizeStoredRecord(
     && table !== 'provider_configs'
     && table !== 'runtime_runs' && table !== 'runtime_run_events'
     && table !== 'wallets'
+    && table !== 'agent_missions'
+    && table !== 'mission_reports'
+    && table !== 'agent_mission_events'
   ) {
     return { value, changed: false }
   }
@@ -590,6 +722,18 @@ function normalizeStoredRecordInner(
     return normalizeStoredMissionEventRecord(value)
   }
 
+  if (table === 'agent_missions') {
+    return normalizeStoredAgentMissionRecord(value)
+  }
+
+  if (table === 'mission_reports') {
+    return normalizeStoredMissionReportRecord(value)
+  }
+
+  if (table === 'agent_mission_events') {
+    return normalizeStoredAgentMissionEventRecord(value)
+  }
+
   if (table === 'delegation_jobs') {
     return normalizeStoredDelegationJobRecord(value)
   }

package/src/lib/server/storage.ts

@@ -26,6 +26,9 @@ import type {
   KnowledgeSource,
   LearnedSkill,
   Message,
+  Mission,
+  MissionEvent,
+  MissionReport,
   ProtocolTemplate,
   ProtocolRun,
   ProtocolRunEvent,
@@ -176,6 +179,9 @@ const COLLECTIONS = [
   'wallets',
   'wallet_transactions',
   'goals',
+  'agent_missions',
+  'mission_reports',
+  'agent_mission_events',
 ] as const
 
 export type StorageCollection = (typeof COLLECTIONS)[number]
@@ -1686,6 +1692,29 @@ export const loadGoal = goalsStore.loadItem
 export const upsertGoal = goalsStore.upsert
 export const deleteGoalItem = goalsStore.deleteItem
 
+// --- Agent Missions (autonomous goal-driven runs) ---
+const agentMissionsStore = createCollectionStore<Mission>('agent_missions', { ttlMs: 5_000 })
+export const loadAgentMissions = agentMissionsStore.load
+export const saveAgentMissions = agentMissionsStore.save
+export const loadAgentMission = agentMissionsStore.loadItem
+export const upsertAgentMission = agentMissionsStore.upsert
+export const patchAgentMission = agentMissionsStore.patch
+export const deleteAgentMission = agentMissionsStore.deleteItem
+
+const missionReportsStore = createCollectionStore<MissionReport>('mission_reports')
+export const loadMissionReports = missionReportsStore.load
+export const saveMissionReports = missionReportsStore.save
+export const loadMissionReport = missionReportsStore.loadItem
+export const upsertMissionReport = missionReportsStore.upsert
+export const deleteMissionReport = missionReportsStore.deleteItem
+
+const agentMissionEventsStore = createCollectionStore<MissionEvent>('agent_mission_events')
+export const loadAgentMissionEvents = agentMissionEventsStore.load
+export const saveAgentMissionEvents = agentMissionEventsStore.save
+export const loadAgentMissionEvent = agentMissionEventsStore.loadItem
+export const upsertAgentMissionEvent = agentMissionEventsStore.upsert
+export const deleteAgentMissionEvent = agentMissionEventsStore.deleteItem
+
 function legacyMissionStatusToWorkingStatus(value: unknown): 'idle' | 'progress' | 'blocked' | 'completed' {
   const normalized = typeof value === 'string' ? value.trim().toLowerCase() : ''
   if (normalized === 'achieved' || normalized === 'completed' || normalized === 'ok') return 'completed'

package/src/types/index.ts

@@ -14,6 +14,7 @@ export * from './run'
 export * from './approval'
 export * from './misc'
 export * from './goal'
+export * from './mission'
 export * from './swarmdock'
 export * from './dream'
 export * from './swarmfeed'

package/src/types/mission.ts

@@ -0,0 +1,115 @@
+export type MissionStatus =
+  | 'draft'
+  | 'running'
+  | 'paused'
+  | 'completed'
+  | 'failed'
+  | 'cancelled'
+  | 'budget_exhausted'
+
+export type MissionReportFormat = 'markdown' | 'slack' | 'discord' | 'email' | 'audio'
+
+export type MissionMilestoneKind =
+  | 'started'
+  | 'budget_warn'
+  | 'budget_hit'
+  | 'check_in'
+  | 'subgoal_done'
+  | 'report_sent'
+  | 'paused'
+  | 'resumed'
+  | 'completed'
+  | 'failed'
+  | 'cancelled'
+
+export interface MissionBudget {
+  maxUsd?: number | null
+  maxTokens?: number | null
+  maxToolCalls?: number | null
+  maxWallclockSec?: number | null
+  maxTurns?: number | null
+  warnAtFractions?: number[]
+}
+
+export interface MissionUsage {
+  usdSpent: number
+  tokensUsed: number
+  toolCallsUsed: number
+  turnsRun: number
+  wallclockMsElapsed: number
+  startedAt: number | null
+  lastUpdatedAt: number
+  warnFractionsHit: number[]
+}
+
+export interface MissionMilestone {
+  id: string
+  at: number
+  kind: MissionMilestoneKind
+  summary: string
+  evidence?: string[]
+  sessionId?: string | null
+  runId?: string | null
+}
+
+export interface MissionReportSchedule {
+  intervalSec: number
+  format: MissionReportFormat
+  enabled: boolean
+  lastReportAt?: number | null
+}
+
+export interface MissionReportDelivery {
+  connectorId?: string | null
+  channelId?: string | null
+  deliveredAt: number
+  status: 'ok' | 'error'
+  error?: string | null
+}
+
+export interface MissionReport {
+  id: string
+  missionId: string
+  generatedAt: number
+  format: MissionReportFormat
+  fromAt: number
+  toAt: number
+  title: string
+  body: string
+  audioUrl?: string | null
+  deliveredTo: MissionReportDelivery[]
+  highlights: Array<{ kind: string; summary: string; evidenceRunId?: string | null }>
+}
+
+export interface MissionEvent {
+  id: string
+  missionId: string
+  at: number
+  kind: string
+  payload: Record<string, unknown>
+  sessionId?: string | null
+  runId?: string | null
+}
+
+export interface Mission {
+  id: string
+  title: string
+  goal: string
+  successCriteria: string[]
+  rootSessionId: string
+  agentIds: string[]
+  status: MissionStatus
+  budget: MissionBudget
+  usage: MissionUsage
+  milestones: MissionMilestone[]
+  reportSchedule?: MissionReportSchedule | null
+  reportConnectorIds: string[]
+  createdAt: number
+  updatedAt: number
+  startedAt?: number | null
+  endedAt?: number | null
+  endReason?: string | null
+}
+
+export const DEFAULT_MISSION_WARN_FRACTIONS = [0.5, 0.8, 0.95]
+export const MISSION_MILESTONE_TAIL_CAP = 200