@swarmclawai/swarmclaw 0.6.7 → 0.6.8

package/README.md

@@ -158,7 +158,7 @@ Notes:
 - **Agent Fleet Management** — Avatar seeds with generated avatars, running/approval fleet filters, soft-delete agent trash with restore/permanent delete, and approval counters in agent cards
 - **Agent Tools** — Shell, process control for long-running commands, files, edit file, send file, web search, web fetch, CLI delegation (Claude/Codex/OpenCode), Playwright browser automation, sub-agent spawning, canvas presentation, direct HTTP requests, git operations, persistent memory, and sandboxed code execution (JS/TS via Deno, Python)
 - **Platform Tools** — Agents can manage other agents, tasks, schedules, skills, connectors, sessions, and encrypted secrets via built-in platform tools
-- **Orchestration** — Multi-agent workflows powered by LangGraph with automatic sub-agent routing, checkpointed execution, and rich delegation cards that link to sub-agent chat threads
+- **Orchestration** — Multi-agent workflows powered by LangGraph with automatic sub-agent routing, checkpointed execution, checkpoint timeline with time-travel restore, and rich delegation cards that link to sub-agent chat threads
 - **Agentic Execution Policy** — Tool-first autonomous action loop with progress updates, evidence-driven answers, and better use of platform tools for long-lived work
 - **Runtime Date/Time Grounding** — Session, orchestrator, chatroom, and connector prompts include authoritative current timestamp context to reduce stale-date behavior
 - **Task Board** — Queue and track agent tasks with status, comments, structured result artifacts (`outputFiles`, uploads), completion reports, and archiving. Strict capability policy pauses tasks for human approval before tool execution
@@ -178,15 +178,21 @@ Notes:
 - **Skills System** — Discover local skills, import skills from URL, and load OpenClaw `SKILL.md` files (frontmatter-compatible)
 - **Execution Logging** — Structured audit trail for triggers, tool calls, file ops, commits, and errors in a dedicated `logs.db`
 - **Context Management** — Auto-compaction of conversation history when approaching context limits, with manual `context_status` and `context_summarize` tools for agents
-- **Memory** — Per-agent and per-session memory with hybrid FTS5 + vector embeddings search, relevance-based memory recall injected into runs, and periodic auto-journaling for durable execution context
-- **Cost Tracking** — Per-message token counting and cost estimation displayed in the chat header
-- **Provider Health Metrics** — Usage dashboard surfaces provider request volume, success rates, models used, and last-used timestamps
+- **Memory** — Per-agent and per-session memory with hybrid FTS5 + vector embeddings search, query expansion (LLM-generated semantic variants), MMR diversity ranking, cross-agent search (`scope: all`), pinned memories (always preloaded), memory sharing between agents, linked memory graph with interactive visualization, image attachments, and periodic auto-journaling for durable execution context
+- **Knowledge Base** — Shared knowledge store (`knowledge_store` / `knowledge_search` actions) with tags, source tracking, and provenance URLs — separate from per-agent memories
+- **Memory Graph Visualization** — Interactive force-directed graph view of linked memories with node details and relationship exploration
+- **Cost Tracking** — Per-message token counting and cost estimation displayed in the chat header, with per-agent monthly budget caps (`warn` or `block` enforcement)
+- **Provider Health Metrics** — Usage dashboard surfaces provider request volume, success rates, average latency, models used, and last-used timestamps
 - **Model Failover** — Automatic key rotation on rate limits and auth errors with configurable fallback credentials
-- **Plugin System** — Extend agent behavior with JS plugins (hooks: beforeAgentStart, afterAgentComplete, beforeToolExec, afterToolExec, onMessage)
+- **Plugin System** — Extend agent behavior with JS plugins (hooks: beforeAgentStart, afterAgentComplete, beforeToolExec, afterToolExec, onMessage, onTaskComplete, onAgentDelegation). Plugins can also define custom tools that agents can use
 - **Secrets Vault** — Encrypted storage for API keys and service tokens
 - **Custom Providers** — Add any OpenAI-compatible API as a provider
 - **MCP Servers** — Connect agents to any Model Context Protocol server. Per-agent server selection with tool discovery and per-tool disable toggles
 - **Sandboxed Code Execution** — Agents can write and run JS/TS (Deno) or Python scripts in an isolated sandbox with network access, scoped filesystem, and artifact output
