@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/stores/use-app-store.ts

@@ -1,826 +1,21 @@
 'use client'
 
 import { create } from 'zustand'
-import type { Sessions, Session, NetworkInfo, Directory, ProviderInfo, Credentials, Agent, Schedule, AppView, BoardTask, AppSettings, OrchestratorSecret, ProviderConfig, Skill, Connector, Webhook, McpServerConfig, PluginMeta, Project, FleetFilter, ActivityEntry, AppNotification, ApprovalRequest, GatewayProfile, ExternalAgentRuntime } from '../types'
-import { fetchChat, fetchChats, fetchDirs, fetchProviders, fetchCredentials } from '../lib/chats'
-import { fetchAgents } from '../lib/agents'
-import { fetchSchedules } from '../lib/schedules'
-import { fetchTasks } from '../lib/tasks'
-import { findLatestObservablePlatformSession, isLocalhostBrowser } from '../lib/local-observability'
-import { api } from '../lib/api-client'
-import { safeStorageGet, safeStorageGetJson, safeStorageRemove, safeStorageSet } from '../lib/safe-storage'
-
-const inflightAgentThreadLoads = new Map<string, Promise<void>>()
-const inflightSessionRefreshes = new Map<string, Promise<void>>()
-
-interface AppState {
-  currentUser: string | null
-  _hydrated: boolean
-  hydrate: () => void
-  setUser: (user: string | null) => void
-
-  sessions: Sessions
-  currentSessionId: string | null
-  loadSessions: () => Promise<void>
-  refreshSession: (id: string) => Promise<void>
-  setCurrentSession: (id: string | null) => void
-  removeSession: (id: string) => void
-  clearSessions: (ids: string[]) => Promise<void>
-  togglePinSession: (id: string) => void
-  updateSessionInStore: (session: Session) => void
-  forkSession: (sessionId: string, messageIndex: number) => Promise<string | null>
-
-  sidebarOpen: boolean
-  setSidebarOpen: (open: boolean) => void
-  toggleSidebar: () => void
-
-  networkInfo: NetworkInfo | null
-  loadNetworkInfo: () => Promise<void>
-
-  dirs: Directory[]
-  loadDirs: () => Promise<void>
-
-  providers: ProviderInfo[]
-  credentials: Credentials
-  loadProviders: () => Promise<void>
-  loadCredentials: () => Promise<void>
-
-  settingsOpen: boolean
-  setSettingsOpen: (open: boolean) => void
-
-  activeView: AppView
-  setActiveView: (view: AppView) => void
-
-  currentAgentId: string | null
-  setCurrentAgent: (id: string | null) => Promise<void>
-
-  agents: Record<string, Agent>
-  loadAgents: () => Promise<void>
-  togglePinAgent: (id: string) => void
-
-  schedules: Record<string, Schedule>
-  loadSchedules: () => Promise<void>
-
-  agentSheetOpen: boolean
-  setAgentSheetOpen: (open: boolean) => void
-  editingAgentId: string | null
-  setEditingAgentId: (id: string | null) => void
-
-  scheduleSheetOpen: boolean
-  setScheduleSheetOpen: (open: boolean) => void
-  editingScheduleId: string | null
-  setEditingScheduleId: (id: string | null) => void
-  scheduleTemplatePrefill: { name: string; taskPrompt: string; scheduleType: 'cron' | 'interval'; cron?: string; intervalMs?: number } | null
-  setScheduleTemplatePrefill: (prefill: { name: string; taskPrompt: string; scheduleType: 'cron' | 'interval'; cron?: string; intervalMs?: number } | null) => void
-
-  memorySheetOpen: boolean
-  setMemorySheetOpen: (open: boolean) => void
-  selectedMemoryId: string | null
-  setSelectedMemoryId: (id: string | null) => void
-  memoryRefreshKey: number
-  triggerMemoryRefresh: () => void
-  memoryAgentFilter: string | null
-  setMemoryAgentFilter: (agentId: string | null) => void
-  memoryTierFilter: 'all' | 'working' | 'durable' | 'archive'
-  setMemoryTierFilter: (tier: 'all' | 'working' | 'durable' | 'archive') => void
-  memoryScopeFilter: 'all' | 'global' | 'agent' | 'session' | 'project'
-  setMemoryScopeFilter: (scope: 'all' | 'global' | 'agent' | 'session' | 'project') => void
-
-  appSettings: AppSettings
-  loadSettings: () => Promise<void>
-  updateSettings: (patch: Partial<AppSettings>) => Promise<void>
-
-  secrets: Record<string, OrchestratorSecret>
-  loadSecrets: () => Promise<void>
-  secretSheetOpen: boolean
-  setSecretSheetOpen: (open: boolean) => void
-  editingSecretId: string | null
-  setEditingSecretId: (id: string | null) => void
-
-  tasks: Record<string, BoardTask>
-  loadTasks: (includeArchived?: boolean) => Promise<void>
-  optimisticUpdateTask: (taskId: string, patch: Partial<BoardTask>) => Promise<boolean>
-  optimisticDeleteTask: (taskId: string) => Promise<boolean>
-  showArchivedTasks: boolean
-  setShowArchivedTasks: (show: boolean) => void
-  taskSheetOpen: boolean
-  setTaskSheetOpen: (open: boolean) => void
-  editingTaskId: string | null
-  setEditingTaskId: (id: string | null) => void
-  taskSheetViewOnly: boolean
-  setTaskSheetViewOnly: (v: boolean) => void
-
-  // Provider configs (custom providers)
-  providerConfigs: ProviderConfig[]
-  loadProviderConfigs: () => Promise<void>
-  providerSheetOpen: boolean
-  setProviderSheetOpen: (open: boolean) => void
-  editingProviderId: string | null
-  setEditingProviderId: (id: string | null) => void
-
-  gatewayProfiles: GatewayProfile[]
-  loadGatewayProfiles: () => Promise<void>
-  gatewaySheetOpen: boolean
-  setGatewaySheetOpen: (open: boolean) => void
-  editingGatewayId: string | null
-  setEditingGatewayId: (id: string | null) => void
-
-  // Skills
-  skills: Record<string, Skill>
-  loadSkills: () => Promise<void>
-  skillSheetOpen: boolean
-  setSkillSheetOpen: (open: boolean) => void
-  editingSkillId: string | null
-  setEditingSkillId: (id: string | null) => void
-
-  // Connectors
-  connectors: Record<string, Connector>
-  loadConnectors: () => Promise<void>
-  connectorSheetOpen: boolean
-  setConnectorSheetOpen: (open: boolean) => void
-  editingConnectorId: string | null
-  setEditingConnectorId: (id: string | null) => void
-
-  // Webhooks
-  webhooks: Record<string, Webhook>
-  loadWebhooks: () => Promise<void>
-  webhookSheetOpen: boolean
-  setWebhookSheetOpen: (open: boolean) => void
-  editingWebhookId: string | null
-  setEditingWebhookId: (id: string | null) => void
-
-  // MCP Servers
-  mcpServers: Record<string, McpServerConfig>
-  loadMcpServers: () => Promise<void>
-  mcpServerSheetOpen: boolean
-  setMcpServerSheetOpen: (open: boolean) => void
-  editingMcpServerId: string | null
-  setEditingMcpServerId: (id: string | null) => void
-
-  // Knowledge Base
-  knowledgeSheetOpen: boolean
-  setKnowledgeSheetOpen: (open: boolean) => void
-  editingKnowledgeId: string | null
-  setEditingKnowledgeId: (id: string | null) => void
-  knowledgeRefreshKey: number
-  triggerKnowledgeRefresh: () => void
-
-  // Plugins
-  plugins: Record<string, PluginMeta>
-  loadPlugins: () => Promise<void>
-  pluginSheetOpen: boolean
-  setPluginSheetOpen: (open: boolean) => void
-  editingPluginFilename: string | null
-  setEditingPluginFilename: (filename: string | null) => void
-
-  // Projects
-  projects: Record<string, Project>
-  loadProjects: () => Promise<void>
-  projectSheetOpen: boolean
-  setProjectSheetOpen: (open: boolean) => void
-  editingProjectId: string | null
-  setEditingProjectId: (id: string | null) => void
-  activeProjectFilter: string | null
-  setActiveProjectFilter: (id: string | null) => void
-
-  // Agent trash
-  trashedAgents: Record<string, Agent>
-  loadTrashedAgents: () => Promise<void>
-  showTrash: boolean
-  setShowTrash: (show: boolean) => void
-
-  // Inspector panel
-  inspectorOpen: boolean
-  setInspectorOpen: (open: boolean) => void
-  inspectorTab: 'overview' | 'files' | 'skills' | 'automations' | 'advanced'
-  setInspectorTab: (tab: 'overview' | 'files' | 'skills' | 'automations' | 'advanced') => void
-
-  // Fleet sidebar filter (F16)
-  fleetFilter: FleetFilter
-  setFleetFilter: (filter: FleetFilter) => void
-
-  // Chat list filter
-  chatFilter: 'all' | 'active' | 'recent'
-  setChatFilter: (filter: 'all' | 'active' | 'recent') => void
-
-  // Activity / Audit Trail
-  activityEntries: ActivityEntry[]
-  loadActivity: (filters?: { entityType?: string; limit?: number }) => Promise<void>
-
-  // Unread tracking (localStorage-backed)
-  lastReadTimestamps: Record<string, number>
-  markChatRead: (id: string) => void
-
-  // Approvals
-  approvals: Record<string, ApprovalRequest>
-  loadApprovals: () => Promise<void>
-  submitApprovalDecision: (id: string, approved: boolean) => Promise<void>
-
-  // Notifications
-  notifications: AppNotification[]
-  unreadNotificationCount: number
-  loadNotifications: () => Promise<void>
-  markNotificationRead: (id: string) => Promise<void>
-  markAllNotificationsRead: () => Promise<void>
-  clearReadNotifications: () => Promise<void>
-
-  // Wallets
-  walletPanelAgentId: string | null
-  setWalletPanelAgentId: (id: string | null) => void
-
-  externalAgents: ExternalAgentRuntime[]
-  loadExternalAgents: () => Promise<void>
-
-}
-
-export const useAppStore = create<AppState>((set, get) => ({
-  currentUser: null,
-  _hydrated: false,
-  hydrate: () => {
-    const user = safeStorageGet('sc_user')
-    const savedAgentId = safeStorageGet('sc_agent')
-    set({ currentUser: user, currentAgentId: savedAgentId, _hydrated: true })
-  },
-  setUser: (user) => {
-    if (user) safeStorageSet('sc_user', user)
-    else safeStorageRemove('sc_user')
-    set({ currentUser: user })
-  },
-
-  sessions: {},
-  currentSessionId: null,
-  loadSessions: async () => {
-    try {
-      const sessions = await fetchChats()
-      const currentSessionId = get().currentSessionId
-      set({
-        sessions,
-        currentSessionId: currentSessionId && sessions[currentSessionId] ? currentSessionId : null,
-      })
-    } catch {
-      // ignore
-    }
-  },
-  refreshSession: async (id) => {
-    if (!id) return
-    const existing = inflightSessionRefreshes.get(id)
-    if (existing) {
-      await existing
-      return
-    }
-
-    const refreshPromise = (async () => {
-      try {
-        const session = await fetchChat(id)
-        const currentSessionId = get().currentSessionId
-        set({
-          sessions: { ...get().sessions, [id]: session },
-          currentSessionId: currentSessionId && currentSessionId === id ? id : currentSessionId,
-        })
-      } catch {
-        // ignore
-      }
-    })()
-
-    inflightSessionRefreshes.set(id, refreshPromise)
-    try {
-      await refreshPromise
-    } finally {
-      if (inflightSessionRefreshes.get(id) === refreshPromise) {
-        inflightSessionRefreshes.delete(id)
-      }
-    }
-  },
-  setCurrentSession: (id) => set({ currentSessionId: id }),
-  removeSession: (id) => {
-    const sessions = { ...get().sessions }
-    delete sessions[id]
-    set({ sessions, currentSessionId: get().currentSessionId === id ? null : get().currentSessionId })
-  },
-  clearSessions: async (ids) => {
-    if (!ids.length) return
-    await api('DELETE', '/chats', { ids })
-    const sessions = { ...get().sessions }
-    for (const id of ids) delete sessions[id]
-    set({ sessions, currentSessionId: ids.includes(get().currentSessionId!) ? null : get().currentSessionId })
-  },
-  togglePinSession: (id) => {
-    const sessions = { ...get().sessions }
-    if (sessions[id]) {
-      sessions[id] = { ...sessions[id], pinned: !sessions[id].pinned }
-      set({ sessions })
-      // Persist to server
-      void api('PUT', `/chats/${id}`, { pinned: sessions[id].pinned })
-    }
-  },
-  updateSessionInStore: (session) => {
-    set({ sessions: { ...get().sessions, [session.id]: session } })
-  },
-  forkSession: async (sessionId, messageIndex) => {
-    try {
-      const forked = await api<Session>('POST', `/chats/${sessionId}/fork`, { messageIndex })
-      if (!forked?.id) return null
-      await get().loadSessions()
-      set({ currentSessionId: forked.id })
-      return forked.id
-    } catch (err: unknown) {
-      console.error('Fork failed:', err instanceof Error ? err.message : String(err))
-      return null
-    }
-  },
-
-  sidebarOpen: false,
-  setSidebarOpen: (open) => set({ sidebarOpen: open }),
-  toggleSidebar: () => set((s) => ({ sidebarOpen: !s.sidebarOpen })),
-
-  networkInfo: null,
-  loadNetworkInfo: async () => {
-    try {
-      const info = await api<NetworkInfo>('GET', '/ip')
-      set({ networkInfo: info })
-    } catch {
-      // ignore
-    }
-  },
-
-  dirs: [],
-  loadDirs: async () => {
-    try {
-      const dirs = await fetchDirs()
-      set({ dirs })
-    } catch {
-      set({ dirs: [] })
-    }
-  },
-
-  providers: [],
-  credentials: {},
-  loadProviders: async () => {
-    try {
-      const providers = await fetchProviders()
-      set({ providers })
-    } catch {
-      // ignore
-    }
-  },
-  loadCredentials: async () => {
-    try {
-      const credentials = await fetchCredentials()
-      set({ credentials })
-    } catch {
-      // ignore
-    }
-  },
-
-  settingsOpen: false,
-  setSettingsOpen: (open) => set({ settingsOpen: open }),
-
-  activeView: 'home',
-  setActiveView: (view) => set({ activeView: view }),
-
-  currentAgentId: null,
-  setCurrentAgent: async (id) => {
-    if (!id) {
-      set({ currentAgentId: null })
-      safeStorageRemove('sc_agent')
-      return
-    }
-    const currentState = get()
-    const currentSession = currentState.currentSessionId ? currentState.sessions[currentState.currentSessionId] : null
-    if (currentState.currentAgentId === id && currentSession?.agentId === id) {
-      return
-    }
-    set({ currentAgentId: id })
-    safeStorageSet('sc_agent', id)
-    if (isLocalhostBrowser()) {
-      const livePlatformSession = findLatestObservablePlatformSession(get().sessions, id)
-      if (livePlatformSession?.id) {
-        set({ currentSessionId: livePlatformSession.id })
-        return
-      }
-    }
-
-    const existingLoad = inflightAgentThreadLoads.get(id)
-    if (existingLoad) {
-      await existingLoad
-      return
-    }
-
-    const loadPromise = (async () => {
-      try {
-        const user = get().currentUser || 'default'
-        const session = await api<Session>('POST', `/agents/${id}/thread`, { user })
-        if (session?.id) {
-          const sessions = { ...get().sessions, [session.id]: session }
-          set({ sessions, currentSessionId: session.id })
-        }
-      } catch {
-        // ignore — thread creation failed
-      }
-    })()
-
-    inflightAgentThreadLoads.set(id, loadPromise)
-    try {
-      await loadPromise
-    } finally {
-      if (inflightAgentThreadLoads.get(id) === loadPromise) {
-        inflightAgentThreadLoads.delete(id)
-      }
-    }
-  },
-
-  agents: {},
-  loadAgents: async () => {
-    try {
-      const agents = await fetchAgents()
-      set({ agents })
-    } catch {
-      // ignore
-    }
-  },
-  togglePinAgent: (id) => {
-    const agents = { ...get().agents }
-    if (agents[id]) {
-      agents[id] = { ...agents[id], pinned: !agents[id].pinned }
-      set({ agents })
-      void api('PUT', `/agents/${id}`, { pinned: agents[id].pinned })
-    }
-  },
-
-  schedules: {},
-  loadSchedules: async () => {
-    try {
-      const schedules = await fetchSchedules()
-      set({ schedules })
-    } catch {
-      // ignore
-    }
-  },
-
-  agentSheetOpen: false,
-  setAgentSheetOpen: (open) => set({ agentSheetOpen: open }),
-  editingAgentId: null,
-  setEditingAgentId: (id) => set({ editingAgentId: id }),
-
-  scheduleSheetOpen: false,
-  setScheduleSheetOpen: (open) => set({ scheduleSheetOpen: open }),
-  editingScheduleId: null,
-  setEditingScheduleId: (id) => set({ editingScheduleId: id }),
-  scheduleTemplatePrefill: null,
-  setScheduleTemplatePrefill: (prefill) => set({ scheduleTemplatePrefill: prefill }),
-
-  memorySheetOpen: false,
-  setMemorySheetOpen: (open) => set({ memorySheetOpen: open }),
-  selectedMemoryId: null,
-  setSelectedMemoryId: (id) => set({ selectedMemoryId: id }),
-  memoryRefreshKey: 0,
-  triggerMemoryRefresh: () => set((s) => ({ memoryRefreshKey: s.memoryRefreshKey + 1 })),
-  memoryAgentFilter: null,
-  setMemoryAgentFilter: (agentId) => set({ memoryAgentFilter: agentId }),
-  memoryTierFilter: 'all',
-  setMemoryTierFilter: (tier) => set({ memoryTierFilter: tier }),
-  memoryScopeFilter: 'all',
-  setMemoryScopeFilter: (scope) => set({ memoryScopeFilter: scope }),
-
-  appSettings: {},
-  loadSettings: async () => {
-    try {
-      const settings = await api<AppSettings>('GET', '/settings')
-      set({ appSettings: settings })
-    } catch {
-      // ignore
-    }
-  },
-  updateSettings: async (patch) => {
-    try {
-      const settings = await api<AppSettings>('PUT', '/settings', patch)
-      set({ appSettings: settings })
-    } catch {
-      // ignore
-    }
-  },
-
-  secrets: {},
-  loadSecrets: async () => {
-    try {
-      const secrets = await api<Record<string, OrchestratorSecret>>('GET', '/secrets')
-      set({ secrets })
-    } catch {
-      // ignore
-    }
-  },
-  secretSheetOpen: false,
-  setSecretSheetOpen: (open) => set({ secretSheetOpen: open }),
-  editingSecretId: null,
-  setEditingSecretId: (id) => set({ editingSecretId: id }),
-
-  tasks: {},
-  loadTasks: async (includeArchived) => {
-    try {
-      const show = includeArchived ?? get().showArchivedTasks
-      const tasks = await fetchTasks(show)
-      set({ tasks })
-    } catch {
-      // ignore
-    }
-  },
-  optimisticUpdateTask: async (taskId, patch) => {
-    const prev = get().tasks[taskId]
-    if (!prev) return false
-    set({ tasks: { ...get().tasks, [taskId]: { ...prev, ...patch, updatedAt: Date.now() } } })
-    try {
-      await api('PUT', `/tasks/${taskId}`, patch)
-      return true
-    } catch {
-      set({ tasks: { ...get().tasks, [taskId]: prev } })
-      return false
-    }
-  },
-  optimisticDeleteTask: async (taskId) => {
-    const prev = get().tasks[taskId]
-    if (!prev) return false
-    const next = { ...get().tasks }
-    delete next[taskId]
-    set({ tasks: next })
-    try {
-      await api('DELETE', `/tasks/${taskId}`)
-      return true
-    } catch {
-      set({ tasks: { ...get().tasks, [taskId]: prev } })
-      return false
-    }
-  },
-  showArchivedTasks: false,
-  setShowArchivedTasks: (show) => {
-    set({ showArchivedTasks: show })
-    get().loadTasks(show)
-  },
-  taskSheetOpen: false,
-  setTaskSheetOpen: (open) => set({ taskSheetOpen: open, ...(open ? {} : { taskSheetViewOnly: false }) }),
-  editingTaskId: null,
-  setEditingTaskId: (id) => set({ editingTaskId: id }),
-  taskSheetViewOnly: false,
-  setTaskSheetViewOnly: (v) => set({ taskSheetViewOnly: v }),
-
-  // Provider configs (custom providers)
-  providerConfigs: [],
-  loadProviderConfigs: async () => {
-    try {
-      const configs = await api<ProviderConfig[]>('GET', '/providers/configs')
-      set({ providerConfigs: configs })
-    } catch {
-      // ignore
-    }
-  },
-  providerSheetOpen: false,
-  setProviderSheetOpen: (open) => set({ providerSheetOpen: open }),
-  editingProviderId: null,
-  setEditingProviderId: (id) => set({ editingProviderId: id }),
-
-  gatewayProfiles: [],
-  loadGatewayProfiles: async () => {
-    try {
-      const gatewayProfiles = await api<GatewayProfile[]>('GET', '/gateways')
-      set({ gatewayProfiles })
-    } catch {
-      // ignore
-    }
-  },
-  gatewaySheetOpen: false,
-  setGatewaySheetOpen: (open) => set({ gatewaySheetOpen: open }),
-  editingGatewayId: null,
-  setEditingGatewayId: (id) => set({ editingGatewayId: id }),
-
-  // Skills
-  skills: {},
-  loadSkills: async () => {
-    try {
-      const skills = await api<Record<string, Skill>>('GET', '/skills')
-      set({ skills })
-    } catch {
-      // ignore
-    }
-  },
-  skillSheetOpen: false,
-  setSkillSheetOpen: (open) => set({ skillSheetOpen: open }),
-  editingSkillId: null,
-  setEditingSkillId: (id) => set({ editingSkillId: id }),
-
-  // Connectors
-  connectors: {},
-  loadConnectors: async () => {
-    try {
-      const connectors = await api<Record<string, Connector>>('GET', '/connectors')
-      set({ connectors })
-    } catch {
-      // ignore
-    }
-  },
-  connectorSheetOpen: false,
-  setConnectorSheetOpen: (open) => set({ connectorSheetOpen: open }),
-  editingConnectorId: null,
-  setEditingConnectorId: (id) => set({ editingConnectorId: id }),
-
-  // Webhooks
-  webhooks: {},
-  loadWebhooks: async () => {
-    try {
-      const webhooks = await api<Record<string, Webhook>>('GET', '/webhooks')
-      set({ webhooks })
-    } catch {
-      // ignore
-    }
-  },
-  webhookSheetOpen: false,
-  setWebhookSheetOpen: (open) => set({ webhookSheetOpen: open }),
-  editingWebhookId: null,
-  setEditingWebhookId: (id) => set({ editingWebhookId: id }),
-
-  // MCP Servers
-  mcpServers: {},
-  loadMcpServers: async () => {
-    try {
-      const mcpServers = await api<Record<string, McpServerConfig>>('GET', '/mcp-servers')
-      set({ mcpServers })
-    } catch {
-      // ignore
-    }
-  },
-  mcpServerSheetOpen: false,
-  setMcpServerSheetOpen: (open) => set({ mcpServerSheetOpen: open }),
-  editingMcpServerId: null,
-  setEditingMcpServerId: (id) => set({ editingMcpServerId: id }),
-
-  // Knowledge Base
-  knowledgeSheetOpen: false,
-  setKnowledgeSheetOpen: (open) => set({ knowledgeSheetOpen: open }),
-  editingKnowledgeId: null,
-  setEditingKnowledgeId: (id) => set({ editingKnowledgeId: id }),
-  knowledgeRefreshKey: 0,
-  triggerKnowledgeRefresh: () => set((s) => ({ knowledgeRefreshKey: s.knowledgeRefreshKey + 1 })),
-
-  // Plugins
-  plugins: {},
-  loadPlugins: async () => {
-    try {
-      const list = await api<PluginMeta[]>('GET', '/plugins')
-      const plugins: Record<string, PluginMeta> = {}
-      for (const p of list) plugins[p.filename] = p
-      set({ plugins })
-    } catch {
-      // ignore
-    }
-  },
-  pluginSheetOpen: false,
-  setPluginSheetOpen: (open) => set({ pluginSheetOpen: open }),
-  editingPluginFilename: null,
-  setEditingPluginFilename: (filename) => set({ editingPluginFilename: filename }),
-
-  // Projects
-  projects: {},
-  loadProjects: async () => {
-    try {
-      const projects = await api<Record<string, Project>>('GET', '/projects')
-      set({ projects })
-    } catch {
-      // ignore
-    }
-  },
-  projectSheetOpen: false,
-  setProjectSheetOpen: (open) => set({ projectSheetOpen: open }),
-  editingProjectId: null,
-  setEditingProjectId: (id) => set({ editingProjectId: id }),
-  activeProjectFilter: null,
-  setActiveProjectFilter: (id) => set({ activeProjectFilter: id }),
-
-  // Agent trash
-  trashedAgents: {},
-  loadTrashedAgents: async () => {
-    try {
-      const trashedAgents = await api<Record<string, Agent>>('GET', '/agents/trash')
-      set({ trashedAgents })
-    } catch {
-      // ignore
-    }
-  },
-  showTrash: false,
-  setShowTrash: (show) => set({ showTrash: show }),
-
-  // Inspector panel
-  inspectorOpen: false,
-  setInspectorOpen: (open) => set({ inspectorOpen: open }),
-  inspectorTab: 'overview',
-  setInspectorTab: (tab) => set({ inspectorTab: tab }),
-
-  // Fleet sidebar filter (persisted to localStorage)
-  fleetFilter: (safeStorageGet('sc_fleet_filter') as FleetFilter) || 'all',
-  setFleetFilter: (filter) => { safeStorageSet('sc_fleet_filter', filter); set({ fleetFilter: filter }) },
-
-  // Chat list filter
-  chatFilter: 'all' as const,
-  setChatFilter: (filter) => set({ chatFilter: filter }),
-
-  // Activity / Audit Trail
-  activityEntries: [],
-  loadActivity: async (filters) => {
-    try {
-      const params = new URLSearchParams()
-      if (filters?.entityType) params.set('entityType', filters.entityType)
-      if (filters?.limit) params.set('limit', String(filters.limit))
-      const qs = params.toString()
-      const entries = await api<ActivityEntry[]>('GET', `/activity${qs ? `?${qs}` : ''}`)
-      set({ activityEntries: entries })
-    } catch {
-      // ignore
-    }
-  },
-
-  // Unread tracking
-  lastReadTimestamps: safeStorageGetJson<Record<string, number>>('sc_last_read', {}),
-  markChatRead: (id) => {
-    const ts = { ...get().lastReadTimestamps, [id]: Date.now() }
-    set({ lastReadTimestamps: ts })
-    safeStorageSet('sc_last_read', JSON.stringify(ts))
-  },
-
-  // Approvals
-  approvals: {},
-  loadApprovals: async () => {
-    try {
-      const list = await api<ApprovalRequest[]>('GET', '/approvals')
-      const approvals: Record<string, ApprovalRequest> = {}
-      for (const a of list) approvals[a.id] = a
-      set({ approvals })
-    } catch { /* ignore */ }
-  },
-  submitApprovalDecision: async (id, approved) => {
-    try {
-      await api('POST', '/approvals', { id, approved })
-      await get().loadApprovals()
-    } catch { /* ignore */ }
-  },
-
-  // Notifications
-  notifications: [],
-  unreadNotificationCount: 0,
-  loadNotifications: async () => {
-    try {
-      const notifications = await api<AppNotification[]>('GET', '/notifications')
-      set({
-        notifications,
-        unreadNotificationCount: notifications.filter((n) => !n.read).length,
-      })
-    } catch {
-      // ignore
-    }
-  },
-  markNotificationRead: async (id) => {
-    const notifications = get().notifications.map((n) =>
-      n.id === id ? { ...n, read: true } : n,
-    )
-    set({
-      notifications,
-      unreadNotificationCount: notifications.filter((n) => !n.read).length,
-    })
-    try {
-      await api('PUT', `/notifications/${id}`, { read: true })
-    } catch {
-      // ignore
-    }
-  },
-  markAllNotificationsRead: async () => {
-    const notifications = get().notifications.map((n) => ({ ...n, read: true }))
-    set({ notifications, unreadNotificationCount: 0 })
-    try {
-      await Promise.all(
-        get().notifications.filter((n) => !n.read).map((n) => api('PUT', `/notifications/${n.id}`, { read: true })),
-      )
-    } catch {
-      // ignore
-    }
-  },
-  clearReadNotifications: async () => {
-    const notifications = get().notifications.filter((n) => !n.read)
-    set({ notifications, unreadNotificationCount: notifications.length })
-    try {
-      await api('DELETE', '/notifications')
-    } catch {
-      // ignore
-    }
-  },
-
-  // Wallets
-  walletPanelAgentId: null,
-  setWalletPanelAgentId: (id) => set({ walletPanelAgentId: id }),
-
-  externalAgents: [],
-  loadExternalAgents: async () => {
-    try {
-      const externalAgents = await api<ExternalAgentRuntime[]>('GET', '/external-agents')
-      set({ externalAgents })
-    } catch {
-      // ignore
-    }
-  },
-
+import type { AuthSlice, SessionSlice, UiSlice, AgentSlice, TaskSlice, DataSlice } from './slices'
+import { createAuthSlice } from './slices/auth-slice'
+import { createSessionSlice } from './slices/session-slice'
+import { createUiSlice } from './slices/ui-slice'
+import { createAgentSlice } from './slices/agent-slice'
+import { createTaskSlice } from './slices/task-slice'
+import { createDataSlice } from './slices/data-slice'
+
+export type AppState = AuthSlice & SessionSlice & UiSlice & AgentSlice & TaskSlice & DataSlice
+
+export const useAppStore = create<AppState>()((...a) => ({
+  ...createAuthSlice(...a),
+  ...createSessionSlice(...a),
+  ...createUiSlice(...a),
+  ...createAgentSlice(...a),
+  ...createTaskSlice(...a),
+  ...createDataSlice(...a)
 }))