@sentry/junior 0.128.1 → 0.129.0

package/dist/app.js

@@ -50,7 +50,7 @@ import {
   startConversationWork,
   startSlackProcessingReaction,
   stripLeadingBotMention
-} from "./chunk-54KP2EAH.js";
+} from "./chunk-CZJUBH6O.js";
 import "./chunk-FA6POGLH.js";
 import {
   ConversationTurnLifecycleService,
@@ -65,13 +65,13 @@ import {
   processPluginTask,
   requireTurnFailureEventId,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-S2O64VXP.js";
+} from "./chunk-ESYXDXNX.js";
 import {
   GET,
   conversationVisibilityFromSlackChannelType,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext
-} from "./chunk-PLAMHS3D.js";
+} from "./chunk-GURSWCI4.js";
 import "./chunk-4CODA7P5.js";
 import "./chunk-UTL3MHPC.js";
 import {
@@ -90,7 +90,7 @@ import {
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-O3C5BJFD.js";
+} from "./chunk-E4UCPRYL.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -112,7 +112,6 @@ import {
   deliverResourceEventSubscription,
   executeAgentRun,
   executeCredentialedEgressRequest,
-  findMatchingEventTasks,
   findMatchingResourceEventSubscriptions,
   getConfigDefaults,
   latestReportedProgress,
@@ -122,10 +121,11 @@ import {
   renderSlackLegacyAttachmentText,
   resolveDestinationVisibility,
   resolveSandboxEgressProviderForHost,
+  sanitizeScheduledTaskPrincipal,
   setConfigDefaults,
   shouldEmitDevAgentTrace,
   shouldPropagateSandboxEgressTrace
-} from "./chunk-AAMF2IRC.js";
+} from "./chunk-6QQOLIJJ.js";
 import "./chunk-DIB4GX3G.js";
 import {
   RetryableDeliveryError,
@@ -136,7 +136,7 @@ import {
   formatProviderLabel,
   postSlackMessage,
   startOAuthFlow
-} from "./chunk-ETGUGGO2.js";
+} from "./chunk-6CMYU62S.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
@@ -192,16 +192,19 @@ import {
   trimTrailingAssistantMessages,
   updateConversationStats,
   upsertConversationMessage
-} from "./chunk-OIQCRZ67.js";
+} from "./chunk-U23X4ASF.js";
 import "./chunk-EPBBYMNE.js";
 import {
   getSandboxResourceConfig,
   setSandboxResourceConfig
-} from "./chunk-P7UUNWC4.js";
-import "./chunk-REHOYCYS.js";
+} from "./chunk-XENYUOZG.js";
+import {
+  createSchedulerSqlStore,
+  findMatchingEventTasks
+} from "./chunk-BDIEEZK7.js";
 import {
   parseSlackThreadId
-} from "./chunk-LIJ4APSS.js";
+} from "./chunk-LV2BQ26V.js";
 import "./chunk-HX236W2U.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
@@ -229,7 +232,7 @@ import {
   verifyEventTaskCredentialSubject,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-H4HMCSOZ.js";
+} from "./chunk-QAOA4GUG.js";
 import {
   contextProvenance,
   createSlackDestination,
@@ -240,16 +243,16 @@ import {
   instructionProvenanceFor,
   requireSlackDestination,
   withConversationEventLock
-} from "./chunk-J3YIO3LE.js";
+} from "./chunk-PQFNTLZI.js";
 import {
   juniorConversationEvents,
   juniorConversations
-} from "./chunk-SHMHHXD5.js";
+} from "./chunk-KB2M27DL.js";
 import {
   acquireActiveLock,
   getStateAdapter,
   sleep
-} from "./chunk-MZ6ZOWMJ.js";
+} from "./chunk-3N4MWF3R.js";
 import {
   STANDARD_MODEL_PROFILE,
   botConfig,
@@ -267,16 +270,16 @@ import {
   modelIdForProfile,
   setSlackReactionConfig,
   standardModelId
-} from "./chunk-5IR7SGRO.js";
+} from "./chunk-2BCQKJTX.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
-import "./chunk-EHEACYJ6.js";
-import "./chunk-EOIA25WC.js";
+import "./chunk-GPWHBHAG.js";
+import "./chunk-R62DRNKB.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-R2LXTX4J.js";
-import "./chunk-O3YROBH4.js";
+} from "./chunk-A6QQPVSH.js";
+import "./chunk-CZQ2DSQZ.js";
 import {
   credentialSubjectSchema
 } from "./chunk-77VDLF3Z.js";
