@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/app/api/schedules/[id]/route.ts

@@ -1,58 +1,58 @@
 import { NextResponse } from 'next/server'
-import { loadAgents, loadSchedules, loadSessions, saveSchedules, deleteSchedule } from '@/lib/server/storage'
+import { deleteSchedule, loadAgents, loadSchedules, loadSessions, upsertSchedules } from '@/lib/server/storage'
 import { WORKSPACE_DIR } from '@/lib/server/data-dir'
-import { resolveScheduleName } from '@/lib/schedule-name'
-import { mutateItem, deleteItem, notFound, type CollectionOps } from '@/lib/server/collection-helpers'
-import { normalizeSchedulePayload } from '@/lib/server/schedule-normalization'
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const ops: CollectionOps<any> = { load: loadSchedules, save: saveSchedules, deleteFn: deleteSchedule, topic: 'schedules' }
+import { notFound } from '@/lib/server/collection-helpers'
+import { getScheduleClusterIds, prepareScheduleUpdate } from '@/lib/server/schedule-service'
+import { errorMessage } from '@/lib/shared-utils'
+import { notify } from '@/lib/server/ws-hub'
 
 export async function PUT(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json()
+  const schedules = loadSchedules()
+  const current = schedules[id]
+  if (!current) return notFound()
   const sessions = loadSessions()
   const agents = loadAgents()
-  let result = null
-  try {
-    result = mutateItem(ops, id, (schedule) => {
-      const sessionCwd = typeof schedule.createdInSessionId === 'string'
-        ? sessions[schedule.createdInSessionId]?.cwd
-        : null
-      const normalized = normalizeSchedulePayload({
-        ...schedule,
-        ...(body as Record<string, unknown>),
-        id,
-      }, {
-        cwd: sessionCwd || WORKSPACE_DIR,
-        now: Date.now(),
-      })
-      if (!normalized.ok) throw new Error(normalized.error)
-      const nextSchedule = {
-        ...schedule,
-        ...normalized.value,
-        id,
-        updatedAt: Date.now(),
-      }
-      if (!agents[String(nextSchedule.agentId)]) {
-        throw new Error(`Agent not found: ${String(nextSchedule.agentId)}`)
-      }
-      nextSchedule.name = resolveScheduleName({
-        name: nextSchedule.name,
-        taskPrompt: nextSchedule.taskPrompt,
-      })
-      return nextSchedule
-    })
-  } catch (error: unknown) {
-    const message = error instanceof Error ? error.message : String(error)
+  const sessionCwd = typeof current.createdInSessionId === 'string'
+    ? sessions[current.createdInSessionId]?.cwd
+    : null
+  const prepared = prepareScheduleUpdate({
+    id,
+    current,
+    patch: body as Record<string, unknown>,
+    schedules,
+    now: Date.now(),
+    cwd: sessionCwd || WORKSPACE_DIR,
+    agentExists: (agentId) => Boolean(agents[agentId]),
+    propagateEquivalentStatuses: true,
+    propagationSource: current,
+  })
+  if (!prepared.ok) {
+    const message = errorMessage(prepared.error)
     return NextResponse.json({ error: message }, { status: 400 })
   }
-  if (!result) return notFound()
-  return NextResponse.json(result)
+  upsertSchedules(prepared.entries)
+  notify('schedules')
+  return NextResponse.json(
+    prepared.affectedScheduleIds.length > 1
+      ? { ...prepared.schedule, affectedScheduleIds: prepared.affectedScheduleIds }
+      : prepared.schedule,
+  )
 }
 
 export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  if (!deleteItem(ops, id)) return notFound()
-  return NextResponse.json({ ok: true })
+  const schedules = loadSchedules()
+  const current = schedules[id]
+  if (!current) return notFound()
+  const deleteIds = getScheduleClusterIds(schedules, current)
+  for (const deleteId of deleteIds) {
+    deleteSchedule(deleteId)
+  }
+  notify('schedules')
+  return NextResponse.json({
+    ok: true,
+    deletedIds: deleteIds,
+  })
 }

package/src/app/api/schedules/[id]/run/route.ts

@@ -1,11 +1,11 @@
 import { NextResponse } from 'next/server'
-import { genId } from '@/lib/id'
 import { notFound } from '@/lib/server/collection-helpers'
