@swarmclawai/swarmclaw 1.2.8 → 1.3.0

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

@@ -1,174 +1,32 @@
 import { NextResponse } from 'next/server'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
-import { loadWallets, upsertWallet, deleteWallet as deleteWalletFromStore, loadAgent, loadAgents, upsertAgent } from '@/lib/server/storage'
-import { notify } from '@/lib/server/ws-hub'
-import { getWalletLimitAtomic, normalizeAtomicString } from '@/lib/wallet/wallet'
-import type { AgentWallet, WalletAssetBalance, WalletPortfolioSummary } from '@/types'
-import { buildEmptyWalletPortfolio, getCachedWalletPortfolio } from '@/lib/server/wallet/wallet-portfolio'
-import {
-  getAgentActiveWalletId,
-  getWalletPortfolioSnapshot,
-  linkWalletToAgent,
-  setAgentActiveWallet,
-  stripWalletPrivateKey,
-  unlinkWalletFromAgent,
-} from '@/lib/server/wallet/wallet-service'
+import { getWalletSafe, removeWallet, updateWallet } from '@/lib/server/wallets/wallet-service'
 export const dynamic = 'force-dynamic'
-const WALLET_DETAIL_PORTFOLIO_TIMEOUT_MS = 2500
 
-function withPortfolio(
-  wallet: AgentWallet,
-  portfolio: {
-    balanceAtomic: string
-    balanceFormatted: string
-    balanceSymbol: string
-    balanceDisplay: string
-    balanceLamports?: number
-    balanceSol?: number
-    assets: WalletAssetBalance[]
-    summary: WalletPortfolioSummary
-  },
-  isActive: boolean,
-) {
-  return {
-    ...stripWalletPrivateKey(wallet as unknown as Record<string, unknown>),
-    balanceAtomic: portfolio.balanceAtomic,
-    balanceFormatted: portfolio.balanceFormatted,
-    balanceSymbol: portfolio.balanceSymbol,
-    balanceDisplay: portfolio.balanceDisplay,
-    balanceLamports: portfolio.balanceLamports,
-    balanceSol: portfolio.balanceSol,
-    assets: portfolio.assets,
-    portfolioSummary: portfolio.summary,
-    isActive,
-  }
-}
-
-export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
+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]
+  const wallet = getWalletSafe(id)
   if (!wallet) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
