@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/stores/slices/data-slice.ts

@@ -0,0 +1,301 @@
+import { StateCreator } from 'zustand'
+import type { AppState } from '../use-app-store'
+import type { NetworkInfo, Directory, ProviderInfo, Credentials, Schedule, AppSettings, OrchestratorSecret, ProviderConfig, Skill, Connector, Webhook, McpServerConfig, PluginMeta, Project, ActivityEntry, AppNotification, ApprovalRequest, GatewayProfile } from '../../types'
+import { fetchDirs, fetchProviders, fetchCredentials } from '../../lib/chats'
+import { fetchSchedules } from '../../lib/schedules'
+import { api } from '../../lib/api-client'
+import { safeStorageGetJson, safeStorageSet } from '../../lib/safe-storage'
+import { setIfChanged } from '../set-if-changed'
+
+export interface DataSlice {
+  networkInfo: NetworkInfo | null
+  loadNetworkInfo: () => Promise<void>
+  dirs: Directory[]
+  loadDirs: () => Promise<void>
+  providers: ProviderInfo[]
+  credentials: Credentials
+  loadProviders: () => Promise<void>
+  loadCredentials: () => Promise<void>
+  schedules: Record<string, Schedule>
+  loadSchedules: () => Promise<void>
+  appSettings: AppSettings
+  loadSettings: () => Promise<void>
+  updateSettings: (patch: Partial<AppSettings>) => Promise<void>
+  secrets: Record<string, OrchestratorSecret>
+  loadSecrets: () => Promise<void>
+  providerConfigs: ProviderConfig[]
+  loadProviderConfigs: () => Promise<void>
+  gatewayProfiles: GatewayProfile[]
+  loadGatewayProfiles: () => Promise<void>
+  skills: Record<string, Skill>
+  loadSkills: () => Promise<void>
+  connectors: Record<string, Connector>
+  loadConnectors: () => Promise<void>
+  webhooks: Record<string, Webhook>
+  loadWebhooks: () => Promise<void>
+  mcpServers: Record<string, McpServerConfig>
+  loadMcpServers: () => Promise<void>
+  plugins: Record<string, PluginMeta>
+  loadPlugins: () => Promise<void>
+  projects: Record<string, Project>
+  loadProjects: () => Promise<void>
+  activityEntries: ActivityEntry[]
+  loadActivity: (filters?: { entityType?: string; limit?: number }) => Promise<void>
+  lastReadTimestamps: Record<string, number>
+  markChatRead: (id: string) => void
+  approvals: Record<string, ApprovalRequest>
+  loadApprovals: () => Promise<void>
+  submitApprovalDecision: (id: string, approved: boolean) => Promise<void>
+  notifications: AppNotification[]
+  unreadNotificationCount: number
+  loadNotifications: () => Promise<void>
+  markNotificationRead: (id: string) => Promise<void>
+  markAllNotificationsRead: () => Promise<void>
+  clearReadNotifications: () => Promise<void>
+}
+
+export const createDataSlice: StateCreator<AppState, [], [], DataSlice> = (set, get) => ({
+  networkInfo: null,
+  loadNetworkInfo: async () => {
+    try {
+      const info = await api<NetworkInfo>('GET', '/ip')
+      setIfChanged<AppState>(set, 'networkInfo', info)
+    } catch (err) {
+      console.warn('Store error:', err)
+      setIfChanged<AppState>(set, 'networkInfo', null)
+    }
+  },
+  dirs: [],
+  loadDirs: async () => {
+    try {
+      const dirs = await fetchDirs()
+      setIfChanged<AppState>(set, 'dirs', dirs)
+    } catch {
+      setIfChanged<AppState>(set, 'dirs', [])
+    }
+  },
+  providers: [],
+  credentials: {},
+  loadProviders: async () => {
+    try {
+      const providers = await fetchProviders()
+      setIfChanged<AppState>(set, 'providers', providers)
+    } catch (err) {
+      console.warn('Store error:', err)
+      setIfChanged<AppState>(set, 'providers', [])
+    }
+  },
+  loadCredentials: async () => {
+    try {
+      const credentials = await fetchCredentials()
+      setIfChanged<AppState>(set, 'credentials', credentials)
+    } catch (err) {
+      console.warn('Store error:', err)
+      setIfChanged<AppState>(set, 'credentials', {})
+    }
+  },
+  schedules: {},
+  loadSchedules: async () => {
+    try {
+      const schedules = await fetchSchedules()
+      setIfChanged<AppState>(set, 'schedules', schedules)
+    } catch (err) {
+      console.warn('Store error:', err)
+      setIfChanged<AppState>(set, 'schedules', {})
+    }
+  },
+  appSettings: {},
+  loadSettings: async () => {
+    try {
+      const settings = await api<AppSettings>('GET', '/settings')
+      setIfChanged<AppState>(set, 'appSettings', settings)
+    } catch (err) {
+      console.warn('Store error:', err)
+      setIfChanged<AppState>(set, 'appSettings', {})
+    }
+  },
+  updateSettings: async (patch) => {
+    try {
+      const settings = await api<AppSettings>('PUT', '/settings', patch)
+      set({ appSettings: settings })
+    } catch (err) {
+      console.warn('Store error:', err)
+    }
+  },
+  secrets: {},
+  loadSecrets: async () => {
+    try {
+      const secrets = await api<Record<string, OrchestratorSecret>>('GET', '/secrets')
+      setIfChanged<AppState>(set, 'secrets', secrets)
+    } catch (err) {
+      console.warn('Store error:', err)
+      setIfChanged<AppState>(set, 'secrets', {})
+    }
+  },
+  providerConfigs: [],
+  loadProviderConfigs: async () => {
+    try {
+      const configs = await api<ProviderConfig[]>('GET', '/providers/configs')
+      setIfChanged<AppState>(set, 'providerConfigs', configs)
+    } catch (err) {
+      console.warn('Store error:', err)
+      setIfChanged<AppState>(set, 'providerConfigs', [])
+    }
+  },
+  gatewayProfiles: [],
+  loadGatewayProfiles: async () => {
+    try {
+      const gatewayProfiles = await api<GatewayProfile[]>('GET', '/gateways')
+      setIfChanged<AppState>(set, 'gatewayProfiles', gatewayProfiles)
+    } catch (err) {
+      console.warn('Store error:', err)
+      setIfChanged<AppState>(set, 'gatewayProfiles', [])
+    }
+  },
+  skills: {},
+  loadSkills: async () => {
+    try {
+      const skills = await api<Record<string, Skill>>('GET', '/skills')
+      setIfChanged<AppState>(set, 'skills', skills)
+    } catch (err) {
+      console.warn('Store error:', err)
+      setIfChanged<AppState>(set, 'skills', {})
+    }
+  },
+  connectors: {},
+  loadConnectors: async () => {
+    try {
+      const connectors = await api<Record<string, Connector>>('GET', '/connectors')
+      setIfChanged<AppState>(set, 'connectors', connectors)
+    } catch (err) {
+      console.warn('Store error:', err)
+      setIfChanged<AppState>(set, 'connectors', {})
+    }
+  },
+  webhooks: {},
+  loadWebhooks: async () => {
+    try {
+      const webhooks = await api<Record<string, Webhook>>('GET', '/webhooks')
+      setIfChanged<AppState>(set, 'webhooks', webhooks)
+    } catch (err) {
+      console.warn('Store error:', err)
+      setIfChanged<AppState>(set, 'webhooks', {})
+    }
+  },
+  mcpServers: {},
+  loadMcpServers: async () => {
+    try {
+      const mcpServers = await api<Record<string, McpServerConfig>>('GET', '/mcp-servers')
+      setIfChanged<AppState>(set, 'mcpServers', mcpServers)
+    } catch (err) {
+      console.warn('Store error:', err)
+      setIfChanged<AppState>(set, 'mcpServers', {})
+    }
+  },
+  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
+      setIfChanged<AppState>(set, 'plugins', plugins)
+    } catch (err) {
+      console.warn('Store error:', err)
+      setIfChanged<AppState>(set, 'plugins', {})
+    }
+  },
+  projects: {},
+  loadProjects: async () => {
+    try {
+      const projects = await api<Record<string, Project>>('GET', '/projects')
+      setIfChanged<AppState>(set, 'projects', projects)
+    } catch (err) {
+      console.warn('Store error:', err)
+      setIfChanged<AppState>(set, 'projects', {})
+    }
+  },
+  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}` : ''}`)
+      setIfChanged<AppState>(set, 'activityEntries', entries)
+    } catch (err) {
+      console.warn('Store error:', err)
+      setIfChanged<AppState>(set, 'activityEntries', [])
+    }
+  },
+  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: {},
+  loadApprovals: async () => {
+    try {
+      const list = await api<ApprovalRequest[]>('GET', '/approvals')
+      const approvals: Record<string, ApprovalRequest> = {}
+      for (const a of list) approvals[a.id] = a
+      setIfChanged<AppState>(set, 'approvals', approvals)
+    } catch (err) { console.warn('Store error:', err) }
+  },
+  submitApprovalDecision: async (id, approved) => {
+    try {
+      await api('POST', '/approvals', { id, approved })
+      await get().loadApprovals()
+    } catch (err) { console.warn('Store error:', err) }
+  },
+  notifications: [],
+  unreadNotificationCount: 0,
+  loadNotifications: async () => {
+    try {
+      const notifications = await api<AppNotification[]>('GET', '/notifications')
+      if (setIfChanged<AppState>(set, 'notifications', notifications)) {
+        set({ unreadNotificationCount: notifications.filter((n) => !n.read).length })
+      }
+    } catch (err) {
+      console.warn('Store error:', err)
+      if (setIfChanged<AppState>(set, 'notifications', [])) {
+        set({ unreadNotificationCount: 0 })
+      }
+    }
+  },
+  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 (err) {
+      console.warn('Store error:', err)
+    }
+  },
+  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 (err) {
+      console.warn('Store error:', err)
+    }
+  },
+  clearReadNotifications: async () => {
+    const notifications = get().notifications.filter((n) => !n.read)
+    set({ notifications, unreadNotificationCount: notifications.length })
+    try {
+      await api('DELETE', '/notifications')
+    } catch (err) {
+      console.warn('Store error:', err)
+    }
+  }
+})

