@sentry/junior-scheduler 0.74.1 → 0.75.0

package/dist/plugin.d.ts

@@ -1,4 +1,4 @@
 /** Create Junior's built-in trusted scheduler plugin. */
-export declare function createSchedulerPlugin(): import("@sentry/junior-plugin-api").JuniorPluginRegistration;
+export declare function createSchedulerPlugin(): import("@sentry/junior-plugin-api").PluginRegistration;
 /** Register trusted scheduler runtime hooks for scheduled Junior tasks. */
 export declare const schedulerPlugin: typeof createSchedulerPlugin;

package/dist/schedule-tools.d.ts

@@ -1,18 +1,19 @@
-import { type AgentPluginCredentialSubject, type AgentPluginState, type AgentPluginToolDefinition, type SlackDestination, type SlackRequester } from "@sentry/junior-plugin-api";
+import { type PluginCredentialSubject, type PluginToolDefinition, type SlackDestination, type SlackRequester } from "@sentry/junior-plugin-api";
+import { type SchedulerStore } from "./store";
 export interface SchedulerToolContext {
-    credentialSubject?: AgentPluginCredentialSubject;
+    credentialSubject?: PluginCredentialSubject;
     requester?: SlackRequester;
     source?: SlackDestination;
-    state: AgentPluginState;
+    store: SchedulerStore;
     userText?: string;
 }
 /** Create a tool that stores a scheduled task for the active Slack context. */
-export declare function createSlackScheduleCreateTaskTool(context: SchedulerToolContext): AgentPluginToolDefinition<any>;
+export declare function createSlackScheduleCreateTaskTool(context: SchedulerToolContext): PluginToolDefinition<any>;
 /** Create a tool that lists scheduled tasks for the active Slack conversation. */
-export declare function createSlackScheduleListTasksTool(context: SchedulerToolContext): AgentPluginToolDefinition<any>;
+export declare function createSlackScheduleListTasksTool(context: SchedulerToolContext): PluginToolDefinition<any>;
 /** Create a tool that edits a scheduled task in the active Slack conversation. */
-export declare function createSlackScheduleUpdateTaskTool(context: SchedulerToolContext): AgentPluginToolDefinition<any>;
+export declare function createSlackScheduleUpdateTaskTool(context: SchedulerToolContext): PluginToolDefinition<any>;
 /** Create a tool that removes a scheduled task from the active Slack conversation. */
-export declare function createSlackScheduleDeleteTaskTool(context: SchedulerToolContext): AgentPluginToolDefinition<any>;
+export declare function createSlackScheduleDeleteTaskTool(context: SchedulerToolContext): PluginToolDefinition<any>;
 /** Create a tool that marks an existing scheduled task due immediately. */
-export declare function createSlackScheduleRunTaskNowTool(context: SchedulerToolContext): AgentPluginToolDefinition<any>;
+export declare function createSlackScheduleRunTaskNowTool(context: SchedulerToolContext): PluginToolDefinition<any>;

package/dist/store.d.ts