-
-  const url = new URL(req.url)
-  const cachedOnly = url.searchParams.get('cached') === '1'
-  const agents = loadAgents()
-  const isActive = getAgentActiveWalletId(agents[wallet.agentId]) === wallet.id
-
-  if (cachedOnly) {
-    const cached = getCachedWalletPortfolio(wallet)
-    if (!cached) {
-      return NextResponse.json({
-        ...stripWalletPrivateKey(wallet as unknown as Record<string, unknown>),
-        isActive,
-      })
-    }
-    return NextResponse.json(withPortfolio(wallet, cached, isActive))
-  }
-
-  let portfolio = buildEmptyWalletPortfolio(wallet)
-  try {
-    portfolio = await getWalletPortfolioSnapshot(wallet, {
-      timeoutMs: WALLET_DETAIL_PORTFOLIO_TIMEOUT_MS,
-      allowStale: true,
-    })
-  } catch {
-    // RPC failure — return 0
-  }
-
-  return NextResponse.json(withPortfolio(wallet, portfolio, isActive))
+  return NextResponse.json(wallet)
 }
 
 export async function PATCH(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 shouldMakeActive = body.makeActive === true
-
-  // Reassign wallet to a different agent
-  if (typeof body.agentId === 'string' && body.agentId !== wallet.agentId) {
-    const newAgent = loadAgent(body.agentId)
-    if (!newAgent) return NextResponse.json({ error: 'Agent not found' }, { status: 404 })
-
-    // Only one wallet per chain per agent.
-    const allWallets = loadWallets() as Record<string, AgentWallet>
-    const conflict = Object.values(allWallets).find((w) => w.agentId === body.agentId && w.id !== id && w.chain === wallet.chain)
-    if (conflict) return NextResponse.json({ error: `Target agent already has a ${wallet.chain} wallet` }, { status: 409 })
-
-    const oldAgent = loadAgent(wallet.agentId)
-    if (oldAgent) {
-      unlinkWalletFromAgent(oldAgent as any, id)
-      oldAgent.updatedAt = Date.now()
-      upsertAgent(wallet.agentId, oldAgent)
-    }
-
-    linkWalletToAgent(newAgent as any, id, shouldMakeActive || getAgentActiveWalletId(newAgent as any) == null)
-    newAgent.updatedAt = Date.now()
-    upsertAgent(body.agentId, newAgent)
-    notify('agents')
-
-    wallet.agentId = body.agentId
-  } else if (shouldMakeActive) {
-    const agent = loadAgent(wallet.agentId)
-    if (agent) {
-      setAgentActiveWallet(agent as any, id)
-      agent.updatedAt = Date.now()
-      upsertAgent(wallet.agentId, agent)
-      notify('agents')
-    }
-  }
-
-  if (body.label !== undefined) wallet.label = body.label as string | undefined
-  if (body.spendingLimitAtomic !== undefined || body.spendingLimitLamports !== undefined) {
-    wallet.spendingLimitAtomic = normalizeAtomicString(body.spendingLimitAtomic ?? body.spendingLimitLamports, getWalletLimitAtomic(wallet, 'perTx'))
-  }
-  if (body.dailyLimitAtomic !== undefined || body.dailyLimitLamports !== undefined) {
-    wallet.dailyLimitAtomic = normalizeAtomicString(body.dailyLimitAtomic ?? body.dailyLimitLamports, getWalletLimitAtomic(wallet, 'daily'))
-  }
-  if (typeof body.requireApproval === 'boolean') wallet.requireApproval = body.requireApproval
-  wallet.updatedAt = Date.now()
-
-  upsertWallet(id, wallet)
-  notify('wallets')
-
-  return NextResponse.json(stripWalletPrivateKey(wallet as unknown as Record<string, unknown>))
+  const patch: Record<string, unknown> = {}
+  if (typeof body.label === 'string') patch.label = body.label
+  if (typeof body.spendingLimitUsdc === 'string' || body.spendingLimitUsdc === null) patch.spendingLimitUsdc = body.spendingLimitUsdc
+  if (typeof body.dailyLimitUsdc === 'string' || body.dailyLimitUsdc === null) patch.dailyLimitUsdc = body.dailyLimitUsdc
+  if (typeof body.requireApproval === 'boolean') patch.requireApproval = body.requireApproval
+  const updated = updateWallet(id, patch)
+  if (!updated) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
+  return NextResponse.json(updated)
 }
 
 export async function DELETE(_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 })
-
-  // Check if balance > 0 and warn
-  let portfolio = buildEmptyWalletPortfolio(wallet)
-  try {
-    portfolio = await getWalletPortfolioSnapshot(wallet, {
-      timeoutMs: WALLET_DETAIL_PORTFOLIO_TIMEOUT_MS,
-      allowStale: true,
-    })
-  } catch { /* ignore */ }
-
-  // Unlink from agent
-  const agent = loadAgent(wallet.agentId)
-  if (agent) {
-    unlinkWalletFromAgent(agent as any, id)
-    agent.updatedAt = Date.now()
-    upsertAgent(wallet.agentId, agent)
-    notify('agents')
-  }
-
-  deleteWalletFromStore(id)
-  notify('wallets')
-
-  return NextResponse.json({
-    ok: true,
-    warning: portfolio.summary.nonZeroAssets > 0
-      ? `Wallet still had ${portfolio.summary.nonZeroAssets} asset${portfolio.summary.nonZeroAssets === 1 ? '' : 's'} remaining, including ${portfolio.balanceDisplay}`
-      : undefined,
-  })
+  const deleted = removeWallet(id)
+  if (!deleted) return NextResponse.json({ error: 'Wallet not found' }, { status: 404 })
+  return NextResponse.json({ ok: true })
 }

package/src/app/api/wallets/generate/route.ts

@@ -0,0 +1,22 @@
+import { NextResponse } from 'next/server'
+import { safeParseBody } from '@/lib/server/safe-parse-body'
+import { generateWallet, WalletServiceError } from '@/lib/server/wallets/wallet-service'
+export const dynamic = 'force-dynamic'
+
+export async function POST(req: Request) {
+  const { data: body, error } = await safeParseBody(req)
+  if (error) return error
+  try {
+    const wallet = await generateWallet({
+      agentId: typeof body.agentId === 'string' ? body.agentId : '',
+      label: typeof body.label === 'string' ? body.label : undefined,
+    })
+    return NextResponse.json(wallet, { status: 201 })
+  } catch (err) {
+    if (err instanceof WalletServiceError) {
+      return NextResponse.json({ error: err.message }, { status: err.status })
+    }
+    const message = err instanceof Error ? err.message : 'Failed to generate wallet'
+    return NextResponse.json({ error: message }, { status: 500 })
+  }
+}

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

