@swarmclawai/swarmclaw 0.3.0 → 0.4.0

package/src/lib/server/orchestrator-lg.ts

@@ -1,12 +1,18 @@
 import { z } from 'zod'
 import { tool } from '@langchain/core/tools'
-import { createReactAgent } from '@langchain/langgraph/prebuilt'
+import { StateGraph, MessagesAnnotation, START, END } from '@langchain/langgraph'
+import { ToolNode } from '@langchain/langgraph/prebuilt'
+import { AIMessage } from '@langchain/core/messages'
 import { loadSessions, saveSessions, loadAgents, loadCredentials, loadSettings, loadSecrets, loadTasks, saveTasks, decryptKey, loadSkills } from './storage'
+import { WORKSPACE_DIR } from './data-dir'
 import { loadRuntimeSettings, getOrchestratorLoopRecursionLimit } from './runtime-settings'
 import { getMemoryDb } from './memory-db'
 import { buildChatModel } from './build-llm'
+import { getCheckpointSaver } from './langgraph-checkpoint'
+import { notify } from './ws-hub'
+import { pushMainLoopEventToMainSessions } from './main-agent-loop'
 import crypto from 'crypto'
-import type { Agent, TaskComment } from '@/types'
+import type { Agent, TaskComment, MessageToolEvent } from '@/types'
 
 const NON_LANGGRAPH_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli'])
 
@@ -73,11 +79,11 @@ function getSecretsForOrchestrator(orchestratorId: string): { name: string; serv
   return result
 }
 
