@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/lib/server/task-lifecycle.ts

@@ -0,0 +1,200 @@
+import { genId } from '@/lib/id'
+import type { BoardTask, BoardTaskStatus, Schedule, TaskComment } from '@/types'
+
+import { ensureTaskCompletionReport, type TaskReportArtifact } from './task-reports'
+import {
+  formatValidationFailure,
+  validateTaskCompletion,
+  type TaskCompletionValidation,
+} from './task-validation'
+
+export interface BuildBoardTaskInput {
+  id?: string
+  title: string
+  description?: string | null
+  agentId: string
+  now: number
+  status?: BoardTaskStatus
+  seed?: Record<string, unknown>
+}
+
+export function buildBoardTask(input: BuildBoardTaskInput): BoardTask {
+  const id = input.id || genId()
+  const seed = input.seed ? { ...input.seed } : {}
+  const seedStatus = typeof seed.status === 'string' ? seed.status as BoardTaskStatus : undefined
+  const task = {
+    sessionId: null,
+    result: null,
+    error: null,
+    createdAt: input.now,
+    updatedAt: input.now,
+    queuedAt: null,
+    startedAt: null,
+    completedAt: null,
+    ...seed,
+    id,
+    title: input.title,
+    description: input.description ?? '',
+    status: input.status ?? seedStatus ?? 'backlog',
+    agentId: input.agentId,
+  } as BoardTask
+  return task
+}
+
+export interface ResetTaskForRerunOptions {
+  title: string
+  now: number
+  runNumber?: number | null
+}
+
+export function resetTaskForRerun(task: BoardTask, options: ResetTaskForRerunOptions): BoardTask {
+  const stats = task as unknown as Record<string, unknown>
+  stats.totalRuns = ((stats.totalRuns as number) || 0) + 1
+  if (task.status === 'completed') stats.totalCompleted = ((stats.totalCompleted as number) || 0) + 1
+  if (task.status === 'failed') stats.totalFailed = ((stats.totalFailed as number) || 0) + 1
+
+  task.status = 'backlog'
+  task.title = options.title
+  task.result = null
+  task.error = null
+  task.outputFiles = []
+  task.artifacts = []
+  task.sessionId = null
+  task.completionReportPath = null
+  task.updatedAt = options.now
+  task.queuedAt = null
+  task.startedAt = null
+  task.completedAt = null
+  task.archivedAt = null
+  task.attempts = 0
+  task.retryScheduledAt = null
+  task.deadLetteredAt = null
+  task.validation = null
+  if (options.runNumber !== undefined) stats.runNumber = options.runNumber
+  return task
+}
+
+export interface PrepareScheduledTaskRunOptions {
+  schedule: Pick<
+    Schedule,
+    | 'id'
+    | 'name'
+    | 'agentId'
+    | 'taskPrompt'
+    | 'linkedTaskId'
+    | 'runNumber'
+    | 'createdInSessionId'
+    | 'createdByAgentId'
+    | 'followupConnectorId'
+    | 'followupChannelId'
+    | 'followupThreadId'
+    | 'followupSenderId'
+    | 'followupSenderName'
+  >
+  tasks: Record<string, BoardTask>
+  now: number
+  scheduleSignature?: string | null
+}
+
+export function prepareScheduledTaskRun(params: PrepareScheduledTaskRunOptions): { taskId: string; task: BoardTask } {
+  const { schedule, tasks, now, scheduleSignature } = params
+  const title = `[Sched] ${schedule.name} (run #${schedule.runNumber})`
+  const existingTaskId = typeof schedule.linkedTaskId === 'string' ? schedule.linkedTaskId : ''
+  const existingTask = existingTaskId ? tasks[existingTaskId] : null
+
+  if (existingTask && existingTask.status !== 'queued' && existingTask.status !== 'running') {
+    return {
+      taskId: existingTaskId,
+      task: resetTaskForRerun(existingTask, {
+        title,
+        now,
+        runNumber: schedule.runNumber,
+      }),
+    }
+  }
+
+  const task = buildBoardTask({
+    title,
+    description: schedule.taskPrompt || '',
+    agentId: schedule.agentId,
+    now,
+    seed: {
+      sourceType: 'schedule',
+      sourceScheduleId: schedule.id,
+      sourceScheduleName: schedule.name,
+      sourceScheduleKey: scheduleSignature || null,
+      createdInSessionId: schedule.createdInSessionId || null,
+      createdByAgentId: schedule.createdByAgentId || null,
+      followupConnectorId: schedule.followupConnectorId || null,
+      followupChannelId: schedule.followupChannelId || null,
+      followupThreadId: schedule.followupThreadId || null,
+      followupSenderId: schedule.followupSenderId || null,
+      followupSenderName: schedule.followupSenderName || null,
+      runNumber: schedule.runNumber,
+    },
+  })
+  tasks[task.id] = task
+  schedule.linkedTaskId = task.id
+  return { taskId: task.id, task }
+}
+
+function sameValidationReasons(a?: string[] | null, b?: string[] | null): boolean {
+  const av = Array.isArray(a) ? a : []
+  const bv = Array.isArray(b) ? b : []
+  if (av.length !== bv.length) return false
+  for (let i = 0; i < av.length; i++) {
+    if (av[i] !== bv[i]) return false
+  }
+  return true
+}
+
+export function didTaskValidationChange(
+  previous: TaskCompletionValidation | null | undefined,
+  next: TaskCompletionValidation,
+): boolean {
+  return !previous
+    || previous.ok !== next.ok
+    || !sameValidationReasons(previous.reasons, next.reasons)
+}
+
+export function refreshTaskCompletionValidation(
+  task: BoardTask,
+  settings?: Record<string, unknown> | null,
+): { report: TaskReportArtifact | null; validation: TaskCompletionValidation } {
+  const report = ensureTaskCompletionReport(task)
+  if (report?.relativePath) task.completionReportPath = report.relativePath
+  const validation = validateTaskCompletion(task, { report, settings: settings || null })
+  task.validation = validation
+  return { report, validation }
+}
+
+export function markValidatedTaskCompleted(
+  task: BoardTask,
+  options: { now: number; preserveCompletedAt?: boolean } ,
+): BoardTask {
+  task.status = 'completed'
+  task.completedAt = options.preserveCompletedAt ? (task.completedAt || options.now) : options.now
+  task.updatedAt = options.now
+  task.error = null
+  return task
+}
+
+export function markInvalidCompletedTaskFailed(
+  task: BoardTask,
+  validation: TaskCompletionValidation,
+  options: { now: number; comment?: Omit<TaskComment, 'id' | 'createdAt'> & { text: string } } ,
+): BoardTask {
+  task.status = 'failed'
+  task.completedAt = null
+  task.updatedAt = options.now
+  task.error = formatValidationFailure(validation.reasons).slice(0, 500)
+  if (options.comment) {
+    if (!task.comments) task.comments = []
+    task.comments.push({
+      id: genId(),
+      createdAt: options.now,
+      ...options.comment,
+    })
+  }
+  return task
+}

