@swarmclawai/swarmclaw 0.7.6 → 0.7.8

package/src/lib/server/queue.ts

@@ -13,7 +13,7 @@ import { extractTaskResult, formatResultBody } from './task-result'
 import { getCheckpointSaver } from './langgraph-checkpoint'
 import { cascadeUnblock } from './dag-validation'
 import { performGuardianRollback } from './guardian'
-import type { Agent, BoardTask, Connector, Message } from '@/types'
+import type { Agent, BoardTask, Connector, Message, Session } from '@/types'
 
 // HMR-safe: pin processing flag to globalThis so hot reloads don't reset it
 const _queueState = ((globalThis as Record<string, unknown>).__swarmclaw_queue__ ??= { processing: false, pendingKick: false }) as { processing: boolean; pendingKick: boolean }
@@ -80,6 +80,36 @@ function normalizeInt(value: unknown, fallback: number, min: number, max: number
   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)
+    ? [...new Set(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)
@@ -98,6 +128,212 @@ function applyTaskPolicyDefaults(task: BoardTask): void {
   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',
@@ -1027,7 +1263,7 @@ function scheduleRetryOrDeadLetter(task: BoardTask, reason: string): 'retry' | '
   return 'dead_lettered'
 }
 
-function dequeueNextRunnableTask(queue: string[], tasks: Record<string, BoardTask>): string | null {
+export function dequeueNextRunnableTask(queue: string[], tasks: Record<string, BoardTask>): string | null {
   const now = Date.now()
 
   // Remove stale entries first.
@@ -1041,7 +1277,9 @@ function dequeueNextRunnableTask(queue: string[], tasks: Record<string, BoardTas
     const task = tasks[id]
     if (!task) return false
     const retryAt = typeof task.retryScheduledAt === 'number' ? task.retryScheduledAt : null
-    return !retryAt || retryAt <= now
+    if (retryAt && retryAt > now) return false
+    const blockers = Array.isArray(task.blockedBy) ? task.blockedBy : []
+    return blockers.every((blockerId) => tasks[blockerId]?.status === 'completed')
   })
   if (idx === -1) return null
   const [taskId] = queue.splice(idx, 1)
@@ -1134,9 +1372,12 @@ export async function processNext() {
       const sourceScheduleId = typeof scheduleTask.sourceScheduleId === 'string'
         ? scheduleTask.sourceScheduleId
         : ''
+      const reusableTaskSessionId = resolveReusableTaskSessionId(task, tasks as Record<string, BoardTask>, sessionsForCwd)
+      const resumeContext = resolveTaskResumeContext(task, tasks as Record<string, BoardTask>, 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()
@@ -1151,7 +1392,13 @@ export async function processNext() {
           }
         }
         if (!sessionId) {
-          sessionId = createOrchestratorSession(agent, task.title, agentThreadSessionId || undefined, taskCwd)
+          sessionId = createOrchestratorSession(
+            agent,
+            task.title,
+            agentThreadSessionId || undefined,
+            taskCwd,
+            taskRoutePreferences,
+          )
         }
         if (linkedSchedule && linkedSchedule.lastSessionId !== sessionId) {
           linkedSchedule.lastSessionId = sessionId
@@ -1160,9 +1407,22 @@ export async function processNext() {
           saveSchedules(schedules)
         }
       } else {
-        sessionId = createOrchestratorSession(agent, task.title, agentThreadSessionId || undefined, taskCwd)
+        sessionId = reusableTaskSessionId || createOrchestratorSession(
+          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)
+
       // Notify the agent's thread that a task has started
       if (agentThreadSessionId) {
         try {
@@ -1188,9 +1448,19 @@ export async function processNext() {
       }
 
       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`,
+        note: `Attempt ${(task.attempts || 0) + 1}/${task.maxAttempts || '?'} started${continuationBits.length ? ` (${continuationBits.join('; ')})` : ''}`,
         updatedAt: Date.now(),
       }
       saveTasks(tasks)
@@ -1208,9 +1478,9 @@ export async function processNext() {
           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}\`\n\nI'll begin working on this now.`
+          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}\`\n\nI'll begin working on this now.`
+          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.`
         }
         sessions[sessionId].messages.push({
           role: 'assistant',

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

@@ -7,6 +7,7 @@ import { log } from './logger'
 import { isInternalHeartbeatRun } from './heartbeat-source'
 import { cleanupSessionBrowser } from './session-tools/web'
 import { cancelDelegationJobsForParentSession } from './delegation-jobs'
+import { handleMainLoopRunResult } from './main-agent-loop'
 
 export type SessionRunStatus = 'queued' | 'running' | 'completed' | 'failed' | 'cancelled'
 export type SessionQueueMode = 'followup' | 'steer' | 'collect'
@@ -276,6 +277,36 @@ async function drainExecution(executionKey: string): Promise<void> {
       error: next.run.error || null,
       durationMs: (next.run.endedAt || now()) - (next.run.startedAt || now()),
     })
+    const followup = handleMainLoopRunResult({
+      sessionId: next.run.sessionId,
+      message: next.message,
+      internal: next.run.internal,
+      source: next.run.source,
+      resultText: result.text,
+      error: next.run.error,
+      toolEvents: result.toolEvents,
+      inputTokens: result.inputTokens,
+      outputTokens: result.outputTokens,
+      estimatedCost: result.estimatedCost,
+    })
+    if (followup) {
+      setTimeout(() => {
+        try {
+          enqueueSessionRun({
+            sessionId: next.run.sessionId,
+            message: followup.message,
+            internal: true,
+            source: 'main-loop-followup',
+            mode: 'followup',
+            dedupeKey: followup.dedupeKey,
+          })
+        } catch (err: unknown) {
+          log.warn('session-run', `Main loop follow-up enqueue failed for ${next.run.sessionId}`, {
+            error: err instanceof Error ? err.message : String(err),
+          })
+        }
+      }, Math.max(0, followup.delayMs || 0))
+    }
     next.resolve(result)
   } catch (err: any) {
     const aborted = next.signalController.signal.aborted

package/src/lib/server/session-tools/connector-inputs.test.ts

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import { describe, it } from 'node:test'
+import { UPLOAD_DIR } from '../storage'
+import { resolveConnectorMediaInput } from './connector'
+
+describe('resolveConnectorMediaInput', () => {
+  it('resolves /api/uploads urls passed via mediaPath back to disk', () => {
+    const filename = `screenshot-test-${Date.now()}.png`
+    const uploadPath = path.join(UPLOAD_DIR, filename)
+    fs.mkdirSync(UPLOAD_DIR, { recursive: true })
+    fs.writeFileSync(uploadPath, 'png')
+
+    try {
+      const resolved = resolveConnectorMediaInput({
+        cwd: process.cwd(),
+        mediaPath: `/api/uploads/${filename}`,
+      })
+      assert.equal(resolved.error, undefined)
+      assert.equal(resolved.mediaPath, uploadPath)
+    } finally {
+      fs.rmSync(uploadPath, { force: true })
+    }
+  })
+
+  it('treats remote urls passed via mediaPath as sendable urls instead of local files', () => {
+    const resolved = resolveConnectorMediaInput({
+      cwd: process.cwd(),
+      mediaPath: 'https://example.com/report.pdf',
+    })
+
+    assert.equal(resolved.error, undefined)
+    assert.equal(resolved.mediaPath, undefined)
+    assert.equal(resolved.fileUrl, 'https://example.com/report.pdf')
+  })
+})

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

@@ -189,7 +189,7 @@ function pickChannelTarget(params: {
   return { channelId }
 }
 
-function resolveConnectorMediaInput(params: {
+export function resolveConnectorMediaInput(params: {
   cwd: string
   mediaPath?: string
   imageUrl?: string
@@ -199,6 +199,23 @@ function resolveConnectorMediaInput(params: {
   let resolvedImageUrl = params.imageUrl?.trim() || undefined
   let resolvedFileUrl = params.fileUrl?.trim() || undefined
 
+  // Be forgiving when the model passes a served upload URL or remote URL in mediaPath.
+  if (resolvedMediaPath?.startsWith('/api/uploads/')) {
+    const fromUpload = resolveUploadUrl(resolvedMediaPath)
+    if (fromUpload) {
+      resolvedMediaPath = fromUpload.mediaPath
+    } else {
+      return { error: `Error: File not found: ${resolvedMediaPath}` }
+    }
+  } else if (resolvedMediaPath && /^https?:\/\//i.test(resolvedMediaPath)) {
+    if (/\.(png|jpe?g|webp|gif|svg)(?:[?#].*)?$/i.test(resolvedMediaPath)) {
+      resolvedImageUrl = resolvedMediaPath
+    } else {
+      resolvedFileUrl = resolvedMediaPath
+    }
+    resolvedMediaPath = undefined
+  }
+
   if (resolvedMediaPath && !path.isAbsolute(resolvedMediaPath) && !resolvedMediaPath.startsWith('/api/uploads/')) {
     const candidatePaths = [
       path.resolve(params.cwd, resolvedMediaPath),
@@ -540,6 +557,14 @@ const ConnectorPlugin: Plugin = {
           messageId: { type: 'string' },
           targetMessage: { type: 'string', enum: ['last_inbound', 'last_outbound'] },
           emoji: { type: 'string' },
+          voiceText: { type: 'string' },
+          voiceId: { type: 'string' },
+          imageUrl: { type: 'string' },
+          fileUrl: { type: 'string' },
+          mediaPath: { type: 'string' },
+          mimeType: { type: 'string' },
+          fileName: { type: 'string' },
+          caption: { type: 'string' },
           replyToMessageId: { type: 'string' },
           threadId: { type: 'string' },
           delaySec: { type: 'number' },

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

@@ -9,6 +9,11 @@ export interface ToolContext {
   platformAssignScope?: 'self' | 'all'
   mcpServerIds?: string[]
   mcpDisabledTools?: string[]
+  projectId?: string | null
+  projectRoot?: string | null
+  projectName?: string | null
+  projectDescription?: string | null
+  memoryScopeMode?: 'auto' | 'all' | 'global' | 'agent' | 'session' | 'project' | null
 }
 
 export interface SessionToolsResult {