@swarmclawai/swarmclaw 1.5.68 → 1.5.69

package/src/lib/server/daemon/controller.ts

@@ -25,7 +25,12 @@ import type {
 } from '@/lib/server/daemon/types'
 import { DATA_DIR } from '@/lib/server/data-dir'
 import { loadEstopState } from '@/lib/server/runtime/estop'
-import { getDaemonStatus } from '@/lib/server/runtime/daemon-state/core'
+import {
+  getDaemonHealthSummary,
+  getDaemonStatus,
+  startDaemon,
+  stopDaemon,
+} from '@/lib/server/runtime/daemon-state/core'
 import { daemonAutostartEnvEnabled } from '@/lib/server/runtime/daemon-policy'
 import {
   releaseRuntimeLock,
@@ -166,6 +171,15 @@ type DaemonSnapshotResponse = {
   healthSummary: DaemonHealthSummaryPayload
 }
 
+function getInProcessDaemonSnapshot(): DaemonSnapshotResponse | null {
+  const status = getDaemonStatus()
+  if (!status.running) return null
+  return {
+    status,
+    healthSummary: getDaemonHealthSummary() as DaemonHealthSummaryPayload,
+  }
+}
+
 async function requestDaemon<T>(
   metadata: DaemonAdminMetadata,
   routePath: string,
@@ -352,18 +366,19 @@ export async function ensureDaemonProcessRunning(
   source: string,
   opts?: { manualStart?: boolean },
 ): Promise<boolean> {
-  // In dev mode, the daemon may already be running in-process (same Next.js server)
-  // without a daemon-admin.json file. Check in-process state first to avoid spawning
-  // a subprocess that fails to acquire the already-held lease.
-  const inProcessStatus = getDaemonStatus()
-  if (inProcessStatus.running) return false
-
   const manualStart = opts?.manualStart === true
   const record = loadDaemonStatusRecord()
   if (loadEstopState().level !== 'none') return false
   if (!manualStart && !daemonAutostartEnvEnabled()) return false
   if (!manualStart && record.manualStopRequested) return false
 
+  const inProcessSnapshot = getInProcessDaemonSnapshot()
+  if (inProcessSnapshot) return false
+
+  const startedInProcess = startDaemon({ source, manualStart })
+  if (startedInProcess) return true
+  if (getInProcessDaemonSnapshot()) return false
+
   const live = await getLiveDaemonSnapshot()
   if (live?.status.running) return false
 
@@ -448,6 +463,28 @@ export async function stopDaemonProcess(opts?: {
   const source = opts?.source || 'unknown'
   const manualStop = opts?.manualStop === true
   const metadata = readDaemonAdminMetadata()
+  const inProcessSnapshot = getInProcessDaemonSnapshot()
+
+  if (inProcessSnapshot && (!metadata || metadata.pid === process.pid || !isProcessRunning(metadata.pid))) {
+    await stopDaemon({ source, manualStop })
+    clearDaemonAdminMetadata()
+    patchDaemonStatusRecord((current) => ({
+      ...current,
+      pid: null,
+      adminPort: null,
+      desiredState: 'stopped',
+      manualStopRequested: manualStop ? true : current.manualStopRequested,
+      stoppedAt: now(),
+      updatedAt: now(),
+      lastStopSource: source,
+      lastStatus: {
+        ...getDaemonStatus(),
+        manualStopRequested: manualStop ? true : current.manualStopRequested,
+      },
+      lastHealthSummary: getDaemonHealthSummary() as DaemonHealthSummaryPayload,
+    }))
+    return true
+  }
 
   if (!metadata || !isProcessRunning(metadata.pid)) {
     clearDaemonAdminMetadata()
@@ -510,12 +547,16 @@ export async function stopDaemonProcess(opts?: {
 }
 
 export async function getDaemonStatusSnapshot(): Promise<DaemonStatusPayload> {
+  const inProcessSnapshot = getInProcessDaemonSnapshot()
+  if (inProcessSnapshot) return inProcessSnapshot.status
   const live = await getLiveDaemonSnapshot()
   if (live) return live.status
   return buildFallbackStatus()
 }
 
 export async function getDaemonHealthSummarySnapshot(): Promise<DaemonHealthSummaryPayload> {
+  const inProcessSnapshot = getInProcessDaemonSnapshot()
+  if (inProcessSnapshot) return inProcessSnapshot.healthSummary
   const live = await getLiveDaemonSnapshot()
   if (live) return live.healthSummary
   return buildFallbackHealthSummary()
@@ -523,6 +564,8 @@ export async function getDaemonHealthSummarySnapshot(): Promise<DaemonHealthSumm
 
 export async function runDaemonHealthCheckViaAdmin(source: string): Promise<DaemonSnapshotResponse> {
   await ensureDaemonProcessRunning(source, { manualStart: true })
+  const inProcessSnapshot = getInProcessDaemonSnapshot()
+  if (inProcessSnapshot) return inProcessSnapshot
   const metadata = readDaemonAdminMetadata()
   if (!metadata) {
     return {

package/src/lib/server/protocols/protocol-agent-turn.test.ts

@@ -0,0 +1,164 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
+
+test('defaultExecuteAgentTurn surfaces execution-log errors instead of returning a blank structured response', () => {
+  const output = runWithTempDataDir<{ error: string | null }>(`
+    const storageMod = await import('./src/lib/server/storage')
+    const protocolsMod = await import('./src/lib/server/protocols/protocol-service')
+    const protocolTurnMod = await import('./src/lib/server/protocols/protocol-agent-turn')
+    const streamMod = await import('./src/lib/server/chat-execution/stream-agent-chat')
+    const executionLogMod = await import('./src/lib/server/execution-log')
+
+    const storage = storageMod.default || storageMod
+    const protocols = protocolsMod.default || protocolsMod
+    const { defaultExecuteAgentTurn } = protocolTurnMod.default || protocolTurnMod
+    const { setStreamAgentChatForTest } = streamMod.default || streamMod
+    const { logExecution } = executionLogMod.default || executionLogMod
+
+    storage.upsertStoredItem('agents', 'agentA', {
+      id: 'agentA',
+      name: 'Agent A',
+      provider: 'openai',
+      model: 'gpt-4.1',
+      systemPrompt: 'test',
+      createdAt: 1,
+      updatedAt: 1,
+    })
+
+    const run = protocols.createProtocolRun({
+      title: 'Credential failure run',
+      templateId: 'single_agent_structured_run',
+      participantAgentIds: ['agentA'],
+      facilitatorAgentId: 'agentA',
+      autoStart: false,
+    }, { now: () => 1000 })
+
+    setStreamAgentChatForTest(async (opts) => {
+      logExecution(opts.session.id, 'error', 'Missing credentials. Please pass an apiKey.', {
+        agentId: opts.session.agentId,
+      })
+      return { fullText: '', finalResponse: '', toolEvents: [] }
+    })
+
+    try {
+      await defaultExecuteAgentTurn({
+        run,
+        phase: { id: 'respond', label: 'Respond', kind: 'round_robin' },
+        agentId: 'agentA',
+        prompt: 'Say something useful.',
+      })
+      console.log(JSON.stringify({ error: null }))
+    } catch (error) {
+      console.log(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }))
+    } finally {
+      setStreamAgentChatForTest(null)
+    }
+  `, { prefix: 'swarmclaw-protocol-agent-turn-error-' })
+
+  assert.match(String(output.error || ''), /missing credentials/i)
+})
+
+test('defaultExecuteAgentTurn rejects blank structured responses even without a logged error', () => {
+  const output = runWithTempDataDir<{ error: string | null }>(`
+    const storageMod = await import('./src/lib/server/storage')
+    const protocolsMod = await import('./src/lib/server/protocols/protocol-service')
+    const protocolTurnMod = await import('./src/lib/server/protocols/protocol-agent-turn')
+    const streamMod = await import('./src/lib/server/chat-execution/stream-agent-chat')
+
+    const storage = storageMod.default || storageMod
+    const protocols = protocolsMod.default || protocolsMod
+    const { defaultExecuteAgentTurn } = protocolTurnMod.default || protocolTurnMod
+    const { setStreamAgentChatForTest } = streamMod.default || streamMod
+
+    storage.upsertStoredItem('agents', 'agentA', {
+      id: 'agentA',
+      name: 'Agent A',
+      provider: 'openai',
+      model: 'gpt-4.1',
+      systemPrompt: 'test',
+      createdAt: 1,
+      updatedAt: 1,
+    })
+
+    const run = protocols.createProtocolRun({
+      title: 'Blank response run',
+      templateId: 'single_agent_structured_run',
+      participantAgentIds: ['agentA'],
+      facilitatorAgentId: 'agentA',
+      autoStart: false,
+    }, { now: () => 1000 })
+
+    setStreamAgentChatForTest(async () => ({ fullText: '', finalResponse: '', toolEvents: [] }))
+
+    try {
+      await defaultExecuteAgentTurn({
+        run,
+        phase: { id: 'summarize', label: 'Summarize', kind: 'summarize' },
+        agentId: 'agentA',
+        prompt: 'Summarize.',
+      })
+      console.log(JSON.stringify({ error: null }))
+    } catch (error) {
+      console.log(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }))
+    } finally {
+      setStreamAgentChatForTest(null)
+    }
+  `, { prefix: 'swarmclaw-protocol-agent-turn-blank-' })
+
+  assert.match(String(output.error || ''), /no visible output/i)
+})
+
+test('defaultExecuteAgentTurn uses direct provider runtime for CLI providers', () => {
+  const output = runWithTempDataDir<{ text: string | null }>(`
+    const storageMod = await import('./src/lib/server/storage')
+    const protocolsMod = await import('./src/lib/server/protocols/protocol-service')
+    const protocolTurnMod = await import('./src/lib/server/protocols/protocol-agent-turn')
+    const providersMod = await import('./src/lib/providers/index')
+
+    const storage = storageMod.default || storageMod
+    const protocols = protocolsMod.default || protocolsMod
+    const { defaultExecuteAgentTurn } = protocolTurnMod.default || protocolTurnMod
+    const providers = providersMod.default || providersMod
+
+    storage.upsertStoredItem('agents', 'agentA', {
+      id: 'agentA',
+      name: 'Agent A',
+      provider: 'copilot-cli',
+      model: 'gpt-5.4',
+      systemPrompt: 'test',
+      createdAt: 1,
+      updatedAt: 1,
+    })
+
+    const originalHandler = providers.PROVIDERS['copilot-cli'].handler
+    providers.PROVIDERS['copilot-cli'].handler = {
+      streamChat: async (opts) => {
+        opts.write('data: ' + JSON.stringify({ t: 'd', text: 'Copilot CLI structured response.' }) + '\\n\\n')
+        return 'Copilot CLI structured response.'
+      },
+    }
+
+    const run = protocols.createProtocolRun({
+      title: 'CLI structured run',
+      templateId: 'single_agent_structured_run',
+      participantAgentIds: ['agentA'],
+      facilitatorAgentId: 'agentA',
+      autoStart: false,
+    }, { now: () => 1000 })
+
+    try {
+      const result = await defaultExecuteAgentTurn({
+        run,
+        phase: { id: 'respond', label: 'Respond', kind: 'round_robin' },
+        agentId: 'agentA',
+        prompt: 'Say something useful.',
+      })
+      console.log(JSON.stringify({ text: result.text }))
+    } finally {
+      providers.PROVIDERS['copilot-cli'].handler = originalHandler
+    }
+  `, { prefix: 'swarmclaw-protocol-agent-turn-cli-' })
+
+  assert.equal(output.text, 'Copilot CLI structured response.')
+})

package/src/lib/server/protocols/protocol-agent-turn.ts

@@ -6,6 +6,8 @@ import { HumanMessage } from '@langchain/core/messages'
 import { z } from 'zod'
 import { log } from '@/lib/server/logger'
 import { genId } from '@/lib/id'
+import { getProvider } from '@/lib/providers'
+import { NON_LANGGRAPH_PROVIDER_IDS } from '@/lib/provider-sets'
 
 const TAG = 'protocol-agent-turn'
 import type {
@@ -49,6 +51,7 @@ import type { ProtocolAgentTurnResult, ProtocolRunDeps } from '@/lib/server/prot
 import { normalizeProtocolRun } from '@/lib/server/protocols/protocol-normalization'
 import { persistChatroomInteractionMemory } from '@/lib/server/chatrooms/chatroom-memory-bridge'
 import { selectKnowledgeCitations } from '@/lib/server/knowledge-sources'
+import { queryLogs } from '@/lib/server/execution-log'
 
 // ---- Zod schema ----
 
@@ -248,24 +251,26 @@ export async function defaultExecuteAgentTurn(params: {
       await new Promise((resolve) => setTimeout(resolve, delay))
     }
     try {
-      const result = await Promise.race([
-        streamAgentChat({
-          session: syntheticSession,
-          message: params.prompt,
-          apiKey,
-          systemPrompt: fullSystemPrompt,
-          write: () => {},
-          history: buildHistoryForAgent(chatroom, agent.id),
-        }),
-        new Promise<never>((_, reject) =>
-          setTimeout(() => reject(new Error(`Agent turn timed out after ${AGENT_TURN_TIMEOUT_MS / 1000}s (agent: ${params.agentId})`)), AGENT_TURN_TIMEOUT_MS),
-        ),
-      ])
-      const rawText = result.finalResponse || result.fullText || ''
-      const text = stripHiddenControlTokens(rawText)
+      const turnStartedAt = Date.now()
+      const history = buildHistoryForAgent(chatroom, agent.id)
+      const result = await executeStructuredSessionTurnWithTimeout({
+        session: syntheticSession,
+        message: params.prompt,
+        apiKey,
+        systemPrompt: fullSystemPrompt,
+        history,
+        agentId: params.agentId,
+      })
+      const rawText = result.text || ''
+      const text = resolveStructuredSessionTurnText({
+        rawText,
+        sessionId: syntheticSession.id,
+        turnStartedAt,
+        agentId: params.agentId,
+      })
       const grounding = selectKnowledgeCitations({
         responseText: text,
-        retrievalTrace: result.knowledgeRetrievalTrace || null,
+        retrievalTrace: result.retrievalTrace || null,
       })
       if (text.trim() && !shouldSuppressHiddenControlText(rawText)) {
         appendSyntheticSessionMessage(syntheticSession.id, 'assistant', text)
@@ -297,6 +302,104 @@ export async function defaultExecuteAgentTurn(params: {
   throw lastError
 }
 
+async function executeStructuredSessionTurn(params: {
+  session: ReturnType<typeof ensureSyntheticSession>
+  message: string
+  apiKey: string | null
+  systemPrompt: string
+  history: ReturnType<typeof buildHistoryForAgent>
+}): Promise<ProtocolAgentTurnResult> {
+  if (NON_LANGGRAPH_PROVIDER_IDS.has(params.session.provider)) {
+    const provider = getProvider(params.session.provider)
+    if (!provider) throw new Error(`Unknown provider: ${params.session.provider}`)
+    let streamedText = ''
+    const rawResponseText = await provider.handler.streamChat({
+      session: params.session,
+      message: params.message,
+      apiKey: params.apiKey,
+      systemPrompt: params.systemPrompt,
+      write: (raw: string) => {
+        for (const line of raw.split('\n')) {
+          if (!line.startsWith('data: ')) continue
+          try {
+            const parsed = JSON.parse(line.slice(6).trim()) as { t?: string; text?: string }
+            if ((parsed.t === 'd' || parsed.t === 'r') && typeof parsed.text === 'string') {
+              streamedText += parsed.text
+            }
+          } catch {
+            // Ignore malformed provider event payloads here and fall back to the final response text.
+          }
+        }
+      },
+      active: new Map<string, unknown>(),
+      loadHistory: () => params.history,
+    })
+    return {
+      text: rawResponseText || streamedText,
+      toolEvents: [],
+      retrievalTrace: null,
+      citations: [],
+    }
+  }
+
+  const streamed = await streamAgentChat({
+    session: params.session,
+    message: params.message,
+    apiKey: params.apiKey,
+    systemPrompt: params.systemPrompt,
+    write: () => {},
+    history: params.history,
+  })
+  return {
+    text: streamed.finalResponse || streamed.fullText || '',
+    toolEvents: streamed.toolEvents || [],
+    retrievalTrace: streamed.knowledgeRetrievalTrace || null,
+    citations: [],
+  }
+}
+
+async function executeStructuredSessionTurnWithTimeout(params: {
+  session: ReturnType<typeof ensureSyntheticSession>
+  message: string
+  apiKey: string | null
+  systemPrompt: string
+  history: ReturnType<typeof buildHistoryForAgent>
+  agentId: string
+}): Promise<ProtocolAgentTurnResult> {
+  let timeoutId: ReturnType<typeof setTimeout> | null = null
+  try {
+    return await Promise.race([
+      executeStructuredSessionTurn(params),
+      new Promise<never>((_, reject) => {
+        timeoutId = setTimeout(
+          () => reject(new Error(`Agent turn timed out after ${AGENT_TURN_TIMEOUT_MS / 1000}s (agent: ${params.agentId})`)),
+          AGENT_TURN_TIMEOUT_MS,
+        )
+      }),
+    ])
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId)
+  }
+}
+
+export function resolveStructuredSessionTurnText(params: {
+  rawText: string
+  sessionId: string
+  turnStartedAt: number
+  agentId: string
+}): string {
+  const text = stripHiddenControlTokens(params.rawText)
+  if (text.trim()) return text
+  const recentError = queryLogs({
+    sessionId: params.sessionId,
+    category: 'error',
+    since: params.turnStartedAt,
+    limit: 1,
+  })[0]
+  if (recentError?.summary) throw new Error(recentError.summary)
+  throw new Error(`Structured session turn produced no visible output for agent ${params.agentId}.`)
+}
+
 export function extractFirstJsonObject(text: string): string | null {
   const source = String(text || '')
   let start = -1

package/src/lib/server/provider-endpoint.ts

@@ -52,9 +52,6 @@ export function resolveProviderCredentialId(input: {
       })[0]?.[0] || normalizedId
   }
 
-  const matchingIds = matchingEntries.map(([id]) => id)
-
-  if (matchingIds.length === 1) return matchingIds[0]
   return normalizedId
 }
 

package/src/lib/server/runs/unified-run-records.ts

@@ -0,0 +1,91 @@
+import type { ProtocolRun, ProtocolRunEvent, RunEventRecord, SessionRunRecord, SessionRunStatus } from '@/types'
+
+function mapProtocolStatus(status: ProtocolRun['status']): SessionRunStatus {
+  switch (status) {
+    case 'draft':
+      return 'queued'
+    case 'running':
+    case 'waiting':
+    case 'paused':
+      return 'running'
+    case 'completed':
+      return 'completed'
+    case 'failed':
+      return 'failed'
+    case 'cancelled':
+    case 'archived':
+      return 'cancelled'
+    default:
+      return 'queued'
+  }
+}
+
+function buildProtocolMessagePreview(run: ProtocolRun): string {
+  return (
+    run.title
+    || run.config?.goal
+    || run.config?.kickoffMessage
+    || run.templateName
+    || 'Structured session run'
+  )
+}
+
+function buildProtocolResultPreview(run: ProtocolRun): string {
+  const summary = typeof run.summary === 'string' ? run.summary.trim() : ''
+  if (summary) return summary
+  const latestArtifact = Array.isArray(run.artifacts)
+    ? [...run.artifacts].sort((left, right) => (right.createdAt || 0) - (left.createdAt || 0))[0]
+    : null
+  const artifactContent = typeof latestArtifact?.content === 'string' ? latestArtifact.content.trim() : ''
+  if (artifactContent) return artifactContent
+  return ''
+}
+
+export function protocolRunToSessionRunRecord(run: ProtocolRun): SessionRunRecord {
+  return {
+    id: run.id,
+    sessionId: run.sessionId || run.transcriptChatroomId || `protocol-run:${run.id}`,
+    kind: 'protocol_step',
+    ownerType: 'protocol_run',
+    ownerId: run.id,
+    source: run.sourceRef.kind === 'schedule' ? 'structured schedule' : 'structured session',
+    internal: run.systemOwned === true,
+    mode: run.templateId,
+    status: mapProtocolStatus(run.status),
+    messagePreview: buildProtocolMessagePreview(run),
+    queuedAt: run.createdAt,
+    startedAt: run.startedAt || undefined,
+    endedAt: run.endedAt || run.archivedAt || undefined,
+    error: run.lastError || undefined,
+    resultPreview: buildProtocolResultPreview(run) || undefined,
+  }
+}
+
+export function protocolEventToRunEventRecord(run: ProtocolRun, event: ProtocolRunEvent): RunEventRecord {
+  const status = event.type === 'failed'
+    ? 'failed'
+    : event.type === 'completed'
+      ? 'completed'
+      : event.type === 'cancelled'
+        ? 'cancelled'
+        : event.type === 'created'
+          ? 'queued'
+          : undefined
+  return {
+    id: event.id,
+    runId: run.id,
+    sessionId: run.sessionId || run.transcriptChatroomId || `protocol-run:${run.id}`,
+    kind: 'protocol_step',
+    ownerType: 'protocol_run',
+    ownerId: run.id,
+    timestamp: event.createdAt,
+    phase: status ? 'status' : 'event',
+    status,
+    summary: event.summary,
+    event: {
+      t: status === 'failed' ? 'err' : status ? 'status' : 'md',
+      text: event.summary,
+    },
+    citations: event.citations,
+  }
+}

package/src/lib/server/schedules/schedule-normalization.ts

@@ -319,7 +319,10 @@ export function normalizeSchedulePayload(payload: SchedulePayload, opts: Normali
         const cronTimezone = trimString(normalized.timezone)
         const interval = CronExpressionParser.parse(
           normalized.cron as string,
-          cronTimezone ? { tz: cronTimezone } : undefined,
+          {
+            ...(cronTimezone ? { tz: cronTimezone } : {}),
+            currentDate: new Date(now),
+          },
         )
         normalized.nextRunAt = applyStagger(interval.next().getTime(), normalized.staggerSec as number | null)
       } catch {

package/src/lib/server/schedules/schedule-service.test.ts

@@ -0,0 +1,73 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { prepareScheduleUpdate } from '@/lib/server/schedules/schedule-service'
+import type { Schedule } from '@/types'
+
+function readNextRunAt(value: object): number | undefined {
+  if (!('nextRunAt' in value)) return undefined
+  const nextRunAt = value.nextRunAt
+  return typeof nextRunAt === 'number' ? nextRunAt : undefined
+}
+
+function makeSchedule(overrides: Partial<Schedule> = {}): Schedule {
+  return {
+    id: 'sched-1',
+    name: 'Morning run',
+    agentId: 'agent-1',
+    taskPrompt: 'Do the thing',
+    scheduleType: 'cron',
+    cron: '40 10 * * *',
+    timezone: 'UTC',
+    status: 'active',
+    createdAt: 0,
+    updatedAt: 0,
+    nextRunAt: Date.parse('2026-01-01T10:40:00.000Z'),
+    ...overrides,
+  }
+}
+
+describe('prepareScheduleUpdate', () => {
+  it('recomputes nextRunAt when cron timing changes', () => {
+    const current = makeSchedule()
+    const now = Date.parse('2026-01-01T10:30:00.000Z')
+    const result = prepareScheduleUpdate({
+      id: current.id,
+      current,
+      patch: { cron: '45 10 * * *' },
+      schedules: { [current.id]: current },
+      now,
+    })
+
+    assert.equal(result.ok, true)
+    if (result.ok) {
+      const nextRunAt = readNextRunAt(result.schedule)
+      assert.notEqual(nextRunAt, current.nextRunAt)
+      assert.equal(typeof nextRunAt, 'number')
+      assert.equal(nextRunAt, Date.parse('2026-01-01T10:45:00.000Z'))
+    }
+  })
+
+  it('recomputes nextRunAt when reactivating a paused interval schedule', () => {
+    const current = makeSchedule({
+      scheduleType: 'interval',
+      cron: undefined,
+      intervalMs: 300_000,
+      status: 'paused',
+      nextRunAt: 123,
+    })
+    const now = 1_000_000
+    const result = prepareScheduleUpdate({
+      id: current.id,
+      current,
+      patch: { status: 'active' },
+      schedules: { [current.id]: current },
+      now,
+    })
+
+    assert.equal(result.ok, true)
+    if (result.ok) {
+      assert.equal(readNextRunAt(result.schedule), 1_300_000)
+    }
+  })
+})

package/src/lib/server/schedules/schedule-service.ts

@@ -211,10 +211,17 @@ export type PrepareScheduleUpdateResult =
     }
 
 export function prepareScheduleUpdate(options: PrepareScheduleUpdateOptions): PrepareScheduleUpdateResult {
+  const nextStatus = normalizeScheduleStatus(options.patch.status)
+  const shouldRecomputeNextRunAt = !('nextRunAt' in options.patch) && (
+    ['scheduleType', 'cron', 'intervalMs', 'runAt', 'timezone', 'staggerSec']
+      .some((key) => key in options.patch)
+    || (nextStatus === 'active' && options.current.status !== 'active')
+  )
   const normalized = normalizeSchedulePayload({
     ...options.current,
     ...options.patch,
     id: options.id,
+    ...(shouldRecomputeNextRunAt ? { nextRunAt: undefined } : {}),
   }, {
     cwd: options.cwd,
     now: options.now,
@@ -237,8 +244,8 @@ export function prepareScheduleUpdate(options: PrepareScheduleUpdateOptions): Pr
   })
 
   const entries: Array<[string, ScheduleLike]> = [[options.id, nextSchedule]]
-  const nextStatus = normalizeScheduleStatus(nextSchedule.status)
-  if (options.propagateEquivalentStatuses && (nextStatus === 'paused' || nextStatus === 'completed' || nextStatus === 'failed' || nextStatus === 'archived')) {
+  const normalizedStatus = normalizeScheduleStatus(nextSchedule.status)
+  if (options.propagateEquivalentStatuses && (normalizedStatus === 'paused' || normalizedStatus === 'completed' || normalizedStatus === 'failed' || normalizedStatus === 'archived')) {
     const relatedIds = findRelatedScheduleIds(
       options.schedules,
       options.propagationSource || options.current,
@@ -249,7 +256,7 @@ export function prepareScheduleUpdate(options: PrepareScheduleUpdateOptions): Pr
       if (!related) continue
       entries.push([relatedId, {
         ...related,
-        status: nextStatus,
+        status: normalizedStatus,
         updatedAt: options.now,
       }])
     }

package/src/lib/server/test-utils/run-with-temp-data-dir.ts

@@ -13,6 +13,7 @@ export function runWithTempDataDir<T = unknown>(
     dataDir?: string
     workspaceDir?: string
     browserProfilesDir?: string
+    timeoutMs?: number
   } = {},
 ): T {
   const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), options.prefix || 'swarmclaw-test-'))
@@ -38,9 +39,10 @@ export function runWithTempDataDir<T = unknown>(
         ...(browserProfilesDir ? { BROWSER_PROFILES_DIR: browserProfilesDir } : {}),
       },
       encoding: 'utf-8',
+      timeout: options.timeoutMs ?? 120_000,
     })
 
-    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    assert.equal(result.status, 0, result.error?.message || result.stderr || result.stdout || 'subprocess failed')
 
     const lines = (result.stdout || '')
       .trim()