@sentry/junior-scheduler 0.57.0

package/dist/index.js

@@ -0,0 +1,1655 @@
+// src/plugin.ts
+import {
+  defineJuniorPlugin
+} from "@sentry/junior-plugin-api";
+
+// src/types.ts
+var SCHEDULED_TASK_SYSTEM_ACTOR = Object.freeze({
+  type: "system",
+  id: "scheduled-task"
+});
+
+// src/prompt.ts
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+var EXECUTION_RULES = [
+  "- Execute as the scheduled-task system actor; creator metadata is audit context, not an active user identity.",
+  "- Complete the task without asking follow-up questions unless access, approval, or required input is missing.",
+  "- Use the available tools and skills that are relevant to the task contract.",
+  "- Do not create, edit, or discuss scheduling during this run; the stored schedule already fired.",
+  "- For reminder tasks, deliver the reminder message now instead of explaining how reminders or delayed posts work.",
+  "- If blocked, report the specific missing provider, permission, configuration, or input.",
+  "- Keep the final result shaped for the configured destination audience."
+];
+function renderOptionalLine(name, value) {
+  return value?.trim() ? [`- ${name}: ${escapeXml(value.trim())}`] : [];
+}
+function buildScheduledTaskRunPrompt(args) {
+  const { run, task } = args;
+  const destination = task.destination;
+  const creator = task.createdBy;
+  const executionActor = task.executionActor ?? SCHEDULED_TASK_SYSTEM_ACTOR;
+  if (!task.task.text?.trim()) {
+    throw new Error("Scheduled task text is required");
+  }
+  return [
+    "<scheduled-task-run>",
+    "This is an autonomous scheduled run. Treat the stored task contract as the user request for this turn.",
+    "",
+    "<scheduled-task>",
+    `- id: ${escapeXml(task.id)}`,
+    "<task-text>",
+    escapeXml(task.task.text),
+    "</task-text>",
+    "</scheduled-task>",
+    "",
+    "<run-context>",
+    `- run_id: ${escapeXml(run.id)}`,
+    `- task_version: ${run.taskVersion}`,
+    `- scheduled_for: ${new Date(run.scheduledForMs).toISOString()}`,
+    `- running_at: ${new Date(args.nowMs).toISOString()}`,
+    `- schedule: ${escapeXml(task.schedule.description)}`,
+    `- timezone: ${escapeXml(task.schedule.timezone)}`,
+    `- schedule_kind: ${task.schedule.kind}`,
+    `- execution_actor_type: ${executionActor.type}`,
+    `- execution_actor_id: ${escapeXml(executionActor.id)}`,
+    ...task.schedule.recurrence ? [
+      `- recurrence_frequency: ${task.schedule.recurrence.frequency}`,
+      `- recurrence_interval: ${task.schedule.recurrence.interval}`,
+      `- recurrence_start_date: ${escapeXml(task.schedule.recurrence.startDate)}`
+    ] : [],
+    `- creator_slack_user_id: ${escapeXml(creator.slackUserId)}`,
+    ...renderOptionalLine("creator_user_name", creator.userName),
+    ...renderOptionalLine("creator_full_name", creator.fullName),
+    `- destination_platform: ${destination.platform}`,
+    `- destination_team_id: ${escapeXml(destination.teamId)}`,
+    `- destination_channel_id: ${escapeXml(destination.channelId)}`,
+    "</run-context>",
+    "",
+    "<execution-rules>",
+    ...EXECUTION_RULES,
+    "</execution-rules>",
+    "",
+    '<current-instruction priority="highest">',
+    "Execute the scheduled task now and provide the final result for the configured destination.",
+    "</current-instruction>",
+    "</scheduled-task-run>"
+  ].join("\n");
+}
+
+// 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);
+  if (existing) {
+    return existing;
+  }
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    hour12: false,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  FORMATTERS.set(timezone, formatter);
+  return formatter;
+}
+function normalizeHour(hour) {
+  return hour === 24 ? 0 : hour;
+}
+function getLocalDateWeekday(date) {
+  return new Date(Date.UTC(date.year, date.month - 1, date.day)).getUTCDay();
+}
+function getZonedDateTimeParts(timestampMs, timezone) {
+  const parts = getFormatter(timezone).formatToParts(new Date(timestampMs));
+  const values = new Map(parts.map((part) => [part.type, part.value]));
+  const year = Number(values.get("year"));
+  const month = Number(values.get("month"));
+  const day = Number(values.get("day"));
+  const hour = normalizeHour(Number(values.get("hour")));
+  const minute = Number(values.get("minute"));
+  const second = Number(values.get("second"));
+  return {
+    year,
+    month,
+    day,
+    hour,
+    minute,
+    second,
+    weekday: getLocalDateWeekday({ year, month, day })
+  };
+}
+function getTimeZoneOffsetMs(timestampMs, timezone) {
+  const parts = getZonedDateTimeParts(timestampMs, timezone);
+  return Date.UTC(
+    parts.year,
+    parts.month - 1,
+    parts.day,
+    parts.hour,
+    parts.minute,
+    parts.second
+  ) - timestampMs;
+}
+function localDateTimeToTimestampMs(args) {
+  const localAsUtcMs = Date.UTC(
+    args.date.year,
+    args.date.month - 1,
+    args.date.day,
+    args.time.hour,
+    args.time.minute,
+    0
+  );
+  let timestampMs = localAsUtcMs - getTimeZoneOffsetMs(localAsUtcMs, args.timezone);
+  for (let index = 0; index < 3; index += 1) {
+    const next = localAsUtcMs - getTimeZoneOffsetMs(timestampMs, args.timezone);
+    if (next === timestampMs) {
+      break;
+    }
+    timestampMs = next;
+  }
+  return timestampMs;
+}
+function compareDate(left, right) {
+  return Date.UTC(left.year, left.month - 1, left.day) - Date.UTC(right.year, right.month - 1, right.day);
+}
+function addDays(date, days) {
+  const next = new Date(Date.UTC(date.year, date.month - 1, date.day + days));
+  return {
+    year: next.getUTCFullYear(),
+    month: next.getUTCMonth() + 1,
+    day: next.getUTCDate()
+  };
+}
+function daysInMonth(year, month) {
+  return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+function parseLocalDate(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) {
+    return void 0;
+  }
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day) || month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month)) {
+    return void 0;
+  }
+  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 };
+}
+function normalizeWeekdays(values) {
+  return [
+    ...new Set((values ?? []).filter((value) => value >= 0 && value <= 6))
+  ].sort((a, b) => a - b);
+}
+function buildCandidate(args) {
+  return localDateTimeToTimestampMs({
+    date: args.date,
+    time: args.recurrence.time,
+    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;
+  }
+  const recurrence = task.schedule.recurrence;
+  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({
+    recurrence,
+    timezone: task.schedule.timezone,
+    scheduledForMs,
+    afterMs
+  });
+}
+
+// src/store.ts
+var SCHEDULER_KEY_PREFIX = "junior:scheduler";
+var SCHEDULER_RECORD_TTL_MS = 5 * 365 * 24 * 60 * 60 * 1e3;
+var SCHEDULED_RUN_TTL_MS = 90 * 24 * 60 * 60 * 1e3;
+var CLAIM_TTL_MS = 6 * 60 * 60 * 1e3;
+var PENDING_CLAIM_STALE_MS = 6e4;
+var MISSED_RUN_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var LOCK_TTL_MS = 1e4;
+function taskKey(taskId) {
+  return `${SCHEDULER_KEY_PREFIX}:task:${taskId}`;
+}
+function taskLockKey(taskId) {
+  return `${taskKey(taskId)}:lock`;
+}
+function runKey(runId) {
+  return `${SCHEDULER_KEY_PREFIX}:run:${runId}`;
+}
+function claimKey(taskId, scheduledForMs) {
+  return `${SCHEDULER_KEY_PREFIX}:claim:${taskId}:${scheduledForMs}`;
+}
+function activeRunKey(taskId) {
+  return `${SCHEDULER_KEY_PREFIX}:active:${taskId}`;
+}
+function globalTaskIndexKey() {
+  return `${SCHEDULER_KEY_PREFIX}:tasks`;
+}
+function teamTaskIndexKey(teamId) {
+  return `${SCHEDULER_KEY_PREFIX}:team:${teamId}:tasks`;
+}
+function indexLockKey(indexKey) {
+  return `${indexKey}:lock`;
+}
+function buildRunId(taskId, scheduledForMs) {
+  return `${taskId}:${scheduledForMs}`;
+}
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+async function withLock(state, key, callback) {
+  return await state.withLock(key, LOCK_TTL_MS, callback);
+}
+async function addToIndex(state, key, taskId) {
+  await withLock(state, indexLockKey(key), async () => {
+    const current = (await state.get(key) ?? []).filter(
+      (value) => typeof value === "string"
+    );
+    await state.set(key, unique([...current, taskId]), SCHEDULER_RECORD_TTL_MS);
+  });
+}
+async function removeFromIndex(state, key, taskId) {
+  await withLock(state, indexLockKey(key), async () => {
+    const current = unique(
+      (await state.get(key) ?? []).filter(
+        (value) => typeof value === "string"
+      )
+    );
+    const next = current.filter((value) => value !== taskId);
+    if (next.length === current.length) {
+      return;
+    }
+    if (next.length === 0) {
+      await state.delete(key);
+      return;
+    }
+    await state.set(key, next, SCHEDULER_RECORD_TTL_MS);
+  });
+}
+async function getIndex(state, key) {
+  const values = await state.get(key) ?? [];
+  return unique(
+    values.filter((value) => typeof value === "string")
+  );
+}
+async function clearActiveRun(state, taskId, runId) {
+  await withLock(state, indexLockKey(activeRunKey(taskId)), async () => {
+    const current = await state.get(activeRunKey(taskId));
+    if (current?.runId === runId) {
+      await state.delete(activeRunKey(taskId));
+    }
+  });
+}
+async function clearStaleActiveRun(state, taskId, nowMs) {
+  const active = await state.get(activeRunKey(taskId));
+  if (typeof active?.runId !== "string") {
+    await state.delete(activeRunKey(taskId));
+    return true;
+  }
+  const activeRun = await state.get(runKey(active.runId)) ?? void 0;
+  if (!isStaleActiveRun(active, activeRun, nowMs)) {
+    return false;
+  }
+  await clearActiveRun(state, taskId, active.runId);
+  if (typeof active.scheduledForMs === "number") {
+    await state.delete(claimKey(taskId, active.scheduledForMs));
+  }
+  return true;
+}
+function isFinishedRun(run) {
+  return run.status === "completed" || run.status === "failed" || run.status === "blocked" || run.status === "skipped";
+}
+function isStaleActiveRun(active, run, nowMs) {
+  if (run) {
+    return isFinishedRun(run) || isStalePendingRun(run, nowMs);
+  }
+  return typeof active.claimedAtMs === "number" && active.claimedAtMs + PENDING_CLAIM_STALE_MS <= nowMs;
+}
+function isStalePendingRun(run, nowMs) {
+  return run?.status === "pending" && run.claimedAtMs + PENDING_CLAIM_STALE_MS <= nowMs;
+}
+function isDueTask(task, nowMs) {
+  return task.status === "active" && (typeof task.runNowAtMs === "number" && Number.isFinite(task.runNowAtMs) && task.runNowAtMs <= nowMs || typeof task.nextRunAtMs === "number" && Number.isFinite(task.nextRunAtMs) && task.nextRunAtMs <= nowMs);
+}
+function getDueRunAtMs(task, nowMs) {
+  if (typeof task.runNowAtMs === "number" && Number.isFinite(task.runNowAtMs) && task.runNowAtMs <= nowMs) {
+    return task.runNowAtMs;
+  }
+  if (typeof task.nextRunAtMs === "number" && Number.isFinite(task.nextRunAtMs) && task.nextRunAtMs <= nowMs) {
+    return task.nextRunAtMs;
+  }
+  return void 0;
+}
+function buildScheduledRun(args) {
+  const idempotencyKey = `${args.task.id}:${args.scheduledForMs}`;
+  return {
+    id: buildRunId(args.task.id, args.scheduledForMs),
+    attempt: 1,
+    claimedAtMs: args.claimedAtMs,
+    idempotencyKey,
+    scheduledForMs: args.scheduledForMs,
+    status: "pending",
+    taskId: args.task.id,
+    taskVersion: args.task.version
+  };
+}
+function buildSkippedScheduledRun(args) {
+  return {
+    ...buildScheduledRun({
+      claimedAtMs: args.completedAtMs,
+      scheduledForMs: args.scheduledForMs,
+      task: args.task
+    }),
+    completedAtMs: args.completedAtMs,
+    errorMessage: args.errorMessage,
+    status: "skipped"
+  };
+}
+function isMissedRunTooOld(args) {
+  return args.scheduledForMs + MISSED_RUN_MAX_AGE_MS < args.nowMs;
+}
+function normalizedText(value) {
+  return value?.trim().replace(/\s+/g, " ").toLowerCase() ?? "";
+}
+function taskDedupeFingerprint(task) {
+  return JSON.stringify({
+    destination: task.destination,
+    schedule: {
+      kind: task.schedule.kind,
+      oneOffAtMs: task.schedule.kind === "one_off" ? task.nextRunAtMs : null,
+      recurrence: task.schedule.recurrence ? {
+        dayOfMonth: task.schedule.recurrence.dayOfMonth ?? null,
+        frequency: task.schedule.recurrence.frequency,
+        interval: task.schedule.recurrence.interval,
+        month: task.schedule.recurrence.month ?? null,
+        startDate: task.schedule.recurrence.startDate,
+        time: task.schedule.recurrence.time,
+        weekdays: [...task.schedule.recurrence.weekdays ?? []].sort()
+      } : null,
+      timezone: task.schedule.timezone
+    },
+    task: normalizedText(task.task.text)
+  });
+}
+function isEarlierTask(left, right) {
+  return left.createdAtMs < right.createdAtMs || left.createdAtMs === right.createdAtMs && left.id < right.id;
+}
+function canFinishRun(run, startedAtMs) {
+  if (run.status === "pending") {
+    return startedAtMs === void 0;
+  }
+  return run.status === "running" && run.startedAtMs === startedAtMs;
+}
+var PluginStateSchedulerStore = class {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  async saveTask(task) {
+    await withLock(this.state, taskLockKey(task.id), async () => {
+      const current = await this.state.get(taskKey(task.id)) ?? void 0;
+      await this.saveTaskRecord(task, current);
+    });
+  }
+  async saveTaskRecord(task, current) {
+    if (current?.status === "blocked" && task.status === "active" && typeof task.nextRunAtMs === "number" && Number.isFinite(task.nextRunAtMs)) {
+      await this.state.delete(claimKey(task.id, task.nextRunAtMs));
+    }
+    await this.state.set(taskKey(task.id), task, SCHEDULER_RECORD_TTL_MS);
+    if (task.status === "deleted") {
+      await removeFromIndex(this.state, globalTaskIndexKey(), task.id);
+      await removeFromIndex(
+        this.state,
+        teamTaskIndexKey(task.destination.teamId),
+        task.id
+      );
+      if (current && current.destination.teamId !== task.destination.teamId) {
+        await removeFromIndex(
+          this.state,
+          teamTaskIndexKey(current.destination.teamId),
+          task.id
+        );
+      }
+      return;
+    }
+    await addToIndex(this.state, globalTaskIndexKey(), task.id);
+    await addToIndex(
+      this.state,
+      teamTaskIndexKey(task.destination.teamId),
+      task.id
+    );
+    if (current && current.destination.teamId !== task.destination.teamId) {
+      await removeFromIndex(
+        this.state,
+        teamTaskIndexKey(current.destination.teamId),
+        task.id
+      );
+    }
+  }
+  async getTask(taskId) {
+    return await this.state.get(taskKey(taskId)) ?? void 0;
+  }
+  async listTasksForTeam(teamId) {
+    const ids = await getIndex(this.state, teamTaskIndexKey(teamId));
+    const tasks = await Promise.all(ids.map((id) => this.getTask(id)));
+    return tasks.filter((task) => Boolean(task)).filter((task) => task.status !== "deleted").sort((a, b) => a.createdAtMs - b.createdAtMs);
+  }
+  async claimDueRun(args) {
+    const ids = await getIndex(this.state, globalTaskIndexKey());
+    for (const id of ids) {
+      const task = await this.getTask(id);
+      if (!task || !isDueTask(task, args.nowMs)) {
+        continue;
+      }
+      const scheduledForMs = getDueRunAtMs(task, args.nowMs);
+      if (scheduledForMs === void 0) {
+        continue;
+      }
+      const runId = buildRunId(task.id, scheduledForMs);
+      const tryClaimActiveRun = async () => await this.state.setIfNotExists(
+        activeRunKey(task.id),
+        { claimedAtMs: args.nowMs, runId, scheduledForMs },
+        CLAIM_TTL_MS
+      );
+      let activeClaimed = await tryClaimActiveRun();
+      if (!activeClaimed) {
+        if (await clearStaleActiveRun(this.state, task.id, args.nowMs)) {
+          activeClaimed = await tryClaimActiveRun();
+        }
+        if (!activeClaimed) {
+          continue;
+        }
+      }
+      if (isMissedRunTooOld({ nowMs: args.nowMs, scheduledForMs })) {
+        await this.skipMissedRun({ nowMs: args.nowMs, scheduledForMs, task });
+        await clearActiveRun(this.state, task.id, runId);
+        continue;
+      }
+      const tryClaimScheduledSlot = async () => await this.state.setIfNotExists(
+        claimKey(task.id, scheduledForMs),
+        { claimedAtMs: args.nowMs },
+        CLAIM_TTL_MS
+      );
+      let claimed = await tryClaimScheduledSlot();
+      if (!claimed) {
+        const existingRun = await this.getRun(runId);
+        if (isStalePendingRun(existingRun, args.nowMs)) {
+          await clearActiveRun(this.state, task.id, runId);
+          await this.state.delete(claimKey(task.id, scheduledForMs));
+          activeClaimed = await tryClaimActiveRun();
+          claimed = activeClaimed ? await tryClaimScheduledSlot() : false;
+        }
+        if (!claimed) {
+          await clearActiveRun(this.state, task.id, runId);
+          continue;
+        }
+      }
+      const run = buildScheduledRun({
+        claimedAtMs: args.nowMs,
+        scheduledForMs,
+        task
+      });
+      await this.state.set(runKey(run.id), run, SCHEDULED_RUN_TTL_MS);
+      return run;
+    }
+    return void 0;
+  }
+  async skipMissedRun(args) {
+    await withLock(this.state, taskLockKey(args.task.id), async () => {
+      const current = await this.state.get(taskKey(args.task.id)) ?? void 0;
+      if (!current || current.status !== "active" || getDueRunAtMs(current, args.nowMs) !== args.scheduledForMs) {
+        return;
+      }
+      const duplicateOf = await this.findStaleRecoveryCanonicalTask(current);
+      const errorMessage = duplicateOf ? `Duplicate stale scheduled task was skipped without dispatch. Canonical task: ${duplicateOf.id}.` : "Scheduled occurrence was more than 24 hours late and was skipped without dispatch.";
+      await this.state.set(
+        runKey(buildRunId(current.id, args.scheduledForMs)),
+        buildSkippedScheduledRun({
+          completedAtMs: args.nowMs,
+          errorMessage,
+          scheduledForMs: args.scheduledForMs,
+          task: current
+        }),
+        SCHEDULED_RUN_TTL_MS
+      );
+      const isRunNow = current.runNowAtMs === args.scheduledForMs;
+      let nextRunAtMs;
+      if (!duplicateOf) {
+        nextRunAtMs = isRunNow && current.nextRunAtMs !== args.scheduledForMs ? current.nextRunAtMs : current.schedule.kind === "recurring" ? getNextRunAtMs(current, args.scheduledForMs, args.nowMs) : void 0;
+      }
+      const nextStatus = nextRunAtMs ? "active" : "paused";
+      await this.saveTaskRecord(
+        {
+          ...current,
+          nextRunAtMs,
+          runNowAtMs: isRunNow ? void 0 : current.runNowAtMs,
+          status: nextStatus,
+          statusReason: nextStatus === "paused" ? errorMessage : void 0,
+          updatedAtMs: args.nowMs,
+          version: current.version + 1
+        },
+        current
+      );
+    });
+  }
+  async findStaleRecoveryCanonicalTask(task) {
+    const fingerprint = taskDedupeFingerprint(task);
+    const ids = await getIndex(
+      this.state,
+      teamTaskIndexKey(task.destination.teamId)
+    );
+    const tasks = await Promise.all(
+      ids.filter((id) => id !== task.id).map((id) => this.getTask(id))
+    );
+    return tasks.filter((candidate) => Boolean(candidate)).filter(
+      (candidate) => candidate.status === "active" && isEarlierTask(candidate, task) && taskDedupeFingerprint(candidate) === fingerprint
+    ).sort((a, b) => a.createdAtMs - b.createdAtMs || a.id.localeCompare(b.id)).at(0);
+  }
+  async getRun(runId) {
+    return await this.state.get(runKey(runId)) ?? void 0;
+  }
+  async listIncompleteRuns() {
+    const ids = await getIndex(this.state, globalTaskIndexKey());
+    const runs = [];
+    for (const taskId of ids) {
+      const active = await this.state.get(
+        activeRunKey(taskId)
+      );
+      if (typeof active?.runId !== "string") {
+        continue;
+      }
+      const run = await this.getRun(active.runId);
+      if (run && !isFinishedRun(run)) {
+        runs.push(run);
+      }
+    }
+    return runs;
+  }
+  async markRunDispatched(args) {
+    return await this.updateRun(
+      args.runId,
+      (run) => run.status === "pending" && run.claimedAtMs === args.claimedAtMs ? {
+        ...run,
+        dispatchId: args.dispatchId,
+        startedAtMs: args.nowMs,
+        status: "running"
+      } : void 0
+    );
+  }
+  async markRunCompleted(args) {
+    const next = await this.updateRun(
+      args.runId,
+      (run) => canFinishRun(run, args.startedAtMs) ? {
+        ...run,
+        completedAtMs: args.completedAtMs,
+        resultMessageTs: args.resultMessageTs,
+        status: "completed"
+      } : void 0
+    );
+    if (next) {
+      await clearActiveRun(this.state, next.taskId, next.id);
+    }
+    return next;
+  }
+  async markRunFailed(args) {
+    const next = await this.updateRun(
+      args.runId,
+      (run) => canFinishRun(run, args.startedAtMs) ? {
+        ...run,
+        completedAtMs: args.completedAtMs,
+        errorMessage: args.errorMessage,
+        status: "failed"
+      } : void 0
+    );
+    if (next) {
+      await clearActiveRun(this.state, next.taskId, next.id);
+    }
+    return next;
+  }
+  async markRunSkipped(args) {
+    const next = await this.updateRun(
+      args.runId,
+      (run) => run.status === "pending" ? {
+        ...run,
+        completedAtMs: args.completedAtMs,
+        errorMessage: args.errorMessage,
+        status: "skipped"
+      } : void 0
+    );
+    if (next) {
+      await clearActiveRun(this.state, next.taskId, next.id);
+    }
+    return next;
+  }
+  async markRunBlocked(args) {
+    const next = await this.updateRun(
+      args.runId,
+      (run) => canFinishRun(run, args.startedAtMs) ? {
+        ...run,
+        completedAtMs: args.completedAtMs,
+        errorMessage: args.errorMessage,
+        status: "blocked"
+      } : void 0
+    );
+    if (next) {
+      await clearActiveRun(this.state, next.taskId, next.id);
+    }
+    return next;
+  }
+  async updateTaskAfterRun(args) {
+    await withLock(this.state, taskLockKey(args.run.taskId), async () => {
+      const current = await this.state.get(taskKey(args.run.taskId)) ?? void 0;
+      if (!current || current.status === "deleted") {
+        return;
+      }
+      const isRunNow = current.runNowAtMs === args.run.scheduledForMs;
+      if (isRunNow) {
+        let nextRunAtMs2 = current.nextRunAtMs;
+        if (args.status !== "blocked" && typeof current.nextRunAtMs === "number" && current.nextRunAtMs <= args.run.scheduledForMs) {
+          nextRunAtMs2 = getNextRunAtMs(
+            current,
+            current.nextRunAtMs,
+            args.nowMs
+          );
+        }
+        await this.saveTaskRecord(
+          {
+            ...current,
+            lastRunAtMs: args.run.scheduledForMs,
+            nextRunAtMs: nextRunAtMs2,
+            runNowAtMs: void 0,
+            status: args.status === "blocked" ? "blocked" : nextRunAtMs2 ? current.status : "paused",
+            statusReason: args.status === "blocked" ? args.errorMessage : void 0,
+            updatedAtMs: args.nowMs,
+            version: current.version + 1
+          },
+          current
+        );
+        return;
+      }
+      if (current.status !== "active" || current.nextRunAtMs !== args.run.scheduledForMs) {
+        await this.saveTaskRecord(
+          {
+            ...current,
+            lastRunAtMs: args.run.scheduledForMs,
+            updatedAtMs: args.nowMs,
+            version: current.version + 1
+          },
+          current
+        );
+        return;
+      }
+      const nextRunAtMs = args.status === "blocked" ? void 0 : getNextRunAtMs(current, args.run.scheduledForMs, args.nowMs);
+      await this.saveTaskRecord(
+        {
+          ...current,
+          lastRunAtMs: args.run.scheduledForMs,
+          nextRunAtMs,
+          status: args.status === "blocked" ? "blocked" : nextRunAtMs ? "active" : "paused",
+          statusReason: args.status === "blocked" ? args.errorMessage : void 0,
+          updatedAtMs: args.nowMs,
+          version: current.version + 1
+        },
+        current
+      );
+    });
+  }
+  async updateRun(runId, update) {
+    return await withLock(this.state, indexLockKey(runKey(runId)), async () => {
+      const current = await this.getRun(runId);
+      if (!current) {
+        return void 0;
+      }
+      const next = update(current);
+      if (!next) {
+        return void 0;
+      }
+      await this.state.set(runKey(runId), next, SCHEDULED_RUN_TTL_MS);
+      return next;
+    });
+  }
+};
+function createSchedulerStore(state) {
+  return new PluginStateSchedulerStore(state);
+}
+
+// src/schedule-tools.ts
+import { randomUUID } from "crypto";
+import { Type } from "@sinclair/typebox";
+import {
+  AgentPluginToolInputError
+} from "@sentry/junior-plugin-api";
+var TASK_ID_PREFIX = "sched";
+var MAX_LISTED_TASKS = 50;
+var DEFAULT_SCHEDULE_TIMEZONE = "America/Los_Angeles";
+var ACTIVE_DESTINATION_GUIDELINE = "Only manage tasks for the active Slack DM or channel; never target an existing thread, another channel, or another user's DM.";
+var ACTIVE_TASK_ID_GUIDELINE = "Use only task IDs returned from this active destination.";
+var RECURRING_GUIDELINE = "Omit recurrence for one-time requests like 'in 1 minute', 'tomorrow', or a specific date; provide recurrence only for requests that explicitly repeat.";
+var recurrenceInputSchema = Type.Union([
+  Type.Literal("daily"),
+  Type.Literal("weekly"),
+  Type.Literal("monthly"),
+  Type.Literal("yearly")
+]);
+function throwToolInputError(error) {
+  throw new AgentPluginToolInputError(error);
+}
+function requireActiveDestination(context) {
+  const channelId = normalizeSlackConversationId(context.channelId);
+  if (!channelId) {
+    throwToolInputError("No active Slack channel context is available.");
+  }
+  if (!context.teamId) {
+    throwToolInputError("No active Slack workspace context is available.");
+  }
+  if (!isSlackTeamId(context.teamId)) {
+    throwToolInputError("Active Slack workspace context is invalid.");
+  }
+  return {
+    platform: "slack",
+    teamId: context.teamId,
+    channelId
+  };
+}
+function requireRequester(context) {
+  const userId = context.requester?.userId;
+  if (!userId) {
+    throwToolInputError("No active Slack requester context is available.");
+  }
+  return {
+    slackUserId: userId,
+    ...context.requester?.userName ? { userName: context.requester.userName } : {},
+    ...context.requester?.fullName ? { fullName: context.requester.fullName } : {}
+  };
+}
+function tool(definition) {
+  return definition;
+}
+function normalizeSlackConversationId(value) {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (!trimmed.startsWith("slack:")) return trimmed;
+  const parts = trimmed.split(":");
+  return parts[1]?.trim() || void 0;
+}
+function isDmChannel(channelId) {
+  return normalizeSlackConversationId(channelId)?.startsWith("D") ?? false;
+}
+function isSlackTeamId(value) {
+  return /^T[A-Z0-9]+$/.test(value);
+}
+function getConversationAccess(destination) {
+  if (isDmChannel(destination.channelId)) {
+    return { audience: "direct", visibility: "private" };
+  }
+  if (destination.channelId.startsWith("G")) {
+    return { audience: "group", visibility: "private" };
+  }
+  if (destination.channelId.startsWith("C")) {
+    return { audience: "channel", visibility: "unknown" };
+  }
+  return { audience: "channel", visibility: "unknown" };
+}
+function getCredentialSubject(args) {
+  if (args.access.audience !== "direct" || args.access.visibility !== "private") {
+    return void 0;
+  }
+  return {
+    type: "user",
+    userId: args.requester.slackUserId,
+    allowedWhen: "private-direct-conversation"
+  };
+}
+function sameDestination(task, destination) {
+  return task.destination.platform === destination.platform && task.destination.teamId === destination.teamId && task.destination.channelId === destination.channelId;
+}
+async function getWritableTask(args) {
+  const destination = requireActiveDestination(args.context);
+  const task = await createSchedulerStore(args.context.state).getTask(
+    args.taskId
+  );
+  if (!task || task.status === "deleted") {
+    throwToolInputError(
+      "Scheduled task was not found in the active destination."
+    );
+  }
+  if (!sameDestination(task, destination)) {
+    throwToolInputError(
+      "Scheduled task can only be managed from the Slack destination where it was created."
+    );
+  }
+  return task;
+}
+function compactTask(task) {
+  return {
+    id: task.id,
+    status: task.status,
+    task: task.task.text,
+    schedule: task.schedule.description,
+    timezone: task.schedule.timezone,
+    recurrence: task.schedule.recurrence ? {
+      frequency: task.schedule.recurrence.frequency,
+      interval: task.schedule.recurrence.interval,
+      start_date: task.schedule.recurrence.startDate,
+      time: task.schedule.recurrence.time,
+      weekdays: task.schedule.recurrence.weekdays,
+      month: task.schedule.recurrence.month,
+      day_of_month: task.schedule.recurrence.dayOfMonth
+    } : null,
+    next_run_at: task.nextRunAtMs ? new Date(task.nextRunAtMs).toISOString() : null,
+    conversation_access: task.conversationAccess ?? null,
+    credential_subject: task.credentialSubject ? {
+      type: task.credentialSubject.type,
+      allowed_when: task.credentialSubject.allowedWhen
+    } : null,
+    last_run_at: task.lastRunAtMs ? new Date(task.lastRunAtMs).toISOString() : null,
+    run_now_at: task.runNowAtMs ? new Date(task.runNowAtMs).toISOString() : null,
+    version: task.version
+  };
+}
+function buildTaskId() {
+  return `${TASK_ID_PREFIX}_${randomUUID()}`;
+}
+function normalizeStatus(value) {
+  if (value === "active" || value === "paused" || value === "blocked") {
+    return 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 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;
+}
+function createSlackScheduleCreateTaskTool(context) {
+  return tool({
+    description: "Create a scheduled Junior task in the active Slack conversation.",
+    promptSnippet: "create future or recurring Junior work here",
+    promptGuidelines: [
+      "Use only when the user explicitly asks Junior to do work later or on a recurring cadence.",
+      ACTIVE_DESTINATION_GUIDELINE,
+      RECURRING_GUIDELINE,
+      "When the user's scheduling intent is clear, create the task immediately without asking for confirmation.",
+      "Ask for confirmation only when the task contract, schedule, or active destination is ambiguous.",
+      "Recurring tasks can run at most once per day; use only daily, weekly, monthly, or yearly recurrence frequencies.",
+      "Provide next_run_at as an exact ISO timestamp computed from the user's requested schedule.",
+      "Provide recurrence only for repeating schedules."
+    ],
+    inputSchema: Type.Object({
+      task: Type.String({ minLength: 1, maxLength: 4e3 }),
+      schedule: Type.String({ minLength: 1, maxLength: 300 }),
+      timezone: Type.Optional(Type.String({ minLength: 1, maxLength: 80 })),
+      next_run_at: Type.Optional(
+        Type.String({
+          minLength: 1,
+          description: "Exact next run time as an ISO timestamp, computed from the user's requested schedule."
+        })
+      ),
+      recurrence: Type.Optional(recurrenceInputSchema)
+    }),
+    execute: async (input) => {
+      const destination = requireActiveDestination(context);
+      const requester = requireRequester(context);
+      const nowMs = Date.now();
+      const timezone = input.timezone ?? getDefaultScheduleTimezone();
+      validateRecurringFrequencyLimit(input);
+      if (!isValidTimeZone(timezone)) {
+        throwToolInputError("timezone must be a valid IANA time zone.");
+      }
+      const nextRunAtMs = parseNextRunAtMs(input.next_run_at);
+      if (!nextRunAtMs) {
+        throwToolInputError("Provide next_run_at as a valid ISO timestamp.");
+      }
+      const recurrence = buildRecurrence({
+        input,
+        nextRunAtMs,
+        timezone
+      });
+      const conversationAccess = getConversationAccess(destination);
+      const credentialSubject = getCredentialSubject({
+        access: conversationAccess,
+        requester
+      });
+      const task = {
+        id: buildTaskId(),
+        createdAtMs: nowMs,
+        updatedAtMs: nowMs,
+        createdBy: requester,
+        conversationAccess,
+        ...credentialSubject ? { credentialSubject } : {},
+        destination,
+        executionActor: SCHEDULED_TASK_SYSTEM_ACTOR,
+        nextRunAtMs,
+        originalRequest: context.userText,
+        schedule: {
+          description: input.schedule,
+          timezone,
+          kind: recurrence ? "recurring" : "one_off",
+          recurrence
+        },
+        status: "active",
+        task: {
+          text: input.task
+        },
+        version: 1
+      };
+      await createSchedulerStore(context.state).saveTask(task);
+      return {
+        ok: true,
+        task: compactTask(task)
+      };
+    }
+  });
+}
+function createSlackScheduleListTasksTool(context) {
+  return tool({
+    description: "List scheduled Junior tasks for the active Slack conversation.",
+    promptSnippet: "list schedules for this Slack destination",
+    promptGuidelines: [
+      "Use when the user asks what is scheduled here or needs task IDs before editing, deleting, or running schedules.",
+      ACTIVE_DESTINATION_GUIDELINE
+    ],
+    annotations: { readOnlyHint: true, destructiveHint: false },
+    inputSchema: Type.Object({}),
+    execute: async () => {
+      const destination = requireActiveDestination(context);
+      const tasks = await createSchedulerStore(context.state).listTasksForTeam(
+        destination.teamId
+      );
+      const matching = tasks.filter(
+        (task) => sameDestination(task, destination)
+      );
+      const visible = matching.slice(0, MAX_LISTED_TASKS).map(compactTask);
+      return {
+        ok: true,
+        tasks: visible,
+        truncated: matching.length > visible.length
+      };
+    }
+  });
+}
+function createSlackScheduleUpdateTaskTool(context) {
+  return tool({
+    description: "Edit, pause, resume, or reschedule a Junior scheduled task.",
+    promptSnippet: "edit/pause/resume one schedule in this Slack destination",
+    promptGuidelines: [
+      ACTIVE_TASK_ID_GUIDELINE,
+      ACTIVE_DESTINATION_GUIDELINE,
+      RECURRING_GUIDELINE,
+      "Do not move scheduled tasks across conversations.",
+      "Provide next_run_at as an exact ISO timestamp when changing the next run.",
+      "Set recurrence to null when converting a recurring task to one-time.",
+      "Set status to active, paused, or blocked when the user asks to resume, pause, or block a task."
+    ],
+    inputSchema: Type.Object({
+      task_id: Type.String({ minLength: 1 }),
+      task: Type.Optional(Type.String({ minLength: 1, maxLength: 4e3 })),
+      schedule: Type.Optional(Type.String({ minLength: 1, maxLength: 300 })),
+      timezone: Type.Optional(Type.String({ minLength: 1, maxLength: 80 })),
+      next_run_at: Type.Optional(Type.String({ minLength: 1 })),
+      recurrence: Type.Optional(
+        Type.Union([recurrenceInputSchema, Type.Null()])
+      ),
+      status: Type.Optional(
+        Type.Union([
+          Type.Literal("active"),
+          Type.Literal("paused"),
+          Type.Literal("blocked")
+        ])
+      )
+    }),
+    execute: async (input) => {
+      const lookup = await getWritableTask({
+        context,
+        taskId: input.task_id
+      });
+      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 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."
+        );
+      }
+      const recurrence = shouldRebuildRecurrence(input) ? buildRecurrence({
+        existing: lookup.schedule.recurrence,
+        input,
+        nextRunAtMs,
+        timezone
+      }) : lookup.schedule.recurrence;
+      const nextStatus = status ?? lookup.status;
+      const next = {
+        ...lookup,
+        updatedAtMs: Date.now(),
+        nextRunAtMs,
+        runNowAtMs: nextStatus === "active" ? 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
+        },
+        task: input.task ? { text: input.task } : lookup.task,
+        version: lookup.version + 1
+      };
+      await createSchedulerStore(context.state).saveTask(next);
+      return {
+        ok: true,
+        task: compactTask(next)
+      };
+    }
+  });
+}
+function createSlackScheduleDeleteTaskTool(context) {
+  return tool({
+    description: "Delete a Junior scheduled task from the active Slack conversation.",
+    promptSnippet: "delete one schedule from this Slack destination",
+    promptGuidelines: [ACTIVE_TASK_ID_GUIDELINE, ACTIVE_DESTINATION_GUIDELINE],
+    inputSchema: Type.Object({
+      task_id: Type.String({ minLength: 1 })
+    }),
+    execute: async ({ task_id }) => {
+      const lookup = await getWritableTask({ context, taskId: task_id });
+      const next = {
+        ...lookup,
+        updatedAtMs: Date.now(),
+        status: "deleted",
+        nextRunAtMs: void 0,
+        runNowAtMs: void 0,
+        version: lookup.version + 1
+      };
+      await createSchedulerStore(context.state).saveTask(next);
+      return {
+        ok: true,
+        task: compactTask(next)
+      };
+    }
+  });
+}
+function createSlackScheduleRunTaskNowTool(context) {
+  return tool({
+    description: "Queue an active Junior scheduled task to run as soon as possible.",
+    promptSnippet: "run one active schedule now without changing its cadence",
+    promptGuidelines: [
+      ACTIVE_TASK_ID_GUIDELINE,
+      ACTIVE_DESTINATION_GUIDELINE,
+      "Use when the user asks to run an existing scheduled task now; do not rewrite the stored calendar cadence."
+    ],
+    inputSchema: Type.Object({
+      task_id: Type.String({ minLength: 1 })
+    }),
+    execute: async ({ task_id }) => {
+      const lookup = await getWritableTask({ context, taskId: task_id });
+      if (lookup.status !== "active") {
+        throwToolInputError(
+          "Scheduled task must be active before it can be run now. Resume the task first if you want it to run."
+        );
+      }
+      const nowMs = Date.now();
+      const next = {
+        ...lookup,
+        updatedAtMs: nowMs,
+        runNowAtMs: nowMs,
+        version: lookup.version + 1
+      };
+      await createSchedulerStore(context.state).saveTask(next);
+      return {
+        ok: true,
+        task: compactTask(next)
+      };
+    }
+  });
+}
+
+// src/plugin.ts
+var SCHEDULER_HEARTBEAT_LIMIT = 10;
+function shouldSkipRun(task, run) {
+  if (task.status === "deleted") {
+    return `Scheduled task ${task.id} was deleted before the run started.`;
+  }
+  if (task.status !== "active") {
+    return `Scheduled task ${task.id} was ${task.status} before the run started.`;
+  }
+  if (task.nextRunAtMs !== run.scheduledForMs && task.runNowAtMs !== run.scheduledForMs) {
+    return `Scheduled task ${task.id} no longer targets ${new Date(run.scheduledForMs).toISOString()}.`;
+  }
+  return void 0;
+}
+function createSchedulerToolContext(ctx) {
+  return {
+    channelCapabilities: ctx.channelCapabilities ?? {
+      canAddReactions: false,
+      canCreateCanvas: false,
+      canPostToChannel: false
+    },
+    channelId: ctx.channelId,
+    messageTs: ctx.messageTs,
+    requester: ctx.requester,
+    state: ctx.state,
+    teamId: ctx.teamId,
+    threadTs: ctx.threadTs,
+    userText: ctx.userText
+  };
+}
+async function applyDispatchResult(args) {
+  if (args.dispatch.status === "completed") {
+    const completed = await args.store.markRunCompleted({
+      completedAtMs: args.nowMs,
+      resultMessageTs: args.dispatch.resultMessageTs,
+      runId: args.run.id,
+      startedAtMs: args.run.startedAtMs
+    });
+    if (!completed) {
+      return false;
+    }
+    await args.store.updateTaskAfterRun({
+      nowMs: args.nowMs,
+      run: args.run,
+      status: "completed"
+    });
+    return true;
+  }
+  if (args.dispatch.status === "blocked") {
+    const blocked = await args.store.markRunBlocked({
+      completedAtMs: args.nowMs,
+      errorMessage: args.dispatch.errorMessage ?? "Dispatch blocked.",
+      runId: args.run.id,
+      startedAtMs: args.run.startedAtMs
+    });
+    if (!blocked) {
+      return false;
+    }
+    await args.store.updateTaskAfterRun({
+      errorMessage: blocked.errorMessage,
+      nowMs: args.nowMs,
+      run: args.run,
+      status: "blocked"
+    });
+    return true;
+  }
+  if (args.dispatch.status === "failed") {
+    const failed = await args.store.markRunFailed({
+      completedAtMs: args.nowMs,
+      errorMessage: args.dispatch.errorMessage ?? "Dispatch failed.",
+      runId: args.run.id,
+      startedAtMs: args.run.startedAtMs
+    });
+    if (!failed) {
+      return false;
+    }
+    await args.store.updateTaskAfterRun({
+      errorMessage: failed.errorMessage,
+      nowMs: args.nowMs,
+      run: args.run,
+      status: "failed"
+    });
+    return true;
+  }
+  return false;
+}
+async function blockClaimedRun(args) {
+  const blocked = await args.store.markRunBlocked({
+    completedAtMs: args.nowMs,
+    errorMessage: args.errorMessage,
+    runId: args.run.id
+  });
+  if (!blocked) {
+    return;
+  }
+  await args.store.updateTaskAfterRun({
+    errorMessage: args.errorMessage,
+    nowMs: args.nowMs,
+    run: args.run,
+    status: "blocked"
+  });
+}
+async function failClaimedRun(args) {
+  const failed = await args.store.markRunFailed({
+    completedAtMs: args.nowMs,
+    errorMessage: args.errorMessage,
+    runId: args.run.id,
+    startedAtMs: args.run.startedAtMs
+  });
+  if (!failed) {
+    return;
+  }
+  await args.store.updateTaskAfterRun({
+    errorMessage: args.errorMessage,
+    nowMs: args.nowMs,
+    run: args.run,
+    status: "failed"
+  });
+}
+function createSchedulerPlugin() {
+  return defineJuniorPlugin({
+    name: "scheduler",
+    pluginConfig: {
+      legacyStatePrefixes: ["junior:scheduler"],
+      packages: ["@sentry/junior-scheduler"]
+    },
+    hooks: {
+      tools(ctx) {
+        if (!ctx.channelId || !ctx.teamId || !ctx.requester?.userId) {
+          return {};
+        }
+        const context = createSchedulerToolContext(ctx);
+        return {
+          slackScheduleCreateTask: createSlackScheduleCreateTaskTool(context),
+          slackScheduleListTasks: createSlackScheduleListTasksTool(context),
+          slackScheduleUpdateTask: createSlackScheduleUpdateTaskTool(context),
+          slackScheduleDeleteTask: createSlackScheduleDeleteTaskTool(context),
+          slackScheduleRunTaskNow: createSlackScheduleRunTaskNowTool(context)
+        };
+      },
+      async heartbeat(ctx) {
+        const store = createSchedulerStore(ctx.state);
+        let processedCount = 0;
+        let dispatchCount = 0;
+        for (const run of await store.listIncompleteRuns()) {
+          if (!run.dispatchId) {
+            continue;
+          }
+          const dispatch = await ctx.agent.get(run.dispatchId);
+          if (!dispatch) {
+            await failClaimedRun({
+              errorMessage: "Scheduled task dispatch record is missing.",
+              nowMs: ctx.nowMs,
+              run,
+              store
+            });
+            continue;
+          }
+          if (await applyDispatchResult({
+            dispatch,
+            nowMs: ctx.nowMs,
+            run,
+            store
+          })) {
+            processedCount += 1;
+          }
+        }
+        for (let index = processedCount; index < SCHEDULER_HEARTBEAT_LIMIT; index += 1) {
+          const run = await store.claimDueRun({ nowMs: ctx.nowMs });
+          if (!run) {
+            break;
+          }
+          const task = await store.getTask(run.taskId);
+          if (!task) {
+            await store.markRunFailed({
+              completedAtMs: ctx.nowMs,
+              errorMessage: `Scheduled task ${run.taskId} was not found`,
+              runId: run.id
+            });
+            continue;
+          }
+          const skippedReason = shouldSkipRun(task, run);
+          if (skippedReason) {
+            await store.markRunSkipped({
+              completedAtMs: ctx.nowMs,
+              errorMessage: skippedReason,
+              runId: run.id
+            });
+            continue;
+          }
+          let prompt;
+          try {
+            prompt = buildScheduledTaskRunPrompt({
+              nowMs: ctx.nowMs,
+              run,
+              task
+            });
+          } catch (error) {
+            const errorMessage = error instanceof Error ? `Scheduled task prompt could not be built: ${error.message}` : "Scheduled task prompt could not be built.";
+            await blockClaimedRun({
+              errorMessage,
+              nowMs: ctx.nowMs,
+              run,
+              store
+            });
+            continue;
+          }
+          let dispatch;
+          try {
+            dispatch = await ctx.agent.dispatch({
+              idempotencyKey: run.id,
+              ...task.credentialSubject ? { credentialSubject: task.credentialSubject } : {},
+              destination: task.destination,
+              input: prompt,
+              metadata: {
+                runId: run.id,
+                taskId: task.id
+              }
+            });
+          } catch (error) {
+            const errorMessage = error instanceof Error ? `Scheduled task dispatch could not be created: ${error.message}` : "Scheduled task dispatch could not be created.";
+            await blockClaimedRun({
+              errorMessage,
+              nowMs: ctx.nowMs,
+              run,
+              store
+            });
+            continue;
+          }
+          await store.markRunDispatched({
+            claimedAtMs: run.claimedAtMs,
+            dispatchId: dispatch.id,
+            nowMs: ctx.nowMs,
+            runId: run.id
+          });
+          dispatchCount += 1;
+        }
+        return { dispatchCount };
+      }
+    }
+  });
+}
+var schedulerPlugin = createSchedulerPlugin;
+export {
+  buildScheduledTaskRunPrompt,
+  createSchedulerPlugin,
+  createSchedulerStore,
+  createSlackScheduleCreateTaskTool,
+  createSlackScheduleDeleteTaskTool,
+  createSlackScheduleListTasksTool,
+  createSlackScheduleRunTaskNowTool,
+  createSlackScheduleUpdateTaskTool,
+  schedulerPlugin
+};