@swarmclawai/swarmclaw 1.2.4 → 1.2.6

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

@@ -1,35 +1,19 @@
 import { NextResponse } from 'next/server'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
-import { genId } from '@/lib/id'
 import { perf } from '@/lib/server/runtime/perf'
-import { deleteTask, loadAgents, loadSettings, loadTasks, logActivity, upsertTask } from '@/lib/server/storage'
 import { TaskCreateSchema, formatZodError } from '@/lib/validation/schemas'
 import { z } from 'zod'
-import { 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 { resolveTaskAgentFromDescription } from '@/lib/server/tasks/task-mention'
-import { validateDag } from '@/lib/server/dag-validation'
-import { getExtensionManager } from '@/lib/server/extensions'
-import { getEnabledCapabilityIds } from '@/lib/capability-selection'
 import {
-  prepareTaskCreation,
-} from '@/lib/server/tasks/task-service'
-import { ensureMissionForTask, enrichTaskWithMissionSummary } from '@/lib/server/missions/mission-service'
-import '@/lib/server/builtin-extensions'
+  createTaskFromRoute,
+  deleteTasksByFilter,
+  prepareTasksForListing,
+} from '@/lib/server/tasks/task-route-service'
 
 export async function GET(req: Request) {
   const endPerf = perf.start('api', 'GET /api/tasks')
-  // Keep completed queue integrity even if daemon is not running.
-  validateCompletedTasksQueue()
-  recoverStalledRunningTasks()
-
   const { searchParams } = new URL(req.url)
   const includeArchived = searchParams.get('includeArchived') === 'true'
-  const allTasks = loadTasks()
-  const missionTasks = Object.fromEntries(
-    Object.entries(allTasks).map(([id, task]) => [id, enrichTaskWithMissionSummary(task)]),
-  )
+  const missionTasks = prepareTasksForListing()
 
   if (includeArchived) {
     endPerf({ count: Object.keys(missionTasks).length })
@@ -37,7 +21,7 @@ export async function GET(req: Request) {
   }
 
   // Exclude archived tasks by default
-  const filtered: Record<string, typeof allTasks[string]> = {}
+  const filtered: Record<string, (typeof missionTasks)[string]> = {}
   for (const [id, task] of Object.entries(missionTasks)) {
     if (task.status !== 'archived') {
       filtered[id] = task
@@ -50,23 +34,7 @@ export async function GET(req: Request) {
 export async function DELETE(req: Request) {
   const { searchParams } = new URL(req.url)
   const filter = searchParams.get('filter') // 'all' | 'schedule' | 'done' | null
-  const tasks = loadTasks()
-  let removed = 0
-
-  const shouldRemove = (task: { status: string; sourceType?: string }) =>
-    filter === 'all' ||
-    (filter === 'schedule' && task.sourceType === 'schedule') ||
-    (filter === 'done' && (task.status === 'completed' || task.status === 'failed')) ||
-    (!filter && task.status === 'archived')
-
-  for (const [id, task] of Object.entries(tasks)) {
-    if (shouldRemove(task as { status: string; sourceType?: string })) {
-      deleteTask(id)
-      removed++
-    }
-  }
-  notify('tasks')
-  return NextResponse.json({ removed, remaining: Object.keys(tasks).length - removed })
+  return NextResponse.json(deleteTasksByFilter(filter))
 }
 
 export async function POST(req: Request) {
@@ -76,136 +44,8 @@ export async function POST(req: Request) {
   if (!parsed.success) {
     return NextResponse.json(formatZodError(parsed.error as z.ZodError), { status: 400 })
   }
-  const body = { ...raw, ...parsed.data } as Record<string, unknown> & typeof parsed.data
-  const id = genId()
-  const now = Date.now()
-  const tasks = loadTasks()
-  const settings = loadSettings()
-  const maxAttempts = Number.isFinite(Number(body.maxAttempts))
-    ? Math.max(1, Math.min(20, Math.trunc(Number(body.maxAttempts))))
-    : Math.max(1, Math.min(20, Math.trunc(Number(settings.defaultTaskMaxAttempts ?? 3))))
-  const retryBackoffSec = Number.isFinite(Number(body.retryBackoffSec))
-    ? Math.max(1, Math.min(3600, Math.trunc(Number(body.retryBackoffSec))))
-    : Math.max(1, Math.min(3600, Math.trunc(Number(settings.taskRetryBackoffSec ?? 30))))
-  // DAG validation: reject if proposed blockedBy would create a cycle
-  if (Array.isArray(body.blockedBy) && body.blockedBy.length > 0) {
-    const dagResult = validateDag(tasks, id, body.blockedBy)
-    if (!dagResult.valid) {
-      return NextResponse.json(
-        { error: 'Dependency cycle detected', cycle: dagResult.cycle },
-        { status: 400 },
-      )
-    }
-  }
-
-  // Resolve @mentions in description to auto-assign agent
-  const resolvedAgentId = body.description
-    ? resolveTaskAgentFromDescription(body.description, body.agentId || '', loadAgents())
-    : (body.agentId || '')
-
-  const prepared = prepareTaskCreation({
-    id,
-    input: {
-      ...body,
-      agentId: resolvedAgentId,
-    },
-    tasks,
-    now,
-    settings,
-    seed: {
-      projectId: typeof body.projectId === 'string' && body.projectId ? body.projectId : null,
-      goalContract: body.goalContract || null,
-      cwd: typeof body.cwd === 'string' ? body.cwd : null,
-      file: typeof body.file === 'string' ? body.file : null,
-      sessionId: typeof body.sessionId === 'string' ? body.sessionId : null,
-      result: typeof body.result === 'string' ? body.result : null,
-      error: typeof body.error === 'string' ? body.error : null,
-      outputFiles: Array.isArray(body.outputFiles)
-        ? body.outputFiles.filter((entry: unknown) => typeof entry === 'string').slice(0, 24)
-        : [],
-      artifacts: Array.isArray(body.artifacts)
-        ? body.artifacts
-            .filter((artifact: unknown) => artifact && typeof artifact === 'object')
-            .map((artifact: unknown) => {
-              const row = artifact as {
-                url?: unknown
-                type?: unknown
-                filename?: unknown
-              }
-              const normalizedType = String(row.type || '')
-              return {
-                url: String(row.url || ''),
-                type: ['image', 'video', 'pdf', 'file'].includes(normalizedType)
-                  ? (normalizedType as 'image' | 'video' | 'pdf' | 'file')
-                  : 'file',
-                filename: String(row.filename || ''),
-              }
-            })
-            .filter((artifact: { url: string; filename: string }) => artifact.url && artifact.filename)
-            .slice(0, 24)
-        : [],
-      archivedAt: null,
-      attempts: 0,
-      maxAttempts,
-      retryBackoffSec,
-      retryScheduledAt: null,
-      deadLetteredAt: null,
-      checkpoint: null,
-      blockedBy: Array.isArray(body.blockedBy) ? body.blockedBy.filter((s: unknown) => typeof s === 'string') : [],
-      blocks: Array.isArray(body.blocks) ? body.blocks.filter((s: unknown) => typeof s === 'string') : [],
-      tags: Array.isArray(body.tags) ? body.tags.filter((s: unknown) => typeof s === 'string') : [],
-      dueAt: typeof body.dueAt === 'number' ? body.dueAt : null,
-      customFields: body.customFields && typeof body.customFields === 'object' ? body.customFields : undefined,
-      priority: body.priority && ['low', 'medium', 'high', 'critical'].includes(body.priority) ? body.priority : undefined,
-    },
-  })
-  if (!prepared.ok) {
-    return NextResponse.json({ error: prepared.error }, { status: 400 })
-  }
-
-  if (prepared.duplicate) {
-    return NextResponse.json({ ...prepared.duplicate, deduplicated: true })
-  }
-
-  const task = prepared.task
-  if (task.status === 'completed') {
-    const agentExtensions = resolvedAgentId ? getEnabledCapabilityIds(loadAgents()[resolvedAgentId]) : []
-    getExtensionManager().runHook(
-      'onTaskComplete',
-      { taskId: id, result: task.result },
-      { enabledIds: agentExtensions },
-    )
-  }
-
-  // Parent/child hierarchy
-  const parentTaskId = typeof body.parentTaskId === 'string' && body.parentTaskId.trim() ? body.parentTaskId.trim() : null
-  if (parentTaskId) {
-    task.parentTaskId = parentTaskId
-    const parentTask = tasks[parentTaskId]
-    if (parentTask) {
-      const subtaskIds = Array.isArray(parentTask.subtaskIds) ? parentTask.subtaskIds : []
-      if (!subtaskIds.includes(id)) {
-        parentTask.subtaskIds = [...subtaskIds, id]
-        parentTask.updatedAt = now
-        upsertTask(parentTaskId, parentTask)
-      }
-    }
-  }
-
-  upsertTask(id, task)
-  const mission = ensureMissionForTask(task, { source: 'manual' })
-  const finalTask = enrichTaskWithMissionSummary({
-    ...task,
-    missionId: mission?.id || task.missionId || null,
-  })
-  logActivity({ entityType: 'task', entityId: id, action: 'created', actor: 'user', summary: `Task created: "${task.title}"` })
-  pushMainLoopEventToMainSessions({
-    type: 'task_created',
-    text: `Task created: "${task.title}" (${id}) with status ${task.status}.`,
-  })
-  if (task.status === 'queued') {
-    enqueueTask(id)
-  }
-  notify('tasks')
-  return NextResponse.json(finalTask)
+  const result = createTaskFromRoute({ ...raw, ...parsed.data } as Record<string, unknown>)
+  return result.ok
+    ? NextResponse.json(result.payload)
+    : NextResponse.json(result.payload, { status: result.status })
 }

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

@@ -2,8 +2,8 @@ import { NextResponse } from 'next/server'
 import fs from 'fs'
 import path from 'path'
 import { genId } from '@/lib/id'
-import { UPLOAD_DIR } from '@/lib/server/storage'
 import { log } from '@/lib/server/logger'
+import { UPLOAD_DIR } from '@/lib/server/upload-path'
 
 const TAG = 'api-upload'
 

package/src/app/api/uploads/[filename]/route.ts

@@ -2,8 +2,8 @@ import { NextResponse } from 'next/server'
 import { notFound } from '@/lib/server/collection-helpers'
 import fs from 'fs'
 import path from 'path'
-import { UPLOAD_DIR } from '@/lib/server/storage'
 import { MIME_TYPES } from '@/lib/server/mime'
+import { UPLOAD_DIR } from '@/lib/server/upload-path'
 
 export async function GET(_req: Request, { params }: { params: Promise<{ filename: string }> }) {
   const { filename } = await params

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

@@ -2,8 +2,8 @@ import { NextResponse } from 'next/server'
 import fs from 'fs'
 import path from 'path'
 import { safeParseBody } from '@/lib/server/safe-parse-body'
-import { UPLOAD_DIR } from '@/lib/server/storage'
 import { getFileCategory } from '@/lib/server/mime'
+import { UPLOAD_DIR } from '@/lib/server/upload-path'
 
 interface UploadFile {
   name: string

package/src/app/api/webhooks/[id]/history/route.ts

@@ -5,8 +5,8 @@ export async function GET(_req: Request, { params }: { params: Promise<{ id: str
   const { id } = await params
   const allLogs = loadWebhookLogs()
   const entries = Object.values(allLogs)
-    .filter((entry: any) => entry.webhookId === id)
-    .sort((a: any, b: any) => (b.timestamp || 0) - (a.timestamp || 0))
+    .filter((entry) => (entry as Record<string, unknown>).webhookId === id)
+    .sort((a, b) => ((b as Record<string, unknown>).timestamp as number || 0) - ((a as Record<string, unknown>).timestamp as number || 0))
     .slice(0, 100)
 
   return NextResponse.json(entries)

package/src/app/layout.tsx

@@ -2,6 +2,7 @@ import type { Metadata, Viewport } from "next"
 import { TooltipProvider } from "@/components/ui/tooltip"
 import { Toaster } from "@/components/ui/sonner"
 import { DashboardShell } from "@/components/layout/dashboard-shell"
+import { AppQueryProvider } from "@/components/providers/app-query-provider"
 import "./globals.css"
 
 export const metadata: Metadata = {
@@ -28,12 +29,14 @@ export default function RootLayout({
   return (
     <html lang="en" className="dark">
       <body className="antialiased" cz-shortcut-listen="true">
-        <TooltipProvider>
-          <DashboardShell>
-            {children}
-          </DashboardShell>
-          <Toaster />
-        </TooltipProvider>
+        <AppQueryProvider>
+          <TooltipProvider>
+            <DashboardShell>
+              {children}
+            </DashboardShell>
+            <Toaster />
+          </TooltipProvider>
+        </AppQueryProvider>
       </body>
     </html>
   )

package/src/app/protocols/page.tsx

@@ -2,8 +2,19 @@
 
 import { useCallback, useEffect, useMemo, useState } from 'react'
 import { useRouter, useSearchParams } from 'next/navigation'
-import { api } from '@/lib/app/api-client'
-import { useWs } from '@/hooks/use-ws'
+import { useAgentsQuery } from '@/features/agents/queries'
+import { useChatroomsQuery } from '@/features/chatrooms/queries'
+import { useMissionsQuery } from '@/features/missions/queries'
+import {
+  useCreateProtocolRunMutation,
+  useDeleteProtocolTemplateMutation,
+  useProtocolRunActionMutation,
+  useProtocolRunDetailQuery,
+  useProtocolRunsQuery,
+  useProtocolTemplatesQuery,
+  useUpsertProtocolTemplateMutation,
+} from '@/features/protocols/queries'
+import { useTasksQuery } from '@/features/tasks/queries'
 import { MainContent } from '@/components/layout/main-content'
 import { StructuredSessionLauncher } from '@/components/protocols/structured-session-launcher'
 import { timeAgo } from '@/lib/time-format'
@@ -67,10 +78,6 @@ const DEFAULT_TEMPLATE_DRAFT: TemplateDraft = {
   entryStepId: 'present',
 }
 
-async function postRunAction(runId: string, payload: RunActionPayload) {
-  await api('POST', `/protocols/runs/${runId}/actions`, payload)
-}
-
 function toTemplateDraft(template: ProtocolTemplate | null): TemplateDraft {
   if (!template) return DEFAULT_TEMPLATE_DRAFT
   return {
@@ -125,16 +132,7 @@ function splitCsv(value: string): string[] {
 export default function ProtocolsPage() {
   const router = useRouter()
   const searchParams = useSearchParams()
-  const [templates, setTemplates] = useState<ProtocolTemplate[]>([])
-  const [runs, setRuns] = useState<ProtocolRun[]>([])
-  const [detail, setDetail] = useState<ProtocolRunDetail | null>(null)
   const [selectedRunId, setSelectedRunId] = useState<string | null>(null)
-  const [agents, setAgents] = useState<AgentList>({})
-  const [chatrooms, setChatrooms] = useState<Record<string, Chatroom>>({})
-  const [missions, setMissions] = useState<Mission[]>([])
-  const [tasks, setTasks] = useState<Record<string, BoardTask>>({})
-  const [loading, setLoading] = useState(true)
-  const [detailLoading, setDetailLoading] = useState(false)
   const [actionPending, setActionPending] = useState<string | null>(null)
   const [templatePending, setTemplatePending] = useState<string | null>(null)
   const [templateEditorOpen, setTemplateEditorOpen] = useState(false)
@@ -160,66 +158,55 @@ export default function ProtocolsPage() {
     autoStart: true,
   })
   const requestedRunId = searchParams.get('runId')
-
-  const loadRuns = useCallback(async () => {
-    const [templateList, runList, agentList, roomList, missionList, taskList] = await Promise.all([
-      api<ProtocolTemplate[]>('GET', '/protocols/templates'),
-      api<ProtocolRun[]>('GET', '/protocols/runs?limit=120'),
-      api<AgentList>('GET', '/agents'),
-      api<Record<string, Chatroom>>('GET', '/chatrooms'),
-      api<Mission[]>('GET', '/missions?limit=80'),
-      api<Record<string, BoardTask>>('GET', '/tasks'),
-    ])
-    setTemplates(Array.isArray(templateList) ? templateList : [])
-    const normalizedRuns = Array.isArray(runList) ? runList : []
-    setRuns(normalizedRuns)
-    setAgents(agentList || {})
-    setChatrooms(roomList || {})
-    setMissions(Array.isArray(missionList) ? missionList : [])
-    setTasks(taskList || {})
-    setSelectedRunId((current) => {
-      if (current && normalizedRuns.some((run) => run.id === current)) return current
-      return normalizedRuns[0]?.id || null
-    })
-    setLoading(false)
-  }, [])
+  const templatesQuery = useProtocolTemplatesQuery()
+  const runsQuery = useProtocolRunsQuery({ limit: 120 })
+  const agentsQuery = useAgentsQuery()
+  const chatroomsQuery = useChatroomsQuery()
+  const missionsQuery = useMissionsQuery({ limit: 80 })
+  const tasksQuery = useTasksQuery({ includeArchived: true })
+  const detailQuery = useProtocolRunDetailQuery(selectedRunId, { enabled: Boolean(selectedRunId) })
+  const createRunMutation = useCreateProtocolRunMutation()
+  const runActionMutation = useProtocolRunActionMutation()
+  const upsertTemplateMutation = useUpsertProtocolTemplateMutation()
+  const deleteTemplateMutation = useDeleteProtocolTemplateMutation()
+  const templates = templatesQuery.data ?? []
+  const runs = runsQuery.data ?? []
+  const detail = detailQuery.data ?? null
+  const agents = agentsQuery.data ?? {}
+  const chatrooms = chatroomsQuery.data ?? {}
+  const missions = missionsQuery.data ?? []
+  const tasks = tasksQuery.data ?? {}
+  const loading = (
+    templatesQuery.isLoading
+    || runsQuery.isLoading
+    || agentsQuery.isLoading
+    || chatroomsQuery.isLoading
+    || missionsQuery.isLoading
+    || tasksQuery.isLoading
+  )
+  const detailLoading = detailQuery.isLoading || detailQuery.isFetching
+  const queryError = [
+    templatesQuery.error,
+    runsQuery.error,
+    agentsQuery.error,
+    chatroomsQuery.error,
+    missionsQuery.error,
+    tasksQuery.error,
+    detailQuery.error,
+  ].find(Boolean)
+  const resolvedError = error || (queryError instanceof Error ? queryError.message : null)
 
   // Apply URL-requested run selection separately so WS refreshes don't snap back
   useEffect(() => {
     if (requestedRunId) setSelectedRunId(requestedRunId)
   }, [requestedRunId])
 
-  const loadDetail = useCallback(async (runId: string | null) => {
-    if (!runId) {
-      setDetail(null)
-      return
-    }
-    setDetailLoading(true)
-    try {
-      const value = await api<ProtocolRunDetail>('GET', `/protocols/runs/${runId}`)
-      setDetail(value)
-      setError(null)
-    } catch (err) {
-      setError(err instanceof Error ? err.message : 'Unable to load structured session.')
-      setDetail(null)
-    } finally {
-      setDetailLoading(false)
-    }
-  }, [])
-
   useEffect(() => {
-    void loadRuns().catch((err) => {
-      setError(err instanceof Error ? err.message : 'Unable to load structured sessions.')
-      setLoading(false)
+    setSelectedRunId((current) => {
+      if (current && runs.some((run) => run.id === current)) return current
+      return runs[0]?.id || null
     })
-  }, [loadRuns])
-
-  useEffect(() => {
-    void loadDetail(selectedRunId)
-  }, [loadDetail, selectedRunId])
-
-  useWs('protocol_runs', loadRuns, 2000)
-  useWs('protocol_templates', loadRuns, 2000)
+  }, [runs])
 
   const selectedTemplate = useMemo(() => templates.find((template) => template.id === form.templateId) || null, [form.templateId, templates])
   const customTemplates = useMemo(() => templates.filter((template) => !template.builtIn), [templates])
@@ -244,7 +231,7 @@ export default function ProtocolsPage() {
       return
     }
     try {
-      const run = await api<ProtocolRun>('POST', '/protocols/runs', {
+      const run = await createRunMutation.mutateAsync({
         title: form.title.trim(),
         templateId: form.templateId,
         participantAgentIds: form.participantAgentIds,
@@ -269,37 +256,34 @@ export default function ProtocolsPage() {
         decisionMode: '',
       }))
       setSelectedRunId(run.id)
-      await loadRuns()
     } catch (err) {
       setError(err instanceof Error ? err.message : 'Unable to create structured session.')
     }
-  }, [form, loadRuns])
+  }, [createRunMutation, form])
 
   const handleAction = useCallback(async (payload: RunActionPayload) => {
     if (!detail?.run.id) return
     setActionPending(payload.action)
     try {
-      await postRunAction(detail.run.id, payload)
-      await Promise.all([loadRuns(), loadDetail(detail.run.id)])
+      await runActionMutation.mutateAsync({ runId: detail.run.id, payload })
       if (payload.action === 'inject_context') setContextDraft('')
     } catch (err) {
       setError(err instanceof Error ? err.message : 'Unable to update structured session.')
     } finally {
       setActionPending(null)
     }
-  }, [detail, loadDetail, loadRuns])
+  }, [detail, runActionMutation])
 
   const handleBranchAction = useCallback(async (runId: string, payload: RunActionPayload) => {
     setActionPending(`${payload.action}:${runId}`)
     try {
-      await postRunAction(runId, payload)
-      await Promise.all([loadRuns(), detail?.run.id ? loadDetail(detail.run.id) : Promise.resolve()])
+      await runActionMutation.mutateAsync({ runId, payload })
     } catch (err) {
       setError(err instanceof Error ? err.message : 'Unable to update branch run.')
     } finally {
       setActionPending(null)
     }
-  }, [detail?.run.id, loadDetail, loadRuns])
+  }, [runActionMutation])
 
   const openTemplateEditor = useCallback((template: ProtocolTemplate | null = null) => {
     setEditingTemplateId(template?.builtIn ? null : template?.id || null)
@@ -328,27 +312,27 @@ export default function ProtocolsPage() {
         return
       }
       setTemplatePending(editingTemplateId ? 'save-edit' : 'save-new')
-      if (editingTemplateId) {
-        await api('PATCH', `/protocols/templates/${editingTemplateId}`, payload)
-      } else {
-        const created = await api<ProtocolTemplate>('POST', '/protocols/templates', payload)
+      const created = await upsertTemplateMutation.mutateAsync({
+        templateId: editingTemplateId,
+        payload,
+      })
+      if (!editingTemplateId) {
         setForm((current) => ({ ...current, templateId: created.id }))
       }
       setTemplateEditorOpen(false)
       setEditingTemplateId(null)
       setTemplateDraft(DEFAULT_TEMPLATE_DRAFT)
-      await loadRuns()
     } catch (err) {
       setError(err instanceof Error ? err.message : 'Unable to save structured-session template.')
     } finally {
       setTemplatePending(null)
     }
-  }, [editingTemplateId, loadRuns, templateDraft])
+  }, [editingTemplateId, templateDraft, upsertTemplateMutation])
 
   const handleDeleteTemplate = useCallback(async (templateId: string) => {
     setTemplatePending(`delete:${templateId}`)
     try {
-      await api('DELETE', `/protocols/templates/${templateId}`)
+      await deleteTemplateMutation.mutateAsync(templateId)
       setTemplateEditorOpen(false)
       setEditingTemplateId(null)
       setTemplateDraft(DEFAULT_TEMPLATE_DRAFT)
@@ -356,13 +340,12 @@ export default function ProtocolsPage() {
         ...current,
         templateId: current.templateId === templateId ? 'facilitated_discussion' : current.templateId,
       }))
-      await loadRuns()
     } catch (err) {
       setError(err instanceof Error ? err.message : 'Unable to delete structured-session template.')
     } finally {
       setTemplatePending(null)
     }
-  }, [loadRuns])
+  }, [deleteTemplateMutation])
 
   const handleSelectRun = useCallback((runId: string) => {
     setSelectedRunId(runId)
@@ -715,9 +698,9 @@ export default function ProtocolsPage() {
                 )}
               </div>
             </div>
-            {error && (
+            {resolvedError && (
               <div className="mt-4 rounded-[14px] border border-red-500/20 bg-red-500/10 px-4 py-3 text-[13px] text-red-200">
-                {error}
+                {resolvedError}
               </div>
             )}
           </section>
@@ -1272,9 +1255,8 @@ export default function ProtocolsPage() {
         open={launcherOpen}
         onClose={() => setLauncherOpen(false)}
         onCreated={(run) => {
+          setLauncherOpen(false)
           setSelectedRunId(run.id)
-          void loadRuns()
-          void loadDetail(run.id)
           router.push(`/protocols?runId=${encodeURIComponent(run.id)}`)
         }}
         allowContextSelection