@sentry/junior 0.178.0 → 0.179.0

package/dist/{catalog-runtime-M7QGKPFZ.js → catalog-runtime-FBVA6WAQ.js}

@@ -1,15 +1,15 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-ABLODWPO.js";
-import "./chunk-D3UJTX4U.js";
+} from "./chunk-YFNAMRGE.js";
+import "./chunk-SLGGOASN.js";
 import "./chunk-CGA4ERJ5.js";
 import "./chunk-M63DETLL.js";
-import "./chunk-UGWBJAGN.js";
+import "./chunk-HQNE5APD.js";
 import "./chunk-6GWA276C.js";
 import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
-import "./chunk-AGJ4OQ2V.js";
-import "./chunk-IQRPDKPJ.js";
+import "./chunk-UT6X7XN7.js";
+import "./chunk-TIEKUH4Q.js";
 import "./chunk-MLKGABMK.js";
 export {
   pluginCatalogRuntime

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;

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

@@ -1,86 +1,135 @@
-/** Durable scheduled-task domain types owned by Junior core. */
-import type { SlackDestination, SystemActor } from "@sentry/junior-plugin-api";
 import { z } from "zod";
-export type ScheduledTaskStatus = "active" | "blocked" | "completed" | "deleted";
-export declare const scheduledTaskCredentialModeSchema: z.ZodEnum<{
+declare const scheduledTaskStatusSchema: z.ZodEnum<{
+    completed: "completed";
+    blocked: "blocked";
+    active: "active";
+    deleted: "deleted";
+}>;
+export type ScheduledTaskStatus = z.output<typeof scheduledTaskStatusSchema>;
+declare const scheduledTaskCredentialModeSchema: z.ZodEnum<{
     system: "system";
     creator: "creator";
 }>;
-export type ScheduledTaskCredentialMode = z.infer<typeof scheduledTaskCredentialModeSchema>;
-export type ScheduledRunStatus = "pending" | "running" | "completed" | "failed" | "blocked" | "skipped";
-export interface ScheduledTaskPrincipal {
-    slackUserId: string;
-    fullName?: string;
-    userName?: string;
-}
-export type ScheduledTaskExecutionActor = SystemActor;
+export type ScheduledTaskCredentialMode = z.output<typeof scheduledTaskCredentialModeSchema>;
+declare const scheduledRunStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    running: "running";
+    completed: "completed";
+    failed: "failed";
+    blocked: "blocked";
+    skipped: "skipped";
+}>;
+export type ScheduledRunStatus = z.output<typeof scheduledRunStatusSchema>;
+/** Validate the current scheduled-task domain shape. */
+export declare const scheduledTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    conversationAccess: z.ZodObject<{
+        audience: z.ZodEnum<{
+            channel: "channel";
+            direct: "direct";
+            group: "group";
+        }>;
+        visibility: z.ZodEnum<{
+            private: "private";
+            public: "public";
+        }>;
+    }, z.core.$strict>;
+    createdAtMs: z.ZodNumber;
+    createdBy: z.ZodObject<{
+        slackUserId: z.ZodString;
+        fullName: z.ZodOptional<z.ZodString>;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    creatorIdentityId: z.ZodString;
+    credentialMode: z.ZodEnum<{
+        system: "system";
+        creator: "creator";
+    }>;
+    destination: z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        channelId: z.ZodString;
+    }, z.core.$strict>;
+    executionActor: z.ZodOptional<z.ZodObject<{
+        platform: z.ZodLiteral<"system">;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    lastRunAtMs: z.ZodOptional<z.ZodNumber>;
+    nextRunAtMs: z.ZodOptional<z.ZodNumber>;
+    originalRequest: z.ZodOptional<z.ZodString>;
+    runNowAtMs: z.ZodOptional<z.ZodNumber>;
+    schedule: z.ZodObject<{
+        description: z.ZodString;
+        kind: z.ZodEnum<{
+            one_off: "one_off";
+            recurring: "recurring";
+        }>;
+        recurrence: z.ZodOptional<z.ZodObject<{
+            dayOfMonth: z.ZodOptional<z.ZodNumber>;
+            frequency: z.ZodEnum<{
+                daily: "daily";
+                weekly: "weekly";
+                monthly: "monthly";
+                yearly: "yearly";
+            }>;
+            interval: z.ZodNumber;
+            month: z.ZodOptional<z.ZodNumber>;
+            startDate: z.ZodString;
+            time: z.ZodObject<{
+                hour: z.ZodNumber;
+                minute: z.ZodNumber;
+            }, z.core.$strict>;
+            weekdays: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strict>>;
+        timezone: z.ZodString;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        completed: "completed";
+        blocked: "blocked";
+        active: "active";
+        deleted: "deleted";
+    }>;
+    statusReason: z.ZodOptional<z.ZodString>;
+    task: z.ZodObject<{
+        text: z.ZodString;
+    }, z.core.$strict>;
+    title: z.ZodOptional<z.ZodString>;
+    updatedAtMs: z.ZodNumber;
+}, z.core.$strict>;
+/** Validate the current scheduled-run domain shape. */
+export declare const scheduledRunSchema: z.ZodObject<{
+    id: z.ZodString;
+    attempt: z.ZodNumber;
+    claimedAtMs: z.ZodNumber;
+    completedAtMs: z.ZodOptional<z.ZodNumber>;
+    dispatchId: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+    resultMessageTs: z.ZodOptional<z.ZodString>;
+    scheduledForMs: z.ZodNumber;
+    startedAtMs: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        blocked: "blocked";
+        skipped: "skipped";
+    }>;
+    taskId: z.ZodString;
+}, z.core.$strict>;
+export type ScheduledTask = z.output<typeof scheduledTaskSchema>;
+export type ScheduledRun = z.output<typeof scheduledRunSchema>;
+export type ScheduledTaskRecord = Omit<ScheduledTask, "title">;
+export type ScheduledTaskPrincipal = ScheduledTask["createdBy"];
+export type ScheduledTaskExecutionActor = NonNullable<ScheduledTask["executionActor"]>;
+export type ScheduledTaskConversationAccess = ScheduledTask["conversationAccess"];
+export type ScheduledTaskSchedule = ScheduledTask["schedule"];
+export type ScheduledTaskRecurrence = NonNullable<ScheduledTaskSchedule["recurrence"]>;
+export type ScheduledTaskSpec = ScheduledTask["task"];
+export type ScheduledCalendarFrequency = ScheduledTaskRecurrence["frequency"];
+export type ScheduledLocalTime = ScheduledTaskRecurrence["time"];
 export declare const SCHEDULED_TASK_SYSTEM_ACTOR: Readonly<{
     platform: "system";
     name: string;
 }>;
-export interface ScheduledTaskConversationAccess {
-    audience: "direct" | "group" | "channel";
-    visibility: "private" | "public";
-}
-export type ScheduledCalendarFrequency = "daily" | "weekly" | "monthly" | "yearly";
-export interface ScheduledLocalTime {
-    hour: number;
-    minute: number;
-}
-export interface ScheduledTaskRecurrence {
-    dayOfMonth?: number;
-    frequency: ScheduledCalendarFrequency;
-    interval: number;
-    month?: number;
-    startDate: string;
-    time: ScheduledLocalTime;
-    weekdays?: number[];
-}
-export interface ScheduledTaskSchedule {
-    description: string;
-    timezone: string;
-    kind: "one_off" | "recurring";
-    recurrence?: ScheduledTaskRecurrence;
-}
-export interface ScheduledTaskSpec {
-    text: string;
-}
-export interface ScheduledTask {
-    id: string;
-    createdAtMs: number;
-    createdBy: ScheduledTaskPrincipal;
-    /** Authoritative provider identity that created the task. */
-    creatorIdentityId: string;
-    conversationAccess: ScheduledTaskConversationAccess;
-    /** Selects system credentials or task-bound creator credential delegation. */
-    credentialMode: ScheduledTaskCredentialMode;
-    destination: SlackDestination;
-    executionActor?: ScheduledTaskExecutionActor;
-    lastRunAtMs?: number;
-    nextRunAtMs?: number;
-    originalRequest?: string;
-    runNowAtMs?: number;
-    schedule: ScheduledTaskSchedule;
-    status: ScheduledTaskStatus;
-    statusReason?: string;
-    task: ScheduledTaskSpec;
-    /**
-     * Short display title generated from the task instruction.
-     * SQL-backed column; never stored inside the JSON record payload.
-     */
-    title?: string;
-    updatedAtMs: number;
-}
-export interface ScheduledRun {
-    id: string;
-    attempt: number;
-    claimedAtMs: number;
-    completedAtMs?: number;
-    dispatchId?: string;
-    errorMessage?: string;
-    resultMessageTs?: string;
-    scheduledForMs: number;
-    startedAtMs?: number;
-    status: ScheduledRunStatus;
-    taskId: string;
-}
+export {};

package/dist/{chunk-JVXZ3WDH.js → chunk-2HIPYNQI.js}

@@ -5,19 +5,19 @@ import {
   isDmChannel,
   normalizeSlackConversationId,
   withSlackRetries
-} from "./chunk-XWUJWHFD.js";
+} from "./chunk-3I7XE3PA.js";
 import {
   parseDestination
-} from "./chunk-XCNS3CXE.js";
+} from "./chunk-VP4OVRDD.js";
 import {
   getStateAdapter
-} from "./chunk-H6ZXBFGX.js";
+} from "./chunk-3TM3FYLQ.js";
 import {
   normalizeSlackEmojiName
-} from "./chunk-3ZZEPLLB.js";
+} from "./chunk-GENV6KF2.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-ABLODWPO.js";
+} from "./chunk-YFNAMRGE.js";
 import {
   parseSlackMessageTs,
   parseSlackUserId
@@ -26,7 +26,7 @@ import {
   isRecord,
   logInfo,
   logWarn
-} from "./chunk-UGWBJAGN.js";
+} from "./chunk-HQNE5APD.js";
 
 // src/chat/slack/outbound.ts
 var MAX_SLACK_MESSAGE_TEXT_CHARS = 4e4;

