@swarmclawai/swarmclaw 1.2.1 → 1.2.3

package/src/lib/chat/chat-streaming-state.test.ts

@@ -43,16 +43,17 @@ describe('chat-streaming-state', () => {
         localStreaming: true,
         hasLiveArtifacts: true,
         assistantRenderId: 'render-1',
+        showLiveRow: true,
+        syntheticAssistant: messages[1],
       } as StreamingAwareMessageListOptions),
       [
         { role: 'user', text: 'hello', time: 1 },
         {
           role: 'assistant',
-          text: 'final answer',
-          time: 0,
+          text: 'partial',
+          time: 2,
           kind: 'chat',
           streaming: true,
-          thinking: 'working...',
           clientRenderId: 'render-1',
         },
       ],
@@ -69,6 +70,7 @@ describe('chat-streaming-state', () => {
         localStreaming: true,
         hasLiveArtifacts: true,
         assistantRenderId: 'render-2',
+        showLiveRow: true,
       } as StreamingAwareMessageListOptions),
       [
         { role: 'user', text: 'hello', time: 1 },
@@ -84,6 +86,43 @@ describe('chat-streaming-state', () => {
     )
   })
 
+  it('can show a synthetic live row for server-driven runs using the latest persisted streaming artifact', () => {
+    const messages: Message[] = [
+      { role: 'user', text: 'queued follow-up', time: 1 },
+      {
+        role: 'assistant',
+        text: 'Drafting the handoff now.',
+        time: 2,
+        streaming: true,
+        thinking: 'Collecting the completion details',
+        toolEvents: [{ name: 'send_file', input: '{}', output: '/api/uploads/deck.pdf' }],
+      },
+    ]
+
+    assert.deepEqual(
+      buildStreamingAwareMessageList(messages, {
+        localStreaming: true,
+        hasLiveArtifacts: false,
+        assistantRenderId: 'render-server',
+        showLiveRow: true,
+        syntheticAssistant: messages[1],
+      }),
+      [
+        { role: 'user', text: 'queued follow-up', time: 1 },
+        {
+          role: 'assistant',
+          text: 'Drafting the handoff now.',
+          time: 2,
+          kind: 'chat',
+          streaming: true,
+          thinking: 'Collecting the completion details',
+          toolEvents: [{ name: 'send_file', input: '{}', output: '/api/uploads/deck.pdf' }],
+          clientRenderId: 'render-server',
+        },
+      ],
+    )
+  })
+
   it('replaces trailing streaming assistant messages with the completed assistant message', () => {
     const messages: Message[] = [
       { role: 'user', text: 'hello', time: 1 },

package/src/lib/chat/chat-streaming-state.ts

@@ -10,6 +10,8 @@ export interface StreamingAwareMessageListOptions {
   localStreaming: boolean
   hasLiveArtifacts: boolean
   assistantRenderId?: string | null
+  showLiveRow?: boolean
+  syntheticAssistant?: Partial<Message> | null
 }
 
 function isStreamingAssistantMessage(
@@ -27,13 +29,13 @@ function isStreamingAssistantMessage(
 
 export function shouldHidePersistedStreamingAssistantMessage(
   message: Message,
-  opts: { localStreaming: boolean; hasLiveArtifacts: boolean },
+  opts: { localStreaming: boolean; hasLiveArtifacts: boolean; showLiveRow?: boolean },
 ): boolean {
+  const showLiveRow = opts.showLiveRow ?? (opts.localStreaming && opts.hasLiveArtifacts)
   return (
-    opts.localStreaming
+    showLiveRow
     && message.role === 'assistant'
     && message.streaming === true
-    && opts.hasLiveArtifacts
   )
 }
 
@@ -41,22 +43,32 @@ export function buildStreamingAwareMessageList(
   messages: Message[],
   opts: StreamingAwareMessageListOptions,
 ): Message[] {
-  const nextMessages = opts.localStreaming && opts.hasLiveArtifacts
+  const showLiveRow = opts.showLiveRow ?? (opts.localStreaming && opts.hasLiveArtifacts)
+  const nextMessages = showLiveRow
     ? messages.filter((message) => !shouldHidePersistedStreamingAssistantMessage(message, opts))
     : messages
 
-  if (!opts.localStreaming || !opts.hasLiveArtifacts || !opts.assistantRenderId) {
+  if (!showLiveRow || !opts.assistantRenderId) {
     return nextMessages
   }
 
   const syntheticAssistantMessage: Message = {
     role: 'assistant',
-    text: '',
-    time: 0,
-    kind: 'chat',
+    text: typeof opts.syntheticAssistant?.text === 'string' ? opts.syntheticAssistant.text : '',
+    time: typeof opts.syntheticAssistant?.time === 'number' ? opts.syntheticAssistant.time : 0,
+    kind: opts.syntheticAssistant?.kind || 'chat',
     streaming: true,
     clientRenderId: opts.assistantRenderId,
   }
+  if (typeof opts.syntheticAssistant?.thinking === 'string') {
+    syntheticAssistantMessage.thinking = opts.syntheticAssistant.thinking
+  }
+  if (Array.isArray(opts.syntheticAssistant?.toolEvents)) {
+    syntheticAssistantMessage.toolEvents = opts.syntheticAssistant.toolEvents
+  }
+  if (opts.syntheticAssistant?.source) {
+    syntheticAssistantMessage.source = opts.syntheticAssistant.source
+  }
 
   return [
     ...nextMessages,

package/src/lib/chat/queued-message-queue.test.ts

@@ -27,7 +27,7 @@ describe('queued-message-queue', () => {
   it('replaces queued items only for the requested session', () => {
     const replaced = replaceQueuedMessagesForSession(queue, 'session-a', [
       { runId: 'q4', sessionId: 'session-a', text: 'replacement', queuedAt: 4, position: 1 },
-    ])
+    ], { activeRunId: null })
     assert.deepEqual(
       listQueuedMessagesForSession(replaced, 'session-a').map((item) => item.runId),
       ['q4'],
@@ -38,6 +38,28 @@ describe('queued-message-queue', () => {
     )
   })
 
+  it('keeps only the newly active run as a sending placeholder when it disappears from the queue snapshot', () => {
+    const replaced = replaceQueuedMessagesForSession(queue, 'session-a', [
+      { runId: 'q3', sessionId: 'session-a', text: 'second a', queuedAt: 3, position: 1 },
+    ], { activeRunId: 'q1' })
+
+    assert.deepEqual(
+      listQueuedMessagesForSession(replaced, 'session-a').map((item) => [item.runId, item.sending === true]),
+      [['q1', true], ['q3', false]],
+    )
+  })
+
+  it('drops missing stale queue rows that are not the active run', () => {
+    const replaced = replaceQueuedMessagesForSession(queue, 'session-a', [
+      { runId: 'q3', sessionId: 'session-a', text: 'second a', queuedAt: 3, position: 1 },
+    ], { activeRunId: 'run-other' })
+
+    assert.deepEqual(
+      listQueuedMessagesForSession(replaced, 'session-a').map((item) => item.runId),
+      ['q3'],
+    )
+  })
+
   it('removes queued items by stable id', () => {
     assert.deepEqual(removeQueuedMessageById(queue, 'q2').map((item) => item.runId), ['q1', 'q3'])
   })

package/src/lib/chat/queued-message-queue.ts

@@ -41,18 +41,27 @@ export function snapshotToQueuedMessages(snapshot: SessionQueueSnapshot): Queued
   return snapshot.items.map((item) => ({ ...item }))
 }
 
+interface ReplaceQueuedMessagesOptions {
+  activeRunId?: string | null
+}
+
 export function replaceQueuedMessagesForSession(
   queue: QueuedSessionMessage[],
   sessionId: string,
   nextItems: QueuedSessionMessage[],
+  options: ReplaceQueuedMessagesOptions = {},
 ): QueuedSessionMessage[] {
   const otherSessions = queue.filter((item) => item.sessionId !== sessionId)
   const previousForSession = queue.filter((item) => item.sessionId === sessionId && !item.sending)
   // Detect consumed messages: items in local state but not in server snapshot.
-  // Keep them visible as "sending" so they don't vanish from the UI.
+  // Keep only the run that actually became active visible as "sending" so it
+  // doesn't vanish from the UI before the transcript refresh catches up.
   const nextRunIds = new Set(nextItems.map((item) => item.runId))
+  const activeRunId = typeof options.activeRunId === 'string' && options.activeRunId.trim()
+    ? options.activeRunId
+    : null
   const consumed = previousForSession
-    .filter((item) => !item.optimistic && !nextRunIds.has(item.runId))
+    .filter((item) => !item.optimistic && !nextRunIds.has(item.runId) && activeRunId === item.runId)
     .map((item) => ({ ...item, sending: true }))
   return [
     ...otherSessions,

package/src/lib/providers/cli-utils.test.ts

@@ -0,0 +1,124 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { isStderrNoise, buildCliEnv, isCliProvider, CLI_PROVIDER_CAPABILITIES } from './cli-utils'
+
+// ---------------------------------------------------------------------------
+// isStderrNoise
+// ---------------------------------------------------------------------------
+
+describe('isStderrNoise', () => {
+  it('returns true for MallocStackLogging lines', () => {
+    assert.equal(isStderrNoise('MallocStackLogging: could not tag MSL'), true)
+  })
+
+  it('returns true for blank/whitespace lines', () => {
+    assert.equal(isStderrNoise(''), true)
+    assert.equal(isStderrNoise('   '), true)
+    assert.equal(isStderrNoise('\t'), true)
+  })
+
+  it('returns false for real error text', () => {
+    assert.equal(isStderrNoise('Error: connection refused'), false)
+    assert.equal(isStderrNoise('FATAL: segfault'), false)
+    assert.equal(isStderrNoise('Permission denied'), false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// buildCliEnv
+// ---------------------------------------------------------------------------
+
+describe('buildCliEnv', () => {
+  it('strips SWARMCLAW_ prefixed vars from env', () => {
+    const orig = process.env.SWARMCLAW_TEST_VAR
+    process.env.SWARMCLAW_TEST_VAR = 'should_be_stripped'
+    try {
+      const env = buildCliEnv()
+      assert.equal(env.SWARMCLAW_TEST_VAR, undefined)
+    } finally {
+      if (orig === undefined) delete process.env.SWARMCLAW_TEST_VAR
+      else process.env.SWARMCLAW_TEST_VAR = orig
+    }
+  })
+
+  it('deletes MallocStackLogging', () => {
+    const orig = process.env.MallocStackLogging
+    process.env.MallocStackLogging = '1'
+    try {
+      const env = buildCliEnv()
+      assert.equal(env.MallocStackLogging, undefined)
+    } finally {
+      if (orig === undefined) delete process.env.MallocStackLogging
+      else process.env.MallocStackLogging = orig
+    }
+  })
+
+  it('injects provided key-value pairs', () => {
+    const env = buildCliEnv({ inject: { MY_CUSTOM_KEY: 'hello' } })
+    assert.equal(env.MY_CUSTOM_KEY, 'hello')
+  })
+
+  it('preserves unrelated user env vars', () => {
+    const env = buildCliEnv()
+    assert.equal(env.PATH, process.env.PATH)
+  })
+
+  it('supports custom stripPrefixes', () => {
+    const orig = process.env.CUSTOM_PREFIX_VAR
+    process.env.CUSTOM_PREFIX_VAR = 'should_be_stripped'
+    try {
+      const env = buildCliEnv({ stripPrefixes: ['CUSTOM_PREFIX_'] })
+      assert.equal(env.CUSTOM_PREFIX_VAR, undefined)
+    } finally {
+      if (orig === undefined) delete process.env.CUSTOM_PREFIX_VAR
+      else process.env.CUSTOM_PREFIX_VAR = orig
+    }
+  })
+
+  it('sets TERM=dumb and NO_COLOR=1', () => {
+    const env = buildCliEnv()
+    assert.equal(env.TERM, 'dumb')
+    assert.equal(env.NO_COLOR, '1')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// isCliProvider
+// ---------------------------------------------------------------------------
+
+describe('isCliProvider', () => {
+  it('returns true for known CLI providers', () => {
+    assert.equal(isCliProvider('claude-cli'), true)
+    assert.equal(isCliProvider('codex-cli'), true)
+    assert.equal(isCliProvider('opencode-cli'), true)
+    assert.equal(isCliProvider('gemini-cli'), true)
+  })
+
+  it('returns false for non-CLI providers', () => {
+    assert.equal(isCliProvider('openai'), false)
+    assert.equal(isCliProvider('anthropic'), false)
+    assert.equal(isCliProvider(''), false)
+    assert.equal(isCliProvider('google'), false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// CLI_PROVIDER_CAPABILITIES
+// ---------------------------------------------------------------------------
+
+describe('CLI_PROVIDER_CAPABILITIES', () => {
+  it('has entries for all 4 CLI providers', () => {
+    assert.ok('claude-cli' in CLI_PROVIDER_CAPABILITIES)
+    assert.ok('codex-cli' in CLI_PROVIDER_CAPABILITIES)
+    assert.ok('opencode-cli' in CLI_PROVIDER_CAPABILITIES)
+    assert.ok('gemini-cli' in CLI_PROVIDER_CAPABILITIES)
+  })
+
+  it('each entry is a non-empty string', () => {
+    for (const [key, value] of Object.entries(CLI_PROVIDER_CAPABILITIES)) {
+      assert.equal(typeof value, 'string', `${key} should be a string`)
+      assert.ok(value.length > 0, `${key} should be non-empty`)
+    }
+  })
+})

package/src/lib/server/activity/activity-log.ts

@@ -0,0 +1,21 @@
+import { loadActivity as loadStoredActivity, logActivity as writeActivityLog } from '@/lib/server/storage'
+import { perf } from '@/lib/server/runtime/perf'
+
+export function loadActivity() {
+  return perf.measureSync('repository', 'activity.list', () => loadStoredActivity())
+}
+
+export function logActivity(entry: {
+  entityType: string
+  entityId: string
+  action: string
+  actor: string
+  actorId?: string
+  summary: string
+  detail?: Record<string, unknown>
+}) {
+  perf.measureSync('repository', 'activity.log', () => writeActivityLog(entry), {
+    entityType: entry.entityType,
+    action: entry.action,
+  })
+}

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