refactor(schedules): drop vestigial recovery code and close a builder gap

Follow-ups from a full re-read of the change. No behavior change except the
removed dead code paths.

The metadata merge stripped a `scheduleRecoveryBlocked` key on every write. That
key has never been written by any shipped code -- it appears nowhere in staging
and nowhere in history outside this branch -- so the strip guarded against a
state that cannot exist, at the cost of an extra jsonb operation and a bind
parameter on every reconciliation write.

`processScheduleItem` set `carrierObservedOrLookupUncertain` immediately before
returning on an ambiguous enqueue. The flag is only read from the surrounding
catch block, which a normal return skips, so the assignment was dead and read as
though it were load-bearing. Replaced with a comment stating why the occurrence
is preserved.

The stale-execution sweep carried two near-identical `jsonb_set` templates that
differed only in their error expression, kept flat because the test mock renders
nested SQL fragments as placeholders. The suite now has a recursive renderer, so
the error expression is a named per-status value and there is one `jsonb_set`.

Success was the only schedule outcome without a named update builder, which left
`executeScheduleJob` using two idioms for the same guarded write and left the
update shape untested. Add `buildScheduleSuccessUpdate` beside its cancellation
and failure siblings, use it from both call sites, and cover it the way
`buildScheduleCancellationUpdate` is covered -- a mutation of its `failedCount`
reset previously passed every suite.

Author: waleedlatif1

apps/sim/app/api/cron/cleanup-stale-executions/route.test.ts

