@swarmclawai/swarmclaw 0.7.3 → 0.7.4

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

@@ -0,0 +1,66 @@
+import { NextResponse } from 'next/server'
+import { genId } from '@/lib/id'
+import { formatZodError, ExternalAgentRegisterSchema } from '@/lib/validation/schemas'
+import { loadExternalAgents, saveExternalAgents } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+import type { ExternalAgentRuntime } from '@/types'
+import { z } from 'zod'
+export const dynamic = 'force-dynamic'
+
+function withDerivedStatus(record: ExternalAgentRuntime): ExternalAgentRuntime {
+  const now = Date.now()
+  const lastSeenAt = typeof record.lastSeenAt === 'number' ? record.lastSeenAt : null
+  const staleMs = 3 * 60_000
+  if (!lastSeenAt) return { ...record, status: record.status || 'offline' }
+  if (record.status === 'offline') return record
+  return {
+    ...record,
+    status: now - lastSeenAt > staleMs ? 'stale' : (record.status || 'online'),
+  }
+}
+
+export async function GET() {
+  const runtimes = loadExternalAgents()
+  const items: ExternalAgentRuntime[] = Object.values(runtimes)
+    .map((item) => withDerivedStatus(item))
+    .sort((a, b) => (b.lastSeenAt || b.updatedAt || 0) - (a.lastSeenAt || a.updatedAt || 0))
+  return NextResponse.json(items)
+}
+
+export async function POST(req: Request) {
+  const raw = await req.json().catch(() => ({}))
+  const parsed = ExternalAgentRegisterSchema.safeParse(raw)
+  if (!parsed.success) {
+    return NextResponse.json(formatZodError(parsed.error as z.ZodError), { status: 400 })
+  }
+  const body = parsed.data
+  const now = Date.now()
+  const items = loadExternalAgents()
+  const id = body.id || `external-${genId()}`
+  const existing = items[id]
+  items[id] = {
+    ...existing,
+    id,
+    name: body.name.trim(),
+    sourceType: body.sourceType,
+    status: body.status || existing?.status || 'online',
+    provider: (body.provider as ExternalAgentRuntime['provider']) || null,
+    model: body.model || null,
+    workspace: body.workspace || null,
+    transport: body.transport || null,
+    endpoint: body.endpoint || null,
+    agentId: body.agentId || null,
+    gatewayProfileId: body.gatewayProfileId || null,
+    capabilities: body.capabilities,
+    labels: body.labels,
+    metadata: body.metadata,
+    tokenStats: body.tokenStats,
+    lastHeartbeatAt: existing?.lastHeartbeatAt || now,
+    lastSeenAt: now,
+    createdAt: existing?.createdAt || now,
+    updatedAt: now,
+  }
+  saveExternalAgents(items)
+  notify('external_agents')
+  return NextResponse.json(items[id])
+}

package/src/app/api/gateways/[id]/health/route.ts

@@ -0,0 +1,28 @@
+import { NextResponse } from 'next/server'
+import { probeOpenClawHealth } from '@/lib/server/openclaw-health'
+import { loadGatewayProfiles, saveGatewayProfiles } from '@/lib/server/storage'
+import { notFound } from '@/lib/server/collection-helpers'
+import { notify } from '@/lib/server/ws-hub'
+export const dynamic = 'force-dynamic'
+
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const gateways = loadGatewayProfiles()
+  const gateway = gateways[id]
+  if (!gateway) return notFound()
+
+  const result = await probeOpenClawHealth({
+    endpoint: gateway.endpoint,
+    credentialId: gateway.credentialId || null,
+  })
+
+  gateway.status = result.ok ? 'healthy' : (result.authProvided ? 'degraded' : 'offline')
+  gateway.lastCheckedAt = Date.now()
+  gateway.lastError = result.ok ? null : (result.error || result.hint || 'Gateway health check failed.')
+  gateway.lastModelCount = Array.isArray(result.models) ? result.models.length : 0
+  gateway.updatedAt = Date.now()
+  saveGatewayProfiles(gateways)
+  notify('gateways')
+
+  return NextResponse.json(result)
+}

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