package/dist/{chunk-BHHWCNXI.js → chunk-3AFVR5UC.js}

@@ -4,7 +4,7 @@ import {
 import {
   formatProviderLabel,
   startOAuthFlow
-} from "./chunk-JVXZ3WDH.js";
+} from "./chunk-2HIPYNQI.js";
 import {
   parseSandboxEgressAuthRequiredSignal
 } from "./chunk-6ZWRNC4D.js";
@@ -12,16 +12,16 @@ import {
   abandonReplacedPendingAuth,
   canReusePendingAuthLink,
   recordAuthorizationRequested
-} from "./chunk-BFLMRTPD.js";
+} from "./chunk-FIDMHAO6.js";
 import {
   AGENT_INVOCATION_MAILBOX_STATUSES
-} from "./chunk-ZCHHVTMF.js";
+} from "./chunk-R6U7N4FS.js";
 import {
   TURN_REASONING_LEVELS
-} from "./chunk-3ZZEPLLB.js";
+} from "./chunk-GENV6KF2.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-ABLODWPO.js";
+} from "./chunk-YFNAMRGE.js";
 import {
   credentialContextSchema
 } from "./chunk-CGA4ERJ5.js";

package/dist/{chunk-XWUJWHFD.js → chunk-3I7XE3PA.js}

