@sentry/junior 0.178.0 → 0.180.0

package/dist/catalog-runtime-WXKGUF3W.js

@@ -0,0 +1,14 @@
+import {
+  pluginCatalogRuntime
+} from "./chunk-DRHEGXTZ.js";
+import "./chunk-2YIRH4E3.js";
+import "./chunk-CEMMLV5L.js";
+import "./chunk-N7TMSOZH.js";
+import "./chunk-DWPN6SCH.js";
+import "./chunk-TXKUKMVO.js";
+import "./chunk-RAZG3YHC.js";
+import "./chunk-PEQXYSSE.js";
+import "./chunk-ZM7ZURJS.js";
+export {
+  pluginCatalogRuntime
+};

package/dist/chat/agent/sandbox.d.ts

@@ -31,8 +31,6 @@ export interface AgentSandboxOptions {
     actor?: Actor;
     locationConfiguration?: LocationConfigurationService;
     configurationValues: Record<string, unknown>;
-    /** Durable-worker soft yield for long Workspace snapshot waits. */
-    shouldYield?: () => boolean;
     getActiveSkill(): Skill | null;
     prepareSandbox(workspace: SandboxWorkspace): void | Promise<void>;
     prepareWorkspace?(workspace: SandboxWorkspace, recipe: Workspace, signal?: AbortSignal): Promise<void>;

package/dist/chat/api-turns/routing.d.ts

@@ -10,6 +10,10 @@ declare const apiTurnMailboxMetadataSchema: z.ZodObject<{
     messageId: z.ZodString;
 }, z.core.$strict>;
 export type ApiTurnMailboxMetadata = z.output<typeof apiTurnMailboxMetadataSchema>;
+/** Return the active root API Turn for one Conversation, if it has one. */
+export declare function getActiveApiTurnId(conversationId: string): Promise<string | undefined>;
+/** Return the idle auth-paused root API Turn for one Conversation. */
+export declare function getAuthPausedApiTurnId(conversationId: string): Promise<string | undefined>;
 /**
  * Resolve API Turn work from mailbox metadata or an active checkpoint.
  *

package/dist/chat/api-turns/work.d.ts

@@ -47,6 +47,11 @@ export declare function createApiConversationId(args: {
     actorEmail: string;
     idempotencyKey: string;
 }): string;
+/** Build the retry-stable Message id used by one API mailbox request. */
+export declare function apiConversationMessageId(args: {
+    conversationId: string;
+    idempotencyKey: string;
+}): string;
 /** Stable turn id for one API mailbox message (matches getTurnUserMessage). */
 export declare function apiTurnIdForMessage(messageId: string): string;
 /** Rebuild the dashboard actor from durable conversation identity. */

package/dist/chat/config.d.ts

@@ -1,5 +1,5 @@
 import { type TurnReasoningLevel } from "@/chat/reasoning-level";
-import { type ExecutionProfileConfig } from "@/chat/model-profile";
+import { type ModelProfileConfig, type ModelProfile } from "@/chat/model-profile";
 export declare const DEFAULT_SQL_STATEMENT_TIMEOUT_MS = 30000;
 /**
  * Buffer between the Vercel function timeout and the agent turn timeout so
@@ -11,12 +11,13 @@ export declare const CONVERSATION_WORK_SOFT_YIELD_BUFFER_SECONDS = 40;
 export interface BotConfig {
     contextWindowTokens: number;
     crossActorMidRunMode: CrossActorMidRunMode;
+    defaultProfile: ModelProfile;
     embeddingModelId: string;
     fastModelId: string;
     guardianModelId: string;
     imageGenerationModelId: string;
     loadingMessages: string[];
-    profiles: Readonly<Record<string, ExecutionProfileConfig>>;
+    profiles: Readonly<Record<string, ModelProfileConfig>>;
     reasoningLevel?: TurnReasoningLevel;
     visionModelId?: string;
     maxSlicesPerTurn: number;
@@ -73,6 +74,8 @@ export interface SlackReactionConfig {
     completedReactionEmoji: string;
     processingReactionEmoji: string;
 }
+/** Apply profiles from createApp(). */
+export declare function setProfiles(profiles: Readonly<Record<string, string>> | undefined, defaultProfile: string | undefined): void;
 /** Return the current Slack reaction emoji config. */
 export declare function getSlackReactionConfig(): SlackReactionConfig;
 /** Apply Slack reaction emoji overrides from createApp() options, validating names. */

package/dist/chat/configuration/defaults.d.ts

@@ -1,4 +1,4 @@
 /** Store install-wide configuration defaults. */
-export declare function setConfigDefaults(defaults: Record<string, unknown> | undefined): void;
+export declare function setConfigDefaults(defaults: unknown): void;
 /** Return the install-wide configuration defaults (empty object when none set). */
 export declare function getConfigDefaults(): Record<string, unknown>;

package/dist/chat/conversations/projection.d.ts

@@ -145,14 +145,16 @@ export declare function recordSubscribedReplyRoute(args: {
     shouldReply: boolean;
     shouldUnsubscribe?: boolean;
 }): Promise<void>;
-/** Load a previously selected execution profile for a resumed turn. */
+/** Load a previously selected model profile for a resumed turn. */
 export declare function loadTurnRoute(args: {
     conversationId: string;
     turnId: string;
-}): Promise<Extract<ConversationEvent["data"], {
+}): Promise<(Extract<ConversationEvent["data"], {
     type: "turn_routed";
-}> | undefined>;
-/** Record the execution profile selected for one turn without changing agent history. */
+}> & {
+    seq: number;
+}) | undefined>;
+/** Record the model profile selected for one turn without changing agent history. */
 export declare function recordTurnRoute(args: {
     conversationId: string;
     turnId: string;

package/dist/chat/ingress/message-router.d.ts

@@ -1,5 +1,8 @@
+import { Message } from "chat";
 export type ThreadMessageKind = "new_mention" | "subscribed_message";
 /** Derive canonical Slack thread IDs from the raw event payload. */
+/** Rebuild a Message onto a normalized Slack thread id. */
+export declare function withNormalizedThreadId(message: Message, threadId: string): Message;
 export declare function normalizeIncomingSlackThreadId(threadId: string, message: unknown): string;
 /** Classify an incoming message as a mention or subscribed message. */
 export declare function determineThreadMessageKind(args: {

package/dist/chat/model-profile.d.ts

@@ -1,14 +1,12 @@
 import { z } from "zod";
 import type { BotConfig } from "@/chat/config";
 import type { TurnReasoningLevel } from "@/chat/reasoning-level";
-export declare const STANDARD_MODEL_PROFILE = "standard";
-export declare const DEFAULT_HANDOFF_MODEL_PROFILE = "handoff";
 /** Keep durable profile names stable and safe to expose in tool schemas. */
 export declare const modelProfileSchema: z.ZodString;
-/** A configured model role rather than a provider-specific model id. */
+/** A configured name for a model. */
 export type ModelProfile = z.output<typeof modelProfileSchema>;
-/** Runtime configuration for one named execution profile. */
-export interface ExecutionProfileConfig {
+/** Runtime configuration for one named model profile. */
+export interface ModelProfileConfig {
     modelId: string;
     reasoningLevel?: TurnReasoningLevel;
 }
@@ -16,9 +14,9 @@ export interface ExecutionProfileConfig {
 export declare class ModelProfileNotConfiguredError extends Error {
     constructor(profile: ModelProfile);
 }
-/** Resolve a stable model profile through the host-owned model catalog. */
+/** Resolve a model id from a configured profile. */
 export declare function modelIdForProfile(config: BotConfig, profile: ModelProfile): string;
-/** Resolve the standard execution profile's model. */
-export declare function standardModelId(config: BotConfig): string;
-/** Resolve a stable model profile through the host-owned profile catalog. */
-export declare function profileConfig(config: BotConfig, profile: ModelProfile): ExecutionProfileConfig;
+/** Resolve the configured default profile's model. */
+export declare function defaultModelId(config: BotConfig): string;
+/** Return one configured profile. */
+export declare function profileConfig(config: BotConfig, profile: ModelProfile): ModelProfileConfig;

package/dist/chat/pi/conversation-events.d.ts

@@ -13,7 +13,7 @@ export interface PiConversationProjection {
     messages: PiMessage[];
     provenance: ConversationMessageProvenance[];
     modelProfile: ModelProfile;
-    modelId: string | undefined;
+    replacementSeq: number | undefined;
 }
 /** Pi context with the source event sequence for every projected message. */
 export interface PiConversationEventProjection extends PiConversationProjection {
@@ -32,6 +32,7 @@ export declare function piMessageFromHistoryItem(data: AgentHistoryItem): PiMess
  * Host-only events are filtered, completed authorization becomes a synthetic
  * observation, and `maxSeq` reproduces an exact committed boundary.
  */
-export declare function projectConversationEvents(events: ConversationEvent[], options?: {
+export declare function projectConversationEvents(events: ConversationEvent[], options: {
+    defaultProfile: ModelProfile;
     maxSeq?: number;
 }): PiConversationEventProjection;

package/dist/chat/plugins/task-queue.d.ts

@@ -1,5 +1,42 @@
-import { type PluginTaskQueueMessage } from "./task-message";
+import { z } from "zod";
+/** Deploy topic name. Keep stable for Vercel queue wiring. */
 export declare const PLUGIN_TASK_QUEUE_TOPIC = "junior_plugin_tasks";
-export declare const PLUGIN_TASK_QUEUE_RETENTION_SECONDS: number;
-/** Send one plugin task wakeup through Vercel Queues. */
+export declare const pluginTaskParamsSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+    sessionId: z.ZodString;
+}, z.core.$strict>;
+export type PluginTaskParams = z.output<typeof pluginTaskParamsSchema>;
+export declare const pluginTaskQueueMessageSchema: z.ZodObject<{
+    name: z.ZodString;
+    params: z.ZodObject<{
+        conversationId: z.ZodString;
+        sessionId: z.ZodString;
+    }, z.core.$strict>;
+    plugin: z.ZodString;
+}, z.core.$strict>;
+export type PluginTaskQueueMessage = z.output<typeof pluginTaskQueueMessageSchema>;
+/** Build the stable id used for delivery dedupe and tracing. */
+export declare function pluginTaskId(args: {
+    name: string;
+    params: PluginTaskParams;
+    plugin: string;
+}): string;
+/** Sign a plugin task message for tests and local checks. */
+export declare function signPluginTaskQueueMessage(message: PluginTaskQueueMessage, nowMs?: number): {
+    name: string;
+    params: {
+        conversationId: string;
+        sessionId: string;
+    };
+    plugin: string;
+} & {
+    signature: string;
+    signatureVersion: "v1";
+    signedAtMs: number;
+};
+/** Send one plugin task through the shared signed delivery path. */
 export declare function sendVercelPluginTask(message: PluginTaskQueueMessage): Promise<void>;
+/** Create the HTTP callback for plugin tasks. */
+export declare function createVercelPluginTaskCallback(): (request: Request) => Promise<Response>;
+/** Register the local-dev consumer for plugin tasks. */
+export declare function registerVercelPluginTaskDevConsumer(): (() => void) | undefined;

package/dist/chat/plugins/task-runner.d.ts

@@ -1,4 +1,4 @@
-import { type PluginTaskParams, type PluginTaskQueueMessage } from "./task-message";
+import { type PluginTaskParams, type PluginTaskQueueMessage } from "./task-queue";
 export interface ScheduleSessionCompletedPluginTasksOptions {
     send?: (message: PluginTaskQueueMessage) => Promise<void>;
 }

package/dist/chat/queue/callback.d.ts

@@ -0,0 +1,26 @@
+/** Shared Vercel Queue callback wiring for signed messages. */
+import { type MessageMetadata } from "@vercel/queue";
+import type { QueueRejectReason, QueueVerifyResult } from "./sign";
+export interface QueueCallbackOptions<Message> {
+    consumerGroup: string;
+    /** Use `null` when durable state already owns the attempt limit. */
+    maxDeliveries: number | null;
+    onRejected(reason: QueueRejectReason | string, metadata: MessageMetadata, error?: unknown): void;
+    permanentError?: (error: unknown) => string | undefined;
+    run(message: Message, metadata: MessageMetadata): Promise<void>;
+    /**
+     * Acknowledge without checking or running the message.
+     * Use for kill switches that must not depend on signing secrets.
+     */
+    skip?: (metadata: MessageMetadata) => boolean;
+    topic: string;
+    verify(value: unknown): QueueVerifyResult<Message>;
+    visibilityTimeoutSeconds?: number;
+}
+/** Build the HTTP callback and local-dev consumer for one signed queue. */
+export declare function queueCallback<Message>(options: QueueCallbackOptions<Message>): {
+    create: () => (requestOrEvent: Request | {
+        request: Request;
+    }) => Promise<Response>;
+    registerDev: () => (() => void) | undefined;
+};

package/dist/chat/queue/sign.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const QUEUE_SIGNATURE_MAX_AGE_MS: number;
+export type QueueRejectReason = "expired" | "malformed" | "signature_mismatch";
+export type QueueVerifyResult<Message> = {
+    status: "verified";
+    message: Message;
+} | {
+    status: "rejected";
+    reason: QueueRejectReason;
+} | {
+    status: "unavailable";
+    reason: "invalid_clock" | "missing_secret";
+};
+export interface QueueSignConfig<Message extends object, Version extends string> {
+    context: string;
+    maxAgeMs?: number;
+    schema: z.ZodType<Message>;
+    /** Kept for jobs that already signed with `:` instead of null bytes. */
+    separator?: string;
+    signatureVersion: Version;
+    parts(message: Message): readonly string[];
+}
+/** Sign one queue message. */
+export declare function signQueueMessage<Message extends object, Version extends string>(config: QueueSignConfig<Message, Version>, message: Message, nowMs?: number): Message & {
+    signature: string;
+    signatureVersion: Version;
+    signedAtMs: number;
+};
+/** Check one signed queue message. */
+export declare function verifyQueueMessage<Message extends object, Version extends string>(config: QueueSignConfig<Message, Version>, value: unknown, nowMs?: number): QueueVerifyResult<Message>;

package/dist/chat/sandbox/sandbox.d.ts

@@ -33,8 +33,6 @@ export interface SandboxOptions {
     skills: SkillMetadata[];
     referenceFiles: string[];
     timeoutMs?: number;
-    /** Durable-worker soft yield for long Workspace snapshot waits. */
-    shouldYield?: () => boolean;
     traceContext?: LogContext;
     tracePropagation?: SandboxEgressTracePropagationConfig;
     credentialEgress?: CredentialContext;

package/dist/chat/sandbox/session.d.ts

@@ -38,8 +38,6 @@ interface SandboxRuntimeOptions {
     skills: SkillMetadata[];
     referenceFiles: string[];
     timeoutMs?: number;
-    /** Durable-worker soft yield for long Workspace snapshot waits. */
-    shouldYield?: () => boolean;
     traceContext?: LogContext;
     commandEnv?: () => Promise<Record<string, string>>;
     createNetworkPolicy?: (egressId: string, traceHeaders?: TracePropagationHeaders) => NetworkPolicy | undefined;

package/dist/chat/sandbox/skill-sync.d.ts

@@ -8,7 +8,7 @@ export declare function resolveHostDataPath(referenceFiles: string[], sandboxPat
 export declare function isHostFileMissingError(error: unknown): boolean;
 /** Copy the current skill set and reference files into a sandbox. */
 export declare function syncSkillsToSandbox(params: {
-    sandbox: SandboxSession;
+    sandbox: Pick<SandboxSession, "mkDir" | "writeFiles">;
     skills: SkillMetadata[];
     referenceFiles?: string[];
     withSpan: <T>(name: string, op: string, attributes: Record<string, unknown>, callback: () => Promise<T>) => Promise<T>;

package/dist/chat/sandbox/snapshot/events.d.ts

@@ -0,0 +1,23 @@
+import type { ResourceEvent, SubscribableResource } from "@sentry/junior-plugin-api";
+export declare const WORKSPACE_SNAPSHOT_NAMESPACE = "junior";
+export declare const WORKSPACE_SNAPSHOT_RESOURCE_TYPE = "workspace_snapshot";
+export declare const WORKSPACE_SNAPSHOT_READY_EVENT = "workspace_snapshot.ready";
+export declare const WORKSPACE_SNAPSHOT_FAILED_EVENT = "workspace_snapshot.failed";
+/** Describe the events that report when a snapshot build ends. */
+export declare function workspaceSnapshotWatch(input: {
+    workspaceId: string;
+    workspaceName: string;
+}): SubscribableResource;
+type WorkspaceSnapshotResult = {
+    workspaceId: string;
+    resultId: string;
+    occurredAtMs?: number;
+} & ({
+    status: "ready";
+} | {
+    status: "failed";
+    error?: string | null;
+});
+/** Report that a Workspace snapshot build is ready or failed. */
+export declare function workspaceSnapshotFinishedEvent(input: WorkspaceSnapshotResult): ResourceEvent;
+export {};

package/dist/chat/sandbox/snapshot/job-callback.d.ts

@@ -0,0 +1,5 @@
+export declare const WORKSPACE_SNAPSHOT_JOB_DEV_CONSUMER_GROUP = "junior_workspace_snapshots_dev";
+/** Create the HTTP route for snapshot build messages. */
+export declare function createVercelWorkspaceSnapshotJobCallback(): (request: Request) => Promise<Response>;
+/** Receive snapshot build messages during local development. */
+export declare function registerVercelWorkspaceSnapshotJobDevConsumer(): (() => void) | undefined;

package/dist/chat/sandbox/snapshot/job-queue.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export declare const WORKSPACE_SNAPSHOT_JOB_QUEUE_TOPIC = "junior_workspace_snapshots";
+declare const workspaceSnapshotJobMessageSchema: z.ZodObject<{
+    workspaceId: z.ZodString;
+    profileHash: z.ZodString;
+}, z.core.$strict>;
+export type WorkspaceSnapshotJobMessage = z.output<typeof workspaceSnapshotJobMessageSchema>;
+/** Sign a Workspace snapshot job for tests and local checks. */
+export declare function signWorkspaceSnapshotJobMessage(message: WorkspaceSnapshotJobMessage, nowMs?: number): {
+    workspaceId: string;
+    profileHash: string;
+} & {
+    signature: string;
+    signatureVersion: "v1";
+    signedAtMs: number;
+};
+/** Check that a recent queue message came from Junior. */
+export declare function verifyWorkspaceSnapshotJobMessage(value: unknown, nowMs?: number): import("@/chat/queue/sign").QueueVerifyResult<{
+    workspaceId: string;
+    profileHash: string;
+}>;
+/** Send a job unless the same Workspace build already has one. */
+export declare function sendWorkspaceSnapshotJob(message: WorkspaceSnapshotJobMessage): Promise<void>;
+/** Send the next job for a Workspace build that is still running. */
+export declare function sendNextWorkspaceSnapshotJob(message: WorkspaceSnapshotJobMessage): Promise<void>;
+export {};

package/dist/chat/sandbox/snapshot/job-runner.d.ts

@@ -0,0 +1,11 @@
+import type { Workspace } from "@/chat/workspaces/types";
+import { type WorkspaceSnapshotJobMessage } from "./job-queue";
+/** Run a snapshot build and send another job if it needs more time. */
+export declare function processWorkspaceSnapshotJob(message: WorkspaceSnapshotJobMessage, options?: {
+    signal?: AbortSignal;
+}): Promise<void>;
+/** Start a snapshot build when no ready snapshot exists. */
+export declare function ensureWorkspaceSnapshotBuild(input: {
+    workspace: Workspace;
+    sendAgain?: boolean;
+}): Promise<"ready" | "building">;

package/dist/chat/sandbox/snapshot/not-ready-error.d.ts

@@ -0,0 +1,6 @@
+/** Report that a Workspace snapshot is not ready to use. */
+export declare class WorkspaceSnapshotNotReadyError extends Error {
+    constructor(workspaceName: string);
+}
+/** Check an error and its causes for a snapshot that is not ready. */
+export declare function isWorkspaceSnapshotNotReadyError(error: unknown): boolean;

package/dist/chat/sandbox/snapshot/workspace.d.ts

@@ -1,16 +1,22 @@
 import type { Snapshot } from "@/chat/sandbox/snapshot/resolve";
 import { type SandboxSession } from "@/chat/sandbox/workspace";
 import type { Workspace } from "@/chat/workspaces/types";
+/** Return the ready snapshot or report that the Workspace must build one. */
+export declare function requireReadyWorkspaceSnapshot(params: {
+    workspace: Workspace;
+    runtime: string;
+    staleSnapshotId?: string;
+}): Promise<Snapshot>;
 /**
- * Resolve a Workspace snapshot through resumable execution slices.
- * Cold builds have one shared one-hour budget across every execution slice.
+ * Continue a Workspace snapshot build from its saved state.
+ * The full build can run for up to one hour.
  */
 export declare function resolveWorkspaceSnapshot(params: {
     workspace: Workspace;
     runtime: string;
     staleSnapshotId?: string;
     signal?: AbortSignal;
-    shouldYield?: () => boolean;
+    shouldStop?: () => boolean;
     applyNetworkPolicy(sandbox: SandboxSession): Promise<unknown>;
     prepareRepositories?(sandbox: SandboxSession, workspace: Workspace, signal?: AbortSignal): Promise<void>;
     removeCredentialRoute: boolean;

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

@@ -1,8 +1,7 @@
 /** Viewer-scoped scheduled-task queries and mutations. */
 import type { User } from "@sentry/junior-plugin-api";
-import type { SchedulerStore } from "./store";
+import type { JuniorDatabase } from "@/db/db";
 import type { ScheduledTask } from "./types";
-type PersonalScheduledTaskStore = Pick<SchedulerStore, "getTask" | "listTasksCreatedBy" | "saveTask">;
 export interface ViewerScheduledTaskPage {
     nextCursor?: string;
     tasks: ScheduledTask[];
@@ -18,9 +17,7 @@ export declare class InvalidScheduledTaskCursorError extends Error {
 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 {};
+/** Delete one scheduled task created by the viewer. */
+export declare function deleteViewerScheduledTask(db: JuniorDatabase, user: User, id: string, nowMs?: number): Promise<void>;
+/** List scheduled tasks created by the viewer with a stable SQL cursor. */
+export declare function listViewerScheduledTasks(db: JuniorDatabase, user: User, input: ViewerScheduledTaskPageInput): Promise<ViewerScheduledTaskPage>;

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

@@ -0,0 +1,49 @@
+import type { JuniorDatabase } from "@/db/db";
+import { type ScheduledRun } from "./types";
+/** List incomplete runs for retained scheduled tasks. */
+export declare function listIncompleteScheduledRuns(db: JuniorDatabase): Promise<ScheduledRun[]>;
+/** Claim one due scheduler run under the deployed global claim lock. */
+export declare function claimDueScheduledRun(db: JuniorDatabase, args: {
+    nowMs: number;
+}): Promise<ScheduledRun | undefined>;
+/** Mark a pending run dispatched only for the active claim. */
+export declare function markScheduledRunDispatched(db: JuniorDatabase, args: {
+    claimedAtMs: number;
+    dispatchId: string;
+    nowMs: number;
+    runId: string;
+}): Promise<ScheduledRun | undefined>;
+/** Complete a run only for its active start timestamp. */
+export declare function markScheduledRunCompleted(db: JuniorDatabase, args: {
+    completedAtMs: number;
+    resultMessageTs?: string;
+    runId: string;
+    startedAtMs: number;
+}): Promise<ScheduledRun | undefined>;
+/** Fail a claimed or running run only for its active transition guard. */
+export declare function markScheduledRunFailed(db: JuniorDatabase, args: {
+    completedAtMs: number;
+    errorMessage: string;
+    startedAtMs?: number;
+    runId: string;
+}): Promise<ScheduledRun | undefined>;
+/** Block a claimed or running run only for its active transition guard. */
+export declare function markScheduledRunBlocked(db: JuniorDatabase, args: {
+    completedAtMs: number;
+    errorMessage: string;
+    runId: string;
+    startedAtMs?: number;
+}): Promise<ScheduledRun | undefined>;
+/** Skip a pending run only before dispatch begins. */
+export declare function markScheduledRunSkipped(db: JuniorDatabase, args: {
+    completedAtMs: number;
+    errorMessage: string;
+    runId: string;
+}): Promise<ScheduledRun | undefined>;
+/** Advance a scheduled task after a terminal run under its task lock. */
+export declare function advanceScheduledTaskAfterRun(db: JuniorDatabase, args: {
+    errorMessage?: string;
+    nowMs: number;
+    run: ScheduledRun;
+    status: "blocked" | "completed" | "failed";
+}): Promise<void>;

package/dist/chat/scheduled-tasks/schedule-intent.d.ts

@@ -11,9 +11,9 @@ export declare const scheduleIntentSchema: z.ZodUnion<readonly [z.ZodObject<{
         type: z.ZodLiteral<"after">;
         value: z.ZodNumber;
         unit: z.ZodEnum<{
-            day: "day";
             hour: "hour";
             minute: "minute";
+            day: "day";
             second: "second";
             week: "week";
         }>;

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

@@ -0,0 +1,27 @@
+import type { JuniorDatabase } from "@/db/db";
+import { juniorSchedulerTasks } from "@/db/schema/scheduled-tasks";
+import { type ScheduledTask } from "./types";
+type ScheduledTaskRow = Pick<typeof juniorSchedulerTasks.$inferSelect, "creatorIdentityId" | "record" | "title">;
+/** Decode a retained scheduler task row and reject invalid routing context. */
+export declare function parseScheduledTaskRow(row: ScheduledTaskRow): ScheduledTask | undefined;
+/** Keep scan paths from returning current or legacy tombstones. */
+export declare function isListedScheduledTask(task: ScheduledTask | undefined): task is ScheduledTask;
+/** Build the stable run id for one task occurrence. */
+export declare function scheduledRunId(taskId: string, scheduledForMs: number): string;
+/** Acquire the deployed advisory lock for one scheduled task. */
+export declare function withScheduledTaskLock<T>(db: JuniorDatabase, taskId: string, callback: (db: JuniorDatabase) => Promise<T>): Promise<T>;
+/** Read and decode one scheduled task. */
+export declare function readScheduledTask(db: JuniorDatabase, taskId: string): Promise<ScheduledTask | undefined>;
+/** List decoded scheduled tasks in stable creation order. */
+export declare function listScheduledTasks(db: JuniorDatabase): Promise<ScheduledTask[]>;
+/** List decoded scheduled tasks for one team in stable creation order. */
+export declare function listScheduledTasksForTeam(db: JuniorDatabase, teamId: string): Promise<ScheduledTask[]>;
+/** Create a scheduled task once under its retry-stable task lock. */
+export declare function createScheduledTask(db: JuniorDatabase, task: ScheduledTask): Promise<ScheduledTask>;
+/** Save a scheduled task and clear its blocked occurrence on reactivation. */
+export declare function saveScheduledTask(db: JuniorDatabase, task: ScheduledTask): Promise<ScheduledTask>;
+/** Save a scheduled task inside a task lock already held by the caller. */
+export declare function saveScheduledTaskInLock(db: JuniorDatabase, task: ScheduledTask, current: ScheduledTask | undefined): Promise<void>;
+/** List scheduled tasks whose current Slack destination is public. */
+export declare function listPublicScheduledTasksForTeams(db: JuniorDatabase, teamIds: string[], limit: number): Promise<ScheduledTask[]>;
+export {};

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

@@ -1,12 +1,10 @@
 import { type Identity, type SlackDestination, type SlackActor, type SlackSource, type User } from "@sentry/junior-plugin-api";
 import { z } from "zod";
-import { type SchedulerStore } from "./store";
 import type { ScheduledTask, ScheduledTaskConversationAccess, ScheduledTaskPrincipal, ScheduledTaskStatus } from "./types";
 export interface SchedulerToolContext {
     actor?: SlackActor;
     now?: () => number;
     source?: SlackSource;
-    store: SchedulerStore;
     users: {
         resolveActor(): Promise<{
             identity: Identity;
@@ -226,8 +224,6 @@ export declare function buildTaskId(args: {
     destination: SlackDestination;
     toolCallId: string | undefined;
 }): string;
-/** Keep concrete scheduler tools coupled to the injected store, not global state. */
-export declare function schedulerStore(context: SchedulerToolContext): SchedulerStore;
 /** Accept only persisted scheduler statuses from model-facing update input. */
 export declare function normalizeStatus(value: string | undefined): ScheduledTaskStatus | undefined;
 /** Centralize scheduler timezone defaulting for all concrete tool entry points. */

package/dist/chat/scheduled-tasks/tools/create.d.ts

@@ -20,7 +20,7 @@ export declare function createSlackScheduleCreateTaskTool(context: SchedulerTool
             timing: {
                 type: "after";
                 value: number;
-                unit: "day" | "hour" | "minute" | "second" | "week";
+                unit: "hour" | "minute" | "day" | "second" | "week";
             } | {
                 type: "at";
                 date: string;

package/dist/chat/scheduled-tasks/tools/update.d.ts

@@ -21,7 +21,7 @@ export declare function createSlackScheduleUpdateTaskTool(context: SchedulerTool
             timing: {
                 type: "after";
                 value: number;
-                unit: "day" | "hour" | "minute" | "second" | "week";
+                unit: "hour" | "minute" | "day" | "second" | "week";
             } | {
                 type: "at";
                 date: string;