@swarmclawai/swarmclaw 1.2.4 → 1.2.6

package/src/app/api/schedules/[id]/run/route.ts

@@ -1,73 +1,12 @@
 import { NextResponse } from 'next/server'
 import { notFound } from '@/lib/server/collection-helpers'
-import { loadSchedule, loadAgents, loadTasks, logActivity, upsertSchedule, upsertTask } from '@/lib/server/storage'
-import { buildAgentDisabledMessage, isAgentDisabled } from '@/lib/server/agents/agent-availability'
-import { enqueueTask } from '@/lib/server/runtime/queue'
-import { pushMainLoopEventToMainSessions } from '@/lib/server/agents/main-agent-loop'
-import { getScheduleSignatureKey } from '@/lib/schedules/schedule-dedupe'
-import { prepareScheduledTaskRun } from '@/lib/server/tasks/task-lifecycle'
-import type { Schedule } from '@/types'
-
-type InFlightTask = {
-  status?: string
-  sourceScheduleKey?: string | null
-}
+import { runScheduleNow } from '@/lib/server/schedules/schedule-route-service'
 
 export async function POST(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const schedule = loadSchedule(id) as Schedule | null
-  if (!schedule) return notFound()
-  if (schedule.status === 'archived') {
-    return NextResponse.json({ error: 'Archived schedules must be restored before they can run.' }, { status: 409 })
-  }
-
-  const agents = loadAgents()
-  const agent = agents[schedule.agentId]
-  if (!agent) return NextResponse.json({ error: 'Agent not found' }, { status: 400 })
-  if (isAgentDisabled(agent)) {
-    return NextResponse.json({ error: buildAgentDisabledMessage(agent, 'run schedules') }, { status: 409 })
-  }
-
-  const tasks = loadTasks()
-  const scheduleSignature = getScheduleSignatureKey(schedule)
-  if (scheduleSignature) {
-    const inFlight = Object.values(tasks as Record<string, InFlightTask>).some((task) =>
-      task
-      && (task.status === 'queued' || task.status === 'running')
-      && task.sourceScheduleKey === scheduleSignature,
-    )
-    if (inFlight) {
-      return NextResponse.json({ ok: true, queued: false, reason: 'in_flight' })
-    }
-  }
-
-  const now = Date.now()
-  schedule.runNumber = (schedule.runNumber || 0) + 1
-
-  const { taskId } = prepareScheduledTaskRun({
-    schedule,
-    tasks,
-    now,
-    scheduleSignature,
-  })
-
-  upsertTask(taskId, tasks[taskId])
-  enqueueTask(taskId)
-  pushMainLoopEventToMainSessions({
-    type: 'schedule_fired',
-    text: `Schedule fired manually: "${schedule.name}" (${schedule.id}) run #${schedule.runNumber} — task ${taskId}`,
-  })
-
-  schedule.lastRunAt = now
-  upsertSchedule(schedule.id, schedule)
-  logActivity({
-    entityType: 'schedule',
-    entityId: schedule.id,
-    action: 'started',
-    actor: 'user',
-    summary: `Schedule run started: "${schedule.name}"`,
-    detail: { taskId, runNumber: schedule.runNumber },
-  })
-
-  return NextResponse.json({ ok: true, queued: true, taskId, runNumber: schedule.runNumber })
+  const result = runScheduleNow(id)
+  if (!result.ok && result.status === 404) return notFound()
+  return result.ok
+    ? NextResponse.json(result.payload)
+    : NextResponse.json(result.payload, { status: result.status })
 }

package/src/app/api/schedules/route.ts

@@ -1,64 +1,22 @@
 import { NextResponse } from 'next/server'
