@sentry/junior 0.144.0 → 0.145.0

package/dist/app.js

@@ -1,26 +1,25 @@
 import {
   processConversationWork
-} from "./chunk-4X5KM7Z6.js";
+} from "./chunk-RUSS62EN.js";
 import {
   bindSpawnAgent
-} from "./chunk-GKA74DRA.js";
+} from "./chunk-LVVSIMBB.js";
 import {
   createAgentInvocationWorker,
   enqueueAgentInvocation,
   listPendingAgentInvocationMailboxAppends,
   routeAgentInvocationWork
-} from "./chunk-PELZ2ZSY.js";
+} from "./chunk-HISR3DTV.js";
 import {
   GET as GET2,
   GET2 as GET3,
-  ResumeTurnBusyError,
   buildAuthPauseResponse,
   buildSlackOutputMessage,
   createSlackAdapterAssistantStatusSession,
   getAssistantThreadContext,
-  getAwaitingAgentContinueRequest,
   getChannelId,
   getMessageTs,
+  getPausedTurnRequest,
   getRunId,
   getSlackApiErrorCode,
   getSlackErrorObservabilityAttributes,
@@ -33,13 +32,13 @@ import {
   receiveLocalOAuthCredential,
   resumeSlackTurn,
   runWithTurnRequestDeadline,
-  scheduleAgentContinue,
   sendSlackReply,
   shouldKeepProcessingReactionForToolInvocation,
   splitSlackReplyText,
   startSlackProcessingReaction,
-  stripLeadingBotMention
-} from "./chunk-QUZJDAQQ.js";
+  stripLeadingBotMention,
+  wakePausedTurn
+} from "./chunk-2XET6PKP.js";
 import "./chunk-FA6POGLH.js";
 import {
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
@@ -51,7 +50,7 @@ import {
   isInvalidConversationRecordError,
   listActiveConversationIds,
   removeActiveConversation
-} from "./chunk-HD6BHR25.js";
+} from "./chunk-HLOUZC5C.js";
 import {
   buildConversationContext,
   buildDeliveredTurnStatePatch,
@@ -90,8 +89,9 @@ import {
   requireTurnFailureEventId,
   resolveTurnSessionRouting,
   scheduleSessionCompletedPluginTasks,
+  turnHasReply,
   upsertConversationMessage
-} from "./chunk-W7JFV5SB.js";
+} from "./chunk-QJBDABQA.js";
 import {
   ConversationTurnLifecycleService
 } from "./chunk-Q6QZTTLS.js";
@@ -100,21 +100,21 @@ import {
   conversationVisibilityFromSlackChannelType,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext
-} from "./chunk-SHEEZSLY.js";
+} from "./chunk-PJ4NMVQB.js";
 import "./chunk-4CODA7P5.js";
 import {
   recordTaskExecution
-} from "./chunk-WSOLZJJS.js";
+} from "./chunk-EIX2LQ6L.js";
 import "./chunk-UTL3MHPC.js";
 import {
   getVercelConversationWorkQueue,
   resolveConversationWorkQueueTopic,
   verifyConversationQueueMessage
-} from "./chunk-KCBZSJRU.js";
+} from "./chunk-WR76IVA5.js";
 import {
   conversationQueueMessageSchema,
   isConversationQueueMessageRejectedError
-} from "./chunk-IUFM5JWV.js";
+} from "./chunk-JAL3CH4G.js";
 import {
   PLUGIN_TASK_QUEUE_TOPIC,
   createVercelQueueClient,
@@ -123,7 +123,7 @@ import {
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-LDWNYCZ6.js";
+} from "./chunk-WF5HVH3M.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -156,18 +156,18 @@ import {
   setConfigDefaults,
   shouldEmitDevAgentTrace,
   shouldPropagateSandboxEgressTrace
-} from "./chunk-SSDTQDYQ.js";
+} from "./chunk-64SBYW2O.js";
 import {
   AuthorizationFlowDisabledError,
   PluginCredentialFailureError
-} from "./chunk-DVO5VKYQ.js";
+} from "./chunk-B46ZMVOV.js";
 import "./chunk-DIB4GX3G.js";
 import {
   createUserTokenStore,
   deleteMcpAuthSessionsForUserProvider,
   deleteMcpServerSessionId,
   deleteMcpStoredOAuthCredentials
-} from "./chunk-BBCWYXHB.js";
+} from "./chunk-I47UGQPJ.js";
 import {
   RetryableDeliveryError
 } from "./chunk-R776HKPK.js";
@@ -175,16 +175,16 @@ import {
   formatProviderLabel,
   postSlackMessage,
   startOAuthFlow
-} from "./chunk-KQBXT5B7.js";
+} from "./chunk-FUBRJA5F.js";
 import {
   estimateTextTokens
-} from "./chunk-CNTWB2SM.js";
+} from "./chunk-VTDMB7XX.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
   TurnInputCommitLostError,
   TurnInputDeferredError,
-  abandonAgentTurnSessionRecord,
+  abandonTurnRecord,
   buildDeterministicAssistantMessageId,
   buildDeterministicTurnId,
   clearPendingAuth,
@@ -192,24 +192,26 @@ import {
   coerceThreadConversationState,
   commitAcceptedReply,
   commitMessages,
-  completeDeliveredTurn,
-  failAgentTurnSessionRecord,
-  getAgentTurnSessionRecord,
-  getAgentTurnSessionRecordForResume,
+  completeTurnRecord,
+  failTurnRecord,
   getAssistantReplyText,
   getChannelConfigurationService,
   getChannelConfigurationServiceById,
   getConversationTurnBoundaryError,
   getPersistedSandboxState,
   getPersistedThreadState,
+  getTurnRecord,
+  getTurnRecordForResume,
   hydrateConversationMessages,
   isCooperativeTurnYieldError,
   isTurnInputCommitLostError,
   isTurnInputDeferredError,
-  listAgentTurnSessionSummariesForConversation,
+  listTurnSummaries,
   loadConversationProjection,
   loadProjection,
+  loadTurnCheckpoint,
   markTurnClosed,
+  markTurnCompleted,
   markTurnFailed,
   mergeArtifactsState,
   persistConversationMessageSummaries,
@@ -218,12 +220,12 @@ import {
   persistThreadState,
   persistThreadStateById,
   persistWithRetry,
-  persistYieldSessionRecord,
-  recordAgentTurnSessionSummary,
+  recordTurnSummary,
+  saveTurnCheckpoint,
   startActiveTurn,
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages
-} from "./chunk-BEGGFVFR.js";
+} from "./chunk-ZIAMN2UW.js";
 import "./chunk-3Y47VMHV.js";
 import "./chunk-HUO3UTAQ.js";
 import {
@@ -233,17 +235,17 @@ import {
 import {
   getSandboxResourceConfig,
   setSandboxResourceConfig
-} from "./chunk-7KAW7UF4.js";
+} from "./chunk-GUWLDMGF.js";
 import {
   createSchedulerSqlStore,
   findMatchingEventTasks,
   logScheduledTaskRunSkipped,
   scheduledTaskRunAttributes
-} from "./chunk-ZZCTGAIT.js";
+} from "./chunk-YD54Q45G.js";
 import {
   parseSlackThreadId
-} from "./chunk-PKH6762I.js";
-import "./chunk-54JMYQYS.js";
+} from "./chunk-DXEQAIUV.js";
+import "./chunk-ZYAJMESY.js";
 import "./chunk-HLXXQI5Q.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
