@sentry/junior-scheduler 0.74.1 → 0.76.0

package/dist/index.js

@@ -1,133 +1,27 @@
 // src/plugin.ts
 import {
+  createSlackSource,
   defineJuniorPlugin
 } from "@sentry/junior-plugin-api";
 
-// src/types.ts
-var SCHEDULED_TASK_SYSTEM_ACTOR = Object.freeze({
-  type: "system",
-  id: "scheduled-task"
-});
-
-// src/identity.ts
-var SLACK_USER_ID_PATTERN = /^[UW][A-Z0-9]{5,}$/;
-function clean(value) {
-  const normalized = value?.trim();
-  return normalized ? normalized : void 0;
-}
-function cleanSlackUserId(value) {
-  const normalized = clean(value);
-  return normalized && normalized.toLowerCase() !== "unknown" ? normalized : void 0;
-}
-function cleanDisplay(value, slackUserId) {
-  const normalized = clean(value);
-  if (!normalized || normalized.toLowerCase() === "unknown" || normalized === slackUserId) {
-    return void 0;
-  }
-  return SLACK_USER_ID_PATTERN.test(normalized) ? void 0 : normalized;
-}
-function sanitizeScheduledTaskPrincipal(principal) {
-  const slackUserId = cleanSlackUserId(principal.slackUserId);
-  if (!slackUserId) {
-    throw new Error("Scheduled task principal requires a Slack user id");
-  }
-  const fullName = cleanDisplay(principal.fullName, slackUserId);
-  const userName = cleanDisplay(principal.userName, slackUserId);
-  return {
-    slackUserId,
-    ...fullName ? { fullName } : {},
-    ...userName ? { userName } : {}
-  };
-}
-function scheduledTaskPrincipalLabel(principal) {
-  const author = sanitizeScheduledTaskPrincipal(principal);
-  if (author.fullName && author.userName) {
-    return `${author.fullName} (@${author.userName})`;
-  }
-  if (author.fullName) {
-    return author.fullName;
-  }
-  if (author.userName) {
-    return `@${author.userName}`;
-  }
-  return `Slack User ${author.slackUserId}`;
-}
-
-// 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 = sanitizeScheduledTaskPrincipal(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/store.ts
 import {
-  agentPluginCredentialSubjectSchema,
+  pluginCredentialSubjectSchema,
   destinationSchema,
   isSlackDestination
 } from "@sentry/junior-plugin-api";
