@swarmclawai/swarmclaw 0.3.1 → 0.4.5

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

@@ -1,14 +1,19 @@
 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 crypto from 'crypto'
-import type { Agent, TaskComment } from '@/types'
-
-const NON_LANGGRAPH_PROVIDER_IDS = new Set(['claude-cli', 'codex-cli', 'opencode-cli'])
+import { getCheckpointSaver } from './langgraph-checkpoint'
+import { notify } from './ws-hub'
+import { pushMainLoopEventToMainSessions } from './main-agent-loop'
+import { genId } from '@/lib/id'
+import { NON_LANGGRAPH_PROVIDER_IDS } from '@/lib/provider-sets'
+import type { Agent, TaskComment, MessageToolEvent } from '@/types'
 
 function resolveCredential(credentialId: string | null | undefined): string | null {
   if (!credentialId) return null
@@ -73,11 +78,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)
 }
@@ -86,16 +91,15 @@ function saveMessage(sessionId: string, role: 'user' | 'assistant', text: string
 async function executeSubTaskViaCli(agent: Agent, task: string, parentSessionId: string): Promise<string> {
   // Dynamic import to avoid circular deps
   const { callProvider } = await import('./orchestrator')
-  const crypto = await import('crypto')
   const { loadSessions: ls, saveSessions: ss } = await import('./storage')
 
   const sessions = ls()
   const parentSession = sessions[parentSessionId]
-  const childId = crypto.randomBytes(4).toString('hex')
+  const childId = genId()
   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 +140,7 @@ export async function executeLangGraphOrchestrator(
   orchestrator: Agent,
   task: string,
   sessionId: string,
+  taskId?: string,
 ): Promise<string> {
   const allAgents = loadAgents()
 
@@ -165,9 +170,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
     },
     {
@@ -263,7 +271,7 @@ export async function executeLangGraphOrchestrator(
       if (!t) return `Task "${taskId}" not found.`
       if (!t.comments) t.comments = []
       const c: TaskComment = {
-        id: crypto.randomBytes(4).toString('hex'),
+        id: genId(),
         author: orchestrator.name,
         agentId: orchestrator.id,
         text: comment,
@@ -288,7 +296,7 @@ export async function executeLangGraphOrchestrator(
   const createTaskTool = tool(
     async ({ title, description: desc }) => {
       const tasks = loadTasks()
-      const id = crypto.randomBytes(4).toString('hex')
+      const id = genId()
       tasks[id] = {
         id,
         title,
@@ -369,12 +377,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 +489,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 +518,65 @@ 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) {
+          // Try OpenClaw approval bridge first when agent uses openclaw provider
+          try {
+            if (orchestrator.provider === 'openclaw') {
+              const { forwardApprovalToOpenClaw } = await import('./openclaw-approvals')
+              const toolName = pendingCall.name || pendingCall.function?.name || 'unknown'
+              const toolArgs = pendingCall.args || (pendingCall.function?.arguments ? JSON.parse(pendingCall.function.arguments) : {})
+              const decision = await forwardApprovalToOpenClaw({ toolName, args: toolArgs })
+              if (decision) {
+                if (decision.approved) {
+                  // OpenClaw approved — resume the graph instead of pausing
+                  console.log(`[orchestrator-lg] OpenClaw approved tool "${toolName}" — resuming graph`)
+                  // Don't set pendingApproval, let the loop continue
+                } else {
+                  console.log(`[orchestrator-lg] OpenClaw rejected tool "${toolName}": ${decision.reason || 'no reason'}`)
+                  // Fall through to SwarmClaw's pendingApproval UI
+                }
+              }
+              // If decision is null (socket unavailable), fall through to SwarmClaw UI
+            }
+          } catch {
+            // OpenClaw approval bridge not available — fall through
+          }
+
+          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 +592,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: genId(),
+        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 = genId()
+      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

@@ -1,8 +1,9 @@
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 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'
@@ -19,11 +20,11 @@ export function createOrchestratorSession(
   cwd?: string,
 ): string {
   const sessions = loadSessions()
-  const sessionId = crypto.randomBytes(4).toString('hex')
+  const sessionId = genId()
   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) {
@@ -244,11 +264,11 @@ async function executeSubTask(
   // Look up parent session cwd to inherit
   const sessions = loadSessions()
   const parentSession = sessions[parentSessionId]
-  const childId = crypto.randomBytes(4).toString('hex')
+  const childId = genId()
   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,
@@ -305,12 +325,12 @@ export async function callProvider(
 
   // Build a mock session for the provider
   const mockSession = {
-    id: 'orch-' + crypto.randomBytes(2).toString('hex'),
+    id: 'orch-' + genId(2),
     provider: agent.provider,
     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/process-manager.ts

@@ -1,4 +1,4 @@
-import crypto from 'crypto'
+import { genId } from '@/lib/id'
 import { spawn, type ChildProcessWithoutNullStreams } from 'child_process'
 
 const MAX_LOG_CHARS = 200_000
@@ -99,7 +99,7 @@ function getShellCommand(command: string): { shell: string; args: string[] } {
 }
 
 export async function startManagedProcess(opts: StartProcessOptions): Promise<StartProcessResult> {
-  const id = crypto.randomBytes(8).toString('hex')
+  const id = genId(8)
   const timeoutMs = Math.max(1000, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS)
   const yieldMs = Math.max(250, opts.yieldMs ?? DEFAULT_BACKGROUND_YIELD_MS)
   const startedAt = now()