@burdenoff/mcp-libs 2026.522.1 → 2026.525.1

package/dist/modules/scheduler/index.js

@@ -38,6 +38,193 @@ var JOB_EXECUTIONS = `
     }
   }
 `;
+var UPDATE_SCHEDULED_JOB = `
+  mutation UpdateScheduledJob($id: ID!, $input: UpdateScheduledJobInput!) {
+    updateScheduledJob(id: $id, input: $input) {
+      id name status scheduleType cronExpression nextExecutionAt
+    }
+  }
+`;
+var GET_JOB_EXECUTION = `
+  query JobExecution($id: ID!) {
+    jobExecution(id: $id) {
+      id scheduleId status attemptNumber startedAt completedAt
+      errorMessage result success
+    }
+  }
+`;
+var RETRY_JOB_EXECUTION = `
+  mutation RetryJobExecution($executionId: ID!) {
+    retryJobExecution(executionId: $executionId) {
+      id status attemptNumber startedAt
+    }
+  }
+`;
+var PAUSE_JOB = `
+  mutation PauseScheduledJob($id: ID!) {
+    pauseScheduledJob(id: $id) { id name status }
+  }
+`;
+var RESUME_JOB = `
+  mutation ResumeScheduledJob($id: ID!) {
+    resumeScheduledJob(id: $id) { id name status }
+  }
+`;
+var ACTIVATE_SCHEDULE = `
+  mutation ActivateSchedule($id: ID!) {
+    activateSchedule(id: $id) { id name status }
+  }
+`;
+var ARCHIVE_SCHEDULE = `
+  mutation ArchiveSchedule($id: ID!) {
+    archiveSchedule(id: $id) { id name status }
+  }
+`;
+var DISABLE_SCHEDULE = `
+  mutation DisableSchedule($id: ID!, $reason: String) {
+    disableSchedule(id: $id, reason: $reason) { id name status }
+  }
+`;
+var CLONE_SCHEDULE = `
+  mutation CloneSchedule($sourceId: ID!, $newWorkspaceId: ID, $overrides: CreateScheduledJobInput) {
+    cloneSchedule(sourceId: $sourceId, newWorkspaceId: $newWorkspaceId, overrides: $overrides) {
+      id name status
+    }
+  }
+`;
+var EXECUTE_JOB_NOW = `
+  mutation ExecuteJobNow($id: ID!) {
+    executeJobNow(id: $id) { id scheduledJobId status }
+  }
+`;
+var PREVIEW_SCHEDULE = `
+  query PreviewSchedule(
+    $scheduleType: ScheduleType!
+    $cronExpression: String
+    $rrule: String
+    $interval: Int
+    $intervalUnit: String
+    $count: Int
+    $startDate: DateTime
+    $endDate: DateTime
+    $timezone: String
+  ) {
+    previewSchedule(
+      scheduleType: $scheduleType
+      cronExpression: $cronExpression
+      rrule: $rrule
+      interval: $interval
+      intervalUnit: $intervalUnit
+      count: $count
+      startDate: $startDate
+      endDate: $endDate
+      timezone: $timezone
+    ) {
+      count startDate endDate nextExecutions
+    }
+  }
+`;
+var LIST_SCHEDULE_TEMPLATES = `
+  query ScheduleTemplates(
+    $workspaceId: ID!
+    $filter: ScheduleTemplateFilterInput
+    $pagination: SchedulerPaginationInput
+  ) {
+    scheduleTemplates(workspaceId: $workspaceId, filter: $filter, pagination: $pagination) {
+      templates { id name category isPublic scheduleType executorType usageCount }
+      total nextCursor
+    }
+  }
+`;
+var LIST_PUBLIC_SCHEDULE_TEMPLATES = `
+  query PublicScheduleTemplates(
+    $filter: ScheduleTemplateFilterInput
+    $pagination: SchedulerPaginationInput
+  ) {
+    publicScheduleTemplates(filter: $filter, pagination: $pagination) {
+      templates { id name category isPublic scheduleType executorType usageCount }
+      total nextCursor
+    }
+  }
+`;
+var GET_SCHEDULE_TEMPLATE = `
+  query ScheduleTemplate($id: ID!) {
+    scheduleTemplate(id: $id) {
+      id name description category isPublic scheduleType executorType
+      scheduleConfig executorConfig usageCount
+    }
+  }
+`;
+var CREATE_SCHEDULE_TEMPLATE = `
+  mutation CreateScheduleTemplate($input: CreateScheduleTemplateInput!, $workspaceId: ID!) {
+    createScheduleTemplate(input: $input, workspaceId: $workspaceId) { id name scheduleType }
+  }
+`;
+var UPDATE_SCHEDULE_TEMPLATE = `
+  mutation UpdateScheduleTemplate($id: ID!, $input: UpdateScheduleTemplateInput!) {
+    updateScheduleTemplate(id: $id, input: $input) { id name }
+  }
+`;
+var DELETE_SCHEDULE_TEMPLATE = `
+  mutation DeleteScheduleTemplate($id: ID!) { deleteScheduleTemplate(id: $id) }
+`;
+var CREATE_SCHEDULE_FROM_TEMPLATE = `
+  mutation CreateScheduleFromTemplate(
+    $templateId: ID!
+    $workspaceId: ID!
+    $overrides: CreateScheduledJobInput
+  ) {
+    createScheduleFromTemplate(templateId: $templateId, workspaceId: $workspaceId, overrides: $overrides) {
+      id name status
+    }
+  }
+`;
+var SCHEDULE_VERSION_HISTORY = `
+  query ScheduleVersionHistory($scheduleId: ID!) {
+    scheduleVersionHistory(scheduleId: $scheduleId) {
+      id scheduleId version changedBy changedFields changeReason createdAt
+    }
+  }
+`;
+var RESTORE_SCHEDULE_VERSION = `
+  mutation RestoreScheduleVersion($scheduleId: ID!, $versionId: ID!) {
+    restoreScheduleVersion(scheduleId: $scheduleId, versionId: $versionId) { id name version }
+  }
+`;
+var TAG_SCHEDULED_JOB = `
+  mutation TagScheduledJob($input: TagScheduledJobInput!) {
+    tagScheduledJob(input: $input) { id entityId tagId source }
+  }
+`;
+var UNTAG_SCHEDULED_JOB = `
+  mutation UntagScheduledJob($input: UntagScheduledJobInput!) {
+    untagScheduledJob(input: $input)
+  }
+`;
+var REPLACE_SCHEDULED_JOB_TAGS = `
+  mutation ReplaceScheduledJobTags($input: ReplaceScheduledJobTagsInput!) {
+    replaceScheduledJobTags(input: $input) { id entityId tagId source }
+  }
+`;
+var GET_SCHEDULED_JOB_TAGS = `
+  query GetScheduledJobTags($input: GetScheduledJobTagsInput!) {
+    getScheduledJobTags(input: $input) { id entityId tagId source }
+  }
+`;
+var EXECUTION_UPDATED_POLL = `
+  query ExecutionUpdatedPoll($id: ID!) {
+    jobExecution(id: $id) {
+      id scheduleId status attemptNumber startedAt completedAt errorMessage success
+    }
+  }
+`;
+var JOB_STATUS_UPDATED_POLL = `
+  query JobStatusUpdatedPoll($id: ID!) {
+    scheduledJob(id: $id) {
+      id name status nextExecutionAt lastExecutionAt updatedAt
+    }
+  }
+`;
 
 // src/modules/scheduler/tools.ts
 function readWorkspaceId(ctx) {
@@ -145,6 +332,63 @@ function registerSchedulerTools(server, ctx, track) {
       }
     }
   );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_jobs_update")),