@@ -0,0 +1,79 @@
+import { NextResponse } from 'next/server'
+import { normalizeOpenClawEndpoint } from '@/lib/openclaw-endpoint'
+import { loadAgents, loadGatewayProfiles, saveAgents, saveGatewayProfiles } from '@/lib/server/storage'
+import { mutateItem, notFound, type CollectionOps } from '@/lib/server/collection-helpers'
+import type { Agent, AgentRoutingTarget, GatewayProfile } from '@/types'
+
+const ops: CollectionOps<GatewayProfile> = {
+  load: loadGatewayProfiles,
+  save: saveGatewayProfiles,
+  topic: 'gateways',
+}
+
+function normalizeTags(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  return value
+    .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
+    .filter(Boolean)
+}
+
+export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const body = await req.json().catch(() => ({}))
+  const result = mutateItem(ops, id, (gateway, all) => {
+    if (body.isDefault === true) {
+      for (const [candidateId, candidate] of Object.entries(all)) {
+        if (candidateId === id || !candidate || typeof candidate !== 'object') continue
+        candidate.isDefault = false
+      }
+    }
+    if (body.name !== undefined) gateway.name = String(body.name || '').trim() || gateway.name
+    if (body.endpoint !== undefined) gateway.endpoint = normalizeOpenClawEndpoint(body.endpoint || undefined)
+    if (body.wsUrl !== undefined) gateway.wsUrl = body.wsUrl || null
+    if (body.credentialId !== undefined) gateway.credentialId = body.credentialId || null
+    if (body.status !== undefined) gateway.status = body.status || 'unknown'
+    if (body.notes !== undefined) gateway.notes = body.notes || null
+    if (body.tags !== undefined) gateway.tags = normalizeTags(body.tags)
+    if (body.lastError !== undefined) gateway.lastError = body.lastError || null
+    if (body.lastCheckedAt !== undefined) gateway.lastCheckedAt = body.lastCheckedAt || null
+    if (body.lastModelCount !== undefined) gateway.lastModelCount = body.lastModelCount || null
+    if (body.discoveredHost !== undefined) gateway.discoveredHost = body.discoveredHost || null
+    if (body.discoveredPort !== undefined) gateway.discoveredPort = body.discoveredPort || null
+    if (body.isDefault !== undefined) gateway.isDefault = body.isDefault === true
+    gateway.updatedAt = Date.now()
+    return gateway
+  })
+  if (!result) return notFound()
+  return NextResponse.json(result)
+}
+
+export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params
+  const gateways = loadGatewayProfiles()
+  if (!gateways[id]) return notFound()
+  delete gateways[id]
+  saveGatewayProfiles(gateways)
+
+  const agents = loadAgents({ includeTrashed: true })
+  let agentChanged = false
+  for (const agent of Object.values(agents) as Agent[]) {
+    if (agent.gatewayProfileId === id) {
+      agent.gatewayProfileId = null
+      agentChanged = true
+    }
+    if (Array.isArray(agent.routingTargets)) {
+      const nextTargets = agent.routingTargets.map((target: AgentRoutingTarget) => (
+        target.gatewayProfileId === id
+          ? { ...target, gatewayProfileId: null }
+          : target
+      ))
+      if (JSON.stringify(nextTargets) !== JSON.stringify(agent.routingTargets)) {
+        agent.routingTargets = nextTargets
+        agentChanged = true
+      }
+    }
+  }
+  if (agentChanged) saveAgents(agents)
+
+  return NextResponse.json({ ok: true })
+}

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