+- **Eval Framework** — Built-in agent evaluation with scenario-based testing across categories (coding, research, companionship, multi-step, memory, planning, tool-usage), weighted scoring criteria, and LLM judge support
+- **Guardian Auto-Recovery** — Automatic workspace recovery when agents fail critically, rolling back to the last known good state via git reset
+- **Soul Library** — Browse and apply pre-built personality templates (archetypes) to agents, or create custom souls for reuse across your swarm
+- **Context Degradation Warnings** — Proactive alerts when context usage exceeds 85%, with strategy recommendations (save to memory, summarize, checkpoint)
 - **Real-Time Sync** — WebSocket push notifications for instant UI updates across tabs and devices (fallback to polling when WS is unavailable)
 - **Mobile-First UI** — Responsive glass-themed dark interface, works on phone and desktop
 
@@ -329,6 +335,7 @@ Agents with platform tools enabled can manage the SwarmClaw instance:
 | Manage Agents | List, create, update, delete agents |
 | Manage Tasks | Create and manage task board items with agent assignment |
 | Manage Schedules | Create cron, interval, or one-time scheduled jobs |
+| Reminders | Schedule a conversational wake event in the current chat (`schedule_wake`) |
 | Manage Skills | List, create, update reusable skill definitions |
 | Manage Documents | Upload/search/get/delete indexed docs for lightweight RAG workflows |
 | Manage Webhooks | Register external webhook endpoints that trigger agent sessions |
@@ -459,10 +466,21 @@ module.exports = {
   hooks: {
     beforeAgentStart: async ({ session, message }) => { /* ... */ },
     afterAgentComplete: async ({ session, response }) => { /* ... */ },
-    beforeToolExec: async ({ toolName, input }) => { /* ... */ },
+    beforeToolExec: async ({ toolName, input }) => { /* return { abort: true } to cancel */ },
     afterToolExec: async ({ toolName, input, output }) => { /* ... */ },
     onMessage: async ({ session, message }) => { /* ... */ },
+    onTaskComplete: async ({ taskId, result }) => { /* ... */ },
+    onAgentDelegation: async ({ sourceAgentId, targetAgentId, task }) => { /* ... */ },
   },
+  // Plugins can also define custom tools that agents can use
+  tools: [
+    {
+      name: 'my_custom_tool',
+      description: 'Does something amazing',
+      parameters: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'] },
+      execute: async (args, ctx) => 'Result: ' + args.query,
+    },
+  ],
 }
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "0.6.7",
+  "version": "0.6.8",
   "description": "Self-hosted AI agent orchestration dashboard — manage LLM providers, orchestrate agent swarms, schedule tasks, and bridge agents to chat platforms.",
   "license": "MIT",
   "repository": {

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

@@ -53,6 +53,7 @@ export async function POST(req: Request) {
     tools: body.tools,
     capabilities: body.capabilities,
     thinkingLevel: body.thinkingLevel || undefined,
+    autoRecovery: body.autoRecovery || false,
     soul: body.soul || undefined,
     createdAt: now,
     updatedAt: now,

package/src/app/api/chatrooms/[id]/chat/route.ts

@@ -18,6 +18,7 @@ import {
 import { filterHealthyChatroomAgents } from '@/lib/server/chatroom-health'
 import { evaluateRoutingRules } from '@/lib/server/chatroom-routing'
 import { markProviderFailure, markProviderSuccess } from '@/lib/server/provider-health'
+import { applyAgentReactionsFromText } from '@/lib/server/chatroom-orchestration'
 import type { Chatroom, ChatroomMessage, Agent } from '@/types'
 
 export const dynamic = 'force-dynamic'
@@ -250,6 +251,9 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
               saveChatrooms(latestChatrooms)
               notify(`chatroom:${id}`)
 
+              // Extract and apply reactions (e.g. [REACTION]{"emoji":"👍","to":"..."})
+              applyAgentReactionsFromText(responseText, id, agent.id)
+
               markProviderSuccess(agent.provider)
               writeEvent({ t: 'cr_agent_done', agentId: agent.id, agentName: agent.name })
 

package/src/app/api/eval/run/route.ts

@@ -0,0 +1,37 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { runEvalScenario } from '@/lib/server/eval/runner'
+import { listEvalRuns } from '@/lib/server/eval/store'
+
+const RunSchema = z.object({
+  scenarioId: z.string().min(1),
+  agentId: z.string().min(1),
+})
+
+export async function POST(req: Request) {
+  try {
+    const body: unknown = await req.json()
+    const parsed = RunSchema.safeParse(body)
+    if (!parsed.success) {
+      return NextResponse.json(
+        { error: parsed.error.issues.map((i) => i.message).join(', ') },
+        { status: 400 },
+      )
+    }
+
+    const result = await runEvalScenario(parsed.data.scenarioId, parsed.data.agentId)
+    return NextResponse.json(result)
+  } catch (err: unknown) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : String(err) },
+      { status: 500 },
+    )
+  }
+}
+
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const limit = Math.min(parseInt(searchParams.get('limit') || '50', 10), 200)
+  const runs = listEvalRuns(limit)
+  return NextResponse.json(runs)
+}

