@swarmclawai/swarmclaw 0.7.2 → 0.7.4

package/src/lib/memory-presentation.ts

@@ -0,0 +1,59 @@
+import type { MemoryEntry } from '@/types'
+
+export type MemoryTier = 'working' | 'durable' | 'archive'
+export type MemoryScopeBadge = 'global' | 'agent' | 'shared' | 'session' | 'project'
+
+const WORKING_CATEGORIES = new Set(['execution', 'working', 'scratch', 'breadcrumb'])
+const ARCHIVE_CATEGORIES = new Set(['session_archive'])
+
+function hasProjectRoot(entry: Pick<MemoryEntry, 'metadata' | 'references' | 'filePaths'>): boolean {
+  const metadataRoot = typeof entry.metadata?.projectRoot === 'string' ? entry.metadata.projectRoot.trim() : ''
+  if (metadataRoot) return true
+
+  if (Array.isArray(entry.references)) {
+    for (const ref of entry.references) {
+      if (typeof ref.projectRoot === 'string' && ref.projectRoot.trim()) return true
+      if ((ref.type === 'project' || ref.type === 'folder' || ref.type === 'file') && typeof ref.path === 'string' && ref.path.trim()) {
+        return true
+      }
+    }
+  }
+
+  if (Array.isArray(entry.filePaths)) {
+    for (const ref of entry.filePaths) {
+      if (typeof ref.projectRoot === 'string' && ref.projectRoot.trim()) return true
+      if (typeof ref.path === 'string' && ref.path.trim()) return true
+    }
+  }
+
+  return false
+}
+
+export function getMemoryTierForCategory(category: unknown): MemoryTier {
+  const normalized = typeof category === 'string' ? category.trim().toLowerCase() : ''
+  if (ARCHIVE_CATEGORIES.has(normalized)) return 'archive'
+  if (WORKING_CATEGORIES.has(normalized)) return 'working'
+  return 'durable'
+}
+
+export function getMemoryTier(entry: Pick<MemoryEntry, 'category' | 'metadata'>): MemoryTier {
+  const metadataTier = typeof entry.metadata?.tier === 'string' ? entry.metadata.tier.trim().toLowerCase() : ''
+  if (metadataTier === 'working' || metadataTier === 'durable' || metadataTier === 'archive') {
+    return metadataTier
+  }
+  if (metadataTier === 'session_archive') return 'archive'
+  return getMemoryTierForCategory(entry.category)
+}
+
+export function deriveMemoryScope(entry: Pick<MemoryEntry, 'agentId' | 'sessionId' | 'sharedWith' | 'metadata' | 'references' | 'filePaths'>): MemoryScopeBadge {
+  if (entry.sessionId) return 'session'
+  if (hasProjectRoot(entry)) return 'project'
+  if (entry.agentId && Array.isArray(entry.sharedWith) && entry.sharedWith.length > 0) return 'shared'
+  if (entry.agentId) return 'agent'
+  return 'global'
+}
+
+export function getMemoryScopeLabel(scope: MemoryScopeBadge): string {
+  if (scope === 'agent') return 'private'
+  return scope
+}

package/src/lib/openclaw-agent-id.test.ts

@@ -0,0 +1,14 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { buildOpenClawMainSessionKey, normalizeOpenClawAgentId } from './openclaw-agent-id'
+
+test('normalizeOpenClawAgentId mirrors gateway-style normalization', () => {
+  assert.equal(normalizeOpenClawAgentId('OpenClaw Ops'), 'openclaw-ops')
+  assert.equal(normalizeOpenClawAgentId('  Agent / Research  '), 'agent-research')
+  assert.equal(normalizeOpenClawAgentId('main'), 'main')
+})
+
+test('buildOpenClawMainSessionKey uses normalized OpenClaw agent ids', () => {
+  assert.equal(buildOpenClawMainSessionKey('OpenClaw Ops'), 'agent:openclaw-ops:main')
+  assert.equal(buildOpenClawMainSessionKey('   '), null)
+})

package/src/lib/openclaw-agent-id.ts

