@sentry/junior 0.184.0 → 0.185.0

package/dist/app.js

@@ -1,20 +1,21 @@
 import {
   processConversationWork
-} from "./chunk-4RONS3WR.js";
+} from "./chunk-C6TS47CQ.js";
 import {
   bindSpawnAgent
-} from "./chunk-QABCY33S.js";
+} from "./chunk-TVVAMOLS.js";
 import {
   createAgentInvocationWorker,
   enqueueAgentInvocation,
   listPendingAgentInvocationMailboxAppends,
   routeAgentInvocationWork
-} from "./chunk-BT53RIGJ.js";
+} from "./chunk-HJPC32TQ.js";
 import {
   GET as GET2,
   GET2 as GET3,
   buildAuthPauseResponse,
   buildSlackOutputMessage,
+  createPausedTurns,
   createSlackAdapterAssistantStatusSession,
   getAssistantThreadContext,
   getChannelId,
@@ -33,10 +34,10 @@ import {
   sendSlackReply,
   shouldKeepProcessingReactionForToolInvocation,
   splitSlackReplyText,
-  startSlackProcessingReaction,
+  startProcessingReaction,
   stripLeadingBotMention,
   wakePausedTurn
-} from "./chunk-ACPDVEJO.js";
+} from "./chunk-X2SS6BF7.js";
 import "./chunk-FA6POGLH.js";
 import {
   GET,
@@ -53,8 +54,12 @@ import {
   resolveSlackConversationContext,
   routeApiTurnWork,
   webActorFromEmail
-} from "./chunk-UBOIHNTH.js";
-import "./chunk-LCP4EDKR.js";
+} from "./chunk-MWOH6CIK.js";
+import "./chunk-UUULGCKK.js";
+import {
+  AgentRunError,
+  executeTurn
+} from "./chunk-W7GCLNIV.js";
 import {
   buildDeliveredTurnStatePatch,
   completeAuthPauseTurn,
@@ -65,7 +70,7 @@ import {
   getTurnUserSlackMessageTs,
   persistAuthPauseTurnState,
   requireTurnFailureEventId
-} from "./chunk-M5YWNMTE.js";
+} from "./chunk-DAPC2HTM.js";
 import {
   claimDispatchMailboxAppend,
   confirmDispatchMailboxAppend,
@@ -85,10 +90,10 @@ import {
   recordTaskExecution,
   resolveTurnSessionRouting,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-6WGC3SO4.js";
+} from "./chunk-FFHXG2FX.js";
 import {
   ConversationTurnLifecycleService
-} from "./chunk-M3QYTBQ6.js";
+} from "./chunk-6Q7YZLCL.js";
 import {
   coerceThreadConversationState,
   getLocationConfigurationService,
@@ -97,17 +102,17 @@ import {
   persistThreadRuntimeState,
   persistThreadState,
   persistThreadStateById
-} from "./chunk-E57WPXWY.js";
+} from "./chunk-Y5G23T2D.js";
 import "./chunk-UTL3MHPC.js";
 import {
   createVercelPluginTaskCallback,
   queueCallback,
   registerVercelPluginTaskDevConsumer
-} from "./chunk-UF6BUA5W.js";
+} from "./chunk-4S47VHJR.js";
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-HUXFMDBZ.js";
+} from "./chunk-ZIF2S464.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -155,36 +160,28 @@ import {
   unpublishedArtifactHeaders,
   verifySlackSignature,
   withNormalizedThreadId
-} from "./chunk-JNO2GUDS.js";
+} from "./chunk-6DOAUXLD.js";
 import {
   AuthorizationFlowDisabledError,
   PluginCredentialFailureError
-} from "./chunk-K7VDC2QW.js";
+} from "./chunk-EWEH2PJW.js";
 import "./chunk-6Y5B5PEX.js";
 import "./chunk-DIB4GX3G.js";
 import {
-  createAgentRunner,
   createUserTokenStore,
   deleteMcpAuthSessionsForUserProvider,
   deleteMcpServerSessionId,
   deleteMcpStoredOAuthCredentials
-} from "./chunk-FKEZZMXS.js";
-import {
-  RetryableDeliveryError
-} from "./chunk-RF6J3DIO.js";
+} from "./chunk-4HA36IWS.js";
 import {
   formatProviderLabel,
   postSlackMessage,
   startOAuthFlow
-} from "./chunk-JM2COLGC.js";
-import {
-  getExperimentalFeatures,
-  isExperimentalFeatureEnabled,
-  setExperimentalFeatures
-} from "./chunk-2LYHWMR4.js";
+} from "./chunk-ZKKGFUWM.js";
 import {
   collectAttachmentGarbage,
   collectEventTaskMatchKeys,
+  createResourceEventTeamIdResolver,
   findMatchingEventTasks,
   getResourceEventCatalog,
   listScheduledTasks,
@@ -197,10 +194,14 @@ import {
   scheduledRunId,
   scheduledRunSchema,
   withScheduledTaskLock
-} from "./chunk-HIPUIPJM.js";
+} from "./chunk-QZKHHG3B.js";
 import {
   parseSlackThreadId
-} from "./chunk-YKX6MTLU.js";
+} from "./chunk-X7NCJQAA.js";
+import {
+  RetryableDeliveryError,
+  createAgentRunner
+} from "./chunk-INQHUE72.js";
 import {
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
   appendAndEnqueueInboundMessage,
@@ -215,7 +216,7 @@ import {
   removeActiveConversation,
   requestConversationWork,
   stopConversationWork
-} from "./chunk-Z3QAXJR7.js";
+} from "./chunk-D63IUQQE.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
@@ -233,7 +234,7 @@ import {
   markTurnCompleted,
   markTurnFailed,
   startActiveTurn
-} from "./chunk-JA43DV4Y.js";
+} from "./chunk-U4CTAVWN.js";
 import {
   abandonTurnRecord,
   appendThreadContextMessages,
@@ -269,11 +270,16 @@ import {
   trimTrailingAssistantMessages,
   turnHasReply,
   upsertConversationMessage
-} from "./chunk-2ZQPVX7C.js";
+} from "./chunk-WLKWN4CD.js";
+import {
+  getExperimentalFeatures,
+  isExperimentalFeatureEnabled,
+  setExperimentalFeatures
+} from "./chunk-2LYHWMR4.js";
 import {
   getSandboxResourceConfig,
   setSandboxResourceConfig
-} from "./chunk-MAPJFUMV.js";
+} from "./chunk-QCT4226Q.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
 import {
@@ -292,7 +298,7 @@ import {
 import "./chunk-7H2VZTWN.js";
 import {
   getTurnRequestDeadline
-} from "./chunk-MLSQX2EX.js";
+} from "./chunk-FTVMXDNN.js";
 import {
   SlackActionError,
   bindEventTaskCredentialSubject,
@@ -302,7 +308,6 @@ import {
   collectResourceEventMatchKeys,
   createPluginLogger,
   createPluginState,
-  createResourceEventTeamIdResolver,
   downloadPrivateSlackFile,
   getPluginApiRoutes,
   getPluginRoutes,
@@ -318,20 +323,18 @@ import {
   verifyEventTaskCredentialSubject,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-4CNDGK25.js";
+} from "./chunk-VH4IU3UC.js";
 import "./chunk-3Y47VMHV.js";
 import {
-  contextProvenance,
   deleteProviderIdentityForSlackUser,
   getConversationEventStore,
   getConversationStore,
   getDb,
   getSqlExecutor,
-  instructionProvenanceFor,
   requireSlackDestination,
   withConversationEventLock,
   withConversationMutationLock
-} from "./chunk-IZDYYYGP.js";
+} from "./chunk-ABAX75GG.js";
 import {
   juniorAgentBindings,
   juniorAgentInvocations,
@@ -339,13 +342,17 @@ import {
   juniorConversations,
   juniorSchedulerRuns,
   juniorSchedulerTasks
-} from "./chunk-BCHYQS4B.js";
-import "./chunk-SHJK75Z2.js";
+} from "./chunk-LVK4WJKM.js";
+import "./chunk-EJYP3NQ4.js";
 import {
   acquireActiveLock,
   getStateAdapter,
   withActiveLock
-} from "./chunk-DUKIDPF6.js";
+} from "./chunk-PNYJOEVV.js";
+import {
+  contextProvenance,
+  instructionProvenanceFor
+} from "./chunk-GFBR4S3Q.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
@@ -354,7 +361,6 @@ import {
   completeObject,
   completeText,
   configureFunctionMaxDurationSeconds,
-  defaultModelId,
   escapeXml,
   getChatConfig,
   getSlackBotToken,
@@ -363,16 +369,19 @@ import {
   getSlackReactionConfig,
   getSlackSigningSecret,
   isProviderRetryError,
-  modelIdForProfile,
   setProfiles,
   setSlackReactionConfig
-} from "./chunk-6UDPINOX.js";
-import "./chunk-BHYRYYLY.js";
-import "./chunk-WQFEWULF.js";
+} from "./chunk-LRI5IRGY.js";
+import {
+  defaultModelId,
+  modelIdForProfile
+} from "./chunk-D4YV5TDV.js";
+import "./chunk-EIJCPJOY.js";
+import "./chunk-ATUWN6Z3.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-PJPRXO2T.js";
-import "./chunk-LHXIZLFF.js";
+} from "./chunk-GJTIZQGJ.js";
+import "./chunk-7MHNIGHP.js";
 import {
   credentialContextForActor
 } from "./chunk-CEMMLV5L.js";
