@swarmclawai/swarmclaw 1.2.4 → 1.2.6

package/src/lib/server/session-tools/manage-tasks.test.ts

@@ -111,4 +111,156 @@ describe('manage_tasks tool', () => {
     assert.equal(output.created.codexResumeId, 'codex-thread-1')
     assert.deepEqual(output.created.blockedBy, ['task-source'])
   })
+
+  it('auto-assigns unowned tasks to a better-fit teammate when delegation is enabled', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage')
+      const crudMod = await import('./src/lib/server/session-tools/crud')
+      const storage = storageMod.default || storageMod
+      const crud = crudMod.default || crudMod
+
+      const now = Date.now()
+      storage.saveAgents({
+        ceo: {
+          id: 'ceo',
+          name: 'CEO',
+          role: 'coordinator',
+          description: 'Directs specialist workers',
+          systemPrompt: '',
+          provider: 'openai',
+          model: 'gpt-test',
+          capabilities: ['coordination', 'delegation', 'operations'],
+          delegationEnabled: true,
+          delegationTargetMode: 'all',
+          delegationTargetAgentIds: [],
+          createdAt: now,
+          updatedAt: now,
+        },
+        builder: {
+          id: 'builder',
+          name: 'Builder',
+          role: 'worker',
+          description: 'Builds and debugs software',
+          systemPrompt: '',
+          provider: 'openai',
+          model: 'gpt-test',
+          capabilities: ['coding', 'implementation', 'debugging'],
+          createdAt: now,
+          updatedAt: now,
+        },
+        researcher: {
+          id: 'researcher',
+          name: 'Researcher',
+          role: 'worker',
+          description: 'Research and synthesis specialist',
+          systemPrompt: '',
+          provider: 'openai',
+          model: 'gpt-test',
+          capabilities: ['research', 'analysis', 'summarization'],
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+
+      const tools = crud.buildCrudTools({
+        cwd: process.env.WORKSPACE_DIR,
+        ctx: { sessionId: 'session-auto-assign', agentId: 'ceo', delegationEnabled: true, delegationTargetMode: 'all', delegationTargetAgentIds: [] },
+        hasExtension: (name) => name === 'manage_tasks',
+      })
+      const tool = tools.find((entry) => entry.name === 'manage_tasks')
+      const raw = await tool.invoke({
+        action: 'create',
+        title: 'Implement API integration',
+        description: 'Build the API client and fix the failing tests.',
+        requiredCapabilities: ['coding'],
+        status: 'backlog',
+      })
+
+      const response = JSON.parse(raw)
+      const stored = storage.loadTasks()[response.id]
+      console.log(JSON.stringify({ response, stored }))
+    `)
+
+    assert.equal(output.response.agentId, 'builder')
+    assert.equal(output.stored.agentId, 'builder')
+    assert.equal(output.response.delegationAdvisory.autoAssigned, true)
+    assert.equal(output.response.delegationAdvisory.recommendedAgentId, 'builder')
+    assert.deepEqual(output.response.delegationAdvisory.requiredCapabilities, ['coding'])
+  })
+
+  it('keeps an explicit assignee but returns delegation advisory when another teammate is a better fit', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage')
+      const crudMod = await import('./src/lib/server/session-tools/crud')
+      const storage = storageMod.default || storageMod
+      const crud = crudMod.default || crudMod
+
+      const now = Date.now()
+      storage.saveAgents({
+        ceo: {
+          id: 'ceo',
+          name: 'CEO',
+          role: 'coordinator',
+          description: 'Directs specialist workers',
+          systemPrompt: '',
+          provider: 'openai',
+          model: 'gpt-test',
+          capabilities: ['coordination', 'delegation', 'operations'],
+          delegationEnabled: true,
+          delegationTargetMode: 'all',
+          delegationTargetAgentIds: [],
+          createdAt: now,
+          updatedAt: now,
+        },
+        builder: {
+          id: 'builder',
+          name: 'Builder',
+          role: 'worker',
+          description: 'Builds and debugs software',
+          systemPrompt: '',
+          provider: 'openai',
+          model: 'gpt-test',
+          capabilities: ['coding', 'implementation', 'debugging'],
+          createdAt: now,
+          updatedAt: now,
+        },
+        researcher: {
+          id: 'researcher',
+          name: 'Researcher',
+          role: 'worker',
+          description: 'Research and synthesis specialist',
+          systemPrompt: '',
+          provider: 'openai',
+          model: 'gpt-test',
+          capabilities: ['research', 'analysis', 'summarization'],
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+
+      const tools = crud.buildCrudTools({
+        cwd: process.env.WORKSPACE_DIR,
+        ctx: { sessionId: 'session-explicit-assign', agentId: 'ceo', delegationEnabled: true, delegationTargetMode: 'all', delegationTargetAgentIds: [] },
+        hasExtension: (name) => name === 'manage_tasks',
+      })
+      const tool = tools.find((entry) => entry.name === 'manage_tasks')
+      const raw = await tool.invoke({
+        action: 'create',
+        title: 'Implement API integration',
+        description: 'Build the API client and fix the failing tests.',
+        agentId: 'researcher',
+        requiredCapabilities: ['coding'],
+        status: 'backlog',
+      })
+
+      const response = JSON.parse(raw)
+      const stored = storage.loadTasks()[response.id]
+      console.log(JSON.stringify({ response, stored }))
+    `)
+
+    assert.equal(output.response.agentId, 'researcher')
+    assert.equal(output.stored.agentId, 'researcher')
+    assert.equal(output.response.delegationAdvisory.autoAssigned, false)
+    assert.equal(output.response.delegationAdvisory.recommendedAgentId, 'builder')
+  })
 })

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

