@sentry/junior 0.110.0 → 0.112.0

package/dist/app.js

@@ -6,14 +6,14 @@ import {
   processPluginTask,
   requireTurnFailureEventId,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-3UBQI73J.js";
+} from "./chunk-AWNDKI5K.js";
 import {
   GET,
   buildSentryConversationUrl,
   conversationVisibilityFromSlackChannelType,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext
-} from "./chunk-3S7YYHBI.js";
+} from "./chunk-2FJ6WEYV.js";
 import "./chunk-2ZTTXTSZ.js";
 import {
   ConversationQueueMessageRejectedError,
@@ -31,7 +31,7 @@ import {
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-Y5FK3CNG.js";
+} from "./chunk-4EJO4HIC.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -84,7 +84,7 @@ import {
   splitSlackReplyText,
   startOAuthFlow,
   truncateStatusText
-} from "./chunk-RHHRKSPI.js";
+} from "./chunk-GR4IB6OQ.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
@@ -143,8 +143,8 @@ import {
   turnHasReply,
   updateConversationStats,
   upsertConversationMessage
-} from "./chunk-C5XAFTHY.js";
-import "./chunk-W6RJZG7F.js";
+} from "./chunk-SKEMI4IF.js";
+import "./chunk-66IP6WED.js";
 import "./chunk-MU6HHZEN.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
@@ -163,12 +163,12 @@ import {
   validatePlugins,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-2T7TIEXI.js";
+} from "./chunk-VBSVNOLA.js";
 import {
   acquireActiveLock,
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-GK47NBDE.js";
+} from "./chunk-X3SP5RDW.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -179,7 +179,7 @@ import {
   normalizeSlackConversationId,
   runWithSlackInstallationToken,
   runWithWorkspaceTeamId
-} from "./chunk-L5XQPJ7T.js";
+} from "./chunk-NDQL4ESR.js";
 import {
   contextProvenance,
   createSlackDestination,
@@ -193,7 +193,7 @@ import {
   requireSlackDestination,
   sameDestination,
   withConversationEventLock
-} from "./chunk-4QU44P7Q.js";
+} from "./chunk-QIALGHRN.js";
 import {
   juniorConversationEvents,
   juniorConversations
@@ -206,6 +206,7 @@ import {
   botConfig,
   completeObject,
   completeText,
+  configureFunctionMaxDurationSeconds,
   escapeXml,
   getChatConfig,
   getRuntimeMetadata,
@@ -221,7 +222,7 @@ import {
   standardModelId,
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages
-} from "./chunk-WNOVRQ67.js";
+} from "./chunk-PK4ETCUQ.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
@@ -233,16 +234,16 @@ import {
 } from "./chunk-6Y5L4BOM.js";
 import {
   discoverSkills
-} from "./chunk-SBOBTS27.js";
+} from "./chunk-GJG67YFS.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-3TV7OEHL.js";
+} from "./chunk-ZHP4KNF7.js";
 import {
   buildOAuthTokenRequest,
   credentialSubjectSchema,
   hasRequiredOAuthScope,
   parseOAuthTokenResponse
-} from "./chunk-Y3H2DN6F.js";
+} from "./chunk-TZU3R5OC.js";
 import {
   createActor,
   createSlackActor,
@@ -267,7 +268,7 @@ import {
   setTags,
   withContext,
   withSpan
-} from "./chunk-IYKPU7H6.js";
+} from "./chunk-CSS7JHEM.js";
 import {
   isRecord,
   parseSlackChannelId,
@@ -284,10 +285,10 @@ import {
 } from "./chunk-3V7OFJZC.js";
 import {
   JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE
-} from "./chunk-W75ZPAGG.js";
+} from "./chunk-AU2JVUDF.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-ZKIOWEFL.js";
+} from "./chunk-IV2O4HQJ.js";
 import "./chunk-MLKGABMK.js";
 
 // src/app.ts
@@ -823,8 +824,7 @@ async function persistRuntimePatch(args) {
   await persistThreadStateById(args.threadId, {
     artifacts: args.artifacts,
     conversation: args.conversation,
-    sandboxId: args.sandboxId,
-    sandboxDependencyProfileHash: args.sandboxDependencyProfileHash
+    sandboxRef: args.sandboxRef
   });
 }
 async function markDispatch(args) {
@@ -946,8 +946,7 @@ async function runAgentDispatchSlice(callback, deps) {
       return;
     }
     let artifacts = coerceThreadArtifactsState(persisted);
-    let sandboxId = typeof persisted.app_sandbox_id === "string" ? persisted.app_sandbox_id : void 0;
-    let sandboxDependencyProfileHash = typeof persisted.app_sandbox_dependency_profile_hash === "string" ? persisted.app_sandbox_dependency_profile_hash : void 0;
+    let sandboxRef = getPersistedSandboxState(persisted);
     const channelConfiguration = getChannelConfigurationServiceById(
       dispatch.destination.channelId
     );
@@ -1052,24 +1051,19 @@ async function runAgentDispatchSlice(callback, deps) {
       },
       state: {
         artifactState: artifacts,
-        sandbox: {
-          sandboxId,
-          sandboxDependencyProfileHash
-        }
+        sandboxRef
       },
       delivery: {
         onAssistantMessage: deliverAssistantMessage
       },
       durability: {
-        onSandboxAcquired: async (sandbox) => {
-          sandboxId = sandbox.sandboxId;
-          sandboxDependencyProfileHash = sandbox.sandboxDependencyProfileHash;
+        onSandboxRefChanged: async (nextSandboxRef) => {
+          sandboxRef = nextSandboxRef;
           await persistRuntimePatch({
             threadId: conversationId,
             conversation,
             artifacts,
-            sandboxId,
-            sandboxDependencyProfileHash
+            sandboxRef
           });
         },
         onArtifactStateUpdated: async (nextArtifacts2) => {
@@ -1078,8 +1072,7 @@ async function runAgentDispatchSlice(callback, deps) {
             threadId: conversationId,
             conversation,
             artifacts,
-            sandboxId,
-            sandboxDependencyProfileHash
+            sandboxRef
           });
         }
       }
@@ -1141,8 +1134,7 @@ async function runAgentDispatchSlice(callback, deps) {
           threadId: conversationId,
           conversation,
           artifacts: nextArtifacts,
-          sandboxId: reply.sandboxId ?? sandboxId,
-          sandboxDependencyProfileHash: reply.sandboxDependencyProfileHash ?? sandboxDependencyProfileHash
+          sandboxRef: reply.sandboxRef ?? sandboxRef
         });
       });
       statePersisted = true;
@@ -1313,8 +1305,10 @@ import { timingSafeEqual as timingSafeEqual2 } from "crypto";
 
 // src/chat/task-execution/state.ts
 import { randomUUID } from "crypto";
+import { destinationSchema as destinationSchema2 } from "@sentry/junior-plugin-api";
+import { z as z2 } from "zod";
 var CONVERSATION_PREFIX = "junior:conversation";
