@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/lib/server/daemon-state.ts

@@ -1,4 +1,4 @@
-import { loadQueue, loadSchedules, loadSessions, saveSessions, loadConnectors, saveConnectors, loadWebhookRetryQueue, upsertWebhookRetry, deleteWebhookRetry, loadWebhooks, loadAgents, loadSettings, appendWebhookLog, loadCredentials, decryptKey } from './storage'
+import { loadQueue, loadSchedules, loadSessions, loadConnectors, saveConnectors, loadWebhookRetryQueue, upsertWebhookRetry, deleteWebhookRetry, loadWebhooks, loadAgents, loadSettings, appendWebhookLog, loadCredentials, decryptKey } from './storage'
 import { notify } from './ws-hub'
 import { processNext, cleanupFinishedTaskSessions, validateCompletedTasksQueue, recoverStalledRunningTasks, resumeQueue } from './queue'
 import { startScheduler, stopScheduler } from './scheduler'
@@ -18,24 +18,37 @@ import {
   getReconnectState,
   setReconnectState,
 } from './connectors/manager'
-import { startHeartbeatService, stopHeartbeatService, getHeartbeatServiceStatus } from './heartbeat-service'
+import { startConnectorOutboxWorker, stopConnectorOutboxWorker } from './connectors/outbox'
+import { startHeartbeatService, stopHeartbeatService, getHeartbeatServiceStatus, pruneHeartbeatState } from './heartbeat-service'
 import { hasOpenClawAgents, ensureGatewayConnected, disconnectGateway, getGateway } from './openclaw-gateway'
 import { enqueueSessionRun } from './session-run-manager'
 import { WORKSPACE_DIR } from './data-dir'
 import { DEFAULT_HEARTBEAT_INTERVAL_SEC } from '@/lib/heartbeat-defaults'
 import { genId } from '@/lib/id'
-import { isProductionRuntime } from '@/lib/runtime-env'
+import { errorMessage, hmrSingleton } from '@/lib/shared-utils'
 import path from 'node:path'
 import type { Session, WebhookRetryEntry } from '@/types'
 import { createNotification } from '@/lib/server/create-notification'
 import { pingProvider, OPENAI_COMPATIBLE_DEFAULTS } from '@/lib/server/provider-health'
 import { runIntegrityMonitor } from '@/lib/server/integrity-monitor'
 import { recoverStaleDelegationJobs } from './delegation-jobs'
+import { pruneMainLoopState } from './main-agent-loop'
+import { sweepManagedProcesses } from './process-manager'
 import {
   listPendingApprovalsNeedingConnectorNotification,
   markApprovalConnectorNotificationAttempt,
   markApprovalConnectorNotificationSent,
 } from './approvals'
+import {
+  buildSessionHeartbeatHealthDedupKey,
+  daemonAutostartEnvEnabled,
+  isDaemonBackgroundServicesEnabled,
+  parseCronToMs,
+  parseHeartbeatIntervalSec,
+  shouldNotifyProviderReachabilityIssue,
+  shouldSuppressSessionHeartbeatHealthAlert,
+  shouldSuppressSyntheticAgentHealthAlert,
+} from './daemon-policy'
 
 const QUEUE_CHECK_INTERVAL = 30_000 // 30 seconds
 const BROWSER_SWEEP_INTERVAL = 60_000 // 60 seconds
@@ -52,74 +65,16 @@ const CONNECTOR_RESTART_BASE_MS = 30_000
 const CONNECTOR_RESTART_MAX_MS = 15 * 60 * 1000
 const MAX_WAKE_ATTEMPTS = 3
 