@@ -263,7 +265,7 @@ import {
   verifyEventTaskCredentialSubject,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-44RJWAND.js";
+} from "./chunk-ZIMRGFYL.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -273,7 +275,7 @@ import {
   normalizeSlackConversationId,
   runWithSlackInstallationToken,
   runWithWorkspaceTeamId
-} from "./chunk-QE3TICD4.js";
+} from "./chunk-TZRXYWRE.js";
 import {
   contextProvenance,
   createSlackDestination,
@@ -285,20 +287,19 @@ import {
   requireSlackDestination,
   withConversationEventLock,
   withConversationMutationLock
-} from "./chunk-SBZP2J5Q.js";
+} from "./chunk-2UH3JI64.js";
 import {
   juniorAgentBindings,
   juniorAgentInvocations,
   juniorConversationEvents,
   juniorConversations
-} from "./chunk-HNO2E5WB.js";
-import {
-  sleep
-} from "./chunk-EM225ITJ.js";
+} from "./chunk-27TEJTZO.js";
+import "./chunk-EM225ITJ.js";
 import {
   acquireActiveLock,
-  getStateAdapter
-} from "./chunk-UDQMY6RS.js";
+  getStateAdapter,
+  withActiveLock
+} from "./chunk-QUG4JSZK.js";
 import {
   STANDARD_MODEL_PROFILE,
   botConfig,
@@ -316,16 +317,16 @@ import {
   modelIdForProfile,
   setSlackReactionConfig,
   standardModelId
-} from "./chunk-3GU4PWA3.js";
+} from "./chunk-XFKIRN3Q.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
-import "./chunk-STFCL3K4.js";
-import "./chunk-SUK7NC5A.js";
+import "./chunk-JTGS3ZZE.js";
+import "./chunk-5PNPQYTO.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-ZF3N3JD6.js";
-import "./chunk-A67GZN73.js";
+} from "./chunk-SIN3MXH6.js";
+import "./chunk-CD2XFGYQ.js";
 import {
   credentialContextForActor
 } from "./chunk-RUIXF3YQ.js";
@@ -357,7 +358,7 @@ import {
   withContext,
   withLogContext,
   withSpan
-} from "./chunk-RIFJUJSI.js";
+} from "./chunk-2LWPFSB4.js";
 import {
   continueTrace
 } from "./chunk-6GWA276C.js";
@@ -365,10 +366,10 @@ import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
 import {
   JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE
-} from "./chunk-WTX2RFJG.js";
+} from "./chunk-DS3J6WGY.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-I44JB7HQ.js";
+} from "./chunk-GDV5LXRA.js";
 import "./chunk-MLKGABMK.js";
 
 // src/app.ts
