@swarmclawai/swarmclaw 0.6.7 → 0.7.0

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

@@ -5,6 +5,7 @@ const MAX_LOG_CHARS = 200_000
 const DEFAULT_BACKGROUND_YIELD_MS = 10_000
 const DEFAULT_TIMEOUT_MS = 30 * 60_000
 const DEFAULT_TTL_MS = 30 * 60_000
+const BACKGROUND_STARTUP_GRACE_MS = 500
 
 export type ProcessStatus = 'running' | 'exited' | 'killed' | 'failed' | 'timeout'
 
@@ -170,6 +171,23 @@ export async function startManagedProcess(opts: StartProcessOptions): Promise<St
   state.exitWaiters.set(id, exitPromise)
 
   if (opts.background) {
+    // Give background processes a brief grace window so immediate crashes
+    // (e.g., bind/permission errors) are surfaced instead of misreported as running.
+    const startupWaitMs = Math.min(
+      Math.max(100, BACKGROUND_STARTUP_GRACE_MS),
+      Math.max(200, timeoutMs),
+    )
+    await wait(startupWaitMs)
+    const rec = state.records.get(id)
+    if (rec && rec.status !== 'running') {
+      return {
+        status: 'completed',
+        processId: id,
+        output: rec.log,
+        exitCode: rec.exitCode,
+        signal: rec.signal,
+      }
+    }
     return {
       status: 'running',
       processId: id,

package/src/lib/server/query-expansion.ts

@@ -0,0 +1,57 @@
+import { loadAgents, loadSettings, loadCredentials, decryptKey } from './storage'
+import { getProvider } from '../providers'
+
+/**
+ * Expands a single user query into multiple semantic search variants
+ * to improve vector database recall (OpenClaw-style).
+ */
+export async function expandQuery(query: string): Promise<string[]> {
+  const agents = loadAgents()
+  const settings = loadSettings()
+  const defaultAgent = agents[settings.defaultAgentId]
+  if (!defaultAgent) return [query]
+
+  const providerEntry = getProvider(defaultAgent.provider)
+  if (!providerEntry?.handler?.streamChat) return [query]
+
+  const creds = loadCredentials()
+  const cred = creds[defaultAgent.credentialId || '']
+  const apiKey = cred ? decryptKey(cred.encryptedKey) : undefined
+
+  const systemPrompt = `You are a search query expansion assistant. 
+Given a user's question, generate 3 different semantic search queries that would help find the answer in a vector database.
+Use different vocabulary and focus on different aspects of the intent.
+Format your response as a simple newline-separated list. No numbering, no bullets, no introduction.`
+
+  let expanded = ''
+  try {
+    await providerEntry.handler.streamChat({
+      session: { id: 'expansion', messages: [], model: defaultAgent.model, provider: defaultAgent.provider },
+      message: query,
+      apiKey,
+      systemPrompt,
+      write: (raw: string) => {
+        const lines = raw.split('\n').filter(Boolean)
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue
+          try {
+            const ev = JSON.parse(line.slice(6))
+            if (ev.t === 'd' && ev.text) expanded += ev.text
+          } catch { /* skip */ }
+        }
+      },
+      active: new Map(),
+      loadHistory: () => [],
+    })
+
+    const variants = expanded.split('\n').map(l => l.trim()).filter(Boolean)
+    if (variants.length > 0) {
+      // Return original query + variants
+      return [query, ...variants.slice(0, 3)]
+    }
+  } catch (err) {
+    console.error('[query-expansion] Failed to expand query:', err)
+  }
+
+  return [query]
+}

package/src/lib/server/queue.ts

@@ -13,6 +13,7 @@ import { extractTaskResult, formatResultBody } from './task-result'
 import { getCheckpointSaver } from './langgraph-checkpoint'
 import { isProtectedMainSession } from './main-session'
 import { cascadeUnblock } from './dag-validation'
+import { performGuardianRollback } from './guardian'
 import type { Agent, BoardTask, Connector, Message } from '@/types'
 
 // HMR-safe: pin processing flag to globalThis so hot reloads don't reset it
@@ -22,12 +23,14 @@ interface SessionMessageLike {
   role?: string
   text?: string
   time?: number
-  kind?: 'chat' | 'heartbeat' | 'system' | 'context-clear'
+  kind?: string
   source?: {
     connectorId?: string
     channelId?: string
   }
   toolEvents?: Array<{ name?: string; output?: string }>
+  streaming?: boolean
+  imageUrl?: string
 }
 
 interface SessionLike {
@@ -96,6 +99,181 @@ function applyTaskPolicyDefaults(task: BoardTask): void {
   if (task.deadLetteredAt === undefined) task.deadLetteredAt = null
 }
 
+const DEV_TASK_HINT = /\b(dev(?:\s+server)?|start(?:ing)?\s+(?:the\s+)?server|run(?:ning)?\s+(?:the\s+)?(?:app|project|site)|serve|localhost|http\s+server|web\s+server|npm\b|pnpm\b|yarn\b|bun\b|vite|next(?:\.js)?|react|build|compile)\b/i
+const TASK_CWD_NOISE_DIRS = new Set([
+  'uploads',
+  'data',
+  'projects',
+  'tasks',
+  '.swarm-data-test',
+  '.git',
+  '.next',
+  'node_modules',
+])
+const PROJECT_MARKER_FILES = ['package.json', 'pyproject.toml', 'Cargo.toml', 'go.mod', '.git']
+const SOURCE_MARKER_DIRS = ['src', 'app', 'public', 'pages']
+const WORKSPACE_PROJECTS_DIR = path.join(WORKSPACE_DIR, 'projects')
+
+interface WorkspaceDirCandidate {
+  dir: string
+  name: string
+  hasProjectMarker: boolean
+  hasSourceMarker: boolean
+}
+
+let workspaceDirCache: { expiresAt: number; candidates: WorkspaceDirCandidate[] } | null = null
+
+function isExistingDirectory(dirPath: string): boolean {
+  try {
+    return fs.statSync(dirPath).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+function isWithinDirectory(parent: string, child: string): boolean {
+  const parentResolved = path.resolve(parent)
+  const childResolved = path.resolve(child)
+  const rel = path.relative(parentResolved, childResolved)
+  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel))
+}
+
+function normalizeForMatch(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim()
+}
+
+function hasAnyMarker(dirPath: string, markers: string[]): boolean {
+  return markers.some((marker) => fs.existsSync(path.join(dirPath, marker)))
+}
+
+function normalizeDirCandidate(raw: unknown, baseDir: string): string | null {
+  if (typeof raw !== 'string') return null
+  const trimmed = raw.trim()
+  if (!trimmed) return null
+  const homeDir = process.env.HOME || ''
+  const expanded = trimmed === '~'
+    ? homeDir
+    : trimmed.startsWith('~/')
+      ? path.join(homeDir, trimmed.slice(2))
+      : trimmed
+  const resolved = path.isAbsolute(expanded) ? path.resolve(expanded) : path.resolve(baseDir, expanded)
+  return isExistingDirectory(resolved) ? resolved : null
+}
+
+function looksLikeDevTask(task: Pick<BoardTask, 'title' | 'description'>): boolean {
+  const text = `${task.title || ''} ${task.description || ''}`.trim()
+  return DEV_TASK_HINT.test(text)
+}
+
+function listWorkspaceDirCandidates(): WorkspaceDirCandidate[] {
+  const now = Date.now()
+  if (workspaceDirCache && workspaceDirCache.expiresAt > now) return workspaceDirCache.candidates
+
+  const candidates: WorkspaceDirCandidate[] = []
+  const seen = new Set<string>()
+  const roots = [WORKSPACE_DIR, WORKSPACE_PROJECTS_DIR]
+
+  for (const root of roots) {
+    if (!isExistingDirectory(root)) continue
+    let entries: fs.Dirent[] = []
+    try {
+      entries = fs.readdirSync(root, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+      const name = entry.name
+      if (!name || name.startsWith('.')) continue
+      if (TASK_CWD_NOISE_DIRS.has(name)) continue
+      const dir = path.join(root, name)
+      const key = path.resolve(dir)
+      if (seen.has(key)) continue
+      seen.add(key)
+      candidates.push({
+        dir: key,
+        name,
+        hasProjectMarker: hasAnyMarker(key, PROJECT_MARKER_FILES),
+        hasSourceMarker: hasAnyMarker(key, SOURCE_MARKER_DIRS),
+      })
+    }
+  }
+
+  candidates.sort((a, b) => a.name.localeCompare(b.name))
+  workspaceDirCache = {
+    expiresAt: now + 15_000,
+    candidates,
+  }
+  return candidates
+}
+
+function inferWorkspaceProjectCwd(task: Pick<BoardTask, 'title' | 'description' | 'file'>): string | null {
+  const candidates = listWorkspaceDirCandidates()
+  if (!candidates.length) return null
+
+  const taskText = normalizeForMatch(`${task.title || ''} ${task.description || ''} ${task.file || ''}`)
+  const devTask = looksLikeDevTask(task)
+  const markerCandidates = candidates.filter((candidate) => candidate.hasProjectMarker)
+
+  let best: { dir: string; score: number } | null = null
+  for (const candidate of candidates) {
+    const nameNorm = normalizeForMatch(candidate.name)
+    if (!nameNorm) continue
+    let score = 0
+    if (taskText.includes(nameNorm)) score += 8
+    for (const token of nameNorm.split(' ')) {
+      if (token.length < 3) continue
+      if (taskText.includes(token)) score += 1
+    }
+    if (candidate.hasProjectMarker) score += devTask ? 3 : 1
+    if (candidate.hasSourceMarker) score += 1
+    if (!best || score > best.score) best = { dir: candidate.dir, score }
+  }
+
+  if (best && best.score >= 4) return best.dir
+  if (devTask && markerCandidates.length === 1) return markerCandidates[0].dir
+  return null
+}
+
+function resolveTaskExecutionCwd(task: ScheduleTaskMeta, sessions: Record<string, SessionLike>): string {
+  const workspaceRoot = path.resolve(WORKSPACE_DIR)
+
+  const explicitCwd = normalizeDirCandidate(task.cwd, workspaceRoot)
+  if (explicitCwd) return explicitCwd
+
+  const projectId = typeof task.projectId === 'string' ? task.projectId.trim() : ''
+  if (projectId) {
+    const projectDir = path.join(WORKSPACE_PROJECTS_DIR, projectId)
+    if (isExistingDirectory(projectDir)) return projectDir
+  }
+
+  const fileRef = typeof task.file === 'string' ? task.file.trim() : ''
+  if (fileRef) {
+    const filePath = path.isAbsolute(fileRef) ? fileRef : path.resolve(workspaceRoot, fileRef)
+    const fileDir = isExistingDirectory(filePath) ? filePath : path.dirname(filePath)
+    if (isExistingDirectory(fileDir) && isWithinDirectory(workspaceRoot, fileDir)) return fileDir
+  }
+
+  const inferredCwd = inferWorkspaceProjectCwd(task)
+  if (inferredCwd) return inferredCwd
+
+  const sourceSessionId = typeof task.createdInSessionId === 'string' ? task.createdInSessionId.trim() : ''
+  const sourceSessionCwd = sourceSessionId
+    ? normalizeDirCandidate(sessions[sourceSessionId]?.cwd, workspaceRoot)
+    : null
+  if (sourceSessionCwd && path.resolve(sourceSessionCwd) !== workspaceRoot) return sourceSessionCwd
+
+  const runSessionId = typeof task.sessionId === 'string' ? task.sessionId.trim() : ''
+  const runSessionCwd = runSessionId
+    ? normalizeDirCandidate(sessions[runSessionId]?.cwd, workspaceRoot)
+    : null
+  if (runSessionCwd && path.resolve(runSessionCwd) !== workspaceRoot) return runSessionCwd
+
+  const sandboxDir = path.join(workspaceRoot, 'tasks', task.id)
+  fs.mkdirSync(sandboxDir, { recursive: true })
+  return sandboxDir
+}
+
 function queueContains(queue: string[], id: string): boolean {
   return queue.includes(id)
 }
@@ -315,12 +493,34 @@ export function resolveTaskOriginConnectorFollowupTarget(params: {
 // Task result extraction now uses Zod-validated structured data
 // from ./task-result.ts (extractTaskResult, formatResultBody)
 
+/** Check if a task result looks incomplete (agent stopped mid-objective). */
+function looksIncomplete(text: string): boolean {
+  if (!text) return false
+  const trimmed = text.trim()
+  // Ends with ellipsis or continuation signal
+  if (trimmed.endsWith('...') || trimmed.endsWith('…')) return true
+  // Ends with a step/phase header (agent was listing next steps)
+  if (/(?:^|\n)#{1,3}\s+(?:Step|Phase|Next)\s+\d/i.test(trimmed.slice(-200))) return true
+  // Contains forward-looking language at the end
+  const lastChunk = trimmed.slice(-300).toLowerCase()
+  if (/\b(?:next i(?:'ll| will)|now i(?:'ll| will)|let me (?:now|next)|moving on to|proceeding to)\b/.test(lastChunk)) return true
+  return false
+}
+
 async function executeTaskRun(
   task: BoardTask,
   agent: Agent,
   sessionId: string,
 ): Promise<string> {
-  const prompt = task.description || task.title
+  const basePrompt = task.description || task.title
+  const prompt = [
+    basePrompt,
+    '',
+    'Completion requirements:',
+    '- Execute the task before replying; do not reply with only a plan.',
+    '- Include concrete evidence in your final summary: changed file paths, commands run, and verification results.',
+    '- If blocked, state the blocker explicitly and what input or permission is missing.',
+  ].join('\n')
   if (agent?.isOrchestrator) {
     return executeOrchestrator(agent, prompt, sessionId, task.id)
   }
@@ -330,11 +530,24 @@ async function executeTaskRun(
     message: prompt,
     internal: false,
     source: 'task',
+    runId: task.id,
   })
-  const text = typeof run.text === 'string' ? run.text.trim() : ''
-  if (text) return text
-  if (run.error) return `Error: ${run.error}`
-  return ''
+  let text = typeof run.text === 'string' ? run.text.trim() : ''
+  if (run.error) return text ? text : `Error: ${run.error}`
+
+  // Auto-continue if the result looks incomplete
+  if (text && looksIncomplete(text)) {
+    const followUp = await executeSessionChatTurn({
+      sessionId,
+      message: 'Continue and complete the remaining steps. Provide a final summary when done.',
+      internal: false,
+      source: 'task',
+    })
+    const contText = typeof followUp.text === 'string' ? followUp.text.trim() : ''
+    if (contText) text = contText
+  }
+
+  return text
 }
 
 function notifyMainChatScheduleResult(task: BoardTask): void {
@@ -377,8 +590,8 @@ function notifyMainChatScheduleResult(task: BoardTask): void {
   const now = Date.now()
   let changed = false
 
-  const buildMsg = (): Message => {
-    const msg: Message = { role: 'assistant', text: body, time: now, kind: 'system' }
+  const buildMsg = (): SessionMessageLike => {
+    const msg: SessionMessageLike = { role: 'assistant', text: body, time: now, kind: 'system' }
     if (firstImage) msg.imageUrl = firstImage.url
     return msg
   }
@@ -701,6 +914,7 @@ export function enqueueTask(taskId: string) {
 export function validateCompletedTasksQueue() {
   const tasks = loadTasks()
   const sessions = loadSessions()
+  const settings = loadSettings()
   const now = Date.now()
   let checked = 0
   let demoted = 0
@@ -717,7 +931,7 @@ export function validateCompletedTasksQueue() {
       tasksDirty = true
     }
 
-    const validation = validateTaskCompletion(task, { report })
+    const validation = validateTaskCompletion(task, { report, settings })
     const prevValidation = task.validation || null
     const validationChanged = !prevValidation
       || prevValidation.ok !== validation.ok
@@ -802,6 +1016,32 @@ function scheduleRetryOrDeadLetter(task: BoardTask, reason: string): 'retry' | '
     text: `Task moved to dead-letter after ${task.attempts}/${task.maxAttempts} attempts.\n\nReason: ${reason}`,
     createdAt: now,
   })
+
+  // Guardian Auto-Rollback
+  const agents = loadAgents()
+  const agent = task.agentId ? agents[task.agentId] : null
+  if (agent?.autoRecovery) {
+    const cwd = task.projectId 
+      ? path.join(WORKSPACE_DIR, 'projects', task.projectId) 
+      : WORKSPACE_DIR
+    const rollback = performGuardianRollback(cwd)
+    if (rollback.ok) {
+      task.comments.push({
+        id: genId(),
+        author: 'Guardian',
+        text: `Auto-recovery triggered: Workspace successfully rolled back to last clean state.`,
+        createdAt: now + 1,
+      })
+    } else {
+      task.comments.push({
+        id: genId(),
+        author: 'Guardian',
+        text: `Auto-recovery failed: ${rollback.reason}`,
+        createdAt: now + 1,
+      })
+    }
+  }
+
   return 'dead_lettered'
 }
 
@@ -903,7 +1143,9 @@ export async function processNext() {
       task.validation = null
       task.updatedAt = Date.now()
 
-      const taskCwd = task.cwd || WORKSPACE_DIR
+      const sessionsForCwd = loadSessions() as Record<string, SessionLike>
+      const taskCwd = resolveTaskExecutionCwd(task as ScheduleTaskMeta, sessionsForCwd)
+      task.cwd = taskCwd
       let sessionId = ''
       const scheduleTask = task as ScheduleTaskMeta
       const isScheduleTask = scheduleTask.sourceType === 'schedule'
@@ -1002,6 +1244,7 @@ export async function processNext() {
       try {
         const result = await executeTaskRun(task, agent, sessionId)
         const t2 = loadTasks()
+        const settings = loadSettings()
         if (t2[taskId]) {
           applyTaskPolicyDefaults(t2[taskId])
           // Structured extraction: Zod-validated result with typed artifacts
@@ -1018,7 +1261,7 @@ export async function processNext() {
           t2[taskId].updatedAt = Date.now()
           const report = ensureTaskCompletionReport(t2[taskId])
           if (report?.relativePath) t2[taskId].completionReportPath = report.relativePath
-          const validation = validateTaskCompletion(t2[taskId], { report })
+          const validation = validateTaskCompletion(t2[taskId], { report, settings })
           t2[taskId].validation = validation
 
           const now = Date.now()
@@ -1233,6 +1476,29 @@ export function recoverStalledRunningTasks(): { recovered: number; deadLettered:
 
   for (const task of Object.values(tasks) as BoardTask[]) {
     if (task.status !== 'running') continue
+    if (!task.startedAt) {
+      const recoveredAt = Date.now()
+      task.status = 'queued'
+      task.queuedAt = task.queuedAt || recoveredAt
+      task.retryScheduledAt = null
+      task.updatedAt = recoveredAt
+      task.error = 'Recovered inconsistent running state (missing startedAt); requeued.'
+      if (!task.comments) task.comments = []
+      task.comments.push({
+        id: genId(),
+        author: 'System',
+        text: 'Recovered inconsistent running state (missing startedAt). Task requeued.',
+        createdAt: recoveredAt,
+      })
+      pushQueueUnique(queue, task.id)
+      recovered++
+      changed = true
+      pushMainLoopEventToMainSessions({
+        type: 'task_stall_recovered',
+        text: `Recovered inconsistent running task "${task.title}" (${task.id}) and requeued it.`,
+      })
+      continue
+    }
     const since = Math.max(task.updatedAt || 0, task.startedAt || 0)
     if (!since || (now - since) < staleMs) continue
 
@@ -1259,6 +1525,9 @@ export function recoverStalledRunningTasks(): { recovered: number; deadLettered:
   if (changed) {
     saveTasks(tasks)
     saveQueue(queue)
+    if (recovered > 0) {
+      setTimeout(() => processNext(), 250)
+    }
   }
 
   return { recovered, deadLettered }

package/src/lib/server/runtime-settings.ts

@@ -3,6 +3,7 @@ import {
   DEFAULT_AGENT_LOOP_RECURSION_LIMIT,
   DEFAULT_CLAUDE_CODE_TIMEOUT_SEC,
   DEFAULT_CLI_PROCESS_TIMEOUT_SEC,
+  DEFAULT_DELEGATION_MAX_DEPTH,
   DEFAULT_LEGACY_ORCHESTRATOR_MAX_TURNS,
   DEFAULT_LOOP_MODE,
   DEFAULT_ONGOING_LOOP_MAX_ITERATIONS,
@@ -17,6 +18,7 @@ export interface RuntimeSettings {
   agentLoopRecursionLimit: number
   orchestratorLoopRecursionLimit: number
   legacyOrchestratorMaxTurns: number
+  delegationMaxDepth: number
   ongoingLoopMaxIterations: number
   ongoingLoopMaxRuntimeMs: number | null
   shellCommandTimeoutMs: number
@@ -61,6 +63,12 @@ export function loadRuntimeSettings(): RuntimeSettings {
     1,
     300,
   )
+  const delegationMaxDepth = parseIntSetting(
+    settings.delegationMaxDepth,
+    DEFAULT_DELEGATION_MAX_DEPTH,
+    1,
+    12,
+  )
   const ongoingLoopMaxIterations = parseIntSetting(
     settings.ongoingLoopMaxIterations,
     DEFAULT_ONGOING_LOOP_MAX_ITERATIONS,
@@ -98,6 +106,7 @@ export function loadRuntimeSettings(): RuntimeSettings {
     agentLoopRecursionLimit,
     orchestratorLoopRecursionLimit,
     legacyOrchestratorMaxTurns,
+    delegationMaxDepth,
     ongoingLoopMaxIterations,
     ongoingLoopMaxRuntimeMs: ongoingLoopMaxRuntimeMinutes > 0 ? ongoingLoopMaxRuntimeMinutes * 60_000 : null,
     shellCommandTimeoutMs: shellCommandTimeoutSec * 1000,

package/src/lib/server/session-run-manager.test.ts

@@ -0,0 +1,23 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { isMainMissionSession } from './session-run-manager'
+
+describe('isMainMissionSession', () => {
+  it('accepts explicit main sessions', () => {
+    assert.equal(isMainMissionSession({ id: 'main-user', name: '__main__' }), true)
+  })
+
+  it('rejects human agent-thread sessions', () => {
+    assert.equal(
+      isMainMissionSession({ id: 'agent-thread-agent_coder-123', name: 'agent-thread:agent_coder', sessionType: 'human' }),
+      false,
+    )
+  })
+
+  it('accepts orchestrated sessions', () => {
+    assert.equal(
+      isMainMissionSession({ id: 'agent-thread-worker-1', name: 'agent-thread:worker', sessionType: 'orchestrated' }),
+      true,
+    )
+  })
+})

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

@@ -203,7 +203,7 @@ function scheduleMainLoopFollowup(sessionId: string, followup: MainLoopFollowupR
     try {
       const sessions = loadSessions()
       const session = sessions[sessionId]
-      if (!session || session.name !== '__main__') return
+      if (!session || !isMainMissionSession(session)) return
       enqueueSessionRun({
         sessionId,
         message: followup.message,
@@ -218,6 +218,16 @@ function scheduleMainLoopFollowup(sessionId: string, followup: MainLoopFollowupR
   }, delayMs)
 }
 
+export function isMainMissionSession(session: Record<string, unknown>): boolean {
+  const id = typeof session.id === 'string' ? session.id.trim() : ''
+  const name = typeof session.name === 'string' ? session.name.trim() : ''
+  const sessionType = typeof session.sessionType === 'string' ? session.sessionType : ''
+  if (id.startsWith('main-') || name === '__main__') return true
+  // Only orchestrated thread sessions should receive autonomous main-loop followups.
+  if (sessionType === 'orchestrated') return true
+  return false
+}
+
 async function drainExecution(executionKey: string): Promise<void> {
   if (state.runningByExecution.has(executionKey)) return
   const q = queueForExecution(executionKey)
@@ -271,6 +281,9 @@ async function drainExecution(executionKey: string): Promise<void> {
         resultText: result.text,
         error: result.error,
         toolEvents: result.toolEvents,
+        inputTokens: result.inputTokens,
+        outputTokens: result.outputTokens,
+        estimatedCost: result.estimatedCost,
       })
     } catch (mainLoopErr: any) {
       log.warn('session-run', `Main-loop update failed for ${next.run.id}`, mainLoopErr?.message || String(mainLoopErr))
@@ -372,6 +385,19 @@ export interface EnqueueSessionRunResult {
   abort: () => void
 }
 
+const LONG_TOOL_NAMES: ReadonlySet<string> = new Set(['claude_code', 'codex_cli', 'opencode_cli'])
+
+function computeEffectiveRunTimeoutMs(
+  baseTimeoutMs: number,
+  sessionTools: string[],
+  runtime: { claudeCodeTimeoutMs: number },
+): number {
+  const hasLongTool = sessionTools.some(t => LONG_TOOL_NAMES.has(t))
+  if (!hasLongTool) return baseTimeoutMs
+  const toolTimeout = runtime.claudeCodeTimeoutMs + 120_000
+  return Math.max(baseTimeoutMs, toolTimeout)
+}
+
 export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSessionRunResult {
   const internal = input.internal === true
   const mode = normalizeMode(input.mode, internal)
@@ -379,9 +405,13 @@ export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSession
   const executionKey = executionKeyForSession(input.sessionId)
   const runtime = loadRuntimeSettings()
   const defaultMaxRuntimeMs = runtime.ongoingLoopMaxRuntimeMs ?? (10 * 60_000)
+  const sessions = loadSessions()
+  const sessionData = sessions[input.sessionId]
+  const sessionTools: string[] = sessionData?.tools || []
+  const adjustedDefaultMs = computeEffectiveRunTimeoutMs(defaultMaxRuntimeMs, sessionTools, runtime)
   const effectiveMaxRuntimeMs = typeof input.maxRuntimeMs === 'number'
     ? input.maxRuntimeMs
-    : defaultMaxRuntimeMs
+    : adjustedDefaultMs
 
   const dedupe = findDedupeMatch(input.sessionId, input.dedupeKey)
   if (dedupe) {