package/src/stores/slices/index.ts

@@ -0,0 +1,7 @@
+
+export * from './auth-slice'
+export * from './session-slice'
+export * from './ui-slice'
+export * from './agent-slice'
+export * from './task-slice'
+export * from './data-slice'

package/src/stores/slices/session-slice.ts

@@ -0,0 +1,112 @@
+const inflightSessionRefreshes = new Map<string, Promise<void>>()
+import { StateCreator } from 'zustand'
+import type { AppState } from '../use-app-store'
+import type { Sessions, Session } from '../../types'
+import { fetchChat, fetchChats } from '../../lib/chats'
+import { api } from '../../lib/api-client'
+import { errorMessage } from '../../lib/shared-utils'
+import { setIfChanged, invalidateFingerprint } from '../set-if-changed'
+
+export interface SessionSlice {
+  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>
+}
+
+export const createSessionSlice: StateCreator<AppState, [], [], SessionSlice> = (set, get) => ({
+  sessions: {},
+  currentSessionId: null,
+  loadSessions: async () => {
+    try {
+      const sessions = await fetchChats()
+      const changed = setIfChanged<AppState>(set, 'sessions', sessions)
+      if (changed) {
+        const currentSessionId = get().currentSessionId
+        if (currentSessionId && !sessions[currentSessionId]) {
+          set({ currentSessionId: null })
+        }
+      }
+    } catch (err) {
+      console.warn('Store error:', err)
+    }
+  },
+  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
+        invalidateFingerprint('sessions')
+        set({
+          sessions: { ...get().sessions, [id]: session },
+          currentSessionId: currentSessionId && currentSessionId === id ? id : currentSessionId,
+        })
+      } catch (err) {
+      console.warn('Store error:', err)
+    }
+    })()
+
+    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]
+    invalidateFingerprint('sessions')
+    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]
+    invalidateFingerprint('sessions')
+    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 }
+      invalidateFingerprint('sessions')
+      set({ sessions })
+      // Persist to server
+      void api('PUT', `/chats/${id}`, { pinned: sessions[id].pinned })
+    }
+  },
+  updateSessionInStore: (session) => {
+    invalidateFingerprint('sessions')
+    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:', errorMessage(err))
+      return null
+    }
+  }
+})