-import { loadAgents, loadSchedules, logActivity, upsertSchedule, upsertSchedules } from '@/lib/server/storage'
-import { buildAgentDisabledMessage, isAgentDisabled } from '@/lib/server/agents/agent-availability'
-import { WORKSPACE_DIR } from '@/lib/server/data-dir'
-import { prepareScheduleCreate } from '@/lib/server/schedules/schedule-service'
-import { notify } from '@/lib/server/ws-hub'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
+import {
+  createScheduleFromRoute,
+  listSchedulesForApi,
+} from '@/lib/server/schedules/schedule-route-service'
 export const dynamic = 'force-dynamic'
 
 export async function GET(req: Request) {
   const { searchParams } = new URL(req.url)
   const includeArchived = searchParams.get('includeArchived') === 'true'
-  const schedules = loadSchedules()
-  if (includeArchived) return NextResponse.json(schedules)
-
-  const filtered: typeof schedules = {}
-  for (const [id, schedule] of Object.entries(schedules)) {
-    if (schedule.status === 'archived') continue
-    filtered[id] = schedule
-  }
-  return NextResponse.json(filtered)
+  return NextResponse.json(listSchedulesForApi(includeArchived))
 }
 
 export async function POST(req: Request) {
   const { data: body, error } = await safeParseBody(req)
   if (error) return error
-  const now = Date.now()
-  const schedules = loadSchedules()
-  const agents = loadAgents()
-  const candidateAgentId = typeof body?.agentId === 'string' ? body.agentId.trim() : ''
-  const agent = agents[candidateAgentId]
-  if (!agent) {
-    return NextResponse.json({ error: `Agent not found: ${String(body?.agentId)}` }, { status: 400 })
-  }
-  if (isAgentDisabled(agent)) {
-    return NextResponse.json({ error: buildAgentDisabledMessage(agent, 'take scheduled work') }, { status: 409 })
-  }
-  const prepared = prepareScheduleCreate({
-    input: body as Record<string, unknown>,
-    schedules,
-    now,
-    cwd: WORKSPACE_DIR,
-  })
-  if (!prepared.ok) {
-    return NextResponse.json({ error: prepared.error }, { status: 400 })
-  }
-  if (prepared.kind === 'duplicate') {
-    if (prepared.entries.length === 1) upsertSchedule(prepared.scheduleId, prepared.schedule)
-    else if (prepared.entries.length > 1) upsertSchedules(prepared.entries)
-    if (prepared.entries.length > 0) notify('schedules')
-    return NextResponse.json(prepared.schedule)
-  }
-
-  upsertSchedule(prepared.scheduleId, prepared.schedule)
-  logActivity({
-    entityType: 'schedule',
-    entityId: prepared.scheduleId,
-    action: 'created',
-    actor: 'user',
-    summary: `Schedule created: "${prepared.schedule.name}"`,
-  })
-  notify('schedules')
-  return NextResponse.json(prepared.schedule)
+  const result = createScheduleFromRoute(body as Record<string, unknown>)
+  return result.ok
+    ? NextResponse.json(result.payload)
+    : NextResponse.json(result.payload, { status: result.status })
 }

package/src/app/api/settings/route.ts

@@ -5,6 +5,7 @@ import { normalizeWhatsAppApprovedContacts } from '@/lib/server/connectors/pairi
 import { loadPublicSettings, loadSettings, saveSettings } from '@/lib/server/storage'
 import { normalizeRuntimeSettingFields } from '@/lib/runtime/runtime-loop'
 import { normalizeSupervisorSettings } from '@/lib/autonomy/supervisor-settings'
+import { ensureDaemonProcessRunning } from '@/lib/server/daemon/controller'
 export const dynamic = 'force-dynamic'
 
 
