@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/lib/server/resolve-image.ts

@@ -0,0 +1,30 @@
+import fs from 'fs'
+import path from 'path'
+import { UPLOAD_DIR } from './storage'
+
+const UPLOAD_URL_PREFIX = '/api/uploads/'
+
+/**
+ * Resolve an image to a valid filesystem path.
+ *
+ * Tries, in order:
+ *   1. `imagePath` (the absolute filesystem path returned by the upload API)
+ *   2. `imageUrl` mapped back to the uploads dir (e.g. `/api/uploads/foo.jpeg` → `UPLOAD_DIR/foo.jpeg`)
+ *
+ * Returns `null` if neither resolves to an existing file.
+ */
+export function resolveImagePath(imagePath?: string, imageUrl?: string): string | null {
+  if (imagePath && fs.existsSync(imagePath)) return imagePath
+
+  // Fall back: resolve relative API URL to filesystem
+  if (imageUrl?.startsWith(UPLOAD_URL_PREFIX)) {
+    const filename = imageUrl.slice(UPLOAD_URL_PREFIX.length)
+    const safeName = filename.replace(/[^a-zA-Z0-9._-]/g, '')
+    if (safeName) {
+      const resolved = path.join(UPLOAD_DIR, safeName)
+      if (fs.existsSync(resolved)) return resolved
+    }
+  }
+
+  return null
+}

package/src/lib/server/runtime-settings.test.ts