package/src/lib/server/task-quality-gate.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
-import { normalizeTaskQualityGate } from './task-quality-gate.ts'
+import { normalizeTaskQualityGate } from './task-quality-gate'
 
 test('normalizeTaskQualityGate uses defaults when unset', () => {
   const gate = normalizeTaskQualityGate(undefined, undefined)

package/src/lib/server/task-resume.ts

@@ -0,0 +1,208 @@
+import type { BoardTask, Session } from '@/types'
+import type { SessionLike } from './task-followups'
+
+export interface TaskResumeState {
+  claudeSessionId: string | null
+  codexThreadId: string | null
+  opencodeSessionId: string | null
+  delegateResumeIds: NonNullable<Session['delegateResumeIds']>
+}
+
+export interface TaskResumeContext {
+  source: 'self' | 'delegated_from_task' | 'blocked_by'
+  sourceTaskId: string
+  sourceTaskTitle: string
+  sourceSessionId: string | null
+  resume: TaskResumeState
+}
+
+function normalizeResumeHandle(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value.trim() : null
+}
+
+function buildEmptyDelegateResumeIds(): NonNullable<Session['delegateResumeIds']> {
+  return {
+    claudeCode: null,
+    codex: null,
+    opencode: null,
+    gemini: null,
+  }
+}
+
+function normalizeCliProvider(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value.trim().toLowerCase() : null
+}
+
+function hasResumeState(state: TaskResumeState | null | undefined): state is TaskResumeState {
+  if (!state) return false
+  return Boolean(
+    state.claudeSessionId
+    || state.codexThreadId
+    || state.opencodeSessionId
+    || state.delegateResumeIds.claudeCode
+    || state.delegateResumeIds.codex
+    || state.delegateResumeIds.opencode
+    || state.delegateResumeIds.gemini
+  )
+}
+
+export function extractTaskResumeState(task: Partial<BoardTask> | null | undefined): TaskResumeState | null {
+  if (!task) return null
+
+  const legacyResumeId = normalizeResumeHandle(task.cliResumeId)
+  const legacyProvider = normalizeCliProvider(task.cliProvider)
+  const claudeSessionId = normalizeResumeHandle(task.claudeResumeId)
+    || (legacyProvider === 'claude-cli' ? legacyResumeId : null)
+  const codexThreadId = normalizeResumeHandle(task.codexResumeId)
+    || (legacyProvider === 'codex-cli' ? legacyResumeId : null)
+  const opencodeSessionId = normalizeResumeHandle(task.opencodeResumeId)
+    || (legacyProvider === 'opencode-cli' ? legacyResumeId : null)
+  const geminiSessionId = normalizeResumeHandle(task.geminiResumeId)
+    || (legacyProvider === 'gemini-cli' ? legacyResumeId : null)
+
+  const resume = {
+    claudeSessionId,
+    codexThreadId,
+    opencodeSessionId,
+    delegateResumeIds: {
+      claudeCode: claudeSessionId,
+      codex: codexThreadId,
+      opencode: opencodeSessionId,
+      gemini: geminiSessionId,
+    },
+  } satisfies TaskResumeState
+
+  return hasResumeState(resume) ? resume : null
+}
+
+export function extractSessionResumeState(session: Partial<Session> | null | undefined): TaskResumeState | null {
+  if (!session) return null
+
+  const claudeSessionId = normalizeResumeHandle(session.claudeSessionId)
+  const codexThreadId = normalizeResumeHandle(session.codexThreadId)
+  const opencodeSessionId = normalizeResumeHandle(session.opencodeSessionId)
+  const delegateResumeIds = session.delegateResumeIds && typeof session.delegateResumeIds === 'object'
+    ? { ...buildEmptyDelegateResumeIds(), ...session.delegateResumeIds }
+    : buildEmptyDelegateResumeIds()
+
+  const resume = {
+    claudeSessionId,
+    codexThreadId,
+    opencodeSessionId,
+    delegateResumeIds: {
+      claudeCode: normalizeResumeHandle(delegateResumeIds.claudeCode) || claudeSessionId,
+      codex: normalizeResumeHandle(delegateResumeIds.codex) || codexThreadId,
+      opencode: normalizeResumeHandle(delegateResumeIds.opencode) || opencodeSessionId,
+      gemini: normalizeResumeHandle(delegateResumeIds.gemini),
+    },
+  } satisfies TaskResumeState
+
+  return hasResumeState(resume) ? resume : null
+}
+
+export function resolveTaskResumeContext(
+  task: BoardTask,
+  tasksById: Record<string, BoardTask>,
+  sessionsById?: Record<string, SessionLike | Session>,
+): TaskResumeContext | null {
+  const candidates: Array<{ source: TaskResumeContext['source']; taskId: string | null | undefined }> = [
+    { source: 'self', taskId: task.id },
+    { source: 'delegated_from_task', taskId: task.delegatedFromTaskId },
+    ...((Array.isArray(task.blockedBy) ? task.blockedBy : []).map((taskId) => ({ source: 'blocked_by' as const, taskId }))),
+  ]
+  const seen = new Set<string>()
+
+  for (const candidate of candidates) {
+    const taskId = typeof candidate.taskId === 'string' ? candidate.taskId.trim() : ''
+    if (!taskId || seen.has(taskId)) continue
+    seen.add(taskId)
+    const sourceTask = taskId === task.id ? task : tasksById[taskId]
+    if (!sourceTask) continue
+    const sourceSessionId = normalizeResumeHandle(sourceTask.checkpoint?.lastSessionId) || normalizeResumeHandle(sourceTask.sessionId)
+    const resume = extractTaskResumeState(sourceTask)
+      || (sourceSessionId && sessionsById?.[sourceSessionId]
+        ? extractSessionResumeState(sessionsById[sourceSessionId] as Session)
+        : null)
+    if (!resume) continue
+    return {
+      source: candidate.source,
+      sourceTaskId: sourceTask.id,
+      sourceTaskTitle: sourceTask.title,
+      sourceSessionId,
+      resume,
+    }
+  }
+
+  return null
+}
+
+export function applyTaskResumeStateToSession(session: Session, resume: TaskResumeState | null | undefined): boolean {
+  if (!hasResumeState(resume)) return false
+
+  let changed = false
+  const directFields: Array<['claudeSessionId' | 'codexThreadId' | 'opencodeSessionId', string | null]> = [
+    ['claudeSessionId', resume.claudeSessionId],
+    ['codexThreadId', resume.codexThreadId],
+    ['opencodeSessionId', resume.opencodeSessionId],
+  ]
+  for (const [key, value] of directFields) {
+    if (!value || session[key] === value) continue
+    session[key] = value
+    changed = true
+  }
+
+  const currentDelegateResume = session.delegateResumeIds && typeof session.delegateResumeIds === 'object'
+    ? { ...buildEmptyDelegateResumeIds(), ...session.delegateResumeIds }
+    : buildEmptyDelegateResumeIds()
+  for (const [key, value] of Object.entries(resume.delegateResumeIds) as Array<[keyof NonNullable<Session['delegateResumeIds']>, string | null]>) {
+    if (!value || currentDelegateResume[key] === value) continue
+    currentDelegateResume[key] = value
+    changed = true
+  }
+  if (changed) session.delegateResumeIds = currentDelegateResume
+  return changed
+}
+
+export function resolveReusableTaskSessionId(
+  task: BoardTask,
+  tasks: Record<string, BoardTask>,
+  sessions: Record<string, SessionLike>,
+): string {
+  const candidateTaskIds = [
+    task.id,
+    typeof task.delegatedFromTaskId === 'string' ? task.delegatedFromTaskId : '',
+    ...(Array.isArray(task.blockedBy) ? task.blockedBy : []),
+  ]
+  const seen = new Set<string>()
+  for (const candidateTaskId of candidateTaskIds) {
+    const taskId = typeof candidateTaskId === 'string' ? candidateTaskId.trim() : ''
+    if (!taskId || seen.has(taskId)) continue
+    seen.add(taskId)
+    const sourceTask = taskId === task.id ? task : tasks[taskId]
+    if (!sourceTask) continue
+    const candidates = [
+      normalizeResumeHandle(sourceTask.checkpoint?.lastSessionId),
+      normalizeResumeHandle(sourceTask.sessionId),
+    ]
+    for (const candidate of candidates) {
+      if (candidate && sessions[candidate]) return candidate
+    }
+  }
+  return ''
+}
+
+export function buildTaskContinuationNote(
+  reusedExistingSession: boolean,
+  resumeContext: TaskResumeContext | null,
+): string {
+  const notes: string[] = []
+  if (reusedExistingSession) {
+    notes.push('Reusing the previous execution session for this task.')
+  }
+  if (resumeContext?.source === 'delegated_from_task' || resumeContext?.source === 'blocked_by') {
+    notes.push(`Stored CLI context is available from related task "${resumeContext.sourceTaskTitle}".`)
+  } else if (resumeContext?.source === 'self' && !reusedExistingSession) {
+    notes.push('Stored CLI resume handles are available for continuation.')
+  }
+  return notes.length ? `\n\n${notes.join(' ')}` : ''
+}

package/src/lib/server/task-service.test.ts

@@ -0,0 +1,108 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { computeTaskFingerprint } from '@/lib/task-dedupe'
+import type { BoardTask } from '@/types'
+
+import { applyTaskPatch, prepareTaskCreation } from './task-service'
+
+function makeTask(overrides: Partial<BoardTask> = {}): BoardTask {
+  return {
+    id: 'task-1',
+    title: 'Example Task',
+    description: 'Do the work',
+    status: 'backlog',
+    agentId: 'agent-1',
+    sessionId: null,
+    result: null,
+    error: null,
+    createdAt: 1,
+    updatedAt: 1,
+    queuedAt: null,
+    startedAt: null,
+    completedAt: null,
+    ...overrides,
+  }
+}
+
+describe('task service helpers', () => {
+  it('prepareTaskCreation derives a title and normalizes running to queued', () => {
+    const prepared = prepareTaskCreation({
+      id: 'task-create',
+      input: {
+        description: 'Please create a new login page for the app.',
+        status: 'running',
+        agentId: 'agent-1',
+      },
+      tasks: {},
+      now: 50,
+      deriveTitleFromDescription: true,
+      requireMeaningfulTitle: true,
+    })
+
+    assert.equal(prepared.ok, true)
+    if (!prepared.ok) return
+    assert.equal(prepared.duplicate, null)
+    assert.equal(prepared.task.title, 'a new login page for the app.')
+    assert.equal(prepared.task.status, 'queued')
+    assert.equal((prepared.task.fingerprint || '').length, 16)
+  })
+
+  it('prepareTaskCreation returns an existing duplicate task instead of a new one', () => {
+    const existing = makeTask({
+      id: 'existing-task',
+      title: 'Unique dedupe title',
+      agentId: 'agent-1',
+      fingerprint: computeTaskFingerprint('Unique dedupe title', 'agent-1'),
+    })
+    const prepared = prepareTaskCreation({
+      id: 'task-create',
+      input: {
+        title: 'Unique dedupe title',
+        description: 'Duplicate task',
+        agentId: 'agent-1',
+      },
+      tasks: { 'existing-task': existing },
+      now: 60,
+    })
+
+    assert.equal(prepared.ok, true)
+    if (!prepared.ok) return
+    assert.equal(prepared.duplicate?.id, 'existing-task')
+  })
+
+  it('applyTaskPatch strips invalid statuses and clears nullable project ids', () => {
+    const task = makeTask({
+      status: 'backlog',
+      projectId: 'project-1',
+    })
+
+    applyTaskPatch({
+      task,
+      patch: {
+        status: 'bananas',
+        projectId: null,
+      },
+      now: 75,
+      clearProjectIdWhenNull: true,
+    })
+
+    assert.equal(task.status, 'backlog')
+    assert.equal('projectId' in task, false)
+    assert.equal(task.updatedAt, 75)
+  })
+
+  it('applyTaskPatch normalizes running updates to queued', () => {
+    const task = makeTask({
+      status: 'backlog',
+    })
+
+    applyTaskPatch({
+      task,
+      patch: { status: 'running' },
+      now: 90,
+    })
+
+    assert.equal(task.status, 'queued')
+  })
+})