@swarmclawai/swarmclaw 1.2.1 → 1.2.2

package/src/lib/server/agents/agent-cascade.ts

@@ -3,22 +3,21 @@
  *
  * When an agent is trashed, related entities (tasks, schedules, watch jobs,
  * connectors, webhooks, delegation jobs, chatroom memberships) must be
- * suspended to prevent phantom daemon activity.  On permanent delete the
+ * suspended to prevent phantom daemon activity. On permanent delete the
  * referencing rows are hard-removed.
  */
 
 import {
-  loadTasks,
-  upsertStoredItems,
-  loadSchedules,
-  loadWatchJobs,
-  loadConnectors,
+  deleteDelegationJob,
   loadDelegationJobs,
-  loadWebhooks,
-  loadChatrooms,
-  deleteStoredItem,
-} from '@/lib/server/storage'
-import type { StorageCollection } from '@/lib/server/storage'
+  saveDelegationJobRecords,
+} from '@/lib/server/agents/delegation-job-repository'
+import { loadChatrooms, saveChatrooms } from '@/lib/server/chatrooms/chatroom-repository'
+import { loadConnectors, saveConnectors } from '@/lib/server/connectors/connector-repository'
+import { deleteWatchJob, loadWatchJobs, upsertWatchJobs } from '@/lib/server/runtime/watch-job-repository'
+import { deleteSchedule, loadSchedules, upsertSchedules } from '@/lib/server/schedules/schedule-repository'
+import { deleteTask, loadTasks, saveTaskMany } from '@/lib/server/tasks/task-repository'
+import { loadWebhooks, saveWebhooks } from '@/lib/server/webhooks/webhook-repository'
 
 interface CascadeCounts {
   tasks: number
@@ -39,7 +38,7 @@ export function suspendAgentReferences(agentId: string): CascadeCounts {
 
   // 1. Tasks — cancel active ones
   const tasks = loadTasks()
-  const taskUpdates: Array<[string, unknown]> = []
+  const taskUpdates: Array<[string, Record<string, unknown>]> = []
   for (const t of Object.values(tasks) as unknown as Array<Record<string, unknown>>) {
     if (!t || t.agentId !== agentId) continue
     const status = t.status as string | undefined
@@ -50,13 +49,13 @@ export function suspendAgentReferences(agentId: string): CascadeCounts {
     }
   }
   if (taskUpdates.length) {
-    upsertStoredItems('tasks', taskUpdates)
+    saveTaskMany(taskUpdates)
     counts.tasks = taskUpdates.length
   }
 
   // 2. Schedules — pause (with marker for restore)
   const schedules = loadSchedules()
-  const schedUpdates: Array<[string, unknown]> = []
+  const schedUpdates: Array<[string, Record<string, unknown>]> = []
   for (const s of Object.values(schedules) as unknown as Array<Record<string, unknown>>) {
     if (!s || s.agentId !== agentId) continue
     if (s.enabled === false) continue
@@ -65,13 +64,13 @@ export function suspendAgentReferences(agentId: string): CascadeCounts {
     schedUpdates.push([s.id as string, s])
   }
   if (schedUpdates.length) {
-    upsertStoredItems('schedules', schedUpdates)
+    upsertSchedules(schedUpdates)
     counts.schedules = schedUpdates.length
   }
 
   // 3. Watch jobs — cancel active
   const watchJobs = loadWatchJobs()
-  const wjUpdates: Array<[string, unknown]> = []
+  const wjUpdates: Array<[string, Record<string, unknown>]> = []
   for (const w of Object.values(watchJobs) as unknown as Array<Record<string, unknown>>) {
     if (!w || w.agentId !== agentId) continue
     if (w.status === 'cancelled') continue
@@ -79,26 +78,28 @@ export function suspendAgentReferences(agentId: string): CascadeCounts {
     wjUpdates.push([w.id as string, w])
   }
   if (wjUpdates.length) {
-    upsertStoredItems('watch_jobs', wjUpdates)
+    upsertWatchJobs(wjUpdates)
     counts.watchJobs = wjUpdates.length
   }
 
   // 4. Connectors — detach agent (keep connector alive but unrouted)
-  const connectors = loadConnectors()
-  const connUpdates: Array<[string, unknown]> = []
-  for (const c of Object.values(connectors) as unknown as Array<Record<string, unknown>>) {
-    if (!c || c.agentId !== agentId) continue
-    c.agentId = null
-    connUpdates.push([c.id as string, c])
-  }
-  if (connUpdates.length) {
-    upsertStoredItems('connectors', connUpdates)
-    counts.connectors = connUpdates.length
+  {
+    const connectors = loadConnectors()
+    let connectorUpdates = 0
+    for (const c of Object.values(connectors)) {
+      if (!c || c.agentId !== agentId) continue
+      c.agentId = null
+      connectorUpdates += 1
+    }
+    if (connectorUpdates > 0) {
+      saveConnectors(connectors)
+      counts.connectors = connectorUpdates
+    }
   }
 
   // 5. Delegation jobs — cancel queued/running
   const delegationJobs = loadDelegationJobs()
-  const djUpdates: Array<[string, unknown]> = []
+  const djUpdates: Array<[string, Record<string, unknown>]> = []
   for (const d of Object.values(delegationJobs) as unknown as Array<Record<string, unknown>>) {
     if (!d || d.agentId !== agentId) continue
     const status = d.status as string | undefined
@@ -108,22 +109,22 @@ export function suspendAgentReferences(agentId: string): CascadeCounts {
     }
   }
   if (djUpdates.length) {
-    upsertStoredItems('delegation_jobs', djUpdates)
+    saveDelegationJobRecords(djUpdates)
     counts.delegationJobs = djUpdates.length
   }
 
   // 6. Webhooks — disable
   const webhooks = loadWebhooks()
-  const whUpdates: Array<[string, unknown]> = []
-  for (const w of Object.values(webhooks) as unknown as Array<Record<string, unknown>>) {
+  let webhookUpdates = 0
+  for (const w of Object.values(webhooks)) {
     if (!w || w.agentId !== agentId) continue
     if (w.enabled === false) continue
     w.enabled = false
-    whUpdates.push([w.id as string, w])
+    webhookUpdates += 1
   }
-  if (whUpdates.length) {
-    upsertStoredItems('webhooks', whUpdates)
-    counts.webhooks = whUpdates.length
+  if (webhookUpdates > 0) {
+    saveWebhooks(webhooks)
+    counts.webhooks = webhookUpdates
   }
 
   // 7. Chatrooms — remove agent from member arrays
@@ -138,23 +139,25 @@ export function suspendAgentReferences(agentId: string): CascadeCounts {
 export function purgeAgentReferences(agentId: string): CascadeCounts {
   const counts: CascadeCounts = { tasks: 0, schedules: 0, watchJobs: 0, connectors: 0, delegationJobs: 0, webhooks: 0, chatrooms: 0 }
 
-  counts.tasks = deleteMatching('tasks', loadTasks(), agentId)
-  counts.schedules = deleteMatching('schedules', loadSchedules(), agentId)
-  counts.watchJobs = deleteMatching('watch_jobs', loadWatchJobs(), agentId)
-  counts.delegationJobs = deleteMatching('delegation_jobs', loadDelegationJobs(), agentId)
-  counts.webhooks = deleteMatching('webhooks', loadWebhooks(), agentId)
+  counts.tasks = deleteMatching(loadTasks(), agentId, deleteTask)
+  counts.schedules = deleteMatching(loadSchedules(), agentId, deleteSchedule)
+  counts.watchJobs = deleteMatching(loadWatchJobs(), agentId, deleteWatchJob)
+  counts.delegationJobs = deleteMatching(loadDelegationJobs(), agentId, deleteDelegationJob)
+  counts.webhooks = purgeWebhooks(agentId)
 
   // Connectors: detach agent but keep the connector record
-  const connectors = loadConnectors()
-  const connUpdates: Array<[string, unknown]> = []
-  for (const c of Object.values(connectors) as unknown as Array<Record<string, unknown>>) {
-    if (!c || c.agentId !== agentId) continue
-    c.agentId = null
-    connUpdates.push([c.id as string, c])
-  }
-  if (connUpdates.length) {
-    upsertStoredItems('connectors', connUpdates)
-    counts.connectors = connUpdates.length
+  {
+    const connectors = loadConnectors()
+    let connectorUpdates = 0
+    for (const c of Object.values(connectors)) {
+      if (!c || c.agentId !== agentId) continue
+      c.agentId = null
+      connectorUpdates += 1
+    }
+    if (connectorUpdates > 0) {
+      saveConnectors(connectors)
+      counts.connectors = connectorUpdates
+    }
   }
 
   counts.chatrooms = removeAgentFromChatrooms(agentId)
@@ -167,7 +170,7 @@ export function purgeAgentReferences(agentId: string): CascadeCounts {
 /** Re-enable schedules that were paused by trash. */
 export function restoreAgentSchedules(agentId: string): number {
   const schedules = loadSchedules()
-  const updates: Array<[string, unknown]> = []
+  const updates: Array<[string, Record<string, unknown>]> = []
   for (const s of Object.values(schedules) as unknown as Array<Record<string, unknown>>) {
     if (!s || s.agentId !== agentId) continue
     if (!s.suspendedByTrash) continue
@@ -176,7 +179,7 @@ export function restoreAgentSchedules(agentId: string): number {
     updates.push([s.id as string, s])
   }
   if (updates.length) {
-    upsertStoredItems('schedules', updates)
+    upsertSchedules(updates)
   }
   return updates.length
 }
@@ -184,15 +187,15 @@ export function restoreAgentSchedules(agentId: string): number {
 // ── Internals ───────────────────────────────────────────────────────────
 
 function deleteMatching<T extends { agentId?: string | null; id?: string | null }>(
-  table: StorageCollection,
   collection: Record<string, T>,
   agentId: string,
+  deleteItem: (id: string) => void,
 ): number {
   let count = 0
   for (const item of Object.values(collection)) {
     if (!item || item.agentId !== agentId) continue
     if (!item.id) continue
-    deleteStoredItem(table, item.id)
+    deleteItem(item.id)
     count++
   }
   return count
@@ -200,7 +203,7 @@ function deleteMatching<T extends { agentId?: string | null; id?: string | null
 
 function removeAgentFromChatrooms(agentId: string): number {
   const chatrooms = loadChatrooms()
-  const updates: Array<[string, unknown]> = []
+  let changedCount = 0
   for (const room of Object.values(chatrooms) as unknown as Array<Record<string, unknown>>) {
     if (!room) continue
     let changed = false
@@ -220,10 +223,27 @@ function removeAgentFromChatrooms(agentId: string): number {
       room.agentIds = agentIds.filter((id) => id !== agentId)
       if ((room.agentIds as string[]).length !== before) changed = true
     }
-    if (changed) updates.push([room.id as string, room])
+    if (changed) changedCount += 1
   }
-  if (updates.length) {
-    upsertStoredItems('chatrooms', updates)
+  if (changedCount > 0) {
+    saveChatrooms(chatrooms)
   }
-  return updates.length
+  return changedCount
+}
+
+function purgeWebhooks(agentId: string): number {
+  const webhooks = loadWebhooks() as Record<string, Record<string, unknown>>
+  const remaining: Record<string, Record<string, unknown>> = {}
+  let count = 0
+  for (const [id, webhook] of Object.entries(webhooks)) {
+    if (webhook && webhook.agentId === agentId) {
+      count += 1
+      continue
+    }
+    remaining[id] = webhook
+  }
+  if (count > 0) {
+    saveWebhooks(remaining)
+  }
+  return count
 }

package/src/lib/server/agents/agent-registry.ts

@@ -1,5 +1,7 @@
-import { loadAgents, loadTasks, loadSessions } from '@/lib/server/storage'
 import type { Agent, BoardTask } from '@/types'
+import { loadAgents } from '@/lib/server/agents/agent-repository'
+import { loadSessions } from '@/lib/server/sessions/session-repository'
+import { loadTasks } from '@/lib/server/tasks/task-repository'
 
 export interface AgentDirectoryEntry {
   id: string

package/src/lib/server/agents/agent-repository.ts

@@ -0,0 +1,90 @@
+import type { Agent } from '@/types'
+
+import {
+  deleteAgent as deleteStoredAgent,
+  loadAgent as loadStoredAgent,
+  loadAgents as loadStoredAgents,
+  loadTrashedAgents as loadStoredTrashedAgents,
+  patchAgent as patchStoredAgent,
+  saveAgents as saveStoredAgents,
+  upsertAgent as upsertStoredAgent,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+type AgentRepositoryOptions = { includeTrashed?: boolean }
+
+export const agentRepository = createRecordRepository<Agent, AgentRepositoryOptions>(
+  'agents',
+  {
+    get(id, options) {
+      return loadStoredAgent(id, options) as Agent | null
+    },
+    list(options) {
+      return loadStoredAgents(options) as Record<string, Agent>
+    },
+    upsert(id, value) {
+      upsertStoredAgent(id, value)
+    },
+    replace(data) {
+      saveStoredAgents(data)
+    },
+    patch(id, updater) {
+      return patchStoredAgent(id, updater as (current: Agent | null) => Agent | null) as Agent | null
+    },
+    delete(id) {
+      deleteStoredAgent(id)
+    },
+  },
+)
+
+export function getAgent(id: string, options?: AgentRepositoryOptions): Agent | null {
+  return agentRepository.get(id, options)
+}
+
+export function getAgents(ids: string[], options?: AgentRepositoryOptions): Record<string, Agent> {
+  return agentRepository.getMany(ids, options)
+}
+
+export function listAgents(options?: AgentRepositoryOptions): Record<string, Agent> {
+  return agentRepository.list(options)
+}
+
+export function saveAgent(id: string, agent: Agent | Record<string, unknown>): void {
+  agentRepository.upsert(id, agent as Agent)
+}
+
+export function saveAgentMany(entries: Array<[string, Agent | Record<string, unknown>]>): void {
+  agentRepository.upsertMany(entries as Array<[string, Agent]>)
+}
+
+export function replaceAgents(agents: Record<string, Agent | Record<string, unknown>>): void {
+  agentRepository.replace(agents as Record<string, Agent>)
+}
+
+export function patchAgent(id: string, updater: (current: Agent | null) => Agent | null): Agent | null {
+  return agentRepository.patch(id, updater)
+}
+
+export function deleteAgent(id: string): void {
+  agentRepository.delete(id)
+}
+
+export function loadAgents(options?: AgentRepositoryOptions): Record<string, Agent> {
+  return listAgents(options)
+}
+
+export function loadAgent(id: string, options?: AgentRepositoryOptions): Agent | null {
+  return getAgent(id, options)
+}
+
+export function saveAgents(agents: Record<string, Agent | Record<string, unknown>>): void {
+  replaceAgents(agents)
+}
+
+export function upsertAgent(id: string, agent: Agent | Record<string, unknown>): void {
+  saveAgent(id, agent)
+}
+
+export function loadTrashedAgents(): Record<string, Agent> {
+  return loadStoredTrashedAgents() as Record<string, Agent>
+}

package/src/lib/server/agents/delegation-job-repository.ts

@@ -0,0 +1,53 @@
+import type { DelegationJobRecord } from '@/types'
+
+import {
+  deleteDelegationJob as deleteStoredDelegationJob,
+  loadDelegationJobItem as loadStoredDelegationJob,
+  loadDelegationJobs as loadStoredDelegationJobs,
+  patchDelegationJob as patchStoredDelegationJob,
+  upsertDelegationJob as upsertStoredDelegationJob,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const delegationJobRepository = createRecordRepository<DelegationJobRecord>(
+  'delegation-jobs',
+  {
+    get(id) {
+      return loadStoredDelegationJob(id) as DelegationJobRecord | null
+    },
+    list() {
+      return loadStoredDelegationJobs() as Record<string, DelegationJobRecord>
+    },
+    upsert(id, value) {
+      upsertStoredDelegationJob(id, value as DelegationJobRecord)
+    },
+    patch(id, updater) {
+      return patchStoredDelegationJob(
+        id,
+        updater as (current: DelegationJobRecord | null) => DelegationJobRecord | null,
+      ) as DelegationJobRecord | null
+    },
+    delete(id) {
+      deleteStoredDelegationJob(id)
+    },
+  },
+)
+
+export const getDelegationJobRecord = (id: string) => delegationJobRepository.get(id)
+export const getDelegationJobRecords = (ids: string[]) => delegationJobRepository.getMany(ids)
+export const listDelegationJobRecords = () => delegationJobRepository.list()
+export const saveDelegationJobRecord = (id: string, value: DelegationJobRecord | Record<string, unknown>) =>
+  delegationJobRepository.upsert(id, value as DelegationJobRecord)
+export const saveDelegationJobRecords = (entries: Array<[string, DelegationJobRecord | Record<string, unknown>]>) =>
+  delegationJobRepository.upsertMany(entries as Array<[string, DelegationJobRecord]>)
+export const patchDelegationJobRecord = (
+  id: string,
+  updater: (current: DelegationJobRecord | null) => DelegationJobRecord | null,
+) => delegationJobRepository.patch(id, updater)
+export const deleteDelegationJobRecord = (id: string) => delegationJobRepository.delete(id)
+
+export const loadDelegationJobs = listDelegationJobRecords
+export const loadDelegationJob = getDelegationJobRecord
+export const upsertDelegationJob = saveDelegationJobRecord
+export const patchDelegationJob = patchDelegationJobRecord
+export const deleteDelegationJob = deleteDelegationJobRecord

package/src/lib/server/agents/delegation-jobs.ts

@@ -1,13 +1,20 @@
 import { genId } from '@/lib/id'
 import { hmrSingleton } from '@/lib/shared-utils'
 import type { DelegationJobArtifact, DelegationJobCheckpoint, DelegationJobRecord, DelegationJobStatus } from '@/types'
-import { loadDelegationJobs, loadDelegationJobItem, loadSession, logActivity, patchDelegationJob, upsertDelegationJob } from '@/lib/server/storage'
+import {
+  loadDelegationJob,
+  loadDelegationJobs,
+  patchDelegationJob,
+  upsertDelegationJob,
+} from '@/lib/server/agents/delegation-job-repository'
+import { logActivity } from '@/lib/server/activity/activity-log'
 import { logExecution } from '@/lib/server/execution-log'
 import { log } from '@/lib/server/logger'
 import { debug } from '@/lib/server/debug'
 import { createNotification } from '@/lib/server/create-notification'
 import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
 import { ensureDelegationMission, syncDelegationMissionFromJob } from '@/lib/server/missions/mission-service'
+import { loadSession } from '@/lib/server/sessions/session-repository'
 import { notify } from '@/lib/server/ws-hub'
 
 interface DelegationRuntimeHandle {
@@ -115,7 +122,7 @@ export function createDelegationJob(input: CreateDelegationJobInput): Delegation
 }
 
 export function getDelegationJob(id: string): DelegationJobRecord | null {
-  const current = loadDelegationJobItem(id)
+  const current = loadDelegationJob(id)
   if (!current || typeof current !== 'object') return null
   return current as DelegationJobRecord
 }
@@ -144,9 +151,9 @@ export function updateDelegationJob(
     }
   })
   if (!result) return null
-  const synced = syncDelegationMissionFromJob(id) || result
+  syncDelegationMissionFromJob(id)
   notifyDelegationJobsChanged()
-  return getDelegationJob(id) || synced
+  return getDelegationJob(id) || result
 }
 
 export function appendDelegationCheckpoint(

package/src/lib/server/agents/guardian-checkpoint-repository.ts

@@ -0,0 +1,35 @@
+import type { GuardianCheckpoint } from '@/types'
+
+import {
+  loadGuardianCheckpoints as loadStoredGuardianCheckpoints,
+  patchGuardianCheckpoint as patchStoredGuardianCheckpoint,
+  upsertGuardianCheckpoint as upsertStoredGuardianCheckpoint,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const guardianCheckpointRepository = createRecordRepository<GuardianCheckpoint>(
+  'guardian-checkpoints',
+  {
+    get(id) {
+      return loadStoredGuardianCheckpoints()[id] || null
+    },
+    list() {
+      return loadStoredGuardianCheckpoints()
+    },
+    upsert(id, value) {
+      upsertStoredGuardianCheckpoint(id, value as GuardianCheckpoint)
+    },
+    patch(id, updater) {
+      return patchStoredGuardianCheckpoint(id, updater)
+    },
+  },
+)
+
+export const loadGuardianCheckpoints = () => guardianCheckpointRepository.list()
+export const loadGuardianCheckpoint = (id: string) => guardianCheckpointRepository.get(id)
+export const upsertGuardianCheckpoint = (id: string, value: GuardianCheckpoint | Record<string, unknown>) =>
+  guardianCheckpointRepository.upsert(id, value as GuardianCheckpoint)
+export const patchGuardianCheckpoint = (
+  id: string,
+  updater: (current: GuardianCheckpoint | null) => GuardianCheckpoint | null,
+) => guardianCheckpointRepository.patch(id, updater)

package/src/lib/server/agents/guardian.ts

@@ -1,12 +1,12 @@
 import { execSync } from 'node:child_process'
 import path from 'node:path'
 import type { ApprovalRequest, GuardianCheckpoint } from '@/types'
+import { loadApprovals } from '@/lib/server/approvals/approval-repository'
 import {
-  loadApprovals,
   loadGuardianCheckpoints,
   patchGuardianCheckpoint,
   upsertGuardianCheckpoint,
-} from '@/lib/server/storage'
+} from '@/lib/server/agents/guardian-checkpoint-repository'
 import { requestApproval } from '@/lib/server/approvals'
 import { errorMessage } from '@/lib/shared-utils'
 import { genId } from '@/lib/id'

package/src/lib/server/agents/main-agent-loop.ts

@@ -1,10 +1,17 @@
 import { hmrSingleton } from '@/lib/shared-utils'
 import type { GoalContract, Message, MessageToolEvent, Session } from '@/types'
 import { mergeGoalContracts, parseGoalContractFromText, parseMainLoopPlan, parseMainLoopReview } from '@/lib/server/agents/autonomy-contract'
+import {
+  deletePersistedMainLoopState,
+  loadPersistedMainLoopState,
+  upsertPersistedMainLoopState,
+} from '@/lib/server/agents/main-loop-state-repository'
+import { loadAgents } from '@/lib/server/agents/agent-repository'
 import { assessAutonomyRun } from '@/lib/server/autonomy/supervisor-reflection'
 import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
-import { loadAgents, loadSessions, loadSettings, loadPersistedMainLoopState, upsertPersistedMainLoopState, deletePersistedMainLoopState } from '@/lib/server/storage'
 import { buildMissionHeartbeatPrompt as buildMissionHeartbeatPromptFromMission, getMissionForSession } from '@/lib/server/missions/mission-service'
+import { loadSettings } from '@/lib/server/settings/settings-repository'
+import { getSession, loadSessions } from '@/lib/server/sessions/session-repository'
 
 const LEGACY_META_LINE_RE = /\[(?:MAIN_LOOP_META|MAIN_LOOP_PLAN|MAIN_LOOP_REVIEW|AGENT_HEARTBEAT_META)\]\s*(\{[^\n]*\})?/i
 const HEARTBEAT_META_RE = /\[AGENT_HEARTBEAT_META\]\s*(\{[^\n]*\})/i
@@ -437,7 +444,7 @@ function hydrateStateFromSession(sessionId: string): MainLoopState | null {
 }
 
 function persistState(sessionId: string, state: MainLoopState): void {
-  upsertPersistedMainLoopState(sessionId, state as unknown)
+  upsertPersistedMainLoopState(sessionId, state as unknown as Record<string, unknown>)
 }
 
 function getOrCreateState(sessionId: string): MainLoopState | null {
@@ -738,7 +745,7 @@ export function isMainSession(session: unknown): boolean {
 export function buildMainLoopHeartbeatPrompt(session: unknown, fallbackPrompt: string): string {
   const candidate = asSession(session)
   if (!candidate?.id) return fallbackPrompt
-  const persistedSession = loadSessions()[String(candidate.id)] as Session | undefined
+  const persistedSession = getSession(String(candidate.id)) as Session | undefined
   const missionPrompt = buildMissionHeartbeatPromptFromMission(
     persistedSession || candidate as Session,
     fallbackPrompt,

package/src/lib/server/agents/main-loop-state-repository.ts

@@ -0,0 +1,38 @@
+import { perf } from '@/lib/server/runtime/perf'
+import {
+  deletePersistedMainLoopState as deleteStoredMainLoopState,
+  loadPersistedMainLoopState as loadStoredMainLoopState,
+  upsertPersistedMainLoopState as upsertStoredMainLoopState,
+} from '@/lib/server/storage'
+
+export type PersistedMainLoopState = Record<string, unknown>
+
+export function loadPersistedMainLoopState(sessionId: string): PersistedMainLoopState | null {
+  return perf.measureSync(
+    'repository',
+    'main-loop-state.get',
+    () => loadStoredMainLoopState(sessionId) as PersistedMainLoopState | null,
+    { sessionId },
+  )
+}
+
+export function upsertPersistedMainLoopState(
+  sessionId: string,
+  value: PersistedMainLoopState,
+): void {
+  perf.measureSync(
+    'repository',
+    'main-loop-state.upsert',
+    () => upsertStoredMainLoopState(sessionId, value),
+    { sessionId },
+  )
+}
+
+export function deletePersistedMainLoopState(sessionId: string): void {
+  perf.measureSync(
+    'repository',
+    'main-loop-state.delete',
+    () => deleteStoredMainLoopState(sessionId),
+    { sessionId },
+  )
+}

package/src/lib/server/agents/subagent-runtime.ts

@@ -8,7 +8,7 @@
 
 import { genId } from '@/lib/id'
 import { DEFAULT_DELEGATION_MAX_DEPTH } from '@/lib/runtime/runtime-loop'
-import { loadAgents, loadSessions, saveSessions } from '@/lib/server/storage'
+import { loadAgents } from '@/lib/server/agents/agent-repository'
 import { enqueueSessionRun, type EnqueueSessionRunResult } from '@/lib/server/runtime/session-run-manager'
 import { loadRuntimeSettings } from '@/lib/server/runtime/runtime-settings'
 import { applyResolvedRoute, resolvePrimaryAgentRoute } from '@/lib/server/agents/agent-runtime-config'
@@ -48,6 +48,7 @@ import { debug } from '@/lib/server/debug'
 import { logExecution } from '@/lib/server/execution-log'
 import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
 import { getEnabledCapabilityIds, splitCapabilityIds } from '@/lib/capability-selection'
+import { getSession, loadSessions, saveSession } from '@/lib/server/sessions/session-repository'
 
 // ---------------------------------------------------------------------------
 // Types
@@ -276,7 +277,7 @@ async function spawnSubagentImpl(
     browserProfileId,
   }
   sessions[sid] = applyResolvedRoute(nextSession, resolvePrimaryAgentRoute(agent))
-  saveSessions(sessions)
+  saveSession(sid, sessions[sid])
 
   log.info('subagent', 'Spawning', { agentId: agent.id, agentName: agent.name, depth: depth + 1, jobId: job.id, sessionId: sid })
   logExecution(sid, 'delegation_start', `Subagent spawning: ${agent.name}`, {
@@ -398,12 +399,13 @@ async function spawnSubagentImpl(
           `subagent:${job.id}`,
         )
       }
+      const completedSession = getSession(sid)
       await runCapabilityHook(
         'sessionEnd',
         {
           sessionId: sid,
-          session: loadSessions()[sid] || null,
-          messageCount: Array.isArray(loadSessions()[sid]?.messages) ? loadSessions()[sid].messages.length : 0,
+          session: completedSession,
+          messageCount: Array.isArray(completedSession?.messages) ? completedSession.messages.length : 0,
           durationMs: subagentResult.durationMs,
           reason: subagentResult.status,
         },
@@ -460,12 +462,13 @@ async function spawnSubagentImpl(
           `subagent:${job.id}`,
         )
       }
+      const failedSession = getSession(sid)
       await runCapabilityHook(
         'sessionEnd',
         {
           sessionId: sid,
-          session: loadSessions()[sid] || null,
-          messageCount: Array.isArray(loadSessions()[sid]?.messages) ? loadSessions()[sid].messages.length : 0,
+          session: failedSession,
+          messageCount: Array.isArray(failedSession?.messages) ? failedSession.messages.length : 0,
           durationMs: subagentResult.durationMs,
           reason: subagentResult.status,
         },