package/src/app/api/eval/scenarios/route.ts

@@ -0,0 +1,24 @@
+import { NextResponse } from 'next/server'
+import { EVAL_SCENARIOS } from '@/lib/server/eval/scenarios'
+
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const category = searchParams.get('category')
+
+  const scenarios = category
+    ? EVAL_SCENARIOS.filter((s) => s.category === category)
+    : EVAL_SCENARIOS
+
+  return NextResponse.json(
+    scenarios.map((s) => ({
+      id: s.id,
+      name: s.name,
+      category: s.category,
+      description: s.description,
+      tools: s.tools,
+      timeoutMs: s.timeoutMs,
+      criteriaCount: s.scoringCriteria.length,
+      maxScore: s.scoringCriteria.reduce((sum, c) => sum + c.weight, 0),
+    })),
+  )
+}

package/src/app/api/eval/suite/route.ts

@@ -0,0 +1,29 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { runEvalSuite } from '@/lib/server/eval/runner'
+
+const SuiteSchema = z.object({
+  agentId: z.string().min(1),
+  categories: z.array(z.string()).optional(),
+})
+
+export async function POST(req: Request) {
+  try {
+    const body: unknown = await req.json()
+    const parsed = SuiteSchema.safeParse(body)
+    if (!parsed.success) {
+      return NextResponse.json(
+        { error: parsed.error.issues.map((i) => i.message).join(', ') },
+        { status: 400 },
+      )
+    }
+
+    const result = await runEvalSuite(parsed.data.agentId, parsed.data.categories)
+    return NextResponse.json(result)
+  } catch (err: unknown) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : String(err) },
+      { status: 500 },
+    )
+  }
+}

package/src/app/api/memory/graph/route.ts

@@ -0,0 +1,46 @@
+import { NextResponse } from 'next/server'
+import { getMemoryDb } from '@/lib/server/memory-db'
+import type { MemoryEntry } from '@/types'
+
+export const dynamic = 'force-dynamic'
+
+/** GET /api/memory/graph — returns a node-link structure of the memory graph */
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const agentId = searchParams.get('agentId')
+  const limit = Math.min(1000, Math.max(1, Number(searchParams.get('limit')) || 200))
+  
+  const db = getMemoryDb()
+  const entries: MemoryEntry[] = db.list(agentId || undefined, limit)
+  
+  const nodes = entries.map(e => ({
+    id: e.id,
+    title: e.title,
+    category: e.category,
+    agentId: e.agentId,
+    contentPreview: e.content.slice(0, 100) + (e.content.length > 100 ? '...' : ''),
+    createdAt: e.createdAt,
+    updatedAt: e.updatedAt,
+    pinned: e.pinned
+  }))
+
+  const links: Array<{ source: string; target: string; type: string }> = []
+  const entryIds = new Set(entries.map(e => e.id))
+
+  for (const entry of entries) {
+    if (entry.linkedMemoryIds && Array.isArray(entry.linkedMemoryIds)) {
+      for (const targetId of entry.linkedMemoryIds) {
+        // Only include links where both nodes are in the current set (or could fetch more if needed)
+        if (entryIds.has(targetId)) {
+          links.push({
+            source: entry.id,
+            target: targetId,
+            type: 'linked'
+          })
+        }
+      }
+    }
+  }
+
+  return NextResponse.json({ nodes, links })
+}

package/src/app/api/sessions/[id]/checkpoints/route.ts

