@sentry/junior 0.137.0 → 0.139.0

package/dist/app.js

@@ -1,27 +1,25 @@
 import {
-  CONVERSATION_WORK_CHECK_IN_INTERVAL_MS,
-  CONVERSATION_WORK_STALE_ENQUEUE_MS,
+  processConversationWork
+} from "./chunk-WQRX57EA.js";
+import {
+  bindSpawnAgent
+} from "./chunk-4V4QIYJH.js";
+import {
+  createAgentInvocationWorker,
+  enqueueAgentInvocation,
+  listPendingAgentInvocationMailboxAppends,
+  routeAgentInvocationWork
+} from "./chunk-AEQISMMU.js";
+import {
   GET as GET2,
   GET2 as GET3,
   ResumeTurnBusyError,
-  ackMessages,
-  appendAndEnqueueInboundMessage,
-  beginConversationResume,
   buildAuthPauseResponse,
   buildSlackOutputMessage,
-  checkInConversationWork,
-  clearConsumedConversationWake,
-  clearExpiredConversationLease,
-  completeConversationWork,
-  countPendingConversationMessages,
   createSlackAdapterAssistantStatusSession,
-  deadLetterAttempt,
-  drainConversationMailbox,
-  ensureConversationWake,
   getAssistantThreadContext,
   getAwaitingAgentContinueRequest,
   getChannelId,
-  getConversationWorkState,
   getMessageTs,
   getRunId,
   getSlackApiErrorCode,
@@ -29,61 +27,84 @@ import {
   getThreadId,
   getThreadTs,
   getTurnRequestDeadline,
-  hasRunnableConversationWork,
-  isFinalAttempt,
-  isInvalidConversationRecordError,
   isRetryableSlackPostError,
   isSlackTitlePermissionError,
-  listActiveConversationIds,
   publishAppHomeView,
   receiveLocalOAuthCredential,
-  recordAttemptFailure,
-  releaseConversationWork,
-  removeActiveConversation,
-  requestConversationContinuation,
   resumeSlackTurn,
   runWithTurnRequestDeadline,
   scheduleAgentContinue,
   sendSlackReply,
   shouldKeepProcessingReactionForToolInvocation,
   splitSlackReplyText,
-  startConversationWork,
   startSlackProcessingReaction,
   stripLeadingBotMention
-} from "./chunk-DQXAAVTR.js";
+} from "./chunk-J6EJQCHY.js";
 import "./chunk-FA6POGLH.js";
 import {
-  ConversationTurnLifecycleService,
+  CONVERSATION_WORK_STALE_ENQUEUE_MS,
+  appendAndEnqueueInboundMessage,
+  clearExpiredConversationLease,
+  ensureConversationWake,
+  getConversationWorkState,
+  hasRunnableConversationWork,
+  isInvalidConversationRecordError,
+  listActiveConversationIds,
+  removeActiveConversation
+} from "./chunk-MQ5RYATN.js";
+import {
   buildDeliveredTurnStatePatch,
+  claimDispatchMailboxAppend,
   completeAuthPauseTurn,
+  confirmDispatchMailboxAppend,
+  createOrGetDispatch,
   finalizeFailedTurnReplyWithEvent,
   getAgentTurnDiagnosticsAttributes,
+  getDispatchConversationId,
+  getDispatchInputMessageId,
+  getDispatchInputMessageIds,
+  getDispatchRecord,
+  getDispatchTurnId,
+  getPluginDispatchProjection,
   getTurnUserMessage,
   getTurnUserReplyAttachmentContext,
   getTurnUserSlackMessageTs,
+  isTerminalDispatchStatus,
+  listPendingDispatchMailboxAppends,
+  markDispatchAwaitingResume,
+  markDispatchBlocked,
+  markDispatchCompleted,
+  markDispatchFailed,
+  markDispatchRunning,
   persistAuthPauseTurnState,
   processPluginTask,
   requireTurnFailureEventId,
   resolveTurnSessionRouting,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-SYCX4DOK.js";
+} from "./chunk-5GSZWRE2.js";
+import {
+  ConversationTurnLifecycleService
+} from "./chunk-Q6QZTTLS.js";
 import {
   GET,
   conversationVisibilityFromSlackChannelType,
-  recordTaskExecution,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext
-} from "./chunk-6QW2RRQT.js";
+} from "./chunk-3T2JAGRH.js";
 import "./chunk-4CODA7P5.js";
+import {
+  recordTaskExecution
+} from "./chunk-GI52BW74.js";
 import "./chunk-UTL3MHPC.js";
 import {
-  ConversationQueueMessageRejectedError,
-  conversationQueueMessageSchema,
   getVercelConversationWorkQueue,
-  isConversationQueueMessageRejectedError,
   resolveConversationWorkQueueTopic,
   verifyConversationQueueMessage
-} from "./chunk-6ZK6FZIV.js";
+} from "./chunk-KCBZSJRU.js";
+import {
+  conversationQueueMessageSchema,
+  isConversationQueueMessageRejectedError
+} from "./chunk-IUFM5JWV.js";
 import {
   PLUGIN_TASK_QUEUE_TOPIC,
   createVercelQueueClient,
@@ -92,7 +113,7 @@ import {
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-UZQ4VY3M.js";
+} from "./chunk-J3S57AXY.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -100,8 +121,6 @@ import {
   pluginRuntimeRegistrationsFromPluginSet
 } from "./chunk-FIANEE7Z.js";
 import {
-  AuthorizationFlowDisabledError,
-  PluginCredentialFailureError,
   SANDBOX_EGRESS_PROXY_PATH,
   appendSlackLegacyAttachmentText,
   buildSteeringPiMessage,
@@ -127,22 +146,29 @@ import {
   setConfigDefaults,
   shouldEmitDevAgentTrace,
   shouldPropagateSandboxEgressTrace
-} from "./chunk-KJ4HGRHN.js";
+} from "./chunk-ZYQSPQYR.js";
+import {
+  AuthorizationFlowDisabledError,
+  PluginCredentialFailureError
+} from "./chunk-WZH4JV7R.js";
 import "./chunk-DIB4GX3G.js";
 import {
-  RetryableDeliveryError,
   createUserTokenStore,
   deleteMcpAuthSessionsForUserProvider,
   deleteMcpServerSessionId,
-  deleteMcpStoredOAuthCredentials,
+  deleteMcpStoredOAuthCredentials
+} from "./chunk-ZQCGQMF2.js";
+import {
+  RetryableDeliveryError
+} from "./chunk-R776HKPK.js";
+import {
   formatProviderLabel,
   postSlackMessage,
   startOAuthFlow
-} from "./chunk-EWDSB24B.js";
+} from "./chunk-U27DSXKB.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
-  JUNIOR_THREAD_STATE_TTL_MS,
   TurnInputCommitLostError,
   TurnInputDeferredError,
   abandonAgentTurnSessionRecord,
@@ -195,47 +221,54 @@ import {
   trimTrailingAssistantMessages,
   updateConversationStats,
   upsertConversationMessage
-} from "./chunk-POBSY47Q.js";
-import "./chunk-EPBBYMNE.js";
+} from "./chunk-PJW6U46K.js";
+import "./chunk-3Y47VMHV.js";
+import "./chunk-HUO3UTAQ.js";
+import {
+  getExperimentalFeatures,
+  setExperimentalFeatures
+} from "./chunk-5IDFPCON.js";
 import {
   getSandboxResourceConfig,
   setSandboxResourceConfig
-} from "./chunk-UOXATPSI.js";
+} from "./chunk-G52UXKGO.js";
 import {
   createSchedulerSqlStore,
   findMatchingEventTasks
-} from "./chunk-K2NCQJKH.js";
+} from "./chunk-DW4PMHNW.js";
 import {
   parseSlackThreadId
-} from "./chunk-YRPC6MJY.js";
+} from "./chunk-MXVD2BDS.js";
 import "./chunk-CDQ4YIZM.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
 import {
-  SlackActionError,
   bindEventTaskCredentialSubject,
   bindScheduledTaskCredentialSubject,
   bindSlackDirectCredentialSubject,
   createPluginLogger,
   createPluginState,
   createResourceEventTeamIdResolver,
-  downloadPrivateSlackFile,
   getPluginApiRoutes,
   getPluginRoutes,
   getPlugins,
-  getSlackClient,
-  getWorkspaceTeamId,
-  isDmChannel,
-  normalizeSlackConversationId,
-  runWithSlackInstallationToken,
-  runWithWorkspaceTeamId,
   setDashboardConversationLinkOptions,
   setPlugins,
   validatePlugins,
   verifyEventTaskCredentialSubject,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-WPPXIAFB.js";
+} from "./chunk-IIESAYDL.js";
+import {
+  SlackActionError,
+  downloadPrivateSlackFile,
+  getSlackClient,
+  getWorkspaceTeamId,
+  isDmChannel,
+  normalizeSlackConversationId,
+  runWithSlackInstallationToken,
+  runWithWorkspaceTeamId
+} from "./chunk-6SU2DT27.js";
 import {
   contextProvenance,
   createSlackDestination,
@@ -245,17 +278,22 @@ import {
   getSqlExecutor,
   instructionProvenanceFor,
   requireSlackDestination,
-  withConversationEventLock
-} from "./chunk-ZFS67WIR.js";
+  withConversationEventLock,
+  withConversationMutationLock
+} from "./chunk-QTBKPZDA.js";
 import {
+  juniorAgentBindings,
+  juniorAgentInvocations,
   juniorConversationEvents,
   juniorConversations
-} from "./chunk-RB4NJKEX.js";
+} from "./chunk-UDBUS533.js";
 import {
-  acquireActiveLock,
-  getStateAdapter,
   sleep
-} from "./chunk-5G34IEK2.js";
+} from "./chunk-EM225ITJ.js";
+import {
+  acquireActiveLock,
+  getStateAdapter
+} from "./chunk-MXTVUV3I.js";
 import {
   STANDARD_MODEL_PROFILE,
   botConfig,
@@ -273,19 +311,19 @@ import {
   modelIdForProfile,
   setSlackReactionConfig,
   standardModelId
-} from "./chunk-UG6ZYPBI.js";
+} from "./chunk-75I3UBIL.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
-import "./chunk-YNFERGKP.js";
-import "./chunk-3Q342EJJ.js";
+import "./chunk-YGZ2OLXL.js";
+import "./chunk-GWQSZT4C.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-36EG34YI.js";
-import "./chunk-BZAMASJP.js";
+} from "./chunk-6OHTDR4F.js";
+import "./chunk-CXH25EL4.js";
 import {
-  credentialSubjectSchema
-} from "./chunk-77VDLF3Z.js";
+  credentialContextForActor
+} from "./chunk-RUIXF3YQ.js";
 import {
   createActor,
   createSlackActor,
@@ -314,7 +352,7 @@ import {
   withContext,
   withLogContext,
   withSpan
-} from "./chunk-T6Z5S6PQ.js";
+} from "./chunk-2ECYPYKP.js";
 import {
   continueTrace
 } from "./chunk-6GWA276C.js";
@@ -322,10 +360,10 @@ import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
 import {
   JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE
-} from "./chunk-5PNJMOY5.js";
+} from "./chunk-C2N6MNO4.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-XZ7NPXAB.js";
+} from "./chunk-U7CMWQ7Z.js";
 import "./chunk-MLKGABMK.js";
 
 // src/app.ts
@@ -387,400 +425,20 @@ async function verifyDispatchCallbackRequest(request) {
   }
 }
 
