@swarmclawai/swarmclaw 1.9.8 → 1.9.9

package/src/lib/server/runtime/scheduler.ts

@@ -13,6 +13,7 @@ import { ensureAgentThreadSession } from '@/lib/server/agents/agent-thread-sessi
 import { hasActiveProtocolRunForSchedule, launchProtocolRunForSchedule } from '@/lib/server/protocols/protocol-service'
 import { hmrSingleton } from '@/lib/shared-utils'
 import { log } from '@/lib/server/logger'
+import { appendScheduleHistoryEntry } from '@/lib/server/schedules/schedule-history'
 import type { Schedule } from '@/types'
 
 const TAG = 'scheduler'
@@ -131,7 +132,13 @@ async function tick(now = Date.now()) {
     const scheduleSignature = getScheduleSignatureKey(schedule)
     if (scheduleSignature && inFlightScheduleKeys.has(scheduleSignature)) {
       advanceSchedule(schedule)
-      upsertSchedule(schedule.id, schedule)
+      upsertSchedule(schedule.id, appendScheduleHistoryEntry(schedule, {
+        now,
+        actor: 'system',
+        action: 'skipped',
+        summary: `Schedule skipped because a run is already in flight: "${schedule.name}"`,
+        metadata: { reason: 'in_flight' },
+      }))
       continue
     }
 
@@ -139,7 +146,19 @@ async function tick(now = Date.now()) {
     if (!agent) {
       log.error(TAG, `Agent ${schedule.agentId} not found for schedule ${schedule.id}`)
       schedule.status = 'failed'
-      upsertSchedule(schedule.id, schedule)
+      upsertSchedule(schedule.id, appendScheduleHistoryEntry(schedule, {
+        now,
+        actor: 'system',
+        action: 'failed',
+        summary: `Schedule failed because agent was not found: "${schedule.name}"`,
+        changes: [{
+          field: 'status',
+          label: 'Status',
+          before: 'active',
+          after: 'failed',
+        }],
+        metadata: { reason: 'agent_not_found' },
+      }))
       pushMainLoopEventToMainSessions({
         type: 'schedule_failed',
         text: `Schedule failed: "${schedule.name}" (${schedule.id}) — agent ${schedule.agentId} not found.`,
@@ -149,7 +168,13 @@ async function tick(now = Date.now()) {
     if (isAgentDisabled(agent)) {
       log.warn(TAG, `Skipping schedule "${schedule.name}" (${schedule.id}) because agent ${schedule.agentId} is disabled`)
       advanceSchedule(schedule)
-      upsertSchedule(schedule.id, schedule)
+      upsertSchedule(schedule.id, appendScheduleHistoryEntry(schedule, {
+        now,
+        actor: 'system',
+        action: 'skipped',
+        summary: `Schedule skipped because agent is disabled: "${schedule.name}"`,
+        metadata: { reason: 'agent_disabled' },
+      }))
       pushMainLoopEventToMainSessions({
         type: 'schedule_skipped',
         text: `Schedule skipped: "${schedule.name}" (${schedule.id}) — agent ${schedule.agentId} is disabled.`,
@@ -162,53 +187,60 @@ async function tick(now = Date.now()) {
     schedule.runNumber = (schedule.runNumber || 0) + 1
     // Compute next run
     advanceSchedule(schedule)
+    const firedSchedule = appendScheduleHistoryEntry(schedule, {
+      now,
+      actor: 'system',
+      action: 'run_started',
+      summary: `Schedule run started: "${schedule.name}"`,
+      metadata: { runNumber: schedule.runNumber || 0 },
+    })
 
-    if (shouldWakeScheduleSession(schedule)) {
+    if (shouldWakeScheduleSession(firedSchedule)) {
       // Wake-only: no board task, just heartbeat the agent
-      upsertSchedule(schedule.id, schedule)
-      const wakeSessionId = resolveScheduleWakeSessionId(schedule, agents as Record<string, unknown>)
+      upsertSchedule(firedSchedule.id, firedSchedule)
+      const wakeSessionId = resolveScheduleWakeSessionId(firedSchedule, agents as Record<string, unknown>)
 
-      const wakeMessage = schedule.message || `Schedule triggered: ${schedule.name}`
+      const wakeMessage = firedSchedule.message || `Schedule triggered: ${firedSchedule.name}`
       pushMainLoopEventToMainSessions({
         type: 'schedule_fired',
-        text: `Schedule fired (wake-only): "${schedule.name}" (${schedule.id}) run #${schedule.runNumber}`,
+        text: `Schedule fired (wake-only): "${firedSchedule.name}" (${firedSchedule.id}) run #${firedSchedule.runNumber}`,
       })
 
       dispatchWake({
         mode: 'immediate',
-        agentId: schedule.agentId,
+        agentId: firedSchedule.agentId,
         ...(wakeSessionId ? { sessionId: wakeSessionId } : {}),
-        eventId: `${schedule.id}:${schedule.runNumber}`,
+        eventId: `${firedSchedule.id}:${firedSchedule.runNumber}`,
         reason: 'schedule',
-        source: `schedule:${schedule.id}`,
+        source: `schedule:${firedSchedule.id}`,
         resumeMessage: wakeMessage,
-        detail: `Run #${schedule.runNumber} (wake-only).`,
+        detail: `Run #${firedSchedule.runNumber} (wake-only).`,
       })
-    } else if (shouldLaunchScheduleProtocol(schedule)) {
-      upsertSchedule(schedule.id, schedule)
-      if (hasActiveProtocolRunForSchedule(schedule.id)) continue
-      const run = launchProtocolRunForSchedule(schedule)
+    } else if (shouldLaunchScheduleProtocol(firedSchedule)) {
+      upsertSchedule(firedSchedule.id, firedSchedule)
+      if (hasActiveProtocolRunForSchedule(firedSchedule.id)) continue
+      const run = launchProtocolRunForSchedule(firedSchedule)
       pushMainLoopEventToMainSessions({
         type: 'schedule_fired',
-        text: `Schedule fired: "${schedule.name}" (${schedule.id}) run #${schedule.runNumber} — structured session ${run.id}`,
+        text: `Schedule fired: "${firedSchedule.name}" (${firedSchedule.id}) run #${firedSchedule.runNumber} — structured session ${run.id}`,
       })
     } else {
       // Default task mode: create a board task
       const { taskId } = prepareScheduledTaskRun({
-        schedule,
+        schedule: firedSchedule,
         tasks,
         now,
         scheduleSignature,
       })
 
       upsertTask(taskId, tasks[taskId])
-      upsertSchedule(schedule.id, schedule)
+      upsertSchedule(firedSchedule.id, firedSchedule)
 
       enqueueTask(taskId)
       if (scheduleSignature) inFlightScheduleKeys.add(scheduleSignature)
       pushMainLoopEventToMainSessions({
         type: 'schedule_fired',
-        text: `Schedule fired: "${schedule.name}" (${schedule.id}) run #${schedule.runNumber} — task ${taskId}`,
+        text: `Schedule fired: "${firedSchedule.name}" (${firedSchedule.id}) run #${firedSchedule.runNumber} — task ${taskId}`,
       })
     }
   }

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

@@ -0,0 +1,121 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import {
+  applyScheduleCreationHistory,
+  applyScheduleUpdateHistory,
+  appendScheduleHistoryEntry,
+  normalizeScheduleHistory,
+} from '@/lib/server/schedules/schedule-history'
+import type { Schedule } from '@/types'
+
+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('schedule history', () => {
+  it('adds a creation entry with revision 1', () => {
+    const schedule = applyScheduleCreationHistory(makeSchedule(), {
+      now: 1_000,
+      actor: 'user',
+      createId: () => 'hist-1',
+    })
+
+    assert.equal(schedule.revision, 1)
+    assert.equal(schedule.history?.length, 1)
+    assert.equal(schedule.history?.[0]?.id, 'hist-1')
+    assert.equal(schedule.history?.[0]?.action, 'created')
+    assert.equal(schedule.history?.[0]?.revision, 1)
+    assert.match(schedule.history?.[0]?.summary || '', /Morning run/)
+  })
+
+  it('records meaningful update changes and ignores bookkeeping fields', () => {
+    const current = makeSchedule({
+      revision: 1,
+      history: [{
+        id: 'hist-1',
+        at: 1_000,
+        actor: 'user',
+        action: 'created',
+        revision: 1,
+        summary: 'Schedule created: "Morning run"',
+      }],
+    })
+    const next = {
+      ...current,
+      name: 'Morning release run',
+      cron: '45 10 * * *',
+      updatedAt: 2_000,
+    }
+
+    const withHistory = applyScheduleUpdateHistory(current, next, {
+      now: 2_000,
+      actor: 'user',
+      createId: () => 'hist-2',
+    })
+
+    assert.equal(withHistory.revision, 2)
+    assert.equal(withHistory.history?.length, 2)
+    assert.equal(withHistory.history?.[0]?.id, 'hist-2')
+    assert.deepEqual(withHistory.history?.[0]?.changes?.map((change) => change.field), ['name', 'cron'])
+  })
+
+  it('does not append history for no-op updates', () => {
+    const current = makeSchedule({
+      revision: 1,
+      history: [{
+        id: 'hist-1',
+        at: 1_000,
+        actor: 'user',
+        action: 'created',
+        revision: 1,
+        summary: 'Schedule created: "Morning run"',
+      }],
+    })
+
+    const withHistory = applyScheduleUpdateHistory(current, {
+      ...current,
+      updatedAt: 2_000,
+    }, {
+      now: 2_000,
+      actor: 'user',
+      createId: () => 'hist-2',
+    })
+
+    assert.equal(withHistory.revision, 1)
+    assert.equal(withHistory.history?.length, 1)
+    assert.equal(withHistory.history?.[0]?.id, 'hist-1')
+  })
+
+  it('keeps only the latest retained entries', () => {
+    let schedule = makeSchedule()
+    for (let index = 0; index < 30; index += 1) {
+      schedule = appendScheduleHistoryEntry(schedule, {
+        now: index,
+        actor: 'system',
+        action: 'updated',
+        summary: `entry ${index}`,
+        createId: () => `hist-${index}`,
+      })
+    }
+
+    const history = normalizeScheduleHistory(schedule.history)
+    assert.equal(history.length, 25)
+    assert.equal(history[0].id, 'hist-29')
+    assert.equal(history[24].id, 'hist-5')
+    assert.equal(schedule.revision, 30)
+  })
+})

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

@@ -0,0 +1,234 @@
+import { genId } from '@/lib/id'
+import type { Schedule, ScheduleHistoryAction, ScheduleHistoryChange, ScheduleHistoryEntry } from '@/types'
+
+export const SCHEDULE_HISTORY_LIMIT = 25
+
+export type ScheduleHistoryActor = {
+  actor: string
+  actorId?: string | null
+}
+
+type ScheduleHistoryOptions = ScheduleHistoryActor & {
+  now: number
+  createId?: () => string
+}
+
+type ScheduleHistoryEventOptions = ScheduleHistoryOptions & {
+  action: ScheduleHistoryAction
+  summary: string
+  changes?: ScheduleHistoryChange[]
+  metadata?: Record<string, string | number | boolean | null>
+}
+
+const CHANGE_FIELDS: Array<{
+  field: keyof Schedule
+  label: string
+}> = [
+  { field: 'name', label: 'Name' },
+  { field: 'status', label: 'Status' },
+  { field: 'agentId', label: 'Agent' },
+  { field: 'projectId', label: 'Project' },
+  { field: 'taskMode', label: 'Mode' },
+  { field: 'taskPrompt', label: 'Prompt' },
+  { field: 'message', label: 'Wake message' },
+  { field: 'protocolTemplateId', label: 'Protocol template' },
+  { field: 'scheduleType', label: 'Cadence type' },
+  { field: 'cron', label: 'Cron' },
+  { field: 'intervalMs', label: 'Interval' },
+  { field: 'runAt', label: 'Run at' },
+  { field: 'timezone', label: 'Timezone' },
+  { field: 'staggerSec', label: 'Stagger' },
+  { field: 'action', label: 'Action' },
+  { field: 'path', label: 'Path' },
+  { field: 'command', label: 'Command' },
+  { field: 'description', label: 'Description' },
+  { field: 'frequency', label: 'Frequency' },
+  { field: 'followupConnectorId', label: 'Connector' },
+  { field: 'followupChannelId', label: 'Channel' },
+  { field: 'followupThreadId', label: 'Thread' },
+  { field: 'followupSenderName', label: 'Sender' },
+]
+
+const HISTORY_ACTIONS = new Set<ScheduleHistoryAction>([
+  'created',
+  'updated',
+  'archived',
+  'restored',
+  'run_started',
+  'skipped',
+  'failed',
+])
+
+function cleanActor(value: string): string {
+  const actor = value.trim()
+  return actor || 'system'
+}
+
+function createHistoryId(options: ScheduleHistoryOptions): string {
+  return options.createId ? options.createId() : genId()
+}
+
+function normalizeHistoryEntry(value: unknown): ScheduleHistoryEntry | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null
+  const entry = value as Partial<ScheduleHistoryEntry>
+  if (typeof entry.id !== 'string' || !entry.id.trim()) return null
+  if (typeof entry.at !== 'number' || !Number.isFinite(entry.at)) return null
+  if (typeof entry.action !== 'string' || !HISTORY_ACTIONS.has(entry.action as ScheduleHistoryAction)) return null
+  if (typeof entry.summary !== 'string' || !entry.summary.trim()) return null
+  const actor = typeof entry.actor === 'string' && entry.actor.trim() ? entry.actor.trim() : 'system'
+  const revision = typeof entry.revision === 'number' && Number.isFinite(entry.revision)
+    ? Math.max(1, Math.trunc(entry.revision))
+    : 1
+  const changes = Array.isArray(entry.changes)
+    ? entry.changes
+        .map((change) => {
+          if (!change || typeof change !== 'object' || Array.isArray(change)) return null
+          const candidate = change as Partial<ScheduleHistoryChange>
+          if (typeof candidate.field !== 'string' || !candidate.field.trim()) return null
+          if (typeof candidate.label !== 'string' || !candidate.label.trim()) return null
+          return {
+            field: candidate.field.trim(),
+            label: candidate.label.trim(),
+            before: candidate.before == null ? null : String(candidate.before),
+            after: candidate.after == null ? null : String(candidate.after),
+          }
+        })
+        .filter((change): change is ScheduleHistoryChange => Boolean(change))
+    : undefined
+  const metadata = entry.metadata && typeof entry.metadata === 'object' && !Array.isArray(entry.metadata)
+    ? Object.fromEntries(
+        Object.entries(entry.metadata).filter(([, metadataValue]) =>
+          metadataValue == null
+          || typeof metadataValue === 'string'
+          || typeof metadataValue === 'number'
+          || typeof metadataValue === 'boolean',
+        ),
+      )
+    : undefined
+
+  return {
+    id: entry.id.trim(),
+    at: Math.trunc(entry.at),
+    actor,
+    actorId: typeof entry.actorId === 'string' && entry.actorId.trim() ? entry.actorId.trim() : null,
+    action: entry.action as ScheduleHistoryAction,
+    revision,
+    summary: entry.summary.trim(),
+    ...(changes && changes.length > 0 ? { changes } : {}),
+    ...(metadata && Object.keys(metadata).length > 0 ? { metadata } : {}),
+  }
+}
+
+export function normalizeScheduleHistory(value: unknown): ScheduleHistoryEntry[] {
+  if (!Array.isArray(value)) return []
+  return value
+    .map(normalizeHistoryEntry)
+    .filter((entry): entry is ScheduleHistoryEntry => Boolean(entry))
+    .sort((left, right) => right.at - left.at || right.revision - left.revision)
+    .slice(0, SCHEDULE_HISTORY_LIMIT)
+}
+
+function normalizeRevision(value: unknown, history: ScheduleHistoryEntry[]): number {
+  const explicit = typeof value === 'number' && Number.isFinite(value) ? Math.trunc(value) : 0
+  const fromHistory = history.reduce((max, entry) => Math.max(max, entry.revision), 0)
+  return Math.max(explicit, fromHistory, 0)
+}
+
+function compactString(value: string, maxLength = 240): string {
+  const compacted = value.replace(/\s+/g, ' ').trim()
+  if (compacted.length <= maxLength) return compacted
+  return `${compacted.slice(0, maxLength - 1)}...`
+}
+
+function formatHistoryValue(value: unknown): string | null {
+  if (value == null) return null
+  if (typeof value === 'string') return compactString(value) || null
+  if (typeof value === 'number') return Number.isFinite(value) ? String(Math.trunc(value)) : null
+  if (typeof value === 'boolean') return value ? 'true' : 'false'
+  if (Array.isArray(value)) {
+    const values = value
+      .map((entry) => formatHistoryValue(entry))
+      .filter((entry): entry is string => Boolean(entry))
+    return values.length > 0 ? compactString(values.join(', ')) : null
+  }
+  if (typeof value === 'object') return compactString(JSON.stringify(value))
+  return null
+}
+
+export function diffScheduleHistoryChanges(previous: Schedule, next: Schedule): ScheduleHistoryChange[] {
+  const changes: ScheduleHistoryChange[] = []
+  for (const item of CHANGE_FIELDS) {
+    const before = formatHistoryValue(previous[item.field])
+    const after = formatHistoryValue(next[item.field])
+    if (before === after) continue
+    changes.push({
+      field: String(item.field),
+      label: item.label,
+      before,
+      after,
+    })
+  }
+  return changes
+}
+
+export function appendScheduleHistoryEntry(
+  schedule: Schedule,
+  options: ScheduleHistoryEventOptions,
+): Schedule {
+  const history = normalizeScheduleHistory(schedule.history)
+  const revision = normalizeRevision(schedule.revision, history) + 1
+  const entry: ScheduleHistoryEntry = {
+    id: createHistoryId(options),
+    at: Math.trunc(options.now),
+    actor: cleanActor(options.actor),
+    actorId: options.actorId || null,
+    action: options.action,
+    revision,
+    summary: compactString(options.summary),
+    ...(options.changes && options.changes.length > 0 ? { changes: options.changes } : {}),
+    ...(options.metadata && Object.keys(options.metadata).length > 0 ? { metadata: options.metadata } : {}),
+  }
+  const nextHistory = [entry, ...history].slice(0, SCHEDULE_HISTORY_LIMIT)
+  return {
+    ...schedule,
+    revision,
+    history: nextHistory,
+  }
+}
+
+export function applyScheduleCreationHistory(
+  schedule: Schedule,
+  options: ScheduleHistoryOptions,
+): Schedule {
+  if (normalizeScheduleHistory(schedule.history).length > 0 || (schedule.revision || 0) > 0) return schedule
+  return appendScheduleHistoryEntry(schedule, {
+    ...options,
+    action: 'created',
+    summary: `Schedule created: "${schedule.name}"`,
+  })
+}
+
+export function applyScheduleUpdateHistory(
+  previous: Schedule,
+  next: Schedule,
+  options: ScheduleHistoryOptions & { summary?: string },
+): Schedule {
+  const changes = diffScheduleHistoryChanges(previous, next)
+  if (changes.length === 0) {
+    return {
+      ...next,
+      revision: normalizeRevision(next.revision ?? previous.revision, normalizeScheduleHistory(next.history ?? previous.history)),
+      history: normalizeScheduleHistory(next.history ?? previous.history),
+    }
+  }
+  return appendScheduleHistoryEntry({
+    ...next,
+    revision: previous.revision,
+    history: next.history ?? previous.history,
+  }, {
+    ...options,
+    action: 'updated',
+    summary: options.summary || `Schedule updated: "${next.name}"`,
+    changes,
+  })
+}

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

@@ -18,6 +18,7 @@ import {
 } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
 import { getScheduleClusterIds } from '@/lib/server/schedules/schedule-service'
+import { appendScheduleHistoryEntry } from '@/lib/server/schedules/schedule-history'
 
 type RestorableScheduleStatus = Exclude<ScheduleStatus, 'archived'>
 
@@ -205,7 +206,7 @@ export function archiveScheduleCluster(
     const previousStatus = schedule.status === 'archived'
       ? (schedule.archivedFromStatus || 'active')
       : schedule.status
-    schedules[id] = {
+    const archivedSchedule: Schedule = {
       ...cloneSchedule(schedule),
       status: 'archived',
       archivedAt: schedule.archivedAt || now,
@@ -213,6 +214,24 @@ export function archiveScheduleCluster(
       nextRunAt: undefined,
       updatedAt: now,
     }
+    schedules[id] = appendScheduleHistoryEntry(archivedSchedule, {
+      now,
+      actor: opts.actor?.actor || 'system',
+      actorId: opts.actor?.actorId || null,
+      action: 'archived',
+      summary: `Schedule archived: "${schedule.name}"`,
+      changes: [{
+        field: 'status',
+        label: 'Status',
+        before: previousStatus,
+        after: 'archived',
+      }],
+      metadata: {
+        cancelledTaskCount: cancelledTaskIds.length,
+        removedQueuedTaskCount: removedQueuedTaskIds.length,
+        abortedRunSessionCount: abortedRunSessionIds.length,
+      },
+    })
   }
 
   if (tasksDirty) {
@@ -289,7 +308,7 @@ export function restoreArchivedScheduleCluster(
       : restoreStatus === 'completed' || restoreStatus === 'failed'
         ? undefined
         : schedule.nextRunAt
-    schedules[id] = {
+    const restoredSchedule: Schedule = {
       ...cloneSchedule(schedule),
       status: restoreStatus,
       archivedAt: null,
@@ -297,6 +316,19 @@ export function restoreArchivedScheduleCluster(
       nextRunAt,
       updatedAt: now,
     }
+    schedules[id] = appendScheduleHistoryEntry(restoredSchedule, {
+      now,
+      actor: opts.actor?.actor || 'system',
+      actorId: opts.actor?.actorId || null,
+      action: 'restored',
+      summary: `Schedule restored: "${schedule.name}"`,
+      changes: [{
+        field: 'status',
+        label: 'Status',
+        before: 'archived',
+        after: restoreStatus,
+      }],
+    })
     restoredIds.push(id)
   }
 

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

@@ -18,6 +18,7 @@ import { loadTasks, saveTask } from '@/lib/server/tasks/task-repository'
 import { pushMainLoopEventToMainSessions } from '@/lib/server/agents/main-agent-loop'
 import { WORKSPACE_DIR } from '@/lib/server/data-dir'
 import { notify } from '@/lib/server/ws-hub'
+import { appendScheduleHistoryEntry } from '@/lib/server/schedules/schedule-history'
 import type { Schedule } from '@/types'
 import type { ScheduleLike } from '@/lib/schedules/schedule-dedupe'
 import type { ServiceResult } from '@/lib/server/service-result'
@@ -55,6 +56,7 @@ export function createScheduleFromRoute(body: Record<string, unknown>): ServiceR
     schedules,
     now,
     cwd: WORKSPACE_DIR,
+    historyActor: { actor: 'user' },
   })
   if (!prepared.ok) {
     return serviceFail(400, prepared.error)
@@ -125,6 +127,7 @@ export function updateScheduleFromRoute(id: string, body: Record<string, unknown
     agentExists: (agentId) => Boolean(agents[agentId]),
     propagateEquivalentStatuses: true,
     propagationSource: current as unknown as Record<string, unknown>,
+    historyActor: { actor: 'user' },
   })
   if (!prepared.ok) {
     return serviceFail(400, errorMessage(prepared.error))
@@ -216,7 +219,14 @@ export function runScheduleNow(id: string): ServiceResult<Record<string, unknown
     text: `Schedule fired manually: "${schedule.name}" (${schedule.id}) run #${schedule.runNumber} — task ${taskId}`,
   })
   schedule.lastRunAt = now
-  upsertSchedule(schedule.id, schedule)
+  const scheduleWithHistory = appendScheduleHistoryEntry(schedule, {
+    now,
+    actor: 'user',
+    action: 'run_started',
+    summary: `Manual schedule run queued: "${schedule.name}"`,
+    metadata: { taskId, runNumber: schedule.runNumber || 0 },
+  })
+  upsertSchedule(schedule.id, scheduleWithHistory)
   logActivity({
     entityType: 'schedule',
     entityId: schedule.id,