chore(scheduled-tasks): remove the scheduled-task logic

Scheduled tasks are retired. This removes the `sourceType = 'job'` half of
`workflow_schedule` from the application, leaving the workflow Schedule
trigger (`sourceType = 'workflow'`) untouched.

Gone:
- the job orchestration layer (`lib/workflows/schedules/orchestration.ts`)
  and the agent-job runner in `background/schedule-execution.ts`
- the job claim/dispatch half of the schedules execute tick
- POST /api/schedules (job creation) and the job branches of
  GET /api/schedules and PUT/DELETE /api/schedules/[id]
- the copilot job tools and handlers, the `scheduledtask` resource type and
  chat-context kind, and the VFS `jobs/` materialization
- the scheduled-task analytics events and the job variant of the
  schedule-disabled email

Kept on purpose: `scheduled-tasks/components/schedule-calendar/**` and
`scheduled-tasks/utils/**`, which the agents module will reuse.

`packages/db/schema.ts` is deliberately untouched — the columns stay for now
and come out in a follow-up with a proper expand/contract migration.

The generated copilot catalog and VFS snapshot types are regenerated from
the matching copilot PR, which removes the tools and the `jobs` snapshot
field at the source.

Verified: 23/23 type-check, biome, api-validation, production build, and the
full vitest suite (18361 passing; the one failure in
executor/handlers/pi/cloud-review-tools.test.ts predates this branch).

Author: waleedlatif1

apps/sim/app/api/emails/preview/route.ts

