@swarmclawai/swarmclaw 0.7.7 → 0.8.0

package/src/lib/server/queue-followups.test.ts

@@ -1,7 +1,14 @@
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
-import type { BoardTask } from '@/types'
-import { resolveTaskOriginConnectorFollowupTarget } from './queue'
+import type { BoardTask, Session } from '@/types'
+import {
+  applyTaskResumeStateToSession,
+  collectTaskConnectorFollowupTargets,
+  dequeueNextRunnableTask,
+  resolveTaskOriginConnectorFollowupTarget,
+  resolveTaskResumeContext,
+  resolveReusableTaskSessionId,
+} from './queue'
 
 function makeTask(partial?: Partial<BoardTask> & { createdInSessionId?: string | null }): BoardTask {
   const now = Date.now()
@@ -18,12 +25,19 @@ function makeTask(partial?: Partial<BoardTask> & { createdInSessionId?: string |
 }
 
 type SessionFixtureMap = Record<string, {
+  connectorContext?: {
+    connectorId?: string
+    channelId?: string
+    threadId?: string
+  }
   messages: Array<{
     role: string
     text?: string
+    historyExcluded?: boolean
     source?: {
       connectorId?: string
       channelId?: string
+      threadId?: string
     }
   }>
 }>
@@ -221,4 +235,397 @@ describe('resolveTaskOriginConnectorFollowupTarget', () => {
       channelId: '447700900123@s.whatsapp.net',
     })
   })