@@ -5,7 +5,7 @@ import {
   getConversationEventStore,
   getDb,
   getSqlExecutor
-} from "./chunk-XCNS3CXE.js";
+} from "./chunk-VP4OVRDD.js";
 import {
   juniorConversationAnnotations,
   juniorConversationEvents,
@@ -14,7 +14,7 @@ import {
   juniorUsers,
   juniorWorkspaceRepos,
   juniorWorkspaces
-} from "./chunk-ZCHHVTMF.js";
+} from "./chunk-R6U7N4FS.js";
 import {
   SANDBOX_WORKSPACE_ROOT,
   getVercelSandboxCredentials,
@@ -22,17 +22,17 @@ import {
   isSandboxMissingError,
   runNonInteractiveCommand,
   sleep
-} from "./chunk-AQHSXA3J.js";
+} from "./chunk-JMJNFEDC.js";
 import {
   getStateAdapter
-} from "./chunk-H6ZXBFGX.js";
+} from "./chunk-3TM3FYLQ.js";
 import {
   botConfig,
   completeObject,
   embedTexts,
   getSlackBotToken,
   standardModelId
-} from "./chunk-3ZZEPLLB.js";
+} from "./chunk-GENV6KF2.js";
 import {
   isActorUserId,
   parseActorUserId,
@@ -48,7 +48,7 @@ import {
   setSpanAttributes,
   setSpanStatus,
   withSpan
-} from "./chunk-UGWBJAGN.js";
+} from "./chunk-HQNE5APD.js";
 
 // src/chat/plugins/agent-hooks.ts
 import {

package/dist/{chunk-H6ZXBFGX.js → chunk-3TM3FYLQ.js}

@@ -1,6 +1,6 @@
 import {
   getChatConfig
-} from "./chunk-3ZZEPLLB.js";
+} from "./chunk-GENV6KF2.js";
 
 // src/chat/state/adapter.ts
 import { createMemoryState } from "@chat-adapter/state-memory";

package/dist/{chunk-6OYVH66J.js → chunk-4GWXAILB.js}