@@ -1,4 +1,4 @@
-import { type AgentPluginReadState, type AgentPluginState } from "@sentry/junior-plugin-api";
+import { type PluginDb, type PluginReadState, type PluginState } from "@sentry/junior-plugin-api";
 import type { ScheduledRun, ScheduledTask } from "./types";
 export interface SchedulerStore {
     claimDueRun(args: {
@@ -51,6 +51,20 @@ export interface SchedulerOperationalStore {
     listTasks(): Promise<ScheduledTask[]>;
 }
 /** Create a scheduler store backed by this plugin's durable state namespace. */
-export declare function createSchedulerStore(state: AgentPluginState): SchedulerStore;
+export declare function createSchedulerStore(state: PluginState): SchedulerStore;
 /** Create a read-only scheduler store for operational reporting. */
-export declare function createSchedulerOperationalStore(state: AgentPluginReadState): SchedulerOperationalStore;
+export declare function createSchedulerOperationalStore(state: PluginReadState): SchedulerOperationalStore;
+/** Create a scheduler store backed by the plugin SQL database. */
+export declare function createSchedulerSqlStore(db: PluginDb): SchedulerStore;
+/** Create a read-only scheduler operational store backed by SQL. */
+export declare function createSchedulerOperationalSqlStore(db: PluginDb): SchedulerOperationalStore;
+/** Copy retained scheduler plugin-state records into the scheduler SQL tables. */
+export declare function migrateSchedulerStateToSql(args: {
+    db: PluginDb;
+    state: PluginState;
+}): Promise<{
+    existing: number;
+    migrated: number;
+    missing: number;
+    scanned: number;
+}>;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { AgentPluginCredentialSubject, SlackDestination } from "@sentry/junior-plugin-api";
+import type { PluginCredentialSubject, SlackDestination } from "@sentry/junior-plugin-api";
 export type ScheduledTaskStatus = "active" | "paused" | "blocked" | "deleted";
 export type ScheduledRunStatus = "pending" | "running" | "completed" | "failed" | "blocked" | "skipped";
 export interface ScheduledTaskPrincipal {
@@ -46,7 +46,7 @@ export interface ScheduledTask {
     createdAtMs: number;
     createdBy: ScheduledTaskPrincipal;
     conversationAccess?: ScheduledTaskConversationAccess;
-    credentialSubject?: AgentPluginCredentialSubject;
+    credentialSubject?: PluginCredentialSubject;
     destination: SlackDestination;
     executionActor?: ScheduledTaskExecutionActor;
     lastRunAtMs?: number;
@@ -58,7 +58,6 @@ export interface ScheduledTask {
     statusReason?: string;
     task: ScheduledTaskSpec;
     updatedAtMs: number;
-    version: number;
 }
 export interface ScheduledRun {
     id: string;
@@ -67,11 +66,9 @@ export interface ScheduledRun {
     completedAtMs?: number;
     dispatchId?: string;
     errorMessage?: string;
-    idempotencyKey: string;
     resultMessageTs?: string;
     scheduledForMs: number;
     startedAtMs?: number;
     status: ScheduledRunStatus;
     taskId: string;
-    taskVersion: number;
 }

package/migrations/0001_scheduler.sql

@@ -0,0 +1,35 @@
+CREATE TABLE IF NOT EXISTS junior_scheduler_tasks (
+  id TEXT PRIMARY KEY,
+  team_id TEXT NOT NULL,
+  status TEXT NOT NULL,
+  next_run_at_ms BIGINT,
+  run_now_at_ms BIGINT,
+  created_at_ms BIGINT NOT NULL,
+  record JSONB NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS junior_scheduler_tasks_team_status_idx
+  ON junior_scheduler_tasks (team_id, created_at_ms, id)
+  WHERE status <> 'deleted';
+
+CREATE INDEX IF NOT EXISTS junior_scheduler_tasks_run_now_due_idx
+  ON junior_scheduler_tasks (run_now_at_ms, created_at_ms, id)
+  WHERE status = 'active' AND run_now_at_ms IS NOT NULL;
+
+CREATE INDEX IF NOT EXISTS junior_scheduler_tasks_next_run_due_idx
+  ON junior_scheduler_tasks (next_run_at_ms, created_at_ms, id)
+  WHERE status = 'active' AND next_run_at_ms IS NOT NULL;
+
+CREATE TABLE IF NOT EXISTS junior_scheduler_runs (
+  id TEXT PRIMARY KEY,
+  task_id TEXT NOT NULL,
+  status TEXT NOT NULL,
+  scheduled_for_ms BIGINT NOT NULL,
+  record JSONB NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS junior_scheduler_runs_task_status_idx
+  ON junior_scheduler_runs (task_id, status, scheduled_for_ms);
+
+CREATE INDEX IF NOT EXISTS junior_scheduler_runs_status_idx
+  ON junior_scheduler_runs (status, scheduled_for_ms);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-scheduler",
-  "version": "0.74.1",
+  "version": "0.75.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -19,11 +19,14 @@
   },
   "files": [
     "dist",
+    "migrations",
     "src"
   ],
   "dependencies": {
     "@sinclair/typebox": "^0.34.49",
-    "@sentry/junior-plugin-api": "0.74.1"
+    "drizzle-orm": "^0.45.2",
+    "zod": "^4.4.3",
+    "@sentry/junior-plugin-api": "0.75.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
@@ -32,6 +35,7 @@
   },
   "scripts": {
     "build": "tsup && tsc -p tsconfig.build.json --emitDeclarationOnly",
+    "db:generate": "pnpm dlx drizzle-kit@0.31.10 generate --config drizzle.config.ts",
     "typecheck": "tsc --noEmit"
   }
 }

package/src/db/schema.ts

@@ -0,0 +1,53 @@
+import { sql } from "drizzle-orm";
+import { bigint, index, jsonb, pgTable, text } from "drizzle-orm/pg-core";
+import type { ScheduledRun, ScheduledTask } from "../types";
+
+export const 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<ScheduledTask>().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`,
+      ),
+  ],
+);
+
+export const 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<ScheduledRun>().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,
+    ),
+  ],
+);

package/src/index.ts

@@ -1,5 +1,4 @@
 export { createSchedulerPlugin, schedulerPlugin } from "./plugin";
-export { buildScheduledTaskRunPrompt } from "./prompt";
 export {
   createSlackScheduleCreateTaskTool,
   createSlackScheduleDeleteTaskTool,
@@ -8,7 +7,11 @@ export {
   createSlackScheduleUpdateTaskTool,
   type SchedulerToolContext,
 } from "./schedule-tools";
-export { createSchedulerStore } from "./store";
+export {
+  createSchedulerOperationalSqlStore,
+  createSchedulerSqlStore,
+  migrateSchedulerStateToSql,
+} from "./store";
 export type {
   ScheduledCalendarFrequency,
   ScheduledLocalTime,

package/src/plugin.ts

@@ -1,19 +1,26 @@
 import {
   defineJuniorPlugin,
   type Dispatch,
-  type AgentPluginToolDefinition,
+  type PluginDb,
+  type PluginToolDefinition,
   type PluginOperationalReportContent,
+  type PluginReadState,
+  type PluginState,
   type SlackDestination,
+  type Source,
   type ToolRegistrationHookContext,
 } from "@sentry/junior-plugin-api";
-import { buildScheduledTaskRunPrompt } from "./prompt";
 import {
-  createSchedulerOperationalStore,
-  createSchedulerStore,
+  createSchedulerOperationalSqlStore,
+  createSchedulerSqlStore,
+  migrateSchedulerStateToSql,
   type SchedulerOperationalStore,
   type SchedulerStore,
 } from "./store";
-import { scheduledTaskPrincipalLabel } from "./identity";
+import {
+  sanitizeScheduledTaskPrincipal,
+  scheduledTaskPrincipalLabel,
+} from "./identity";
 import type {
   ScheduledRun,
   ScheduledTask,
@@ -31,6 +38,67 @@ import {
 const SCHEDULER_HEARTBEAT_LIMIT = 10;
 const DASHBOARD_TABLE_LIMIT = 5;
 
+function singleLineMetadataValue(value: string): string {
+  return value
+    .replace(/[\r\n]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function buildScheduledTaskDispatchMetadata(args: {
+  nowMs: number;
+  run: ScheduledRun;
+  task: ScheduledTask;
+}): Record<string, string> {
+  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: ScheduledTask): Source {
+  return {
+    platform: "slack",
+    teamId: task.destination.teamId,
+    channelId: task.destination.channelId,
+  };
+}
+
+function schedulerStore(ctx: { db?: PluginDb }): SchedulerStore {
+  if (!ctx.db) {
+    throw new Error("Scheduler plugin requires ctx.db");
+  }
+  return createSchedulerSqlStore(ctx.db);
+}
+
+function schedulerOperationalStore(ctx: {
+  db?: PluginDb;
+}): SchedulerOperationalStore {
+  if (!ctx.db) {
+    throw new Error("Scheduler plugin requires ctx.db");
+  }
+  return createSchedulerOperationalSqlStore(ctx.db);
+}
+
 function shouldSkipRun(
   task: ScheduledTask,
   run: ScheduledRun,
@@ -64,7 +132,7 @@ function createSchedulerToolContext(
           }
         : undefined,
     requester: ctx.requester?.platform === "slack" ? ctx.requester : undefined,
-    state: ctx.state,
+    store: schedulerStore(ctx),
     userText: ctx.userText,
   };
 }
@@ -73,7 +141,7 @@ async function applyDispatchResult(args: {
   dispatch: Dispatch;
   nowMs: number;
   run: ScheduledRun;
-  store: ReturnType<typeof createSchedulerStore>;
+  store: SchedulerStore;
 }): Promise<boolean> {
   if (args.dispatch.status === "completed") {
     const completed = await args.store.markRunCompleted({
@@ -362,19 +430,20 @@ async function buildSchedulerOperationalReport(args: {
 /** Create Junior's built-in trusted scheduler plugin. */
 export function createSchedulerPlugin() {
   return defineJuniorPlugin({
+    database: {},
     manifest: {
       name: "scheduler",
       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"
         ) {
-          return {} as Record<string, AgentPluginToolDefinition<any>>;
+          return {} as Record<string, PluginToolDefinition<any>>;
         }
         const context = createSchedulerToolContext(ctx);
         return {
@@ -383,10 +452,10 @@ export function createSchedulerPlugin() {
           slackScheduleUpdateTask: createSlackScheduleUpdateTaskTool(context),
           slackScheduleDeleteTask: createSlackScheduleDeleteTaskTool(context),
           slackScheduleRunTaskNow: createSlackScheduleRunTaskNowTool(context),
-        } satisfies Record<string, AgentPluginToolDefinition<any>>;
+        } satisfies Record<string, PluginToolDefinition<any>>;
       },
       async heartbeat(ctx) {
-        const store = createSchedulerStore(ctx.state);
+        const store = schedulerStore(ctx);
         let processedCount = 0;
         let dispatchCount = 0;
         for (const run of await store.listIncompleteRuns()) {
@@ -443,9 +512,9 @@ export function createSchedulerPlugin() {
             continue;
           }
 
-          let prompt: string;
+          let dispatchMetadata: Record<string, string>;
           try {
-            prompt = buildScheduledTaskRunPrompt({
+            dispatchMetadata = buildScheduledTaskDispatchMetadata({
               nowMs: ctx.nowMs,
               run,
               task,
@@ -453,8 +522,8 @@ export function createSchedulerPlugin() {
           } catch (error) {
             const errorMessage =
               error instanceof Error
-                ? `Scheduled task prompt could not be built: ${error.message}`
-                : "Scheduled task prompt could not be built.";
+                ? `Scheduled task dispatch metadata could not be built: ${error.message}`
+                : "Scheduled task dispatch metadata could not be built.";
             await blockClaimedRun({
               errorMessage,
               nowMs: ctx.nowMs,
@@ -471,11 +540,9 @@ export function createSchedulerPlugin() {
                 ? { 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 =
@@ -504,7 +571,16 @@ export function createSchedulerPlugin() {
       async operationalReport(ctx) {
         return buildSchedulerOperationalReport({
           nowMs: ctx.nowMs,
-          store: createSchedulerOperationalStore(ctx.state),
+          store: schedulerOperationalStore(ctx),
+        });
+      },
+      async migrateStorage(ctx) {
+        if (!ctx.db) {
+          throw new Error("Scheduler storage migration requires ctx.db");
+        }
+        return await migrateSchedulerStateToSql({
+          db: ctx.db,
+          state: ctx.state,
         });
       },
     },

package/src/schedule-tools.ts

@@ -1,19 +1,18 @@
 import { randomUUID } from "node:crypto";
 import { Type } from "@sinclair/typebox";
 import {
-  AgentPluginToolInputError,
-  agentPluginCredentialSubjectSchema,
+  PluginToolInputError,
+  pluginCredentialSubjectSchema,
   destinationSchema,
   isSlackDestination,
-  type AgentPluginCredentialSubject,
-  type AgentPluginState,
-  type AgentPluginToolDefinition,
+  type PluginCredentialSubject,
+  type PluginToolDefinition,
   type SlackDestination,
   type SlackRequester,
 } from "@sentry/junior-plugin-api";
 import { buildCalendarRecurrence, parseScheduleTimestamp } from "./cadence";
 import { sanitizeScheduledTaskPrincipal } from "./identity";
-import { createSchedulerStore } from "./store";
+import { type SchedulerStore } from "./store";
 import { SCHEDULED_TASK_SYSTEM_ACTOR } from "./types";
 import type {
   ScheduledCalendarFrequency,
@@ -25,10 +24,10 @@ import type {
 } from "./types";
 
 export interface SchedulerToolContext {
-  credentialSubject?: AgentPluginCredentialSubject;
+  credentialSubject?: PluginCredentialSubject;
   requester?: SlackRequester;
   source?: SlackDestination;
-  state: AgentPluginState;
+  store: SchedulerStore;
   userText?: string;
 }
 
@@ -42,7 +41,7 @@ type SchemaIssue = {
 };
 
 function throwToolInputError(error: string): never {
-  throw new AgentPluginToolInputError(error);
+  throw new PluginToolInputError(error);
 }
 
 function requireActiveConversation(
@@ -99,8 +98,8 @@ function requireRequester(
 }
 
 function tool<TInput = any>(
-  definition: AgentPluginToolDefinition<TInput>,
-): AgentPluginToolDefinition<TInput> {
+  definition: PluginToolDefinition<TInput>,
+): PluginToolDefinition<TInput> {
   return definition;
 }
 
@@ -125,8 +124,8 @@ function getConversationAccess(
 
 function getCredentialSubject(args: {
   access: ScheduledTaskConversationAccess;
-  subject: AgentPluginCredentialSubject | undefined;
-}): AgentPluginCredentialSubject | undefined {
+  subject: PluginCredentialSubject | undefined;
+}): PluginCredentialSubject | undefined {
   if (
     args.access.audience !== "direct" ||
     args.access.visibility !== "private"
@@ -136,7 +135,7 @@ function getCredentialSubject(args: {
   if (!args.subject) {
     return undefined;
   }
-  const subject = agentPluginCredentialSubjectSchema.safeParse(args.subject);
+  const subject = pluginCredentialSubjectSchema.safeParse(args.subject);
   if (!subject.success) {
     throwToolInputError("Active Slack credential subject is invalid.");
   }
@@ -165,9 +164,7 @@ async function getWritableTask(args: {
 }): Promise<ScheduledTask> {
   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.",
@@ -216,7 +213,6 @@ function compactTask(task: ScheduledTask): Record<string, unknown> {
     run_now_at: task.runNowAtMs
       ? new Date(task.runNowAtMs).toISOString()
       : null,
-    version: task.version,
   };
 }
 
@@ -224,6 +220,10 @@ function buildTaskId(): string {
   return `${TASK_ID_PREFIX}_${randomUUID()}`;
 }
 
+function schedulerStore(context: SchedulerToolContext): SchedulerStore {
+  return context.store;
+}
+
 function normalizeStatus(
   value: string | undefined,
 ): ScheduledTaskStatus | undefined {
@@ -299,6 +299,30 @@ function validateRecurringFrequencyLimit(input: { recurrence?: unknown }) {
   }
 }
 
+function validateCreateScheduleKind(input: {
+  recurrence?: unknown;
+  schedule_kind?: unknown;
+}) {
+  if (input.schedule_kind === undefined) {
+    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 !== undefined) {
+    throwToolInputError("Omit recurrence when schedule_kind is one_off.");
+  }
+  if (
+    input.schedule_kind === "recurring" &&
+    (input.recurrence === undefined || input.recurrence === null)
+  ) {
+    throwToolInputError("Provide recurrence when schedule_kind is recurring.");
+  }
+}
+
 function shouldRebuildRecurrence(input: {
   next_run_at?: string;
   recurrence?: unknown;
@@ -343,11 +367,18 @@ export function createSlackScheduleCreateTaskTool(
 ) {
   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.",
+      "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: 4000 }),
       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,
@@ -373,7 +404,7 @@ export function createSlackScheduleCreateTaskTool(
           ],
           {
             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.",
+              "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.",
           },
         ),
       ),
@@ -384,6 +415,7 @@ export function createSlackScheduleCreateTaskTool(
 
       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.");
@@ -424,10 +456,9 @@ export function createSlackScheduleCreateTaskTool(
         task: {
           text: input.task,
         },
-        version: 1,
       };
 
-      await createSchedulerStore(context.state).saveTask(task);
+      await schedulerStore(context).saveTask(task);
       return {
         ok: true,
         task: compactTask(task),
@@ -448,7 +479,7 @@ export function createSlackScheduleListTasksTool(
     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((task) =>
@@ -571,10 +602,9 @@ export function createSlackScheduleUpdateTaskTool(
           recurrence,
         },
         task: input.task ? { text: input.task } : lookup.task,
-        version: lookup.version + 1,
       };
 
-      await createSchedulerStore(context.state).saveTask(next);
+      await schedulerStore(context).saveTask(next);
       return {
         ok: true,
         task: compactTask(next),
@@ -607,10 +637,9 @@ export function createSlackScheduleDeleteTaskTool(
         status: "deleted",
         nextRunAtMs: undefined,
         runNowAtMs: undefined,
-        version: lookup.version + 1,
       };
 
-      await createSchedulerStore(context.state).saveTask(next);
+      await schedulerStore(context).saveTask(next);
       return {
         ok: true,
         task: compactTask(next),
@@ -647,10 +676,9 @@ export function createSlackScheduleRunTaskNowTool(
         ...lookup,
         updatedAtMs: nowMs,
         runNowAtMs: nowMs,
-        version: lookup.version + 1,
       };
 
-      await createSchedulerStore(context.state).saveTask(next);
+      await schedulerStore(context).saveTask(next);
       return {
         ok: true,
         task: compactTask(next),