@swarmclawai/swarmclaw 1.5.3 → 1.5.33

package/skills/swarmclaw/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: swarmclaw
+description: AI agent runtime and multi-agent orchestration platform. Teaches agents how to use SwarmClaw's 6 primitive tools, persistent memory, dreaming, delegation, connectors, credentials, and the skill system. Use when an agent is running on SwarmClaw and needs to understand the platform's capabilities.
+metadata:
+  openclaw:
+    emoji: "\U0001F41D"
+    privacyPolicy: All data stays on the local SwarmClaw instance. Memory, workspace files, and session data are stored on the host machine. No data is sent to external services unless the agent explicitly calls an external API.
+    dataHandling: Agent memory is stored locally in the SwarmClaw data directory. Workspace files are scoped per agent. Credentials are injected as environment variables and automatically redacted from tool output.
+version: 2.4.1
+author: swarmclawai
+homepage: https://swarmclaw.ai
+tags: [agents, orchestration, multi-agent, runtime, memory, delegation, skills, connectors, dreaming]
+---
+
+# SwarmClaw Platform
+
+SwarmClaw is an AI agent runtime and multi-agent orchestration platform. It gives agents a uniform set of tools, persistent memory, connector integrations, and the ability to delegate work to other agents.
+
+Website: https://swarmclaw.ai
+Docs: https://swarmclaw.ai/docs
+GitHub: https://github.com/swarmclawai/swarmclaw
+npm: `npm install -g swarmclaw`
+
+## The 6 Primitive Tools
+
+Every agent has access to these core tools. They cover the full range of agent capabilities.
+
+| Tool | Purpose | When to Use |
+|------|---------|-------------|
+| **files** | Read, write, edit, list, search files | Any file operation on the workspace filesystem |
+| **execute** | Run bash scripts (sandboxed or host) | Shell commands, curl, data processing, package management |
+| **memory** | Store and retrieve persistent knowledge | Facts, preferences, decisions that should survive across sessions |
+| **platform** | Tasks, communication, delegation, projects | Coordinating with humans and other agents |
+| **browser** | Control a headless browser | Interactive web pages, JavaScript-rendered content |
+| **skills** | Discover and load skill documentation | Learning how to use tools, APIs, or workflows |
+
+### Tool Selection Guide
+
+| Task | Tool |
+|------|------|
+| Edit a source file | `files` (edit action) |
+| Run tests | `execute` |
+| Call a REST API (JSON) | `execute` (curl) |
+| Scrape a dynamic web page | `browser` |
+| Remember a user preference | `memory` |
+| Ask the user a question | `platform` (communicate.ask_human) |
+| Send a Slack message | `platform` (communicate.send_message) |
+| Hand off work to another agent | `platform` (communicate.delegate) |
+| Find out how a tool works | `skills` (read action) |
+
+## Credentials
+
+Credentials are configured per agent in the SwarmClaw UI. They are:
+
+- **Injected as environment variables** into `execute` tool runs (e.g., `$OPENAI_API_KEY`, `$GITHUB_TOKEN`)
+- **Automatically redacted** from all tool output -- secrets never appear in chat history
+- **Named by convention**: `<PROVIDER>_API_KEY` or custom names set in the credential config
+
+You never need to ask the user for API keys directly. If a credential is configured, it's available as an env var. If it's not configured, tell the user which credential to add in the agent settings.
+
+## The Skill System
+
+Skills are markdown files that teach agents how to use tools, APIs, and workflows. They are documentation, not executable code.
+
+### Loading Skills
+
+```json
+{ "tool": "skills", "action": "list" }
+{ "tool": "skills", "action": "read", "name": "tools/files" }
+{ "tool": "skills", "action": "search", "query": "github pr" }
+```
+
+### Skill Locations
+
+- `skills/` -- built-in skills shipped with SwarmClaw
+- `data/skills/` -- user-created skills added at runtime
+
+### When to Load Skills
+
+- Before using a tool you're unfamiliar with
+- When a task involves an API or workflow you haven't used before
+- When the user asks you to do something and you're unsure of the best approach
+
+## Agent Capabilities
+
+### Memory
+
+Agents have persistent memory across sessions:
+
+- **Working memory** (session-scoped): scratch notes, intermediate results
+- **Durable memory** (cross-session): user preferences, project facts, decisions
+- Memories are automatically surfaced in context when relevant
+- Store important learnings proactively -- don't wait to be asked
+
+### Dreaming
+
+Agents with dreaming enabled automatically consolidate memories during idle periods. You can also trigger a dream manually:
+
+#### Check dream status
+```json
+{ "tool": "memory", "action": "list", "category": "dream_reflection" }
+```
+
+#### Manual dream trigger
+Use the platform API to trigger a dream cycle:
+```json
+{ "tool": "execute", "command": "curl -s -X POST http://localhost:3456/api/memory/dream -H 'Content-Type: application/json' -d '{\"agentId\":\"YOUR_AGENT_ID\"}'" }
+```
+
+Dream cycles produce `dream_reflection` and `consolidated_insight` memories that help maintain a clean, coherent memory store over time.
+
+### Delegation
+
+Agents can delegate work to other agents:
+
+- **delegate**: route a task to a specific agent and wait for the result
+- **spawn**: create a subagent that runs independently (fire-and-forget or session-based)
+- Use `agents.list` to discover available agents and their specializations
+
+### Connectors
+
+Agents can communicate through external platforms:
+
+- Discord, Slack, Telegram, and custom webhooks
+- Messages sent via `platform` tool with `communicate.send_message`
+- Inbound messages from connectors trigger agent sessions automatically
+
+## Workspace Conventions
+
+- The workspace root is the agent's working directory
+- File paths in tool calls are relative to the workspace root
+- `/workspace/...` paths are resolved to the workspace root automatically
+- The `$WORKSPACE` env var points to the workspace root in execute tool runs
+
+## Best Practices
+
+1. **Load skills before unfamiliar operations.** A 30-second skill read prevents minutes of trial and error.
+
+2. **Use the right tool for the job.** Don't use `execute` with `echo > file.txt` when `files` write action is cleaner. Don't use `browser` when `curl` in `execute` suffices.
+
+3. **Store important context in memory.** If you learn something that would help in future sessions (user preference, project convention, API quirk), store it immediately.
+
+4. **Ask rather than guess.** When genuinely uncertain about user intent, use `communicate.ask_human`. A brief clarification is better than wasted work on the wrong approach.
+
+5. **Delegate when appropriate.** If another agent is better suited for a subtask, delegate. Check `agents.list` to know what's available.
+
+6. **Be explicit about what you're doing.** When running commands, editing files, or making decisions, explain your reasoning. Transparency builds trust.
+
+7. **Respect file access boundaries.** Stay within the workspace unless the agent has machine-scope access. Never write to system directories.
+
+8. **Handle errors gracefully.** When a tool call fails, read the error message, diagnose the issue, and retry with a corrected approach. Don't repeat the same failing call.

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

