@swarmclawai/swarmclaw 1.2.4 → 1.2.6

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

@@ -0,0 +1,330 @@
+import type { Message, Session } from '@/types'
+import { perf } from '@/lib/server/runtime/perf'
+import { log } from '@/lib/server/logger'
+import { getDb, withTransaction, loadSession, patchSession } from '@/lib/server/storage'
+import { notify } from '@/lib/server/ws-hub'
+
+const TAG = 'message-repo'
+const MAX_SUMMARY_TEXT = 280
+
+// ---------------------------------------------------------------------------
+// Prepared statements — lazily created so the db is fully initialised first
+// ---------------------------------------------------------------------------
+
+type Stmts = ReturnType<typeof buildStatements>
+let _stmts: Stmts | null = null
+
+function stmts(): Stmts {
+  if (!_stmts) _stmts = buildStatements()
+  return _stmts
+}
+
+function buildStatements() {
+  const db = getDb()
+  return {
+    selectAll: db.prepare(
+      'SELECT data FROM session_messages WHERE session_id = ? ORDER BY seq ASC',
+    ),
+    selectCount: db.prepare(
+      'SELECT COUNT(*) as count FROM session_messages WHERE session_id = ?',
+    ),
+    selectLast: db.prepare(
+      'SELECT data FROM session_messages WHERE session_id = ? ORDER BY seq DESC LIMIT 1',
+    ),
+    selectRecent: db.prepare(
+      'SELECT data FROM session_messages WHERE session_id = ? ORDER BY seq DESC LIMIT ?',
+    ),
+    selectMaxSeq: db.prepare(
+      'SELECT MAX(seq) as maxSeq FROM session_messages WHERE session_id = ?',
+    ),
+    insert: db.prepare(
+      'INSERT INTO session_messages (session_id, seq, data) VALUES (?, ?, ?)',
+    ),
+    update: db.prepare(
+      'UPDATE session_messages SET data = ? WHERE session_id = ? AND seq = ?',
+    ),
+    deleteAfter: db.prepare(
+      'DELETE FROM session_messages WHERE session_id = ? AND seq > ?',
+    ),
+    deleteAll: db.prepare(
+      'DELETE FROM session_messages WHERE session_id = ?',
+    ),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+function nextSeq(sessionId: string): number {
+  const row = stmts().selectMaxSeq.get(sessionId) as { maxSeq: number | null } | undefined
+  return (row?.maxSeq ?? -1) + 1
+}
+
+function rowCount(sessionId: string): number {
+  return (stmts().selectCount.get(sessionId) as { count: number }).count
+}
+
+function parseMsg(raw: string): Message | null {
+  try {
+    return JSON.parse(raw) as Message
+  } catch {
+    return null
+  }
+}
+
+function summarizeForMeta(message: Message): Message {
+  return {
+    role: message.role,
+    text: typeof message.text === 'string' ? message.text.slice(0, MAX_SUMMARY_TEXT) : '',
+    time: message.time,
+    kind: message.kind,
+    source: message.source,
+    suppressed: message.suppressed,
+    streaming: message.streaming,
+    bookmarked: message.bookmarked,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Session metadata sync — keeps messageCount / lastMessageSummary on the blob
+// ---------------------------------------------------------------------------
+
+function syncSessionMeta(sessionId: string): void {
+  const count = rowCount(sessionId)
+  const lastRow = stmts().selectLast.get(sessionId) as { data: string } | undefined
+  const lastMsg = lastRow ? parseMsg(lastRow.data) : null
+
+  patchSession(sessionId, (current) => {
+    if (!current) return null
+    current.messageCount = count
+    current.lastMessageSummary = lastMsg ? summarizeForMeta(lastMsg) : null
+    if (lastMsg?.role === 'assistant' && typeof lastMsg.time === 'number') {
+      current.lastAssistantAt = lastMsg.time
+    }
+    current.lastActiveAt = Date.now()
+    return current
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Lazy migration — copies blob messages → table on first access
+// ---------------------------------------------------------------------------
+
+function ensureMigrated(sessionId: string): void {
+  if (rowCount(sessionId) > 0) return
+  lazyMigrateSession(sessionId)
+}
+
+function lazyMigrateSession(sessionId: string): Message[] | null {
+  const session = loadSession(sessionId)
+  if (!session || !Array.isArray(session.messages) || session.messages.length === 0) {
+    return null
+  }
+
+  const messages = session.messages
+  log.info(TAG, `Lazy-migrating ${messages.length} messages for session ${sessionId}`)
+
+  withTransaction(() => {
+    // Double-check inside transaction to prevent duplicate migration
+    if (rowCount(sessionId) > 0) return
+
+    const ins = stmts().insert
+    for (let i = 0; i < messages.length; i++) {
+      ins.run(sessionId, i, JSON.stringify(messages[i]))
+    }
+
+    // Compute metadata on the blob (keep messages intact for backward compat)
+    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
+      }
+    }
+
+    patchSession(sessionId, (current) => {
+      if (!current) return null
+      current.messageCount = messages.length
+      current.lastMessageSummary = lastMsg ? summarizeForMeta(lastMsg) : null
+      if (lastAssistantAt !== null && typeof current.lastAssistantAt !== 'number') {
+        current.lastAssistantAt = lastAssistantAt
+      }
+      return current
+    })
+  })
+
+  return messages
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/** Return all messages for a session, ordered by sequence. */
+export function getMessages(sessionId: string): Message[] {
+  return perf.measureSync('message-repo', 'getMessages', () => {
+    const rows = stmts().selectAll.all(sessionId) as Array<{ data: string }>
+
+    // Lazy migration: populate table from session blob on first read
+    if (rows.length === 0) {
+      const migrated = lazyMigrateSession(sessionId)
+      if (migrated) return migrated
+    }
+
+    const out: Message[] = []
+    for (const row of rows) {
+      const m = parseMsg(row.data)
+      if (m) out.push(m)
+    }
+    return out
+  }, { sessionId })
+}
+
+/** Return message count (from table, with blob fallback pre-migration). */
+export function getMessageCount(sessionId: string): number {
+  return perf.measureSync('message-repo', 'getMessageCount', () => {
+    const count = rowCount(sessionId)
+    if (count > 0) return count
+    // Pre-migration fallback
+    const session = loadSession(sessionId)
+    return Array.isArray(session?.messages) ? session.messages.length : 0
+  }, { sessionId })
+}
+
+/** Return the last message (from table, with blob fallback). */
+export function getLastMessage(sessionId: string): Message | null {
+  return perf.measureSync('message-repo', 'getLastMessage', () => {
+    const row = stmts().selectLast.get(sessionId) as { data: string } | undefined
+    if (row) return parseMsg(row.data)
+    const session = loadSession(sessionId)
+    const msgs = session?.messages
+    return Array.isArray(msgs) && msgs.length > 0 ? msgs[msgs.length - 1] : null
+  }, { sessionId })
+}
+
+/** Return the last N messages in chronological order. */
+export function getRecentMessages(sessionId: string, n: number): Message[] {
+  return perf.measureSync('message-repo', 'getRecentMessages', () => {
+    const rows = stmts().selectRecent.all(sessionId, n) as Array<{ data: string }>
+    if (rows.length > 0) {
+      const out: Message[] = []
+      for (const row of rows) {
+        const m = parseMsg(row.data)
+        if (m) out.push(m)
+      }
+      return out.reverse() // DESC → ASC
+    }
+    // Pre-migration fallback
+    const session = loadSession(sessionId)
+    return Array.isArray(session?.messages) ? session.messages.slice(-n) : []
+  }, { sessionId, n })
+}
+
+/** Append a single message. Returns the assigned sequence number. */
+export function appendMessage(sessionId: string, message: Message): number {
+  return perf.measureSync('message-repo', 'appendMessage', () => {
+    ensureMigrated(sessionId)
+    const seq = nextSeq(sessionId)
+    stmts().insert.run(sessionId, seq, JSON.stringify(message))
+    syncSessionMeta(sessionId)
+    notify('messages', 'append', sessionId)
+    return seq
+  }, { sessionId })
+}
+
+/** Append multiple messages in a single transaction. */
+export function appendMessages(sessionId: string, messages: Message[]): void {
+  if (!messages.length) return
+  perf.measureSync('message-repo', 'appendMessages', () => {
+    ensureMigrated(sessionId)
+    withTransaction(() => {
+      let seq = nextSeq(sessionId)
+      const ins = stmts().insert
+      for (const msg of messages) {
+        ins.run(sessionId, seq++, JSON.stringify(msg))
+      }
+    })
+    syncSessionMeta(sessionId)
+    notify('messages', 'append', sessionId)
+  }, { sessionId, count: messages.length })
+}
+
+/** Replace the message at a given sequence number (e.g. replace-last-assistant). */
+export function replaceMessageAt(sessionId: string, seq: number, message: Message): void {
+  perf.measureSync('message-repo', 'replaceMessageAt', () => {
+    stmts().update.run(JSON.stringify(message), sessionId, seq)
+    syncSessionMeta(sessionId)
+    notify('messages', 'update', sessionId)
+  }, { sessionId, seq })
+}
+
+/** Delete all messages with seq > the given value (edit-and-resend). */
+export function truncateAfter(sessionId: string, seq: number): void {
+  perf.measureSync('message-repo', 'truncateAfter', () => {
+    stmts().deleteAfter.run(sessionId, seq)
+    syncSessionMeta(sessionId)
+    notify('messages', 'truncate', sessionId)
+  }, { sessionId, seq })
+}
+
+/** Remove all messages for a session. */
+export function clearMessages(sessionId: string): void {
+  perf.measureSync('message-repo', 'clearMessages', () => {
+    stmts().deleteAll.run(sessionId)
+    syncSessionMeta(sessionId)
+    notify('messages', 'clear', sessionId)
+  }, { sessionId })
+}
+
+/** Replace the entire message list (used after in-memory prune operations). */
+export function replaceAllMessages(sessionId: string, messages: Message[]): void {
+  perf.measureSync('message-repo', 'replaceAllMessages', () => {
+    withTransaction(() => {
+      stmts().deleteAll.run(sessionId)
+      const ins = stmts().insert
+      for (let i = 0; i < messages.length; i++) {
+        ins.run(sessionId, i, JSON.stringify(messages[i]))
+      }
+    })
+    syncSessionMeta(sessionId)
+    notify('messages', 'replace', sessionId)
+  }, { sessionId, count: messages.length })
+}
+
+/** Cleanup: delete all rows for a session (called on session delete). */
+export function deleteSessionMessages(sessionId: string): void {
+  stmts().deleteAll.run(sessionId)
+}
+
+// ---------------------------------------------------------------------------
+// Bulk migration (for CLI / admin endpoint)
+// ---------------------------------------------------------------------------
+
+export function migrateAllSessions(): { migrated: 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 skipped = 0
+
+  for (const row of rows) {
+    try {
+      const session = JSON.parse(row.data) as Session
+      if (!Array.isArray(session.messages) || session.messages.length === 0) {
+        skipped++
+        continue
+      }
+      if (rowCount(row.id) > 0) {
+        skipped++
+        continue
+      }
+      lazyMigrateSession(row.id)
+      migrated++
+    } catch {
+      skipped++
+    }
+  }
+
+  return { migrated, skipped, total: rows.length }
+}

package/src/lib/server/missions/mission-service/core.ts

@@ -18,6 +18,7 @@ import type {
   SessionQueuedTurn,
   SessionRunRecord,
 } from '@/types'
+import { getMessages } from '@/lib/server/messages/message-repository'
 import { loadApprovals } from '@/lib/server/approvals/approval-repository'
 import { loadDelegationJob } from '@/lib/server/agents/delegation-job-repository'
 import { logActivity } from '@/lib/server/activity/activity-log'
@@ -49,6 +50,8 @@ import { errorMessage, hmrSingleton } from '@/lib/shared-utils'
 import { getSessionQueueSnapshot, listRuns } from '@/lib/server/runtime/session-run-manager'
 import { loadTask, loadTasks, patchTask } from '@/lib/server/tasks/task-repository'
 import { notify } from '@/lib/server/ws-hub'
+import { buildExecutionBrief, buildExecutionBriefContextBlock } from '@/lib/server/execution-brief'
+import { cleanText } from '@/lib/server/text-normalization'
 
 const TAG = 'mission-service'
 
@@ -56,10 +59,6 @@ function now(): number {
   return Date.now()
 }
 
-function cleanText(value: unknown, max = 320): string {
-  return typeof value === 'string' ? value.replace(/\s+/g, ' ').trim().slice(0, max) : ''
-}
-
 function uniqueStrings(values: unknown, maxItems: number, maxChars = 180): string[] {
   const source = Array.isArray(values) ? values : []
   const out: string[] = []
@@ -1571,7 +1570,7 @@ export async function resolveMissionForTurn(params: {
       sessionId: params.session.id,
       agentId: params.session.agentId || null,
       message: params.message,
-      recentMessages: Array.isArray(params.session.messages) ? params.session.messages : [],
+      recentMessages: getMessages(params.session.id),
       currentMission: currentMission ? buildMissionSummary(currentMission) : null,
       session: params.session,
     }, params.generateText ? { generateText: params.generateText } : undefined)
@@ -2254,7 +2253,10 @@ export function buildMissionContextBlock(mission: Mission | null | undefined): s
 export function buildMissionHeartbeatPrompt(session: Session, fallbackPrompt: string): string | null {
   const mission = getMissionForSession(session)
   if (!mission || isMissionTerminal(mission.status)) return null
-  const contextBlock = buildMissionContextBlock(mission)
+  const contextBlock = buildExecutionBriefContextBlock(buildExecutionBrief({
+    session,
+    mission,
+  }))
   return [
     'MAIN_AGENT_HEARTBEAT_TICK',
     `Time: ${new Date().toISOString()}`,

package/src/lib/server/openclaw/agent-resolver.ts

@@ -1,7 +1,7 @@
 import type { Agent } from '@/types'
 import { normalizeOpenClawAgentId } from '@/lib/openclaw/openclaw-agent-id'
+import { loadAgent } from '@/lib/server/agents/agent-repository'
 import { ensureGatewayConnected, type OpenClawGateway } from './gateway'
-import { loadAgents } from '../storage'
 
 export interface OpenClawGatewayAgentSummary {
   id: string
@@ -101,8 +101,7 @@ export async function resolveOpenClawGatewayAgentId(
     throw new Error('Missing agentId')
   }
 
-  const localAgents = loadAgents({ includeTrashed: true }) as Record<string, Agent>
-  const localAgent = localAgents[trimmedRef] || null
+  const localAgent = loadAgent(trimmedRef, { includeTrashed: true }) as Agent | null
   if (localAgent && localAgent.provider !== 'openclaw') {
     throw new Error(`Agent "${localAgent.name}" is not an OpenClaw agent`)
   }

package/src/lib/server/openclaw/doctor.ts

@@ -2,7 +2,7 @@ import { execFile } from 'child_process'
 import { promisify } from 'util'
 import * as path from 'path'
 import * as os from 'os'
-import { loadSettings } from '../storage'
+import { loadSettings } from '../settings/settings-repository'
 
 const execFileAsync = promisify(execFile)
 

package/src/lib/server/openclaw/gateway.test.ts

@@ -1,8 +1,9 @@
 import assert from 'node:assert/strict'
-import { afterEach, test } from 'node:test'
+import { afterEach, beforeEach, test } from 'node:test'
 
 import type { Agent, GatewayProfile } from '@/types'
 import {
+  deleteAgent,
   encryptKey,
   loadAgents,
   loadCredentials,
@@ -24,6 +25,14 @@ const originalCredentials = loadCredentials()
 const originalGateways = loadGatewayProfiles()
 const originalAgents = loadAgents({ includeTrashed: true })
 
+beforeEach(() => {
+  saveCredentials({})
+  saveGatewayProfiles({})
+  for (const agentId of Object.keys(loadAgents({ includeTrashed: true }))) {
+    deleteAgent(agentId)
+  }
+})
+
 afterEach(() => {
   disconnectGateway()
   saveCredentials(originalCredentials)

package/src/lib/server/openclaw/gateway.ts

@@ -2,7 +2,8 @@ import { WebSocket } from 'ws'
 import { randomUUID } from 'crypto'
 import { wsConnect } from '@/lib/providers/openclaw'
 import { deriveOpenClawWsUrl } from '@/lib/openclaw/openclaw-endpoint'
-import { loadAgents, loadCredentials, decryptKey } from '../storage'
+import { loadAgent, loadAgents } from '@/lib/server/agents/agent-repository'
+import { resolveCredentialSecret } from '@/lib/server/credentials/credential-service'
 import { notify, notifyWithPayload } from '../ws-hub'
 import { getGatewayProfile, getGatewayProfiles, resolvePrimaryAgentRoute } from '@/lib/server/agents/agent-runtime-config'
 import { isAgentDisabled } from '@/lib/server/agents/agent-availability'
@@ -80,16 +81,7 @@ function normalizeWsUrl(raw: string): string {
 }
 
 function resolveTokenForCredential(credentialId?: string | null): string | undefined {
-  const id = typeof credentialId === 'string' && credentialId.trim() ? credentialId.trim() : ''
-  if (!id) return undefined
-  const creds = loadCredentials()
-  const cred = creds[id]
-  if (!cred?.encryptedKey) return undefined
-  try {
-    return decryptKey(cred.encryptedKey)
-  } catch {
-    return undefined
-  }
+  return resolveCredentialSecret(credentialId) || undefined
 }
 
 export function resolveGatewayConfig(target?: {
@@ -110,8 +102,7 @@ export function resolveGatewayConfig(target?: {
 
   const agentId = typeof target?.agentId === 'string' ? target.agentId.trim() : ''
   if (agentId) {
-    const agents = loadAgents({ includeTrashed: true })
-    const agent = agents[agentId] as Agent | undefined
+    const agent = loadAgent(agentId, { includeTrashed: true }) as Agent | null
     const config = agent ? buildGatewayConfigFromAgent(agent, { allowDisabled: true, allowTrashed: true }) : null
     if (config) return config
   }
@@ -236,7 +227,7 @@ export class OpenClawGateway {
   }
 
   private rejectAllPending(reason: string) {
-    for (const [id, p] of this.pending) {
+    for (const p of this.pending.values()) {
       clearTimeout(p.timer)
       p.reject(new Error(reason))
     }

package/src/lib/server/openclaw/health.ts

@@ -1,6 +1,7 @@
 import { deriveOpenClawWsUrl, normalizeOpenClawEndpoint } from '@/lib/openclaw/openclaw-endpoint'
 import { wsConnect } from '@/lib/providers/openclaw'
-import { decryptKey, loadCredentials, loadGatewayProfiles, saveGatewayProfiles } from '../storage'
+import { resolveCredentialSecret } from '@/lib/server/credentials/credential-service'
+import { loadGatewayProfiles, saveGatewayProfiles } from '@/lib/server/gateways/gateway-profile-repository'
 import { notify } from '../ws-hub'
 import type { GatewayProfile } from '@/types'
 
@@ -60,16 +61,7 @@ function getErrorMessage(err: unknown): string | undefined {
 }
 
 function resolveCredentialToken(credentialId?: string | null): string | null {
-  const id = normalizeToken(credentialId)
-  if (!id) return null
-  const credentials = loadCredentials()
-  const credential = credentials[id]
-  if (!credential?.encryptedKey) return null
-  try {
-    return decryptKey(credential.encryptedKey)
-  } catch {
-    return null
-  }
+  return resolveCredentialSecret(normalizeToken(credentialId))
 }
 
 function extractModels(payload: unknown): string[] {

package/src/lib/server/openclaw/sync.ts

@@ -4,8 +4,11 @@ import path from 'node:path'
 import crypto from 'node:crypto'
 import { DATA_DIR } from '../data-dir'
 import { normalizeOpenClawAgentId } from '@/lib/openclaw/openclaw-agent-id'
-import { loadSettings, loadAgents, upsertAgent, loadSchedules, upsertSchedules, loadCredentials, decryptKey, encryptKey } from '../storage'
+import { loadAgents, upsertAgent } from '@/lib/server/agents/agent-repository'
+import { decryptKey, encryptKey, loadCredentials, saveCredentials } from '@/lib/server/credentials/credential-repository'
 import { getMemoryDb } from '@/lib/server/memory/memory-db'
+import { loadSchedules, upsertSchedules } from '@/lib/server/schedules/schedule-repository'
+import { loadSettings } from '@/lib/server/settings/settings-repository'
 import type { AppSettings, MemoryEntry, Schedule } from '@/types'
 
 export interface OpenClawSyncConfig {
@@ -289,7 +292,7 @@ export function pullSchedulesFromOpenClaw(): { imported: number } {
     if (existingNames.has(key)) continue
 
     const id = crypto.randomUUID()
-    const schedule = {
+    const schedule: Schedule = {
       id,
       name: job.name,
       agentId: job.agentId || '',
@@ -299,8 +302,8 @@ export function pullSchedulesFromOpenClaw(): { imported: number } {
       status: 'active',
       createdAt: Date.now(),
     }
-    schedules[id] = schedule as any
-    importedEntries.push([id, schedule as any])
+    schedules[id] = schedule
+    importedEntries.push([id, schedule])
     existingNames.add(key)
     imported++
   }
@@ -324,8 +327,7 @@ export async function pullCredentialsFromOpenClaw(): Promise<{ imported: number
     return { imported: 0 }
   }
 
-  const { loadCredentials: loadCreds, saveCredentials } = await import('../storage')
-  const creds = loadCreds()
+  const creds = loadCredentials()
   const existingProviders = new Set(Object.values(creds).map((c: Record<string, unknown>) => c.provider))
   let imported = 0
 

package/src/lib/server/persistence/storage-context.ts

@@ -4,6 +4,7 @@ import { agentRepository } from '@/lib/server/agents/agent-repository'
 import { approvalRepository } from '@/lib/server/approvals/approval-repository'
 import { chatroomRepository } from '@/lib/server/chatrooms/chatroom-repository'
 import { connectorRepository } from '@/lib/server/connectors/connector-repository'
+import * as messageRepository from '@/lib/server/messages/message-repository'
 import { missionEventRepository, missionRepository } from '@/lib/server/missions/mission-repository'
 import { projectRepository } from '@/lib/server/projects/project-repository'
 import { scheduleRepository } from '@/lib/server/schedules/schedule-repository'
@@ -17,6 +18,7 @@ export interface StorageTxContext {
   approvals: typeof approvalRepository
   chatrooms: typeof chatroomRepository
   connectors: typeof connectorRepository
+  messages: typeof messageRepository
   missions: typeof missionRepository
   missionEvents: typeof missionEventRepository
   projects: typeof projectRepository
@@ -34,6 +36,7 @@ export function createStorageTxContext(): StorageTxContext {
     approvals: approvalRepository,
     chatrooms: chatroomRepository,
     connectors: connectorRepository,
+    messages: messageRepository,
     missions: missionRepository,
     missionEvents: missionEventRepository,
     projects: projectRepository,

package/src/lib/server/protocols/protocol-agent-turn.ts

@@ -29,14 +29,19 @@ import {
 import { streamAgentChat } from '@/lib/server/chat-execution/stream-agent-chat'
 import { shouldSuppressHiddenControlText, stripHiddenControlTokens } from '@/lib/server/agents/assistant-control'
 import { resolvePrimaryAgentRoute } from '@/lib/server/agents/agent-runtime-config'
+import { getAgent, getAgents } from '@/lib/server/agents/agent-repository'
 import { buildLLM } from '@/lib/server/build-llm'
 import {
-  loadAgents,
-  loadChatrooms,
-  patchProtocolRun,
+  loadChatroom,
+  patchChatroom,
   upsertChatroom,
+} from '@/lib/server/chatrooms/chatroom-repository'
+import {
+  loadProtocolRunEventsByRunId,
+  patchProtocolRun,
+  upsertProtocolRun,
   upsertProtocolRunEvent,
-} from '@/lib/server/storage'
+} from '@/lib/server/protocols/protocol-run-repository'
 import { notify } from '@/lib/server/ws-hub'
 import { errorMessage } from '@/lib/shared-utils'
 import { AGENT_TURN_TIMEOUT_MS, cleanText, now } from '@/lib/server/protocols/protocol-types'
@@ -76,22 +81,24 @@ export function appendProtocolEvent(runId: string, event: Omit<ProtocolRunEvent,
 }
 
 export function listEvents(runId: string): ProtocolRunEvent[] {
-  const { loadProtocolRunEventsByRunId } = require('@/lib/server/storage') as typeof import('@/lib/server/storage')
   return loadProtocolRunEventsByRunId(runId)
 }
 
 export function appendTranscriptMessage(chatroomId: string, message: Omit<ChatroomMessage, 'id' | 'time'>, deps?: ProtocolRunDeps): ChatroomMessage | null {
-  const chatrooms = loadChatrooms()
-  const chatroom = chatrooms[chatroomId]
-  if (!chatroom) return null
   const nextMessage: ChatroomMessage = {
     ...message,
     id: genId(),
     time: now(deps),
   }
-  chatroom.messages = Array.isArray(chatroom.messages) ? [...chatroom.messages, nextMessage] : [nextMessage]
-  chatroom.updatedAt = nextMessage.time
-  upsertChatroom(chatroomId, chatroom)
+  const updated = patchChatroom(chatroomId, (current) => {
+    if (!current) return null
+    return {
+      ...current,
+      messages: Array.isArray(current.messages) ? [...current.messages, nextMessage] : [nextMessage],
+      updatedAt: nextMessage.time,
+    }
+  })
+  if (!updated) return null
   notify(`chatroom:${chatroomId}`)
   return nextMessage
 }
@@ -184,8 +191,7 @@ export async function defaultExecuteAgentTurn(params: {
   agentId: string
   prompt: string
 }): Promise<ProtocolAgentTurnResult> {
-  const agents = loadAgents() as Record<string, Agent>
-  const agent = agents[params.agentId]
+  const agent = getAgent(params.agentId) as Agent | null
   if (!agent) throw new Error(`Agent not found: ${params.agentId}`)
   let run = params.run
   if (!run.transcriptChatroomId) {
@@ -201,8 +207,12 @@ export async function defaultExecuteAgentTurn(params: {
       updatedAt: Date.now(),
     })
   }
-  const chatroom = loadChatrooms()[run.transcriptChatroomId!]
+  const chatroom = loadChatroom(run.transcriptChatroomId!)
   if (!chatroom) throw new Error(`Structured session transcript room not found: ${run.transcriptChatroomId}`)
+  const agents = {
+    ...getAgents(chatroom.agentIds),
+    [agent.id]: agent,
+  } as Record<string, Agent>
 
   const route = resolvePrimaryAgentRoute(agent)
   const apiKey = resolveApiKey(route?.credentialId || agent.credentialId)
@@ -369,8 +379,7 @@ export function createTranscriptRoom(input: {
   participantAgentIds: string[]
   parentChatroomId?: string | null
 }, deps?: ProtocolRunDeps): Chatroom {
-  const chatrooms = loadChatrooms()
-  const parentChatroom = input.parentChatroomId ? chatrooms[input.parentChatroomId] || null : null
+  const parentChatroom = input.parentChatroomId ? loadChatroom(input.parentChatroomId) : null
   const room: Chatroom = {
     id: genId(),
     name: transcriptRoomName(input.title, parentChatroom),
@@ -404,7 +413,6 @@ export function createArtifact(run: ProtocolRun, phase: ProtocolPhaseDefinition,
 
 export function persistRun(run: ProtocolRun): ProtocolRun {
   const normalized = normalizeProtocolRun(run)
-  const { upsertProtocolRun } = require('@/lib/server/storage') as typeof import('@/lib/server/storage')
   upsertProtocolRun(normalized.id, normalized)
   notify('protocol_runs')
   notify(`protocol_run:${normalized.id}`)