@@ -308,7 +311,7 @@ import {
   withContext,
   withLogContext,
   withSpan
-} from "./chunk-TONH5NXR.js";
+} from "./chunk-P6I7LFKC.js";
 import {
   continueTrace
 } from "./chunk-6GWA276C.js";
@@ -316,10 +319,10 @@ import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
 import {
   JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE
-} from "./chunk-Q5TMMCBV.js";
+} from "./chunk-K3U5447S.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-MKM5552O.js";
+} from "./chunk-NNRV4T2C.js";
 import "./chunk-MLKGABMK.js";
 
 // src/app.ts
@@ -1236,6 +1239,11 @@ async function recoverConversationWork(args) {
   return result;
 }
 
+// src/chat/scheduled-tasks/heartbeat.ts
+import {
+  createSlackSource
+} from "@sentry/junior-plugin-api";
+
 // src/chat/agent-dispatch/validation.ts
 import {
   dispatchOptionsSchema,
@@ -1470,6 +1478,264 @@ async function dispatchEventTask(args) {
     plugin
   });
 }
+async function dispatchScheduledTask(args) {
+  const plugin = "scheduler";
+  const { credentialSubject, ...unboundOptions } = args.options;
+  validateDispatchOptions({ ...unboundOptions });
+  const boundSubject = credentialSubject ? bindScheduledTaskCredentialSubject({
+    plugin,
+    subject: credentialSubject
+  }) : void 0;
+  if (credentialSubject && !boundSubject) {
+    throw new Error("Dispatch credentialSubject is not valid for this action");
+  }
+  const options = {
+    ...unboundOptions,
+    ...boundSubject ? { credentialSubject: boundSubject } : {}
+  };
+  return await dispatch({
+    conversationWorkQueue: args.conversationWorkQueue,
+    nowMs: args.nowMs,
+    options,
+    plugin
+  });
+}
+async function getScheduledTaskDispatch(id) {
+  return await getPluginDispatchProjection({ plugin: "scheduler", id });
+}
+
+// src/chat/scheduled-tasks/heartbeat.ts
+var SCHEDULED_TASK_HEARTBEAT_LIMIT = 10;
+var SCHEDULE_FREQUENCY_COPY = {
+  daily: { label: "Daily", unit: "day" },
+  weekly: { label: "Weekly", unit: "week" },
+  monthly: { label: "Monthly", unit: "month" },
+  yearly: { label: "Yearly", unit: "year" }
+};
+function singleLineMetadataValue(value) {
+  return value.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function buildDispatchMetadata(args) {
+  const creator = sanitizeScheduledTaskPrincipal(args.task.createdBy);
+  if (!args.task.task.text?.trim()) {
+    throw new Error("Scheduled task text is required");
+  }
+  return {
+    creatorSlackUserId: creator.slackUserId,
+    runId: args.run.id,
+    schedule: singleLineMetadataValue(args.task.schedule.description),
+    scheduleKind: args.task.schedule.kind,
+    scheduledFor: new Date(args.run.scheduledForMs).toISOString(),
+    runningAt: new Date(args.nowMs).toISOString(),
+    taskId: args.task.id,
+    timezone: args.task.schedule.timezone,
+    ...args.task.schedule.recurrence ? {
+      recurrenceFrequency: args.task.schedule.recurrence.frequency,
+      recurrenceInterval: String(args.task.schedule.recurrence.interval),
+      recurrenceStartDate: args.task.schedule.recurrence.startDate
+    } : {}
+  };
+}
+function replyAttribution(task) {
+  if (task.schedule.kind === "one_off") {
+    return { label: "Scheduled task", detail: "One-time" };
+  }
+  const recurrence = task.schedule.recurrence;
+  if (!recurrence) {
+    return { label: "Scheduled task", detail: "Recurring" };
+  }
+  const frequency = SCHEDULE_FREQUENCY_COPY[recurrence.frequency];
+  return recurrence.interval === 1 ? { label: "Scheduled task", detail: frequency.label } : {
+    label: "Scheduled task",
+    detail: `Every ${recurrence.interval} ${frequency.unit}s`
+  };
+}
+function dispatchSource(task) {
+  return createSlackSource({
+    teamId: task.destination.teamId,
+    channelId: task.destination.channelId,
+    visibility: task.conversationAccess.visibility
+  });
+}
+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;
+}
+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 finishClaimedRun(args) {
+  const finished = args.status === "blocked" ? await args.store.markRunBlocked({
+    completedAtMs: args.nowMs,
+    errorMessage: args.errorMessage,
+    runId: args.run.id
+  }) : await args.store.markRunFailed({
+    completedAtMs: args.nowMs,
+    errorMessage: args.errorMessage,
+    runId: args.run.id,
+    startedAtMs: args.run.startedAtMs
+  });
+  if (!finished) return;
+  await args.store.updateTaskAfterRun({
+    errorMessage: args.errorMessage,
+    nowMs: args.nowMs,
+    run: args.run,
+    status: args.status
+  });
+}
+async function runScheduledTaskHeartbeat(args) {
+  const store = createSchedulerSqlStore(getDb());
+  let processedCount = 0;
+  let dispatchCount = 0;
+  for (const run of await store.listIncompleteRuns()) {
+    if (!run.dispatchId) continue;
+    const dispatch2 = await getScheduledTaskDispatch(run.dispatchId);
+    if (!dispatch2) {
+      await finishClaimedRun({
+        errorMessage: "Scheduled task dispatch record is missing.",
+        nowMs: args.nowMs,
+        run,
+        status: "failed",
+        store
+      });
+      continue;
+    }
+    if (await applyDispatchResult({ dispatch: dispatch2, nowMs: args.nowMs, run, store })) {
+      processedCount += 1;
+    }
+  }
+  for (let index = processedCount; index < SCHEDULED_TASK_HEARTBEAT_LIMIT; index += 1) {
+    const run = await store.claimDueRun({ nowMs: args.nowMs });
+    if (!run) break;
+    const task = await store.getTask(run.taskId);
+    if (!task) {
+      await store.markRunFailed({
+        completedAtMs: args.nowMs,
+        errorMessage: `Scheduled task ${run.taskId} was not found`,
+        runId: run.id
+      });
+      continue;
+    }
+    const skippedReason = shouldSkipRun(task, run);
+    if (skippedReason) {
+      await store.markRunSkipped({
+        completedAtMs: args.nowMs,
+        errorMessage: skippedReason,
+        runId: run.id
+      });
+      continue;
+    }
+    let metadata;
+    try {
+      metadata = buildDispatchMetadata({ nowMs: args.nowMs, run, task });
+    } catch (error) {
+      await finishClaimedRun({
+        errorMessage: error instanceof Error ? `Scheduled task dispatch metadata could not be built: ${error.message}` : "Scheduled task dispatch metadata could not be built.",
+        nowMs: args.nowMs,
+        run,
+        status: "blocked",
+        store
+      });
+      continue;
+    }
+    let dispatch2;
+    try {
+      dispatch2 = await dispatchScheduledTask({
+        conversationWorkQueue: args.conversationWorkQueue,
+        nowMs: args.nowMs,
+        options: {
+          idempotencyKey: run.id,
+          ...task.credentialMode === "creator" ? {
+            credentialSubject: {
+              type: "user",
+              userId: task.createdBy.slackUserId,
+              allowedWhen: "scheduled-task",
+              taskId: task.id
+            }
+          } : {},
+          destination: task.destination,
+          destinationVisibility: task.conversationAccess.visibility,
+          input: task.task.text,
+          metadata,
+          replyAttribution: replyAttribution(task),
+          source: dispatchSource(task)
+        }
+      });
+    } catch (error) {
+      await finishClaimedRun({
+        errorMessage: error instanceof Error ? `Scheduled task dispatch could not be created: ${error.message}` : "Scheduled task dispatch could not be created.",
+        nowMs: args.nowMs,
+        run,
+        status: "blocked",
+        store
+      });
+      continue;
+    }
+    await store.markRunDispatched({
+      claimedAtMs: run.claimedAtMs,
+      dispatchId: dispatch2.id,
+      nowMs: args.nowMs,
+      runId: run.id
+    });
+    dispatchCount += 1;
+  }
+  return dispatchCount;
+}
 
 // src/chat/agent-dispatch/heartbeat.ts
 var DEFAULT_PLUGIN_LIMIT = 25;
