@swarmclawai/swarmclaw 1.2.3 → 1.2.5

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

package/src/app/tasks/page.tsx

@@ -2,8 +2,15 @@
 
 import { useEffect, useCallback, useState, useRef, useMemo } from 'react'
 import { useAppStore } from '@/stores/use-app-store'
-import { useWs } from '@/hooks/use-ws'
-import { updateTask, bulkUpdateTasks, importGitHubIssues, type GitHubIssueImportResult } from '@/lib/tasks'
+import { useAgentsQuery } from '@/features/agents/queries'
+import { useProjectsQuery } from '@/features/projects/queries'
+import {
+  useBulkUpdateTasksMutation,
+  useImportGitHubIssuesMutation,
+  useTasksQuery,
+  useUpdateTaskMutation,
+  type GitHubIssueImportResult,
+} from '@/features/tasks/queries'
 import { TaskColumn } from '@/components/tasks/task-column'
 import { TaskCard } from '@/components/tasks/task-card'
 import { Skeleton } from '@/components/shared/skeleton'
@@ -63,18 +70,18 @@ function attentionRank(task: BoardTask, now: number | null): number {
 
 export default function TasksPage() {
   const now = useNow()
-  const tasks = useAppStore((s) => s.tasks)
-  const loadTasks = useAppStore((s) => s.loadTasks)
-  const loadAgents = useAppStore((s) => s.loadAgents)
   const setTaskSheetOpen = useAppStore((s) => s.setTaskSheetOpen)
   const setEditingTaskId = useAppStore((s) => s.setEditingTaskId)
-  const agents = useAppStore((s) => s.agents)
-  const projects = useAppStore((s) => s.projects)
-  const loadProjects = useAppStore((s) => s.loadProjects)
   const activeProjectFilter = useAppStore((s) => s.activeProjectFilter)
   const setActiveProjectFilter = useAppStore((s) => s.setActiveProjectFilter)
   const showArchived = useAppStore((s) => s.showArchivedTasks)
   const setShowArchived = useAppStore((s) => s.setShowArchivedTasks)
+  const { data: tasks = {}, isLoading: tasksLoading } = useTasksQuery({ includeArchived: true })
+  const { data: agents = {}, isLoading: agentsLoading } = useAgentsQuery()
+  const { data: projects = {}, isLoading: projectsLoading } = useProjectsQuery()
+  const bulkUpdateTasksMutation = useBulkUpdateTasksMutation()
+  const updateTaskMutation = useUpdateTaskMutation()
+  const importGitHubIssuesMutation = useImportGitHubIssuesMutation()
 
   // Bulk selection
   const [selectedIds, setSelectedIds] = useState<Set<string>>(new Set())
@@ -97,8 +104,7 @@ export default function TasksPage() {
     if (selectedIds.size === 0) return
     setBulkActing(true)
     try {
-      await bulkUpdateTasks([...selectedIds], { status })
-      await loadTasks()
+      await bulkUpdateTasksMutation.mutateAsync({ ids: [...selectedIds], patch: { status } })
       toast.success(`Moved ${selectedIds.size} task(s) to ${status}`)
       clearSelection()
     } catch {
@@ -106,15 +112,13 @@ export default function TasksPage() {
     } finally {
       setBulkActing(false)
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [selectedIds])
+  }, [bulkUpdateTasksMutation, clearSelection, selectedIds])
 
   const handleBulkAgent = useCallback(async (agentId: string) => {
     if (selectedIds.size === 0) return
     setBulkActing(true)
     try {
-      await bulkUpdateTasks([...selectedIds], { agentId })
-      await loadTasks()
+      await bulkUpdateTasksMutation.mutateAsync({ ids: [...selectedIds], patch: { agentId } })
       const name = agents[agentId]?.name || 'agent'
       toast.success(`Assigned ${selectedIds.size} task(s) to ${name}`)
       clearSelection()
@@ -123,15 +127,13 @@ export default function TasksPage() {
     } finally {
       setBulkActing(false)
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [selectedIds, agents])
+  }, [agents, bulkUpdateTasksMutation, clearSelection, selectedIds])
 
   const handleBulkProject = useCallback(async (projectId: string | null) => {
     if (selectedIds.size === 0) return
     setBulkActing(true)
     try {
-      await bulkUpdateTasks([...selectedIds], { projectId })
-      await loadTasks()
+      await bulkUpdateTasksMutation.mutateAsync({ ids: [...selectedIds], patch: { projectId } })
       toast.success(projectId ? `Assigned ${selectedIds.size} task(s) to project` : `Cleared project from ${selectedIds.size} task(s)`)
       clearSelection()
     } catch {
@@ -139,8 +141,7 @@ export default function TasksPage() {
     } finally {
       setBulkActing(false)
     }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [selectedIds])
+  }, [bulkUpdateTasksMutation, clearSelection, selectedIds])
 
   // Bulk action bar dropdowns
   const [bulkAgentOpen, setBulkAgentOpen] = useState(false)
@@ -196,11 +197,7 @@ export default function TasksPage() {
     window.history.replaceState(null, '', newUrl)
   }, [activeProjectFilter, filterAgentId, filterTag, filtersHydrated, taskScopeFilter])
 
-  const [loaded, setLoaded] = useState(Object.keys(tasks).length > 0)
-  useEffect(() => {
-    Promise.all([loadTasks(), loadAgents(), loadProjects()]).then(() => setLoaded(true))
-  }, [loadAgents, loadProjects, loadTasks])
-  useWs('tasks', loadTasks, 5000)
+  const loaded = !tasksLoading && !agentsLoading && !projectsLoading
 
   // Collect all unique tags across tasks
   const allTags = dedup(Object.values(tasks).flatMap((t) => t.tags || [])).sort()
@@ -259,10 +256,8 @@ export default function TasksPage() {
   const handleDrop = useCallback(async (taskId: string, newStatus: BoardTaskStatus) => {
     const task = tasks[taskId]
     if (!task || task.status === newStatus) return
-    await updateTask(taskId, { status: newStatus })
-    await loadTasks()
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [tasks])
+    await updateTaskMutation.mutateAsync({ id: taskId, patch: { status: newStatus } })
+  }, [tasks, updateTaskMutation])
 
   const archivedCount = Object.values(tasks).filter((t) => t.status === 'archived').length
 
@@ -284,7 +279,7 @@ export default function TasksPage() {
     try {
       const rawLimit = Number.parseInt(githubLimit, 10)
       const limit = Number.isFinite(rawLimit) ? Math.max(1, Math.min(rawLimit, 200)) : 25
-      const result = await importGitHubIssues({
+      const result = await importGitHubIssuesMutation.mutateAsync({
         repo: githubRepo.trim(),
         token: githubToken.trim() || undefined,
         state: githubState,
@@ -296,7 +291,6 @@ export default function TasksPage() {
         projectId: activeProjectFilter,
       })
       setGitHubImportResult(result)
-      await loadTasks()
       const summary = result.created.length > 0
         ? `Imported ${result.created.length} issue(s) from ${result.repo}`
         : `No new issues imported from ${result.repo}`
@@ -316,7 +310,7 @@ export default function TasksPage() {
     githubRepo,
     githubState,
     githubToken,
-    loadTasks,
+    importGitHubIssuesMutation,
   ])
 
   // Task counts per project (non-archived)
@@ -759,6 +753,9 @@ export default function TasksPage() {
                 <TaskColumn
                   status={status}
                   tasks={tasksByStatus(status)}
+                  agents={agents}
+                  projects={projects}
+                  tasksById={tasks}
                   onDrop={handleDrop}
                   selectionMode={selectionMode}
                   selectedIds={selectedIds}
@@ -804,6 +801,9 @@ export default function TasksPage() {
                   <TaskCard
                     key={task.id}
                     task={task}
+                    agents={agents}
+                    projects={projects}
+                    tasksById={tasks}
                     index={idx}
                     selectionMode={selectionMode}
                     selected={selectedIds.has(task.id)}

package/src/cli/index.js

@@ -596,6 +596,7 @@ const COMMAND_GROUPS = [
         defaultBody: { action: 'status' },
       }),
       cmd('checkpoints', 'GET', '/chats/:id/checkpoints', 'List checkpoint history for a chat'),
+      cmd('migrate-messages', 'POST', '/chats/migrate-messages', 'Migrate messages from session blobs to relational table'),
     ],
   },
   {

package/src/cli/spec.js

@@ -428,6 +428,7 @@ const COMMAND_GROUPS = {
       delete: { description: 'Delete one chat', method: 'DELETE', path: '/chats/:id', params: ['id'] },
       'delete-many': { description: 'Delete multiple chats (body: {"ids":[...]})', method: 'DELETE', path: '/chats' },
       'heartbeat-disable-all': { description: 'Disable all chat heartbeats and cancel queued heartbeat runs', method: 'POST', path: '/chats/heartbeat' },
+      'migrate-messages': { description: 'Migrate messages from session blobs to relational table', method: 'POST', path: '/chats/migrate-messages' },
       messages: { description: 'Get chat message history', method: 'GET', path: '/chats/:id/messages', params: ['id'] },
       'messages-update': { description: 'Update chat message metadata (e.g. bookmark)', method: 'PUT', path: '/chats/:id/messages', params: ['id'] },
       'messages-send': { description: 'Append a user/system message to a chat', method: 'POST', path: '/chats/:id/messages', params: ['id'] },