-var CONVERSATION_SCHEMA_VERSION = 1;
+var CONVERSATION_SCHEMA_VERSION = 2;
 var CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH = 1e4;
 var CONVERSATION_INDEX_LOCK_TTL_MS = 1e4;
 var CONVERSATION_INDEX_LOCK_WAIT_MS = 2e3;
@@ -1345,6 +1339,36 @@ var CONVERSATION_WORK_LEASE_TTL_MS = 9e4;
 var CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15e3;
 var CONVERSATION_WORK_STALE_ENQUEUE_MS = 6e4;
 var CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS = 5;
+var inboundMessageSourceSchema = z2.enum([
+  "api",
+  "internal",
+  "local",
+  "plugin",
+  "resource_event",
+  "scheduler",
+  "slack"
+]);
+var agentInputSchema = z2.object({
+  attachments: z2.array(z2.unknown()).optional(),
+  authorId: z2.string().min(1).optional(),
+  metadata: z2.record(z2.string(), z2.unknown()).optional(),
+  text: z2.string()
+}).strict().refine((input) => input.text.trim() || input.attachments?.length, {
+  message: "agent input requires text or attachments"
+});
+var inboundMessageDeliverySchema = z2.enum(["defer", "interrupt"]);
+var inboundMessageSchema = z2.object({
+  attemptCount: z2.number().finite().optional(),
+  conversationId: z2.string().refine((value) => value.trim().length > 0),
+  createdAtMs: z2.number().finite(),
+  delivery: inboundMessageDeliverySchema,
+  destination: destinationSchema2,
+  inboundMessageId: z2.string().refine((value) => value.trim().length > 0),
+  injectedAtMs: z2.number().finite().optional(),
+  input: agentInputSchema,
+  receivedAtMs: z2.number().finite(),
+  source: inboundMessageSourceSchema
+}).strict();
 function conversationKey(conversationId) {
   return `${CONVERSATION_PREFIX}:${conversationId}`;
 }