@@ -118,7 +118,6 @@ const emailTemplates = {
   'schedule-disabled': () =>
     renderScheduleDisabledEmail({
       recipientName: 'John',
-      kind: 'workflow',
       resourceName: 'Daily digest',
       reason: 'consecutive_failures',
       failedCount: 100,
@@ -127,10 +126,9 @@ const emailTemplates = {
   'schedule-disabled-auth': () =>
     renderScheduleDisabledEmail({
       recipientName: 'John',
-      kind: 'job',
       resourceName: 'Weekly report',
       reason: 'authentication_error',
-      manageLink: 'https://sim.ai/workspace/ws_123/scheduled-tasks',
+      manageLink: 'https://sim.ai/workspace/ws_123/w/wf_456',
     }),
 } as const
 

apps/sim/app/api/mothership/execute/route.test.ts

@@ -89,11 +89,7 @@ vi.mock('@/lib/workspaces/permissions/utils', () => ({
 }))
 
 import type { CopilotLifecycleOptions } from '@/lib/copilot/request/lifecycle/run'
-import {
-  buildExecuteResponsePayload,
-  CALLER_VISIBLE_SERVER_TOOLS,
-  POST,
-} from '@/app/api/mothership/execute/route'
+import { buildExecuteResponsePayload, POST } from '@/app/api/mothership/execute/route'
 
 type Payload = Parameters<typeof buildExecuteResponsePayload>[0]
 
@@ -102,25 +98,6 @@ function resultWithToolCalls(names: string[]): Payload {
 }
 
 describe('buildExecuteResponsePayload', () => {
-  // The scheduled-task runner branches on whether the agent called
-  // complete_scheduled_task (background/schedule-execution.ts reads
-  // responseBody.toolCalls). This filter used to admit only integration tools
-  // and mcp-*, so that check was permanently false: a job completed itself, the
-  // signal was dropped here, and the runner's post-run bookkeeping wrote
-  // status='active' with a fresh nextRunAt straight back over the completion —
-  // the job then reran forever, each time telling the model it was done.
-  it('keeps complete_scheduled_task so the schedule runner can see it', () => {
-    const payload = buildExecuteResponsePayload(
-      resultWithToolCalls(['complete_scheduled_task']),
-      'chat-1',
-      []
-    )
-
-    expect(payload.toolCalls.map((tc: { name: string }) => tc.name)).toContain(
-      'complete_scheduled_task'
-    )
-  })
-
   it('still admits integration and mcp tool calls, and still drops other server tools', () => {
     const payload = buildExecuteResponsePayload(
       resultWithToolCalls(['gmail_send', 'mcp-notion-create', 'read', 'edit_workflow']),
@@ -131,13 +108,6 @@ describe('buildExecuteResponsePayload', () => {
     const names = payload.toolCalls.map((tc: { name: string }) => tc.name)
     expect(names).toEqual(['gmail_send', 'mcp-notion-create'])
   })
-
-  // Guards the cross-file contract: the literal the runner greps for must be in
-  // the allowlist above. These live in different files and nothing else ties
-  // them together.
-  it('exposes the exact tool name the schedule runner looks for', () => {
-    expect(CALLER_VISIBLE_SERVER_TOOLS.has('complete_scheduled_task')).toBe(true)
-  })
 })
 
 describe('mothership private trace provenance transport', () => {

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

@@ -89,26 +89,14 @@ function encodeNdjson(value: unknown): Uint8Array {
   return ndjsonEncoder.encode(`${JSON.stringify(value)}\n`)
 }
 
-/**
- * Server-owned tools whose invocation the CALLER must see, even though they are
- * not client/integration tools. The scheduled-task runner branches on whether
- * the agent called complete_scheduled_task; filtering it out of the response
- * made that check permanently false, so a completed job was rescheduled by the
- * runner's own post-run bookkeeping.
- */
-export const CALLER_VISIBLE_SERVER_TOOLS = new Set(['complete_scheduled_task'])
-
 export function buildExecuteResponsePayload(
   result: Awaited<ReturnType<typeof runHeadlessCopilotLifecycle>>,
   effectiveChatId: string,
   integrationTools: Array<{ name: string }>
 ) {
   const clientToolNames = new Set(integrationTools.map((t) => t.name))
   const clientToolCalls = (result.toolCalls || []).filter(
-    (tc: { name: string }) =>
-      clientToolNames.has(tc.name) ||
-      tc.name.startsWith('mcp-') ||
-      CALLER_VISIBLE_SERVER_TOOLS.has(tc.name)
+    (tc: { name: string }) => clientToolNames.has(tc.name) || tc.name.startsWith('mcp-')
   )
 
   return {

apps/sim/app/api/schedules/[id]/route.ts

@@ -14,14 +14,7 @@ import { parseRequest } from '@/lib/api/server'
 import { getSession } from '@/lib/auth'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
-import { captureServerEvent } from '@/lib/posthog/server'
-import {
-  performDeleteJob,
-  performExcludeOccurrence,
-  performUpdateJob,
-} from '@/lib/workflows/schedules/orchestration'
 import { validateCronExpression } from '@/lib/workflows/schedules/utils'
-import { verifyWorkspaceMembership } from '@/app/api/workflows/utils'
 
 const logger = createLogger('ScheduleAPI')
 
@@ -46,18 +39,6 @@ async function fetchAndAuthorize(
     return NextResponse.json({ error: 'Schedule not found' }, { status: 404 })
   }
 
-  if (schedule.sourceType === 'job') {
-    if (!schedule.sourceWorkspaceId) {
-      return NextResponse.json({ error: 'Job has no workspace' }, { status: 400 })
-    }
-    const permission = await verifyWorkspaceMembership(userId, schedule.sourceWorkspaceId)
-    const canWrite = permission === 'admin' || permission === 'write'
-    if (!permission || (action === 'write' && !canWrite)) {
-      return NextResponse.json({ error: 'Not authorized' }, { status: 403 })
-    }
-    return { schedule, workspaceId: schedule.sourceWorkspaceId }
-  }
-
   if (!schedule.workflowId) {
     logger.warn(`[${requestId}] Schedule has no workflow: ${scheduleId}`)
     return NextResponse.json({ error: 'Schedule has no associated workflow' }, { status: 400 })
@@ -178,95 +159,6 @@ export const PUT = withRouteHandler(
         return NextResponse.json({ message: 'Schedule disabled successfully' })
       }
 
-      if (action === 'update') {
-        if (schedule.sourceType !== 'job') {
-          return NextResponse.json(
-            { error: 'Only standalone job schedules can be edited' },
-            { status: 400 }
-          )
-        }
-
-        if (!workspaceId) {
-          return NextResponse.json({ error: 'Job has no workspace' }, { status: 400 })
-        }
-
-        const updateResult = await performUpdateJob({
-          jobId: scheduleId,
-          workspaceId,
-          userId: session.user.id,
-          actorName: session.user.name,
-          actorEmail: session.user.email,
-          title: validatedBody.title,
-          prompt: validatedBody.prompt,
-          timezone: validatedBody.timezone,
-          lifecycle: validatedBody.lifecycle,
-          maxRuns: validatedBody.maxRuns,
-          cronExpression: validatedBody.cronExpression,
-          time: validatedBody.time,
-          endsAt: validatedBody.endsAt,
-          contexts: validatedBody.contexts,
-          secretScope: validatedBody.secretScope,
-          mountedSecrets: validatedBody.mountedSecrets,
-          request,
-        })
-        if (!updateResult.success) {
-          return NextResponse.json(
-            { error: updateResult.error || 'Failed to update schedule' },
-            {
-              status:
-                updateResult.errorCode === 'forbidden'
-                  ? 403
-                  : updateResult.errorCode === 'validation'
-                    ? 400
-                    : 500,
-            }
-          )
-        }
-
-        logger.info(`[${requestId}] Updated job schedule: ${scheduleId}`)
-
-        return NextResponse.json({ message: 'Schedule updated successfully' })
-      }
-
-      if (action === 'exclude_occurrence') {
-        if (schedule.sourceType !== 'job') {
-          return NextResponse.json(
-            { error: 'Only standalone job schedules have occurrences' },
-            { status: 400 }
-          )
-        }
-        if (!workspaceId) {
-          return NextResponse.json({ error: 'Job has no workspace' }, { status: 400 })
-        }
-
-        const excludeResult = await performExcludeOccurrence({
-          jobId: scheduleId,
-          workspaceId,
-          userId: session.user.id,
-          actorName: session.user.name,
-          actorEmail: session.user.email,
-          occurrence: validatedBody.occurrence,
-          request,
-        })
-        if (!excludeResult.success) {
-          return NextResponse.json(
-            { error: excludeResult.error || 'Failed to delete occurrence' },
-            {
-              status:
-                excludeResult.errorCode === 'not_found'
-                  ? 404
-                  : excludeResult.errorCode === 'validation'
-                    ? 400
-                    : 500,
-            }
-          )
-        }
-
-        logger.info(`[${requestId}] Excluded occurrence on job schedule: ${scheduleId}`)
-
-        return NextResponse.json({ message: 'Occurrence deleted successfully' })
-      }
-
       // reactivate
       if (schedule.status === 'active') {
         return NextResponse.json({ message: 'Schedule is already active' })
@@ -341,27 +233,6 @@ export const DELETE = withRouteHandler(
       if (result instanceof NextResponse) return result
       const { schedule, workspaceId } = result
 
-      if (schedule.sourceType === 'job') {
-        if (!workspaceId) {
-          return NextResponse.json({ error: 'Job has no workspace' }, { status: 400 })
-        }
-        const deleteResult = await performDeleteJob({
-          jobId: scheduleId,
-          workspaceId,
-          userId: session.user.id,
-          actorName: session.user.name,
-          actorEmail: session.user.email,
-          request,
-        })
-        if (!deleteResult.success) {
-          return NextResponse.json(
-            { error: deleteResult.error || 'Failed to delete schedule' },
-            { status: deleteResult.errorCode === 'not_found' ? 404 : 500 }
-          )
-        }
-        return NextResponse.json({ message: 'Schedule deleted successfully' })
-      }
-
       await db.delete(workflowSchedule).where(eq(workflowSchedule.id, scheduleId))
 
       logger.info(`[${requestId}] Deleted schedule: ${scheduleId}`)
@@ -375,7 +246,7 @@ export const DELETE = withRouteHandler(
         resourceType: AuditResourceType.SCHEDULE,
         resourceId: scheduleId,
         resourceName: schedule.jobTitle ?? undefined,
-        description: `Deleted ${schedule.sourceType === 'job' ? 'job' : 'schedule'} "${schedule.jobTitle ?? scheduleId}"`,
+        description: `Deleted schedule "${schedule.jobTitle ?? scheduleId}"`,
         metadata: {
           sourceType: schedule.sourceType,
           cronExpression: schedule.cronExpression,
@@ -384,13 +255,6 @@ export const DELETE = withRouteHandler(
         request,
       })
 
-      captureServerEvent(
-        session.user.id,
-        'scheduled_task_deleted',
-        { workspace_id: workspaceId ?? '' },
-        workspaceId ? { groups: { workspace: workspaceId } } : undefined
-      )
-
       return NextResponse.json({ message: 'Schedule deleted successfully' })
     } catch (error) {
       logger.error(`[${requestId}] Error deleting schedule`, error)

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

@@ -21,7 +21,6 @@ const orderByLimitMock = vi.fn()
 const {
   mockVerifyCronAuth,
   mockExecuteScheduleJob,
-  mockExecuteJobInline,
   mockReleaseScheduleLock,
   mockEnqueue,
   mockGetJob,
@@ -37,7 +36,6 @@ const {
 } = vi.hoisted(() => ({
   mockVerifyCronAuth: vi.fn().mockReturnValue(null),
   mockExecuteScheduleJob: vi.fn().mockResolvedValue(undefined),
-  mockExecuteJobInline: vi.fn().mockResolvedValue(undefined),
   mockReleaseScheduleLock: vi.fn().mockResolvedValue(undefined),
   mockEnqueue: vi.fn().mockResolvedValue('job-id-1'),
   mockGetJob: vi.fn().mockResolvedValue(null),
@@ -63,7 +61,6 @@ vi.mock('@/lib/billing/core/billing-attribution', () => ({
 
 vi.mock('@/background/schedule-execution', () => ({
   executeScheduleJob: mockExecuteScheduleJob,
-  executeJobInline: mockExecuteJobInline,
   releaseScheduleLock: mockReleaseScheduleLock,
   applyScheduleFailureUpdate: mockApplyScheduleFailureUpdate,
 }))
@@ -205,18 +202,6 @@ function createBillingAttribution(workspaceId: string, actorUserId = `owner-${wo
   }
 }
 
-const SINGLE_JOB = [
-  {
-    id: 'job-1',
-    cronExpression: '0 * * * *',
-    failedCount: 0,
-    infraRetryCount: 0,
-    timezone: 'UTC',
-    lastQueuedAt: undefined,
-    sourceType: 'job',
-  },
-]
-
 function conditionContains(
   condition: unknown,
   predicate: (entry: Record<string, unknown>) => boolean
@@ -313,8 +298,6 @@ describe('Scheduled Workflow Execution API Route', () => {
     mockCancelJob.mockResolvedValue(undefined)
     mockExecuteScheduleJob.mockReset()
     mockExecuteScheduleJob.mockResolvedValue(undefined)
-    mockExecuteJobInline.mockReset()
-    mockExecuteJobInline.mockResolvedValue(undefined)
     mockReleaseScheduleLock.mockReset()
     mockReleaseScheduleLock.mockResolvedValue(undefined)
     mockAssertBillingAttributionSnapshot.mockReset()
@@ -375,21 +358,6 @@ describe('Scheduled Workflow Execution API Route', () => {
     expect(result.processedCount).toBe(2)
   })
 
-  it('should execute mothership jobs inline', async () => {
-    dbChainMockFns.limit.mockResolvedValueOnce([]).mockResolvedValueOnce([{ id: 'job-1' }])
-    dbChainMockFns.returning.mockReturnValueOnce(SINGLE_JOB)
-
-    await runScheduleTick('test-request-id')
-    expect(mockExecuteJobInline).toHaveBeenCalledWith(
-      expect.objectContaining({
-        scheduleId: 'job-1',
-        cronExpression: '0 * * * *',
-        failedCount: 0,
-        now: expect.any(String),
-      })
-    )
-  })
-
   it('should enqueue schedule with one atomic system actor and payer snapshot', async () => {
     dbChainMockFns.limit
       .mockResolvedValueOnce(SINGLE_CLAIMED_SCHEDULE_ROWS)
@@ -1024,7 +992,11 @@ describe('Scheduled Workflow Execution API Route', () => {
     const result = await runScheduleTick('test-request-id')
 
     expect(result.processedCount).toBe(100)
-    expect(dbChainMockFns.limit).toHaveBeenCalledWith(100)
+    // The workflow claim is capped by SCHEDULE_WORKFLOW_ENQUEUE_LIMIT
+    // (SCHEDULE_EXECUTION_CONCURRENCY_LIMIT 30 x SCHEDULE_ENQUEUE_BUDGET_MULTIPLIER 2),
+    // not by WORKFLOW_CHUNK_SIZE. This used to read 100, which only ever matched
+    // the separate job claim's chunk size rather than the budget under test.
+    expect(dbChainMockFns.limit).toHaveBeenCalledWith(60)
     expect(mockEnqueue).toHaveBeenCalledTimes(100)
   })