@swarmclawai/swarmclaw 1.5.47 → 1.5.49

package/README.md

@@ -396,6 +396,21 @@ Operational docs: https://swarmclaw.ai/docs/observability
 
 ## Releases
 
+### v1.5.49 Highlights
+
+- **Autonomous Missions**: a new first-class concept for long-running, goal-driven agent work. Hand your agent team a goal on Friday, come back Monday to see what they shipped. Each mission carries a title, a natural-language objective, bulleted success criteria, hard budgets (USD, tokens, turns, wallclock), periodic markdown reports, and a full milestone timeline. Missions drive any session through the existing heartbeat pipeline, so delegation to Claude Code, Codex, OpenCode, Cursor, Droid, Goose, Qwen, or native SwarmClaw agents all work without changes.
+- **Budget enforcement in the run pipeline**: `enqueueSessionRun` now consults the mission's budget before every autonomous turn. When any cap is hit the mission transitions to `budget_exhausted`, the queue drains, and a final report fires. Warn thresholds (default 50% / 80% / 95% of each cap) emit `budget_warn` milestones exactly once each.
+- **Scheduler tick from heartbeat**: `runMissionScheduler()` fires every heartbeat tick, independent of the active-hours window, so wallclock budgets and periodic reports still fire overnight. Report cadence is configurable per mission; reports land as in-app notifications today and ship as Slack/Discord/audio in a follow-up.
+- **`/missions` dashboard**: new page with a live mission list, status pills, four-axis budget gauges, a scrollable milestone timeline, a reports drawer, and start / pause / cancel / mark-complete / generate-report-now controls.
+- **CLI commands**: `swarmclaw missions list|get|create|update|delete|control|reports|report-now|events`. Create a mission, start it, and watch the timeline from the terminal or CI.
+- **New storage collections**: `agent_missions`, `mission_reports`, and `agent_mission_events`. The legacy deprecated `missions` table is left untouched so nothing in existing installs is disturbed.
+
+### v1.5.48 Highlights
+
+- **SwarmDock MCP preset now points at the hosted endpoint**: *MCP Servers → Quick Setup → SwarmDock* is pre-filled with `streamable-http` transport pointed at `https://swarmdock-api.onrender.com/mcp` and a ready-to-edit `Authorization: Bearer <key>` header template. Users no longer need to run `npx swarmdock-mcp` locally — the SwarmDock team hosts the MCP server in-process on the existing API service. First-time setup (browser keygen + agent registration) lives at [swarmdock.ai/mcp/connect](https://www.swarmdock.ai/mcp/connect).
+- **McpPreset gains `url` and `headersTemplate`**: `applyPreset` now prefills the URL input and the Headers textarea in addition to command/args/env, so remote presets can ship complete configs.
+- **Skills doc refresh**: the `swarmclaw` skill's MCP Servers section points to the hosted flow instead of the prior stdio instructions.
+
 ### v1.5.47 Highlights
 
 - **MCP injection for GitHub Copilot CLI and OpenAI Codex CLI agents**: agents using the `copilot-cli` or `codex-cli` providers now run with their assigned MCP servers attached at runtime. Copilot CLI receives the servers via `--additional-mcp-config @<tempfile>`; Codex CLI gets per-session `[mcp_servers.*]` TOML sections appended to a scoped `config.toml`. Stdio transports (command, args, env, cwd) and SSE / streamable-http transports (url, headers) are both supported. Skills assigned to the agent continue to be injected via the system prompt.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.5.47",
+  "version": "1.5.49",
   "description": "Build and run autonomous AI agents with OpenClaw, Hermes, multiple model providers, orchestration, delegation, memory, skills, schedules, and chat connectors.",
   "main": "electron-dist/main.js",
   "license": "MIT",

package/skills/swarmclaw/SKILL.md

@@ -125,6 +125,14 @@ Agents can communicate through external platforms:
 - Messages sent via `platform` tool with `communicate.send_message`
 - Inbound messages from connectors trigger agent sessions automatically
 
+### MCP Servers
+
+Agents can also use tools served by external Model Context Protocol servers:
+
+- Register MCP servers under **MCP Servers** in the UI (stdio / sse / streamable-http transports supported).
+- Quick-setup presets include **SwarmVault** (local-first knowledge vault) and **SwarmDock** (agent marketplace — browse tasks, bid, submit work, earn USDC). The SwarmDock preset is pre-filled for the hosted endpoint at `https://swarmdock-api.onrender.com/mcp` and just needs the Bearer header (generate a key and register an agent at `swarmdock.ai/mcp/connect`). See `docs/mcp-servers.md` for the full workflow.
+- Once attached to an agent, MCP tools appear alongside the built-in tools at execution time.
+
 ## Workspace Conventions
 
 - The workspace root is the agent's working directory

package/src/app/api/missions/[id]/control/route.ts

@@ -0,0 +1,57 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
+import { formatZodError } from '@/lib/validation/schemas'
+import { notFound } from '@/lib/server/collection-helpers'
+import { getMission } from '@/lib/server/missions/mission-repository'
+import {
+  cancelMission,
+  completeMission,
+  failMission,
+  pauseMission,
+  startMission,
+} from '@/lib/server/missions/mission-service'
+
+export const dynamic = 'force-dynamic'
+
+const ControlSchema = z.object({
+  action: z.enum(['start', 'pause', 'resume', 'cancel', 'complete', 'fail']),
+  reason: z.string().max(1000).optional(),
+}).strict()
+
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const mission = getMission(id)
+  if (!mission) return notFound()
+  const { data: body, error } = await safeParseBody<Record<string, unknown>>(req)
+  if (error) return error
+  const parsed = ControlSchema.safeParse(body)
+  if (!parsed.success) return NextResponse.json(formatZodError(parsed.error), { status: 400 })
+
+  switch (parsed.data.action) {
+    case 'start':
+    case 'resume': {
+      const updated = startMission(id)
+      return NextResponse.json(updated)
+    }
+    case 'pause': {
+      const updated = pauseMission(id, parsed.data.reason)
+      return NextResponse.json(updated)
+    }
+    case 'cancel': {
+      const updated = cancelMission(id, parsed.data.reason)
+      return NextResponse.json(updated)
+    }
+    case 'complete': {
+      const updated = completeMission(id, parsed.data.reason)
+      return NextResponse.json(updated)
+    }
+    case 'fail': {
+      if (!parsed.data.reason) {
+        return NextResponse.json({ error: 'reason is required for fail action' }, { status: 400 })
+      }
+      const updated = failMission(id, parsed.data.reason)
+      return NextResponse.json(updated)
+    }
+  }
+}