@@ -166,9 +167,9 @@ export async function PUT(req: Request) {
   saveSettings(settings)
 
   if ('daemonAutostartEnabled' in sanitizedBody && settings.daemonAutostartEnabled) {
-    import('@/lib/server/runtime/daemon-state').then(({ startDaemon }) => {
-      startDaemon({ source: 'api/settings:put:daemon-autostart', manualStart: true })
-    }).catch(() => { /* daemon runtime may not be initialized yet */ })
+    void ensureDaemonProcessRunning('api/settings:put:daemon-autostart', { manualStart: true }).catch(() => {
+      // The daemon launcher may not be available during early bootstrap.
+    })
   }
 
   // Restart heartbeat service when heartbeat-related settings change

package/src/app/api/setup/check-provider/route.ts

@@ -326,8 +326,30 @@ export async function POST(req: Request) {
         const result = await checkOpenClaw(apiKey, endpoint)
         return NextResponse.json(result)
       }
-      default:
+      default: {
+        let configs: Record<string, { name?: string; baseUrl?: string; isEnabled?: boolean }>
+        try {
+          const storage = await import('@/lib/server/storage')
+          configs = storage.loadProviderConfigs() as Record<string, { name?: string; baseUrl?: string; isEnabled?: boolean }>
+        } catch {
+          return NextResponse.json(
+            { ok: false, message: `Failed to load provider configurations while checking ${provider}.` },
+            { status: 500 },
+          )
+        }
+        const custom = configs[provider]
+        if (custom?.baseUrl) {
+          const result = await checkOpenAiCompatible(
+            custom.name || 'Custom Provider',
+            apiKey || '',
+            endpoint || custom.baseUrl,
+            custom.baseUrl,
+            model
+          )
+          return NextResponse.json(result)
+        }
         return NextResponse.json({ ok: false, message: `Unsupported provider: ${provider}` }, { status: 400 })
+      }
     }
   } catch (err: unknown) {
     const message = err instanceof Error && err.name === 'TimeoutError'

package/src/app/api/setup/openclaw-device/route.ts

@@ -7,7 +7,7 @@ export async function GET(_req: Request) {
   try {
     const deviceId = getDeviceId()
     return NextResponse.json({ deviceId })
-  } catch (err: any) {
-    return NextResponse.json({ deviceId: null, error: err?.message }, { status: 500 })
+  } catch (err: unknown) {
+    return NextResponse.json({ deviceId: null, error: err instanceof Error ? err.message : 'Unknown error' }, { status: 500 })
   }
 }

package/src/app/api/system/status/route.ts

@@ -1,9 +1,9 @@
 import { NextResponse } from 'next/server'
-import { getDaemonHealthSummary } from '@/lib/server/runtime/daemon-state'
+import { getDaemonHealthSummarySnapshot } from '@/lib/server/daemon/controller'
 import packageJson from '../../../../../package.json'
 
 export async function GET() {
-  const summary = getDaemonHealthSummary()
+  const summary = await getDaemonHealthSummarySnapshot()
   return NextResponse.json({
     ...summary,
     version: packageJson.version,

package/src/app/api/tasks/[id]/route.ts

@@ -1,221 +1,35 @@
 import { NextResponse } from 'next/server'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
-import { loadAgents, loadSettings, loadTasks, logActivity, upsertStoredItems, upsertTask } from '@/lib/server/storage'
 import { notFound } from '@/lib/server/collection-helpers'
-import { disableSessionHeartbeat, enqueueTask, recoverStalledRunningTasks, validateCompletedTasksQueue } from '@/lib/server/runtime/queue'
-import { pushMainLoopEventToMainSessions } from '@/lib/server/agents/main-agent-loop'
-import { notify } from '@/lib/server/ws-hub'
-import { createNotification } from '@/lib/server/create-notification'
-import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
-import { dispatchWake } from '@/lib/server/runtime/wake-dispatcher'
-import { validateDag, cascadeUnblock } from '@/lib/server/dag-validation'
-import { getExtensionManager } from '@/lib/server/extensions'
-import { getEnabledCapabilityIds } from '@/lib/capability-selection'
+import { loadTask } from '@/lib/server/tasks/task-repository'
 import {
-  applyTaskPatch,
-} from '@/lib/server/tasks/task-service'
-import type { BoardTask } from '@/types'
-import { ensureMissionForTask, enrichTaskWithMissionSummary, noteMissionTaskFinished } from '@/lib/server/missions/mission-service'
-import '@/lib/server/builtin-extensions'
+  archiveTaskFromRoute,
+  prepareTasksForListing,
+  updateTaskFromRoute,
+} from '@/lib/server/tasks/task-route-service'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
-  // Keep completed queue integrity even if daemon is not running.
-  validateCompletedTasksQueue()
-  recoverStalledRunningTasks()
-
   const { id } = await params
-  const tasks = loadTasks()
+  const tasks = prepareTasksForListing()
   if (!tasks[id]) return notFound()
-  return NextResponse.json(enrichTaskWithMissionSummary(tasks[id]))
+  return NextResponse.json(tasks[id])
 }
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const { data: body, error } = await safeParseBody<Record<string, unknown>>(req)
   if (error) return error
-  const settings = loadSettings()
-  const tasks = loadTasks()
-  if (!tasks[id]) return notFound()
-
-  const prevStatus = tasks[id].status
-
-  // DAG validation: reject if proposed blockedBy would create a cycle
-  if (Array.isArray(body.blockedBy)) {
-    const dagResult = validateDag(tasks, id, body.blockedBy)
-    if (!dagResult.valid) {
-      return NextResponse.json(
-        { error: 'Dependency cycle detected', cycle: dagResult.cycle },
-        { status: 400 },
-      )
-    }
-  }
-
-  // Support atomic comment append to avoid race conditions
-  if (body.appendComment) {
-    if (!tasks[id].comments) tasks[id].comments = []
-    tasks[id].comments.push(body.appendComment)
-    tasks[id].updatedAt = Date.now()
-  } else {
-    applyTaskPatch({
-      task: tasks[id],
-      patch: body as Record<string, unknown>,
-      now: Date.now(),
-      settings,
-      preserveCompletedAt: true,
-      clearProjectIdWhenNull: true,
-      invalidCompletionCommentAuthor: 'System',
-    })
-  }
-  tasks[id].id = id // prevent id overwrite
-
-  // Maintain parent/child subtask links
-  if (typeof body.parentTaskId === 'string' || body.parentTaskId === null) {
-    const oldParentId = tasks[id].parentTaskId
-    const newParentId = typeof body.parentTaskId === 'string' && body.parentTaskId.trim() ? body.parentTaskId.trim() : null
-    // Remove from old parent's subtaskIds
-    if (oldParentId && oldParentId !== newParentId && tasks[oldParentId]) {
-      const oldSubs = Array.isArray(tasks[oldParentId].subtaskIds) ? tasks[oldParentId].subtaskIds : []
-      tasks[oldParentId].subtaskIds = oldSubs.filter((s: string) => s !== id)
-      tasks[oldParentId].updatedAt = Date.now()
-      upsertTask(oldParentId, tasks[oldParentId])
-    }
-    // Add to new parent's subtaskIds
-    if (newParentId && tasks[newParentId]) {
-      const newSubs = Array.isArray(tasks[newParentId].subtaskIds) ? tasks[newParentId].subtaskIds : []
-      if (!newSubs.includes(id)) {
-        tasks[newParentId].subtaskIds = [...newSubs, id]
-        tasks[newParentId].updatedAt = Date.now()
-        upsertTask(newParentId, tasks[newParentId])
-      }
-    }
-    tasks[id].parentTaskId = newParentId
-  }
-
-  // Set archivedAt when transitioning to archived
-  if (prevStatus !== 'archived' && tasks[id].status === 'archived') {
-    tasks[id].archivedAt = Date.now()
-  }
-
-  upsertTask(id, tasks[id])
-  const mission = ensureMissionForTask(tasks[id], { source: 'manual' })
-  if (tasks[id].status === 'completed' || tasks[id].status === 'failed' || tasks[id].status === 'cancelled') {
-    noteMissionTaskFinished(tasks[id], tasks[id].status, tasks[id].id)
-  }
-  logActivity({ entityType: 'task', entityId: id, action: 'updated', actor: 'user', summary: `Task updated: "${tasks[id].title}" (${prevStatus} → ${tasks[id].status})` })
-  if (prevStatus !== tasks[id].status) {
-    pushMainLoopEventToMainSessions({
-      type: 'task_status_changed',
-      text: `Task "${tasks[id].title}" (${id}) moved ${prevStatus} → ${tasks[id].status}.`,
-    })
-  }
-
-  if (prevStatus !== tasks[id].status && tasks[id].status === 'cancelled') {
-    disableSessionHeartbeat(tasks[id].sessionId)
-    notify('tasks')
-    return NextResponse.json(enrichTaskWithMissionSummary({
-      ...tasks[id],
-      missionId: mission?.id || tasks[id].missionId || null,
-    }))
-  }
-
-  // If task is manually transitioned to a terminal status, disable session heartbeat.
-  if (prevStatus !== tasks[id].status && (tasks[id].status === 'completed' || tasks[id].status === 'failed')) {
-    disableSessionHeartbeat(tasks[id].sessionId)
-    createNotification({
-      type: tasks[id].status === 'completed' ? 'success' : 'error',
-      title: `Task ${tasks[id].status}: "${tasks[id].title}"`,
-      message: tasks[id].status === 'failed' ? tasks[id].error?.slice(0, 200) : undefined,
-      entityType: 'task',
-      entityId: id,
-    })
-    
-    if (tasks[id].status === 'completed') {
-      const agentExtensions = tasks[id].agentId ? getEnabledCapabilityIds(loadAgents()[tasks[id].agentId]) : []
-      getExtensionManager().runHook(
-        'onTaskComplete',
-        { taskId: id, result: tasks[id].result },
-        { enabledIds: agentExtensions },
-      )
-    }
-
-    // Enqueue system event + heartbeat wake
-    if (tasks[id].sessionId) {
-      enqueueSystemEvent(tasks[id].sessionId, `Task ${tasks[id].status}: ${tasks[id].title}`)
-    }
-    if (tasks[id].agentId) {
-      dispatchWake({
-        mode: 'immediate',
-        agentId: tasks[id].agentId,
-        sessionId: tasks[id].sessionId || undefined,
-        eventId: `task:${id}:${tasks[id].status}`,
-        reason: 'task-completed',
-        source: `task:${id}`,
-        resumeMessage: `Task ${tasks[id].status}: ${tasks[id].title}`,
-        detail: tasks[id].status === 'failed'
-          ? String(tasks[id].error || '').slice(0, 400)
-          : JSON.stringify(tasks[id].result || '').slice(0, 400),
-      })
-    }
-  }
-
-  // Dependency check: cannot queue a task if any blocker is incomplete
-  if (tasks[id].status === 'queued') {
-    const blockers = Array.isArray(tasks[id].blockedBy) ? tasks[id].blockedBy : []
-    const incompleteBlocker = blockers.find((bid: string) => tasks[bid] && tasks[bid].status !== 'completed')
-    if (incompleteBlocker) {
-      // Revert status change and reject
-      tasks[id].status = prevStatus
-      tasks[id].updatedAt = Date.now()
-      upsertTask(id, tasks[id])
-      return NextResponse.json(
-        { error: 'Cannot queue: blocked by incomplete tasks', blockedBy: incompleteBlocker },
-        { status: 409 },
-      )
-    }
-  }
-
-  // When a task is completed, cascade unblock dependent tasks
-  if (tasks[id].status === 'completed') {
-    const unblockedIds = cascadeUnblock(tasks, id)
-    if (unblockedIds.length > 0) {
-      upsertStoredItems('tasks', [
-        [id, tasks[id]],
-        ...unblockedIds.map((uid) => [uid, tasks[uid]] as [string, BoardTask]),
-      ])
-      for (const uid of unblockedIds) {
-        enqueueTask(uid)
-      }
-    }
-  }
-
-  // If status changed to 'queued', enqueue it
-  if (prevStatus !== 'queued' && tasks[id].status === 'queued') {
-    enqueueTask(id)
-  }
-
-  notify('tasks')
-  return NextResponse.json(enrichTaskWithMissionSummary({
-    ...tasks[id],
-    missionId: mission?.id || tasks[id].missionId || null,
-  }))
+  const result = updateTaskFromRoute(id, body)
+  if (!result.ok && result.status === 404) return notFound()
+  return result.ok
+    ? NextResponse.json(result.payload)
+    : NextResponse.json(result.payload, { status: result.status })
 }
 
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const tasks = loadTasks()
-  if (!tasks[id]) return notFound()
-
-  // Soft delete: move to archived status instead of hard delete
-  tasks[id].status = 'archived'
-  tasks[id].archivedAt = Date.now()
-  tasks[id].updatedAt = Date.now()
-  upsertTask(id, tasks[id])
-  logActivity({ entityType: 'task', entityId: id, action: 'deleted', actor: 'user', summary: `Task archived: "${tasks[id].title}"` })
-  pushMainLoopEventToMainSessions({
-    type: 'task_archived',
-    text: `Task archived: "${tasks[id].title}" (${id}).`,
-  })
-
-  notify('tasks')
-  return NextResponse.json(tasks[id])
+  if (!loadTask(id)) return notFound()
+  const result = archiveTaskFromRoute(id)
+  if (!result.ok) return notFound()
+  return NextResponse.json(result.payload)
 }

