@swarmclawai/swarmclaw 1.2.1 → 1.2.3

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

@@ -1,2061 +1,5 @@
-import { log } from '@/lib/server/logger'
-import { matchesCapabilities, filterAgentsByCapabilities, capabilityMatchScore } from '@/lib/server/agents/capability-match'
-import { genId } from '@/lib/id'
-import { dedup, hmrSingleton, jitteredBackoff } from '@/lib/shared-utils'
-import fs from 'node:fs'
-import path from 'node:path'
-import { loadTasks, saveTasks, loadQueue, saveQueue, loadAgents, loadSchedules, saveSchedules, loadSessions, saveSessions, loadSettings, logActivity, withTransaction } from '@/lib/server/storage'
-import { notify } from '@/lib/server/ws-hub'
-import { perf } from '@/lib/server/runtime/perf'
-import { WORKSPACE_DIR } from '@/lib/server/data-dir'
-import { createAgentTaskSession } from '@/lib/server/agents/task-session'
-import { formatValidationFailure } from '@/lib/server/tasks/task-validation'
-import { pushMainLoopEventToMainSessions } from '@/lib/server/agents/main-agent-loop'
-import { executeSessionChatTurn, type ExecuteChatTurnResult } from '@/lib/server/chat-execution/chat-execution'
-import { checkAgentBudgetLimits } from '@/lib/server/cost'
-import { extractTaskResult, formatResultBody } from '@/lib/server/tasks/task-result'
-import {
-  assessAutonomyRun,
-  classifyRuntimeFailure,
-  observeAutonomyRunOutcome,
-  recordSupervisorIncident,
-} from '@/lib/server/autonomy/supervisor-reflection'
-import {
-  collectTaskConnectorFollowupTargets as collectTaskConnectorFollowupTargetsImpl,
-  extractLikelyOutputFiles,
-  isSendableAttachment,
-  maybeResolveUploadMediaPathFromUrl,
-  notifyConnectorTaskFollowups,
-  resolveExistingOutputFilePath,
-  resolveTaskOriginConnectorFollowupTarget as resolveTaskOriginConnectorFollowupTargetImpl,
-  type ScheduleTaskMeta,
-  type SessionLike,
-} from '@/lib/server/tasks/task-followups'
-import { getCheckpointSaver } from '@/lib/server/langgraph-checkpoint'
-import { cascadeUnblock } from '@/lib/server/dag-validation'
-import { captureGuardianCheckpoint, prepareGuardianRecovery } from '@/lib/server/agents/guardian'
-import { notifyOrchestrators } from '@/lib/server/runtime/orchestrator-events'
-import type { Agent, BoardTask, Message, Session } from '@/types'
-import { buildAgentDisabledMessage, isAgentDisabled } from '@/lib/server/agents/agent-availability'
-import {
-  didTaskValidationChange,
-  markInvalidCompletedTaskFailed,
-  markValidatedTaskCompleted,
-  refreshTaskCompletionValidation,
-} from '@/lib/server/tasks/task-lifecycle'
-import { noteMissionTaskFinished, noteMissionTaskStarted } from '@/lib/server/missions/mission-service'
-
-const TAG = 'queue'
-
-export const collectTaskConnectorFollowupTargets = collectTaskConnectorFollowupTargetsImpl
-export const resolveTaskOriginConnectorFollowupTarget = resolveTaskOriginConnectorFollowupTargetImpl
-
-// HMR-safe: pin processing state to globalThis so hot reloads don't reset it
-const _queueState = hmrSingleton('__swarmclaw_queue__', () => ({
-  activeCount: 0,
-  maxConcurrent: 3,
-  pendingKick: false,
-}))
-
-function normalizeInt(value: unknown, fallback: number, min: number, max: number): number {
-  const parsed = typeof value === 'number'
-    ? value
-    : typeof value === 'string'
-      ? Number.parseInt(value, 10)
-      : Number.NaN
-  if (!Number.isFinite(parsed)) return fallback
-  return Math.max(min, Math.min(max, Math.trunc(parsed)))
-}
-
-const OPENCLAW_USE_CASE_TAGS = new Set([
-  'local-dev',
-  'single-vps',
-  'private-tailnet',
-  'browser-heavy',
-  'team-control',
-])
-
-function deriveTaskRoutePreferences(task: BoardTask): {
-  preferredGatewayTags?: string[]
-  preferredGatewayUseCase?: string | null
-} {
-  const tags = Array.isArray(task.tags)
-    ? dedup(task.tags.map((tag) => (typeof tag === 'string' ? tag.trim().toLowerCase() : '')).filter(Boolean))
-    : []
-  const customUseCase = typeof task.customFields?.openclawUseCase === 'string'
-    ? task.customFields.openclawUseCase
-    : typeof task.customFields?.gatewayUseCase === 'string'
-      ? task.customFields.gatewayUseCase
-      : null
-  const preferredGatewayUseCase = customUseCase && OPENCLAW_USE_CASE_TAGS.has(customUseCase)
-    ? customUseCase
-    : (tags.find((tag) => OPENCLAW_USE_CASE_TAGS.has(tag)) || null)
-  const preferredGatewayTags = tags.filter((tag) => tag !== preferredGatewayUseCase)
-  return {
-    preferredGatewayTags,
-    preferredGatewayUseCase,
-  }
-}
-
-function resolveTaskPolicy(task: BoardTask): { maxAttempts: number; backoffSec: number } {
-  const settings = loadSettings()
-  const defaultMaxAttempts = normalizeInt(settings.defaultTaskMaxAttempts, 3, 1, 20)
-  const defaultBackoffSec = normalizeInt(settings.taskRetryBackoffSec, 30, 1, 3600)
-  const maxAttempts = normalizeInt(task.maxAttempts, defaultMaxAttempts, 1, 20)
-  const backoffSec = normalizeInt(task.retryBackoffSec, defaultBackoffSec, 1, 3600)
-  return { maxAttempts, backoffSec }
-}
-
-function applyTaskPolicyDefaults(task: BoardTask): void {
-  const policy = resolveTaskPolicy(task)
-  if (typeof task.attempts !== 'number' || task.attempts < 0) task.attempts = 0
-  task.maxAttempts = policy.maxAttempts
-  task.retryBackoffSec = policy.backoffSec
-  if (task.retryScheduledAt === undefined) task.retryScheduledAt = null
-  if (task.deadLetteredAt === undefined) task.deadLetteredAt = null
-}
-
-export interface TaskResumeState {
-  claudeSessionId: string | null
-  codexThreadId: string | null
-  opencodeSessionId: string | null
-  delegateResumeIds: NonNullable<Session['delegateResumeIds']>
-}
-
-export interface TaskResumeContext {
-  source: 'self' | 'delegated_from_task' | 'blocked_by'
-  sourceTaskId: string
-  sourceTaskTitle: string
-  sourceSessionId: string | null
-  resume: TaskResumeState
-}
-
-function normalizeResumeHandle(value: unknown): string | null {
-  return typeof value === 'string' && value.trim() ? value.trim() : null
-}
-
-function buildEmptyDelegateResumeIds(): NonNullable<Session['delegateResumeIds']> {
-  return {
-    claudeCode: null,
-    codex: null,
-    opencode: null,
-    gemini: null,
-  }
-}
-
-function normalizeCliProvider(value: unknown): string | null {
-  return typeof value === 'string' && value.trim() ? value.trim().toLowerCase() : null
-}
-
-function hasResumeState(state: TaskResumeState | null | undefined): state is TaskResumeState {
-  if (!state) return false
-  return Boolean(
-    state.claudeSessionId
-    || state.codexThreadId
-    || state.opencodeSessionId
-    || state.delegateResumeIds.claudeCode
-    || state.delegateResumeIds.codex
-    || state.delegateResumeIds.opencode
-    || state.delegateResumeIds.gemini
-  )
-}
-
-export function extractTaskResumeState(task: Partial<BoardTask> | null | undefined): TaskResumeState | null {
-  if (!task) return null
-
-  const legacyResumeId = normalizeResumeHandle(task.cliResumeId)
-  const legacyProvider = normalizeCliProvider(task.cliProvider)
-  const claudeSessionId = normalizeResumeHandle(task.claudeResumeId)
-    || (legacyProvider === 'claude-cli' ? legacyResumeId : null)
-  const codexThreadId = normalizeResumeHandle(task.codexResumeId)
-    || (legacyProvider === 'codex-cli' ? legacyResumeId : null)
-  const opencodeSessionId = normalizeResumeHandle(task.opencodeResumeId)
-    || (legacyProvider === 'opencode-cli' ? legacyResumeId : null)
-  const geminiSessionId = normalizeResumeHandle(task.geminiResumeId)
-    || (legacyProvider === 'gemini-cli' ? legacyResumeId : null)
-
-  const resume = {
-    claudeSessionId,
-    codexThreadId,
-    opencodeSessionId,
-    delegateResumeIds: {
-      claudeCode: claudeSessionId,
-      codex: codexThreadId,
-      opencode: opencodeSessionId,
-      gemini: geminiSessionId,
-    },
-  } satisfies TaskResumeState
-
-  return hasResumeState(resume) ? resume : null
-}
-
-export function extractSessionResumeState(session: Partial<Session> | null | undefined): TaskResumeState | null {
-  if (!session) return null
-
-  const claudeSessionId = normalizeResumeHandle(session.claudeSessionId)
-  const codexThreadId = normalizeResumeHandle(session.codexThreadId)
-  const opencodeSessionId = normalizeResumeHandle(session.opencodeSessionId)
-  const delegateResumeIds = session.delegateResumeIds && typeof session.delegateResumeIds === 'object'
-    ? { ...buildEmptyDelegateResumeIds(), ...session.delegateResumeIds }
-    : buildEmptyDelegateResumeIds()
-
-  const resume = {
-    claudeSessionId,
-    codexThreadId,
-    opencodeSessionId,
-    delegateResumeIds: {
-      claudeCode: normalizeResumeHandle(delegateResumeIds.claudeCode) || claudeSessionId,
-      codex: normalizeResumeHandle(delegateResumeIds.codex) || codexThreadId,
-      opencode: normalizeResumeHandle(delegateResumeIds.opencode) || opencodeSessionId,
-      gemini: normalizeResumeHandle(delegateResumeIds.gemini),
-    },
-  } satisfies TaskResumeState
-
-  return hasResumeState(resume) ? resume : null
-}
-
-export function resolveTaskResumeContext(
-  task: BoardTask,
-  tasksById: Record<string, BoardTask>,
-  sessionsById?: Record<string, SessionLike | Session>,
-): TaskResumeContext | null {
-  const candidates: Array<{ source: TaskResumeContext['source']; taskId: string | null | undefined }> = [
-    { source: 'self', taskId: task.id },
-    { source: 'delegated_from_task', taskId: task.delegatedFromTaskId },
-    ...((Array.isArray(task.blockedBy) ? task.blockedBy : []).map((taskId) => ({ source: 'blocked_by' as const, taskId }))),
-  ]
-  const seen = new Set<string>()
-
-  for (const candidate of candidates) {
-    const taskId = typeof candidate.taskId === 'string' ? candidate.taskId.trim() : ''
-    if (!taskId || seen.has(taskId)) continue
-    seen.add(taskId)
-    const sourceTask = taskId === task.id ? task : tasksById[taskId]
-    if (!sourceTask) continue
-    const sourceSessionId = normalizeResumeHandle(sourceTask.checkpoint?.lastSessionId) || normalizeResumeHandle(sourceTask.sessionId)
-    const resume = extractTaskResumeState(sourceTask)
-      || (sourceSessionId && sessionsById?.[sourceSessionId]
-        ? extractSessionResumeState(sessionsById[sourceSessionId] as Session)
-        : null)
-    if (!resume) continue
-    return {
-      source: candidate.source,
-      sourceTaskId: sourceTask.id,
-      sourceTaskTitle: sourceTask.title,
-      sourceSessionId,
-      resume,
-    }
-  }
-
-  return null
-}
-
-export function applyTaskResumeStateToSession(session: Session, resume: TaskResumeState | null | undefined): boolean {
-  if (!hasResumeState(resume)) return false
-
-  let changed = false
-  const directFields: Array<['claudeSessionId' | 'codexThreadId' | 'opencodeSessionId', string | null]> = [
-    ['claudeSessionId', resume.claudeSessionId],
-    ['codexThreadId', resume.codexThreadId],
-    ['opencodeSessionId', resume.opencodeSessionId],
-  ]
-  for (const [key, value] of directFields) {
-    if (!value || session[key] === value) continue
-    session[key] = value
-    changed = true
-  }
-
-  const currentDelegateResume = session.delegateResumeIds && typeof session.delegateResumeIds === 'object'
-    ? { ...buildEmptyDelegateResumeIds(), ...session.delegateResumeIds }
-    : buildEmptyDelegateResumeIds()
-  for (const [key, value] of Object.entries(resume.delegateResumeIds) as Array<[keyof NonNullable<Session['delegateResumeIds']>, string | null]>) {
-    if (!value || currentDelegateResume[key] === value) continue
-    currentDelegateResume[key] = value
-    changed = true
-  }
-  if (changed) session.delegateResumeIds = currentDelegateResume
-  return changed
-}
-
-export function resolveReusableTaskSessionId(
-  task: BoardTask,
-  tasks: Record<string, BoardTask>,
-  sessions: Record<string, SessionLike>,
-): string {
-  const candidateTaskIds = [
-    task.id,
-    typeof task.delegatedFromTaskId === 'string' ? task.delegatedFromTaskId : '',
-    ...(Array.isArray(task.blockedBy) ? task.blockedBy : []),
-  ]
-  const seen = new Set<string>()
-  for (const candidateTaskId of candidateTaskIds) {
-    const taskId = typeof candidateTaskId === 'string' ? candidateTaskId.trim() : ''
-    if (!taskId || seen.has(taskId)) continue
-    seen.add(taskId)
-    const sourceTask = taskId === task.id ? task : tasks[taskId]
-    if (!sourceTask) continue
-    const candidates = [
-      normalizeResumeHandle(sourceTask.checkpoint?.lastSessionId),
-      normalizeResumeHandle(sourceTask.sessionId),
-    ]
-    for (const candidate of candidates) {
-      if (candidate && sessions[candidate]) return candidate
-    }
-  }
-  return ''
-}
-
-function buildTaskContinuationNote(
-  reusedExistingSession: boolean,
-  resumeContext: TaskResumeContext | null,
-): string {
-  const notes: string[] = []
-  if (reusedExistingSession) {
-    notes.push('Reusing the previous execution session for this task.')
-  }
-  if (resumeContext?.source === 'delegated_from_task' || resumeContext?.source === 'blocked_by') {
-    notes.push(`Stored CLI context is available from related task "${resumeContext.sourceTaskTitle}".`)
-  } else if (resumeContext?.source === 'self' && !reusedExistingSession) {
-    notes.push('Stored CLI resume handles are available for continuation.')
-  }
-  return notes.length ? `\n\n${notes.join(' ')}` : ''
-}
-
-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)
-}
-
-function isCancelledTask(task: Partial<BoardTask> | null | undefined): boolean {
-  return task?.status === 'cancelled'
-}
-
-function pushQueueUnique(queue: string[], id: string): void {
-  if (!queueContains(queue, id)) queue.push(id)
-}
-
-function isAgentCreatedTask(task: Partial<BoardTask> | null | undefined): boolean {
-  return Boolean(typeof task?.createdByAgentId === 'string' && task.createdByAgentId.trim())
-}
-
-function resolveTaskTerminalChatSessionId(
-  task: BoardTask,
-  sessions: Record<string, SessionLike>,
-): string | null {
-  if (task.status !== 'completed' && task.status !== 'failed') return null
-  if (task.sourceType === 'schedule') return null
-  if (isAgentCreatedTask(task)) return null
-  const createdInSessionId = typeof task.createdInSessionId === 'string'
-    ? task.createdInSessionId.trim()
-    : ''
-  return createdInSessionId && sessions[createdInSessionId] ? createdInSessionId : null
-}
-
-interface TaskResultDeliveryData {
-  statusLabel: 'completed' | 'failed'
-  resultBody: string
-  outputFileRefs: string[]
-  firstImage?: NonNullable<BoardTask['artifacts']>[number]
-  followupMediaPath?: string
-  mediaFileName?: string
-  execCwd: string
-  resumeLines: string[]
-}
-
-function collectTaskResultDeliveryData(
-  task: BoardTask,
-  sessions: Record<string, SessionLike>,
-): TaskResultDeliveryData {
-  const runSessionId = typeof task.sessionId === 'string' ? task.sessionId : ''
-  const runSession = runSessionId ? sessions[runSessionId] : null
-  const fallbackText = runSession ? latestAssistantText(runSession) : ''
-  const taskResult = extractTaskResult(
-    runSession,
-    task.result || fallbackText || null,
-    { sinceTime: typeof task.startedAt === 'number' ? task.startedAt : null },
-  )
-  const resultBody = formatResultBody(taskResult)
-  const outputFileRefs = Array.isArray(task.outputFiles) && task.outputFiles.length > 0
-    ? task.outputFiles
-    : extractLikelyOutputFiles(resultBody)
-  const firstImage = taskResult.artifacts.find((artifact) => artifact.type === 'image')
-  const firstArtifactMediaPath = taskResult.artifacts
-    .map((artifact) => maybeResolveUploadMediaPathFromUrl(artifact.url))
-    .find((candidate): candidate is string => Boolean(candidate))
-  const resumeLines: string[] = []
-  if (task.claudeResumeId) resumeLines.push(`Claude session: \`${task.claudeResumeId}\``)
-  if (task.codexResumeId) resumeLines.push(`Codex thread: \`${task.codexResumeId}\``)
-  if (task.opencodeResumeId) resumeLines.push(`OpenCode session: \`${task.opencodeResumeId}\``)
-  if (task.geminiResumeId) resumeLines.push(`Gemini session: \`${task.geminiResumeId}\``)
-  if (resumeLines.length === 0 && task.cliResumeId) {
-    resumeLines.push(`${task.cliProvider || 'CLI'} session: \`${task.cliResumeId}\``)
-  }
-  const execCwd = runSession?.cwd || ''
-  const existingOutputPaths = outputFileRefs
-    .map((fileRef: string) => resolveExistingOutputFilePath(fileRef, execCwd))
-    .filter((candidate: string | null): candidate is string => Boolean(candidate))
-  const firstLocalOutputPath = existingOutputPaths.find((candidate: string) => isSendableAttachment(candidate))
-  const followupMediaPath = firstArtifactMediaPath || firstLocalOutputPath || undefined
-
-  return {
-    statusLabel: task.status === 'completed' ? 'completed' : 'failed',
-    resultBody,
-    outputFileRefs,
-    firstImage,
-    followupMediaPath,
-    mediaFileName: followupMediaPath ? path.basename(followupMediaPath) : undefined,
-    execCwd,
-    resumeLines,
-  }
-}
-
-function buildTaskTerminalMessage(
-  prefix: string,
-  task: BoardTask,
-  delivery: TaskResultDeliveryData,
-): string {
-  const parts = [prefix]
-  if (delivery.execCwd) parts.push(`Working directory: \`${delivery.execCwd}\``)
-  if (delivery.outputFileRefs.length > 0) {
-    parts.push(`Output files:\n${delivery.outputFileRefs.slice(0, 8).map((fileRef: string) => `- \`${fileRef}\``).join('\n')}`)
-  }
-  if (task.completionReportPath) parts.push(`Task report: \`${task.completionReportPath}\``)
-  if (delivery.resumeLines.length > 0) parts.push(delivery.resumeLines.join(' | '))
-  parts.push(delivery.resultBody || 'No summary.')
-  return parts.join('\n\n')
-}
-
-function latestAssistantText(session: SessionLike | null | undefined): string {
-  if (!Array.isArray(session?.messages)) return ''
-  for (let i = session.messages.length - 1; i >= 0; i--) {
-    const msg = session.messages[i]
-    if (msg?.role !== 'assistant') continue
-    const text = typeof msg?.text === 'string' ? msg.text.trim() : ''
-    if (!text) continue
-    if (/^HEARTBEAT_OK$/i.test(text)) continue
-    return text
-  }
-  return ''
-}
-
-// 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
-}
-
-function queueTaskAutonomyObservation(input: {
-  runId: string
-  sessionId: string
-  taskId: string
-  agentId: string
-  status: 'completed' | 'failed' | 'cancelled'
-  resultText?: string | null
-  error?: string | null
-  toolEvents?: ExecuteChatTurnResult['toolEvents']
-  sourceMessage?: string | null
-}) {
-  void observeAutonomyRunOutcome({
-    runId: input.runId,
-    sessionId: input.sessionId,
-    taskId: input.taskId,
-    agentId: input.agentId,
-    source: 'task',
-    status: input.status,
-    resultText: input.resultText,
-    error: input.error || undefined,
-    toolEvents: input.toolEvents,
-    sourceMessage: input.sourceMessage,
-  }).catch((err: unknown) => {
-    log.warn(TAG, `[queue] Autonomy observation failed for ${input.runId}:`, err)
-  })
-}
-
-async function executeTaskRun(
-  task: BoardTask,
-  agent: Agent,
-  sessionId: string,
-): Promise<ExecuteChatTurnResult> {
-  if (agent.autoRecovery) {
-    const cwd = task.projectId
-      ? path.join(WORKSPACE_DIR, 'projects', task.projectId)
-      : WORKSPACE_DIR
-    captureGuardianCheckpoint(cwd, `task:${task.id}`)
-  }
-  const settings = loadSettings()
-  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')
-  // All agents go through the unified chat execution path.
-  // Agents with delegation enabled get delegation tools automatically via session-tools.
-  let latestRun: ExecuteChatTurnResult = await executeSessionChatTurn({
-    sessionId,
-    message: prompt,
-    internal: false,
-    source: 'task',
-    runId: task.id,
-  })
-  let text = typeof latestRun.text === 'string' ? latestRun.text.trim() : ''
-  let previousSummary: string | null = null
-  let totalInputTokens = latestRun.inputTokens || 0
-  let totalOutputTokens = latestRun.outputTokens || 0
-  let totalEstimatedCost = Number(latestRun.estimatedCost || 0)
-  if (latestRun.error) {
-    return {
-      ...latestRun,
-      text,
-    }
-  }
-
-  const maxSupervisorFollowups = 2
-  for (let followupIndex = 0; followupIndex < maxSupervisorFollowups; followupIndex += 1) {
-    const sessions = loadSessions()
-    const session = sessions[sessionId] as unknown as Session | undefined
-    const assessment = assessAutonomyRun({
-      runId: `${task.id}:attempt-${(task.attempts || 0) + 1}:step-${followupIndex + 1}`,
-      sessionId,
-      taskId: task.id,
-      agentId: agent.id,
-      source: 'task',
-      status: latestRun.error ? 'failed' : 'completed',
-      resultText: text,
-      error: latestRun.error,
-      toolEvents: latestRun.toolEvents,
-      mainLoopState: {
-        followupChainCount: followupIndex + 1,
-        summary: previousSummary,
-        missionCostUsd: totalEstimatedCost,
-      },
-      session: session || null,
-      settings,
-    })
-    if (assessment.shouldBlock) break
-    if (assessment.autoActions?.length) {
-      const { executeSupervisorAutoActions } = await import('@/lib/server/autonomy/supervisor-reflection')
-      const result = await executeSupervisorAutoActions({
-        actions: assessment.autoActions,
-        sessionId,
-        agentId: agent?.id,
-      })
-      if (result.blocked) break
-    }
-    const followupMessage = assessment.interventionPrompt
-      || (text && looksIncomplete(text)
-        ? 'Continue and complete the remaining steps. Provide a final summary when done.'
-        : null)
-    if (!followupMessage) break
-
-    // Budget check before follow-up
-    const typedAgentForBudget = agent as Agent
-    if (typedAgentForBudget.monthlyBudget || typedAgentForBudget.dailyBudget || typedAgentForBudget.hourlyBudget) {
-      try {
-        const followupBudget = checkAgentBudgetLimits(typedAgentForBudget)
-        if (!followupBudget.ok) {
-          log.warn(TAG, `[queue] Budget exceeded for "${typedAgentForBudget.name}" during follow-up, stopping.`)
-          break
-        }
-      } catch {}
-    }
-
-    previousSummary = text || previousSummary
-    const followUp = await executeSessionChatTurn({
-      sessionId,
-      message: followupMessage,
-      internal: false,
-      source: 'task',
-    })
-    totalInputTokens += followUp.inputTokens || 0
-    totalOutputTokens += followUp.outputTokens || 0
-    totalEstimatedCost += Number(followUp.estimatedCost || 0)
-    text = typeof followUp.text === 'string' ? followUp.text.trim() : ''
-    latestRun = {
-      ...followUp,
-      text,
-      inputTokens: totalInputTokens,
-      outputTokens: totalOutputTokens,
-      estimatedCost: totalEstimatedCost,
-    }
-    if (latestRun.error) break
-  }
-
-  return {
-    ...latestRun,
-    text,
-    inputTokens: totalInputTokens,
-    outputTokens: totalOutputTokens,
-    estimatedCost: totalEstimatedCost,
-  }
-}
-
-function hasFinishedExecutionSession(session: SessionLike | Session | null | undefined): boolean {
-  if (!session) return false
-  return session.active === false && !session.currentRunId
-}
-
-export function reconcileFinishedRunningTasks(): { reconciled: number; deadLettered: number } {
-  const tasks = loadTasks()
-  const sessions = loadSessions() as Record<string, SessionLike>
-  const settings = loadSettings()
-  const queue = loadQueue()
-  const now = Date.now()
-  let reconciled = 0
-  let deadLettered = 0
-  let tasksDirty = false
-  let sessionsDirty = false
-  let queueDirty = false
-  const terminalTasks: BoardTask[] = []
-
-  for (const task of Object.values(tasks) as BoardTask[]) {
-    if (task.status !== 'running') continue
-    const sessionId = typeof task.sessionId === 'string' ? task.sessionId : ''
-    if (!sessionId) continue
-    const session = sessions[sessionId]
-    if (!hasFinishedExecutionSession(session)) continue
-
-    const fallbackText = latestAssistantText(session)
-    if (!fallbackText && !task.result) {
-      task.status = 'failed'
-      task.result = 'Agent session finished without producing output.'
-      task.updatedAt = now
-      tasksDirty = true
-      continue
-    }
-
-    applyTaskPolicyDefaults(task)
-    const taskResult = extractTaskResult(
-      session,
-      task.result || fallbackText || null,
-      { sinceTime: typeof task.startedAt === 'number' ? task.startedAt : null },
-    )
-    const enrichedResult = formatResultBody(taskResult)
-    task.result = enrichedResult.slice(0, 4000) || null
-    task.artifacts = taskResult.artifacts.slice(0, 24)
-    task.outputFiles = extractLikelyOutputFiles(enrichedResult).slice(0, 24)
-    task.updatedAt = now
-    const { validation } = refreshTaskCompletionValidation(task, settings)
-    if (!task.comments) task.comments = []
-
-    if (validation.ok) {
-      markValidatedTaskCompleted(task, { now })
-      task.retryScheduledAt = null
-      task.deadLetteredAt = null
-      task.checkpoint = {
-        ...(task.checkpoint || {}),
-        lastRunId: sessionId,
-        lastSessionId: sessionId,
-        note: 'Recovered completed task state from finished session.',
-        updatedAt: now,
-      }
-      task.comments.push({
-        id: genId(),
-        author: 'System',
-        text: 'Recovered completed task state from a finished execution session.',
-        createdAt: now,
-      })
-      reconciled++
-      terminalTasks.push(task)
-    } else {
-      const failureReason = formatValidationFailure(validation.reasons).slice(0, 500)
-      const retryState = scheduleRetryOrDeadLetter(task, failureReason)
-      task.completedAt = retryState === 'dead_lettered' ? null : task.completedAt
-      task.comments.push({
-        id: genId(),
-        author: 'System',
-        text: `Recovered finished session but the task result failed validation.\n\n${validation.reasons.map((reason) => `- ${reason}`).join('\n')}`,
-        createdAt: now,
-      })
-      if (retryState === 'retry') {
-        pushQueueUnique(queue, task.id)
-        queueDirty = true
-        reconciled++
-        pushMainLoopEventToMainSessions({
-          type: 'task_retry_scheduled',
-          text: `Task retry scheduled: "${task.title}" (${task.id}) attempt ${task.attempts}/${task.maxAttempts} in ${task.retryBackoffSec}s.`,
-        })
-      } else {
-        deadLettered++
-        terminalTasks.push(task)
-      }
-    }
-
-    if (session.heartbeatEnabled !== false) {
-      session.heartbeatEnabled = false
-      session.lastActiveAt = now
-      sessionsDirty = true
-    }
-    tasksDirty = true
-  }
-
-  if (tasksDirty) {
-    saveTasks(tasks)
-    notify('tasks')
-    notify('runs')
-  }
-  if (sessionsDirty) saveSessions(sessions as Record<string, Session>)
-  if (queueDirty) saveQueue(queue)
-
-  for (const task of terminalTasks) {
-    if (task.status === 'completed') {
-      logActivity({ entityType: 'task', entityId: task.id, action: 'completed', actor: 'system', actorId: task.agentId, summary: `Task completed: "${task.title}"` })
-      pushMainLoopEventToMainSessions({
-        type: 'task_completed',
-        text: `Task completed: "${task.title}" (${task.id})`,
-      })
-      notifyOrchestrators(`Task completed: "${task.title}"`, `task-complete:${task.id}`)
-    } else if (task.status === 'failed') {
-      logActivity({ entityType: 'task', entityId: task.id, action: 'failed', actor: 'system', actorId: task.agentId, summary: `Task failed: "${task.title}"` })
-      pushMainLoopEventToMainSessions({
-        type: 'task_failed',
-        text: `Task failed validation: "${task.title}" (${task.id})`,
-      })
-      notifyOrchestrators(`Task failed: "${task.title}" — validation failure`, `task-fail:${task.id}`)
-    }
-    handleTerminalTaskResultDeliveries(task)
-    cleanupTerminalOneOffSchedule(task)
-  }
-
-  return { reconciled, deadLettered }
-}
-
-function cleanupTerminalOneOffSchedule(task: BoardTask): void {
-  void task
-}
-
-function pushUserFacingTaskResult(task: BoardTask, sessions: Record<string, SessionLike>): void {
-  if (task.status !== 'completed' && task.status !== 'failed') return
-  const targetSessionId = resolveTaskTerminalChatSessionId(task, sessions)
-  if (!targetSessionId) return
-  const targetSession = sessions[targetSessionId]
-  if (!targetSession) return
-
-  const delivery = collectTaskResultDeliveryData(task, sessions)
-  const taskLink = `[${task.title}](#task:${task.id})`
-  const body = buildTaskTerminalMessage(`Task ${delivery.statusLabel}: **${taskLink}**`, task, delivery)
-  const now = Date.now()
-  if (!Array.isArray(targetSession.messages)) targetSession.messages = []
-  const lastMsg = targetSession.messages.at(-1)
-  if (lastMsg?.role === 'assistant' && lastMsg?.text === body && typeof lastMsg?.time === 'number' && now - lastMsg.time < 30_000) {
-    return
-  }
-
-  const message: Message = {
-    role: 'assistant',
-    text: body,
-    time: now,
-    kind: 'system',
-  }
-  if (delivery.firstImage) message.imageUrl = delivery.firstImage.url
-  targetSession.messages.push(message)
-  targetSession.lastActiveAt = now
-  saveSessions(sessions as Record<string, Session>)
-  notify(`messages:${targetSessionId}`)
-}
-
-function deliverTaskConnectorFollowups(task: BoardTask, sessions: Record<string, SessionLike>): void {
-  if (task.status !== 'completed' && task.status !== 'failed') return
-  const delivery = collectTaskResultDeliveryData(task, sessions)
-  void notifyConnectorTaskFollowups({
-    task,
-    statusLabel: delivery.statusLabel,
-    summaryText: delivery.resultBody || '',
-    imageUrl: delivery.firstImage?.url,
-    mediaPath: delivery.followupMediaPath,
-    mediaFileName: delivery.mediaFileName,
-  })
-}
-
-function handleTerminalTaskResultDeliveries(task: BoardTask): void {
-  const sessions = loadSessions() as Record<string, SessionLike>
-  pushUserFacingTaskResult(task, sessions)
-  deliverTaskConnectorFollowups(task, sessions)
-}
-
-/** Disable heartbeat on a task's session when the task finishes. */
-export function disableSessionHeartbeat(sessionId: string | null | undefined) {
-  if (!sessionId) return
-  const sessions = loadSessions()
-  const session = sessions[sessionId]
-  if (!session || session.heartbeatEnabled === false) return
-  session.heartbeatEnabled = false
-  session.lastActiveAt = Date.now()
-  saveSessions(sessions)
-  log.info(TAG, `[queue] Disabled heartbeat on session ${sessionId} (task finished)`)
-}
-
-export function enqueueTask(taskId: string) {
-  const tasks = loadTasks()
-  const task = tasks[taskId] as BoardTask | undefined
-  if (!task) return
-
-  applyTaskPolicyDefaults(task)
-  task.status = 'queued'
-  task.queuedAt = Date.now()
-  task.retryScheduledAt = null
-  task.updatedAt = Date.now()
-  saveTasks(tasks)
-
-  const queue = loadQueue()
-  pushQueueUnique(queue, taskId)
-  saveQueue(queue)
-
-  logActivity({ entityType: 'task', entityId: taskId, action: 'queued', actor: 'system', summary: `Task queued: "${task.title}"` })
-
-  pushMainLoopEventToMainSessions({
-    type: 'task_queued',
-    text: `Task queued: "${task.title}" (${task.id})`,
-  })
-
-  // If processNext is at capacity, mark a pending kick so it picks up work when a slot frees
-  if (_queueState.activeCount >= _queueState.maxConcurrent) {
-    _queueState.pendingKick = true
-  }
-  // Delay before kicking worker so UI shows the queued state
-  setTimeout(() => processNext(), 2000)
-}
-
-/**
- * Re-validate all completed tasks so the completed queue only contains
- * tasks with concrete completion evidence.
- */
-export function validateCompletedTasksQueue() {
-  const tasks = loadTasks()
-  const sessions = loadSessions()
-  const settings = loadSettings()
-  const now = Date.now()
-  let checked = 0
-  let demoted = 0
-  let tasksDirty = false
-  let sessionsDirty = false
-
-  for (const task of Object.values(tasks) as BoardTask[]) {
-    if (task.status !== 'completed') continue
-    checked++
-
-    const previousValidation = task.validation || null
-    const previousReportPath = task.completionReportPath || null
-    const { validation } = refreshTaskCompletionValidation(task, settings)
-    if (task.completionReportPath !== previousReportPath) {
-      tasksDirty = true
-    }
-    const validationChanged = didTaskValidationChange(previousValidation, validation)
-
-    if (validationChanged) {
-      tasksDirty = true
-    }
-
-    if (validation.ok) {
-      if (!task.completedAt) {
-        markValidatedTaskCompleted(task, { now, preserveCompletedAt: true })
-        tasksDirty = true
-      }
-      continue
-    }
-
-    markInvalidCompletedTaskFailed(task, validation, {
-      now,
-      comment: {
-        author: 'System',
-        text: `Task auto-failed completed-queue validation.\n\n${validation.reasons.map((r) => `- ${r}`).join('\n')}`,
-      },
-    })
-    tasksDirty = true
-    demoted++
-
-    if (task.sessionId) {
-      const session = sessions[task.sessionId]
-      if (session && session.heartbeatEnabled !== false) {
-        session.heartbeatEnabled = false
-        session.lastActiveAt = now
-        sessionsDirty = true
-      }
-    }
-  }
-
-  if (tasksDirty) { saveTasks(tasks); notify('tasks') }
-  if (sessionsDirty) saveSessions(sessions)
-  if (demoted > 0) {
-    log.warn(TAG, `[queue] Demoted ${demoted} invalid completed task(s) to failed after validation audit`)
-  }
-  return { checked, demoted }
-}
-
-function scheduleRetryOrDeadLetter(task: BoardTask, reason: string): 'retry' | 'dead_lettered' {
-  if (isCancelledTask(task)) {
-    task.retryScheduledAt = null
-    task.deadLetteredAt = null
-    task.updatedAt = Date.now()
-    return 'dead_lettered'
-  }
-  applyTaskPolicyDefaults(task)
-  const now = Date.now()
-  task.attempts = (task.attempts || 0) + 1
-
-  if ((task.attempts || 0) < (task.maxAttempts || 1)) {
-    const delayMs = jitteredBackoff((task.retryBackoffSec || 30) * 1000, Math.max(0, (task.attempts || 1) - 1), 6 * 3600_000)
-    task.status = 'queued'
-    task.retryScheduledAt = now + delayMs
-    task.updatedAt = now
-    task.error = `Retry scheduled after failure: ${reason}`.slice(0, 500)
-    if (!task.comments) task.comments = []
-    task.comments.push({
-      id: genId(),
-      author: 'System',
-      text: `Attempt ${task.attempts}/${task.maxAttempts} failed. Retrying in ${Math.round(delayMs / 1000)}s.\n\nReason: ${reason}`,
-      createdAt: now,
-    })
-    return 'retry'
-  }
-
-  task.status = 'failed'
-  task.deadLetteredAt = now
-  task.retryScheduledAt = null
-  task.updatedAt = now
-  task.error = `Dead-lettered after ${task.attempts}/${task.maxAttempts} attempts: ${reason}`.slice(0, 500)
-  if (!task.comments) task.comments = []
-  task.comments.push({
-    id: genId(),
-    author: 'System',
-    text: `Task moved to dead-letter after ${task.attempts}/${task.maxAttempts} attempts.\n\nReason: ${reason}`,
-    createdAt: now,
-  })
-  notifyOrchestrators(`Task failed: "${task.title}" — ${(reason || 'unknown error').slice(0, 100)}`, `task-fail:${task.id}`)
-  if (task.sessionId) {
-    const failure = classifyRuntimeFailure({ source: 'task', message: reason })
-    recordSupervisorIncident({
-      runId: task.id,
-      sessionId: task.sessionId,
-      taskId: task.id,
-      agentId: task.agentId || null,
-      source: 'task',
-      kind: 'runtime_failure',
-      severity: failure.severity,
-      summary: `Task dead-lettered: ${reason}`.slice(0, 320),
-      details: reason,
-      failureFamily: failure.family,
-      remediation: failure.remediation,
-      repairPrompt: failure.repairPrompt,
-      autoAction: null,
-    })
-  }
-
-  // Guardian recovery is approval-backed. Dead-lettering prepares a restore
-  // request instead of mutating the workspace automatically.
-  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 recovery = prepareGuardianRecovery({
-      cwd,
-      reason,
-      requester: `task:${task.id}`,
-    })
-    if (recovery.ok && recovery.approval) {
-      task.comments.push({
-        id: genId(),
-        author: 'Guardian',
-        text: `Recovery prepared for checkpoint ${recovery.checkpoint?.head.slice(0, 12) || 'unknown'}.\n\nApprove restore request ${recovery.approval.id} to roll the workspace back safely.`,
-        createdAt: now + 1,
-      })
-    } else {
-      task.comments.push({
-        id: genId(),
-        author: 'Guardian',
-        text: `Recovery advisory: ${recovery.reason || 'Unable to prepare a restore request.'}`,
-        createdAt: now + 1,
-      })
-    }
-  }
-
-  return 'dead_lettered'
-}
-
-export function dequeueNextRunnableTask(queue: string[], tasks: Record<string, BoardTask>): string | null {
-  const now = Date.now()
-
-  // Remove stale entries first.
-  for (let i = queue.length - 1; i >= 0; i--) {
-    const id = queue[i]
-    const task = tasks[id]
-    if (!task || task.status !== 'queued') queue.splice(i, 1)
-  }
-
-  const idx = queue.findIndex((id) => {
-    const task = tasks[id]
-    if (!task) return false
-    const retryAt = typeof task.retryScheduledAt === 'number' ? task.retryScheduledAt : null
-    if (retryAt && retryAt > now) return false
-    const blockers = Array.isArray(task.blockedBy) ? task.blockedBy : []
-    if (blockers.some((blockerId) => tasks[blockerId]?.status !== 'completed')) return false
-    // Skip pool-mode tasks that haven't been claimed yet
-    if (task.assignmentMode === 'pool' && !task.claimedByAgentId) return false
-    return true
-  })
-  if (idx === -1) return null
-  const [taskId] = queue.splice(idx, 1)
-  return taskId || null
-}
-
-export async function processNext() {
-  const settings = loadSettings()
-  _queueState.maxConcurrent = normalizeInt(
-    (settings as Record<string, unknown>).taskQueueConcurrency, 3, 1, 10
-  )
-
-  if (_queueState.activeCount >= _queueState.maxConcurrent) {
-    _queueState.pendingKick = true
-    return
-  }
-  _queueState.activeCount++
-  const endQueuePerf = perf.start('queue', 'processNext')
-
-  try {
-    // Recover orphaned tasks: status is 'queued' but missing from the queue array
-    // Only run from the first worker to avoid redundant scans
-    if (_queueState.activeCount === 1) {
-      const allTasks = loadTasks()
-      const currentQueue = loadQueue()
-      const queueSet = new Set(currentQueue)
-      let recovered = false
-      for (const [id, t] of Object.entries(allTasks) as [string, BoardTask][]) {
-        if (t.status === 'queued' && !queueSet.has(id)) {
-          log.info(TAG, `[queue] Recovering orphaned queued task: "${t.title}" (${id})`)
-          pushQueueUnique(currentQueue, id)
-          recovered = true
-        }
-      }
-      if (recovered) saveQueue(currentQueue)
-    }
-
-    // Process ONE task per invocation (no while loop)
-    {
-      const tasks = loadTasks()
-      const queue = loadQueue()
-      if (queue.length === 0) return
-
-      const taskId = dequeueNextRunnableTask(queue, tasks as Record<string, BoardTask>)
-      saveQueue(queue)
-      if (!taskId) return
-      const latestTasks = loadTasks() as Record<string, BoardTask>
-      let task = latestTasks[taskId] as BoardTask | undefined
-
-      if (!task || task.status !== 'queued') {
-        return
-      }
-
-      // Dependency guard: skip tasks whose blockers are not all completed
-      const blockers = Array.isArray(task.blockedBy) ? task.blockedBy as string[] : []
-      if (blockers.length > 0) {
-        const allBlockersDone = blockers.every((bid) => {
-          const blocker = latestTasks[bid] as BoardTask | undefined
-          return blocker?.status === 'completed'
-        })
-        if (!allBlockersDone) {
-          // Put it back in the queue and skip
-          pushQueueUnique(queue, taskId)
-          saveQueue(queue)
-          log.info(TAG, `[queue] Skipping task "${task.title}" (${taskId}) — blocked by incomplete dependencies`)
-          return
-        }
-      }
-
-      const agents = loadAgents()
-      let agent = agents[task.agentId]
-      if (!agent) {
-        task.status = 'failed'
-        task.deadLetteredAt = Date.now()
-        task.error = `Agent ${task.agentId} not found`
-        task.updatedAt = Date.now()
-        saveTasks(latestTasks)
-        pushMainLoopEventToMainSessions({
-          type: 'task_failed',
-          text: `Task failed: "${task.title}" (${task.id}) — agent not found.`,
-        })
-        return
-      }
-
-      // Capability matching — reroute if assigned agent doesn't have required capabilities
-      const reqCaps = Array.isArray(task.requiredCapabilities) ? task.requiredCapabilities as string[] : []
-      if (reqCaps.length > 0 && !matchesCapabilities(agent.capabilities, reqCaps)) {
-        const candidates = filterAgentsByCapabilities(agents, reqCaps)
-          .filter((a) => a.id !== agent!.id && !a.disabled)
-        if (candidates.length > 0) {
-          // Pick best match by capability score, then alphabetically for stability
-          candidates.sort((a, b) => {
-            const scoreA = capabilityMatchScore(a.capabilities, reqCaps)
-            const scoreB = capabilityMatchScore(b.capabilities, reqCaps)
-            if (scoreB !== scoreA) return scoreB - scoreA
-            return a.name.localeCompare(b.name)
-          })
-          const rerouted = candidates[0]
-          log.info(TAG, `[queue] Rerouting task "${task.title}" (${taskId}) from agent "${agent.name}" to "${rerouted.name}" — capability match`)
-          task.agentId = rerouted.id
-          agent = rerouted
-        } else {
-          task.status = 'failed'
-          task.deadLetteredAt = Date.now()
-          task.error = `No agent matches required capabilities: [${reqCaps.join(', ')}]`
-          task.updatedAt = Date.now()
-          saveTasks(latestTasks)
-          pushMainLoopEventToMainSessions({
-            type: 'task_failed',
-            text: `Task failed: "${task.title}" (${task.id}) — no agent matches required capabilities [${reqCaps.join(', ')}].`,
-          })
-          return
-        }
-      }
-
-      if (isAgentDisabled(agent)) {
-        const now = Date.now()
-        task.deferredReason = buildAgentDisabledMessage(agent, 'process queued tasks')
-        task.status = 'deferred'
-        task.updatedAt = now
-        task.retryScheduledAt = null
-        saveTasks(latestTasks)
-        notify('tasks')
-        pushMainLoopEventToMainSessions({
-          type: 'task_deferred',
-          text: `Task deferred: "${task.title}" (${task.id}) — agent ${task.agentId} is disabled.`,
-        })
-        return
-      }
-
-      // Budget enforcement gate
-      const typedAgent = agent as Agent
-      if (typedAgent.monthlyBudget || typedAgent.dailyBudget || typedAgent.hourlyBudget) {
-        try {
-          const budgetCheck = checkAgentBudgetLimits(typedAgent)
-          if (!budgetCheck.ok) {
-            const now = Date.now()
-            const exceeded = budgetCheck.exceeded[0]
-            task.status = 'deferred'
-            task.deferredReason = exceeded?.message || 'Agent budget exceeded'
-            task.retryScheduledAt = null
-            task.updatedAt = now
-            saveTasks(latestTasks)
-            notify('tasks')
-
-            recordSupervisorIncident({
-              runId: task.id,
-              sessionId: task.sessionId || '',
-              taskId: task.id,
-              agentId: typedAgent.id,
-              source: 'task',
-              kind: 'budget_pressure',
-              severity: 'high',
-              summary: exceeded?.message || `Agent "${typedAgent.name}" budget exceeded, task deferred.`,
-              autoAction: 'budget_trim',
-            })
-            return
-          }
-        } catch {}
-      }
-
-      const beforeStartTasks = loadTasks() as Record<string, BoardTask>
-      task = beforeStartTasks[taskId] as BoardTask | undefined
-      if (!task || task.status !== 'queued') {
-        return
-      }
-
-      // Mark as running
-      applyTaskPolicyDefaults(task)
-      task.status = 'running'
-      task.startedAt = Date.now()
-      task.lastActivityAt = Date.now()
-      task.retryScheduledAt = null
-      task.deadLetteredAt = null
-      // Clear transient failure fields so validation/error state reflects only this attempt.
-      task.error = null
-      task.validation = null
-      task.updatedAt = Date.now()
-      logActivity({ entityType: 'task', entityId: taskId, action: 'running', actor: 'system', actorId: task.agentId, summary: `Task started: "${task.title}"` })
-
-      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'
-      const sourceScheduleId = typeof scheduleTask.sourceScheduleId === 'string'
-        ? scheduleTask.sourceScheduleId
-        : ''
-      const reusableTaskSessionId = resolveReusableTaskSessionId(task, beforeStartTasks, sessionsForCwd)
-      const resumeContext = resolveTaskResumeContext(task, beforeStartTasks, sessionsForCwd as Record<string, SessionLike | Session>)
-
-      // Resolve the agent's persistent thread session to use as parentSessionId
-      const agentThreadSessionId = agent.threadSessionId || null
-      const taskRoutePreferences = deriveTaskRoutePreferences(task)
-
-      if (isScheduleTask && sourceScheduleId) {
-        const schedules = loadSchedules()
-        const linkedSchedule = schedules[sourceScheduleId]
-        const linkedScheduleRecord = linkedSchedule as unknown as Record<string, unknown> | undefined
-        const existingSessionId = typeof linkedScheduleRecord?.lastSessionId === 'string'
-          ? linkedScheduleRecord.lastSessionId
-          : ''
-        if (existingSessionId) {
-          const sessions = loadSessions()
-          if (sessions[existingSessionId]) {
-            sessionId = existingSessionId
-          }
-        }
-        if (!sessionId) {
-          sessionId = createAgentTaskSession(
-            agent,
-            task.title,
-            agentThreadSessionId || undefined,
-            taskCwd,
-            taskRoutePreferences,
-          )
-        }
-        if (linkedScheduleRecord && linkedScheduleRecord.lastSessionId !== sessionId) {
-          linkedScheduleRecord.lastSessionId = sessionId
-          linkedScheduleRecord.updatedAt = Date.now()
-          const updatedLinkedSchedule = linkedScheduleRecord as unknown as typeof linkedSchedule
-          schedules[sourceScheduleId] = updatedLinkedSchedule
-          saveSchedules(schedules)
-        }
-      } else {
-        sessionId = reusableTaskSessionId || createAgentTaskSession(
-          agent,
-          task.title,
-          agentThreadSessionId || undefined,
-          taskCwd,
-          taskRoutePreferences,
-        )
-      }
-
-      const executionSessions = loadSessions() as Record<string, Session>
-      const executionSession = executionSessions[sessionId]
-      const seededResumeState = executionSession
-        ? applyTaskResumeStateToSession(executionSession, resumeContext?.resume)
-        : false
-      if (seededResumeState) saveSessions(executionSessions)
-
-      task.sessionId = sessionId
-      const reusedExistingSession = !isScheduleTask && Boolean(reusableTaskSessionId) && reusableTaskSessionId === sessionId
-      const continuationBits: string[] = []
-      if (reusedExistingSession) {
-        continuationBits.push('reusing prior session')
-      }
-      if (resumeContext?.source === 'delegated_from_task' || resumeContext?.source === 'blocked_by') {
-        continuationBits.push(`seeded from task ${resumeContext.sourceTaskId}`)
-      } else if (seededResumeState) {
-        continuationBits.push('restored CLI resume handles')
-      }
-      task.checkpoint = {
-        lastSessionId: sessionId,
-        note: `Attempt ${(task.attempts || 0) + 1}/${task.maxAttempts || '?'} started${continuationBits.length ? ` (${continuationBits.join('; ')})` : ''}`,
-        updatedAt: Date.now(),
-      }
-      saveTasks(beforeStartTasks)
-      noteMissionTaskStarted(task, task.id)
-      pushMainLoopEventToMainSessions({
-        type: 'task_running',
-        text: `Task running: "${task.title}" (${task.id}) with ${agent.name}`,
-      })
-
-      // Save initial assistant message so user sees context when opening the session
-      const sessions = loadSessions()
-      if (sessions[sessionId]) {
-        const isDelegation = (task as unknown as Record<string, unknown>).sourceType === 'delegation'
-        let initialText: string
-        if (isDelegation) {
-          const delegatorId = (task as unknown as Record<string, unknown>).delegatedByAgentId as string | undefined
-          const delegator = delegatorId ? agents[delegatorId] : null
-          const prefix = `[delegation-source:${delegatorId || ''}:${delegator?.name || 'Agent'}:${delegator?.avatarSeed || ''}]`
-          initialText = `${prefix}\nDelegated by **${delegator?.name || 'another agent'}** | [${task.title}](#task:${task.id})\n\n${task.description || ''}\n\nWorking directory: \`${taskCwd}\`${buildTaskContinuationNote(Boolean(reusedExistingSession), resumeContext)}\n\nI'll begin working on this now.`
-        } else {
-          initialText = `Starting task: **${task.title}**\n\n${task.description || ''}\n\nWorking directory: \`${taskCwd}\`${buildTaskContinuationNote(Boolean(reusedExistingSession), resumeContext)}\n\nI'll begin working on this now.`
-        }
-        // Inject upstream task results context
-        if (Array.isArray(task.upstreamResults) && task.upstreamResults.length > 0) {
-          const upstreamBlock = task.upstreamResults
-            .map((ur) => `### ${ur.taskTitle}\n${ur.resultPreview || '(no result)'}`)
-            .join('\n\n')
-          initialText += `\n\n## Context from upstream tasks\n\n${upstreamBlock}`
-        }
-        sessions[sessionId].messages.push({
-          role: 'assistant',
-          text: initialText,
-          time: Date.now(),
-          ...(isDelegation ? { kind: 'system' as const } : {}),
-        })
-        saveSessions(sessions)
-      }
-
-      log.info(TAG, `[queue] Running task "${task.title}" (${taskId}) with ${agent.name}`)
-
-      try {
-        const taskRunId = `${taskId}:attempt-${(task.attempts || 0) + 1}`
-        const endTaskRunPerf = perf.start('queue', 'executeTaskRun', { taskId, agentName: agent.name })
-        const taskRun = await executeTaskRun(task, agent, sessionId)
-        endTaskRunPerf()
-        // Update lastActivityAt after execution completes (idle timeout tracking)
-        {
-          const latestTasks = loadTasks() as Record<string, BoardTask>
-          const updatedTask = latestTasks[taskId]
-          if (updatedTask) {
-            updatedTask.lastActivityAt = Date.now()
-            saveTasks(latestTasks)
-          }
-        }
-        const result = taskRun.error
-          ? (taskRun.text || `Error: ${taskRun.error}`)
-          : taskRun.text
-        const t2 = loadTasks()
-        const settings = loadSettings()
-        if (isCancelledTask(t2[taskId])) {
-          disableSessionHeartbeat(t2[taskId].sessionId)
-          notify('tasks')
-          notify('runs')
-          queueTaskAutonomyObservation({
-            runId: taskRunId,
-            sessionId,
-            taskId,
-            agentId: agent.id,
-            status: 'cancelled',
-            error: t2[taskId].error || 'Task cancelled',
-            toolEvents: taskRun.toolEvents,
-            sourceMessage: task.description || task.title,
-          })
-          log.warn(TAG, `[queue] Task "${task.title}" cancelled during execution`)
-          return
-        }
-        if (t2[taskId]) {
-          applyTaskPolicyDefaults(t2[taskId])
-          // Structured extraction: Zod-validated result with typed artifacts
-          const runSessions = loadSessions()
-          const taskResult = extractTaskResult(
-            runSessions[sessionId],
-            result || null,
-            { sinceTime: typeof t2[taskId].startedAt === 'number' ? t2[taskId].startedAt : null },
-          )
-          const enrichedResult = formatResultBody(taskResult)
-          t2[taskId].result = enrichedResult.slice(0, 4000) || null
-          t2[taskId].artifacts = taskResult.artifacts.slice(0, 24)
-          t2[taskId].outputFiles = extractLikelyOutputFiles(enrichedResult).slice(0, 24)
-          t2[taskId].updatedAt = Date.now()
-          const { validation } = refreshTaskCompletionValidation(t2[taskId], settings)
-
-          const now = Date.now()
-          // Add a completion/failure comment from the executing agent.
-          if (!t2[taskId].comments) t2[taskId].comments = []
-
-          if (validation.ok) {
-            markValidatedTaskCompleted(t2[taskId], { now })
-            t2[taskId].retryScheduledAt = null
-            t2[taskId].checkpoint = {
-              ...(t2[taskId].checkpoint || {}),
-              lastRunId: sessionId,
-              lastSessionId: sessionId,
-              note: `Completed on attempt ${t2[taskId].attempts || 0}/${t2[taskId].maxAttempts || '?'}`,
-              updatedAt: now,
-            }
-            t2[taskId].comments!.push({
-              id: genId(),
-              author: agent.name,
-              agentId: agent.id,
-              text: `Task completed.\n\n${result?.slice(0, 1000) || 'No summary provided.'}`,
-              createdAt: now,
-            })
-          } else {
-            const failureReason = formatValidationFailure(validation.reasons).slice(0, 500)
-            const retryState = scheduleRetryOrDeadLetter(t2[taskId], failureReason)
-            t2[taskId].completedAt = retryState === 'dead_lettered' ? null : t2[taskId].completedAt
-            t2[taskId].comments!.push({
-              id: genId(),
-              author: agent.name,
-              agentId: agent.id,
-              text: `Task failed validation and was not marked completed.\n\n${validation.reasons.map((r) => `- ${r}`).join('\n')}`,
-              createdAt: now,
-            })
-            if (retryState === 'retry') {
-              const qRetry = loadQueue()
-              pushQueueUnique(qRetry, taskId)
-              saveQueue(qRetry)
-              pushMainLoopEventToMainSessions({
-                type: 'task_retry_scheduled',
-                text: `Task retry scheduled: "${task.title}" (${taskId}) attempt ${t2[taskId].attempts}/${t2[taskId].maxAttempts} in ${t2[taskId].retryBackoffSec}s.`,
-              })
-            }
-          }
-
-          // Copy ALL CLI resume IDs from the execution session to the task record
-          try {
-            const execSessions = loadSessions()
-            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 }
-                | 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
-              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
-              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'
-              }
-              log.info(TAG, `[queue] CLI resume IDs for task ${taskId}: claude=${claudeId}, codex=${codexId}, opencode=${opencodeId}, gemini=${geminiId}`)
-            }
-          } catch (e) {
-            log.warn(TAG, `[queue] Failed to extract CLI resume IDs for task ${taskId}:`, e)
-          }
-
-          saveTasks(t2)
-          notify('tasks')
-          notify('runs')
-          disableSessionHeartbeat(t2[taskId].sessionId)
-        }
-        const doneTask = t2[taskId]
-        if (doneTask?.status === 'completed') {
-          noteMissionTaskFinished(doneTask, 'completed', taskRunId)
-        } else if (doneTask?.status === 'failed') {
-          noteMissionTaskFinished(doneTask, 'failed', taskRunId)
-        } else if (doneTask?.status === 'cancelled') {
-          noteMissionTaskFinished(doneTask, 'cancelled', taskRunId)
-        }
-        queueTaskAutonomyObservation({
-          runId: taskRunId,
-          sessionId,
-          taskId,
-          agentId: agent.id,
-          status: doneTask?.status === 'completed'
-            ? 'completed'
-            : doneTask?.status === 'cancelled'
-              ? 'cancelled'
-              : 'failed',
-          resultText: doneTask?.result || result || null,
-          error: doneTask?.status === 'completed' ? null : (doneTask?.error || taskRun.error || null),
-          toolEvents: taskRun.toolEvents,
-          sourceMessage: task.description || task.title,
-        })
-        if (doneTask?.status === 'completed') {
-          pushMainLoopEventToMainSessions({
-            type: 'task_completed',
-            text: `Task completed: "${task.title}" (${taskId})`,
-          })
-          notifyOrchestrators(`Task completed: "${task.title}"`, `task-complete:${taskId}`)
-          handleTerminalTaskResultDeliveries(doneTask)
-          cleanupTerminalOneOffSchedule(doneTask)
-          // Clean up LangGraph checkpoints for completed tasks
-          getCheckpointSaver().deleteThread(taskId).catch((e) =>
-            log.warn(TAG, `[queue] Failed to clean up checkpoints for task ${taskId}:`, e)
-          )
-          // Cascade unblock: auto-queue tasks whose blockers are all done
-          const latestTasks = loadTasks()
-          const unblockedIds = cascadeUnblock(latestTasks, taskId)
-          if (unblockedIds.length > 0) {
-            saveTasks(latestTasks)
-            for (const uid of unblockedIds) {
-              enqueueTask(uid)
-              log.info(TAG, `[queue] Auto-unblocked task "${latestTasks[uid]?.title}" (${uid})`)
-            }
-            notify('tasks')
-          }
-          // Wake waiting protocol runs when a linked task completes
-          if (latestTasks[taskId]?.protocolRunId) {
-            try {
-              const { wakeProtocolRunFromTaskCompletion } = await import('@/lib/server/protocols/protocol-service')
-              wakeProtocolRunFromTaskCompletion(taskId)
-            } catch (e) {
-              log.warn(TAG, `[queue] Failed to wake protocol run for task ${taskId}:`, e)
-            }
-          }
-          log.info(TAG, `[queue] Task "${task.title}" completed`)
-        } else if (doneTask?.status === 'cancelled') {
-          log.warn(TAG, `[queue] Task "${task.title}" cancelled during execution`)
-        } else {
-          if (doneTask?.status === 'queued') {
-            log.warn(TAG, `[queue] Task "${task.title}" scheduled for retry`)
-          } else {
-            pushMainLoopEventToMainSessions({
-              type: 'task_failed',
-              text: `Task failed validation: "${task.title}" (${taskId})`,
-            })
-            notifyOrchestrators(`Task failed: "${task.title}" — validation failure`, `task-fail:${taskId}`)
-            if (doneTask?.status === 'failed') {
-              handleTerminalTaskResultDeliveries(doneTask)
-              cleanupTerminalOneOffSchedule(doneTask)
-            }
-            log.warn(TAG, `[queue] Task "${task.title}" failed completion validation`)
-          }
-        }
-      } catch (err: unknown) {
-        const errMsg = err instanceof Error ? err.message : String(err || 'Unknown error')
-        log.error(TAG, `[queue] Task "${task.title}" failed:`, errMsg)
-        const taskRunId = `${taskId}:attempt-${(task.attempts || 0) + 1}`
-        const t2 = loadTasks()
-        if (isCancelledTask(t2[taskId])) {
-          disableSessionHeartbeat(t2[taskId].sessionId)
-          notify('tasks')
-          notify('runs')
-          queueTaskAutonomyObservation({
-            runId: taskRunId,
-            sessionId,
-            taskId,
-            agentId: agent.id,
-            status: 'cancelled',
-            error: t2[taskId].error || errMsg,
-            sourceMessage: task.description || task.title,
-          })
-          log.warn(TAG, `[queue] Task "${task.title}" aborted because it was cancelled`)
-          return
-        }
-        if (t2[taskId]) {
-          applyTaskPolicyDefaults(t2[taskId])
-
-          // Auto-repair: attempt a repair turn before retrying if a repairPrompt is available
-          const failureClassification = classifyRuntimeFailure({ source: 'task', message: errMsg })
-          if (failureClassification.repairPrompt && t2[taskId].sessionId) {
-            try {
-              const repairRunId = `repair:${taskId}:${Date.now()}`
-              t2[taskId].repairRunId = repairRunId
-              t2[taskId].lastRepairAttemptAt = Date.now()
-              saveTasks(t2)
-              await executeSessionChatTurn({
-                sessionId: t2[taskId].sessionId!,
-                message: `[AUTO-REPAIR] ${failureClassification.repairPrompt}\n\nOriginal error: ${errMsg.slice(0, 300)}`,
-                internal: true,
-                source: 'task-repair',
-                runId: repairRunId,
-              })
-              log.info(TAG, `[queue] Repair turn completed for task "${task.title}" (${taskId})`)
-            } catch (repairErr: unknown) {
-              log.warn(TAG, `[queue] Repair turn failed for task "${task.title}":`, repairErr instanceof Error ? repairErr.message : String(repairErr))
-              // If repair fails, attempt guardian recovery
-              const taskCwd = t2[taskId].cwd || WORKSPACE_DIR
-              prepareGuardianRecovery({
-                cwd: taskCwd,
-                reason: `Auto-repair failed for task "${task.title}": ${errMsg.slice(0, 200)}`,
-                requester: agent.id,
-              })
-            }
-          }
-
-          // Reload tasks after the async repair turn to avoid overwriting concurrent mutations
-          const t3 = loadTasks()
-          // Carry forward repair fields that were saved before the async turn
-          if (t2[taskId].repairRunId && t3[taskId]) {
-            t3[taskId].repairRunId = t2[taskId].repairRunId
-            t3[taskId].lastRepairAttemptAt = t2[taskId].lastRepairAttemptAt
-          }
-          const retryState = scheduleRetryOrDeadLetter(t3[taskId], errMsg.slice(0, 500) || 'Unknown error')
-          if (!t3[taskId].comments) t3[taskId].comments = []
-          // Only add a failure comment if the last comment isn't already an error comment
-          const lastComment = t3[taskId].comments!.at(-1)
-          const isRepeatError = lastComment?.agentId === agent.id && lastComment?.text.startsWith('Task failed')
-          if (!isRepeatError) {
-            t3[taskId].comments!.push({
-              id: genId(),
-              author: agent.name,
-              agentId: agent.id,
-              text: 'Task failed — see error details above.',
-              createdAt: Date.now(),
-            })
-          }
-          saveTasks(t3)
-          if (t3[taskId].status === 'failed') {
-            noteMissionTaskFinished(t3[taskId], 'failed', taskRunId)
-          } else if (t3[taskId].status === 'cancelled') {
-            noteMissionTaskFinished(t3[taskId], 'cancelled', taskRunId)
-          }
-          notify('tasks')
-          notify('runs')
-          disableSessionHeartbeat(t3[taskId].sessionId)
-          if (retryState === 'retry') {
-            const qRetry = loadQueue()
-            pushQueueUnique(qRetry, taskId)
-            saveQueue(qRetry)
-            pushMainLoopEventToMainSessions({
-              type: 'task_retry_scheduled',
-              text: `Task retry scheduled: "${task.title}" (${taskId}) attempt ${t3[taskId].attempts}/${t3[taskId].maxAttempts}.`,
-            })
-          }
-        }
-        queueTaskAutonomyObservation({
-          runId: taskRunId,
-          sessionId,
-          taskId,
-          agentId: agent.id,
-          status: 'failed',
-          error: errMsg,
-          sourceMessage: task.description || task.title,
-        })
-        const latest = loadTasks()[taskId] as BoardTask | undefined
-        if (latest?.status === 'queued') {
-          log.warn(TAG, `[queue] Task "${task.title}" queued for retry after error`)
-        } else if (latest?.status === 'cancelled') {
-          log.warn(TAG, `[queue] Task "${task.title}" stayed cancelled after abort`)
-        } else {
-          pushMainLoopEventToMainSessions({
-            type: 'task_failed',
-            text: `Task failed: "${task.title}" (${taskId}) — ${errMsg.slice(0, 200)}`,
-          })
-          if (latest?.status === 'failed') {
-            handleTerminalTaskResultDeliveries(latest)
-            cleanupTerminalOneOffSchedule(latest)
-          }
-        }
-      }
-    }
-  } finally {
-    _queueState.activeCount--
-    endQueuePerf()
-    // Kick next worker if more work is available or was requested
-    const remainingQueue = loadQueue()
-    if (remainingQueue.length > 0 || _queueState.pendingKick) {
-      _queueState.pendingKick = false
-      setTimeout(() => processNext(), 0)
-    }
-  }
-}
-
-/** On boot, disable heartbeat on sessions whose tasks are already terminal. */
-export function cleanupFinishedTaskSessions() {
-  const tasks = loadTasks()
-  const sessions = loadSessions()
-  let cleaned = 0
-  for (const task of Object.values(tasks) as BoardTask[]) {
-    if ((task.status === 'completed' || task.status === 'failed' || task.status === 'cancelled') && task.sessionId) {
-      const session = sessions[task.sessionId]
-      if (session && session.heartbeatEnabled !== false) {
-        session.heartbeatEnabled = false
-        session.lastActiveAt = Date.now()
-        cleaned++
-      }
-    }
-  }
-  if (cleaned > 0) {
-    saveSessions(sessions)
-    log.info(TAG, `[queue] Disabled heartbeat on ${cleaned} session(s) with finished tasks`)
-  }
-}
-
-/** Recover running tasks that appear stalled and requeue/dead-letter them per retry policy. */
-export function recoverStalledRunningTasks(): { recovered: number; deadLettered: number } {
-  const finished = reconcileFinishedRunningTasks()
-  const settings = loadSettings()
-  const stallTimeoutMin = normalizeInt(settings.taskStallTimeoutMin, 45, 5, 24 * 60)
-  const staleMs = stallTimeoutMin * 60_000
-  const idleTimeoutMin = normalizeInt((settings as Record<string, unknown>).taskIdleTimeoutMin, 15, 2, 120)
-  const idleMs = idleTimeoutMin * 60_000
-  const now = Date.now()
-  const tasks = loadTasks()
-  const queue = loadQueue()
-  let recovered = finished.reconciled
-  let deadLettered = finished.deadLettered
-  let changed = false
-
-  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 = Date.now() + 30_000
-      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
-    }
-    // Existing stall check (overall timeout based on updatedAt/startedAt)
-    const since = Math.max(task.updatedAt || 0, task.startedAt || 0)
-    const isStalled = since > 0 && (now - since) >= staleMs
-
-    // Idle check (no LLM output for idleTimeoutMin)
-    const lastActivity = task.lastActivityAt || task.startedAt || 0
-    const idleDuration = lastActivity > 0 ? now - lastActivity : 0
-    const isIdle = lastActivity > 0 && idleDuration >= idleMs
-
-    if (!isStalled && !isIdle) continue
-
-    const reason = isIdle
-      ? `Idle timeout: no output for ${Math.round(idleDuration / 60_000)}m`
-      : `Detected stalled run after ${stallTimeoutMin}m without progress`
-    const state = scheduleRetryOrDeadLetter(task, reason)
-    disableSessionHeartbeat(task.sessionId)
-    changed = true
-    if (state === 'retry') {
-      pushQueueUnique(queue, task.id)
-      recovered++
-      pushMainLoopEventToMainSessions({
-        type: 'task_stall_recovered',
-        text: `Recovered stalled task "${task.title}" (${task.id}) and requeued attempt ${task.attempts}/${task.maxAttempts}.`,
-      })
-    } else {
-      deadLettered++
-      pushMainLoopEventToMainSessions({
-        type: 'task_dead_lettered',
-        text: `Task dead-lettered after stalling: "${task.title}" (${task.id}).`,
-      })
-      notifyOrchestrators(`Task failed: "${task.title}" — stalled and dead-lettered`, `task-fail:${task.id}`)
-    }
-  }
-
-  if (changed) {
-    saveTasks(tasks)
-    saveQueue(queue)
-    if (recovered > 0) {
-      setTimeout(() => processNext(), 250)
-    }
-  }
-
-  return { recovered, deadLettered }
-}
-
-let _resumeQueueCalled = false
-
-export function claimPoolTask(taskId: string, agentId: string): { success: boolean; error?: string } {
-  // Atomic claim inside a SQLite transaction to prevent concurrent double-claims
-  const result = withTransaction(() => {
-    const tasks = loadTasks() as Record<string, BoardTask>
-    const task = tasks[taskId]
-    if (!task) return { success: false as const, error: 'Task not found' }
-    if (task.assignmentMode !== 'pool') return { success: false as const, error: 'Task is not in pool mode' }
-    if (task.claimedByAgentId) return { success: false as const, error: `Task already claimed by ${task.claimedByAgentId}` }
-    if (task.status !== 'queued' && task.status !== 'backlog') return { success: false as const, error: `Task status is ${task.status}, not claimable` }
-    const candidates = Array.isArray(task.poolCandidateAgentIds) ? task.poolCandidateAgentIds : []
-    if (candidates.length > 0 && !candidates.includes(agentId)) {
-      return { success: false as const, error: 'Agent is not in the candidate pool for this task' }
-    }
-    // Capability check — reject claim if agent doesn't have required capabilities
-    const taskReqCaps = Array.isArray(task.requiredCapabilities) ? task.requiredCapabilities as string[] : []
-    if (taskReqCaps.length > 0) {
-      const allAgents = loadAgents()
-      const claimingAgent = allAgents[agentId]
-      if (!claimingAgent || !matchesCapabilities(claimingAgent.capabilities, taskReqCaps)) {
-        return { success: false as const, error: `Agent does not match required capabilities: [${taskReqCaps.join(', ')}]` }
-      }
-    }
-    task.claimedByAgentId = agentId
-    task.claimedAt = Date.now()
-    task.agentId = agentId
-    task.updatedAt = Date.now()
-    saveTasks(tasks)
-    return { success: true as const, title: task.title }
-  })
-  if (!result.success) return result
-  logActivity({ entityType: 'task', entityId: taskId, action: 'claimed', actor: 'agent', actorId: agentId, summary: `Task "${result.title}" claimed by agent ${agentId}` })
-  notify('tasks')
-  return { success: true }
-}
-
-export function listClaimableTasks(agentId: string): BoardTask[] {
-  const tasks = loadTasks() as Record<string, BoardTask>
-  return Object.values(tasks).filter((task) => {
-    if (task.assignmentMode !== 'pool') return false
-    if (task.claimedByAgentId) return false
-    if (task.status !== 'queued' && task.status !== 'backlog') return false
-    const candidates = Array.isArray(task.poolCandidateAgentIds) ? task.poolCandidateAgentIds : []
-    return candidates.length === 0 || candidates.includes(agentId)
-  })
-}
-
-/** Resume any queued tasks on server boot */
-export function resumeQueue() {
-  if (_resumeQueueCalled) return
-  _resumeQueueCalled = true
-  // Check for tasks stuck in 'queued' status but not in the queue array
-  const tasks = loadTasks()
-  const queue = loadQueue()
-  let modified = false
-  for (const task of Object.values(tasks) as BoardTask[]) {
-    if (task.status === 'queued' && !queue.includes(task.id)) {
-      applyTaskPolicyDefaults(task)
-      log.info(TAG, `[queue] Recovering stuck queued task: "${task.title}" (${task.id})`)
-      queue.push(task.id)
-      task.queuedAt = task.queuedAt || Date.now()
-      modified = true
-    }
-  }
-
-  // Orphan reap: all running tasks are orphans on fresh daemon startup
-  let recovered = 0
-  for (const task of Object.values(tasks) as BoardTask[]) {
-    if (task.status !== 'running') continue
-    const reason = 'process_lost: task was running when daemon restarted'
-    applyTaskPolicyDefaults(task)
-    const outcome = scheduleRetryOrDeadLetter(task, reason)
-    if (outcome === 'retry') {
-      pushQueueUnique(queue, task.id)
-    }
-    if (!task.comments) task.comments = []
-    task.comments.push({
-      id: genId(),
-      author: 'System',
-      text: `Orphan recovery: ${reason}`,
-      createdAt: Date.now(),
-    })
-    modified = true
-    recovered++
-  }
-  if (recovered > 0) {
-    log.info(TAG, `[queue] Recovered ${recovered} orphaned running task(s) on boot`)
-  }
-
-  if (modified) {
-    saveQueue(queue)
-    saveTasks(tasks)
-  }
-
-  if (queue.length > 0) {
-    log.info(TAG, `[queue] Resuming ${queue.length} queued task(s) on boot`)
-    processNext()
-  }
-}
-
-/** Re-queue deferred tasks whose agents are now available. */
-export function promoteDeferred(agentId?: string): number {
-  const tasks = loadTasks() as Record<string, BoardTask>
-  const agents = loadAgents()
-  const queue = loadQueue()
-  let promoted = 0
-
-  for (const task of Object.values(tasks)) {
-    if (task.status !== 'deferred') continue
-    if (agentId && task.agentId !== agentId) continue
-
-    const agent = agents[task.agentId]
-    if (!agent || isAgentDisabled(agent as Agent)) continue
-
-    // Check budget if applicable
-    const typedAgent = agent as Agent
-    if (typedAgent.monthlyBudget || typedAgent.dailyBudget || typedAgent.hourlyBudget) {
-      try {
-        const check = checkAgentBudgetLimits(typedAgent)
-        if (!check.ok) continue // still over budget
-      } catch {}
-    }
-
-    task.status = 'queued'
-    task.deferredReason = null
-    task.updatedAt = Date.now()
-    pushQueueUnique(queue, task.id)
-    promoted++
-  }
-
-  if (promoted > 0) {
-    saveTasks(tasks)
-    saveQueue(queue)
-    notify('tasks')
-    setTimeout(() => processNext(), 0)
-  }
-  return promoted
-}
+export * from './queue/followups'
+export * from './queue/queries'
+export * from './queue/execution'
+export * from './queue/recovery'
+export * from './queue/claims'