package/src/app/api/missions/[id]/events/route.ts

@@ -0,0 +1,21 @@
+import { NextResponse } from 'next/server'
+import { notFound } from '@/lib/server/collection-helpers'
+import { getMission, listMissionEvents } from '@/lib/server/missions/mission-repository'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const mission = getMission(id)
+  if (!mission) return notFound()
+  const url = new URL(req.url)
+  const sinceRaw = url.searchParams.get('sinceAt')
+  const untilRaw = url.searchParams.get('untilAt')
+  const sinceAt = sinceRaw ? Number.parseInt(sinceRaw, 10) : undefined
+  const untilAt = untilRaw ? Number.parseInt(untilRaw, 10) : undefined
+  const events = listMissionEvents(id, {
+    sinceAt: Number.isFinite(sinceAt) ? sinceAt : undefined,
+    untilAt: Number.isFinite(untilAt) ? untilAt : undefined,
+  })
+  return NextResponse.json(events)
+}

package/src/app/api/missions/[id]/reports/route.ts

@@ -0,0 +1,33 @@
+import { NextResponse } from 'next/server'
+import { notFound } from '@/lib/server/collection-helpers'
+import {
+  getMission,
+  listMissionReports,
+  saveMissionReport,
+} from '@/lib/server/missions/mission-repository'
+import { buildMissionReport } from '@/lib/server/missions/mission-report-builder'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const mission = getMission(id)
+  if (!mission) return notFound()
+  const url = new URL(req.url)
+  const limitRaw = url.searchParams.get('limit')
+  const limit = limitRaw ? Math.min(100, Math.max(1, Number.parseInt(limitRaw, 10) || 20)) : 20
+  return NextResponse.json(listMissionReports(id, limit))
+}
+
+export async function POST(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const mission = getMission(id)
+  if (!mission) return notFound()
+  const from = mission.reportSchedule?.lastReportAt
+    ?? mission.usage.startedAt
+    ?? mission.createdAt
+  const to = Date.now()
+  const { report } = buildMissionReport(mission, { from, to }, { windowSource: 'on_demand' })
+  saveMissionReport(report)
+  return NextResponse.json(report)
+}