@@ -0,0 +1,147 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import test from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-wallet-routes-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        CREDENTIAL_SECRET: 'test-credential-secret',
+        DATA_DIR: path.join(tempDir, 'data'),
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+test('wallet routes reject unknown agents and invalid addresses while returning safe payloads', () => {
+  const output = runWithTempDataDir(`
+    const storageMod = await import('./src/lib/server/storage')
+    const walletsRouteMod = await import('./src/app/api/wallets/route')
+    const walletsGenerateRouteMod = await import('./src/app/api/wallets/generate/route')
+    const storage = storageMod.default || storageMod
+    const walletsRoute = walletsRouteMod.default || walletsRouteMod
+    const walletsGenerateRoute = walletsGenerateRouteMod.default || walletsGenerateRouteMod
+
+    storage.saveAgents({
+      agent_1: {
+        id: 'agent_1',
+        name: 'Agent One',
+      },
+    })
+
+    const missingAgentResponse = await walletsRoute.POST(new Request('http://local/api/wallets', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        agentId: 'missing-agent',
+        walletAddress: '0x000000000000000000000000000000000000dEaD',
+      }),
+    }))
+    const missingAgentPayload = await missingAgentResponse.json()
+
+    const blankAddressResponse = await walletsRoute.POST(new Request('http://local/api/wallets', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        agentId: 'agent_1',
+        walletAddress: '   ',
+      }),
+    }))
+    const blankAddressPayload = await blankAddressResponse.json()
+
+    const invalidAddressResponse = await walletsRoute.POST(new Request('http://local/api/wallets', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        agentId: 'agent_1',
+        walletAddress: '0x1234',
+      }),
+    }))
+    const invalidAddressPayload = await invalidAddressResponse.json()
+
+    const createResponse = await walletsRoute.POST(new Request('http://local/api/wallets', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        agentId: 'agent_1',
+        walletAddress: '0x000000000000000000000000000000000000dead',
+        label: 'Manual Wallet',
+      }),
+    }))
+    const createPayload = await createResponse.json()
+
+    const generateMissingResponse = await walletsGenerateRoute.POST(new Request('http://local/api/wallets/generate', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        agentId: 'missing-agent',
+      }),
+    }))
+    const generateMissingPayload = await generateMissingResponse.json()
+
+    const generateResponse = await walletsGenerateRoute.POST(new Request('http://local/api/wallets/generate', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        agentId: 'agent_1',
+        label: 'Generated Wallet',
+      }),
+    }))
+    const generatePayload = await generateResponse.json()
+
+    const storedWallets = Object.values(storage.loadWallets())
+    const generatedStoredWallet = storedWallets.find((wallet) => wallet.label === 'Generated Wallet') || null
+
+    console.log(JSON.stringify({
+      missingAgentStatus: missingAgentResponse.status,
+      missingAgentError: missingAgentPayload?.error || null,
+      blankAddressStatus: blankAddressResponse.status,
+      blankAddressError: blankAddressPayload?.error || null,
+      invalidAddressStatus: invalidAddressResponse.status,
+      invalidAddressError: invalidAddressPayload?.error || null,
+      createStatus: createResponse.status,
+      createAddress: createPayload?.walletAddress || null,
+      createHasPrivateKey: Boolean(createPayload && Object.prototype.hasOwnProperty.call(createPayload, 'encryptedPrivateKey')),
+      generateMissingStatus: generateMissingResponse.status,
+      generateMissingError: generateMissingPayload?.error || null,
+      generateStatus: generateResponse.status,
+      generateHasPrivateKey: Boolean(generatePayload && Object.prototype.hasOwnProperty.call(generatePayload, 'encryptedPrivateKey')),
+      storedGeneratedHasPrivateKey: Boolean(generatedStoredWallet?.encryptedPrivateKey),
+    }))
+  `)
+
+  assert.equal(output.missingAgentStatus, 404)
+  assert.match(String(output.missingAgentError || ''), /Agent not found/i)
+  assert.equal(output.blankAddressStatus, 400)
+  assert.equal(output.blankAddressError, 'walletAddress is required')
+  assert.equal(output.invalidAddressStatus, 400)
+  assert.match(String(output.invalidAddressError || ''), /valid Base\/Ethereum address/i)
+  assert.equal(output.createStatus, 201)
+  assert.equal(output.createAddress, '0x000000000000000000000000000000000000dEaD')
+  assert.equal(output.createHasPrivateKey, false)
+  assert.equal(output.generateMissingStatus, 404)
+  assert.match(String(output.generateMissingError || ''), /Agent not found/i)
+  assert.equal(output.generateStatus, 201)
+  assert.equal(output.generateHasPrivateKey, false)
+  assert.equal(output.storedGeneratedHasPrivateKey, true)
+})

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

