@swarmclawai/swarmclaw 1.9.35 → 1.9.37

package/src/components/protocols/builder/protocol-builder-canvas.tsx

@@ -1,6 +1,6 @@
 'use client'
 
-import { useCallback, useMemo, type DragEvent } from 'react'
+import { useCallback, useEffect, useMemo, useRef, type DragEvent } from 'react'
 import {
   ReactFlow,
   Background,
@@ -12,16 +12,19 @@ import {
   type NodeChange,
   type EdgeChange,
   type Node,
+  type Edge,
+  type ReactFlowInstance,
 } from '@xyflow/react'
 import '@xyflow/react/dist/style.css'
-import { useProtocolBuilderStore, type BuilderNodeData } from '@/features/protocols/builder/protocol-builder-store'
+import { useProtocolBuilderStore, type BuilderEdgeData, type BuilderNodeData } from '@/features/protocols/builder/protocol-builder-store'
 import { getNodeTypeForKind } from '@/features/protocols/builder/utils/template-to-nodes'
+import { isBuilderTemplateReadOnly } from '@/features/protocols/builder/utils/builder-template-access'
 import { PhaseNode, BranchNode, LoopNode, ParallelNode, JoinNode, ForEachNode, SubflowNode, SwarmNode, CompleteNode } from './node-types'
 import { DefaultEdge, BranchEdge, LoopEdge } from './edge-types'
 import { NodePalette } from './node-palette'
 import { NodeInspector } from './node-inspector'
 import { ValidationPanel } from './validation-panel'
-import type { ProtocolStepKind } from '@/types'
+import type { ProtocolStepKind, ProtocolTemplate } from '@/types'
 
 const nodeTypes = {
   phase: PhaseNode,
@@ -41,6 +44,54 @@ const edgeTypes = {
   loop: LoopEdge,
 }
 
+function BuiltInTemplatePanel({
+  template,
+  onSelectStep,
+}: {
+  template: ProtocolTemplate | null
+  onSelectStep: (stepId: string) => void
+}) {
+  const steps = template?.steps && template.steps.length > 0
+    ? template.steps
+    : template?.defaultPhases ?? []
+
+  return (
+    <div className="flex w-52 shrink-0 flex-col overflow-y-auto rounded-lg border bg-card p-3 shadow-sm">
+      <div className="mb-3">
+        <div className="text-xs font-bold uppercase tracking-wider text-muted-foreground">
+          Built-in template
+        </div>
+        <div className="mt-1 text-sm font-semibold text-foreground">{template?.name || 'Template'}</div>
+        {template?.description && (
+          <div className="mt-1 text-xs leading-relaxed text-muted-foreground">
+            {template.description}
+          </div>
+        )}
+      </div>
+
+      <div className="space-y-1">
+        {steps.map((step, index) => (
+          <button
+            key={step.id}
+            type="button"
+            onClick={() => onSelectStep(step.id)}
+            className="w-full rounded-md border bg-background px-3 py-2 text-left"
+            title={step.kind.replace(/_/g, ' ')}
+          >
+            <div className="text-[10px] font-semibold uppercase tracking-wider text-muted-foreground">
+              Step {index + 1}
+            </div>
+            <div className="mt-1 text-sm font-medium text-foreground">{step.label}</div>
+            <div className="mt-1 text-xs capitalize text-muted-foreground">
+              {step.kind.replace(/_/g, ' ')}
+            </div>
+          </button>
+        ))}
+      </div>
+    </div>
+  )
+}
+
 export function ProtocolBuilderCanvas() {
   const nodes = useProtocolBuilderStore((s) => s.nodes)
   const edges = useProtocolBuilderStore((s) => s.edges)
@@ -54,23 +105,44 @@ export function ProtocolBuilderCanvas() {
   const isDirty = useProtocolBuilderStore((s) => s.isDirty)
   const undo = useProtocolBuilderStore((s) => s.undo)
   const redo = useProtocolBuilderStore((s) => s.redo)
+  const currentTemplate = useProtocolBuilderStore((s) => s.currentTemplate)
+  const flowRef = useRef<ReactFlowInstance<Node<BuilderNodeData>, Edge<BuilderEdgeData>> | null>(null)
+
+  const readOnly = isBuilderTemplateReadOnly(currentTemplate)
+
+  useEffect(() => {
+    if (nodes.length === 0) return
+    const frame = window.requestAnimationFrame(() => {
+      void flowRef.current?.fitView({ padding: 0.24, duration: 160 })
+    })
+    return () => window.cancelAnimationFrame(frame)
+  }, [nodes.length, edges.length])
 
   const onNodesChange = useCallback(
     (changes: NodeChange<Node<BuilderNodeData>>[]) => {
-      setNodes(applyNodeChanges(changes, nodes))
+      const allowedChanges = readOnly
+        ? changes.filter((change) => change.type === 'select')
+        : changes
+      if (allowedChanges.length === 0) return
+      setNodes(applyNodeChanges(allowedChanges, nodes), { markDirty: !readOnly })
     },
-    [nodes, setNodes],
+    [nodes, readOnly, setNodes],
   )
 
   const onEdgesChange = useCallback(
     (changes: EdgeChange[]) => {
-      setEdges(applyEdgeChanges(changes, edges) as typeof edges)
+      const allowedChanges = readOnly
+        ? changes.filter((change) => change.type === 'select')
+        : changes
+      if (allowedChanges.length === 0) return
+      setEdges(applyEdgeChanges(allowedChanges, edges) as typeof edges, { markDirty: !readOnly })
     },
-    [edges, setEdges],
+    [edges, readOnly, setEdges],
   )
 
   const onConnect = useCallback(
     (connection: Connection) => {
+      if (readOnly) return
       pushUndo()
       addEdge({
         id: `${connection.source}--${connection.target}--${Date.now()}`,
@@ -82,7 +154,7 @@ export function ProtocolBuilderCanvas() {
         data: { edgeType: 'default' },
       })
     },
-    [addEdge, pushUndo],
+    [addEdge, pushUndo, readOnly],
   )
 
   const onNodeClick = useCallback(
@@ -112,6 +184,7 @@ export function ProtocolBuilderCanvas() {
   const onDrop = useCallback(
     (e: DragEvent) => {
       e.preventDefault()
+      if (readOnly) return
       const kind = e.dataTransfer.getData('application/x-protocol-node-kind') as ProtocolStepKind
       const label = e.dataTransfer.getData('application/x-protocol-node-label')
       if (!kind) return
@@ -127,32 +200,43 @@ export function ProtocolBuilderCanvas() {
       }
       addNode(newNode)
     },
-    [addNode, pushUndo],
+    [addNode, pushUndo, readOnly],
   )
 
   const onKeyDown = useCallback(
     (e: React.KeyboardEvent) => {
+      if (readOnly) return
       if ((e.metaKey || e.ctrlKey) && e.key === 'z') {
         e.preventDefault()
         if (e.shiftKey) redo()
         else undo()
       }
     },
-    [undo, redo],
+    [readOnly, undo, redo],
   )
 
   const memoizedNodeTypes = useMemo(() => nodeTypes, [])
   const memoizedEdgeTypes = useMemo(() => edgeTypes, [])
 
   return (
-    <div className="flex h-full w-full gap-3" onKeyDown={onKeyDown} tabIndex={0}>
-      <NodePalette />
-      <div className="relative flex-1 overflow-hidden rounded-lg border">
+    <div className="flex h-full min-h-0 w-full min-w-0 gap-3" onKeyDown={onKeyDown} tabIndex={0}>
+      {readOnly ? <BuiltInTemplatePanel template={currentTemplate} onSelectStep={selectNode} /> : <NodePalette />}
+      <div className="relative min-h-0 min-w-0 flex-1 overflow-hidden rounded-lg border">
         {isDirty && (
           <div className="absolute left-1/2 top-2 z-10 -translate-x-1/2 rounded bg-amber-500/10 px-2 py-1 text-xs text-amber-500">
             Unsaved changes
           </div>
         )}
+        {nodes.length === 0 && (
+          <div className="pointer-events-none absolute inset-0 z-10 flex items-center justify-center p-6">
+            <div className="pointer-events-auto max-w-md rounded-lg border bg-card/95 p-4 text-center shadow-sm">
+              <div className="text-sm font-semibold text-foreground">No visual steps</div>
+              <div className="mt-1 text-sm text-muted-foreground">
+                This template does not expose a protocol graph yet.
+              </div>
+            </div>
+          </div>
+        )}
         <ReactFlow
           nodes={nodes}
           edges={edges}
@@ -166,8 +250,15 @@ export function ProtocolBuilderCanvas() {
           onPaneClick={onPaneClick}
           onDragOver={onDragOver}
           onDrop={onDrop}
+          onInit={(instance) => {
+            flowRef.current = instance
+          }}
           fitView
-          deleteKeyCode="Delete"
+          fitViewOptions={{ padding: 0.24 }}
+          nodesDraggable={!readOnly}
+          nodesConnectable={!readOnly}
+          edgesReconnectable={!readOnly}
+          deleteKeyCode={readOnly ? null : 'Delete'}
           defaultEdgeOptions={{ type: 'default', data: { edgeType: 'default' } }}
         >
           <Background />
@@ -175,7 +266,7 @@ export function ProtocolBuilderCanvas() {
           <MiniMap />
         </ReactFlow>
       </div>
-      <div className="flex w-72 flex-col gap-3">
+      <div className="flex w-72 shrink-0 flex-col gap-3">
         <NodeInspector />
         <ValidationPanel />
       </div>

package/src/components/providers/theme-provider.tsx

@@ -0,0 +1,16 @@
+'use client'
+
+import { ThemeProvider as NextThemeProvider } from 'next-themes'
+
+export function ThemeProvider({ children }: { children: React.ReactNode }) {
+  return (
+    <NextThemeProvider
+      attribute="class"
+      defaultTheme="dark"
+      enableSystem
+      disableTransitionOnChange
+    >
+      {children}
+    </NextThemeProvider>
+  )
+}

package/src/features/protocols/builder/hooks/use-template-sync.ts

@@ -2,6 +2,7 @@ import { useEffect, useRef } from 'react'
 import { useProtocolBuilderStore } from '../protocol-builder-store'
 import { useUpsertProtocolTemplateMutation, type ProtocolTemplatePayload } from '@/features/protocols/queries'
 import { nodesToTemplate } from '../utils/nodes-to-template'
+import { isBuilderTemplateReadOnly } from '../utils/builder-template-access'
 
 export function useTemplateSync(autoSaveDelayMs = 2000) {
   const nodes = useProtocolBuilderStore((s) => s.nodes)
@@ -15,6 +16,10 @@ export function useTemplateSync(autoSaveDelayMs = 2000) {
 
   useEffect(() => {
     if (!isDirty || !currentTemplate || validationErrors.length > 0) return
+    if (isBuilderTemplateReadOnly(currentTemplate)) {
+      if (debounceRef.current) clearTimeout(debounceRef.current)
+      return
+    }
 
     if (debounceRef.current) clearTimeout(debounceRef.current)
 

package/src/features/protocols/builder/protocol-builder-store.ts

@@ -67,8 +67,8 @@ export interface ProtocolBuilderState {
   redoStack: UndoSnapshot[]
   activeRunId: string | null
 
-  setNodes: (nodes: BuilderNode[]) => void
-  setEdges: (edges: BuilderEdge[]) => void
+  setNodes: (nodes: BuilderNode[], options?: { markDirty?: boolean }) => void
+  setEdges: (edges: BuilderEdge[], options?: { markDirty?: boolean }) => void
   selectNode: (nodeId: string | null) => void
   selectEdge: (edgeId: string | null) => void
   updateNodeData: (nodeId: string, data: Partial<BuilderNodeData>) => void
@@ -110,8 +110,8 @@ export const useProtocolBuilderStore = create<ProtocolBuilderState>()(
     (set, get) => ({
       ...initialState,
 
-      setNodes: (nodes) => set({ nodes, isDirty: true }),
-      setEdges: (edges) => set({ edges, isDirty: true }),
+      setNodes: (nodes, options) => set({ nodes, isDirty: options?.markDirty ?? true }),
+      setEdges: (edges, options) => set({ edges, isDirty: options?.markDirty ?? true }),
 
       selectNode: (nodeId) =>
         set({ selectedNodeId: nodeId, selectedEdgeId: null }),

package/src/features/protocols/builder/utils/builder-template-access.test.ts

@@ -0,0 +1,30 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import type { ProtocolTemplate } from '@/types'
+import { isBuilderTemplateReadOnly } from './builder-template-access'
+
+function makeTemplate(overrides: Partial<ProtocolTemplate> = {}): ProtocolTemplate {
+  return {
+    id: 'template-1',
+    name: 'Template One',
+    description: 'A template',
+    builtIn: false,
+    defaultPhases: [],
+    ...overrides,
+  }
+}
+
+describe('isBuilderTemplateReadOnly', () => {
+  it('marks built-in templates as read-only', () => {
+    assert.equal(isBuilderTemplateReadOnly(makeTemplate({ builtIn: true })), true)
+  })
+
+  it('keeps custom templates editable', () => {
+    assert.equal(isBuilderTemplateReadOnly(makeTemplate({ builtIn: false })), false)
+  })
+
+  it('treats an unloaded template as non-editable only after one is present', () => {
+    assert.equal(isBuilderTemplateReadOnly(null), false)
+    assert.equal(isBuilderTemplateReadOnly(undefined), false)
+  })
+})

package/src/features/protocols/builder/utils/builder-template-access.ts

@@ -0,0 +1,5 @@
+import type { ProtocolTemplate } from '@/types'
+
+export function isBuilderTemplateReadOnly(template: ProtocolTemplate | null | undefined): boolean {
+  return Boolean(template?.builtIn)
+}

package/src/lib/server/messages/message-repository.test.ts

@@ -68,3 +68,125 @@ test('appendMessage notifies both generic and per-session message topics', () =>
   assert.deepEqual(output.genericTopics, ['messages'])
   assert.deepEqual(output.sessionTopics, ['messages:sess-notify'])
 })
+
+test('lazy migration compacts legacy session message blobs after table persistence', () => {
+  const output = runWithTempDataDir<{
+    returnedTexts: string[]
+    secondReadTexts: string[]
+    blobMessageCount: number
+    messageCount: number
+    lastMessageText: string | null
+  }>(`
+    const storageMod = await import('@/lib/server/storage')
+    const repoMod = await import('@/lib/server/messages/message-repository')
+    const storage = storageMod.default || storageMod
+    const repo = repoMod.default || repoMod
+
+    storage.saveSessions({
+      'sess-legacy-blob': {
+        id: 'sess-legacy-blob',
+        name: 'Legacy blob session',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'tester',
+        provider: 'openai',
+        model: 'gpt-5',
+        claudeSessionId: null,
+        codexThreadId: null,
+        opencodeSessionId: null,
+        delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null },
+        messages: [
+          { role: 'user', text: 'first legacy prompt', time: 1 },
+          { role: 'assistant', text: 'first legacy reply', time: 2 },
+          { role: 'user', text: 'second legacy prompt', time: 3 },
+        ],
+        createdAt: Date.now(),
+        lastActiveAt: Date.now(),
+      },
+    })
+
+    const returned = repo.getMessages('sess-legacy-blob')
+    const secondRead = repo.getMessages('sess-legacy-blob')
+    const stored = storage.loadSessions()['sess-legacy-blob']
+
+    console.log(JSON.stringify({
+      returnedTexts: returned.map((message) => message.text),
+      secondReadTexts: secondRead.map((message) => message.text),
+      blobMessageCount: Array.isArray(stored.messages) ? stored.messages.length : -1,
+      messageCount: stored.messageCount,
+      lastMessageText: stored.lastMessageSummary?.text || null,
+    }))
+  `, { prefix: 'swarmclaw-message-repo-compact-' })
+
+  assert.deepEqual(output.returnedTexts, [
+    'first legacy prompt',
+    'first legacy reply',
+    'second legacy prompt',
+  ])
+  assert.deepEqual(output.secondReadTexts, output.returnedTexts)
+  assert.equal(output.blobMessageCount, 0)
+  assert.equal(output.messageCount, 3)
+  assert.equal(output.lastMessageText, 'second legacy prompt')
+})
+
+test('bulk migration reports compaction for table-backed legacy blobs', () => {
+  const output = runWithTempDataDir<{
+    result: {
+      migrated: number
+      compacted: number
+      skipped: number
+      total: number
+    }
+    blobMessageCount: number
+    messageCount: number
+  }>(`
+    const storageMod = await import('@/lib/server/storage')
+    const repoMod = await import('@/lib/server/messages/message-repository')
+    const storage = storageMod.default || storageMod
+    const repo = repoMod.default || repoMod
+
+    const messages = [
+      { role: 'user', text: 'stale blob prompt', time: 10 },
+      { role: 'assistant', text: 'stale blob reply', time: 20 },
+    ]
+
+    storage.saveSessions({
+      'sess-table-backed-blob': {
+        id: 'sess-table-backed-blob',
+        name: 'Table backed blob session',
+        cwd: process.env.WORKSPACE_DIR,
+        user: 'tester',
+        provider: 'openai',
+        model: 'gpt-5',
+        claudeSessionId: null,
+        codexThreadId: null,
+        opencodeSessionId: null,
+        delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null },
+        messages,
+        createdAt: Date.now(),
+        lastActiveAt: Date.now(),
+      },
+    })
+
+    const db = storage.getDb()
+    const insert = db.prepare('INSERT INTO session_messages (session_id, seq, data) VALUES (?, ?, ?)')
+    messages.forEach((message, index) => {
+      insert.run('sess-table-backed-blob', index, JSON.stringify(message))
+    })
+
+    const result = repo.migrateAllSessions()
+    const stored = storage.loadSessions()['sess-table-backed-blob']
+
+    console.log(JSON.stringify({
+      result,
+      blobMessageCount: Array.isArray(stored.messages) ? stored.messages.length : -1,
+      messageCount: stored.messageCount,
+    }))
+  `, { prefix: 'swarmclaw-message-repo-migrate-report-' })
+
+  assert.equal(output.result.migrated, 0)
+  assert.equal(output.result.compacted, 1)
+  assert.equal(output.result.skipped, 1)
+  assert.equal(output.result.total, 1)
+  assert.equal(output.blobMessageCount, 0)
+  assert.equal(output.messageCount, 2)
+})

package/src/lib/server/messages/message-repository.ts

@@ -86,6 +86,38 @@ function summarizeForMeta(message: Message): Message {
   }
 }
 
+function getLastAssistantAt(messages: Message[]): number | null {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === 'assistant' && typeof messages[i].time === 'number') {
+      return messages[i].time
+    }
+  }
+  return null
+}
+
+function compactDeprecatedBlobMessages(
+  sessionId: string,
+  persistedCount: number,
+  lastMsg: Message | null,
+  lastAssistantAt: number | null,
+): boolean {
+  let compacted = false
+  patchSession(sessionId, (current) => {
+    if (!current) return null
+    const blobCount = Array.isArray(current.messages) ? current.messages.length : 0
+    if (blobCount === 0) return current
+    if (persistedCount < blobCount) return current
+
+    current.messages = []
+    current.messageCount = persistedCount
+    current.lastMessageSummary = lastMsg ? summarizeForMeta(lastMsg) : null
+    if (lastAssistantAt !== null) current.lastAssistantAt = lastAssistantAt
+    compacted = true
+    return current
+  })
+  return compacted
+}
+
 // ---------------------------------------------------------------------------
 // Session metadata sync — keeps messageCount / lastMessageSummary on the blob
 // ---------------------------------------------------------------------------
@@ -139,18 +171,14 @@ function lazyMigrateSession(sessionId: string): Message[] | null {
       ins.run(sessionId, i, JSON.stringify(messages[i]))
     }
 
-    // Compute metadata on the blob (keep messages intact for backward compat)
+    // Compute metadata before compacting deprecated blob storage.
     const lastMsg = messages[messages.length - 1]
-    let lastAssistantAt: number | null = null
-    for (let i = messages.length - 1; i >= 0; i--) {
-      if (messages[i].role === 'assistant' && typeof messages[i].time === 'number') {
-        lastAssistantAt = messages[i].time
-        break
-      }
-    }
+    const lastAssistantAt = getLastAssistantAt(messages)
+    const persistedCount = rowCount(sessionId)
 
     patchSession(sessionId, (current) => {
       if (!current) return null
+      current.messages = persistedCount >= messages.length ? [] : current.messages
       current.messageCount = messages.length
       current.lastMessageSummary = lastMsg ? summarizeForMeta(lastMsg) : null
       if (lastAssistantAt !== null && typeof current.lastAssistantAt !== 'number') {
@@ -183,6 +211,7 @@ export function getMessages(sessionId: string): Message[] {
       const m = parseMsg(row.data)
       if (m) out.push(m)
     }
+    compactDeprecatedBlobMessages(sessionId, out.length, out[out.length - 1] || null, getLastAssistantAt(out))
     return out
   }, { sessionId })
 }
@@ -338,10 +367,16 @@ export function deleteSessionMessages(sessionId: string): void {
 // Bulk migration (for CLI / admin endpoint)
 // ---------------------------------------------------------------------------
 
-export function migrateAllSessions(): { migrated: number; skipped: number; total: number } {
+export function migrateAllSessions(): {
+  migrated: number
+  compacted: number
+  skipped: number
+  total: number
+} {
   const db = getDb()
   const rows = db.prepare('SELECT id, data FROM sessions').all() as Array<{ id: string; data: string }>
   let migrated = 0
+  let compacted = 0
   let skipped = 0
 
   for (const row of rows) {
@@ -351,16 +386,37 @@ export function migrateAllSessions(): { migrated: number; skipped: number; total
         skipped++
         continue
       }
-      if (rowCount(row.id) > 0) {
+
+      const persistedCount = rowCount(row.id)
+      if (persistedCount > 0) {
+        const persistedRows = stmts().selectAll.all(row.id) as Array<{ data: string }>
+        const persistedMessages: Message[] = []
+        for (const persistedRow of persistedRows) {
+          const message = parseMsg(persistedRow.data)
+          if (message) persistedMessages.push(message)
+        }
+        if (compactDeprecatedBlobMessages(
+          row.id,
+          persistedCount,
+          persistedMessages[persistedMessages.length - 1] || null,
+          getLastAssistantAt(persistedMessages),
+        )) {
+          compacted++
+        }
         skipped++
         continue
       }
+
       lazyMigrateSession(row.id)
       migrated++
+      const stored = loadSession(row.id)
+      if (!Array.isArray(stored?.messages) || stored.messages.length === 0) {
+        compacted++
+      }
     } catch {
       skipped++
     }
   }
 
-  return { migrated, skipped, total: rows.length }
+  return { migrated, compacted, skipped, total: rows.length }
 }

package/src/lib/server/runtime/devserver-launch.ts

@@ -23,10 +23,10 @@ const NEXT_CONFIG_FILES = [
 ]
 
 function readPackageJson(dir: string): PackageJsonLike | null {
-  const pkgPath = path.join(dir, 'package.json')
-  if (!fs.existsSync(pkgPath)) return null
+  const pkgPath = path.join(/*turbopackIgnore: true*/ dir, 'package.json')
+  if (!fs.existsSync(/*turbopackIgnore: true*/ pkgPath)) return null
   try {
-    const parsed: unknown = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+    const parsed: unknown = JSON.parse(fs.readFileSync(/*turbopackIgnore: true*/ pkgPath, 'utf8'))
     return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
       ? parsed as PackageJsonLike
       : null
@@ -46,7 +46,10 @@ function hasNextScript(pkg: PackageJsonLike): boolean {
 }
 
 function hasNextConfig(dir: string): boolean {
-  return NEXT_CONFIG_FILES.some((file) => fs.existsSync(path.join(dir, file)))
+  return NEXT_CONFIG_FILES.some((file) => {
+    const configPath = path.join(/*turbopackIgnore: true*/ dir, file)
+    return fs.existsSync(/*turbopackIgnore: true*/ configPath)
+  })
 }
 
 function classifyPackageRoot(dir: string, pkg: PackageJsonLike): FrameworkKind {

package/src/lib/theme-mode.ts

@@ -0,0 +1,5 @@
+export type ThemeMode = 'light' | 'dark' | 'system'
+
+export function normalizeThemeMode(value: unknown): ThemeMode {
+  return value === 'light' || value === 'system' ? value : 'dark'
+}

package/src/types/app-settings.ts

@@ -1,5 +1,6 @@
 import type { SessionResetMode } from './session'
 import type { ExtensionManagedLocalFolderDeclaration } from './extension'
+import type { ThemeMode } from '@/lib/theme-mode'
 
 // --- App Settings ---
 export type LoopMode = 'bounded' | 'ongoing'
@@ -134,6 +135,7 @@ export interface AppSettings {
   defaultAgentId?: string | null
   // Theme
   themeHue?: string
+  themeMode?: ThemeMode
   // Web search provider
   webSearchProvider?: 'duckduckgo' | 'google' | 'bing' | 'searxng' | 'tavily' | 'brave' | 'exa'
   searxngUrl?: string