@@ -140,25 +140,18 @@ describe('stale execution cleanup deadline grace', () => {
         totalDurationMs: { toSQL: () => { sql: string; params: unknown[] } }
         executionData: { toSQL: () => { sql: string; params: unknown[] } }
       }
-      const errorExpression = update.executionData.toSQL()
-      const staleDurationExpression = errorExpression.params.find(
-        (value): value is { toSQL: () => { sql: string; params: unknown[] } } =>
-          typeof value === 'object' &&
-          value !== null &&
-          'toSQL' in value &&
-          value.toSQL().sql.includes('EXTRACT(EPOCH')
-      )
       const totalDurationLeaves = flattenSqlParams(update.totalDurationMs.toSQL())
-
-      expect(errorExpression.sql).toContain('CASE')
-      expect(errorExpression.sql).toContain('IS NOT NULL')
-      expect(errorExpression.params).toContain(workflowExecutionLogs.executionDeadlineAt)
-      expect(errorExpression.params).toContain('Execution timed out')
-      expect(errorExpression.params).toContain(
-        'Execution terminated: worker timeout or crash after '
-      )
-      expect(staleDurationExpression?.toSQL().sql).toContain('ROUND')
-      expect(staleDurationExpression?.toSQL().params).toContain(workflowExecutionLogs.startedAt)
+      const renderedError = renderSql(update.executionData)
+      const errorLeaves = collectSqlParams(update.executionData)
+
+      expect(renderedError).toContain('CASE')
+      expect(renderedError).toContain('IS NOT NULL')
+      expect(renderedError).toContain('ROUND')
+      expect(renderedError).toContain('EXTRACT(EPOCH')
+      expect(errorLeaves).toContain(workflowExecutionLogs.executionDeadlineAt)
+      expect(errorLeaves).toContain('Execution timed out')
+      expect(errorLeaves).toContain('Execution terminated: worker timeout or crash after ')
+      expect(errorLeaves).toContain(workflowExecutionLogs.startedAt)
       expect(totalDurationLeaves).toContain(2_147_483_647)
       expect(totalDurationLeaves).toContain(workflowExecutionLogs.startedAt)
       expect(totalDurationLeaves).toContainEqual(new Date('2026-08-03T12:10:00.000Z'))

apps/sim/app/api/cron/cleanup-stale-executions/route.ts

@@ -178,6 +178,21 @@ export const GET = withRouteHandler(async (request: NextRequest) => {
         EXTRACT(EPOCH FROM (${cleanupTimestamp} - ${workflowExecutionLogs.startedAt})) / 60
       )::integer`
       const totalDurationMs = elapsedDurationMsSql(now)
+      const staleDurationError = sql`${'Execution terminated: worker timeout or crash after '}::text
+        || ${staleDurationMinutes}::text
+        || ' minutes'`
+      /**
+       * A `redacting` row is never swept by the deadline rule, so the deadline
+       * message cannot apply to it.
+       */
+      const staleExecutionError = (status: StaleSweepableExecutionStatus) =>
+        status === 'redacting'
+          ? staleDurationError
+          : sql`CASE
+              WHEN ${workflowExecutionLogs.executionDeadlineAt} IS NOT NULL
+                THEN ${EXECUTION_DEADLINE_ERROR}::text
+              ELSE ${staleDurationError}
+            END`
       /**
        * Swept one status at a time so each pass stays on its own partial index;
        * `status IN (...)` would match neither. The row budget is shared across
@@ -212,29 +227,10 @@ export const GET = withRouteHandler(async (request: NextRequest) => {
                 endedAt: now,
                 executionDeadlineAt: null,
                 totalDurationMs,
-                executionData:
-                  executionStatus === 'redacting'
-                    ? sql`jsonb_set(
+                executionData: sql`jsonb_set(
                   COALESCE(execution_data, '{}'::jsonb),
                   ARRAY['error'],
-                  to_jsonb(
-                    ${'Execution terminated: worker timeout or crash after '}::text
-                      || ${staleDurationMinutes}::text
-                      || ' minutes'
-                  )
-                )`
-                    : sql`jsonb_set(
-                  COALESCE(execution_data, '{}'::jsonb),
-                  ARRAY['error'],
-                  to_jsonb(
-                    CASE
-                      WHEN ${workflowExecutionLogs.executionDeadlineAt} IS NOT NULL
-                        THEN ${EXECUTION_DEADLINE_ERROR}::text
-                      ELSE ${'Execution terminated: worker timeout or crash after '}::text
-                        || ${staleDurationMinutes}::text
-                        || ' minutes'
-                    END
-                  )
+                  to_jsonb(${staleExecutionError(executionStatus)})
                 )`,
               })
               .where(

apps/sim/app/api/schedules/execute/route.ts

@@ -1579,10 +1579,13 @@ async function processScheduleItem(
         error,
         { acceptance, jobId: scheduleJobId }
       )
-      if (acceptance !== 'rejected') {
-        carrierObservedOrLookupUncertain = true
-        return
-      }
+      /**
+       * The queue may have accepted the job before the response was lost, and
+       * the job id is deterministic, so retrying could double-dispatch the
+       * occurrence. Leave the claim in place and let the next tick reconcile
+       * against whatever carrier actually exists.
+       */
+      if (acceptance !== 'rejected') return
       await handleClaimedScheduleSetupFailure(
         schedule,
         requestId,

apps/sim/background/schedule-execution.test.ts

@@ -24,6 +24,7 @@ vi.mock('@sim/db', () => ({ ...databaseMock, ...schemaMock }))
 import {
   applyScheduleFailureUpdate,
   buildScheduleCancellationUpdate,
+  buildScheduleSuccessUpdate,
   classifyScheduleExecutionResult,
   releaseScheduleLock,
 } from '@/background/schedule-execution'
@@ -141,4 +142,20 @@ describe('schedule cancellation accounting', () => {
     expect(buildScheduleCancellationUpdate(now, nextRunAt)).not.toHaveProperty('failedCount')
     expect(buildScheduleCancellationUpdate(now, nextRunAt)).not.toHaveProperty('lastFailedAt')
   })
+
+  it('advances cadence, releases the claim and clears failure accounting on success', () => {
+    const now = new Date('2026-08-03T12:00:00.000Z')
+    const nextRunAt = new Date('2026-08-03T13:00:00.000Z')
+
+    expect(buildScheduleSuccessUpdate(now, nextRunAt)).toEqual({
+      lastRanAt: now,
+      updatedAt: now,
+      nextRunAt,
+      failedCount: 0,
+      lastQueuedAt: null,
+      infraRetryCount: 0,
+    })
+    expect(buildScheduleSuccessUpdate(now, nextRunAt)).not.toHaveProperty('lastFailedAt')
+    expect(buildScheduleSuccessUpdate(now, nextRunAt)).not.toHaveProperty('status')
+  })
 })

apps/sim/background/schedule-execution.ts

@@ -158,6 +158,23 @@ export function classifyScheduleExecutionResult(
 }
 
 /** Advances cadence after user cancellation without mutating the failure counter. */
+/**
+ * Successful-run accounting: stamps `lastRanAt`, clears the claim, advances to
+ * `nextRunAt`, and resets the consecutive-failure and infra-retry counters. The
+ * sibling of {@link buildScheduleCancellationUpdate} and
+ * {@link buildScheduleFailureUpdate}.
+ */
+export function buildScheduleSuccessUpdate(now: Date, nextRunAt: Date): WorkflowScheduleUpdate {
+  return {
+    lastRanAt: now,
+    updatedAt: now,
+    nextRunAt,
+    failedCount: 0,
+    lastQueuedAt: null,
+    ...resetScheduleInfraRetryCount(),
+  }
+}
+
 export function buildScheduleCancellationUpdate(
   now: Date,
   nextRunAt: Date
@@ -283,14 +300,7 @@ export async function applyScheduleSuccessUpdate(params: {
 
   const outcome = await applyScheduleUpdate(
     scheduleId,
-    {
-      lastRanAt: now,
-      updatedAt: now,
-      nextRunAt,
-      failedCount: 0,
-      lastQueuedAt: null,
-      ...resetScheduleInfraRetryCount(),
-    },
+    buildScheduleSuccessUpdate(now, nextRunAt),
     requestId,
     context,
     { expectedLastQueuedAt, executor }
@@ -1142,29 +1152,21 @@ export async function executeScheduleJob(
 
             const nextRunAt = calculateNextRunTime(payload, executionResult.blocks)
 
-            await applyScheduleSuccessUpdate({
-              scheduleId: payload.scheduleId,
-              now,
-              nextRunAt,
-              expectedLastQueuedAt: claimedAt,
-              requestId,
-              context: `Error updating schedule ${payload.scheduleId} after success`,
-            })
+            await updateClaimedSchedule(
+              buildScheduleSuccessUpdate(now, nextRunAt),
+              `Error updating schedule ${payload.scheduleId} after success`
+            )
             return
           }
 
           if (executionResult.status === 'cancelled') {
             logger.info(`[${requestId}] Workflow ${payload.workflowId} execution was cancelled`)
 
             const nextRunAt = calculateNextRunTime(payload, executionResult.blocks)
-            await applyScheduleCancellationUpdate({
-              scheduleId: payload.scheduleId,
-              now,
-              nextRunAt,
-              expectedLastQueuedAt: claimedAt,
-              requestId,
-              context: `Error updating schedule ${payload.scheduleId} after cancellation`,
-            })
+            await updateClaimedSchedule(
+              buildScheduleCancellationUpdate(now, nextRunAt),
+              `Error updating schedule ${payload.scheduleId} after cancellation`
+            )
             return
           }
 

apps/sim/lib/workflows/schedules/carrier-metadata.ts

@@ -24,9 +24,6 @@ export const SCHEDULE_CARRIER_IRRECOVERABLE_METADATA_KEY = 'scheduleRecoveryIrre
  */
 export const SCHEDULE_CARRIER_IRRECOVERABLE_RETENTION_HOURS = 30 * 24
 
-/** Superseded reconciliation key stripped on every metadata merge. */
-const LEGACY_SCHEDULE_CARRIER_RECOVERY_BLOCKED_METADATA_KEY = 'scheduleRecoveryBlocked'
-
 /**
  * `COALESCE(metadata ->> '<key>', 'false')`, with the key spelled as a SQL
  * *literal* rather than a bind parameter.
@@ -62,7 +59,7 @@ export function carrierNotIrrecoverableSql(metadata: Column): SQL {
 
 /**
  * Builds the jsonb merge that stamps reconciliation bookkeeping onto a carrier
- * while preserving every other metadata key and dropping the legacy one.
+ * while preserving every other metadata key it already carries.
  */
 export function buildCarrierReconciledMetadata(
   metadata: Column,
@@ -75,5 +72,5 @@ export function buildCarrierReconciledMetadata(
     patch[SCHEDULE_CARRIER_IRRECOVERABLE_METADATA_KEY] = true
   }
 
-  return sql`(COALESCE(${metadata}, '{}'::jsonb) - ${LEGACY_SCHEDULE_CARRIER_RECOVERY_BLOCKED_METADATA_KEY}) || ${JSON.stringify(patch)}::jsonb`
+  return sql`COALESCE(${metadata}, '{}'::jsonb) || ${JSON.stringify(patch)}::jsonb`
 }