+import {
+  and,
+  asc,
+  eq,
+  inArray,
+  isNotNull,
+  lte,
+  ne,
+  or,
+  sql as sql2
+} from "drizzle-orm";
+import { z } from "zod";
 
 // src/cadence.ts
 function parseScheduleTimestamp(value) {
@@ -215,7 +109,7 @@ function localDateTimeToTimestampMs(args) {
     0
   );
   let timestampMs = localAsUtcMs - getTimeZoneOffsetMs(localAsUtcMs, args.timezone);
-  for (let index = 0; index < 3; index += 1) {
+  for (let index2 = 0; index2 < 3; index2 += 1) {
     const next = localAsUtcMs - getTimeZoneOffsetMs(timestampMs, args.timezone);
     if (next === timestampMs) {
       break;
@@ -476,6 +370,52 @@ function getNextRunAtMs(task, scheduledForMs, afterMs = scheduledForMs) {
   });
 }
 
+// src/db/schema.ts
+import { sql } from "drizzle-orm";
+import { bigint, index, jsonb, pgTable, text } from "drizzle-orm/pg-core";
+var juniorSchedulerTasks = pgTable(
+  "junior_scheduler_tasks",
+  {
+    id: text("id").primaryKey(),
+    teamId: text("team_id").notNull(),
+    status: text("status").notNull(),
+    nextRunAtMs: bigint("next_run_at_ms", { mode: "number" }),
+    runNowAtMs: bigint("run_now_at_ms", { mode: "number" }),
+    createdAtMs: bigint("created_at_ms", { mode: "number" }).notNull(),
+    record: jsonb("record").$type().notNull()
+  },
+  (table) => [
+    index("junior_scheduler_tasks_team_status_idx").on(table.teamId, table.createdAtMs, table.id).where(sql`${table.status} <> 'deleted'`),
+    index("junior_scheduler_tasks_run_now_due_idx").on(table.runNowAtMs, table.createdAtMs, table.id).where(
+      sql`${table.status} = 'active' AND ${table.runNowAtMs} IS NOT NULL`
+    ),
+    index("junior_scheduler_tasks_next_run_due_idx").on(table.nextRunAtMs, table.createdAtMs, table.id).where(
+      sql`${table.status} = 'active' AND ${table.nextRunAtMs} IS NOT NULL`
+    )
+  ]
+);
+var juniorSchedulerRuns = pgTable(
+  "junior_scheduler_runs",
+  {
+    id: text("id").primaryKey(),
+    taskId: text("task_id").notNull(),
+    status: text("status").notNull(),
+    scheduledForMs: bigint("scheduled_for_ms", { mode: "number" }).notNull(),
+    record: jsonb("record").$type().notNull()
+  },
+  (table) => [
+    index("junior_scheduler_runs_task_status_idx").on(
+      table.taskId,
+      table.status,
+      table.scheduledForMs
+    ),
+    index("junior_scheduler_runs_status_idx").on(
+      table.status,
+      table.scheduledForMs
+    )
+  ]
+);
+
 // src/store.ts
 var SCHEDULER_KEY_PREFIX = "junior:scheduler";
 var SCHEDULER_RECORD_TTL_MS = 5 * 365 * 24 * 60 * 60 * 1e3;
@@ -483,7 +423,81 @@ 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;
+var SQL_INCOMPLETE_RUN_STATUSES = ["pending", "running"];
+var slackDestinationSchema = destinationSchema.refine(isSlackDestination);
+var taskPrincipalSchema = z.object({
+  slackUserId: z.string(),
+  fullName: z.string().optional(),
+  userName: z.string().optional()
+}).strict();
+var recurrenceSchema = z.object({
+  dayOfMonth: z.number().optional(),
+  frequency: z.enum(["daily", "weekly", "monthly", "yearly"]),
+  interval: z.number(),
+  month: z.number().optional(),
+  startDate: z.string(),
+  time: z.object({
+    hour: z.number(),
+    minute: z.number()
+  }).strict(),
+  weekdays: z.array(z.number()).optional()
+}).strict();
+var taskScheduleSchema = z.object({
+  description: z.string(),
+  kind: z.enum(["one_off", "recurring"]),
+  recurrence: recurrenceSchema.optional(),
+  timezone: z.string()
+}).strict();
+var taskSpecSchema = z.object({
+  text: z.string()
+}).strict();
+var taskRecordSchema = z.object({
+  id: z.string(),
+  conversationAccess: z.object({
+    audience: z.enum(["direct", "group", "channel"]),
+    visibility: z.enum(["private", "public", "unknown"])
+  }).strict().optional(),
+  createdAtMs: z.number(),
+  createdBy: taskPrincipalSchema,
+  credentialSubject: pluginCredentialSubjectSchema.optional(),
+  destination: slackDestinationSchema,
+  executionActor: z.object({
+    type: z.literal("system"),
+    id: z.string()
+  }).strict().optional(),
+  lastRunAtMs: z.number().optional(),
+  nextRunAtMs: z.number().optional(),
+  originalRequest: z.string().optional(),
+  runNowAtMs: z.number().optional(),
+  schedule: taskScheduleSchema,
+  status: z.enum(["active", "paused", "blocked", "deleted"]),
+  statusReason: z.string().optional(),
+  task: taskSpecSchema,
+  updatedAtMs: z.number(),
+  version: z.number().optional()
+}).strict();
+var runRecordSchema = z.object({
+  id: z.string(),
+  attempt: z.number(),
+  claimedAtMs: z.number(),
+  completedAtMs: z.number().optional(),
+  dispatchId: z.string().optional(),
+  errorMessage: z.string().optional(),
+  idempotencyKey: z.string().optional(),
+  resultMessageTs: z.string().optional(),
+  scheduledForMs: z.number(),
+  startedAtMs: z.number().optional(),
+  status: z.enum([
+    "pending",
+    "running",
+    "completed",
+    "failed",
+    "blocked",
+    "skipped"
+  ]),
+  taskId: z.string(),
+  taskVersion: z.number().optional()
+}).strict();
 function taskKey(taskId) {
   return `${SCHEDULER_KEY_PREFIX}:task:${taskId}`;
 }
@@ -493,18 +507,12 @@ function taskLockKey(taskId) {
 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`;
 }
@@ -514,80 +522,18 @@ function buildRunId(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;
@@ -598,16 +544,13 @@ function getDueRunAtMs(task, nowMs) {
   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
+    taskId: args.task.id
   };
 }
 function buildSkippedScheduledRun(args) {
@@ -658,23 +601,40 @@ function canFinishRun(run, startedAtMs) {
   return run.status === "running" && run.startedAtMs === startedAtMs;
 }
 function parseStoredTask(value) {
-  if (!value || typeof value !== "object") {
-    return void 0;
-  }
-  const record = value;
-  const destination = destinationSchema.safeParse(record.destination);
-  if (!destination.success || !isSlackDestination(destination.data)) {
-    return void 0;
+  const parsed = taskRecordSchema.safeParse(parseJsonRecord(value));
+  return parsed.success ? stripLegacyTaskFields(parsed.data) : void 0;
+}
+function parseStoredRun(value) {
+  const parsed = runRecordSchema.safeParse(parseJsonRecord(value));
+  return parsed.success ? stripLegacyRunFields(parsed.data) : void 0;
+}
+function stripLegacyTaskFields(task) {
+  const { version: _version, ...current } = task;
+  return current;
+}
+function stripLegacyRunFields(run) {
+  const {
+    idempotencyKey: _idempotencyKey,
+    taskVersion: _taskVersion,
+    ...current
+  } = run;
+  return current;
+}
+function parseJsonRecord(value) {
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return void 0;
+    }
   }
-  const credentialSubject = record.credentialSubject === void 0 ? void 0 : agentPluginCredentialSubjectSchema.safeParse(record.credentialSubject);
-  if (credentialSubject && !credentialSubject.success) {
-    return void 0;
+  if (value && typeof value === "object") {
+    return value;
   }
-  return {
-    ...record,
-    destination: destination.data,
-    ...credentialSubject ? { credentialSubject: credentialSubject.data } : {}
-  };
+  return void 0;
+}
+function present(value) {
+  return value !== void 0;
 }
 function requireStoredTask(task) {
   const parsed = parseStoredTask(task);
@@ -686,13 +646,8 @@ function requireStoredTask(task) {
 async function getTaskFromState(state, taskId) {
   return parseStoredTask(await state.get(taskKey(taskId)));
 }
-async function listTasksFromState(state, indexKey) {
-  const ids = await getIndex(state, indexKey);
-  const tasks = await Promise.all(ids.map((id) => getTaskFromState(state, id)));
-  return tasks.filter((task) => Boolean(task)).filter((task) => task.status !== "deleted").sort((a, b) => a.createdAtMs - b.createdAtMs);
-}
 async function getRunFromState(state, runId) {
-  return await state.get(runKey(runId)) ?? void 0;
+  return parseStoredRun(await state.get(runKey(runId)));
 }
 async function listIncompleteRunsForTasksFromState(state, tasks) {
   const runs = [];
@@ -708,191 +663,266 @@ async function listIncompleteRunsForTasksFromState(state, tasks) {
   }
   return runs;
 }
-var PluginStateSchedulerOperationalStore = class {
-  state;
-  constructor(state) {
-    this.state = state;
-  }
-  async listTasks() {
-    return await listTasksFromState(this.state, globalTaskIndexKey());
-  }
-  async listIncompleteRunsForTasks(tasks) {
-    return await listIncompleteRunsForTasksFromState(this.state, tasks);
+function parseSqlTaskRecord(value) {
+  const parsed = taskRecordSchema.safeParse(parseJsonRecord(value));
+  return parsed.success ? stripLegacyTaskFields(parsed.data) : void 0;
+}
+function parseSqlTaskRow(row) {
+  return parseSqlTaskRecord(row.record);
+}
+function parseSqlRunRow(row) {
+  const parsed = runRecordSchema.safeParse(parseJsonRecord(row.record));
+  return parsed.success ? stripLegacyRunFields(parsed.data) : void 0;
+}
+async function withSqlLock(db, key, callback) {
+  return await db.transaction(async (tx) => {
+    await tx.execute(sql2`SELECT pg_advisory_xact_lock(hashtext(${key}))`);
+    return await callback(tx);
+  });
+}
+async function upsertSqlTask(db, task) {
+  await db.insert(juniorSchedulerTasks).values({
+    createdAtMs: task.createdAtMs,
+    id: task.id,
+    nextRunAtMs: task.nextRunAtMs,
+    record: task,
+    runNowAtMs: task.runNowAtMs,
+    status: task.status,
+    teamId: task.destination.teamId
+  }).onConflictDoUpdate({
+    target: juniorSchedulerTasks.id,
+    set: {
+      createdAtMs: sql2`excluded.created_at_ms`,
+      nextRunAtMs: sql2`excluded.next_run_at_ms`,
+      record: sql2`excluded.record`,
+      runNowAtMs: sql2`excluded.run_now_at_ms`,
+      status: sql2`excluded.status`,
+      teamId: sql2`excluded.team_id`
+    }
+  });
+}
+async function upsertSqlRun(db, run) {
+  await db.insert(juniorSchedulerRuns).values({
+    id: run.id,
+    record: run,
+    scheduledForMs: run.scheduledForMs,
+    status: run.status,
+    taskId: run.taskId
+  }).onConflictDoUpdate({
+    target: juniorSchedulerRuns.id,
+    set: {
+      record: sql2`excluded.record`,
+      scheduledForMs: sql2`excluded.scheduled_for_ms`,
+      status: sql2`excluded.status`,
+      taskId: sql2`excluded.task_id`
+    }
+  });
+}
+async function getTaskFromSql(db, taskId) {
+  const rows = await db.select({ record: juniorSchedulerTasks.record }).from(juniorSchedulerTasks).where(eq(juniorSchedulerTasks.id, taskId)).limit(1);
+  return rows[0] ? parseSqlTaskRow(rows[0]) : void 0;
+}
+async function getRunFromSql(db, runId) {
+  const rows = await db.select({ record: juniorSchedulerRuns.record }).from(juniorSchedulerRuns).where(eq(juniorSchedulerRuns.id, runId)).limit(1);
+  return rows[0] ? parseSqlRunRow(rows[0]) : void 0;
+}
+async function listTasksFromSql(db) {
+  const rows = await db.select({ record: juniorSchedulerTasks.record }).from(juniorSchedulerTasks).where(ne(juniorSchedulerTasks.status, "deleted")).orderBy(
+    asc(juniorSchedulerTasks.createdAtMs),
+    asc(juniorSchedulerTasks.id)
+  );
+  return rows.map(parseSqlTaskRow).filter(present);
+}
+async function listTasksForTeamFromSql(db, teamId) {
+  const rows = await db.select({ record: juniorSchedulerTasks.record }).from(juniorSchedulerTasks).where(
+    and(
+      eq(juniorSchedulerTasks.teamId, teamId),
+      ne(juniorSchedulerTasks.status, "deleted")
+    )
+  ).orderBy(
+    asc(juniorSchedulerTasks.createdAtMs),
+    asc(juniorSchedulerTasks.id)
+  );
+  return rows.map(parseSqlTaskRow).filter(present);
+}
+async function listIncompleteRunsForTasksFromSql(db, tasks) {
+  if (tasks.length === 0) {
+    return [];
   }
-};
-var PluginStateSchedulerStore = class {
-  state;
-  constructor(state) {
-    this.state = state;
+  const rows = await db.select({ record: juniorSchedulerRuns.record }).from(juniorSchedulerRuns).where(
+    and(
+      inArray(
+        juniorSchedulerRuns.taskId,
+        tasks.map((task) => task.id)
+      ),
+      inArray(juniorSchedulerRuns.status, [...SQL_INCOMPLETE_RUN_STATUSES])
+    )
+  ).orderBy(
+    asc(juniorSchedulerRuns.scheduledForMs),
+    asc(juniorSchedulerRuns.id)
+  );
+  return rows.map(parseSqlRunRow).filter(present);
+}
+var SqlSchedulerStore = class {
+  constructor(db) {
+    this.db = db;
   }
+  db;
   async saveTask(task) {
     const next = requireStoredTask(task);
-    await withLock(this.state, taskLockKey(task.id), async () => {
-      const current = await getTaskFromState(this.state, task.id);
-      await this.saveTaskRecord(next, current);
+    await withSqlLock(this.db, taskLockKey(task.id), async (db) => {
+      const current = await getTaskFromSql(db, task.id);
+      await this.saveTaskRecord(db, next, current);
     });
   }
-  async saveTaskRecord(task, current) {
+  async saveTaskRecord(db, 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
+      await db.delete(juniorSchedulerRuns).where(
+        and(
+          eq(juniorSchedulerRuns.id, buildRunId(task.id, task.nextRunAtMs)),
+          eq(juniorSchedulerRuns.status, "blocked")
+        )
       );
     }
+    await upsertSqlTask(db, task);
   }
   async getTask(taskId) {
-    return await getTaskFromState(this.state, taskId);
+    return await getTaskFromSql(this.db, taskId);
   }
   async listTasks() {
-    return await listTasksFromState(this.state, globalTaskIndexKey());
+    return await listTasksFromSql(this.db);
   }
   async listTasksForTeam(teamId) {
-    return await listTasksFromState(this.state, teamTaskIndexKey(teamId));
+    return await listTasksForTeamFromSql(this.db, teamId);
   }
   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
+    return await withSqlLock(this.db, "junior:scheduler:claim", async (db) => {
+      const rows = await db.select({ record: juniorSchedulerTasks.record }).from(juniorSchedulerTasks).where(
+        and(
+          eq(juniorSchedulerTasks.status, "active"),
+          or(
+            and(
+              isNotNull(juniorSchedulerTasks.runNowAtMs),
+              lte(juniorSchedulerTasks.runNowAtMs, args.nowMs)
+            ),
+            and(
+              isNotNull(juniorSchedulerTasks.nextRunAtMs),
+              lte(juniorSchedulerTasks.nextRunAtMs, args.nowMs)
+            )
+          )
+        )
+      ).orderBy(
+        asc(juniorSchedulerTasks.createdAtMs),
+        asc(juniorSchedulerTasks.id)
       );
-      let activeClaimed = await tryClaimActiveRun();
-      if (!activeClaimed) {
-        if (await clearStaleActiveRun(this.state, task.id, args.nowMs)) {
-          activeClaimed = await tryClaimActiveRun();
+      for (const row of rows) {
+        const task = parseSqlTaskRow(row);
+        if (!task) {
+          continue;
         }
-        if (!activeClaimed) {
+        const scheduledForMs = getDueRunAtMs(task, args.nowMs);
+        if (scheduledForMs === void 0) {
           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;
+        const runId = buildRunId(task.id, scheduledForMs);
+        const incompleteRuns = await listIncompleteRunsForTasksFromSql(db, [
+          task
+        ]);
+        const incompleteRun = incompleteRuns.find((run2) => run2.id === runId);
+        const blockingRun = incompleteRuns.find(
+          (run2) => run2.id !== runId && !isStalePendingRun(run2, args.nowMs)
+        );
+        if (blockingRun) {
+          continue;
+        }
+        if (incompleteRun) {
+          if (!isStalePendingRun(incompleteRun, args.nowMs)) {
+            continue;
+          }
+          const reclaimed = {
+            ...incompleteRun,
+            attempt: incompleteRun.attempt + 1,
+            claimedAtMs: args.nowMs
+          };
+          await upsertSqlRun(db, reclaimed);
+          return reclaimed;
         }
-        if (!claimed) {
-          await clearActiveRun(this.state, task.id, runId);
+        const existingRun = await getRunFromSql(db, runId);
+        if (existingRun) {
           continue;
         }
+        if (isMissedRunTooOld({ nowMs: args.nowMs, scheduledForMs })) {
+          await this.skipMissedRun(db, {
+            nowMs: args.nowMs,
+            scheduledForMs,
+            task
+          });
+          continue;
+        }
+        const run = buildScheduledRun({
+          claimedAtMs: args.nowMs,
+          scheduledForMs,
+          task
+        });
+        await upsertSqlRun(db, run);
+        return run;
       }
-      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 getTaskFromState(this.state, 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
-      );
+      return void 0;
     });
   }
-  async findStaleRecoveryCanonicalTask(task) {
-    const fingerprint = taskDedupeFingerprint(task);
-    const ids = await getIndex(
-      this.state,
-      teamTaskIndexKey(task.destination.teamId)
+  async skipMissedRun(db, args) {
+    const current = await getTaskFromSql(db, args.task.id);
+    if (!current || current.status !== "active" || getDueRunAtMs(current, args.nowMs) !== args.scheduledForMs) {
+      return;
+    }
+    const duplicateOf = await this.findStaleRecoveryCanonicalTask(db, 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 upsertSqlRun(
+      db,
+      buildSkippedScheduledRun({
+        completedAtMs: args.nowMs,
+        errorMessage,
+        scheduledForMs: args.scheduledForMs,
+        task: current
+      })
     );
-    const tasks = await Promise.all(
-      ids.filter((id) => id !== task.id).map((id) => this.getTask(id))
+    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(
+      db,
+      {
+        ...current,
+        nextRunAtMs,
+        runNowAtMs: isRunNow ? void 0 : current.runNowAtMs,
+        status: nextStatus,
+        statusReason: nextStatus === "paused" ? errorMessage : void 0,
+        updatedAtMs: args.nowMs
+      },
+      current
     );
-    return tasks.filter((candidate) => Boolean(candidate)).filter(
+  }
+  async findStaleRecoveryCanonicalTask(db, task) {
+    const fingerprint = taskDedupeFingerprint(task);
+    const tasks = await listTasksForTeamFromSql(db, task.destination.teamId);
+    return tasks.filter((candidate) => candidate.id !== task.id).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 getRunFromState(this.state, runId);
+    return await getRunFromSql(this.db, runId);
   }
   async listIncompleteRuns() {
-    const tasks = await this.listTasks();
-    return await listIncompleteRunsForTasksFromState(this.state, tasks);
+    return await listIncompleteRunsForTasksFromSql(
+      this.db,
+      await this.listTasks()
+    );
+  }
+  async listIncompleteRunsForTasks(tasks) {
+    return await listIncompleteRunsForTasksFromSql(this.db, tasks);
   }
   async markRunDispatched(args) {
     return await this.updateRun(
@@ -915,13 +945,10 @@ var PluginStateSchedulerStore = class {
         status: "completed"
       } : void 0
     );
-    if (next) {
-      await clearActiveRun(this.state, next.taskId, next.id);
-    }
     return next;
   }
   async markRunFailed(args) {
-    const next = await this.updateRun(
+    return await this.updateRun(
       args.runId,
       (run) => canFinishRun(run, args.startedAtMs) ? {
         ...run,
@@ -930,13 +957,9 @@ var PluginStateSchedulerStore = class {
         status: "failed"
       } : void 0
     );
-    if (next) {
-      await clearActiveRun(this.state, next.taskId, next.id);
-    }
-    return next;
   }
   async markRunSkipped(args) {
-    const next = await this.updateRun(
+    return await this.updateRun(
       args.runId,
       (run) => run.status === "pending" ? {
         ...run,
@@ -945,13 +968,9 @@ var PluginStateSchedulerStore = class {
         status: "skipped"
       } : void 0
     );
-    if (next) {
-      await clearActiveRun(this.state, next.taskId, next.id);
-    }
-    return next;
   }
   async markRunBlocked(args) {
-    const next = await this.updateRun(
+    return await this.updateRun(
       args.runId,
       (run) => canFinishRun(run, args.startedAtMs) ? {
         ...run,
@@ -960,14 +979,10 @@ var PluginStateSchedulerStore = class {
         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 getTaskFromState(this.state, args.run.taskId) ?? void 0;
+    await withSqlLock(this.db, taskLockKey(args.run.taskId), async (db) => {
+      const current = await getTaskFromSql(db, args.run.taskId);
       if (!current || current.status === "deleted") {
         return;
       }
@@ -982,6 +997,7 @@ var PluginStateSchedulerStore = class {
           );
         }
         await this.saveTaskRecord(
+          db,
           {
             ...current,
             lastRunAtMs: args.run.scheduledForMs,
@@ -989,8 +1005,7 @@ var PluginStateSchedulerStore = class {
             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
+            updatedAtMs: args.nowMs
           },
           current
         );
@@ -998,11 +1013,11 @@ var PluginStateSchedulerStore = class {
       }
       if (current.status !== "active" || current.nextRunAtMs !== args.run.scheduledForMs) {
         await this.saveTaskRecord(
+          db,
           {
             ...current,
             lastRunAtMs: args.run.scheduledForMs,
-            updatedAtMs: args.nowMs,
-            version: current.version + 1
+            updatedAtMs: args.nowMs
           },
           current
         );
@@ -1010,58 +1025,153 @@ var PluginStateSchedulerStore = class {
       }
       const nextRunAtMs = args.status === "blocked" ? void 0 : getNextRunAtMs(current, args.run.scheduledForMs, args.nowMs);
       await this.saveTaskRecord(
+        db,
         {
           ...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
+          updatedAtMs: args.nowMs
         },
         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;
+    return await withSqlLock(
+      this.db,
+      indexLockKey(runKey(runId)),
+      async (db) => {
+        const current = await getRunFromSql(db, runId);
+        if (!current) {
+          return void 0;
+        }
+        const next = update(current);
+        if (!next) {
+          return void 0;
+        }
+        await upsertSqlRun(db, next);
+        return next;
       }
-      await this.state.set(runKey(runId), next, SCHEDULED_RUN_TTL_MS);
-      return next;
-    });
+    );
   }
 };
-function createSchedulerStore(state) {
-  return new PluginStateSchedulerStore(state);
+function createSchedulerSqlStore(db) {
+  return new SqlSchedulerStore(db);
+}
+function createSchedulerOperationalSqlStore(db) {
+  return new SqlSchedulerStore(db);
+}
+async function migrateSchedulerStateToSql(args) {
+  const store = createSchedulerSqlStore(args.db);
+  const ids = await getIndex(args.state, globalTaskIndexKey());
+  let existing = 0;
+  let migrated = 0;
+  let missing = 0;
+  const migratedTasks = [];
+  for (const id of ids) {
+    const task = await getTaskFromState(args.state, id);
+    if (!task) {
+      missing += 1;
+      continue;
+    }
+    migratedTasks.push(task);
+    if (await store.getTask(task.id)) {
+      existing += 1;
+      continue;
+    }
+    await store.saveTask(task);
+    migrated += 1;
+  }
+  const runs = await listIncompleteRunsForTasksFromState(
+    args.state,
+    migratedTasks
+  );
+  for (const run of runs) {
+    if (await store.getRun(run.id)) {
+      existing += 1;
+      continue;
+    }
+    await upsertSqlRun(args.db, run);
+    migrated += 1;
+  }
+  return {
+    existing,
+    migrated,
+    missing,
+    scanned: ids.length + runs.length
+  };
+}
+
+// src/identity.ts
+var SLACK_USER_ID_PATTERN = /^[UW][A-Z0-9]{5,}$/;
+function clean(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
 }
-function createSchedulerOperationalStore(state) {
-  return new PluginStateSchedulerOperationalStore(state);
+function cleanSlackUserId(value) {
+  const normalized = clean(value);
+  return normalized && normalized.toLowerCase() !== "unknown" ? normalized : void 0;
+}
+function cleanDisplay(value, slackUserId) {
+  const normalized = clean(value);
+  if (!normalized || normalized.toLowerCase() === "unknown" || normalized === slackUserId) {
+    return void 0;
+  }
+  return SLACK_USER_ID_PATTERN.test(normalized) ? void 0 : normalized;
+}
+function sanitizeScheduledTaskPrincipal(principal) {
+  const slackUserId = cleanSlackUserId(principal.slackUserId);
+  if (!slackUserId) {
+    throw new Error("Scheduled task principal requires a Slack user id");
+  }
+  const fullName = cleanDisplay(principal.fullName, slackUserId);
+  const userName = cleanDisplay(principal.userName, slackUserId);
+  return {
+    slackUserId,
+    ...fullName ? { fullName } : {},
+    ...userName ? { userName } : {}
+  };
+}
+function scheduledTaskPrincipalLabel(principal) {
+  const author = sanitizeScheduledTaskPrincipal(principal);
+  if (author.fullName && author.userName) {
+    return `${author.fullName} (@${author.userName})`;
+  }
+  if (author.fullName) {
+    return author.fullName;
+  }
+  if (author.userName) {
+    return `@${author.userName}`;
+  }
+  return `Slack User ${author.slackUserId}`;
 }
 
 // src/schedule-tools.ts
 import { randomUUID } from "crypto";
 import { Type } from "@sinclair/typebox";
 import {
-  AgentPluginToolInputError,
-  agentPluginCredentialSubjectSchema as agentPluginCredentialSubjectSchema2,
-  destinationSchema as destinationSchema2,
-  isSlackDestination as isSlackDestination2
+  PluginToolInputError,
+  pluginCredentialSubjectSchema as pluginCredentialSubjectSchema2,
+  sourceSchema
 } from "@sentry/junior-plugin-api";
+
+// src/types.ts
+var SCHEDULED_TASK_SYSTEM_ACTOR = Object.freeze({
+  type: "system",
+  id: "scheduled-task"
+});
+
+// src/schedule-tools.ts
 var TASK_ID_PREFIX = "sched";
 var MAX_LISTED_TASKS = 50;
 var DEFAULT_SCHEDULE_TIMEZONE = "America/Los_Angeles";
 function throwToolInputError(error) {
-  throw new AgentPluginToolInputError(error);
+  throw new PluginToolInputError(error);
 }
 function requireActiveConversation(context) {
-  const parsed = destinationSchema2.safeParse(context.source);
+  const parsed = sourceSchema.safeParse(context.source);
   if (!parsed.success) {
     const source = context.source;
     const issues = parsed.error.issues;
@@ -1081,10 +1191,14 @@ function requireActiveConversation(context) {
     }
     throwToolInputError("No active Slack conversation is available.");
   }
-  if (!isSlackDestination2(parsed.data)) {
+  if (parsed.data.platform !== "slack") {
     throwToolInputError("No active Slack conversation is available.");
   }
-  return parsed.data;
+  return {
+    platform: "slack",
+    teamId: parsed.data.teamId,
+    channelId: parsed.data.channelId
+  };
 }
 function requireRequester(context) {
   if (context.requester?.platform !== "slack") {
@@ -1125,7 +1239,7 @@ function getCredentialSubject(args) {
   if (!args.subject) {
     return void 0;
   }
-  const subject = agentPluginCredentialSubjectSchema2.safeParse(args.subject);
+  const subject = pluginCredentialSubjectSchema2.safeParse(args.subject);
   if (!subject.success) {
     throwToolInputError("Active Slack credential subject is invalid.");
   }
@@ -1141,9 +1255,7 @@ function sameDestination(task, destination) {
 }
 async function getWritableTask(args) {
   const destination = requireActiveConversation(args.context);
-  const task = await createSchedulerStore(args.context.state).getTask(
-    args.taskId
-  );
+  const task = await schedulerStore(args.context).getTask(args.taskId);
   if (!task || task.status === "deleted") {
     throwToolInputError(
       "Scheduled task was not found in the active Slack conversation."
@@ -1179,13 +1291,15 @@ function compactTask(task) {
       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
+    run_now_at: task.runNowAtMs ? new Date(task.runNowAtMs).toISOString() : null
   };
 }
 function buildTaskId() {
   return `${TASK_ID_PREFIX}_${randomUUID()}`;
 }
+function schedulerStore(context) {
+  return context.store;
+}
 function normalizeStatus(value) {
   if (value === "active" || value === "paused" || value === "blocked") {
     return value;
@@ -1230,6 +1344,20 @@ function validateRecurringFrequencyLimit(input) {
     );
   }
 }
+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) {
+    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;
 }
@@ -1256,11 +1384,17 @@ function parseNextRunAtMs(nextRunAtIso) {
 }
 function createSlackScheduleCreateTaskTool(context) {
   return tool({
-    description: "Create a future or recurring Junior task in the active Slack conversation. Use only when the user explicitly asks Junior to do work later or on a recurring cadence. Only manage tasks for the active Slack DM or channel; never target threads, other channels, or another user's DM. When the task, schedule, and destination are clear, create it without asking for confirmation; ask only when one of those is ambiguous.",
+    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. Only manage tasks for the active Slack DM or channel; never target threads, other channels, or another user's DM. When the task, schedule, and destination are clear, create it without asking for confirmation; ask only when one of those is ambiguous.",
     executionMode: "sequential",
     inputSchema: Type.Object({
       task: Type.String({ minLength: 1, maxLength: 4e3 }),
       schedule: Type.String({ minLength: 1, maxLength: 300 }),
+      schedule_kind: Type.Union(
+        [Type.Literal("one_off"), Type.Literal("recurring")],
+        {
+          description: "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."
+        }
+      ),
       timezone: Type.Optional(
         Type.String({
           minLength: 1,
@@ -1283,7 +1417,7 @@ function createSlackScheduleCreateTaskTool(context) {
             Type.Literal("yearly")
           ],
           {
-            description: "Provide only for explicitly repeating schedules; omit for one-time requests like 'in 1 minute', 'tomorrow', or a specific date. Recurring tasks run at most once per day: use daily, weekly, monthly, or yearly only."
+            description: "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."
           }
         )
       )
@@ -1293,6 +1427,7 @@ function createSlackScheduleCreateTaskTool(context) {
       const requester = requireRequester(context);
       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.");
@@ -1331,10 +1466,9 @@ function createSlackScheduleCreateTaskTool(context) {
         status: "active",
         task: {
           text: input.task
-        },
-        version: 1
+        }
       };
-      await createSchedulerStore(context.state).saveTask(task);
+      await schedulerStore(context).saveTask(task);
       return {
         ok: true,
         task: compactTask(task)
@@ -1349,7 +1483,7 @@ function createSlackScheduleListTasksTool(context) {
     inputSchema: Type.Object({}),
     execute: async () => {
       const destination = requireActiveConversation(context);
-      const tasks = await createSchedulerStore(context.state).listTasksForTeam(
+      const tasks = await schedulerStore(context).listTasksForTeam(
         destination.teamId
       );
       const matching = tasks.filter(
@@ -1454,10 +1588,9 @@ function createSlackScheduleUpdateTaskTool(context) {
           kind: recurrence ? "recurring" : "one_off",
           recurrence
         },
-        task: input.task ? { text: input.task } : lookup.task,
-        version: lookup.version + 1
+        task: input.task ? { text: input.task } : lookup.task
       };
-      await createSchedulerStore(context.state).saveTask(next);
+      await schedulerStore(context).saveTask(next);
       return {
         ok: true,
         task: compactTask(next)
@@ -1482,10 +1615,9 @@ function createSlackScheduleDeleteTaskTool(context) {
         updatedAtMs: Date.now(),
         status: "deleted",
         nextRunAtMs: void 0,
-        runNowAtMs: void 0,
-        version: lookup.version + 1
+        runNowAtMs: void 0
       };
-      await createSchedulerStore(context.state).saveTask(next);
+      await schedulerStore(context).saveTask(next);
       return {
         ok: true,
         task: compactTask(next)
@@ -1514,10 +1646,9 @@ function createSlackScheduleRunTaskNowTool(context) {
       const next = {
         ...lookup,
         updatedAtMs: nowMs,
-        runNowAtMs: nowMs,
-        version: lookup.version + 1
+        runNowAtMs: nowMs
       };
-      await createSchedulerStore(context.state).saveTask(next);
+      await schedulerStore(context).saveTask(next);
       return {
         ok: true,
         task: compactTask(next)
@@ -1529,6 +1660,43 @@ function createSlackScheduleRunTaskNowTool(context) {
 // src/plugin.ts
 var SCHEDULER_HEARTBEAT_LIMIT = 10;
 var DASHBOARD_TABLE_LIMIT = 5;
+function singleLineMetadataValue(value) {
+  return value.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function buildScheduledTaskDispatchMetadata(args) {
+  const { run, task } = args;
+  const creator = sanitizeScheduledTaskPrincipal(task.createdBy);
+  if (!task.task.text?.trim()) {
+    throw new Error("Scheduled task text is required");
+  }
+  return {
+    creatorSlackUserId: creator.slackUserId,
+    runId: run.id,
+    schedule: singleLineMetadataValue(task.schedule.description),
+    scheduleKind: task.schedule.kind,
+    scheduledFor: new Date(run.scheduledForMs).toISOString(),
+    runningAt: new Date(args.nowMs).toISOString(),
+    taskId: task.id,
+    timezone: task.schedule.timezone,
+    ...task.schedule.recurrence ? {
+      recurrenceFrequency: task.schedule.recurrence.frequency,
+      recurrenceInterval: String(task.schedule.recurrence.interval),
+      recurrenceStartDate: task.schedule.recurrence.startDate
+    } : {}
+  };
+}
+function scheduledTaskDispatchSource(task) {
+  return createSlackSource({
+    teamId: task.destination.teamId,
+    channelId: task.destination.channelId
+  });
+}
+function schedulerStore2(ctx) {
+  return createSchedulerSqlStore(ctx.db);
+}
+function schedulerOperationalStore(ctx) {
+  return createSchedulerOperationalSqlStore(ctx.db);
+}
 function shouldSkipRun(task, run) {
   if (task.status === "deleted") {
     return `Scheduled task ${task.id} was deleted before the run started.`;
@@ -1544,13 +1712,9 @@ function shouldSkipRun(task, run) {
 function createSchedulerToolContext(ctx) {
   return {
     credentialSubject: ctx.slack?.credentialSubject,
-    source: ctx.source.platform === "slack" ? {
-      platform: "slack",
-      teamId: ctx.source.teamId,
-      channelId: ctx.source.channelId
-    } : void 0,
+    source: ctx.source.platform === "slack" ? ctx.source : void 0,
     requester: ctx.requester?.platform === "slack" ? ctx.requester : void 0,
-    state: ctx.state,
+    store: schedulerStore2(ctx),
     userText: ctx.userText
   };
 }
@@ -1800,7 +1964,7 @@ function createSchedulerPlugin() {
       displayName: "Scheduler",
       description: "Scheduled Junior task management and heartbeat dispatch"
     },
-    legacyStatePrefixes: ["junior:scheduler"],
+    packageName: "@sentry/junior-scheduler",
     hooks: {
       tools(ctx) {
         if (ctx.source.platform !== "slack" || ctx.requester?.platform !== "slack") {
@@ -1816,7 +1980,7 @@ function createSchedulerPlugin() {
         };
       },
       async heartbeat(ctx) {
-        const store = createSchedulerStore(ctx.state);
+        const store = schedulerStore2(ctx);
         let processedCount = 0;
         let dispatchCount = 0;
         for (const run of await store.listIncompleteRuns()) {
@@ -1842,7 +2006,7 @@ function createSchedulerPlugin() {
             processedCount += 1;
           }
         }
-        for (let index = processedCount; index < SCHEDULER_HEARTBEAT_LIMIT; index += 1) {
+        for (let index2 = processedCount; index2 < SCHEDULER_HEARTBEAT_LIMIT; index2 += 1) {
           const run = await store.claimDueRun({ nowMs: ctx.nowMs });
           if (!run) {
             break;
@@ -1865,15 +2029,15 @@ function createSchedulerPlugin() {
             });
             continue;
           }
-          let prompt;
+          let dispatchMetadata;
           try {
-            prompt = buildScheduledTaskRunPrompt({
+            dispatchMetadata = buildScheduledTaskDispatchMetadata({
               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.";
+            const errorMessage = error instanceof Error ? `Scheduled task dispatch metadata could not be built: ${error.message}` : "Scheduled task dispatch metadata could not be built.";
             await blockClaimedRun({
               errorMessage,
               nowMs: ctx.nowMs,
@@ -1888,11 +2052,9 @@ function createSchedulerPlugin() {
               idempotencyKey: run.id,
               ...task.credentialSubject ? { credentialSubject: task.credentialSubject } : {},
               destination: task.destination,
-              input: prompt,
-              metadata: {
-                runId: run.id,
-                taskId: task.id
-              }
+              input: task.task.text,
+              metadata: dispatchMetadata,
+              source: scheduledTaskDispatchSource(task)
             });
           } catch (error) {
             const errorMessage = error instanceof Error ? `Scheduled task dispatch could not be created: ${error.message}` : "Scheduled task dispatch could not be created.";
@@ -1917,7 +2079,13 @@ function createSchedulerPlugin() {
       async operationalReport(ctx) {
         return buildSchedulerOperationalReport({
           nowMs: ctx.nowMs,
-          store: createSchedulerOperationalStore(ctx.state)
+          store: schedulerOperationalStore(ctx)
+        });
+      },
+      async migrateStorage(ctx) {
+        return await migrateSchedulerStateToSql({
+          db: ctx.db,
+          state: ctx.state
         });
       }
     }
@@ -1925,13 +2093,14 @@ function createSchedulerPlugin() {
 }
 var schedulerPlugin = createSchedulerPlugin;
 export {
-  buildScheduledTaskRunPrompt,
+  createSchedulerOperationalSqlStore,
   createSchedulerPlugin,
-  createSchedulerStore,
+  createSchedulerSqlStore,
   createSlackScheduleCreateTaskTool,
   createSlackScheduleDeleteTaskTool,
   createSlackScheduleListTasksTool,
   createSlackScheduleRunTaskNowTool,
   createSlackScheduleUpdateTaskTool,
+  migrateSchedulerStateToSql,
   schedulerPlugin
 };