@@ -15,6 +15,7 @@ import { expandQuery } from '../query-expansion'
 import type { FileReference, MemoryEntry, MemoryImage, MemoryReference, Extension, ExtensionHooks, Session } from '@/types'
 import type { ToolBuildContext } from './context'
 import { registerNativeCapability } from '../native-capabilities'
+import { getMessages } from '@/lib/server/messages/message-repository'
 import { normalizeToolInputArgs } from './normalize-tool-args'
 import { getMemoryTier, partitionMemoriesByTier, shouldHideFromDurableRecall } from '@/lib/server/memory/memory-tiers'
 import { syncSessionArchiveMemory } from '@/lib/server/memory/session-archive-memory'
@@ -88,13 +89,14 @@ function isSessionContext(ctx: MemoryActionContext | null | undefined): ctx is S
   return !!ctx
     && typeof ctx.id === 'string'
     && typeof ctx.name === 'string'
-    && Array.isArray(ctx.messages)
+    && typeof ctx.provider === 'string'
 }
 
 function latestUserFactFromSession(session: Session | null): string {
-  if (!session || !Array.isArray(session.messages)) return ''
-  for (let index = session.messages.length - 1; index >= 0; index--) {
-    const message = session.messages[index]
+  if (!session) return ''
+  const messages = getMessages(session.id)
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index]
     if (message?.role !== 'user') continue
     const text = typeof message.text === 'string' ? message.text.replace(/\s+/g, ' ').trim() : ''
     if (text) return text

package/src/lib/server/session-tools/session-info.test.ts

@@ -0,0 +1,56 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { buildSessionIdentityPayload } from '@/lib/server/session-tools/session-info'
+
+describe('buildSessionIdentityPayload', () => {
+  it('includes harness, project, provider, and delegation context for identity queries', () => {
+    const payload = buildSessionIdentityPayload({
+      context: { sessionId: 'session-child', agentId: 'agent-1' },
+      currentSession: {
+        id: 'session-child',
+        name: 'Builder Chat',
+        cwd: '/workspace/projects/northstar',
+        provider: 'openai',
+        model: 'gpt-5',
+        user: 'system',
+        createdAt: 1,
+        lastActiveAt: 1,
+        claudeSessionId: null,
+        parentSessionId: 'session-parent',
+        sessionType: 'human',
+        agentId: 'agent-1',
+        messages: [],
+      } as never,
+      currentAgent: {
+        name: 'Builder',
+        delegationTargetMode: 'selected',
+        delegationTargetAgentIds: ['qa-1', 'ops-1'],
+      } as never,
+      activeProjectContext: {
+        projectId: 'project-1',
+        project: { name: 'Northstar' },
+      } as never,
+      enabledExtensions: ['files', 'manage_sessions', 'codex_cli'],
+      toolPolicy: {
+        mode: 'balanced',
+        requestedExtensions: ['files', 'manage_sessions', 'codex_cli', 'manage_secrets'],
+        enabledExtensions: ['files', 'manage_sessions', 'codex_cli'],
+        blockedExtensions: [{ tool: 'manage_secrets', reason: 'blocked by policy', source: 'policy' }],
+      },
+      rootSessionId: 'session-root',
+    })
+
+    assert.equal(payload.promptMode, 'minimal')
+    assert.equal(payload.projectId, 'project-1')
+    assert.equal(payload.projectName, 'Northstar')
+    assert.equal(payload.provider, 'openai')
+    assert.equal(payload.model, 'gpt-5')
+    assert.equal(payload.rootSessionId, 'session-root')
+    assert.deepEqual(payload.enabledExtensions, ['files', 'manage_sessions', 'codex_cli'])
+    assert.deepEqual(payload.blockedExtensions, [{ tool: 'manage_secrets', reason: 'blocked by policy', source: 'policy' }])
+    assert.equal(payload.delegationEnabled, true)
+    assert.equal(payload.delegationTargetMode, 'selected')
+    assert.deepEqual(payload.delegationTargetAgentIds, ['qa-1', 'ops-1'])
+  })
+})

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

@@ -3,10 +3,19 @@ import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import { genId } from '@/lib/id'
 import { loadSessions, saveSessions, loadAgents } from '../storage'
 import type { ToolBuildContext } from './context'
-import type { Extension, ExtensionHooks } from '@/types'
+import type { ActiveProjectContext } from '@/lib/server/project-context'
+import type { SessionToolPolicyDecision } from '@/lib/server/tool-capability-policy'
+import type { Agent, Extension, ExtensionHooks, Session } from '@/types'
 import { registerNativeCapability } from '../native-capabilities'
 import { normalizeToolInputArgs } from './normalize-tool-args'
-import { getEnabledCapabilitySelection } from '@/lib/capability-selection'
+import { getEnabledCapabilityIds, getEnabledCapabilitySelection } from '@/lib/capability-selection'
+import { getExtensionManager } from '@/lib/server/extensions'
+import { canonicalizeExtensionId, expandExtensionIds } from '@/lib/server/tool-aliases'
+import { resolvePromptMode } from '@/lib/server/chat-execution/prompt-mode'
+import { resolveActiveProjectContext } from '@/lib/server/project-context'
+import { resolveSessionLineageIds } from '@/lib/server/sessions/session-lineage'
+import { loadSettings } from '@/lib/server/settings/settings-repository'
+import { resolveSessionToolPolicy } from '@/lib/server/tool-capability-policy'
 
 /**
  * Core Session Info Execution Logic
@@ -15,17 +24,111 @@ async function executeWhoAmI(context: { sessionId?: string; agentId?: string })
   try {
     const sessions = loadSessions()
     const current = context.sessionId ? sessions[context.sessionId] : null
-    return JSON.stringify({
-      sessionId: context.sessionId || undefined,
-      sessionName: current?.name || undefined,
-      sessionType: current?.sessionType || undefined,
-      user: current?.user || undefined,
-      agentId: context.agentId || current?.agentId || undefined,
-      parentSessionId: current?.parentSessionId || undefined,
-    })
+    const agents = loadAgents()
+    const agentRecord = (context.agentId ? agents[context.agentId] : null) || (current?.agentId ? agents[current.agentId] : null) || null
+    const { toolPolicy, enabledExtensions } = resolveSessionIdentityAccess(current)
+    const activeProjectContext = resolveActiveProjectContext(current || { agentId: context.agentId || null, cwd: null, projectId: null })
+    const { rootSessionId } = resolveSessionLineageIds(current || { id: context.sessionId || '', parentSessionId: null })
+    return JSON.stringify(buildSessionIdentityPayload({
+      context,
+      currentSession: current,
+      currentAgent: agentRecord || null,
+      activeProjectContext,
+      enabledExtensions,
+      toolPolicy,
+      rootSessionId,
+    }))
   } catch (err: any) { return `Error: ${err.message}` }
 }
 
+function normalizeRuntimeExtensionId(extensionId: string): string {
+  const normalized = extensionId.trim().toLowerCase()
+  if (!normalized) return ''
+  if (normalized === 'delegate_to_claude_code' || normalized === 'claude_code') return 'claude_code'
+  if (normalized === 'delegate_to_codex_cli' || normalized === 'codex_cli') return 'codex_cli'
+  if (normalized === 'delegate_to_opencode_cli' || normalized === 'opencode_cli') return 'opencode_cli'
+  if (normalized === 'delegate_to_gemini_cli' || normalized === 'gemini_cli') return 'gemini_cli'
+  if (['session_info', 'sessions_tool', 'whoami_tool', 'search_history_tool'].includes(normalized)) return 'manage_sessions'
+  return canonicalizeExtensionId(normalized)
+}
+
+function canonicalizeEnabledExtensions(enabledExtensions: string[]): string[] {
+  const seen = new Set<string>()
+  const values: string[] = []
+  for (const extensionId of enabledExtensions) {
+    const normalized = normalizeRuntimeExtensionId(extensionId)
+    if (!normalized || seen.has(normalized)) continue
+    seen.add(normalized)
+    values.push(normalized)
+  }
+  return values
+}
+
+function resolveSessionIdentityAccess(current: Session | null): {
+  toolPolicy: SessionToolPolicyDecision
+  enabledExtensions: string[]
+} {
+  const rawExtensions = getEnabledCapabilityIds(current)
+  const hasShellCapability = rawExtensions.some((toolId) => ['shell', 'execute_command'].includes(String(toolId)))
+  const extensionManager = getExtensionManager()
+  const requestedExtensions = expandExtensionIds([
+    ...rawExtensions,
+    ...(hasShellCapability ? ['process'] : []),
+  ]).filter((id) => !extensionManager.isExplicitlyDisabled(id))
+  const toolPolicy = resolveSessionToolPolicy(requestedExtensions, loadSettings())
+  const blockedExtensionIds = new Set(expandExtensionIds(toolPolicy.blockedExtensions.map((entry) => entry.tool)))
+  const enabledExtensions = canonicalizeEnabledExtensions(
+    expandExtensionIds(toolPolicy.enabledExtensions)
+      .filter((id) => !blockedExtensionIds.has(id))
+      .filter((id) => !extensionManager.isExplicitlyDisabled(id)),
+  )
+  return { toolPolicy, enabledExtensions }
+}
+
+export function buildSessionIdentityPayload(params: {
+  context: { sessionId?: string; agentId?: string }
+  currentSession: Session | null
+  currentAgent?: Agent | null
+  activeProjectContext?: ActiveProjectContext | null
+  enabledExtensions?: string[]
+  toolPolicy?: SessionToolPolicyDecision | null
+  rootSessionId?: string | null
+}): Record<string, unknown> {
+  const current = params.currentSession
+  const currentAgent = params.currentAgent || null
+  const activeProjectContext = params.activeProjectContext || null
+  const enabledExtensions = Array.isArray(params.enabledExtensions) ? params.enabledExtensions : []
+  const toolPolicy = params.toolPolicy || null
+  const delegationEnabled = enabledExtensions.some((extensionId) => ['delegate', 'spawn_subagent', 'claude_code', 'codex_cli', 'opencode_cli', 'gemini_cli'].includes(extensionId))
+
+  return {
+    sessionId: params.context.sessionId || undefined,
+    sessionName: current?.name || undefined,
+    sessionType: current?.sessionType || undefined,
+    sessionKind: current?.parentSessionId ? 'delegated_child' : 'root_chat',
+    promptMode: current ? resolvePromptMode(current) : undefined,
+    user: current?.user || undefined,
+    agentId: params.context.agentId || current?.agentId || undefined,
+    agentName: typeof currentAgent?.name === 'string' ? currentAgent.name : undefined,
+    parentSessionId: current?.parentSessionId || undefined,
+    rootSessionId: params.rootSessionId || current?.id || undefined,
+    cwd: current?.cwd || undefined,
+    projectId: activeProjectContext?.projectId || undefined,
+    projectName: activeProjectContext?.project?.name || undefined,
+    provider: current?.provider || undefined,
+    model: current?.model || undefined,
+    enabledExtensions,
+    blockedExtensions: toolPolicy?.blockedExtensions || [],
+    delegationEnabled,
+    delegationTargetMode: delegationEnabled
+      ? (currentAgent?.delegationTargetMode === 'selected' ? 'selected' : 'all')
+      : undefined,
+    delegationTargetAgentIds: delegationEnabled && Array.isArray(currentAgent?.delegationTargetAgentIds)
+      ? currentAgent.delegationTargetAgentIds
+      : [],
+  }
+}
+
 function inferSessionsAction(
   normalized: Record<string, unknown>,
   context: { sessionId?: string; agentId?: string },
@@ -133,8 +236,12 @@ const SessionInfoExtension: Extension = {
   name: 'Core Session Info',
   description: 'Identify current session context and manage other agent sessions.',
   hooks: {
-    getCapabilityDescription: () => 'I can manage chat sessions (`sessions_tool`) — check my identity with action `identity`, look up past conversations, spawn sessions, and coordinate work.',
-    getOperatingGuidance: () => 'Inspect existing chats before creating duplicates.',
+    getCapabilityDescription: () => 'I can manage chat sessions (`sessions_tool`) — inspect live harness/session context with action `identity`, look up past session messages with `history`, spawn sessions, and coordinate work.',
+    getOperatingGuidance: () => [
+      'Use `sessions_tool` action `identity` when you need live session, project, lineage, or enabled-tool context.',
+      'Use `sessions_tool` action `history` only when you need earlier messages from this same session that are not already visible in the current thread.',
+      'Inspect existing chats before creating duplicates.',
+    ],
   } as ExtensionHooks,
   tools: [
     {

package/src/lib/server/session-tools/skill-runtime.ts

@@ -2,7 +2,9 @@ import { z } from 'zod'
 import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import type { Agent, Session, SessionSkillRuntimeState } from '@/types'
 import { errorMessage } from '@/lib/shared-utils'
-import { loadAgent, loadSkills, patchSession } from '@/lib/server/storage'
+import { loadAgent } from '@/lib/server/agents/agent-repository'
+import { loadSkills } from '@/lib/server/skills/skill-repository'
+import { patchSession } from '@/lib/server/sessions/session-repository'
 import {
   findResolvedSkill,
   recommendRuntimeSkillsForTask,

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

@@ -4,11 +4,15 @@ import { dedup, errorMessage } from '@/lib/shared-utils'
 import { requestApproval } from '@/lib/server/approvals'
 import {
   loadAgent,
-  loadApprovals,
-  loadSkills,
   patchAgent,
-  saveSkills,
-} from '@/lib/server/storage'
+} from '@/lib/server/agents/agent-repository'
+import { loadApproval, loadApprovals } from '@/lib/server/approvals/approval-repository'
+import {
+  deleteSkill,
+  loadSkill,
+  loadSkills,
+  saveSkill,
+} from '@/lib/server/skills/skill-repository'
 import { fetchSkillContent, searchClawHub } from '@/lib/server/skills/clawhub-client'
 import { clearDiscoveredSkillsCache } from '@/lib/server/skills/skill-discovery'
 import {
@@ -133,11 +137,10 @@ function upsertStoredSkill(input: {
   existingId?: string
   body: Record<string, unknown>
 }): Skill {
-  const skills = loadSkills()
   const normalized = normalizeSkillPayload(input.body)
   const now = Date.now()
   const id = input.existingId || genId()
-  const previous = input.existingId ? skills[input.existingId] : null
+  const previous = input.existingId ? loadSkill(input.existingId) : null
 
   const next: Skill = {
     id,
@@ -171,8 +174,7 @@ function upsertStoredSkill(input: {
     updatedAt: now,
   }
 
-  skills[id] = next
-  saveSkills(skills)
+  saveSkill(id, next)
   clearDiscoveredSkillsCache()
   return next
 }
@@ -241,7 +243,7 @@ function ensureApprovedInstall(approvalId: string | null | undefined): ApprovalR
   if (!normalized) {
     throw new Error('This install requires approval. Call manage_skills install first to create the approval request, then retry with approvalId after approval.')
   }
-  const approval = loadApprovals()[normalized]
+  const approval = loadApproval(normalized)
   if (!approval) throw new Error(`Approval "${normalized}" not found.`)
   if (approval.status !== 'approved') {
     throw new Error(`Approval "${normalized}" is not approved yet.`)
@@ -251,7 +253,7 @@ function ensureApprovedInstall(approvalId: string | null | undefined): ApprovalR
 
 async function materializeResolvedSkill(skill: ResolvedRuntimeSkill): Promise<Skill> {
   const skills = loadSkills()
-  const existing = skill.storageId ? skills[skill.storageId] : null
+  const existing = skill.storageId ? loadSkill(skill.storageId) : null
   if (existing) return existing
   const duplicate = Object.values(skills).find((entry) =>
     normalizeKey(entry.skillKey || entry.name) === normalizeKey(skill.skillKey || skill.name),
@@ -366,7 +368,7 @@ export async function executeManageSkillsAction(
       case 'update': {
         const skillId = typeof normalized.id === 'string' ? normalized.id.trim() : ''
         if (!skillId) return 'Error: "id" is required for update action.'
-        const existing = loadSkills()[skillId]
+        const existing = loadSkill(skillId)
         if (!existing) return `Not found: skills "${skillId}"`
         const updated = upsertStoredSkill({
           existingId: skillId,
@@ -377,10 +379,8 @@ export async function executeManageSkillsAction(
       case 'delete': {
         const skillId = typeof normalized.id === 'string' ? normalized.id.trim() : ''
         if (!skillId) return 'Error: "id" is required for delete action.'
-        const skills = loadSkills()
-        if (!skills[skillId]) return `Not found: skills "${skillId}"`
-        delete skills[skillId]
-        saveSkills(skills)
+        if (!loadSkill(skillId)) return `Not found: skills "${skillId}"`
+        deleteSkill(skillId)
         return JSON.stringify({ deleted: skillId })
       }
       case 'status': {

package/src/lib/server/session-tools/subagent.test.ts

@@ -1,8 +1,41 @@
 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'
 
 import { buildSessionTools } from './index'
 
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-subagent-tool-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        DATA_DIR: path.join(tempDir, 'data'),
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+        SWARMCLAW_BUILD_MODE: '1',
+      },
+      encoding: 'utf-8',
+      timeout: 30_000,
+    })
+    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('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
 describe('spawn_subagent runtime access', () => {
   it('hides spawn_subagent unless delegation is enabled', async () => {
     const built = await buildSessionTools(process.cwd(), ['spawn_subagent'], {
@@ -42,9 +75,90 @@ describe('spawn_subagent runtime access', () => {
         message: 'hello',
       })
 
-      assert.match(String(raw), /not in the allowed delegate agent list/i)
+      assert.match(String(raw), /allowed delegation list/i)
     } finally {
       await built.cleanup()
     }
   })
+
+  it('resolves best_fit start requests to the best allowed delegate', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage')
+      const toolsMod = await import('./src/lib/server/session-tools')
+      const storage = storageMod.default || storageMod
+      const toolsApi = toolsMod.default || toolsMod
+
+      const now = Date.now()
+      storage.saveAgents({
+        ceo: {
+          id: 'ceo',
+          name: 'CEO',
+          role: 'coordinator',
+          description: 'Executes through specialists',
+          systemPrompt: '',
+          provider: 'openai',
+          model: 'gpt-test',
+          capabilities: ['coordination', 'delegation', 'operations'],
+          delegationEnabled: true,
+          delegationTargetMode: 'selected',
+          delegationTargetAgentIds: ['builder', 'writer'],
+          createdAt: now,
+          updatedAt: now,
+        },
+        builder: {
+          id: 'builder',
+          name: 'Builder',
+          role: 'worker',
+          description: 'Builds product changes',
+          systemPrompt: '',
+          provider: 'openai',
+          model: 'gpt-test',
+          capabilities: ['coding', 'implementation', 'debugging'],
+          createdAt: now,
+          updatedAt: now,
+        },
+        writer: {
+          id: 'writer',
+          name: 'Writer',
+          role: 'worker',
+          description: 'Writes and edits content',
+          systemPrompt: '',
+          provider: 'openai',
+          model: 'gpt-test',
+          capabilities: ['writing', 'editing'],
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+
+      const built = await toolsApi.buildSessionTools(process.env.WORKSPACE_DIR, ['spawn_subagent'], {
+        sessionId: 'session-best-fit',
+        agentId: 'ceo',
+        delegationEnabled: true,
+        delegationTargetMode: 'selected',
+        delegationTargetAgentIds: ['builder', 'writer'],
+      })
+
+      try {
+        const tool = built.tools.find((entry) => entry.name === 'spawn_subagent')
+        const raw = await tool.invoke({
+          action: 'start',
+          selectionMode: 'best_fit',
+          message: 'Implement the API change and fix the failing tests.',
+          workType: 'coding',
+          requiredCapabilities: ['coding', 'debugging'],
+          background: true,
+        })
+        console.log(JSON.stringify(JSON.parse(String(raw))))
+      } finally {
+        await built.cleanup()
+      }
+      process.exit(0)
+    `)
+
+    assert.equal(output.selectionMode, 'best_fit')
+    assert.equal(output.agentId, 'builder')
+    assert.equal(output.workType, 'coding')
+    assert.deepEqual(output.requiredCapabilities, ['coding', 'debugging'])
+  })
 })