@@ -1,9 +1,17 @@
 import { NextResponse } from 'next/server'
 import { notFound } from '@/lib/server/collection-helpers'
 import { trashAgent, updateAgent } from '@/lib/server/agents/agent-service'
+import { loadAgent } from '@/lib/server/agents/agent-repository'
 import { notify } from '@/lib/server/ws-hub'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const agent = loadAgent(id)
+  if (!agent) return notFound()
+  return NextResponse.json(agent)
+}
+
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const { data: body, error } = await safeParseBody(req)

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

@@ -0,0 +1,114 @@
+import assert from 'node:assert/strict'
+import test, { afterEach } from 'node:test'
+
+// Disable daemon autostart during tests
+process.env.SWARMCLAW_DAEMON_AUTOSTART = '0'
+
+import { GET as getAgent } from './[id]/route'
+import { POST as createAgent } from './route'
+import { loadAgents, saveAgents } from '@/lib/server/storage'
+
+const originalAgents = loadAgents()
+
+function routeParams(id: string) {
+  return { params: Promise.resolve({ id }) }
+}
+
+function seedAgent(id: string, overrides: Record<string, unknown> = {}) {
+  const agents = loadAgents()
+  const now = Date.now()
+  agents[id] = {
+    id,
+    name: 'Test Agent',
+    description: 'Route test',
+    systemPrompt: '',
+    provider: 'ollama',
+    model: 'qwen3.5',
+    credentialId: null,
+    fallbackCredentialIds: [],
+    apiEndpoint: null,
+    gatewayProfileId: null,
+    extensions: [],
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  }
+  saveAgents(agents)
+}
+
+afterEach(() => {
+  saveAgents(originalAgents)
+})
+
+// --- GET /api/agents/:id ---
+
+test('GET /api/agents/:id returns the agent when it exists', async () => {
+  seedAgent('agent-get-test', { name: 'GetMe' })
+
+  const response = await getAgent(
+    new Request('http://local/api/agents/agent-get-test'),
+    routeParams('agent-get-test'),
+  )
+
+  assert.equal(response.status, 200)
+  const body = await response.json()
+  assert.equal(body.id, 'agent-get-test')
+  assert.equal(body.name, 'GetMe')
+})
+
+test('GET /api/agents/:id returns 404 for a non-existent agent', async () => {
+  const response = await getAgent(
+    new Request('http://local/api/agents/does-not-exist'),
+    routeParams('does-not-exist'),
+  )
+
+  assert.equal(response.status, 404)
+  const body = await response.json()
+  assert.equal(body.error, 'Not found')
+})
+
+// --- POST /api/agents (provider validation) ---
+
+test('POST /api/agents rejects an unknown provider with a 400', async () => {
+  const response = await createAgent(new Request('http://local/api/agents', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ name: 'Bad Provider Agent', provider: 'nonexistent_provider', model: 'x' }),
+  }))
+
+  assert.equal(response.status, 400)
+  const body = await response.json()
+  assert.equal(body.error, 'Validation failed')
+  assert.ok(body.issues.some((i: { path: string; message: string }) => i.path === 'provider'))
+})
+
+test('POST /api/agents accepts a valid provider and creates the agent', async () => {
+  const response = await createAgent(new Request('http://local/api/agents', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ name: 'Good Agent', provider: 'ollama', model: 'qwen3.5' }),
+  }))
+
+  assert.equal(response.status, 200)
+  const body = await response.json()
+  assert.equal(body.name, 'Good Agent')
+  assert.equal(body.provider, 'ollama')
+  assert.ok(body.id)
+
+  // Clean up
+  const agents = loadAgents()
+  delete agents[body.id]
+  saveAgents(agents)
+})
+
+test('POST /api/agents rejects missing required fields with a 400', async () => {
+  const response = await createAgent(new Request('http://local/api/agents', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({}),
+  }))
+
+  assert.equal(response.status, 400)
+  const body = await response.json()
+  assert.equal(body.error, 'Validation failed')
+})

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