@@ -0,0 +1,31 @@
+import { NextResponse } from 'next/server'
+import { getCheckpointSaver } from '@/lib/server/langgraph-checkpoint'
+
+export const dynamic = 'force-dynamic'
+
+/** GET /api/sessions/[id]/checkpoints — returns checkpoint history for a thread */
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id: threadId } = await params
+  if (!threadId) return NextResponse.json({ error: 'Thread ID is required' }, { status: 400 })
+
+  const saver = getCheckpointSaver()
+  const checkpoints = []
+  
+  // LangGraph's list() is an async generator
+  const iterator = saver.list({ configurable: { thread_id: threadId } })
+  
+  for await (const tuple of iterator) {
+    checkpoints.push({
+      checkpointId: tuple.config.configurable?.checkpoint_id,
+      parentCheckpointId: tuple.parentConfig?.configurable?.checkpoint_id,
+      metadata: tuple.metadata,
+      createdAt: new Date(tuple.checkpoint.ts).getTime(),
+      values: tuple.checkpoint.channel_values,
+    })
+  }
+
+  // Sort by created_at descending (saver.list usually does this but we want to be sure)
+  checkpoints.sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0))
+
+  return NextResponse.json(checkpoints)
+}

package/src/app/api/sessions/[id]/restore/route.ts

@@ -0,0 +1,36 @@
+import { NextResponse } from 'next/server'
+import { getCheckpointSaver } from '@/lib/server/langgraph-checkpoint'
+import { loadSessions, saveSessions } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+
+export const dynamic = 'force-dynamic'
+
+/** POST /api/sessions/[id]/restore — restores thread to a specific checkpoint */
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id: sessionId } = await params
+  const { checkpointId, timestamp } = await req.json()
+  
+  if (!checkpointId || !timestamp) {
+    return NextResponse.json({ error: 'checkpointId and timestamp are required' }, { status: 400 })
+  }
+
+  const saver = getCheckpointSaver()
+  
+  // 1. Delete all checkpoints after the target one
+  await saver.deleteCheckpointsAfter(sessionId, timestamp)
+
+  // 2. Truncate messages in the session to match the timestamp
+  // Both timestamp (from checkpoint.ts → getTime()) and Message.time use epoch milliseconds
+  const sessions = loadSessions()
+  const session = sessions[sessionId]
+  if (session) {
+    session.messages = session.messages.filter((m: { time: number }) => m.time <= timestamp)
+    session.lastActiveAt = Date.now()
+    saveSessions(sessions)
+  }
+
+  notify(`messages:${sessionId}`)
+  notify('sessions')
+  
+  return NextResponse.json({ ok: true, restoredTo: checkpointId })
+}

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

@@ -0,0 +1,65 @@
+import { NextResponse } from 'next/server'
+import { loadSouls, saveSouls, deleteSoul, logActivity } from '@/lib/server/storage'
+import { SOUL_LIBRARY } from '@/lib/soul-library'
+import { notify } from '@/lib/server/ws-hub'
+
+export const dynamic = 'force-dynamic'
+
+/** GET /api/souls/[id] */
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  
+  // Check static library first
+  const staticSoul = SOUL_LIBRARY.find(s => s.id === id)
+  if (staticSoul) return NextResponse.json(staticSoul)
+
+  const souls = loadSouls()
+  if (!souls[id]) return NextResponse.json({ error: 'Soul not found' }, { status: 404 })
+  return NextResponse.json(souls[id])
+}
+
+/** PUT /api/souls/[id] — update custom soul */
+export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const body = await req.json()
+  
+  // Can only update custom souls
+  const souls = loadSouls()
+  if (!souls[id]) {
+    return NextResponse.json({ error: 'Only custom souls can be modified via this endpoint' }, { status: 403 })
+  }
+
+  const updated = { ...souls[id], ...body, id, updatedAt: Date.now() }
+  souls[id] = updated
+  saveSouls(souls)
+  
+  notify('souls')
+  return NextResponse.json(updated)
+}
+
+/** DELETE /api/souls/[id] — delete custom soul */
+export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  
+  // Only allow deleting custom ones
+  const souls = loadSouls()
+  if (!souls[id]) {
+     const isStatic = SOUL_LIBRARY.some(s => s.id === id)
+     if (isStatic) return NextResponse.json({ error: 'Cannot delete static library souls' }, { status: 403 })
+     return NextResponse.json({ error: 'Soul not found' }, { status: 404 })
+  }
+
+  const name = souls[id].name
+  deleteSoul(id)
+  
+  logActivity({ 
+    entityType: 'soul', 
+    entityId: id, 
+    action: 'deleted', 
+    actor: 'user', 
+    summary: `Custom soul deleted: "${name}"` 
+  })
+  
+  notify('souls')
+  return NextResponse.json({ deleted: id })
+}

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

