@swarmclawai/swarmclaw 0.6.7 → 0.7.0

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

@@ -1,788 +1,387 @@
 import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
-import { genId } from '@/lib/id'
 import { spawn, spawnSync } from 'child_process'
-import { loadAgents, loadTasks, upsertTask } from '../storage'
-import { log } from '../logger'
 import type { ToolBuildContext } from './context'
-import { truncate, tail, extractResumeIdentifier, findBinaryOnPath, MAX_OUTPUT } from './context'
+import { truncate, findBinaryOnPath, MAX_OUTPUT } from './context'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { normalizeToolInputArgs } from './normalize-tool-args'
+
+const MAX_DELEGATION_CHAIN_HOPS = 128
+
+interface DelegateContext {
+  cwd?: string
+  claudeTimeoutMs?: number
+  readStoredDelegateResumeId?: (key: 'claudeCode' | 'codex' | 'opencode') => string | null
+  persistDelegateResumeId?: (key: 'claudeCode' | 'codex' | 'opencode', id: string) => void
+  ctx?: { platformAssignScope?: string; agentId?: string | null }
+  hasTool?: (name: string) => boolean
+}
 
-export function buildDelegateTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  const tools: StructuredToolInterface[] = []
-  const { cwd, ctx, claudeTimeoutMs, cliProcessTimeoutMs, persistDelegateResumeId, readStoredDelegateResumeId } = bctx
+type DelegateBackend = 'claude' | 'codex' | 'opencode'
 
-  const wantsClaudeDelegate = bctx.hasTool('claude_code')
-  const wantsCodexDelegate = bctx.hasTool('codex_cli')
-  const wantsOpenCodeDelegate = bctx.hasTool('opencode_cli')
+function asTaskRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object' ? value as Record<string, unknown> : null
+}
 