@@ -3,6 +3,7 @@ import { perf } from '@/lib/server/runtime/perf'
 import { listAgentsForApi, createAgent } from '@/lib/server/agents/agent-service'
 import { AgentCreateSchema, formatZodError } from '@/lib/validation/schemas'
 import { ensureDaemonProcessRunning } from '@/lib/server/daemon/controller'
+import { getProvider } from '@/lib/providers'
 import { z } from 'zod'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 import { loadSettings } from '@/lib/server/storage'
@@ -40,6 +41,15 @@ export async function POST(req: Request) {
   }
   const body = parsed.data as unknown as Record<string, unknown>
 
+  // Validate provider exists
+  const providerId = String(body.provider || '')
+  if (providerId && !getProvider(providerId)) {
+    return NextResponse.json(
+      { error: 'Validation failed', issues: [{ path: 'provider', message: `Unknown provider: "${providerId}"` }] },
+      { status: 400 },
+    )
+  }
+
   // Check approval policy — if enabled, create an approval request instead of the agent
   const settings = loadSettings()
   if (settings.approvalPolicies?.requireApprovalForAgentCreate) {

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

@@ -13,21 +13,33 @@ import { ensureDaemonProcessRunning } from '@/lib/server/daemon/controller'
 export const dynamic = 'force-dynamic'
 
 export async function GET() {
-  const endPerf = perf.start('api', 'GET /api/connectors')
-  const connectors = await listConnectorsWithRuntime()
-  endPerf({ count: Object.keys(connectors).length })
-  return NextResponse.json(connectors)
+  try {
+    const endPerf = perf.start('api', 'GET /api/connectors')
+    const connectors = await listConnectorsWithRuntime()
+    endPerf({ count: Object.keys(connectors).length })
+    return NextResponse.json(connectors)
+  } catch (err) {
+    return NextResponse.json({ error: err instanceof Error ? err.message : String(err) }, { status: 500 })
+  }
 }
 
 export async function POST(req: Request) {
-  await ensureDaemonProcessRunning('api/connectors:post')
-  const { data: raw, error } = await safeParseBody<Record<string, unknown>>(req)
-  if (error) return error
-  const parsed = ConnectorCreateSchema.safeParse(raw)
-  if (!parsed.success) {
-    return NextResponse.json(formatZodError(parsed.error as z.ZodError), { status: 400 })
+  try {
+    await ensureDaemonProcessRunning('api/connectors:post')
+    const { data: raw, error } = await safeParseBody<Record<string, unknown>>(req)
+    if (error) return error
+    const parsed = ConnectorCreateSchema.safeParse(raw)
+    if (!parsed.success) {
+      return NextResponse.json(formatZodError(parsed.error as z.ZodError), { status: 400 })
+    }
+    const connector = createConnector(parsed.data as unknown as Record<string, unknown>)
+    try {
+      await autoStartConnectorIfNeeded(connector, parsed.data as unknown as Record<string, unknown>)
+    } catch {
+      // Auto-start failure is non-fatal — the connector is still saved.
+    }
+    return NextResponse.json(await getConnectorWithRuntime(connector.id) || connector)
+  } catch (err) {
+    return NextResponse.json({ error: err instanceof Error ? err.message : String(err) }, { status: 500 })
   }
-  const connector = createConnector(parsed.data as unknown as Record<string, unknown>)
-  await autoStartConnectorIfNeeded(connector, parsed.data as unknown as Record<string, unknown>)
-  return NextResponse.json(await getConnectorWithRuntime(connector.id) || connector)
 }

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

@@ -1,11 +1,18 @@
 import { NextResponse } from 'next/server'
-import { deleteCredentialRecord } from '@/lib/server/credentials/credential-service'
+import { deleteCredentialRecord, getCredentialSummary } from '@/lib/server/credentials/credential-service'
 import { notFound } from '@/lib/server/collection-helpers'
 import { log } from '@/lib/server/logger'
 import { logActivity } from '@/lib/server/activity/activity-log'
 
 const TAG = 'api-credentials'
 
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const summary = getCredentialSummary(id)
+  if (!summary) return notFound()
+  return NextResponse.json(summary)
+}
+
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id: credId } = await params
   if (!deleteCredentialRecord(credId)) {

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

@@ -1,11 +1,19 @@
 import { NextResponse } from 'next/server'
 import { notFound } from '@/lib/server/collection-helpers'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
+import { loadSchedule } from '@/lib/server/schedules/schedule-repository'
 import {
   deleteScheduleFromRoute,
   updateScheduleFromRoute,
 } from '@/lib/server/schedules/schedule-route-service'
 
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const schedule = loadSchedule(id)
+  if (!schedule) return notFound()
+  return NextResponse.json(schedule)
+}
+
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const { data: body, error } = await safeParseBody(req)

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