-import { loadSchedules, saveSchedules, loadAgents, loadTasks, saveTasks } from '@/lib/server/storage'
+import { loadSchedule, loadAgents, loadTasks, upsertSchedule, upsertTask } from '@/lib/server/storage'
 import { buildAgentDisabledMessage, isAgentDisabled } from '@/lib/server/agent-availability'
 import { enqueueTask } from '@/lib/server/queue'
 import { pushMainLoopEventToMainSessions } from '@/lib/server/main-agent-loop'
 import { getScheduleSignatureKey } from '@/lib/schedule-dedupe'
+import { prepareScheduledTaskRun } from '@/lib/server/task-lifecycle'
 
 type InFlightTask = {
   status?: string
@@ -14,8 +14,7 @@ type InFlightTask = {
 
 export async function POST(_req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
-  const schedules = loadSchedules()
-  const schedule = schedules[id]
+  const schedule = loadSchedule(id)
   if (!schedule) return notFound()
 
   const agents = loadAgents()
@@ -41,64 +40,14 @@ export async function POST(_req: Request, { params }: { params: Promise<{ id: st
   const now = Date.now()
   schedule.runNumber = (schedule.runNumber || 0) + 1
 
-  // Reuse linked task if it exists and is not in-flight
-  let taskId = ''
-  const existingTaskId = typeof schedule.linkedTaskId === 'string' ? schedule.linkedTaskId : ''
-  const existingTask = existingTaskId ? tasks[existingTaskId] : null
-
-  if (existingTask && existingTask.status !== 'queued' && existingTask.status !== 'running') {
-    taskId = existingTaskId
-    const prev = existingTask as Record<string, unknown>
-    prev.totalRuns = ((prev.totalRuns as number) || 0) + 1
-    if (existingTask.status === 'completed') prev.totalCompleted = ((prev.totalCompleted as number) || 0) + 1
-    if (existingTask.status === 'failed') prev.totalFailed = ((prev.totalFailed as number) || 0) + 1
-
-    existingTask.status = 'backlog'
-    existingTask.title = `[Sched] ${schedule.name} (run #${schedule.runNumber})`
-    existingTask.result = null
-    existingTask.error = null
-    existingTask.outputFiles = []
-    existingTask.artifacts = []
-    existingTask.sessionId = null
-    existingTask.completionReportPath = null
-    existingTask.updatedAt = now
-    existingTask.queuedAt = null
-    existingTask.startedAt = null
-    existingTask.completedAt = null
-    existingTask.archivedAt = null
-    existingTask.attempts = 0
-    existingTask.retryScheduledAt = null
-    existingTask.deadLetteredAt = null
-    existingTask.validation = null
-    prev.runNumber = schedule.runNumber
-  } else {
-    taskId = genId()
-    tasks[taskId] = {
-      id: taskId,
-      title: `[Sched] ${schedule.name} (run #${schedule.runNumber})`,
-      description: schedule.taskPrompt || '',
-      status: 'backlog',
-      agentId: schedule.agentId,
-      sessionId: null,
-      result: null,
-      error: null,
-      createdAt: now,
-      updatedAt: now,
-      queuedAt: null,
-      startedAt: null,
-      completedAt: null,
-      sourceType: 'schedule',
-      sourceScheduleId: schedule.id,
-      sourceScheduleName: schedule.name,
-      sourceScheduleKey: scheduleSignature || null,
-      createdInSessionId: schedule.createdInSessionId || null,
-      createdByAgentId: schedule.createdByAgentId || null,
-      runNumber: schedule.runNumber,
-    }
-    schedule.linkedTaskId = taskId
-  }
+  const { taskId } = prepareScheduledTaskRun({
+    schedule,
+    tasks,
+    now,
+    scheduleSignature,
+  })
 
-  saveTasks(tasks)
+  upsertTask(taskId, tasks[taskId])
   enqueueTask(taskId)
   pushMainLoopEventToMainSessions({
     type: 'schedule_fired',
@@ -106,7 +55,7 @@ export async function POST(_req: Request, { params }: { params: Promise<{ id: st
   })
 
   schedule.lastRunAt = now
-  saveSchedules(schedules)
+  upsertSchedule(schedule.id, schedule)
 
   return NextResponse.json({ ok: true, queued: true, taskId, runNumber: schedule.runNumber })
 }

package/src/app/api/schedules/route.ts

@@ -1,33 +1,11 @@
 import { NextResponse } from 'next/server'
-import { genId } from '@/lib/id'
-import { loadAgents, loadSchedules, saveSchedules } from '@/lib/server/storage'
-import { WORKSPACE_DIR } from '@/lib/server/data-dir'
-import { normalizeSchedulePayload } from '@/lib/server/schedule-normalization'
+import { loadAgents, loadSchedules, upsertSchedule, upsertSchedules } from '@/lib/server/storage'
 import { buildAgentDisabledMessage, isAgentDisabled } from '@/lib/server/agent-availability'
-import { resolveScheduleName } from '@/lib/schedule-name'
-import { findDuplicateSchedule } from '@/lib/schedule-dedupe'
+import { WORKSPACE_DIR } from '@/lib/server/data-dir'
+import { prepareScheduleCreate } from '@/lib/server/schedule-service'
 import { notify } from '@/lib/server/ws-hub'
 export const dynamic = 'force-dynamic'
 
-function asString(value: unknown): string {
-  return typeof value === 'string' ? value.trim() : ''
-}
-
-function asPositiveInt(value: unknown): number | null {
-  const parsed = typeof value === 'number'
-    ? value
-    : typeof value === 'string'
-      ? Number.parseInt(value, 10)
-      : Number.NaN
-  if (!Number.isFinite(parsed)) return null
-  const intValue = Math.trunc(parsed)
-  return intValue > 0 ? intValue : null
-}
-
-function asScheduleType(value: unknown): 'cron' | 'interval' | 'once' {
-  return value === 'cron' || value === 'interval' || value === 'once' ? value : 'cron'
-}
-
 export async function GET(_req: Request) {
   return NextResponse.json(loadSchedules())
 }
@@ -36,76 +14,32 @@ export async function POST(req: Request) {
   const body = await req.json()
   const now = Date.now()
   const schedules = loadSchedules()
-  const normalizedSchedule = normalizeSchedulePayload(body as Record<string, unknown>, {
-    cwd: WORKSPACE_DIR,
-    now,
-  })
-  if (!normalizedSchedule.ok) {
-    return NextResponse.json({ error: normalizedSchedule.error }, { status: 400 })
-  }
-
-  const candidate = normalizedSchedule.value
   const agents = loadAgents()
-  const agent = agents[String(candidate.agentId)]
+  const candidateAgentId = typeof body?.agentId === 'string' ? body.agentId.trim() : ''
+  const agent = agents[candidateAgentId]
   if (!agent) {
-    return NextResponse.json({ error: `Agent not found: ${String(candidate.agentId)}` }, { status: 400 })
+    return NextResponse.json({ error: `Agent not found: ${String(body?.agentId)}` }, { status: 400 })
   }
   if (isAgentDisabled(agent)) {
     return NextResponse.json({ error: buildAgentDisabledMessage(agent, 'take scheduled work') }, { status: 409 })
   }
-  const scheduleType = asScheduleType(candidate.scheduleType)
-  const candidateAgentId = asString(candidate.agentId) || null
-  const candidateTaskPrompt = asString(candidate.taskPrompt)
-  const candidateCron = asString(candidate.cron) || null
-  const candidateIntervalMs = asPositiveInt(candidate.intervalMs)
-  const candidateRunAt = asPositiveInt(candidate.runAt)
-
-  const duplicate = findDuplicateSchedule(schedules, {
-    agentId: candidateAgentId,
-    taskPrompt: candidateTaskPrompt,
-    scheduleType,
-    cron: candidateCron,
-    intervalMs: candidateIntervalMs,
-    runAt: candidateRunAt,
+  const prepared = prepareScheduleCreate({
+    input: body as Record<string, unknown>,
+    schedules,
+    now,
+    cwd: WORKSPACE_DIR,
   })
-  if (duplicate) {
-    const duplicateId = duplicate.id || ''
-    let changed = false
-    const nextName = resolveScheduleName({
-      name: candidate.name ?? duplicate.name,
-      taskPrompt: candidate.taskPrompt ?? duplicate.taskPrompt,
-    })
-    if (nextName && nextName !== duplicate.name) {
-      duplicate.name = nextName
-      changed = true
-    }
-    const normalizedStatus = typeof candidate.status === 'string' ? candidate.status.trim().toLowerCase() : ''
-    if ((normalizedStatus === 'active' || normalizedStatus === 'paused') && duplicate.status !== normalizedStatus) {
-      duplicate.status = normalizedStatus as 'active' | 'paused'
-      changed = true
-    }
-    if (changed) {
-      const mutableDuplicate = duplicate as Record<string, unknown>
-      mutableDuplicate.updatedAt = now
-      if (duplicateId) schedules[duplicateId] = duplicate
-      saveSchedules(schedules)
-      notify('schedules')
-    }
-    return NextResponse.json(duplicate)
+  if (!prepared.ok) {
+    return NextResponse.json({ error: prepared.error }, { status: 400 })
   }
-
-  const id = genId()
-
-  schedules[id] = {
-    id,
-    ...candidate,
-    name: resolveScheduleName({ name: candidate.name, taskPrompt: candidate.taskPrompt }),
-    scheduleType,
-    lastRunAt: undefined,
-    createdAt: now,
-    updatedAt: now,
+  if (prepared.kind === 'duplicate') {
+    if (prepared.entries.length === 1) upsertSchedule(prepared.scheduleId, prepared.schedule)
+    else if (prepared.entries.length > 1) upsertSchedules(prepared.entries)
+    if (prepared.entries.length > 0) notify('schedules')
+    return NextResponse.json(prepared.schedule)
   }
-  saveSchedules(schedules)
+
+  upsertSchedule(prepared.scheduleId, prepared.schedule)
   notify('schedules')
-  return NextResponse.json(schedules[id])
+  return NextResponse.json(prepared.schedule)
 }

package/src/app/api/settings/route.ts

@@ -1,5 +1,6 @@
 import { NextResponse } from 'next/server'
 import { normalizeHeartbeatSettingFields } from '@/lib/heartbeat-defaults'
+import { normalizeWhatsAppApprovedContacts } from '@/lib/server/connectors/pairing'
 import { loadPublicSettings, loadSettings, saveSettings } from '@/lib/server/storage'
 import { normalizeRuntimeSettingFields } from '@/lib/runtime-loop'
 export const dynamic = 'force-dynamic'
@@ -130,6 +131,7 @@ export async function PUT(req: Request) {
   settings.projectManagementEnabled = parseBoolSetting(settings.projectManagementEnabled, true)
   settings.integrityMonitorEnabled = parseBoolSetting(settings.integrityMonitorEnabled, true)
   settings.sessionResetMode = settings.sessionResetMode === 'daily' ? 'daily' : settings.sessionResetMode === 'idle' ? 'idle' : null
+  settings.whatsappApprovedContacts = normalizeWhatsAppApprovedContacts(settings.whatsappApprovedContacts)
   settings.sessionIdleTimeoutSec = parseIntSetting(
     settings.sessionIdleTimeoutSec,
     12 * 60 * 60,

package/src/app/api/setup/doctor/route.ts

@@ -2,7 +2,9 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { spawnSync } from 'node:child_process'
 import { NextResponse } from 'next/server'
+import { DATA_DIR } from '@/lib/server/data-dir'
 import { loadAgents, loadCredentials, loadSettings } from '@/lib/server/storage'
+import { dedup, errorMessage } from '@/lib/shared-utils'
 
 type CheckStatus = 'pass' | 'warn' | 'fail'
 
@@ -38,7 +40,7 @@ function run(command: string, args: string[], timeoutMs = 8_000): CommandResult
     }
     return { ok: true, output: (result.stdout || '').trim() }
   } catch (err: unknown) {
-    const message = err instanceof Error ? err.message : String(err)
+    const message = errorMessage(err)
     return { ok: false, output: '', error: message }
   }
 }
@@ -77,7 +79,7 @@ function testDataWriteAccess(dataDir: string): { ok: boolean; error?: string } {
     fs.unlinkSync(probe)
     return { ok: true }
   } catch (err: unknown) {
-    const message = err instanceof Error ? err.message : String(err)
+    const message = errorMessage(err)
     return { ok: false, error: message }
   }
 }
@@ -124,13 +126,12 @@ export async function GET(req: Request) {
     actions.push('Run `npm run setup:easy` to install Deno automatically, or install Deno from https://deno.land/#installation.')
   }
 
-  const dataDir = path.join(process.cwd(), 'data')
-  const dataWrite = testDataWriteAccess(dataDir)
+  const dataWrite = testDataWriteAccess(DATA_DIR)
   if (dataWrite.ok) {
-    pushCheck(checks, 'data-dir', 'Data directory permissions', 'pass', `Writable: ${dataDir}`, true)
+    pushCheck(checks, 'data-dir', 'Data directory permissions', 'pass', `Writable: ${DATA_DIR}`, true)
   } else {
-    pushCheck(checks, 'data-dir', 'Data directory permissions', 'fail', dataWrite.error || `Cannot write to ${dataDir}`, true)
-    actions.push(`Fix filesystem permissions for ${dataDir}.`)
+    pushCheck(checks, 'data-dir', 'Data directory permissions', 'fail', dataWrite.error || `Cannot write to ${DATA_DIR}`, true)
+    actions.push(`Fix filesystem permissions for ${DATA_DIR}.`)
   }
 
   const envFile = path.join(process.cwd(), '.env.local')
@@ -259,7 +260,7 @@ export async function GET(req: Request) {
     checkedAt,
     summary,
     checks,
-    actions: Array.from(new Set(actions)),
+    actions: dedup(actions),
     git: {
       localSha,
       remoteSha,

package/src/app/api/tasks/[id]/approve/route.ts

@@ -1,16 +1,16 @@
 import { NextResponse } from 'next/server'
-import { loadTasks, saveTasks, loadAgents } from '@/lib/server/storage'
+import { loadTask, patchTask, loadAgents } from '@/lib/server/storage'
 import { notFound } from '@/lib/server/collection-helpers'
 import { notify } from '@/lib/server/ws-hub'
 import { getCheckpointSaver } from '@/lib/server/langgraph-checkpoint'
+import { errorMessage } from '@/lib/shared-utils'
 
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params
   const body = await req.json()
   const approved = body.approved === true
 
-  const tasks = loadTasks()
-  const task = tasks[id]
+  const task = loadTask(id)
   if (!task) return notFound()
   if (!task.pendingApproval) {
     return NextResponse.json({ error: 'No pending approval on this task' }, { status: 400 })
@@ -20,11 +20,14 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
 
   if (!approved) {
     // Reject: clear approval, delete checkpoint, fail the task
-    task.pendingApproval = null
-    task.status = 'failed'
-    task.error = 'Tool execution rejected by user'
-    task.updatedAt = Date.now()
-    saveTasks(tasks)
+    patchTask(id, (current) => {
+      if (!current) return current
+      current.pendingApproval = null
+      current.status = 'failed'
+      current.error = 'Tool execution rejected by user'
+      current.updatedAt = Date.now()
+      return current
+    })
     await getCheckpointSaver().deleteThread(threadId)
     notify('tasks')
     return NextResponse.json({ status: 'rejected' })
@@ -37,37 +40,37 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
     return NextResponse.json({ error: 'Agent not found' }, { status: 400 })
   }
 
-  task.pendingApproval = null
-  task.updatedAt = Date.now()
-  saveTasks(tasks)
+  const approvedTask = patchTask(id, (current) => {
+    if (!current) return current
+    current.pendingApproval = null
+    current.updatedAt = Date.now()
+    return current
+  })
   notify('tasks')
 
   // Resume in the background
-  const sessionId = task.sessionId || ''
+  const sessionId = approvedTask?.sessionId || task.sessionId || ''
   setImmediate(async () => {
     try {
       const { resumeLangGraphOrchestrator } = await import('@/lib/server/orchestrator-lg')
       const result = await resumeLangGraphOrchestrator(agent, sessionId, threadId)
-      const t2 = loadTasks()
-      if (t2[id] && !t2[id].pendingApproval) {
-        // Only mark completed if not paused again
-        if (t2[id].status === 'running') {
-          t2[id].result = result
-        }
-        t2[id].updatedAt = Date.now()
-        saveTasks(t2)
-        notify('tasks')
-      }
+      const updated = patchTask(id, (current) => {
+        if (!current || current.pendingApproval) return current
+        if (current.status === 'running') current.result = result
+        current.updatedAt = Date.now()
+        return current
+      })
+      if (updated) notify('tasks')
     } catch (err: unknown) {
-      const errMsg = err instanceof Error ? err.message : String(err)
+      const errMsg = errorMessage(err)
       console.error(`[approve] Resume failed for task ${id}:`, errMsg)
-      const t2 = loadTasks()
-      if (t2[id]) {
-        t2[id].error = errMsg
-        t2[id].updatedAt = Date.now()
-        saveTasks(t2)
-        notify('tasks')
-      }
+      const updated = patchTask(id, (current) => {
+        if (!current) return current
+        current.error = errMsg
+        current.updatedAt = Date.now()
+        return current
+      })
+      if (updated) notify('tasks')
     }
   })
 

package/src/app/api/tasks/[id]/route.ts

@@ -1,10 +1,7 @@
-import { genId } from '@/lib/id'
 import { NextResponse } from 'next/server'
 import { loadAgents, loadSettings, loadTasks, logActivity, upsertStoredItems, upsertTask } from '@/lib/server/storage'
 import { notFound } from '@/lib/server/collection-helpers'
 import { disableSessionHeartbeat, enqueueTask, recoverStalledRunningTasks, validateCompletedTasksQueue } from '@/lib/server/queue'
-import { ensureTaskCompletionReport } from '@/lib/server/task-reports'
-import { formatValidationFailure, validateTaskCompletion } from '@/lib/server/task-validation'
 import { pushMainLoopEventToMainSessions } from '@/lib/server/main-agent-loop'
 import { notify } from '@/lib/server/ws-hub'
 import { createNotification } from '@/lib/server/create-notification'
@@ -12,7 +9,9 @@ import { enqueueSystemEvent } from '@/lib/server/system-events'
 import { requestHeartbeatNow } from '@/lib/server/heartbeat-wake'
 import { validateDag, cascadeUnblock } from '@/lib/server/dag-validation'
 import { getPluginManager } from '@/lib/server/plugins'
-import { normalizeTaskQualityGate } from '@/lib/server/task-quality-gate'
+import {
+  applyTaskPatch,
+} from '@/lib/server/task-service'
 import type { BoardTask } from '@/types'
 import '@/lib/server/builtin-plugins'
 
@@ -53,14 +52,15 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
     tasks[id].comments.push(body.appendComment)
     tasks[id].updatedAt = Date.now()
   } else {
-    if (Object.prototype.hasOwnProperty.call(body, 'qualityGate')) {
-      body.qualityGate = body.qualityGate
-        ? normalizeTaskQualityGate(body.qualityGate, settings)
-        : null
-    }
-    Object.assign(tasks[id], body, { updatedAt: Date.now() })
-    // Explicitly clear nullable fields when sent as null (Object.assign copies null but not undefined)
-    if (body.projectId === null) delete tasks[id].projectId
+    applyTaskPatch({
+      task: tasks[id],
+      patch: body as Record<string, unknown>,
+      now: Date.now(),
+      settings,
+      preserveCompletedAt: true,
+      clearProjectIdWhenNull: true,
+      invalidCompletionCommentAuthor: 'System',
+    })
   }
   tasks[id].id = id // prevent id overwrite
 
@@ -69,29 +69,6 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
     tasks[id].archivedAt = Date.now()
   }
 
-  // Re-validate any completed task updates so "completed" always means actually done.
-  if (tasks[id].status === 'completed') {
-    const report = ensureTaskCompletionReport(tasks[id])
-    if (report?.relativePath) tasks[id].completionReportPath = report.relativePath
-    const validation = validateTaskCompletion(tasks[id], { report, settings })
-    tasks[id].validation = validation
-    if (validation.ok) {
-      tasks[id].completedAt = tasks[id].completedAt || Date.now()
-      tasks[id].error = null
-    } else {
-      tasks[id].status = 'failed'
-      tasks[id].completedAt = null
-      tasks[id].error = formatValidationFailure(validation.reasons).slice(0, 500)
-      if (!tasks[id].comments) tasks[id].comments = []
-      tasks[id].comments.push({
-        id: genId(),
-        author: 'System',
-        text: `Completion validation failed.\n\n${validation.reasons.map((r) => `- ${r}`).join('\n')}`,
-        createdAt: Date.now(),
-      })
-    }
-  }
-
   upsertTask(id, tasks[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) {

package/src/app/api/tasks/import/github/route.ts

@@ -6,6 +6,7 @@ import { formatZodError } from '@/lib/validation/schemas'
 import { loadSettings, loadTasks, logActivity, upsertStoredItems } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
 import type { BoardTask } from '@/types'
+import { dedup } from '@/lib/shared-utils'
 
 const MAX_IMPORT_LIMIT = 200
 const BODY_CHAR_LIMIT = 12_000
@@ -131,7 +132,7 @@ export function buildGitHubIssueTaskTags(issue: GitHubIssueRecord, repoFullName:
     repoFullName,
     ...(issue.labels || []).map(normalizeLabelName),
   ]
-  return Array.from(new Set(raw.map(normalizeTag).filter(Boolean))).slice(0, 8)
+  return dedup(raw.map(normalizeTag).filter(Boolean)).slice(0, 8)
 }
 
 function findExistingImportedTask(