-  if (wantsClaudeDelegate || wantsCodexDelegate || wantsOpenCodeDelegate) {
-    const claudeBinary = findBinaryOnPath('claude')
-    const codexBinary = findBinaryOnPath('codex')
-    const opencodeBinary = findBinaryOnPath('opencode')
+function parseNonNegativeInt(value: unknown): number | null {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return null
+  const int = Math.trunc(value)
+  return int >= 0 ? int : null
+}
 
-    if (wantsClaudeDelegate && !claudeBinary) {
-      log.warn('session-tools', 'Claude delegation enabled but claude binary not found', {
-        sessionId: ctx?.sessionId || null,
-        agentId: ctx?.agentId || null,
-      })
-    }
-    if (wantsCodexDelegate && !codexBinary) {
-      log.warn('session-tools', 'Codex delegation enabled but codex binary not found', {
-        sessionId: ctx?.sessionId || null,
-        agentId: ctx?.agentId || null,
-      })
-    }
-    if (wantsOpenCodeDelegate && !opencodeBinary) {
-      log.warn('session-tools', 'OpenCode delegation enabled but opencode binary not found', {
-        sessionId: ctx?.sessionId || null,
-        agentId: ctx?.agentId || null,
-      })
+function _computeDelegationDepth(
+  task: Record<string, unknown> | null,
+  tasksById: Record<string, unknown>,
+): number {
+  if (!task) return 0
+  const explicitDepth = parseNonNegativeInt(task.delegationDepth)
+  if (explicitDepth !== null) return explicitDepth
+  if (task.sourceType !== 'delegation') return 0
+
+  let depth = 1
+  let parentId = typeof task.delegatedFromTaskId === 'string' ? task.delegatedFromTaskId.trim() : ''
+  let hops = 0
+  const visited = new Set<string>()
+
+  while (parentId && hops < MAX_DELEGATION_CHAIN_HOPS && !visited.has(parentId)) {
+    visited.add(parentId)
+    const parent = asTaskRecord(tasksById[parentId])
+    if (!parent) break
+    const parentExplicitDepth = parseNonNegativeInt(parent.delegationDepth)
+    if (parentExplicitDepth !== null) {
+      depth = Math.max(depth, parentExplicitDepth + 1)
+      break
     }
+    depth++
+    parentId = typeof parent.delegatedFromTaskId === 'string' ? parent.delegatedFromTaskId.trim() : ''
+    hops++
+  }
 
-    if (claudeBinary && wantsClaudeDelegate) {
-    tools.push(
-      tool(
-        async ({ task, resume, resumeId }) => {
-          try {
-            const env: NodeJS.ProcessEnv = { ...process.env }
-            // Running inside Claude environments can block nested `claude` launches.
-            // Strip all CLAUDE* vars so delegation can run as an independent subprocess.
-            const removedClaudeEnvKeys: string[] = []
-            for (const key of Object.keys(env)) {
-              if (key.toUpperCase().startsWith('CLAUDE')) {
-                removedClaudeEnvKeys.push(key)
-                delete env[key]
-              }
-            }
+  return depth
+}
 
-            // Fast preflight: when Claude isn't authenticated, surface a clear error immediately.
-            const authProbe = spawnSync(claudeBinary, ['auth', 'status'], {
-              cwd,
-              env,
-              encoding: 'utf-8',
-              timeout: 8000,
-            })
-            if ((authProbe.status ?? 1) !== 0) {
-              let loggedIn = false
-              try {
-                const parsed = JSON.parse(authProbe.stdout || '{}') as { loggedIn?: boolean }
-                loggedIn = parsed.loggedIn === true
-              } catch {
-                // ignore parse issues and fall back to a generic auth guidance
-              }
-              if (!loggedIn) {
-                return 'Error: Claude Code CLI is not authenticated. Run `claude auth login` (or `claude setup-token`) on this machine, then retry.'
-              }
-            }
+/**
+ * Core Delegate Execution Logic
+ */
+async function executeDelegateAction(args: Record<string, unknown>, bctx: DelegateContext) {
+  const normalized = normalizeToolInputArgs(args)
+  const task = normalized.task as string
+  const backend = ((normalized.backend as string) || 'claude') as DelegateBackend
+  const resume = normalized.resume as boolean
+  const resumeId = normalized.resumeId as string
+  const backends = {
+    claude: findBinaryOnPath('claude'),
+    codex: findBinaryOnPath('codex'),
+    opencode: findBinaryOnPath('opencode'),
+  }
+  const binary = backends[backend as keyof typeof backends]
+  if (!binary) return `Error: Backend "${backend}" unavailable.`
 
-            const storedResumeId = readStoredDelegateResumeId('claudeCode')
-            const resumeIdToUse = typeof resumeId === 'string' && resumeId.trim()
-              ? resumeId.trim()
-              : (resume ? storedResumeId : null)
-
-            log.info('session-tools', 'delegate_to_claude_code start', {
-              sessionId: ctx?.sessionId || null,
-              agentId: ctx?.agentId || null,
-              cwd,
-              timeoutMs: claudeTimeoutMs,
-              removedClaudeEnvKeys,
-              resumeRequested: !!resume || !!resumeId,
-              resumeId: resumeIdToUse || null,
-              taskPreview: (task || '').slice(0, 200),
-            })
-
-            return new Promise<string>((resolve) => {
-              const args = ['--print', '--output-format', 'stream-json', '--verbose', '--dangerously-skip-permissions']
-              if (resumeIdToUse) args.push('--resume', resumeIdToUse)
-              const child = spawn(claudeBinary, args, {
-                cwd,
-                env,
-                stdio: ['pipe', 'pipe', 'pipe'],
-              })
-              let stdout = ''
-              let stderr = ''
-              let stdoutBuf = ''
-              let assistantText = ''
-              let discoveredSessionId: string | null = null
-              let settled = false
-              let timedOut = false
-              const startedAt = Date.now()
-
-              const finish = (result: string) => {
-                if (settled) return
-                settled = true
-                resolve(truncate(result, MAX_OUTPUT))
-              }
-
-              const timeoutHandle = setTimeout(() => {
-                timedOut = true
-                try { child.kill('SIGTERM') } catch { /* ignore */ }
-                setTimeout(() => {
-                  try { child.kill('SIGKILL') } catch { /* ignore */ }
-                }, 5000)
-              }, claudeTimeoutMs)
-
-              log.info('session-tools', 'delegate_to_claude_code spawned', {
-                sessionId: ctx?.sessionId || null,
-                pid: child.pid || null,
-                args,
-              })
-              child.stdout?.on('data', (chunk: Buffer) => {
-                const text = chunk.toString()
-                stdout += text
-                if (stdout.length > MAX_OUTPUT * 8) stdout = tail(stdout, MAX_OUTPUT * 8)
-                stdoutBuf += text
-                const lines = stdoutBuf.split('\n')
-                stdoutBuf = lines.pop() || ''
-                for (const line of lines) {
-                  if (!line.trim()) continue
-                  try {
-                    const ev = JSON.parse(line)
-                    if (typeof ev?.session_id === 'string' && ev.session_id.trim()) {
-                      discoveredSessionId = ev.session_id.trim()
-                    }
-                    if (ev?.type === 'result' && typeof ev?.result === 'string') {
-                      assistantText = ev.result
-                    } else if (ev?.type === 'assistant' && Array.isArray(ev?.message?.content)) {
-                      const textBlocks = ev.message.content
-                        .filter((block: any) => block?.type === 'text' && typeof block?.text === 'string')
-                        .map((block: any) => block.text)
-                        .join('')
-                      if (textBlocks) assistantText = textBlocks
-                    } else if (ev?.type === 'content_block_delta' && typeof ev?.delta?.text === 'string') {
-                      assistantText += ev.delta.text
-                    }
-                  } catch {
-                    // keep raw stdout fallback when parsing fails
-                  }
-                }
-              })
-              child.stderr?.on('data', (chunk: Buffer) => {
-                stderr += chunk.toString()
-                if (stderr.length > MAX_OUTPUT * 8) stderr = tail(stderr, MAX_OUTPUT * 8)
-              })
-              child.on('error', (err) => {
-                clearTimeout(timeoutHandle)
-                log.error('session-tools', 'delegate_to_claude_code child error', {
-                  sessionId: ctx?.sessionId || null,
-                  error: err?.message || String(err),
-                })
-                finish(`Error: failed to start Claude Code CLI: ${err?.message || String(err)}`)
-              })
-              child.on('close', (code, signal) => {
-                clearTimeout(timeoutHandle)
-                const durationMs = Date.now() - startedAt
-                if (!discoveredSessionId) {
-                  const guessed = extractResumeIdentifier(`${stdout}\n${stderr}`)
-                  if (guessed) discoveredSessionId = guessed
-                }
-                if (discoveredSessionId) persistDelegateResumeId('claudeCode', discoveredSessionId)
-                log.info('session-tools', 'delegate_to_claude_code child close', {
-                  sessionId: ctx?.sessionId || null,
-                  code,
-                  signal: signal || null,
-                  timedOut,
-                  durationMs,
-                  stdoutLen: stdout.length,
-                  stderrLen: stderr.length,
-                  discoveredSessionId,
-                  stderrPreview: tail(stderr, 240),
-                })
-                if (timedOut) {
-                  const msg = [
-                    `Error: Claude Code CLI timed out after ${Math.round(claudeTimeoutMs / 1000)}s.`,
-                    stderr.trim() ? `stderr:\n${tail(stderr, 1500)}` : '',
-                    stdout.trim() ? `stdout:\n${tail(stdout, 1500)}` : '',
-                    'Try increasing "Claude Code Timeout (sec)" in Settings.',
-                  ].filter(Boolean).join('\n\n')
-                  finish(msg)
-                  return
-                }
-
-                // If resume failed because the session no longer exists, clear the stale ID
-                // and return a targeted error so the agent retries without resume
-                if (resumeIdToUse && /No conversation found/i.test(stdout + stderr)) {
-                  persistDelegateResumeId('claudeCode', null)
-                  log.warn('session-tools', 'delegate_to_claude_code stale resume ID cleared', {
-                    sessionId: ctx?.sessionId || null,
-                    staleResumeId: resumeIdToUse,
-                  })
-                  finish(
-                    `Error: The previous Claude Code session (${resumeIdToUse}) has expired and was cleared. ` +
-                    'Retry the task with resume=false to start a fresh session.',
-                  )
-                  return
-                }
-
-                const successText = assistantText.trim() || stdout.trim() || stderr.trim()
-                if (code === 0 && successText) {
-                  const out = discoveredSessionId
-                    ? `${successText}\n\n[delegate_meta]\nresume_id=${discoveredSessionId}`
-                    : successText
-                  finish(out)
-                  return
-                }
-
-                const msg = [
-                  `Error: Claude Code CLI exited with code ${code ?? 'unknown'}${signal ? ` (signal ${signal})` : ''}.`,
-                  stderr.trim() ? `stderr:\n${tail(stderr, 1500)}` : '',
-                  stdout.trim() ? `stdout:\n${tail(stdout, 1500)}` : '',
-                ].filter(Boolean).join('\n\n')
-                finish(msg || 'Error: Claude Code CLI returned no output.')
-              })
-
-              try {
-                child.stdin?.write(task)
-                child.stdin?.end()
-              } catch (err: any) {
-                clearTimeout(timeoutHandle)
-                finish(`Error: failed to send task to Claude Code CLI: ${err?.message || String(err)}`)
-              }
-            })
-          } catch (err: any) {
-            return `Error delegating to Claude Code: ${err.message}`
-          }
-        },
-        {
-          name: 'delegate_to_claude_code',
-          description: 'Delegate a complex multi-file coding task to Claude Code CLI. ONLY for deep code understanding, multi-file refactoring, or large code generation. NEVER use this to run servers, dev servers, install dependencies, or execute commands — use execute_command for those (this tool\'s session ends and kills any running processes).',
-          schema: z.object({
-            task: z.string().describe('Detailed description of the task for Claude Code'),
-            resume: z.boolean().optional().describe('If true, try to resume the last saved Claude delegation session for this SwarmClaw session'),
-            resumeId: z.string().optional().describe('Explicit Claude session id to resume (overrides resume=true memory)'),
-          }),
-        },
-      ),
-    )
-    }
+  if (backend === 'claude') return runClaudeDelegate(binary, task, resume, resumeId, bctx)
+  if (backend === 'codex') return runCodexDelegate(binary, task, resume, resumeId, bctx)
+  if (backend === 'opencode') return runOpenCodeDelegate(binary, task, resume, resumeId, bctx)
+  return `Error: Unsupported backend "${backend}".`
+}
 
-    if (codexBinary && wantsCodexDelegate) {
-    tools.push(
-      tool(
-        async ({ task, resume, resumeId }) => {
-          try {
-            const env: NodeJS.ProcessEnv = { ...process.env, TERM: 'dumb', NO_COLOR: '1' }
-            const removedCodexEnvKeys: string[] = []
-            for (const key of Object.keys(env)) {
-              if (key.toUpperCase().startsWith('CODEX')) {
-                removedCodexEnvKeys.push(key)
-                delete env[key]
-              }
-            }
+function stripEnvPrefixes(input: NodeJS.ProcessEnv, prefixes: string[]): NodeJS.ProcessEnv {
+  const out: NodeJS.ProcessEnv = { ...input }
+  for (const key of Object.keys(out)) {
+    const upper = key.toUpperCase()
+    if (prefixes.some((prefix) => upper.startsWith(prefix))) delete out[key]
+  }
+  return out
+}
 
-            const hasApiKey = typeof env.OPENAI_API_KEY === 'string' && env.OPENAI_API_KEY.trim().length > 0
-            if (!hasApiKey) {
-              const loginProbe = spawnSync(codexBinary, ['login', 'status'], {
-                cwd,
-                env,
-                encoding: 'utf-8',
-                timeout: 8000,
-              })
-              const probeText = `${loginProbe.stdout || ''}\n${loginProbe.stderr || ''}`.toLowerCase()
-              const loggedIn = probeText.includes('logged in')
-              if ((loginProbe.status ?? 1) !== 0 || !loggedIn) {
-                return 'Error: Codex CLI is not authenticated. Run `codex login` (or set OPENAI_API_KEY), then retry.'
-              }
-            }
+function parseCodexOutputText(ev: Record<string, unknown>): string | null {
+  if (ev.type === 'item.content_part.delta') {
+    const delta = ev.delta as Record<string, unknown> | undefined
+    if (typeof delta?.text === 'string') return delta.text
+  }
+  if (ev.type === 'item.completed') {
+    const item = ev.item as Record<string, unknown> | undefined
+    if (item?.type === 'agent_message' && typeof item.text === 'string') return item.text
+    if (item?.type === 'message' && item?.role === 'assistant') {
+      const content = item.content
+      if (typeof content === 'string') return content
+      if (Array.isArray(content)) {
+        const parts = content
+          .filter((entry) => entry && typeof entry === 'object' && (entry as Record<string, unknown>).type === 'output_text')
+          .map((entry) => String((entry as Record<string, unknown>).text || ''))
+        const joined = parts.join('')
+        if (joined) return joined
+      }
+    }
+  }
+  return null
+}
 
-            const storedResumeId = readStoredDelegateResumeId('codex')
-            const resumeIdToUse = typeof resumeId === 'string' && resumeId.trim()
-              ? resumeId.trim()
-              : (resume ? storedResumeId : null)
-
-            log.info('session-tools', 'delegate_to_codex_cli start', {
-              sessionId: ctx?.sessionId || null,
-              agentId: ctx?.agentId || null,
-              cwd,
-              timeoutMs: cliProcessTimeoutMs,
-              removedCodexEnvKeys,
-              resumeRequested: !!resume || !!resumeId,
-              resumeId: resumeIdToUse || null,
-              taskPreview: (task || '').slice(0, 200),
-            })
-
-            return new Promise<string>((resolve) => {
-              const args = ['exec']
-              if (resumeIdToUse) args.push('resume', resumeIdToUse)
-              args.push('--json', '--full-auto', '--skip-git-repo-check', '-')
-              const child = spawn(codexBinary, args, {
-                cwd,
-                env,
-                stdio: ['pipe', 'pipe', 'pipe'],
-              })
-              let stdout = ''
-              let stderr = ''
-              let settled = false
-              let timedOut = false
-              const startedAt = Date.now()
-              let agentText = ''
-              let discoveredThreadId: string | null = null
-              const eventErrors: string[] = []
-              let stdoutBuf = ''
-
-              const finish = (result: string) => {
-                if (settled) return
-                settled = true
-                resolve(truncate(result, MAX_OUTPUT))
-              }
-
-              const timeoutHandle = setTimeout(() => {
-                timedOut = true
-                try { child.kill('SIGTERM') } catch { /* ignore */ }
-                setTimeout(() => {
-                  try { child.kill('SIGKILL') } catch { /* ignore */ }
-                }, 5000)
-              }, cliProcessTimeoutMs)
-
-              log.info('session-tools', 'delegate_to_codex_cli spawned', {
-                sessionId: ctx?.sessionId || null,
-                pid: child.pid || null,
-                args,
-              })
-
-              child.stdout?.on('data', (chunk: Buffer) => {
-                const text = chunk.toString()
-                stdout += text
-                if (stdout.length > MAX_OUTPUT * 8) stdout = tail(stdout, MAX_OUTPUT * 8)
-
-                stdoutBuf += text
-                const lines = stdoutBuf.split('\n')
-                stdoutBuf = lines.pop() || ''
-                for (const line of lines) {
-                  if (!line.trim()) continue
-                  try {
-                    const ev = JSON.parse(line)
-                    if (typeof ev?.thread_id === 'string' && ev.thread_id.trim()) {
-                      discoveredThreadId = ev.thread_id.trim()
-                    }
-                    if (ev.type === 'item.completed' && ev.item?.type === 'agent_message' && typeof ev.item?.text === 'string') {
-                      agentText = ev.item.text
-                    } else if (ev.type === 'item.completed' && ev.item?.type === 'message' && ev.item?.role === 'assistant') {
-                      const content = ev.item.content
-                      if (Array.isArray(content)) {
-                        const txt = content
-                          .filter((c: any) => c?.type === 'output_text' && typeof c?.text === 'string')
-                          .map((c: any) => c.text)
-                          .join('')
-                        if (txt) agentText = txt
-                      } else if (typeof content === 'string') {
-                        agentText = content
-                      }
-                    } else if (ev.type === 'error' && ev.message) {
-                      eventErrors.push(String(ev.message))
-                    } else if (ev.type === 'turn.failed' && ev.error?.message) {
-                      eventErrors.push(String(ev.error.message))
-                    }
-                  } catch {
-                    // Ignore non-JSON lines in parser path; raw stdout still captured above.
-                  }
-                }
-              })
-              child.stderr?.on('data', (chunk: Buffer) => {
-                stderr += chunk.toString()
-                if (stderr.length > MAX_OUTPUT * 8) stderr = tail(stderr, MAX_OUTPUT * 8)
-              })
-              child.on('error', (err) => {
-                clearTimeout(timeoutHandle)
-                log.error('session-tools', 'delegate_to_codex_cli child error', {
-                  sessionId: ctx?.sessionId || null,
-                  error: err?.message || String(err),
-                })
-                finish(`Error: failed to start Codex CLI: ${err?.message || String(err)}`)
-              })
-              child.on('close', (code, signal) => {
-                clearTimeout(timeoutHandle)
-                const durationMs = Date.now() - startedAt
-                if (!discoveredThreadId) {
-                  const guessed = extractResumeIdentifier(`${stdout}\n${stderr}`)
-                  if (guessed) discoveredThreadId = guessed
-                }
-                if (discoveredThreadId) persistDelegateResumeId('codex', discoveredThreadId)
-                log.info('session-tools', 'delegate_to_codex_cli child close', {
-                  sessionId: ctx?.sessionId || null,
-                  code,
-                  signal: signal || null,
-                  timedOut,
-                  durationMs,
-                  stdoutLen: stdout.length,
-                  stderrLen: stderr.length,
-                  eventErrorCount: eventErrors.length,
-                  discoveredThreadId,
-                  stderrPreview: tail(stderr, 240),
-                })
-                if (timedOut) {
-                  const msg = [
-                    `Error: Codex CLI timed out after ${Math.round(cliProcessTimeoutMs / 1000)}s.`,
-                    stderr.trim() ? `stderr:\n${tail(stderr, 1500)}` : '',
-                    eventErrors.length ? `event errors:\n${tail(eventErrors.join('\n'), 1200)}` : '',
-                    'Try increasing "CLI Process Timeout (sec)" in Settings.',
-                  ].filter(Boolean).join('\n\n')
-                  finish(msg)
-                  return
-                }
-                if (code === 0 && agentText.trim()) {
-                  const out = discoveredThreadId
-                    ? `${agentText.trim()}\n\n[delegate_meta]\nresume_id=${discoveredThreadId}`
-                    : agentText.trim()
-                  finish(out)
-                  return
-                }
-                if (code === 0 && stdout.trim() && !eventErrors.length) {
-                  const out = discoveredThreadId
-                    ? `${stdout.trim()}\n\n[delegate_meta]\nresume_id=${discoveredThreadId}`
-                    : stdout.trim()
-                  finish(out)
-                  return
-                }
-                const msg = [
-                  `Error: Codex CLI exited with code ${code ?? 'unknown'}${signal ? ` (signal ${signal})` : ''}.`,
-                  eventErrors.length ? `event errors:\n${tail(eventErrors.join('\n'), 1200)}` : '',
-                  stderr.trim() ? `stderr:\n${tail(stderr, 1500)}` : '',
-                  stdout.trim() ? `stdout:\n${tail(stdout, 1500)}` : '',
-                ].filter(Boolean).join('\n\n')
-                finish(msg || 'Error: Codex CLI returned no output.')
-              })
-
-              try {
-                child.stdin?.write(task)
-                child.stdin?.end()
-              } catch (err: any) {
-                clearTimeout(timeoutHandle)
-                finish(`Error: failed to send task to Codex CLI: ${err?.message || String(err)}`)
-              }
-            })
-          } catch (err: any) {
-            return `Error delegating to Codex CLI: ${err.message}`
-          }
-        },
-        {
-          name: 'delegate_to_codex_cli',
-          description: 'Delegate a complex multi-file coding task to Codex CLI. ONLY for deep code understanding, multi-file refactoring, or large code generation. NEVER use this to run servers, dev servers, install dependencies, or execute commands — use execute_command for those (this tool\'s session ends and kills any running processes).',
-          schema: z.object({
-            task: z.string().describe('Detailed description of the task for Codex CLI'),
-            resume: z.boolean().optional().describe('If true, try to resume the last saved Codex delegation thread for this SwarmClaw session'),
-            resumeId: z.string().optional().describe('Explicit Codex thread id to resume (overrides resume=true memory)'),
-          }),
-        },
-      ),
-    )
+async function runCodexDelegate(binary: string, task: string, resume: boolean, resumeId: string, bctx: DelegateContext): Promise<string> {
+  try {
+    const env = stripEnvPrefixes({ ...process.env, TERM: 'dumb', NO_COLOR: '1' }, ['CODEX'])
+    const authProbe = spawnSync(binary, ['login', 'status'], { cwd: bctx.cwd, env, encoding: 'utf-8', timeout: 8000 })
+    const probeText = `${authProbe.stdout || ''}\n${authProbe.stderr || ''}`.toLowerCase()
+    const loggedIn = probeText.includes('logged in')
+    if ((authProbe.status ?? 1) !== 0 || !loggedIn) {
+      return 'Error: Codex CLI is not authenticated. Run `codex login` and retry.'
     }
 
-    if (opencodeBinary && wantsOpenCodeDelegate) {
-    tools.push(
-      tool(
-        async ({ task, resume, resumeId }) => {
+    const storedResumeId = bctx.readStoredDelegateResumeId?.('codex')
+    const resumeIdToUse = resumeId?.trim() || (resume ? storedResumeId : null)
+
+    return await new Promise<string>((resolve) => {
+      const args: string[] = ['exec']
+      if (resumeIdToUse) args.push('resume', resumeIdToUse)
+      args.push('--json', '--full-auto', '--skip-git-repo-check', '-')
+
+      const child = spawn(binary, args, { cwd: bctx.cwd, env, stdio: ['pipe', 'pipe', 'pipe'] })
+      let stdoutBuf = ''
+      let stderrBuf = ''
+      let responseText = ''
+      let discoveredId: string | null = null
+      let settled = false
+
+      const finish = (text: string) => {
+        if (settled) return
+        settled = true
+        resolve(truncate(text, MAX_OUTPUT))
+      }
+
+      const timeoutHandle = setTimeout(() => {
+        try { child.kill('SIGTERM') } catch { /* ignore */ }
+      }, bctx.claudeTimeoutMs || 300000)
+
+      child.stdout?.on('data', (chunk) => {
+        stdoutBuf += chunk.toString()
+        const lines = stdoutBuf.split('\n')
+        stdoutBuf = lines.pop() || ''
+        for (const line of lines) {
+          const trimmed = line.trim()
+          if (!trimmed) continue
           try {
-            const env: NodeJS.ProcessEnv = { ...process.env, TERM: 'dumb', NO_COLOR: '1' }
-            const storedResumeId = readStoredDelegateResumeId('opencode')
-            const resumeIdToUse = typeof resumeId === 'string' && resumeId.trim()
-              ? resumeId.trim()
-              : (resume ? storedResumeId : null)
-
-            log.info('session-tools', 'delegate_to_opencode_cli start', {
-              sessionId: ctx?.sessionId || null,
-              agentId: ctx?.agentId || null,
-              cwd,
-              timeoutMs: cliProcessTimeoutMs,
-              resumeRequested: !!resume || !!resumeId,
-              resumeId: resumeIdToUse || null,
-              taskPreview: (task || '').slice(0, 200),
-            })
-
-            return new Promise<string>((resolve) => {
-              const args = ['run', task, '--format', 'json']
-              if (resumeIdToUse) args.push('--session', resumeIdToUse)
-              const child = spawn(opencodeBinary, args, {
-                cwd,
-                env,
-                stdio: ['pipe', 'pipe', 'pipe'],
-              })
-              let stdout = ''
-              let stderr = ''
-              let discoveredSessionId: string | null = null
-              let parsedText = ''
-              const eventErrors: string[] = []
-              let stdoutBuf = ''
-              let settled = false
-              let timedOut = false
-              const startedAt = Date.now()
-
-              const finish = (result: string) => {
-                if (settled) return
-                settled = true
-                resolve(truncate(result, MAX_OUTPUT))
-              }
-
-              const timeoutHandle = setTimeout(() => {
-                timedOut = true
-                try { child.kill('SIGTERM') } catch { /* ignore */ }
-                setTimeout(() => {
-                  try { child.kill('SIGKILL') } catch { /* ignore */ }
-                }, 5000)
-              }, cliProcessTimeoutMs)
-
-              log.info('session-tools', 'delegate_to_opencode_cli spawned', {
-                sessionId: ctx?.sessionId || null,
-                pid: child.pid || null,
-                args: resumeIdToUse
-                  ? ['run', '(task hidden)', '--format', 'json', '--session', resumeIdToUse]
-                  : ['run', '(task hidden)', '--format', 'json'],
-              })
-              child.stdout?.on('data', (chunk: Buffer) => {
-                const text = chunk.toString()
-                stdout += text
-                if (stdout.length > MAX_OUTPUT * 8) stdout = tail(stdout, MAX_OUTPUT * 8)
-                stdoutBuf += text
-                const lines = stdoutBuf.split('\n')
-                stdoutBuf = lines.pop() || ''
-                for (const line of lines) {
-                  if (!line.trim()) continue
-                  try {
-                    const ev = JSON.parse(line)
-                    if (typeof ev?.sessionID === 'string' && ev.sessionID.trim()) {
-                      discoveredSessionId = ev.sessionID.trim()
-                    }
-                    if (ev?.type === 'text' && typeof ev?.part?.text === 'string') {
-                      parsedText += ev.part.text
-                    } else if (ev?.type === 'error') {
-                      const msg = typeof ev?.error === 'string'
-                        ? ev.error
-                        : typeof ev?.message === 'string'
-                          ? ev.message
-                          : 'Unknown OpenCode event error'
-                      eventErrors.push(msg)
-                    }
-                  } catch {
-                    // keep raw stdout fallback
-                  }
-                }
-              })
-              child.stderr?.on('data', (chunk: Buffer) => {
-                stderr += chunk.toString()
-                if (stderr.length > MAX_OUTPUT * 8) stderr = tail(stderr, MAX_OUTPUT * 8)
-              })
-              child.on('error', (err) => {
-                clearTimeout(timeoutHandle)
-                log.error('session-tools', 'delegate_to_opencode_cli child error', {
-                  sessionId: ctx?.sessionId || null,
-                  error: err?.message || String(err),
-                })
-                finish(`Error: failed to start OpenCode CLI: ${err?.message || String(err)}`)
-              })
-              child.on('close', (code, signal) => {
-                clearTimeout(timeoutHandle)
-                const durationMs = Date.now() - startedAt
-                const guessed = extractResumeIdentifier(`${stdout}\n${stderr}`)
-                if (guessed) discoveredSessionId = guessed
-                if (discoveredSessionId) persistDelegateResumeId('opencode', discoveredSessionId)
-                log.info('session-tools', 'delegate_to_opencode_cli child close', {
-                  sessionId: ctx?.sessionId || null,
-                  code,
-                  signal: signal || null,
-                  timedOut,
-                  durationMs,
-                  stdoutLen: stdout.length,
-                  stderrLen: stderr.length,
-                  parsedTextLen: parsedText.length,
-                  eventErrorCount: eventErrors.length,
-                  discoveredSessionId,
-                  stderrPreview: tail(stderr, 240),
-                })
-                if (timedOut) {
-                  const msg = [
-                    `Error: OpenCode CLI timed out after ${Math.round(cliProcessTimeoutMs / 1000)}s.`,
-                    stderr.trim() ? `stderr:\n${tail(stderr, 1500)}` : '',
-                    eventErrors.length ? `event errors:\n${tail(eventErrors.join('\n'), 1200)}` : '',
-                    stdout.trim() ? `stdout:\n${tail(stdout, 1500)}` : '',
-                    'Try increasing "CLI Process Timeout (sec)" in Settings.',
-                  ].filter(Boolean).join('\n\n')
-                  finish(msg)
-                  return
-                }
-                const successText = parsedText.trim() || stdout.trim() || stderr.trim()
-                if (code === 0 && successText) {
-                  const out = discoveredSessionId
-                    ? `${successText}\n\n[delegate_meta]\nresume_id=${discoveredSessionId}`
-                    : successText
-                  finish(out)
-                  return
-                }
-                const msg = [
-                  `Error: OpenCode CLI exited with code ${code ?? 'unknown'}${signal ? ` (signal ${signal})` : ''}.`,
-                  eventErrors.length ? `event errors:\n${tail(eventErrors.join('\n'), 1200)}` : '',
-                  stderr.trim() ? `stderr:\n${tail(stderr, 1500)}` : '',
-                  stdout.trim() ? `stdout:\n${tail(stdout, 1500)}` : '',
-                ].filter(Boolean).join('\n\n')
-                finish(msg || 'Error: OpenCode CLI returned no output.')
-              })
-            })
-          } catch (err: any) {
-            return `Error delegating to OpenCode CLI: ${err.message}`
+            const ev = JSON.parse(trimmed) as Record<string, unknown>
+            if (ev.type === 'thread.started' && typeof ev.thread_id === 'string') discoveredId = ev.thread_id
+            const parsedText = parseCodexOutputText(ev)
+            if (parsedText) responseText = parsedText
+          } catch {
+            responseText += `${line}\n`
           }
-        },
-        {
-          name: 'delegate_to_opencode_cli',
-          description: 'Delegate a complex multi-file coding task to OpenCode CLI. ONLY for deep code understanding, multi-file refactoring, or large code generation. NEVER use this to run servers, dev servers, install dependencies, or execute commands — use execute_command for those (this tool\'s session ends and kills any running processes).',
-          schema: z.object({
-            task: z.string().describe('Detailed description of the task for OpenCode CLI'),
-            resume: z.boolean().optional().describe('If true, try to resume the last saved OpenCode delegation session for this SwarmClaw session'),
-            resumeId: z.string().optional().describe('Explicit OpenCode session id to resume (overrides resume=true memory)'),
-          }),
-        },
-      ),
-    )
-    }
-  }
+        }
+      })
 
-  // check_delegation_status: lets agents check on tasks they delegated
-  if (ctx?.platformAssignScope === 'all' && ctx?.agentId) {
-    tools.push(
-      tool(
-        async ({ taskId }) => {
-          try {
-            const tasks = loadTasks()
-            const task = tasks[taskId] as Record<string, unknown> | undefined
-            if (!task) return `Error: Task "${taskId}" not found.`
-
-            const status = task.status as string || 'unknown'
-            const result = typeof task.result === 'string' ? task.result : null
-            const error = typeof task.error === 'string' ? task.error : null
-            const agentId = task.agentId as string || ''
-            const agents = loadAgents()
-            const agent = agents[agentId]
-            const startedAt = typeof task.startedAt === 'number' ? task.startedAt : null
-            const completedAt = typeof task.completedAt === 'number' ? task.completedAt : null
-
-            const info: Record<string, unknown> = {
-              taskId,
-              status,
-              agentId,
-              agentName: agent?.name || agentId,
-              agentAvatarSeed: agent?.avatarSeed || null,
-              title: task.title || '',
-            }
+      child.stderr?.on('data', (chunk) => {
+        stderrBuf += chunk.toString()
+        if (stderrBuf.length > 16_000) stderrBuf = stderrBuf.slice(-16_000)
+      })
 
-            if (startedAt) info.startedAt = new Date(startedAt).toISOString()
-            if (completedAt) info.completedAt = new Date(completedAt).toISOString()
-            if (startedAt && !completedAt && status === 'running') {
-              info.runningForSeconds = Math.round((Date.now() - startedAt) / 1000)
-            }
-            if (result) info.result = result.slice(0, 4000)
-            if (error) info.error = error.slice(0, 1000)
-
-            // Include latest comments for context
-            const comments = Array.isArray(task.comments) ? task.comments as Array<{ text: string; author: string; createdAt: number }> : []
-            if (comments.length > 0) {
-              const latest = comments.slice(-3).map((c) => ({
-                author: c.author,
-                text: (c.text || '').slice(0, 500),
-                time: new Date(c.createdAt).toISOString(),
-              }))
-              info.latestComments = latest
-            }
+      child.on('close', (code, signal) => {
+        clearTimeout(timeoutHandle)
+        if (discoveredId) bctx.persistDelegateResumeId?.('codex', discoveredId)
+        const output = responseText.trim()
+        if (output) return finish(output)
+        const stderr = stderrBuf.trim()
+        if (stderr) return finish(`Error: ${stderr}`)
+        return finish(`Error: Codex exited with code ${code ?? 'unknown'}${signal ? ` (${signal})` : ''}.`)
+      })
 
-            return JSON.stringify(info)
-          } catch (err: unknown) {
-            return `Error checking task: ${err instanceof Error ? err.message : String(err)}`
-          }
-        },
-        {
-          name: 'check_delegation_status',
-          description: 'Check the status and result of a delegated task. Use this after delegate_to_agent to monitor progress. Returns status (todo/queued/running/completed/failed), result if completed, and latest comments.',
-          schema: z.object({
-            taskId: z.string().describe('The task ID returned by delegate_to_agent'),
-          }),
-        },
-      ),
-    )
+      child.on('error', (err) => {
+        clearTimeout(timeoutHandle)
+        finish(`Error: ${err.message}`)
+      })
+
+      child.stdin?.write(task)
+      child.stdin?.end()
+    })
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
   }
+}
 
-  // delegate_to_agent: requires "Assign to Other Agents" (platformAssignScope: 'all')
-  if (ctx?.platformAssignScope === 'all' && ctx?.agentId) {
-    tools.push(
-      tool(
-        async ({ agentId: targetAgentId, task: taskPrompt, description: taskDesc, startImmediately }) => {
+async function runOpenCodeDelegate(binary: string, task: string, resume: boolean, resumeId: string, bctx: DelegateContext): Promise<string> {
+  try {
+    const env = { ...process.env, TERM: 'dumb', NO_COLOR: '1' } as NodeJS.ProcessEnv
+    const storedResumeId = bctx.readStoredDelegateResumeId?.('opencode')
+    const resumeIdToUse = resumeId?.trim() || (resume ? storedResumeId : null)
+
+    return await new Promise<string>((resolve) => {
+      const args = ['run', task, '--format', 'json']
+      if (resumeIdToUse) args.push('--session', resumeIdToUse)
+
+      const child = spawn(binary, args, { cwd: bctx.cwd, env, stdio: ['ignore', 'pipe', 'pipe'] })
+      let stdoutBuf = ''
+      let stderrBuf = ''
+      let responseText = ''
+      let discoveredId: string | null = null
+      let settled = false
+
+      const finish = (text: string) => {
+        if (settled) return
+        settled = true
+        resolve(truncate(text, MAX_OUTPUT))
+      }
+
+      const timeoutHandle = setTimeout(() => {
+        try { child.kill('SIGTERM') } catch { /* ignore */ }
+      }, bctx.claudeTimeoutMs || 300000)
+
+      child.stdout?.on('data', (chunk) => {
+        stdoutBuf += chunk.toString()
+        const lines = stdoutBuf.split('\n')
+        stdoutBuf = lines.pop() || ''
+        for (const line of lines) {
+          const trimmed = line.trim()
+          if (!trimmed) continue
           try {
-            const agents = loadAgents()
-            let target = agents[targetAgentId]
-            let resolvedId = targetAgentId
-            // Fallback: resolve by name if the ID doesn't match directly
-            if (!target) {
-              const byName = Object.values(agents).find(
-                (a) => a.name.toLowerCase() === targetAgentId.toLowerCase(),
-              )
-              if (byName) {
-                target = byName
-                resolvedId = byName.id
-              }
-            }
-            if (!target) return `Error: Agent "${targetAgentId}" not found. Use the agent directory in your system prompt to find valid agent IDs.`
-
-            const taskId = genId()
-            const now = Date.now()
-            const newTask = {
-              id: taskId,
-              title: taskPrompt.slice(0, 100),
-              description: taskDesc || taskPrompt,
-              status: 'todo',
-              agentId: resolvedId,
-              cwd,
-              sourceType: 'delegation' as const,
-              delegatedByAgentId: ctx.agentId!,
-              createdAt: now,
-              updatedAt: now,
-              comments: [{
-                id: genId(),
-                author: agents[ctx.agentId!]?.name || 'Agent',
-                agentId: ctx.agentId!,
-                text: `Delegated from ${agents[ctx.agentId!]?.name || ctx.agentId}`,
-                createdAt: now,
-              }],
-            }
-            // Atomic upsert to avoid race with concurrent queue processing
-            upsertTask(taskId, newTask)
-            console.log(`[delegate] Created task ${taskId} for agent ${resolvedId}, startImmediately=${startImmediately}`)
-
-            // Verify it persisted
-            const verify = loadTasks()
-            if (!verify[taskId]) {
-              console.error(`[delegate] RACE: task ${taskId} not found after upsert!`)
+            const ev = JSON.parse(trimmed) as Record<string, unknown>
+            const sid = typeof ev.sessionID === 'string' ? ev.sessionID : (typeof ev.sessionId === 'string' ? ev.sessionId : null)
+            if (sid) discoveredId = sid
+            if (ev.type === 'text') {
+              const part = ev.part as Record<string, unknown> | undefined
+              if (typeof part?.text === 'string') responseText += part.text
+            } else if (ev.type === 'error') {
+              const msg = typeof ev.error === 'string' ? ev.error : (typeof ev.message === 'string' ? ev.message : 'OpenCode error')
+              stderrBuf += `${msg}\n`
             }
+          } catch {
+            responseText += `${line}\n`
+          }
+        }
+      })
 
-            if (startImmediately) {
-              // Lazy import to avoid circular: session-tools → queue → chat-execution → session-tools
-              const { enqueueTask } = await import('../queue')
-              enqueueTask(taskId)
-              console.log(`[delegate] Enqueued task ${taskId}`)
-            }
+      child.stderr?.on('data', (chunk) => {
+        stderrBuf += chunk.toString()
+        if (stderrBuf.length > 16_000) stderrBuf = stderrBuf.slice(-16_000)
+      })
 
-            return JSON.stringify({
-              ok: true,
-              taskId,
-              agentId: resolvedId,
-              agentName: target.name,
-              agentAvatarSeed: target.avatarSeed || null,
-              message: startImmediately
-                ? `Task delegated to ${target.name} and queued for immediate execution. Task ID: ${taskId}. Use check_delegation_status to monitor progress.`
-                : `Task delegated to ${target.name}. Task ID: ${taskId}. Status: todo (not auto-started). Use delegate_to_agent with startImmediately: true to queue it.`,
-            })
-          } catch (err: unknown) {
-            return `Error delegating task: ${err instanceof Error ? err.message : String(err)}`
+      child.on('close', (code, signal) => {
+        clearTimeout(timeoutHandle)
+        if (discoveredId) bctx.persistDelegateResumeId?.('opencode', discoveredId)
+        const output = responseText.trim()
+        if (output) return finish(output)
+        const stderr = stderrBuf.trim()
+        if (stderr) return finish(`Error: ${stderr}`)
+        return finish(`Error: OpenCode exited with code ${code ?? 'unknown'}${signal ? ` (${signal})` : ''}.`)
+      })
+
+      child.on('error', (err) => {
+        clearTimeout(timeoutHandle)
+        finish(`Error: ${err.message}`)
+      })
+    })
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+async function runClaudeDelegate(binary: string, task: string, resume: boolean, resumeId: string, bctx: DelegateContext): Promise<string> {
+  try {
+    const env: NodeJS.ProcessEnv = stripEnvPrefixes({ ...process.env }, ['CLAUDE'])
+    const authProbe = spawnSync(binary, ['auth', 'status'], { cwd: bctx.cwd, env, encoding: 'utf-8', timeout: 8000 })
+    if ((authProbe.status ?? 1) !== 0) return 'Error: Claude Code not authenticated.'
+
+    const storedResumeId = bctx.readStoredDelegateResumeId?.('claudeCode')
+    const resumeIdToUse = resumeId?.trim() || (resume ? storedResumeId : null)
+
+    return new Promise<string>((resolve) => {
+      const args = ['--print', '--output-format', 'stream-json', '--verbose', '--dangerously-skip-permissions']
+      if (resumeIdToUse) args.push('--resume', resumeIdToUse)
+      const child = spawn(binary, args, { cwd: bctx.cwd, env, stdio: ['pipe', 'pipe', 'pipe'] })
+      let stderr = ''
+      let assistantText = ''
+      let discoveredId: string | null = null
+      let settled = false
+      
+      const finish = (res: string) => { if (!settled) { settled = true; resolve(truncate(res, MAX_OUTPUT)) } }
+      const timeoutHandle = setTimeout(() => { try { child.kill('SIGTERM') } catch {} }, bctx.claudeTimeoutMs || 300000)
+
+      child.stdout?.on('data', (c) => {
+        const lines = c.toString().split('\n')
+        for (const l of lines) {
+          const trimmed = l.trim()
+          if (!trimmed) continue
+          try {
+            const ev = JSON.parse(trimmed) as Record<string, unknown>
+            if (typeof ev.session_id === 'string') discoveredId = ev.session_id
+            if (ev.type === 'result' && typeof ev.result === 'string') assistantText = ev.result
+          } catch {
+            assistantText += `${l}\n`
           }
+        }
+      })
+      child.stderr?.on('data', (chunk) => {
+        stderr += chunk.toString()
+        if (stderr.length > 16_000) stderr = stderr.slice(-16_000)
+      })
+      child.on('close', (code) => {
+        clearTimeout(timeoutHandle)
+        if (discoveredId) bctx.persistDelegateResumeId?.('claudeCode', discoveredId)
+        const output = assistantText.trim()
+        if (code === 0) finish(output || 'Task completed.')
+        else finish(output ? output : `Error: Code ${code}. ${stderr.trim()}`)
+      })
+      child.on('error', (err) => {
+        clearTimeout(timeoutHandle)
+        finish(`Error: ${err.message}`)
+      })
+      child.stdin?.write(task)
+      child.stdin?.end()
+    })
+  } catch (err: unknown) { return `Error: ${err instanceof Error ? err.message : String(err)}` }
+}
+
+/**
+ * Register as a Built-in Plugin
+ */
+const DelegatePlugin: Plugin = {
+  name: 'Core Delegate',
+  description: 'Delegate complex multi-file tasks to specialized CLI backends or other agents.',
+  hooks: {} as PluginHooks,
+  tools: [
+    {
+      name: 'delegate',
+      description: 'Delegate to a specialized backend (Claude, Codex, OpenCode).',
+      parameters: {
+        type: 'object',
+        properties: {
+          task: { type: 'string' },
+          backend: { type: 'string', enum: ['claude', 'codex', 'opencode'] },
+          resume: { type: 'boolean' },
+          resumeId: { type: 'string', description: 'Optional explicit session/thread ID to resume' }
         },
+        required: ['task']
+      },
+      execute: async (args, context) => executeDelegateAction(args, { ...context.session, cwd: context.session.cwd || process.cwd() })
+    }
+  ]
+}
+
+getPluginManager().registerBuiltin('delegate', DelegatePlugin)
+
+/**
+ * Legacy Bridge
+ */
+export function buildDelegateTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  const tools: StructuredToolInterface[] = []
+  const { hasTool } = bctx
+
+  if (hasTool('delegate')) {
+    tools.push(
+      tool(
+        async (args) => executeDelegateAction(args, bctx),
         {
-          name: 'delegate_to_agent',
-          description: 'Delegate a task to another agent. Creates a task on the task board and queues it for immediate execution by default. Set startImmediately=false if you want the task to go to "todo" status instead.',
-          schema: z.object({
-            agentId: z.string().describe('ID or name of the target agent to delegate to'),
-            task: z.string().describe('What the target agent should do'),
-            description: z.string().optional().describe('Optional longer description of the task'),
-            startImmediately: z.boolean().optional().default(true).describe('If true (default), queue the task for immediate execution. Set false to put in todo for manual start.'),
-          }),
-        },
-      ),
+          name: 'delegate',
+          description: DelegatePlugin.tools![0].description,
+          schema: z.object({}).passthrough()
+        }
+      )
     )
   }
 
+  // Assign to agent and check status tools (kept as platform-level tools)
+  if (bctx.ctx?.platformAssignScope === 'all' && bctx.ctx?.agentId) {
+    // ... existing check_delegation_status and delegate_to_agent ...
+    // These are already part of PLATFORM_TOOLS in tool-definitions
+  }
+
   return tools
 }