+
+  it('prefers explicit task followup metadata over later thread traffic', () => {
+    const task = makeTask({
+      createdInSessionId: 'session-1',
+      followupConnectorId: 'conn-wa',
+      followupChannelId: '447700900111@s.whatsapp.net',
+      followupThreadId: 'thread-me',
+    })
+    const sessions = {
+      'session-1': {
+        messages: [
+          {
+            role: 'user',
+            text: 'wife said hello',
+            source: {
+              connectorId: 'conn-wa',
+              channelId: '447700900222@s.whatsapp.net',
+              threadId: 'thread-wife',
+            },
+          },
+        ],
+      },
+    }
+    const connectors = {
+      'conn-wa': {
+        id: 'conn-wa',
+        platform: 'whatsapp',
+        agentId: 'agent-a',
+        config: {},
+      },
+    }
+    const running = [
+      {
+        id: 'conn-wa',
+        platform: 'whatsapp',
+        agentId: 'agent-a',
+        supportsSend: true,
+        configuredTargets: [],
+        recentChannelId: '447700900222@s.whatsapp.net',
+      },
+    ]
+
+    const target = resolveTaskOriginConnectorFollowupTarget({
+      task,
+      sessions: sessions as SessionFixtureMap,
+      connectors,
+      running,
+    })
+
+    assert.deepEqual(target, {
+      connectorId: 'conn-wa',
+      channelId: '447700900111@s.whatsapp.net',
+      threadId: 'thread-me',
+    })
+  })
+
+  it('ignores mirrored connector transcript copies when resolving delayed followups', () => {
+    const task = makeTask({ createdInSessionId: 'session-main' })
+    const sessions = {
+      'session-main': {
+        messages: [
+          {
+            role: 'user',
+            text: 'from me over whatsapp',
+            historyExcluded: true,
+            source: {
+              connectorId: 'conn-wa',
+              channelId: '447700900111@s.whatsapp.net',
+            },
+          },
+          {
+            role: 'user',
+            text: 'from wife over whatsapp later',
+            historyExcluded: true,
+            source: {
+              connectorId: 'conn-wa',
+              channelId: '447700900222@s.whatsapp.net',
+            },
+          },
+        ],
+      },
+    }
+    const connectors = {
+      'conn-wa': {
+        id: 'conn-wa',
+        platform: 'whatsapp',
+        agentId: 'agent-a',
+        config: {
+          taskFollowups: 'true',
+        },
+      },
+    }
+    const running = [
+      {
+        id: 'conn-wa',
+        platform: 'whatsapp',
+        agentId: 'agent-a',
+        supportsSend: true,
+        configuredTargets: [],
+        recentChannelId: '447700900222@s.whatsapp.net',
+      },
+    ]
+
+    const target = resolveTaskOriginConnectorFollowupTarget({
+      task,
+      sessions: sessions as SessionFixtureMap,
+      connectors,
+      running,
+    })
+
+    assert.equal(target, null)
+  })
+})
+
+describe('collectTaskConnectorFollowupTargets', () => {
+  it('does not fall back to a connector recent channel when there is no explicit origin target', () => {
+    const task = makeTask({ createdInSessionId: 'session-main' })
+    const sessions = {
+      'session-main': {
+        messages: [
+          {
+            role: 'user',
+            text: 'mirrored from me',
+            historyExcluded: true,
+            source: {
+              connectorId: 'conn-wa',
+              channelId: '447700900111@s.whatsapp.net',
+            },
+          },
+        ],
+      },
+    }
+    const connectors = {
+      'conn-wa': {
+        id: 'conn-wa',
+        platform: 'whatsapp',
+        agentId: 'agent-a',
+        config: {
+          taskFollowups: 'true',
+        },
+      },
+    }
+    const running = [
+      {
+        id: 'conn-wa',
+        platform: 'whatsapp',
+        agentId: 'agent-a',
+        supportsSend: true,
+        configuredTargets: [],
+        recentChannelId: '447700900222@s.whatsapp.net',
+      },
+    ]
+
+    const targets = collectTaskConnectorFollowupTargets({
+      task,
+      sessions: sessions as SessionFixtureMap,
+      connectors,
+      running,
+    })
+
+    assert.deepEqual(targets, [])
+  })
+
+  it('uses only the origin target when both origin and a different recent channel exist', () => {
+    const task = makeTask({
+      createdInSessionId: 'session-origin',
+      followupConnectorId: 'conn-wa',
+      followupChannelId: '447700900111@s.whatsapp.net',
+    })
+    const sessions = {
+      'session-origin': {
+        messages: [],
+      },
+    }
+    const connectors = {
+      'conn-wa': {
+        id: 'conn-wa',
+        platform: 'whatsapp',
+        agentId: 'agent-a',
+        config: {
+          taskFollowups: 'true',
+          outboundJid: '447700900333@s.whatsapp.net',
+        },
+      },
+    }
+    const running = [
+      {
+        id: 'conn-wa',
+        platform: 'whatsapp',
+        agentId: 'agent-a',
+        supportsSend: true,
+        configuredTargets: [],
+        recentChannelId: '447700900222@s.whatsapp.net',
+      },
+    ]
+
+    const targets = collectTaskConnectorFollowupTargets({
+      task,
+      sessions: sessions as SessionFixtureMap,
+      connectors,
+      running,
+    })
+
+    assert.deepEqual(targets, [
+      {
+        connectorId: 'conn-wa',
+        channelId: '447700900111@s.whatsapp.net',
+      },
+    ])
+  })
+
+  it('uses configured outbound targets for generic task followups', () => {
+    const task = makeTask({ createdInSessionId: 'session-main' })
+    const sessions = {
+      'session-main': {
+        messages: [],
+      },
+    }
+    const connectors = {
+      'conn-wa': {
+        id: 'conn-wa',
+        platform: 'whatsapp',
+        agentId: 'agent-a',
+        config: {
+          taskFollowups: 'true',
+          outboundJid: '+44 7700 900333',
+        },
+      },
+    }
+    const running = [
+      {
+        id: 'conn-wa',
+        platform: 'whatsapp',
+        agentId: 'agent-a',
+        supportsSend: true,
+        configuredTargets: [],
+        recentChannelId: '447700900222@s.whatsapp.net',
+      },
+    ]
+
+    const targets = collectTaskConnectorFollowupTargets({
+      task,
+      sessions: sessions as SessionFixtureMap,
+      connectors,
+      running,
+    })
+
+    assert.deepEqual(targets, [
+      {
+        connectorId: 'conn-wa',
+        channelId: '447700900333@s.whatsapp.net',
+      },
+    ])
+  })
+})
+
+describe('task resume context', () => {
+  it('falls back to delegated parent task resume handles for follow-up work', () => {
+    const parent = makeTask({
+      id: 'task-parent',
+      title: 'Parent task',
+      codexResumeId: 'codex-thread-123',
+      geminiResumeId: 'gemini-session-123',
+      sessionId: 'session-parent',
+    })
+    const child = makeTask({
+      id: 'task-child',
+      title: 'Child task',
+      delegatedFromTaskId: 'task-parent',
+    })
+
+    const context = resolveTaskResumeContext(child, {
+      [parent.id]: parent,
+      [child.id]: child,
+    })
+
+    assert.ok(context)
+    assert.equal(context?.source, 'delegated_from_task')
+    assert.equal(context?.sourceTaskId, 'task-parent')
+    assert.equal(context?.sourceSessionId, 'session-parent')
+    assert.equal(context?.resume.codexThreadId, 'codex-thread-123')
+    assert.equal(context?.resume.delegateResumeIds.gemini, 'gemini-session-123')
+  })
+
+  it('hydrates task execution sessions with stored resume state', () => {
+    const session = {
+      id: 'session-task',
+      name: 'Task session',
+      cwd: process.cwd(),
+      user: 'system',
+      provider: 'codex-cli',
+      model: 'gpt-5-codex',
+      claudeSessionId: null,
+      codexThreadId: null,
+      opencodeSessionId: null,
+      delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null },
+      messages: [],
+      createdAt: Date.now(),
+      lastActiveAt: Date.now(),
+      sessionType: 'human',
+      agentId: 'agent-a',
+      parentSessionId: null,
+      plugins: ['delegate'],
+    } satisfies Session
+
+    const changed = applyTaskResumeStateToSession(session, {
+      claudeSessionId: 'claude-resume-1',
+      codexThreadId: 'codex-resume-1',
+      opencodeSessionId: 'opencode-resume-1',
+      delegateResumeIds: {
+        claudeCode: 'claude-resume-1',
+        codex: 'codex-resume-1',
+        opencode: 'opencode-resume-1',
+        gemini: 'gemini-resume-1',
+      },
+    })
+
+    assert.equal(changed, true)
+    assert.equal(session.claudeSessionId, 'claude-resume-1')
+    assert.equal(session.codexThreadId, 'codex-resume-1')
+    assert.equal(session.opencodeSessionId, 'opencode-resume-1')
+    assert.equal(session.delegateResumeIds?.gemini, 'gemini-resume-1')
+  })
+})
+
+describe('dequeueNextRunnableTask', () => {
+  it('leaves blocked queued tasks in place until their dependencies are completed', () => {
+    const source = makeTask({
+      id: 'task-source',
+      title: 'Source task',
+      status: 'running',
+    })
+    const followup = makeTask({
+      id: 'task-followup',
+      title: 'Follow-up task',
+      status: 'queued',
+      blockedBy: ['task-source'],
+    })
+    const queue = ['task-followup']
+
+    const selectedWhileBlocked = dequeueNextRunnableTask(queue, {
+      [source.id]: source,
+      [followup.id]: followup,
+    })
+
+    assert.equal(selectedWhileBlocked, null)
+    assert.deepEqual(queue, ['task-followup'])
+
+    source.status = 'completed'
+    const selectedAfterUnblock = dequeueNextRunnableTask(queue, {
+      [source.id]: source,
+      [followup.id]: followup,
+    })
+
+    assert.equal(selectedAfterUnblock, 'task-followup')
+    assert.deepEqual(queue, [])
+  })
+})
+
+describe('resolveReusableTaskSessionId', () => {
+  it('reuses the completed dependency session for continuation tasks once it exists', () => {
+    const source = makeTask({
+      id: 'task-source',
+      title: 'Source task',
+      status: 'completed',
+      sessionId: 'session-source',
+      checkpoint: {
+        lastSessionId: 'session-source',
+        updatedAt: Date.now(),
+      },
+    })
+    const followup = makeTask({
+      id: 'task-followup',
+      title: 'Follow-up task',
+      status: 'queued',
+      blockedBy: ['task-source'],
+    })
+
+    const sessionId = resolveReusableTaskSessionId(
+      followup,
+      {
+        [source.id]: source,
+        [followup.id]: followup,
+      },
+      {
+        'session-source': {
+          messages: [],
+        },
+      } as SessionFixtureMap,
+    )
+
+    assert.equal(sessionId, 'session-source')
+  })
 })