@@ -0,0 +1,31 @@
+const VALID_ID_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/i
+const INVALID_CHARS_RE = /[^a-z0-9_-]+/g
+const LEADING_DASH_RE = /^-+/
+const TRAILING_DASH_RE = /-+$/
+
+export function normalizeOpenClawAgentId(value: string | undefined | null): string {
+  const trimmed = (value ?? '').trim()
+  if (!trimmed) {
+    return 'main'
+  }
+  if (VALID_ID_RE.test(trimmed)) {
+    return trimmed.toLowerCase()
+  }
+  return (
+    trimmed
+      .toLowerCase()
+      .replace(INVALID_CHARS_RE, '-')
+      .replace(LEADING_DASH_RE, '')
+      .replace(TRAILING_DASH_RE, '')
+      .slice(0, 64)
+    || 'main'
+  )
+}
+
+export function buildOpenClawMainSessionKey(agentNameOrId: string | undefined | null): string | null {
+  const trimmed = (agentNameOrId ?? '').trim()
+  if (!trimmed) {
+    return null
+  }
+  return `agent:${normalizeOpenClawAgentId(trimmed)}:main`
+}

package/src/lib/provider-model-discovery-client.ts

@@ -0,0 +1,29 @@
+import { api } from './api-client'
+import type { ProviderModelDiscoveryResult } from '@/types'
+
+export interface DiscoverProviderModelsParams {
+  providerId: string
+  credentialId?: string | null
+  endpoint?: string | null
+  force?: boolean
+  requiresApiKey?: boolean
+}
+
+export function buildProviderModelDiscoveryPath(params: DiscoverProviderModelsParams): string {
+  const searchParams = new URLSearchParams()
+  if (params.credentialId) searchParams.set('credentialId', params.credentialId)
+  if (params.endpoint?.trim()) searchParams.set('endpoint', params.endpoint.trim())
+  if (params.force) searchParams.set('force', '1')
+  if (typeof params.requiresApiKey === 'boolean') {
+    searchParams.set('requiresApiKey', params.requiresApiKey ? '1' : '0')
+  }
+  const query = searchParams.toString()
+  const encodedProviderId = encodeURIComponent(params.providerId)
+  return `/providers/${encodedProviderId}/discover-models${query ? `?${query}` : ''}`
+}
+
+export function fetchProviderModelDiscovery(
+  params: DiscoverProviderModelsParams,
+): Promise<ProviderModelDiscoveryResult> {
+  return api<ProviderModelDiscoveryResult>('GET', buildProviderModelDiscoveryPath(params))
+}

package/src/lib/providers/index.ts