package/src/app/api/missions/[id]/route.ts

@@ -0,0 +1,82 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
+import { formatZodError } from '@/lib/validation/schemas'
+import { notFound } from '@/lib/server/collection-helpers'
+import {
+  getMission,
+  patchMission,
+  removeMission,
+} from '@/lib/server/missions/mission-repository'
+import { patchSession } from '@/lib/server/sessions/session-repository'
+
+export const dynamic = 'force-dynamic'
+
+const MissionUpdateSchema = z.object({
+  title: z.string().min(1).max(200).optional(),
+  goal: z.string().min(1).max(4000).optional(),
+  successCriteria: z.array(z.string().min(1)).max(32).optional(),
+  agentIds: z.array(z.string().min(1)).max(32).optional(),
+  budget: z.object({
+    maxUsd: z.number().positive().nullable().optional(),
+    maxTokens: z.number().positive().int().nullable().optional(),
+    maxToolCalls: z.number().positive().int().nullable().optional(),
+    maxWallclockSec: z.number().positive().int().nullable().optional(),
+    maxTurns: z.number().positive().int().nullable().optional(),
+    warnAtFractions: z.array(z.number().positive().lt(1)).max(10).optional(),
+  }).partial().optional(),
+  reportSchedule: z.object({
+    intervalSec: z.number().int().min(30),
+    format: z.enum(['markdown', 'slack', 'discord', 'email', 'audio']),
+    enabled: z.boolean().default(true),
+    lastReportAt: z.number().nullable().optional(),
+  }).strict().nullable().optional(),
+  reportConnectorIds: z.array(z.string().min(1)).max(8).optional(),
+}).strict()
+
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const mission = getMission(id)
+  if (!mission) return notFound()
+  return NextResponse.json(mission)
+}
+
+export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const { data: body, error } = await safeParseBody<Record<string, unknown>>(req)
+  if (error) return error
+  const parsed = MissionUpdateSchema.safeParse(body)
+  if (!parsed.success) return NextResponse.json(formatZodError(parsed.error), { status: 400 })
+  const updated = patchMission(id, (current) => {
+    if (!current) return null
+    return {
+      ...current,
+      ...(parsed.data.title != null ? { title: parsed.data.title } : {}),
+      ...(parsed.data.goal != null ? { goal: parsed.data.goal } : {}),
+      ...(parsed.data.successCriteria != null ? { successCriteria: parsed.data.successCriteria } : {}),
+      ...(parsed.data.agentIds != null ? { agentIds: parsed.data.agentIds } : {}),
+      ...(parsed.data.budget != null ? { budget: { ...current.budget, ...parsed.data.budget } } : {}),
+      ...(parsed.data.reportSchedule !== undefined ? { reportSchedule: parsed.data.reportSchedule } : {}),
+      ...(parsed.data.reportConnectorIds != null ? { reportConnectorIds: parsed.data.reportConnectorIds } : {}),
+    }
+  })
+  if (!updated) return notFound()
+  return NextResponse.json(updated)
+}
+
+export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const mission = getMission(id)
+  if (!mission) return notFound()
+  removeMission(id)
+  try {
+    patchSession(mission.rootSessionId, (current) => {
+      if (!current) return null
+      if (current.missionId !== id) return current
+      return { ...current, missionId: null }
+    })
+  } catch {
+    // Session may already be gone.
+  }
+  return new NextResponse('OK')
+}

package/src/app/api/missions/route.test.ts