@@ -6,6 +6,16 @@ import { safeParseBody } from '@/lib/server/safe-parse-body'
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const ops: CollectionOps<any> = { load: loadSecrets, save: saveSecrets }
 
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const secrets = loadSecrets()
+  const secret = secrets[id]
+  if (!secret) return notFound()
+  // Never expose the encrypted value
+  const { encryptedValue, ...safe } = secret as Record<string, unknown>
+  return NextResponse.json(safe)
+}
+
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   if (!deleteItem(ops, id)) return notFound()

package/src/app/api/setup/check-provider/route.ts

@@ -1,11 +1,20 @@
 import { NextResponse } from 'next/server'
 import { loadCredentials, decryptKey } from '@/lib/server/storage'
 import { getDeviceId, wsConnect, rpcOnConnectedGateway } from '@/lib/providers/openclaw'
+import { buildCliEnv, probeCliAuth, resolveCliBinary } from '@/lib/providers/cli-utils'
 import { OPENAI_COMPATIBLE_DEFAULTS } from '@/lib/server/provider-health'
 import { resolveOllamaRuntimeConfig } from '@/lib/server/ollama-runtime'
 import { normalizeOllamaSetupEndpoint, normalizeOpenClawUrl, parseErrorMessage } from './helpers'
 
 type SetupProvider =