-// src/chat/agent-dispatch/store.ts
-import { createHash } from "crypto";
-import {
-  destinationSchema,
-  destinationVisibilitySchema,
-  isSlackDestination,
-  replyAttributionSchema,
-  sourceSchema
-} from "@sentry/junior-plugin-api";
-import { z as z2 } from "zod";
-var DISPATCH_PREFIX = "junior:agent_dispatch";
-var DISPATCH_LOCK_TTL_MS = 10 * 60 * 1e3;
-var DISPATCH_MAILBOX_APPEND_INDEX_LOCK_TTL_MS = 1e4;
-var DISPATCH_MAILBOX_APPEND_INDEX_MAX_LENGTH = 1e4;
-var nonEmptyExactStringSchema = z2.string().min(1).refine(
-  (value) => value === value.trim() && value.toLowerCase() !== "unknown"
-);
-var pendingDispatchMailboxAppendIndexSchema = z2.array(
-  nonEmptyExactStringSchema
-);
-var dispatchStatusSchema = z2.enum([
-  "pending",
-  "running",
-  "awaiting_resume",
-  "completed",
-  "failed",
-  "blocked"
-]);
-var dispatchActorSchema = z2.object({
-  platform: z2.literal("system"),
-  name: nonEmptyExactStringSchema
-}).strict();
-var dispatchRecordSchema = z2.object({
-  actor: dispatchActorSchema,
-  createdAtMs: z2.number().finite(),
-  credentialSubject: credentialSubjectSchema.optional(),
-  destination: destinationSchema,
-  destinationVisibility: destinationVisibilitySchema,
-  errorMessage: z2.string().optional(),
-  id: nonEmptyExactStringSchema,
-  idempotencyKey: z2.string().min(1),
-  input: z2.string().min(1),
-  metadata: z2.record(z2.string(), z2.string()).optional(),
-  plugin: nonEmptyExactStringSchema,
-  replyAttribution: replyAttributionSchema.optional(),
-  resultMessageTs: z2.string().optional(),
-  source: sourceSchema,
-  status: dispatchStatusSchema,
-  updatedAtMs: z2.number().finite()
-}).strict().superRefine((record, ctx) => {
-  if (!isSlackDestination(record.destination)) {
-    ctx.addIssue({
-      code: z2.ZodIssueCode.custom,
-      message: "Dispatch destination platform must be slack",
-      path: ["destination"]
-    });
-    return;
-  }
-  const subject = record.credentialSubject;
-  if (!subject) {
-    return;
-  }
-  if (subject.allowedWhen === "private-direct-conversation") {
-    if (!record.destination.channelId.startsWith("D")) {
-      ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
-        message: "Dispatch credentialSubject requires a private direct Slack destination",
-        path: ["credentialSubject"]
-      });
-      return;
-    }
-    if (subject.binding.type !== "slack-direct-conversation" || subject.binding.teamId !== record.destination.teamId || subject.binding.channelId !== record.destination.channelId) {
-      ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
-        message: "Dispatch credentialSubject binding must match destination",
-        path: ["credentialSubject", "binding"]
-      });
-    }
-    return;
-  }
-  if (subject.binding.type !== subject.allowedWhen || subject.binding.plugin !== record.plugin || subject.binding.taskId !== subject.taskId) {
-    ctx.addIssue({
-      code: z2.ZodIssueCode.custom,
-      message: "Dispatch credentialSubject binding must match task",
-      path: ["credentialSubject", "binding"]
-    });
-  }
-});
-var storedDispatchRecordSchema = dispatchRecordSchema.extend({
-  attempt: z2.number().int().nonnegative().optional(),
-  lastCallbackAtMs: z2.number().finite().optional(),
-  leaseExpiresAtMs: z2.number().finite().optional(),
-  maxAttempts: z2.number().int().positive().optional(),
-  version: z2.number().int().positive().optional()
-});
-function getDispatchStorageKey(id) {
-  return `${DISPATCH_PREFIX}:record:${id}`;
-}
-function dispatchLockKey(id) {
-  return `${DISPATCH_PREFIX}:lock:${id}`;
-}
-function pendingDispatchMailboxAppendIndexKey() {
-  return `${DISPATCH_PREFIX}:incomplete`;
-}
-function pendingDispatchMailboxAppendIndexLockKey() {
-  return `${DISPATCH_PREFIX}:incomplete:lock`;
-}
-function normalizeMetadata(metadata) {
-  if (!metadata) {
-    return void 0;
-  }
-  const entries = Object.entries(metadata).filter(
-    (entry) => typeof entry[0] === "string" && typeof entry[1] === "string"
-  );
-  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
-}
-function buildDispatchId(plugin, idempotencyKey) {
-  const digest = createHash("sha256").update(plugin).update("\0").update(idempotencyKey).digest("hex").slice(0, 32);
-  return `dispatch_${digest}`;
-}
-function parseDispatchRecord(value) {
-  const parsed = parseStoredDispatchRecord(value);
-  return parsed?.record;
-}
-function parseStoredDispatchRecord(value) {
-  const parsed = storedDispatchRecordSchema.safeParse(value);
-  if (!parsed.success) {
-    return void 0;
-  }
-  const {
-    attempt: _attempt,
-    lastCallbackAtMs: _lastCallbackAtMs,
-    leaseExpiresAtMs: _leaseExpiresAtMs,
-    maxAttempts: _maxAttempts,
-    version: _version,
-    ...record
-  } = parsed.data;
-  return {
-    ...typeof parsed.data.leaseExpiresAtMs === "number" ? { legacyLeaseExpiresAtMs: parsed.data.leaseExpiresAtMs } : {},
-    record
-  };
-}
-function getDispatchConversationId(dispatch2) {
-  return `agent-dispatch:${dispatch2.id}`;
-}
-function getDispatchInputMessageId(dispatchId) {
-  return `agent-dispatch:${dispatchId}`;
-}
-function getLegacyDispatchInputMessageId(dispatchId) {
-  return `dispatch:${dispatchId}:user`;
-}
-function getDispatchInputMessageIds(dispatchId) {
-  return [
-    getDispatchInputMessageId(dispatchId),
-    getLegacyDispatchInputMessageId(dispatchId)
-  ];
-}
-function getDispatchTurnId(dispatchId) {
-  return `dispatch:${dispatchId}`;
-}
-function toDispatchProjection(record) {
-  return {
-    id: record.id,
-    status: record.status,
-    ...record.resultMessageTs ? { resultMessageTs: record.resultMessageTs } : {},
-    ...record.errorMessage ? { errorMessage: record.errorMessage } : {}
-  };
-}
-function isTerminalDispatchStatus(status) {
-  return status === "completed" || status === "failed" || status === "blocked";
-}
-async function withDispatchLock(dispatchId, task) {
-  const state = getStateAdapter();
-  await state.connect();
-  const lock = await state.acquireLock(
-    dispatchLockKey(dispatchId),
-    DISPATCH_LOCK_TTL_MS
-  );
-  if (!lock) {
-    throw new Error(`Could not acquire dispatch lock for ${dispatchId}`);
-  }
-  try {
-    return await task(state);
-  } finally {
-    await state.releaseLock(lock);
-  }
-}
-async function putRecord(state, record) {
-  const parsed = dispatchRecordSchema.safeParse(record);
-  if (!parsed.success) {
-    throw new Error(
-      `Dispatch record is invalid: ${parsed.error.issues.map((issue) => `${issue.path.join(".") || "<root>"} ${issue.message}`).join("; ")}`
-    );
-  }
-  const next = parsed.data;
-  await state.set(
-    getDispatchStorageKey(next.id),
-    next,
-    JUNIOR_THREAD_STATE_TTL_MS
-  );
-}
-async function updatePendingDispatchMailboxAppendIndex(state, update) {
-  const lock = await state.acquireLock(
-    pendingDispatchMailboxAppendIndexLockKey(),
-    DISPATCH_MAILBOX_APPEND_INDEX_LOCK_TTL_MS
-  );
-  if (!lock) {
-    throw new Error("Could not acquire dispatch mailbox append index lock");
-  }
-  try {
-    const stored = await state.get(pendingDispatchMailboxAppendIndexKey());
-    const ids = stored === void 0 || stored === null ? [] : pendingDispatchMailboxAppendIndexSchema.parse(stored);
-    const next = [...new Set(update([...new Set(ids)]))].slice(
-      -DISPATCH_MAILBOX_APPEND_INDEX_MAX_LENGTH
-    );
-    if (next.length === ids.length && next.every((id, index) => id === ids[index])) {
-      return;
-    }
-    await state.set(
-      pendingDispatchMailboxAppendIndexKey(),
-      next,
-      JUNIOR_THREAD_STATE_TTL_MS
-    );
-  } finally {
-    await state.releaseLock(lock);
-  }
-}
-async function getDispatchRecord(id) {
-  const state = getStateAdapter();
-  await state.connect();
-  return parseDispatchRecord(await state.get(getDispatchStorageKey(id)));
-}
-async function createOrGetDispatch(args) {
-  const id = buildDispatchId(args.plugin, args.options.idempotencyKey);
-  return await withDispatchLock(id, async (state) => {
-    const existing = parseDispatchRecord(
-      await state.get(getDispatchStorageKey(id))
-    );
-    if (existing) {
-      return { record: existing, status: "already_exists" };
-    }
-    const metadata = normalizeMetadata(args.options.metadata);
-    const record = {
-      actor: { platform: "system", name: args.plugin },
-      createdAtMs: args.nowMs,
-      ...args.options.credentialSubject ? { credentialSubject: args.options.credentialSubject } : {},
-      destination: args.options.destination,
-      destinationVisibility: args.options.destinationVisibility,
-      id,
-      idempotencyKey: args.options.idempotencyKey,
-      input: args.options.input,
-      ...metadata ? { metadata } : {},
-      plugin: args.plugin,
-      ...args.options.replyAttribution ? { replyAttribution: args.options.replyAttribution } : {},
-      status: "pending",
-      source: args.options.source,
-      updatedAtMs: args.nowMs
-    };
-    await updatePendingDispatchMailboxAppendIndex(
-      state,
-      (ids) => ids.includes(id) ? ids : [...ids, id]
-    );
-    await putRecord(state, record);
-    return { record, status: "created" };
-  });
-}
-async function transitionDispatch(id, transition) {
-  return await withDispatchLock(id, async (state) => {
-    const current = parseDispatchRecord(
-      await state.get(getDispatchStorageKey(id))
-    );
-    if (!current) {
-      return void 0;
-    }
-    const transitioned = transition(current);
-    if (transitioned === current) {
-      return current;
-    }
-    const next = {
-      ...transitioned,
-      updatedAtMs: Date.now()
-    };
-    await putRecord(state, next);
-    return next;
-  });
-}
-async function markDispatchRunning(id) {
-  return await transitionDispatch(
-    id,
-    (record) => isTerminalDispatchStatus(record.status) ? record : { ...record, status: "running", errorMessage: void 0 }
-  );
-}
-async function markDispatchAwaitingResume(id) {
-  return await transitionDispatch(
-    id,
-    (record) => isTerminalDispatchStatus(record.status) ? record : {
-      ...record,
-      status: "awaiting_resume"
-    }
-  );
-}
-async function markDispatchBlocked(id, errorMessage, resultMessageTs) {
-  return await transitionDispatch(
-    id,
-    (record) => isTerminalDispatchStatus(record.status) ? record : {
-      ...record,
-      errorMessage,
-      ...resultMessageTs ? { resultMessageTs } : {},
-      status: "blocked"
-    }
-  );
-}
-async function markDispatchCompleted(id, resultMessageTs) {
-  const previous = await getDispatchRecord(id);
-  const next = await transitionDispatch(
-    id,
-    (record) => isTerminalDispatchStatus(record.status) ? record : {
-      ...record,
-      errorMessage: void 0,
-      ...resultMessageTs ? { resultMessageTs } : {},
-      status: "completed"
-    }
-  );
-  if (next?.status === "completed" && previous?.status !== "completed" && next.plugin === "junior") {
-    const eventTaskId = next.metadata?.eventTaskId;
-    if (eventTaskId) {
-      await recordTaskExecution("event", eventTaskId, {
-        conversationId: getDispatchConversationId(next),
-        executionId: next.id,
-        nowMs: next.updatedAtMs
-      });
-    }
-  }
-  return next;
-}
-async function markDispatchFailed(id, errorMessage, resultMessageTs) {
-  return await transitionDispatch(
-    id,
-    (record) => isTerminalDispatchStatus(record.status) ? record : {
-      ...record,
-      errorMessage,
-      ...resultMessageTs ? { resultMessageTs } : {},
-      status: "failed"
-    }
-  );
-}
-async function confirmDispatchMailboxAppend(id) {
-  const state = getStateAdapter();
-  await state.connect();
-  await updatePendingDispatchMailboxAppendIndex(
-    state,
-    (ids) => ids.filter((candidate) => candidate !== id)
-  );
-}
-async function listPendingDispatchMailboxAppends() {
-  const state = getStateAdapter();
-  await state.connect();
-  const stored = await state.get(pendingDispatchMailboxAppendIndexKey());
-  return stored === void 0 || stored === null ? [] : [...new Set(pendingDispatchMailboxAppendIndexSchema.parse(stored))];
-}
-async function claimDispatchMailboxAppend(id, nowMs) {
-  return await withDispatchLock(id, async (state) => {
-    const stored = parseStoredDispatchRecord(
-      await state.get(getDispatchStorageKey(id))
-    );
-    if (!stored || stored.legacyLeaseExpiresAtMs && stored.legacyLeaseExpiresAtMs > nowMs) {
-      return void 0;
-    }
-    await putRecord(state, stored.record);
-    return stored.record;
-  });
-}
-async function getPluginDispatchProjection(args) {
-  const record = await getDispatchRecord(args.id);
-  if (!record || record.plugin !== args.plugin) {
-    return void 0;
-  }
-  return toDispatchProjection(record);
-}
-
 // src/chat/agent-dispatch/work.ts