@@ -1,7 +1,7 @@
 import {
   FUNCTION_TIMEOUT_BUFFER_SECONDS,
   getChatConfig
-} from "./chunk-3ZZEPLLB.js";
+} from "./chunk-GENV6KF2.js";
 
 // src/chat/runtime/request-deadline.ts
 import { AsyncLocalStorage } from "async_hooks";

package/dist/{chunk-BUGO42R6.js → chunk-5IRROPA5.js}

@@ -8,14 +8,14 @@ import {
   getConversationStore,
   parseDestination,
   sameDestination
-} from "./chunk-XCNS3CXE.js";
+} from "./chunk-VP4OVRDD.js";
 import {
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-H6ZXBFGX.js";
+} from "./chunk-3TM3FYLQ.js";
 import {
   getChatConfig
-} from "./chunk-3ZZEPLLB.js";
+} from "./chunk-GENV6KF2.js";
 import {
   parseStoredSlackActor
 } from "./chunk-M63DETLL.js";
@@ -23,7 +23,7 @@ import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-UGWBJAGN.js";
+} from "./chunk-HQNE5APD.js";
 
 // src/chat/task-execution/state.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-534BO42N.js → chunk-B6ECUSVX.js}

@@ -6,14 +6,14 @@ import {
   isStale,
   runNonInteractiveCommand,
   sleep
-} from "./chunk-AQHSXA3J.js";
+} from "./chunk-JMJNFEDC.js";
 import {
   getStateAdapter
-} from "./chunk-H6ZXBFGX.js";
+} from "./chunk-3TM3FYLQ.js";
 import {
   setSpanAttributes,
   withSpan
-} from "./chunk-UGWBJAGN.js";
+} from "./chunk-HQNE5APD.js";
 
 // src/chat/sandbox/resources.ts
 var configuredResources;

package/dist/{chunk-G3CQEUHI.js → chunk-CJLBLELR.js}

@@ -1,18 +1,18 @@
 import {
   persistConversationMessages
-} from "./chunk-BFLMRTPD.js";
+} from "./chunk-FIDMHAO6.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS
 } from "./chunk-3Y47VMHV.js";
 import {
   getDb
-} from "./chunk-XCNS3CXE.js";
+} from "./chunk-VP4OVRDD.js";
 import {
   juniorLocationConfigurations
-} from "./chunk-ZCHHVTMF.js";
+} from "./chunk-R6U7N4FS.js";
 import {
   getStateAdapter
-} from "./chunk-H6ZXBFGX.js";
+} from "./chunk-3TM3FYLQ.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
@@ -20,7 +20,7 @@ import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-UGWBJAGN.js";
+} from "./chunk-HQNE5APD.js";
 
 // src/chat/conversations/turn-lifecycle.ts
 var ConversationTurnLifecycleService = class {

package/dist/{chunk-22T3HB44.js → chunk-FAS6AIMF.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-M63DETLL.js";
 import {
   toOptionalString
-} from "./chunk-UGWBJAGN.js";
+} from "./chunk-HQNE5APD.js";
 
 // src/chat/slack/context.ts
 import { z } from "zod";

package/dist/{chunk-BFLMRTPD.js → chunk-FIDMHAO6.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-PDO5BLNM.js";
 import {
   ToolInputError
-} from "./chunk-XWUJWHFD.js";
+} from "./chunk-3I7XE3PA.js";
 import {
   agentHistoryItemSchema,
   bindProviderConversation,
@@ -16,25 +16,25 @@ import {
   instructionProvenanceFor,
   sanitizePostgresJson,
   withConversationEventLock
-} from "./chunk-XCNS3CXE.js";
+} from "./chunk-VP4OVRDD.js";
 import {
   SANDBOX_REPOS_ROOT,
   SANDBOX_WORKSPACE_ROOT,
   sleep
-} from "./chunk-AQHSXA3J.js";
+} from "./chunk-JMJNFEDC.js";
 import {
   MUTATION_LOCK_TTL_MS,
   fenceLock,
   getStateAdapter,
   withLock
-} from "./chunk-H6ZXBFGX.js";
+} from "./chunk-3TM3FYLQ.js";
 import {
   botConfig,
   completeText,
   escapeXml,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-3ZZEPLLB.js";
+} from "./chunk-GENV6KF2.js";
 import {
   parseSlackMessageTs,
   toStoredSlackActor
@@ -44,7 +44,7 @@ import {
   logException,
   logWarn,
   setSpanAttributes
-} from "./chunk-UGWBJAGN.js";
+} from "./chunk-HQNE5APD.js";
 
 // src/chat/turn-context-tag.ts
 var TURN_CONTEXT_TAG = "runtime-turn-context";