@@ -407,13 +416,13 @@ import {
   withContext,
   withLogContext,
   withSpan
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-OMQ2J6F6.js";
 import {
   continueTrace
 } from "./chunk-PEQXYSSE.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-6VOYP4M6.js";
+} from "./chunk-7GAP2XG4.js";
 
 // src/app.ts
 import { createRequire } from "module";
@@ -4218,9 +4227,10 @@ function shouldRethrowTurnControlError(error) {
 function getQueuedMessages(context, options) {
   return (context?.skipped ?? []).map((message) => {
     const content = parseContent(message);
-    const stripped = options.stripLeadingBotMention(
+    const stripped = stripLeadingBotMention(
       stripLeadingSteeringOverride(content.topLevelText),
       {
+        botUserId: options.botUserId,
         stripLeadingSlackMentionToken: options.explicitMention || Boolean(message.isMention)
       }
     );
@@ -4295,7 +4305,7 @@ function createSlackTurnRuntime(deps) {
     return true;
   };
   const failConversationTurn = async (args) => {
-    const conversationId = deps.getThreadId(args.thread, args.message) ?? deps.getRunId(args.thread, args.message);
+    const conversationId = getThreadId(args.thread, args.message) ?? getRunId(args.thread, args.message);
     if (!conversationId) {
       return;
     }
@@ -4328,7 +4338,7 @@ function createSlackTurnRuntime(deps) {
     const processingReactionByMessage = /* @__PURE__ */ new Map();
     return {
       start: async (context, targetMessage) => {
-        const channelId = deps.getChannelId(thread, targetMessage);
+        const channelId = getChannelId(thread, targetMessage);
         const messageTs = getMessageTs(targetMessage);
         const reactionKey = channelId && messageTs ? `${channelId}:${messageTs}` : void 0;
         if (reactionKey) {
@@ -4337,10 +4347,9 @@ function createSlackTurnRuntime(deps) {
             return existing;
           }
         }
-        const started = await startSlackProcessingReaction({
+        const started = await startProcessingReaction({
           thread,
-          message: targetMessage,
-          logException: deps.logException
+          message: targetMessage
         });
         processingReactions.push(started);
         if (reactionKey) {
@@ -4356,7 +4365,7 @@ function createSlackTurnRuntime(deps) {
     try {
       await args.thread.post(buildTurnFailureResponse(args.eventId));
     } catch (postError) {
-      deps.logException(postError, args.postFailureEventName, {
+      logException(postError, args.postFailureEventName, {
         "app.slack.reply_stage": "error_fallback_post",
         "app.error.original_event_id": args.eventId,
         ...getSlackErrorObservabilityAttributes(postError)
@@ -4367,15 +4376,16 @@ function createSlackTurnRuntime(deps) {
   const decideSteeringMessage = async (thread, candidate, conversationContext) => {
     const { message } = candidate;
     const context = {
-      threadId: deps.getThreadId(thread, message),
+      threadId: getThreadId(thread, message),
       actorId: message.author.userId,
-      channelId: deps.getChannelId(thread, message),
-      runId: deps.getRunId(thread, message)
+      channelId: getChannelId(thread, message),
+      runId: getRunId(thread, message)
     };
     const content = parseContent(message);
-    const strippedUserText = deps.stripLeadingBotMention(
+    const strippedUserText = stripLeadingBotMention(
       stripLeadingSteeringOverride(content.topLevelText),
       {
+        botUserId: deps.getBotUserId(),
         stripLeadingSlackMentionToken: Boolean(message.isMention)
       }
     );
@@ -4407,7 +4417,7 @@ function createSlackTurnRuntime(deps) {
         runId: args.context.runId
       }),
       () => {
-        deps.logWarn("subscribed_message.reply.skipped", {
+        logWarn("subscribed_message.reply.skipped", {
           "app.decision.reason": args.decision.reason
         });
       }
@@ -4503,7 +4513,7 @@ function createSlackTurnRuntime(deps) {
       }
     } catch (error) {
       withLogContext(args.context, () => {
-        deps.logException(error, "agent.turn.steering_flush.failed");
+        logException(error, "agent.turn.steering_flush.failed");
       });
     }
   };
@@ -4520,18 +4530,18 @@ function createSlackTurnRuntime(deps) {
           thread,
           pending: skippedSteeringMessages,
           context: logContext({
-            threadId: deps.getThreadId(thread, message),
+            threadId: getThreadId(thread, message),
             actorId: message.author.userId,
             actorUserName: actorUserName(message),
-            channelId: deps.getChannelId(thread, message),
-            runId: deps.getRunId(thread, message)
+            channelId: getChannelId(thread, message),
+            runId: getRunId(thread, message)
           })
         });
       };
       try {
-        const threadId = deps.getThreadId(thread, message);
-        const channelId = deps.getChannelId(thread, message);
-        const runId = deps.getRunId(thread, message);
+        const threadId = getThreadId(thread, message);
+        const channelId = getChannelId(thread, message);
+        const runId = getRunId(thread, message);
         const context = logContext({
           threadId,
           channelId,
@@ -4544,11 +4554,11 @@ function createSlackTurnRuntime(deps) {
           processingReaction,
           hooks
         );
-        await deps.withSpan("chat.turn", "chat.turn", context, async () => {
+        await withSpan("chat.turn", "chat.turn", context, async () => {
           await thread.subscribe();
           const queuedMessages = getQueuedMessages(hooks.messageContext, {
-            explicitMention: true,
-            stripLeadingBotMention: deps.stripLeadingBotMention
+            botUserId: deps.getBotUserId(),
+            explicitMention: true
           });
           let queuedProcessingReactionsStarted = false;
           const startQueuedProcessingReactions = async () => {
@@ -4568,6 +4578,7 @@ function createSlackTurnRuntime(deps) {
             await startQueuedProcessingReactions();
           };
           const drainSteeringMessages = createAcceptedSteeringDrain(hooks, {
+            botUserId: deps.getBotUserId(),
             explicitMention: true,
             onAcceptedForProcessing: async (messages) => {
               await Promise.all(
@@ -4586,8 +4597,7 @@ function createSlackTurnRuntime(deps) {
               conversationContext: drainContext?.conversationContext,
               messages,
               thread
-            }),
-            stripLeadingBotMention: deps.stripLeadingBotMention
+            })
           });
           await deps.executeSlackTurn(thread, message, {
             explicitMention: true,
@@ -4606,11 +4616,11 @@ function createSlackTurnRuntime(deps) {
         });
       } catch (error) {
         const failureLogContext = logContext({
-          threadId: deps.getThreadId(thread, message),
+          threadId: getThreadId(thread, message),
           actorId: message.author.userId,
           actorUserName: actorUserName(message),
-          channelId: deps.getChannelId(thread, message),
-          runId: deps.getRunId(thread, message)
+          channelId: getChannelId(thread, message),
+          runId: getRunId(thread, message)
         });
         const classifiedFailure = getConversationTurnBoundaryError(error);
         const failureCause = classifiedFailure?.cause ?? error;
@@ -4623,7 +4633,7 @@ function createSlackTurnRuntime(deps) {
         const failureCode = classifiedFailure?.failureCode ?? "agent_run_failed";
         if (failureCause instanceof SlackActionError && failureCause.code === "read_only_channel") {
           withLogContext(failureLogContext, () => {
-            deps.logWarn("mention.handler.skipped", {
+            logWarn("mention.handler.skipped", {
               "app.decision.reason": "read_only_channel"
             });
           });
@@ -4631,7 +4641,7 @@ function createSlackTurnRuntime(deps) {
         }
         const eventId = classifiedFailure?.eventId ?? withLogContext(
           failureLogContext,
-          () => deps.logException(failureCause, "mention.handler.failed")
+          () => logException(failureCause, "mention.handler.failed")
         );
         if (!acked && hooks.isFinalAttempt === false) {
           return;
@@ -4669,11 +4679,11 @@ function createSlackTurnRuntime(deps) {
             thread,
             pending: skippedSteeringMessages,
             context: logContext({
-              threadId: deps.getThreadId(thread, message),
+              threadId: getThreadId(thread, message),
               actorId: message.author.userId,
               actorUserName: actorUserName(message),
-              channelId: deps.getChannelId(thread, message),
-              runId: deps.getRunId(thread, message)
+              channelId: getChannelId(thread, message),
+              runId: getRunId(thread, message)
             })
           });
           await processingReactions.stopAll();
@@ -4692,18 +4702,18 @@ function createSlackTurnRuntime(deps) {
           thread,
           pending: skippedSteeringMessages,
           context: logContext({
-            threadId: deps.getThreadId(thread, message),
+            threadId: getThreadId(thread, message),
             actorId: message.author.userId,
             actorUserName: actorUserName(message),
-            channelId: deps.getChannelId(thread, message),
-            runId: deps.getRunId(thread, message)
+            channelId: getChannelId(thread, message),
+            runId: getRunId(thread, message)
           })
         });
       };
       try {
-        const threadId = deps.getThreadId(thread, message);
-        const channelId = deps.getChannelId(thread, message);
-        const runId = deps.getRunId(thread, message);
+        const threadId = getThreadId(thread, message);
+        const channelId = getChannelId(thread, message);
+        const runId = getRunId(thread, message);
         const isResourceEventNotification = isResourceEventSlackMessage(message);
         const actorId = isResourceEventNotification ? void 0 : message.author.userId;
         const turnContext = logContext({
@@ -4713,11 +4723,12 @@ function createSlackTurnRuntime(deps) {
           channelId,
           runId
         });
-        await deps.withSpan("chat.turn", "chat.turn", turnContext, async () => {
+        await withSpan("chat.turn", "chat.turn", turnContext, async () => {
           const content = parseContent(message);
-          const strippedUserText = deps.stripLeadingBotMention(
+          const strippedUserText = stripLeadingBotMention(
             stripLeadingSteeringOverride(content.topLevelText),
             {
+              botUserId: deps.getBotUserId(),
               stripLeadingSlackMentionToken: Boolean(message.isMention)
             }
           );
@@ -4732,8 +4743,8 @@ function createSlackTurnRuntime(deps) {
             runId
           };
           const queuedMessages = getQueuedMessages(hooks.messageContext, {
-            explicitMention: Boolean(message.isMention),
-            stripLeadingBotMention: deps.stripLeadingBotMention
+            botUserId: deps.getBotUserId(),
+            explicitMention: Boolean(message.isMention)
           });
           const combinedText = combineTurnText(queuedMessages, currentText);
           const turnIsExplicitMention = Boolean(message.isMention) || queuedMessages.some((queued) => queued.explicitMention);
@@ -4833,6 +4844,7 @@ function createSlackTurnRuntime(deps) {
           }
           const conversationContext = deps.getPreparedConversationContext(preparedState);
           const drainSteeringMessages = createAcceptedSteeringDrain(hooks, {
+            botUserId: deps.getBotUserId(),
             explicitMention: Boolean(message.isMention),
             onAcceptedForProcessing: async (messages) => {
               await Promise.all(
@@ -4851,8 +4863,7 @@ function createSlackTurnRuntime(deps) {
               conversationContext: drainContext?.conversationContext ?? conversationContext,
               messages,
               thread
-            }),
-            stripLeadingBotMention: deps.stripLeadingBotMention
+            })
           });
           processingReaction = await processingReactions.start(
             turnContext,
@@ -4897,11 +4908,11 @@ function createSlackTurnRuntime(deps) {
         });
       } catch (error) {
         const failureLogContext = logContext({
-          threadId: deps.getThreadId(thread, message),
+          threadId: getThreadId(thread, message),
           actorId: message.author.userId,
           actorUserName: actorUserName(message),
-          channelId: deps.getChannelId(thread, message),
-          runId: deps.getRunId(thread, message)
+          channelId: getChannelId(thread, message),
+          runId: getRunId(thread, message)
         });
         const classifiedFailure = getConversationTurnBoundaryError(error);
         const failureCause = classifiedFailure?.cause ?? error;
@@ -4914,7 +4925,7 @@ function createSlackTurnRuntime(deps) {
         const failureCode = classifiedFailure?.failureCode ?? "agent_run_failed";
         if (failureCause instanceof SlackActionError && failureCause.code === "read_only_channel") {
           withLogContext(failureLogContext, () => {
-            deps.logWarn("subscribed_message.handler.skipped", {
+            logWarn("subscribed_message.handler.skipped", {
               "app.decision.reason": "read_only_channel"
             });
           });
@@ -4922,10 +4933,7 @@ function createSlackTurnRuntime(deps) {
         }
         const eventId = classifiedFailure?.eventId ?? withLogContext(
           failureLogContext,
-          () => deps.logException(
-            failureCause,
-            "subscribed_message.handler.failed"
-          )
+          () => logException(failureCause, "subscribed_message.handler.failed")
         );
         if (!acked && hooks.isFinalAttempt === false) {
           return;
@@ -4963,11 +4971,11 @@ function createSlackTurnRuntime(deps) {
             thread,
             pending: skippedSteeringMessages,
             context: logContext({
-              threadId: deps.getThreadId(thread, message),
+              threadId: getThreadId(thread, message),
               actorId: message.author.userId,
               actorUserName: actorUserName(message),
-              channelId: deps.getChannelId(thread, message),
-              runId: deps.getRunId(thread, message)
+              channelId: getChannelId(thread, message),
+              runId: getRunId(thread, message)
             })
           });
           await processingReactions.stopAll();
@@ -4990,7 +4998,7 @@ function createSlackTurnRuntime(deps) {
               sourceChannelId: event.context?.channelId
             });
           } catch (error) {
-            deps.logException(error, "assistant.thread.initialization.failed");
+            logException(error, "assistant.thread.initialization.failed");
           }
         }
       );
@@ -5011,7 +5019,7 @@ function createSlackTurnRuntime(deps) {
               sourceChannelId: event.context?.channelId
             });
           } catch (error) {
-            deps.logException(error, "assistant.context.refresh.failed");
+            logException(error, "assistant.context.refresh.failed");
           }
         }
       );
@@ -5493,24 +5501,14 @@ function createJuniorRuntimeServices(overrides = {}) {
     listThreadReplies: overrides.visionContext?.listThreadReplies ?? listThreadReplies,
     downloadFile: overrides.visionContext?.downloadFile ?? downloadPrivateSlackFile
   });
-  const agentRunner = overrides.replyExecutor?.agentRunner ?? createAgentRunner(executeAgentRun, {
+  const agentRunner = overrides.agentRunner ?? createAgentRunner(executeAgentRun, {
     bindSpawnAgent: (request) => bindSpawnAgent(request, { queue: getVercelConversationWorkQueue }),
     tracePropagation: overrides.sandbox?.tracePropagation
   });
   return {
     conversationMemory,
     contextCompactor,
-    replyExecutor: {
-      contextCompactor: overrides.replyExecutor?.contextCompactor ?? contextCompactor,
-      agentRunner,
-      getPausedTurnRequest: overrides.replyExecutor?.getPausedTurnRequest ?? getPausedTurnRequest,
-      lookupSlackUser: overrides.replyExecutor?.lookupSlackUser ?? lookupSlackUser,
-      wakePausedTurn: overrides.replyExecutor?.wakePausedTurn ?? wakePausedTurn,
-      scheduleSessionCompletedPluginTasks: overrides.replyExecutor?.scheduleSessionCompletedPluginTasks ?? (async (params) => {
-        await scheduleSessionCompletedPluginTasks(params);
-      }),
-      turnLifecycle: overrides.replyExecutor?.turnLifecycle ?? new ConversationTurnLifecycleService(getConversationEventStore())
-    },
+    executeTurn: async (run, saveResult, timeoutMs) => await executeTurn(agentRunner, run, saveResult, timeoutMs),
     subscribedReplyPolicy: createSubscribedReplyPolicy({
       completeObject: overrides.subscribedReplyPolicy?.completeObject ?? completeObject
     }),
@@ -5616,11 +5614,8 @@ async function maybeApplyProviderDefaultConfigRequest(args) {
   };
 }
 
-// src/chat/providers/slack/turn.ts
-async function persistThreadRuntimeStateWithRetry(thread, patch) {
-  await persistWithRetry(() => persistThreadRuntimeState(thread, patch));
-}
-function parkedInputKey(message) {
+// src/chat/providers/slack/input.ts
+function steeringMessageKey(message) {
   if (message.role !== "user") {
     return void 0;
   }
@@ -5629,19 +5624,19 @@ function parkedInputKey(message) {
   return `${message.timestamp}:${text}`;
 }
 function renderRecentThreadMessageLines(conversationContext, messages) {
-  const passiveMessages = messages.filter((queued) => {
+  const messagesForContext = messages.filter((queued) => {
     if (queued.explicitMention) {
       return false;
     }
-    const slackTs = queuedInstructionActor(queued)?.slackTs;
+    const slackTs = inboundMessageActor(queued)?.slackTs;
     return !slackTs || !conversationContext?.includes(`slack_ts="${slackTs}"`);
   });
-  if (passiveMessages.length === 0) {
+  if (messagesForContext.length === 0) {
     return [];
   }
   const lines = [];
-  for (const queued of passiveMessages) {
-    const actor = queuedInstructionActor(queued);
+  for (const queued of messagesForContext) {
+    const actor = inboundMessageActor(queued);
     const author = escapeXml(actor?.authorName ?? "user");
     const attrs = [
       `role="user"`,
@@ -5658,14 +5653,13 @@ function renderRecentThreadMessageLines(conversationContext, messages) {
   }
   return lines;
 }
-function appendRecentThreadMessagesToContext(conversationContext, messages, options) {
-  const baseContext = options?.includeConversationContext === false ? void 0 : conversationContext;
+function appendRecentMessagesToContext(conversationContext, messages) {
   return appendThreadContextMessages(
-    baseContext,
+    conversationContext,
     renderRecentThreadMessageLines(conversationContext, messages)
   );
 }
-function queuedInstructionActor(queued) {
+function inboundMessageActor(queued) {
   const actor = getMessageActorIdentity(queued.message);
   const authorId = actor?.userId ?? parseActorUserId(queued.message.author.userId);
   const authorName = actor?.fullName ?? actor?.userName;
@@ -5676,7 +5670,7 @@ function queuedInstructionActor(queued) {
     ...slackTs ? { slackTs } : void 0
   };
 }
-function queuedInstructionProvenance(queued, teamId) {
+function inboundMessageProvenance(queued, teamId) {
   if (isResourceEventSlackMessage(queued.message)) {
     return contextProvenance;
   }
@@ -5703,12 +5697,57 @@ async function resolveChannelName(thread) {
     return void 0;
   }
 }
-function collectTurnAttachments(message, queuedMessages) {
+function collectAttachments(message, batchedMessages) {
   return [
-    ...(queuedMessages ?? []).flatMap((queued) => queued.message.attachments),
+    ...(batchedMessages ?? []).flatMap((queued) => queued.message.attachments),
     ...message.attachments
   ];
 }
+async function saveSteeringMessages(args) {
+  if (args.messages.length === 0) {
+    return true;
+  }
+  const state = getStateAdapter();
+  await state.connect();
+  const lock = await acquireActiveLock(state, args.conversationId);
+  if (!lock) {
+    return false;
+  }
+  try {
+    const projection = await loadConversationProjection({
+      conversationId: args.conversationId
+    });
+    const savedKeys = new Set(
+      projection.messages.map(steeringMessageKey).filter((key) => key !== void 0)
+    );
+    const missing = args.messages.filter((entry) => {
+      const key = steeringMessageKey(entry.message);
+      return key === void 0 || !savedKeys.has(key);
+    });
+    if (missing.length === 0) {
+      return true;
+    }
+    await commitMessages({
+      conversationId: args.conversationId,
+      messages: [
+        ...projection.messages,
+        ...missing.map((entry) => entry.message)
+      ],
+      provenance: [
+        ...projection.provenance,
+        ...missing.map((entry) => entry.provenance)
+      ]
+    });
+    return true;
+  } finally {
+    await state.releaseLock(lock);
+  }
+}
+
+// src/chat/providers/slack/turn.ts
+async function persistThreadRuntimeStateWithRetry(thread, patch) {
+  await persistWithRetry(() => persistThreadRuntimeState(thread, patch));
+}
 async function loadPiMessagesForTurn(args) {
   if (!args.conversationId) {
     return {};
@@ -5810,7 +5849,7 @@ function createSlackTurn(deps) {
             (queued) => ensureSlackMessageActorIdentity(
               queued.message,
               teamId,
-              deps.services.lookupSlackUser
+              lookupSlackUser
             )
           )
         );
@@ -5827,7 +5866,7 @@ function createSlackTurn(deps) {
           executionActor = await ensureSlackMessageActorIdentity(
             message,
             teamId,
-            deps.services.lookupSlackUser
+            lookupSlackUser
           );
           if (executionActor) {
             credentialContext = credentialContextForActor(executionActor);
@@ -5905,8 +5944,8 @@ function createSlackTurn(deps) {
             queuedMessages.map(async (queued) => {
               const attachments = queued.message.attachments;
               return {
-                actor: queuedInstructionActor(queued),
-                provenance: queuedInstructionProvenance(queued, teamId),
+                actor: inboundMessageActor(queued),
+                provenance: inboundMessageProvenance(queued, teamId),
                 text: queued.userText,
                 timestampMs: queued.message.metadata.dateSent.getTime(),
                 omittedImageAttachmentCount: !isVisionEnabled() && hasPotentialImageAttachment(attachments) ? countPotentialImageAttachments(attachments) : 0,
@@ -5922,51 +5961,11 @@ function createSlackTurn(deps) {
             })
           );
         };
-        const drainParkedInputToEventLog = async (pairs) => {
-          if (!conversationId || pairs.length === 0) {
-            return true;
-          }
-          const stateAdapter = getStateAdapter();
-          await stateAdapter.connect();
-          const lock = await acquireActiveLock(stateAdapter, conversationId);
-          if (!lock) {
-            return false;
-          }
-          try {
-            const projection = await loadConversationProjection({
-              conversationId
-            });
-            const appendedKeys = new Set(
-              projection.messages.map(parkedInputKey).filter((key) => key !== void 0)
-            );
-            const missing = pairs.filter((pair) => {
-              const key = parkedInputKey(pair.message);
-              return key === void 0 || !appendedKeys.has(key);
-            });
-            if (missing.length === 0) {
-              return true;
-            }
-            await commitMessages({
-              conversationId,
-              messages: [
-                ...projection.messages,
-                ...missing.map((pair) => pair.message)
-              ],
-              provenance: [
-                ...projection.provenance,
-                ...missing.map((pair) => pair.provenance)
-              ]
-            });
-            return true;
-          } finally {
-            await stateAdapter.releaseLock(lock);
-          }
-        };
-        const appendParkedTurnInput = async (parkedSessionId) => {
+        const saveMessagesForPausedTurn = async (pausedTurnId) => {
           if (!conversationId) {
             return true;
           }
-          const parkedMessages = [
+          const messagesForPausedTurn = [
             ...options.queuedMessages ?? [],
             {
               explicitMention: Boolean(
@@ -5977,18 +5976,21 @@ function createSlackTurn(deps) {
               userText: currentText.userText
             }
           ].filter(
-            // Redelivery of the parked turn's own message must not duplicate
+            // Redelivery of the paused Turn's own message must not duplicate
             // the prompt that already started the session.
-            (queued) => buildDeterministicTurnId(queued.message.id) !== parkedSessionId
+            (queued) => buildDeterministicTurnId(queued.message.id) !== pausedTurnId
           );
-          if (parkedMessages.length === 0) {
+          if (messagesForPausedTurn.length === 0) {
             return true;
           }
-          const parkedPairs = (await resolveSteeringMessages(parkedMessages)).map((steering) => ({
+          const steeringMessages = (await resolveSteeringMessages(messagesForPausedTurn)).map((steering) => ({
             message: buildSteeringPiMessage(steering),
             provenance: steering.provenance
           }));
-          return drainParkedInputToEventLog(parkedPairs);
+          return saveSteeringMessages({
+            conversationId,
+            messages: steeringMessages
+          });
         };
         if (preparedState.userMessageAlreadyReplied) {
           const deliveredMessage = [...preparedState.conversation.messages].reverse().find(
@@ -6005,16 +6007,16 @@ function createSlackTurn(deps) {
           return;
         }
         if (conversationId && activeTurnId) {
-          const pausedTurn = await deps.services.getPausedTurnRequest({
+          const pausedTurn = await deps.pausedTurns.get({
             conversationId,
             turnId: activeTurnId
           });
           if (pausedTurn) {
-            if (!await appendParkedTurnInput(pausedTurn.turnId)) {
+            if (!await saveMessagesForPausedTurn(pausedTurn.turnId)) {
               throw new TurnInputDeferredError();
             }
             try {
-              await deps.services.wakePausedTurn(pausedTurn);
+              await deps.pausedTurns.wake(pausedTurn);
             } catch (error) {
               logException(error, "agent.continue.schedule.failed", {
                 "app.ai.resume_session_version": pausedTurn.expectedVersion,
@@ -6039,6 +6041,7 @@ function createSlackTurn(deps) {
               await abandonTurnRecord({
                 conversationId,
                 turnId: activeTurnId,
+                // TODO(dcramer): Rename this legacy text in Slack and Conversation API Turn records together.
                 errorMessage: "Auth-parked session superseded by a new user message"
               });
               markTurnClosed({
@@ -6108,7 +6111,7 @@ function createSlackTurn(deps) {
           nextTurnId: turnId
         });
         if (conversationId && preparedState.userMessageId) {
-          await deps.services.turnLifecycle.start({
+          await deps.turnLifecycle.start({
             conversationId,
             createdAtMs: Date.now(),
             inputMessageIds: [
@@ -6168,7 +6171,7 @@ function createSlackTurn(deps) {
         if (actor?.userName) {
           setTags({ userName: actor.userName });
         }
-        const turnAttachments = collectTurnAttachments(
+        const turnAttachments = collectAttachments(
           message,
           options.queuedMessages
         );
@@ -6197,7 +6200,6 @@ function createSlackTurn(deps) {
         let runResultHandled = false;
         let assistantMessageDelivered = false;
         let acceptedDeliveryId;
-        let lifecycleTerminalized = false;
         let turnCompletionNotified = false;
         const recordDispatchOutcome = async (dispatchOutcome, state) => {
           const dispatchId = options.execution?.dispatch?.id;
@@ -6222,7 +6224,6 @@ function createSlackTurn(deps) {
         };
         let turnWakeError;
         let boundaryFailureCode = "agent_run_failed";
-        let finalizedFailureEventId;
         let terminalDispatchFailureOutcome;
         const notifyTurnCompleted = async () => {
           if (turnCompletionNotified) {
@@ -6354,7 +6355,7 @@ function createSlackTurn(deps) {
           });
           let piMessages = loadedPiMessages.piMessages;
           if (conversationId && loadedPiMessages.canCompact && piMessages?.length) {
-            const compaction = await deps.services.contextCompactor.maybeCompact({
+            const compaction = await deps.contextCompactor.maybeCompact({
               conversation: preparedState.conversation,
               conversationContext: preparedState.conversationContext,
               conversationId,
@@ -6379,7 +6380,7 @@ function createSlackTurn(deps) {
             }
           }
           const hasDurablePromptHistory = Boolean(piMessages?.length);
-          const batchedInstructions = (await resolveSteeringMessages(
+          const batchedSteeringMessages = (await resolveSteeringMessages(
             (options.queuedMessages ?? []).filter(
               (queued) => queued.explicitMention
             )
@@ -6387,20 +6388,23 @@ function createSlackTurn(deps) {
             message: buildSteeringPiMessage(steering),
             provenance: steering.provenance
           }));
-          if (!await drainParkedInputToEventLog(batchedInstructions)) {
+          if (!await saveSteeringMessages({
+            conversationId,
+            messages: batchedSteeringMessages
+          })) {
             shouldPersistFailureState = false;
             throw new TurnInputDeferredError();
           }
-          if (batchedInstructions.length > 0) {
+          if (batchedSteeringMessages.length > 0) {
             const presentKeys = new Set(
-              (piMessages ?? []).map(parkedInputKey).filter((key) => key !== void 0)
+              (piMessages ?? []).map(steeringMessageKey).filter((key) => key !== void 0)
             );
-            const newlyBatched = batchedInstructions.map((entry) => entry.message).filter((batchedMessage) => {
-              const key = parkedInputKey(batchedMessage);
+            const newSteeringMessages = batchedSteeringMessages.map((entry) => entry.message).filter((batchedMessage) => {
+              const key = steeringMessageKey(batchedMessage);
               return key === void 0 || !presentKeys.has(key);
             });
-            if (newlyBatched.length > 0) {
-              piMessages = [...piMessages ?? [], ...newlyBatched];
+            if (newSteeringMessages.length > 0) {
+              piMessages = [...piMessages ?? [], ...newSteeringMessages];
             }
           }
           status.update();
@@ -6420,7 +6424,7 @@ function createSlackTurn(deps) {
           const toolChannelId = channelId;
           const activeInstructionAuthorId = actor?.userId ?? parseActorUserId(message.author.userId);
           const activeInstructionAuthorName = actor?.fullName ?? actor?.userName;
-          const promptConversationContext = appendRecentThreadMessagesToContext(
+          const promptConversationContext = appendRecentMessagesToContext(
             preparedState.conversationContext,
             options.queuedMessages ?? []
           );
@@ -6435,7 +6439,7 @@ function createSlackTurn(deps) {
             );
             return acceptedMessages ?? await resolveSteeringMessages(drained);
           } : void 0;
-          const outcome = await deps.services.agentRunner.run({
+          const run = {
             conversationId,
             turnId,
             ...runId ? { runId } : void 0,
@@ -6507,7 +6511,121 @@ function createSlackTurn(deps) {
                 });
               }
             }
-          });
+          };
+          let completedResult;
+          const saveResult = async (result) => {
+            let finalResult = result;
+            setTags({ modelId: finalResult.diagnostics.modelId });
+            const diagnosticsAttributes = getAgentTurnDiagnosticsAttributes(finalResult);
+            setSpanAttributes(diagnosticsAttributes);
+            let failureEventId;
+            let failureReason;
+            if (finalResult.diagnostics.outcome !== "success") {
+              const finalized = finalizeFailedTurnReplyWithEvent({
+                reply: finalResult,
+                logException
+              });
+              finalResult = finalized.reply;
+              failureEventId = finalized.eventId;
+              failureReason = finalized.failureReason;
+              await deliverAssistantMessage(finalResult.text);
+            }
+            const turnResult = finalResult.diagnostics.outcome === "success" ? { outcome: "completed" } : {
+              errorMessage: finalResult.diagnostics.errorMessage ?? `Agent turn ended with ${finalResult.diagnostics.outcome}.`,
+              outcome: "failed"
+            };
+            runResultHandled = true;
+            shouldPersistFailureState = false;
+            boundaryFailureCode = "agent_run_failed";
+            const completedState = buildDeliveredTurnStatePatch({
+              conversation: preparedState.conversation,
+              reply: finalResult,
+              sessionId: turnId,
+              userMessageId: preparedState.userMessageId
+            });
+            let saveFailed = false;
+            let saveFailureEventId;
+            try {
+              if (conversationId && finalResult.piMessages?.length) {
+                await saveTurnCheckpoint({
+                  mode: "completed",
+                  channelName,
+                  conversationId,
+                  turnId,
+                  durationMs: finalResult.diagnostics.durationMs,
+                  usage: finalResult.diagnostics.usage,
+                  destination,
+                  destinationVisibility,
+                  source,
+                  sliceId: 1,
+                  dispatchOutcome: finalResult.diagnostics.outcome === "success" ? "completed" : "failed",
+                  ...options.execution?.dispatch && turnResult.errorMessage ? { errorMessage: turnResult.errorMessage } : void 0,
+                  ...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : void 0,
+                  messages: finalResult.piMessages,
+                  actor: executionActor,
+                  surface: options.execution?.surface ?? "slack",
+                  dispatchId: options.execution?.dispatch?.id
+                });
+              } else if (conversationId) {
+                await recordTurnSummary({
+                  channelName,
+                  conversationId,
+                  cumulativeDurationMs: finalResult.diagnostics.durationMs,
+                  cumulativeUsage: finalResult.diagnostics.usage,
+                  turnId,
+                  sliceId: 1,
+                  startedAtMs: message.metadata.dateSent.getTime(),
+                  state: "completed",
+                  actor: executionActor,
+                  destination,
+                  destinationVisibility,
+                  source,
+                  surface: options.execution?.surface ?? "slack",
+                  dispatchId: options.execution?.dispatch?.id,
+                  dispatchOutcome: finalResult.diagnostics.outcome === "success" ? "completed" : "failed",
+                  ...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : void 0,
+                  traceId: getActiveTraceId()
+                });
+              }
+              await persistWithRetry(
+                () => persistConversationMessages({
+                  conversation: completedState.conversation,
+                  conversationId
+                })
+              );
+              await persistThreadRuntimeStateWithRetry(thread, completedState);
+            } catch (saveError) {
+              saveFailed = true;
+              saveFailureEventId = logException(
+                saveError,
+                "slack.reply.post_delivery_commit.failed",
+                messageTs ? { "messaging.message.id": messageTs } : {}
+              );
+            }
+            preparedState.conversation = completedState.conversation;
+            persistedAtLeastOnce = true;
+            options.onTurnOutcome?.(turnResult);
+            completedResult = finalResult;
+            if (saveFailed) {
+              return {
+                ...saveFailureEventId ? { eventId: saveFailureEventId } : void 0,
+                failureCode: "persistence_failed",
+                outcome: "failed"
+              };
+            }
+            if (finalResult.diagnostics.outcome === "success") {
+              return {
+                outcome: assistantMessageDelivered ? "success" : "no_reply"
+              };
+            }
+            return {
+              ...failureEventId ? { eventId: failureEventId } : void 0,
+              failureCode: "model_execution_failed",
+              ...failureReason ? { failureReason } : void 0,
+              outcome: "failed"
+            };
+          };
+          const outcome = await deps.executeTurn(run, saveResult);
           if (outcome.status === "awaiting_auth") {
             await recordDispatchOutcome("blocked", "failed");
             options.onTurnOutcome?.({ outcome: "blocked" });
@@ -6530,14 +6648,13 @@ function createSlackTurn(deps) {
                 conversation: preparedState.conversation
               });
               if (conversationId) {
-                await deps.services.turnLifecycle.fail({
+                await deps.turnLifecycle.fail({
                   conversationId,
                   createdAtMs: Date.now(),
                   ...authFailureEventId ? { eventId: authFailureEventId } : void 0,
                   failureCode: "agent_run_failed",
                   turnId
                 });
-                lifecycleTerminalized = true;
               }
               persistedAtLeastOnce = true;
               shouldPersistFailureState = false;
@@ -6570,7 +6687,7 @@ function createSlackTurn(deps) {
               );
             }
             try {
-              await deps.services.wakePausedTurn({
+              await deps.pausedTurns.wake({
                 conversationId,
                 destination,
                 turnId,
@@ -6588,134 +6705,26 @@ function createSlackTurn(deps) {
             }
             return;
           }
-          let reply = outcome.result;
-          setTags({ modelId: reply.diagnostics.modelId });
-          const diagnosticsAttributes = getAgentTurnDiagnosticsAttributes(reply);
-          setSpanAttributes(diagnosticsAttributes);
-          if (reply.diagnostics.outcome !== "success") {
-            const finalized = finalizeFailedTurnReplyWithEvent({
-              reply,
-              logException
-            });
-            reply = finalized.reply;
-            finalizedFailureEventId = finalized.eventId;
-            await deliverAssistantMessage(reply.text);
-          }
-          const turnResult = reply.diagnostics.outcome === "success" ? { outcome: "completed" } : {
-            errorMessage: reply.diagnostics.errorMessage ?? `Agent turn ended with ${reply.diagnostics.outcome}.`,
-            outcome: "failed"
-          };
-          runResultHandled = true;
-          shouldPersistFailureState = false;
-          boundaryFailureCode = "agent_run_failed";
-          const completedState = buildDeliveredTurnStatePatch({
-            conversation: preparedState.conversation,
-            reply,
-            sessionId: turnId,
-            userMessageId: preparedState.userMessageId
-          });
-          try {
-            if (conversationId && reply.piMessages?.length) {
-              await saveTurnCheckpoint({
-                mode: "completed",
-                channelName,
-                conversationId,
-                turnId,
-                durationMs: reply.diagnostics.durationMs,
-                usage: reply.diagnostics.usage,
-                destination,
-                destinationVisibility,
-                source,
-                sliceId: 1,
-                dispatchOutcome: reply.diagnostics.outcome === "success" ? "completed" : "failed",
-                ...options.execution?.dispatch && turnResult.errorMessage ? { errorMessage: turnResult.errorMessage } : void 0,
-                ...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : void 0,
-                messages: reply.piMessages,
-                actor: executionActor,
-                surface: options.execution?.surface ?? "slack",
-                dispatchId: options.execution?.dispatch?.id
-              });
-            } else if (conversationId) {
-              await recordTurnSummary({
-                channelName,
-                conversationId,
-                cumulativeDurationMs: reply.diagnostics.durationMs,
-                cumulativeUsage: reply.diagnostics.usage,
-                turnId,
-                sliceId: 1,
-                startedAtMs: message.metadata.dateSent.getTime(),
-                state: "completed",
-                actor: executionActor,
-                destination,
-                destinationVisibility,
-                source,
-                surface: options.execution?.surface ?? "slack",
-                dispatchId: options.execution?.dispatch?.id,
-                dispatchOutcome: reply.diagnostics.outcome === "success" ? "completed" : "failed",
-                ...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : void 0,
-                traceId: getActiveTraceId()
-              });
-            }
-            await persistWithRetry(
-              () => persistConversationMessages({
-                conversation: completedState.conversation,
-                conversationId
-              })
-            );
-            await persistThreadRuntimeStateWithRetry(thread, completedState);
-          } catch (commitError) {
-            const persistenceEventId = logException(
-              commitError,
-              "slack.reply.post_delivery_commit.failed",
-              messageTs ? { "messaging.message.id": messageTs } : {}
-            );
-            if (conversationId && !lifecycleTerminalized) {
-              await deps.services.turnLifecycle.fail({
-                conversationId,
-                createdAtMs: Date.now(),
-                ...persistenceEventId ? { eventId: persistenceEventId } : void 0,
-                failureCode: "persistence_failed",
-                turnId
-              });
-              lifecycleTerminalized = true;
-            }
-          }
-          preparedState.conversation = completedState.conversation;
-          persistedAtLeastOnce = true;
-          options.onTurnOutcome?.(turnResult);
-          if (!lifecycleTerminalized && conversationId) {
-            if (reply.diagnostics.outcome === "success") {
-              await deps.services.turnLifecycle.complete({
-                conversationId,
-                createdAtMs: Date.now(),
-                outcome: assistantMessageDelivered ? "success" : "no_reply",
-                turnId
-              });
-            } else {
-              await deps.services.turnLifecycle.fail({
-                conversationId,
-                createdAtMs: Date.now(),
-                ...finalizedFailureEventId ? { eventId: finalizedFailureEventId } : void 0,
-                failureCode: "model_execution_failed",
-                turnId
-              });
-            }
-            lifecycleTerminalized = true;
+          if (!completedResult) {
+            throw new Error("Completed Turn did not save a result");
           }
           if (shouldEmitDevAgentTrace()) {
             logInfo("agent.turn.completed", {
-              "app.ai.outcome": reply.diagnostics.outcome,
-              "app.ai.tool_call_count": reply.diagnostics.toolCalls.length,
-              "app.ai.tool_error_results": reply.diagnostics.toolErrorCount
+              "app.ai.outcome": completedResult.diagnostics.outcome,
+              "app.ai.tool_call_count": completedResult.diagnostics.toolCalls.length,
+              "app.ai.tool_error_results": completedResult.diagnostics.toolErrorCount
             });
           }
           await notifyTurnCompleted();
-          if (reply.diagnostics.outcome === "success" && conversationId) {
+          if (completedResult.diagnostics.outcome === "success" && conversationId) {
             try {
-              await deps.services.scheduleSessionCompletedPluginTasks({
-                conversationId,
-                sessionId: turnId
-              });
+              await scheduleSessionCompletedPluginTasks(
+                {
+                  conversationId,
+                  sessionId: turnId
+                },
+                deps.sendPluginTask ? { send: deps.sendPluginTask } : void 0
+              );
             } catch (error) {
               logException(
                 error,
@@ -6754,8 +6763,9 @@ function createSlackTurn(deps) {
             shouldPersistFailureState = true;
           }
           shouldPersistFailureState = true;
-          const classifiedFailure = getConversationTurnBoundaryError(error);
-          const failureCause = classifiedFailure?.cause ?? error;
+          const runFailure = error instanceof AgentRunError ? error.cause : error;
+          const classifiedFailure = getConversationTurnBoundaryError(runFailure);
+          const failureCause = classifiedFailure?.cause ?? runFailure;
           if (failureCause instanceof AuthorizationFlowDisabledError || failureCause instanceof PluginCredentialFailureError) {
             terminalDispatchFailureOutcome = "blocked";
           }
@@ -7209,6 +7219,9 @@ function upsertSkippedConversationMessage(conversation, args) {
 }
 function createSlackRuntime(options) {
   const services = createJuniorRuntimeServices(options.services);
+  const turnLifecycle = new ConversationTurnLifecycleService(
+    getConversationEventStore()
+  );
   const prepareTurnState = createPrepareTurnState({
     compactConversationIfNeeded: services.conversationMemory.compactConversationIfNeeded,
     hydrateConversationVisionContext: services.visionContext.hydrateConversationVisionContext,
@@ -7224,34 +7237,29 @@ function createSlackRuntime(options) {
           (message) => ensureSlackMessageActorIdentity(
             message,
             destination.teamId,
-            services.replyExecutor.lookupSlackUser
+            lookupSlackUser
           )
         )
       );
     }
   });
   const executeSlackTurn = createSlackTurn({
+    contextCompactor: services.contextCompactor,
+    executeTurn: services.executeTurn,
     getSlackAdapter: options.getSlackAdapter,
+    pausedTurns: options.pausedTurns ?? createPausedTurns(),
     prepareTurnState,
     resolveUserAttachments: services.visionContext.resolveUserAttachments,
-    services: services.replyExecutor
+    sendPluginTask: options.sendPluginTask,
+    turnLifecycle
   });
   const runtime = createSlackTurnRuntime({
     assistantUserName: botConfig.userName,
     cancelEventSubscriptions: cancelSubscriptions,
+    getBotUserId: () => options.getSlackAdapter().botUserId,
     modelId: defaultModelId(botConfig),
     now: options.now ?? (() => Date.now()),
-    getThreadId,
-    getChannelId,
-    getRunId,
-    stripLeadingBotMention: (text, stripOptions) => stripLeadingBotMention(text, {
-      ...stripOptions,
-      botUserId: options.getSlackAdapter().botUserId
-    }),
-    withSpan,
-    logWarn,
-    logException,
-    failConversationTurn: (input) => services.replyExecutor.turnLifecycle.fail(input),
+    failConversationTurn: (input) => turnLifecycle.fail(input),
     prepareTurnState,
     persistPreparedState: async ({ thread, preparedState }) => {
       await persistThreadState(thread, {
@@ -7552,8 +7560,7 @@ async function runPausedTurnInContext(payload, options, runOptions) {
     "Paused turn"
   );
   const wakePausedTurn2 = options.wakePausedTurn ?? wakePausedTurn;
-  const resumeTurn = options.resumeTurn ?? resumeSlackTurn;
-  return await resumeTurn({
+  return await resumeSlackTurn({
     messageText: "",
     conversationId: payload.conversationId,
     turnId: payload.turnId,
@@ -7562,7 +7569,7 @@ async function runPausedTurnInContext(payload, options, runOptions) {
     lockKey: payload.conversationId,
     // Queue continue runs under the conversation work lease already.
     ownsConversationLease: true,
-    agentRunner: options.agentRunner,
+    executeTurn: async (run, saveResult, timeoutMs) => await executeTurn(options.agentRunner, run, saveResult, timeoutMs),
     scheduleSessionCompletedPluginTasks: options.scheduleSessionCompletedPluginTasks,
     beforeStart: async () => {
       let turn;
@@ -7650,7 +7657,7 @@ async function runPausedTurnInContext(payload, options, runOptions) {
           messageTs: getTurnUserSlackMessageTs(userMessage),
           inputMessageIds: [userMessage.id],
           initialStatus: latestReportedProgress(turnMessages),
-          replyContext: {
+          run: {
             instruction: {
               ...conversationContext ? { context: conversationContext } : void 0,
               // Attachment fields come from the turn user message context helper.
@@ -7888,24 +7895,18 @@ async function runNextPausedTurnInContext(conversationId, options, runOptions) {
 // src/chat/app/conversation-work.ts
 function createConversationWork(options) {
   const apiTurnCancellation = createApiTurnCancellation();
-  const services = {
-    ...options.services,
-    replyExecutor: {
-      ...options.services?.replyExecutor,
-      agentRunner: options.agentRunner,
-      getPausedTurnRequest: options.services?.replyExecutor?.getPausedTurnRequest ?? (async (request) => await getPausedTurnRequest({
-        ...request,
-        conversationStore: options.conversationStore
-      })),
-      wakePausedTurn: options.services?.replyExecutor?.wakePausedTurn ?? (async (request) => await wakePausedTurn(request, {
-        queue: options.queue,
-        state: options.state
-      }))
-    }
-  };
+  const pausedTurns = createPausedTurns({
+    conversationStore: options.conversationStore,
+    queue: options.queue,
+    ...options.state ? { state: options.state } : void 0
+  });
   const runtime = createSlackRuntime({
     getSlackAdapter: options.getSlackAdapter,
-    services
+    pausedTurns,
+    services: {
+      ...options.services,
+      agentRunner: options.agentRunner
+    }
   });
   const slackWorker = createSlackConversationWorker({
     getSlackAdapter: options.getSlackAdapter,
@@ -7914,8 +7915,7 @@ function createConversationWork(options) {
       conversationId,
       {
         agentRunner: options.agentRunner,
-        scheduleSessionCompletedPluginTasks: services.replyExecutor?.scheduleSessionCompletedPluginTasks,
-        wakePausedTurn: services.replyExecutor?.wakePausedTurn
+        wakePausedTurn: pausedTurns.wake
       },
       runOptions
     ),
@@ -7930,8 +7930,7 @@ function createConversationWork(options) {
           agentRunner: options.agentRunner,
           inputMessageIds: [getDispatchInputMessageId(dispatch2.id)],
           routingContext: buildDispatchRoutingContext(dispatch2),
-          scheduleSessionCompletedPluginTasks: services.replyExecutor?.scheduleSessionCompletedPluginTasks,
-          wakePausedTurn: services.replyExecutor?.wakePausedTurn
+          wakePausedTurn: pausedTurns.wake
         },
         { shouldYield: hooks.shouldYield }
       );
@@ -7947,11 +7946,10 @@ function createConversationWork(options) {
     conversationStore: options.conversationStore,
     queue: options.queue,
     run: routeApiTurnWork({
-      apiTurnWorker: createApiTurnWorker({
-        agentRunner: options.agentRunner,
-        cancellation: apiTurnCancellation,
-        turnLifecycle: services.replyExecutor?.turnLifecycle
-      }),
+      apiTurnWorker: createApiTurnWorker(
+        options.agentRunner,
+        apiTurnCancellation
+      ),
       fallbackWorker: routeAgentInvocationWork({
         invocationWorker: createAgentInvocationWorker(options.agentRunner),
         fallbackWorker: providerWorker
@@ -8477,9 +8475,25 @@ var textContentBlockSchema = z5.object({
   text: z5.string(),
   type: z5.literal("text")
 }).strict();
+var resourceLinkContentBlockSchema = z5.object({
+  _meta: metaSchema.optional(),
+  annotations: annotationsSchema.nullable().optional(),
+  description: z5.string().nullable().optional(),
+  mimeType: z5.string().nullable().optional(),
+  name: z5.string(),
+  size: z5.number().finite().nullable().optional(),
+  title: z5.string().nullable().optional(),
+  type: z5.literal("resource_link"),
+  uri: z5.string()
+}).strict();
 var promptParamsSchema = z5.object({
   _meta: metaSchema.optional(),
-  prompt: z5.array(textContentBlockSchema),
+  prompt: z5.array(
+    z5.discriminatedUnion("type", [
+      textContentBlockSchema,
+      resourceLinkContentBlockSchema
+    ])
+  ),
   sessionId: acpSessionIdSchema
 }).strict();
 var cancelParamsSchema = z5.object({
@@ -9619,15 +9633,30 @@ function rejectUnsupportedMcpServers(mcpServers) {
     );
   }
 }
+function resourceLinkText(block) {
+  return [
+    "Resource link:",
+    `Name: ${block.name}`,
+    `URI: ${block.uri}`,
+    ...block.title ? [`Title: ${block.title}`] : [],
+    ...block.description ? [`Description: ${block.description}`] : [],
+    ...block.mimeType ? [`MIME type: ${block.mimeType}`] : [],
+    ...block.size !== void 0 && block.size !== null ? [`Size: ${block.size} bytes`] : []
+  ].join("\n");
+}
 function promptText(prompt) {
   if (prompt.length === 0) {
     throw acp4.RequestError.invalidParams(
       { field: "prompt" },
-      "Junior accepts one or more text blocks only"
+      "Junior accepts one or more text or resource link blocks"
     );
   }
   const blocks = [];
   for (const block of prompt) {
+    if (block.type === "resource_link") {
+      blocks.push(resourceLinkText(block));
+      continue;
+    }
     if (!block.text.trim()) {
       throw acp4.RequestError.invalidParams(
         { field: "prompt" },
@@ -10710,7 +10739,7 @@ async function createApp(options) {
     tracePropagation
   });
   const runtimeServiceOverrides = {
-    replyExecutor: { agentRunner },
+    agentRunner,
     sandbox: { tracePropagation }
   };
   let conversationWorkOptions;