-function parseBoolish(value: unknown, fallback: boolean): boolean {
-  if (typeof value === 'boolean') return value
-  if (typeof value !== 'string') return fallback
-  const normalized = value.trim().toLowerCase()
-  if (!normalized) return fallback
-  if (['1', 'true', 'yes', 'on'].includes(normalized)) return true
-  if (['0', 'false', 'no', 'off'].includes(normalized)) return false
-  return fallback
-}
-
-function daemonAutostartEnvEnabled(): boolean {
-  return parseBoolish(process.env.SWARMCLAW_DAEMON_AUTOSTART, isProductionRuntime())
-}
-
-export function isDaemonBackgroundServicesEnabled(): boolean {
-  return parseBoolish(process.env.SWARMCLAW_DAEMON_BACKGROUND_SERVICES, true)
-}
-
-function parseHeartbeatIntervalSec(value: unknown, fallback = DEFAULT_HEARTBEAT_INTERVAL_SEC): number {
-  const parsed = typeof value === 'number'
-    ? value
-    : typeof value === 'string'
-      ? Number.parseInt(value, 10)
-      : Number.NaN
-  if (!Number.isFinite(parsed)) return fallback
-  return Math.max(0, Math.min(3600, Math.trunc(parsed)))
-}
-
-export function shouldNotifyProviderReachabilityIssue(provider: string): boolean {
-  return provider !== 'openclaw'
-}
-
-const SYNTHETIC_HEALTH_SESSION_USERS = new Set(['workbench', 'comparison-bench'])
-const SYNTHETIC_HEALTH_SESSION_PREFIXES = ['wb-', 'cmp-']
-
-function hasSyntheticHealthPrefix(value: unknown): boolean {
-  const normalized = typeof value === 'string' ? value.trim().toLowerCase() : ''
-  return SYNTHETIC_HEALTH_SESSION_PREFIXES.some((prefix) => normalized.startsWith(prefix))
-}
-
-export function shouldSuppressSessionHeartbeatHealthAlert(
-  session: Pick<Session, 'id' | 'name' | 'user' | 'shortcutForAgentId'>,
-): boolean {
-  const user = typeof session.user === 'string' ? session.user.trim().toLowerCase() : ''
-  if (SYNTHETIC_HEALTH_SESSION_USERS.has(user)) return true
-  if (hasSyntheticHealthPrefix(session.id)) return true
-  if (hasSyntheticHealthPrefix(session.shortcutForAgentId)) return true
-
-  const name = typeof session.name === 'string' ? session.name.trim().toLowerCase() : ''
-  return name.startsWith('workbench ')
-    || name.startsWith('assistant benchmark ')
-    || name.startsWith('comparison ')
-}
-
-export function shouldSuppressSyntheticAgentHealthAlert(agentId: string): boolean {
-  return hasSyntheticHealthPrefix(agentId)
-}
-
-export function buildSessionHeartbeatHealthDedupKey(
-  sessionId: string,
-  state: 'stale' | 'auto-disabled',
-): string {
-  return `health-alert:session-heartbeat:${state}:${sessionId}`
+export {
+  buildSessionHeartbeatHealthDedupKey,
+  isDaemonBackgroundServicesEnabled,
+  shouldNotifyProviderReachabilityIssue,
+  shouldSuppressSessionHeartbeatHealthAlert,
+  shouldSuppressSyntheticAgentHealthAlert,
 }
 
 // Store daemon state on globalThis to survive HMR reloads
-const gk = '__swarmclaw_daemon__' as const
-const ds: {
+interface DaemonState {
   queueIntervalId: ReturnType<typeof setInterval> | null
   browserSweepId: ReturnType<typeof setInterval> | null
   healthIntervalId: ReturnType<typeof setInterval> | null
@@ -138,8 +93,9 @@ const ds: {
   manualStopRequested: boolean
   running: boolean
   lastProcessedAt: number | null
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-} = (globalThis as any)[gk] ?? ((globalThis as any)[gk] = {
+}
+
+const ds: DaemonState = hmrSingleton<DaemonState>('__swarmclaw_daemon__', () => ({
   queueIntervalId: null,
   browserSweepId: null,
   healthIntervalId: null,
@@ -155,7 +111,7 @@ const ds: {
   manualStopRequested: false,
   running: false,
   lastProcessedAt: null,
-})
+}))
 
 // Backfill fields for hot-reloaded daemon state objects from older code versions.
 if (!ds.staleSessionIds) ds.staleSessionIds = new Set<string>()
@@ -193,7 +149,7 @@ export function startDaemon(options?: { source?: string; manualStart?: boolean }
     startBrowserSweep()
     startHeartbeatService()
     startMemoryConsolidation()
-    syncDaemonBackgroundServices()
+    syncDaemonBackgroundServices({ runConnectorHealthCheckImmediately: false })
     return
   }
   ds.running = true
@@ -210,18 +166,18 @@ export function startDaemon(options?: { source?: string; manualStart?: boolean }
     startBrowserSweep()
     startHeartbeatService()
     startMemoryConsolidation()
-    syncDaemonBackgroundServices()
+    syncDaemonBackgroundServices({ runConnectorHealthCheckImmediately: false })
   } catch (err: unknown) {
     ds.running = false
     notify('daemon')
-    console.error('[daemon] Failed to start:', err instanceof Error ? err.message : String(err))
+    console.error('[daemon] Failed to start:', errorMessage(err))
     throw err
   }
 
   if (isDaemonBackgroundServicesEnabled()) {
     // Auto-start enabled connectors only when the full background stack is enabled.
     autoStartConnectors().catch((err: unknown) => {
-      console.error('[daemon] Error auto-starting connectors:', err instanceof Error ? err.message : String(err))
+      console.error('[daemon] Error auto-starting connectors:', errorMessage(err))
     })
   }
 }
@@ -239,10 +195,11 @@ export function stopDaemon(options?: { source?: string; manualStop?: boolean })
   stopBrowserSweep()
   stopHealthMonitor()
   stopConnectorHealthMonitor()
+  stopConnectorOutboxWorker()
   stopHeartbeatService()
   stopMemoryConsolidation()
   stopEvalScheduler()
-  stopAllConnectors().catch(() => {})
+  stopAllConnectors({ disable: false }).catch(() => {})
 }
 
 function startBrowserSweep() {
@@ -270,6 +227,7 @@ function stopBrowserSweep() {
 function startQueueProcessor() {
   if (ds.queueIntervalId) return
   ds.queueIntervalId = setInterval(async () => {
+    if (!ds.running) return
     const queue = loadQueue()
     if (queue.length > 0) {
       console.log(`[daemon] Processing ${queue.length} queued task(s)`)
@@ -323,7 +281,7 @@ async function runConnectorHealthChecks(now: number) {
   try {
     await checkConnectorHealth()
   } catch (err: unknown) {
-    console.error('[health] Connector isAlive check failed:', err instanceof Error ? err.message : String(err))
+    console.error('[health] Connector isAlive check failed:', errorMessage(err))
   }
 
   const connectors = loadConnectors()
@@ -369,7 +327,7 @@ async function runConnectorHealthChecks(now: number) {
       clearReconnectState(connector.id)
       await sendHealthAlert(`Connector "${connector.name}" (${connector.platform}) was down and has been auto-restarted.`)
     } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : String(err)
+      const message = errorMessage(err)
       const next = advanceConnectorReconnectState(current, message, now, {
         initialBackoffMs: CONNECTOR_RESTART_BASE_MS,
         maxBackoffMs: CONNECTOR_RESTART_MAX_MS,
@@ -474,9 +432,8 @@ async function processWebhookRetries() {
         heartbeatEnabled: (agent.heartbeatEnabled as boolean | undefined) ?? false,
         heartbeatIntervalSec: (agent.heartbeatIntervalSec as number | null | undefined) ?? null,
       }
-      sessions[session.id as string] = session
-      const { saveSessions: save } = await import('./storage')
-      save(sessions)
+      const { upsertSession: upsert } = await import('./storage')
+      upsert(session.id as string, session)
     }
 
     const payloadPreview = (entry.payload || '').slice(0, 12_000)
@@ -518,7 +475,7 @@ async function processWebhookRetries() {
       deleteWebhookRetry(entry.id)
       console.log(`[webhook-retry] Successfully retried ${entry.id} for webhook ${entry.webhookId} (attempt ${entry.attempts})`)
     } catch (err: unknown) {
-      const errorMsg = err instanceof Error ? err.message : String(err)
+      const errorMsg = errorMessage(err)
       entry.attempts += 1
 
       if (entry.attempts >= entry.maxAttempts) {
@@ -699,7 +656,7 @@ async function runOpenClawGatewayHealthChecks() {
         const { runOpenClawDoctor } = await import('./openclaw-doctor')
         await runOpenClawDoctor({ fix: true })
       } catch (err: unknown) {
-        console.warn('[daemon] openclaw doctor --fix failed:', err instanceof Error ? err.message : String(err))
+        console.warn('[daemon] openclaw doctor --fix failed:', errorMessage(err))
       }
       repair.attempts += 1
       repair.lastAttemptAt = now
@@ -750,7 +707,7 @@ async function runPendingApprovalConnectorNotifications(now: number) {
         entityId: reminder.approvalId,
       })
     } catch (err: unknown) {
-      const errorMsg = err instanceof Error ? err.message : String(err)
+      const errorMsg = errorMessage(err)
       markApprovalConnectorNotificationAttempt(reminder.approvalId, {
         at: now,
         connectorId: reminder.connectorId,
@@ -763,6 +720,33 @@ async function runPendingApprovalConnectorNotifications(now: number) {
   }
 }
 
+/**
+ * Prune orphaned entries from module-level Maps/Sets that reference
+ * sessions, connectors, or agents that no longer exist in storage.
+ * Runs every health-check cycle (2 minutes).
+ */
+function pruneOrphanedState(sessions: Record<string, unknown>): void {
+  const liveSessionIds = new Set(Object.keys(sessions))
+
+  // Main-loop state map (per-session autonomous state)
+  pruneMainLoopState(liveSessionIds)
+
+  // Heartbeat service tracking maps
+  pruneHeartbeatState(liveSessionIds)
+
+  // Process manager — sweep completed processes older than TTL
+  sweepManagedProcesses()
+
+  // Daemon-local: prune openclawRepairState for agents that no longer exist
+  const agents = loadAgents()
+  for (const agentId of ds.openclawRepairState.keys()) {
+    if (!agents[agentId]) ds.openclawRepairState.delete(agentId)
+  }
+  for (const agentId of ds.openclawDownAgentIds) {
+    if (!agents[agentId]) ds.openclawDownAgentIds.delete(agentId)
+  }
+}
+
 async function runHealthChecks() {
   // Continuously keep the completed queue honest.
   validateCompletedTasksQueue()
@@ -774,7 +758,7 @@ async function runHealthChecks() {
   const sessions = loadSessions()
   const now = Date.now()
   const currentlyStale = new Set<string>()
-  let sessionsDirty = false
+  const dirtySessionIds: string[] = []
 
   for (const session of Object.values(sessions) as Record<string, unknown>[]) {
     if (!session?.id || typeof session.id !== 'string') continue
@@ -799,7 +783,7 @@ async function runHealthChecks() {
       if (staleForMs > autoDisableAfter) {
         session.heartbeatEnabled = false
         session.lastActiveAt = now
-        sessionsDirty = true
+        dirtySessionIds.push(sessionId)
         ds.staleSessionIds.delete(sessionId)
         await sendHealthAlert({
           text: `Auto-disabled heartbeat for stale session "${sessionLabel}" after ${Math.round(staleForMs / 60_000)}m of inactivity.`,
@@ -831,26 +815,32 @@ async function runHealthChecks() {
     }
   }
 
-  if (sessionsDirty) saveSessions(sessions)
+  for (const sid of dirtySessionIds) {
+    const s = sessions[sid]
+    if (s) {
+      const { upsertSession: upsert } = await import('./storage')
+      upsert(sid, s)
+    }
+  }
 
   // Provider reachability checks
   try {
     await runProviderHealthChecks()
   } catch (err: unknown) {
-    console.error('[daemon] Provider health check failed:', err instanceof Error ? err.message : String(err))
+    console.error('[daemon] Provider health check failed:', errorMessage(err))
   }
 
   // OpenClaw gateway health checks + auto-repair
   try {
     await runOpenClawGatewayHealthChecks()
   } catch (err: unknown) {
-    console.error('[daemon] OpenClaw gateway health check failed:', err instanceof Error ? err.message : String(err))
+    console.error('[daemon] OpenClaw gateway health check failed:', errorMessage(err))
   }
 
   try {
     await runPendingApprovalConnectorNotifications(now)
   } catch (err: unknown) {
-    console.error('[daemon] Approval connector reminder check failed:', err instanceof Error ? err.message : String(err))
+    console.error('[daemon] Approval connector reminder check failed:', errorMessage(err))
   }
 
   // Integrity drift monitoring for identity/config/plugin files.
@@ -879,14 +869,21 @@ async function runHealthChecks() {
       await sendHealthAlert(`Integrity monitor detected ${integrity.drifts.length} file drift event(s).`)
     }
   } catch (err: unknown) {
-    console.error('[daemon] Integrity monitor check failed:', err instanceof Error ? err.message : String(err))
+    console.error('[daemon] Integrity monitor check failed:', errorMessage(err))
   }
 
   // Process webhook retry queue
   try {
     await processWebhookRetries()
   } catch (err: unknown) {
-    console.error('[daemon] Webhook retry processing failed:', err instanceof Error ? err.message : String(err))
+    console.error('[daemon] Webhook retry processing failed:', errorMessage(err))
+  }
+
+  // Periodic memory hygiene: prune orphaned state for deleted sessions/connectors
+  try {
+    pruneOrphanedState(sessions)
+  } catch (err: unknown) {
+    console.error('[daemon] Memory hygiene sweep failed:', errorMessage(err))
   }
 }
 
@@ -906,28 +903,32 @@ function stopHealthMonitor() {
   }
 }
 
-function syncDaemonBackgroundServices() {
+function syncDaemonBackgroundServices(options?: { runConnectorHealthCheckImmediately?: boolean }) {
   if (isDaemonBackgroundServicesEnabled()) {
     startHealthMonitor()
-    startConnectorHealthMonitor()
+    startConnectorHealthMonitor({
+      runImmediately: options?.runConnectorHealthCheckImmediately !== false,
+    })
+    startConnectorOutboxWorker()
     startEvalScheduler()
     return
   }
   stopHealthMonitor()
   stopConnectorHealthMonitor()
+  stopConnectorOutboxWorker()
   stopEvalScheduler()
 }
 
-function startConnectorHealthMonitor() {
+function startConnectorHealthMonitor(options?: { runImmediately?: boolean }) {
   if (ds.connectorHealthIntervalId) return
 
   const tick = () => {
     runConnectorHealthChecks(Date.now()).catch((err) => {
-      console.error('[daemon] Connector health tick failed:', err instanceof Error ? err.message : String(err))
+      console.error('[daemon] Connector health tick failed:', errorMessage(err))
     })
   }
 
-  tick()
+  if (options?.runImmediately !== false) tick()
   ds.connectorHealthIntervalId = setInterval(tick, CONNECTOR_HEALTH_CHECK_INTERVAL)
 }
 
@@ -949,7 +950,7 @@ function runConsolidationTick() {
       }
     }),
   ).catch((err: unknown) => {
-    console.error('[daemon] Memory consolidation failed:', err instanceof Error ? err.message : String(err))
+    console.error('[daemon] Memory consolidation failed:', errorMessage(err))
   })
 }
 
@@ -978,14 +979,6 @@ function stopMemoryConsolidation() {
 
 const EVAL_DEFAULT_INTERVAL_MS = 24 * 3600_000 // 24 hours
 
-function parseCronToMs(cron: string | null | undefined): number | null {
-  if (!cron || typeof cron !== 'string') return null
-  // Simple heuristic: extract hours from common cron patterns like "0 */6 * * *"
-  const hourMatch = cron.match(/\*\/(\d+)/)
-  if (hourMatch) return parseInt(hourMatch[1], 10) * 3600_000
-  return EVAL_DEFAULT_INTERVAL_MS
-}
-
 async function runEvalSchedulerTick() {
   try {
     const settings = loadSettings()
@@ -1009,11 +1002,11 @@ async function runEvalSchedulerTick() {
           type: result.percentage >= 60 ? 'info' : 'warning',
         })
       } catch (err: unknown) {
-        console.error(`[daemon:eval] Failed for agent ${agentId}:`, err instanceof Error ? err.message : String(err))
+        console.error(`[daemon:eval] Failed for agent ${agentId}:`, errorMessage(err))
       }
     }
   } catch (err: unknown) {
-    console.error('[daemon:eval] Scheduler tick error:', err instanceof Error ? err.message : String(err))
+    console.error('[daemon:eval] Scheduler tick error:', errorMessage(err))
   }
 }
 
@@ -1022,7 +1015,7 @@ function startEvalScheduler() {
   try {
     const settings = loadSettings()
     if (!settings.autonomyEvalEnabled) return
-    const intervalMs = parseCronToMs(settings.autonomyEvalCron) || EVAL_DEFAULT_INTERVAL_MS
+    const intervalMs = parseCronToMs(settings.autonomyEvalCron, EVAL_DEFAULT_INTERVAL_MS) || EVAL_DEFAULT_INTERVAL_MS
     ds.evalSchedulerIntervalId = setInterval(runEvalSchedulerTick, intervalMs)
     console.log(`[daemon:eval] Eval scheduler started (interval=${Math.round(intervalMs / 3600_000)}h)`)
   } catch {
@@ -1086,6 +1079,10 @@ export async function runDaemonHealthCheckNow() {
   ])
 }
 
+export async function runConnectorHealthCheckNowForTest(now = Date.now()) {
+  await runConnectorHealthChecks(now)
+}
+
 export function getDaemonStatus() {
   const queue = loadQueue()
   const schedules = loadSchedules()

package/src/lib/server/data-dir.test.ts

@@ -28,7 +28,7 @@ describe('data-dir resolution', () => {
 
     try {
       const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', `
-        const modNs = await import('./src/lib/server/data-dir.ts')
+        const modNs = await import('./src/lib/server/data-dir')
         const mod = modNs.default || modNs['module.exports'] || modNs
         console.log(JSON.stringify({
           dataDir: mod.DATA_DIR,
@@ -60,12 +60,12 @@ describe('data-dir resolution', () => {
 
     try {
       const env = { ...process.env, HOME: fakeHome, npm_lifecycle_event: 'build:ci' }
-      delete env.DATA_DIR
-      delete env.WORKSPACE_DIR
-      delete env.BROWSER_PROFILES_DIR
+      delete (env as any).DATA_DIR
+      delete (env as any).WORKSPACE_DIR
+      delete (env as any).BROWSER_PROFILES_DIR
 
       const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', `
-        const modNs = await import('./src/lib/server/data-dir.ts')
+        const modNs = await import('./src/lib/server/data-dir')
         const mod = modNs.default || modNs['module.exports'] || modNs
         console.log(JSON.stringify({
           isBuildBootstrap: mod.IS_BUILD_BOOTSTRAP,

package/src/lib/server/data-dir.ts

@@ -20,6 +20,10 @@ function resolveDataDir(): string {
 }
 
 export const DATA_DIR = resolveDataDir()
+export const CONNECTORS_DATA_DIR = path.join(DATA_DIR, 'connectors')
+export const OPENCLAW_DATA_DIR = path.join(DATA_DIR, 'openclaw')
+export const MEMORY_IMAGES_DIR = path.join(DATA_DIR, 'memory-images')
+export const APP_LOG_PATH = path.join(DATA_DIR, 'app.log')
 
 function supportsChildWrites(dir: string): boolean {
   try {

package/src/lib/server/delegation-jobs-advanced.test.ts

@@ -275,7 +275,7 @@ describe('delegation-jobs-advanced', () => {
     // Kept: file-6..file-9 (4) + all batch2 (10) + all batch3 (10) = 24
     const first = afterBatch3.artifacts[0]
     assert.equal(first.type, 'file')
-    assert.equal(first.value, '/output/file-6.ts')
+    assert.equal(first.value, '/output/file-6')
 
     const last = afterBatch3.artifacts[23]
     assert.equal(last.type, 'image')

package/src/lib/server/delegation-jobs.test.ts

@@ -99,6 +99,93 @@ describe('delegation-jobs', () => {
     assert.match(String(latest?.error || ''), /interrupted/i)
   })
 
+  // ---------------------------------------------------------------------------
+  // Reliability fix #4: atomic updateDelegationJob preserves fields
+  // ---------------------------------------------------------------------------
+
+  it('atomic update preserves all original fields', () => {
+    const job = delegationJobs.createDelegationJob({
+      kind: 'subagent',
+      task: 'Atomic update test',
+      agentId: 'ag-atomic',
+      agentName: 'Atomic Agent',
+      parentSessionId: 'parent-atomic',
+    })
+
+    // Partial update should not lose unrelated fields
+    const updated = delegationJobs.updateDelegationJob(job.id, { status: 'running' })
+    assert.ok(updated)
+    assert.equal(updated!.status, 'running')
+    assert.equal(updated!.task, 'Atomic update test')
+    assert.equal(updated!.agentId, 'ag-atomic')
+    assert.equal(updated!.agentName, 'Atomic Agent')
+    assert.equal(updated!.parentSessionId, 'parent-atomic')
+    assert.equal(updated!.kind, 'subagent')
+  })
+
+  it('sequential updates preserve intermediate state', () => {
+    const job = delegationJobs.createDelegationJob({
+      kind: 'subagent',
+      task: 'Sequential updates',
+    })
+
+    delegationJobs.updateDelegationJob(job.id, { status: 'running', startedAt: Date.now() })
+    delegationJobs.updateDelegationJob(job.id, { result: 'partial result' })
+
+    const final = delegationJobs.getDelegationJob(job.id)
+    assert.ok(final)
+    assert.equal(final!.status, 'running')
+    assert.equal(final!.result, 'partial result')
+    assert.ok(final!.startedAt! > 0)
+  })
+
+  it('updateDelegationJob returns null for non-existent job', () => {
+    const result = delegationJobs.updateDelegationJob('nonexistent-abc', { status: 'running' })
+    assert.equal(result, null)
+  })
+
+  // ---------------------------------------------------------------------------
+  // Reliability fix (bonus): cancel ordering — state committed before handle delete
+  // ---------------------------------------------------------------------------
+
+  it('cancel records checkpoint and timestamp atomically', () => {
+    const job = delegationJobs.createDelegationJob({
+      kind: 'subagent',
+      task: 'Cancel ordering test',
+    })
+
+    const cancelled = delegationJobs.cancelDelegationJob(job.id)
+    assert.ok(cancelled)
+    assert.equal(cancelled!.status, 'cancelled')
+    assert.ok(cancelled!.completedAt! > 0)
+    const cps = cancelled!.checkpoints ?? []
+    const lastCp = cps[cps.length - 1]
+    assert.equal(lastCp?.status, 'cancelled')
+    assert.equal(lastCp?.note, 'Job cancelled')
+  })
+
+  it('cancel is idempotent — repeated cancel returns unchanged job', () => {
+    const job = delegationJobs.createDelegationJob({
+      kind: 'subagent',
+      task: 'Idempotent cancel',
+    })
+
+    const first = delegationJobs.cancelDelegationJob(job.id)!
+    const second = delegationJobs.cancelDelegationJob(job.id)!
+    assert.equal(second.status, 'cancelled')
+    assert.equal((second.checkpoints ?? []).length, (first.checkpoints ?? []).length)
+  })
+
+  it('does not cancel completed jobs', () => {
+    const job = delegationJobs.createDelegationJob({
+      kind: 'subagent',
+      task: 'Completed job cancel',
+    })
+    delegationJobs.completeDelegationJob(job.id, 'All done')
+    const afterCancel = delegationJobs.cancelDelegationJob(job.id)
+    assert.equal(afterCancel!.status, 'completed')
+  })
+
   it('cancels all running jobs for a parent session', () => {
     const jobA = delegationJobs.createDelegationJob({
       kind: 'delegate',