@@ -0,0 +1,57 @@
+import { NextResponse } from 'next/server'
+import { genId } from '@/lib/id'
+import { normalizeOpenClawEndpoint } from '@/lib/openclaw-endpoint'
+import { getGatewayProfiles } from '@/lib/server/agent-runtime-config'
+import { loadGatewayProfiles, saveGatewayProfiles } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+export const dynamic = 'force-dynamic'
+
+function normalizeTags(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  return value
+    .map((entry) => (typeof entry === 'string' ? entry.trim() : ''))
+    .filter(Boolean)
+}
+
+export async function GET() {
+  return NextResponse.json(getGatewayProfiles('openclaw'))
+}
+
+export async function POST(req: Request) {
+  const body = await req.json().catch(() => ({}))
+  const endpoint = normalizeOpenClawEndpoint(body.endpoint || undefined)
+  const now = Date.now()
+  const gateways = loadGatewayProfiles()
+  const id = body.id || `gateway-${genId()}`
+  const isDefault = body.isDefault === true
+
+  if (isDefault) {
+    for (const gateway of Object.values(gateways) as Array<Record<string, unknown>>) {
+      gateway.isDefault = false
+    }
+  }
+
+  gateways[id] = {
+    id,
+    name: typeof body.name === 'string' && body.name.trim() ? body.name.trim() : 'OpenClaw Gateway',
+    provider: 'openclaw',
+    endpoint,
+    wsUrl: body.wsUrl || null,
+    credentialId: body.credentialId || null,
+    status: body.status || 'unknown',
+    notes: typeof body.notes === 'string' ? body.notes : null,
+    tags: normalizeTags(body.tags),
+    lastError: null,
+    lastCheckedAt: null,
+    lastModelCount: null,
+    discoveredHost: typeof body.discoveredHost === 'string' ? body.discoveredHost : null,
+    discoveredPort: typeof body.discoveredPort === 'number' ? body.discoveredPort : null,
+    isDefault,
+    createdAt: now,
+    updatedAt: now,
+  }
+
+  saveGatewayProfiles(gateways)
+  notify('gateways')
+  return NextResponse.json(gateways[id])
+}

package/src/app/api/openclaw/gateway/route.ts