@@ -256,11 +256,16 @@ export function getProviderList(): ProviderInfo[] {
   const overrides = getModelOverrides()
   const builtins = Object.values(PROVIDERS)
     .filter(({ id }) => id !== 'openclaw')
-    .map(({ handler, ...info }) => ({
-      ...info,
-      models: overrides[info.id] || info.models,
-      defaultModels: info.models,
-    }))
+    .map((provider) => {
+      const { handler, ...info } = provider
+      void handler
+      return {
+        ...info,
+        models: overrides[info.id] || info.models,
+        defaultModels: info.models,
+        supportsModelDiscovery: !['claude-cli', 'codex-cli', 'opencode-cli', 'fireworks'].includes(info.id),
+      }
+    })
   
   const customs: ProviderInfo[] = Object.values(getCustomProviders())
     .filter((c) => c.isEnabled)
@@ -269,6 +274,7 @@ export function getProviderList(): ProviderInfo[] {
       name: c.name,
       models: c.models,
       defaultModels: c.models,
+      supportsModelDiscovery: !!(c.baseUrl && c.baseUrl.trim()),
       requiresApiKey: c.requiresApiKey,
       requiresEndpoint: false as boolean,
       defaultEndpoint: c.baseUrl,
@@ -283,6 +289,7 @@ export function getProviderList(): ProviderInfo[] {
       name: String(p.name),
       models: p.models as string[],
       defaultModels: p.models as string[],
+      supportsModelDiscovery: Boolean(p.supportsModelDiscovery),
       requiresApiKey: Boolean(p.requiresApiKey),
       requiresEndpoint: Boolean(p.requiresEndpoint),
       defaultEndpoint: p.defaultEndpoint as string | undefined,

package/src/lib/runtime-loop.ts

@@ -3,9 +3,28 @@ import type { LoopMode } from '@/types'
 export const DEFAULT_LOOP_MODE: LoopMode = 'bounded'
 
 // Loop limits
-export const DEFAULT_AGENT_LOOP_RECURSION_LIMIT = 30
-export const DEFAULT_ORCHESTRATOR_LOOP_RECURSION_LIMIT = 40
-export const DEFAULT_LEGACY_ORCHESTRATOR_MAX_TURNS = 10
+export const AGENT_LOOP_RECURSION_LIMIT_MIN = 1
+export const AGENT_LOOP_RECURSION_LIMIT_MAX = 200
+export const ORCHESTRATOR_LOOP_RECURSION_LIMIT_MIN = 1
+export const ORCHESTRATOR_LOOP_RECURSION_LIMIT_MAX = 300
+export const LEGACY_ORCHESTRATOR_MAX_TURNS_MIN = 1
+export const LEGACY_ORCHESTRATOR_MAX_TURNS_MAX = 300
+export const ONGOING_LOOP_MAX_ITERATIONS_MIN = 10
+export const ONGOING_LOOP_MAX_ITERATIONS_MAX = 5000
+export const ONGOING_LOOP_MAX_RUNTIME_MINUTES_MIN = 0
+export const ONGOING_LOOP_MAX_RUNTIME_MINUTES_MAX = 1440
+export const DELEGATION_MAX_DEPTH_MIN = 1
+export const DELEGATION_MAX_DEPTH_MAX = 12
+export const SHELL_COMMAND_TIMEOUT_SEC_MIN = 1
+export const SHELL_COMMAND_TIMEOUT_SEC_MAX = 600
+export const CLAUDE_CODE_TIMEOUT_SEC_MIN = 5
+export const CLAUDE_CODE_TIMEOUT_SEC_MAX = 7200
+export const CLI_PROCESS_TIMEOUT_SEC_MIN = 10
+export const CLI_PROCESS_TIMEOUT_SEC_MAX = 7200
+
+export const DEFAULT_AGENT_LOOP_RECURSION_LIMIT = 60
+export const DEFAULT_ORCHESTRATOR_LOOP_RECURSION_LIMIT = 80
+export const DEFAULT_LEGACY_ORCHESTRATOR_MAX_TURNS = 16
 export const DEFAULT_ONGOING_LOOP_MAX_ITERATIONS = 250
 export const DEFAULT_ONGOING_LOOP_MAX_RUNTIME_MINUTES = 60
 export const DEFAULT_DELEGATION_MAX_DEPTH = 3
@@ -14,3 +33,86 @@ export const DEFAULT_DELEGATION_MAX_DEPTH = 3
 export const DEFAULT_SHELL_COMMAND_TIMEOUT_SEC = 30
 export const DEFAULT_CLAUDE_CODE_TIMEOUT_SEC = 1800
 export const DEFAULT_CLI_PROCESS_TIMEOUT_SEC = 1800
+
+function parseIntSetting(value: unknown, fallback: number, min: number, max: number): number {
+  const parsed = typeof value === 'number'
+    ? value
+    : typeof value === 'string'
+      ? Number.parseInt(value, 10)
+      : Number.NaN
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.max(min, Math.min(max, Math.trunc(parsed)))
+}
+
+export interface NormalizedRuntimeSettingFields {
+  loopMode: LoopMode
+  agentLoopRecursionLimit: number
+  orchestratorLoopRecursionLimit: number
+  legacyOrchestratorMaxTurns: number
+  delegationMaxDepth: number
+  ongoingLoopMaxIterations: number
+  ongoingLoopMaxRuntimeMinutes: number
+  shellCommandTimeoutSec: number
+  claudeCodeTimeoutSec: number
+  cliProcessTimeoutSec: number
+}
+
+export function normalizeRuntimeSettingFields(settings: Record<string, unknown>): NormalizedRuntimeSettingFields {
+  return {
+    loopMode: settings.loopMode === 'ongoing' ? 'ongoing' : DEFAULT_LOOP_MODE,
+    agentLoopRecursionLimit: parseIntSetting(
+      settings.agentLoopRecursionLimit,
+      DEFAULT_AGENT_LOOP_RECURSION_LIMIT,
+      AGENT_LOOP_RECURSION_LIMIT_MIN,
+      AGENT_LOOP_RECURSION_LIMIT_MAX,
+    ),
+    orchestratorLoopRecursionLimit: parseIntSetting(
+      settings.orchestratorLoopRecursionLimit,
+      DEFAULT_ORCHESTRATOR_LOOP_RECURSION_LIMIT,
+      ORCHESTRATOR_LOOP_RECURSION_LIMIT_MIN,
+      ORCHESTRATOR_LOOP_RECURSION_LIMIT_MAX,
+    ),
+    legacyOrchestratorMaxTurns: parseIntSetting(
+      settings.legacyOrchestratorMaxTurns,
+      DEFAULT_LEGACY_ORCHESTRATOR_MAX_TURNS,
+      LEGACY_ORCHESTRATOR_MAX_TURNS_MIN,
+      LEGACY_ORCHESTRATOR_MAX_TURNS_MAX,
+    ),
+    delegationMaxDepth: parseIntSetting(
+      settings.delegationMaxDepth,
+      DEFAULT_DELEGATION_MAX_DEPTH,
+      DELEGATION_MAX_DEPTH_MIN,
+      DELEGATION_MAX_DEPTH_MAX,
+    ),
+    ongoingLoopMaxIterations: parseIntSetting(
+      settings.ongoingLoopMaxIterations,
+      DEFAULT_ONGOING_LOOP_MAX_ITERATIONS,
+      ONGOING_LOOP_MAX_ITERATIONS_MIN,
+      ONGOING_LOOP_MAX_ITERATIONS_MAX,
+    ),
+    ongoingLoopMaxRuntimeMinutes: parseIntSetting(
+      settings.ongoingLoopMaxRuntimeMinutes,
+      DEFAULT_ONGOING_LOOP_MAX_RUNTIME_MINUTES,
+      ONGOING_LOOP_MAX_RUNTIME_MINUTES_MIN,
+      ONGOING_LOOP_MAX_RUNTIME_MINUTES_MAX,
+    ),
+    shellCommandTimeoutSec: parseIntSetting(
+      settings.shellCommandTimeoutSec,
+      DEFAULT_SHELL_COMMAND_TIMEOUT_SEC,
+      SHELL_COMMAND_TIMEOUT_SEC_MIN,
+      SHELL_COMMAND_TIMEOUT_SEC_MAX,
+    ),
+    claudeCodeTimeoutSec: parseIntSetting(
+      settings.claudeCodeTimeoutSec,
+      DEFAULT_CLAUDE_CODE_TIMEOUT_SEC,
+      CLAUDE_CODE_TIMEOUT_SEC_MIN,
+      CLAUDE_CODE_TIMEOUT_SEC_MAX,
+    ),
+    cliProcessTimeoutSec: parseIntSetting(
+      settings.cliProcessTimeoutSec,
+      DEFAULT_CLI_PROCESS_TIMEOUT_SEC,
+      CLI_PROCESS_TIMEOUT_SEC_MIN,
+      CLI_PROCESS_TIMEOUT_SEC_MAX,
+    ),
+  }
+}

package/src/lib/safe-storage.ts

@@ -1,5 +1,10 @@
 function canUseLocalStorage(): boolean {
-  return typeof window !== 'undefined' && !!window.localStorage
+  if (typeof window === 'undefined') return false
+  try {
+    return !!window.localStorage
+  } catch {
+    return false
+  }
 }
 
 export function safeStorageGet(key: string): string | null {

package/src/lib/server/agent-assignment.test.ts

@@ -0,0 +1,112 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import type { Agent } from '@/types'
+import {
+  isDelegationTaskPayload,
+  resolveDelegatorAgentId,
+  resolveManagedAgentAssignment,
+  validateManagedAgentAssignment,
+} from './agent-assignment'
+
+const now = Date.now()
+const agents: Record<string, Agent> = {
+  molly: {
+    id: 'molly',
+    name: 'Molly',
+    description: '',
+    systemPrompt: '',
+    provider: 'openai',
+    model: 'gpt-4o',
+    createdAt: now,
+    updatedAt: now,
+  },
+  writer: {
+    id: 'writer',
+    name: 'Writer',
+    description: '',
+    systemPrompt: '',
+    provider: 'openai',
+    model: 'gpt-4o',
+    createdAt: now,
+    updatedAt: now,
+  },
+}
+
+describe('resolveManagedAgentAssignment', () => {
+  it('resolves explicit aliases to concrete agent ids', () => {
+    const resolved = resolveManagedAgentAssignment({ assignee: 'Writer' }, agents, 'molly')
+    assert.equal(resolved.agentId, 'writer')
+    assert.equal(resolved.source, 'explicit')
+  })
+
+  it('resolves description-based delegation before scope checks', () => {
+    const resolved = resolveManagedAgentAssignment(
+      { description: 'Please delegate this to @Writer and let them handle the draft.' },
+      agents,
+      'molly',
+    )
+    assert.equal(resolved.agentId, 'writer')
+    assert.equal(resolved.source, 'description')
+  })
+})
+
+describe('validateManagedAgentAssignment', () => {
+  it('blocks assigning another agent when scope is self', () => {
+    const resolved = resolveManagedAgentAssignment({ assignee: 'writer' }, agents, 'molly')
+    const error = validateManagedAgentAssignment({
+      resourceLabel: 'tasks',
+      agents,
+      assignScope: 'self',
+      currentAgentId: 'molly',
+      targetAgentId: resolved.agentId,
+      unresolvedReference: resolved.unresolvedReference,
+    })
+    assert.match(error || '', /only assign tasks to yourself/i)
+  })
+
+  it('allows self-assignment in self scope', () => {
+    const resolved = resolveManagedAgentAssignment({ agentId: 'molly' }, agents, 'molly')
+    const error = validateManagedAgentAssignment({
+      resourceLabel: 'tasks',
+      agents,
+      assignScope: 'self',
+      currentAgentId: 'molly',
+      targetAgentId: resolved.agentId,
+      unresolvedReference: resolved.unresolvedReference,
+    })
+    assert.equal(error, null)
+  })
+
+  it('rejects unknown explicit agent references', () => {
+    const resolved = resolveManagedAgentAssignment({ agentId: 'missing-agent' }, agents, 'molly')
+    const error = validateManagedAgentAssignment({
+      resourceLabel: 'tasks',
+      agents,
+      assignScope: 'all',
+      currentAgentId: 'molly',
+      targetAgentId: resolved.agentId,
+      unresolvedReference: resolved.unresolvedReference,
+    })
+    assert.match(error || '', /unknown agent "missing-agent"/i)
+  })
+
+  it('rejects self-delegation using resolved agent ids', () => {
+    const payload = {
+      agentId: 'molly',
+      sourceType: 'delegation',
+      delegatedByAgentId: 'Molly',
+    }
+    const resolved = resolveManagedAgentAssignment(payload, agents, 'molly')
+    const error = validateManagedAgentAssignment({
+      resourceLabel: 'tasks',
+      agents,
+      assignScope: 'all',
+      currentAgentId: 'molly',
+      targetAgentId: resolved.agentId,
+      unresolvedReference: resolved.unresolvedReference,
+      isDelegation: isDelegationTaskPayload(payload),
+      delegatorAgentId: resolveDelegatorAgentId(payload, agents, 'molly'),
+    })
+    assert.match(error || '', /different agent id/i)
+  })
+})

package/src/lib/server/agent-assignment.ts

@@ -0,0 +1,169 @@
+import type { Agent } from '@/types'
+import { resolveAgentReference, resolveTaskAgentFromDescription } from './task-mention'
+
+export const MANAGED_AGENT_REFERENCE_KEYS = [
+  'agentId',
+  'agent_id',
+  'assignedAgentId',
+  'assigned_agent_id',
+  'assignedToAgentId',
+  'assigned_to_agent_id',
+  'assigneeId',
+  'assignee_id',
+  'assignedAgent',
+  'assigned_agent',
+  'assignedTo',
+  'assigned_to',
+  'assignee',
+  'agent',
+  'owner',
+] as const
+
+type AssignmentSource = 'explicit' | 'description' | 'fallback' | 'none'
+
+export interface ManagedAgentAssignmentResolution {
+  agentId: string | null
+  explicitReference: string | null
+  unresolvedReference: string | null
+  source: AssignmentSource
+  hadExplicitInput: boolean
+}
+
+function firstNonEmptyString(
+  parsed: Record<string, unknown>,
+  keys: readonly string[],
+): string | null {
+  for (const key of keys) {
+    const raw = parsed[key]
+    if (typeof raw !== 'string') continue
+    const trimmed = raw.trim()
+    if (trimmed) return trimmed
+  }
+  return null
+}
+
+export function hasManagedAgentAssignmentInput(
+  parsed: Record<string, unknown>,
+  keys: readonly string[] = MANAGED_AGENT_REFERENCE_KEYS,
+): boolean {
+  return keys.some((key) => Object.prototype.hasOwnProperty.call(parsed, key))
+}
+
+export function resolveManagedAgentAssignment(
+  parsed: Record<string, unknown>,
+  agents: Record<string, Agent>,
+  fallbackAgentId?: string | null,
+  opts?: {
+    allowDescription?: boolean
+    keys?: readonly string[]
+  },
+): ManagedAgentAssignmentResolution {
+  const keys = opts?.keys ?? MANAGED_AGENT_REFERENCE_KEYS
+  const explicitReference = firstNonEmptyString(parsed, keys)
+  const hadExplicitInput = hasManagedAgentAssignmentInput(parsed, keys)
+  if (explicitReference) {
+    const resolved = resolveAgentReference(explicitReference, agents)
+    return {
+      agentId: resolved,
+      explicitReference,
+      unresolvedReference: resolved ? null : explicitReference,
+      source: 'explicit',
+      hadExplicitInput,
+    }
+  }
+
+  if (opts?.allowDescription !== false) {
+    const description = typeof parsed.description === 'string' ? parsed.description.trim() : ''
+    if (description) {
+      const resolvedFromDescription = resolveTaskAgentFromDescription(description, '', agents).trim()
+      if (resolvedFromDescription) {
+        return {
+          agentId: resolvedFromDescription,
+          explicitReference: null,
+          unresolvedReference: null,
+          source: 'description',
+          hadExplicitInput,
+        }
+      }
+    }
+  }
+
+  const fallback = typeof fallbackAgentId === 'string' ? fallbackAgentId.trim() : ''
+  if (fallback) {
+    return {
+      agentId: fallback,
+      explicitReference: null,
+      unresolvedReference: null,
+      source: 'fallback',
+      hadExplicitInput,
+    }
+  }
+
+  return {
+    agentId: null,
+    explicitReference: null,
+    unresolvedReference: null,
+    source: 'none',
+    hadExplicitInput,
+  }
+}
+
+export function resolveDelegatorAgentId(
+  parsed: Record<string, unknown>,
+  agents: Record<string, Agent>,
+  fallbackAgentId?: string | null,
+): string | null {
+  const explicitDelegator = typeof parsed.delegatedByAgentId === 'string'
+    ? parsed.delegatedByAgentId.trim()
+    : ''
+  if (explicitDelegator) {
+    return resolveAgentReference(explicitDelegator, agents) || explicitDelegator
+  }
+  const fallback = typeof fallbackAgentId === 'string' ? fallbackAgentId.trim() : ''
+  return fallback || null
+}
+
+export function isDelegationTaskPayload(parsed: Record<string, unknown>): boolean {
+  const sourceType = typeof parsed.sourceType === 'string' ? parsed.sourceType.trim().toLowerCase() : ''
+  if (sourceType === 'delegation') return true
+  if (typeof parsed.delegatedFromTaskId === 'string' && parsed.delegatedFromTaskId.trim()) return true
+  if (typeof parsed.delegatedByAgentId === 'string' && parsed.delegatedByAgentId.trim()) return true
+  return false
+}
+
+export function validateManagedAgentAssignment(params: {
+  resourceLabel: string
+  agents: Record<string, Agent>
+  assignScope: 'self' | 'all'
+  currentAgentId?: string | null
+  targetAgentId?: string | null
+  unresolvedReference?: string | null
+  isDelegation?: boolean
+  delegatorAgentId?: string | null
+}): string | null {
+  const currentAgentId = typeof params.currentAgentId === 'string' ? params.currentAgentId.trim() : ''
+  const targetAgentId = typeof params.targetAgentId === 'string' ? params.targetAgentId.trim() : ''
+  const unresolvedReference = typeof params.unresolvedReference === 'string' ? params.unresolvedReference.trim() : ''
+  const delegatorAgentId = typeof params.delegatorAgentId === 'string' ? params.delegatorAgentId.trim() : ''
+
+  if (unresolvedReference) {
+    return `Error: Unknown agent "${unresolvedReference}". Use an existing agent ID or exact agent name.`
+  }
+
+  if (targetAgentId && !params.agents[targetAgentId]) {
+    return `Error: Unknown agent "${targetAgentId}". Use an existing agent ID or exact agent name.`
+  }
+
+  if (params.assignScope === 'self' && currentAgentId && targetAgentId && targetAgentId !== currentAgentId) {
+    return `Error: You can only assign ${params.resourceLabel} to yourself ("${currentAgentId}"). To assign to other agents, ask a user to enable "Assign to Other Agents" in your agent settings.`
+  }
+
+  if (params.isDelegation && targetAgentId) {
+    const comparisonId = delegatorAgentId || currentAgentId
+    if (comparisonId && targetAgentId === comparisonId) {
+      return 'Error: Delegation target must be a different agent ID. Create a normal self-task instead of delegating to yourself.'
+    }
+  }
+
+  return null
+}