+    {
+      title: "Update Scheduled Job",
+      description: "Update a scheduled job (cron expression, executor config, retry policy, etc.). At least one field must be provided. Returns the updated ScheduledJob.",
+      inputSchema: {
+        id: z.string().describe("Job ID"),
+        name: z.string().optional().describe("Updated job name"),
+        description: z.string().optional().describe("Updated description"),
+        cronExpression: z.string().optional().describe("Updated cron expression (CRON jobs only)"),
+        interval: z.number().int().optional().describe("Updated interval (INTERVAL jobs only)"),
+        intervalUnit: z.string().optional().describe("Interval unit (SECONDS|MINUTES|HOURS|DAYS, will be uppercased)"),
+        endDate: z.string().optional().describe("Updated end date (ISO-8601)"),
+        executorConfig: z.record(z.string(), z.unknown()).optional().describe("Updated executor configuration"),
+        maxRetries: z.number().int().optional().describe("Max retry attempts on failure"),
+        changeReason: z.string().optional().describe("Audit-trail reason for the change")
+      }
+    },
+    async ({
+      id,
+      name,
+      description,
+      cronExpression,
+      interval,
+      intervalUnit,
+      endDate,
+      executorConfig,
+      maxRetries,
+      changeReason
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (description !== void 0) input.description = description;
+        if (cronExpression !== void 0) input.cronExpression = cronExpression;
+        if (interval !== void 0) input.interval = interval;
+        if (intervalUnit !== void 0) input.intervalUnit = intervalUnit.toUpperCase();
+        if (endDate !== void 0) input.endDate = endDate;
+        if (executorConfig !== void 0) input.executorConfig = executorConfig;
+        if (maxRetries !== void 0) input.maxRetries = maxRetries;
+        if (changeReason !== void 0) input.changeReason = changeReason;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one field to update");
+        }
+        const data = await ctx.gql.workspace.request(
+          UPDATE_SCHEDULED_JOB,
+          { id, input }
+        );
+        return jsonResult(data.updateScheduledJob);
+      } catch (error) {
+        ctx.logger.error("scheduler_jobs_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update scheduled job: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
   server.registerTool(
     track(mcpToolName(ctx.productName, "scheduler_jobs_delete")),
     {
@@ -192,6 +436,622 @@ function registerSchedulerTools(server, ctx, track) {
       }
     }
   );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_executions_get")),
+    {
+      title: "Get Job Execution",
+      description: "Fetch a single job execution by ID, including status, attempt number, timings, error message and result payload. Returns the JobExecution or an error if not found.",
+      inputSchema: { id: z.string().describe("Execution ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          GET_JOB_EXECUTION,
+          { id }
+        );
+        if (!data.jobExecution) return errorResult(`Execution ${id} not found`);
+        return jsonResult(data.jobExecution);
+      } catch (error) {
+        ctx.logger.error("scheduler_executions_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get job execution: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  for (const [tool, op, title, desc, mutationField] of [
+    [
+      "scheduler_jobs_pause",
+      PAUSE_JOB,
+      "Pause Scheduled Job",
+      "Pause a scheduled job.",
+      "pauseScheduledJob"
+    ],
+    [
+      "scheduler_jobs_resume",
+      RESUME_JOB,
+      "Resume Scheduled Job",
+      "Resume a paused scheduled job.",
+      "resumeScheduledJob"
+    ],
+    [
+      "scheduler_jobs_activate",
+      ACTIVATE_SCHEDULE,
+      "Activate Schedule",
+      "Activate a draft or disabled schedule.",
+      "activateSchedule"
+    ],
+    [
+      "scheduler_jobs_archive",
+      ARCHIVE_SCHEDULE,
+      "Archive Schedule",
+      "Archive a scheduled job (soft delete).",
+      "archiveSchedule"
+    ]
+  ]) {
+    server.registerTool(
+      track(mcpToolName(ctx.productName, tool)),
+      {
+        title,
+        description: desc,
+        inputSchema: { id: z.string().describe("Schedule ID") }
+      },
+      async ({ id }) => {
+        try {
+          const data = await ctx.gql.workspace.request(op, { id });
+          return jsonResult(data[mutationField]);
+        } catch (error) {
+          ctx.logger.error(`${tool} failed`, { error: String(error) });
+          return errorResult(
+            `${title} failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    );
+  }
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_jobs_disable")),
+    {
+      title: "Disable Schedule",
+      description: "Disable a schedule with an optional reason.",
+      inputSchema: {
+        id: z.string().describe("Schedule ID"),
+        reason: z.string().optional().describe("Disable reason (audit trail)")
+      }
+    },
+    async ({ id, reason }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          DISABLE_SCHEDULE,
+          { id, reason: reason ?? null }
+        );
+        return jsonResult(data.disableSchedule);
+      } catch (error) {
+        ctx.logger.error("scheduler_jobs_disable failed", { error: String(error) });
+        return errorResult(
+          `Failed to disable: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_jobs_clone")),
+    {
+      title: "Clone Schedule",
+      description: "Clone an existing schedule. Optionally move to another workspace and supply override fields.",
+      inputSchema: {
+        sourceId: z.string().describe("Source schedule ID"),
+        newWorkspaceId: z.string().optional().describe("Target workspace (defaults to source)"),
+        overrides: z.record(z.string(), z.unknown()).optional().describe("CreateScheduledJobInput overrides")
+      }
+    },
+    async ({ sourceId, newWorkspaceId, overrides }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          CLONE_SCHEDULE,
+          { sourceId, newWorkspaceId: newWorkspaceId ?? null, overrides: overrides ?? null }
+        );
+        return jsonResult(data.cloneSchedule);
+      } catch (error) {
+        ctx.logger.error("scheduler_jobs_clone failed", { error: String(error) });
+        return errorResult(
+          `Failed to clone: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_jobs_execute_now")),
+    {
+      title: "Execute Job Now",
+      description: "Trigger a scheduled job to execute immediately (out-of-band).",
+      inputSchema: { id: z.string().describe("Schedule ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          EXECUTE_JOB_NOW,
+          { id }
+        );
+        return jsonResult(data.executeJobNow);
+      } catch (error) {
+        ctx.logger.error("scheduler_jobs_execute_now failed", { error: String(error) });
+        return errorResult(
+          `Failed to execute: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_jobs_preview")),
+    {
+      title: "Preview Schedule",
+      description: "Compute upcoming execution times for a schedule definition without creating it.",
+      inputSchema: {
+        scheduleType: z.string().describe("CRON | FIXED_INTERVAL | ONE_TIME | RRULE | WINDOWED"),
+        cronExpression: z.string().optional(),
+        rrule: z.string().optional(),
+        interval: z.number().int().optional(),
+        intervalUnit: z.string().optional(),
+        count: z.number().int().optional().describe("How many upcoming executions to return"),
+        startDate: z.string().optional(),
+        endDate: z.string().optional(),
+        timezone: z.string().optional()
+      }
+    },
+    async ({
+      scheduleType,
+      cronExpression,
+      rrule,
+      interval,
+      intervalUnit,
+      count,
+      startDate,
+      endDate,
+      timezone
+    }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PREVIEW_SCHEDULE, {
+          scheduleType: scheduleType.toUpperCase(),
+          cronExpression: cronExpression ?? null,
+          rrule: rrule ?? null,
+          interval: interval ?? null,
+          intervalUnit: intervalUnit ?? null,
+          count: count ?? null,
+          startDate: startDate ?? null,
+          endDate: endDate ?? null,
+          timezone: timezone ?? null
+        });
+        return jsonResult(data.previewSchedule);
+      } catch (error) {
+        ctx.logger.error("scheduler_jobs_preview failed", { error: String(error) });
+        return errorResult(
+          `Failed to preview: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_templates_list")),
+    {
+      title: "List Schedule Templates",
+      description: "List schedule templates in the active workspace.",
+      inputSchema: {
+        category: z.string().optional(),
+        isPublic: z.boolean().optional(),
+        limit: z.number().optional()
+      }
+    },
+    async ({ category, isPublic, limit }) => {
+      try {
+        const workspaceId = readWorkspaceId(ctx);
+        if (!workspaceId) return errorResult("No workspace set.");
+        const filter = {};
+        if (category !== void 0) filter.category = category;
+        if (isPublic !== void 0) filter.isPublic = isPublic;
+        const data = await ctx.gql.workspace.request(LIST_SCHEDULE_TEMPLATES, {
+          workspaceId,
+          filter: Object.keys(filter).length > 0 ? filter : void 0,
+          pagination: { first: limit ?? 100 }
+        });
+        return jsonResult(data.scheduleTemplates);
+      } catch (error) {
+        ctx.logger.error("scheduler_templates_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list templates: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_templates_list_public")),
+    {
+      title: "List Public Schedule Templates",
+      description: "List public (cross-workspace) schedule templates.",
+      inputSchema: {
+        category: z.string().optional(),
+        limit: z.number().optional()
+      }
+    },
+    async ({ category, limit }) => {
+      try {
+        const filter = {};
+        if (category !== void 0) filter.category = category;
+        const data = await ctx.gql.workspace.request(LIST_PUBLIC_SCHEDULE_TEMPLATES, {
+          filter: Object.keys(filter).length > 0 ? filter : void 0,
+          pagination: { first: limit ?? 100 }
+        });
+        return jsonResult(data.publicScheduleTemplates);
+      } catch (error) {
+        ctx.logger.error("scheduler_templates_list_public failed", { error: String(error) });
+        return errorResult(
+          `Failed to list: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_templates_get")),
+    {
+      title: "Get Schedule Template",
+      description: "Get a schedule template by ID.",
+      inputSchema: { id: z.string() }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          GET_SCHEDULE_TEMPLATE,
+          { id }
+        );
+        if (!data.scheduleTemplate) return errorResult(`Template ${id} not found`);
+        return jsonResult(data.scheduleTemplate);
+      } catch (error) {
+        ctx.logger.error("scheduler_templates_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get template: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_templates_create")),
+    {
+      title: "Create Schedule Template",
+      description: "Create a reusable schedule template in the active workspace.",
+      inputSchema: {
+        name: z.string(),
+        scheduleType: z.string().describe("CRON | FIXED_INTERVAL | ONE_TIME | RRULE | WINDOWED"),
+        executorType: z.string().describe("WEBHOOK | INTERNAL_API | NATS_TOPIC | GRAPHQL"),
+        scheduleConfig: z.record(z.string(), z.unknown()),
+        executorConfig: z.record(z.string(), z.unknown()),
+        description: z.string().optional(),
+        category: z.string().optional(),
+        isPublic: z.boolean().optional()
+      }
+    },
+    async ({
+      name,
+      scheduleType,
+      executorType,
+      scheduleConfig,
+      executorConfig,
+      description,
+      category,
+      isPublic
+    }) => {
+      try {
+        const workspaceId = readWorkspaceId(ctx);
+        if (!workspaceId) return errorResult("No workspace set.");
+        const input = {
+          name,
+          scheduleType: scheduleType.toUpperCase(),
+          executorType: executorType.toUpperCase(),
+          scheduleConfig,
+          executorConfig
+        };
+        if (description !== void 0) input.description = description;
+        if (category !== void 0) input.category = category;
+        if (isPublic !== void 0) input.isPublic = isPublic;
+        const data = await ctx.gql.workspace.request(
+          CREATE_SCHEDULE_TEMPLATE,
+          { workspaceId, input }
+        );
+        return jsonResult(data.createScheduleTemplate);
+      } catch (error) {
+        ctx.logger.error("scheduler_templates_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create template: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_templates_update")),
+    {
+      title: "Update Schedule Template",
+      description: "Update a schedule template.",
+      inputSchema: {
+        id: z.string(),
+        name: z.string().optional(),
+        description: z.string().optional(),
+        category: z.string().optional(),
+        isPublic: z.boolean().optional()
+      }
+    },
+    async ({ id, name, description, category, isPublic }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (description !== void 0) input.description = description;
+        if (category !== void 0) input.category = category;
+        if (isPublic !== void 0) input.isPublic = isPublic;
+        if (Object.keys(input).length === 0) {
+          return errorResult("Provide at least one field to update");
+        }
+        const data = await ctx.gql.workspace.request(
+          UPDATE_SCHEDULE_TEMPLATE,
+          { id, input }
+        );
+        return jsonResult(data.updateScheduleTemplate);
+      } catch (error) {
+        ctx.logger.error("scheduler_templates_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update template: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_templates_delete")),
+    {
+      title: "Delete Schedule Template",
+      description: "Delete a schedule template.",
+      inputSchema: { id: z.string() }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          DELETE_SCHEDULE_TEMPLATE,
+          { id }
+        );
+        return jsonResult({ deleted: data.deleteScheduleTemplate, id });
+      } catch (error) {
+        ctx.logger.error("scheduler_templates_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_templates_create_from")),
+    {
+      title: "Create Schedule From Template",
+      description: "Instantiate a schedule from a template; optional overrides.",
+      inputSchema: {
+        templateId: z.string(),
+        overrides: z.record(z.string(), z.unknown()).optional()
+      }
+    },
+    async ({ templateId, overrides }) => {
+      try {
+        const workspaceId = readWorkspaceId(ctx);
+        if (!workspaceId) return errorResult("No workspace set.");
+        const data = await ctx.gql.workspace.request(
+          CREATE_SCHEDULE_FROM_TEMPLATE,
+          { templateId, workspaceId, overrides: overrides ?? null }
+        );
+        return jsonResult(data.createScheduleFromTemplate);
+      } catch (error) {
+        ctx.logger.error("scheduler_templates_create_from failed", { error: String(error) });
+        return errorResult(
+          `Failed to create: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_versions_history")),
+    {
+      title: "Schedule Version History",
+      description: "List version history for a schedule.",
+      inputSchema: { scheduleId: z.string() }
+    },
+    async ({ scheduleId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          SCHEDULE_VERSION_HISTORY,
+          { scheduleId }
+        );
+        return jsonResult(data.scheduleVersionHistory);
+      } catch (error) {
+        ctx.logger.error("scheduler_versions_history failed", { error: String(error) });
+        return errorResult(
+          `Failed to get history: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_versions_restore")),
+    {
+      title: "Restore Schedule Version",
+      description: "Restore a schedule to a prior version.",
+      inputSchema: { scheduleId: z.string(), versionId: z.string() }
+    },
+    async ({ scheduleId, versionId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          RESTORE_SCHEDULE_VERSION,
+          { scheduleId, versionId }
+        );
+        return jsonResult(data.restoreScheduleVersion);
+      } catch (error) {
+        ctx.logger.error("scheduler_versions_restore failed", { error: String(error) });
+        return errorResult(
+          `Failed to restore: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_jobs_tag_add")),
+    {
+      title: "Tag Scheduled Job",
+      description: "Add a tag assignment to a scheduled job.",
+      inputSchema: {
+        entityId: z.string(),
+        tagId: z.string(),
+        source: z.string().optional()
+      }
+    },
+    async ({ entityId, tagId, source }) => {
+      try {
+        const input = { entityId, tagId };
+        if (source !== void 0) input.source = source;
+        const data = await ctx.gql.workspace.request(
+          TAG_SCHEDULED_JOB,
+          { input }
+        );
+        return jsonResult(data.tagScheduledJob);
+      } catch (error) {
+        ctx.logger.error("scheduler_jobs_tag_add failed", { error: String(error) });
+        return errorResult(
+          `Failed to tag: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_jobs_tag_remove")),
+    {
+      title: "Untag Scheduled Job",
+      description: "Remove a tag assignment from a scheduled job.",
+      inputSchema: { entityId: z.string(), tagId: z.string() }
+    },
+    async ({ entityId, tagId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          UNTAG_SCHEDULED_JOB,
+          { input: { entityId, tagId } }
+        );
+        return jsonResult({ removed: data.untagScheduledJob });
+      } catch (error) {
+        ctx.logger.error("scheduler_jobs_tag_remove failed", { error: String(error) });
+        return errorResult(
+          `Failed to untag: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_jobs_tag_replace")),
+    {
+      title: "Replace Scheduled Job Tags",
+      description: "Replace all tag assignments on a scheduled job.",
+      inputSchema: { entityId: z.string(), tagIds: z.array(z.string()) }
+    },
+    async ({ entityId, tagIds }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          REPLACE_SCHEDULED_JOB_TAGS,
+          { input: { entityId, tagIds } }
+        );
+        return jsonResult(data.replaceScheduledJobTags);
+      } catch (error) {
+        ctx.logger.error("scheduler_jobs_tag_replace failed", { error: String(error) });
+        return errorResult(
+          `Failed to replace tags: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_jobs_tag_list")),
+    {
+      title: "List Scheduled Job Tags",
+      description: "List tag assignments on a scheduled job.",
+      inputSchema: { entityId: z.string() }
+    },
+    async ({ entityId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          GET_SCHEDULED_JOB_TAGS,
+          { input: { entityId } }
+        );
+        return jsonResult(data.getScheduledJobTags);
+      } catch (error) {
+        ctx.logger.error("scheduler_jobs_tag_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list tags: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_executions_check")),
+    {
+      title: "Check Execution Status (poll)",
+      description: "Polling proxy for the executionUpdated subscription \u2014 returns the current state of an execution.",
+      inputSchema: { id: z.string().describe("Execution ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          EXECUTION_UPDATED_POLL,
+          { id }
+        );
+        if (!data.jobExecution) return errorResult(`Execution ${id} not found`);
+        return jsonResult(data.jobExecution);
+      } catch (error) {
+        ctx.logger.error("scheduler_executions_check failed", { error: String(error) });
+        return errorResult(`Failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_jobs_check")),
+    {
+      title: "Check Job Status (poll)",
+      description: "Polling proxy for the jobStatusUpdated subscription \u2014 returns the current state of a scheduled job.",
+      inputSchema: { id: z.string().describe("Schedule ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          JOB_STATUS_UPDATED_POLL,
+          { id }
+        );
+        if (!data.scheduledJob) return errorResult(`Job ${id} not found`);
+        return jsonResult(data.scheduledJob);
+      } catch (error) {
+        ctx.logger.error("scheduler_jobs_check failed", { error: String(error) });
+        return errorResult(`Failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "scheduler_executions_retry")),
+    {
+      title: "Retry Job Execution",
+      description: "Re-run a failed (or completed) scheduled-job execution. Returns the new JobExecution row created for the retry.",
+      inputSchema: { executionId: z.string().describe("Execution ID to retry") }
+    },
+    async ({ executionId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          RETRY_JOB_EXECUTION,
+          { executionId }
+        );
+        return jsonResult(data.retryJobExecution);
+      } catch (error) {
+        ctx.logger.error("scheduler_executions_retry failed", { error: String(error) });
+        return errorResult(
+          `Failed to retry job execution: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
 }
 
 // src/modules/scheduler/index.ts