@@ -0,0 +1,70 @@
+import { NextResponse } from 'next/server'
+import { SOUL_LIBRARY, type SoulTemplate } from '@/lib/soul-library'
+import { loadSouls, saveSouls, logActivity } from '@/lib/server/storage'
+import { genId } from '@/lib/id'
+import { notify } from '@/lib/server/ws-hub'
+
+export const dynamic = 'force-dynamic'
+
+/** GET /api/souls — returns merged list of static library and custom user souls */
+export async function GET(req: Request) {
+  const customSouls = loadSouls()
+  const { searchParams } = new URL(req.url)
+  const query = searchParams.get('q')?.toLowerCase() || ''
+  const archetype = searchParams.get('archetype')
+
+  const merged: SoulTemplate[] = [
+    ...SOUL_LIBRARY,
+    ...Object.values(customSouls) as SoulTemplate[],
+  ]
+
+  let filtered = merged
+  if (archetype && archetype !== 'All') {
+    filtered = filtered.filter((s) => s.archetype === archetype)
+  }
+  if (query) {
+    filtered = filtered.filter(
+      (s) =>
+        s.name.toLowerCase().includes(query) ||
+        s.description.toLowerCase().includes(query) ||
+        s.tags.some((t) => t.toLowerCase().includes(query)) ||
+        s.soul.toLowerCase().includes(query),
+    )
+  }
+
+  return NextResponse.json(filtered)
+}
+
+/** POST /api/souls — create a custom soul */
+export async function POST(req: Request) {
+  const body = await req.json()
+  if (!body.name || !body.soul) {
+    return NextResponse.json({ error: 'Name and soul content are required' }, { status: 400 })
+  }
+
+  const id = body.id || `custom-${genId()}`
+  const souls = loadSouls()
+  
+  const newSoul: SoulTemplate = {
+    id,
+    name: body.name,
+    description: body.description || '',
+    soul: body.soul,
+    tags: Array.isArray(body.tags) ? body.tags : [],
+    archetype: body.archetype || 'Custom',
+  }
+
+  souls[id] = newSoul
+  saveSouls(souls)
+  
+  logActivity({ 
+    entityType: 'soul', 
+    entityId: id, 
+    action: 'created', 
+    actor: 'user', 
+    summary: `Custom soul created: "${newSoul.name}"` 
+  })
+  
+  notify('souls')
+  return NextResponse.json(newSoul)
+}

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

@@ -11,6 +11,7 @@ import { createNotification } from '@/lib/server/create-notification'
 import { enqueueSystemEvent } from '@/lib/server/system-events'
 import { requestHeartbeatNow } from '@/lib/server/heartbeat-wake'
 import { validateDag, cascadeUnblock } from '@/lib/server/dag-validation'
+import { getPluginManager } from '@/lib/server/plugins'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   // Keep completed queue integrity even if daemon is not running.
@@ -100,6 +101,10 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
       entityType: 'task',
       entityId: id,
     })
