@swarmclawai/swarmclaw 1.2.0 → 1.2.2

package/src/lib/server/agents/agent-availability.test.ts

@@ -1,20 +1,25 @@
 import assert from 'node:assert/strict'
 import { describe, it } from 'node:test'
+import type { Agent, ProviderType } from '@/types'
 import { isWorkerOnlyAgent, buildWorkerOnlyAgentMessage } from './agent-availability'
 
 describe('isWorkerOnlyAgent', () => {
-  const CLI_PROVIDERS = ['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'openclaw']
-  const NON_CLI_PROVIDERS = ['openai', 'anthropic', 'google', 'deepseek', 'groq', 'custom']
+  const CLI_PROVIDERS = ['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'openclaw'] satisfies ProviderType[]
+  const NON_CLI_PROVIDERS = ['openai', 'anthropic', 'google', 'deepseek', 'groq', 'together'] satisfies ProviderType[]
+
+  function withProvider(provider: unknown): Pick<Agent, 'provider'> {
+    return { provider } as Pick<Agent, 'provider'>
+  }
 
   for (const provider of CLI_PROVIDERS) {
     it(`returns true for ${provider}`, () => {
-      assert.equal(isWorkerOnlyAgent({ provider }), true)
+      assert.equal(isWorkerOnlyAgent(withProvider(provider)), true)
     })
   }
 
   for (const provider of NON_CLI_PROVIDERS) {
     it(`returns false for ${provider}`, () => {
-      assert.equal(isWorkerOnlyAgent({ provider }), false)
+      assert.equal(isWorkerOnlyAgent(withProvider(provider)), false)
     })
   }
 
@@ -27,7 +32,7 @@ describe('isWorkerOnlyAgent', () => {
   })
 
   it('returns false for empty provider string', () => {
-    assert.equal(isWorkerOnlyAgent({ provider: '' }), false)
+    assert.equal(isWorkerOnlyAgent(withProvider('')), false)
   })
 })
 

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
@@ -52,19 +54,36 @@ export function getAgentDirectory(excludeId?: string): AgentDirectoryEntry[] {
   return entries
 }
 
-export function buildAgentAwarenessBlock(excludeId: string): string {
-  const directory = getAgentDirectory(excludeId)
+export function buildAgentAwarenessBlock(
+  excludeId: string,
+  opts?: {
+    delegationTargetMode?: 'all' | 'selected'
+    delegationTargetAgentIds?: string[]
+  },
+): string {
+  let directory = getAgentDirectory(excludeId)
   if (!directory.length) return ''
 
+  const isFiltered = opts?.delegationTargetMode === 'selected'
+  if (isFiltered) {
+    const allowedIds = new Set(opts.delegationTargetAgentIds || [])
+    directory = directory.filter((entry) => allowedIds.has(entry.id))
+    if (!directory.length) return ''
+  }
+
   const lines = directory.map((entry) => {
     const caps = entry.capabilities.length ? ` (${entry.capabilities.join(', ')})` : ''
     const status = entry.statusDetail || entry.status
     return `- **${entry.name}** [id: ${entry.id}]${caps} — ${status}`
   })
 
+  const header = isFiltered
+    ? 'These are the ONLY agents I can delegate tasks to. Do not attempt to delegate to any other agents:'
+    : 'These are the other agents I work alongside. I can hand off tasks to any of them if their skills are a better fit:'
+
   return [
     '## My Colleagues',
-    'These are the other agents I work alongside. I can hand off tasks to any of them if their skills are a better fit:',
+    header,
     ...lines,
   ].join('\n')
 }

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
@@ -12,7 +19,7 @@ const MAX_PENDING_EVENTS = 16
 const MAX_TIMELINE_ITEMS = 40
 const MAX_WORKING_MEMORY_NOTES = 12
 const DEFAULT_FOLLOWUP_DELAY_MS = 1500
-const DEFAULT_MAX_FOLLOWUP_CHAIN = 6
+const DEFAULT_MAX_FOLLOWUP_CHAIN = 4
 const MAX_LIFETIME_ITERATIONS = 200
 
 export interface MainLoopState {
@@ -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,
@@ -778,6 +785,7 @@ export function buildMainLoopHeartbeatPrompt(session: unknown, fallbackPrompt: s
     boundedFallbackPrompt ? `Base heartbeat instructions:\n${boundedFallbackPrompt}` : '',
     '',
     'You are checking the durable main mission thread for this agent.',
+    'Keep this status check brief — 5-10 tool calls maximum. Read key state, summarize progress, and report. Do not attempt fixes or deep investigation during heartbeats.',
     'Use only the current goal, plan, next action, and pending external events shown above.',
     'Do not infer or repeat old tasks from prior heartbeats.',
     'Prefer taking the single highest-value next step over restating the plan. Do not repeat completed work.',
@@ -1072,8 +1080,8 @@ export function handleMainLoopRunResult(input: HandleMainLoopRunResultInput): Ma
         || (needsReplan
           ? 'Replan from the latest outcome, then execute only the highest-value remaining step. Do not repeat completed work.'
           : state.nextAction
-            ? `Continue the objective. Resume from this next action: ${state.nextAction}`
-            : 'Continue the objective and finish the next highest-value remaining step.')
+            ? `Continue. Next action: ${state.nextAction}. Do not repeat tool calls from previous turns.`
+            : `Continue. You have used ${state.followupChainCount} of ${limit} followup turns. Focus on completing one concrete step, then summarize progress.`)
       followup = {
         message,
         delayMs: DEFAULT_FOLLOWUP_DELAY_MS,