package/src/lib/server/queue-reconcile.test.ts

@@ -0,0 +1,128 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { describe, it } from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-queue-reconcile-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        DATA_DIR: path.join(tempDir, 'data'),
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+        SWARMCLAW_BUILD_MODE: '1',
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+describe('reconcileFinishedRunningTasks', () => {
+  it('finalizes a completed one-off scheduled task from its finished session and deletes the schedule', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const queueMod = await import('./src/lib/server/queue.ts')
+      const storage = storageMod.default || storageMod
+      const queue = queueMod.default || queueMod
+
+      const now = Date.now()
+      const workspace = process.env.WORKSPACE_DIR
+      storage.saveAgents({
+        agent_birthday: {
+          id: 'agent_birthday',
+          name: 'Birthday Bot',
+          description: '',
+          systemPrompt: '',
+          provider: 'openai',
+          model: 'gpt-test',
+          threadSessionId: null,
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+      storage.saveSessions({
+        'session-birthday': {
+          id: 'session-birthday',
+          name: 'Birthday Run',
+          cwd: workspace,
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [
+            {
+              role: 'assistant',
+              text: 'Happy birthday. I sent a WhatsApp follow-up to the user directly and confirmed delivery with message id 3EB0B7262FF68B7BD261D4.',
+              time: now,
+            },
+          ],
+          createdAt: now - 10_000,
+          lastActiveAt: now,
+          active: false,
+          currentRunId: null,
+          heartbeatEnabled: true,
+        },
+      })
+      storage.saveSchedules({
+        'schedule-birthday': {
+          id: 'schedule-birthday',
+          name: 'Birthday Reminder',
+          scheduleType: 'once',
+          status: 'completed',
+          agentId: 'agent_birthday',
+          createdByAgentId: 'agent_birthday',
+          createdAt: now - 20_000,
+          updatedAt: now - 5_000,
+        },
+      })
+      storage.saveTasks({
+        'task-birthday': {
+          id: 'task-birthday',
+          title: 'Birthday follow-up',
+          description: 'Wish me happy birthday tomorrow over WhatsApp.',
+          status: 'running',
+          agentId: 'agent_birthday',
+          createdAt: now - 20_000,
+          updatedAt: now - 5_000,
+          startedAt: now - 15_000,
+          sessionId: 'session-birthday',
+          sourceType: 'schedule',
+          sourceScheduleId: 'schedule-birthday',
+          sourceScheduleName: 'Birthday Reminder',
+          maxAttempts: 3,
+          retryBackoffSec: 30,
+        },
+      })
+
+      const result = queue.reconcileFinishedRunningTasks()
+      console.log(JSON.stringify({
+        result,
+        task: storage.loadTasks()['task-birthday'],
+        schedule: storage.loadSchedules()['schedule-birthday'] || null,
+        session: storage.loadSessions()['session-birthday'],
+      }))
+    `)
+
+    assert.equal(output.result.reconciled, 1)
+    assert.equal(output.task.status, 'completed')
+    assert.equal(output.schedule, null)
+    assert.equal(output.session.heartbeatEnabled, false)
+    assert.match(output.task.result, /WhatsApp follow-up/i)
+  })
+})