@@ -5,6 +5,7 @@ import { ensureGatewayConnected, getGateway, disconnectGateway, manualConnect }
 export async function POST(req: Request) {
   const body = await req.json()
   const { method, params } = body as { method?: string; params?: Record<string, unknown> }
+  const profileId = typeof params?.profileId === 'string' ? params.profileId : undefined
   if (!method || typeof method !== 'string') {
     return NextResponse.json({ error: 'Missing RPC method' }, { status: 400 })
   }
@@ -14,7 +15,7 @@ export async function POST(req: Request) {
     try {
       const url = (params?.url as string) || undefined
       const token = (params?.token as string) || undefined
-      const ok = await manualConnect(url, token)
+      const ok = await manualConnect(url, token, profileId)
       return NextResponse.json({ ok })
     } catch (err: unknown) {
       return NextResponse.json({ ok: false, error: err instanceof Error ? err.message : String(err) }, { status: 502 })
@@ -22,13 +23,13 @@ export async function POST(req: Request) {
   }
 
   if (method === 'gateway.disconnect') {
-    disconnectGateway()
+    disconnectGateway(profileId)
     return NextResponse.json({ ok: true })
   }
 
   // Reload mode get/set
   if (method === 'gateway.reload-mode.get') {
-    const gw = await ensureGatewayConnected()
+    const gw = await ensureGatewayConnected({ profileId })
     if (!gw) return NextResponse.json({ error: 'Not connected' }, { status: 503 })
     try {
       const config = await gw.rpc('config.get') as Record<string, unknown> | undefined
@@ -40,7 +41,7 @@ export async function POST(req: Request) {
   }
 
   if (method === 'gateway.reload-mode.set') {
-    const gw = await ensureGatewayConnected()
+    const gw = await ensureGatewayConnected({ profileId })
     if (!gw) return NextResponse.json({ error: 'Not connected' }, { status: 503 })
     try {
       await gw.rpc('config.set', { reloadMode: params?.mode })
@@ -51,7 +52,7 @@ export async function POST(req: Request) {
   }
 
   // General RPC proxy
-  const gw = await ensureGatewayConnected()
+  const gw = await ensureGatewayConnected({ profileId })
   if (!gw) {
     return NextResponse.json({ error: 'OpenClaw gateway not connected' }, { status: 503 })
   }
@@ -66,7 +67,9 @@ export async function POST(req: Request) {
 }
 
 /** GET — check gateway connection status */
-export async function GET() {
-  const gw = getGateway()
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url)
+  const profileId = searchParams.get('profileId') || undefined
+  const gw = getGateway(profileId || undefined)
   return NextResponse.json({ connected: !!gw?.connected })
 }

package/src/app/api/openclaw/skills/route.ts

@@ -4,7 +4,7 @@ import { resolveOpenClawGatewayAgentId } from '@/lib/server/openclaw-agent-resol
 import { normalizeOpenClawSkillsPayload } from '@/lib/server/openclaw-skills-normalize'
 import { loadAgents, saveAgents } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
-import type { OpenClawSkillEntry, SkillAllowlistMode } from '@/types'
+import type { SkillAllowlistMode } from '@/types'
 
 /** GET ?agentId=X — fetch skills from gateway with eligibility */
 export async function GET(req: Request) {

package/src/app/api/providers/[id]/discover-models/route.ts

@@ -0,0 +1,27 @@
+import { NextResponse } from 'next/server'
+import { discoverProviderModels } from '@/lib/server/provider-model-discovery'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const { id } = await params
+  const { searchParams } = new URL(req.url)
+  const result = await discoverProviderModels({
+    providerId: id,
+    credentialId: searchParams.get('credentialId'),
+    endpoint: searchParams.get('endpoint'),
+    force: searchParams.get('force') === '1',
+    requiresApiKey: searchParams.has('requiresApiKey')
+      ? searchParams.get('requiresApiKey') !== '0'
+      : undefined,
+  })
+
+  return NextResponse.json(result, {
+    headers: {
+      'Cache-Control': 'private, no-store',
+    },
+  })
+}

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

@@ -1,7 +1,9 @@
 import { NextResponse } from 'next/server'
-import { loadSchedules, saveSchedules, deleteSchedule } from '@/lib/server/storage'
+import { loadAgents, loadSchedules, loadSessions, saveSchedules, deleteSchedule } from '@/lib/server/storage'
+import { WORKSPACE_DIR } from '@/lib/server/data-dir'
 import { resolveScheduleName } from '@/lib/schedule-name'
 import { mutateItem, deleteItem, notFound, type CollectionOps } from '@/lib/server/collection-helpers'
+import { normalizeSchedulePayload } from '@/lib/server/schedule-normalization'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const ops: CollectionOps<any> = { load: loadSchedules, save: saveSchedules, deleteFn: deleteSchedule, topic: 'schedules' }
@@ -9,15 +11,42 @@ const ops: CollectionOps<any> = { load: loadSchedules, save: saveSchedules, dele
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json()
-  const result = mutateItem(ops, id, (schedule) => {
-    Object.assign(schedule, body)
-    schedule.id = id
-    schedule.name = resolveScheduleName({
-      name: schedule.name,
-      taskPrompt: schedule.taskPrompt,
+  const sessions = loadSessions()
+  const agents = loadAgents()
+  let result = null
+  try {
+    result = mutateItem(ops, id, (schedule) => {
+      const sessionCwd = typeof schedule.createdInSessionId === 'string'
+        ? sessions[schedule.createdInSessionId]?.cwd
+        : null
+      const normalized = normalizeSchedulePayload({
+        ...schedule,
+        ...(body as Record<string, unknown>),
+        id,
+      }, {
+        cwd: sessionCwd || WORKSPACE_DIR,
+        now: Date.now(),
+      })
+      if (!normalized.ok) throw new Error(normalized.error)
+      const nextSchedule = {
+        ...schedule,
+        ...normalized.value,
+        id,
+        updatedAt: Date.now(),
+      }
+      if (!agents[String(nextSchedule.agentId)]) {
+        throw new Error(`Agent not found: ${String(nextSchedule.agentId)}`)
+      }
+      nextSchedule.name = resolveScheduleName({
+        name: nextSchedule.name,
+        taskPrompt: nextSchedule.taskPrompt,
+      })
+      return nextSchedule
     })
-    return schedule
-  })
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error)
+    return NextResponse.json({ error: message }, { status: 400 })
+  }
   if (!result) return notFound()
   return NextResponse.json(result)
 }

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

@@ -1,11 +1,31 @@
 import { NextResponse } from 'next/server'
 import { genId } from '@/lib/id'
-import { loadSchedules, saveSchedules } from '@/lib/server/storage'
+import { loadAgents, loadSchedules, saveSchedules } from '@/lib/server/storage'
+import { WORKSPACE_DIR } from '@/lib/server/data-dir'
+import { normalizeSchedulePayload } from '@/lib/server/schedule-normalization'
 import { resolveScheduleName } from '@/lib/schedule-name'
 import { findDuplicateSchedule } from '@/lib/schedule-dedupe'
 import { notify } from '@/lib/server/ws-hub'
 export const dynamic = 'force-dynamic'
 
+function asString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function asPositiveInt(value: unknown): number | null {
+  const parsed = typeof value === 'number'
+    ? value
+    : typeof value === 'string'
+      ? Number.parseInt(value, 10)
+      : Number.NaN
+  if (!Number.isFinite(parsed)) return null
+  const intValue = Math.trunc(parsed)
+  return intValue > 0 ? intValue : null
+}
+
+function asScheduleType(value: unknown): 'cron' | 'interval' | 'once' {
+  return value === 'cron' || value === 'interval' || value === 'once' ? value : 'cron'
+}
 
 export async function GET(_req: Request) {
   return NextResponse.json(loadSchedules())
@@ -15,28 +35,46 @@ export async function POST(req: Request) {
   const body = await req.json()
   const now = Date.now()
   const schedules = loadSchedules()
-  const scheduleType = body.scheduleType || 'cron'
+  const normalizedSchedule = normalizeSchedulePayload(body as Record<string, unknown>, {
+    cwd: WORKSPACE_DIR,
+    now,
+  })
+  if (!normalizedSchedule.ok) {
+    return NextResponse.json({ error: normalizedSchedule.error }, { status: 400 })
+  }
+
+  const candidate = normalizedSchedule.value
+  const agents = loadAgents()
+  if (!agents[String(candidate.agentId)]) {
+    return NextResponse.json({ error: `Agent not found: ${String(candidate.agentId)}` }, { status: 400 })
+  }
+  const scheduleType = asScheduleType(candidate.scheduleType)
+  const candidateAgentId = asString(candidate.agentId) || null
+  const candidateTaskPrompt = asString(candidate.taskPrompt)
+  const candidateCron = asString(candidate.cron) || null
+  const candidateIntervalMs = asPositiveInt(candidate.intervalMs)
+  const candidateRunAt = asPositiveInt(candidate.runAt)
 
   const duplicate = findDuplicateSchedule(schedules, {
-    agentId: body.agentId || null,
-    taskPrompt: body.taskPrompt || '',
+    agentId: candidateAgentId,
+    taskPrompt: candidateTaskPrompt,
     scheduleType,
-    cron: body.cron,
-    intervalMs: body.intervalMs,
-    runAt: body.runAt,
+    cron: candidateCron,
+    intervalMs: candidateIntervalMs,
+    runAt: candidateRunAt,
   })
   if (duplicate) {
     const duplicateId = duplicate.id || ''
     let changed = false
     const nextName = resolveScheduleName({
-      name: body.name ?? duplicate.name,
-      taskPrompt: body.taskPrompt ?? duplicate.taskPrompt,
+      name: candidate.name ?? duplicate.name,
+      taskPrompt: candidate.taskPrompt ?? duplicate.taskPrompt,
     })
     if (nextName && nextName !== duplicate.name) {
       duplicate.name = nextName
       changed = true
     }
-    const normalizedStatus = typeof body.status === 'string' ? body.status.trim().toLowerCase() : ''
+    const normalizedStatus = typeof candidate.status === 'string' ? candidate.status.trim().toLowerCase() : ''
     if ((normalizedStatus === 'active' || normalizedStatus === 'paused') && duplicate.status !== normalizedStatus) {
       duplicate.status = normalizedStatus as 'active' | 'paused'
       changed = true
@@ -53,29 +91,14 @@ export async function POST(req: Request) {
 
   const id = genId()
 
-  let nextRunAt: number | undefined
-  if (scheduleType === 'once' && body.runAt) {
-    nextRunAt = body.runAt
-  } else if (scheduleType === 'interval' && body.intervalMs) {
-    nextRunAt = now + body.intervalMs
-  } else if (scheduleType === 'cron') {
-    // nextRunAt will be computed by the scheduler engine
-    nextRunAt = undefined
-  }
-
   schedules[id] = {
     id,
-    name: resolveScheduleName({ name: body.name, taskPrompt: body.taskPrompt }),
-    agentId: body.agentId,
-    taskPrompt: body.taskPrompt || '',
+    ...candidate,
+    name: resolveScheduleName({ name: candidate.name, taskPrompt: candidate.taskPrompt }),
     scheduleType,
-    cron: body.cron,
-    intervalMs: body.intervalMs,
-    runAt: body.runAt,
     lastRunAt: undefined,
-    nextRunAt,
-    status: body.status || 'active',
     createdAt: now,
+    updatedAt: now,
   }
   saveSchedules(schedules)
   notify('schedules')

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

@@ -1,6 +1,7 @@
 import { NextResponse } from 'next/server'
+import { normalizeHeartbeatSettingFields } from '@/lib/heartbeat-defaults'
 import { loadPublicSettings, loadSettings, saveSettings } from '@/lib/server/storage'
-import { DEFAULT_DELEGATION_MAX_DEPTH } from '@/lib/runtime-loop'
+import { normalizeRuntimeSettingFields } from '@/lib/runtime-loop'
 export const dynamic = 'force-dynamic'
 
 
@@ -10,8 +11,6 @@ const MEMORY_PER_LOOKUP_MIN = 1
 const MEMORY_PER_LOOKUP_MAX = 200
 const MEMORY_LINKED_MIN = 0
 const MEMORY_LINKED_MAX = 1000
-const DELEGATION_DEPTH_MIN = 1
-const DELEGATION_DEPTH_MAX = 12
 const RESPONSE_CACHE_TTL_MIN_SEC = 5
 const RESPONSE_CACHE_TTL_MAX_SEC = 7 * 24 * 3600
 const RESPONSE_CACHE_MAX_ENTRIES_MIN = 1
@@ -83,12 +82,8 @@ export async function PUT(req: Request) {
     MEMORY_LINKED_MIN,
     MEMORY_LINKED_MAX,
   )
-  const nextDelegationDepth = parseIntSetting(
-    settings.delegationMaxDepth,
-    DEFAULT_DELEGATION_MAX_DEPTH,
-    DELEGATION_DEPTH_MIN,
-    DELEGATION_DEPTH_MAX,
-  )
+  const normalizedRuntime = normalizeRuntimeSettingFields(settings)
+  const normalizedHeartbeat = normalizeHeartbeatSettingFields(settings)
   const nextResponseCacheTtlSec = parseIntSetting(
     settings.responseCacheTtlSec,
     15 * 60,
@@ -120,7 +115,8 @@ export async function PUT(req: Request) {
   settings.maxMemoriesPerLookup = nextPerLookup
   settings.memoryMaxPerLookup = nextPerLookup
   settings.maxLinkedMemoriesExpanded = nextLinked
-  settings.delegationMaxDepth = nextDelegationDepth
+  Object.assign(settings, normalizedRuntime)
+  Object.assign(settings, normalizedHeartbeat)
   settings.responseCacheTtlSec = nextResponseCacheTtlSec
   settings.responseCacheMaxEntries = nextResponseCacheMaxEntries
   settings.responseCacheEnabled = parseBoolSetting(settings.responseCacheEnabled, true)

package/src/app/api/setup/doctor/route.ts

@@ -90,12 +90,14 @@ export async function GET(req: Request) {
   const checkedAt = Date.now()
 
   const nodeVersion = process.versions.node
-  const nodeMajor = Number.parseInt(String(nodeVersion).split('.')[0] || '0', 10)
-  if (nodeMajor >= 20) {
+  const [nodeMajorRaw, nodeMinorRaw] = String(nodeVersion).split('.')
+  const nodeMajor = Number.parseInt(nodeMajorRaw || '0', 10)
+  const nodeMinor = Number.parseInt(nodeMinorRaw || '0', 10)
+  if (nodeMajor > 22 || (nodeMajor === 22 && nodeMinor >= 6)) {
     pushCheck(checks, 'node-version', 'Node.js version', 'pass', `Detected Node ${nodeVersion}.`, true)
   } else {
-    pushCheck(checks, 'node-version', 'Node.js version', 'fail', `Detected Node ${nodeVersion}. Node 20+ is required.`, true)
-    actions.push('Install Node.js 20 or newer from https://nodejs.org and rerun setup.')
+    pushCheck(checks, 'node-version', 'Node.js version', 'fail', `Detected Node ${nodeVersion}. Node 22.6+ is required.`, true)
+    actions.push('Install Node.js 22.6 or newer from https://nodejs.org and rerun setup.')
   }
 
   const npmCheck = run('npm', ['--version'], 5_000)

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

@@ -13,6 +13,7 @@ import { requestHeartbeatNow } from '@/lib/server/heartbeat-wake'
 import { validateDag, cascadeUnblock } from '@/lib/server/dag-validation'
 import { getPluginManager } from '@/lib/server/plugins'
 import { normalizeTaskQualityGate } from '@/lib/server/task-quality-gate'
+import type { BoardTask } from '@/types'
 import '@/lib/server/builtin-plugins'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
@@ -151,7 +152,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
     if (unblockedIds.length > 0) {
       upsertStoredItems('tasks', [
         [id, tasks[id]],
-        ...unblockedIds.map((uid) => [uid, tasks[uid]] as [string, any]),
+        ...unblockedIds.map((uid) => [uid, tasks[uid]] as [string, BoardTask]),
       ])
       for (const uid of unblockedIds) {
         enqueueTask(uid)

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

@@ -4,7 +4,7 @@ import { enqueueTask, disableSessionHeartbeat } from '@/lib/server/queue'
 import { pushMainLoopEventToMainSessions } from '@/lib/server/main-agent-loop'
 import { notify } from '@/lib/server/ws-hub'
 import { createNotification } from '@/lib/server/create-notification'
-import type { BoardTaskStatus } from '@/types'
+import type { BoardTask, BoardTaskStatus } from '@/types'
 
 const VALID_STATUSES: BoardTaskStatus[] = ['backlog', 'queued', 'running', 'completed', 'failed', 'archived']
 
@@ -82,7 +82,7 @@ export async function POST(req: Request) {
     }
   }
 
-  upsertStoredItems('tasks', results.map((id) => [id, tasks[id]] as [string, any]))
+  upsertStoredItems('tasks', results.map((id) => [id, tasks[id]] as [string, BoardTask]))
 
   if (updated > 0) {
     const action = body.status