-function saveMessage(sessionId: string, role: 'user' | 'assistant', text: string) {
+function saveMessage(sessionId: string, role: 'user' | 'assistant', text: string, toolEvents?: MessageToolEvent[]) {
   const sessions = loadSessions()
   const session = sessions[sessionId]
   if (!session) return
-  session.messages.push({ role, text, time: Date.now() })
+  session.messages.push({ role, text, time: Date.now(), ...(toolEvents?.length ? { toolEvents } : {}) })
   session.lastActiveAt = Date.now()
   saveSessions(sessions)
 }
@@ -95,7 +101,7 @@ async function executeSubTaskViaCli(agent: Agent, task: string, parentSessionId:
   sessions[childId] = {
     id: childId,
     name: `[Agent] ${agent.name}: ${task.slice(0, 40)}`,
-    cwd: parentSession?.cwd || process.cwd(),
+    cwd: parentSession?.cwd || WORKSPACE_DIR,
     user: 'system',
     provider: agent.provider,
     model: agent.model,
@@ -136,6 +142,7 @@ export async function executeLangGraphOrchestrator(
   orchestrator: Agent,
   task: string,
   sessionId: string,
+  taskId?: string,
 ): Promise<string> {
   const allAgents = loadAgents()
 
@@ -165,9 +172,12 @@ export async function executeLangGraphOrchestrator(
         return `Agent "${agentName}" not found. Available: ${agents.map((a) => a.name).join(', ')}`
       }
       console.log(`[orchestrator-lg] Delegating to ${agent.name}: ${agentTask.slice(0, 80)}`)
-      saveMessage(sessionId, 'assistant', `[Delegating to ${agent.name}]: ${agentTask}`)
       const result = await executeSubTaskViaCli(agent, agentTask, sessionId)
-      saveMessage(sessionId, 'user', `[Agent ${agent.name} result]: ${result.slice(0, 2000)}`)
+      saveMessage(sessionId, 'assistant', `Delegated to ${agent.name}: ${agentTask.slice(0, 100)}`, [{
+        name: 'delegate_to_agent',
+        input: JSON.stringify({ agentName: agent.name, agentId: agent.id, task: agentTask }),
+        output: result.slice(0, 2000),
+      }])
       return result
     },
     {
@@ -369,12 +379,102 @@ export async function executeLangGraphOrchestrator(
     taskContext,
   ].join('\n')
 
-  const agent = createReactAgent({
-    llm,
-    tools: [delegateTool, storeMemoryTool, searchMemoryTool, getSecretTool, commentOnTaskTool, createTaskTool, markCompleteTool],
-    stateModifier: systemMessage,
+  const checkpointSaver = getCheckpointSaver()
+  const isStrictMode = settings.capabilityPolicyMode === 'strict'
+  const allTools = [delegateTool, storeMemoryTool, searchMemoryTool, getSecretTool, commentOnTaskTool, createTaskTool, markCompleteTool]
+  const llmWithTools = llm.bindTools(allTools)
+  const toolNode = new ToolNode(allTools)
+
+  // Track fallback attempts for delegate_to_agent failures
+  let fallbackAttempts = 0
+  const MAX_FALLBACK_ATTEMPTS = 2
+
+  // Agent node: calls LLM with tools
+  async function agentNode(state: typeof MessagesAnnotation.State) {
+    const response = await llmWithTools.invoke([
+      { role: 'system' as const, content: systemMessage },
+      ...state.messages,
+    ])
+    return { messages: [response] }
+  }
+
+  // Router node: inspects tool results, decides next step
+  function routerNode(state: typeof MessagesAnnotation.State) {
+    const messages = state.messages
+    const lastMsg = messages[messages.length - 1]
+
+    // Check if the last tool message contains an error from delegate_to_agent
+    if (lastMsg && typeof (lastMsg as any).content === 'string') {
+      const content = (lastMsg as any).content as string
+      const isError = content.startsWith('Error:') || content.startsWith('Agent "') && content.includes('not found')
+
+      if (isError && fallbackAttempts < MAX_FALLBACK_ATTEMPTS) {
+        fallbackAttempts++
+        // Look for a delegate tool call in recent messages and try to find alternative agent
+        const failedToolCall = [...messages].reverse().find(
+          (m) => (m as any).tool_calls?.some((tc: any) => tc.name === 'delegate_to_agent')
+        )
+        if (failedToolCall) {
+          const tc = (failedToolCall as any).tool_calls?.find((tc: any) => tc.name === 'delegate_to_agent')
+          const failedAgentName = tc?.args?.agentName || 'unknown'
+          const fallbackHint = `The agent "${failedAgentName}" failed. Try delegating to a different agent with matching capabilities, or re-plan your approach. Fallback attempt ${fallbackAttempts}/${MAX_FALLBACK_ATTEMPTS}.`
+          return { messages: [new AIMessage({ content: fallbackHint })] }
+        }
+      }
+    }
+
+    // No fallback needed — pass through
+    return { messages: [] }
+  }
+
+  // Routing function: after agent node, check if there are tool calls
+  function shouldContinue(state: typeof MessagesAnnotation.State) {
+    const lastMsg = state.messages[state.messages.length - 1]
+    const toolCalls = (lastMsg as any)?.tool_calls
+    if (toolCalls && toolCalls.length > 0) {
+      return 'tools'
+    }
+    return END
+  }
+
+  // After router, decide whether to go back to agent or end
+  function afterRouter(state: typeof MessagesAnnotation.State) {
+    const messages = state.messages
+    // If router added a fallback hint, route back to agent
+    const lastMsg = messages[messages.length - 1]
+    if (lastMsg && typeof (lastMsg as any).content === 'string' && (lastMsg as any).content.includes('Fallback attempt')) {
+      return 'agent'
+    }
+    return 'agent'
+  }
+
+  // Build the StateGraph
+  const graph = new StateGraph(MessagesAnnotation)
+    .addNode('agent', agentNode)
+    .addNode('tools', toolNode)
+    .addNode('router', routerNode)
+    .addEdge(START, 'agent')
+    .addConditionalEdges('agent', shouldContinue, { tools: 'tools', [END]: END })
+    .addEdge('tools', 'router')
+    .addConditionalEdges('router', afterRouter, { agent: 'agent' })
+
+  const compiledGraph = graph.compile({
+    checkpointer: checkpointSaver,
+    ...(isStrictMode ? { interruptBefore: ['tools'] } : {}),
   })
 
+  // Export graph structure for introspection
+  ;(compiledGraph as any).__graphStructure = {
+    nodes: ['agent', 'tools', 'router'],
+    edges: [
+      { from: START, to: 'agent' },
+      { from: 'agent', to: 'tools', condition: 'has_tool_calls' },
+      { from: 'agent', to: END, condition: 'no_tool_calls' },
+      { from: 'tools', to: 'router' },
+      { from: 'router', to: 'agent', condition: 'fallback_or_continue' },
+    ],
+  }
+
   // Save initial user message
   saveMessage(sessionId, 'user', task)
 
@@ -391,9 +491,15 @@ export async function executeLangGraphOrchestrator(
     : null
 
   try {
-    const stream = await agent.stream(
+    const threadId = taskId || sessionId
+    const streamConfig = {
+      recursionLimit,
+      signal: abortController.signal,
+      configurable: { thread_id: threadId },
+    }
+    const stream = await compiledGraph.stream(
       { messages: [{ role: 'user' as const, content: task }] },
-      { recursionLimit, signal: abortController.signal },
+      streamConfig,
     )
 
     for await (const chunk of stream) {
@@ -414,6 +520,42 @@ export async function executeLangGraphOrchestrator(
         }
       }
     }
+
+    // Check for interrupt (paused before tool execution in strict mode)
+    if (isStrictMode && taskId) {
+      const state = await compiledGraph.getState({ configurable: { thread_id: threadId } })
+      const nextNodes = state?.next || []
+      if (nextNodes.includes('tools')) {
+        // Graph is paused before tool execution — extract pending tool call
+        const messages = state.values?.messages || []
+        const lastMsg = messages[messages.length - 1]
+        const toolCalls = lastMsg?.tool_calls || lastMsg?.additional_kwargs?.tool_calls || []
+        const pendingCall = toolCalls[0]
+        if (pendingCall) {
+          const tasks = loadTasks()
+          const t = tasks[taskId]
+          if (t) {
+            t.pendingApproval = {
+              toolName: pendingCall.name || pendingCall.function?.name || 'unknown',
+              args: pendingCall.args || (pendingCall.function?.arguments ? JSON.parse(pendingCall.function.arguments) : {}),
+              threadId,
+            }
+            t.updatedAt = Date.now()
+            saveTasks(tasks)
+            notify('tasks')
+            const approvalMsg = `[Awaiting approval] Tool: ${t.pendingApproval.toolName}\nArgs: ${JSON.stringify(t.pendingApproval.args).slice(0, 300)}\n\nApprove or reject in the task board.`
+            saveMessage(sessionId, 'assistant', approvalMsg)
+            notify(`messages:${sessionId}`)
+            pushMainLoopEventToMainSessions({
+              type: 'pending_approval',
+              text: `Task "${t.title}" needs approval: ${t.pendingApproval.toolName}(${JSON.stringify(t.pendingApproval.args).slice(0, 100)})`,
+            })
+            console.log(`[orchestrator-lg] Interrupt: waiting for approval of tool "${t.pendingApproval.toolName}" on task ${taskId}`)
+            return approvalMsg
+          }
+        }
+      }
+    }
   } catch (err: any) {
     const errMsg = timedOut
       ? 'Ongoing loop stopped after reaching the configured runtime limit.'
@@ -429,3 +571,242 @@ export async function executeLangGraphOrchestrator(
   const completeMatch = finalResult.match(/ORCHESTRATION_COMPLETE:\s*([\s\S]+)/)
   return completeMatch ? completeMatch[1].trim() : finalResult
 }
+
+/**
+ * Resume a paused orchestrator run after human approval.
+ * Re-creates the same agent graph and streams from the saved checkpoint.
+ */
+export async function resumeLangGraphOrchestrator(
+  orchestrator: Agent,
+  sessionId: string,
+  threadId: string,
+): Promise<string> {
+  const allAgents = loadAgents()
+  const agentIds = orchestrator.subAgentIds || []
+  const agents = agentIds.map((id) => allAgents[id]).filter(Boolean) as Agent[]
+
+  // Recreate the same tools
+  const delegateTool = tool(
+    async ({ agentName, task: agentTask }) => {
+      const agent = agents.find((a) => a.name.toLowerCase() === agentName.toLowerCase())
+      if (!agent) return `Agent "${agentName}" not found. Available: ${agents.map((a) => a.name).join(', ')}`
+      const result = await executeSubTaskViaCli(agent, agentTask, sessionId)
+      saveMessage(sessionId, 'assistant', `Delegated to ${agent.name}: ${agentTask.slice(0, 100)}`, [{
+        name: 'delegate_to_agent',
+        input: JSON.stringify({ agentName: agent.name, agentId: agent.id, task: agentTask }),
+        output: result.slice(0, 2000),
+      }])
+      return result
+    },
+    {
+      name: 'delegate_to_agent',
+      description: 'Delegate a task to one of the available agents.',
+      schema: z.object({
+        agentName: z.string().describe('Name of the agent to delegate to'),
+        task: z.string().describe('The task description for the agent'),
+      }),
+    },
+  )
+
+  const db = getMemoryDb()
+  const storeMemoryTool = tool(
+    async ({ category, title, content }) => {
+      db.add({ agentId: orchestrator.id, sessionId, category, title, content })
+      return 'Memory stored successfully.'
+    },
+    {
+      name: 'store_memory',
+      description: 'Store information in long-term memory.',
+      schema: z.object({
+        category: z.string(), title: z.string(), content: z.string(),
+      }),
+    },
+  )
+
+  const searchMemoryTool = tool(
+    async ({ query }) => {
+      const results = db.search(query, orchestrator.id)
+      if (!results.length) return 'No matching memories found.'
+      return results.map((m) => `[${m.category}] ${m.title}: ${m.content.slice(0, 300)}`).join('\n')
+    },
+    {
+      name: 'search_memory',
+      description: 'Search long-term memory.',
+      schema: z.object({ query: z.string() }),
+    },
+  )
+
+  const markCompleteTool = tool(
+    async ({ summary }) => `ORCHESTRATION_COMPLETE: ${summary}`,
+    {
+      name: 'mark_complete',
+      description: 'Signal orchestration is done.',
+      schema: z.object({ summary: z.string() }),
+    },
+  )
+
+  const availableSecrets = getSecretsForOrchestrator(orchestrator.id)
+  const getSecretTool = tool(
+    async ({ serviceName }) => {
+      const match = availableSecrets.find(
+        (s) => s.service.toLowerCase() === serviceName.toLowerCase() || s.name.toLowerCase() === serviceName.toLowerCase(),
+      )
+      if (!match) return `No secret found for "${serviceName}".`
+      return JSON.stringify({ name: match.name, service: match.service, value: match.value })
+    },
+    {
+      name: 'get_secret',
+      description: 'Retrieve a stored credential/secret by service name.',
+      schema: z.object({ serviceName: z.string() }),
+    },
+  )
+
+  const commentOnTaskTool = tool(
+    async ({ taskId, comment }) => {
+      const tasks = loadTasks()
+      const t = tasks[taskId]
+      if (!t) return `Task "${taskId}" not found.`
+      if (!t.comments) t.comments = []
+      t.comments.push({
+        id: crypto.randomBytes(4).toString('hex'),
+        author: orchestrator.name,
+        agentId: orchestrator.id,
+        text: comment,
+        createdAt: Date.now(),
+      })
+      t.updatedAt = Date.now()
+      saveTasks(tasks)
+      return `Comment added to task "${t.title}".`
+    },
+    {
+      name: 'comment_on_task',
+      description: 'Add a comment to a task.',
+      schema: z.object({ taskId: z.string(), comment: z.string() }),
+    },
+  )
+
+  const createTaskTool = tool(
+    async ({ title, description: desc }) => {
+      const tasks = loadTasks()
+      const id = crypto.randomBytes(4).toString('hex')
+      tasks[id] = {
+        id, title, description: desc, status: 'backlog',
+        agentId: orchestrator.id, sessionId: null, result: null, error: null,
+        comments: [], createdAt: Date.now(), updatedAt: Date.now(),
+        queuedAt: null, startedAt: null, completedAt: null,
+      }
+      saveTasks(tasks)
+      return `Task "${title}" created in backlog (id: ${id}).`
+    },
+    {
+      name: 'create_task',
+      description: 'Create a new task in the backlog.',
+      schema: z.object({ title: z.string(), description: z.string() }),
+    },
+  )
+
+  const engine = getOrchestrationEngineConfig(orchestrator)
+  const llm = buildChatModel({
+    provider: engine.provider, model: engine.model,
+    apiKey: engine.apiKey, apiEndpoint: engine.apiEndpoint,
+  })
+
+  const checkpointSaver = getCheckpointSaver()
+  const settings = loadSettings()
+  const isStrictMode = settings.capabilityPolicyMode === 'strict'
+
+  const allTools = [delegateTool, storeMemoryTool, searchMemoryTool, getSecretTool, commentOnTaskTool, createTaskTool, markCompleteTool]
+  const llmWithTools = llm.bindTools(allTools)
+  const toolNode = new ToolNode(allTools)
+
+  async function agentNode(state: typeof MessagesAnnotation.State) {
+    const response = await llmWithTools.invoke(state.messages)
+    return { messages: [response] }
+  }
+  function routerNode(state: typeof MessagesAnnotation.State) {
+    return { messages: [] }
+  }
+  function shouldContinue(state: typeof MessagesAnnotation.State) {
+    const lastMsg = state.messages[state.messages.length - 1]
+    const toolCalls = (lastMsg as any)?.tool_calls
+    if (toolCalls && toolCalls.length > 0) return 'tools'
+    return END
+  }
+
+  const graphAgent = new StateGraph(MessagesAnnotation)
+    .addNode('agent', agentNode)
+    .addNode('tools', toolNode)
+    .addNode('router', routerNode)
+    .addEdge(START, 'agent')
+    .addConditionalEdges('agent', shouldContinue, { tools: 'tools', [END]: END })
+    .addEdge('tools', 'router')
+    .addEdge('router', 'agent')
+    .compile({
+      checkpointer: checkpointSaver,
+      ...(isStrictMode ? { interruptBefore: ['tools'] } : {}),
+    })
+
+  let finalResult = ''
+  const runtime = loadRuntimeSettings()
+  const recursionLimit = getOrchestratorLoopRecursionLimit(runtime)
+
+  try {
+    // Resume from checkpoint with null input — the checkpoint has the full state
+    const stream = await graphAgent.stream(null, {
+      recursionLimit,
+      configurable: { thread_id: threadId },
+    })
+
+    for await (const chunk of stream) {
+      const agentChunk = (chunk as any).agent
+      if (agentChunk?.messages) {
+        const msgs = Array.isArray(agentChunk.messages) ? agentChunk.messages : [agentChunk.messages]
+        for (const msg of msgs) {
+          const text = typeof msg.content === 'string'
+            ? msg.content
+            : Array.isArray(msg.content)
+              ? msg.content.map((c: any) => c.text || '').join('')
+              : ''
+          if (text) {
+            finalResult = text
+            saveMessage(sessionId, 'assistant', text)
+          }
+        }
+      }
+    }
+
+    // Check for another interrupt
+    const state = await graphAgent.getState({ configurable: { thread_id: threadId } })
+    const nextNodes = state?.next || []
+    if (nextNodes.includes('tools')) {
+      const messages = state.values?.messages || []
+      const lastMsg = messages[messages.length - 1]
+      const toolCalls = lastMsg?.tool_calls || lastMsg?.additional_kwargs?.tool_calls || []
+      const pendingCall = toolCalls[0]
+      if (pendingCall) {
+        // Find the task by threadId
+        const tasks = loadTasks()
+        for (const t of Object.values(tasks)) {
+          if (t.pendingApproval?.threadId === threadId || t.id === threadId) {
+            t.pendingApproval = {
+              toolName: pendingCall.name || pendingCall.function?.name || 'unknown',
+              args: pendingCall.args || {},
+              threadId,
+            }
+            t.updatedAt = Date.now()
+            saveTasks(tasks)
+            notify('tasks')
+            return `Waiting for approval: ${t.pendingApproval.toolName}`
+          }
+        }
+      }
+    }
+  } catch (err: any) {
+    console.error(`[orchestrator-lg] Resume error:`, err.message || String(err))
+    saveMessage(sessionId, 'assistant', `[Error] ${err.message || String(err)}`)
+    throw err
+  }
+
+  const completeMatch = finalResult.match(/ORCHESTRATION_COMPLETE:\s*([\s\S]+)/)
+  return completeMatch ? completeMatch[1].trim() : finalResult
+}

package/src/lib/server/orchestrator.ts

@@ -3,6 +3,7 @@ import {
   loadSessions, saveSessions, loadAgents,
   loadCredentials, decryptKey, loadSettings, loadSkills,
 } from './storage'
+import { WORKSPACE_DIR } from './data-dir'
 import { loadRuntimeSettings, getLegacyOrchestratorMaxTurns } from './runtime-settings'
 import { getMemoryDb } from './memory-db'
 import { getProvider } from '../providers'
@@ -23,7 +24,7 @@ export function createOrchestratorSession(
   sessions[sessionId] = {
     id: sessionId,
     name: `[Orch] ${orchestrator.name}: ${task.slice(0, 40)}`,
-    cwd: cwd || process.cwd(),
+    cwd: cwd || WORKSPACE_DIR,
     user: 'system',
     provider: orchestrator.provider,
     model: orchestrator.model,
@@ -63,13 +64,14 @@ export async function executeOrchestrator(
   orchestrator: Agent,
   task: string,
   sessionId: string,
+  taskId?: string,
 ): Promise<string> {
   // Use LangGraph for all non-CLI providers (including OpenAI-compatible custom providers)
   const isCliProvider = orchestrator.provider === 'claude-cli' || orchestrator.provider === 'codex-cli' || orchestrator.provider === 'opencode-cli'
   if (!isCliProvider) {
     console.log(`[orchestrator] Using LangGraph engine for ${orchestrator.name} (${orchestrator.provider})`)
     const { executeLangGraphOrchestrator } = await import('./orchestrator-lg')
-    return executeLangGraphOrchestrator(orchestrator, task, sessionId)
+    return executeLangGraphOrchestrator(orchestrator, task, sessionId, taskId)
   }
 
   // claude-cli fallback (no structured tool calling)
@@ -156,7 +158,10 @@ async function executeOrchestratorLegacy(
       }
     }
 
-    const fullText = await callProvider(orchestrator, systemPrompt, conversationHistory)
+    const windowedHistory = conversationHistory.length > 10
+      ? [conversationHistory[0], ...conversationHistory.slice(-9)]
+      : conversationHistory
+    const fullText = await callProvider(orchestrator, systemPrompt, windowedHistory)
     conversationHistory.push({ role: 'assistant', text: fullText })
 
     // Save to session
@@ -189,6 +194,21 @@ async function executeOrchestratorLegacy(
           role: 'user',
           text: `[Agent ${agent.name} result]:\n${subResult}`,
         })
+        // Save structured delegation message for rich card rendering
+        session.messages.push({
+          role: 'assistant' as const,
+          text: `Delegated to ${agent.name}: ${cmd.delegate.task.slice(0, 100)}`,
+          time: Date.now(),
+          toolEvents: [{
+            name: 'delegate_to_agent',
+            input: JSON.stringify({ agentName: agent.name, agentId: agent.id, task: cmd.delegate.task }),
+            output: subResult.slice(0, 2000),
+          }],
+        })
+        session.lastActiveAt = Date.now()
+        const ds = loadSessions()
+        ds[sessionId] = session
+        saveSessions(ds)
       }
 
       if (cmd.memory_store) {
@@ -248,7 +268,7 @@ async function executeSubTask(
   const childSession = {
     id: childId,
     name: `[Agent] ${agent.name}: ${task.slice(0, 40)}`,
-    cwd: parentSession?.cwd || process.cwd(),
+    cwd: parentSession?.cwd || WORKSPACE_DIR,
     user: 'system',
     provider: agent.provider,
     model: agent.model,
@@ -310,7 +330,7 @@ export async function callProvider(
     model: agent.model,
     credentialId: agent.credentialId,
     apiEndpoint: agent.apiEndpoint,
-    cwd: process.cwd(),
+    cwd: WORKSPACE_DIR,
     tools: agent.tools || [],
     messages: history.map((h) => ({
       role: h.role as 'user' | 'assistant',

package/src/lib/server/queue.ts

@@ -1,11 +1,14 @@
 import crypto from 'crypto'
 import { loadTasks, saveTasks, loadQueue, saveQueue, loadAgents, loadSchedules, saveSchedules, loadSessions, saveSessions, loadSettings } from './storage'
+import { notify } from './ws-hub'
+import { WORKSPACE_DIR } from './data-dir'
 import { createOrchestratorSession, executeOrchestrator } from './orchestrator'
 import { formatValidationFailure, validateTaskCompletion } from './task-validation'
 import { ensureTaskCompletionReport } from './task-reports'
 import { pushMainLoopEventToMainSessions } from './main-agent-loop'
 import { executeSessionChatTurn } from './chat-execution'
 import { extractTaskResult, formatResultBody } from './task-result'
+import { getCheckpointSaver } from './langgraph-checkpoint'
 import type { Agent, BoardTask, Message } from '@/types'
 
 let processing = false
@@ -119,7 +122,7 @@ async function executeTaskRun(
 ): Promise<string> {
   const prompt = task.description || task.title
   if (agent?.isOrchestrator) {
-    return executeOrchestrator(agent, prompt, sessionId)
+    return executeOrchestrator(agent, prompt, sessionId, task.id)
   }
 
   const run = await executeSessionChatTurn({
@@ -389,7 +392,7 @@ export function validateCompletedTasksQueue() {
     }
   }
 
-  if (tasksDirty) saveTasks(tasks)
+  if (tasksDirty) { saveTasks(tasks); notify('tasks') }
   if (sessionsDirty) saveSessions(sessions)
   if (demoted > 0) {
     console.warn(`[queue] Demoted ${demoted} invalid completed task(s) to failed after validation audit`)
@@ -510,9 +513,12 @@ export async function processNext() {
       task.startedAt = 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()
 
-      const taskCwd = task.cwd || process.cwd()
+      const taskCwd = task.cwd || WORKSPACE_DIR
       let sessionId = ''
       const scheduleTask = task as ScheduleTaskMeta
       const isScheduleTask = scheduleTask.sourceType === 'schedule'
@@ -688,6 +694,8 @@ export async function processNext() {
           }
 
           saveTasks(t2)
+          notify('tasks')
+          notify('runs')
           disableSessionHeartbeat(t2[taskId].sessionId)
         }
         const doneTask = t2[taskId]
@@ -698,6 +706,10 @@ export async function processNext() {
           })
           notifyMainChatScheduleResult(doneTask)
           notifyAgentThreadTaskResult(doneTask)
+          // Clean up LangGraph checkpoints for completed tasks
+          getCheckpointSaver().deleteThread(taskId).catch((e) =>
+            console.warn(`[queue] Failed to clean up checkpoints for task ${taskId}:`, e)
+          )
           console.log(`[queue] Task "${task.title}" completed`)
         } else {
           if (doneTask?.status === 'queued') {
@@ -735,6 +747,8 @@ export async function processNext() {
             })
           }
           saveTasks(t2)
+          notify('tasks')
+          notify('runs')
           disableSessionHeartbeat(t2[taskId].sessionId)
           if (retryState === 'retry') {
             const qRetry = loadQueue()

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

@@ -31,6 +31,7 @@ interface QueueEntry {
   message: string
   imagePath?: string
   imageUrl?: string
+  attachedFiles?: string[]
   onEvents: Array<(event: SSEEvent) => void>
   signalController: AbortController
   maxRuntimeMs?: number
@@ -236,6 +237,7 @@ async function drainExecution(executionKey: string): Promise<void> {
       message: next.message,
       imagePath: next.imagePath,
       imageUrl: next.imageUrl,
+      attachedFiles: next.attachedFiles,
       internal: next.run.internal,
       source: next.run.source,
       runId: next.run.id,
@@ -333,6 +335,7 @@ export interface EnqueueSessionRunInput {
   message: string
   imagePath?: string
   imageUrl?: string
+  attachedFiles?: string[]
   internal?: boolean
   source?: string
   mode?: SessionQueueMode
@@ -384,7 +387,7 @@ export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSession
 
   const running = state.runningByExecution.get(executionKey)
   const q = queueForExecution(executionKey)
-  if (mode === 'collect' && !input.imagePath && !input.imageUrl) {
+  if (mode === 'collect' && !input.imagePath && !input.imageUrl && !input.attachedFiles?.length) {
     const nowMs = now()
     const candidate = q.at(-1)
     const canCoalesce = !!candidate
@@ -393,6 +396,7 @@ export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSession
       && candidate.run.source === source
       && !candidate.imagePath
       && !candidate.imageUrl
+      && !candidate.attachedFiles?.length
       && (nowMs - candidate.run.queuedAt) <= COLLECT_COALESCE_WINDOW_MS
 
     if (candidate && canCoalesce) {
@@ -444,6 +448,7 @@ export function enqueueSessionRun(input: EnqueueSessionRunInput): EnqueueSession
     message: input.message,
     imagePath: input.imagePath,
     imageUrl: input.imageUrl,
+    attachedFiles: input.attachedFiles,
     onEvents: input.onEvent ? [input.onEvent] : [],
     signalController: new AbortController(),
     maxRuntimeMs: effectiveMaxRuntimeMs > 0 ? effectiveMaxRuntimeMs : undefined,