@swarmclawai/swarmclaw 0.4.0 → 0.5.0

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

@@ -1,13 +1,13 @@
 import { NextResponse } from 'next/server'
 import fs from 'fs'
 import path from 'path'
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 import { UPLOAD_DIR } from '@/lib/server/storage'
 
 export async function POST(req: Request) {
   const filename = req.headers.get('x-filename') || 'image.png'
   const buf = Buffer.from(await req.arrayBuffer())
-  const name = crypto.randomBytes(4).toString('hex') + '-' + filename.replace(/[^a-zA-Z0-9._-]/g, '_')
+  const name = genId() + '-' + filename.replace(/[^a-zA-Z0-9._-]/g, '_')
   const filePath = path.join(UPLOAD_DIR, name)
 
   if (!fs.existsSync(UPLOAD_DIR)) fs.mkdirSync(UPLOAD_DIR, { recursive: true })

package/src/app/api/uploads/[filename]/route.ts

@@ -1,4 +1,5 @@
 import { NextResponse } from 'next/server'
+import { notFound } from '@/lib/server/collection-helpers'
 import fs from 'fs'
 import path from 'path'
 import { UPLOAD_DIR } from '@/lib/server/storage'
@@ -43,16 +44,18 @@ export async function GET(_req: Request, { params }: { params: Promise<{ filenam
   const filePath = path.join(UPLOAD_DIR, safeName)
 
   if (!fs.existsSync(filePath)) {
-    return new NextResponse(null, { status: 404 })
+    return notFound()
   }
 
   const ext = path.extname(safeName).toLowerCase()
   const contentType = MIME_TYPES[ext] || 'application/octet-stream'
   const data = fs.readFileSync(filePath)
 
+  const inline = contentType.startsWith('image/') || contentType.startsWith('video/') || contentType.startsWith('text/') || contentType === 'application/pdf'
   return new NextResponse(data, {
     headers: {
       'Content-Type': contentType,
+      'Content-Disposition': inline ? 'inline' : `attachment; filename="${path.basename(safeName)}"`,
       'Cache-Control': 'public, max-age=86400',
     },
   })

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

@@ -1,8 +1,12 @@
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 import { NextResponse } from 'next/server'
 import { loadAgents, loadSessions, loadWebhooks, saveSessions, saveWebhooks, appendWebhookLog } from '@/lib/server/storage'
 import { WORKSPACE_DIR } from '@/lib/server/data-dir'
 import { enqueueSessionRun } from '@/lib/server/session-run-manager'
+import { mutateItem, deleteItem, notFound, type CollectionOps } from '@/lib/server/collection-helpers'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const ops: CollectionOps<any> = { load: loadWebhooks, save: saveWebhooks }
 
 function normalizeEvents(value: unknown): string[] {
   if (!Array.isArray(value)) return []
@@ -22,36 +26,30 @@ export async function GET(_req: Request, { params }: { params: Promise<{ id: str
   const { id } = await params
   const webhooks = loadWebhooks()
   const webhook = webhooks[id]
-  if (!webhook) return NextResponse.json({ error: 'Webhook not found' }, { status: 404 })
+  if (!webhook) return notFound('Webhook not found')
   return NextResponse.json(webhook)
 }
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json().catch(() => ({}))
-  const webhooks = loadWebhooks()
-  const webhook = webhooks[id]
-  if (!webhook) return NextResponse.json({ error: 'Webhook not found' }, { status: 404 })
-
-  if (body.name !== undefined) webhook.name = body.name
-  if (body.source !== undefined) webhook.source = body.source
-  if (body.events !== undefined) webhook.events = normalizeEvents(body.events)
-  if (body.agentId !== undefined) webhook.agentId = body.agentId
-  if (body.secret !== undefined) webhook.secret = body.secret
-  if (body.isEnabled !== undefined) webhook.isEnabled = !!body.isEnabled
-  webhook.updatedAt = Date.now()
-
-  webhooks[id] = webhook
-  saveWebhooks(webhooks)
-  return NextResponse.json(webhook)
+  const result = mutateItem(ops, id, (webhook) => {
+    if (body.name !== undefined) webhook.name = body.name
+    if (body.source !== undefined) webhook.source = body.source
+    if (body.events !== undefined) webhook.events = normalizeEvents(body.events)
+    if (body.agentId !== undefined) webhook.agentId = body.agentId
+    if (body.secret !== undefined) webhook.secret = body.secret
+    if (body.isEnabled !== undefined) webhook.isEnabled = !!body.isEnabled
+    webhook.updatedAt = Date.now()
+    return webhook
+  })
+  if (!result) return notFound('Webhook not found')
+  return NextResponse.json(result)
 }
 
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const webhooks = loadWebhooks()
-  if (!webhooks[id]) return NextResponse.json({ error: 'Webhook not found' }, { status: 404 })
-  delete webhooks[id]
-  saveWebhooks(webhooks)
+  if (!deleteItem(ops, id)) return notFound('Webhook not found')
   return NextResponse.json({ ok: true })
 }
 
@@ -59,10 +57,10 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   const { id } = await params
   const webhooks = loadWebhooks()
   const webhook = webhooks[id]
-  if (!webhook) return NextResponse.json({ error: 'Webhook not found' }, { status: 404 })
+  if (!webhook) return notFound('Webhook not found')
   if (webhook.isEnabled === false) {
-    appendWebhookLog(crypto.randomBytes(8).toString('hex'), {
-      id: crypto.randomBytes(8).toString('hex'), webhookId: id, event: 'unknown',
+    appendWebhookLog(genId(8), {
+      id: genId(8), webhookId: id, event: 'unknown',
       payload: '', status: 'error', error: 'Webhook is disabled', timestamp: Date.now(),
     })
     return NextResponse.json({ error: 'Webhook is disabled' }, { status: 409 })
@@ -73,8 +71,8 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
     const url = new URL(req.url)
     const provided = req.headers.get('x-webhook-secret') || url.searchParams.get('secret') || ''
     if (provided !== secret) {
-      appendWebhookLog(crypto.randomBytes(8).toString('hex'), {
-        id: crypto.randomBytes(8).toString('hex'), webhookId: id, event: 'unknown',
+      appendWebhookLog(genId(8), {
+        id: genId(8), webhookId: id, event: 'unknown',
         payload: '', status: 'error', error: 'Invalid webhook secret', timestamp: Date.now(),
       })
       return NextResponse.json({ error: 'Invalid webhook secret' }, { status: 401 })
@@ -122,8 +120,8 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   const agents = loadAgents()
   const agent = webhook.agentId ? agents[webhook.agentId] : null
   if (!agent) {
-    appendWebhookLog(crypto.randomBytes(8).toString('hex'), {
-      id: crypto.randomBytes(8).toString('hex'), webhookId: id, event: incomingEvent,
+    appendWebhookLog(genId(8), {
+      id: genId(8), webhookId: id, event: incomingEvent,
       payload: (rawBody || '').slice(0, 2000), status: 'error', error: 'Webhook agent is not configured or missing', timestamp: Date.now(),
     })
     return NextResponse.json({ error: 'Webhook agent is not configured or missing' }, { status: 400 })
@@ -133,7 +131,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   const sessionName = `webhook:${id}`
   let session = Object.values(sessions).find((s: any) => s.name === sessionName && s.agentId === agent.id) as any
   if (!session) {
-    const sessionId = crypto.randomBytes(4).toString('hex')
+    const sessionId = genId()
     const now = Date.now()
     session = {
       id: sessionId,
@@ -189,8 +187,8 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
     mode: 'followup',
   })
 
-  appendWebhookLog(crypto.randomBytes(8).toString('hex'), {
-    id: crypto.randomBytes(8).toString('hex'), webhookId: id, event: incomingEvent,
+  appendWebhookLog(genId(8), {
+    id: genId(8), webhookId: id, event: incomingEvent,
     payload: (rawBody || '').slice(0, 2000), status: 'success',
     sessionId: session.id, runId: run.runId, timestamp: Date.now(),
   })

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

@@ -1,4 +1,4 @@
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 import { NextResponse } from 'next/server'
 import { loadWebhooks, saveWebhooks } from '@/lib/server/storage'
 export const dynamic = 'force-dynamic'
@@ -19,7 +19,7 @@ export async function GET(_req: Request) {
 export async function POST(req: Request) {
   const body = await req.json().catch(() => ({}))
   const webhooks = loadWebhooks()
-  const id = crypto.randomBytes(4).toString('hex')
+  const id = genId()
   const now = Date.now()
 
   webhooks[id] = {

package/src/app/globals.css

@@ -79,6 +79,9 @@
 }
 
 :root {
+  --font-dm-sans: 'Segoe UI';
+  --font-sora: 'Segoe UI';
+  --font-jetbrains-mono: 'SF Mono';
   --radius: 0.625rem;
   --background: #08080d;
   --foreground: #e2e2ec;
@@ -203,6 +206,17 @@ body {
   100% { background-position: 0% 50%; }
 }
 
+/* AI avatar mood animations */
+@keyframes ai-pulse { 0%,100% { transform: scale(1); } 50% { transform: scale(1.15); } }
+@keyframes ai-glow { 0%,100% { box-shadow: 0 0 0 0 rgba(99,102,241,0); } 50% { box-shadow: 0 0 12px 4px rgba(99,102,241,0.35); } }
+@keyframes ai-shake { 0%,100% { transform: translateX(0); } 20% { transform: translateX(-3px); } 40% { transform: translateX(3px); } 60% { transform: translateX(-2px); } 80% { transform: translateX(2px); } }
+@keyframes ai-bounce { 0%,100% { transform: scale(1); } 40% { transform: scale(1.25); } 60% { transform: scale(0.95); } }
+
+.ai-mood-pulse { animation: ai-pulse 2s ease-in-out infinite; }
+.ai-mood-glow { animation: ai-glow 1.8s ease-in-out infinite; }
+.ai-mood-shake { animation: ai-shake 0.5s ease-in-out; }
+.ai-mood-bounce { animation: ai-bounce 0.6s ease-out; }
+
 /* ===== Markdown content ===== */
 .msg-content pre {
   background: #0a0a12 !important;

package/src/app/layout.tsx

@@ -1,27 +1,8 @@
 import type { Metadata, Viewport } from "next"
-import { Sora, DM_Sans, JetBrains_Mono } from "next/font/google"
 import { TooltipProvider } from "@/components/ui/tooltip"
 import { Toaster } from "@/components/ui/sonner"
 import "./globals.css"
 
-const sora = Sora({
-  variable: "--font-sora",
-  subsets: ["latin"],
-  weight: ["400", "500", "600", "700", "800"],
-})
-
-const dmSans = DM_Sans({
-  variable: "--font-dm-sans",
-  subsets: ["latin"],
-  weight: ["400", "500", "600", "700"],
-})
-
-const jetbrainsMono = JetBrains_Mono({
-  variable: "--font-jetbrains-mono",
-  subsets: ["latin"],
-  weight: ["400", "500"],
-})
-
 export const metadata: Metadata = {
   title: "SwarmClaw",
   description: "AI agent orchestration dashboard with multi-provider support",
@@ -34,6 +15,10 @@ export const viewport: Viewport = {
   viewportFit: "cover",
 }
 
+// Avoid static prerendering for the app shell. This prevents flaky
+// Turbopack prerender failures seen in detached fresh-install builds.
+export const dynamic = "force-dynamic"
+
 export default function RootLayout({
   children,
 }: Readonly<{
@@ -41,7 +26,7 @@ export default function RootLayout({
 }>) {
   return (
     <html lang="en" className="dark">
-      <body className={`${sora.variable} ${dmSans.variable} ${jetbrainsMono.variable} antialiased`} cz-shortcut-listen="true">
+      <body className="antialiased" cz-shortcut-listen="true">
         <TooltipProvider>
           {children}
           <Toaster />

package/src/app/page.tsx

@@ -10,6 +10,7 @@ import { AccessKeyGate } from '@/components/auth/access-key-gate'
 import { UserPicker } from '@/components/auth/user-picker'
 import { SetupWizard } from '@/components/auth/setup-wizard'
 import { AppLayout } from '@/components/layout/app-layout'
+import { useViewRouter } from '@/hooks/use-view-router'
 
 export default function Home() {
   const currentUser = useAppStore((s) => s.currentUser)
@@ -17,7 +18,6 @@ export default function Home() {
   const hydrated = useAppStore((s) => s._hydrated)
   const hydrate = useAppStore((s) => s.hydrate)
   const loadNetworkInfo = useAppStore((s) => s.loadNetworkInfo)
-  const sessions = useAppStore((s) => s.sessions)
   const loadSessions = useAppStore((s) => s.loadSessions)
   const loadSettings = useAppStore((s) => s.loadSettings)
 
@@ -107,29 +107,6 @@ export default function Home() {
     return () => { cancelled = true }
   }, [authenticated, currentUser])
 
-  // Keep __main__ session for backward compat — create if missing
-  useEffect(() => {
-    if (!authenticated || !currentUser) return
-    const sessionList = Object.values(sessions)
-    const mainSession = sessionList.find((s: any) => s.name === '__main__' && s.user === currentUser)
-    if (mainSession) return
-    let cancelled = false
-    ;(async () => {
-      try {
-        const mainId = `main-${currentUser}`
-        await api<any>('POST', '/sessions', {
-          id: mainId,
-          name: '__main__',
-          user: currentUser,
-          agentId: 'default',
-          heartbeatEnabled: true,
-        })
-        if (!cancelled) await loadSessions()
-      } catch { /* ignore */ }
-    })()
-    return () => { cancelled = true }
-  }, [authenticated, currentUser, sessions, loadSessions])
-
   // Check if first-run setup is needed
   useEffect(() => {
     if (!authenticated || !currentUser) return
@@ -169,6 +146,8 @@ export default function Home() {
     return () => window.removeEventListener('sc_auth_required', handler)
   }, [])
 
+  useViewRouter()
+
   if (!hydrated || !authChecked) return null
   if (!authenticated) return <AccessKeyGate onAuthenticated={() => setAuthenticated(true)} />
   if (!currentUser) return <UserPicker />

package/src/cli/index.js

@@ -17,6 +17,9 @@ const COMMAND_GROUPS = [
       cmd('create', 'POST', '/agents', 'Create an agent', { expectsJsonBody: true }),
       cmd('update', 'PUT', '/agents/:id', 'Update an agent', { expectsJsonBody: true }),
       cmd('delete', 'DELETE', '/agents/:id', 'Delete an agent'),
+      cmd('trash', 'GET', '/agents/trash', 'List trashed agents'),
+      cmd('restore', 'POST', '/agents/trash', 'Restore a trashed agent', { expectsJsonBody: true }),
+      cmd('purge', 'DELETE', '/agents/trash', 'Permanently delete a trashed agent', { expectsJsonBody: true }),
       cmd('thread', 'POST', '/agents/:id/thread', 'Get or create agent thread session'),
     ],
   },
@@ -55,6 +58,7 @@ const COMMAND_GROUPS = [
       cmd('create', 'POST', '/connectors', 'Create connector', { expectsJsonBody: true }),
       cmd('update', 'PUT', '/connectors/:id', 'Update connector', { expectsJsonBody: true }),
       cmd('delete', 'DELETE', '/connectors/:id', 'Delete connector'),
+      cmd('webhook', 'POST', '/connectors/:id/webhook', 'Trigger connector webhook ingress', { expectsJsonBody: true }),
       cmd('start', 'PUT', '/connectors/:id', 'Start connector', {
         expectsJsonBody: true,
         defaultBody: { action: 'start' },
@@ -199,6 +203,42 @@ const COMMAND_GROUPS = [
         expectsJsonBody: true,
         waitEntityFrom: 'taskId',
       }),
+      cmd('graph', 'GET', '/orchestrator/graph', 'Get orchestrator graph structure'),
+    ],
+  },
+  {
+    name: 'openclaw',
+    description: 'OpenClaw discovery, gateway control, and runtime APIs',
+    commands: [
+      cmd('discover', 'GET', '/openclaw/discover', 'Discover OpenClaw gateways'),
+      cmd('directory', 'GET', '/openclaw/directory', 'List directory entries from running OpenClaw connectors'),
+      cmd('gateway-status', 'GET', '/openclaw/gateway', 'Check OpenClaw gateway connection status'),
+      cmd('gateway', 'POST', '/openclaw/gateway', 'Call OpenClaw gateway RPC/control action', { expectsJsonBody: true }),
+      cmd('config-sync', 'GET', '/openclaw/config-sync', 'Detect OpenClaw gateway config issues'),
+      cmd('config-sync-repair', 'POST', '/openclaw/config-sync', 'Repair a detected OpenClaw config issue', { expectsJsonBody: true }),
+      cmd('approvals', 'GET', '/openclaw/approvals', 'List pending OpenClaw execution approvals'),
+      cmd('approvals-resolve', 'POST', '/openclaw/approvals', 'Resolve an OpenClaw execution approval', { expectsJsonBody: true }),
+      cmd('cron', 'GET', '/openclaw/cron', 'List OpenClaw cron jobs'),
+      cmd('cron-action', 'POST', '/openclaw/cron', 'Create/run/remove OpenClaw cron jobs', { expectsJsonBody: true }),
+      cmd('agent-files', 'GET', '/openclaw/agent-files', 'Fetch OpenClaw agent files'),
+      cmd('agent-files-set', 'PUT', '/openclaw/agent-files', 'Save an OpenClaw agent file', { expectsJsonBody: true }),
+      cmd('dotenv-keys', 'GET', '/openclaw/dotenv-keys', 'List gateway .env keys'),
+      cmd('exec-config', 'GET', '/openclaw/exec-config', 'Fetch OpenClaw exec approval config'),
+      cmd('exec-config-set', 'PUT', '/openclaw/exec-config', 'Save OpenClaw exec approval config', { expectsJsonBody: true }),
+      cmd('history-preview', 'GET', '/openclaw/history', 'Preview OpenClaw session history'),
+      cmd('history-merge', 'POST', '/openclaw/history', 'Merge OpenClaw session history into local session', { expectsJsonBody: true }),
+      cmd('media', 'GET', '/openclaw/media', 'Proxy OpenClaw media/file content'),
+      cmd('models', 'GET', '/openclaw/models', 'List allowed OpenClaw models'),
+      cmd('permissions', 'GET', '/openclaw/permissions', 'Get OpenClaw permission preset/config'),
+      cmd('permissions-set', 'PUT', '/openclaw/permissions', 'Apply OpenClaw permission preset', { expectsJsonBody: true }),
+      cmd('sandbox-env', 'GET', '/openclaw/sandbox-env', 'List OpenClaw sandbox env allowlist'),
+      cmd('sandbox-env-set', 'PUT', '/openclaw/sandbox-env', 'Update OpenClaw sandbox env allowlist', { expectsJsonBody: true }),
+      cmd('skills', 'GET', '/openclaw/skills', 'List OpenClaw skills and eligibility'),
+      cmd('skills-update', 'PATCH', '/openclaw/skills', 'Update OpenClaw skill state/config', { expectsJsonBody: true }),
+      cmd('skills-save', 'PUT', '/openclaw/skills', 'Save OpenClaw skill allowlist mode/config', { expectsJsonBody: true }),
+      cmd('skills-install', 'POST', '/openclaw/skills/install', 'Install OpenClaw skill dependencies', { expectsJsonBody: true }),
+      cmd('skills-remove', 'POST', '/openclaw/skills/remove', 'Remove OpenClaw skill', { expectsJsonBody: true }),
+      cmd('sync', 'POST', '/openclaw/sync', 'Run OpenClaw sync action', { expectsJsonBody: true }),
     ],
   },
   {
@@ -208,6 +248,17 @@ const COMMAND_GROUPS = [
       cmd('manage', 'POST', '/preview-server', 'Start/stop/status/detect preview server', { expectsJsonBody: true }),
     ],
   },
+  {
+    name: 'projects',
+    description: 'Manage projects',
+    commands: [
+      cmd('list', 'GET', '/projects', 'List projects'),
+      cmd('get', 'GET', '/projects/:id', 'Get project by id'),
+      cmd('create', 'POST', '/projects', 'Create project', { expectsJsonBody: true }),
+      cmd('update', 'PUT', '/projects/:id', 'Update project', { expectsJsonBody: true }),
+      cmd('delete', 'DELETE', '/projects/:id', 'Delete project'),
+    ],
+  },
   {
     name: 'plugins',
     description: 'Manage plugins and marketplace',
@@ -281,6 +332,9 @@ const COMMAND_GROUPS = [
         defaultBody: { action: 'disable_all' },
       }),
       cmd('messages', 'GET', '/sessions/:id/messages', 'Get session messages'),
+      cmd('messages-update', 'PUT', '/sessions/:id/messages', 'Update session message metadata (e.g. bookmark)', { expectsJsonBody: true }),
+      cmd('fork', 'POST', '/sessions/:id/fork', 'Fork session from a specific message index', { expectsJsonBody: true }),
+      cmd('edit-resend', 'POST', '/sessions/:id/edit-resend', 'Edit and resend from a specific message index', { expectsJsonBody: true }),
       cmd('main-loop', 'GET', '/sessions/:id/main-loop', 'Get main mission loop state'),
       cmd('main-loop-action', 'POST', '/sessions/:id/main-loop', 'Control main mission loop (pause/resume/set_goal/set_mode/clear_events/nudge)', {
         expectsJsonBody: true,
@@ -351,6 +405,7 @@ const COMMAND_GROUPS = [
       cmd('update', 'PUT', '/tasks/:id', 'Update task', { expectsJsonBody: true }),
       cmd('delete', 'DELETE', '/tasks/:id', 'Delete task'),
       cmd('purge', 'DELETE', '/tasks', 'Bulk delete tasks', { expectsJsonBody: true }),
+      cmd('approve', 'POST', '/tasks/:id/approve', 'Approve or reject a pending tool execution', { expectsJsonBody: true }),
     ],
   },
   {
@@ -362,6 +417,11 @@ const COMMAND_GROUPS = [
         responseType: 'binary',
         bodyFlagMap: { text: 'text' },
       }),
+      cmd('stream', 'POST', '/tts/stream', 'Generate streaming TTS audio', {
+        expectsJsonBody: true,
+        responseType: 'binary',
+        bodyFlagMap: { text: 'text' },
+      }),
     ],
   },
   {

package/src/cli/index.ts

@@ -928,7 +928,7 @@ export function buildProgram(): Command {
   connectors
     .command('create')
     .description('Create connector')
-    .requiredOption('--platform <platform>', 'Connector platform (discord|telegram|slack|whatsapp|openclaw)')
+    .requiredOption('--platform <platform>', 'Connector platform (discord|telegram|slack|whatsapp|openclaw|bluebubbles|signal|teams|googlechat|matrix)')
     .requiredOption('--agent-id <agentId>', 'Agent id')
     .option('--name <name>', 'Connector name')
     .option('--credential-id <credentialId>', 'Credential id')

package/src/cli/spec.js

@@ -7,6 +7,9 @@ const COMMAND_GROUPS = {
       create: { description: 'Create an agent', method: 'POST', path: '/agents' },
       update: { description: 'Update an agent', method: 'PUT', path: '/agents/:id', params: ['id'] },
       delete: { description: 'Delete an agent', method: 'DELETE', path: '/agents/:id', params: ['id'] },
+      trash: { description: 'List trashed agents', method: 'GET', path: '/agents/trash' },
+      restore: { description: 'Restore a trashed agent', method: 'POST', path: '/agents/trash' },
+      purge: { description: 'Permanently delete a trashed agent', method: 'DELETE', path: '/agents/trash' },
     },
   },
   auth: {
@@ -127,6 +130,41 @@ const COMMAND_GROUPS = {
       run: { description: 'Run orchestrator task now', method: 'POST', path: '/orchestrator/run', waitable: true },
       runs: { description: 'List queued/running/completed runs', method: 'GET', path: '/runs' },
       'run-get': { description: 'Get run by id', method: 'GET', path: '/runs/:id', params: ['id'] },
+      graph: { description: 'Get orchestrator graph structure', method: 'GET', path: '/orchestrator/graph' },
+    },
+  },
+  openclaw: {
+    description: 'OpenClaw discovery, gateway control, and runtime APIs',
+    commands: {
+      discover: { description: 'Discover OpenClaw gateways', method: 'GET', path: '/openclaw/discover' },
+      directory: { description: 'List directory entries from running OpenClaw connectors', method: 'GET', path: '/openclaw/directory' },
+      'gateway-status': { description: 'Check OpenClaw gateway connection status', method: 'GET', path: '/openclaw/gateway' },
+      gateway: { description: 'Call OpenClaw gateway RPC/control action', method: 'POST', path: '/openclaw/gateway' },
+      'config-sync': { description: 'Detect OpenClaw gateway config issues', method: 'GET', path: '/openclaw/config-sync' },
+      'config-sync-repair': { description: 'Repair a detected OpenClaw config issue', method: 'POST', path: '/openclaw/config-sync' },
+      approvals: { description: 'List pending OpenClaw execution approvals', method: 'GET', path: '/openclaw/approvals' },
+      'approvals-resolve': { description: 'Resolve an OpenClaw execution approval', method: 'POST', path: '/openclaw/approvals' },
+      cron: { description: 'List OpenClaw cron jobs', method: 'GET', path: '/openclaw/cron' },
+      'cron-action': { description: 'Create/run/remove OpenClaw cron jobs', method: 'POST', path: '/openclaw/cron' },
+      'agent-files': { description: 'Fetch OpenClaw agent files', method: 'GET', path: '/openclaw/agent-files' },
+      'agent-files-set': { description: 'Save an OpenClaw agent file', method: 'PUT', path: '/openclaw/agent-files' },
+      'dotenv-keys': { description: 'List gateway .env keys', method: 'GET', path: '/openclaw/dotenv-keys' },
+      'exec-config': { description: 'Fetch OpenClaw exec approval config', method: 'GET', path: '/openclaw/exec-config' },
+      'exec-config-set': { description: 'Save OpenClaw exec approval config', method: 'PUT', path: '/openclaw/exec-config' },
+      'history-preview': { description: 'Preview OpenClaw session history', method: 'GET', path: '/openclaw/history' },
+      'history-merge': { description: 'Merge OpenClaw session history into local session', method: 'POST', path: '/openclaw/history' },
+      media: { description: 'Proxy OpenClaw media/file content', method: 'GET', path: '/openclaw/media' },
+      models: { description: 'List allowed OpenClaw models', method: 'GET', path: '/openclaw/models' },
+      permissions: { description: 'Get OpenClaw permission preset/config', method: 'GET', path: '/openclaw/permissions' },
+      'permissions-set': { description: 'Apply OpenClaw permission preset', method: 'PUT', path: '/openclaw/permissions' },
+      'sandbox-env': { description: 'List OpenClaw sandbox env allowlist', method: 'GET', path: '/openclaw/sandbox-env' },
+      'sandbox-env-set': { description: 'Update OpenClaw sandbox env allowlist', method: 'PUT', path: '/openclaw/sandbox-env' },
+      skills: { description: 'List OpenClaw skills and eligibility', method: 'GET', path: '/openclaw/skills' },
+      'skills-update': { description: 'Update OpenClaw skill state/config', method: 'PATCH', path: '/openclaw/skills' },
+      'skills-save': { description: 'Save OpenClaw skill allowlist mode/config', method: 'PUT', path: '/openclaw/skills' },
+      'skills-install': { description: 'Install OpenClaw skill dependencies', method: 'POST', path: '/openclaw/skills/install' },
+      'skills-remove': { description: 'Remove OpenClaw skill', method: 'POST', path: '/openclaw/skills/remove' },
+      sync: { description: 'Run OpenClaw sync action', method: 'POST', path: '/openclaw/sync' },
     },
   },
   plugins: {
@@ -186,6 +224,9 @@ const COMMAND_GROUPS = {
       'delete-many': { description: 'Delete multiple sessions (body: {"ids":[...]})', method: 'DELETE', path: '/sessions' },
       'heartbeat-disable-all': { description: 'Disable all session heartbeats and cancel queued heartbeat runs', method: 'POST', path: '/sessions/heartbeat' },
       messages: { description: 'Get session message history', method: 'GET', path: '/sessions/:id/messages', params: ['id'] },
+      'messages-update': { description: 'Update session message metadata (e.g. bookmark)', method: 'PUT', path: '/sessions/:id/messages', params: ['id'] },
+      fork: { description: 'Fork session from a specific message index', method: 'POST', path: '/sessions/:id/fork', params: ['id'] },
+      'edit-resend': { description: 'Edit and resend from a specific message index', method: 'POST', path: '/sessions/:id/edit-resend', params: ['id'] },
       'main-loop': { description: 'Get main mission loop state for a session', method: 'GET', path: '/sessions/:id/main-loop', params: ['id'] },
       'main-loop-action': { description: 'Control main mission loop (pause/resume/set_goal/set_mode/clear_events/nudge)', method: 'POST', path: '/sessions/:id/main-loop', params: ['id'] },
       chat: { description: 'Send chat message (SSE stream)', method: 'POST', path: '/sessions/:id/chat', params: ['id'], stream: true, waitable: true },
@@ -243,6 +284,7 @@ const COMMAND_GROUPS = {
       update: { description: 'Update task', method: 'PUT', path: '/tasks/:id', params: ['id'] },
       delete: { description: 'Archive task', method: 'DELETE', path: '/tasks/:id', params: ['id'] },
       archive: { description: 'Archive task', method: 'DELETE', path: '/tasks/:id', params: ['id'] },
+      approve: { description: 'Approve or reject a pending tool execution', method: 'POST', path: '/tasks/:id/approve', params: ['id'] },
     },
   },
   webhooks: {

package/src/components/agents/agent-avatar.tsx

@@ -0,0 +1,45 @@
+'use client'
+
+import { useMemo } from 'react'
+import multiavatar from '@multiavatar/multiavatar'
+
+interface Props {
+  seed?: string | null
+  name: string
+  size?: number
+  className?: string
+}
+
+export function AgentAvatar({ seed, name, size = 32, className = '' }: Props) {
+  const svgHtml = useMemo(() => {
+    if (!seed) return null
+    return multiavatar(seed)
+  }, [seed])
+
+  if (svgHtml) {
+    return (
+      <div
+        className={`shrink-0 rounded-full overflow-hidden ${className}`}
+        style={{ width: size, height: size }}
+        dangerouslySetInnerHTML={{ __html: svgHtml }}
+      />
+    )
+  }
+
+  // Fallback: initials
+  const initials = name
+    .split(/\s+/)
+    .slice(0, 2)
+    .map((w) => w[0] || '')
+    .join('')
+    .toUpperCase()
+
+  return (
+    <div
+      className={`shrink-0 rounded-full flex items-center justify-center bg-accent-soft text-accent-bright font-600 ${className}`}
+      style={{ width: size, height: size, fontSize: size * 0.38 }}
+    >
+      {initials || '?'}
+    </div>
+  )
+}

package/src/components/agents/agent-card.tsx

@@ -15,14 +15,17 @@ import {
   DropdownMenuTrigger,
 } from '@/components/ui/dropdown-menu'
 import { ConfirmDialog } from '@/components/shared/confirm-dialog'
+import { useApprovalStore } from '@/stores/use-approval-store'
+import { AgentAvatar } from './agent-avatar'
 
 interface Props {
   agent: Agent
   isDefault?: boolean
+  isRunning?: boolean
   onSetDefault?: (id: string) => void
 }
 
-export function AgentCard({ agent, isDefault, onSetDefault }: Props) {
+export function AgentCard({ agent, isDefault, isRunning, onSetDefault }: Props) {
   const setEditingAgentId = useAppStore((s) => s.setEditingAgentId)
   const setAgentSheetOpen = useAppStore((s) => s.setAgentSheetOpen)
   const loadSessions = useAppStore((s) => s.loadSessions)
@@ -34,6 +37,8 @@ export function AgentCard({ agent, isDefault, onSetDefault }: Props) {
   const [dialogOpen, setDialogOpen] = useState(false)
   const [taskInput, setTaskInput] = useState('')
   const [confirmDelete, setConfirmDelete] = useState(false)
+  const approvals = useApprovalStore((s) => s.approvals)
+  const pendingApprovalCount = Object.values(approvals).filter((a) => a.agentId === agent.id).length
 
   const handleClick = () => {
     setEditingAgentId(agent.id)
@@ -111,13 +116,22 @@ export function AgentCard({ agent, isDefault, onSetDefault }: Props) {
               onClick={() => setConfirmDelete(true)}
               className="text-red-400 focus:text-red-400"
             >
-              Delete
+              Move to Trash
             </DropdownMenuItem>
           </DropdownMenuContent>
         </DropdownMenu>
 
         <div className="flex items-center gap-2.5">
+          <AgentAvatar seed={agent.avatarSeed} name={agent.name} size={28} />
+          {isRunning && (
+            <span className="shrink-0 w-2 h-2 rounded-full bg-emerald-400" style={{ animation: 'pulse 2s ease infinite' }} title="Running" />
+          )}
           <span className="font-display text-[14px] font-600 truncate flex-1 tracking-[-0.01em]">{agent.name}</span>
+          {pendingApprovalCount > 0 && (
+            <span className="shrink-0 inline-flex items-center justify-center min-w-[18px] h-[18px] px-1 rounded-full bg-red-500 text-white text-[10px] font-700">
+              {pendingApprovalCount}
+            </span>
+          )}
           {isDefault && (
             <span className="shrink-0 text-[10px] font-600 uppercase tracking-wider text-accent-bright bg-accent-soft px-2 py-0.5 rounded-[6px]">
               default
@@ -207,9 +221,9 @@ export function AgentCard({ agent, isDefault, onSetDefault }: Props) {
 
       <ConfirmDialog
         open={confirmDelete}
-        title="Delete Agent"
-        message={`Are you sure you want to delete "${agent.name}"? This cannot be undone.`}
-        confirmLabel="Delete"
+        title="Move to Trash"
+        message={`Move "${agent.name}" to trash? You can restore it later from the trash.`}
+        confirmLabel="Move to Trash"
         danger
         onConfirm={handleDelete}
         onCancel={() => setConfirmDelete(false)}