-import { z as z3 } from "zod";
-var agentDispatchMailboxMetadataSchema = z3.object({
-  dispatchId: z3.string().min(1),
-  kind: z3.literal("agent_dispatch")
+import { z as z2 } from "zod";
+var agentDispatchMailboxMetadataSchema = z2.object({
+  dispatchId: z2.string().min(1),
+  kind: z2.literal("agent_dispatch")
 }).strict();
 var AGENT_DISPATCH_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 function buildDispatchRoutingContext(dispatch2) {
   return {
     actor: dispatch2.actor,
-    credentialContext: {
-      actor: dispatch2.actor,
-      ...dispatch2.credentialSubject ? { subject: dispatch2.credentialSubject } : {}
-    },
+    credentialContext: credentialContextForActor(
+      dispatch2.actor,
+      dispatch2.credentialSubject
+    ),
     destinationVisibility: dispatch2.destinationVisibility,
     dispatch: {
       actor: dispatch2.actor,
@@ -1020,7 +678,7 @@ function createAgentDispatchConversationWorker(options) {
         `Dispatch ${dispatch2.id} belongs to ${expectedConversationId}, not ${context.conversationId}`
       );
     }
-    if (context.destination.platform !== dispatch2.destination.platform || context.destination.teamId !== dispatch2.destination.teamId || context.destination.channelId !== dispatch2.destination.channelId) {
+    if (!context.destination || context.destination.platform !== dispatch2.destination.platform || context.destination.teamId !== dispatch2.destination.teamId || context.destination.channelId !== dispatch2.destination.channelId) {
       throw new Error(
         `Dispatch ${dispatch2.id} destination does not match its conversation lease`
       );
@@ -1159,6 +817,10 @@ function heartbeatIdempotencyKey(reason, conversationId, nowMs) {
   return `heartbeat:${reason}:${conversationId}:${nowMs}`;
 }
 async function recoverConversationWork(args) {
+  if (!getChatConfig().conversationWorkEnabled) {
+    logWarn("conversation.work.recovery.disabled");
+    return { expiredLeaseCount: 0, pendingCount: 0 };
+  }
   const result = {
     expiredLeaseCount: 0,
     pendingCount: 0
@@ -1203,12 +865,24 @@ async function recoverConversationWork(args) {
           return;
         }
         if (work.execution.lease && work.execution.lease.expiresAtMs <= args.nowMs) {
-          const cleared = await clearExpiredConversationLease({
+          const recovery = await clearExpiredConversationLease({
             conversationId,
             nowMs: args.nowMs,
             state: args.state
           });
-          if (!cleared) {
+          if (recovery === "not_expired") {
+            return;
+          }
+          if (recovery === "stopped") {
+            logException(
+              new Error("Conversation work stopped after repeated failed attempts"),
+              "conversation.work.retry.exhausted",
+              {
+                "app.run.id": work.execution.runId ?? "unknown",
+                "app.worker.last_progress_at_ms": work.execution.lastProgressAtMs ?? work.createdAtMs,
+                "app.worker.retry_count": (work.execution.retryCount ?? 0) + 1
+              }
+            );
             return;
           }
           const wake2 = await ensureConversationWake({
@@ -1263,7 +937,7 @@ import {
 // src/chat/agent-dispatch/validation.ts
 import {
   dispatchOptionsSchema,
-  isSlackDestination as isSlackDestination2
+  isSlackDestination
 } from "@sentry/junior-plugin-api";
 function hasIssueAtPath(issues, path) {
   return issues.some(
@@ -1360,7 +1034,7 @@ function validateDispatchOptions(options) {
   }
   const candidate = parsed.data;
   const { credentialSubject, destination } = candidate;
-  if (!isSlackDestination2(destination)) {
+  if (!isSlackDestination(destination)) {
     throw new Error("Dispatch destination platform must be slack");
   }
   if (credentialSubject !== void 0) {
@@ -1585,6 +1259,15 @@ function shouldSkipRun(task, run) {
   }
   return void 0;
 }
+async function recordScheduledExecution(args) {
+  const dispatchId = args.run.dispatchId;
+  await recordTaskExecution("scheduled", args.run.taskId, {
+    ...dispatchId ? { conversationId: getDispatchConversationId({ id: dispatchId }) } : {},
+    executionId: args.run.id,
+    nowMs: args.nowMs,
+    status: args.status
+  });
+}
 async function applyDispatchResult(args) {
   if (args.dispatch.status === "completed") {
     const completed = await args.store.markRunCompleted({
@@ -1599,14 +1282,11 @@ async function applyDispatchResult(args) {
       run: args.run,
       status: "completed"
     });
-    const dispatchId = args.run.dispatchId;
-    if (dispatchId) {
-      await recordTaskExecution("scheduled", args.run.taskId, {
-        conversationId: getDispatchConversationId({ id: dispatchId }),
-        executionId: args.run.id,
-        nowMs: args.nowMs
-      });
-    }
+    await recordScheduledExecution({
+      nowMs: args.nowMs,
+      run: args.run,
+      status: "completed"
+    });
     return true;
   }
   if (args.dispatch.status === "blocked") {
@@ -1623,6 +1303,11 @@ async function applyDispatchResult(args) {
       run: args.run,
       status: "blocked"
     });
+    await recordScheduledExecution({
+      nowMs: args.nowMs,
+      run: args.run,
+      status: "blocked"
+    });
     return true;
   }
   if (args.dispatch.status === "failed") {
@@ -1639,6 +1324,11 @@ async function applyDispatchResult(args) {
       run: args.run,
       status: "failed"
     });
+    await recordScheduledExecution({
+      nowMs: args.nowMs,
+      run: args.run,
+      status: "failed"
+    });
     return true;
   }
   return false;
@@ -1661,6 +1351,11 @@ async function finishClaimedRun(args) {
     run: args.run,
     status: args.status
   });
+  await recordScheduledExecution({
+    nowMs: args.nowMs,
+    run: args.run,
+    status: args.status
+  });
 }
 async function runScheduledTaskHeartbeat(args) {
   const store = createSchedulerSqlStore(getDb());
@@ -1765,6 +1460,7 @@ async function runScheduledTaskHeartbeat(args) {
 var DEFAULT_PLUGIN_LIMIT = 25;
 var PLUGIN_HEARTBEAT_TIMEOUT_MS = 25e3;
 var DISPATCH_MAILBOX_APPEND_LIMIT = 100;
+var AGENT_INVOCATION_MAILBOX_APPEND_LIMIT = 100;
 async function runWithTimeout(promise, timeoutMs) {
   let timeout;
   try {
@@ -1851,6 +1547,23 @@ async function recoverPendingDispatchMailboxAppends(args) {
     }
   }
 }
+async function recoverPendingAgentInvocationMailboxAppends(args) {
+  const invocations = await listPendingAgentInvocationMailboxAppends(
+    AGENT_INVOCATION_MAILBOX_APPEND_LIMIT
+  );
+  for (const invocation of invocations) {
+    try {
+      await enqueueAgentInvocation(invocation, {
+        nowMs: args.nowMs,
+        queue: args.conversationWorkQueue
+      });
+    } catch (error) {
+      logException(error, "agent.invocation.mailbox.append_recovery.failed", {
+        "app.agent.invocation_id": invocation.invocationId
+      });
+    }
+  }
+}
 async function runHeartbeat(args) {
   const queue = args.conversationWorkQueue ?? getVercelConversationWorkQueue();
   await recoverConversationWork({
@@ -1861,6 +1574,10 @@ async function runHeartbeat(args) {
     conversationWorkQueue: queue,
     nowMs: args.nowMs
   });
+  await recoverPendingAgentInvocationMailboxAppends({
+    conversationWorkQueue: queue,
+    nowMs: args.nowMs
+  });
   try {
     const dispatchCount = await runScheduledTaskHeartbeat({
       conversationWorkQueue: queue,
@@ -1919,7 +1636,7 @@ async function GET4(request, waitUntil, options = {}) {
 import { timingSafeEqual as timingSafeEqual3 } from "crypto";
 
 // src/chat/conversations/sql/purge.ts
-import { and, asc, eq as eq2, inArray, isNull, sql } from "drizzle-orm";
+import { and, asc, eq as eq2, inArray, isNull, or, sql } from "drizzle-orm";
 
 // src/chat/conversations/sql/privacy.ts
 import { eq } from "drizzle-orm";
@@ -2010,6 +1727,16 @@ async function selectExpiredRoots(executor, args) {
       select 1 from junior_conversation_events events
       where events.conversation_id = tree.conversation_id
     )
+      or exists (
+        select 1 from junior_agent_invocations invocations
+        where invocations.parent_conversation_id = tree.conversation_id
+           or invocations.child_conversation_id = tree.conversation_id
+      )
+      or exists (
+        select 1 from junior_agent_bindings bindings
+        where bindings.parent_conversation_id = tree.conversation_id
+           or bindings.child_conversation_id = tree.conversation_id
+      )
       or (
         ${juniorDestinations.visibility} is distinct from 'public'
         and exists (
@@ -2045,69 +1772,85 @@ async function selectExpiredRoots(executor, args) {
   }));
 }
 async function purgeConversationTree(executor, args) {
-  return await executor.transaction(async () => {
-    const initialRoots = await executor.db().select({
-      conversationId: juniorConversations.conversationId,
-      parentConversationId: juniorConversations.parentConversationId
-    }).from(juniorConversations).where(eq2(juniorConversations.conversationId, args.rootConversationId));
-    const initialRoot = initialRoots[0];
-    if (!initialRoot || args.retention && initialRoot.parentConversationId !== null) {
-      return { purged: false, conversations: 0 };
-    }
-    const tree = await discoverConversationTree(executor, initialRoot);
-    return await withConversationEventLock(
-      executor,
-      args.rootConversationId,
-      async () => {
-        for (const conversation of tree.slice(1)) {
-          await withConversationEventLock(
-            executor,
-            conversation.conversationId,
-            async () => void 0
-          );
-        }
-        const roots = await executor.db().select({
-          conversationId: juniorConversations.conversationId,
-          destinationId: juniorConversations.destinationId,
-          parentConversationId: juniorConversations.parentConversationId
-        }).from(juniorConversations).where(
-          eq2(juniorConversations.conversationId, args.rootConversationId)
-        ).for("update");
-        const root = roots[0];
-        if (!root || args.retention && root.parentConversationId !== null) {
-          return { purged: false, conversations: 0 };
-        }
-        const resolvedScrubMetadata = args.scrubMetadataFromRootVisibility ? (await resolveRootVisibility(executor, args.rootConversationId)).visibility !== "public" : args.scrubMetadata;
-        const destinations = root.destinationId ? await executor.db().select({ visibility: juniorDestinations.visibility }).from(juniorDestinations).where(eq2(juniorDestinations.id, root.destinationId)).for("share") : [];
-        const isPublic = destinations[0]?.visibility === "public";
-        const ids = tree.map((conversation) => conversation.conversationId);
-        if (args.retention) {
-          const currentActivity = await executor.db().select({
+  return await withConversationMutationLock(
+    executor,
+    args.rootConversationId,
+    async () => {
+      const initialRoots = await executor.db().select({
+        conversationId: juniorConversations.conversationId,
+        parentConversationId: juniorConversations.parentConversationId
+      }).from(juniorConversations).where(eq2(juniorConversations.conversationId, args.rootConversationId));
+      const initialRoot = initialRoots[0];
+      if (!initialRoot || args.retention && initialRoot.parentConversationId !== null) {
+        return { purged: false, conversations: 0 };
+      }
+      const tree = await discoverConversationTree(executor, initialRoot);
+      return await withConversationEventLock(
+        executor,
+        args.rootConversationId,
+        async () => {
+          for (const conversation of tree.slice(1)) {
+            await withConversationEventLock(
+              executor,
+              conversation.conversationId,
+              async () => void 0
+            );
+          }
+          const roots = await executor.db().select({
             conversationId: juniorConversations.conversationId,
-            lastActivityAt: juniorConversations.lastActivityAt
-          }).from(juniorConversations).where(inArray(juniorConversations.conversationId, ids));
-          if (currentActivity.length !== ids.length) {
+            destinationId: juniorConversations.destinationId,
+            parentConversationId: juniorConversations.parentConversationId
+          }).from(juniorConversations).where(
+            eq2(juniorConversations.conversationId, args.rootConversationId)
+          ).for("update");
+          const root = roots[0];
+          if (!root || args.retention && root.parentConversationId !== null) {
             return { purged: false, conversations: 0 };
           }
-          const windowMs = isPublic ? args.retention.publicWindowMs : args.retention.privateWindowMs;
-          const effectiveLastActivityAt = Math.max(
-            ...currentActivity.map(
-              (conversation) => conversation.lastActivityAt.getTime()
+          const resolvedScrubMetadata = args.scrubMetadataFromRootVisibility ? (await resolveRootVisibility(executor, args.rootConversationId)).visibility !== "public" : args.scrubMetadata;
+          const destinations = root.destinationId ? await executor.db().select({ visibility: juniorDestinations.visibility }).from(juniorDestinations).where(eq2(juniorDestinations.id, root.destinationId)).for("share") : [];
+          const isPublic = destinations[0]?.visibility === "public";
+          const ids = tree.map((conversation) => conversation.conversationId);
+          if (args.retention) {
+            const currentActivity = await executor.db().select({
+              conversationId: juniorConversations.conversationId,
+              lastActivityAt: juniorConversations.lastActivityAt
+            }).from(juniorConversations).where(inArray(juniorConversations.conversationId, ids));
+            if (currentActivity.length !== ids.length) {
+              return { purged: false, conversations: 0 };
+            }
+            const windowMs = isPublic ? args.retention.publicWindowMs : args.retention.privateWindowMs;
+            const effectiveLastActivityAt = Math.max(
+              ...currentActivity.map(
+                (conversation) => conversation.lastActivityAt.getTime()
+              )
+            );
+            if (effectiveLastActivityAt >= args.nowMs - windowMs) {
+              return { purged: false, conversations: 0 };
+            }
+          }
+          await executor.db().delete(juniorConversationEvents).where(inArray(juniorConversationEvents.conversationId, ids));
+          await executor.db().delete(juniorAgentInvocations).where(
+            or(
+              inArray(juniorAgentInvocations.parentConversationId, ids),
+              inArray(juniorAgentInvocations.childConversationId, ids)
             )
           );
-          if (effectiveLastActivityAt >= args.nowMs - windowMs) {
-            return { purged: false, conversations: 0 };
-          }
+          await executor.db().delete(juniorAgentBindings).where(
+            or(
+              inArray(juniorAgentBindings.parentConversationId, ids),
+              inArray(juniorAgentBindings.childConversationId, ids)
+            )
+          );
+          await executor.db().update(juniorConversations).set({
+            transcriptPurgedAt: new Date(args.nowMs),
+            ...(args.retention ? !isPublic : resolvedScrubMetadata) ? { title: null, channelName: null, actor: null } : {}
+          }).where(inArray(juniorConversations.conversationId, ids));
+          return { purged: true, conversations: ids.length };
         }
-        await executor.db().delete(juniorConversationEvents).where(inArray(juniorConversationEvents.conversationId, ids));
-        await executor.db().update(juniorConversations).set({
-          transcriptPurgedAt: new Date(args.nowMs),
-          ...(args.retention ? !isPublic : resolvedScrubMetadata) ? { title: null, channelName: null, actor: null } : {}
-        }).where(inArray(juniorConversations.conversationId, ids));
-        return { purged: true, conversations: ids.length };
-      }
-    );
-  });
+      );
+    }
+  );
 }
 
 // src/chat/conversations/retention.ts
@@ -2219,9 +1962,9 @@ function buildJwksUrl(value) {
   return url;
 }
 async function getJwks(issuer) {
-  const now2 = Date.now();
+  const now = Date.now();
   const cached = jwksByIssuer.get(issuer);
-  if (cached && cached.expiresAtMs > now2) {
+  if (cached && cached.expiresAtMs > now) {
     return cached.jwks;
   }
   if (cached) {
@@ -2246,7 +1989,7 @@ async function getJwks(issuer) {
   }
   jwksByIssuer.set(issuer, {
     jwks,
-    expiresAtMs: now2 + OIDC_DISCOVERY_CACHE_TTL_MS
+    expiresAtMs: now + OIDC_DISCOVERY_CACHE_TTL_MS
   });
   return jwks;
 }
@@ -2572,7 +2315,7 @@ import {
   Message,
   ThreadImpl
 } from "chat";
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 
 // src/chat/ingress/message-router.ts
 function normalizeIncomingSlackThreadId(threadId, message) {
@@ -2743,14 +2486,14 @@ async function ensureSlackMessageActorIdentity(message, teamId, lookupSlackUser2
 }
 
 // src/chat/slack/user.ts
-import { z as z4 } from "zod";
-var slackUserInfoSchema = z4.object({
-  ok: z4.literal(true),
-  user: z4.object({
-    name: z4.string().nullish(),
-    profile: z4.object({
-      email: z4.string().nullish(),
-      real_name: z4.string().nullish()
+import { z as z3 } from "zod";
+var slackUserInfoSchema = z3.object({
+  ok: z3.literal(true),
+  user: z3.object({
+    name: z3.string().nullish(),
+    profile: z3.object({
+      email: z3.string().nullish(),
+      real_name: z3.string().nullish()
     }).optional()
   })
 });
@@ -2827,6 +2570,20 @@ async function lookupSlackUser(teamId, userId) {
   }
 }
 
+// src/chat/resource-events/actor.ts
+var RESOURCE_EVENT_SLACK_AUTHOR_ID = "UJRNEVENT";
+var RESOURCE_EVENT_SYSTEM_ACTOR = {
+  platform: "system",
+  name: "resource-event"
+};
+function isResourceEventConversationMessage(message) {
+  return Boolean(message.meta?.eventType) || message.author?.userId === RESOURCE_EVENT_SLACK_AUTHOR_ID;
+}
+function isResourceEventSlackMessage(message) {
+  const raw = message.raw && typeof message.raw === "object" ? message.raw : void 0;
+  return raw?.event_type === "resource_event";
+}
+
 // src/chat/slack/message-control.ts
 var LEADING_MENTION_BEFORE_STEERING_RE = /^(\s*(?:<@[^>]+>|@[A-Za-z0-9._-]+\b)[\s,:-]*)!!\s*/;
 function stripLeadingSteeringOverride(text) {
@@ -2834,17 +2591,17 @@ function stripLeadingSteeringOverride(text) {
 }
 
 // src/chat/task-execution/slack-work.ts
-var slackConversationRouteSchema = z5.enum(["mention", "subscribed"]);
+var slackConversationRouteSchema = z4.enum(["mention", "subscribed"]);
 function hasSteeringOverride(text) {
   return stripLeadingSteeringOverride(text) !== text;
 }
-var serializedDateSchema = z5.iso.datetime();
-var mdastPointSchema = z5.object({
-  column: z5.number().int().positive(),
-  line: z5.number().int().positive(),
-  offset: z5.number().int().nonnegative().optional()
+var serializedDateSchema = z4.iso.datetime();
+var mdastPointSchema = z4.object({
+  column: z4.number().int().positive(),
+  line: z4.number().int().positive(),
+  offset: z4.number().int().nonnegative().optional()
 }).strict();
-var mdastPositionSchema = z5.object({
+var mdastPositionSchema = z4.object({
   end: mdastPointSchema,
   start: mdastPointSchema
 }).strict();
@@ -2956,7 +2713,7 @@ function isFormattedContentNode(value) {
       return false;
   }
 }
-var formattedContentSchema = z5.custom(
+var formattedContentSchema = z4.custom(
   (value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
       return false;
@@ -2966,79 +2723,79 @@ var formattedContentSchema = z5.custom(
   },
   "must be a valid formatted-content root"
 );
-var serializedMessageSchema = z5.object({
-  _type: z5.literal("chat:Message"),
-  attachments: z5.array(
-    z5.object({
-      type: z5.enum(["image", "file", "video", "audio"]),
-      url: z5.string().optional(),
-      name: z5.string().optional(),
-      mimeType: z5.string().optional(),
-      size: z5.number().finite().optional(),
-      width: z5.number().finite().optional(),
-      height: z5.number().finite().optional(),
-      fetchMetadata: z5.record(z5.string(), z5.string()).optional()
+var serializedMessageSchema = z4.object({
+  _type: z4.literal("chat:Message"),
+  attachments: z4.array(
+    z4.object({
+      type: z4.enum(["image", "file", "video", "audio"]),
+      url: z4.string().optional(),
+      name: z4.string().optional(),
+      mimeType: z4.string().optional(),
+      size: z4.number().finite().optional(),
+      width: z4.number().finite().optional(),
+      height: z4.number().finite().optional(),
+      fetchMetadata: z4.record(z4.string(), z4.string()).optional()
     }).strict()
   ),
-  author: z5.object({
-    userId: z5.string(),
-    userName: z5.string(),
-    fullName: z5.string(),
-    isBot: z5.union([z5.boolean(), z5.literal("unknown")]),
-    isMe: z5.boolean()
+  author: z4.object({
+    userId: z4.string(),
+    userName: z4.string(),
+    fullName: z4.string(),
+    isBot: z4.union([z4.boolean(), z4.literal("unknown")]),
+    isMe: z4.boolean()
   }).strict(),
   formatted: formattedContentSchema,
-  id: z5.string().min(1),
-  isMention: z5.boolean().optional(),
-  links: z5.array(
-    z5.object({
-      url: z5.string(),
-      title: z5.string().optional(),
-      description: z5.string().optional(),
-      imageUrl: z5.string().optional(),
-      siteName: z5.string().optional()
+  id: z4.string().min(1),
+  isMention: z4.boolean().optional(),
+  links: z4.array(
+    z4.object({
+      url: z4.string(),
+      title: z4.string().optional(),
+      description: z4.string().optional(),
+      imageUrl: z4.string().optional(),
+      siteName: z4.string().optional()
     }).strict()
   ).optional(),
-  metadata: z5.object({
+  metadata: z4.object({
     dateSent: serializedDateSchema,
-    edited: z5.boolean(),
+    edited: z4.boolean(),
     editedAt: serializedDateSchema.optional()
   }).strict(),
-  raw: z5.unknown(),
-  text: z5.string(),
-  threadId: z5.string().min(1)
+  raw: z4.unknown(),
+  text: z4.string(),
+  threadId: z4.string().min(1)
 }).strict();
-var serializedThreadSchema = z5.object({
-  _type: z5.literal("chat:Thread"),
-  adapterName: z5.literal("slack"),
-  channelId: z5.string().min(1),
-  channelVisibility: z5.enum(["private", "workspace", "external", "unknown"]).optional(),
+var serializedThreadSchema = z4.object({
+  _type: z4.literal("chat:Thread"),
+  adapterName: z4.literal("slack"),
+  channelId: z4.string().min(1),
+  channelVisibility: z4.enum(["private", "workspace", "external", "unknown"]).optional(),
   currentMessage: serializedMessageSchema.optional(),
-  id: z5.string().min(1),
-  isDM: z5.boolean()
+  id: z4.string().min(1),
+  isDM: z4.boolean()
 }).strict();
-var slackInstallationSchema = z5.object({
-  enterpriseId: z5.string().optional(),
-  isEnterpriseInstall: z5.boolean().optional(),
-  teamId: z5.string().optional()
+var slackInstallationSchema = z4.object({
+  enterpriseId: z4.string().optional(),
+  isEnterpriseInstall: z4.boolean().optional(),
+  teamId: z4.string().optional()
 }).strict();
-var slackConversationMessageMetadataBaseSchema = z5.object({
+var slackConversationMessageMetadataBaseSchema = z4.object({
   installation: slackInstallationSchema.optional(),
   message: serializedMessageSchema,
-  platform: z5.literal("slack"),
+  platform: z4.literal("slack"),
   route: slackConversationRouteSchema,
   thread: serializedThreadSchema
 });
-var slackConversationMessageMetadataSchema = z5.union([
+var slackConversationMessageMetadataSchema = z4.union([
   slackConversationMessageMetadataBaseSchema.strict(),
   slackConversationMessageMetadataBaseSchema.extend({
-    kind: z5.literal("resource_event"),
-    resourceEvent: z5.object({
-      eventKey: z5.string(),
-      eventType: z5.string(),
-      namespace: z5.string(),
-      identifier: z5.string(),
-      subscriptionId: z5.string()
+    kind: z4.literal("resource_event"),
+    resourceEvent: z4.object({
+      eventKey: z4.string(),
+      eventType: z4.string(),
+      namespace: z4.string(),
+      identifier: z4.string(),
+      subscriptionId: z4.string()
     }).strict()
   }).strict()
 ]);
@@ -3071,7 +2828,7 @@ function slackSerializedResourceEventMessage(input) {
     _type: "chat:Message",
     attachments: [],
     author: {
-      userId: "UJRNEVENT",
+      userId: RESOURCE_EVENT_SLACK_AUTHOR_ID,
       userName: "junior-event",
       fullName: "Junior event",
       isBot: true,
@@ -3089,7 +2846,7 @@ function slackSerializedResourceEventMessage(input) {
       resource_event_type: input.eventType,
       thread_ts: input.threadTs,
       type: "message",
-      user: "UJRNEVENT"
+      user: RESOURCE_EVENT_SLACK_AUTHOR_ID
     },
     text: input.text,
     threadId: `slack:${input.channelId}:${input.threadTs}`
@@ -3133,7 +2890,7 @@ function createSlackResourceEventInboundMessage(input) {
     receivedAtMs: Date.now(),
     input: {
       text: input.text,
-      authorId: "UJRNEVENT",
+      authorId: RESOURCE_EVENT_SLACK_AUTHOR_ID,
       metadata: {
         kind: "resource_event",
         installation: {
@@ -3173,10 +2930,6 @@ function routeForRecords(records) {
     return metadata.route === "mention";
   }) ? "mention" : "subscribed";
 }
-function isResourceEventNotificationMessage(message) {
-  const raw = message.raw && typeof message.raw === "object" ? message.raw : void 0;
-  return raw?.event_type === "resource_event";
-}
 function restoreMessage(args) {
   const metadata = parseSlackMetadata(args.record.input.metadata);
   if (!metadata) {
@@ -3192,7 +2945,7 @@ function restoreMessage(args) {
 async function bindSlackActorIdentities(args) {
   const byAuthorId = /* @__PURE__ */ new Map();
   for (const message of args.messages) {
-    if (isResourceEventNotificationMessage(message)) {
+    if (isResourceEventSlackMessage(message)) {
       continue;
     }
     const authorId = requireSlackAuthorId(message);
@@ -3352,7 +3105,7 @@ function createSlackConversationWorker(options) {
           if (route === "mention") {
             await options.runtime.handleNewMention(thread, latestMessage, {
               conversationId: context.conversationId,
-              destination: context.destination,
+              destination,
               messageContext,
               drainSteeringMessages,
               ack,
@@ -3365,7 +3118,7 @@ function createSlackConversationWorker(options) {
               latestMessage,
               {
                 conversationId: context.conversationId,
-                destination: context.destination,
+                destination,
                 messageContext,
                 drainSteeringMessages,
                 ack,
@@ -4143,663 +3896,114 @@ async function handleSlackWebhook(args) {
     if (shouldPersistBeforeAck(parsed)) {
       const failureResponse = await withLogContext(
         eventLogContext,
-        async () => {
-          try {
-            await handleSlackEvent({
-              body: parsed,
-              services: args.services
-            });
-          } catch (error) {
-            if (error instanceof SlackEventPersistenceError) {
-              logException(error.cause, "slack.event.persist.failed");
-            } else {
-              logException(error, "slack.event.routing.failed");
-            }
-            return new Response("Slack event handling failed", { status: 503 });
-          }
-          return void 0;
-        }
-      );
-      if (failureResponse) {
-        return failureResponse;
-      }
-    } else {
-      enqueue(
-        args.waitUntil,
-        withLogContext(
-          eventLogContext,
-          () => handleSlackEvent({
-            body: parsed,
-            services: args.services
-          }).catch((error) => {
-            logException(error, "slack.event.enqueue.failed");
-          })
-        )
-      );
-    }
-  }
-  return new Response("ok", { status: 200 });
-}
-
-// src/handlers/webhooks.ts
-async function handleWebhookRequest(request, platform, run) {
-  const requestContext = createRequestContext(request, { platform });
-  const requestUrl = new URL(request.url);
-  return await withContext(requestContext, async () => {
-    try {
-      return await withSpan(
-        "http.server.request",
-        "http.server",
-        requestContext,
-        async () => {
-          try {
-            const response = await run();
-            if (response.status >= 400) {
-              let responseBodySnippet;
-              try {
-                responseBodySnippet = (await response.clone().text()).slice(
-                  0,
-                  300
-                );
-              } catch {
-                responseBodySnippet = void 0;
-              }
-              logWarn("webhook.response.unsuccessful", {
-                "http.response.status_code": response.status,
-                "http.request.header.x_slack_signature": request.headers.get("x-slack-signature") ?? void 0,
-                "http.request.header.x_slack_request_timestamp": request.headers.get("x-slack-request-timestamp") ?? void 0,
-                ...responseBodySnippet ? { "app.webhook.response_body": responseBodySnippet } : {}
-              });
-            }
-            setSpanAttributes({
-              "http.response.status_code": response.status
-            });
-            setSpanStatus(response.status >= 500 ? "error" : "ok");
-            return response;
-          } catch (error) {
-            setSpanStatus("error");
-            throw error;
-          }
-        },
-        {
-          "http.request.method": request.method,
-          "url.path": requestUrl.pathname
-        }
-      );
-    } catch (error) {
-      logException(error, "webhook.handler.failed");
-      throw error;
-    }
-  });
-}
-
-// src/handlers/slack-webhook.ts
-async function POST2(request, waitUntil, services) {
-  return handleWebhookRequest(
-    request,
-    "slack",
-    () => handleSlackWebhook({
-      request,
-      services,
-      waitUntil
-    })
-  );
-}
-
-// src/chat/task-execution/vercel-callback.ts
-import {
-  handleCallback,
-  registerDevConsumer
-} from "@vercel/queue";
-
-// src/chat/task-execution/worker.ts
-var CONVERSATION_WORK_DEFER_DELAY_MS = 15e3;
-function now(options) {
-  return options.nowMs?.() ?? Date.now();
-}
-function selectContiguousActorBatch(messages) {
-  const first = messages[0];
-  if (!first) {
-    return [];
-  }
-  const nextActorIndex = messages.findIndex(
-    (message) => message.input.authorId !== first.input.authorId
-  );
-  return messages.slice(
-    0,
-    nextActorIndex === -1 ? messages.length : nextActorIndex
-  );
-}
-function selectAttemptMessages(work) {
-  const messages = work.messages;
-  const interrupts = messages.filter(
-    (message) => message.delivery === "interrupt"
-  );
-  if (interrupts.length > 0) {
-    return selectContiguousActorBatch(interrupts);
-  }
-  return work.execution.status === "awaiting_resume" ? [] : selectContiguousActorBatch(messages);
-}
-function nudgeIdempotencyKey(reason, conversationId, nowMs) {
-  return `${reason}:${conversationId}:${nowMs}`;
-}
-async function requestLostLeaseRecovery(args) {
-  const resumeRequested = await requestConversationContinuation({
-    conversationId: args.conversationId,
-    destination: args.destination,
-    leaseToken: args.leaseToken,
-    conversationStore: args.options.conversationStore,
-    nowMs: args.nowMs,
-    state: args.options.state
-  });
-  if (!resumeRequested) {
-    return;
-  }
-  const released = await releaseConversationWork({
-    conversationId: args.conversationId,
-    leaseToken: args.leaseToken,
-    conversationStore: args.options.conversationStore,
-    nowMs: args.nowMs,
-    state: args.options.state
-  });
-  if (!released) {
-    return;
-  }
-  await ensureConversationWake({
-    conversationId: args.conversationId,
-    conversationStore: args.options.conversationStore,
-    idempotencyKey: nudgeIdempotencyKey(
-      "lost_lease",
-      args.conversationId,
-      args.nowMs
-    ),
-    nowMs: args.nowMs,
-    queue: args.options.queue,
-    replaceExistingWake: true,
-    state: args.options.state
-  });
-}
-async function recordFailedDeliveryAttempt(args) {
-  const failure = await recordAttemptFailure({
-    conversationId: args.conversationId,
-    inboundMessageIds: args.messageIds,
-    leaseToken: args.leaseToken,
-    conversationStore: args.options.conversationStore,
-    nowMs: args.nowMs,
-    state: args.options.state
-  });
-  for (const message of failure.deadLetteredMessages) {
-    logWarn("conversation.work.dead_lettered", {
-      "app.conversation.source": message.source,
-      "app.inbound.attempt_count": message.attemptCount ?? 0,
-      "app.inbound.message_id": message.inboundMessageId,
-      "app.inbound.pending_count": failure.pendingCount
-    });
-  }
-  return failure;
-}
-function isTerminalFailure(failure) {
-  return failure.status === "recorded" && failure.deadLetteredMessages.length > 0 && failure.pendingCount === 0;
-}
-function startLeaseCheckIn(args) {
-  const timer = setInterval(() => {
-    const nowMs = now(args.options);
-    void checkInConversationWork({
-      conversationId: args.conversationId,
-      leaseToken: args.leaseToken,
-      conversationStore: args.options.conversationStore,
-      nowMs,
-      state: args.options.state
-    }).then(
-      (checkedIn) => {
-        if (!checkedIn) {
-          args.onLostLease();
-          logWarn("conversation.work.check_in.failed");
-        }
-      },
-      (error) => {
-        logException(error, "conversation.work.check_in.failed");
-      }
-    );
-  }, args.options.checkInIntervalMs ?? CONVERSATION_WORK_CHECK_IN_INTERVAL_MS);
-  timer.unref?.();
-  return timer;
-}
-async function processConversationWork(message, options) {
-  return withLogContext(
-    { conversationId: message.conversationId },
-    () => processConversationWorkInContext(message, options)
-  );
-}
-async function processConversationWorkInContext(message, options) {
-  const conversationId = message.conversationId;
-  let initial;
-  try {
-    initial = await getConversationWorkState({
-      conversationId,
-      state: options.state
-    });
-  } catch (error) {
-    if (isInvalidConversationRecordError(error)) {
-      throw new ConversationQueueMessageRejectedError(
-        "invalid_record",
-        `Conversation record failed validation for ${conversationId}`,
-        { conversationId }
-      );
-    }
-    throw error;
-  }
-  if (!initial || countPendingConversationMessages(initial) === 0 && initial.execution.status === "idle" && !initial.execution.lease) {
-    if (initial) {
-      await clearConsumedConversationWake({
-        conversationId,
-        conversationStore: options.conversationStore,
-        nowMs: now(options),
-        state: options.state
-      });
-    }
-    return { status: "no_work" };
-  }
-  if (!initial.destination) {
-    throw new ConversationQueueMessageRejectedError(
-      "invalid_record",
-      `Conversation work is missing destination context for ${conversationId}`,
-      { conversationId }
-    );
-  }
-  const destination = initial.destination;
-  const lease = await startConversationWork({
-    conversationId,
-    conversationStore: options.conversationStore,
-    nowMs: now(options),
-    state: options.state
-  });
-  if (lease.status === "no_work") {
-    await clearConsumedConversationWake({
-      conversationId,
-      conversationStore: options.conversationStore,
-      nowMs: now(options),
-      state: options.state
-    });
-    return { status: "no_work" };
-  }
-  if (lease.status === "active") {
-    const nudgeNowMs = now(options);
-    await ensureConversationWake({
-      conversationId,
-      conversationStore: options.conversationStore,
-      delayMs: CONVERSATION_WORK_DEFER_DELAY_MS,
-      idempotencyKey: nudgeIdempotencyKey("active", conversationId, nudgeNowMs),
-      nowMs: nudgeNowMs,
-      queue: options.queue,
-      replaceExistingWake: true,
-      state: options.state
-    });
-    logInfo("conversation.work.nudge.deferred", {
-      "app.lease.expires_at_ms": lease.leaseExpiresAtMs
-    });
-    return { status: "active" };
-  }
-  const startedAtMs = now(options);
-  const softYieldDeadlineMs = startedAtMs + (options.softYieldAfterMs ?? getChatConfig().conversationWorkSoftYieldAfterMs);
-  let attemptMessageIds = [];
-  let attemptSelectedMessageIds = /* @__PURE__ */ new Set();
-  let attemptStartMessageIds = /* @__PURE__ */ new Set();
-  let leaseLost = false;
-  const markLeaseLost = () => {
-    leaseLost = true;
-  };
-  const timer = startLeaseCheckIn({
-    conversationId,
-    leaseToken: lease.leaseToken,
-    onLostLease: markLeaseLost,
-    options
-  });
-  logInfo("conversation.work.lease.acquired", {
-    "app.lease.expires_at_ms": lease.leaseExpiresAtMs,
-    "app.worker.soft_yield_deadline_ms": softYieldDeadlineMs
-  });
-  const drain = (handle) => drainConversationMailbox({
-    conversationId,
-    leaseToken: lease.leaseToken,
-    conversationStore: options.conversationStore,
-    handle: async (messages) => {
-      const candidates = messages.filter(
-        (message2) => message2.delivery === "interrupt" && (attemptSelectedMessageIds.has(message2.inboundMessageId) || !attemptStartMessageIds.has(message2.inboundMessageId))
-      );
-      if (candidates.length === 0) {
-        return [];
-      }
-      return await handle(candidates) ?? candidates.map((message2) => message2.inboundMessageId);
-    },
-    nowMs: now(options),
-    state: options.state
-  });
-  const shouldYield = () => leaseLost || now(options) >= softYieldDeadlineMs;
-  const checkIn = async () => {
-    const checkedIn = await checkInConversationWork({
-      conversationId,
-      leaseToken: lease.leaseToken,
-      conversationStore: options.conversationStore,
-      nowMs: now(options),
-      state: options.state
-    });
-    if (!checkedIn) {
-      markLeaseLost();
-    }
-    return checkedIn;
-  };
-  const yieldWork = async () => {
-    const yieldNowMs = now(options);
-    await ensureConversationWake({
-      conversationId,
-      conversationStore: options.conversationStore,
-      idempotencyKey: nudgeIdempotencyKey("yield", conversationId, yieldNowMs),
-      nowMs: yieldNowMs,
-      queue: options.queue,
-      replaceExistingWake: true,
-      state: options.state
-    });
-    const released = await releaseConversationWork({
-      conversationId,
-      leaseToken: lease.leaseToken,
-      conversationStore: options.conversationStore,
-      nowMs: yieldNowMs,
-      state: options.state
-    });
-    if (!released) {
-      return { status: "lost_lease" };
-    }
-    logInfo("conversation.work.yielded", {
-      "app.worker.elapsed_ms": now(options) - startedAtMs,
-      "app.worker.soft_yield_deadline_ms": softYieldDeadlineMs
-    });
-    return { status: "yielded" };
-  };
-  try {
-    let hasRun = false;
-    while (true) {
-      attemptMessageIds = [];
-      const leasedWork = await getConversationWorkState({
-        conversationId,
-        state: options.state
-      });
-      if (!leasedWork || leasedWork.lease?.leaseToken !== lease.leaseToken || leaseLost) {
-        markLeaseLost();
-        await requestLostLeaseRecovery({
-          conversationId,
-          destination,
-          leaseToken: lease.leaseToken,
-          nowMs: now(options),
-          options
-        });
-        return { status: "lost_lease" };
-      }
-      const resumePending = leasedWork.execution.status === "awaiting_resume";
-      const attemptMessages = selectAttemptMessages(leasedWork);
-      attemptStartMessageIds = new Set(
-        leasedWork.messages.map((message2) => message2.inboundMessageId)
-      );
-      if (hasRun && shouldYield()) {
-        if (resumePending) {
-          return await yieldWork();
-        }
-        break;
-      }
-      if (resumePending && attemptMessages.length === 0) {
-        const resumeStarted = await beginConversationResume({
-          conversationId,
-          leaseToken: lease.leaseToken,
-          conversationStore: options.conversationStore,
-          nowMs: now(options),
-          state: options.state
-        });
-        if (!resumeStarted) {
-          markLeaseLost();
-          await requestLostLeaseRecovery({
-            conversationId,
-            destination,
-            leaseToken: lease.leaseToken,
-            nowMs: now(options),
-            options
-          });
-          return { status: "lost_lease" };
+        async () => {
+          try {
+            await handleSlackEvent({
+              body: parsed,
+              services: args.services
+            });
+          } catch (error) {
+            if (error instanceof SlackEventPersistenceError) {
+              logException(error.cause, "slack.event.persist.failed");
+            } else {
+              logException(error, "slack.event.routing.failed");
+            }
+            return new Response("Slack event handling failed", { status: 503 });
+          }
+          return void 0;
         }
-      }
-      attemptMessageIds = attemptMessages.map(
-        (message2) => message2.inboundMessageId
       );
-      attemptSelectedMessageIds = new Set(attemptMessageIds);
-      const ack = async () => {
-        const acknowledged = await ackMessages({
-          conversationId,
-          inboundMessageIds: attemptMessageIds,
-          leaseToken: lease.leaseToken,
-          conversationStore: options.conversationStore,
-          nowMs: now(options),
-          state: options.state
-        });
-        if (!acknowledged) {
-          markLeaseLost();
-          throw new Error(
-            `Conversation work lease lost before inbox ack for ${conversationId}`
-          );
-        }
-      };
-      const workerContext = {
-        attempt: {
-          ack,
-          conversationId,
-          destination,
-          drain,
-          isFinalAttempt: attemptMessages.some(
-            (message2) => isFinalAttempt(message2)
-          ),
-          messages: attemptMessages
-        },
-        conversationId,
-        destination,
-        shouldYield,
-        checkIn
-      };
-      const result = await options.run(workerContext);
-      hasRun = true;
-      if (result.status === "lost_lease") {
-        await requestLostLeaseRecovery({
-          conversationId,
-          destination,
-          leaseToken: lease.leaseToken,
-          nowMs: now(options),
-          options
-        });
-        return { status: "lost_lease" };
-      }
-      if (leaseLost) {
-        await requestLostLeaseRecovery({
-          conversationId,
-          destination,
-          leaseToken: lease.leaseToken,
-          nowMs: now(options),
-          options
-        });
-        return { status: "lost_lease" };
-      }
-      if (result.status === "yielded") {
-        const resumeRequested = await requestConversationContinuation({
-          conversationId,
-          destination,
-          leaseToken: lease.leaseToken,
-          conversationStore: options.conversationStore,
-          nowMs: now(options),
-          state: options.state
-        });
-        if (!resumeRequested) {
-          return { status: "lost_lease" };
-        }
-        return await yieldWork();
-      }
-      if (result.status === "deferred") {
-        const deferredNowMs = now(options);
-        const released = await releaseConversationWork({
-          conversationId,
-          leaseToken: lease.leaseToken,
-          conversationStore: options.conversationStore,
-          nowMs: deferredNowMs,
-          state: options.state
-        });
-        if (!released) {
-          return { status: "lost_lease" };
-        }
-        const wake = await ensureConversationWake({
-          conversationId,
-          conversationStore: options.conversationStore,
-          idempotencyKey: nudgeIdempotencyKey(
-            "deferred",
-            conversationId,
-            deferredNowMs
-          ),
-          nowMs: deferredNowMs,
-          queue: options.queue,
-          state: options.state
-        });
-        return wake.status === "enqueued" ? { status: "pending_requeued" } : { status: "completed" };
-      }
-      if (attemptMessageIds.length > 0) {
-        const failure = await recordFailedDeliveryAttempt({
-          conversationId,
-          leaseToken: lease.leaseToken,
-          nowMs: now(options),
-          messageIds: attemptMessageIds,
-          options
-        });
-        if (isTerminalFailure(failure)) {
-          await deadLetterAttempt({
-            conversationId,
-            leaseToken: lease.leaseToken,
-            conversationStore: options.conversationStore,
-            nowMs: now(options),
-            state: options.state
-          });
-          return { status: "failed" };
-        }
-        if (failure.status === "lost_lease") {
-          return { status: "lost_lease" };
-        }
-        if (failure.status === "recorded") {
-          break;
-        }
-      }
-      const next = await getConversationWorkState({
-        conversationId,
-        state: options.state
-      });
-      if (!next || next.lease?.leaseToken !== lease.leaseToken) {
-        return { status: "lost_lease" };
-      }
-      if (next.execution.status !== "awaiting_resume" && countPendingConversationMessages(next) === 0) {
-        break;
+      if (failureResponse) {
+        return failureResponse;
       }
+    } else {
+      enqueue(
+        args.waitUntil,
+        withLogContext(
+          eventLogContext,
+          () => handleSlackEvent({
+            body: parsed,
+            services: args.services
+          }).catch((error) => {
+            logException(error, "slack.event.enqueue.failed");
+          })
+        )
+      );
     }
-    const completion = await completeConversationWork({
-      conversationId,
-      leaseToken: lease.leaseToken,
-      conversationStore: options.conversationStore,
-      nowMs: now(options),
-      state: options.state
-    });
-    if (completion === "lost_lease") {
-      return { status: "lost_lease" };
-    }
-    if (completion === "pending") {
-      const nudgeNowMs = now(options);
-      const wake = await ensureConversationWake({
-        conversationId,
-        conversationStore: options.conversationStore,
-        idempotencyKey: nudgeIdempotencyKey(
-          "pending",
-          conversationId,
-          nudgeNowMs
-        ),
-        nowMs: nudgeNowMs,
-        queue: options.queue,
-        state: options.state
-      });
-      return wake.status === "enqueued" ? { status: "pending_requeued" } : { status: "completed" };
-    }
-    logInfo("conversation.work.completed", {
-      "app.worker.elapsed_ms": now(options) - startedAtMs
-    });
-    return { status: "completed" };
-  } catch (error) {
-    const errorNowMs = now(options);
-    let recoveryRecorded = false;
+  }
+  return new Response("ok", { status: 200 });
+}
+
+// src/handlers/webhooks.ts
+async function handleWebhookRequest(request, platform, run) {
+  const requestContext = createRequestContext(request, { platform });
+  const requestUrl = new URL(request.url);
+  return await withContext(requestContext, async () => {
     try {
-      const failure = attemptMessageIds.length > 0 ? await recordFailedDeliveryAttempt({
-        conversationId,
-        leaseToken: lease.leaseToken,
-        nowMs: errorNowMs,
-        messageIds: attemptMessageIds,
-        options
-      }) : void 0;
-      if (failure && isTerminalFailure(failure)) {
-        await deadLetterAttempt({
-          conversationId,
-          leaseToken: lease.leaseToken,
-          conversationStore: options.conversationStore,
-          nowMs: errorNowMs,
-          state: options.state
-        });
-      } else {
-        const resumeRequested = await requestConversationContinuation({
-          conversationId,
-          destination,
-          leaseToken: lease.leaseToken,
-          conversationStore: options.conversationStore,
-          nowMs: errorNowMs,
-          state: options.state
-        });
-        if (resumeRequested) {
-          await ensureConversationWake({
-            conversationId,
-            conversationStore: options.conversationStore,
-            idempotencyKey: nudgeIdempotencyKey(
-              "error",
-              conversationId,
-              errorNowMs
-            ),
-            nowMs: errorNowMs,
-            queue: options.queue,
-            replaceExistingWake: true,
-            state: options.state
-          });
+      return await withSpan(
+        "http.server.request",
+        "http.server",
+        requestContext,
+        async () => {
+          try {
+            const response = await run();
+            if (response.status >= 400) {
+              let responseBodySnippet;
+              try {
+                responseBodySnippet = (await response.clone().text()).slice(
+                  0,
+                  300
+                );
+              } catch {
+                responseBodySnippet = void 0;
+              }
+              logWarn("webhook.response.unsuccessful", {
+                "http.response.status_code": response.status,
+                "http.request.header.x_slack_signature": request.headers.get("x-slack-signature") ?? void 0,
+                "http.request.header.x_slack_request_timestamp": request.headers.get("x-slack-request-timestamp") ?? void 0,
+                ...responseBodySnippet ? { "app.webhook.response_body": responseBodySnippet } : {}
+              });
+            }
+            setSpanAttributes({
+              "http.response.status_code": response.status
+            });
+            setSpanStatus(response.status >= 500 ? "error" : "ok");
+            return response;
+          } catch (error) {
+            setSpanStatus("error");
+            throw error;
+          }
+        },
+        {
+          "http.request.method": request.method,
+          "url.path": requestUrl.pathname
         }
-        await releaseConversationWork({
-          conversationId,
-          leaseToken: lease.leaseToken,
-          conversationStore: options.conversationStore,
-          nowMs: errorNowMs,
-          state: options.state
-        });
-      }
-      recoveryRecorded = true;
-    } catch (recoveryError) {
-      logException(recoveryError, "conversation.work.requeue.failed");
-    }
-    if (!isProviderRetryError(error)) {
-      logException(error, "conversation.work.failed", {
-        "app.worker.elapsed_ms": now(options) - startedAtMs
-      });
-    }
-    if (!recoveryRecorded) {
+      );
+    } catch (error) {
+      logException(error, "webhook.handler.failed");
       throw error;
     }
-    return { status: "failed" };
-  } finally {
-    clearInterval(timer);
-  }
+  });
+}
+
+// src/handlers/slack-webhook.ts
+async function POST2(request, waitUntil, services) {
+  return handleWebhookRequest(
+    request,
+    "slack",
+    () => handleSlackWebhook({
+      request,
+      services,
+      waitUntil
+    })
+  );
 }
 
 // src/chat/task-execution/vercel-callback.ts
+import {
+  handleCallback,
+  registerDevConsumer
+} from "@vercel/queue";
 var CONVERSATION_WORK_VISIBILITY_TIMEOUT_BUFFER_SECONDS = 30;
 var CONVERSATION_WORK_DEV_CONSUMER_GROUP = "junior_conversation_work_dev";
 function parseConversationQueueMessage(message) {
@@ -4825,6 +4029,15 @@ async function processConversationQueueMessage(message, options) {
   });
 }
 async function handleConversationQueueMessage(message, metadata, options) {
+  if (!getChatConfig().conversationWorkEnabled) {
+    logWarn("conversation.work.processing.disabled", {
+      "app.queue.consumer_group": metadata.consumerGroup,
+      "app.queue.delivery_count": metadata.deliveryCount,
+      "app.queue.message_id": metadata.messageId,
+      "app.queue.topic_name": metadata.topicName
+    });
+    return;
+  }
   const verification = verifyConversationQueueMessage(message);
   if (verification.status === "rejected") {
     logConversationQueueMessageRejected(verification.reason, metadata);
@@ -4951,7 +4164,7 @@ function registerVercelPluginTaskDevConsumer() {
 }
 
 // src/chat/services/subscribed-decision.ts
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 
 // src/chat/services/subscribed-reply-router-policy.ts
 function buildSubscribedReplyRouterPolicy(assistantName) {
@@ -4996,13 +4209,13 @@ Assess conversation floor ownership and whether the latest message continues wor
 }
 
 // src/chat/services/subscribed-decision.ts
-var replyDecisionSchema = z6.object({
-  should_reply: z6.boolean().describe("Whether Junior should respond to this thread message."),
-  should_unsubscribe: z6.boolean().describe(
+var replyDecisionSchema = z5.object({
+  should_reply: z5.boolean().describe("Whether Junior should respond to this thread message."),
+  should_unsubscribe: z5.boolean().describe(
     "Whether Junior should unsubscribe from this thread because the user clearly asked it to stop participating."
   ),
-  confidence: z6.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
-  reason: z6.string().describe("Short reason for the decision; use an empty string if none.")
+  confidence: z5.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
+  reason: z5.string().describe("Short reason for the decision; use an empty string if none.")
 }).strict();
 var ROUTER_CONFIDENCE_THRESHOLD = 0.7;
 var ROUTER_CLASSIFIER_MAX_TOKENS = 400;
@@ -5457,10 +4670,6 @@ function buildLogContext(deps, args) {
 function actorUserName(message) {
   return getMessageActorIdentity(message)?.userName;
 }
-function isResourceEventNotificationMessage2(message) {
-  const raw = message.raw && typeof message.raw === "object" ? message.raw : void 0;
-  return raw?.event_type === "resource_event";
-}
 function createSlackTurnRuntime(deps) {
   const logContext = (args) => buildLogContext(deps, args);
   const maybeHandleThreadOptOutDecision = async (args) => {
@@ -5881,7 +5090,7 @@ function createSlackTurnRuntime(deps) {
         const threadId = deps.getThreadId(thread, message);
         const channelId = deps.getChannelId(thread, message);
         const runId = deps.getRunId(thread, message);
-        const isResourceEventNotification = isResourceEventNotificationMessage2(message);
+        const isResourceEventNotification = isResourceEventSlackMessage(message);
         const actorId = isResourceEventNotification ? void 0 : message.author.userId;
         const turnContext = logContext({
           threadId,
@@ -6649,14 +5858,16 @@ function createJuniorRuntimeServices(overrides = {}) {
     listThreadReplies: overrides.visionContext?.listThreadReplies ?? listThreadReplies,
     downloadFile: overrides.visionContext?.downloadFile ?? downloadPrivateSlackFile
   });
+  const agentRunner = overrides.replyExecutor?.agentRunner ?? createAgentRunner(executeAgentRun, {
+    bindSpawnAgent: (request) => bindSpawnAgent(request, { queue: getVercelConversationWorkQueue }),
+    tracePropagation: overrides.sandbox?.tracePropagation
+  });
   return {
     conversationMemory,
     contextCompactor,
     replyExecutor: {
       contextCompactor: overrides.replyExecutor?.contextCompactor ?? contextCompactor,
-      agentRunner: overrides.replyExecutor?.agentRunner ?? createAgentRunner(executeAgentRun, {
-        tracePropagation: overrides.sandbox?.tracePropagation
-      }),
+      agentRunner,
       getAwaitingAgentContinueRequest: overrides.replyExecutor?.getAwaitingAgentContinueRequest ?? getAwaitingAgentContinueRequest,
       lookupSlackUser: overrides.replyExecutor?.lookupSlackUser ?? lookupSlackUser,
       scheduleAgentContinue: overrides.replyExecutor?.scheduleAgentContinue ?? scheduleAgentContinue,
@@ -6677,11 +5888,11 @@ function createJuniorRuntimeServices(overrides = {}) {
 import { createSlackSource as createSlackSource2 } from "@sentry/junior-plugin-api";
 
 // src/chat/slack/action-token.ts
-import { z as z7 } from "zod";
-var slackActionTokenSchema = z7.string().trim().min(1).brand();
-var slackMessageEnvelopeSchema = z7.object({
-  raw: z7.object({
-    action_token: z7.unknown().optional()
+import { z as z6 } from "zod";
+var slackActionTokenSchema = z6.string().trim().min(1).brand();
+var slackMessageEnvelopeSchema = z6.object({
+  raw: z6.object({
+    action_token: z6.unknown().optional()
   }).optional()
 });
 function readSlackActionToken(message) {
@@ -6845,7 +6056,7 @@ function queuedInstructionActor(queued) {
   };
 }
 function queuedInstructionProvenance(queued, teamId) {
-  if (isResourceEventMessage(queued.message)) {
+  if (isResourceEventSlackMessage(queued.message)) {
     return contextProvenance;
   }
   const identity = getMessageActorIdentity(queued.message);
@@ -6859,13 +6070,6 @@ function queuedInstructionProvenance(queued, teamId) {
   );
   return instructionProvenanceFor(author);
 }
-function isResourceEventMessage(message) {
-  const raw = message.raw && typeof message.raw === "object" ? message.raw : void 0;
-  return raw?.event_type === "resource_event";
-}
-function resourceEventCredentialContext(message) {
-  return isResourceEventMessage(message) ? { actor: { platform: "system", name: "resource-event" } } : void 0;
-}
 async function resolveChannelName(thread) {
   const existingName = thread.channel.name?.trim();
   if (existingName) {
@@ -6994,7 +6198,7 @@ function createReplyToThread(deps) {
           )
         };
         await Promise.all(
-          (options.queuedMessages ?? []).filter((queued) => !isResourceEventMessage(queued.message)).map(
+          (options.queuedMessages ?? []).filter((queued) => !isResourceEventSlackMessage(queued.message)).map(
             (queued) => ensureSlackMessageActorIdentity(
               queued.message,
               teamId,
@@ -7003,15 +6207,28 @@ function createReplyToThread(deps) {
           )
         );
         const effectiveUserText = currentText.userText;
-        const credentialContext = options.execution?.credentialContext ?? resourceEventCredentialContext(message) ?? {
-          actor: { type: "user", userId: message.author.userId }
-        };
-        const actor = "type" in credentialContext.actor ? await ensureSlackMessageActorIdentity(
-          message,
-          teamId,
-          deps.services.lookupSlackUser
-        ) : void 0;
-        const executionActor = "type" in credentialContext.actor ? actor : credentialContext.actor;
+        let executionActor;
+        let credentialContext;
+        if (options.execution) {
+          executionActor = options.execution.dispatch.actor;
+          credentialContext = options.execution.credentialContext;
+        } else if (isResourceEventSlackMessage(message)) {
+          executionActor = RESOURCE_EVENT_SYSTEM_ACTOR;
+          credentialContext = credentialContextForActor(executionActor);
+        } else {
+          executionActor = await ensureSlackMessageActorIdentity(
+            message,
+            teamId,
+            deps.services.lookupSlackUser
+          );
+          if (executionActor) {
+            credentialContext = credentialContextForActor(executionActor);
+          }
+        }
+        if (!executionActor || !credentialContext) {
+          throw new Error("Slack reply execution requires an actor");
+        }
+        const actor = "userId" in executionActor ? executionActor : void 0;
         const slackActorId = actor?.userId;
         const preparedState = options.preparedState ?? await deps.prepareTurnState({
           thread,
@@ -7085,7 +6302,7 @@ function createReplyToThread(deps) {
                   attachments,
                   {
                     threadId,
-                    actorId: isResourceEventMessage(queued.message) ? void 0 : queued.message.author.userId,
+                    actorId: isResourceEventSlackMessage(queued.message) ? void 0 : queued.message.author.userId,
                     channelId,
                     runId,
                     conversation: preparedState.conversation,
@@ -7660,7 +6877,9 @@ function createReplyToThread(deps) {
             },
             routing: {
               credentialContext,
-              actor: options.execution ? executionActor : actor,
+              // Always set the execution actor when known. Resource-event turns
+              // carry the system principal; interactive turns carry the Slack user.
+              actor: executionActor,
               slackConversation,
               source,
               destination,
@@ -7673,7 +6892,7 @@ function createReplyToThread(deps) {
             policy: {
               configuration: preparedState.configuration,
               channelConfiguration: preparedState.channelConfiguration,
-              authorizationFlowMode: options.execution?.authorizationFlowMode ?? (message.author.isBot === true ? "disabled" : void 0),
+              disabledFeatures: options.execution?.disabledFeatures ?? (message.author.isBot === true ? ["interactive-auth"] : void 0),
               turnDeadlineAtMs: getTurnRequestDeadline()?.deadlineAtMs
             },
             state: {
@@ -8387,7 +7606,7 @@ function createSlackDispatchTurnRunner(options) {
       conversationId,
       destination: dispatch2.destination,
       execution: {
-        authorizationFlowMode: "disabled",
+        disabledFeatures: ["interactive-auth"],
         channelConfiguration: options.getChannelConfiguration(
           dispatch2.destination.channelId
         ),
@@ -8688,27 +7907,57 @@ async function failContinuationStartup(args) {
     );
   }
 }
-async function resolveContinuationActor(args) {
-  const stored = args.sessionRecordActor;
-  if (stored?.platform === "slack" && stored.teamId === args.teamId && stored.userId === args.userId) {
+async function resolveSlackResumeUserActor(args) {
+  try {
+    const work = await getConversationWorkState({
+      conversationId: args.conversationId
+    });
+    const workActor = work?.actor;
+    if (workActor?.teamId === args.teamId && workActor.slackUserId === args.userId) {
+      try {
+        return createSlackActor(args.teamId, args.userId, {
+          email: workActor.email,
+          fullName: workActor.fullName,
+          userName: workActor.slackUserName
+        });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  try {
     return createSlackResumeActor({
-      actor: stored,
       teamId: args.teamId,
       userId: args.userId
     });
+  } catch {
+    return void 0;
   }
-  const work = await getConversationWorkState({
-    conversationId: args.conversationId
-  });
-  const workActor = work?.actor;
-  if (workActor && workActor.teamId === args.teamId && workActor.slackUserId === args.userId) {
-    return createSlackActor(args.teamId, args.userId, {
-      email: workActor.email,
-      fullName: workActor.fullName,
-      userName: workActor.slackUserName
+}
+async function resolveResumeExecutionIdentity(args) {
+  const routing = args.routingContext;
+  if (routing?.credentialContext) {
+    const actor2 = routing.dispatch?.actor ?? routing.actor ?? (!("type" in routing.credentialContext.actor) ? routing.credentialContext.actor : void 0);
+    return actor2 ? { actor: actor2, credentialContext: routing.credentialContext } : void 0;
+  }
+  let actor = routing?.actor;
+  if (!actor && isResourceEventConversationMessage(args.userMessage)) {
+    actor = RESOURCE_EVENT_SYSTEM_ACTOR;
+  }
+  if (!actor && args.userMessage.author?.userId) {
+    actor = await resolveSlackResumeUserActor({
+      conversationId: args.conversationId,
+      teamId: args.teamId,
+      userId: args.userMessage.author.userId
     });
   }
-  return void 0;
+  if (!actor) {
+    return void 0;
+  }
+  return {
+    actor,
+    credentialContext: credentialContextForActor(actor)
+  };
 }
 function isContinuationResume(summary) {
   return summary.state === "awaiting_resume" && (summary.resumeReason === "timeout" || summary.resumeReason === "yield" || summary.resumeReason === "retry");
@@ -8726,7 +7975,6 @@ async function failUnresumableContinuation(args) {
         conversationId: args.conversationId
       });
       await recordAgentTurnSessionSummary({
-        actor: args.summary.actor,
         conversationId: args.conversationId,
         destination: routing.destination,
         dispatchId: args.summary.dispatchId,
@@ -8793,16 +8041,32 @@ async function continueSlackAgentRunInContext(payload, options, runOptions) {
           (message) => message.role === "user" && options.inputMessageIds?.includes(message.id)
         ) : void 0;
         const userMessage = getTurnUserMessage(conversation, payload.sessionId) ?? dispatchUserMessage;
-        const systemActor = activeSessionRecord.actor?.platform === "system" ? activeSessionRecord.actor : void 0;
-        const userActorId = userMessage?.author?.userId;
-        if (!userMessage || !systemActor && !userActorId) {
-          throw new Error(
-            `Unable to locate the persisted user message for agent continuation session "${payload.sessionId}"`
-          );
+        if (!userMessage) {
+          await failStrandedSessionWithFallback({
+            conversationId: payload.conversationId,
+            errorMessage: `Unable to locate the persisted user message for agent continuation session "${payload.sessionId}"`,
+            sessionRecord: activeSessionRecord
+          });
+          return false;
         }
         if (conversation.processing.activeTurnId !== payload.sessionId) {
           return false;
         }
+        const identity = await resolveResumeExecutionIdentity({
+          conversationId: payload.conversationId,
+          routingContext: options.routingContext,
+          teamId: destination.teamId,
+          userMessage
+        });
+        if (!identity) {
+          await failStrandedSessionWithFallback({
+            conversationId: payload.conversationId,
+            errorMessage: "Unable to rebuild Slack actor for continuation",
+            sessionRecord: activeSessionRecord
+          });
+          return false;
+        }
+        const { actor, credentialContext } = identity;
         const channelConfiguration = getChannelConfigurationServiceById(
           destination.channelId
         );
@@ -8810,34 +8074,6 @@ async function continueSlackAgentRunInContext(payload, options, runOptions) {
           excludeMessageId: userMessage.id
         });
         const sandboxRef = getPersistedSandboxState(currentState);
-        let actor;
-        let credentialContext;
-        if (options.routingContext?.credentialContext) {
-          credentialContext = options.routingContext.credentialContext;
-        } else if (systemActor) {
-          credentialContext = { actor: systemActor };
-        } else {
-          actor = await resolveContinuationActor({
-            conversationId: payload.conversationId,
-            sessionRecordActor: activeSessionRecord.actor,
-            teamId: destination.teamId,
-            userId: userActorId
-          });
-          if (!actor) {
-            await failStrandedSessionWithFallback({
-              conversationId: payload.conversationId,
-              errorMessage: "Stored Slack actor missing for continuation",
-              sessionRecord: activeSessionRecord
-            });
-            return false;
-          }
-          credentialContext = {
-            actor: {
-              type: "user",
-              userId: actor.userId
-            }
-          };
-        }
         const routing = await resolveTurnSessionRouting({
           conversationId: payload.conversationId
         });
@@ -8885,7 +8121,7 @@ async function continueSlackAgentRunInContext(payload, options, runOptions) {
             routing: {
               ...options.routingContext,
               credentialContext,
-              ...options.routingContext?.actor ?? actor ? { actor: options.routingContext?.actor ?? actor } : {},
+              actor,
               destination: routingDestination,
               source,
               toolChannelId: artifacts.assistantContextChannelId ?? destination.channelId
@@ -9006,7 +8242,6 @@ async function failStrandedSessionWithFallback(args) {
   }
   if (args.sessionRecord.dispatchId) {
     await recordAgentTurnSessionSummary({
-      actor: args.sessionRecord.actor,
       conversationId: args.conversationId,
       destination: routing.destination,
       dispatchId: args.sessionRecord.dispatchId,
@@ -9071,7 +8306,6 @@ async function recoverStrandedRunningSession(args) {
     messages: sessionRecord.piMessages,
     errorMessage: "Recovered running session after hard worker death",
     modelId,
-    actor: sessionRecord.actor,
     surface: sessionRecord.surface
   });
   if (!parked) {
@@ -9279,12 +8513,18 @@ function createProductionConversationWorkOptions(options) {
     },
     runTurn: runtime.runDispatchTurn
   });
+  const providerWorker = createAgentDispatchWorkRouter({
+    dispatchWorker,
+    fallbackWorker: slackWorker
+  });
   return {
     conversationStore,
     queue,
-    run: createAgentDispatchWorkRouter({
-      dispatchWorker,
-      fallbackWorker: slackWorker
+    run: routeAgentInvocationWork({
+      invocationWorker: createAgentInvocationWorker({
+        agentRunner
+      }),
+      fallbackWorker: providerWorker
     })
   };
 }
@@ -9395,7 +8635,7 @@ async function ingestResourceEvent(input, options) {
 }
 
 // src/chat/event-tasks/ingest.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash } from "crypto";
 import {
   createSlackSource as createSlackSource3,
   RESOURCE_EVENT_SUMMARY_MAX_LENGTH,
@@ -9403,7 +8643,7 @@ import {
   resourceEventSchema as resourceEventSchema2
 } from "@sentry/junior-plugin-api";
 function eventTaskDispatchKey(taskId, namespace, eventKey) {
-  return `event-task:${createHash2("sha256").update(`${taskId}\0${namespace}\0${eventKey}`).digest("hex").slice(0, 32)}`;
+  return `event-task:${createHash("sha256").update(`${taskId}\0${namespace}\0${eventKey}`).digest("hex").slice(0, 32)}`;
 }
 function oneLine(value) {
   return value.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 512);
@@ -9815,6 +9055,7 @@ async function createApp(options) {
   const previousConfigDefaults = getConfigDefaults();
   const previousSlackReactionConfig = getSlackReactionConfig();
   const previousSandboxResources = getSandboxResourceConfig();
+  const previousExperimentalFeatures = getExperimentalFeatures();
   const previousDashboardLinkOptions = setDashboardConversationLinkOptions(dashboard);
   let pluginRoutes = [];
   let pluginApiRoutes = [];
@@ -9850,6 +9091,7 @@ async function createApp(options) {
       options?.sandbox?.egressTracePropagationDomains
     );
     setSandboxResourceConfig(options?.sandbox);
+    setExperimentalFeatures(options?.experimental);
     setConfigDefaults(options?.configDefaults);
     warnUnregisteredConfigDefaults(options?.configDefaults);
     if (options?.slack) {
@@ -9873,12 +9115,15 @@ async function createApp(options) {
     setConfigDefaults(previousConfigDefaults);
     setSlackReactionConfig(previousSlackReactionConfig);
     setSandboxResourceConfig(previousSandboxResources);
+    setExperimentalFeatures(previousExperimentalFeatures);
     setDashboardConversationLinkOptions(previousDashboardLinkOptions);
     throw error;
   }
   const waitUntil = options?.waitUntil ?? await defaultWaitUntil();
   const tracePropagation = { domains: sandboxEgressTracePropagationDomains };
+  const conversationWorkQueue = getVercelConversationWorkQueue();
   const agentRunner = createAgentRunner(executeAgentRun, {
+    bindSpawnAgent: (request) => bindSpawnAgent(request, { queue: conversationWorkQueue }),
     tracePropagation
   });
   const runtimeServiceOverrides = {