package/src/stores/slices/task-slice.ts

@@ -0,0 +1,63 @@
+import { StateCreator } from 'zustand'
+import type { AppState } from '../use-app-store'
+import type { BoardTask } from '../../types'
+import { fetchTasks } from '../../lib/tasks'
+import { api } from '../../lib/api-client'
+import { setIfChanged, invalidateFingerprint } from '../set-if-changed'
+
+export interface TaskSlice {
+  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
+}
+
+export const createTaskSlice: StateCreator<AppState, [], [], TaskSlice> = (set, get) => ({
+  tasks: {},
+  loadTasks: async (includeArchived) => {
+    try {
+      const show = includeArchived ?? get().showArchivedTasks
+      const tasks = await fetchTasks(show)
+      setIfChanged<AppState>(set, 'tasks', tasks)
+    } catch (err) {
+      console.warn('Store error:', err)
+    }
+  },
+  optimisticUpdateTask: async (taskId, patch) => {
+    const prev = get().tasks[taskId]
+    if (!prev) return false
+    invalidateFingerprint('tasks')
+    set({ tasks: { ...get().tasks, [taskId]: { ...prev, ...patch, updatedAt: Date.now() } } })
+    try {
+      await api('PUT', `/tasks/${taskId}`, patch)
+      return true
+    } catch {
+      invalidateFingerprint('tasks')
+      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]
+    invalidateFingerprint('tasks')
+    set({ tasks: next })
+    try {
+      await api('DELETE', `/tasks/${taskId}`)
+      return true
+    } catch {
+      invalidateFingerprint('tasks')
+      set({ tasks: { ...get().tasks, [taskId]: prev } })
+      return false
+    }
+  },
+  showArchivedTasks: false,
+  setShowArchivedTasks: (show) => {
+    set({ showArchivedTasks: show })
+    get().loadTasks(show)
+  }
+})

