@swarmclawai/swarmclaw 0.7.2 → 0.7.3

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

@@ -22,7 +22,13 @@ import {
 import { resolveScheduleName } from '@/lib/schedule-name'
 import { findDuplicateSchedule, type ScheduleLike } from '@/lib/schedule-dedupe'
 import { computeTaskFingerprint, findDuplicateTask } from '@/lib/task-dedupe'
-import { resolveTaskAgentFromDescription } from '@/lib/server/task-mention'
+import {
+  hasManagedAgentAssignmentInput,
+  isDelegationTaskPayload,
+  resolveDelegatorAgentId,
+  resolveManagedAgentAssignment,
+  validateManagedAgentAssignment,
+} from '@/lib/server/agent-assignment'
 import { normalizeTaskQualityGate } from '@/lib/server/task-quality-gate'
 import type { ToolBuildContext } from './context'
 import { safePath, findBinaryOnPath } from './context'
@@ -137,7 +143,8 @@ const RESOURCE_DEFAULTS: Record<string, (parsed: any) => any> = {
     soul: p.soul || '',
     provider: p.provider || 'claude-cli',
     model: p.model || '',
-    isOrchestrator: p.isOrchestrator || false,
+    platformAssignScope: p.platformAssignScope === 'all' ? 'all' : 'self',
+    isOrchestrator: p.platformAssignScope === 'all',
     tools: p.tools || [],
     skills: p.skills || [],
     skillIds: p.skillIds || [],
@@ -256,12 +263,12 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
     let description = `Manage SwarmClaw ${res.label}. ${res.readOnly ? 'List and get only.' : 'List, get, create, update, or delete.'} Returns JSON.`
     if (toolKey === 'manage_tasks') {
       if (assignScope === 'self') {
-        description += `\n\nDo NOT create tasks for yourself — just do the work directly. Tasks are for delegating work to other agents or for user-created work items. You can only list, get, update status, or complete tasks assigned to you ("${ctx?.agentId || 'unknown'}"). Valid manual statuses: backlog, queued, completed, failed, archived. "running" is runtime-only and set automatically when execution starts.`
+        description += `\n\nYou may create tasks for yourself ("${ctx?.agentId || 'unknown'}") or leave them unassigned to track multi-step work. You cannot assign tasks to other agents unless a user enables "Assign to Other Agents" in your agent settings. Valid manual statuses: backlog, queued, completed, failed, archived. "running" is runtime-only and set automatically when execution starts.`
       } else {
-        description += `\n\nDo NOT create tasks for yourself — just do the work directly. Only create tasks to delegate work to OTHER agents. Your agent ID is "${ctx?.agentId || 'unknown'}". Valid manual statuses: backlog, queued, completed, failed, archived. "running" is runtime-only and set automatically when execution starts.` + agentSummary
+        description += `\n\nYou may create tasks for yourself, leave them unassigned, or delegate them to other agents. Your agent ID is "${ctx?.agentId || 'unknown'}". When delegating, set a target agent using "agentId", "assignee", "agent", "assignedAgentId", or "assigned_agent_id". Use the target agent's exact ID when possible. Valid manual statuses: backlog, queued, completed, failed, archived. "running" is runtime-only and set automatically when execution starts.` + agentSummary
       }
     } else if (toolKey === 'manage_agents') {
-      description += `\n\nAgents may self-edit their own soul. To update your soul, use action="update", id="${ctx?.agentId || 'your-agent-id'}", and include data with the "soul" field.`
+      description += `\n\nAgents may self-edit their own soul. To update your soul, use action="update", id="${ctx?.agentId || 'your-agent-id'}", and include data with the "soul" field. Set "platformAssignScope":"all" to let an agent delegate work across the fleet; use "self" for solo execution.`
     } else if (toolKey === 'manage_schedules') {
       if (assignScope === 'self') {
         description += `\n\nSet "agentId" to assign a schedule to yourself ("${ctx?.agentId || 'unknown'}") or leave it null. You can only assign schedules to yourself. Schedule types: interval (set intervalMs), cron (set cron), once (set runAt). Set taskPrompt for what the agent should do. Before create, call list/get to avoid duplicate schedules. If an equivalent active/paused schedule already exists, create returns that existing schedule (deduplicated=true).`
@@ -337,13 +344,30 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
               if (parsed && typeof parsed === 'object' && 'id' in parsed) {
                 delete (parsed as Record<string, unknown>).id
               }
-              // Enforce assignment scope for tasks and schedules
-              if (assignScope === 'self' && (toolKey === 'manage_tasks' || toolKey === 'manage_schedules')) {
-                if (parsed.agentId && parsed.agentId !== ctx?.agentId) {
-                  return `Error: You can only assign ${res.label} to yourself ("${ctx?.agentId}"). To assign to other agents, ask a user to enable "Assign to Other Agents" in your agent settings.`
-                }
-              }
               const now = Date.now()
+              if (toolKey === 'manage_tasks' || toolKey === 'manage_schedules') {
+                const agents = loadAgents()
+                const resolution = resolveManagedAgentAssignment(
+                  parsed as Record<string, unknown>,
+                  agents,
+                  toolKey === 'manage_tasks' ? (parsed.agentId || ctx?.agentId || null) : null,
+                  { allowDescription: toolKey === 'manage_tasks' },
+                )
+                const assignmentError = validateManagedAgentAssignment({
+                  resourceLabel: res.label,
+                  agents,
+                  assignScope,
+                  currentAgentId: ctx?.agentId || null,
+                  targetAgentId: resolution.agentId,
+                  unresolvedReference: resolution.unresolvedReference,
+                  isDelegation: toolKey === 'manage_tasks' ? isDelegationTaskPayload(parsed as Record<string, unknown>) : false,
+                  delegatorAgentId: toolKey === 'manage_tasks'
+                    ? resolveDelegatorAgentId(parsed as Record<string, unknown>, agents, ctx?.agentId || null)
+                    : null,
+                })
+                if (assignmentError) return assignmentError
+                parsed.agentId = resolution.agentId
+              }
               if (toolKey === 'manage_schedules') {
                 const duplicate = findDuplicateSchedule(all as Record<string, ScheduleLike>, {
                   agentId: parsed.agentId || null,
@@ -387,23 +411,6 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                   })
                 }
               }
-              // @mention agent resolution for tasks
-              if (toolKey === 'manage_tasks' && parsed.description) {
-                const agents = loadAgents()
-                parsed.agentId = resolveTaskAgentFromDescription(
-                  parsed.description,
-                  parsed.agentId || ctx?.agentId || '',
-                  agents,
-                )
-              }
-              // Agents cannot create tasks for themselves — just do the work directly.
-              // Tasks are for delegating to other agents or user-created work items.
-              if (toolKey === 'manage_tasks' && ctx?.agentId) {
-                const resolvedAgentId = parsed.agentId || ctx.agentId
-                if (resolvedAgentId === ctx.agentId) {
-                  return 'Error: You cannot create tasks for yourself — just do the work directly. Tasks are for delegating work to other agents. If you need to track progress, use memory instead.'
-                }
-              }
               if (toolKey === 'manage_tasks') {
                 parsed.title = deriveTaskTitle(parsed)
                 if (!parsed.title || /^untitled task$/i.test(parsed.title)) {
@@ -507,10 +514,41 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                   ? normalizeTaskQualityGate(parsed.qualityGate, settings)
                   : null
               }
-              // Enforce assignment scope for tasks and schedules
-              if (assignScope === 'self' && (toolKey === 'manage_tasks' || toolKey === 'manage_schedules')) {
-                if (parsed.agentId && parsed.agentId !== ctx?.agentId) {
-                  return `Error: You can only assign ${res.label} to yourself ("${ctx?.agentId}"). To assign to other agents, ask a user to enable "Assign to Other Agents" in your agent settings.`
+              if (toolKey === 'manage_tasks' || toolKey === 'manage_schedules') {
+                const agents = loadAgents()
+                const requestedClear = Object.prototype.hasOwnProperty.call(parsed, 'agentId') && parsed.agentId == null
+                const shouldResolveAssignment = requestedClear
+                  || hasManagedAgentAssignmentInput(parsed as Record<string, unknown>)
+                if (shouldResolveAssignment) {
+                  const resolution = resolveManagedAgentAssignment(
+                    parsed as Record<string, unknown>,
+                    agents,
+                    null,
+                    { allowDescription: false },
+                  )
+                  const assignmentError = validateManagedAgentAssignment({
+                    resourceLabel: res.label,
+                    agents,
+                    assignScope,
+                    currentAgentId: ctx?.agentId || null,
+                    targetAgentId: requestedClear ? null : resolution.agentId,
+                    unresolvedReference: requestedClear ? null : resolution.unresolvedReference,
+                    isDelegation: toolKey === 'manage_tasks'
+                      ? isDelegationTaskPayload({
+                          ...all[id],
+                          ...parsed,
+                          agentId: requestedClear ? null : resolution.agentId,
+                        } as Record<string, unknown>)
+                      : false,
+                    delegatorAgentId: toolKey === 'manage_tasks'
+                      ? resolveDelegatorAgentId({
+                          ...all[id],
+                          ...parsed,
+                        } as Record<string, unknown>, agents, ctx?.agentId || null)
+                      : null,
+                  })
+                  if (assignmentError) return assignmentError
+                  if (!requestedClear) parsed.agentId = resolution.agentId
                 }
               }
               all[id] = { ...all[id], ...parsed, updatedAt: Date.now() }

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

@@ -0,0 +1,219 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { describe, it } from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../../..')
+
+function writeExecutable(dir: string, name: string, source: string) {
+  const filePath = path.join(dir, name)
+  fs.writeFileSync(filePath, source, { mode: 0o755 })
+  return filePath
+}
+
+function runWithFakeDelegates(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-delegate-fallback-'))
+  try {
+    writeExecutable(tempDir, 'claude', `#!/bin/sh
+if [ "$1" = "auth" ] && [ "$2" = "status" ]; then
+  echo '{"loggedIn":false}'
+  exit 1
+fi
+echo "unexpected claude invocation" >&2
+exit 2
+`)
+
+    writeExecutable(tempDir, 'codex', `#!/bin/sh
+if [ "$1" = "login" ] && [ "$2" = "status" ]; then
+  echo 'logged in'
+  exit 0
+fi
+if [ "$1" = "exec" ]; then
+  cat >/dev/null
+  printf '%s\\n' '{"type":"item.completed","item":{"type":"agent_message","text":"codex fallback ok"}}'
+  exit 0
+fi
+echo "unexpected codex invocation" >&2
+exit 2
+`)
+
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        PATH: `${tempDir}:${process.env.PATH || ''}`,
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{') || line.startsWith('['))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+describe('delegate fallback', () => {
+  it('falls back to another backend when Claude Code is unavailable', () => {
+    const output = runWithFakeDelegates(`
+      const mod = await import('./src/lib/server/session-tools/delegate.ts')
+      const { buildDelegateTools } = mod.default || mod['module.exports'] || mod
+
+      const tools = buildDelegateTools({
+        cwd: process.cwd(),
+        ctx: { sessionId: 'session-test', agentId: 'agent-test', platformAssignScope: 'self' },
+        hasPlugin: (name) => name === 'delegate',
+        hasTool: (name) => name === 'delegate',
+        cleanupFns: [],
+        commandTimeoutMs: 5000,
+        claudeTimeoutMs: 5000,
+        cliProcessTimeoutMs: 5000,
+        persistDelegateResumeId: () => {},
+        readStoredDelegateResumeId: () => null,
+        resolveCurrentSession: () => null,
+        activePlugins: ['delegate'],
+      })
+
+      const delegateTool = tools.find((tool) => tool.name === 'delegate')
+      const raw = await delegateTool.invoke({ task: 'write a helper', backend: 'claude' })
+      console.log(raw)
+    `)
+
+    assert.equal(output.backend, 'codex')
+    assert.equal(output.status, 'completed')
+    assert.match(String(output.response || ''), /codex fallback ok/i)
+  })
+
+  it('accepts wrapped function-call payloads with tool_name aliases', () => {
+    const output = runWithFakeDelegates(`
+      const mod = await import('./src/lib/server/session-tools/delegate.ts')
+      const { buildDelegateTools } = mod.default || mod['module.exports'] || mod
+
+      const tools = buildDelegateTools({
+        cwd: process.cwd(),
+        ctx: { sessionId: 'session-test', agentId: 'agent-test', platformAssignScope: 'self' },
+        hasPlugin: (name) => name === 'delegate',
+        hasTool: (name) => name === 'delegate',
+        cleanupFns: [],
+        commandTimeoutMs: 5000,
+        claudeTimeoutMs: 5000,
+        cliProcessTimeoutMs: 5000,
+        persistDelegateResumeId: () => {},
+        readStoredDelegateResumeId: () => null,
+        resolveCurrentSession: () => null,
+        activePlugins: ['delegate'],
+      })
+
+      const delegateTool = tools.find((tool) => tool.name === 'delegate')
+      const raw = await delegateTool.invoke({
+        input: JSON.stringify({
+          function: 'delegate',
+          parameters: {
+            tool_name: 'Claude Code',
+            parameters: {
+              task: 'Create a proof file',
+            },
+          },
+        }),
+      })
+      console.log(raw)
+    `)
+
+    assert.equal(output.backend, 'codex')
+    assert.equal(output.status, 'completed')
+    assert.match(String(output.response || ''), /codex fallback ok/i)
+  })
+
+  it('synthesizes a delegated task from write-style payloads', () => {
+    const output = runWithFakeDelegates(`
+      const mod = await import('./src/lib/server/session-tools/delegate.ts')
+      const { buildDelegateTools } = mod.default || mod['module.exports'] || mod
+
+      const tools = buildDelegateTools({
+        cwd: process.cwd(),
+        ctx: { sessionId: 'session-test', agentId: 'agent-test', platformAssignScope: 'self' },
+        hasPlugin: (name) => name === 'delegate',
+        hasTool: (name) => name === 'delegate',
+        cleanupFns: [],
+        commandTimeoutMs: 5000,
+        claudeTimeoutMs: 5000,
+        cliProcessTimeoutMs: 5000,
+        persistDelegateResumeId: () => {},
+        readStoredDelegateResumeId: () => null,
+        resolveCurrentSession: () => null,
+        activePlugins: ['delegate'],
+      })
+
+      const delegateTool = tools.find((tool) => tool.name === 'delegate')
+      const raw = await delegateTool.invoke({
+        input: JSON.stringify({
+          action: 'write',
+          target: 'delegate-proof.md',
+          content: 'Proof content',
+        }),
+      })
+      console.log(raw)
+    `)
+
+    assert.equal(output.backend, 'codex')
+    assert.equal(output.status, 'completed')
+    assert.match(String(output.response || ''), /codex fallback ok/i)
+  })
+
+  it('synthesizes a delegated task for action=start payloads that only provide files', () => {
+    const output = runWithFakeDelegates(`
+      const mod = await import('./src/lib/server/session-tools/delegate.ts')
+      const { buildDelegateTools } = mod.default || mod['module.exports'] || mod
+
+      const tools = buildDelegateTools({
+        cwd: process.cwd(),
+        ctx: { sessionId: 'session-test', agentId: 'agent-test', platformAssignScope: 'self' },
+        hasPlugin: (name) => name === 'delegate',
+        hasTool: (name) => name === 'delegate',
+        cleanupFns: [],
+        commandTimeoutMs: 5000,
+        claudeTimeoutMs: 5000,
+        cliProcessTimeoutMs: 5000,
+        persistDelegateResumeId: () => {},
+        readStoredDelegateResumeId: () => null,
+        resolveCurrentSession: () => null,
+        activePlugins: ['delegate'],
+      })
+
+      const delegateTool = tools.find((tool) => tool.name === 'delegate')
+      const raw = await delegateTool.invoke({
+        input: JSON.stringify({
+          action: 'start',
+          name: 'Create Weather Script',
+          files: [{
+            path: 'weather_update/weather_fetcher.py',
+            content: 'print("weather")',
+          }],
+        }),
+      })
+      console.log(raw)
+    `)
+
+    assert.equal(output.backend, 'codex')
+    assert.equal(output.status, 'completed')
+    assert.match(String(output.response || ''), /codex fallback ok/i)
+  })
+
+  it('ranks authenticated delegate backends ahead of unauthenticated ones', () => {
+    const output = runWithFakeDelegates(`
+      const mod = await import('./src/lib/server/provider-health.ts')
+      const { rankDelegatesByHealth } = mod.default || mod['module.exports'] || mod
+      const ranked = rankDelegatesByHealth(['delegate_to_claude_code', 'delegate_to_codex_cli'])
+      console.log(JSON.stringify(ranked))
+    `)
+
+    assert.deepEqual(output, ['delegate_to_codex_cli', 'delegate_to_claude_code'])
+  })
+})