@@ -1,109 +1,27 @@
 import { NextResponse } from 'next/server'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
-import { loadAgents, loadSettings, loadWallets } from '@/lib/server/storage'
-import { createAgentWallet, getAgentActiveWalletId, getWalletPortfolioSnapshot, stripWalletPrivateKey } from '@/lib/server/wallet/wallet-service'
-import { buildEmptyWalletPortfolio } from '@/lib/server/wallet/wallet-portfolio'
-import type { AgentWallet, WalletPortfolioSummary } from '@/types'
-import { errorMessage } from '@/lib/shared-utils'
+import { listWalletsSafe, createWallet, WalletServiceError } from '@/lib/server/wallets/wallet-service'
 export const dynamic = 'force-dynamic'
-const WALLET_LIST_PORTFOLIO_TIMEOUT_MS = 1500
 
-function withPortfolio(
-  wallet: AgentWallet,
-  portfolio: {
-    balanceAtomic: string
-    balanceFormatted: string
-    balanceSymbol: string
-    balanceDisplay: string
-    balanceLamports?: number
-    balanceSol?: number
-    assets: unknown[]
-    summary: WalletPortfolioSummary
-  },
-  isActive: boolean,
-) {
-  return {
-    ...stripWalletPrivateKey(wallet as unknown as Record<string, unknown>),
-    balanceAtomic: portfolio.balanceAtomic,
-    balanceFormatted: portfolio.balanceFormatted,
-    balanceSymbol: portfolio.balanceSymbol,
-    balanceDisplay: portfolio.balanceDisplay,
-    balanceLamports: portfolio.balanceLamports,
-    balanceSol: portfolio.balanceSol,
-    assets: portfolio.assets,
-    portfolioSummary: portfolio.summary,
-    isActive,
-  }
-}
-
-export async function GET(req: Request) {
-  const wallets = loadWallets() as Record<string, AgentWallet>
-  const agents = loadAgents()
-  const { searchParams } = new URL(req.url)
-  const agentId = searchParams.get('agentId')?.trim() || ''
-  const walletEntries = Object.entries(wallets)
-    .filter(([, wallet]) => !agentId || wallet.agentId === agentId)
-  const entries = await Promise.all(
-    walletEntries.map(async ([id, wallet]) => {
-      let portfolio = buildEmptyWalletPortfolio(wallet)
-      try {
-        portfolio = await getWalletPortfolioSnapshot(wallet, {
-          timeoutMs: WALLET_LIST_PORTFOLIO_TIMEOUT_MS,
-          allowStale: true,
-        })
-      } catch {
-        // Slow or failed RPC discovery — return empty/stale portfolio for list view
-      }
-      const activeWalletId = getAgentActiveWalletId(agents[wallet.agentId])
-      return [id, withPortfolio(wallet, portfolio, activeWalletId === wallet.id)] as const
-    }),
-  )
-  return NextResponse.json(Object.fromEntries(entries))
-}
-
-interface WalletCreateBody {
-  agentId: string
-  chain?: string | null
-  provider?: string | null
-  label?: string
-  requireApproval?: boolean
-  spendingLimitAtomic?: string | number | null
-  spendingLimitLamports?: string | number | null
-  dailyLimitAtomic?: string | number | null
-  dailyLimitLamports?: string | number | null
+export async function GET() {
+  return NextResponse.json(listWalletsSafe())
 }
 
 export async function POST(req: Request) {
-  const { data: body, error } = await safeParseBody<WalletCreateBody>(req)
+  const { data: body, error } = await safeParseBody(req)
   if (error) return error
-  const settings = loadSettings()
   try {
-    const wallet = createAgentWallet({
-      agentId: body.agentId,
-      chain: body.chain,
-      provider: body.provider,
-      label: body.label,
-      requireApproval: typeof body.requireApproval === 'boolean'
-        ? body.requireApproval
-        : settings.walletApprovalsEnabled !== false,
-      spendingLimitAtomic: body.spendingLimitAtomic ?? body.spendingLimitLamports,
-      dailyLimitAtomic: body.dailyLimitAtomic ?? body.dailyLimitLamports,
+    const wallet = await createWallet({
+      agentId: typeof body.agentId === 'string' ? body.agentId : '',
+      walletAddress: typeof body.walletAddress === 'string' ? body.walletAddress : '',
+      label: typeof body.label === 'string' ? body.label : undefined,
     })
-    return NextResponse.json(stripWalletPrivateKey(wallet as unknown as Record<string, unknown>))
-  } catch (err: unknown) {
-    const message = errorMessage(err)
-    if (message === 'agentId is required') {
-      return NextResponse.json({ error: message }, { status: 400 })
-    }
-    if (/^Unsupported wallet chain or provider: /.test(message)) {
-      return NextResponse.json({ error: message }, { status: 400 })
-    }
-    if (message === 'Agent not found') {
-      return NextResponse.json({ error: message }, { status: 404 })
-    }
-    if (/^Agent already has a (solana|ethereum) wallet$/.test(message)) {
-      return NextResponse.json({ error: message }, { status: 409 })
+    return NextResponse.json(wallet, { status: 201 })
+  } catch (err) {
+    if (err instanceof WalletServiceError) {
+      return NextResponse.json({ error: err.message }, { status: err.status })
     }
+    const message = err instanceof Error ? err.message : 'Failed to create wallet'
     return NextResponse.json({ error: message }, { status: 500 })
   }
 }

package/src/app/autonomy/page.tsx

@@ -7,7 +7,7 @@ import { StatCard } from '@/components/ui/stat-card'
 import { isOrchestratorEligible } from '@/lib/orchestrator-config'
 import { timeAgo } from '@/lib/time-format'
 import { useWs } from '@/hooks/use-ws'
-import type { Agent, ApprovalRequest, EstopState, Mission, SupervisorIncident } from '@/types'
+import type { Agent, ApprovalRequest, EstopState, SupervisorIncident } from '@/types'
 
 type EstopResponse = EstopState & {
   ok?: boolean
@@ -108,7 +108,6 @@ function previewIncidentDetails(value: string): string {
 export default function AutonomyPage() {
   const [estop, setEstop] = useState<EstopResponse | null>(null)
   const [incidents, setIncidents] = useState<SupervisorIncident[]>([])
-  const [missions, setMissions] = useState<Mission[]>([])
   const [agents, setAgents] = useState<Agent[]>([])
   const [loading, setLoading] = useState(true)
   const [refreshing, setRefreshing] = useState(false)
@@ -122,15 +121,13 @@ export default function AutonomyPage() {
     if (mode === 'initial') setLoading(true)
     else setRefreshing(true)
     try {
-      const [estopState, incidentList, missionList, agentMap] = await Promise.all([
+      const [estopState, incidentList, agentMap] = await Promise.all([
         api<EstopResponse>('GET', '/autonomy/estop'),
         api<SupervisorIncident[]>('GET', '/autonomy/incidents?limit=60'),
-        api<Mission[]>('GET', '/missions?status=non_terminal&limit=20'),
         api<Record<string, Agent>>('GET', '/agents'),
       ])
       setEstop(estopState)
       setIncidents(Array.isArray(incidentList) ? incidentList : [])
-      setMissions(Array.isArray(missionList) ? missionList : [])
       setAgents(agentMap ? Object.values(agentMap) : [])
       setRefreshedAt(Date.now())
       setError(null)
@@ -287,14 +284,6 @@ export default function AutonomyPage() {
     () => [...incidents].sort((left, right) => right.createdAt - left.createdAt),
     [incidents],
   )
-  const activeMissions = useMemo(
-    () => [...missions].sort((left, right) => right.updatedAt - left.updatedAt),
-    [missions],
-  )
-  const blockedMissions = activeMissions.filter((mission) =>
-    mission.status === 'waiting' || mission.status === 'failed' || mission.status === 'cancelled',
-  )
-
   const filteredIncidents = useMemo(() => {
     if (incidentFilter === 'high') return sortedIncidents.filter((incident) => incident.severity === 'high')
     if (incidentFilter === 'runtime_failure') return sortedIncidents.filter((incident) => incident.kind === 'runtime_failure')
@@ -491,50 +480,6 @@ export default function AutonomyPage() {
           </div>
         )}
 
-        <section className="rounded-[20px] border border-white/[0.06] bg-surface p-5">
-          <div className="mb-4 flex items-start justify-between gap-4">
-            <div>
-              <h2 className="font-display text-[18px] font-700 tracking-[-0.02em] text-text">Active Missions</h2>
-              <p className="mt-1 text-[12px] leading-[1.7] text-text-3/72">
-                Durable goals that are still running or waiting. Waiting missions surface here so operators can see blockers without digging through incidents.
-              </p>
-            </div>
-            <div className="rounded-full border border-white/[0.08] bg-white/[0.03] px-3 py-1 text-[11px] text-text-3/72">
-              {activeMissions.length} active
-              {blockedMissions.length > 0 ? ` · ${blockedMissions.length} waiting` : ''}
-            </div>
-          </div>
-
-          {activeMissions.length === 0 ? (
-            <div className="rounded-[16px] border border-white/[0.06] bg-white/[0.02] px-4 py-3 text-[12px] text-text-3/70">
-              No durable missions are active right now.
-            </div>
-          ) : (
-            <div className="grid gap-3 lg:grid-cols-2">
-              {activeMissions.slice(0, 6).map((mission) => {
-                const waiting = mission.status === 'waiting' || mission.status === 'failed' || mission.status === 'cancelled'
-                return (
-                  <div
-                    key={mission.id}
-                    className={`rounded-[16px] border p-4 ${waiting ? 'border-amber-500/18 bg-amber-500/[0.05]' : 'border-white/[0.06] bg-white/[0.02]'}`}
-                  >
-                    <div className="mb-2 flex items-center justify-between gap-3">
-                      <span className={`rounded-full px-2.5 py-1 text-[10px] font-700 uppercase tracking-[0.08em] ${waiting ? 'bg-amber-500/12 text-amber-300' : 'bg-emerald-500/12 text-emerald-300'}`}>
-                        {mission.status}
-                      </span>
-                      <span className="text-[11px] text-text-3/65">{timeAgo(mission.updatedAt, now)}</span>
-                    </div>
-                    <div className="text-[14px] font-600 text-text">{mission.objective}</div>
-                    <div className="mt-2 text-[12px] leading-[1.7] text-text-3/72">
-                      {mission.waitState?.reason || mission.currentStep || mission.verifierSummary || mission.plannerSummary || 'Mission active.'}
-                    </div>
-                  </div>
-                )
-              })}
-            </div>
-          )}
-        </section>
-
         <section className="rounded-[20px] border border-white/[0.06] bg-surface p-5">
           <div className="mb-4 flex items-start justify-between gap-4">
             <div>

package/src/app/home/page.tsx

@@ -42,6 +42,9 @@ const ACTIVITY_ICONS: Record<ActivityEntry['action'], string> = {
   incident: 'M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0zM12 9v4m0 4h.01',
   running: 'M12 2v4m0 12v4m10-10h-4M6 12H2',
   claimed: 'M9 12l2 2 4-4m6 2a10 10 0 1 1-20 0 10 10 0 0 1 20 0z',
+  configured: 'M12.22 2h-.44a2 2 0 0 0-2 2v.18a2 2 0 0 1-1 1.73l-.43.25a2 2 0 0 1-2 0l-.15-.08a2 2 0 0 0-2.73.73l-.22.38a2 2 0 0 0 .73 2.73l.15.1a2 2 0 0 1 1 1.72v.51a2 2 0 0 1-1 1.74l-.15.09a2 2 0 0 0-.73 2.73l.22.38a2 2 0 0 0 2.73.73l.15-.08a2 2 0 0 1 2 0l.43.25a2 2 0 0 1 1 1.73V20a2 2 0 0 0 2 2h.44a2 2 0 0 0 2-2v-.18a2 2 0 0 1 1-1.73l.43-.25a2 2 0 0 1 2 0l.15.08a2 2 0 0 0 2.73-.73l.22-.39a2 2 0 0 0-.73-2.73l-.15-.08a2 2 0 0 1-1-1.74v-.5a2 2 0 0 1 1-1.74l.15-.09a2 2 0 0 0 .73-2.73l-.22-.38a2 2 0 0 0-2.73-.73l-.15.08a2 2 0 0 1-2 0l-.43-.25a2 2 0 0 1-1-1.73V4a2 2 0 0 0-2-2z',
+  budget_exceeded: 'M12 2a10 10 0 1 0 0 20 10 10 0 0 0 0-20m0 6v4m0 4h.01',
+  budget_warning: 'M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0zM12 9v4m0 4h.01',
 }
 
 const ACTIVITY_COLORS: Record<string, string> = {