@@ -1364,10 +1388,16 @@ function inputHasAttachments(input) {
   return Array.isArray(input.attachments) && input.attachments.length > 0;
 }
 function upgradedPendingMessage(stored, duplicate) {
-  if (!inputHasAttachments(duplicate.input) || inputHasAttachments(stored.input)) {
+  const promotesInterrupt = stored.delivery === "defer" && duplicate.delivery === "interrupt";
+  const delivery = promotesInterrupt ? "interrupt" : stored.delivery;
+  const input = promotesInterrupt ? {
+    ...duplicate.input,
+    ...inputHasAttachments(duplicate.input) || !inputHasAttachments(stored.input) ? {} : { attachments: stored.input.attachments }
+  } : inputHasAttachments(duplicate.input) && !inputHasAttachments(stored.input) ? duplicate.input : stored.input;
+  if (input === stored.input && delivery === stored.delivery) {
     return stored;
   }
-  return { ...stored, input: duplicate.input };
+  return { ...stored, delivery, input };
 }
 function compareIndexDescending(left, right) {
   return right.score - left.score || right.conversationId.localeCompare(left.conversationId);
@@ -1379,10 +1409,8 @@ function uniqueStrings(values) {
   return [...new Set(values)];
 }
 function normalizeSource(value) {
-  if (value === "api" || value === "internal" || value === "local" || value === "plugin" || value === "resource_event" || value === "scheduler" || value === "slack") {
-    return value;
-  }
-  return void 0;
+  const parsed = inboundMessageSourceSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
 }
 function normalizeExecutionStatus(value) {
   if (value === "awaiting_resume" || value === "failed" || value === "idle" || value === "pending" || value === "running") {
@@ -1390,53 +1418,13 @@ function normalizeExecutionStatus(value) {
   }
   return void 0;
 }
-function normalizeMetadata2(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  return value;
-}
-function normalizeInput(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const text = typeof value.text === "string" ? value.text : void 0;
-  const attachments = Array.isArray(value.attachments) ? [...value.attachments] : void 0;
-  if (text === void 0 || !text.trim() && !attachments?.length) {
-    return void 0;
-  }
-  return {
-    text,
-    authorId: toOptionalString(value.authorId),
-    attachments,
-    metadata: normalizeMetadata2(value.metadata)
-  };
-}
-function normalizeMessage(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const conversationId = toOptionalString(value.conversationId);
-  const inboundMessageId = toOptionalString(value.inboundMessageId);
-  const source = normalizeSource(value.source);
-  const destination = parseDestination(value.destination);
-  const createdAtMs = toOptionalNumber(value.createdAtMs);
-  const receivedAtMs = toOptionalNumber(value.receivedAtMs);
-  const input = normalizeInput(value.input);
-  if (!conversationId || !destination || !inboundMessageId || !source || typeof createdAtMs !== "number" || typeof receivedAtMs !== "number" || !input) {
-    return void 0;
-  }
-  return {
-    conversationId,
-    destination,
-    inboundMessageId,
-    source,
-    createdAtMs,
-    receivedAtMs,
-    input,
-    injectedAtMs: toOptionalNumber(value.injectedAtMs),
-    attemptCount: toOptionalNumber(value.attemptCount)
-  };
+function normalizeMessage(value, schemaVersion) {
+  const candidate = schemaVersion === 1 && isRecord(value) && value.delivery === void 0 ? {
+    ...value,
+    delivery: "defer"
+  } : value;
+  const parsed = inboundMessageSchema.safeParse(candidate);
+  return parsed.success ? parsed.data : void 0;
 }
 function isFinalAttempt(message) {
   return (message.attemptCount ?? 0) >= CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS - 1;
@@ -1462,7 +1450,7 @@ function normalizeLease(value) {
     expiresAtMs
   };
 }
-function normalizeExecution(conversationId, value) {
+function normalizeExecution(conversationId, value, schemaVersion) {
   if (!isRecord(value)) {
     return void 0;
   }
@@ -1470,7 +1458,20 @@ function normalizeExecution(conversationId, value) {
   if (!status) {
     return void 0;
   }
-  const pendingMessages2 = Array.isArray(value.pendingMessages) ? value.pendingMessages.map(normalizeMessage).filter((message) => Boolean(message)).filter((message) => message.conversationId === conversationId).filter((message) => message.injectedAtMs === void 0).sort(compareMessages) : [];
+  const pendingMessages2 = [];
+  if (Array.isArray(value.pendingMessages)) {
+    for (const rawMessage of value.pendingMessages) {
+      const message = normalizeMessage(rawMessage, schemaVersion);
+      if (!message || message.conversationId !== conversationId) {
+        return void 0;
+      }
+      if (message.injectedAtMs !== void 0) {
+        continue;
+      }
+      pendingMessages2.push(message);
+    }
+    pendingMessages2.sort(compareMessages);
+  }
   const inboundMessageIds = Array.isArray(value.inboundMessageIds) ? uniqueStrings(
     value.inboundMessageIds.map((id) => typeof id === "string" ? id : void 0).filter((id) => Boolean(id))
   ) : [];
@@ -1492,14 +1493,19 @@ function normalizeExecution(conversationId, value) {
   };
 }
 function normalizeConversation(conversationId, value) {
-  if (!isRecord(value) || value.schemaVersion !== CONVERSATION_SCHEMA_VERSION) {
+  if (!isRecord(value) || value.schemaVersion !== 1 && value.schemaVersion !== CONVERSATION_SCHEMA_VERSION) {
     return void 0;
   }
+  const schemaVersion = value.schemaVersion;
   const storedConversationId = toOptionalString(value.conversationId);
   const createdAtMs = toOptionalNumber(value.createdAtMs);
   const lastActivityAtMs = toOptionalNumber(value.lastActivityAtMs);
   const updatedAtMs = toOptionalNumber(value.updatedAtMs);
-  const execution = normalizeExecution(conversationId, value.execution);
+  const execution = normalizeExecution(
+    conversationId,
+    value.execution,
+    schemaVersion
+  );
   const destination = value.destination === void 0 ? void 0 : parseDestination(value.destination);
   if (storedConversationId !== conversationId || typeof createdAtMs !== "number" || typeof lastActivityAtMs !== "number" || typeof updatedAtMs !== "number" || !execution || value.destination !== void 0 && !destination) {
     return void 0;
@@ -2107,7 +2113,7 @@ async function startConversationWork(args) {
         {
           ...current.execution,
           lease,
-          status: "running",
+          status: current.execution.status === "awaiting_resume" ? "awaiting_resume" : "running",
           runId: current.execution.runId ?? randomUUID(),
           lastEnqueuedAtMs: void 0
         },
@@ -2159,22 +2165,25 @@ async function drainConversationMailbox(args) {
     return pendingMessages(current);
   });
   if (pending.length === 0) {
-    return [];
+    return { changed: false, messages: [] };
   }
-  const acknowledgedIds = await args.handle(pending);
+  const result = await args.handle(pending);
   const pendingIds = new Set(
     pending.map((message) => message.inboundMessageId)
   );
-  for (const inboundMessageId of acknowledgedIds ?? []) {
+  const acknowledgedIds = new Set(
+    result ?? pending.map((message) => message.inboundMessageId)
+  );
+  for (const inboundMessageId of acknowledgedIds) {
     if (!pendingIds.has(inboundMessageId)) {
       throw new Error(
-        `Conversation mailbox acknowledgement is not pending for ${args.conversationId}`
+        `Conversation mailbox drain result is not pending for ${args.conversationId}`
       );
     }
   }
-  const drainedIds = new Set(
-    acknowledgedIds ?? pending.map((message) => message.inboundMessageId)
-  );
+  if (acknowledgedIds.size === 0) {
+    return { changed: false, messages: [] };
+  }
   await withConversationMutation(args, async (state, lock) => {
     const current = await readConversation(state, args.conversationId);
     if (!current || current.execution.lease?.token !== args.leaseToken) {
@@ -2183,7 +2192,7 @@ async function drainConversationMailbox(args) {
       );
     }
     const pendingMessages2 = current.execution.pendingMessages.filter(
-      (message) => !drainedIds.has(message.inboundMessageId)
+      (message) => !acknowledgedIds.has(message.inboundMessageId)
     );
     await writeConversation(
       state,
@@ -2199,7 +2208,12 @@ async function drainConversationMailbox(args) {
       )
     );
   });
-  return pending.filter((message) => drainedIds.has(message.inboundMessageId));
+  return {
+    changed: true,
+    messages: pending.filter(
+      (message) => acknowledgedIds.has(message.inboundMessageId)
+    )
+  };
 }
 async function ackMessages(args) {
   const nowMs = args.nowMs ?? now();
@@ -2260,6 +2274,28 @@ async function requestConversationContinuation(args) {
     return true;
   });
 }
+async function beginConversationResume(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken || current.execution.status !== "awaiting_resume") {
+      return false;
+    }
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          status: "running"
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
 async function releaseConversationWork(args) {
   const nowMs = args.nowMs ?? now();
   return await withConversationMutation(args, async (state, lock) => {
@@ -2301,7 +2337,7 @@ async function completeConversationWork(args) {
         {
           ...current.execution,
           lease: void 0,
-          status: runnable ? "pending" : "idle",
+          status: needsRun ? "awaiting_resume" : hasPending ? "pending" : "idle",
           runId: runnable ? current.execution.runId : void 0
         },
         nowMs
@@ -2410,7 +2446,7 @@ async function clearExpiredConversationLease(args) {
         {
           ...current.execution,
           lease: void 0,
-          status: "pending"
+          status: "awaiting_resume"
         },
         nowMs
       )
@@ -2501,6 +2537,9 @@ async function ensureConversationWake(args) {
   if (!conversation.destination) {
     return { status: "no_work" };
   }
+  if (args.replaceExistingWake !== true && conversation.execution.lease && conversation.execution.lease.expiresAtMs > nowMs) {
+    return { status: "lease_active" };
+  }
   if (args.replaceExistingWake !== true && hasRecentEnqueueMarker(conversation, nowMs)) {
     return { status: "already_enqueued" };
   }
@@ -2612,10 +2651,10 @@ async function checkInConversationWork2(args) {
 }
 async function drainConversationMailbox2(args) {
   const result = await drainConversationMailbox(args);
-  if (result.length > 0) {
+  if (result.changed) {
     await recordExecutionMetadata(args);
   }
-  return result;
+  return result.messages;
 }
 async function ackMessages2(args) {
   const result = await ackMessages(args);
@@ -2627,6 +2666,13 @@ async function requestConversationContinuation2(args) {
   await recordExecutionMetadata(args);
   return result;
 }
+async function beginConversationResume2(args) {
+  const result = await beginConversationResume(args);
+  if (result) {
+    await recordExecutionMetadata(args);
+  }
+  return result;
+}
 async function releaseConversationWork2(args) {
   const result = await releaseConversationWork(args);
   await recordExecutionMetadata(args);
@@ -4065,9 +4111,26 @@ async function startSlackProcessingReactionForMessage(args) {
 }
 
 // src/chat/services/auth-pause-response.ts
-function buildAuthPauseResponse(slackUserId, providerDisplayName) {
+var MAX_AUTH_REQUEST_LENGTH = 200;
+function formatAuthRequest(requestText) {
+  const normalized = requestText.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return void 0;
+  }
+  const bounded = normalized.length > MAX_AUTH_REQUEST_LENGTH ? `${normalized.slice(0, MAX_AUTH_REQUEST_LENGTH - 1).trimEnd()}\u2026` : normalized;
+  return bounded.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function buildAuthPauseResponse(slackUserId, providerDisplayName, requestText) {
   const mention = slackUserId ? `<@${slackUserId}> ` : "";
-  return `${mention}I'll need you to authorize ${providerDisplayName}. I sent you a link.`;
+  const request = requestText ? formatAuthRequest(requestText) : void 0;
+  if (!request) {
+    return `${mention}I'll need you to authorize ${providerDisplayName}. I sent you a link.`;
+  }
+  return `${mention}I need access to ${providerDisplayName} to continue.
+
+*Why:* ${request}
+
+I sent you a link.`;
 }
 
 // src/chat/runtime/request-deadline.ts
@@ -4313,12 +4376,11 @@ function createResumeReplyContext(args, statusSession, delivery) {
     delivery,
     durability: {
       ...replyContext.durability,
-      onSandboxAcquired: async (sandbox) => {
+      onSandboxRefChanged: async (sandboxRef) => {
         await persistThreadStateById(threadId, {
-          sandboxId: sandbox.sandboxId,
-          sandboxDependencyProfileHash: sandbox.sandboxDependencyProfileHash
+          sandboxRef
         });
-        await replyContext.durability?.onSandboxAcquired?.(sandbox);
+        await replyContext.durability?.onSandboxRefChanged?.(sandboxRef);
       },
       onArtifactStateUpdated: async (artifacts) => {
         await persistThreadStateById(threadId, { artifacts });
@@ -4519,7 +4581,8 @@ async function resumeSlackTurn(args) {
       if (outcome.status === "awaiting_auth" && onAuthPause) {
         deferredAuthInfo = {
           providerDisplayName: outcome.providerDisplayName,
-          actorId: isUserActor(resumeActor) ? resumeActor.userId : void 0
+          actorId: isUserActor(resumeActor) ? resumeActor.userId : void 0,
+          ...outcome.requestText ? { requestText: outcome.requestText } : {}
         };
         deferredPauseHandler = async () => {
           await onAuthPause({
@@ -4673,7 +4736,8 @@ async function resumeSlackTurn(args) {
           runArgs.threadTs,
           buildAuthPauseResponse(
             deferredAuthInfo.actorId,
-            deferredAuthInfo.providerDisplayName
+            deferredAuthInfo.providerDisplayName,
+            deferredAuthInfo.requestText
           ),
           runArgs.conversationId
         );
@@ -5067,7 +5131,7 @@ async function resumeAuthorizedMcpTurn(args) {
           state: {
             artifactState: lockedArtifacts,
             pendingAuth: lockedPendingAuth,
-            sandbox: getPersistedSandboxState(lockedState)
+            sandboxRef: getPersistedSandboxState(lockedState)
           },
           durability: {
             recordPendingAuth: async (nextPendingAuth) => {
@@ -5665,7 +5729,7 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
           state: {
             artifactState: lockedArtifacts,
             pendingAuth: lockedPendingAuth,
-            sandbox: getPersistedSandboxState(lockedState)
+            sandboxRef: getPersistedSandboxState(lockedState)
           },
           durability: {
             recordPendingAuth: async (nextPendingAuth) => {
@@ -6302,7 +6366,7 @@ import {
   Message,
   ThreadImpl
 } from "chat";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/chat/ingress/message-router.ts
 function normalizeIncomingSlackThreadId(threadId, message) {
@@ -6473,14 +6537,14 @@ async function ensureSlackMessageActorIdentity(message, teamId, lookupSlackUser2
 }
 
 // src/chat/slack/user.ts
-import { z as z2 } from "zod";
-var slackUserInfoSchema = z2.object({
-  ok: z2.literal(true),
-  user: z2.object({
-    name: z2.string().nullish(),
-    profile: z2.object({
-      email: z2.string().nullish(),
-      real_name: z2.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()
   })
 });
@@ -6568,14 +6632,14 @@ async function lookupSlackUser(teamId, userId) {
 }
 
 // src/chat/task-execution/slack-work.ts
-var slackConversationRouteSchema = z3.enum(["mention", "subscribed"]);
-var serializedDateSchema = z3.iso.datetime();
-var mdastPointSchema = z3.object({
-  column: z3.number().int().positive(),
-  line: z3.number().int().positive(),
-  offset: z3.number().int().nonnegative().optional()
+var slackConversationRouteSchema = z4.enum(["mention", "subscribed"]);
+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 = z3.object({
+var mdastPositionSchema = z4.object({
   end: mdastPointSchema,
   start: mdastPointSchema
 }).strict();
@@ -6687,7 +6751,7 @@ function isFormattedContentNode(value) {
       return false;
   }
 }
-var formattedContentSchema = z3.custom(
+var formattedContentSchema = z4.custom(
   (value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
       return false;
@@ -6697,79 +6761,79 @@ var formattedContentSchema = z3.custom(
   },
   "must be a valid formatted-content root"
 );
-var serializedMessageSchema = z3.object({
-  _type: z3.literal("chat:Message"),
-  attachments: z3.array(
-    z3.object({
-      type: z3.enum(["image", "file", "video", "audio"]),
-      url: z3.string().optional(),
-      name: z3.string().optional(),
-      mimeType: z3.string().optional(),
-      size: z3.number().finite().optional(),
-      width: z3.number().finite().optional(),
-      height: z3.number().finite().optional(),
-      fetchMetadata: z3.record(z3.string(), z3.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: z3.object({
-    userId: z3.string(),
-    userName: z3.string(),
-    fullName: z3.string(),
-    isBot: z3.union([z3.boolean(), z3.literal("unknown")]),
-    isMe: z3.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: z3.string().min(1),
-  isMention: z3.boolean().optional(),
-  links: z3.array(
-    z3.object({
-      url: z3.string(),
-      title: z3.string().optional(),
-      description: z3.string().optional(),
-      imageUrl: z3.string().optional(),
-      siteName: z3.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: z3.object({
+  metadata: z4.object({
     dateSent: serializedDateSchema,
-    edited: z3.boolean(),
+    edited: z4.boolean(),
     editedAt: serializedDateSchema.optional()
   }).strict(),
-  raw: z3.unknown(),
-  text: z3.string(),
-  threadId: z3.string().min(1)
+  raw: z4.unknown(),
+  text: z4.string(),
+  threadId: z4.string().min(1)
 }).strict();
-var serializedThreadSchema = z3.object({
-  _type: z3.literal("chat:Thread"),
-  adapterName: z3.literal("slack"),
-  channelId: z3.string().min(1),
-  channelVisibility: z3.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: z3.string().min(1),
-  isDM: z3.boolean()
+  id: z4.string().min(1),
+  isDM: z4.boolean()
 }).strict();
-var slackInstallationSchema = z3.object({
-  enterpriseId: z3.string().optional(),
-  isEnterpriseInstall: z3.boolean().optional(),
-  teamId: z3.string().optional()
+var slackInstallationSchema = z4.object({
+  enterpriseId: z4.string().optional(),
+  isEnterpriseInstall: z4.boolean().optional(),
+  teamId: z4.string().optional()
 }).strict();
-var slackConversationMessageMetadataBaseSchema = z3.object({
+var slackConversationMessageMetadataBaseSchema = z4.object({
   installation: slackInstallationSchema.optional(),
   message: serializedMessageSchema,
-  platform: z3.literal("slack"),
+  platform: z4.literal("slack"),
   route: slackConversationRouteSchema,
   thread: serializedThreadSchema
 });
-var slackConversationMessageMetadataSchema = z3.union([
+var slackConversationMessageMetadataSchema = z4.union([
   slackConversationMessageMetadataBaseSchema.strict(),
   slackConversationMessageMetadataBaseSchema.extend({
-    kind: z3.literal("resource_event"),
-    resourceEvent: z3.object({
-      eventKey: z3.string(),
-      eventType: z3.string(),
-      provider: z3.string(),
-      resourceRef: z3.string(),
-      subscriptionId: z3.string()
+    kind: z4.literal("resource_event"),
+    resourceEvent: z4.object({
+      eventKey: z4.string(),
+      eventType: z4.string(),
+      provider: z4.string(),
+      resourceRef: z4.string(),
+      subscriptionId: z4.string()
     }).strict()
   }).strict()
 ]);
@@ -6859,6 +6923,7 @@ function createSlackResourceEventInboundMessage(input) {
     createdAtMs: input.event.occurredAtMs,
     destination,
     inboundMessageId: `resource-event:${input.subscription.id}:${input.event.eventKey}`,
+    delivery: "defer",
     source: "resource_event",
     receivedAtMs: Date.now(),
     input: {
@@ -6903,10 +6968,6 @@ function routeForRecords(records) {
     return metadata.route === "mention";
   }) ? "mention" : "subscribed";
 }
-function isSlackAssistantThreadUserMessage(message) {
-  const raw = message.raw && typeof message.raw === "object" ? message.raw : void 0;
-  return raw?.channel_type === "im" && typeof raw.thread_ts === "string" && raw.thread_ts.trim().length > 0;
-}
 function isResourceEventNotificationMessage(message) {
   const raw = message.raw && typeof message.raw === "object" ? message.raw : void 0;
   return raw?.event_type === "resource_event";
@@ -7001,7 +7062,9 @@ function createSlackConversationWorker(options) {
         installation: { teamId: destination.teamId },
         state,
         task: async () => {
-          await options.resumeAwaitingContinuation(context.conversationId);
+          await options.resumeAwaitingContinuation(context.conversationId, {
+            shouldYield: context.shouldYield
+          });
         }
       });
       return { status: "completed" };
@@ -7069,21 +7132,12 @@ function createSlackConversationWorker(options) {
         };
         const drainSteeringMessages = async (accept) => {
           await context.attempt.drain(async (pendingRecords) => {
-            const messages2 = pendingRecords.map((record) => {
-              const metadata = parseSlackMetadata(record.input.metadata);
-              if (!metadata) {
-                throw new Error(
-                  "Conversation mailbox record is not Slack metadata"
-                );
-              }
-              const message = restoreMessage({ adapter, record });
-              return {
-                activeRequest: metadata.route === "mention" || isSlackAssistantThreadUserMessage(message),
+            return await accept(
+              pendingRecords.map((record) => ({
                 inboundMessageId: record.inboundMessageId,
-                message
-              };
-            });
-            return await accept(messages2);
+                message: restoreMessage({ adapter, record })
+              }))
+            );
           });
         };
         try {
@@ -7096,16 +7150,20 @@ function createSlackConversationWorker(options) {
               isFinalAttempt: context.attempt.isFinalAttempt,
               shouldYield: context.shouldYield
             });
-            return;
+          } else {
+            await options.runtime.handleSubscribedMessage(
+              thread,
+              latestMessage,
+              {
+                destination: context.destination,
+                messageContext,
+                drainSteeringMessages,
+                ack,
+                isFinalAttempt: context.attempt.isFinalAttempt,
+                shouldYield: context.shouldYield
+              }
+            );
           }
-          await options.runtime.handleSubscribedMessage(thread, latestMessage, {
-            destination: context.destination,
-            messageContext,
-            drainSteeringMessages,
-            ack,
-            isFinalAttempt: context.attempt.isFinalAttempt,
-            shouldYield: context.shouldYield
-          });
         } catch (error) {
           if (isTurnInputDeferredError(error)) {
             return { status: "deferred" };
@@ -7144,6 +7202,7 @@ function buildSlackInboundMessage(args) {
       args.conversationId,
       args.message.id
     ].join(":"),
+    delivery: args.message.isMention ? "interrupt" : "defer",
     source: "slack",
     createdAtMs: args.message.metadata.dateSent.getTime(),
     receivedAtMs: args.receivedAtMs,
@@ -7935,15 +7994,24 @@ import {
 
 // src/chat/task-execution/worker.ts
 var CONVERSATION_WORK_DEFER_DELAY_MS = 15e3;
-var CONVERSATION_WORK_SOFT_YIELD_AFTER_MS = 24e4;
 function now3(options) {
   return options.nowMs?.() ?? Date.now();
 }
+function selectAttemptMessages(work) {
+  const messages = work.messages;
+  const interrupts = messages.filter(
+    (message) => message.delivery === "interrupt"
+  );
+  if (interrupts.length > 0) {
+    return interrupts;
+  }
+  return work.execution.status === "awaiting_resume" ? [] : messages;
+}
 function nudgeIdempotencyKey(reason, conversationId, nowMs) {
   return `${reason}:${conversationId}:${nowMs}`;
 }
 async function requestLostLeaseRecovery(args) {
-  const continuationMarked = await requestConversationContinuation2({
+  const resumeRequested = await requestConversationContinuation2({
     conversationId: args.conversationId,
     destination: args.destination,
     leaseToken: args.leaseToken,
@@ -7951,7 +8019,7 @@ async function requestLostLeaseRecovery(args) {
     nowMs: args.nowMs,
     state: args.options.state
   });
-  if (!continuationMarked) {
+  if (!resumeRequested) {
     return;
   }
   const released = await releaseConversationWork2({
@@ -8115,15 +8183,8 @@ async function processConversationWork(message, options) {
     return { status: "active" };
   }
   const startedAtMs = now3(options);
-  const softYieldDeadlineMs = startedAtMs + (options.softYieldAfterMs ?? CONVERSATION_WORK_SOFT_YIELD_AFTER_MS);
-  const leasedWork = await getConversationWorkState2({
-    conversationId,
-    state: options.state
-  });
-  const attemptMessages = leasedWork?.messages ?? initial.messages;
-  const attemptMessageIds = attemptMessages.map(
-    (message2) => message2.inboundMessageId
-  );
+  const softYieldDeadlineMs = startedAtMs + (options.softYieldAfterMs ?? getChatConfig().conversationWorkSoftYieldAfterMs);
+  let attemptMessageIds = [];
   let leaseLost = false;
   const markLeaseLost = () => {
     leaseLost = true;
@@ -8143,166 +8204,246 @@ async function processConversationWork(message, options) {
     },
     "Conversation work lease acquired"
   );
-  const drainInbox = (handle) => drainConversationMailbox2({
+  const drain = (handle) => drainConversationMailbox2({
     conversationId,
     leaseToken: lease.leaseToken,
     conversationStore: options.conversationStore,
-    handle,
+    handle: async (messages) => {
+      const candidates = messages.filter(
+        (message2) => message2.delivery === "interrupt"
+      );
+      if (candidates.length === 0) {
+        return [];
+      }
+      return await handle(candidates) ?? candidates.map((message2) => message2.inboundMessageId);
+    },
     nowMs: now3(options),
     state: options.state
   });
-  const ack = async () => {
-    const acknowledged = await ackMessages2({
+  const shouldYield = () => leaseLost || now3(options) >= softYieldDeadlineMs;
+  const checkIn = async () => {
+    const checkedIn = await checkInConversationWork2({
       conversationId,
-      inboundMessageIds: attemptMessageIds,
       leaseToken: lease.leaseToken,
       conversationStore: options.conversationStore,
       nowMs: now3(options),
       state: options.state
     });
-    if (!acknowledged) {
+    if (!checkedIn) {
       markLeaseLost();
-      throw new Error(
-        `Conversation work lease lost before inbox ack for ${conversationId}`
-      );
     }
+    return checkedIn;
   };
-  const workerContext = {
-    attempt: {
-      ack,
+  const yieldWork = async () => {
+    const yieldNowMs = now3(options);
+    await ensureConversationWake({
       conversationId,
-      destination,
-      drain: drainInbox,
-      isFinalAttempt: attemptMessages.some(
-        (message2) => isFinalAttempt(message2)
-      ),
-      messages: attemptMessages
-    },
-    conversationId,
-    destination,
-    shouldYield: () => leaseLost || now3(options) >= softYieldDeadlineMs,
-    checkIn: async () => {
-      const checkedIn = await checkInConversationWork2({
-        conversationId,
-        leaseToken: lease.leaseToken,
-        conversationStore: options.conversationStore,
-        nowMs: now3(options),
-        state: options.state
-      });
-      if (!checkedIn) {
-        markLeaseLost();
-      }
-      return checkedIn;
+      conversationStore: options.conversationStore,
+      idempotencyKey: nudgeIdempotencyKey("yield", conversationId, yieldNowMs),
+      nowMs: yieldNowMs,
+      queue: options.queue,
+      replaceExistingWake: true,
+      state: options.state
+    });
+    const released = await releaseConversationWork2({
+      conversationId,
+      leaseToken: lease.leaseToken,
+      conversationStore: options.conversationStore,
+      nowMs: yieldNowMs,
+      state: options.state
+    });
+    if (!released) {
+      return { status: "lost_lease" };
     }
+    logInfo(
+      "conversation_work_cooperative_yield",
+      { conversationId },
+      {
+        "app.worker.elapsed_ms": now3(options) - startedAtMs,
+        "app.worker.soft_yield_deadline_ms": softYieldDeadlineMs
+      },
+      "Conversation work yielded cooperatively"
+    );
+    return { status: "yielded" };
   };
   try {
-    const result = await options.run(workerContext);
-    if (result.status === "lost_lease") {
-      await requestLostLeaseRecovery({
-        conversationId,
-        destination,
-        leaseToken: lease.leaseToken,
-        nowMs: now3(options),
-        options
-      });
-      return { status: "lost_lease" };
-    }
-    if (leaseLost) {
-      await requestLostLeaseRecovery({
+    let hasRun = false;
+    while (true) {
+      attemptMessageIds = [];
+      const leasedWork = await getConversationWorkState2({
         conversationId,
-        destination,
-        leaseToken: lease.leaseToken,
-        nowMs: now3(options),
-        options
-      });
-      return { status: "lost_lease" };
-    }
-    if (result.status === "yielded") {
-      const yieldNowMs = now3(options);
-      const continuationMarked = await requestConversationContinuation2({
-        conversationId,
-        destination,
-        leaseToken: lease.leaseToken,
-        conversationStore: options.conversationStore,
-        nowMs: yieldNowMs,
         state: options.state
       });
-      if (!continuationMarked) {
+      if (!leasedWork || leasedWork.lease?.leaseToken !== lease.leaseToken || leaseLost) {
+        markLeaseLost();
+        await requestLostLeaseRecovery({
+          conversationId,
+          destination,
+          leaseToken: lease.leaseToken,
+          nowMs: now3(options),
+          options
+        });
         return { status: "lost_lease" };
       }
-      await ensureConversationWake({
-        conversationId,
-        conversationStore: options.conversationStore,
-        idempotencyKey: nudgeIdempotencyKey(
-          "yield",
+      const resumePending = leasedWork.execution.status === "awaiting_resume";
+      const attemptMessages = selectAttemptMessages(leasedWork);
+      if (hasRun && shouldYield()) {
+        if (resumePending) {
+          return await yieldWork();
+        }
+        break;
+      }
+      if (resumePending && attemptMessages.length === 0) {
+        const resumeStarted = await beginConversationResume2({
           conversationId,
-          yieldNowMs
-        ),
-        nowMs: yieldNowMs,
-        queue: options.queue,
-        state: options.state
-      });
-      await releaseConversationWork2({
-        conversationId,
-        leaseToken: lease.leaseToken,
-        conversationStore: options.conversationStore,
-        nowMs: yieldNowMs,
-        state: options.state
-      });
-      logInfo(
-        "conversation_work_cooperative_yield",
-        { conversationId },
-        {
-          "app.worker.elapsed_ms": now3(options) - startedAtMs,
-          "app.worker.soft_yield_deadline_ms": softYieldDeadlineMs
-        },
-        "Conversation work yielded cooperatively"
+          leaseToken: lease.leaseToken,
+          conversationStore: options.conversationStore,
+          nowMs: now3(options),
+          state: options.state
+        });
+        if (!resumeStarted) {
+          markLeaseLost();
+          await requestLostLeaseRecovery({
+            conversationId,
+            destination,
+            leaseToken: lease.leaseToken,
+            nowMs: now3(options),
+            options
+          });
+          return { status: "lost_lease" };
+        }
+      }
+      attemptMessageIds = attemptMessages.map(
+        (message2) => message2.inboundMessageId
       );
-      return { status: "yielded" };
-    }
-    if (result.status === "deferred") {
-      const deferredNowMs = now3(options);
-      const released = await releaseConversationWork2({
+      const ack = async () => {
+        const acknowledged = await ackMessages2({
+          conversationId,
+          inboundMessageIds: attemptMessageIds,
+          leaseToken: lease.leaseToken,
+          conversationStore: options.conversationStore,
+          nowMs: now3(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,
-        leaseToken: lease.leaseToken,
-        conversationStore: options.conversationStore,
-        nowMs: deferredNowMs,
-        state: options.state
-      });
-      if (!released) {
+        destination,
+        shouldYield,
+        checkIn
+      };
+      const result = await options.run(workerContext);
+      hasRun = true;
+      if (result.status === "lost_lease") {
+        await requestLostLeaseRecovery({
+          conversationId,
+          destination,
+          leaseToken: lease.leaseToken,
+          nowMs: now3(options),
+          options
+        });
         return { status: "lost_lease" };
       }
-      const wake = await ensureConversationWake({
-        conversationId,
-        conversationStore: options.conversationStore,
-        idempotencyKey: nudgeIdempotencyKey(
-          "deferred",
+      if (leaseLost) {
+        await requestLostLeaseRecovery({
           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: now3(options),
-        messageIds: attemptMessageIds,
-        options
-      });
-      if (isTerminalFailure(failure)) {
-        await deadLetterAttempt2({
+          destination,
+          leaseToken: lease.leaseToken,
+          nowMs: now3(options),
+          options
+        });
+        return { status: "lost_lease" };
+      }
+      if (result.status === "yielded") {
+        const resumeRequested = await requestConversationContinuation2({
           conversationId,
+          destination,
           leaseToken: lease.leaseToken,
           conversationStore: options.conversationStore,
           nowMs: now3(options),
           state: options.state
         });
-        return { status: "failed" };
+        if (!resumeRequested) {
+          return { status: "lost_lease" };
+        }
+        return await yieldWork();
+      }
+      if (result.status === "deferred") {
+        const deferredNowMs = now3(options);
+        const released = await releaseConversationWork2({
+          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: now3(options),
+          messageIds: attemptMessageIds,
+          options
+        });
+        if (isTerminalFailure(failure)) {
+          await deadLetterAttempt2({
+            conversationId,
+            leaseToken: lease.leaseToken,
+            conversationStore: options.conversationStore,
+            nowMs: now3(options),
+            state: options.state
+          });
+          return { status: "failed" };
+        }
+        if (failure.status === "lost_lease") {
+          return { status: "lost_lease" };
+        }
+        if (failure.status === "recorded") {
+          break;
+        }
+      }
+      const next = await getConversationWorkState2({
+        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;
       }
     }
     const completion = await completeConversationWork2({
@@ -8360,7 +8501,7 @@ async function processConversationWork(message, options) {
           state: options.state
         });
       } else {
-        const continuationMarked = await requestConversationContinuation2({
+        const resumeRequested = await requestConversationContinuation2({
           conversationId,
           destination,
           leaseToken: lease.leaseToken,
@@ -8368,7 +8509,7 @@ async function processConversationWork(message, options) {
           nowMs: errorNowMs,
           state: options.state
         });
-        if (continuationMarked) {
+        if (resumeRequested) {
           await ensureConversationWake({
             conversationId,
             conversationStore: options.conversationStore,
@@ -8379,6 +8520,7 @@ async function processConversationWork(message, options) {
             ),
             nowMs: errorNowMs,
             queue: options.queue,
+            replaceExistingWake: true,
             state: options.state
           });
         }
@@ -8580,14 +8722,14 @@ function registerVercelPluginTaskDevConsumer() {
 }
 
 // src/chat/services/subscribed-decision.ts
-import { z as z4 } from "zod";
-var replyDecisionSchema = z4.object({
-  should_reply: z4.boolean().describe("Whether Junior should respond to this thread message."),
-  should_unsubscribe: z4.boolean().describe(
+import { z as z5 } from "zod";
+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: z4.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
-  reason: z4.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.8;
 var ROUTER_CLASSIFIER_MAX_TOKENS = 240;
@@ -8961,12 +9103,14 @@ function createAcceptedSteeringDrain(hooks, options) {
     await hooks.drainSteeringMessages(async (messages) => {
       const selection = await options.selectMessages(messages, context);
       await options.onSkipped?.(selection.skipped);
-      const interrupted = selection.accepted.filter((accepted) => accepted.mode === "interrupt").map((accepted) => accepted.message);
+      const interrupted = selection.accepted.map(
+        (accepted) => accepted.message
+      );
       await accept(getQueuedMessagesFromSlackMessages(interrupted, options));
       interruptedMessages = interrupted;
       await options.onAcceptedForProcessing?.(interrupted);
       return [
-        ...selection.accepted.filter((accepted) => accepted.mode === "interrupt").map((accepted) => accepted.inboundMessageId),
+        ...selection.accepted.map((accepted) => accepted.inboundMessageId),
         ...selection.skipped.map((skipped) => skipped.inboundMessageId)
       ];
     });
@@ -9100,19 +9244,17 @@ function createSlackTurnRuntime(deps) {
       rawText: appendSlackLegacyAttachmentText(message.text, message.raw),
       userText: appendSlackLegacyAttachmentText(strippedUserText, message.raw)
     };
-    const isActiveRequest = candidate.activeRequest || Boolean(message.isMention);
     const decision = await deps.decideSubscribedReply({
       rawText: text.rawText,
       text: text.userText,
       conversationContext,
       hasAttachments: message.attachments.length > 0 || legacyAttachmentText !== "",
-      isExplicitMention: isActiveRequest,
+      isExplicitMention: true,
       context
     });
     return {
       context,
       decision,
-      mode: isActiveRequest ? "interrupt" : "defer",
       text
     };
   };
@@ -9166,7 +9308,6 @@ function createSlackTurnRuntime(deps) {
         context: decision.context,
         decision: decision.decision,
         inboundMessageId: candidate.inboundMessageId,
-        mode: decision.mode,
         message: candidate.message,
         text: decision.text
       });
@@ -9188,8 +9329,7 @@ function createSlackTurnRuntime(deps) {
     return {
       accepted: selected.filter((message) => message.decision.shouldReply).map((message) => ({
         inboundMessageId: message.inboundMessageId,
-        message: message.message,
-        mode: message.mode
+        message: message.message
       })),
       skipped: selected.filter((message) => !message.decision.shouldReply)
     };
@@ -10354,11 +10494,11 @@ function getSlackMessageTs(message) {
 }
 
 // src/chat/slack/action-token.ts
-import { z as z5 } from "zod";
-var slackActionTokenSchema = z5.string().trim().min(1).brand();
-var slackMessageEnvelopeSchema = z5.object({
-  raw: z5.object({
-    action_token: z5.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) {
@@ -10749,13 +10889,14 @@ function createReplyToThread(deps) {
           beforeFirstResponsePostCalled = true;
           await options.beforeFirstResponsePost?.();
         };
-        const postAuthPauseNotice = async (providerDisplayName) => {
+        const postAuthPauseNotice = async (providerDisplayName, requestText) => {
           if (!actor) {
             throw new Error("Slack auth pause notice requires an actor");
           }
           const text = buildAuthPauseResponse(
             actor.userId,
-            providerDisplayName
+            providerDisplayName,
+            requestText
           );
           try {
             await beforeFirstResponsePost();
@@ -11353,10 +11494,7 @@ function createReplyToThread(deps) {
             state: {
               artifactState: preparedState.artifacts,
               pendingAuth: preparedState.conversation.processing.pendingAuth,
-              sandbox: {
-                sandboxId: preparedState.sandboxId,
-                sandboxDependencyProfileHash: preparedState.sandboxDependencyProfileHash
-              }
+              sandboxRef: preparedState.sandboxRef
             },
             observers: {
               onStatus: (nextStatus) => status.update(nextStatus),
@@ -11369,10 +11507,9 @@ function createReplyToThread(deps) {
               onInputCommitted: options.ack,
               drainSteeringMessages,
               shouldYield: options.shouldYield,
-              onSandboxAcquired: async (sandbox) => {
+              onSandboxRefChanged: async (sandboxRef) => {
                 await persistThreadState(thread, {
-                  sandboxId: sandbox.sandboxId,
-                  sandboxDependencyProfileHash: sandbox.sandboxDependencyProfileHash
+                  sandboxRef
                 });
               },
               onArtifactStateUpdated: async (artifacts) => {
@@ -11428,7 +11565,10 @@ function createReplyToThread(deps) {
               shouldPersistFailureState = false;
               return;
             }
-            await postAuthPauseNotice(outcome.providerDisplayName);
+            await postAuthPauseNotice(
+              outcome.providerDisplayName,
+              outcome.requestText
+            );
             completeAuthPauseTurn({
               conversation: preparedState.conversation,
               sessionId: turnId
@@ -11932,12 +12072,7 @@ async function seedConversationBackfill(thread, conversation, currentTurn) {
 function createPrepareTurnState(deps) {
   return async function prepareTurnState(args) {
     const existingState = await args.thread.state;
-    const existingSandboxId = existingState ? toOptionalString(
-      existingState.app_sandbox_id
-    ) : void 0;
-    const existingSandboxDependencyProfileHash = existingState ? toOptionalString(
-      existingState.app_sandbox_dependency_profile_hash
-    ) : void 0;
+    const sandboxRef = getPersistedSandboxState(existingState ?? {});
     const artifacts = coerceThreadArtifactsState(existingState);
     const conversation = coerceThreadConversationState(existingState);
     const conversationId = args.context.threadId ?? args.context.runId;
@@ -12006,8 +12141,7 @@ function createPrepareTurnState(deps) {
       configuration,
       channelConfiguration,
       conversation,
-      sandboxId: existingSandboxId,
-      sandboxDependencyProfileHash: existingSandboxDependencyProfileHash,
+      sandboxRef,
       conversationContext,
       userMessageAlreadyReplied,
       userMessageId
@@ -12315,7 +12449,7 @@ async function failUnresumableContinuation(args) {
     errorMessage: args.errorMessage
   });
 }
-async function continueSlackAgentRun(payload, options) {
+async function continueSlackAgentRun(payload, options, runOptions = {}) {
   const thread = parseSlackThreadId(payload.conversationId);
   if (!thread) {
     throw new Error(
@@ -12368,7 +12502,7 @@ async function continueSlackAgentRun(payload, options) {
         const conversationContext = buildConversationContext(conversation, {
           excludeMessageId: userMessage.id
         });
-        const sandbox = getPersistedSandboxState(currentState);
+        const sandboxRef = getPersistedSandboxState(currentState);
         const destination = requireSlackDestination(
           payload.destination,
           "Slack continuation"
@@ -12440,9 +12574,10 @@ async function continueSlackAgentRun(payload, options) {
             state: {
               artifactState: artifacts,
               pendingAuth: conversation.processing.pendingAuth,
-              sandbox
+              sandboxRef
             },
             durability: {
+              shouldYield: runOptions.shouldYield,
               recordPendingAuth: async (nextPendingAuth) => {
                 conversation.processing.pendingAuth = nextPendingAuth;
                 await persistThreadStateById(payload.conversationId, {
@@ -12605,7 +12740,11 @@ async function recoverStrandedRunningSession(args) {
     });
     return false;
   }
-  if (await continueSlackAgentRunWithLockRetry(request, args.options)) {
+  if (await continueSlackAgentRunWithLockRetry(
+    request,
+    args.options,
+    args.runOptions
+  )) {
     return true;
   }
   await failUnresumableContinuation({
@@ -12616,13 +12755,14 @@ async function recoverStrandedRunningSession(args) {
   });
   return false;
 }
-async function resumeAwaitingSlackContinuation(conversationId, options) {
+async function resumeAwaitingSlackContinuation(conversationId, options, runOptions = {}) {
   const summaries = await listAgentTurnSessionSummariesForConversation(conversationId);
   const newest = summaries[0];
   if (newest?.state === "running") {
     return await recoverStrandedRunningSession({
       conversationId,
       options,
+      runOptions,
       summary: newest
     });
   }
@@ -12642,7 +12782,7 @@ async function resumeAwaitingSlackContinuation(conversationId, options) {
       });
       continue;
     }
-    if (await continueSlackAgentRunWithLockRetry(request, options)) {
+    if (await continueSlackAgentRunWithLockRetry(request, options, runOptions)) {
       return true;
     }
     await failUnresumableContinuation({
@@ -12654,14 +12794,14 @@ async function resumeAwaitingSlackContinuation(conversationId, options) {
   }
   return false;
 }
-async function continueSlackAgentRunWithLockRetry(payload, options) {
+async function continueSlackAgentRunWithLockRetry(payload, options, runOptions = {}) {
   const scheduleAgentContinue2 = options.scheduleAgentContinue ?? scheduleAgentContinue;
   for (const [attempt, delayMs] of [
     ...AGENT_CONTINUE_LOCK_RETRY_DELAYS_MS,
     void 0
   ].entries()) {
     try {
-      return await continueSlackAgentRun(payload, options);
+      return await continueSlackAgentRun(payload, options, runOptions);
     } catch (error) {
       if (!(error instanceof ResumeTurnBusyError)) {
         throw error;
@@ -12756,10 +12896,14 @@ function createProductionConversationWorkOptions(options) {
     run: createSlackConversationWorker({
       getSlackAdapter: getProductionSlackAdapter,
       conversationStore,
-      resumeAwaitingContinuation: async (conversationId) => await resumeAwaitingSlackContinuation(conversationId, {
-        agentRunner,
-        scheduleSessionCompletedPluginTasks: services.replyExecutor?.scheduleSessionCompletedPluginTasks
-      }),
+      resumeAwaitingContinuation: async (conversationId, runOptions) => await resumeAwaitingSlackContinuation(
+        conversationId,
+        {
+          agentRunner,
+          scheduleSessionCompletedPluginTasks: services.replyExecutor?.scheduleSessionCompletedPluginTasks
+        },
+        runOptions
+      ),
       runtime
     })
   };
@@ -12889,6 +13033,7 @@ async function resolveVirtualConfig() {
     const mod = await import("#junior/config");
     return {
       createDashboardApp: mod.createDashboardApp,
+      functionMaxDurationSeconds: mod.functionMaxDurationSeconds,
       dashboard: mod.dashboard,
       pluginSet: mod.pluginSet,
       plugins: mod.plugins,
@@ -13142,6 +13287,11 @@ function mountRoutes(app, routes) {
 }
 async function createApp(options) {
   const virtualConfig = await resolveVirtualConfig();
+  if (virtualConfig?.functionMaxDurationSeconds !== void 0) {
+    configureFunctionMaxDurationSeconds(
+      virtualConfig.functionMaxDurationSeconds
+    );
+  }
   const dashboard = options?.dashboard ?? virtualConfig?.dashboard;
   const configuredPlugins = options?.plugins ?? virtualConfig?.pluginSet;
   const plugins = pluginRuntimeRegistrationsFromPluginSet(configuredPlugins);