@swarmclawai/swarmclaw 1.2.8 → 1.3.0

package/src/types/working-state.ts

@@ -1,18 +1,16 @@
-import type { MissionStatus, MissionPhase, MissionWaitState } from './mission'
 
 export type WorkingStateStatus = 'idle' | 'progress' | 'blocked' | 'waiting' | 'completed'
 export type WorkingStateItemStatus = 'active' | 'resolved' | 'superseded'
 
 export interface EvidenceRef {
   id: string
-  type: 'tool' | 'message' | 'mission' | 'task' | 'artifact' | 'error' | 'approval'
+  type: 'tool' | 'message' | 'task' | 'artifact' | 'error' | 'approval'
   summary: string
   value?: string | null
   toolName?: string | null
   toolCallId?: string | null
   runId?: string | null
   sessionId?: string | null
-  missionId?: string | null
   taskId?: string | null
   createdAt: number
 }
@@ -28,7 +26,7 @@ export interface WorkingPlanStep {
 export interface WorkingFact {
   id: string
   statement: string
-  source: 'user' | 'tool' | 'assistant' | 'mission' | 'system'
+  source: 'user' | 'tool' | 'assistant' | 'system'
   status: WorkingStateItemStatus
   evidenceIds?: string[]
   createdAt: number
@@ -165,7 +163,6 @@ export interface WorkingStatePatch {
 
 export interface SessionWorkingState {
   sessionId: string
-  missionId?: string | null
   objective?: string | null
   summary?: string | null
   constraints: string[]
@@ -192,7 +189,6 @@ export interface ExecutionBriefPlanStep {
 
 export interface ExecutionBrief {
   sessionId?: string | null
-  missionId?: string | null
   objective: string | null
   summary: string | null
   status: WorkingStateStatus
@@ -203,9 +199,6 @@ export interface ExecutionBrief {
   artifacts: string[]
   constraints: string[]
   successCriteria: string[]
-  missionStatus?: MissionStatus | null
-  missionPhase?: MissionPhase | null
-  waitState?: MissionWaitState | null
   evidenceRefs: EvidenceRef[]
   parentContext: string | null
 }

package/src/views/settings/section-runtime-loop.tsx

@@ -55,20 +55,6 @@ export function RuntimeLoopSection({ appSettings, patchSettings, inputClass }: S
           </div>
         </div>
 
-        <label className="block font-display text-[11px] font-600 text-text-3 uppercase tracking-[0.08em] mb-3">Mission Human Loop</label>
-        <div className="flex items-center gap-3 mb-6">
-          <button
-            onClick={() => patchSettings({ missionHumanLoopEnabled: !(appSettings.missionHumanLoopEnabled ?? false) })}
-            className={`relative w-10 h-[22px] rounded-full transition-colors duration-200 cursor-pointer ${(appSettings.missionHumanLoopEnabled ?? false) ? 'bg-accent' : 'bg-white/[0.12]'}`}
-          >
-            <span className={`absolute top-[3px] left-[3px] w-4 h-4 rounded-full bg-white transition-transform duration-200 ${(appSettings.missionHumanLoopEnabled ?? false) ? 'translate-x-[18px]' : ''}`} />
-          </button>
-          <div>
-            <div className="text-[12px] text-text-2">Allow missions to stay open waiting for a human follow-up</div>
-            <div className="text-[11px] text-text-3/60 mt-1">Off by default for new users. When disabled, generic mission handoffs like “waiting for your next instruction” are closed instead of lingering as open waiting missions. Explicit tool approvals and real external blockers still apply.</div>
-          </div>
-        </div>
-
         <label className="flex items-center gap-1.5 font-display text-[11px] font-600 text-text-3 uppercase tracking-[0.08em] mb-3">Loop Mode <HintTip text="Bounded = fixed max steps. Ongoing = runs until the task completes (with a safety cap)" /></label>
         <div className="grid grid-cols-2 gap-2 mb-5">
           {([

package/src/app/api/canvas/[sessionId]/route.ts

@@ -1,35 +0,0 @@
-import { NextResponse } from 'next/server'
-import { loadSessions, saveSessions } from '@/lib/server/storage'
-import { notify } from '@/lib/server/ws-hub'
-import { normalizeCanvasContent } from '@/lib/canvas-content'
-import { safeParseBody } from '@/lib/server/safe-parse-body'
-
-export async function GET(_req: Request, { params }: { params: Promise<{ sessionId: string }> }) {
-  const { sessionId } = await params
-  const sessions = loadSessions()
-  const session = sessions[sessionId]
-  if (!session) return NextResponse.json({ error: 'Session not found' }, { status: 404 })
-
-  return NextResponse.json({
-    sessionId,
-    content: (session as unknown as Record<string, unknown>).canvasContent || null,
-  })
-}
-
-export async function POST(req: Request, { params }: { params: Promise<{ sessionId: string }> }) {
-  const { sessionId } = await params
-  const { data: body, error } = await safeParseBody(req)
-  if (error) return error
-  const sessions = loadSessions()
-  const session = sessions[sessionId]
-  if (!session) return NextResponse.json({ error: 'Session not found' }, { status: 404 })
-
-  const nextContent = normalizeCanvasContent(body.document ?? body.content)
-  ;(session as unknown as Record<string, unknown>).canvasContent = nextContent
-  session.lastActiveAt = Date.now()
-  sessions[sessionId] = session
-  saveSessions(sessions)
-
-  notify(`canvas:${sessionId}`)
-  return NextResponse.json({ ok: true, sessionId })
-}

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

@@ -1,31 +0,0 @@
-import { NextResponse } from 'next/server'
-import { notFound } from '@/lib/server/collection-helpers'
-import { loadMissionById, performMissionAction } from '@/lib/server/missions/mission-service'
-
-export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
-  const { id } = await params
-  const mission = loadMissionById(id)
-  if (!mission) return notFound()
-
-  const body = await req.json().catch(() => ({}))
-  const action = body?.action
-  if (action !== 'resume' && action !== 'replan' && action !== 'cancel' && action !== 'retry_verification' && action !== 'wait') {
-    return NextResponse.json({ error: 'Invalid mission action.' }, { status: 400 })
-  }
-
-  const result = performMissionAction({
-    missionId: id,
-    action,
-    reason: typeof body.reason === 'string' ? body.reason : null,
-    waitKind: typeof body.waitKind === 'string' ? body.waitKind : undefined,
-    untilAt: typeof body.untilAt === 'number' ? body.untilAt : null,
-  })
-  if (!result) {
-    return NextResponse.json({ error: 'Unable to update mission.' }, { status: 409 })
-  }
-  return NextResponse.json({
-    ok: true,
-    mission: result.mission,
-    appendedEvent: result.event,
-  })
-}

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

@@ -1,14 +0,0 @@
-import { NextResponse } from 'next/server'
-import { notFound } from '@/lib/server/collection-helpers'
-import { listMissionEventsForMission, loadMissionById } from '@/lib/server/missions/mission-service'
-
-export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
-  const { id } = await params
-  const mission = loadMissionById(id)
-  if (!mission) return notFound()
-
-  const { searchParams } = new URL(req.url)
-  const limitParam = searchParams.get('limit')
-  const limit = limitParam ? Number.parseInt(limitParam, 10) : undefined
-  return NextResponse.json(listMissionEventsForMission(id, Number.isFinite(limit) ? limit : undefined))
-}

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

@@ -1,10 +0,0 @@
-import { NextResponse } from 'next/server'
-import { notFound } from '@/lib/server/collection-helpers'
-import { getMissionDetail } from '@/lib/server/missions/mission-service'
-
-export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
-  const { id } = await params
-  const mission = getMissionDetail(id)
-  if (!mission) return notFound()
-  return NextResponse.json(mission)
-}

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

@@ -1,244 +0,0 @@
-import assert from 'node:assert/strict'
-import test from 'node:test'
-
-import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
-
-test('missions routes list, detail, and events expose durable mission state', () => {
-  const output = runWithTempDataDir<{
-    listCount: number
-    firstMissionId: string | null
-    detailMissionId: string | null
-    linkedTaskId: string | null
-    parentMissionId: string | null
-    eventsCount: number
-    latestEventType: string | null
-  }>(`
-    const storageMod = await import('./src/lib/server/storage')
-    const listRouteMod = await import('./src/app/api/missions/route')
-    const detailRouteMod = await import('./src/app/api/missions/[id]/route')
-    const eventsRouteMod = await import('./src/app/api/missions/[id]/events/route')
-    const storage = storageMod.default || storageMod
-    const listRoute = listRouteMod.default || listRouteMod
-    const detailRoute = detailRouteMod.default || detailRouteMod
-    const eventsRoute = eventsRouteMod.default || eventsRouteMod
-
-    storage.saveAgents({
-      agentA: {
-        id: 'agentA',
-        name: 'Agent A',
-        provider: 'ollama',
-        model: 'test-model',
-        systemPrompt: 'test',
-      },
-    })
-
-    storage.saveTasks({
-      taskA: {
-        id: 'taskA',
-        title: 'Prepare release summary',
-        description: 'Create the release summary.',
-        status: 'backlog',
-        agentId: 'agentA',
-        createdAt: 1,
-        updatedAt: 1,
-        missionId: 'missionA',
-      },
-    })
-
-    storage.saveMissions({
-      missionParent: {
-        id: 'missionParent',
-        source: 'chat',
-        sourceRef: { kind: 'chat', sessionId: 'sessionA' },
-        objective: 'Parent mission',
-        status: 'active',
-        phase: 'planning',
-        sessionId: 'sessionA',
-        agentId: 'agentA',
-        taskIds: [],
-        childMissionIds: ['missionA'],
-        dependencyMissionIds: [],
-        dependencyTaskIds: [],
-        createdAt: 1,
-        updatedAt: 1,
-      },
-      missionA: {
-        id: 'missionA',
-        source: 'chat',
-        sourceRef: { kind: 'chat', sessionId: 'sessionA' },
-        objective: 'Prepare the release handoff',
-        status: 'waiting',
-        phase: 'waiting',
-        sessionId: 'sessionA',
-        agentId: 'agentA',
-        parentMissionId: 'missionParent',
-        rootMissionId: 'missionParent',
-        taskIds: ['taskA'],
-        childMissionIds: [],
-        dependencyMissionIds: [],
-        dependencyTaskIds: [],
-        waitState: { kind: 'approval', reason: 'Waiting for release approval.' },
-        plannerSummary: 'Track the release handoff.',
-        currentStep: 'Wait for approval',
-        createdAt: 2,
-        updatedAt: 3,
-      },
-      missionB: {
-        id: 'missionB',
-        source: 'manual',
-        sourceRef: { kind: 'manual' },
-        objective: 'Unrelated completed mission',
-        status: 'completed',
-        phase: 'completed',
-        sessionId: 'sessionB',
-        agentId: 'agentA',
-        taskIds: [],
-        childMissionIds: [],
-        dependencyMissionIds: [],
-        dependencyTaskIds: [],
-        createdAt: 1,
-        updatedAt: 1,
-      },
-    })
-
-    storage.saveMissionEvents({
-      eventCreated: {
-        id: 'eventCreated',
-        missionId: 'missionA',
-        type: 'created',
-        source: 'chat',
-        summary: 'Mission created.',
-        sessionId: 'sessionA',
-        createdAt: 2,
-      },
-      eventWaiting: {
-        id: 'eventWaiting',
-        missionId: 'missionA',
-        type: 'waiting',
-        source: 'system',
-        summary: 'Waiting for release approval.',
-        sessionId: 'sessionA',
-        createdAt: 3,
-      },
-    })
-
-    const listResponse = await listRoute.GET(new Request('http://local/api/missions?status=waiting&sessionId=sessionA&limit=1'))
-    const listPayload = await listResponse.json()
-
-    const detailResponse = await detailRoute.GET(
-      new Request('http://local/api/missions/missionA'),
-      { params: Promise.resolve({ id: 'missionA' }) },
-    )
-    const detailPayload = await detailResponse.json()
-
-    const eventsResponse = await eventsRoute.GET(
-      new Request('http://local/api/missions/missionA/events?limit=1'),
-      { params: Promise.resolve({ id: 'missionA' }) },
-    )
-    const eventsPayload = await eventsResponse.json()
-
-    console.log(JSON.stringify({
-      listCount: Array.isArray(listPayload) ? listPayload.length : -1,
-      firstMissionId: Array.isArray(listPayload) ? listPayload[0]?.id || null : null,
-      detailMissionId: detailPayload?.mission?.id || null,
-      linkedTaskId: Array.isArray(detailPayload?.linkedTasks) ? detailPayload.linkedTasks[0]?.id || null : null,
-      parentMissionId: detailPayload?.parent?.id || null,
-      eventsCount: Array.isArray(eventsPayload) ? eventsPayload.length : -1,
-      latestEventType: Array.isArray(eventsPayload) ? eventsPayload[0]?.type || null : null,
-    }))
-  `, { prefix: 'swarmclaw-missions-route-' })
-
-  assert.equal(output.listCount, 1)
-  assert.equal(output.firstMissionId, 'missionA')
-  assert.equal(output.detailMissionId, 'missionA')
-  assert.equal(output.linkedTaskId, 'taskA')
-  assert.equal(output.parentMissionId, 'missionParent')
-  assert.equal(output.eventsCount, 1)
-  assert.equal(output.latestEventType, 'waiting')
-})
-
-test('mission actions route validates input and persists operator wait actions', () => {
-  const output = runWithTempDataDir<{
-    invalidStatus: number
-    invalidError: string | null
-    waitStatus: number
-    waitOk: boolean
-    missionStatus: string | null
-    missionPhase: string | null
-    waitKind: string | null
-    waitReason: string | null
-    eventType: string | null
-    eventAction: string | null
-  }>(`
-    const storageMod = await import('./src/lib/server/storage')
-    const actionsRouteMod = await import('./src/app/api/missions/[id]/actions/route')
-    const storage = storageMod.default || storageMod
-    const actionsRoute = actionsRouteMod.default || actionsRouteMod
-
-    storage.saveMissions({
-      missionA: {
-        id: 'missionA',
-        source: 'chat',
-        sourceRef: { kind: 'chat', sessionId: 'sessionA' },
-        objective: 'Prepare the release handoff',
-        status: 'active',
-        phase: 'planning',
-        sessionId: 'sessionA',
-        taskIds: [],
-        childMissionIds: [],
-        dependencyMissionIds: [],
-        dependencyTaskIds: [],
-        createdAt: 1,
-        updatedAt: 1,
-      },
-    })
-
-    const invalidResponse = await actionsRoute.POST(
-      new Request('http://local/api/missions/missionA/actions', {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({ action: 'ship_it' }),
-      }),
-      { params: Promise.resolve({ id: 'missionA' }) },
-    )
-    const invalidPayload = await invalidResponse.json()
-
-    const waitResponse = await actionsRoute.POST(
-      new Request('http://local/api/missions/missionA/actions', {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({
-          action: 'wait',
-          reason: 'Waiting for operator confirmation.',
-          waitKind: 'approval',
-        }),
-      }),
-      { params: Promise.resolve({ id: 'missionA' }) },
-    )
-    const waitPayload = await waitResponse.json()
-
-    console.log(JSON.stringify({
-      invalidStatus: invalidResponse.status,
-      invalidError: invalidPayload?.error || null,
-      waitStatus: waitResponse.status,
-      waitOk: waitPayload?.ok === true,
-      missionStatus: waitPayload?.mission?.status || null,
-      missionPhase: waitPayload?.mission?.phase || null,
-      waitKind: waitPayload?.mission?.waitState?.kind || null,
-      waitReason: waitPayload?.mission?.waitState?.reason || null,
-      eventType: waitPayload?.appendedEvent?.type || null,
-      eventAction: waitPayload?.appendedEvent?.data?.action || null,
-    }))
-  `, { prefix: 'swarmclaw-missions-route-' })
-
-  assert.equal(output.invalidStatus, 400)
-  assert.match(String(output.invalidError || ''), /invalid mission action/i)
-  assert.equal(output.waitStatus, 200)
-  assert.equal(output.waitOk, true)
-  assert.equal(output.missionStatus, 'waiting')
-  assert.equal(output.missionPhase, 'waiting')
-  assert.equal(output.waitKind, 'approval')
-  assert.equal(output.waitReason, 'Waiting for operator confirmation.')
-  assert.equal(output.eventType, 'operator_action')
-  assert.equal(output.eventAction, 'wait')
-})

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

@@ -1,57 +0,0 @@
-import { NextResponse } from 'next/server'
-import type { MissionPhase, MissionSource, MissionStatus } from '@/types'
-import { listMissions } from '@/lib/server/missions/mission-service'
-
-export const dynamic = 'force-dynamic'
-
-export async function GET(req: Request) {
-  const { searchParams } = new URL(req.url)
-  const sessionId = searchParams.get('sessionId')
-  const agentId = searchParams.get('agentId')
-  const projectId = searchParams.get('projectId')
-  const parentMissionId = searchParams.get('parentMissionId')
-  const limitParam = searchParams.get('limit')
-  const rawStatus = searchParams.get('status')
-  const rawPhase = searchParams.get('phase')
-  const rawSource = searchParams.get('source')
-  const limit = limitParam ? Number.parseInt(limitParam, 10) : undefined
-  const status = rawStatus === 'non_terminal'
-    || rawStatus === 'active'
-    || rawStatus === 'waiting'
-    || rawStatus === 'completed'
-    || rawStatus === 'failed'
-    || rawStatus === 'cancelled'
-    ? rawStatus as MissionStatus | 'non_terminal'
-    : undefined
-  const phase = rawPhase === 'intake'
-    || rawPhase === 'planning'
-    || rawPhase === 'dispatching'
-    || rawPhase === 'executing'
-    || rawPhase === 'verifying'
-    || rawPhase === 'waiting'
-    || rawPhase === 'completed'
-    || rawPhase === 'failed'
-    ? rawPhase as MissionPhase
-    : undefined
-  const source = rawSource === 'chat'
-    || rawSource === 'connector'
-    || rawSource === 'heartbeat'
-    || rawSource === 'main-loop-followup'
-    || rawSource === 'task'
-    || rawSource === 'schedule'
-    || rawSource === 'delegation'
-    || rawSource === 'manual'
-    ? rawSource as MissionSource
-    : undefined
-
-  return NextResponse.json(listMissions({
-    ...(sessionId ? { sessionId } : {}),
-    ...(agentId ? { agentId } : {}),
-    ...(projectId ? { projectId } : {}),
-    ...(parentMissionId ? { parentMissionId } : {}),
-    ...(status ? { status } : {}),
-    ...(phase ? { phase } : {}),
-    ...(source ? { source } : {}),
-    ...(Number.isFinite(limit) ? { limit } : {}),
-  }))
-}

package/src/app/api/wallets/[id]/approve/route.ts

@@ -1,79 +0,0 @@
-import { NextResponse } from 'next/server'
-import { safeParseBody } from '@/lib/server/safe-parse-body'
-import { loadWallets, loadWalletTransactions, upsertWalletTransaction } from '@/lib/server/storage'
-import { notify } from '@/lib/server/ws-hub'
-import type { AgentWallet, WalletTransaction } from '@/types'
-import { getWalletAtomicAmount } from '@/lib/wallet/wallet'
-import { sendWalletNativeAsset, validateWalletSendLimits } from '@/lib/server/wallet/wallet-service'
-import { errorMessage } from '@/lib/shared-utils'
-export const dynamic = 'force-dynamic'
-
-export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
-  const { id } = await params
-  const wallets = loadWallets() as Record<string, AgentWallet>
-  const wallet = wallets[id]
-  if (!wallet) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
-
-  const { data: body, error } = await safeParseBody(req)
-  if (error) return error
-  const transactionId = typeof body.transactionId === 'string' ? body.transactionId.trim() : ''
-  const decision = body.decision as 'approve' | 'deny'
-
-  if (!transactionId) {
-    return NextResponse.json({ error: 'transactionId is required' }, { status: 400 })
-  }
-  if (decision !== 'approve' && decision !== 'deny') {
-    return NextResponse.json({ error: 'decision must be "approve" or "deny"' }, { status: 400 })
-  }
-
-  const allTxs = loadWalletTransactions() as Record<string, WalletTransaction>
-  const tx = allTxs[transactionId]
-  if (!tx || tx.walletId !== id) {
-    return NextResponse.json({ error: 'Transaction not found' }, { status: 404 })
-  }
-  if (tx.status !== 'pending_approval') {
-    return NextResponse.json({ error: `Transaction is already ${tx.status}` }, { status: 409 })
-  }
-
-  if (decision === 'deny') {
-    tx.status = 'denied'
-    tx.approvedBy = 'user'
-    upsertWalletTransaction(transactionId, tx)
-    notify('wallets')
-    return NextResponse.json({ status: 'denied', transactionId })
-  }
-
-  // Approve — sign and submit
-  try {
-    const limitError = validateWalletSendLimits({ wallet, amountAtomic: getWalletAtomicAmount(tx), excludeTransactionId: transactionId })
-    if (limitError) {
-      tx.status = 'failed'
-      upsertWalletTransaction(transactionId, tx)
-      notify('wallets')
-      return NextResponse.json({
-        error: limitError,
-        transactionId,
-        status: 'failed',
-      }, { status: limitError === 'Amount must be positive' ? 400 : 403 })
-    }
-
-    const { signature, feeAtomic } = await sendWalletNativeAsset(wallet, tx.toAddress, getWalletAtomicAmount(tx))
-    tx.status = 'confirmed'
-    tx.signature = signature
-    tx.feeAtomic = feeAtomic
-    tx.feeLamports = wallet.chain === 'solana' && feeAtomic ? Number.parseInt(feeAtomic, 10) : undefined
-    tx.approvedBy = 'user'
-    upsertWalletTransaction(transactionId, tx)
-    notify('wallets')
-    return NextResponse.json({ status: 'confirmed', transactionId, signature })
-  } catch (err: unknown) {
-    tx.status = 'failed'
-    upsertWalletTransaction(transactionId, tx)
-    notify('wallets')
-    return NextResponse.json({
-      error: errorMessage(err),
-      transactionId,
-      status: 'failed',
-    }, { status: 500 })
-  }
-}

package/src/app/api/wallets/[id]/balance-history/route.ts

@@ -1,18 +0,0 @@
-import { NextResponse } from 'next/server'
-import { loadWallets, loadWalletBalanceHistory } from '@/lib/server/storage'
-import type { AgentWallet, WalletBalanceSnapshot } from '@/types'
-export const dynamic = 'force-dynamic'
-
-export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
-  const { id } = await params
-  const wallets = loadWallets() as Record<string, AgentWallet>
-  const wallet = wallets[id]
-  if (!wallet) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
-
-  const allSnapshots = loadWalletBalanceHistory() as Record<string, WalletBalanceSnapshot>
-  const walletSnapshots = Object.values(allSnapshots)
-    .filter((s) => s.walletId === id)
-    .sort((a, b) => a.timestamp - b.timestamp)
-
-  return NextResponse.json(walletSnapshots)
-}