package/src/app/api/tasks/bulk/route.ts

@@ -1,13 +1,6 @@
 import { NextResponse } from 'next/server'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
-import { loadTasks, logActivity, upsertStoredItems } from '@/lib/server/storage'
-import { enqueueTask, disableSessionHeartbeat } from '@/lib/server/runtime/queue'
-import { pushMainLoopEventToMainSessions } from '@/lib/server/agents/main-agent-loop'
-import { notify } from '@/lib/server/ws-hub'
-import { createNotification } from '@/lib/server/create-notification'
-import type { BoardTask, BoardTaskStatus } from '@/types'
-
-const VALID_STATUSES: BoardTaskStatus[] = ['backlog', 'queued', 'running', 'completed', 'failed', 'archived']
+import { bulkUpdateTasksFromRoute } from '@/lib/server/tasks/task-route-service'
 
 /**
  * Bulk update tasks — batch status changes, agent/project reassignment, or archive/delete.
@@ -21,82 +14,8 @@ const VALID_STATUSES: BoardTaskStatus[] = ['backlog', 'queued', 'running', 'comp
 export async function POST(req: Request) {
   const { data: body, error } = await safeParseBody<Record<string, unknown>>(req)
   if (error) return error
-  const ids: unknown = body.ids
-  if (!Array.isArray(ids) || ids.length === 0) {
-    return NextResponse.json({ error: 'ids must be a non-empty array' }, { status: 400 })
-  }
-
-  const taskIds = ids.filter((id): id is string => typeof id === 'string')
-  if (taskIds.length === 0) {
-    return NextResponse.json({ error: 'No valid task IDs provided' }, { status: 400 })
-  }
-
-  const tasks = loadTasks()
-  let updated = 0
-  const results: string[] = []
-
-  for (const id of taskIds) {
-    if (!tasks[id]) continue
-    const prevStatus = tasks[id].status
-
-    if (typeof body.status === 'string' && VALID_STATUSES.includes(body.status as BoardTaskStatus)) {
-      tasks[id].status = body.status as BoardTaskStatus
-      if (body.status === 'archived' && prevStatus !== 'archived') {
-        tasks[id].archivedAt = Date.now()
-      }
-    }
-
-    if ('agentId' in body) {
-      tasks[id].agentId = body.agentId === null ? '' : String(body.agentId)
-    }
-
-    if ('projectId' in body) {
-      if (body.projectId === null) {
-        delete tasks[id].projectId
-      } else {
-        tasks[id].projectId = String(body.projectId)
-      }
-    }
-
-    tasks[id].updatedAt = Date.now()
-    updated++
-    results.push(id)
-
-    // Side-effects for status transitions
-    if (prevStatus !== tasks[id].status) {
-      logActivity({
-        entityType: 'task',
-        entityId: id,
-        action: 'updated',
-        actor: 'user',
-        summary: `Bulk update: "${tasks[id].title}" (${prevStatus} → ${tasks[id].status})`,
-      })
-      pushMainLoopEventToMainSessions({
-        type: 'task_status_changed',
-        text: `Task "${tasks[id].title}" (${id}) moved ${prevStatus} → ${tasks[id].status}.`,
-      })
-      if (tasks[id].status === 'completed' || tasks[id].status === 'failed') {
-        disableSessionHeartbeat(tasks[id].sessionId)
-      }
-      if (prevStatus !== 'queued' && tasks[id].status === 'queued') {
-        enqueueTask(id)
-      }
-    }
-  }
-
-  upsertStoredItems('tasks', results.map((id) => [id, tasks[id]] as [string, BoardTask]))
-
-  if (updated > 0) {
-    const action = body.status
-      ? `moved ${updated} task(s) to ${body.status}`
-      : `updated ${updated} task(s)`
-    createNotification({
-      type: 'success',
-      title: `Bulk update: ${action}`,
-      entityType: 'task',
-    })
-  }
-
-  notify('tasks')
-  return NextResponse.json({ updated, ids: results })
+  const result = bulkUpdateTasksFromRoute(body)
+  return result.ok
+    ? NextResponse.json(result.payload)
+    : NextResponse.json(result.payload, { status: result.status })
 }

package/src/app/api/tasks/metrics/route.ts

@@ -1,5 +1,6 @@
 import { NextResponse } from 'next/server'
-import { loadTasks, loadAgents } from '@/lib/server/storage'
+import { loadAgents } from '@/lib/server/agents/agent-repository'
+import { loadTasks } from '@/lib/server/tasks/task-repository'
 
 type Range = '24h' | '7d' | '30d'