@@ -533,12 +534,10 @@ async function resolveAgentDispatchId(context) {
   if (context.attempt.messages.length > 0) {
     return void 0;
   }
-  const summaries = await listAgentTurnSessionSummariesForConversation(
-    context.conversationId
-  );
+  const summaries = await listTurnSummaries(context.conversationId);
   const activeDispatchIds = new Set(
     summaries.filter(
-      (summary) => (summary.state === "awaiting_resume" || summary.state === "running") && Boolean(summary.dispatchId)
+      (summary) => (summary.state === "paused" || summary.state === "running") && Boolean(summary.dispatchId)
     ).map((summary) => summary.dispatchId).filter((id) => Boolean(id))
   );
   if (activeDispatchIds.size > 1) {
@@ -585,8 +584,10 @@ function createAgentDispatchWorkRouter(options) {
 async function readDispatchTurnResult(dispatch2) {
   const conversationId = getDispatchConversationId(dispatch2);
   const turnId = getDispatchTurnId(dispatch2.id);
-  const storedSession = await getAgentTurnSessionRecord(conversationId, turnId);
-  const summary = (await listAgentTurnSessionSummariesForConversation(conversationId)).find((candidate) => candidate.sessionId === turnId);
+  const storedSession = await getTurnRecord(conversationId, turnId);
+  const summary = (await listTurnSummaries(conversationId)).find(
+    (candidate) => candidate.turnId === turnId
+  );
   const session = storedSession ?? summary;
   const dispatchOutcome = summary?.dispatchOutcome ?? storedSession?.dispatchOutcome;
   const resultMessageTs = summary?.resultMessageId ?? storedSession?.resultMessageId;
@@ -607,7 +608,7 @@ async function readDispatchTurnResult(dispatch2) {
   if (!session) {
     return {};
   }
-  if (session.state === "awaiting_resume") {
+  if (session.state === "paused") {
     return { hasResumableRun: true, outcome: "awaiting_resume" };
   }
   if (session.state === "running") {
@@ -652,15 +653,15 @@ function getDispatchBlockingError(error) {
 async function persistBlockedDispatchTurn(dispatch2, error) {
   const conversationId = getDispatchConversationId(dispatch2);
   const sessionId = getDispatchTurnId(dispatch2.id);
-  const session = await getAgentTurnSessionRecord(conversationId, sessionId);
-  await recordAgentTurnSessionSummary({
+  const session = await getTurnRecord(conversationId, sessionId);
+  await recordTurnSummary({
     actor: dispatch2.actor,
     conversationId,
     destination: dispatch2.destination,
     destinationVisibility: dispatch2.destinationVisibility,
     dispatchId: dispatch2.id,
     dispatchOutcome: "blocked",
-    sessionId,
+    turnId: sessionId,
     sliceId: session?.sliceId ?? 1,
     source: dispatch2.source,
     state: "failed",
@@ -880,7 +881,9 @@ async function recoverConversationWork(args) {
           }
           if (recovery === "stopped") {
             logException(
-              new Error("Conversation work stopped after repeated failed attempts"),
+              new Error(
+                "Conversation work stopped after repeated failed attempts"
+              ),
               "conversation.work.retry.exhausted",
               {
                 "app.run.id": work.execution.runId ?? "unknown",
@@ -3098,14 +3101,14 @@ function createSlackConversationWorker(options) {
     if (records.length === 0) {
       const destination = requireSlackDestination(
         context.destination,
-        "Slack continuation recovery"
+        "Slack paused-turn recovery"
       );
       await runWithSlackInstallation({
         adapter,
         installation: { teamId: destination.teamId },
         state,
         task: async () => {
-          await options.resumeAwaitingContinuation(context.conversationId, {
+          await options.runNextPausedTurn(context.conversationId, {
             shouldYield: context.shouldYield
           });
         }
@@ -5945,9 +5948,9 @@ function createJuniorRuntimeServices(overrides = {}) {
     replyExecutor: {
       contextCompactor: overrides.replyExecutor?.contextCompactor ?? contextCompactor,
       agentRunner,
-      getAwaitingAgentContinueRequest: overrides.replyExecutor?.getAwaitingAgentContinueRequest ?? getAwaitingAgentContinueRequest,
+      getPausedTurnRequest: overrides.replyExecutor?.getPausedTurnRequest ?? getPausedTurnRequest,
       lookupSlackUser: overrides.replyExecutor?.lookupSlackUser ?? lookupSlackUser,
-      scheduleAgentContinue: overrides.replyExecutor?.scheduleAgentContinue ?? scheduleAgentContinue,
+      wakePausedTurn: overrides.replyExecutor?.wakePausedTurn ?? wakePausedTurn,
       scheduleSessionCompletedPluginTasks: overrides.replyExecutor?.scheduleSessionCompletedPluginTasks ?? (async (params) => {
         await scheduleSessionCompletedPluginTasks(params);
       }),
@@ -6183,7 +6186,7 @@ async function loadPiMessagesForTurn(args) {
     return {};
   }
   if (args.activeTurnId) {
-    const sessionRecord = await getAgentTurnSessionRecord(
+    const sessionRecord = await getTurnRecord(
       args.conversationId,
       args.activeTurnId
     );
@@ -6473,20 +6476,20 @@ function createReplyToThread(deps) {
           return;
         }
         if (conversationId && activeTurnId) {
-          const resumeRequest = await deps.services.getAwaitingAgentContinueRequest({
+          const pausedTurn = await deps.services.getPausedTurnRequest({
             conversationId,
-            sessionId: activeTurnId
+            turnId: activeTurnId
           });
-          if (resumeRequest) {
-            if (!await appendParkedTurnInput(resumeRequest.sessionId)) {
+          if (pausedTurn) {
+            if (!await appendParkedTurnInput(pausedTurn.turnId)) {
               throw new TurnInputDeferredError();
             }
             try {
-              await deps.services.scheduleAgentContinue(resumeRequest);
+              await deps.services.wakePausedTurn(pausedTurn);
             } catch (error) {
               logException(error, "agent.continue.schedule.failed", {
-                "app.ai.resume_session_version": resumeRequest.expectedVersion,
-                "app.ai.resume_session_id": resumeRequest.sessionId,
+                "app.ai.resume_session_version": pausedTurn.expectedVersion,
+                "app.ai.resume_session_id": pausedTurn.turnId,
                 ...messageTs ? { "messaging.message.id": messageTs } : {}
               });
               throw error;
@@ -6498,15 +6501,15 @@ function createReplyToThread(deps) {
             await options.ack?.();
             return;
           }
-          const sessionRecord = await getAgentTurnSessionRecord(
+          const sessionRecord = await getTurnRecord(
             conversationId,
             activeTurnId
           );
-          if (sessionRecord?.state === "awaiting_resume") {
+          if (sessionRecord?.state === "paused") {
             if (sessionRecord.resumeReason === "auth") {
-              await abandonAgentTurnSessionRecord({
+              await abandonTurnRecord({
                 conversationId,
-                sessionId: activeTurnId,
+                turnId: activeTurnId,
                 errorMessage: "Auth-parked session superseded by a new user message"
               });
               markTurnClosed({
@@ -6516,11 +6519,11 @@ function createReplyToThread(deps) {
               });
               activeTurnId = void 0;
             } else {
-              await failAgentTurnSessionRecord({
+              await failTurnRecord({
                 conversationId,
                 expectedVersion: sessionRecord.version,
-                sessionId: activeTurnId,
-                errorMessage: "Awaiting agent continuation metadata could not be materialized"
+                turnId: activeTurnId,
+                errorMessage: "Awaiting paused-turn metadata could not be materialized"
               });
               markTurnFailed({
                 conversation: preparedState.conversation,
@@ -6590,10 +6593,10 @@ function createReplyToThread(deps) {
         }
         if (conversationId) {
           const turnStartedAtMs = message.metadata.dateSent.getTime();
-          void recordAgentTurnSessionSummary({
+          void recordTurnSummary({
             channelName,
             conversationId,
-            sessionId: turnId,
+            turnId,
             sliceId: 1,
             startedAtMs: turnStartedAtMs,
             state: "running",
@@ -6669,7 +6672,7 @@ function createReplyToThread(deps) {
           if (!dispatchId) {
             return;
           }
-          await recordAgentTurnSessionSummary({
+          await recordTurnSummary({
             channelName,
             conversationId,
             destination,
@@ -6677,7 +6680,7 @@ function createReplyToThread(deps) {
             dispatchId,
             dispatchOutcome,
             ...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : {},
-            sessionId: turnId,
+            turnId,
             sliceId: 1,
             source,
             startedAtMs: message.metadata.dateSent.getTime(),
@@ -6687,7 +6690,7 @@ function createReplyToThread(deps) {
         };
         let latestArtifacts = preparedState.artifacts;
         let assistantTitleArtifacts = {};
-        let agentContinueScheduleError;
+        let turnWakeError;
         let boundaryFailureCode = "agent_run_failed";
         let finalizedFailureEventId;
         let terminalDispatchFailureOutcome;
@@ -6789,14 +6792,14 @@ function createReplyToThread(deps) {
           if (slackTs && options.execution?.dispatch?.id) {
             try {
               await persistWithRetry(
-                () => recordAgentTurnSessionSummary({
+                () => recordTurnSummary({
                   channelName,
                   conversationId,
                   destination,
                   destinationVisibility,
                   dispatchId: options.execution?.dispatch?.id,
                   resultMessageId: slackTs,
-                  sessionId: turnId,
+                  turnId,
                   sliceId: 1,
                   source,
                   startedAtMs: message.metadata.dateSent.getTime(),
@@ -7063,14 +7066,14 @@ function createReplyToThread(deps) {
             }
             if (!destination || !conversationId) {
               throw new Error(
-                "Agent continuation requires a destination and conversation id"
+                "Paused turn requires a destination and conversation id"
               );
             }
             try {
-              await deps.services.scheduleAgentContinue({
+              await deps.services.wakePausedTurn({
                 conversationId,
                 destination,
-                sessionId: turnId,
+                turnId,
                 expectedVersion: outcome.resumeVersion
               });
               shouldPersistFailureState = false;
@@ -7080,7 +7083,7 @@ function createReplyToThread(deps) {
                 "app.ai.resume_session_version": outcome.resumeVersion
               });
               shouldPersistFailureState = true;
-              agentContinueScheduleError = scheduleError;
+              turnWakeError = scheduleError;
               throw scheduleError;
             }
             return;
@@ -7122,16 +7125,17 @@ function createReplyToThread(deps) {
           }
           try {
             if (conversationId && reply.piMessages?.length) {
-              await completeDeliveredTurn({
+              await saveTurnCheckpoint({
+                mode: "completed",
                 channelName,
                 conversationId,
+                turnId,
                 durationMs: reply.diagnostics.durationMs,
                 usage: reply.diagnostics.usage,
                 reasoningLevel: reply.diagnostics.reasoningLevel,
                 destination,
                 destinationVisibility,
                 source,
-                sessionId: turnId,
                 sliceId: 1,
                 dispatchOutcome: reply.diagnostics.outcome === "success" ? "completed" : "failed",
                 ...options.execution?.dispatch && turnResult.errorMessage ? { errorMessage: turnResult.errorMessage } : {},
@@ -7143,12 +7147,12 @@ function createReplyToThread(deps) {
                 dispatchId: options.execution?.dispatch?.id
               });
             } else if (conversationId) {
-              await recordAgentTurnSessionSummary({
+              await recordTurnSummary({
                 channelName,
                 conversationId,
                 cumulativeDurationMs: reply.diagnostics.durationMs,
                 cumulativeUsage: reply.diagnostics.usage,
-                sessionId: turnId,
+                turnId,
                 sliceId: 1,
                 startedAtMs: message.metadata.dateSent.getTime(),
                 state: "completed",
@@ -7262,7 +7266,7 @@ function createReplyToThread(deps) {
             shouldPersistFailureState = false;
             throw error;
           }
-          if (error === agentContinueScheduleError) {
+          if (error === turnWakeError) {
             shouldPersistFailureState = true;
           }
           shouldPersistFailureState = true;
@@ -7285,15 +7289,12 @@ function createReplyToThread(deps) {
             const recoveryText = buildCanvasRecoveryReply(createdCanvasUrl);
             await deliverAssistantMessage(recoveryText, dispatchOutcome);
             if (conversationId) {
-              const sessionRecord = await getAgentTurnSessionRecord(
-                conversationId,
-                turnId
-              );
+              const sessionRecord = await getTurnRecord(conversationId, turnId);
               if (sessionRecord) {
-                await failAgentTurnSessionRecord({
+                await failTurnRecord({
                   conversationId,
                   expectedVersion: sessionRecord.version,
-                  sessionId: turnId,
+                  turnId,
                   errorMessage
                 });
               }
@@ -7343,10 +7344,10 @@ function createReplyToThread(deps) {
             });
             if (conversationId) {
               try {
-                await recordAgentTurnSessionSummary({
+                await recordTurnSummary({
                   channelName,
                   conversationId,
-                  sessionId: turnId,
+                  turnId,
                   sliceId: 1,
                   startedAtMs: message.metadata.dateSent.getTime(),
                   state: "failed",
@@ -7361,15 +7362,15 @@ function createReplyToThread(deps) {
                   } : {},
                   traceId: getActiveTraceId()
                 });
-                const sessionRecord = await getAgentTurnSessionRecord(
+                const sessionRecord = await getTurnRecord(
                   conversationId,
                   turnId
                 );
                 if (sessionRecord) {
-                  await failAgentTurnSessionRecord({
+                  await failTurnRecord({
                     conversationId,
                     expectedVersion: sessionRecord.version,
-                    sessionId: turnId,
+                    turnId,
                     errorMessage: "Agent turn failed before assistant output handling completed"
                   });
                 }
@@ -7871,39 +7872,33 @@ function createJuniorSlackAdapter(config) {
   return createSlackAdapter(config);
 }
 
-// src/chat/runtime/agent-continue-runner.ts
-var AGENT_CONTINUE_LOCK_RETRY_DELAYS_MS = [250, 1e3, 2e3];
+// src/chat/task-execution/paused-turn.ts
 async function persistCompletedReplyState(args) {
-  const currentState = await getPersistedThreadState(
-    args.sessionRecord.conversationId
-  );
+  const currentState = await getPersistedThreadState(args.turn.conversationId);
   const conversation = coerceThreadConversationState(currentState);
   await hydrateConversationMessages({
     conversation,
-    conversationId: args.sessionRecord.conversationId
+    conversationId: args.turn.conversationId
   });
   const artifacts = coerceThreadArtifactsState(currentState);
-  const userMessage = getTurnUserMessage(
-    conversation,
-    args.sessionRecord.sessionId
-  );
+  const userMessage = getTurnUserMessage(conversation, args.turn.turnId);
   const statePatch = buildDeliveredTurnStatePatch({
     artifacts,
     conversation,
     reply: args.reply,
-    sessionId: args.sessionRecord.sessionId,
+    sessionId: args.turn.turnId,
     userMessageId: userMessage?.id
   });
-  await persistThreadStateById(args.sessionRecord.conversationId, {
+  await persistThreadStateById(args.turn.conversationId, {
     ...statePatch
   });
 }
-async function failSessionRecordBestEffort(args) {
+async function failTurnBestEffort(args) {
   try {
-    await failAgentTurnSessionRecord({
-      conversationId: args.sessionRecord.conversationId,
-      expectedVersion: args.sessionRecord.version,
-      sessionId: args.sessionRecord.sessionId,
+    await failTurnRecord({
+      conversationId: args.turn.conversationId,
+      expectedVersion: args.turn.version,
+      turnId: args.turn.turnId,
       errorMessage: args.errorMessage
     });
   } catch (error) {
@@ -7911,51 +7906,49 @@ async function failSessionRecordBestEffort(args) {
       error,
       "agent.continue.session_record.failure_persistence.failed",
       {
-        "app.ai.conversation_id": args.sessionRecord.conversationId,
-        "app.ai.session_id": args.sessionRecord.sessionId
+        "app.ai.conversation_id": args.turn.conversationId,
+        "app.ai.session_id": args.turn.turnId
       }
     );
   }
 }
-async function persistFailedReplyState(sessionRecord, errorMessage = "Paused agent run failed while continuing") {
-  const currentState = await getPersistedThreadState(
-    sessionRecord.conversationId
-  );
+async function persistFailedReplyState(turn, errorMessage = "Paused agent run failed while continuing") {
+  const currentState = await getPersistedThreadState(turn.conversationId);
   const conversation = coerceThreadConversationState(currentState);
   await hydrateConversationMessages({
     conversation,
-    conversationId: sessionRecord.conversationId
+    conversationId: turn.conversationId
   });
-  clearPendingAuth(conversation, sessionRecord.sessionId);
+  clearPendingAuth(conversation, turn.turnId);
   markTurnFailed({
     conversation,
     nowMs: Date.now(),
-    sessionId: sessionRecord.sessionId,
-    userMessageId: getTurnUserMessage(conversation, sessionRecord.sessionId)?.id,
+    sessionId: turn.turnId,
+    userMessageId: getTurnUserMessage(conversation, turn.turnId)?.id,
     markConversationMessage
   });
-  await failSessionRecordBestEffort({
-    sessionRecord,
+  await failTurnBestEffort({
+    turn,
     errorMessage
   });
-  await persistThreadStateById(sessionRecord.conversationId, {
+  await persistThreadStateById(turn.conversationId, {
     conversation
   });
 }
-async function failContinuationStartup(args) {
+async function failPausedTurnStart(args) {
   try {
-    await persistFailedReplyState(args.sessionRecord, args.errorMessage);
+    await persistFailedReplyState(args.turn, args.errorMessage);
   } catch (persistError) {
-    await failSessionRecordBestEffort({
-      sessionRecord: args.sessionRecord,
-      errorMessage: "Paused agent run failed while preparing continuation"
+    await failTurnBestEffort({
+      turn: args.turn,
+      errorMessage: "Paused turn failed before it could run"
     });
     logException(
       persistError,
       "agent.continue.startup_failure_persist.failed",
       {
-        "app.ai.conversation_id": args.sessionRecord.conversationId,
-        "app.ai.session_id": args.sessionRecord.sessionId
+        "app.ai.conversation_id": args.turn.conversationId,
+        "app.ai.session_id": args.turn.turnId
       }
     );
   }
@@ -8012,74 +8005,78 @@ async function resolveResumeExecutionIdentity(args) {
     credentialContext: credentialContextForActor(actor)
   };
 }
-function isContinuationResume(summary) {
-  return summary.state === "awaiting_resume" && (summary.resumeReason === "timeout" || summary.resumeReason === "yield" || summary.resumeReason === "retry");
+function isPausedTurn(summary) {
+  return summary.state === "paused" && (summary.resumeReason === "timeout" || summary.resumeReason === "yield" || summary.resumeReason === "retry");
 }
-async function failUnresumableContinuation(args) {
-  await failAgentTurnSessionRecord({
+async function failPausedTurn(args) {
+  const failed = await failTurnRecord({
     conversationId: args.conversationId,
     expectedVersion: args.expectedVersion ?? args.summary.version,
-    sessionId: args.summary.sessionId,
+    turnId: args.summary.turnId,
     errorMessage: args.errorMessage
   });
-  if (args.summary.dispatchId) {
+  if (!failed) return;
+  if (failed.dispatchId) {
     try {
       const routing = await resolveTurnSessionRouting({
         conversationId: args.conversationId
       });
-      await recordAgentTurnSessionSummary({
+      await recordTurnSummary({
         conversationId: args.conversationId,
         destination: routing.destination,
-        dispatchId: args.summary.dispatchId,
+        dispatchId: failed.dispatchId,
         dispatchOutcome: "failed",
-        sessionId: args.summary.sessionId,
-        sliceId: args.summary.sliceId,
+        turnId: failed.turnId,
+        sliceId: failed.sliceId,
         source: routing.source,
         state: "failed",
-        surface: args.summary.surface
+        surface: failed.surface
       });
     } catch (error) {
       logException(error, "agent.continue.dispatch_failure_summary.failed", {
         "app.ai.conversation_id": args.conversationId,
-        "app.ai.session_id": args.summary.sessionId
+        "app.ai.session_id": args.summary.turnId
       });
     }
   }
 }
-async function continueSlackAgentRun(payload, options, runOptions = {}) {
+async function runPausedTurn(payload, options, runOptions = {}) {
   return withLogContext(
     { conversationId: payload.conversationId },
-    () => continueSlackAgentRunInContext(payload, options, runOptions)
+    () => runPausedTurnInContext(payload, options, runOptions)
   );
 }
-async function continueSlackAgentRunInContext(payload, options, runOptions) {
+async function runPausedTurnInContext(payload, options, runOptions) {
   const thread = parseSlackThreadId(payload.conversationId);
   const destination = requireSlackDestination(
     payload.destination,
-    "Agent continuation"
+    "Paused turn"
   );
-  const scheduleAgentContinue2 = options.scheduleAgentContinue ?? scheduleAgentContinue;
+  const wakePausedTurn2 = options.wakePausedTurn ?? wakePausedTurn;
   const resumeTurn = options.resumeTurn ?? resumeSlackTurn;
   return await resumeTurn({
     messageText: "",
     conversationId: payload.conversationId,
-    turnId: payload.sessionId,
+    turnId: payload.turnId,
     channelId: thread?.channelId ?? destination.channelId,
     ...thread?.threadTs ? { threadTs: thread.threadTs } : {},
     lockKey: payload.conversationId,
+    // Queue continue runs under the conversation work lease already.
+    ownsConversationLease: true,
     agentRunner: options.agentRunner,
     scheduleSessionCompletedPluginTasks: options.scheduleSessionCompletedPluginTasks,
     beforeStart: async () => {
-      let sessionRecord;
+      let turn;
       try {
-        sessionRecord = await getAgentTurnSessionRecord(
-          payload.conversationId,
-          payload.sessionId
-        );
-        if (!sessionRecord || sessionRecord.state !== "awaiting_resume" || sessionRecord.resumeReason !== "timeout" && sessionRecord.resumeReason !== "yield" && sessionRecord.resumeReason !== "retry" || sessionRecord.version !== payload.expectedVersion) {
+        const checkpoint = await loadTurnCheckpoint({
+          conversationId: payload.conversationId,
+          turnId: payload.turnId
+        });
+        turn = checkpoint.record;
+        if (!turn || turn.state !== "paused" || turn.resumeReason !== "timeout" && turn.resumeReason !== "yield" && turn.resumeReason !== "retry" || turn.version !== payload.expectedVersion) {
           return false;
         }
-        const activeSessionRecord = sessionRecord;
+        const activeTurn = turn;
         const currentState = await getPersistedThreadState(
           payload.conversationId
         );
@@ -8089,20 +8086,20 @@ async function continueSlackAgentRunInContext(payload, options, runOptions) {
           conversationId: payload.conversationId
         });
         const artifacts = coerceThreadArtifactsState(currentState);
-        const dispatchId = activeSessionRecord.dispatchId ?? options.routingContext?.dispatch?.id;
+        const dispatchId = activeTurn.dispatchId ?? options.routingContext?.dispatch?.id;
         const dispatchUserMessage = dispatchId ? conversation.messages.find(
           (message) => message.role === "user" && options.inputMessageIds?.includes(message.id)
         ) : void 0;
-        const userMessage = getTurnUserMessage(conversation, payload.sessionId) ?? dispatchUserMessage;
+        const userMessage = getTurnUserMessage(conversation, payload.turnId) ?? dispatchUserMessage;
         if (!userMessage) {
-          await failStrandedSessionWithFallback({
+          await failStrandedTurnWithFallback({
             conversationId: payload.conversationId,
-            errorMessage: `Unable to locate the persisted user message for agent continuation session "${payload.sessionId}"`,
-            sessionRecord: activeSessionRecord
+            errorMessage: `Unable to locate the persisted user message for paused turn "${payload.turnId}"`,
+            turn: activeTurn
           });
           return false;
         }
-        if (conversation.processing.activeTurnId !== payload.sessionId) {
+        if (conversation.processing.activeTurnId !== payload.turnId) {
           return false;
         }
         const identity = await resolveResumeExecutionIdentity({
@@ -8112,10 +8109,10 @@ async function continueSlackAgentRunInContext(payload, options, runOptions) {
           userMessage
         });
         if (!identity) {
-          await failStrandedSessionWithFallback({
+          await failStrandedTurnWithFallback({
             conversationId: payload.conversationId,
-            errorMessage: "Unable to rebuild Slack actor for continuation",
-            sessionRecord: activeSessionRecord
+            errorMessage: "Unable to rebuild the Slack actor for the paused turn",
+            turn: activeTurn
           });
           return false;
         }
@@ -8132,22 +8129,20 @@ async function continueSlackAgentRunInContext(payload, options, runOptions) {
         });
         const source = routing.source;
         const routingDestination = routing.destination;
-        const turnMessages = activeSessionRecord.turnStartMessageIndex === void 0 ? [] : activeSessionRecord.piMessages.slice(
-          activeSessionRecord.turnStartMessageIndex
-        );
+        const turnMessages = activeTurn.turnStartMessageIndex === void 0 ? [] : activeTurn.piMessages.slice(activeTurn.turnStartMessageIndex);
         const recordDispatchOutcome = async (dispatchOutcome) => {
           const dispatchId2 = options.routingContext?.dispatch?.id;
           if (!dispatchId2) {
             return;
           }
-          await recordAgentTurnSessionSummary({
+          await recordTurnSummary({
             conversationId: payload.conversationId,
             destination: routingDestination,
             destinationVisibility: options.routingContext?.destinationVisibility,
             dispatchId: dispatchId2,
             dispatchOutcome,
-            sessionId: payload.sessionId,
-            sliceId: activeSessionRecord.sliceId,
+            turnId: payload.turnId,
+            sliceId: activeTurn.sliceId,
             source,
             state: "failed",
             surface: options.routingContext?.surface ?? "slack"
@@ -8155,7 +8150,7 @@ async function continueSlackAgentRunInContext(payload, options, runOptions) {
         };
         return {
           messageText: userMessage.text,
-          sliceId: activeSessionRecord.sliceId,
+          sliceId: activeTurn.sliceId,
           messageTs: getTurnUserSlackMessageTs(userMessage),
           inputMessageIds: [userMessage.id],
           initialStatus: latestReportedProgress(turnMessages),
@@ -8166,7 +8161,7 @@ async function continueSlackAgentRunInContext(payload, options, runOptions) {
               // exact dispatch session so unrelated conversation input cannot
               // gain system authority. Interactive turns retain their merged
               // projection so queued steering remains visible.
-              piMessages: dispatchId ? activeSessionRecord.piMessages : await loadProjection({
+              piMessages: dispatchId ? activeTurn.piMessages : await loadProjection({
                 conversationId: payload.conversationId
               }),
               ...getTurnUserReplyAttachmentContext(userMessage)
@@ -8199,51 +8194,51 @@ async function continueSlackAgentRunInContext(payload, options, runOptions) {
           },
           commitResult: async (reply) => {
             await persistCompletedReplyState({
-              sessionRecord: activeSessionRecord,
+              turn: activeTurn,
               reply
             });
           },
           onFailure: async (error) => {
             await persistFailedReplyState(
-              activeSessionRecord,
+              activeTurn,
               error instanceof Error ? error.message : String(error)
             );
             await recordDispatchOutcome("failed");
           },
           onPostDeliveryCommitFailure: async () => {
-            await failAgentTurnSessionRecord({
-              conversationId: activeSessionRecord.conversationId,
-              expectedVersion: activeSessionRecord.version,
-              sessionId: activeSessionRecord.sessionId,
+            await failTurnRecord({
+              conversationId: activeTurn.conversationId,
+              expectedVersion: activeTurn.version,
+              turnId: activeTurn.turnId,
               errorMessage: "Continued agent reply was delivered but completion state did not persist"
             });
             await recordDispatchOutcome("failed");
           },
           onAuthPause: async () => {
             await persistAuthPauseTurnState({
-              sessionId: payload.sessionId,
+              sessionId: payload.turnId,
               threadStateId: payload.conversationId
             });
             await recordDispatchOutcome("blocked");
             logWarn("agent.continue.reparked_for_auth", {
               "app.ai.conversation_id": payload.conversationId,
-              "app.ai.session_id": payload.sessionId
+              "app.ai.session_id": payload.turnId
             });
           },
           onSuspend: async (resumeVersion) => {
-            await scheduleAgentContinue2({
+            await wakePausedTurn2({
               conversationId: payload.conversationId,
               destination: payload.destination,
-              sessionId: payload.sessionId,
+              turnId: payload.turnId,
               expectedVersion: resumeVersion
             });
           }
         };
       } catch (error) {
-        if (sessionRecord) {
-          await failContinuationStartup({
+        if (turn) {
+          await failPausedTurnStart({
             errorMessage: error instanceof Error ? error.message : String(error),
-            sessionRecord
+            turn
           });
         }
         throw error;
@@ -8251,13 +8246,14 @@ async function continueSlackAgentRunInContext(payload, options, runOptions) {
     }
   });
 }
-async function failStrandedSessionWithFallback(args) {
-  await failAgentTurnSessionRecord({
+async function failStrandedTurnWithFallback(args) {
+  const failed = await failTurnRecord({
     conversationId: args.conversationId,
-    expectedVersion: args.sessionRecord.version,
-    sessionId: args.sessionRecord.sessionId,
+    expectedVersion: args.turn.version,
+    turnId: args.turn.turnId,
     errorMessage: args.errorMessage
   });
+  if (!failed) return false;
   const currentState = await getPersistedThreadState(args.conversationId);
   const conversation = coerceThreadConversationState(currentState);
   await hydrateConversationMessages({
@@ -8267,18 +8263,15 @@ async function failStrandedSessionWithFallback(args) {
   markTurnFailed({
     conversation,
     nowMs: Date.now(),
-    sessionId: args.sessionRecord.sessionId,
-    userMessageId: getTurnUserMessage(
-      conversation,
-      args.sessionRecord.sessionId
-    )?.id,
+    sessionId: failed.turnId,
+    userMessageId: getTurnUserMessage(conversation, failed.turnId)?.id,
     markConversationMessage
   });
   await persistThreadStateById(args.conversationId, { conversation });
   const eventName = "agent.turn.stranded_session.failed";
   const eventId = logException(new Error(args.errorMessage), eventName, {
     "app.ai.conversation_id": args.conversationId,
-    "app.ai.session_id": args.sessionRecord.sessionId
+    "app.ai.session_id": failed.turnId
   });
   let routing;
   try {
@@ -8288,25 +8281,25 @@ async function failStrandedSessionWithFallback(args) {
   } catch (error) {
     logException(error, "agent.turn.stranded_session.routing_unavailable", {
       "app.ai.conversation_id": args.conversationId,
-      "app.ai.session_id": args.sessionRecord.sessionId
+      "app.ai.session_id": failed.turnId
     });
-    return;
+    return true;
   }
-  if (args.sessionRecord.dispatchId) {
-    await recordAgentTurnSessionSummary({
+  if (failed.dispatchId) {
+    await recordTurnSummary({
       conversationId: args.conversationId,
       destination: routing.destination,
-      dispatchId: args.sessionRecord.dispatchId,
+      dispatchId: failed.dispatchId,
       dispatchOutcome: "failed",
-      sessionId: args.sessionRecord.sessionId,
-      sliceId: args.sessionRecord.sliceId,
+      turnId: failed.turnId,
+      sliceId: failed.sliceId,
       source: routing.source,
       state: "failed",
-      surface: args.sessionRecord.surface
+      surface: failed.surface
     });
   }
   const thread = parseSlackThreadId(args.conversationId);
-  const channelId = thread?.channelId ?? requireSlackDestination(routing.destination, "Stranded agent continuation").channelId;
+  const channelId = thread?.channelId ?? requireSlackDestination(routing.destination, "Stranded paused turn").channelId;
   await postSlackMessage({
     channelId,
     ...thread?.threadTs ? { threadTs: thread.threadTs } : {},
@@ -8314,173 +8307,154 @@ async function failStrandedSessionWithFallback(args) {
       requireTurnFailureEventId(eventId, eventName)
     )
   });
+  return true;
 }
-async function recoverStrandedRunningSession(args) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const probe = await acquireActiveLock(stateAdapter, args.conversationId);
-  if (!probe) {
-    return false;
-  }
-  await stateAdapter.releaseLock(probe);
-  const sessionRecord = await getAgentTurnSessionRecordForResume(
-    args.conversationId,
-    args.summary.sessionId
-  );
-  if (!sessionRecord || sessionRecord.state !== "running") {
-    return false;
-  }
-  const recoveryProjection = await loadConversationProjection({
-    conversationId: args.conversationId
-  });
-  const modelProfile = recoveryProjection.modelProfile;
-  const modelId = modelIdForProfile(botConfig, modelProfile);
-  let routing;
-  try {
-    routing = await resolveTurnSessionRouting({
-      conversationId: args.conversationId
-    });
-  } catch (error) {
-    await failStrandedSessionWithFallback({
-      conversationId: args.conversationId,
-      errorMessage: error instanceof Error ? error.message : String(error),
-      sessionRecord
-    });
-    return false;
-  }
-  const parked = await persistYieldSessionRecord({
-    channelName: sessionRecord.channelName,
-    conversationId: args.conversationId,
-    sessionId: sessionRecord.sessionId,
-    currentSliceId: sessionRecord.sliceId,
-    destination: routing.destination,
-    source: routing.source,
-    messages: sessionRecord.piMessages,
-    errorMessage: "Recovered running session after hard worker death",
-    modelId,
-    surface: sessionRecord.surface
-  });
-  if (!parked) {
-    await failStrandedSessionWithFallback({
-      conversationId: args.conversationId,
-      errorMessage: "Stranded running session had no resumable boundary after worker death",
-      sessionRecord
-    });
-    return false;
-  }
-  const request = await getAwaitingAgentContinueRequest({
-    conversationId: args.conversationId,
-    sessionId: sessionRecord.sessionId
-  });
-  if (!request) {
-    await failStrandedSessionWithFallback({
-      conversationId: args.conversationId,
-      errorMessage: "Stranded running session could not materialize continuation metadata",
-      sessionRecord: parked
-    });
-    return false;
-  }
-  if (await continueSlackAgentRunWithLockRetry(
-    request,
-    args.options,
-    args.runOptions
-  )) {
-    return true;
-  }
-  await failUnresumableContinuation({
-    conversationId: args.conversationId,
-    expectedVersion: request.expectedVersion,
-    summary: args.summary,
-    errorMessage: "Awaiting agent continuation was stale before it could run"
-  });
-  return false;
-}
-async function resumeAwaitingSlackContinuation(conversationId, options, runOptions = {}) {
+async function runNextPausedTurn(conversationId, options, runOptions = {}) {
   return withLogContext(
     { conversationId },
-    () => resumeAwaitingSlackContinuationInContext(
-      conversationId,
-      options,
-      runOptions
-    )
+    () => runNextPausedTurnInContext(conversationId, options, runOptions)
   );
 }
-async function resumeAwaitingSlackContinuationInContext(conversationId, options, runOptions) {
-  const summaries = await listAgentTurnSessionSummariesForConversation(conversationId);
+async function runNextPausedTurnInContext(conversationId, options, runOptions) {
+  const summaries = await listTurnSummaries(conversationId);
+  const persisted = await getPersistedThreadState(conversationId);
+  const conversation = coerceThreadConversationState(persisted);
+  await hydrateConversationMessages({ conversation, conversationId });
   const newest = summaries[0];
-  if (newest?.state === "running") {
-    return await recoverStrandedRunningSession({
-      conversationId,
-      options,
-      runOptions,
-      summary: newest
+  const running = newest ? await getTurnRecord(conversationId, newest.turnId) : void 0;
+  if (running?.state === "running") {
+    if (turnHasReply(conversation, running.turnId)) {
+      const acceptedReply = [...conversation.messages].reverse().find(
+        (message) => message.role === "assistant" && message.id.startsWith(`${running.turnId}:assistant:`)
+      );
+      const completed = await completeTurnRecord({
+        conversationId,
+        expectedVersion: running.version,
+        resultMessageId: acceptedReply?.meta?.slackTs,
+        turnId: running.turnId
+      });
+      if (!completed) return false;
+      markTurnCompleted({
+        conversation,
+        nowMs: Date.now(),
+        sessionId: running.turnId
+      });
+      await persistThreadStateById(conversationId, { conversation });
+      return false;
+    }
+    const state = getStateAdapter();
+    await state.connect();
+    await withActiveLock(state, conversationId, async () => {
+      const record = await getTurnRecordForResume(
+        conversationId,
+        running.turnId
+      );
+      if (!record || record.state !== "running") return;
+      await failStrandedTurnWithFallback({
+        conversationId,
+        errorMessage: "Turn lost its worker before reaching a safe boundary",
+        turn: record
+      });
     });
+    return false;
   }
   for (const summary of summaries) {
-    if (!isContinuationResume(summary)) {
+    if (!isPausedTurn(summary)) {
       continue;
     }
-    const request = await getAwaitingAgentContinueRequest({
+    const request = await getPausedTurnRequest({
       conversationId,
-      sessionId: summary.sessionId
+      turnId: summary.turnId
     });
     if (!request) {
-      await failUnresumableContinuation({
+      await failPausedTurn({
         conversationId,
         summary,
-        errorMessage: "Awaiting agent continuation metadata could not be materialized"
+        errorMessage: "Awaiting paused-turn metadata could not be materialized"
       });
       continue;
     }
-    if (await continueSlackAgentRunWithLockRetry(request, options, runOptions)) {
+    if (await runPausedTurn(request, options, runOptions)) {
       return true;
     }
-    await failUnresumableContinuation({
+    await failPausedTurn({
       conversationId,
       expectedVersion: request.expectedVersion,
       summary,
-      errorMessage: "Awaiting agent continuation was stale before it could run"
+      errorMessage: "Awaiting paused turn was stale before it could run"
     });
   }
   return false;
 }
-async function continueSlackAgentRunWithLockRetry(payload, options, runOptions = {}) {
-  return withLogContext(
-    { conversationId: payload.conversationId },
-    () => continueSlackAgentRunWithLockRetryInContext(payload, options, runOptions)
-  );
-}
-async function continueSlackAgentRunWithLockRetryInContext(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, runOptions);
-    } catch (error) {
-      if (!(error instanceof ResumeTurnBusyError)) {
-        throw error;
-      }
-      if (typeof delayMs !== "number") {
-        logWarn("agent.continue.lock.busy", {
-          "app.ai.conversation_id": payload.conversationId,
-          "app.ai.session_id": payload.sessionId,
-          "app.ai.resume_lock_retry_count": attempt
-        });
-        await scheduleAgentContinue2(payload);
-        return true;
-      }
-      logWarn("agent.continue.lock.retrying", {
-        "app.ai.conversation_id": payload.conversationId,
-        "app.ai.session_id": payload.sessionId,
-        "app.ai.resume_lock_retry_attempt": attempt + 1,
-        "app.ai.resume_lock_retry_delay_ms": delayMs
-      });
-      await sleep(delayMs);
+
+// src/chat/app/conversation-work.ts
+function createConversationWork(options) {
+  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
+      }))
     }
-  }
-  return true;
+  };
+  const runtime = createSlackRuntime({
+    getSlackAdapter: options.getSlackAdapter,
+    services
+  });
+  const slackWorker = createSlackConversationWorker({
+    getSlackAdapter: options.getSlackAdapter,
+    conversationStore: options.conversationStore,
+    runNextPausedTurn: async (conversationId, runOptions) => await runNextPausedTurn(
+      conversationId,
+      {
+        agentRunner: options.agentRunner,
+        scheduleSessionCompletedPluginTasks: services.replyExecutor?.scheduleSessionCompletedPluginTasks,
+        wakePausedTurn: services.replyExecutor?.wakePausedTurn
+      },
+      runOptions
+    ),
+    runtime,
+    state: options.state
+  });
+  const dispatchWorker = createAgentDispatchConversationWorker({
+    resumeTurn: async (dispatch2, hooks) => {
+      await runNextPausedTurn(
+        getDispatchConversationId(dispatch2),
+        {
+          agentRunner: options.agentRunner,
+          inputMessageIds: getDispatchInputMessageIds(dispatch2.id),
+          routingContext: buildDispatchRoutingContext(dispatch2),
+          scheduleSessionCompletedPluginTasks: services.replyExecutor?.scheduleSessionCompletedPluginTasks,
+          wakePausedTurn: services.replyExecutor?.wakePausedTurn
+        },
+        { shouldYield: hooks.shouldYield }
+      );
+    },
+    runTurn: runtime.runDispatchTurn
+  });
+  const providerWorker = createAgentDispatchWorkRouter({
+    dispatchWorker,
+    fallbackWorker: slackWorker
+  });
+  return {
+    conversationStore: options.conversationStore,
+    queue: options.queue,
+    run: routeAgentInvocationWork({
+      invocationWorker: createAgentInvocationWorker({
+        agentRunner: options.agentRunner
+      }),
+      fallbackWorker: providerWorker
+    }),
+    runtime,
+    state: options.state
+  };
 }
 
 // src/chat/app/production.ts
@@ -8524,61 +8498,13 @@ function createProductionSlackWebhookServices(options) {
 }
 function createProductionConversationWorkOptions(options) {
   const conversationStore = getProductionConversationStore();
-  const { agentRunner } = options;
-  const services = {
-    ...options.services,
-    replyExecutor: {
-      ...options.services?.replyExecutor,
-      agentRunner
-    }
-  };
-  const runtime = createSlackRuntime({
-    getSlackAdapter: getProductionSlackAdapter,
-    services
-  });
-  const queue = getVercelConversationWorkQueue();
-  const slackWorker = createSlackConversationWorker({
-    getSlackAdapter: getProductionSlackAdapter,
+  return createConversationWork({
+    agentRunner: options.agentRunner,
     conversationStore,
-    resumeAwaitingContinuation: async (conversationId, runOptions) => await resumeAwaitingSlackContinuation(
-      conversationId,
-      {
-        agentRunner,
-        scheduleSessionCompletedPluginTasks: services.replyExecutor?.scheduleSessionCompletedPluginTasks
-      },
-      runOptions
-    ),
-    runtime
-  });
-  const dispatchWorker = createAgentDispatchConversationWorker({
-    resumeTurn: async (dispatch2, hooks) => {
-      await resumeAwaitingSlackContinuation(
-        getDispatchConversationId(dispatch2),
-        {
-          agentRunner,
-          inputMessageIds: getDispatchInputMessageIds(dispatch2.id),
-          routingContext: buildDispatchRoutingContext(dispatch2),
-          scheduleSessionCompletedPluginTasks: services.replyExecutor?.scheduleSessionCompletedPluginTasks
-        },
-        { shouldYield: hooks.shouldYield }
-      );
-    },
-    runTurn: runtime.runDispatchTurn
-  });
-  const providerWorker = createAgentDispatchWorkRouter({
-    dispatchWorker,
-    fallbackWorker: slackWorker
+    getSlackAdapter: getProductionSlackAdapter,
+    queue: getVercelConversationWorkQueue(),
+    services: options.services
   });
-  return {
-    conversationStore,
-    queue,
-    run: routeAgentInvocationWork({
-      invocationWorker: createAgentInvocationWorker({
-        agentRunner
-      }),
-      fallbackWorker: providerWorker
-    })
-  };
 }
 
 // src/chat/resource-events/ingest.ts