@@ -0,0 +1,170 @@
+import assert from 'node:assert/strict'
+import test, { afterEach } from 'node:test'
+
+// Disable daemon autostart during tests
+process.env.SWARMCLAW_DAEMON_AUTOSTART = '0'
+
+import { GET as listMissionsRoute, POST as createMissionRoute } from './route'
+import { GET as getMissionRoute, PUT as updateMissionRoute, DELETE as deleteMissionRoute } from './[id]/route'
+import { POST as controlMissionRoute } from './[id]/control/route'
+import { GET as listReportsRoute, POST as forceReportRoute } from './[id]/reports/route'
+import {
+  loadAgentMissions,
+  saveAgentMissions,
+  loadMissionReports,
+  saveMissionReports,
+  loadAgentMissionEvents,
+  saveAgentMissionEvents,
+} from '@/lib/server/storage'
+
+const originalMissions = loadAgentMissions()
+const originalReports = loadMissionReports()
+const originalEvents = loadAgentMissionEvents()
+
+afterEach(() => {
+  saveAgentMissions(originalMissions)
+  saveMissionReports(originalReports)
+  saveAgentMissionEvents(originalEvents)
+})
+
+function routeParams(id: string) {
+  return { params: Promise.resolve({ id }) }
+}
+
+function jsonRequest(url: string, body: unknown, method = 'POST'): Request {
+  return new Request(url, {
+    method,
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+}
+
+test('POST /api/missions creates a mission and GET lists it', async () => {
+  const req = jsonRequest('http://local/api/missions', {
+    title: 'Route smoke',
+    goal: 'Demonstrate the API',
+    rootSessionId: 'route_smoke_session_1',
+    budget: { maxTurns: 5, maxWallclockSec: 120 },
+  })
+  const createRes = await createMissionRoute(req)
+  assert.equal(createRes.status, 200)
+  const created = await createRes.json()
+  assert.equal(created.status, 'draft')
+  assert.ok(created.id)
+
+  const listRes = await listMissionsRoute()
+  const items = await listRes.json()
+  const found = items.find((m: { id: string }) => m.id === created.id)
+  assert.ok(found, 'created mission should appear in list')
+})
+
+test('POST /api/missions rejects a body missing rootSessionId', async () => {
+  const req = jsonRequest('http://local/api/missions', {
+    title: 'Broken',
+    goal: 'No session',
+  })
+  const res = await createMissionRoute(req)
+  assert.equal(res.status, 400)
+})
+
+test('GET /api/missions/:id returns 404 for unknown id', async () => {
+  const res = await getMissionRoute(
+    new Request('http://local/api/missions/does-not-exist'),
+    routeParams('does-not-exist'),
+  )
+  assert.equal(res.status, 404)
+})
+
+test('PUT /api/missions/:id patches allowed fields only', async () => {
+  const created = await createMissionRoute(
+    jsonRequest('http://local/api/missions', {
+      title: 'Update target',
+      goal: 'before',
+      rootSessionId: 'route_update_session',
+    }),
+  ).then((r) => r.json())
+
+  const res = await updateMissionRoute(
+    jsonRequest(`http://local/api/missions/${created.id}`, {
+      goal: 'after',
+      budget: { maxTurns: 99 },
+    }, 'PUT'),
+    routeParams(created.id),
+  )
+  assert.equal(res.status, 200)
+  const body = await res.json()
+  assert.equal(body.goal, 'after')
+  assert.equal(body.budget.maxTurns, 99)
+  assert.equal(body.title, 'Update target', 'unchanged fields preserved')
+})
+
+test('POST /api/missions/:id/control transitions draft to running', async () => {
+  const created = await createMissionRoute(
+    jsonRequest('http://local/api/missions', {
+      title: 'Control target',
+      goal: 'run',
+      rootSessionId: 'route_control_session',
+    }),
+  ).then((r) => r.json())
+
+  const res = await controlMissionRoute(
+    jsonRequest(`http://local/api/missions/${created.id}/control`, { action: 'start' }),
+    routeParams(created.id),
+  )
+  assert.equal(res.status, 200)
+  const body = await res.json()
+  assert.equal(body.status, 'running')
+})
+
+test('POST /api/missions/:id/reports force-generates a report', async () => {
+  const created = await createMissionRoute(
+    jsonRequest('http://local/api/missions', {
+      title: 'Report target',
+      goal: 'produce reports',
+      rootSessionId: 'route_report_session',
+    }),
+  ).then((r) => r.json())
+  await controlMissionRoute(
+    jsonRequest(`http://local/api/missions/${created.id}/control`, { action: 'start' }),
+    routeParams(created.id),
+  )
+
+  const genRes = await forceReportRoute(
+    new Request(`http://local/api/missions/${created.id}/reports`, { method: 'POST' }),
+    routeParams(created.id),
+  )
+  assert.equal(genRes.status, 200)
+  const report = await genRes.json()
+  assert.equal(report.format, 'markdown')
+  assert.ok(report.body.includes('Report target'))
+
+  const listRes = await listReportsRoute(
+    new Request(`http://local/api/missions/${created.id}/reports`),
+    routeParams(created.id),
+  )
+  assert.equal(listRes.status, 200)
+  const reports = await listRes.json()
+  assert.ok(reports.find((r: { id: string }) => r.id === report.id))
+})
+
+test('DELETE /api/missions/:id removes the mission', async () => {
+  const created = await createMissionRoute(
+    jsonRequest('http://local/api/missions', {
+      title: 'Delete target',
+      goal: 'bye',
+      rootSessionId: 'route_delete_session',
+    }),
+  ).then((r) => r.json())
+
+  const res = await deleteMissionRoute(
+    new Request(`http://local/api/missions/${created.id}`, { method: 'DELETE' }),
+    routeParams(created.id),
+  )
+  assert.equal(res.status, 200)
+
+  const getRes = await getMissionRoute(
+    new Request(`http://local/api/missions/${created.id}`),
+    routeParams(created.id),
+  )
+  assert.equal(getRes.status, 404)
+})

package/src/app/api/missions/route.ts

@@ -0,0 +1,58 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
+import { formatZodError } from '@/lib/validation/schemas'
+import { listMissions } from '@/lib/server/missions/mission-repository'
+import { createMission } from '@/lib/server/missions/mission-service'
+import { patchSession } from '@/lib/server/sessions/session-repository'
+
+export const dynamic = 'force-dynamic'
+
+const MissionBudgetSchema = z.object({
+  maxUsd: z.number().positive().nullable().optional(),
+  maxTokens: z.number().positive().int().nullable().optional(),
+  maxToolCalls: z.number().positive().int().nullable().optional(),
+  maxWallclockSec: z.number().positive().int().nullable().optional(),
+  maxTurns: z.number().positive().int().nullable().optional(),
+  warnAtFractions: z.array(z.number().positive().lt(1)).max(10).optional(),
+}).strict()
+
+const ReportScheduleSchema = z.object({
+  intervalSec: z.number().int().min(30),
+  format: z.enum(['markdown', 'slack', 'discord', 'email', 'audio']),
+  enabled: z.boolean().default(true),
+  lastReportAt: z.number().nullable().optional(),
+}).strict()
+
+const MissionCreateSchema = z.object({
+  title: z.string().min(1, 'Title is required').max(200),
+  goal: z.string().min(1, 'Goal is required').max(4000),
+  successCriteria: z.array(z.string().min(1)).max(32).optional(),
+  rootSessionId: z.string().min(1, 'rootSessionId is required'),
+  agentIds: z.array(z.string().min(1)).max(32).optional(),
+  budget: MissionBudgetSchema.optional(),
+  reportSchedule: ReportScheduleSchema.nullable().optional(),
+  reportConnectorIds: z.array(z.string().min(1)).max(8).optional(),
+})
+
+export async function GET() {
+  return NextResponse.json(listMissions())
+}
+
+export async function POST(req: Request) {
+  const { data: body, error } = await safeParseBody<Record<string, unknown>>(req)
+  if (error) return error
+  const parsed = MissionCreateSchema.safeParse(body)
+  if (!parsed.success) return NextResponse.json(formatZodError(parsed.error), { status: 400 })
+  const mission = createMission(parsed.data)
+  // Wire the session back-reference so enqueue.ts budget hook picks it up fast.
+  try {
+    patchSession(mission.rootSessionId, (current) => {
+      if (!current) return null
+      return { ...current, missionId: mission.id }
+    })
+  } catch {
+    // Session may not exist yet, budget hook falls back to the service map.
+  }
+  return NextResponse.json(mission)
+}