@swarmclawai/swarmclaw 1.5.3 → 1.5.33

package/src/components/auth/setup-wizard/step-agents.tsx

@@ -12,6 +12,24 @@ import { AVAILABLE_TOOLS, PLATFORM_TOOLS } from '@/lib/tool-definitions'
 import { AgentAvatar } from '@/components/agents/agent-avatar'
 import { isOrchestratorProviderEligible } from '@/lib/orchestrator-config'
 
+const SETUP_PROVIDERS_WITH_MODEL_DISCOVERY = new Set([
+  'openai',
+  'openrouter',
+  'anthropic',
+  'google',
+  'deepseek',
+  'groq',
+  'together',
+  'mistral',
+  'xai',
+  'fireworks',
+  'nebius',
+  'deepinfra',
+  'ollama',
+  'openclaw',
+  'hermes',
+])
+
 /* ── Model combobox: search discovered models or type a custom one ── */
 
 function ModelCombobox({
@@ -36,7 +54,7 @@ function ModelCombobox({
   const fetched = useRef<string | null>(null)
 
   const effectiveEndpoint = endpointOverride || provider?.endpoint || null
-  const supportsModelDiscovery = Boolean(provider && provider.setupProvider !== 'custom')
+  const supportsModelDiscovery = Boolean(provider && SETUP_PROVIDERS_WITH_MODEL_DISCOVERY.has(provider.setupProvider))
 
   const fetchModels = useCallback(async (force?: boolean) => {
     if (!provider || !supportsModelDiscovery) return

package/src/components/chat/activity-moment.tsx

@@ -12,6 +12,9 @@ const NOTABLE_TOOLS: Record<string, { label: string; color: string; icon: 'brain
   delegate_to_claude_code: { label: 'Delegated to Claude Code', color: '#38BDF8', icon: 'delegate' },
   delegate_to_codex_cli: { label: 'Delegated to Codex', color: '#38BDF8', icon: 'delegate' },
   delegate_to_opencode_cli: { label: 'Delegated to OpenCode', color: '#38BDF8', icon: 'delegate' },
+  delegate_to_gemini_cli: { label: 'Delegated to Gemini CLI', color: '#38BDF8', icon: 'delegate' },
+  delegate_to_cursor_cli: { label: 'Delegated to Cursor CLI', color: '#38BDF8', icon: 'delegate' },
+  delegate_to_qwen_code_cli: { label: 'Delegated to Qwen Code', color: '#38BDF8', icon: 'delegate' },
   delegate_to_agent: { label: 'Delegating task', color: '#6366F1', icon: 'delegate' },
   check_delegation_status: { label: 'Checking delegation', color: '#6366F1', icon: 'delegate' },
   web_search: { label: 'Searched the web', color: '#22C55E', icon: 'search' },

package/src/components/chat/chat-header.tsx

@@ -164,6 +164,12 @@ export function ChatHeader({ session, streaming, onStop, onMenuToggle, onBack, m
     const fromSessionOpenCode = session.opencodeSessionId
       ? { label: 'OpenCode', id: session.opencodeSessionId, command: `opencode run \"<task>\" --session ${session.opencodeSessionId}` }
       : null
+    const fromSessionCursor = session.cursorSessionId
+      ? { label: 'Cursor', id: session.cursorSessionId, command: `cursor-agent --resume ${session.cursorSessionId} --print \"<task>\"` }
+      : null
+    const fromSessionQwen = session.qwenSessionId
+      ? { label: 'Qwen Code', id: session.qwenSessionId, command: `qwen --resume ${session.qwenSessionId} -p \"<task>\"` }
+      : null
     const fromDelegateClaude = session.delegateResumeIds?.claudeCode
       ? { label: 'Claude', id: session.delegateResumeIds.claudeCode, command: `claude --resume ${session.delegateResumeIds.claudeCode}` }
       : null
@@ -176,15 +182,25 @@ export function ChatHeader({ session, streaming, onStop, onMenuToggle, onBack, m
     const fromDelegateGemini = session.delegateResumeIds?.gemini
       ? { label: 'Gemini', id: session.delegateResumeIds.gemini, command: `gemini --resume ${session.delegateResumeIds.gemini} --prompt \"<task>\"` }
       : null
+    const fromDelegateCursor = session.delegateResumeIds?.cursor
+      ? { label: 'Cursor', id: session.delegateResumeIds.cursor, command: `cursor-agent --resume ${session.delegateResumeIds.cursor} --print \"<task>\"` }
+      : null
+    const fromDelegateQwen = session.delegateResumeIds?.qwen
+      ? { label: 'Qwen Code', id: session.delegateResumeIds.qwen, command: `qwen --resume ${session.delegateResumeIds.qwen} -p \"<task>\"` }
+      : null
     return fromSessionClaude
       || fromSessionCodex
       || fromSessionOpenCode
+      || fromSessionCursor
+      || fromSessionQwen
       || fromDelegateClaude
       || fromDelegateCodex
       || fromDelegateOpenCode
       || fromDelegateGemini
+      || fromDelegateCursor
+      || fromDelegateQwen
       || null
-  }, [session.claudeSessionId, session.codexThreadId, session.opencodeSessionId, session.delegateResumeIds])
+  }, [session.claudeSessionId, session.codexThreadId, session.opencodeSessionId, session.cursorSessionId, session.qwenSessionId, session.delegateResumeIds])
 
   const handleCopySessionId = () => {
     if (!resumeHandle) return
@@ -202,7 +218,12 @@ export function ChatHeader({ session, streaming, onStop, onMenuToggle, onBack, m
         claudeSessionId: null,
         codexThreadId: null,
         opencodeSessionId: null,
-        delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null },
+        geminiSessionId: null,
+        copilotSessionId: null,
+        cursorSessionId: null,
+        qwenSessionId: null,
+        acpSessionId: null,
+        delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null, copilot: null, cursor: null, qwen: null },
       })
       await refreshSession(session.id)
     } catch { /* best-effort */ }

package/src/components/chat/tool-call-bubble.tsx

@@ -26,6 +26,10 @@ const TOOL_COLORS: Record<string, string> = {
   delegate_to_claude_code: '#6366F1',
   delegate_to_codex_cli: '#0EA5E9',
   delegate_to_opencode_cli: '#14B8A6',
+  delegate_to_gemini_cli: '#2563EB',
+  delegate_to_copilot_cli: '#6366F1',
+  delegate_to_cursor_cli: '#F97316',
+  delegate_to_qwen_code_cli: '#22C55E',
   whoami_tool: '#8B5CF6',
   connector_message_tool: '#EC4899',
   search_history_tool: '#8B5CF6',
@@ -75,12 +79,20 @@ export const TOOL_LABELS: Record<string, string> = {
   claude_code: 'Claude Code',
   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',
   spawn_subagent: 'Subagent',
   delegate_to_agent: 'Agent Delegation',
   check_delegation_status: 'Check Delegation',
   delegate_to_claude_code: 'Claude Code',
   delegate_to_codex_cli: 'Codex CLI',
   delegate_to_opencode_cli: 'OpenCode CLI',
+  delegate_to_gemini_cli: 'Gemini CLI',
+  delegate_to_copilot_cli: 'Copilot CLI',
+  delegate_to_cursor_cli: 'Cursor CLI',
+  delegate_to_qwen_code_cli: 'Qwen Code CLI',
   whoami_tool: 'Who Am I',
   connector_message_tool: 'Connector Message',
   search_history_tool: 'Search History',
@@ -115,12 +127,20 @@ export const TOOL_DESCRIPTIONS: Record<string, string> = {
   claude_code: 'Enable delegation to Claude Code CLI',
   codex_cli: 'Enable delegation to OpenAI Codex CLI',
   opencode_cli: 'Enable delegation to OpenCode CLI',
+  gemini_cli: 'Enable delegation to Gemini CLI',
+  copilot_cli: 'Enable delegation to GitHub Copilot CLI',
+  cursor_cli: 'Enable delegation to Cursor Agent CLI',
+  qwen_code_cli: 'Enable delegation to Qwen Code CLI',
   spawn_subagent: 'Spawn native subagents with lineage tracking and batch support',
   delegate_to_agent: 'Delegate a task to another agent',
   check_delegation_status: 'Check the status of a delegated task',
   delegate_to_claude_code: 'Delegate complex coding tasks to Claude Code',
   delegate_to_codex_cli: 'Delegate complex coding tasks to Codex CLI',
   delegate_to_opencode_cli: 'Delegate complex coding tasks to OpenCode CLI',
+  delegate_to_gemini_cli: 'Delegate complex coding tasks to Gemini CLI',
+  delegate_to_copilot_cli: 'Delegate complex coding tasks to GitHub Copilot CLI',
+  delegate_to_cursor_cli: 'Delegate complex coding tasks to Cursor Agent CLI',
+  delegate_to_qwen_code_cli: 'Delegate complex coding tasks to Qwen Code CLI',
   whoami_tool: 'Reveal the current agent and chat context',
   connector_message_tool: 'Send proactive outbound messages via running connectors',
   search_history_tool: 'Search chat history for relevant prior context',

package/src/components/layout/sidebar-rail.tsx

@@ -16,6 +16,7 @@ import type { AppView } from '@/types'
 
 const RAIL_EXPANDED_KEY = 'sc_rail_expanded'
 const GITHUB_REPO_URL = 'https://github.com/swarmclawai/swarmclaw'
+const DISCORD_URL = 'https://discord.gg/sbEavS8cPV'
 const NETWORK_LINKS = [
   { href: 'https://www.swarmdock.ai', label: 'SwarmDock', abbr: 'DO' },
   { href: 'https://swarmrecall.ai', label: 'SwarmRecall', abbr: 'RE' },
@@ -487,6 +488,34 @@ export function SidebarRail({
               </a>
             </RailTooltip>
           )}
+          {railExpanded ? (
+            <a
+              href={DISCORD_URL}
+              target="_blank"
+              rel="noopener noreferrer"
+              className="w-full flex items-center gap-2.5 px-3 py-2 rounded-[10px] text-[13px] font-500 cursor-pointer transition-all
+                bg-transparent text-text-3 hover:text-text hover:bg-white/[0.04] no-underline"
+              style={{ fontFamily: 'inherit' }}
+            >
+              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" className="shrink-0">
+                <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
+                <path d="M8 10h.01M12 10h.01M16 10h.01" />
+              </svg>
+              Join Discord
+              <svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" className="ml-auto opacity-40">
+                <path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6" /><polyline points="15 3 21 3 21 9" /><line x1="10" y1="14" x2="21" y2="3" />
+              </svg>
+            </a>
+          ) : (
+            <RailTooltip label="Join Discord" description="Open the SwarmClaw community">
+              <a href={DISCORD_URL} target="_blank" rel="noopener noreferrer" className="rail-btn">
+                <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round">
+                  <path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" />
+                  <path d="M8 10h.01M12 10h.01M16 10h.01" />
+                </svg>
+              </a>
+            </RailTooltip>
+          )}
           {railExpanded && <DaemonIndicator />}
           {railExpanded ? (
             <NotificationCenter variant="row" align="left" direction="up" />

package/src/hooks/setup-done-detection.test.ts

@@ -2,8 +2,10 @@ import assert from 'node:assert/strict'
 import { test } from 'node:test'
 import { resolveSetupDone } from './setup-done-detection'
 
-test('resolveSetupDone returns true when both fetches failed', () => {
-  assert.equal(resolveSetupDone({}, {}, true), true)
+test('resolveSetupDone returns false when both fetches failed so the wizard is shown', () => {
+  // When both API calls fail we cannot determine setup state — default to
+  // showing the wizard so the user doesn't land in a broken app.
+  assert.equal(resolveSetupDone({}, {}, true), false)
 })
 
 test('resolveSetupDone returns true when setupCompleted is true', () => {

package/src/hooks/setup-done-detection.ts

@@ -7,7 +7,7 @@ export function resolveSetupDone(
   creds: Record<string, unknown>,
   bothFailed: boolean,
 ): boolean {
-  if (bothFailed) return true
+  if (bothFailed) return false
   const hasCreds = Object.keys(creds).length > 0
   return settings.setupCompleted === true || hasCreds
 }

package/src/lib/orchestrator-config.ts

@@ -4,6 +4,11 @@ export const NON_ORCHESTRATOR_PROVIDERS = new Set([
   'claude-cli',
   'codex-cli',
   'opencode-cli',
+  'gemini-cli',
+  'copilot-cli',
+  'cursor-cli',
+  'qwen-code-cli',
+  'goose',
   'openclaw',
   'hermes',
 ])

package/src/lib/provider-sets.ts

@@ -1,11 +1,11 @@
 /** CLI providers that use their own tool execution outside the shared tool-runtime path. */
-export const NON_LANGGRAPH_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli'])
+export const NON_LANGGRAPH_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'cursor-cli', 'qwen-code-cli'])
 
 /** Providers that manage their own runtime/tool loop even when reached over an API endpoint. */
-export const RUNTIME_MANAGED_PROVIDER_IDS = new Set(['hermes'])
+export const RUNTIME_MANAGED_PROVIDER_IDS = new Set(['hermes', 'goose'])
 
 /** Providers with native tool/capability support (CLI providers + OpenClaw + Hermes). */
-export const NATIVE_CAPABILITY_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'openclaw', 'hermes'])
+export const NATIVE_CAPABILITY_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'cursor-cli', 'qwen-code-cli', 'goose', 'openclaw', 'hermes'])
 
 /** Providers that can only act as workers — no coordinator role, no heartbeat, no advanced settings. */
-export const WORKER_ONLY_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'openclaw', 'hermes'])
+export const WORKER_ONLY_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'cursor-cli', 'qwen-code-cli', 'goose', 'openclaw', 'hermes'])

package/src/lib/providers/acp-client.ts

@@ -0,0 +1,116 @@
+import { spawn, type ChildProcess } from 'child_process'
+import { EventEmitter } from 'events'
+
+interface JsonRpcRequest {
+  jsonrpc: '2.0'
+  id: number
+  method: string
+  params?: unknown
+}
+
+interface JsonRpcResponse {
+  jsonrpc: '2.0'
+  id?: number | string | null
+  result?: unknown
+  error?: {
+    code?: number
+    message?: string
+    data?: unknown
+  }
+  method?: string
+  params?: unknown
+}
+
+export interface AcpClientOptions {
+  command: string
+  args?: string[]
+  cwd?: string
+  env?: NodeJS.ProcessEnv
+  timeoutMs?: number
+}
+
+export class AcpClient extends EventEmitter {
+  private readonly proc: ChildProcess
+  private readonly timeoutMs: number
+  private readonly pending = new Map<number, { resolve: (value: unknown) => void; reject: (error: Error) => void; timer: NodeJS.Timeout }>()
+  private nextId = 1
+  private stdoutBuf = ''
+
+  constructor(options: AcpClientOptions) {
+    super()
+    this.timeoutMs = Math.max(1_000, options.timeoutMs || 30_000)
+    this.proc = spawn(options.command, options.args || [], {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    this.proc.stdout?.on('data', (chunk: Buffer) => this.handleStdout(chunk.toString()))
+    this.proc.stderr?.on('data', (chunk: Buffer) => {
+      this.emit('stderr', chunk.toString())
+    })
+    this.proc.on('error', (err) => this.failPending(err))
+    this.proc.on('close', () => this.failPending(new Error('ACP process closed')))
+  }
+
+  async request(method: string, params?: unknown): Promise<unknown> {
+    const id = this.nextId++
+    const payload: JsonRpcRequest = { jsonrpc: '2.0', id, method }
+    if (params !== undefined) payload.params = params
+
+    const response = await new Promise<unknown>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id)
+        reject(new Error(`ACP request timed out: ${method}`))
+      }, this.timeoutMs)
+      this.pending.set(id, { resolve, reject, timer })
+      this.proc.stdin?.write(`${JSON.stringify(payload)}\n`)
+    })
+
+    return response
+  }
+
+  notify(method: string, params?: unknown): void {
+    const payload = params === undefined
+      ? { jsonrpc: '2.0', method }
+      : { jsonrpc: '2.0', method, params }
+    this.proc.stdin?.write(`${JSON.stringify(payload)}\n`)
+  }
+
+  close(): void {
+    this.failPending(new Error('ACP client closed'))
+    try { this.proc.kill('SIGTERM') } catch { /* ignore */ }
+  }
+
+  private handleStdout(raw: string): void {
+    this.stdoutBuf += raw
+    const lines = this.stdoutBuf.split('\n')
+    this.stdoutBuf = lines.pop() || ''
+
+    for (const line of lines) {
+      if (!line.trim()) continue
+      try {
+        const message = JSON.parse(line) as JsonRpcResponse
+        if (typeof message.id === 'number' && this.pending.has(message.id)) {
+          const entry = this.pending.get(message.id)!
+          clearTimeout(entry.timer)
+          this.pending.delete(message.id)
+          if (message.error?.message) entry.reject(new Error(message.error.message))
+          else entry.resolve(message.result)
+          continue
+        }
+        this.emit('notification', message)
+      } catch {
+        this.emit('raw', line)
+      }
+    }
+  }
+
+  private failPending(err: Error): void {
+    for (const [, entry] of this.pending) {
+      clearTimeout(entry.timer)
+      entry.reject(err)
+    }
+    this.pending.clear()
+  }
+}

package/src/lib/providers/cli-utils.test.ts

@@ -93,6 +93,10 @@ describe('isCliProvider', () => {
     assert.equal(isCliProvider('codex-cli'), true)
     assert.equal(isCliProvider('opencode-cli'), true)
     assert.equal(isCliProvider('gemini-cli'), true)
+    assert.equal(isCliProvider('copilot-cli'), true)
+    assert.equal(isCliProvider('cursor-cli'), true)
+    assert.equal(isCliProvider('qwen-code-cli'), true)
+    assert.equal(isCliProvider('goose'), true)
   })
 
   it('returns false for non-CLI providers', () => {
@@ -108,11 +112,15 @@ describe('isCliProvider', () => {
 // ---------------------------------------------------------------------------
 
 describe('CLI_PROVIDER_CAPABILITIES', () => {
-  it('has entries for all 4 CLI providers', () => {
+  it('has entries for all supported local CLI-backed providers', () => {
     assert.ok('claude-cli' in CLI_PROVIDER_CAPABILITIES)
     assert.ok('codex-cli' in CLI_PROVIDER_CAPABILITIES)
     assert.ok('opencode-cli' in CLI_PROVIDER_CAPABILITIES)
     assert.ok('gemini-cli' in CLI_PROVIDER_CAPABILITIES)
+    assert.ok('copilot-cli' in CLI_PROVIDER_CAPABILITIES)
+    assert.ok('cursor-cli' in CLI_PROVIDER_CAPABILITIES)
+    assert.ok('qwen-code-cli' in CLI_PROVIDER_CAPABILITIES)
+    assert.ok('goose' in CLI_PROVIDER_CAPABILITIES)
   })
 
   it('each entry is a non-empty string', () => {

package/src/lib/providers/cli-utils.ts

@@ -2,8 +2,7 @@
  * Shared CLI utility module for CLI-based providers and delegation backends.
  *
  * Consolidates environment building, binary discovery, auth probing,
- * abort handling, and config forwarding used by claude-cli, codex-cli,
- * opencode-cli, and gemini-cli providers.
+ * abort handling, and config forwarding used by CLI-backed providers.
  */
 
 import fs from 'fs'
@@ -46,6 +45,24 @@ const KNOWN_BINARY_PATHS: Record<string, string[]> = {
     '/opt/homebrew/bin/copilot',
     path.join(os.homedir(), '.npm-global/bin/copilot'),
   ],
+  'cursor-agent': [
+    path.join(os.homedir(), '.local/bin/cursor-agent'),
+    '/usr/local/bin/cursor-agent',
+    '/opt/homebrew/bin/cursor-agent',
+    path.join(os.homedir(), '.npm-global/bin/cursor-agent'),
+  ],
+  qwen: [
+    path.join(os.homedir(), '.local/bin/qwen'),
+    '/usr/local/bin/qwen',
+    '/opt/homebrew/bin/qwen',
+    path.join(os.homedir(), '.npm-global/bin/qwen'),
+  ],
+  goose: [
+    path.join(os.homedir(), '.local/bin/goose'),
+    '/usr/local/bin/goose',
+    '/opt/homebrew/bin/goose',
+    path.join(os.homedir(), '.cargo/bin/goose'),
+  ],
 }
 
 function getNvmBinaryPaths(name: string): string[] {
@@ -145,11 +162,11 @@ export interface AuthProbeResult {
 }
 
 /**
- * Unified auth check for all 4 CLI tools.
+ * Unified auth check for supported CLI-backed providers.
  */
 export function probeCliAuth(
   binary: string,
-  backend: 'claude' | 'codex' | 'opencode' | 'gemini' | 'copilot',
+  backend: 'claude' | 'codex' | 'opencode' | 'gemini' | 'copilot' | 'cursor' | 'qwen' | 'goose',
   env: NodeJS.ProcessEnv,
   cwd?: string,
 ): AuthProbeResult {
@@ -260,6 +277,71 @@ export function probeCliAuth(
     return { authenticated: true }
   }
 
+  if (backend === 'cursor') {
+    try {
+      const probe = spawnSync(binary, ['status'], {
+        cwd, env, encoding: 'utf-8', timeout: 8_000,
+      })
+      const probeText = `${probe.stdout || ''}\n${probe.stderr || ''}`.toLowerCase()
+      if ((probe.status ?? 1) === 0 || probeText.includes('authenticated') || probeText.includes('logged in')) {
+        return { authenticated: true }
+      }
+    } catch { /* ignore */ }
+
+    const configPaths = [
+      path.join(os.homedir(), '.cursor', 'config.json'),
+      path.join(os.homedir(), '.config', 'cursor', 'config.json'),
+    ]
+    const hasConfig = configPaths.some((p) => fs.existsSync(p))
+    if (!hasConfig) {
+      return {
+        authenticated: false,
+        errorMessage: 'Cursor Agent CLI is not authenticated. Run `cursor-agent login` and try again.',
+      }
+    }
+    return { authenticated: true }
+  }
+
+  if (backend === 'qwen') {
+    const envKeys = ['QWEN_API_KEY', 'DASHSCOPE_API_KEY', 'OPENAI_API_KEY', 'ANTHROPIC_API_KEY', 'GEMINI_API_KEY']
+    if (envKeys.some((key) => typeof env[key] === 'string' && env[key]?.trim())) {
+      return { authenticated: true }
+    }
+    const configPaths = [
+      path.join(os.homedir(), '.qwen', 'settings.json'),
+      path.join(os.homedir(), '.config', 'qwen', 'settings.json'),
+    ]
+    const hasConfig = configPaths.some((p) => fs.existsSync(p))
+    if (!hasConfig) {
+      return {
+        authenticated: false,
+        errorMessage: 'Qwen Code CLI is not configured. Run `qwen`, finish `/auth`, or configure ~/.qwen/settings.json and try again.',
+      }
+    }
+    return { authenticated: true }
+  }
+
+  if (backend === 'goose') {
+    const envKeys = ['GOOSE_API_KEY', 'OPENAI_API_KEY', 'ANTHROPIC_API_KEY', 'GEMINI_API_KEY']
+    if (envKeys.some((key) => typeof env[key] === 'string' && env[key]?.trim())) {
+      return { authenticated: true }
+    }
+    const configPaths = [
+      path.join(os.homedir(), '.config', 'goose', 'config.yaml'),
+      path.join(os.homedir(), '.config', 'goose', 'config.yml'),
+      path.join(os.homedir(), '.goose', 'config.yaml'),
+      path.join(os.homedir(), '.goose', 'config.yml'),
+    ]
+    const hasConfig = configPaths.some((p) => fs.existsSync(p))
+    if (!hasConfig) {
+      return {
+        authenticated: false,
+        errorMessage: 'Goose CLI is not configured. Run `goose configure` and try again.',
+      }
+    }
+    return { authenticated: true }
+  }
+
   return { authenticated: true }
 }
 
@@ -345,6 +427,9 @@ export const CLI_PROVIDER_CAPABILITIES: Record<string, string> = {
   'opencode-cli': 'code analysis, generation across multiple LLM backends',
   'gemini-cli': 'code generation, analysis with Gemini models',
   'copilot-cli': 'code generation, analysis, multi-model support via GitHub Copilot',
+  'cursor-cli': 'full-agent coding workflows, multi-file edits, project-aware code changes',
+  'qwen-code-cli': 'terminal-native coding workflows, code generation, review, and automation',
+  goose: 'agentic coding workflows with extensions, tools, and runtime-managed execution',
 }
 
 /** Check if a provider ID is a CLI-based provider. */