+  | 'claude-cli'
+  | 'codex-cli'
+  | 'opencode-cli'
+  | 'gemini-cli'
+  | 'copilot-cli'
+  | 'cursor-cli'
+  | 'qwen-code-cli'
+  | 'goose'
   | 'openai'
   | 'openrouter'
   | 'anthropic'
@@ -22,6 +31,8 @@ type SetupProvider =
   | 'openclaw'
   | 'hermes'
 
+type CliSetupProvider = 'claude-cli' | 'codex-cli' | 'opencode-cli' | 'gemini-cli' | 'copilot-cli' | 'cursor-cli' | 'qwen-code-cli' | 'goose'
+
 interface SetupCheckBody {
   provider?: string
   apiKey?: string
@@ -266,6 +277,34 @@ async function checkOpenClaw(apiKey: string, endpointRaw: string): Promise<{ ok:
   return { ok: true, message: 'Connected to OpenClaw gateway.', normalizedEndpoint, deviceId, recommendedModel }
 }
 
+function checkCliProvider(provider: CliSetupProvider): { ok: boolean; message: string } {
+  const env = buildCliEnv()
+  const config = {
+    'claude-cli': { binary: 'claude', backend: 'claude' as const, label: 'Claude Code CLI' },
+    'codex-cli': { binary: 'codex', backend: 'codex' as const, label: 'OpenAI Codex CLI' },
+    'opencode-cli': { binary: 'opencode', backend: 'opencode' as const, label: 'OpenCode CLI' },
+    'gemini-cli': { binary: 'gemini', backend: 'gemini' as const, label: 'Gemini CLI' },
+    'copilot-cli': { binary: 'copilot', backend: 'copilot' as const, label: 'GitHub Copilot CLI' },
+    'cursor-cli': { binary: 'cursor-agent', backend: 'cursor' as const, label: 'Cursor Agent CLI' },
+    'qwen-code-cli': { binary: 'qwen', backend: 'qwen' as const, label: 'Qwen Code CLI' },
+    goose: { binary: 'goose', backend: 'goose' as const, label: 'Goose CLI' },
+  }[provider]
+
+  if (!config) return { ok: false, message: 'Unknown CLI provider.' }
+  const binary = resolveCliBinary(config.binary)
+  if (!binary) {
+    return {
+      ok: false,
+      message: `${config.label} is not installed. Install \`${config.binary}\` and ensure it is on your PATH.`,
+    }
+  }
+  const auth = probeCliAuth(binary, config.backend, env, process.cwd())
+  if (!auth.authenticated) {
+    return { ok: false, message: auth.errorMessage || `${config.label} is not configured.` }
+  }
+  return { ok: true, message: `${config.label} is installed and ready.` }
+}
+
 export async function POST(req: Request) {
   const body = parseBody(await req.json().catch(() => ({})))
   const provider = clean(body.provider) as SetupProvider
@@ -273,6 +312,7 @@ export async function POST(req: Request) {
   const credentialId = clean(body.credentialId)
   const endpoint = clean(body.endpoint)
   const model = clean(body.model)
+  const CLI_PROVIDERS = new Set<CliSetupProvider>(['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'cursor-cli', 'qwen-code-cli', 'goose'])
 
   // Resolve credentialId to an API key if no raw key was provided
   if (!apiKey && credentialId) {
@@ -287,6 +327,11 @@ export async function POST(req: Request) {
     }
   }
 
+  if (CLI_PROVIDERS.has(provider as CliSetupProvider)) {
+    const result = checkCliProvider(provider as CliSetupProvider)
+    return NextResponse.json(result)
+  }
+
   if (!provider) {
     return NextResponse.json({ ok: false, message: 'Provider is required.' }, { status: 400 })
   }

package/src/app/api/setup/doctor/route.ts

@@ -171,6 +171,11 @@ export async function GET(req: Request) {
     { id: 'claude-cli', label: 'Claude Code CLI', command: 'claude' },
     { id: 'codex-cli', label: 'OpenAI Codex CLI', command: 'codex' },
     { id: 'opencode-cli', label: 'OpenCode CLI', command: 'opencode' },
+    { id: 'gemini-cli', label: 'Gemini CLI', command: 'gemini' },
+    { id: 'copilot-cli', label: 'GitHub Copilot CLI', command: 'copilot' },
+    { id: 'cursor-cli', label: 'Cursor Agent CLI', command: 'cursor-agent' },
+    { id: 'qwen-code-cli', label: 'Qwen Code CLI', command: 'qwen' },
+    { id: 'goose', label: 'Goose CLI', command: 'goose' },
     { id: 'google-workspace-cli', label: 'Google Workspace CLI', command: 'gws' },
   ]
 

package/src/cli/binary.test.js

@@ -113,6 +113,17 @@ test('legacy-routed binary commands fall back to platform-api-key.txt', () => {
   fs.rmSync(tmpDir, { recursive: true, force: true })
 })
 
+test('legacy-routed binary commands accept documented global aliases after the subcommand', () => {
+  const { result, capture } = runWithMockedFetch(
+    ['agents', 'list', '--access-key', 'alias-key', '--base-url', 'http://127.0.0.1:4567', '--json'],
+  )
+
+  assert.equal(result.status, 0, result.stderr)
+  assert.equal(result.stdout.trim(), '[]')
+  assert.equal(capture.headers['X-Access-Key'], 'alias-key')
+  assert.equal(capture.url, 'http://127.0.0.1:4567/api/agents')
+})
+
 test('binary server help exits successfully', () => {
   const result = runBinary(['server', '--help'])
   assert.equal(result.status, 0, result.stderr)

package/src/cli/index.js

@@ -15,7 +15,7 @@ const COMMAND_GROUPS = [
     description: 'Manage agents',
     commands: [
       cmd('list', 'GET', '/agents', 'List agents'),
-      cmd('get', 'GET', '/agents/:id', 'Get an agent by id', { virtual: true, clientGetRoute: '/agents' }),
+      cmd('get', 'GET', '/agents/:id', 'Get an agent by id'),
       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'),
@@ -142,7 +142,7 @@ const COMMAND_GROUPS = [
     description: 'Manage encrypted provider credentials',
     commands: [
       cmd('list', 'GET', '/credentials', 'List credentials'),
-      cmd('get', 'GET', '/credentials/:id', 'Get credential metadata by id', { virtual: true, clientGetRoute: '/credentials' }),
+      cmd('get', 'GET', '/credentials/:id', 'Get credential metadata by id'),
       cmd('create', 'POST', '/credentials', 'Create credential', { expectsJsonBody: true }),
       cmd('delete', 'DELETE', '/credentials/:id', 'Delete credential'),
     ],
@@ -541,7 +541,7 @@ const COMMAND_GROUPS = [
     description: 'Manage schedules',
     commands: [
       cmd('list', 'GET', '/schedules', 'List schedules'),
-      cmd('get', 'GET', '/schedules/:id', 'Get schedule by id', { virtual: true, clientGetRoute: '/schedules' }),
+      cmd('get', 'GET', '/schedules/:id', 'Get schedule by id'),
       cmd('create', 'POST', '/schedules', 'Create schedule', { expectsJsonBody: true }),
       cmd('update', 'PUT', '/schedules/:id', 'Update schedule', { expectsJsonBody: true }),
       cmd('delete', 'DELETE', '/schedules/:id', 'Delete schedule'),
@@ -553,7 +553,7 @@ const COMMAND_GROUPS = [
     description: 'Manage reusable encrypted secrets',
     commands: [
       cmd('list', 'GET', '/secrets', 'List secrets metadata'),
-      cmd('get', 'GET', '/secrets/:id', 'Get secret metadata by id', { virtual: true, clientGetRoute: '/secrets' }),
+      cmd('get', 'GET', '/secrets/:id', 'Get secret metadata by id'),
       cmd('create', 'POST', '/secrets', 'Create secret', { expectsJsonBody: true }),
       cmd('update', 'PUT', '/secrets/:id', 'Update secret metadata', { expectsJsonBody: true }),
       cmd('delete', 'DELETE', '/secrets/:id', 'Delete secret'),

package/src/cli/index.test.js

@@ -453,7 +453,10 @@ test('client-side collection lookups fail cleanly when the entity is missing', a
   const stdout = makeWritable()
   const stderr = makeWritable()
 
-  const fetchImpl = async () => jsonResponse([{ id: 'agent-2', name: 'Other Agent' }])
+  const fetchImpl = async () => new Response(JSON.stringify({ error: 'Not found' }), {
+    status: 404,
+    headers: { 'content-type': 'application/json' },
+  })
 
   const exitCode = await runCli(
     ['agents', 'get', 'agent-1'],
@@ -468,7 +471,7 @@ test('client-side collection lookups fail cleanly when the entity is missing', a
 
   assert.equal(exitCode, 1)
   assert.equal(stdout.toString(), '')
-  assert.match(stderr.toString(), /entity not found for id: agent-1/i)
+  assert.match(stderr.toString(), /not found/i)
 })
 
 test('runCli loads request JSON from @file inputs', async () => {

package/src/cli/index.ts

@@ -479,7 +479,7 @@ export function buildProgram(): Command {
     .description('SwarmClaw CLI')
     .option('-u, --url <url>', 'SwarmClaw base URL', DEFAULT_BASE_URL)
     .option('-k, --key <key>', 'SwarmClaw access key', DEFAULT_ACCESS_KEY)
-    .option('--raw', 'Print compact JSON output')
+    .option('--raw, --json', 'Print compact JSON output')
     .showHelpAfterError()
 
   const agents = program.command('agents').description('Manage agents')

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

@@ -2506,10 +2506,22 @@ export function AgentSheet() {
             {provider === 'claude-cli'
               ? 'Claude CLI uses its own built-in capabilities — no additional local tool/platform configuration is needed.'
               : provider === 'codex-cli'
-                ? 'OpenAI Codex CLI uses its own built-in tools (shell, files, etc.) — no additional local tool configuration needed.'
-                : provider === 'hermes'
-                  ? 'Hermes Agent runs behind its own API server and tool runtime. SwarmClaw sends prompts to Hermes directly instead of injecting local platform tools.'
-                  : 'OpenCode CLI uses its own built-in tools (shell, files, etc.) — no additional local tool configuration needed.'}
+                ? 'OpenAI Codex CLI uses its own built-in tools (shell, files, etc.) — no additional local tool configuration is needed.'
+                : provider === 'opencode-cli'
+                  ? 'OpenCode CLI uses its own built-in tools (shell, files, etc.) — no additional local tool configuration is needed.'
+                  : provider === 'gemini-cli'
+                    ? 'Gemini CLI uses its own built-in tools and runtime — SwarmClaw does not inject local platform tools for it.'
+                    : provider === 'copilot-cli'
+                      ? 'GitHub Copilot CLI uses its own built-in tools and runtime — SwarmClaw does not inject local platform tools for it.'
+                      : provider === 'cursor-cli'
+                        ? 'Cursor Agent CLI runs with its own native tool/runtime layer — SwarmClaw sends prompts directly without injecting local platform tools.'
+                        : provider === 'qwen-code-cli'
+                          ? 'Qwen Code CLI uses its own native tools and runtime — SwarmClaw does not inject local platform tools for it.'
+                          : provider === 'goose'
+                            ? 'Goose manages its own runtime, tools, and extensions — SwarmClaw sends prompts directly instead of injecting local platform tools.'
+                            : provider === 'hermes'
+                              ? 'Hermes Agent runs behind its own API server and tool runtime. SwarmClaw sends prompts to Hermes directly instead of injecting local platform tools.'
+                              : 'This provider manages its own native capabilities and runtime.'}
           </p>
         </div>
       )}

package/src/components/agents/inspector-panel.tsx

@@ -51,6 +51,11 @@ const PROVIDER_LABELS: Record<string, string> = {
   'claude-cli': 'Claude CLI',
   'codex-cli': 'Codex CLI',
   'opencode-cli': 'OpenCode CLI',
+  'gemini-cli': 'Gemini CLI',
+  'copilot-cli': 'Copilot CLI',
+  'cursor-cli': 'Cursor CLI',
+  'qwen-code-cli': 'Qwen Code CLI',
+  goose: 'Goose',
   openai: 'OpenAI',
   anthropic: 'Anthropic',
   openclaw: 'OpenClaw',