@swarmclawai/swarmclaw 1.5.3 → 1.5.33

package/src/lib/server/chat-execution/chat-turn-preparation.ts

@@ -616,7 +616,11 @@ export async function prepareChatTurn(input: ExecuteChatTurnInput): Promise<Prep
   }
 
   const turnHistory = getMessages(sessionId)
-  const classification = !internal
+  // Skip message classification for local/CLI providers to avoid sending
+  // a blocking LLM call to the same single-request provider (e.g. Ollama)
+  const isLocalProvider = sessionForRun.provider === 'ollama' && sessionForRun.ollamaMode !== 'cloud'
+  const skipClassifier = internal || NON_LANGGRAPH_PROVIDER_IDS.has(sessionForRun.provider) || isLocalProvider
+  const classification = !skipClassifier
     ? await classifyMessage({
         sessionId,
         agentId: session.agentId || null,

package/src/lib/server/chat-execution/chat-turn-tool-routing.ts

@@ -503,6 +503,9 @@ const FORCED_DELEGATION_TOOLS: DelegateTool[] = [
   'delegate_to_codex_cli',
   'delegate_to_opencode_cli',
   'delegate_to_gemini_cli',
+  'delegate_to_copilot_cli',
+  'delegate_to_cursor_cli',
+  'delegate_to_qwen_code_cli',
 ]
 
 export async function runPostLlmToolRouting(

package/src/lib/server/chat-execution/iteration-timers.test.ts

@@ -0,0 +1,84 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import { IterationTimers } from './iteration-timers'
+
+function makeTimers(opts?: { streamIdleStallMs?: number; initialPrefillStallMs?: number }) {
+  const controller = new AbortController()
+  const timers = new IterationTimers(controller, {
+    streamIdleStallMs: opts?.streamIdleStallMs ?? 100,
+    initialPrefillStallMs: opts?.initialPrefillStallMs,
+    requiredToolKickoffMs: 5000,
+    shouldEnforceEarlyRequiredToolKickoff: false,
+  })
+  return { timers, controller }
+}
+
+describe('IterationTimers', () => {
+  it('first arm uses initialPrefillStallMs when provided', async () => {
+    const { timers, controller } = makeTimers({
+      streamIdleStallMs: 50,
+      initialPrefillStallMs: 200,
+    })
+
+    timers.armIdleWatchdog(false)
+
+    // After 50ms (streamIdleStallMs), should NOT have timed out
+    await new Promise((r) => setTimeout(r, 80))
+    assert.equal(timers.idleTimedOut, false, 'should not time out at streamIdleStallMs')
+
+    // After 200ms (initialPrefillStallMs), should have timed out
+    await new Promise((r) => setTimeout(r, 150))
+    assert.equal(timers.idleTimedOut, true, 'should time out at initialPrefillStallMs')
+    assert.equal(controller.signal.aborted, true)
+
+    timers.clearAll()
+  })
+
+  it('second arm uses streamIdleStallMs (not prefill)', async () => {
+    const { timers, controller } = makeTimers({
+      streamIdleStallMs: 50,
+      initialPrefillStallMs: 500,
+    })
+
+    // First arm — uses prefill timeout
+    timers.armIdleWatchdog(false)
+    // Immediately re-arm (simulates receiving a stream token)
+    timers.armIdleWatchdog(false)
+
+    // After 80ms (> streamIdleStallMs), should have timed out
+    await new Promise((r) => setTimeout(r, 80))
+    assert.equal(timers.idleTimedOut, true, 'second arm should use streamIdleStallMs')
+    assert.equal(controller.signal.aborted, true)
+
+    timers.clearAll()
+  })
+
+  it('defaults initialPrefillStallMs to 2x streamIdleStallMs when not set', async () => {
+    const { timers } = makeTimers({
+      streamIdleStallMs: 60,
+      // initialPrefillStallMs not set — should default to 120
+    })
+
+    timers.armIdleWatchdog(false)
+
+    // After 80ms (> 60ms but < 120ms), should NOT have timed out
+    await new Promise((r) => setTimeout(r, 80))
+    assert.equal(timers.idleTimedOut, false, 'should not time out before 2x default')
+
+    // After 60 more ms (total ~140ms, > 120ms), should have timed out
+    await new Promise((r) => setTimeout(r, 60))
+    assert.equal(timers.idleTimedOut, true, 'should time out at 2x default')
+
+    timers.clearAll()
+  })
+
+  it('does not arm when waitingForToolResult is true', () => {
+    const { timers } = makeTimers({ streamIdleStallMs: 10 })
+
+    timers.armIdleWatchdog(true)
+
+    // Timer should not be set
+    assert.equal(timers.idleTimedOut, false)
+    timers.clearAll()
+  })
+})

package/src/lib/server/chat-execution/iteration-timers.ts

@@ -6,6 +6,12 @@
 export interface IterationTimerOpts {
   /** Milliseconds of idle streaming before aborting the iteration. */
   streamIdleStallMs: number
+  /**
+   * Milliseconds before aborting the initial model prefill phase (before any
+   * streaming token arrives). Defaults to `streamIdleStallMs * 2` when unset.
+   * Local models with large prompts may need extra time for the prefill pass.
+   */
+  initialPrefillStallMs?: number
   /** Milliseconds before forcing a required-tool kickoff reminder. */
   requiredToolKickoffMs: number
   /** Whether the early kickoff enforcement is enabled at all. */
@@ -17,6 +23,7 @@ export class IterationTimers {
   private requiredToolKickoffTimer: ReturnType<typeof setTimeout> | null = null
   private _idleTimedOut = false
   private _requiredToolKickoffTimedOut = false
+  private _receivedFirstStreamEvent = false
 
   constructor(
     private readonly iterationController: AbortController,
@@ -26,13 +33,23 @@ export class IterationTimers {
   get idleTimedOut(): boolean { return this._idleTimedOut }
   get requiredToolKickoffTimedOut(): boolean { return this._requiredToolKickoffTimedOut }
 
+  /**
+   * Arm the idle watchdog. On the first call (before any streaming tokens
+   * arrive), use the longer `initialPrefillStallMs` timeout to allow for
+   * model prefill on local providers. Subsequent re-arms use the standard
+   * `streamIdleStallMs` timeout.
+   */
   armIdleWatchdog(waitingForToolResult: boolean): void {
     this.clearIdleWatchdog()
     if (waitingForToolResult || this.iterationController.signal.aborted) return
+    const timeoutMs = this._receivedFirstStreamEvent
+      ? this.opts.streamIdleStallMs
+      : (this.opts.initialPrefillStallMs ?? this.opts.streamIdleStallMs * 2)
+    this._receivedFirstStreamEvent = true
     this.idleTimer = setTimeout(() => {
       this._idleTimedOut = true
       this.iterationController.abort()
-    }, this.opts.streamIdleStallMs)
+    }, timeoutMs)
   }
 
   clearIdleWatchdog(): void {

package/src/lib/server/chat-execution/prompt-sections.ts

@@ -120,6 +120,8 @@ function normalizeRuntimeExtensionId(extensionId: string): string {
   if (normalized === 'delegate_to_codex_cli' || normalized === 'codex_cli') return 'codex_cli'
   if (normalized === 'delegate_to_opencode_cli' || normalized === 'opencode_cli') return 'opencode_cli'
   if (normalized === 'delegate_to_gemini_cli' || normalized === 'gemini_cli') return 'gemini_cli'
+  if (normalized === 'delegate_to_cursor_cli' || normalized === 'cursor_cli') return 'cursor_cli'
+  if (normalized === 'delegate_to_qwen_code_cli' || normalized === 'qwen_code_cli') return 'qwen_code_cli'
   if (['session_info', 'sessions_tool', 'whoami_tool', 'search_history_tool'].includes(normalized)) return 'manage_sessions'
   return canonicalizeExtensionId(normalized)
 }
@@ -189,7 +191,7 @@ export function buildRuntimeOrientationSection(params: {
   const enabledExtensions = canonicalizeEnabledExtensions(params.sessionExtensions)
   const workspaceMarkers = collectWorkspaceMarkers(session.cwd)
   const delegationEnabled = enabledExtensions.some((extensionId) =>
-    ['delegate', 'spawn_subagent', 'claude_code', 'codex_cli', 'opencode_cli', 'gemini_cli'].includes(extensionId),
+    ['delegate', 'spawn_subagent', 'claude_code', 'codex_cli', 'opencode_cli', 'gemini_cli', 'cursor_cli', 'qwen_code_cli'].includes(extensionId),
   )
 
   const lines = [

package/src/lib/server/chat-execution/stream-agent-chat.ts

@@ -929,8 +929,13 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
       if (abortController.signal.aborted) iterationController.abort()
       else abortController.signal.addEventListener('abort', onParentAbort)
 
+      // Local models (e.g. Ollama) need extra time for prompt prefill before
+      // the first streaming token arrives. Use 2x the idle stall timeout for
+      // the initial prefill phase.
+      const isLocalModel = session.provider === 'ollama' && session.ollamaMode !== 'cloud'
       const timers = new IterationTimers(iterationController, {
         streamIdleStallMs: runtime.streamIdleStallMs,
+        initialPrefillStallMs: isLocalModel ? runtime.streamIdleStallMs * 2 : undefined,
         requiredToolKickoffMs: runtime.requiredToolKickoffMs,
         shouldEnforceEarlyRequiredToolKickoff,
       })

package/src/lib/server/chatrooms/chatroom-helpers.ts

@@ -281,6 +281,9 @@ function buildEmptyDelegateResumeIds(): NonNullable<Session['delegateResumeIds']
     codex: null,
     opencode: null,
     gemini: null,
+    copilot: null,
+    cursor: null,
+    qwen: null,
   }
 }
 
@@ -302,6 +305,11 @@ export function buildSyntheticSession(agent: Agent, chatroomId: string): Session
     claudeSessionId: null,
     codexThreadId: null,
     opencodeSessionId: null,
+    geminiSessionId: null,
+    copilotSessionId: null,
+    cursorSessionId: null,
+    qwenSessionId: null,
+    acpSessionId: null,
     delegateResumeIds: buildEmptyDelegateResumeIds(),
     messages: [],
     createdAt: now,
@@ -352,6 +360,11 @@ export function ensureSyntheticSession(agent: Agent, chatroomId: string): Sessio
   }
   if (session.codexThreadId === undefined) session.codexThreadId = null
   if (session.opencodeSessionId === undefined) session.opencodeSessionId = null
+  if (session.geminiSessionId === undefined) session.geminiSessionId = null
+  if (session.copilotSessionId === undefined) session.copilotSessionId = null
+  if (session.cursorSessionId === undefined) session.cursorSessionId = null
+  if (session.qwenSessionId === undefined) session.qwenSessionId = null
+  if (session.acpSessionId === undefined) session.acpSessionId = null
   saveSession(sessionId, session)
   return session
 }

package/src/lib/server/chats/chat-session-service.ts

@@ -46,6 +46,9 @@ function emptyDelegateResumeIds() {
     codex: null,
     opencode: null,
     gemini: null,
+    copilot: null,
+    cursor: null,
+    qwen: null,
   }
 }
 
@@ -124,6 +127,11 @@ export function createChatSession(input: Record<string, unknown>): ServiceResult
     claudeSessionId: null,
     codexThreadId: null,
     opencodeSessionId: null,
+    geminiSessionId: null,
+    copilotSessionId: null,
+    cursorSessionId: null,
+    qwenSessionId: null,
+    acpSessionId: null,
     delegateResumeIds: emptyDelegateResumeIds(),
     messages: Array.isArray(input.messages) ? input.messages : [],
     createdAt: now,
@@ -279,6 +287,11 @@ export function updateChatSession(sessionId: string, updates: Record<string, unk
   if (updates.claudeSessionId !== undefined) session.claudeSessionId = updates.claudeSessionId
   if (updates.codexThreadId !== undefined) session.codexThreadId = updates.codexThreadId
   if (updates.opencodeSessionId !== undefined) session.opencodeSessionId = updates.opencodeSessionId
+  if (updates.geminiSessionId !== undefined) session.geminiSessionId = updates.geminiSessionId
+  if (updates.copilotSessionId !== undefined) session.copilotSessionId = updates.copilotSessionId
+  if (updates.cursorSessionId !== undefined) session.cursorSessionId = updates.cursorSessionId
+  if (updates.qwenSessionId !== undefined) session.qwenSessionId = updates.qwenSessionId
+  if (updates.acpSessionId !== undefined) session.acpSessionId = updates.acpSessionId
   if (updates.delegateResumeIds !== undefined) session.delegateResumeIds = updates.delegateResumeIds
   if (!Array.isArray(session.messages)) session.messages = []
 
@@ -360,6 +373,11 @@ export function clearChatMessages(sessionId: string): boolean {
   session.claudeSessionId = null
   session.codexThreadId = null
   session.opencodeSessionId = null
+  session.geminiSessionId = null
+  session.copilotSessionId = null
+  session.cursorSessionId = null
+  session.qwenSessionId = null
+  session.acpSessionId = null
   session.delegateResumeIds = emptyDelegateResumeIds()
   saveSession(sessionId, session)
   notify('sessions')

package/src/lib/server/connectors/session.ts

@@ -341,11 +341,19 @@ export function resolveDirectSession(params: {
       claudeSessionId: null,
       codexThreadId: null,
       opencodeSessionId: 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,
       },
       messages: [],
       createdAt: Date.now(),

package/src/lib/server/context-manager.ts

@@ -77,6 +77,10 @@ const PROVIDER_DEFAULT_WINDOWS: Record<string, number> = {
   openai: 128_000,
   'codex-cli': 1_047_576,
   'opencode-cli': 200_000,
+  'gemini-cli': 1_048_576,
+  'copilot-cli': 200_000,
+  'cursor-cli': 200_000,
+  'qwen-code-cli': 1_048_576,
   google: 1_048_576,
   deepseek: 64_000,
   groq: 32_768,
@@ -85,6 +89,7 @@ const PROVIDER_DEFAULT_WINDOWS: Record<string, number> = {
   xai: 131_072,
   fireworks: 32_768,
   ollama: 32_768,
+  goose: 200_000,
   openclaw: 128_000,
 }
 

package/src/lib/server/provider-health.ts

@@ -5,7 +5,7 @@ import { log } from './logger'
 
 const TAG = 'provider-health'
 
-type DelegateTool = 'delegate_to_claude_code' | 'delegate_to_codex_cli' | 'delegate_to_opencode_cli' | 'delegate_to_gemini_cli'
+type DelegateTool = 'delegate_to_claude_code' | 'delegate_to_codex_cli' | 'delegate_to_opencode_cli' | 'delegate_to_gemini_cli' | 'delegate_to_copilot_cli' | 'delegate_to_cursor_cli' | 'delegate_to_qwen_code_cli'
 
 interface ProviderHealthState {
   failures: number
@@ -119,6 +119,9 @@ function delegateBinary(delegateTool: DelegateTool): string {
   if (delegateTool === 'delegate_to_claude_code') return 'claude'
   if (delegateTool === 'delegate_to_codex_cli') return 'codex'
   if (delegateTool === 'delegate_to_gemini_cli') return 'gemini'
+  if (delegateTool === 'delegate_to_copilot_cli') return 'copilot'
+  if (delegateTool === 'delegate_to_cursor_cli') return 'cursor-agent'
+  if (delegateTool === 'delegate_to_qwen_code_cli') return 'qwen'
   return 'opencode'
 }
 
@@ -146,6 +149,10 @@ function delegateToolReady(delegateTool: DelegateTool): boolean {
     const probe = spawnSync(binary, ['login', 'status'], { encoding: 'utf-8', timeout: 8000 })
     const probeText = `${probe.stdout || ''}\n${probe.stderr || ''}`.toLowerCase()
     ok = (probe.status ?? 1) === 0 && probeText.includes('logged in')
+  } else if (ok && delegateTool === 'delegate_to_cursor_cli') {
+    const probe = spawnSync(binary, ['status'], { encoding: 'utf-8', timeout: 8000 })
+    const probeText = `${probe.stdout || ''}\n${probe.stderr || ''}`.toLowerCase()
+    ok = (probe.status ?? 1) === 0 || probeText.includes('authenticated') || probeText.includes('logged in')
   }
 
   delegateReadyCache.set(delegateTool, { at: now, ok })
@@ -156,6 +163,9 @@ function delegateProviderId(delegateTool: DelegateTool): string {
   if (delegateTool === 'delegate_to_claude_code') return 'claude-cli'
   if (delegateTool === 'delegate_to_codex_cli') return 'codex-cli'
   if (delegateTool === 'delegate_to_gemini_cli') return 'gemini-cli'
+  if (delegateTool === 'delegate_to_copilot_cli') return 'copilot-cli'
+  if (delegateTool === 'delegate_to_cursor_cli') return 'cursor-cli'
+  if (delegateTool === 'delegate_to_qwen_code_cli') return 'qwen-code-cli'
   return 'opencode-cli'
 }
 
@@ -331,14 +341,14 @@ export async function pingOpenClaw(
 
 /**
  * Ping a provider to check reachability. Returns `{ ok, message }`.
- * Skips CLI-based providers (claude-cli, codex-cli, opencode-cli, gemini-cli) — returns ok.
+ * Skips CLI-based providers — returns ok.
  */
 export async function pingProvider(
   provider: string,
   apiKey: string | undefined,
   endpoint: string | undefined,
 ): Promise<{ ok: boolean; message: string }> {
-  const CLI_PROVIDERS = ['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli']
+  const CLI_PROVIDERS = ['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'cursor-cli', 'qwen-code-cli', 'goose']
   const OPTIONAL_OPENAI_COMPATIBLE_KEY_PROVIDERS = new Set(['hermes'])
   if (CLI_PROVIDERS.includes(provider)) return { ok: true, message: 'CLI provider — skipped.' }
 

package/src/lib/server/provider-model-discovery.test.ts

@@ -228,6 +228,14 @@ test('resolveDescriptor uses Hermes as an OpenAI-compatible provider with option
   assert.equal(descriptor?.optionalApiKey, true)
 })
 
+test('resolveDescriptor disables model discovery for local CLI-backed providers without live model catalogs', () => {
+  for (const providerId of ['copilot-cli', 'cursor-cli', 'qwen-code-cli', 'goose']) {
+    const descriptor = resolveDescriptor({ providerId })
+    assert.equal(descriptor?.supportsDiscovery, false, `${providerId} should not support discovery`)
+    assert.equal(descriptor?.endpoint, undefined, `${providerId} should not expose a discovery endpoint`)
+  }
+})
+
 // ---------------------------------------------------------------------------
 // ttlForDescriptor
 // ---------------------------------------------------------------------------

package/src/lib/server/provider-model-discovery.ts

@@ -55,7 +55,7 @@ function toOpenAiCompatibleEndpoint(raw: string | null | undefined, fallback: st
 }
 
 function supportsBuiltInModelDiscovery(providerId: string): boolean {
-  return !['claude-cli', 'codex-cli', 'opencode-cli'].includes(providerId)
+  return !['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'cursor-cli', 'qwen-code-cli', 'goose'].includes(providerId)
 }
 
 function normalizeGoogleModelsEndpoint(raw: string | null | undefined): string {

package/src/lib/server/runtime/daemon-state/core.ts

@@ -704,7 +704,7 @@ async function runProviderHealthChecks() {
     if (!agent?.id || typeof agent.id !== 'string') continue
     if (shouldSuppressSyntheticAgentHealthAlert(agent.id)) continue
     const provider = typeof agent.provider === 'string' ? agent.provider : ''
-    if (!provider || ['claude-cli', 'codex-cli', 'opencode-cli'].includes(provider)) continue
+    if (!provider || ['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'cursor-cli', 'qwen-code-cli', 'goose'].includes(provider)) continue
 
     const credentialId = typeof agent.credentialId === 'string' ? agent.credentialId : ''
     const apiEndpoint = typeof agent.apiEndpoint === 'string' ? agent.apiEndpoint : ''
@@ -1508,7 +1508,7 @@ export function getDaemonHealthSummary(): {
   for (const agent of agentEntries) {
     if (!agent?.id || typeof agent.id !== 'string') continue
     const provider = typeof agent.provider === 'string' ? agent.provider : ''
-    if (!provider || ['claude-cli', 'codex-cli', 'opencode-cli'].includes(provider)) continue
+    if (!provider || ['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'cursor-cli', 'qwen-code-cli', 'goose'].includes(provider)) continue
     const credentialId = typeof agent.credentialId === 'string' ? agent.credentialId : ''
     const apiEndpoint = typeof agent.apiEndpoint === 'string' ? agent.apiEndpoint : ''
     providerKeys.add(`${provider}:${credentialId || 'no-cred'}:${apiEndpoint}`)

package/src/lib/server/runtime/queue/core.ts

@@ -128,6 +128,8 @@ export interface TaskResumeState {
   claudeSessionId: string | null
   codexThreadId: string | null
   opencodeSessionId: string | null
+  cursorSessionId?: string | null
+  qwenSessionId?: string | null
   delegateResumeIds: NonNullable<Session['delegateResumeIds']>
 }
 
@@ -149,6 +151,9 @@ function buildEmptyDelegateResumeIds(): NonNullable<Session['delegateResumeIds']
     codex: null,
     opencode: null,
     gemini: null,
+    copilot: null,
+    cursor: null,
+    qwen: null,
   }
 }
 
@@ -166,6 +171,8 @@ function hasResumeState(state: TaskResumeState | null | undefined): state is Tas
     || state.delegateResumeIds.codex
     || state.delegateResumeIds.opencode
     || state.delegateResumeIds.gemini
+    || state.delegateResumeIds.cursor
+    || state.delegateResumeIds.qwen
   )
 }
 
@@ -182,16 +189,22 @@ export function extractTaskResumeState(task: Partial<BoardTask> | null | undefin
     || (legacyProvider === 'opencode-cli' ? legacyResumeId : null)
   const geminiSessionId = normalizeResumeHandle(task.geminiResumeId)
     || (legacyProvider === 'gemini-cli' ? legacyResumeId : null)
+  const cursorSessionId = legacyProvider === 'cursor-cli' ? legacyResumeId : null
+  const qwenSessionId = legacyProvider === 'qwen-code-cli' ? legacyResumeId : null
 
   const resume = {
     claudeSessionId,
     codexThreadId,
     opencodeSessionId,
+    cursorSessionId,
+    qwenSessionId,
     delegateResumeIds: {
       claudeCode: claudeSessionId,
       codex: codexThreadId,
       opencode: opencodeSessionId,
       gemini: geminiSessionId,
+      cursor: cursorSessionId,
+      qwen: qwenSessionId,
     },
   } satisfies TaskResumeState
 
@@ -204,6 +217,8 @@ export function extractSessionResumeState(session: Partial<Session> | null | und
   const claudeSessionId = normalizeResumeHandle(session.claudeSessionId)
   const codexThreadId = normalizeResumeHandle(session.codexThreadId)
   const opencodeSessionId = normalizeResumeHandle(session.opencodeSessionId)
+  const cursorSessionId = normalizeResumeHandle(session.cursorSessionId)
+  const qwenSessionId = normalizeResumeHandle(session.qwenSessionId)
   const delegateResumeIds = session.delegateResumeIds && typeof session.delegateResumeIds === 'object'
     ? { ...buildEmptyDelegateResumeIds(), ...session.delegateResumeIds }
     : buildEmptyDelegateResumeIds()
@@ -212,11 +227,16 @@ export function extractSessionResumeState(session: Partial<Session> | null | und
     claudeSessionId,
     codexThreadId,
     opencodeSessionId,
+    cursorSessionId,
+    qwenSessionId,
     delegateResumeIds: {
       claudeCode: normalizeResumeHandle(delegateResumeIds.claudeCode) || claudeSessionId,
       codex: normalizeResumeHandle(delegateResumeIds.codex) || codexThreadId,
       opencode: normalizeResumeHandle(delegateResumeIds.opencode) || opencodeSessionId,
       gemini: normalizeResumeHandle(delegateResumeIds.gemini),
+      cursor: normalizeResumeHandle(delegateResumeIds.cursor) || cursorSessionId,
+      qwen: normalizeResumeHandle(delegateResumeIds.qwen) || qwenSessionId,
+      copilot: normalizeResumeHandle(delegateResumeIds.copilot),
     },
   } satisfies TaskResumeState
 
@@ -263,10 +283,12 @@ export function applyTaskResumeStateToSession(session: Session, resume: TaskResu
   if (!hasResumeState(resume)) return false
 
   let changed = false
-  const directFields: Array<['claudeSessionId' | 'codexThreadId' | 'opencodeSessionId', string | null]> = [
+  const directFields: Array<['claudeSessionId' | 'codexThreadId' | 'opencodeSessionId' | 'cursorSessionId' | 'qwenSessionId', string | null]> = [
     ['claudeSessionId', resume.claudeSessionId],
     ['codexThreadId', resume.codexThreadId],
     ['opencodeSessionId', resume.opencodeSessionId],
+    ['cursorSessionId', resume.cursorSessionId ?? null],
+    ['qwenSessionId', resume.qwenSessionId ?? null],
   ]
   for (const [key, value] of directFields) {
     if (!value || session[key] === value) continue
@@ -1444,27 +1466,31 @@ export async function processNext() {
             const execSession = execSessions[sessionId] as unknown as Record<string, unknown> | undefined
             if (execSession) {
               const delegateIds = execSession.delegateResumeIds as
-                | { claudeCode?: string | null; codex?: string | null; opencode?: string | null; gemini?: string | null }
+                | { claudeCode?: string | null; codex?: string | null; opencode?: string | null; gemini?: string | null; cursor?: string | null; qwen?: string | null }
                 | undefined
               // Store each CLI resume ID separately
               const claudeId = (execSession.claudeSessionId as string) || delegateIds?.claudeCode || null
               const codexId = (execSession.codexThreadId as string) || delegateIds?.codex || null
               const opencodeId = (execSession.opencodeSessionId as string) || delegateIds?.opencode || null
               const geminiId = delegateIds?.gemini || null
+              const cursorId = (execSession.cursorSessionId as string) || delegateIds?.cursor || null
+              const qwenId = (execSession.qwenSessionId as string) || delegateIds?.qwen || null
               if (claudeId) t2[taskId].claudeResumeId = claudeId
               if (codexId) t2[taskId].codexResumeId = codexId
               if (opencodeId) t2[taskId].opencodeResumeId = opencodeId
               if (geminiId) t2[taskId].geminiResumeId = geminiId
               // Keep backward-compat single field (first available)
-              const primaryId = claudeId || codexId || opencodeId || geminiId
+              const primaryId = claudeId || codexId || opencodeId || geminiId || cursorId || qwenId
               if (primaryId) {
                 t2[taskId].cliResumeId = primaryId
                 if (claudeId) t2[taskId].cliProvider = 'claude-cli'
                 else if (codexId) t2[taskId].cliProvider = 'codex-cli'
                 else if (opencodeId) t2[taskId].cliProvider = 'opencode-cli'
                 else if (geminiId) t2[taskId].cliProvider = 'gemini-cli'
+                else if (cursorId) t2[taskId].cliProvider = 'cursor-cli'
+                else if (qwenId) t2[taskId].cliProvider = 'qwen-code-cli'
               }
-              log.info(TAG, `[queue] CLI resume IDs for task ${taskId}: claude=${claudeId}, codex=${codexId}, opencode=${opencodeId}, gemini=${geminiId}`)
+              log.info(TAG, `[queue] CLI resume IDs for task ${taskId}: claude=${claudeId}, codex=${codexId}, opencode=${opencodeId}, gemini=${geminiId}, cursor=${cursorId}, qwen=${qwenId}`)
             }
           } catch (e) {
             log.warn(TAG, `[queue] Failed to extract CLI resume IDs for task ${taskId}:`, e)

package/src/lib/server/runtime/session-run-manager/enqueue.ts

@@ -44,7 +44,7 @@ type RepairSessionRunQueueFn = (
 
 type DrainExecutionFn = (executionKey: string) => Promise<void>
 
-const LONG_TOOL_NAMES: ReadonlySet<string> = new Set(['claude_code', 'codex_cli', 'opencode_cli'])
+const LONG_TOOL_NAMES: ReadonlySet<string> = new Set(['claude_code', 'codex_cli', 'opencode_cli', 'gemini_cli', 'cursor_cli', 'qwen_code_cli'])
 
 type SessionToolConfig = {
   tools?: string[] | null

package/src/lib/server/session-reset-policy.test.ts

@@ -102,6 +102,22 @@ describe('session-reset-policy', () => {
       })
       assert.equal(policy.idleTimeoutSec, 1800)
     })
+
+    it('isolated mode is preserved and not replaced by fallback', () => {
+      const policy = mod.resolveSessionResetPolicy({
+        resetType: 'direct',
+        session: { sessionResetMode: 'isolated' } as never,
+      })
+      assert.equal(policy.mode, 'isolated')
+    })
+
+    it('isolated mode from agent config is preserved', () => {
+      const policy = mod.resolveSessionResetPolicy({
+        resetType: 'direct',
+        agent: { sessionResetMode: 'isolated' } as never,
+      })
+      assert.equal(policy.mode, 'isolated')
+    })
   })
 
   // ---- evaluateSessionFreshness ----

package/src/lib/server/session-reset-policy.ts

@@ -67,7 +67,7 @@ function parseIntBounded(value: unknown, min: number, max: number): number | nul
 
 function normalizeMode(raw: unknown, fallback: SessionResetMode): SessionResetMode {
   const value = typeof raw === 'string' ? raw.trim().toLowerCase() : ''
-  return value === 'daily' ? 'daily' : value === 'idle' ? 'idle' : fallback
+  return value === 'daily' ? 'daily' : value === 'idle' ? 'idle' : value === 'isolated' ? 'isolated' : fallback
 }
 
 function normalizeTimeHHMM(raw: unknown): string | null {
@@ -282,11 +282,19 @@ export function resetSessionRuntime(
   session.claudeSessionId = null
   session.codexThreadId = null
   session.opencodeSessionId = null
+  session.geminiSessionId = null
+  session.copilotSessionId = null
+  session.cursorSessionId = null
+  session.qwenSessionId = null
+  session.acpSessionId = null
   session.delegateResumeIds = {
     claudeCode: null,
     codex: null,
     opencode: null,
     gemini: null,
+    copilot: null,
+    cursor: null,
+    qwen: null,
   }
   session.createdAt = now
   session.lastActiveAt = now

package/src/lib/server/session-tools/context.ts

@@ -86,8 +86,8 @@ export interface ToolBuildContext {
   commandTimeoutMs: number
   claudeTimeoutMs: number
   cliProcessTimeoutMs: number
-  persistDelegateResumeId: (key: 'claudeCode' | 'codex' | 'opencode' | 'gemini', id: string | null | undefined) => void
-  readStoredDelegateResumeId: (key: 'claudeCode' | 'codex' | 'opencode' | 'gemini') => string | null
+  persistDelegateResumeId: (key: 'claudeCode' | 'codex' | 'opencode' | 'gemini' | 'copilot' | 'cursor' | 'qwen', id: string | null | undefined) => void
+  readStoredDelegateResumeId: (key: 'claudeCode' | 'codex' | 'opencode' | 'gemini' | 'copilot' | 'cursor' | 'qwen') => string | null
   resolveCurrentSession: () => any | null
   activeExtensions: string[]
   /** Agent's file access policy — passed to shell for command-level enforcement */