@@ -1571,6 +1837,19 @@ async function runHeartbeat(args) {
     conversationWorkQueue: queue,
     nowMs: args.nowMs
   });
+  try {
+    const dispatchCount = await runScheduledTaskHeartbeat({
+      conversationWorkQueue: queue,
+      nowMs: args.nowMs
+    });
+    if (dispatchCount > 0) {
+      logInfo("scheduled_tasks.heartbeat.dispatched", {
+        "app.dispatch.count": dispatchCount
+      });
+    }
+  } catch (error) {
+    logException(error, "scheduled_tasks.heartbeat.failed");
+  }
   await runPluginHeartbeats({
     conversationWorkQueue: queue,
     nowMs: args.nowMs
@@ -6259,7 +6538,7 @@ function createJuniorRuntimeServices(overrides = {}) {
 }
 
 // src/chat/runtime/reply-executor.ts
-import { createSlackSource } from "@sentry/junior-plugin-api";
+import { createSlackSource as createSlackSource2 } from "@sentry/junior-plugin-api";
 
 // src/chat/slack/message.ts
 function getSlackMessageTs(message) {
@@ -6549,7 +6828,7 @@ function createReplyToThread(deps) {
     const assistantThreadContext = getAssistantThreadContext(message);
     const messageTs = getMessageTs(message);
     const teamId = destination.teamId;
-    const source = options.execution?.source ?? createSlackSource({
+    const source = options.execution?.source ?? createSlackSource2({
       channelId: channelId ?? destination.channelId,
       messageTs,
       teamId,
@@ -8958,7 +9237,7 @@ async function ingestResourceEvent(input, options) {
 // src/chat/event-tasks/ingest.ts
 import { createHash as createHash2 } from "crypto";
 import {
-  createSlackSource as createSlackSource2,
+  createSlackSource as createSlackSource3,
   RESOURCE_EVENT_SUMMARY_MAX_LENGTH,
   RESOURCE_EVENT_TEXT_MAX_LENGTH,
   resourceEventSchema as resourceEventSchema2
@@ -9021,7 +9300,7 @@ async function ingestEventTasks(input, options) {
           destination: task.destination,
           destinationVisibility: task.destinationVisibility,
           input: eventInput(task, event),
-          source: createSlackSource2({
+          source: createSlackSource3({
             teamId: task.destination.teamId,
             channelId: task.destination.channelId,
             visibility: task.destinationVisibility
@@ -9196,6 +9475,7 @@ function dashboardHostRoutePaths(dashboard) {
     `${pagePath("locations")}/*`,
     peoplePath,
     `${peoplePath}/*`,
+    pagePath("tasks"),
     pagePath("system"),
     `${pagePath("system")}/*`,
     pagePath("plugins"),
@@ -9219,6 +9499,8 @@ function dashboardHostRoutePaths(dashboard) {
     "/api/plugin-reports",
     "/api/user-pages",
     "/api/user-pages/*",
+    "/api/tasks",
+    "/api/tasks/*",
     "/api/skills",
     "/api/stats",
     "/api/conversations",

package/dist/{catalog-runtime-KLSYFS4A.js → catalog-runtime-TN2GPVEI.js}

@@ -1,16 +1,16 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-R2LXTX4J.js";
-import "./chunk-O3YROBH4.js";
+} from "./chunk-A6QQPVSH.js";
+import "./chunk-CZQ2DSQZ.js";
 import "./chunk-77VDLF3Z.js";
 import "./chunk-HZF5P5UN.js";
 import "./chunk-F3B2YJ76.js";
-import "./chunk-TONH5NXR.js";
+import "./chunk-P6I7LFKC.js";
 import "./chunk-6GWA276C.js";
 import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
-import "./chunk-Q5TMMCBV.js";
-import "./chunk-MKM5552O.js";
+import "./chunk-K3U5447S.js";
+import "./chunk-NNRV4T2C.js";
 import "./chunk-MLKGABMK.js";
 export {
   pluginCatalogRuntime

package/dist/chat/agent-dispatch/context.d.ts

@@ -23,3 +23,21 @@ export declare function dispatchEventTask(args: {
     id: string;
     status: "already_exists" | "created";
 }>;
+/** Create and enqueue one core-owned scheduled task dispatch. */
+export declare function dispatchScheduledTask(args: {
+    conversationWorkQueue: ConversationWorkQueue;
+    nowMs: number;
+    options: Omit<SlackDispatchOptions, "credentialSubject"> & {
+        credentialSubject?: {
+            allowedWhen: "scheduled-task";
+            taskId: string;
+            type: "user";
+            userId: string;
+        };
+    };
+}): Promise<{
+    id: string;
+    status: "already_exists" | "created";
+}>;
+/** Read the bounded outcome for one core-owned scheduled task dispatch. */
+export declare function getScheduledTaskDispatch(id: string): Promise<import("./types").DispatchProjection | undefined>;

package/dist/chat/event-tasks/store.d.ts

@@ -1,4 +1,4 @@
-import { type ResourceEvent } from "@sentry/junior-plugin-api";
+import { type ResourceEvent, type User } from "@sentry/junior-plugin-api";
 import type { JuniorDatabase } from "@/db/db";
 import { type EventTask } from "./types";
 /** Read one event task by id. */
@@ -11,5 +11,11 @@ export declare function saveEventTask(db: JuniorDatabase, task: EventTask): Prom
 export declare function deleteEventTask(db: JuniorDatabase, id: string): Promise<EventTask | undefined>;
 /** List event tasks in one Slack workspace. */
 export declare function listEventTasksForTeam(db: JuniorDatabase, teamId: string): Promise<EventTask[]>;
+/** Return whether one event task was created by a viewer-linked Slack identity. */
+export declare function eventTaskBelongsToUser(task: EventTask, user: User): boolean;
+/** List a bounded newest-first page of event tasks created by one user. */
+export declare function listEventTasksCreatedBy(db: JuniorDatabase, user: User, limit: number): Promise<EventTask[]>;
+/** List event tasks whose current Slack destination is public. */
+export declare function listPublicEventTasksForTeams(db: JuniorDatabase, teamIds: string[], limit: number): Promise<EventTask[]>;
 /** Find every task matching one normalized resource event. */
 export declare function findMatchingEventTasks(db: JuniorDatabase, event: ResourceEvent, teamId: string): Promise<EventTask[]>;

package/dist/chat/event-tasks/tool-support.d.ts

@@ -102,6 +102,7 @@ export declare function eventTaskMatchesDestination(task: EventTask, destination
 }): boolean;
 /** Load one task only when it belongs to this Slack channel or DM. */
 export declare function writableEventTask(context: ToolRuntimeContext, id: string): Promise<EventTask>;
+export declare function eventTaskTriggerAvailable(task: EventTask, catalog: ResourceEventCatalog): boolean;
 /** Project an event task into the bounded tool-result shape. */
 export declare function compactEventTask(task: EventTask, catalog: ResourceEventCatalog): {
     id: string;

package/dist/chat/resource-events/runtime-catalog.d.ts

@@ -0,0 +1,3 @@
+import type { ResourceEventCatalog } from "@/chat/resource-events/catalog";
+/** Read enabled plugin resource-event registrations as one core catalog. */
+export declare function getResourceEventCatalog(): ResourceEventCatalog;

package/dist/chat/scheduled-tasks/cadence.d.ts

@@ -0,0 +1,27 @@
+/** Calendar arithmetic for core-owned scheduled tasks. */
+import type { ScheduledLocalTime, ScheduledTask, ScheduledTaskRecurrence } from "./types";
+export interface ZonedDateTimeParts {
+    day: number;
+    hour: number;
+    minute: number;
+    month: number;
+    second: number;
+    weekday: number;
+    year: number;
+}
+/** Resolve a UTC timestamp into calendar parts for a named time zone. */
+export declare function getZonedDateTimeParts(timestampMs: number, timezone: string): ZonedDateTimeParts;
+/** Resolve local time, rejecting DST gaps and choosing the earlier instant in a fold. */
+export declare function resolveLocalScheduleAtMs(args: {
+    date: string;
+    time: ScheduledLocalTime;
+    timezone: string;
+}): number | undefined;
+/** Compute the first recurring calendar occurrence strictly after a timestamp. */
+export declare function getFirstRunAtMs(args: {
+    afterMs: number;
+    recurrence: ScheduledTaskRecurrence;
+    timezone: string;
+}): number | undefined;
+/** Return the next fire time after a completed run, when the task recurs. */
+export declare function getNextRunAtMs(task: ScheduledTask, scheduledForMs: number, afterMs?: number): number | undefined;

package/dist/chat/scheduled-tasks/heartbeat.d.ts

@@ -0,0 +1,6 @@
+import type { ConversationWorkQueue } from "@/chat/task-execution/queue";
+/** Reconcile completed dispatches and enqueue a bounded batch of due tasks. */
+export declare function runScheduledTaskHeartbeat(args: {
+    conversationWorkQueue: ConversationWorkQueue;
+    nowMs: number;
+}): Promise<number>;

package/dist/chat/scheduled-tasks/identity.d.ts

@@ -0,0 +1,6 @@
+/** Presentation helpers for persisted scheduled-task creators. */
+import type { ScheduledTaskPrincipal } from "./types";
+/** Keep scheduler creator metadata from promoting Slack IDs into display names. */
+export declare function sanitizeScheduledTaskPrincipal(principal: ScheduledTaskPrincipal): ScheduledTaskPrincipal;
+/** Render scheduler creator metadata without inventing human profile fields. */
+export declare function scheduledTaskPrincipalLabel(principal: ScheduledTaskPrincipal): string;

package/dist/chat/scheduled-tasks/personal.d.ts

@@ -0,0 +1,26 @@
+/** Viewer-scoped scheduled-task queries and mutations. */
+import type { User } from "@sentry/junior-plugin-api";
+import type { SchedulerStore } from "./store";
+import type { ScheduledTask } from "./types";
+type PersonalScheduledTaskStore = Pick<SchedulerStore, "getTask" | "listTasksCreatedBy" | "saveTask">;
+export interface ViewerScheduledTaskPage {
+    nextCursor?: string;
+    tasks: ScheduledTask[];
+}
+export interface ViewerScheduledTaskPageInput {
+    cursor?: string;
+    limit: number;
+    query?: string;
+}
+export declare class InvalidScheduledTaskCursorError extends Error {
+    constructor();
+}
+export declare class PersonalScheduledTaskNotFoundError extends Error {
+    constructor();
+}
+/** Build scheduled-task operations limited to tasks created by one user. */
+export declare function createViewerScheduledTasks(store: PersonalScheduledTaskStore, user: User): {
+    delete(id: string, nowMs?: number): Promise<void>;
+    list(input: ViewerScheduledTaskPageInput): Promise<ViewerScheduledTaskPage>;
+};
+export {};