package/src/stores/slices/ui-slice.ts

@@ -0,0 +1,192 @@
+import { StateCreator } from 'zustand'
+import type { AppState } from '../use-app-store'
+import type { AppView, FleetFilter } from '../../types'
+import { safeStorageGet, safeStorageSet } from '../../lib/safe-storage'
+
+export interface UiSlice {
+  sidebarOpen: boolean
+  setSidebarOpen: (open: boolean) => void
+  toggleSidebar: () => void
+  settingsOpen: boolean
+  setSettingsOpen: (open: boolean) => void
+  activeView: AppView
+  setActiveView: (view: AppView) => 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
+  secretSheetOpen: boolean
+  setSecretSheetOpen: (open: boolean) => void
+  editingSecretId: string | null
+  setEditingSecretId: (id: string | null) => void
+  taskSheetOpen: boolean
+  setTaskSheetOpen: (open: boolean) => void
+  editingTaskId: string | null
+  setEditingTaskId: (id: string | null) => void
+  taskSheetViewOnly: boolean
+  setTaskSheetViewOnly: (v: boolean) => void
+  providerSheetOpen: boolean
+  setProviderSheetOpen: (open: boolean) => void
+  editingProviderId: string | null
+  setEditingProviderId: (id: string | null) => void
+  gatewaySheetOpen: boolean
+  setGatewaySheetOpen: (open: boolean) => void
+  editingGatewayId: string | null
+  setEditingGatewayId: (id: string | null) => void
+  skillSheetOpen: boolean
+  setSkillSheetOpen: (open: boolean) => void
+  editingSkillId: string | null
+  setEditingSkillId: (id: string | null) => void
+  connectorSheetOpen: boolean
+  setConnectorSheetOpen: (open: boolean) => void
+  editingConnectorId: string | null
+  setEditingConnectorId: (id: string | null) => void
+  webhookSheetOpen: boolean
+  setWebhookSheetOpen: (open: boolean) => void
+  editingWebhookId: string | null
+  setEditingWebhookId: (id: string | null) => void
+  mcpServerSheetOpen: boolean
+  setMcpServerSheetOpen: (open: boolean) => void
+  editingMcpServerId: string | null
+  setEditingMcpServerId: (id: string | null) => void
+  knowledgeSheetOpen: boolean
+  setKnowledgeSheetOpen: (open: boolean) => void
+  editingKnowledgeId: string | null
+  setEditingKnowledgeId: (id: string | null) => void
+  knowledgeRefreshKey: number
+  triggerKnowledgeRefresh: () => void
+  pluginSheetOpen: boolean
+  setPluginSheetOpen: (open: boolean) => void
+  editingPluginFilename: string | null
+  setEditingPluginFilename: (filename: string | null) => void
+  projectSheetOpen: boolean
+  setProjectSheetOpen: (open: boolean) => void
+  editingProjectId: string | null
+  setEditingProjectId: (id: string | null) => void
+  activeProjectFilter: string | null
+  setActiveProjectFilter: (id: string | null) => void
+  showTrash: boolean
+  setShowTrash: (show: boolean) => void
+  inspectorOpen: boolean
+  setInspectorOpen: (open: boolean) => void
+  inspectorTab: 'overview' | 'files' | 'skills' | 'automations' | 'advanced'
+  setInspectorTab: (tab: 'overview' | 'files' | 'skills' | 'automations' | 'advanced') => void
+  fleetFilter: FleetFilter
+  setFleetFilter: (filter: FleetFilter) => void
+  chatFilter: 'all' | 'active' | 'recent'
+  setChatFilter: (filter: 'all' | 'active' | 'recent') => void
+  walletPanelAgentId: string | null
+  setWalletPanelAgentId: (id: string | null) => void
+}
+
+export const createUiSlice: StateCreator<AppState, [], [], UiSlice> = (set, get) => ({
+  sidebarOpen: false,
+  setSidebarOpen: (open) => set({ sidebarOpen: open }),
+  toggleSidebar: () => set((s) => ({ sidebarOpen: !s.sidebarOpen })),
+  settingsOpen: false,
+  setSettingsOpen: (open) => set({ settingsOpen: open }),
+  activeView: 'home',
+  setActiveView: (view) => set({ activeView: view }),
+  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 }),
+  secretSheetOpen: false,
+  setSecretSheetOpen: (open) => set({ secretSheetOpen: open }),
+  editingSecretId: null,
+  setEditingSecretId: (id) => set({ editingSecretId: id }),
+  taskSheetOpen: false,
+  setTaskSheetOpen: (open) => set({ taskSheetOpen: open, ...(open ? {} : { taskSheetViewOnly: false }) }),
+  editingTaskId: null,
+  setEditingTaskId: (id) => set({ editingTaskId: id }),
+  taskSheetViewOnly: false,
+  setTaskSheetViewOnly: (v) => set({ taskSheetViewOnly: v }),
+  providerSheetOpen: false,
+  setProviderSheetOpen: (open) => set({ providerSheetOpen: open }),
+  editingProviderId: null,
+  setEditingProviderId: (id) => set({ editingProviderId: id }),
+  gatewaySheetOpen: false,
+  setGatewaySheetOpen: (open) => set({ gatewaySheetOpen: open }),
+  editingGatewayId: null,
+  setEditingGatewayId: (id) => set({ editingGatewayId: id }),
+  skillSheetOpen: false,
+  setSkillSheetOpen: (open) => set({ skillSheetOpen: open }),
+  editingSkillId: null,
+  setEditingSkillId: (id) => set({ editingSkillId: id }),
+  connectorSheetOpen: false,
+  setConnectorSheetOpen: (open) => set({ connectorSheetOpen: open }),
+  editingConnectorId: null,
+  setEditingConnectorId: (id) => set({ editingConnectorId: id }),
+  webhookSheetOpen: false,
+  setWebhookSheetOpen: (open) => set({ webhookSheetOpen: open }),
+  editingWebhookId: null,
+  setEditingWebhookId: (id) => set({ editingWebhookId: id }),
+  mcpServerSheetOpen: false,
+  setMcpServerSheetOpen: (open) => set({ mcpServerSheetOpen: open }),
+  editingMcpServerId: null,
+  setEditingMcpServerId: (id) => set({ editingMcpServerId: id }),
+  knowledgeSheetOpen: false,
+  setKnowledgeSheetOpen: (open) => set({ knowledgeSheetOpen: open }),
+  editingKnowledgeId: null,
+  setEditingKnowledgeId: (id) => set({ editingKnowledgeId: id }),
+  knowledgeRefreshKey: 0,
+  triggerKnowledgeRefresh: () => set((s) => ({ knowledgeRefreshKey: s.knowledgeRefreshKey + 1 })),
+  pluginSheetOpen: false,
+  setPluginSheetOpen: (open) => set({ pluginSheetOpen: open }),
+  editingPluginFilename: null,
+  setEditingPluginFilename: (filename) => set({ editingPluginFilename: filename }),
+  projectSheetOpen: false,
+  setProjectSheetOpen: (open) => set({ projectSheetOpen: open }),
+  editingProjectId: null,
+  setEditingProjectId: (id) => set({ editingProjectId: id }),
+  activeProjectFilter: null,
+  setActiveProjectFilter: (id) => set({ activeProjectFilter: id }),
+  showTrash: false,
+  setShowTrash: (show) => set({ showTrash: show }),
+  inspectorOpen: false,
+  setInspectorOpen: (open) => set({ inspectorOpen: open }),
+  inspectorTab: 'overview',
+  setInspectorTab: (tab) => set({ inspectorTab: tab }),
+  fleetFilter: (safeStorageGet('sc_fleet_filter') as FleetFilter) || 'all',
+  setFleetFilter: (filter) => { safeStorageSet('sc_fleet_filter', filter); set({ fleetFilter: filter }) },
+  chatFilter: 'all' as const,
+  setChatFilter: (filter) => set({ chatFilter: filter }),
+  walletPanelAgentId: null,
+  setWalletPanelAgentId: (id) => set({ walletPanelAgentId: id })
+})