+    
+    if (tasks[id].status === 'completed') {
+      getPluginManager().runHook('onTaskComplete', { taskId: id, result: tasks[id].result })
+    }
 
     // Enqueue system event + heartbeat wake
     if (tasks[id].sessionId) {

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

@@ -11,6 +11,7 @@ import { notify } from '@/lib/server/ws-hub'
 import { computeTaskFingerprint, findDuplicateTask } from '@/lib/task-dedupe'
 import { resolveTaskAgentFromDescription } from '@/lib/server/task-mention'
 import { validateDag } from '@/lib/server/dag-validation'
+import { getPluginManager } from '@/lib/server/plugins'
 
 export async function GET(req: Request) {
   // Keep completed queue integrity even if daemon is not running.
@@ -162,6 +163,7 @@ export async function POST(req: Request) {
     if (validation.ok) {
       tasks[id].completedAt = Date.now()
       tasks[id].error = null
+      getPluginManager().runHook('onTaskComplete', { taskId: id, result: tasks[id].result })
     } else {
       tasks[id].status = 'failed'
       tasks[id].completedAt = null

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

@@ -94,12 +94,14 @@ export async function GET(req: Request) {
     errorCount: number
     lastUsed: number
     models: Set<string>
+    totalDurationMs: number
+    latencyCount: number
   }> = {}
 
   for (const r of records) {
     const prov = r.provider || 'unknown'
     if (!healthAccum[prov]) {
-      healthAccum[prov] = { totalRequests: 0, successCount: 0, errorCount: 0, lastUsed: 0, models: new Set() }
+      healthAccum[prov] = { totalRequests: 0, successCount: 0, errorCount: 0, lastUsed: 0, models: new Set(), totalDurationMs: 0, latencyCount: 0 }
     }
     const h = healthAccum[prov]
     h.totalRequests += 1
@@ -107,6 +109,11 @@ export async function GET(req: Request) {
     h.successCount += 1
     if ((r.timestamp || 0) > h.lastUsed) h.lastUsed = r.timestamp || 0
     if (r.model) h.models.add(r.model)
+    
+    if (typeof r.durationMs === 'number' && r.durationMs > 0) {
+      h.totalDurationMs += r.durationMs
+      h.latencyCount += 1
+    }
   }
 
   const providerHealth: Record<string, {
@@ -125,7 +132,7 @@ export async function GET(req: Request) {
       successCount: h.successCount,
       errorCount: h.errorCount,
       errorRate: h.totalRequests > 0 ? h.errorCount / h.totalRequests : 0,
-      avgLatencyMs: 0, // UsageRecord does not track latency
+      avgLatencyMs: h.latencyCount > 0 ? h.totalDurationMs / h.latencyCount : 0,
       lastUsed: h.lastUsed,
       models: Array.from(h.models),
     }

package/src/cli/index.js

@@ -160,6 +160,16 @@ const COMMAND_GROUPS = [
       cmd('delete', 'DELETE', '/documents/:id', 'Delete document'),
     ],
   },
+  {
+    name: 'eval',
+    description: 'Run agent evaluation scenarios',
+    commands: [
+      cmd('scenarios', 'GET', '/eval/scenarios', 'List available eval scenarios'),
+      cmd('status', 'GET', '/eval/run', 'Get eval run status'),
+      cmd('run', 'POST', '/eval/run', 'Run an eval scenario against an agent', { expectsJsonBody: true }),
+      cmd('suite', 'POST', '/eval/suite', 'Run a full eval suite against an agent', { expectsJsonBody: true }),
+    ],
+  },
   {
     name: 'files',
     description: 'Serve and manage local files',
@@ -209,6 +219,7 @@ const COMMAND_GROUPS = [
       cmd('delete', 'DELETE', '/memory/:id', 'Delete memory entry'),
       cmd('maintenance', 'GET', '/memory/maintenance', 'Analyze memory dedupe/prune candidates'),
       cmd('maintenance-run', 'POST', '/memory/maintenance', 'Run memory dedupe/prune maintenance', { expectsJsonBody: true }),
+      cmd('graph', 'GET', '/memory/graph', 'Get memory graph (nodes and links) for visualization'),
     ],
   },
   {
@@ -428,6 +439,8 @@ const COMMAND_GROUPS = [
         expectsJsonBody: true,
         defaultBody: { action: 'status' },
       }),
+      cmd('checkpoints', 'GET', '/sessions/:id/checkpoints', 'List checkpoint history for a session'),
+      cmd('restore', 'POST', '/sessions/:id/restore', 'Restore session to a previous checkpoint', { expectsJsonBody: true }),
     ],
   },
   {
@@ -459,6 +472,17 @@ const COMMAND_GROUPS = [
       cmd('import', 'POST', '/skills/import', 'Import skill from URL', { expectsJsonBody: true }),
     ],
   },
+  {
+    name: 'souls',
+    description: 'Browse and manage soul library templates',
+    commands: [
+      cmd('list', 'GET', '/souls', 'List soul templates'),
+      cmd('get', 'GET', '/souls/:id', 'Get soul template by id'),
+      cmd('create', 'POST', '/souls', 'Create custom soul template', { expectsJsonBody: true }),
+      cmd('update', 'PUT', '/souls/:id', 'Update soul template', { expectsJsonBody: true }),
+      cmd('delete', 'DELETE', '/souls/:id', 'Delete soul template'),
+    ],
+  },
   {
     name: 'tasks',
     description: 'Manage task board items',