@swarmclawai/swarmclaw 1.2.4 → 1.2.5

package/src/lib/server/tasks/task-followups.ts

@@ -3,11 +3,14 @@ import path from 'node:path'
 import type { BoardTask, Connector, MessageToolEvent } from '@/types'
 import { normalizeWhatsappTarget } from '@/lib/server/connectors/response-media'
 import { isDirectConnectorSession } from '@/lib/server/connectors/session-kind'
+import { loadConnectors } from '@/lib/server/connectors/connector-repository'
 import { WORKSPACE_DIR } from '@/lib/server/data-dir'
-import { loadConnectors, loadSessions, UPLOAD_DIR } from '@/lib/server/storage'
+import { loadSessions } from '@/lib/server/sessions/session-repository'
+import { UPLOAD_DIR } from '@/lib/server/upload-path'
 import { errorMessage } from '@/lib/shared-utils'
 import { isMainSession } from '@/lib/server/agents/main-agent-loop'
 import { log } from '@/lib/server/logger'
+import { getMessages } from '@/lib/server/messages/message-repository'
 
 const TAG = 'task-followups'
 
@@ -291,9 +294,10 @@ export function resolveTaskOriginConnectorFollowupTarget(params: {
   const ownerSessionTarget = resolveMainSessionOwnerTarget()
   if (ownerSessionTarget) return ownerSessionTarget
 
-  if (!isMainSession(sourceSession) && Array.isArray(sourceSession.messages)) {
-    for (let index = sourceSession.messages.length - 1; index >= 0; index -= 1) {
-      const message = sourceSession.messages[index]
+  const sourceMessages = typeof sourceSession.id === 'string' ? getMessages(sourceSession.id) : []
+  if (!isMainSession(sourceSession) && sourceMessages.length > 0) {
+    for (let index = sourceMessages.length - 1; index >= 0; index -= 1) {
+      const message = sourceMessages[index]
       if (!message || message.role !== 'user') continue
       if (message.historyExcluded === true) continue
 
@@ -408,14 +412,15 @@ export function taskAlreadyDeliveredToConnectorTarget(params: {
       : ''
   if (!taskSessionId) return false
   const session = params.sessions[taskSessionId]
-  if (!session || !Array.isArray(session.messages)) return false
+  if (!session) return false
 
+  const sessionMessages = typeof session.id === 'string' ? getMessages(session.id) : []
   const connector = params.connectors[params.target.connectorId]
   const normalizedTargetChannel = normalizeFollowupChannelForConnector(connector, params.target.channelId)
   if (!normalizedTargetChannel) return false
 
-  for (let index = session.messages.length - 1; index >= 0; index -= 1) {
-    const message = session.messages[index]
+  for (let index = sessionMessages.length - 1; index >= 0; index -= 1) {
+    const message = sessionMessages[index]
     if (!message || message.role !== 'assistant' || !Array.isArray(message.toolEvents)) continue
     for (const event of message.toolEvents) {
       const delivered = extractDeliveredConnectorTarget(event as MessageToolEvent)
@@ -446,14 +451,14 @@ export async function notifyConnectorTaskFollowups(params: {
   const targets = collectTaskConnectorFollowupTargets({
     task,
     sessions: sessions as Record<string, SessionLike>,
-    connectors: connectors as any,
+    connectors,
     running: running as RunningConnectorLike[],
   })
   if (!targets.length) return
   const originTarget = resolveTaskOriginConnectorFollowupTarget({
     task,
     sessions: sessions as Record<string, SessionLike>,
-    connectors: connectors as any,
+    connectors,
     running: running as RunningConnectorLike[],
   })
   const preferredTargetKey = originTarget
@@ -473,8 +478,8 @@ export async function notifyConnectorTaskFollowups(params: {
       continue
     }
 
-    const template = typeof (connector as any).config?.taskFollowupTemplate === 'string'
-      ? (connector as any).config.taskFollowupTemplate.trim()
+    const template = typeof connector.config?.taskFollowupTemplate === 'string'
+      ? connector.config.taskFollowupTemplate.trim()
       : ''
     const message = template
       ? fillTaskFollowupTemplate(template, {

package/src/lib/server/tasks/task-result.test.ts

@@ -4,41 +4,37 @@ import { extractTaskResult } from '@/lib/server/tasks/task-result'
 
 describe('extractTaskResult', () => {
   it('limits artifact extraction to messages from the current run window', () => {
-    const session = {
-      messages: [
-        {
-          role: 'assistant',
-          time: 1_000,
-          text: 'old run artifact: /api/uploads/wiki-old.png',
-        },
-        {
-          role: 'assistant',
-          time: 2_000,
-          text: 'new run artifact: /api/uploads/wiki-new.png',
-        },
-      ],
-    }
+    const messages = [
+      {
+        role: 'assistant',
+        time: 1_000,
+        text: 'old run artifact: /api/uploads/wiki-old.png',
+      },
+      {
+        role: 'assistant',
+        time: 2_000,
+        text: 'new run artifact: /api/uploads/wiki-new.png',
+      },
+    ]
 
-    const result = extractTaskResult(session, 'done', { sinceTime: 1_500 })
+    const result = extractTaskResult(messages, 'done', { sinceTime: 1_500 })
     assert.deepEqual(result.artifacts.map((a) => a.url), ['/api/uploads/wiki-new.png'])
   })
 
   it('excludes messages without timestamps when sinceTime is provided', () => {
-    const session = {
-      messages: [
-        {
-          role: 'assistant',
-          text: 'undated artifact: /api/uploads/undated.png',
-        },
-        {
-          role: 'assistant',
-          time: 5_000,
-          text: 'dated artifact: /api/uploads/dated.png',
-        },
-      ],
-    }
+    const messages = [
+      {
+        role: 'assistant',
+        text: 'undated artifact: /api/uploads/undated.png',
+      },
+      {
+        role: 'assistant',
+        time: 5_000,
+        text: 'dated artifact: /api/uploads/dated.png',
+      },
+    ]
 
-    const result = extractTaskResult(session, 'done', { sinceTime: 4_000 })
+    const result = extractTaskResult(messages, 'done', { sinceTime: 4_000 })
     assert.deepEqual(result.artifacts.map((a) => a.url), ['/api/uploads/dated.png'])
   })
 })

package/src/lib/server/tasks/task-result.ts

@@ -49,10 +49,6 @@ interface MessageLike {
   toolEvents?: Array<{ name?: string; output?: string }>
 }
 
-interface SessionLike {
-  messages?: MessageLike[]
-}
-
 interface ExtractTaskResultOptions {
   sinceTime?: number | null
 }
@@ -62,12 +58,12 @@ interface ExtractTaskResultOptions {
 // ---------------------------------------------------------------------------
 
 /**
- * Walk a session's messages and extract all artifacts + a clean summary.
+ * Walk messages and extract all artifacts + a clean summary.
  * Replaces the old regex-based `extractLatestUploadUrl` and
  * `summarizeScheduleTaskResult` with a single Zod-validated pass.
  */
 export function extractTaskResult(
-  session: SessionLike | null | undefined,
+  messages: MessageLike[] | null | undefined,
   rawResultText: string | null | undefined,
   options?: ExtractTaskResultOptions,
 ): TaskResult {
@@ -85,9 +81,9 @@ export function extractTaskResult(
     artifacts.push({ url, type: classifyArtifact(filename), filename })
   }
 
-  // Walk session messages to collect all artifact URLs
-  if (Array.isArray(session?.messages)) {
-    for (const msg of session.messages) {
+  // Walk messages to collect all artifact URLs
+  if (Array.isArray(messages)) {
+    for (const msg of messages) {
       if (sinceTime !== null) {
         const msgTime = typeof msg.time === 'number' && Number.isFinite(msg.time) ? msg.time : null
         if (msgTime === null || msgTime < sinceTime) continue

package/src/lib/server/tasks/task-route-service.ts

@@ -0,0 +1,449 @@
+import { genId } from '@/lib/id'
+import { getEnabledCapabilityIds } from '@/lib/capability-selection'
+import { pushMainLoopEventToMainSessions } from '@/lib/server/agents/main-agent-loop'
+import { loadAgents } from '@/lib/server/agents/agent-repository'
+import { logActivity } from '@/lib/server/activity/activity-log'
+import { createNotification } from '@/lib/server/create-notification'
+import { validateDag, cascadeUnblock } from '@/lib/server/dag-validation'
+import { getExtensionManager } from '@/lib/server/extensions'
+import {
+  enrichTaskWithMissionSummary,
+  ensureMissionForTask,
+  noteMissionTaskFinished,
+} from '@/lib/server/missions/mission-service'
+import {
+  disableSessionHeartbeat,
+  enqueueTask,
+  recoverStalledRunningTasks,
+  validateCompletedTasksQueue,
+} from '@/lib/server/runtime/queue'
+import { dispatchWake } from '@/lib/server/runtime/wake-dispatcher'
+import { serviceFail, serviceOk } from '@/lib/server/service-result'
+import { loadSettings } from '@/lib/server/settings/settings-repository'
+import {
+  deleteTask,
+  loadTask,
+  loadTasks,
+  saveTask,
+  saveTaskMany,
+} from '@/lib/server/tasks/task-repository'
+import { resolveTaskAgentFromDescription } from '@/lib/server/tasks/task-mention'
+import { applyTaskPatch, prepareTaskCreation } from '@/lib/server/tasks/task-service'
+import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
+import { notify } from '@/lib/server/ws-hub'
+import type { BoardTask, BoardTaskStatus, TaskComment } from '@/types'
+import type { ServiceResult } from '@/lib/server/service-result'
+
+import '@/lib/server/builtin-extensions'
+
+const VALID_BULK_STATUSES: BoardTaskStatus[] = ['backlog', 'queued', 'running', 'completed', 'failed', 'archived']
+
+function normalizeTaskCommentInput(value: unknown): TaskComment | null {
+  if (typeof value === 'string' && value.trim()) {
+    return {
+      id: genId(),
+      author: 'user',
+      text: value.trim(),
+      createdAt: Date.now(),
+    }
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null
+  const row = value as Record<string, unknown>
+  const text = typeof row.text === 'string' ? row.text.trim() : ''
+  if (!text) return null
+  return {
+    id: typeof row.id === 'string' && row.id.trim() ? row.id.trim() : genId(),
+    author: typeof row.author === 'string' && row.author.trim() ? row.author.trim() : 'user',
+    agentId: typeof row.agentId === 'string' && row.agentId.trim() ? row.agentId.trim() : undefined,
+    text,
+    createdAt: typeof row.createdAt === 'number' && Number.isFinite(row.createdAt) ? row.createdAt : Date.now(),
+  }
+}
+
+export function prepareTasksForListing() {
+  validateCompletedTasksQueue()
+  recoverStalledRunningTasks()
+  const allTasks = loadTasks()
+  return Object.fromEntries(
+    Object.entries(allTasks).map(([id, task]) => [id, enrichTaskWithMissionSummary(task)]),
+  )
+}
+
+export function updateTaskFromRoute(id: string, body: Record<string, unknown>): ServiceResult<BoardTask> {
+  const settings = loadSettings()
+  const tasks = loadTasks()
+  if (!tasks[id]) return serviceFail(404, 'Task not found')
+
+  const prevStatus = tasks[id].status
+  if (Array.isArray(body.blockedBy)) {
+    const dagResult = validateDag(tasks, id, body.blockedBy)
+    if (!dagResult.valid) {
+      return serviceFail(400, 'Dependency cycle detected')
+    }
+  }
+
+  if (body.appendComment) {
+    const appendedComment = normalizeTaskCommentInput(body.appendComment)
+    if (!appendedComment) {
+      return serviceFail(400, 'Invalid task comment payload')
+    }
+    if (!tasks[id].comments) tasks[id].comments = []
+    tasks[id].comments.push(appendedComment)
+    tasks[id].updatedAt = Date.now()
+  } else {
+    applyTaskPatch({
+      task: tasks[id],
+      patch: body,
+      now: Date.now(),
+      settings,
+      preserveCompletedAt: true,
+      clearProjectIdWhenNull: true,
+      invalidCompletionCommentAuthor: 'System',
+    })
+  }
+  tasks[id].id = id
+
+  if (typeof body.parentTaskId === 'string' || body.parentTaskId === null) {
+    const oldParentId = tasks[id].parentTaskId
+    const newParentId = typeof body.parentTaskId === 'string' && body.parentTaskId.trim() ? body.parentTaskId.trim() : null
+    if (oldParentId && oldParentId !== newParentId && tasks[oldParentId]) {
+      const oldSubs = Array.isArray(tasks[oldParentId].subtaskIds) ? tasks[oldParentId].subtaskIds : []
+      tasks[oldParentId].subtaskIds = oldSubs.filter((s: string) => s !== id)
+      tasks[oldParentId].updatedAt = Date.now()
+      saveTask(oldParentId, tasks[oldParentId])
+    }
+    if (newParentId && tasks[newParentId]) {
+      const newSubs = Array.isArray(tasks[newParentId].subtaskIds) ? tasks[newParentId].subtaskIds : []
+      if (!newSubs.includes(id)) {
+        tasks[newParentId].subtaskIds = [...newSubs, id]
+        tasks[newParentId].updatedAt = Date.now()
+        saveTask(newParentId, tasks[newParentId])
+      }
+    }
+    tasks[id].parentTaskId = newParentId
+  }
+
+  if (prevStatus !== 'archived' && tasks[id].status === 'archived') {
+    tasks[id].archivedAt = Date.now()
+  }
+
+  saveTask(id, tasks[id])
+  const mission = ensureMissionForTask(tasks[id], { source: 'manual' })
+  if (tasks[id].status === 'completed' || tasks[id].status === 'failed' || tasks[id].status === 'cancelled') {
+    noteMissionTaskFinished(tasks[id], tasks[id].status, tasks[id].id)
+  }
+  logActivity({ entityType: 'task', entityId: id, action: 'updated', actor: 'user', summary: `Task updated: "${tasks[id].title}" (${prevStatus} → ${tasks[id].status})` })
+  if (prevStatus !== tasks[id].status) {
+    pushMainLoopEventToMainSessions({
+      type: 'task_status_changed',
+      text: `Task "${tasks[id].title}" (${id}) moved ${prevStatus} → ${tasks[id].status}.`,
+    })
+  }
+
+  if (prevStatus !== tasks[id].status && tasks[id].status === 'cancelled') {
+    disableSessionHeartbeat(tasks[id].sessionId)
+    notify('tasks')
+    return serviceOk(enrichTaskWithMissionSummary({
+      ...tasks[id],
+      missionId: mission?.id || tasks[id].missionId || null,
+    }))
+  }
+
+  if (prevStatus !== tasks[id].status && (tasks[id].status === 'completed' || tasks[id].status === 'failed')) {
+    disableSessionHeartbeat(tasks[id].sessionId)
+    createNotification({
+      type: tasks[id].status === 'completed' ? 'success' : 'error',
+      title: `Task ${tasks[id].status}: "${tasks[id].title}"`,
+      message: tasks[id].status === 'failed' ? tasks[id].error?.slice(0, 200) : undefined,
+      entityType: 'task',
+      entityId: id,
+    })
+
+    if (tasks[id].status === 'completed') {
+      const agentExtensions = tasks[id].agentId ? getEnabledCapabilityIds(loadAgents()[tasks[id].agentId]) : []
+      getExtensionManager().runHook(
+        'onTaskComplete',
+        { taskId: id, result: tasks[id].result },
+        { enabledIds: agentExtensions },
+      )
+    }
+
+    if (tasks[id].sessionId) {
+      enqueueSystemEvent(tasks[id].sessionId, `Task ${tasks[id].status}: ${tasks[id].title}`)
+    }
+    if (tasks[id].agentId) {
+      dispatchWake({
+        mode: 'immediate',
+        agentId: tasks[id].agentId,
+        sessionId: tasks[id].sessionId || undefined,
+        eventId: `task:${id}:${tasks[id].status}`,
+        reason: 'task-completed',
+        source: `task:${id}`,
+        resumeMessage: `Task ${tasks[id].status}: ${tasks[id].title}`,
+        detail: tasks[id].status === 'failed'
+          ? String(tasks[id].error || '').slice(0, 400)
+          : JSON.stringify(tasks[id].result || '').slice(0, 400),
+      })
+    }
+  }
+
+  if (tasks[id].status === 'queued') {
+    const blockers = Array.isArray(tasks[id].blockedBy) ? tasks[id].blockedBy : []
+    const incompleteBlocker = blockers.find((bid: string) => tasks[bid] && tasks[bid].status !== 'completed')
+    if (incompleteBlocker) {
+      tasks[id].status = prevStatus
+      tasks[id].updatedAt = Date.now()
+      saveTask(id, tasks[id])
+      return serviceFail(409, 'Cannot queue: blocked by incomplete tasks')
+    }
+  }
+
+  if (tasks[id].status === 'completed') {
+    const unblockedIds = cascadeUnblock(tasks, id)
+    if (unblockedIds.length > 0) {
+      saveTaskMany([
+        [id, tasks[id]],
+        ...unblockedIds.map((uid) => [uid, tasks[uid]] as [string, BoardTask]),
+      ])
+      for (const uid of unblockedIds) {
+        enqueueTask(uid)
+      }
+    }
+  }
+
+  if (prevStatus !== 'queued' && tasks[id].status === 'queued') {
+    enqueueTask(id)
+  }
+
+  notify('tasks')
+  return serviceOk(enrichTaskWithMissionSummary({
+    ...tasks[id],
+    missionId: mission?.id || tasks[id].missionId || null,
+  }))
+}
+
+export function archiveTaskFromRoute(id: string): ServiceResult<BoardTask> {
+  const task = loadTask(id)
+  if (!task) return serviceFail(404, 'Task not found')
+  task.status = 'archived'
+  task.archivedAt = Date.now()
+  task.updatedAt = Date.now()
+  saveTask(id, task)
+  logActivity({ entityType: 'task', entityId: id, action: 'deleted', actor: 'user', summary: `Task archived: "${task.title}"` })
+  pushMainLoopEventToMainSessions({
+    type: 'task_archived',
+    text: `Task archived: "${task.title}" (${id}).`,
+  })
+  notify('tasks')
+  return serviceOk(task)
+}
+
+export function createTaskFromRoute(body: Record<string, unknown>): ServiceResult<BoardTask> {
+  const id = genId()
+  const now = Date.now()
+  const tasks = loadTasks()
+  const settings = loadSettings()
+  const maxAttempts = Number.isFinite(Number(body.maxAttempts))
+    ? Math.max(1, Math.min(20, Math.trunc(Number(body.maxAttempts))))
+    : Math.max(1, Math.min(20, Math.trunc(Number(settings.defaultTaskMaxAttempts ?? 3))))
+  const retryBackoffSec = Number.isFinite(Number(body.retryBackoffSec))
+    ? Math.max(1, Math.min(3600, Math.trunc(Number(body.retryBackoffSec))))
+    : Math.max(1, Math.min(3600, Math.trunc(Number(settings.taskRetryBackoffSec ?? 30))))
+  if (Array.isArray(body.blockedBy) && body.blockedBy.length > 0) {
+    const dagResult = validateDag(tasks, id, body.blockedBy)
+    if (!dagResult.valid) {
+      return serviceFail(400, 'Dependency cycle detected')
+    }
+  }
+  const description = typeof body.description === 'string' ? body.description : ''
+  const resolvedAgentId = description
+    ? resolveTaskAgentFromDescription(description, (body.agentId as string) || '', loadAgents())
+    : ((body.agentId as string) || '')
+
+  const prepared = prepareTaskCreation({
+    id,
+    input: {
+      ...body,
+      agentId: resolvedAgentId,
+    },
+    tasks,
+    now,
+    settings,
+    seed: {
+      projectId: typeof body.projectId === 'string' && body.projectId ? body.projectId : null,
+      goalContract: body.goalContract || null,
+      cwd: typeof body.cwd === 'string' ? body.cwd : null,
+      file: typeof body.file === 'string' ? body.file : null,
+      sessionId: typeof body.sessionId === 'string' ? body.sessionId : null,
+      result: typeof body.result === 'string' ? body.result : null,
+      error: typeof body.error === 'string' ? body.error : null,
+      outputFiles: Array.isArray(body.outputFiles)
+        ? body.outputFiles.filter((entry): entry is string => typeof entry === 'string').slice(0, 24)
+        : [],
+      artifacts: Array.isArray(body.artifacts)
+        ? body.artifacts
+            .filter((artifact) => artifact && typeof artifact === 'object')
+            .map((artifact) => {
+              const row = artifact as { url?: unknown; type?: unknown; filename?: unknown }
+              const normalizedType = String(row.type || '')
+              return {
+                url: String(row.url || ''),
+                type: ['image', 'video', 'pdf', 'file'].includes(normalizedType)
+                  ? (normalizedType as 'image' | 'video' | 'pdf' | 'file')
+                  : 'file',
+                filename: String(row.filename || ''),
+              }
+            })
+            .filter((artifact) => artifact.url && artifact.filename)
+            .slice(0, 24)
+        : [],
+      archivedAt: null,
+      attempts: 0,
+      maxAttempts,
+      retryBackoffSec,
+      retryScheduledAt: null,
+      deadLetteredAt: null,
+      checkpoint: null,
+      blockedBy: Array.isArray(body.blockedBy) ? body.blockedBy.filter((s): s is string => typeof s === 'string') : [],
+      blocks: Array.isArray(body.blocks) ? body.blocks.filter((s): s is string => typeof s === 'string') : [],
+      tags: Array.isArray(body.tags) ? body.tags.filter((s): s is string => typeof s === 'string') : [],
+      dueAt: typeof body.dueAt === 'number' ? body.dueAt : null,
+      customFields: body.customFields && typeof body.customFields === 'object' ? body.customFields : undefined,
+      priority: body.priority && ['low', 'medium', 'high', 'critical'].includes(String(body.priority))
+        ? body.priority as BoardTask['priority']
+        : undefined,
+    },
+  })
+  if (!prepared.ok) {
+    return serviceFail(400, prepared.error)
+  }
+  if (prepared.duplicate) {
+    return serviceOk({ ...prepared.duplicate, deduplicated: true } as BoardTask)
+  }
+
+  const task = prepared.task
+  if (task.status === 'completed') {
+    const agentExtensions = resolvedAgentId ? getEnabledCapabilityIds(loadAgents()[resolvedAgentId]) : []
+    getExtensionManager().runHook(
+      'onTaskComplete',
+      { taskId: id, result: task.result },
+      { enabledIds: agentExtensions },
+    )
+  }
+
+  const parentTaskId = typeof body.parentTaskId === 'string' && body.parentTaskId.trim() ? body.parentTaskId.trim() : null
+  if (parentTaskId) {
+    task.parentTaskId = parentTaskId
+    const parentTask = tasks[parentTaskId]
+    if (parentTask) {
+      const subtaskIds = Array.isArray(parentTask.subtaskIds) ? parentTask.subtaskIds : []
+      if (!subtaskIds.includes(id)) {
+        parentTask.subtaskIds = [...subtaskIds, id]
+        parentTask.updatedAt = now
+        saveTask(parentTaskId, parentTask)
+      }
+    }
+  }
+
+  saveTask(id, task)
+  const mission = ensureMissionForTask(task, { source: 'manual' })
+  const finalTask = enrichTaskWithMissionSummary({
+    ...task,
+    missionId: mission?.id || task.missionId || null,
+  })
+  logActivity({ entityType: 'task', entityId: id, action: 'created', actor: 'user', summary: `Task created: "${task.title}"` })
+  pushMainLoopEventToMainSessions({
+    type: 'task_created',
+    text: `Task created: "${task.title}" (${id}) with status ${task.status}.`,
+  })
+  if (task.status === 'queued') {
+    enqueueTask(id)
+  }
+  notify('tasks')
+  return serviceOk(finalTask)
+}
+
+export function bulkUpdateTasksFromRoute(body: Record<string, unknown>): ServiceResult<{ updated: number; ids: string[] }> {
+  const ids = body.ids
+  if (!Array.isArray(ids) || ids.length === 0) {
+    return serviceFail(400, 'ids must be a non-empty array')
+  }
+  const taskIds = ids.filter((id): id is string => typeof id === 'string')
+  if (taskIds.length === 0) {
+    return serviceFail(400, 'No valid task IDs provided')
+  }
+  const tasks = loadTasks()
+  let updated = 0
+  const results: string[] = []
+
+  for (const id of taskIds) {
+    if (!tasks[id]) continue
+    const prevStatus = tasks[id].status
+    if (typeof body.status === 'string' && VALID_BULK_STATUSES.includes(body.status as BoardTaskStatus)) {
+      tasks[id].status = body.status as BoardTaskStatus
+      if (body.status === 'archived' && prevStatus !== 'archived') {
+        tasks[id].archivedAt = Date.now()
+      }
+    }
+    if ('agentId' in body) {
+      tasks[id].agentId = body.agentId === null ? '' : String(body.agentId)
+    }
+    if ('projectId' in body) {
+      if (body.projectId === null) delete tasks[id].projectId
+      else tasks[id].projectId = String(body.projectId)
+    }
+    tasks[id].updatedAt = Date.now()
+    updated += 1
+    results.push(id)
+    if (prevStatus !== tasks[id].status) {
+      logActivity({
+        entityType: 'task',
+        entityId: id,
+        action: 'updated',
+        actor: 'user',
+        summary: `Bulk update: "${tasks[id].title}" (${prevStatus} → ${tasks[id].status})`,
+      })
+      pushMainLoopEventToMainSessions({
+        type: 'task_status_changed',
+        text: `Task "${tasks[id].title}" (${id}) moved ${prevStatus} → ${tasks[id].status}.`,
+      })
+      if (tasks[id].status === 'completed' || tasks[id].status === 'failed') {
+        disableSessionHeartbeat(tasks[id].sessionId)
+      }
+      if (prevStatus !== 'queued' && tasks[id].status === 'queued') {
+        enqueueTask(id)
+      }
+    }
+  }
+  saveTaskMany(results.map((id) => [id, tasks[id]] as [string, BoardTask]))
+  if (updated > 0) {
+    const action = body.status
+      ? `moved ${updated} task(s) to ${body.status}`
+      : `updated ${updated} task(s)`
+    createNotification({
+      type: 'success',
+      title: `Bulk update: ${action}`,
+      entityType: 'task',
+    })
+  }
+  notify('tasks')
+  return serviceOk({ updated, ids: results })
+}
+
+export function deleteTasksByFilter(filter: string | null) {
+  const tasks = loadTasks()
+  let removed = 0
+  const shouldRemove = (task: { status: string; sourceType?: string }) =>
+    filter === 'all'
+    || (filter === 'schedule' && task.sourceType === 'schedule')
+    || (filter === 'done' && (task.status === 'completed' || task.status === 'failed'))
+    || (!filter && task.status === 'archived')
+
+  for (const [id, task] of Object.entries(tasks)) {
+    if (!shouldRemove(task as { status: string; sourceType?: string })) continue
+    deleteTask(id)
+    removed += 1
+  }
+  notify('tasks')
+  return { removed, remaining: Object.keys(tasks).length - removed }
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Shared text-normalization utilities.
+ *
+ * Consolidates the cleanText / cleanMultiline / normalizeList helpers that
+ * were previously duplicated across 7+ server modules.
+ */
+
+/** Collapse whitespace, trim, and cap at `max` characters. Returns `''` for non-string input. */
+export function cleanText(value: unknown, max = 320): string {
+  if (typeof value !== 'string') return ''
+  return value.replace(/\s+/g, ' ').trim().slice(0, max)
+}
+
+/** Trim each line, drop blanks, rejoin, and cap at `max` characters. Returns `''` for non-string input. */
+export function cleanMultiline(value: unknown, max = 1_200): string {
+  if (typeof value !== 'string') return ''
+  return value
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .join('\n')
+    .slice(0, max)
+    .trim()
+}
+
+/** Deduplicated, cleaned list of strings from unknown input. */
+export function normalizeList(input: unknown, maxItems: number, maxChars = 240): string[] {
+  const values = Array.isArray(input) ? input : []
+  const seen = new Set<string>()
+  const out: string[] = []
+  for (const value of values) {
+    const cleaned = cleanText(value, maxChars)
+    if (!cleaned) continue
+    const key = cleaned.toLowerCase()
+    if (seen.has(key)) continue
+    seen.add(key)
+    out.push(cleaned)
+    if (out.length >= maxItems) break
+  }
+  return out
+}