@swarmclawai/swarmclaw 1.2.4 → 1.2.6

package/src/lib/server/skills/skill-suggestions.ts

@@ -5,13 +5,20 @@ import { genId } from '@/lib/id'
 import type { Agent, Session, Skill, SkillSuggestion } from '@/types'
 import { errorMessage } from '@/lib/shared-utils'
 import {
-  loadAgents,
-  loadSessions,
+  loadAgent,
+} from '@/lib/server/agents/agent-repository'
+import {
+  loadSession,
+} from '@/lib/server/sessions/session-repository'
+import { getMessages, getRecentMessages } from '@/lib/server/messages/message-repository'
+import {
+  loadSkill,
+  loadSkillSuggestion,
   loadSkillSuggestions,
   loadSkills,
-  saveSkillSuggestions,
-  saveSkills,
-} from '@/lib/server/storage'
+  saveSkill,
+  upsertSkillSuggestion,
+} from '@/lib/server/skills/skill-repository'
 import { buildLLM, type GenerationModelPreference } from '@/lib/server/build-llm'
 import { notify } from '@/lib/server/ws-hub'
 import { resolveAgentRouteCandidates } from '@/lib/server/agents/agent-runtime-config'
@@ -91,7 +98,7 @@ function ensureHeading(name: string, content: string): string {
 }
 
 export function buildSessionTranscript(session: Session, maxMessages = DEFAULT_TRANSCRIPT_MESSAGES): string {
-  const messages = Array.isArray(session.messages) ? session.messages.slice(-maxMessages) : []
+  const messages = getRecentMessages(session.id, maxMessages)
   const lines: string[] = []
   for (const message of messages) {
     if (!message || message.suppressed) continue
@@ -109,9 +116,8 @@ export function buildSessionTranscript(session: Session, maxMessages = DEFAULT_T
 }
 
 function getSessionMessageCount(session: Session): number {
-  return Array.isArray(session.messages)
-    ? session.messages.filter((message) => message && !message.suppressed && (message.text || message.toolEvents?.length)).length
-    : 0
+  return getMessages(session.id)
+    .filter((message) => message && !message.suppressed && (message.text || message.toolEvents?.length)).length
 }
 
 function buildSuggestionPrompt(params: {
@@ -234,11 +240,9 @@ export async function createSkillSuggestionFromSession(
   sessionId: string,
   options?: { generateText?: (prompt: string) => Promise<string> },
 ): Promise<SkillSuggestion> {
-  const sessions = loadSessions()
-  const session = sessions[sessionId] as unknown as Session | undefined
+  const session = loadSession(sessionId)
   if (!session) throw new Error(`Session "${sessionId}" not found.`)
-  const agents = loadAgents()
-  const agent = session.agentId ? agents[session.agentId] : null
+  const agent = session.agentId ? loadAgent(session.agentId) : null
 
   const transcript = buildSessionTranscript(session)
   const sourceMessageCount = getSessionMessageCount(session)
@@ -331,18 +335,16 @@ export async function createSkillSuggestionFromSession(
     updatedAt: now,
   }
 
-  suggestions[suggestion.id] = suggestion
-  saveSkillSuggestions(suggestions)
+  upsertSkillSuggestion(suggestion.id, suggestion)
   notify('skill_suggestions')
   return suggestion
 }
 
 export function materializeSkillSuggestion(id: string): { suggestion: SkillSuggestion; skill: Skill } {
-  const suggestions = loadSkillSuggestions()
-  const suggestion = suggestions[id]
+  const suggestion = loadSkillSuggestion(id)
   if (!suggestion) throw new Error(`Skill suggestion "${id}" not found.`)
   if (suggestion.status === 'approved' && suggestion.createdSkillId) {
-    const existing = loadSkills()[suggestion.createdSkillId]
+    const existing = loadSkill(suggestion.createdSkillId)
     if (existing) return { suggestion, skill: existing }
   }
 
@@ -370,8 +372,7 @@ export function materializeSkillSuggestion(id: string): { suggestion: SkillSugge
       approvedAt: now,
       updatedAt: now,
     }
-    suggestions[id] = approved
-    saveSkillSuggestions(suggestions)
+    upsertSkillSuggestion(id, approved)
     notify('skill_suggestions')
     return { suggestion: approved, skill: existingSkill }
   }
@@ -399,8 +400,7 @@ export function materializeSkillSuggestion(id: string): { suggestion: SkillSugge
     updatedAt: now,
   }
 
-  skills[skill.id] = skill
-  saveSkills(skills)
+  saveSkill(skill.id, skill)
   clearDiscoveredSkillsCache()
 
   const approved: SkillSuggestion = {
@@ -410,16 +410,14 @@ export function materializeSkillSuggestion(id: string): { suggestion: SkillSugge
     approvedAt: now,
     updatedAt: now,
   }
-  suggestions[id] = approved
-  saveSkillSuggestions(suggestions)
+  upsertSkillSuggestion(id, approved)
   notify('skills')
   notify('skill_suggestions')
   return { suggestion: approved, skill }
 }
 
 export function rejectSkillSuggestion(id: string): SkillSuggestion {
-  const suggestions = loadSkillSuggestions()
-  const suggestion = suggestions[id]
+  const suggestion = loadSkillSuggestion(id)
   if (!suggestion) throw new Error(`Skill suggestion "${id}" not found.`)
   const rejected: SkillSuggestion = {
     ...suggestion,
@@ -427,8 +425,7 @@ export function rejectSkillSuggestion(id: string): SkillSuggestion {
     rejectedAt: Date.now(),
     updatedAt: Date.now(),
   }
-  suggestions[id] = rejected
-  saveSkillSuggestions(suggestions)
+  upsertSkillSuggestion(id, rejected)
   notify('skill_suggestions')
   return rejected
 }

package/src/lib/server/storage-normalization.test.ts

@@ -1,270 +1,47 @@
 import assert from 'node:assert/strict'
-import { after, before, describe, it } from 'node:test'
-
-let normalizeStoredRecord: typeof import('@/lib/server/storage-normalization').normalizeStoredRecord
-
-const noopLoader = () => null
-
-before(async () => {
-  process.env.SWARMCLAW_BUILD_MODE = '1'
-  const mod = await import('@/lib/server/storage-normalization')
-  normalizeStoredRecord = mod.normalizeStoredRecord
-})
-
-after(() => {
-  delete process.env.SWARMCLAW_BUILD_MODE
-})
-
-describe('storage-normalization', () => {
-  // ---- Agent normalization ----
-  describe('agents', () => {
-    it('adds default capabilities, delegation, role, orgChart fields', () => {
-      const agent = { id: 'a1', name: 'Test' } as Record<string, unknown>
-      const result = normalizeStoredRecord('agents', agent, noopLoader).value as Record<string, unknown>
-      assert.deepEqual(result.capabilities, [])
-      assert.equal(result.role, 'worker')
-      assert.equal(result.delegationEnabled, false)
-      assert.equal(result.orgChart, null)
-      assert.ok(Array.isArray(result.tools))
-      assert.ok(Array.isArray(result.extensions))
-    })
-
-    it('preserves existing values', () => {
-      const agent = {
-        id: 'a1',
-        name: 'Test',
-        capabilities: ['web', 'code'],
-        role: 'coordinator',
-        delegationEnabled: true,
-        delegationTargetMode: 'all',
-        delegationTargetAgentIds: [],
-        orgChart: { parentId: 'p1', teamLabel: 'Eng', teamColor: '#fff', x: 10, y: 20 },
-      } as Record<string, unknown>
-      const result = normalizeStoredRecord('agents', agent, noopLoader).value as Record<string, unknown>
-      assert.deepEqual(result.capabilities, ['web', 'code'])
-      assert.equal(result.role, 'coordinator')
-      assert.equal(result.delegationEnabled, true)
-    })
-
-    it('coordinator always has delegation enabled', () => {
-      const agent = { id: 'a1', name: 'Test', role: 'coordinator', delegationEnabled: false } as Record<string, unknown>
-      const result = normalizeStoredRecord('agents', agent, noopLoader).value as Record<string, unknown>
-      assert.equal(result.delegationEnabled, true)
-    })
-
-    it('migrates legacy platformAssignScope', () => {
-      const agent = { id: 'a1', name: 'Test', platformAssignScope: 'all' } as Record<string, unknown>
-      const result = normalizeStoredRecord('agents', agent, noopLoader).value as Record<string, unknown>
-      assert.equal(result.delegationEnabled, true)
-      assert.equal(result.platformAssignScope, undefined)
-    })
-
-    it('migrates legacy subAgentIds to delegationTargetAgentIds', () => {
-      const agent = { id: 'a1', name: 'Test', subAgentIds: ['b1', 'b2'] } as Record<string, unknown>
-      const result = normalizeStoredRecord('agents', agent, noopLoader).value as Record<string, unknown>
-      assert.deepEqual(result.delegationTargetAgentIds, ['b1', 'b2'])
-      assert.equal(result.delegationTargetMode, 'selected')
-      assert.equal(result.subAgentIds, undefined)
-    })
-
-    it('deletes legacy plugins field', () => {
-      const agent = { id: 'a1', name: 'Test', plugins: ['old'] } as Record<string, unknown>
-      const result = normalizeStoredRecord('agents', agent, noopLoader).value as Record<string, unknown>
-      assert.equal(result.plugins, undefined)
-    })
-  })
-
-  // ---- Session normalization ----
-  describe('sessions', () => {
-    it('type migration orchestrated → delegated', () => {
-      const session = { id: 's1', sessionType: 'orchestrated' } as Record<string, unknown>
-      const result = normalizeStoredRecord('sessions', session, noopLoader).value as Record<string, unknown>
-      assert.equal(result.sessionType, 'delegated')
-    })
-
-    it('defaults invalid sessionType to human', () => {
-      const session = { id: 's1', sessionType: 'bogus' } as Record<string, unknown>
-      const result = normalizeStoredRecord('sessions', session, noopLoader).value as Record<string, unknown>
-      assert.equal(result.sessionType, 'human')
-    })
-
-    it('detects shortcut session from id prefix', () => {
-      const session = { id: 'agent-thread-abc', agentId: 'a1', sessionType: 'human' } as Record<string, unknown>
-      const result = normalizeStoredRecord('sessions', session, noopLoader).value as Record<string, unknown>
-      assert.equal(result.shortcutForAgentId, 'a1')
-    })
-
-    it('normalizes capabilities', () => {
-      const session = { id: 's1', sessionType: 'human', tools: ['web'] } as Record<string, unknown>
-      const result = normalizeStoredRecord('sessions', session, noopLoader).value as Record<string, unknown>
-      assert.ok(Array.isArray(result.tools))
-      assert.ok(Array.isArray(result.extensions))
-    })
-
-    it('deletes legacy plugins and mainLoopState', () => {
-      const session = { id: 's1', sessionType: 'human', plugins: ['old'], mainLoopState: {} } as Record<string, unknown>
-      const result = normalizeStoredRecord('sessions', session, noopLoader).value as Record<string, unknown>
-      assert.equal(result.plugins, undefined)
-      assert.equal(result.mainLoopState, undefined)
-    })
-  })
-
-  // ---- Schedule normalization ----
-  describe('schedules', () => {
-    it('type resolution from scheduleType', () => {
-      const schedule = { id: 'sch1', scheduleType: 'cron', status: 'active' } as Record<string, unknown>
-      const result = normalizeStoredRecord('schedules', schedule, noopLoader).value as Record<string, unknown>
-      assert.equal(result.scheduleType, 'cron')
-    })
-
-    it('legacy type field migrated', () => {
-      const schedule = { id: 'sch1', type: 'once', status: 'active' } as Record<string, unknown>
-      const result = normalizeStoredRecord('schedules', schedule, noopLoader).value as Record<string, unknown>
-      assert.equal(result.scheduleType, 'once')
-      assert.equal(result.type, undefined)
-    })
-
-    it('invalid status defaults to active', () => {
-      const schedule = { id: 'sch1', status: 'bogus' } as Record<string, unknown>
-      const result = normalizeStoredRecord('schedules', schedule, noopLoader).value as Record<string, unknown>
-      assert.equal(result.status, 'active')
-    })
-
-    it('timestamp parsing from number', () => {
-      const schedule = { id: 'sch1', status: 'active', lastRunAt: 1700000000000 } as Record<string, unknown>
-      const result = normalizeStoredRecord('schedules', schedule, noopLoader).value as Record<string, unknown>
-      assert.equal(result.lastRunAt, 1700000000000)
-    })
-  })
-
-  // ---- Task normalization ----
-  describe('tasks', () => {
-    it('subtaskIds default to empty array', () => {
-      const task = { id: 't1', title: 'Test' } as Record<string, unknown>
-      const result = normalizeStoredRecord('tasks', task, noopLoader).value as Record<string, unknown>
-      assert.deepEqual(result.subtaskIds, [])
-    })
-
-    it('preserves existing subtaskIds', () => {
-      const task = { id: 't1', title: 'Test', subtaskIds: ['t2'] } as Record<string, unknown>
-      const result = normalizeStoredRecord('tasks', task, noopLoader).value as Record<string, unknown>
-      assert.deepEqual(result.subtaskIds, ['t2'])
-    })
-
-    it('removes missionSummary field', () => {
-      const task = { id: 't1', missionSummary: 'old' } as Record<string, unknown>
-      const result = normalizeStoredRecord('tasks', task, noopLoader).value as Record<string, unknown>
-      assert.equal(result.missionSummary, undefined)
-    })
-  })
-
-  describe('provider_configs', () => {
-    it('defaults legacy custom provider configs to enabled with normalized fields', () => {
-      const providerConfig = {
-        id: 'custom-llama',
-        name: '  Llama.cpp  ',
-        type: 'custom',
-        baseUrl: ' http://localhost:8080/v1/ ',
-        models: [' llama-3.1-70b ', 'llama-3.1-70b', ''],
-      } as Record<string, unknown>
-      const result = normalizeStoredRecord('provider_configs', providerConfig, noopLoader).value as Record<string, unknown>
-      assert.equal(result.name, 'Llama.cpp')
-      assert.equal(result.baseUrl, 'http://localhost:8080/v1/')
-      assert.deepEqual(result.models, ['llama-3.1-70b'])
-      assert.equal(result.requiresApiKey, true)
-      assert.equal(result.isEnabled, true)
-      assert.equal(result.credentialId, null)
-    })
-
-    it('normalizes builtin override configs without treating them as custom providers', () => {
-      const providerConfig = {
-        id: 'openai',
-        type: 'builtin',
-        isEnabled: false,
-      } as Record<string, unknown>
-      const result = normalizeStoredRecord('provider_configs', providerConfig, noopLoader).value as Record<string, unknown>
-      assert.equal(result.type, 'builtin')
-      assert.equal(result.name, 'Built-in Provider')
-      assert.equal(result.baseUrl, '')
-      assert.deepEqual(result.models, [])
-      assert.equal(result.requiresApiKey, true)
-      assert.equal(result.isEnabled, false)
-      assert.equal(result.credentialId, null)
-    })
-
-    it('defaults createdAt and updatedAt for legacy records missing timestamps', () => {
-      const providerConfig = {
-        id: 'custom-old',
-        name: 'Old Provider',
-        type: 'custom',
-        baseUrl: 'http://localhost:8080/v1',
-        models: ['model-a'],
-      } as Record<string, unknown>
-      const result = normalizeStoredRecord('provider_configs', providerConfig, noopLoader).value as Record<string, unknown>
-      assert.equal(typeof result.createdAt, 'number')
-      assert.equal(typeof result.updatedAt, 'number')
-      assert.ok((result.createdAt as number) > 0)
-      assert.equal(result.updatedAt, result.createdAt)
-    })
-  })
-
-  // ---- Mission normalization ----
-  describe('missions', () => {
-    it('defaults status/phase/sourceRef', () => {
-      const mission = { id: 'm1' } as Record<string, unknown>
-      const result = normalizeStoredRecord('missions', mission, noopLoader).value as Record<string, unknown>
-      assert.equal(result.status, 'active')
-      assert.equal(result.phase, 'planning')
-      assert.deepEqual(result.sourceRef, { kind: 'manual' })
-    })
-
-    it('preserves valid status and phase', () => {
-      const mission = { id: 'm1', status: 'waiting', phase: 'executing' } as Record<string, unknown>
-      const result = normalizeStoredRecord('missions', mission, noopLoader).value as Record<string, unknown>
-      assert.equal(result.status, 'waiting')
-      assert.equal(result.phase, 'executing')
-    })
-
-    it('sourceRef from sessionId', () => {
-      const mission = { id: 'm1', sessionId: 'sess-1' } as Record<string, unknown>
-      const result = normalizeStoredRecord('missions', mission, noopLoader).value as Record<string, unknown>
-      assert.deepEqual(result.sourceRef, { kind: 'chat', sessionId: 'sess-1' })
-    })
-
-    it('waitState defaults', () => {
-      const mission = {
-        id: 'm1',
-        waitState: { kind: 'approval', reason: 'Needs sign-off' },
-      } as Record<string, unknown>
-      const result = normalizeStoredRecord('missions', mission, noopLoader).value as Record<string, unknown>
-      const ws = result.waitState as Record<string, unknown>
-      assert.equal(ws.kind, 'approval')
-      assert.equal(ws.reason, 'Needs sign-off')
-    })
-  })
-
-  // ---- DelegationJob normalization ----
-  describe('delegation_jobs', () => {
-    it('missionId cleanup', () => {
-      const job = { id: 'j1', missionId: '  m1  ' } as Record<string, unknown>
-      const result = normalizeStoredRecord('delegation_jobs', job, noopLoader).value as Record<string, unknown>
-      assert.equal(result.missionId, 'm1')
-    })
-
-    it('empty missionId is deleted', () => {
-      const job = { id: 'j1', missionId: '  ' } as Record<string, unknown>
-      const result = normalizeStoredRecord('delegation_jobs', job, noopLoader).value as Record<string, unknown>
-      assert.equal(result.missionId, undefined)
-    })
-  })
-
-  // ---- Unknown collection ----
-  describe('unknown collection', () => {
-    it('passes through unchanged', () => {
-      const data = { id: 'x1', foo: 'bar' }
-      const result = normalizeStoredRecord('widgets', data, noopLoader)
-      assert.deepEqual(result.value, data)
-      assert.equal(result.changed, false)
-    })
+import { describe, it } from 'node:test'
+
+import { normalizeStoredRecord } from '@/lib/server/storage-normalization'
+
+const loadItem = () => null
+
+describe('storage normalization for runtime execution records', () => {
+  it('backfills execution metadata on legacy runtime runs', () => {
+    const { value, changed } = normalizeStoredRecord('runtime_runs', {
+      id: 'run_1',
+      sessionId: 'sess_1',
+      source: 'task',
+      internal: false,
+      mode: 'followup',
+      status: 'queued',
+      messagePreview: 'Build the feature',
+      queuedAt: 123,
+    }, loadItem)
+
+    const record = value as Record<string, unknown>
+    assert.equal(changed, true)
+    assert.equal(record.kind, 'session_turn')
+    assert.equal(record.ownerType, 'session')
+    assert.equal(record.ownerId, 'sess_1')
+    assert.equal(record.parentExecutionId, null)
+    assert.equal(record.recoveryPolicy, 'restart_recoverable')
+  })
+
+  it('backfills execution metadata on legacy runtime run events', () => {
+    const { value, changed } = normalizeStoredRecord('runtime_run_events', {
+      id: 'evt_1',
+      runId: 'run_1',
+      sessionId: 'sess_1',
+      timestamp: 123,
+      phase: 'status',
+      event: { t: 'md', text: '{}' },
+    }, loadItem)
+
+    const record = value as Record<string, unknown>
+    assert.equal(changed, true)
+    assert.equal(record.kind, 'session_turn')
+    assert.equal(record.ownerType, 'session')
+    assert.equal(record.ownerId, 'sess_1')
+    assert.equal(record.parentExecutionId, null)
   })
 })

package/src/lib/server/storage-normalization.ts

@@ -369,6 +369,47 @@ function normalizeStoredDelegationJobRecord(value: unknown): unknown {
   return job
 }
 
+function normalizeStoredRuntimeRunRecord(value: unknown): unknown {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return value
+  const run = value as StoredObject
+
+  if (typeof run.kind !== 'string' || !run.kind.trim()) run.kind = 'session_turn'
+  if (run.ownerType === undefined) run.ownerType = 'session'
+  if (run.ownerId === undefined) {
+    const sessionId = typeof run.sessionId === 'string' && run.sessionId.trim() ? run.sessionId.trim() : ''
+    run.ownerId = sessionId || null
+  }
+  if (run.parentExecutionId === undefined) run.parentExecutionId = null
+  if (run.recoveryPolicy === undefined) {
+    const source = typeof run.source === 'string' ? run.source.trim().toLowerCase() : ''
+    run.recoveryPolicy = source === 'heartbeat'
+      || source === 'heartbeat-wake'
+      || source === 'schedule'
+      || source === 'task'
+      || source === 'delegation'
+      || source === 'subagent'
+      ? 'restart_recoverable'
+      : 'ephemeral'
+  }
+
+  return run
+}
+
+function normalizeStoredRuntimeRunEventRecord(value: unknown): unknown {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return value
+  const event = value as StoredObject
+
+  if (typeof event.kind !== 'string' || !event.kind.trim()) event.kind = 'session_turn'
+  if (event.ownerType === undefined) event.ownerType = 'session'
+  if (event.ownerId === undefined) {
+    const sessionId = typeof event.sessionId === 'string' && event.sessionId.trim() ? event.sessionId.trim() : ''
+    event.ownerId = sessionId || null
+  }
+  if (event.parentExecutionId === undefined) event.parentExecutionId = null
+
+  return event
+}
+
 // --- Main dispatch function ---
 
 export interface NormalizationResult {
@@ -393,6 +434,7 @@ export function normalizeStoredRecord(
     && table !== 'mission_events' && table !== 'delegation_jobs'
     && table !== 'schedules' && table !== 'sessions'
     && table !== 'provider_configs'
+    && table !== 'runtime_runs' && table !== 'runtime_run_events'
   ) {
     return { value, changed: false }
   }
@@ -517,6 +559,14 @@ function normalizeStoredRecordInner(
     return normalizeStoredDelegationJobRecord(value)
   }
 
+  if (table === 'runtime_runs') {
+    return normalizeStoredRuntimeRunRecord(value)
+  }
+
+  if (table === 'runtime_run_events') {
+    return normalizeStoredRuntimeRunEventRecord(value)
+  }
+
   if (table === 'schedules') {
     return normalizeStoredScheduleRecord(value, loadItem)
   }
@@ -547,11 +597,36 @@ function normalizeStoredRecordInner(
   if ('plugins' in session) delete session.plugins
   if ('mainLoopState' in session) delete session.mainLoopState
   if ('missionSummary' in session) delete session.missionSummary
+  // Messages are now stored in session_messages table — ensure default empty array
+  if (!Array.isArray(session.messages)) session.messages = []
+  // Default messageCount for pre-migration blobs
+  if (typeof session.messageCount !== 'number') {
+    session.messageCount = (session.messages as unknown[]).length
+  }
   // Default geminiSessionId for new field
   if (session.geminiSessionId === undefined) session.geminiSessionId = null
   // Default injectedMemoryIds for proactive recall dedup
   if (!session.injectedMemoryIds || typeof session.injectedMemoryIds !== 'object') {
     session.injectedMemoryIds = {}
   }
+  // Validate runContext if present — leave null/undefined alone (created on demand)
+  if (session.runContext != null) {
+    if (typeof session.runContext !== 'object' || Array.isArray(session.runContext)) {
+      session.runContext = null
+    } else {
+      const rc = session.runContext as Record<string, unknown>
+      if (typeof rc.objective !== 'string' && rc.objective !== null) rc.objective = null
+      if (!Array.isArray(rc.constraints)) rc.constraints = []
+      if (!Array.isArray(rc.keyFacts)) rc.keyFacts = []
+      if (!Array.isArray(rc.discoveries)) rc.discoveries = []
+      if (!Array.isArray(rc.failedApproaches)) rc.failedApproaches = []
+      if (!Array.isArray(rc.currentPlan)) rc.currentPlan = []
+      if (!Array.isArray(rc.completedSteps)) rc.completedSteps = []
+      if (!Array.isArray(rc.blockers)) rc.blockers = []
+      if (typeof rc.parentContext !== 'string' && rc.parentContext !== null) rc.parentContext = null
+      if (typeof rc.updatedAt !== 'number') rc.updatedAt = Date.now()
+      if (typeof rc.version !== 'number') rc.version = 0
+    }
+  }
   return session
 }

package/src/lib/server/storage.ts

@@ -100,6 +100,9 @@ export function withTransaction<T>(fn: () => T): T {
   return wrapped()
 }
 
+/** Internal: raw database handle for specialized repositories (e.g. message-repository). */
+export function getDb(): InstanceType<typeof Database> { return db }
+
 type StoredObject = Record<string, unknown>
 type StoredSessionRecord = Session
 type StoredAgentRecord = Agent
@@ -157,6 +160,8 @@ const COLLECTIONS = [
   'provider_health',
   'swarm_snapshots',
   'main_loop_states',
+  'working_states',
+  'daemon_status',
 ] as const
 
 export type StorageCollection = (typeof COLLECTIONS)[number]
@@ -180,6 +185,14 @@ db.exec(`CREATE TABLE IF NOT EXISTS runtime_locks (
   updated_at INTEGER NOT NULL
 )`)
 
+// Relational message storage — messages extracted from session blobs (Phase 1)
+db.exec(`CREATE TABLE IF NOT EXISTS session_messages (
+  session_id TEXT NOT NULL,
+  seq INTEGER NOT NULL,
+  data TEXT NOT NULL,
+  PRIMARY KEY (session_id, seq)
+) WITHOUT ROWID`)
+
 // --- Internal normalize helper that binds the loadItem dependency ---
 function normalize(table: string, value: unknown): NormalizationResult {
   return normalizeStoredRecord(table, value, loadCollectionItem)
@@ -1594,6 +1607,12 @@ export const loadPersistedMainLoopState = mainLoopStatesStore.loadItem
 export const upsertPersistedMainLoopState = mainLoopStatesStore.upsert
 export const deletePersistedMainLoopState = mainLoopStatesStore.deleteItem
 
+// --- Working States ---
+const workingStatesStore = createCollectionStore('working_states')
+export const loadPersistedWorkingState = workingStatesStore.loadItem
+export const upsertPersistedWorkingState = workingStatesStore.upsert
+export const deletePersistedWorkingState = workingStatesStore.deleteItem
+
 export function getSessionMessages(sessionId: string): Message[] {
   const session = loadSession(sessionId)
   return Array.isArray(session?.messages) ? session.messages : []

package/src/lib/server/structured-extract.ts

@@ -1,6 +1,6 @@
 import type { Session } from '@/types'
 import { getProvider, streamChatWithFailover } from '@/lib/providers'
-import { decryptKey, loadCredentials } from './storage'
+import { requireCredentialSecret, resolveCredentialSecret } from './credentials/credential-service'
 import { extractDocumentArtifact, type DocumentArtifact } from './document-utils'
 
 type JsonSchemaLike = Record<string, unknown>
@@ -31,21 +31,10 @@ function resolveApiKey(session: ExtractionSession): string | null {
   if (!provider) throw new Error(`Unknown provider: ${session.provider}`)
   if (provider.requiresApiKey) {
     if (!session.credentialId) throw new Error('No API key configured for this session')
-    const creds = loadCredentials()
-    const cred = creds[session.credentialId]
-    if (!cred?.encryptedKey) throw new Error('API key not found. Please add one in Settings.')
-    return decryptKey(cred.encryptedKey)
+    return requireCredentialSecret(session.credentialId, 'API key not found. Please add one in Settings.')
   }
   if (provider.optionalApiKey && session.credentialId) {
-    const creds = loadCredentials()
-    const cred = creds[session.credentialId]
-    if (cred?.encryptedKey) {
-      try {
-        return decryptKey(cred.encryptedKey)
-      } catch {
-        return null
-      }
-    }
+    return resolveCredentialSecret(session.credentialId)
   }
   return null
 }