@@ -35,8 +35,8 @@ function runWithTempDataDir(script: string) {
 describe('runtime settings defaults', () => {
   it('backfills explicit runtime defaults for clean installs', () => {
     const output = runWithTempDataDir(`
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const runtimeMod = await import('./src/lib/server/runtime-settings.ts')
+      const storageMod = await import('./src/lib/server/storage')
+      const runtimeMod = await import('./src/lib/server/runtime-settings')
       const storage = storageMod.default || storageMod
       const runtime = runtimeMod.default || runtimeMod
       console.log(JSON.stringify({
@@ -68,8 +68,8 @@ describe('runtime settings defaults', () => {
 
   it('clamps invalid persisted runtime settings into the supported range', () => {
     const output = runWithTempDataDir(`
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const runtimeMod = await import('./src/lib/server/runtime-settings.ts')
+      const storageMod = await import('./src/lib/server/storage')
+      const runtimeMod = await import('./src/lib/server/runtime-settings')
       const storage = storageMod.default || storageMod
       const runtime = runtimeMod.default || runtimeMod
 

package/src/lib/server/runtime-storage-write-paths.test.ts

@@ -0,0 +1,60 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import test from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../..')
+
+function readRepoSource(relativePath: string): string {
+  return fs.readFileSync(path.join(repoRoot, relativePath), 'utf-8')
+}
+
+test('runtime hot paths use row-level task, schedule, and agent writes', () => {
+  const expectations = [
+    {
+      file: 'src/lib/server/queue',
+      required: ['patchTask(', 'upsertTask(', 'upsertTasks(', 'upsertSchedule(', 'deleteSchedule('],
+      forbidden: ['saveTasks(', 'saveSchedules('],
+    },
+    {
+      file: 'src/lib/server/scheduler',
+      required: ['upsertTask(', 'upsertSchedule(', 'upsertSchedules('],
+      forbidden: ['saveTasks(', 'saveSchedules('],
+    },
+    {
+      file: 'src/lib/server/orchestrator-lg',
+      required: ['patchTask(', 'upsertTask('],
+      forbidden: ['saveTasks('],
+    },
+    {
+      file: 'src/app/api/orchestrator/run/route',
+      required: ['upsertTask('],
+      forbidden: ['saveTasks('],
+    },
+    {
+      file: 'src/app/api/schedules/[id]/run/route',
+      required: ['upsertTask(', 'upsertSchedule('],
+      forbidden: ['saveTasks(', 'saveSchedules('],
+    },
+    {
+      file: 'src/app/api/tasks/[id]/approve/route',
+      required: ['patchTask('],
+      forbidden: ['saveTasks('],
+    },
+    {
+      file: 'src/lib/server/wallet-service',
+      required: ['loadAgent(', 'upsertAgent('],
+      forbidden: ['saveAgents('],
+    },
+  ] as const
+
+  for (const expectation of expectations) {
+    const src = readRepoSource(expectation.file)
+    for (const token of expectation.required) {
+      assert.equal(src.includes(token), true, `${expectation.file} should use ${token}`)
+    }
+    for (const token of expectation.forbidden) {
+      assert.equal(src.includes(token), false, `${expectation.file} should not use ${token}`)
+    }
+  }
+})

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

@@ -0,0 +1,279 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { after, before, describe, it } from 'node:test'
+
+const originalEnv = {
+  DATA_DIR: process.env.DATA_DIR,
+  WORKSPACE_DIR: process.env.WORKSPACE_DIR,
+  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
+}
+
+let tempDir = ''
+let workspaceDir = ''
+let mod: typeof import('./schedule-normalization')
+
+before(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-schedule-norm-'))
+  workspaceDir = path.join(tempDir, 'workspace')
+  fs.mkdirSync(workspaceDir, { recursive: true })
+  process.env.DATA_DIR = path.join(tempDir, 'data')
+  process.env.WORKSPACE_DIR = workspaceDir
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  mod = await import('./schedule-normalization')
+})
+
+after(() => {
+  if (originalEnv.DATA_DIR === undefined) delete process.env.DATA_DIR
+  else process.env.DATA_DIR = originalEnv.DATA_DIR
+  if (originalEnv.WORKSPACE_DIR === undefined) delete process.env.WORKSPACE_DIR
+  else process.env.WORKSPACE_DIR = originalEnv.WORKSPACE_DIR
+  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
+  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
+  fs.rmSync(tempDir, { recursive: true, force: true })
+})
+
+describe('extractScheduleCommandScriptPath', () => {
+  it('extracts script path from python command', () => {
+    assert.equal(mod.extractScheduleCommandScriptPath('python3 scripts/run.py'), 'scripts/run.py')
+  })
+
+  it('extracts script path from node command', () => {
+    assert.equal(mod.extractScheduleCommandScriptPath('node ./build/index.js'), './build/index.js')
+  })
+
+  it('extracts script path from bash command', () => {
+    assert.equal(mod.extractScheduleCommandScriptPath('bash deploy.sh'), 'deploy.sh')
+  })
+
+  it('extracts script path from npx tsx command', () => {
+    assert.equal(mod.extractScheduleCommandScriptPath('npx tsx src/worker.ts'), 'src/worker.ts')
+  })
+
+  it('extracts script path from deno run command', () => {
+    assert.equal(mod.extractScheduleCommandScriptPath('deno run main.ts'), 'main.ts')
+  })
+
+  it('skips flags before finding path', () => {
+    assert.equal(mod.extractScheduleCommandScriptPath('python3 -u scripts/run.py'), 'scripts/run.py')
+  })
+
+  it('returns null for bare command with no script-like argument', () => {
+    assert.equal(mod.extractScheduleCommandScriptPath('echo hello'), null)
+  })
+
+  it('returns null for empty command', () => {
+    assert.equal(mod.extractScheduleCommandScriptPath(''), null)
+  })
+
+  it('handles quoted paths', () => {
+    assert.equal(mod.extractScheduleCommandScriptPath('python3 "my script.py"'), 'my script.py')
+  })
+})
+
+describe('normalizeSchedulePayload', () => {
+  it('rejects missing agentId', () => {
+    const result = mod.normalizeSchedulePayload({ taskPrompt: 'do stuff' })
+    assert.equal(result.ok, false)
+    if (!result.ok) assert.match(result.error, /agentId/)
+  })
+
+  it('rejects missing taskPrompt/command/path', () => {
+    const result = mod.normalizeSchedulePayload({ agentId: 'agent-1' })
+    assert.equal(result.ok, false)
+    if (!result.ok) assert.match(result.error, /taskPrompt/)
+  })
+
+  it('accepts valid payload with taskPrompt', () => {
+    const result = mod.normalizeSchedulePayload({
+      agentId: 'agent-1',
+      taskPrompt: 'Run the daily report',
+    })
+    assert.equal(result.ok, true)
+    if (result.ok) {
+      assert.equal(result.value.agentId, 'agent-1')
+      assert.equal(result.value.taskPrompt, 'Run the daily report')
+    }
+  })
+
+  it('derives taskPrompt from command when not explicit', () => {
+    const result = mod.normalizeSchedulePayload({
+      agentId: 'agent-1',
+      command: 'echo hello',
+    })
+    assert.equal(result.ok, true)
+    if (result.ok) {
+      assert.match(result.value.taskPrompt as string, /echo hello/)
+    }
+  })
+
+  it('normalizes scheduleType to interval by default', () => {
+    const result = mod.normalizeSchedulePayload({
+      agentId: 'agent-1',
+      taskPrompt: 'test',
+    })
+    assert.equal(result.ok, true)
+    if (result.ok) assert.equal(result.value.scheduleType, 'interval')
+  })
+
+  it('preserves valid scheduleType values', () => {
+    for (const t of ['cron', 'interval', 'once'] as const) {
+      const result = mod.normalizeSchedulePayload({
+        agentId: 'agent-1',
+        taskPrompt: 'test',
+        scheduleType: t,
+      })
+      assert.equal(result.ok, true)
+      if (result.ok) assert.equal(result.value.scheduleType, t)
+    }
+  })
+
+  it('falls back invalid scheduleType to interval', () => {
+    const result = mod.normalizeSchedulePayload({
+      agentId: 'agent-1',
+      taskPrompt: 'test',
+      scheduleType: 'bogus',
+    })
+    assert.equal(result.ok, true)
+    if (result.ok) assert.equal(result.value.scheduleType, 'interval')
+  })
+
+  it('normalizes status to active for unknown values', () => {
+    const result = mod.normalizeSchedulePayload({
+      agentId: 'agent-1',
+      taskPrompt: 'test',
+      status: 'invalid-status',
+    })
+    assert.equal(result.ok, true)
+    if (result.ok) assert.equal(result.value.status, 'active')
+  })
+
+  it('preserves valid status values', () => {
+    for (const s of ['active', 'paused', 'completed', 'failed']) {
+      const result = mod.normalizeSchedulePayload({
+        agentId: 'agent-1',
+        taskPrompt: 'test',
+        status: s,
+      })
+      assert.equal(result.ok, true)
+      if (result.ok) assert.equal(result.value.status, s)
+    }
+  })
+
+  it('calculates nextRunAt for interval type when intervalMs is set', () => {
+    const now = 1_000_000
+    const result = mod.normalizeSchedulePayload(
+      { agentId: 'agent-1', taskPrompt: 'test', scheduleType: 'interval', intervalMs: 5000 },
+      { now },
+    )
+    assert.equal(result.ok, true)
+    if (result.ok) assert.equal(result.value.nextRunAt, 1_005_000)
+  })
+
+  it('uses runAt for once type', () => {
+    const result = mod.normalizeSchedulePayload(
+      { agentId: 'agent-1', taskPrompt: 'test', scheduleType: 'once', runAt: 9_999_999 },
+      { now: 1_000_000 },
+    )
+    assert.equal(result.ok, true)
+    if (result.ok) assert.equal(result.value.nextRunAt, 9_999_999)
+  })
+
+  it('does not overwrite existing nextRunAt', () => {
+    const result = mod.normalizeSchedulePayload(
+      { agentId: 'agent-1', taskPrompt: 'test', scheduleType: 'interval', intervalMs: 5000, nextRunAt: 42 },
+      { now: 1_000_000 },
+    )
+    assert.equal(result.ok, true)
+    if (result.ok) assert.equal(result.value.nextRunAt, 42)
+  })
+
+  it('trims whitespace from agentId', () => {
+    const result = mod.normalizeSchedulePayload({
+      agentId: '  agent-1  ',
+      taskPrompt: 'test',
+    })
+    assert.equal(result.ok, true)
+    if (result.ok) assert.equal(result.value.agentId, 'agent-1')
+  })
+
+  it('rejects run_script action without path', () => {
+    const result = mod.normalizeSchedulePayload({
+      agentId: 'agent-1',
+      taskPrompt: 'test',
+      action: 'run_script',
+    })
+    assert.equal(result.ok, false)
+    if (!result.ok) assert.match(result.error, /run_script/)
+  })
+
+  it('rejects path outside workspace', () => {
+    const result = mod.normalizeSchedulePayload(
+      { agentId: 'agent-1', taskPrompt: 'test', path: '/etc/passwd' },
+      { cwd: workspaceDir },
+    )
+    assert.equal(result.ok, false)
+    if (!result.ok) assert.match(result.error, /must stay inside/)
+  })
+
+  it('validates path exists for file-based schedules', () => {
+    const result = mod.normalizeSchedulePayload(
+      { agentId: 'agent-1', taskPrompt: 'test', path: 'nonexistent.py' },
+      { cwd: workspaceDir },
+    )
+    assert.equal(result.ok, false)
+    if (!result.ok) assert.match(result.error, /not found/)
+  })
+
+  it('accepts path that exists inside workspace', () => {
+    const scriptPath = path.join(workspaceDir, 'test-script.py')
+    fs.writeFileSync(scriptPath, '#!/usr/bin/env python3\nprint("ok")')
+    const result = mod.normalizeSchedulePayload(
+      { agentId: 'agent-1', taskPrompt: 'test', path: 'test-script.py' },
+      { cwd: workspaceDir },
+    )
+    assert.equal(result.ok, true)
+  })
+
+  it('derives taskPrompt from path with run_script action', () => {
+    const scriptPath = path.join(workspaceDir, 'runner.sh')
+    fs.writeFileSync(scriptPath, '#!/bin/bash\necho ok')
+    const result = mod.normalizeSchedulePayload(
+      { agentId: 'agent-1', action: 'run_script', path: 'runner.sh' },
+      { cwd: workspaceDir },
+    )
+    assert.equal(result.ok, true)
+    if (result.ok) assert.match(result.value.taskPrompt as string, /Run the script/)
+  })
+
+  it('derives taskPrompt from path without specific action', () => {
+    const filePath = path.join(workspaceDir, 'data.csv')
+    fs.writeFileSync(filePath, 'a,b\n1,2')
+    const result = mod.normalizeSchedulePayload(
+      { agentId: 'agent-1', path: 'data.csv' },
+      { cwd: workspaceDir },
+    )
+    assert.equal(result.ok, true)
+    if (result.ok) assert.match(result.value.taskPrompt as string, /Use the file/)
+  })
+
+  it('rejects command referencing a missing script file', () => {
+    const result = mod.normalizeSchedulePayload(
+      { agentId: 'agent-1', taskPrompt: 'test', command: 'python3 missing_script.py' },
+      { cwd: workspaceDir },
+    )
+    assert.equal(result.ok, false)
+    if (!result.ok) assert.match(result.error, /missing file/)
+  })
+
+  it('accepts command referencing an existing script file', () => {
+    const scriptPath = path.join(workspaceDir, 'existing.py')
+    fs.writeFileSync(scriptPath, 'print("ok")')
+    const result = mod.normalizeSchedulePayload(
+      { agentId: 'agent-1', taskPrompt: 'test', command: 'python3 existing.py' },
+      { cwd: workspaceDir },
+    )
+    assert.equal(result.ok, true)
+  })
+})

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

@@ -0,0 +1,263 @@
+import { genId } from '@/lib/id'
+import {
+  findDuplicateSchedule,
+  findEquivalentSchedules,
+  type ScheduleLike,
+} from '@/lib/schedule-dedupe'
+import { resolveScheduleName } from '@/lib/schedule-name'
+import type { Schedule, ScheduleStatus } from '@/types'
+import { dedup } from '@/lib/shared-utils'
+
+import { normalizeSchedulePayload } from './schedule-normalization'
+
+export interface ScheduleCreatorScope {
+  agentId?: string | null
+  sessionId?: string | null
+}
+
+export function buildScheduleCreatorScope(schedule: Record<string, unknown> | null | undefined): ScheduleCreatorScope | null {
+  if (!schedule || typeof schedule !== 'object') return null
+  const agentId = typeof schedule.createdByAgentId === 'string' && schedule.createdByAgentId.trim()
+    ? schedule.createdByAgentId.trim()
+    : null
+  const sessionId = typeof schedule.createdInSessionId === 'string' && schedule.createdInSessionId.trim()
+    ? schedule.createdInSessionId.trim()
+    : null
+  if (!agentId && !sessionId) return null
+  return { agentId, sessionId }
+}
+
+export function findRelatedScheduleIds(
+  schedules: Record<string, ScheduleLike>,
+  schedule: Record<string, unknown> | null | undefined,
+  opts: { ignoreId?: string | null } = {},
+): string[] {
+  if (!schedule || typeof schedule !== 'object') return []
+  const scope = buildScheduleCreatorScope(schedule)
+  if (!scope?.sessionId) return []
+  const matches = findEquivalentSchedules(schedules, {
+    id: typeof schedule.id === 'string' ? schedule.id : null,
+    agentId: typeof schedule.agentId === 'string' ? schedule.agentId : null,
+    taskPrompt: typeof schedule.taskPrompt === 'string' ? schedule.taskPrompt : null,
+    scheduleType: typeof schedule.scheduleType === 'string' ? schedule.scheduleType : null,
+    cron: typeof schedule.cron === 'string' ? schedule.cron : null,
+    intervalMs: typeof schedule.intervalMs === 'number' ? schedule.intervalMs : null,
+    runAt: typeof schedule.runAt === 'number' ? schedule.runAt : null,
+    createdByAgentId: scope.agentId,
+    createdInSessionId: scope.sessionId,
+  }, {
+    ignoreId: opts.ignoreId || (typeof schedule.id === 'string' ? schedule.id : null),
+    creatorScope: scope,
+  })
+  return dedup(matches
+    .map((entry) => (typeof entry.id === 'string' ? entry.id : ''))
+    .filter(Boolean))
+}
+
+export function getScheduleClusterIds(
+  schedules: Record<string, ScheduleLike>,
+  schedule: Record<string, unknown> | null | undefined,
+  opts: { ignoreId?: string | null } = {},
+): string[] {
+  const id = typeof schedule?.id === 'string' ? schedule.id : ''
+  const relatedIds = findRelatedScheduleIds(schedules, schedule, {
+    ignoreId: opts.ignoreId || id || null,
+  })
+  const ids = [
+    ...(!opts.ignoreId && id ? [id] : []),
+    ...relatedIds,
+  ]
+  return dedup(ids.filter(Boolean))
+}
+
+function normalizeScheduleStatus(value: unknown): ScheduleStatus | '' {
+  if (typeof value !== 'string') return ''
+  const normalized = value.trim().toLowerCase()
+  return normalized === 'active'
+    || normalized === 'paused'
+    || normalized === 'completed'
+    || normalized === 'failed'
+    ? normalized
+    : ''
+}
+
+export interface PrepareScheduleCreateOptions {
+  input: Record<string, unknown>
+  schedules: Record<string, ScheduleLike>
+  now: number
+  cwd?: string | null
+  creatorScope?: ScheduleCreatorScope | null
+  dedupeCreatorScope?: ScheduleCreatorScope | null
+  followupTarget?: Partial<Schedule>
+  createId?: () => string
+}
+
+export type PrepareScheduleCreateResult =
+  | { ok: false; error: string }
+  | {
+      ok: true
+      kind: 'duplicate'
+      scheduleId: string
+      schedule: ScheduleLike
+      changed: boolean
+      entries: Array<[string, ScheduleLike]>
+    }
+  | {
+      ok: true
+      kind: 'created'
+      scheduleId: string
+      schedule: Schedule
+      entries: Array<[string, Schedule]>
+    }
+
+export function prepareScheduleCreate(options: PrepareScheduleCreateOptions): PrepareScheduleCreateResult {
+  const normalized = normalizeSchedulePayload(options.input, {
+    cwd: options.cwd,
+    now: options.now,
+  })
+  if (!normalized.ok) return { ok: false, error: normalized.error }
+
+  const candidate = normalized.value
+  const dedupeScope = options.dedupeCreatorScope || null
+  const duplicate = findDuplicateSchedule(options.schedules, {
+    agentId: typeof candidate.agentId === 'string' ? candidate.agentId : null,
+    taskPrompt: typeof candidate.taskPrompt === 'string' ? candidate.taskPrompt : '',
+    scheduleType: typeof candidate.scheduleType === 'string' ? candidate.scheduleType : 'interval',
+    cron: typeof candidate.cron === 'string' ? candidate.cron : null,
+    intervalMs: typeof candidate.intervalMs === 'number' ? candidate.intervalMs : null,
+    runAt: typeof candidate.runAt === 'number' ? candidate.runAt : null,
+    createdByAgentId: dedupeScope?.agentId || null,
+    createdInSessionId: dedupeScope?.sessionId || null,
+  }, dedupeScope
+    ? { creatorScope: dedupeScope }
+    : undefined)
+
+  if (duplicate) {
+    const duplicateId = typeof duplicate.id === 'string' ? duplicate.id : ''
+    const nextSchedule = { ...duplicate }
+    let changed = false
+    const nextName = resolveScheduleName({
+      name: candidate.name ?? nextSchedule.name,
+      taskPrompt: candidate.taskPrompt ?? nextSchedule.taskPrompt,
+    })
+    if (nextName && nextName !== nextSchedule.name) {
+      nextSchedule.name = nextName
+      changed = true
+    }
+    const nextStatus = normalizeScheduleStatus(candidate.status)
+    if ((nextStatus === 'active' || nextStatus === 'paused') && nextSchedule.status !== nextStatus) {
+      nextSchedule.status = nextStatus
+      changed = true
+    }
+    if (changed) nextSchedule.updatedAt = options.now
+    return {
+      ok: true,
+      kind: 'duplicate',
+      scheduleId: duplicateId,
+      schedule: nextSchedule,
+      changed,
+      entries: changed && duplicateId ? [[duplicateId, nextSchedule]] : [],
+    }
+  }
+
+  const id = options.createId ? options.createId() : genId()
+  const creatorFields = options.creatorScope
+    ? {
+        createdByAgentId: options.creatorScope.agentId || null,
+        createdInSessionId: options.creatorScope.sessionId || null,
+      }
+    : {}
+  const schedule = {
+    id,
+    ...candidate,
+    ...creatorFields,
+    ...(options.followupTarget || {}),
+    name: resolveScheduleName({ name: candidate.name, taskPrompt: candidate.taskPrompt }),
+    scheduleType: candidate.scheduleType === 'cron' || candidate.scheduleType === 'once' ? candidate.scheduleType : 'interval',
+    lastRunAt: undefined,
+    createdAt: options.now,
+    updatedAt: options.now,
+  } as Schedule
+
+  return {
+    ok: true,
+    kind: 'created',
+    scheduleId: id,
+    schedule,
+    entries: [[id, schedule]],
+  }
+}
+
+export interface PrepareScheduleUpdateOptions {
+  id: string
+  current: ScheduleLike
+  patch: Record<string, unknown>
+  schedules: Record<string, ScheduleLike>
+  now: number
+  cwd?: string | null
+  agentExists?: (agentId: string) => boolean
+  propagateEquivalentStatuses?: boolean
+  propagationSource?: Record<string, unknown> | null
+}
+
+export type PrepareScheduleUpdateResult =
+  | { ok: false; error: string }
+  | {
+      ok: true
+      schedule: ScheduleLike
+      entries: Array<[string, ScheduleLike]>
+      affectedScheduleIds: string[]
+    }
+
+export function prepareScheduleUpdate(options: PrepareScheduleUpdateOptions): PrepareScheduleUpdateResult {
+  const normalized = normalizeSchedulePayload({
+    ...options.current,
+    ...options.patch,
+    id: options.id,
+  }, {
+    cwd: options.cwd,
+    now: options.now,
+  })
+  if (!normalized.ok) return { ok: false, error: normalized.error }
+
+  const nextSchedule = {
+    ...options.current,
+    ...normalized.value,
+    id: options.id,
+    updatedAt: options.now,
+  }
+  const agentId = typeof nextSchedule.agentId === 'string' ? nextSchedule.agentId : ''
+  if (options.agentExists && (!agentId || !options.agentExists(agentId))) {
+    return { ok: false, error: `Agent not found: ${String(nextSchedule.agentId)}` }
+  }
+  nextSchedule.name = resolveScheduleName({
+    name: nextSchedule.name,
+    taskPrompt: nextSchedule.taskPrompt,
+  })
+
+  const entries: Array<[string, ScheduleLike]> = [[options.id, nextSchedule]]
+  const nextStatus = normalizeScheduleStatus(nextSchedule.status)
+  if (options.propagateEquivalentStatuses && (nextStatus === 'paused' || nextStatus === 'completed' || nextStatus === 'failed')) {
+    const relatedIds = findRelatedScheduleIds(
+      options.schedules,
+      options.propagationSource || options.current,
+      { ignoreId: options.id },
+    )
+    for (const relatedId of relatedIds) {
+      const related = options.schedules[relatedId]
+      if (!related) continue
+      entries.push([relatedId, {
+        ...related,
+        status: nextStatus,
+        updatedAt: options.now,
+      }])
+    }
+  }
+
+  return {
+    ok: true,
+    schedule: nextSchedule,
+    entries,
+    affectedScheduleIds: dedup(entries.map(([id]) => id)),
+  }
+}