@sentry/junior-scheduler 0.107.0 → 0.108.0

package/dist/index.js

@@ -25,26 +25,6 @@ import {
 import { z as z2 } from "zod";
 
 // src/cadence.ts
-function parseScheduleTimestamp(value) {
-  const trimmed = value.trim();
-  const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,9})?)?(Z|[+-]\d{2}:\d{2})$/.exec(
-    trimmed
-  );
-  if (!match) {
-    return void 0;
-  }
-  const year = Number(match[1]);
-  const month = Number(match[2]);
-  const day = Number(match[3]);
-  const hour = Number(match[4]);
-  const minute = Number(match[5]);
-  const second = match[6] ? Number(match[6]) : 0;
-  if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day) || !Number.isInteger(hour) || !Number.isInteger(minute) || !Number.isInteger(second) || month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month) || hour < 0 || hour > 23 || minute < 0 || minute > 59 || second < 0 || second > 59) {
-    return void 0;
-  }
-  const parsed = Date.parse(trimmed);
-  return Number.isFinite(parsed) ? parsed : void 0;
-}
 var FORMATTERS = /* @__PURE__ */ new Map();
 function getFormatter(timezone) {
   const existing = FORMATTERS.get(timezone);
@@ -70,6 +50,9 @@ function normalizeHour(hour) {
 function getLocalDateWeekday(date) {
   return new Date(Date.UTC(date.year, date.month - 1, date.day)).getUTCDay();
 }
+function getWeekStart(date) {
+  return addDays(date, -((getLocalDateWeekday(date) + 6) % 7));
+}
 function getZonedDateTimeParts(timestampMs, timezone) {
   const parts = getFormatter(timezone).formatToParts(new Date(timestampMs));
   const values = new Map(parts.map((part) => [part.type, part.value]));
@@ -109,15 +92,163 @@ function localDateTimeToTimestampMs(args) {
     args.time.minute,
     0
   );
-  let timestampMs = localAsUtcMs - getTimeZoneOffsetMs(localAsUtcMs, args.timezone);
-  for (let index2 = 0; index2 < 3; index2 += 1) {
-    const next = localAsUtcMs - getTimeZoneOffsetMs(timestampMs, args.timezone);
-    if (next === timestampMs) {
-      break;
+  const offsets = /* @__PURE__ */ new Set();
+  for (const probeDeltaMs of [
+    -36 * 60 * 60 * 1e3,
+    -12 * 60 * 60 * 1e3,
+    0,
+    12 * 60 * 60 * 1e3,
+    36 * 60 * 60 * 1e3
+  ]) {
+    offsets.add(
+      getTimeZoneOffsetMs(localAsUtcMs + probeDeltaMs, args.timezone)
+    );
+  }
+  const matches = [...offsets].map((offsetMs) => localAsUtcMs - offsetMs).filter((timestampMs) => {
+    const parts = getZonedDateTimeParts(timestampMs, args.timezone);
+    return parts.year === args.date.year && parts.month === args.date.month && parts.day === args.date.day && parts.hour === args.time.hour && parts.minute === args.time.minute;
+  });
+  if (matches.length === 0) {
+    return void 0;
+  }
+  return Math.min(...matches);
+}
+function resolveLocalScheduleAtMs(args) {
+  const date = parseLocalDate(args.date);
+  if (!date) {
+    return void 0;
+  }
+  return localDateTimeToTimestampMs({
+    date,
+    time: args.time,
+    timezone: args.timezone
+  });
+}
+function daysBetween(left, right) {
+  return Math.floor(
+    (Date.UTC(right.year, right.month - 1, right.day) - Date.UTC(left.year, left.month - 1, left.day)) / (24 * 60 * 60 * 1e3)
+  );
+}
+function weeklyRecurrenceMatchesDate(date, start, recurrence) {
+  if (compareDate(date, start) < 0) {
+    return false;
+  }
+  return normalizeWeekdays(recurrence.weekdays).includes(
+    getLocalDateWeekday(date)
+  ) && Math.floor(daysBetween(getWeekStart(start), getWeekStart(date)) / 7) % recurrence.interval === 0;
+}
+function greatestCommonDivisor(left, right) {
+  let a = Math.abs(left);
+  let b = Math.abs(right);
+  while (b !== 0) {
+    [a, b] = [b, a % b];
+  }
+  return a;
+}
+function findNextRunAtMs(args) {
+  const start = parseLocalDate(args.recurrence.startDate);
+  const interval = args.recurrence.interval;
+  if (!start || !Number.isInteger(interval) || interval <= 0) {
+    return void 0;
+  }
+  const searchFrom = compareDate(args.searchFrom, start) < 0 ? start : args.searchFrom;
+  if (args.recurrence.frequency === "daily") {
+    const offsetDays = daysBetween(start, searchFrom);
+    let candidateDate = addDays(
+      start,
+      Math.ceil(offsetDays / interval) * interval
+    );
+    const gregorianCycleDays = 146097;
+    const candidateCount2 = gregorianCycleDays / greatestCommonDivisor(gregorianCycleDays, interval);
+    for (let attempts = 0; attempts < candidateCount2; attempts += 1) {
+      const candidate = buildCandidate({
+        date: candidateDate,
+        recurrence: args.recurrence,
+        timezone: args.timezone
+      });
+      if (candidate !== void 0 && candidate > args.afterMs) {
+        return candidate;
+      }
+      candidateDate = addDays(candidateDate, interval);
     }
-    timestampMs = next;
+    return void 0;
   }
-  return timestampMs;
+  if (args.recurrence.frequency === "weekly") {
+    if (normalizeWeekdays(args.recurrence.weekdays).length === 0) {
+      return void 0;
+    }
+    let candidateDate = searchFrom;
+    const gregorianCycleDays = 146097;
+    const cadenceDays = interval * 7;
+    const searchDays = gregorianCycleDays * cadenceDays / greatestCommonDivisor(gregorianCycleDays, cadenceDays);
+    for (let attempts = 0; attempts < searchDays; attempts += 1) {
+      if (weeklyRecurrenceMatchesDate(candidateDate, start, args.recurrence)) {
+        const candidate = buildCandidate({
+          date: candidateDate,
+          recurrence: args.recurrence,
+          timezone: args.timezone
+        });
+        if (candidate !== void 0 && candidate > args.afterMs) {
+          return candidate;
+        }
+      }
+      candidateDate = addDays(candidateDate, 1);
+    }
+    return void 0;
+  }
+  if (args.recurrence.frequency === "monthly") {
+    const startMonth = start.year * 12 + start.month - 1;
+    const searchMonth = searchFrom.year * 12 + searchFrom.month - 1;
+    let candidateMonth = startMonth + Math.ceil((searchMonth - startMonth) / interval) * interval;
+    const gregorianCycleMonths = 4800;
+    const candidateCount2 = gregorianCycleMonths / greatestCommonDivisor(gregorianCycleMonths, interval);
+    for (let attempts = 0; attempts < candidateCount2; attempts += 1) {
+      const candidateDate = {
+        year: Math.floor(candidateMonth / 12),
+        month: candidateMonth % 12 + 1,
+        day: args.recurrence.dayOfMonth ?? 0
+      };
+      if (compareDate(candidateDate, searchFrom) >= 0) {
+        const candidate = buildCandidate({
+          date: candidateDate,
+          recurrence: args.recurrence,
+          timezone: args.timezone
+        });
+        if (candidate !== void 0 && candidate > args.afterMs) {
+          return candidate;
+        }
+      }
+      candidateMonth += interval;
+    }
+    return void 0;
+  }
+  let candidateYear = start.year + Math.ceil((searchFrom.year - start.year) / interval) * interval;
+  const candidateCount = 400 / greatestCommonDivisor(400, interval);
+  for (let attempts = 0; attempts < candidateCount; attempts += 1) {
+    const candidateDate = {
+      year: candidateYear,
+      month: args.recurrence.month ?? 0,
+      day: args.recurrence.dayOfMonth ?? 0
+    };
+    if (compareDate(candidateDate, searchFrom) >= 0) {
+      const candidate = buildCandidate({
+        date: candidateDate,
+        recurrence: args.recurrence,
+        timezone: args.timezone
+      });
+      if (candidate !== void 0 && candidate > args.afterMs) {
+        return candidate;
+      }
+    }
+    candidateYear += interval;
+  }
+  return void 0;
+}
+function getFirstRunAtMs(args) {
+  return findNextRunAtMs({
+    ...args,
+    searchFrom: getLocalDate(args.afterMs, args.timezone)
+  });
 }
 function compareDate(left, right) {
   return Date.UTC(left.year, left.month - 1, left.day) - Date.UTC(right.year, right.month - 1, right.day);
@@ -146,13 +277,6 @@ function parseLocalDate(value) {
   }
   return { year, month, day };
 }
-function formatLocalDate(date) {
-  return [
-    String(date.year).padStart(4, "0"),
-    String(date.month).padStart(2, "0"),
-    String(date.day).padStart(2, "0")
-  ].join("-");
-}
 function getLocalDate(timestampMs, timezone) {
   const parts = getZonedDateTimeParts(timestampMs, timezone);
   return { year: parts.year, month: parts.month, day: parts.day };
@@ -169,168 +293,6 @@ function buildCandidate(args) {
     timezone: args.timezone
   });
 }
-function getDailyNextRunAtMs(args) {
-  const start = parseLocalDate(args.recurrence.startDate);
-  if (!start) {
-    return void 0;
-  }
-  let candidateDate = addDays(
-    getLocalDate(args.scheduledForMs, args.timezone),
-    args.recurrence.interval
-  );
-  if (compareDate(candidateDate, start) < 0) {
-    candidateDate = start;
-  }
-  let candidate = buildCandidate({
-    date: candidateDate,
-    recurrence: args.recurrence,
-    timezone: args.timezone
-  });
-  while (candidate <= args.afterMs) {
-    candidateDate = addDays(candidateDate, args.recurrence.interval);
-    candidate = buildCandidate({
-      date: candidateDate,
-      recurrence: args.recurrence,
-      timezone: args.timezone
-    });
-  }
-  return candidate;
-}
-function getWeeklyNextRunAtMs(args) {
-  const start = parseLocalDate(args.recurrence.startDate);
-  if (!start) {
-    return void 0;
-  }
-  const weekdays = normalizeWeekdays(args.recurrence.weekdays);
-  if (weekdays.length === 0) {
-    return void 0;
-  }
-  let candidateDate = addDays(
-    getLocalDate(args.scheduledForMs, args.timezone),
-    1
-  );
-  for (let attempts = 0; attempts < 3660; attempts += 1) {
-    const weeksSinceStart = Math.floor(
-      (Date.UTC(
-        candidateDate.year,
-        candidateDate.month - 1,
-        candidateDate.day
-      ) - Date.UTC(start.year, start.month - 1, start.day)) / (7 * 24 * 60 * 60 * 1e3)
-    );
-    const isInCycle = weeksSinceStart >= 0 && weeksSinceStart % args.recurrence.interval === 0;
-    if (isInCycle && weekdays.includes(getLocalDateWeekday(candidateDate))) {
-      const candidate = buildCandidate({
-        date: candidateDate,
-        recurrence: args.recurrence,
-        timezone: args.timezone
-      });
-      if (candidate > args.afterMs) {
-        return candidate;
-      }
-    }
-    candidateDate = addDays(candidateDate, 1);
-  }
-  return void 0;
-}
-function getMonthlyNextRunAtMs(args) {
-  const start = parseLocalDate(args.recurrence.startDate);
-  const dayOfMonth = args.recurrence.dayOfMonth;
-  if (!start || !dayOfMonth) {
-    return void 0;
-  }
-  const scheduledDate = getLocalDate(args.scheduledForMs, args.timezone);
-  let monthIndex = scheduledDate.year * 12 + scheduledDate.month - 1;
-  const startMonthIndex = start.year * 12 + start.month - 1;
-  for (let attempts = 0; attempts < 1200; attempts += 1) {
-    monthIndex += args.recurrence.interval;
-    if (monthIndex < startMonthIndex) {
-      monthIndex = startMonthIndex;
-    }
-    const year = Math.floor(monthIndex / 12);
-    const month = monthIndex % 12 + 1;
-    if (dayOfMonth > daysInMonth(year, month)) {
-      continue;
-    }
-    const candidate = buildCandidate({
-      date: { year, month, day: dayOfMonth },
-      recurrence: args.recurrence,
-      timezone: args.timezone
-    });
-    if (candidate > args.afterMs) {
-      return candidate;
-    }
-  }
-  return void 0;
-}
-function getYearlyNextRunAtMs(args) {
-  const start = parseLocalDate(args.recurrence.startDate);
-  const month = args.recurrence.month;
-  const dayOfMonth = args.recurrence.dayOfMonth;
-  if (!start || !month || !dayOfMonth) {
-    return void 0;
-  }
-  const scheduledDate = getLocalDate(args.scheduledForMs, args.timezone);
-  let year = scheduledDate.year;
-  for (let attempts = 0; attempts < 100; attempts += 1) {
-    year += args.recurrence.interval;
-    if (year < start.year) {
-      year = start.year;
-    }
-    if (dayOfMonth > daysInMonth(year, month)) {
-      continue;
-    }
-    const candidate = buildCandidate({
-      date: { year, month, day: dayOfMonth },
-      recurrence: args.recurrence,
-      timezone: args.timezone
-    });
-    if (candidate > args.afterMs) {
-      return candidate;
-    }
-  }
-  return void 0;
-}
-function buildCalendarRecurrence(args) {
-  const interval = args.interval && args.interval > 0 ? args.interval : 1;
-  const parts = getZonedDateTimeParts(args.nextRunAtMs, args.timezone);
-  const time = { hour: parts.hour, minute: parts.minute };
-  const startDate = formatLocalDate(parts);
-  if (args.frequency === "weekly") {
-    const weekdays = normalizeWeekdays(args.weekdays);
-    return {
-      frequency: args.frequency,
-      interval,
-      startDate,
-      time,
-      weekdays: weekdays.length > 0 ? weekdays : [parts.weekday]
-    };
-  }
-  if (args.frequency === "monthly") {
-    return {
-      dayOfMonth: parts.day,
-      frequency: args.frequency,
-      interval,
-      startDate,
-      time
-    };
-  }
-  if (args.frequency === "yearly") {
-    return {
-      dayOfMonth: parts.day,
-      frequency: args.frequency,
-      interval,
-      month: parts.month,
-      startDate,
-      time
-    };
-  }
-  return {
-    frequency: args.frequency,
-    interval,
-    startDate,
-    time
-  };
-}
 function getNextRunAtMs(task, scheduledForMs, afterMs = scheduledForMs) {
   if (task.schedule.kind !== "recurring") {
     return void 0;
@@ -339,35 +301,14 @@ function getNextRunAtMs(task, scheduledForMs, afterMs = scheduledForMs) {
   if (!recurrence || !Number.isFinite(recurrence.interval) || recurrence.interval <= 0) {
     return void 0;
   }
-  if (recurrence.frequency === "daily") {
-    return getDailyNextRunAtMs({
-      recurrence,
-      timezone: task.schedule.timezone,
-      scheduledForMs,
-      afterMs
-    });
-  }
-  if (recurrence.frequency === "weekly") {
-    return getWeeklyNextRunAtMs({
-      recurrence,
-      timezone: task.schedule.timezone,
-      scheduledForMs,
-      afterMs
-    });
-  }
-  if (recurrence.frequency === "monthly") {
-    return getMonthlyNextRunAtMs({
-      recurrence,
-      timezone: task.schedule.timezone,
-      scheduledForMs,
-      afterMs
-    });
-  }
-  return getYearlyNextRunAtMs({
+  const timezone = task.schedule.timezone;
+  const afterDate = getLocalDate(afterMs, timezone);
+  const nextScheduledDate = addDays(getLocalDate(scheduledForMs, timezone), 1);
+  return findNextRunAtMs({
+    afterMs,
     recurrence,
-    timezone: task.schedule.timezone,
-    scheduledForMs,
-    afterMs
+    searchFrom: compareDate(afterDate, nextScheduledDate) < 0 ? nextScheduledDate : afterDate,
+    timezone
   });
 }
 
@@ -538,11 +479,12 @@ function buildRunId(taskId, scheduledForMs) {
 function unique(values) {
   return [...new Set(values.filter(Boolean))];
 }
+var schedulerTaskIndexSchema = z2.array(z2.string().min(1));
+function parseStringIndex(value) {
+  return value === void 0 ? [] : schedulerTaskIndexSchema.parse(value);
+}
 async function getIndex(state, key) {
-  const values = await state.get(key) ?? [];
-  return unique(
-    values.filter((value) => typeof value === "string")
-  );
+  return unique(parseStringIndex(await state.get(key)));
 }
 function isFinishedRun(run) {
   return run.status === "completed" || run.status === "failed" || run.status === "blocked" || run.status === "skipped";
@@ -798,6 +740,17 @@ var SqlSchedulerStore = class {
     this.db = db;
   }
   db;
+  async createTask(task) {
+    const next = requireStoredTask(task);
+    return await withSqlLock(this.db, taskLockKey(task.id), async (db) => {
+      const current = await getTaskFromSql(db, task.id);
+      if (current) {
+        return current;
+      }
+      await this.saveTaskRecord(db, next, void 0);
+      return next;
+    });
+  }
   async saveTask(task) {
     const next = requireStoredTask(task);
     await withSqlLock(this.db, taskLockKey(task.id), async (db) => {
@@ -1181,55 +1134,304 @@ function scheduledTaskPrincipalLabel(principal) {
 
 // src/tools/create-task.ts
 import { definePluginTool } from "@sentry/junior-plugin-api";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
+
+// src/schedule-intent.ts
+import { z as z3 } from "zod";
+var localDateSchema = z3.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Use a local date in YYYY-MM-DD format.");
+var localTimeSchema = z3.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "Use local time in HH:MM format.");
+var timezoneSchema = z3.string().min(1).max(80).describe(
+  "IANA timezone, for example America/Los_Angeles. Omit or use null for the scheduler default."
+).nullable().optional();
+var weekdaySchema = z3.enum([
+  "sunday",
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday"
+]);
+var oneOffScheduleIntentSchema = z3.object({
+  kind: z3.literal("one_off").describe("A schedule that runs once."),
+  timezone: timezoneSchema,
+  timing: z3.discriminatedUnion("type", [
+    z3.object({
+      type: z3.literal("after").describe("Run after a relative delay from the server clock."),
+      value: z3.number().int().positive().max(1e5),
+      unit: z3.enum(["second", "minute", "hour", "day", "week"])
+    }).strict(),
+    z3.object({
+      type: z3.literal("at").describe("Run at an explicit local calendar date and time."),
+      date: localDateSchema.describe(
+        "Requested local calendar date in YYYY-MM-DD format."
+      ),
+      time: localTimeSchema.describe(
+        "Requested local wall-clock time in HH:MM format."
+      )
+    }).strict()
+  ]).describe("Relative delay or explicit local time for the one-off run.")
+}).strict();
+var recurringScheduleIntentSchema = z3.object({
+  kind: z3.literal("recurring").describe("A repeating calendar schedule."),
+  frequency: z3.enum(["daily", "weekly", "monthly", "yearly"]).describe("Recurring tasks can run at most once per day."),
+  interval: z3.number().int().positive().max(365).describe("Repeat every N frequency units. Defaults to 1.").nullable().optional(),
+  time: localTimeSchema.describe(
+    "Local wall-clock time for each occurrence in HH:MM format."
+  ),
+  weekdays: z3.array(weekdaySchema).min(1).max(7).describe("Required for weekly schedules.").nullable().optional(),
+  day_of_month: z3.number().int().min(1).max(31).describe("Required for monthly and yearly schedules.").nullable().optional(),
+  month: z3.number().int().min(1).max(12).describe("Required for yearly schedules, where January is 1.").nullable().optional(),
+  start_date: localDateSchema.describe(
+    "Optional local calendar date that anchors the recurrence. Omit to start with the next matching occurrence."
+  ).nullable().optional(),
+  timezone: timezoneSchema
+}).strict().superRefine((schedule, context) => {
+  if (schedule.frequency === "weekly" && schedule.weekdays == null) {
+    context.addIssue({
+      code: "custom",
+      message: "Weekly schedules require weekdays.",
+      path: ["weekdays"]
+    });
+  }
+  if ((schedule.frequency === "monthly" || schedule.frequency === "yearly") && schedule.day_of_month == null) {
+    context.addIssue({
+      code: "custom",
+      message: `${schedule.frequency} schedules require day_of_month.`,
+      path: ["day_of_month"]
+    });
+  }
+  if (schedule.frequency === "yearly" && schedule.month == null) {
+    context.addIssue({
+      code: "custom",
+      message: "Yearly schedules require month.",
+      path: ["month"]
+    });
+  }
+  if (schedule.frequency !== "weekly" && schedule.weekdays != null) {
+    context.addIssue({
+      code: "custom",
+      message: "weekdays applies only to weekly schedules.",
+      path: ["weekdays"]
+    });
+  }
+  if (schedule.frequency !== "monthly" && schedule.frequency !== "yearly" && schedule.day_of_month != null) {
+    context.addIssue({
+      code: "custom",
+      message: "day_of_month applies only to monthly or yearly schedules.",
+      path: ["day_of_month"]
+    });
+  }
+  if (schedule.frequency !== "yearly" && schedule.month != null) {
+    context.addIssue({
+      code: "custom",
+      message: "month applies only to yearly schedules.",
+      path: ["month"]
+    });
+  }
+});
+var scheduleIntentSchema = z3.union([
+  oneOffScheduleIntentSchema,
+  recurringScheduleIntentSchema
+]);
+var WEEKDAY_INDEX = {
+  sunday: 0,
+  monday: 1,
+  tuesday: 2,
+  wednesday: 3,
+  thursday: 4,
+  friday: 5,
+  saturday: 6
+};
+var DURATION_MS = {
+  second: 1e3,
+  minute: 60 * 1e3,
+  hour: 60 * 60 * 1e3,
+  day: 24 * 60 * 60 * 1e3,
+  week: 7 * 24 * 60 * 60 * 1e3
+};
+function parseLocalTime(value) {
+  const [hour, minute] = value.split(":").map(Number);
+  return { hour, minute };
+}
+function localDateAt(timestampMs, timezone) {
+  const parts = getZonedDateTimeParts(timestampMs, timezone);
+  return [parts.year, parts.month, parts.day].map(
+    (value, index2) => index2 === 0 ? String(value).padStart(4, "0") : String(value).padStart(2, "0")
+  ).join("-");
+}
+function isValidTimeZone(timezone) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: timezone }).format();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function plural(value, unit) {
+  return value === 1 ? unit : `${unit}s`;
+}
+function formatWeekdays(weekdays) {
+  const labels = weekdays.map(
+    (weekday) => `${weekday[0].toUpperCase()}${weekday.slice(1)}`
+  );
+  if (labels.length < 2) {
+    return labels[0] ?? "";
+  }
+  return `${labels.slice(0, -1).join(", ")} and ${labels.at(-1)}`;
+}
+function recurringDescription(schedule, timezone) {
+  const interval = schedule.interval ?? 1;
+  const cadenceUnit = {
+    daily: "day",
+    weekly: "week",
+    monthly: "month",
+    yearly: "year"
+  }[schedule.frequency];
+  const cadence = interval === 1 ? cadenceUnit : `${interval} ${cadenceUnit}s`;
+  let detail = "";
+  if (schedule.frequency === "weekly") {
+    detail = ` on ${formatWeekdays(schedule.weekdays)}`;
+  } else if (schedule.frequency === "monthly") {
+    detail = ` on day ${schedule.day_of_month}`;
+  } else if (schedule.frequency === "yearly") {
+    detail = ` on ${String(schedule.month).padStart(2, "0")}-${String(
+      schedule.day_of_month
+    ).padStart(2, "0")}`;
+  }
+  return `Every ${cadence}${detail} at ${schedule.time} (${timezone})`;
+}
+var ScheduleIntentError = class extends Error {
+};
+function compileScheduleIntent(args) {
+  const timezone = args.intent.timezone ?? args.defaultTimezone;
+  if (!isValidTimeZone(timezone)) {
+    throw new ScheduleIntentError("timezone must be a valid IANA time zone.");
+  }
+  if (args.intent.kind === "one_off") {
+    if (args.intent.timing.type === "after") {
+      const nextRunAtMs3 = args.nowMs + args.intent.timing.value * DURATION_MS[args.intent.timing.unit];
+      return {
+        nextRunAtMs: nextRunAtMs3,
+        schedule: {
+          description: `In ${args.intent.timing.value} ${plural(
+            args.intent.timing.value,
+            args.intent.timing.unit
+          )}`,
+          kind: "one_off",
+          timezone
+        }
+      };
+    }
+    const nextRunAtMs2 = resolveLocalScheduleAtMs({
+      date: args.intent.timing.date,
+      time: parseLocalTime(args.intent.timing.time),
+      timezone
+    });
+    if (nextRunAtMs2 === void 0) {
+      throw new ScheduleIntentError(
+        "The requested local date or time does not exist in that timezone."
+      );
+    }
+    if (nextRunAtMs2 <= args.nowMs) {
+      throw new ScheduleIntentError(
+        "The requested one-off schedule must be in the future."
+      );
+    }
+    return {
+      nextRunAtMs: nextRunAtMs2,
+      schedule: {
+        description: `Once on ${args.intent.timing.date} at ${args.intent.timing.time} (${timezone})`,
+        kind: "one_off",
+        timezone
+      }
+    };
+  }
+  const recurrence = {
+    frequency: args.intent.frequency,
+    interval: args.intent.interval ?? 1,
+    startDate: args.intent.start_date ?? localDateAt(args.nowMs, timezone),
+    time: parseLocalTime(args.intent.time),
+    ...args.intent.frequency === "weekly" ? {
+      weekdays: [
+        ...new Set(
+          args.intent.weekdays.map((weekday) => WEEKDAY_INDEX[weekday])
+        )
+      ].sort((left, right) => left - right)
+    } : {},
+    ...args.intent.frequency === "monthly" || args.intent.frequency === "yearly" ? { dayOfMonth: args.intent.day_of_month ?? void 0 } : {},
+    ...args.intent.frequency === "yearly" ? { month: args.intent.month ?? void 0 } : {}
+  };
+  const searchRecurrence = args.intent.start_date ? recurrence : { ...recurrence, interval: 1 };
+  const nextRunAtMs = getFirstRunAtMs({
+    afterMs: args.nowMs,
+    recurrence: searchRecurrence,
+    timezone
+  });
+  if (nextRunAtMs === void 0) {
+    throw new ScheduleIntentError(
+      "The recurring schedule has no valid future occurrence."
+    );
+  }
+  const materializedRecurrence = args.intent.start_date ? recurrence : { ...recurrence, startDate: localDateAt(nextRunAtMs, timezone) };
+  return {
+    nextRunAtMs,
+    schedule: {
+      description: recurringDescription(args.intent, timezone),
+      kind: "recurring",
+      recurrence: materializedRecurrence,
+      timezone
+    }
+  };
+}
 
 // src/tool-support.ts
-import { randomUUID } from "crypto";
+import { createHash } from "crypto";
 import {
   PluginToolInputError,
   pluginToolResultSchema,
   sourceSchema
 } from "@sentry/junior-plugin-api";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var TASK_ID_PREFIX = "sched";
 var MAX_LISTED_TASKS = 50;
 var DEFAULT_SCHEDULE_TIMEZONE = "America/Los_Angeles";
-var compactTaskResultSchema = z3.object({
-  id: z3.string(),
-  status: z3.enum(["active", "paused", "blocked", "deleted"]),
-  task: z3.string(),
-  schedule: z3.string(),
-  timezone: z3.string(),
-  recurrence: z3.unknown().nullable(),
-  next_run_at: z3.string().nullable(),
-  conversation_access: z3.unknown().nullable(),
-  credential_mode: z3.enum(["system", "creator"]),
-  last_run_at: z3.string().nullable(),
-  run_now_at: z3.string().nullable()
+var compactTaskResultSchema = z4.object({
+  id: z4.string(),
+  status: z4.enum(["active", "paused", "blocked", "deleted"]),
+  task: z4.string(),
+  schedule: z4.string(),
+  timezone: z4.string(),
+  recurrence: z4.unknown().nullable(),
+  next_run_at: z4.string().nullable(),
+  conversation_access: z4.unknown().nullable(),
+  credential_mode: z4.enum(["system", "creator"]),
+  last_run_at: z4.string().nullable(),
+  run_now_at: z4.string().nullable()
 }).strict();
-var scheduleTaskResultDataSchema = z3.object({
-  ok: z3.literal(true),
+var scheduleTaskResultDataSchema = z4.object({
+  ok: z4.literal(true),
   task: compactTaskResultSchema
 }).strict();
 var scheduleTaskToolResultSchema = pluginToolResultSchema.extend({
-  ok: z3.literal(true),
-  status: z3.literal("success"),
-  target: z3.string(),
+  ok: z4.literal(true),
+  status: z4.literal("success"),
+  target: z4.string(),
   data: scheduleTaskResultDataSchema,
   task: compactTaskResultSchema
 });
-var scheduleListResultDataSchema = z3.object({
-  ok: z3.literal(true),
-  tasks: z3.array(compactTaskResultSchema),
-  truncated: z3.boolean()
+var scheduleListResultDataSchema = z4.object({
+  ok: z4.literal(true),
+  tasks: z4.array(compactTaskResultSchema),
+  truncated: z4.boolean()
 }).strict();
 var scheduleListToolResultSchema = pluginToolResultSchema.extend({
-  ok: z3.literal(true),
-  status: z3.literal("success"),
-  target: z3.string(),
+  ok: z4.literal(true),
+  status: z4.literal("success"),
+  target: z4.string(),
   data: scheduleListResultDataSchema,
-  tasks: z3.array(compactTaskResultSchema),
-  truncated: z3.boolean()
+  tasks: z4.array(compactTaskResultSchema),
+  truncated: z4.boolean()
 });
 function throwToolInputError(error) {
   throw new PluginToolInputError(error);
@@ -1363,8 +1565,21 @@ function scheduleListToolResult(args) {
     truncated: args.truncated
   };
 }
-function buildTaskId() {
-  return `${TASK_ID_PREFIX}_${randomUUID()}`;
+function buildTaskId(args) {
+  const toolCallId = args.toolCallId?.trim();
+  if (!toolCallId) {
+    throw new Error("Scheduler task creation requires a tool-call identity.");
+  }
+  const digest = createHash("sha256").update(
+    JSON.stringify({
+      actor: args.actor.slackUserId,
+      channel: args.destination.channelId,
+      operation: toolCallId,
+      platform: args.destination.platform,
+      team: args.destination.teamId
+    })
+  ).digest("hex").slice(0, 32);
+  return `${TASK_ID_PREFIX}_${digest}`;
 }
 function schedulerStore(context) {
   return context.store;
@@ -1375,133 +1590,64 @@ function normalizeStatus(value) {
   }
   return void 0;
 }
-function normalizeFrequency(value) {
-  if (value === "daily" || value === "weekly" || value === "monthly" || value === "yearly") {
-    return value;
-  }
-  return void 0;
-}
-function buildRecurrence(args) {
-  if (args.input.recurrence === null) {
-    return void 0;
-  }
-  const frequency = normalizeFrequency(args.input.recurrence) ?? args.existing?.frequency;
-  if (!frequency) {
-    return void 0;
-  }
-  if (!args.nextRunAtMs) {
-    throwToolInputError("Recurring scheduled tasks require next_run_at.");
-  }
-  try {
-    return buildCalendarRecurrence({
-      frequency,
-      interval: args.existing?.interval,
-      nextRunAtMs: args.nextRunAtMs,
-      timezone: args.timezone,
-      weekdays: frequency === "weekly" ? args.existing?.weekdays : void 0
-    });
-  } catch (error) {
-    throwToolInputError(
-      error instanceof RangeError ? "timezone must be a valid IANA time zone." : error instanceof Error ? error.message : String(error)
-    );
-  }
-}
-function validateRecurringFrequencyLimit(input) {
-  if (input.recurrence !== void 0 && input.recurrence !== null && !normalizeFrequency(input.recurrence)) {
-    throwToolInputError(
-      "Recurring scheduled tasks can run at most once per day."
-    );
-  }
-}
-function validateCreateScheduleKind(input) {
-  if (input.schedule_kind === void 0) {
-    throwToolInputError("Provide schedule_kind as one_off or recurring.");
-  }
-  if (input.schedule_kind !== "one_off" && input.schedule_kind !== "recurring") {
-    throwToolInputError("schedule_kind must be one_off or recurring.");
-  }
-  if (input.schedule_kind === "one_off" && input.recurrence !== void 0 && input.recurrence !== null) {
-    throwToolInputError("Omit recurrence when schedule_kind is one_off.");
-  }
-  if (input.schedule_kind === "recurring" && (input.recurrence === void 0 || input.recurrence === null)) {
-    throwToolInputError("Provide recurrence when schedule_kind is recurring.");
-  }
-}
-function shouldRebuildRecurrence(input) {
-  return input.next_run_at !== void 0 || input.recurrence !== void 0 || input.timezone !== void 0;
-}
 function getDefaultScheduleTimezone() {
   return process.env.JUNIOR_TIMEZONE?.trim() || DEFAULT_SCHEDULE_TIMEZONE;
 }
-function isValidTimeZone(timezone) {
-  try {
-    new Intl.DateTimeFormat("en-US", { timeZone: timezone }).format();
-    return true;
-  } catch {
-    return false;
-  }
-}
-function parseNextRunAtMs(nextRunAtIso) {
-  try {
-    if (nextRunAtIso) {
-      return parseScheduleTimestamp(nextRunAtIso);
-    }
-  } catch {
-    return void 0;
-  }
-  return void 0;
-}
 
 // src/tools/create-task.ts
 function createSlackScheduleCreateTaskTool(context) {
   return definePluginTool({
-    description: "Create a one-time or recurring Junior task in the active Slack conversation. For one-time reminders or one-time scheduled work, omit recurrence entirely; never choose a default recurrence. Use only when the user explicitly asks Junior to do work later or on a recurring cadence. Do not create scheduled polling tasks to watch provider resources when a subscribable tool result can deliver the requested events. Only manage tasks for the active Slack DM or channel; never target threads, other channels, or another user's DM. Set credential_mode to creator only when the current user explicitly authorizes future scheduled use of their connected credentials. If connected-credential use is needed but authorization is ambiguous, ask before creating the task. Otherwise omit credential_mode and use system credentials. When the task, schedule, destination, and credential mode are clear, create it without another confirmation.",
+    description: "Create a one-time or recurring Junior task in the active Slack conversation when the user asks Junior to do work later or repeatedly.",
     executionMode: "sequential",
-    inputSchema: z4.object({
-      task: z4.string().min(1).max(4e3),
-      schedule: z4.string().min(1).max(300),
-      schedule_kind: z4.enum(["one_off", "recurring"]).describe(
-        "Required schedule classification. Use one_off for one-time reminders or one-time scheduled work. Use recurring only when the user explicitly asks for a repeating schedule."
+    inputSchema: z5.object({
+      task: z5.string().min(1).max(4e3),
+      schedule: scheduleIntentSchema.describe(
+        "When the task runs. The scheduler computes the exact next run from this intent and the server clock."
       ),
-      timezone: z4.string().min(1).max(80).describe(
-        "IANA timezone, e.g. 'America/Los_Angeles'. Defaults to the channel's configured timezone."
-      ).optional(),
-      next_run_at: z4.string().min(1).describe(
-        "Exact next run time as an ISO timestamp, computed from the user's requested schedule."
-      ).optional(),
-      recurrence: z4.enum(["daily", "weekly", "monthly", "yearly"]).nullable().describe(
-        "Required when schedule_kind is recurring. Omit when schedule_kind is one_off. Recurring tasks run at most once per day: use daily, weekly, monthly, or yearly only."
-      ).optional(),
-      credential_mode: z4.enum(["system", "creator"]).nullable().describe(
+      credential_mode: z5.enum(["system", "creator"]).nullable().describe(
         "Use creator only when the current user explicitly authorizes future scheduled use of their connected credentials. Omit or use system otherwise."
       ).optional()
-    }),
+    }).strict(),
     outputSchema: scheduleTaskToolResultSchema,
-    execute: async (input) => {
+    execute: async (input, options) => {
       const destination = requireActiveConversation(context);
       const actor = requireActor(context, destination);
-      const nowMs = Date.now();
-      const timezone = input.timezone ?? getDefaultScheduleTimezone();
-      validateCreateScheduleKind(input);
-      validateRecurringFrequencyLimit(input);
-      if (!isValidTimeZone(timezone)) {
-        throwToolInputError("timezone must be a valid IANA time zone.");
+      const store = schedulerStore(context);
+      const id = buildTaskId({
+        actor,
+        destination,
+        toolCallId: options.toolCallId
+      });
+      const existing = await store.getTask(id);
+      if (existing) {
+        if (!sameDestination(existing, destination) || existing.createdBy.slackUserId !== actor.slackUserId) {
+          throwToolInputError("Scheduled task operation identity is invalid.");
+        }
+        return scheduleTaskToolResult(
+          "slackScheduleCreateTask",
+          compactTask(existing)
+        );
       }
-      const nextRunAtMs = parseNextRunAtMs(input.next_run_at);
-      if (!nextRunAtMs) {
-        throwToolInputError("Provide next_run_at as a valid ISO timestamp.");
+      const nowMs = context.now?.() ?? Date.now();
+      let compiled;
+      try {
+        compiled = compileScheduleIntent({
+          defaultTimezone: getDefaultScheduleTimezone(),
+          intent: input.schedule,
+          nowMs
+        });
+      } catch (error) {
+        if (error instanceof ScheduleIntentError) {
+          throwToolInputError(error.message);
+        }
+        throw error;
       }
-      const recurrence = buildRecurrence({
-        input,
-        nextRunAtMs,
-        timezone
-      });
       const conversationAccess = getConversationAccess(
         destination,
         context.source
       );
       const task = {
-        id: buildTaskId(),
+        id,
         createdAtMs: nowMs,
         updatedAtMs: nowMs,
         createdBy: actor,
@@ -1509,23 +1655,21 @@ function createSlackScheduleCreateTaskTool(context) {
         credentialMode: input.credential_mode ?? "system",
         destination,
         executionActor: SCHEDULED_TASK_SYSTEM_ACTOR,
-        nextRunAtMs,
+        nextRunAtMs: compiled.nextRunAtMs,
         originalRequest: context.userText,
-        schedule: {
-          description: input.schedule,
-          timezone,
-          kind: recurrence ? "recurring" : "one_off",
-          recurrence
-        },
+        schedule: compiled.schedule,
         status: "active",
         task: {
           text: input.task
         }
       };
-      await schedulerStore(context).saveTask(task);
+      const committed = await store.createTask(task);
+      if (!sameDestination(committed, destination) || committed.createdBy.slackUserId !== actor.slackUserId) {
+        throwToolInputError("Scheduled task operation identity is invalid.");
+      }
       return scheduleTaskToolResult(
         "slackScheduleCreateTask",
-        compactTask(task)
+        compactTask(committed)
       );
     }
   });
@@ -1533,13 +1677,13 @@ function createSlackScheduleCreateTaskTool(context) {
 
 // src/tools/delete-task.ts
 import { definePluginTool as definePluginTool2 } from "@sentry/junior-plugin-api";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 function createSlackScheduleDeleteTaskTool(context) {
   return definePluginTool2({
     description: "Delete one scheduled Junior task from the active Slack conversation. Use only task IDs returned for this conversation. Do not delete schedules from threads, other channels, or another user's DM.",
     executionMode: "sequential",
-    inputSchema: z5.object({
-      task_id: z5.string().min(1).describe(
+    inputSchema: z6.object({
+      task_id: z6.string().min(1).describe(
         "ID of the task to delete. Must be from this active Slack conversation."
       )
     }),
@@ -1564,12 +1708,12 @@ function createSlackScheduleDeleteTaskTool(context) {
 
 // src/tools/list-tasks.ts
 import { definePluginTool as definePluginTool3 } from "@sentry/junior-plugin-api";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 function createSlackScheduleListTasksTool(context) {
   return definePluginTool3({
     description: "List scheduled Junior tasks for the active Slack conversation. Use when the user asks what is scheduled here, or when task IDs are needed before editing, deleting, or running schedules. Only manages tasks for the active Slack DM or channel.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z6.object({}),
+    inputSchema: z7.object({}),
     outputSchema: scheduleListToolResultSchema,
     execute: async () => {
       const destination = requireActiveConversation(context);
@@ -1591,13 +1735,13 @@ function createSlackScheduleListTasksTool(context) {
 
 // src/tools/run-task-now.ts
 import { definePluginTool as definePluginTool4 } from "@sentry/junior-plugin-api";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 function createSlackScheduleRunTaskNowTool(context) {
   return definePluginTool4({
     description: "Queue an existing active scheduled Junior task to run as soon as possible, without changing its cadence. Use when the user asks to run an existing scheduled task now. Use only task IDs returned for this conversation.",
     executionMode: "sequential",
-    inputSchema: z7.object({
-      task_id: z7.string().min(1).describe(
+    inputSchema: z8.object({
+      task_id: z8.string().min(1).describe(
         "ID of the active task to run now. Must be from this active Slack conversation."
       )
     }),
@@ -1626,29 +1770,26 @@ function createSlackScheduleRunTaskNowTool(context) {
 
 // src/tools/update-task.ts
 import { definePluginTool as definePluginTool5 } from "@sentry/junior-plugin-api";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 function createSlackScheduleUpdateTaskTool(context) {
   return definePluginTool5({
-    description: "Edit, pause, resume, reschedule, or change credential use for an existing Junior scheduled task in the active Slack conversation. Use only task IDs returned for this conversation. Do not move scheduled tasks across conversations. Set credential_mode to creator only when the task creator explicitly authorizes future scheduled use of their connected credentials. If creator credential use is requested but authorization is ambiguous, ask before enabling it. If another user changes the executable task text, creator credential use is cleared automatically.",
+    description: "Edit, pause, resume, reschedule, or change credential use for an existing Junior scheduled task in the active Slack conversation.",
     executionMode: "sequential",
-    inputSchema: z8.object({
-      task_id: z8.string().min(1).describe(
+    inputSchema: z9.object({
+      task_id: z9.string().min(1).describe(
         "ID of the task to update. Must be from this active Slack conversation."
       ),
-      task: z8.string().min(1).max(4e3).optional(),
-      schedule: z8.string().min(1).max(300).optional(),
-      timezone: z8.string().min(1).max(80).optional(),
-      next_run_at: z8.string().min(1).describe("Exact ISO timestamp when changing the next run time.").optional(),
-      recurrence: z8.enum(["daily", "weekly", "monthly", "yearly"]).nullable().describe(
-        "Provide only for repeating schedules. Omit for one-time requests. Set to null to convert a recurring task to one-time."
-      ).optional(),
-      status: z8.enum(["active", "paused", "blocked"]).describe(
+      task: z9.string().min(1).max(4e3).optional(),
+      schedule: scheduleIntentSchema.describe(
+        "Complete replacement schedule when rescheduling. Omit for task, status, or credential-only changes; the scheduler computes the next run."
+      ).nullable().optional(),
+      status: z9.enum(["active", "paused", "blocked"]).describe(
         "Set to active, paused, or blocked to resume, pause, or block the task."
       ).optional(),
-      credential_mode: z8.enum(["system", "creator"]).nullable().describe(
+      credential_mode: z9.enum(["system", "creator"]).nullable().describe(
         "Set creator only when the current actor is the task creator and explicitly authorizes future scheduled credential use. Set system to disable delegation."
       ).optional()
-    }),
+    }).strict(),
     outputSchema: scheduleTaskToolResultSchema,
     execute: async (input) => {
       const lookup = await getWritableTask({
@@ -1662,48 +1803,43 @@ function createSlackScheduleUpdateTaskTool(context) {
           "Only the scheduled task creator can enable creator credential use."
         );
       }
-      const timezone = input.timezone ?? lookup.schedule.timezone;
-      validateRecurringFrequencyLimit(input);
-      if (!isValidTimeZone(timezone)) {
-        throwToolInputError("timezone must be a valid IANA time zone.");
-      }
-      const parsedNextRunAtMs = parseNextRunAtMs(input.next_run_at);
-      const nextRunAtMs = input.next_run_at ? parsedNextRunAtMs : lookup.nextRunAtMs;
-      if (input.next_run_at && !nextRunAtMs) {
-        throwToolInputError("Provide next_run_at as a valid ISO timestamp.");
+      const nowMs = context.now?.() ?? Date.now();
+      let compiled;
+      if (input.schedule) {
+        try {
+          compiled = compileScheduleIntent({
+            defaultTimezone: lookup.schedule.timezone || getDefaultScheduleTimezone(),
+            intent: input.schedule,
+            nowMs
+          });
+        } catch (error) {
+          if (error instanceof ScheduleIntentError) {
+            throwToolInputError(error.message);
+          }
+          throw error;
+        }
       }
+      const nextRunAtMs = compiled?.nextRunAtMs ?? lookup.nextRunAtMs;
       const status = normalizeStatus(input.status);
       if (input.status && !status) {
         throwToolInputError("status must be active, paused, or blocked.");
       }
       if (status === "active" && !nextRunAtMs) {
         throwToolInputError(
-          "Active scheduled tasks require next_run_at when no next run is stored."
+          "Active scheduled tasks require a schedule with a future occurrence."
         );
       }
-      const recurrence = shouldRebuildRecurrence(input) ? buildRecurrence({
-        existing: lookup.schedule.recurrence,
-        input,
-        nextRunAtMs,
-        timezone
-      }) : lookup.schedule.recurrence;
       const nextStatus = status ?? lookup.status;
       const credentialMode = input.task !== void 0 && input.task !== lookup.task.text && !isCreator ? "system" : input.credential_mode ?? lookup.credentialMode;
       const next = {
         ...lookup,
         credentialMode,
-        updatedAtMs: Date.now(),
+        updatedAtMs: nowMs,
         nextRunAtMs,
-        runNowAtMs: nextStatus === "active" ? lookup.runNowAtMs : void 0,
+        runNowAtMs: nextStatus === "active" && !compiled ? lookup.runNowAtMs : void 0,
         status: nextStatus,
         statusReason: nextStatus === "blocked" ? lookup.statusReason : void 0,
-        schedule: {
-          ...lookup.schedule,
-          description: input.schedule ?? lookup.schedule.description,
-          timezone,
-          kind: recurrence ? "recurring" : "one_off",
-          recurrence
-        },
+        schedule: compiled?.schedule ?? lookup.schedule,
         task: input.task ? { text: input.task } : lookup.task
       };
       await schedulerStore(context).saveTask(next);