@swarmclawai/swarmclaw 1.2.4 → 1.2.6

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

@@ -1,45 +1,16 @@
 import { NextResponse } from 'next/server'
-import { genId } from '@/lib/id'
 import { perf } from '@/lib/server/runtime/perf'
-import { loadAgents, loadSessions, loadUsage, logActivity, upsertStoredItem } from '@/lib/server/storage'
-import { normalizeProviderEndpoint } from '@/lib/openclaw/openclaw-endpoint'
-import { notify } from '@/lib/server/ws-hub'
-import { getAgentSpendWindows } from '@/lib/server/cost'
-import { resolveAgentToolSelection } from '@/lib/agent-default-tools'
-import { normalizeAgentSandboxConfig } from '@/lib/agent-sandbox-defaults'
-import { normalizeOrchestratorConfig } from '@/lib/orchestrator-config'
+import { listAgentsForApi, createAgent } from '@/lib/server/agents/agent-service'
 import { AgentCreateSchema, formatZodError } from '@/lib/validation/schemas'
+import { ensureDaemonProcessRunning } from '@/lib/server/daemon/controller'
 import { z } from 'zod'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 export const dynamic = 'force-dynamic'
 
-async function ensureDaemonIfNeeded(source: string) {
-  const { ensureDaemonStarted } = await import('@/lib/server/runtime/daemon-state')
-  ensureDaemonStarted(source)
-}
-
 
 export async function GET(req: Request) {
   const endPerf = perf.start('api', 'GET /api/agents')
-  const agents = loadAgents()
-  const sessions = loadSessions()
-  const usage = loadUsage()
-  // Enrich agents that have spend limits with current spend windows
-  for (const agent of Object.values(agents)) {
-    if (
-      (typeof agent.monthlyBudget === 'number' && agent.monthlyBudget > 0)
-      || (typeof agent.dailyBudget === 'number' && agent.dailyBudget > 0)
-      || (typeof agent.hourlyBudget === 'number' && agent.hourlyBudget > 0)
-    ) {
-      const spend = getAgentSpendWindows(agent.id, Date.now(), {
-        sessions: sessions as unknown as Record<string, Record<string, unknown>>,
-        usage,
-      })
-      if (typeof agent.monthlyBudget === 'number' && agent.monthlyBudget > 0) agent.monthlySpend = spend.monthly
-      if (typeof agent.dailyBudget === 'number' && agent.dailyBudget > 0) agent.dailySpend = spend.daily
-      if (typeof agent.hourlyBudget === 'number' && agent.hourlyBudget > 0) agent.hourlySpend = spend.hourly
-    }
-  }
+  const agents = listAgentsForApi()
 
   const { searchParams } = new URL(req.url)
   const limitParam = searchParams.get('limit')
@@ -57,7 +28,7 @@ export async function GET(req: Request) {
 }
 
 export async function POST(req: Request) {
-  await ensureDaemonIfNeeded('api/agents:post')
+  await ensureDaemonProcessRunning('api/agents:post')
   const { data: raw, error } = await safeParseBody(req)
   if (error) return error
   const rawRecord = raw && typeof raw === 'object' ? raw as Record<string, unknown> : null
@@ -65,91 +36,6 @@ export async function POST(req: Request) {
   if (!parsed.success) {
     return NextResponse.json(formatZodError(parsed.error as z.ZodError), { status: 400 })
   }
-  const body = parsed.data
-  const orchestratorConfig = normalizeOrchestratorConfig({
-    provider: body.provider,
-    orchestratorEnabled: body.orchestratorEnabled,
-    orchestratorMission: body.orchestratorMission,
-    orchestratorWakeInterval: body.orchestratorWakeInterval,
-    orchestratorGovernance: body.orchestratorGovernance,
-    orchestratorMaxCyclesPerDay: body.orchestratorMaxCyclesPerDay,
-  })
-  const capabilitySelection = resolveAgentToolSelection({
-    hasExplicitTools: Boolean(rawRecord && Object.prototype.hasOwnProperty.call(rawRecord, 'tools')),
-    hasExplicitExtensions: Boolean(rawRecord && Object.prototype.hasOwnProperty.call(rawRecord, 'extensions')),
-    tools: body.tools,
-    extensions: body.extensions,
-  })
-  const id = genId()
-  const now = Date.now()
-  const agent = {
-    id,
-    name: body.name,
-    description: body.description,
-    soul: body.soul || undefined,
-    systemPrompt: body.systemPrompt,
-    provider: body.provider,
-    model: body.model,
-    ollamaMode: body.provider === 'ollama' ? (body.ollamaMode || 'local') : null,
-    credentialId: body.credentialId,
-    fallbackCredentialIds: body.fallbackCredentialIds,
-    apiEndpoint: normalizeProviderEndpoint(body.provider, body.apiEndpoint || null),
-    gatewayProfileId: body.gatewayProfileId,
-    preferredGatewayTags: body.preferredGatewayTags,
-    preferredGatewayUseCase: body.preferredGatewayUseCase,
-    routingStrategy: body.routingStrategy,
-    routingTargets: body.routingTargets?.map((target) => ({
-      ...target,
-      ollamaMode: target.provider === 'ollama' ? (target.ollamaMode || 'local') : null,
-      apiEndpoint: normalizeProviderEndpoint(target.provider, target.apiEndpoint || null),
-    })),
-    delegationEnabled: body.delegationEnabled ?? false,
-    delegationTargetMode: body.delegationTargetMode ?? 'all',
-    delegationTargetAgentIds: (body.delegationTargetMode === 'selected' ? body.delegationTargetAgentIds : []).filter(Boolean),
-    tools: capabilitySelection.tools,
-    extensions: capabilitySelection.extensions,
-    skills: body.skills,
-    skillIds: body.skillIds,
-    mcpServerIds: body.mcpServerIds,
-    mcpDisabledTools: body.mcpDisabledTools?.length ? body.mcpDisabledTools : undefined,
-    capabilities: body.capabilities,
-    thinkingLevel: body.thinkingLevel || undefined,
-    autoRecovery: body.autoRecovery || false,
-    disabled: body.disabled || false,
-    heartbeatEnabled: body.heartbeatEnabled ?? true,
-    heartbeatInterval: body.heartbeatInterval,
-    heartbeatIntervalSec: body.heartbeatIntervalSec,
-    heartbeatModel: body.heartbeatModel,
-    heartbeatPrompt: body.heartbeatPrompt,
-    orchestratorEnabled: orchestratorConfig.orchestratorEnabled,
-    orchestratorMission: orchestratorConfig.orchestratorMission,
-    orchestratorWakeInterval: orchestratorConfig.orchestratorWakeInterval,
-    orchestratorGovernance: orchestratorConfig.orchestratorGovernance,
-    orchestratorMaxCyclesPerDay: orchestratorConfig.orchestratorMaxCyclesPerDay,
-    elevenLabsVoiceId: body.elevenLabsVoiceId,
-    monthlyBudget: body.monthlyBudget ?? null,
-    dailyBudget: body.dailyBudget ?? null,
-    hourlyBudget: body.hourlyBudget ?? null,
-    budgetAction: body.budgetAction || 'warn',
-    identityState: body.identityState ?? null,
-    memoryScopeMode: body.memoryScopeMode,
-    memoryTierPreference: body.memoryTierPreference,
-    proactiveMemory: body.proactiveMemory ?? true,
-    autoDraftSkillSuggestions: body.autoDraftSkillSuggestions,
-    projectId: body.projectId,
-    avatarSeed: body.avatarSeed,
-    avatarUrl: body.avatarUrl,
-    sessionResetMode: body.sessionResetMode ?? null,
-    sessionIdleTimeoutSec: body.sessionIdleTimeoutSec ?? null,
-    sessionMaxAgeSec: body.sessionMaxAgeSec ?? null,
-    sessionDailyResetAt: body.sessionDailyResetAt ?? null,
-    sessionResetTimezone: body.sessionResetTimezone ?? null,
-    sandboxConfig: normalizeAgentSandboxConfig(body.sandboxConfig),
-    createdAt: now,
-    updatedAt: now,
-  }
-  upsertStoredItem('agents', id, agent)
-  logActivity({ entityType: 'agent', entityId: id, action: 'created', actor: 'user', summary: `Agent created: "${agent.name}"` })
-  notify('agents')
+  const agent = createAgent({ body: parsed.data as unknown as Record<string, unknown>, rawRecord })
   return NextResponse.json(agent)
 }

package/src/app/api/agents/trash/route.ts

@@ -1,13 +1,16 @@
 import { NextResponse } from 'next/server'
-import { loadTrashedAgents, loadAgents, saveAgents, deleteAgent } from '@/lib/server/storage'
+import {
+  listTrashedAgentsForApi,
+  permanentlyDeleteTrashedAgent,
+  restoreTrashedAgent,
+} from '@/lib/server/agents/agent-service'
 import { notify } from '@/lib/server/ws-hub'
 import { badRequest, notFound } from '@/lib/server/collection-helpers'
-import { purgeAgentReferences, restoreAgentSchedules } from '@/lib/server/agents/agent-cascade'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 
 /** GET — list trashed agents */
 export async function GET() {
-  return NextResponse.json(loadTrashedAgents())
+  return NextResponse.json(listTrashedAgentsForApi())
 }
 
 /** POST { id } — restore a trashed agent */
@@ -17,21 +20,9 @@ export async function POST(req: Request) {
   const id = body?.id as string | undefined
   if (!id) return badRequest('Missing agent id')
 
-  const all = loadAgents({ includeTrashed: true })
-  const agent = all[id]
+  const agent = restoreTrashedAgent(id)
   if (!agent) return notFound()
-  if (!agent.trashedAt) return badRequest('Agent is not trashed')
-
-  delete agent.trashedAt
-  agent.updatedAt = Date.now()
-  all[id] = agent
-  saveAgents(all)
   notify('agents')
-
-  // Re-enable schedules that were paused when the agent was trashed
-  const restoredSchedules = restoreAgentSchedules(id)
-  if (restoredSchedules) notify('schedules')
-
   return NextResponse.json(agent)
 }
 
@@ -42,14 +33,12 @@ export async function DELETE(req: Request) {
   const id = body?.id as string | undefined
   if (!id) return badRequest('Missing agent id')
 
-  const all = loadAgents({ includeTrashed: true })
-  const agent = all[id]
-  if (!agent) return notFound()
-  if (!agent.trashedAt) return badRequest('Agent must be trashed before permanent deletion')
-
-  // Hard-delete all referencing entities before removing the agent record
-  const purged = purgeAgentReferences(id)
-  deleteAgent(id)
+  const result = permanentlyDeleteTrashedAgent(id)
+  if (!result.ok) {
+    if (result.reason === 'not_found') return notFound()
+    return badRequest('Agent must be trashed before permanent deletion')
+  }
+  const purged = result.purged
   notify('agents')
   if (purged.tasks) notify('tasks')
   if (purged.schedules) notify('schedules')

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

@@ -4,6 +4,7 @@ import { log } from '@/lib/server/logger'
 import { getAccessKey, validateAccessKey, isFirstTimeSetup, markSetupComplete, replaceAccessKey } from '@/lib/server/storage-auth'
 import { AUTH_COOKIE_NAME, getCookieValue } from '@/lib/auth'
 import { isProductionRuntime } from '@/lib/runtime/runtime-env'
+import { ensureDaemonProcessRunning } from '@/lib/server/daemon/controller'
 import { hmrSingleton } from '@/lib/shared-utils'
 export const dynamic = 'force-dynamic'
 
@@ -79,16 +80,9 @@ function pruneExpiredEntries() {
 }
 
 function startDaemonAfterAuth() {
-  void import('@/lib/server/runtime/daemon-state')
-    .then(({ ensureDaemonStarted }) => {
-      try {
-        ensureDaemonStarted('api/auth:post')
-      } catch (err: unknown) {
-        log.error(TAG, 'Deferred daemon start failed', err)
-      }
-    })
+  void ensureDaemonProcessRunning('api/auth:post')
     .catch((err: unknown) => {
-      log.error(TAG, 'Failed to load daemon-state for deferred start', err)
+      log.error(TAG, 'Deferred daemon start failed', err)
     })
 }
 

package/src/app/api/autonomy/estop/route.ts

@@ -1,6 +1,6 @@
 import { NextResponse } from 'next/server'
 import { cancelAllRuns } from '@/lib/server/runtime/session-run-manager'
-import { startDaemon, stopDaemon } from '@/lib/server/runtime/daemon-state'
+import { ensureDaemonProcessRunning, stopDaemonProcess } from '@/lib/server/daemon/controller'
 import {
   areEstopResumeApprovalsEnabled,
   engageEstop,
@@ -37,7 +37,7 @@ export async function POST(req: Request) {
         reason: typeof body.reason === 'string' ? body.reason : null,
         engagedBy: typeof body.engagedBy === 'string' ? body.engagedBy : 'user',
       })
-      await stopDaemon({ source: `api/autonomy/estop:${level}` })
+      await stopDaemonProcess({ source: `api/autonomy/estop:${level}` })
       const cancelled = level === 'all'
         ? cancelAllRuns('Cancelled because all estop is engaged.')
         : { cancelledQueued: 0, abortedRunning: 0 }
@@ -55,7 +55,7 @@ export async function POST(req: Request) {
 
       if (!requiresApproval) {
         const resumed = resumeEstop({ bypassApproval: true })
-        startDaemon({ source: 'api/autonomy/estop:resume', manualStart: true })
+        await ensureDaemonProcessRunning('api/autonomy/estop:resume', { manualStart: true })
         return NextResponse.json({ ok: true, state: buildStateResponse(resumed) })
       }
 
@@ -63,7 +63,7 @@ export async function POST(req: Request) {
         const existingApproval = state.resumeApprovalId ? findEstopResumeApproval(state.resumeApprovalId) : null
         if (existingApproval?.status === 'approved') {
           const resumed = resumeEstop({ approvalId: existingApproval.id })
-          startDaemon({ source: 'api/autonomy/estop:resume', manualStart: true })
+          await ensureDaemonProcessRunning('api/autonomy/estop:resume', { manualStart: true })
           return NextResponse.json({ ok: true, state: buildStateResponse(resumed) })
         }
 
@@ -79,7 +79,7 @@ export async function POST(req: Request) {
       }
 
       const resumed = resumeEstop({ approvalId })
-      startDaemon({ source: 'api/autonomy/estop:resume', manualStart: true })
+      await ensureDaemonProcessRunning('api/autonomy/estop:resume', { manualStart: true })
       return NextResponse.json({ ok: true, state: buildStateResponse(resumed) })
     }
 

package/src/app/api/chatrooms/[id]/chat/route.ts

@@ -20,7 +20,10 @@ import {
   isMuted,
 } from '@/lib/server/chatrooms/chatroom-helpers'
 import { filterHealthyChatroomAgents } from '@/lib/server/chatrooms/chatroom-health'
-import { evaluateRoutingRules } from '@/lib/server/chatrooms/chatroom-routing'
+import {
+  ensureChatroomRoutingGuidance,
+  selectChatroomRecipients,
+} from '@/lib/server/chatrooms/chatroom-routing'
 import { markProviderFailure, markProviderSuccess } from '@/lib/server/provider-health'
 import { applyAgentReactionsFromText } from '@/lib/server/chatrooms/chatroom-agent-signals'
 import { resolvePrimaryAgentRoute } from '@/lib/server/agents/agent-runtime-config'
@@ -60,11 +63,14 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   // Persist incoming message
   const senderName = senderId === 'user' ? 'You' : (agents[senderId]?.name || senderId)
   const replyTargetAgentId = resolveReplyTargetAgentId(replyToId, chatroom.messages, chatroom.agentIds)
+  ensureChatroomRoutingGuidance(chatroom, agents)
   let mentions = parseMentions(text, agents, chatroom.agentIds, { replyTargetAgentId, senderId: senderId !== 'user' ? senderId : null })
-  // Routing rules: if no explicit mentions, evaluate keyword/capability rules
-  if (mentions.length === 0 && chatroom.routingRules?.length) {
-    const agentList = chatroom.agentIds.map((aid) => agents[aid]).filter(Boolean)
-    mentions = evaluateRoutingRules(text, chatroom.routingRules, agentList)
+  if (mentions.length === 0 && !chatroom.autoAddress) {
+    mentions = await selectChatroomRecipients({
+      text,
+      chatroom,
+      agentsById: agents,
+    })
   }
   // Auto-address: if enabled and still no mentions, address all agents
   if (chatroom.autoAddress && mentions.length === 0) {

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

@@ -5,12 +5,21 @@ import { notFound } from '@/lib/server/collection-helpers'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 import { genId } from '@/lib/id'
 import { isWorkerOnlyAgent } from '@/lib/server/agents/agent-availability'
+import {
+  ensureChatroomRoutingGuidance,
+  synthesizeRoutingGuidanceFromRules,
+} from '@/lib/server/chatrooms/chatroom-routing'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const chatrooms = loadChatrooms()
   const chatroom = chatrooms[id]
   if (!chatroom) return notFound()
+  const agents = loadAgents()
+  if (ensureChatroomRoutingGuidance(chatroom, agents)) {
+    chatrooms[id] = chatroom
+    saveChatrooms(chatrooms)
+  }
   return NextResponse.json(chatroom)
 }
 
@@ -30,8 +39,16 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   if (body.autoAddress !== undefined) {
     chatroom.autoAddress = Boolean(body.autoAddress)
   }
-  if (body.routingRules !== undefined) {
-    chatroom.routingRules = Array.isArray(body.routingRules) ? body.routingRules : undefined
+  if (body.routingGuidance !== undefined || body.routingRules !== undefined) {
+    const agents = loadAgents()
+    const routingGuidance = (typeof body.routingGuidance === 'string' && body.routingGuidance.trim())
+      ? body.routingGuidance.trim()
+      : synthesizeRoutingGuidanceFromRules(
+          Array.isArray(body.routingRules) ? body.routingRules : undefined,
+          agents,
+        )
+    chatroom.routingGuidance = routingGuidance
+    delete chatroom.routingRules
   }
 
   // Diff agentIds and inject join/leave system messages
@@ -99,6 +116,10 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
     chatroom.agentIds = agentIds
   }
 
+  if (body.routingGuidance === undefined && body.routingRules === undefined) {
+    ensureChatroomRoutingGuidance(chatroom, loadAgents())
+  }
+
   chatroom.updatedAt = Date.now()
 
   chatrooms[id] = chatroom

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

@@ -7,6 +7,10 @@ import { safeParseBody } from '@/lib/server/safe-parse-body'
 import { z } from 'zod'
 import type { Chatroom, ChatroomMessage } from '@/types'
 import { isWorkerOnlyAgent } from '@/lib/server/agents/agent-availability'
+import {
+  ensureChatroomRoutingGuidance,
+  synthesizeRoutingGuidanceFromRules,
+} from '@/lib/server/chatrooms/chatroom-routing'
 
 export const dynamic = 'force-dynamic'
 
@@ -14,9 +18,12 @@ export async function GET(req: Request) {
   const { searchParams } = new URL(req.url)
   const filter = searchParams.get('filter') || 'chatrooms'
   const chatrooms = loadChatrooms()
+  const agents = loadAgents()
   const filtered: typeof chatrooms = {}
+  let migrated = false
   for (const [id, chatroom] of Object.entries(chatrooms)) {
     if (chatroom.archivedAt) continue
+    if (ensureChatroomRoutingGuidance(chatroom, agents)) migrated = true
     if (filter === 'chatrooms') {
       // Default: exclude hidden (protocol transcript rooms)
       if (chatroom.hidden === true) continue
@@ -27,6 +34,7 @@ export async function GET(req: Request) {
     // filter === 'all': include everything except archived
     filtered[id] = chatroom
   }
+  if (migrated) saveChatrooms(chatrooms)
   return NextResponse.json(filtered)
 }
 
@@ -63,6 +71,9 @@ export async function POST(req: Request) {
   const chatMode = body.chatMode === 'parallel' ? 'parallel' : 'sequential'
   const autoAddress = Boolean(body.autoAddress)
   const now = Date.now()
+  const routingGuidance = (typeof body.routingGuidance === 'string' && body.routingGuidance.trim())
+    ? body.routingGuidance.trim()
+    : synthesizeRoutingGuidanceFromRules(body.routingRules, knownAgents)
 
   // Generate join messages for initial agents
   const agents = agentIds.length > 0 ? knownAgents : {}
@@ -85,8 +96,8 @@ export async function POST(req: Request) {
     messages: joinMessages,
     chatMode,
     autoAddress,
-    ...(Array.isArray(body.routingRules) && body.routingRules.length > 0
-      ? { routingRules: body.routingRules }
+    ...(routingGuidance
+      ? { routingGuidance }
       : {}),
     createdAt: now,
     updatedAt: now,

package/src/app/api/chats/[id]/clear/route.ts

@@ -1,20 +1,9 @@
 import { NextResponse } from 'next/server'
-import { loadSession, upsertSession } from '@/lib/server/storage'
+import { clearChatMessages } from '@/lib/server/chats/chat-session-service'
 import { notFound } from '@/lib/server/collection-helpers'
 
 export async function POST(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const session = loadSession(id)
-  if (!session) return notFound()
-  session.messages = []
-  session.claudeSessionId = null
-  session.codexThreadId = null
-  session.opencodeSessionId = null
-  session.delegateResumeIds = {
-    claudeCode: null,
-    codex: null,
-    opencode: null,
-  }
-  upsertSession(id, session)
+  if (!clearChatMessages(id)) return notFound()
   return new NextResponse('OK')
 }

package/src/app/api/chats/[id]/deploy/route.ts

@@ -1,16 +1,15 @@
 import { NextResponse } from 'next/server'
 import { execSync } from 'child_process'
-import { loadSessions } from '@/lib/server/storage'
 import { notFound } from '@/lib/server/collection-helpers'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
 import { log } from '@/lib/server/logger'
+import { getSession } from '@/lib/server/sessions/session-repository'
 
 const TAG = 'api-deploy'
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const sessions = loadSessions()
-  const session = sessions[id]
+  const session = getSession(id)
   if (!session) return notFound()
 
   const { data: body, error } = await safeParseBody<{ message?: string }>(req)

package/src/app/api/chats/[id]/edit-resend/route.ts

@@ -1,21 +1,15 @@
 import { NextResponse } from 'next/server'
-import { loadSession, upsertSession } from '@/lib/server/storage'
+import { editAndResendChatTurn } from '@/lib/server/chats/chat-session-service'
 import { notFound } from '@/lib/server/collection-helpers'
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json().catch(() => ({})) as { messageIndex: number; newText: string }
-  const session = loadSession(id)
-  if (!session) return notFound()
-
-  const { messageIndex, newText } = body
-  if (typeof messageIndex !== 'number' || messageIndex < 0 || messageIndex >= session.messages.length) {
-    return NextResponse.json({ error: 'Invalid message index' }, { status: 400 })
+  const result = editAndResendChatTurn(id, body.messageIndex, body.newText)
+  if (!result.ok) {
+    return result.status === 404
+      ? notFound()
+      : NextResponse.json(result.payload, { status: result.status })
   }
-
-  // Truncate messages to messageIndex (discard that msg + everything after)
-  session.messages = session.messages.slice(0, messageIndex)
-  upsertSession(id, session)
-
-  return NextResponse.json({ message: newText })
+  return NextResponse.json(result.payload)
 }

package/src/app/api/chats/[id]/mailbox/route.ts

@@ -1,6 +1,6 @@
 import { NextResponse } from 'next/server'
 import { ackMailboxEnvelope, clearMailbox, listMailbox, sendMailboxEnvelope } from '@/lib/server/chatrooms/session-mailbox'
-import { loadSessions } from '@/lib/server/storage'
+import { getSession } from '@/lib/server/sessions/session-repository'
 
 function parseIntParam(value: string | null, fallback: number, min: number, max: number): number {
   const parsed = value ? Number.parseInt(value, 10) : Number.NaN
@@ -16,8 +16,8 @@ export async function GET(req: Request, { params }: { params: Promise<{ id: stri
   try {
     const envelopes = listMailbox(id, { limit, includeAcked })
     return NextResponse.json({ sessionId: id, count: envelopes.length, envelopes })
-  } catch (err: any) {
-    return NextResponse.json({ error: err?.message || 'Failed to load mailbox.' }, { status: 404 })
+  } catch (err: unknown) {
+    return NextResponse.json({ error: err instanceof Error ? err.message : 'Failed to load mailbox.' }, { status: 404 })
   }
 }
 
@@ -25,8 +25,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
   const { id } = await params
   const body = await req.json().catch(() => ({}))
   const action = typeof body?.action === 'string' ? body.action : 'send'
-  const sessions = loadSessions()
-  const current = sessions[id]
+  const current = getSession(id)
   if (!current) return NextResponse.json({ error: `Session not found: ${id}` }, { status: 404 })
 
   try {
@@ -63,8 +62,7 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
     }
 
     return NextResponse.json({ error: `Unsupported action: ${action}` }, { status: 400 })
-  } catch (err: any) {
-    return NextResponse.json({ error: err?.message || 'Mailbox operation failed.' }, { status: 500 })
+  } catch (err: unknown) {
+    return NextResponse.json({ error: err instanceof Error ? err.message : 'Mailbox operation failed.' }, { status: 500 })
   }
 }
-

package/src/app/api/chats/[id]/queue/route.ts

@@ -1,84 +1,37 @@
 import { NextResponse } from 'next/server'
 import { notFound } from '@/lib/server/collection-helpers'
-import { loadSession } from '@/lib/server/storage'
 import {
-  cancelQueuedRunById,
-  cancelQueuedRunsForSession,
-  enqueueSessionRun,
-  getSessionQueueSnapshot,
-} from '@/lib/server/runtime/session-run-manager'
+  cancelQueuedChatMessages,
+  getQueueSnapshot,
+  queueChatMessage,
+} from '@/lib/server/chats/chat-session-service'
 
 export const dynamic = 'force-dynamic'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const session = loadSession(id)
-  if (!session) return notFound()
-  return NextResponse.json(getSessionQueueSnapshot(id))
+  const snapshot = getQueueSnapshot(id)
+  if (!snapshot) return notFound()
+  return NextResponse.json(snapshot)
 }
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const session = loadSession(id)
-  if (!session) return notFound()
-
   const body = await req.json().catch(() => ({}))
-  const message = typeof body.message === 'string' ? body.message : ''
-  const imagePath = typeof body.imagePath === 'string' ? body.imagePath : undefined
-  const imageUrl = typeof body.imageUrl === 'string' ? body.imageUrl : undefined
-  const attachedFiles = Array.isArray(body.attachedFiles)
-    ? body.attachedFiles.filter((file: unknown): file is string => typeof file === 'string' && file.trim().length > 0)
-    : undefined
-  const replyToId = typeof body.replyToId === 'string' ? body.replyToId : undefined
-  const hasFiles = !!(imagePath || imageUrl || attachedFiles?.length)
-
-  if (!message.trim() && !hasFiles) {
-    return NextResponse.json({ error: 'message or file is required' }, { status: 400 })
+  const result = queueChatMessage(id, body as Record<string, unknown>)
+  if (!result.ok) {
+    return result.status === 404
+      ? notFound()
+      : NextResponse.json(result.payload, { status: result.status })
   }
-
-  const queued = enqueueSessionRun({
-    sessionId: id,
-    missionId: session.missionId || null,
-    message,
-    imagePath,
-    imageUrl,
-    attachedFiles,
-    source: 'chat',
-    mode: 'followup',
-    replyToId,
-  })
-
-  return NextResponse.json({
-    queued: {
-      runId: queued.runId,
-      position: queued.position,
-    },
-    snapshot: getSessionQueueSnapshot(id),
-  }, { status: 202 })
+  return NextResponse.json(result.payload)
 }
 
 export async function DELETE(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const session = loadSession(id)
-  if (!session) return notFound()
-
   const body = await req.json().catch(() => ({}))
-  const runId = typeof body.runId === 'string' ? body.runId.trim() : ''
-  if (runId) {
-    const snapshot = getSessionQueueSnapshot(id)
-    if (!snapshot.items.some((item) => item.runId === runId)) {
-      return NextResponse.json({ error: 'Queued run not found' }, { status: 404 })
-    }
-    cancelQueuedRunById(runId, 'Removed from queue')
-    return NextResponse.json({
-      cancelled: 1,
-      snapshot: getSessionQueueSnapshot(id),
-    })
-  }
-
-  const cancelled = cancelQueuedRunsForSession(id, 'Cleared queued messages')
-  return NextResponse.json({
-    cancelled,
-    snapshot: getSessionQueueSnapshot(id),
-  })
+  const result = cancelQueuedChatMessages(id, typeof body.runId === 'string' ? body.runId : '')
+  if (!result) return notFound()
+  if (!result.ok) return NextResponse.json(result.payload, { status: result.status })
+  return NextResponse.json(result.payload)
 }