@sentry/junior 0.71.3 → 0.72.0

package/dist/app.js

@@ -1,3 +1,11 @@
+import {
+  defineJuniorPlugins,
+  getVercelConversationWorkQueue,
+  pluginCatalogConfigFromPluginSet,
+  pluginHookRegistrationsFromPluginSet,
+  resolveConversationWorkQueueTopic,
+  verifyConversationQueueMessage
+} from "./chunk-ICKIDP7G.js";
 import {
   GET,
   JUNIOR_PERSONALITY,
@@ -20,7 +28,6 @@ import {
   getAgentTurnSessionRecord,
   getInterruptionMarker,
   initConversationContext,
-  listAgentTurnSessionSummaries,
   listAgentTurnSessionSummariesForConversation,
   loadConnectedMcpProviders,
   loadProjection,
@@ -39,13 +46,53 @@ import {
   upsertAgentTurnSessionRecord,
   validateAgentPlugins,
   verifySlackDirectCredentialSubject
-} from "./chunk-HOGQL2H6.js";
+} from "./chunk-VSNA5KAB.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-GT67ZWZQ.js";
+} from "./chunk-55XEZFGD.js";
+import {
+  buildConversationStatePatch,
+  coerceThreadConversationState
+} from "./chunk-4JXCSGSA.js";
+import {
+  CONVERSATION_WORK_CHECK_IN_INTERVAL_MS,
+  CONVERSATION_WORK_STALE_ENQUEUE_MS,
+  JUNIOR_THREAD_STATE_TTL_MS,
+  appendAndEnqueueInboundMessage,
+  checkInConversationWork,
+  clearExpiredConversationLease,
+  completeConversationWork,
+  countPendingConversationMessages,
+  drainConversationMailbox,
+  getConversationWorkState,
+  hasRunnableConversationWork,
+  listActiveConversationIds,
+  markConversationMessagesInjected,
+  markConversationWorkEnqueued,
+  releaseConversationWork,
+  removeActiveConversation,
+  requestConversationContinuation,
+  requestConversationWork,
+  startConversationWork
+} from "./chunk-HNMUVGSR.js";
+import {
+  SlackActionError,
+  createSlackDestination,
+  destinationKey,
+  downloadPrivateSlackFile,
+  getFilePermalink,
+  getHeaderString,
+  getSlackClient,
+  isConversationScopedChannel,
+  isDmChannel,
+  normalizeSlackConversationId,
+  parseDestination,
+  sameDestination,
+  withSlackRetries
+} from "./chunk-XC33FJZN.js";
 import {
   buildNonInteractiveShellScript,
   createSandboxInstance,
@@ -54,19 +101,16 @@ import {
   isSnapshotMissingError,
   resolveRuntimeDependencySnapshot,
   runNonInteractiveCommand
-} from "./chunk-B5HKWWQB.js";
+} from "./chunk-VLIO6RQR.js";
 import {
-  ACTIVE_LOCK_TTL_MS,
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
   SANDBOX_WORKSPACE_ROOT,
-  getStateAdapter,
   sandboxSkillDir,
   sandboxSkillFile
-} from "./chunk-R62YWUNO.js";
+} from "./chunk-G3E7SCME.js";
 import {
   CredentialUnavailableError,
-  buildActorIdentity,
   buildOAuthTokenRequest,
   createPluginBroker,
   credentialContextSchema,
@@ -77,39 +121,21 @@ import {
   getPluginOAuthConfig,
   getPluginProviders,
   hasRequiredOAuthScope,
-  isActorUserId,
   isPluginConfigKey,
   isPluginProvider,
-  parseActorUserId,
   parseOAuthTokenResponse,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv,
-  setPluginCatalogConfig,
-  slackActorIdentity
-} from "./chunk-UXG6TU2U.js";
+  setPluginCatalogConfig
+} from "./chunk-GB3AL54K.js";
 import {
-  defineJuniorPlugins,
-  getVercelConversationWorkQueue,
-  pluginCatalogConfigFromPluginSet,
-  pluginHookRegistrationsFromPluginSet,
-  resolveConversationWorkQueueTopic,
-  verifyConversationQueueMessage
-} from "./chunk-XE2VFQQN.js";
+  homeDir,
+  listReferenceFiles
+} from "./chunk-KVZL5NZS.js";
 import {
-  SlackActionError,
-  createSlackDestination,
-  destinationKey,
-  downloadPrivateSlackFile,
-  getFilePermalink,
-  getHeaderString,
-  getSlackClient,
-  isConversationScopedChannel,
-  isDmChannel,
-  normalizeSlackConversationId,
-  parseDestination,
-  sameDestination,
-  withSlackRetries
-} from "./chunk-76YMBKW7.js";
+  ACTIVE_LOCK_TTL_MS,
+  getStateAdapter
+} from "./chunk-3FYPXHPL.js";
 import {
   FUNCTION_TIMEOUT_BUFFER_SECONDS,
   GEN_AI_PROVIDER_NAME,
@@ -161,7 +187,15 @@ import {
   toObservablePromptPart,
   trimTrailingAssistantMessages,
   upsertActiveSkill
-} from "./chunk-JS4HURDT.js";
+} from "./chunk-ZJQPA67D.js";
+import {
+  createRequester,
+  createRequesterFromStoredSlackRequester,
+  createSlackRequester,
+  isActorUserId,
+  parseActorUserId,
+  toStoredSlackRequester
+} from "./chunk-PP7AGSBU.js";
 import {
   buildTurnFailureResponse,
   createChatSdkLogger,
@@ -170,9 +204,7 @@ import {
   extractGenAiUsageSummary,
   getActiveTraceId,
   getLogContextAttributes,
-  homeDir,
   isRecord,
-  listReferenceFiles,
   logError,
   logException,
   logInfo,
@@ -183,11 +215,10 @@ import {
   setSpanAttributes,
   setSpanStatus,
   setTags,
-  toOptionalNumber,
   toOptionalString,
   withContext,
   withSpan
-} from "./chunk-BBXYXOJW.js";
+} from "./chunk-6GEYPE6T.js";
 import {
   sentry_exports
 } from "./chunk-Z3YD6NHK.js";
@@ -1051,6 +1082,12 @@ function getMcpAwareErrorType(error, fallback) {
 function getMcpAwareErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function getMcpAwareTelemetryMessage(error, privacy) {
+  if (privacy === "private" && error instanceof McpToolError) {
+    return "MCP tool call failed";
+  }
+  return getMcpAwareErrorMessage(error);
+}
 
 // src/chat/mcp/tool-manager.ts
 function normalizeMcpToolName(provider, toolName) {
@@ -1270,63 +1307,104 @@ var McpToolManager = class {
       ...tool2.title?.trim() ? { title: tool2.title.trim() } : {},
       ...outputSchema ? { outputSchema } : {},
       ...annotations ? { annotations } : {},
-      execute: async (args) => {
+      execute: async (args, options) => {
         const resolvedArgs = typeof args === "object" && args !== null ? args : {};
+        const conversationPrivacy = options?.conversationPrivacy ?? "private";
+        const managedToolName = normalizeMcpToolName(
+          plugin.manifest.name,
+          tool2.name
+        );
         const baseAttributes = {
-          "mcp.method.name": "tools/call"
-        };
-        setSpanAttributes(baseAttributes);
-        try {
-          const result = await client.callTool(tool2.name, resolvedArgs);
-          if ("isError" in result && result.isError) {
-            throw new McpToolError(extractMcpErrorMessage(result));
-          }
-          return {
-            content: toAgentToolContent(result),
-            details: {
-              provider: plugin.manifest.name,
-              tool: tool2.name,
-              rawResult: result
-            }
-          };
-        } catch (error) {
-          if (error instanceof McpAuthorizationRequiredError && await this.handleAuthorizationRequired(
+          "mcp.method.name": "tools/call",
+          "gen_ai.operation.name": "execute_tool",
+          "gen_ai.tool.name": managedToolName,
+          "gen_ai.tool.description": describeMcpTool(
             plugin.manifest.name,
-            error
-          )) {
-            return {
-              // Pi turns thrown tool errors into toolResult isError frames.
-              // Once auth pause has been requested, return a placeholder result
-              // and let the aborted turn park cleanly instead of surfacing a
-              // spurious tool failure to the model.
-              content: [{ type: "text", text: "Authorization pending." }],
-              details: {
-                provider: plugin.manifest.name,
-                tool: tool2.name,
-                rawResult: {
+            tool2
+          ),
+          "gen_ai.tool.type": "extension",
+          "app.plugin.name": plugin.manifest.name,
+          ...options?.toolCallId ? { "gen_ai.tool.call.id": options.toolCallId } : {}
+        };
+        const argumentAttribute = serializeMcpPayload(
+          resolvedArgs,
+          conversationPrivacy
+        );
+        return await withSpan(
+          `execute_tool ${managedToolName}`,
+          "gen_ai.execute_tool",
+          {},
+          async () => {
+            try {
+              const result = await client.callTool(tool2.name, resolvedArgs);
+              if ("isError" in result && result.isError) {
+                throw new McpToolError(extractMcpErrorMessage(result));
+              }
+              const resultAttribute = serializeMcpPayload(
+                result,
+                conversationPrivacy
+              );
+              if (resultAttribute) {
+                setSpanAttributes({
+                  "gen_ai.tool.call.result": resultAttribute
+                });
+              }
+              return {
+                content: toAgentToolContent(result),
+                details: {
+                  provider: plugin.manifest.name,
+                  tool: tool2.name,
+                  rawResult: result
+                }
+              };
+            } catch (error) {
+              if (error instanceof McpAuthorizationRequiredError && await this.handleAuthorizationRequired(
+                plugin.manifest.name,
+                error
+              )) {
+                const parkedResult = {
                   toolResult: {
                     authorizationPending: true
                   }
-                }
+                };
+                return {
+                  // Pi turns thrown tool errors into toolResult isError frames.
+                  // Once auth pause has been requested, return a placeholder result
+                  // and let the aborted turn park cleanly instead of surfacing a
+                  // spurious tool failure to the model.
+                  content: [{ type: "text", text: "Authorization pending." }],
+                  details: {
+                    provider: plugin.manifest.name,
+                    tool: tool2.name,
+                    rawResult: parkedResult
+                  }
+                };
               }
-            };
-          }
-          const errorAttributes = {
+              const errorAttributes = {
+                ...baseAttributes,
+                "error.type": getMcpAwareErrorType(error, "mcp_tool_error"),
+                "exception.message": getMcpAwareTelemetryMessage(
+                  error,
+                  conversationPrivacy
+                )
+              };
+              setSpanAttributes(errorAttributes);
+              if (error instanceof McpToolError) {
+                logWarn(
+                  "mcp_tool_call_failed",
+                  {},
+                  errorAttributes,
+                  "MCP tool call failed"
+                );
+              }
+              throw error;
+            }
+          },
+          {
             ...baseAttributes,
-            "error.type": getMcpAwareErrorType(error, "mcp_tool_error"),
-            "exception.message": getMcpAwareErrorMessage(error)
-          };
-          setSpanAttributes(errorAttributes);
-          if (error instanceof McpToolError) {
-            logWarn(
-              "mcp_tool_call_failed",
-              {},
-              errorAttributes,
-              "MCP tool call failed"
-            );
+            ...argumentAttribute ? { "gen_ai.tool.call.arguments": argumentAttribute } : {}
           }
-          throw error;
-        }
+        );
       }
     };
   }
@@ -1371,6 +1449,11 @@ var McpToolManager = class {
 function toOptionalRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
+function serializeMcpPayload(payload, privacy) {
+  return serializeGenAiAttribute(
+    privacy === "private" ? toGenAiPayloadMetadata(payload) : payload
+  );
+}
 
 // src/chat/mcp/tool-name.ts
 function parseMcpProviderFromToolName(toolName) {
@@ -2713,7 +2796,7 @@ function createCallMcpToolTool(mcpToolManager) {
       },
       { additionalProperties: false }
     ),
-    execute: async (input) => {
+    execute: async (input, options) => {
       const { tool_name } = input;
       const provider = parseMcpProviderFromToolName(tool_name);
       if (provider) {
@@ -2738,7 +2821,11 @@ function createCallMcpToolTool(mcpToolManager) {
         throw new McpToolError(missingToolMessage(tool_name, provider));
       }
       return await mcpTool.execute(
-        resolveMcpArguments(input)
+        resolveMcpArguments(input),
+        {
+          conversationPrivacy: options?.conversationPrivacy ?? "private",
+          ...options?.toolCallId ? { toolCallId: options.toolCallId } : {}
+        }
       );
     }
   });
@@ -5226,13 +5313,13 @@ function createSystemTimeTool() {
     annotations: { readOnlyHint: true, destructiveHint: false },
     inputSchema: Type20.Object({}),
     execute: async () => {
-      const now3 = /* @__PURE__ */ new Date();
+      const now2 = /* @__PURE__ */ new Date();
       return {
         ok: true,
-        unix_ms: now3.getTime(),
-        iso_utc: now3.toISOString(),
-        iso_local: new Date(now3.getTime() - now3.getTimezoneOffset() * 6e4).toISOString().replace("Z", ""),
-        timezone_offset_minutes: now3.getTimezoneOffset()
+        unix_ms: now2.getTime(),
+        iso_utc: now2.toISOString(),
+        iso_local: new Date(now2.getTime() - now2.getTimezoneOffset() * 6e4).toISOString().replace("Z", ""),
+        timezone_offset_minutes: now2.getTimezoneOffset()
       };
     }
   });
@@ -5244,9 +5331,6 @@ import {
 } from "@earendil-works/pi-agent-core";
 import { Type as Type21 } from "@sinclair/typebox";
 
-// src/chat/state/ttl.ts
-var JUNIOR_THREAD_STATE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
-
 // src/chat/tools/advisor/session-store.ts
 var ADVISOR_SESSION_TTL_MS = JUNIOR_THREAD_STATE_TTL_MS;
 function cloneMessages(messages) {
@@ -6667,11 +6751,11 @@ function getSandboxEgressSecret() {
 }
 function createSandboxEgressCredentialToken(input) {
   const ttlMs = Math.max(1, input.ttlMs ?? DEFAULT_SESSION_TTL_MS);
-  const now3 = Date.now();
+  const now2 = Date.now();
   const context = {
     credentials: input.credentials,
     egressId: input.egressId,
-    expiresAtMs: now3 + ttlMs,
+    expiresAtMs: now2 + ttlMs,
     contextId: randomUUID()
   };
   const payload = `${SANDBOX_EGRESS_TOKEN_VERSION}.${base64Url(
@@ -7953,14 +8037,14 @@ function createSandboxExecutor(options) {
     if (!credentialEgress) {
       throw new Error("Sandbox credential egress is not configured");
     }
-    const now3 = Date.now();
+    const now2 = Date.now();
     const token = createSandboxEgressCredentialToken({
       credentials: credentialEgress,
       egressId,
       ttlMs: sandboxEgressTokenTtlMs
     });
     sandboxEgressCredentialTokens.set(egressId, {
-      expiresAtMs: now3 + sandboxEgressTokenTtlMs,
+      expiresAtMs: now2 + sandboxEgressTokenTtlMs,
       token
     });
     return token;
@@ -8763,12 +8847,12 @@ async function deleteMcpAuthSession(authSessionId) {
 }
 async function deleteMcpAuthSessionsForUserProvider(userId, provider) {
   const stateAdapter = await getConnectedStateAdapter();
-  const indexKey2 = sessionIndexKey(userId, provider);
-  const authSessionIds = parseSessionIndex(await stateAdapter.get(indexKey2));
+  const indexKey = sessionIndexKey(userId, provider);
+  const authSessionIds = parseSessionIndex(await stateAdapter.get(indexKey));
   for (const authSessionId of authSessionIds) {
     await stateAdapter.delete(sessionKey(authSessionId));
   }
-  await stateAdapter.delete(indexKey2);
+  await stateAdapter.delete(indexKey);
 }
 async function getLatestMcpAuthSessionForUserProvider(userId, provider) {
   const stateAdapter = await getConnectedStateAdapter();
@@ -9328,9 +9412,9 @@ function getToolErrorAttributes(error) {
     ...error.detailRule ? { "app.slack.detail_rule": error.detailRule } : {}
   };
 }
-function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, traceContext) {
+function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, traceContext, conversationPrivacy) {
   const errorType = getToolErrorType(error);
-  const errorMessage = getMcpAwareErrorMessage(error);
+  const errorMessage = getMcpAwareTelemetryMessage(error, conversationPrivacy);
   setSpanAttributes({
     "error.type": errorType,
     ...error instanceof PluginCredentialFailureError ? { "app.credential.provider": error.provider } : {}
@@ -9453,7 +9537,9 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
               ...signal ? { signal } : {}
             }) : await toolDef.execute(toolInput, {
               experimental_context: sandbox,
-              ...signal ? { signal } : {}
+              ...signal ? { signal } : {},
+              conversationPrivacy: effectiveConversationPrivacy,
+              ...normalizedToolCallId ? { toolCallId: normalizedToolCallId } : {}
             });
             const normalized = normalizeToolResult(result, isSandbox);
             if (bashCommand && pluginAuthOrchestration) {
@@ -9484,16 +9570,17 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
               toolName,
               normalizedToolCallId,
               shouldTrace,
-              spanContext
+              spanContext,
+              effectiveConversationPrivacy
             );
           }
         },
         {
           "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
           "gen_ai.operation.name": "execute_tool",
-          "app.conversation.privacy": effectiveConversationPrivacy,
           "gen_ai.tool.name": toolName,
           "gen_ai.tool.description": toolDef.description,
+          "gen_ai.tool.type": "extension",
           ...toolArgumentsMetadata,
           ...normalizedToolCallId ? { "gen_ai.tool.call.id": normalizedToolCallId } : {},
           ...toolArgumentsAttribute ? { "gen_ai.tool.call.arguments": toolArgumentsAttribute } : {}
@@ -9699,208 +9786,6 @@ function createChannelConfigurationService(storage) {
   };
 }
 
-// src/chat/state/conversation.ts
-function coerceRole(value) {
-  return value === "assistant" || value === "system" || value === "user" ? value : "user";
-}
-function coerceAuthor(value) {
-  if (!isRecord(value)) return void 0;
-  const author = {
-    fullName: toOptionalString(value.fullName),
-    userId: toOptionalString(value.userId),
-    userName: toOptionalString(value.userName)
-  };
-  if (typeof value.isBot === "boolean") {
-    author.isBot = value.isBot;
-  }
-  if (!author.fullName && !author.userId && !author.userName && author.isBot === void 0) {
-    return void 0;
-  }
-  return author;
-}
-function coerceMessageMeta(value) {
-  if (!isRecord(value)) return void 0;
-  const meta = {};
-  const attachmentCount = toOptionalNumber(value.attachmentCount);
-  if (typeof attachmentCount === "number" && attachmentCount > 0) {
-    meta.attachmentCount = attachmentCount;
-  }
-  if (typeof value.explicitMention === "boolean") {
-    meta.explicitMention = value.explicitMention;
-  }
-  const imageAttachmentCount = toOptionalNumber(value.imageAttachmentCount);
-  if (typeof imageAttachmentCount === "number" && imageAttachmentCount > 0) {
-    meta.imageAttachmentCount = imageAttachmentCount;
-  }
-  if (typeof value.replied === "boolean") {
-    meta.replied = value.replied;
-  }
-  if (typeof value.skippedReason === "string" && value.skippedReason.trim().length > 0) {
-    meta.skippedReason = value.skippedReason;
-  }
-  if (typeof value.slackTs === "string" && value.slackTs.trim().length > 0) {
-    meta.slackTs = value.slackTs;
-  }
-  if (Array.isArray(value.imageFileIds)) {
-    const imageFileIds = value.imageFileIds.filter(
-      (entry) => typeof entry === "string" && entry.trim().length > 0
-    );
-    if (imageFileIds.length > 0) {
-      meta.imageFileIds = imageFileIds;
-    }
-  }
-  if (typeof value.imagesHydrated === "boolean") {
-    meta.imagesHydrated = value.imagesHydrated;
-  }
-  if (meta.attachmentCount === void 0 && meta.explicitMention === void 0 && meta.imageAttachmentCount === void 0 && meta.replied === void 0 && meta.skippedReason === void 0 && meta.slackTs === void 0 && meta.imageFileIds === void 0 && meta.imagesHydrated === void 0) {
-    return void 0;
-  }
-  return meta;
-}
-function defaultConversationState() {
-  const nowMs = Date.now();
-  return {
-    schemaVersion: 1,
-    messages: [],
-    piMessages: [],
-    compactions: [],
-    backfill: {},
-    processing: {},
-    stats: {
-      estimatedContextTokens: 0,
-      totalMessageCount: 0,
-      compactedMessageCount: 0,
-      updatedAtMs: nowMs
-    },
-    vision: {
-      byFileId: {}
-    }
-  };
-}
-function coercePendingAuthState(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const kind = value.kind;
-  const provider = toOptionalString(value.provider);
-  const requesterId = toOptionalString(value.requesterId);
-  const scope = toOptionalString(value.scope);
-  const sessionId = toOptionalString(value.sessionId);
-  const linkSentAtMs = toOptionalNumber(value.linkSentAtMs);
-  if (kind !== "mcp" && kind !== "plugin" || !provider || !requesterId || !sessionId || typeof linkSentAtMs !== "number") {
-    return void 0;
-  }
-  return {
-    kind,
-    provider,
-    requesterId,
-    ...scope ? { scope } : {},
-    sessionId,
-    linkSentAtMs
-  };
-}
-function coerceThreadConversationState(value) {
-  if (!isRecord(value)) {
-    return defaultConversationState();
-  }
-  const root = value;
-  const rawConversation = isRecord(root.conversation) ? root.conversation : {};
-  const base = defaultConversationState();
-  const rawMessages = Array.isArray(rawConversation.messages) ? rawConversation.messages : [];
-  const messages = [];
-  for (const item of rawMessages) {
-    if (!isRecord(item)) continue;
-    const id = toOptionalString(item.id);
-    const text = toOptionalString(item.text);
-    const createdAtMs = toOptionalNumber(item.createdAtMs);
-    if (!id || !text || !createdAtMs) continue;
-    messages.push({
-      id,
-      role: coerceRole(item.role),
-      text,
-      createdAtMs,
-      author: coerceAuthor(item.author),
-      meta: coerceMessageMeta(item.meta)
-    });
-  }
-  const rawCompactions = Array.isArray(rawConversation.compactions) ? rawConversation.compactions : [];
-  const compactions = [];
-  for (const item of rawCompactions) {
-    if (!isRecord(item)) continue;
-    const id = toOptionalString(item.id);
-    const summary = toOptionalString(item.summary);
-    const createdAtMs = toOptionalNumber(item.createdAtMs);
-    if (!id || !summary || !createdAtMs) continue;
-    const coveredMessageIds = Array.isArray(item.coveredMessageIds) ? item.coveredMessageIds.filter(
-      (entry) => typeof entry === "string" && entry.length > 0
-    ) : [];
-    compactions.push({
-      id,
-      summary,
-      createdAtMs,
-      coveredMessageIds
-    });
-  }
-  const rawBackfill = isRecord(rawConversation.backfill) ? rawConversation.backfill : {};
-  const backfill = {
-    completedAtMs: toOptionalNumber(rawBackfill.completedAtMs),
-    source: rawBackfill.source === "recent_messages" || rawBackfill.source === "thread_fetch" ? rawBackfill.source : void 0
-  };
-  const rawProcessing = isRecord(rawConversation.processing) ? rawConversation.processing : {};
-  const processing = {
-    activeTurnId: toOptionalString(rawProcessing.activeTurnId),
-    lastCompletedAtMs: toOptionalNumber(rawProcessing.lastCompletedAtMs),
-    pendingAuth: coercePendingAuthState(rawProcessing.pendingAuth)
-  };
-  const rawStats = isRecord(rawConversation.stats) ? rawConversation.stats : {};
-  const stats = {
-    estimatedContextTokens: toOptionalNumber(rawStats.estimatedContextTokens) ?? base.stats.estimatedContextTokens,
-    totalMessageCount: toOptionalNumber(rawStats.totalMessageCount) ?? messages.length,
-    compactedMessageCount: toOptionalNumber(rawStats.compactedMessageCount) ?? 0,
-    updatedAtMs: toOptionalNumber(rawStats.updatedAtMs) ?? base.stats.updatedAtMs
-  };
-  const rawVision = isRecord(rawConversation.vision) ? rawConversation.vision : {};
-  const rawVisionByFileId = isRecord(rawVision.byFileId) ? rawVision.byFileId : {};
-  const byFileId = {};
-  for (const [fileId, value2] of Object.entries(rawVisionByFileId)) {
-    if (typeof fileId !== "string" || fileId.trim().length === 0) continue;
-    if (!isRecord(value2)) continue;
-    const summary = toOptionalString(value2.summary);
-    const analyzedAtMs = toOptionalNumber(value2.analyzedAtMs);
-    if (!summary || !analyzedAtMs) continue;
-    byFileId[fileId] = {
-      summary,
-      analyzedAtMs
-    };
-  }
-  return {
-    schemaVersion: 1,
-    messages,
-    piMessages: Array.isArray(rawConversation.piMessages) ? rawConversation.piMessages : [],
-    compactions,
-    backfill,
-    processing,
-    stats,
-    vision: {
-      backfillCompletedAtMs: toOptionalNumber(rawVision.backfillCompletedAtMs),
-      byFileId
-    }
-  };
-}
-function buildConversationStatePatch(conversation) {
-  return {
-    conversation: {
-      ...conversation,
-      schemaVersion: 1,
-      stats: {
-        ...conversation.stats,
-        totalMessageCount: conversation.messages.length,
-        updatedAtMs: Date.now()
-      }
-    }
-  };
-}
-
 // src/chat/state/artifacts.ts
 function coerceThreadArtifactsState(value) {
   if (!value || typeof value !== "object") {
@@ -10664,7 +10549,7 @@ function addAgentTurnUsage(...usages) {
 }
 
 // src/chat/services/turn-session-record.ts
-var AGENT_TURN_TIMEOUT_RESUME_MAX_SLICES = 48;
+var AGENT_CONTINUE_MAX_SLICES = 48;
 function logSessionRecordError(error, eventName, args, attributes, message) {
   logException(
     error,
@@ -10740,7 +10625,10 @@ async function persistRunningSessionRecord(args) {
       ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
       ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
       ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
-      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
+      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {},
+      ...(args.turnStartMessageIndex ?? latestSessionRecord?.turnStartMessageIndex) !== void 0 ? {
+        turnStartMessageIndex: args.turnStartMessageIndex ?? latestSessionRecord?.turnStartMessageIndex
+      } : {}
     });
     return true;
   } catch (recordError) {
@@ -10781,7 +10669,10 @@ async function persistCompletedSessionRecord(args) {
       ...args.surface ?? latestSessionRecord?.surface ? { surface: args.surface ?? latestSessionRecord?.surface } : {},
       ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
       ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
-      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
+      ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {},
+      ...(args.turnStartMessageIndex ?? latestSessionRecord?.turnStartMessageIndex) !== void 0 ? {
+        turnStartMessageIndex: args.turnStartMessageIndex ?? latestSessionRecord?.turnStartMessageIndex
+      } : {}
     });
   } catch (recordError) {
     logSessionRecordError(
@@ -10869,7 +10760,7 @@ async function persistTimeoutSessionRecord(args) {
       latestSessionRecord?.cumulativeUsage,
       args.currentUsage
     );
-    if (nextSliceId > AGENT_TURN_TIMEOUT_RESUME_MAX_SLICES) {
+    if (nextSliceId > AGENT_CONTINUE_MAX_SLICES) {
       return await upsertAgentTurnSessionRecord({
         ...args.channelName ?? latestSessionRecord?.channelName ? {
           channelName: args.channelName ?? latestSessionRecord?.channelName
@@ -10888,7 +10779,7 @@ async function persistTimeoutSessionRecord(args) {
         ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
         resumeReason: "timeout",
         resumedFromSliceId: latestSessionRecord?.resumedFromSliceId,
-        errorMessage: `Turn exceeded timeout resume slice limit (${AGENT_TURN_TIMEOUT_RESUME_MAX_SLICES})`,
+        errorMessage: `Agent continuation exceeded slice limit (${AGENT_CONTINUE_MAX_SLICES})`,
         ...args.requester ?? latestSessionRecord?.requester ? { requester: args.requester ?? latestSessionRecord?.requester } : {},
         ...getActiveTraceId() ?? latestSessionRecord?.traceId ? { traceId: getActiveTraceId() ?? latestSessionRecord?.traceId } : {}
       });
@@ -10914,13 +10805,13 @@ async function persistTimeoutSessionRecord(args) {
   } catch (recordError) {
     logSessionRecordError(
       recordError,
-      "agent_turn_timeout_resume_session_record_failed",
+      "agent_continue_session_record_failed",
       args,
       {
         "app.ai.resume_from_slice_id": args.currentSliceId,
         "app.ai.resume_next_slice_id": nextSliceId
       },
-      "Failed to persist timeout session record before scheduling resume"
+      "Failed to persist session record before scheduling agent continuation"
     );
     return void 0;
   }
@@ -11114,13 +11005,13 @@ var StateBackedMcpOAuthClientProvider = class {
     if (!this.sessionContext) {
       throw new Error(`Unknown MCP auth session: ${this.authSessionId}`);
     }
-    const now3 = Date.now();
+    const now2 = Date.now();
     const nextSession = {
       authSessionId: this.authSessionId,
       ...this.sessionContext,
       ...patch,
-      createdAtMs: now3,
-      updatedAtMs: now3
+      createdAtMs: now2,
+      updatedAtMs: now2
     };
     await putMcpAuthSession(nextSession);
     return nextSession;
@@ -11158,7 +11049,7 @@ async function createMcpOAuthClientProvider(input) {
     input.provider
   );
   const reusableSession = existingSession && existingSession.conversationId === input.conversationId && existingSession.sessionId === input.sessionId ? existingSession : void 0;
-  const now3 = Date.now();
+  const now2 = Date.now();
   const authSessionId = reusableSession?.authSessionId ?? randomUUID3();
   await putMcpAuthSession({
     authSessionId,
@@ -11175,8 +11066,8 @@ async function createMcpOAuthClientProvider(input) {
     ...input.artifactState ? { artifactState: input.artifactState } : {},
     ...reusableSession?.authorizationUrl ? { authorizationUrl: reusableSession.authorizationUrl } : {},
     ...reusableSession?.codeVerifier ? { codeVerifier: reusableSession.codeVerifier } : {},
-    createdAtMs: reusableSession?.createdAtMs ?? now3,
-    updatedAtMs: now3
+    createdAtMs: reusableSession?.createdAtMs ?? now2,
+    updatedAtMs: now2
   });
   return new StateBackedMcpOAuthClientProvider(
     authSessionId,
@@ -11415,18 +11306,15 @@ function extractSliceUsage(messages, beforeMessageCount) {
   );
   return hasAgentTurnUsage(usage) ? usage : void 0;
 }
-function requesterFromContext(requester, requesterId) {
-  const identity = actorRequesterFromContext(requester, requesterId);
-  const agentRequester = {
-    ...identity?.email ? { email: identity.email } : {},
-    ...identity?.fullName ? { fullName: identity.fullName } : {},
-    ...identity?.userId ? { slackUserId: identity.userId } : {},
-    ...identity?.userName ? { slackUserName: identity.userName } : {}
-  };
-  return Object.keys(agentRequester).length > 0 ? agentRequester : void 0;
+function requesterFromContext(context) {
+  const identity = actorRequesterFromContext(context);
+  return identity ? toStoredSlackRequester(identity) : void 0;
 }
-function actorRequesterFromContext(requester, requesterId) {
-  return buildActorIdentity(requester, requesterId);
+function actorRequesterFromContext(context) {
+  return createRequester(context.requester, {
+    teamId: context.destination?.teamId ?? context.correlation?.teamId ?? context.requester?.teamId,
+    userId: context.correlation?.requesterId
+  });
 }
 function surfaceFromContext(context) {
   if (context.surface) {
@@ -11544,6 +11432,7 @@ async function generateAssistantReply(messageText2, context = {}) {
   let timeoutResumeSliceId = 1;
   let timeoutResumeMessages = [];
   let beforeMessageCount = 0;
+  let turnStartMessageIndex;
   let lastKnownSandboxId = context.sandbox?.sandboxId;
   let lastKnownSandboxDependencyProfileHash = context.sandbox?.sandboxDependencyProfileHash;
   let loadedSkillNamesForResume = [];
@@ -11556,14 +11445,8 @@ async function generateAssistantReply(messageText2, context = {}) {
   let inputCommitted = false;
   let turnUsage;
   let thinkingSelection;
-  const requester = requesterFromContext(
-    context.requester,
-    context.correlation?.requesterId
-  );
-  const actorRequester = actorRequesterFromContext(
-    context.requester,
-    context.correlation?.requesterId
-  );
+  const requester = requesterFromContext(context);
+  const actorRequester = actorRequesterFromContext(context);
   const surface = surfaceFromContext(context);
   const credentialActor = context.credentialContext?.actor;
   const credentialActorLogContext = credentialActor ? {
@@ -12094,7 +11977,8 @@ async function generateAssistantReply(messageText2, context = {}) {
         loadedSkillNames: loadedSkillNamesForResume,
         logContext: sessionRecordLogContext,
         requester,
-        ...surface ? { surface } : {}
+        ...surface ? { surface } : {},
+        ...turnStartMessageIndex !== void 0 ? { turnStartMessageIndex } : {}
       });
       if (!persisted) {
         return false;
@@ -12229,10 +12113,14 @@ async function generateAssistantReply(messageText2, context = {}) {
           existingSessionRecord.piMessages,
           turnContextPrompt
         ) : existingSessionRecord.piMessages;
+        turnStartMessageIndex = existingSessionRecord.turnStartMessageIndex;
       } else if (context.piMessages && context.piMessages.length > 0) {
         agent.state.messages = [...context.piMessages];
       }
       beforeMessageCount = agent.state.messages.length;
+      if (!resumedFromSessionRecord) {
+        turnStartMessageIndex = beforeMessageCount;
+      }
       await withSpan(
         `invoke_agent ${botConfig.modelId}`,
         "gen_ai.invoke_agent",
@@ -12407,7 +12295,8 @@ async function generateAssistantReply(messageText2, context = {}) {
         loadedSkillNames: loadedSkillNamesForResume,
         logContext: sessionRecordLogContext,
         requester,
-        ...surface ? { surface } : {}
+        ...surface ? { surface } : {},
+        ...turnStartMessageIndex !== void 0 ? { turnStartMessageIndex } : {}
       });
     }
     return buildTurnResult({
@@ -12478,7 +12367,7 @@ async function generateAssistantReply(messageText2, context = {}) {
       }
       if (sessionRecord.state === "awaiting_resume") {
         throw new RetryableTurnError(
-          "turn_timeout_resume",
+          "agent_continue",
           `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${sessionRecord.sliceId} version=${sessionRecord.version}`,
           {
             conversationId: timeoutResumeConversationId,
@@ -13871,7 +13760,7 @@ async function runAgentDispatchSlice(callback, deps = {}) {
       });
       return;
     }
-    if (isRetryableTurnError(error, "turn_timeout_resume")) {
+    if (isRetryableTurnError(error, "agent_continue")) {
       const version = error.metadata?.version;
       if (typeof version === "number") {
         const awaiting = await markDispatch({
@@ -13932,828 +13821,36 @@ async function POST(request, waitUntil) {
 }
 
 // src/handlers/heartbeat.ts
-import { timingSafeEqual as timingSafeEqual4 } from "crypto";
+import { timingSafeEqual as timingSafeEqual3 } from "crypto";
 
-// src/chat/services/timeout-resume.ts
-import { createHmac as createHmac3, timingSafeEqual as timingSafeEqual3 } from "crypto";
-
-// src/chat/task-execution/store.ts
-import { randomUUID as randomUUID4 } from "crypto";
-var CONVERSATION_WORK_PREFIX = "junior:conversation-work";
-var CONVERSATION_WORK_SCHEMA_VERSION = 1;
-var CONVERSATION_WORK_INDEX_MAX_LENGTH = 1e4;
-var CONVERSATION_WORK_INDEX_LOCK_TTL_MS = 1e4;
-var CONVERSATION_WORK_INDEX_LOCK_WAIT_MS = 2e3;
-var CONVERSATION_WORK_INDEX_LOCK_RETRY_MS = 25;
-var CONVERSATION_WORK_MUTATION_LOCK_TTL_MS = 1e4;
-var CONVERSATION_WORK_MUTATION_WAIT_MS = 1e4;
-var CONVERSATION_WORK_MUTATION_RETRY_MS = 25;
-var CONVERSATION_WORK_LEASE_TTL_MS = 9e4;
-var CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15e3;
-var CONVERSATION_WORK_STALE_ENQUEUE_MS = 6e4;
-var CONVERSATION_WORK_MAX_CONSECUTIVE_FAILURES = 5;
-function duplicateInboundNudgeIdempotencyKey(message, nowMs) {
-  return `duplicate:${message.conversationId}:${message.inboundMessageId}:${nowMs}`;
-}
-function hasRecentEnqueueMarker(state, nowMs) {
-  return typeof state.lastEnqueuedAtMs === "number" && state.lastEnqueuedAtMs + CONVERSATION_WORK_STALE_ENQUEUE_MS > nowMs;
-}
-function stateKey(conversationId) {
-  return `${CONVERSATION_WORK_PREFIX}:state:${conversationId}`;
-}
-function indexKey() {
-  return `${CONVERSATION_WORK_PREFIX}:index`;
-}
-function indexLockKey() {
-  return `${CONVERSATION_WORK_PREFIX}:index:lock`;
-}
-function mutationLockKey(conversationId) {
-  return `${CONVERSATION_WORK_PREFIX}:mutation:${conversationId}`;
-}
-function now() {
-  return Date.now();
-}
-function uniqueStrings(values) {
-  return [
-    ...new Set(
-      values.filter((value) => {
-        return typeof value === "string" && value.trim().length > 0;
-      })
-    )
-  ];
-}
-function compareMessages(left, right) {
-  return left.createdAtMs - right.createdAtMs || left.receivedAtMs - right.receivedAtMs || left.inboundMessageId.localeCompare(right.inboundMessageId);
-}
-function normalizeSource(value) {
-  if (value === "plugin" || value === "scheduler" || value === "slack") {
-    return value;
-  }
-  return void 0;
-}
-function normalizeMetadata2(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  return value;
-}
-function normalizeInput(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const text = toOptionalString(value.text);
-  if (!text) {
-    return void 0;
-  }
-  return {
-    text,
-    authorId: toOptionalString(value.authorId),
-    attachments: Array.isArray(value.attachments) ? [...value.attachments] : void 0,
-    metadata: normalizeMetadata2(value.metadata)
-  };
+// src/chat/task-execution/heartbeat.ts
+var DEFAULT_RECOVERY_LIMIT = 25;
+function heartbeatIdempotencyKey(reason, conversationId, nowMs) {
+  return `heartbeat:${reason}:${conversationId}:${nowMs}`;
 }
-function normalizeMessage(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const conversationId = toOptionalString(value.conversationId);
-  const inboundMessageId = toOptionalString(value.inboundMessageId);
-  const source = normalizeSource(value.source);
-  const destination = parseDestination(value.destination);
-  const createdAtMs = toOptionalNumber(value.createdAtMs);
-  const receivedAtMs = toOptionalNumber(value.receivedAtMs);
-  const input = normalizeInput(value.input);
-  if (!conversationId || !destination || !inboundMessageId || !source || typeof createdAtMs !== "number" || typeof receivedAtMs !== "number" || !input) {
-    return void 0;
-  }
-  return {
-    conversationId,
-    destination,
-    inboundMessageId,
-    source,
-    createdAtMs,
-    receivedAtMs,
-    input,
-    injectedAtMs: toOptionalNumber(value.injectedAtMs)
-  };
+async function sendRecoveryNudge(args) {
+  await args.queue.send(
+    {
+      conversationId: args.conversationId,
+      destination: args.destination
+    },
+    { idempotencyKey: args.idempotencyKey }
+  );
+  await markConversationWorkEnqueued({
+    conversationId: args.conversationId,
+    nowMs: args.nowMs,
+    state: args.state
+  });
 }
-function normalizeLease(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const leaseToken = toOptionalString(value.leaseToken);
-  const acquiredAtMs = toOptionalNumber(value.acquiredAtMs);
-  const lastCheckInAtMs = toOptionalNumber(value.lastCheckInAtMs);
-  const leaseExpiresAtMs = toOptionalNumber(value.leaseExpiresAtMs);
-  if (!leaseToken || typeof acquiredAtMs !== "number" || typeof lastCheckInAtMs !== "number" || typeof leaseExpiresAtMs !== "number") {
-    return void 0;
-  }
-  return {
-    leaseToken,
-    acquiredAtMs,
-    lastCheckInAtMs,
-    leaseExpiresAtMs
+async function recoverConversationWork(args) {
+  const result = {
+    expiredLeaseCount: 0,
+    pendingCount: 0
   };
-}
-function normalizeWorkState(conversationId, value) {
-  if (!isRecord(value) || value.schemaVersion !== CONVERSATION_WORK_SCHEMA_VERSION) {
-    return void 0;
-  }
-  const storedConversationId = toOptionalString(value.conversationId);
-  const destination = parseDestination(value.destination);
-  const updatedAtMs = toOptionalNumber(value.updatedAtMs);
-  if (storedConversationId !== conversationId || !destination || typeof updatedAtMs !== "number") {
-    return void 0;
-  }
-  const messages = Array.isArray(value.messages) ? value.messages.map(normalizeMessage).filter((message) => Boolean(message)).filter((message) => message.conversationId === conversationId).sort(compareMessages) : [];
-  return {
-    schemaVersion: CONVERSATION_WORK_SCHEMA_VERSION,
-    conversationId,
-    destination,
-    messages,
-    needsRun: value.needsRun === true,
-    updatedAtMs,
-    consecutiveFailureCount: toOptionalNumber(value.consecutiveFailureCount) ?? 0,
-    lastEnqueuedAtMs: toOptionalNumber(value.lastEnqueuedAtMs),
-    lastFailureAtMs: toOptionalNumber(value.lastFailureAtMs),
-    lease: normalizeLease(value.lease),
-    terminallyFailedAtMs: toOptionalNumber(value.terminallyFailedAtMs)
-  };
-}
-function emptyWorkState(args) {
-  return {
-    schemaVersion: CONVERSATION_WORK_SCHEMA_VERSION,
-    conversationId: args.conversationId,
-    consecutiveFailureCount: 0,
-    destination: args.destination,
-    messages: [],
-    needsRun: false,
-    updatedAtMs: args.nowMs
-  };
-}
-function isLeaseActive(lease, nowMs) {
-  return Boolean(lease && lease.leaseExpiresAtMs > nowMs);
-}
-function pendingMessages(state) {
-  return state.messages.filter((message) => message.injectedAtMs === void 0).sort(compareMessages);
-}
-function shouldKeepIndexed(state) {
-  if (state.terminallyFailedAtMs !== void 0) {
-    return false;
-  }
-  return state.needsRun || Boolean(state.lease) || pendingMessages(state).length > 0;
-}
-async function getConnectedState(stateAdapter) {
-  const state = stateAdapter ?? getStateAdapter();
-  await state.connect();
-  return state;
-}
-async function sleep3(ms) {
-  await new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
-    timer.unref?.();
-  });
-}
-async function withIndexLock(state, callback) {
-  const startedAtMs = now();
-  let lock;
-  while (true) {
-    lock = await state.acquireLock(
-      indexLockKey(),
-      CONVERSATION_WORK_INDEX_LOCK_TTL_MS
-    );
-    if (lock) {
-      break;
-    }
-    if (now() - startedAtMs >= CONVERSATION_WORK_INDEX_LOCK_WAIT_MS) {
-      throw new Error("Could not acquire conversation work index lock");
-    }
-    await sleep3(CONVERSATION_WORK_INDEX_LOCK_RETRY_MS);
-  }
-  try {
-    return await callback();
-  } finally {
-    await state.releaseLock(lock);
-  }
-}
-async function addToIndex(state, conversationId) {
-  await withIndexLock(state, async () => {
-    const existing = uniqueStrings(
-      await state.get(indexKey()) ?? []
-    );
-    if (existing.includes(conversationId)) {
-      return;
-    }
-    const indexed = [...existing, conversationId];
-    const remove = /* @__PURE__ */ new Set();
-    for (const id of indexed) {
-      if (indexed.length - remove.size <= CONVERSATION_WORK_INDEX_MAX_LENGTH) {
-        break;
-      }
-      const work = await readWorkState(state, id);
-      if (!work || !shouldKeepIndexed(work)) {
-        remove.add(id);
-      }
-    }
-    await state.set(
-      indexKey(),
-      indexed.filter((id) => !remove.has(id)),
-      JUNIOR_THREAD_STATE_TTL_MS
-    );
-  });
-}
-async function removeFromIndex(state, conversationId) {
-  await withIndexLock(state, async () => {
-    const existing = uniqueStrings(
-      await state.get(indexKey()) ?? []
-    );
-    const next = existing.filter((id) => id !== conversationId);
-    if (next.length === existing.length) {
-      return;
-    }
-    await state.set(indexKey(), next, JUNIOR_THREAD_STATE_TTL_MS);
-  });
-}
-async function acquireMutationLock(state, conversationId) {
-  const startedAtMs = now();
-  while (true) {
-    const lock = await state.acquireLock(
-      mutationLockKey(conversationId),
-      CONVERSATION_WORK_MUTATION_LOCK_TTL_MS
-    );
-    if (lock) {
-      return lock;
-    }
-    if (now() - startedAtMs >= CONVERSATION_WORK_MUTATION_WAIT_MS) {
-      throw new Error(
-        `Could not acquire conversation work mutation lock for ${conversationId}`
-      );
-    }
-    await sleep3(CONVERSATION_WORK_MUTATION_RETRY_MS);
-  }
-}
-async function withConversationMutation(args, callback) {
-  const state = await getConnectedState(args.state);
-  const lock = await acquireMutationLock(state, args.conversationId);
-  try {
-    return await callback(state);
-  } finally {
-    await state.releaseLock(lock);
-  }
-}
-async function readWorkState(state, conversationId) {
-  const raw = await state.get(stateKey(conversationId));
-  if (raw == null) {
-    return void 0;
-  }
-  const work = normalizeWorkState(conversationId, raw);
-  if (!work) {
-    throw new Error(`Conversation work state is invalid for ${conversationId}`);
-  }
-  return work;
-}
-async function writeWorkState(state, work) {
-  await state.set(
-    stateKey(work.conversationId),
-    work,
-    JUNIOR_THREAD_STATE_TTL_MS
-  );
-  if (shouldKeepIndexed(work)) {
-    await addToIndex(state, work.conversationId);
-  } else {
-    await removeFromIndex(state, work.conversationId);
-  }
-}
-function hasRunnableWork(state) {
-  if (state.terminallyFailedAtMs !== void 0) {
-    return false;
-  }
-  return state.needsRun || pendingMessages(state).length > 0;
-}
-function assertSameConversationDestination(args) {
-  if (sameDestination(args.current, args.next)) {
-    return;
-  }
-  throw new Error(
-    `Conversation work destination changed for ${args.conversationId}`
-  );
-}
-async function getConversationWorkState(args) {
-  const state = await getConnectedState(args.state);
-  return await readWorkState(state, args.conversationId);
-}
-function countPendingConversationMessages(state) {
-  return pendingMessages(state).length;
-}
-function hasRunnableConversationWork(state) {
-  return hasRunnableWork(state);
-}
-async function appendInboundMessage(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(
-    { conversationId: args.message.conversationId, state: args.state },
-    async (state) => {
-      const current = await readWorkState(state, args.message.conversationId) ?? emptyWorkState({
-        conversationId: args.message.conversationId,
-        destination: args.message.destination,
-        nowMs
-      });
-      assertSameConversationDestination({
-        conversationId: args.message.conversationId,
-        current: current.destination,
-        next: args.message.destination
-      });
-      const existing = current.messages.find(
-        (message) => message.inboundMessageId === args.message.inboundMessageId
-      );
-      if (existing) {
-        const next2 = {
-          ...current,
-          needsRun: current.needsRun || existing.injectedAtMs === void 0,
-          updatedAtMs: nowMs
-        };
-        await writeWorkState(state, next2);
-        return { status: "duplicate" };
-      }
-      const next = {
-        ...current,
-        consecutiveFailureCount: 0,
-        lastFailureAtMs: void 0,
-        messages: [...current.messages, args.message].sort(compareMessages),
-        needsRun: true,
-        terminallyFailedAtMs: void 0,
-        updatedAtMs: nowMs
-      };
-      await writeWorkState(state, next);
-      return { status: "appended" };
-    }
-  );
-}
-async function appendAndEnqueueInboundMessage(args) {
-  const nowMs = args.nowMs ?? now();
-  const appendResult = await appendInboundMessage({
-    message: args.message,
-    nowMs,
-    state: args.state
-  });
-  let idempotencyKey = args.message.inboundMessageId;
-  if (appendResult.status === "duplicate") {
-    const work = await getConversationWorkState({
-      conversationId: args.message.conversationId,
-      state: args.state
-    });
-    if (!work || hasRecentEnqueueMarker(work, nowMs)) {
-      return appendResult;
-    }
-    idempotencyKey = duplicateInboundNudgeIdempotencyKey(args.message, nowMs);
-  }
-  const queueResult = await args.queue.send(
-    {
-      conversationId: args.message.conversationId,
-      destination: args.message.destination
-    },
-    { idempotencyKey }
-  );
-  await markConversationWorkEnqueued({
-    conversationId: args.message.conversationId,
-    nowMs,
-    state: args.state
-  });
-  return {
-    ...appendResult,
-    queueMessageId: queueResult?.messageId
-  };
-}
-async function requestConversationWork(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state) => {
-    const existing = await readWorkState(state, args.conversationId);
-    if (existing) {
-      assertSameConversationDestination({
-        conversationId: args.conversationId,
-        current: existing.destination,
-        next: args.destination
-      });
-    }
-    const current = existing ?? emptyWorkState({
-      conversationId: args.conversationId,
-      destination: args.destination,
-      nowMs
-    });
-    await writeWorkState(state, {
-      ...current,
-      needsRun: true,
-      updatedAtMs: nowMs
-    });
-    return { status: existing === void 0 ? "created" : "updated" };
-  });
-}
-async function markConversationWorkEnqueued(args) {
-  const nowMs = args.nowMs ?? now();
-  await withConversationMutation(args, async (state) => {
-    const current = await readWorkState(state, args.conversationId);
-    if (!current) {
-      return;
-    }
-    await writeWorkState(state, {
-      ...current,
-      lastEnqueuedAtMs: nowMs,
-      updatedAtMs: nowMs
-    });
-  });
-}
-async function startConversationWork(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state) => {
-    const current = await readWorkState(state, args.conversationId);
-    if (!current) {
-      return { status: "no_work" };
-    }
-    if (isLeaseActive(current.lease, nowMs)) {
-      return {
-        status: "active",
-        leaseExpiresAtMs: current.lease.leaseExpiresAtMs
-      };
-    }
-    if (!hasRunnableWork(current)) {
-      return { status: "no_work" };
-    }
-    const lease = {
-      leaseToken: randomUUID4(),
-      acquiredAtMs: nowMs,
-      lastCheckInAtMs: nowMs,
-      leaseExpiresAtMs: nowMs + CONVERSATION_WORK_LEASE_TTL_MS
-    };
-    await writeWorkState(state, {
-      ...current,
-      lease,
-      needsRun: false,
-      updatedAtMs: nowMs
-    });
-    return {
-      status: "acquired",
-      leaseToken: lease.leaseToken,
-      leaseExpiresAtMs: lease.leaseExpiresAtMs
-    };
-  });
-}
-async function checkInConversationWork(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state) => {
-    const current = await readWorkState(state, args.conversationId);
-    if (!current || current.lease?.leaseToken !== args.leaseToken) {
-      return false;
-    }
-    await writeWorkState(state, {
-      ...current,
-      lease: {
-        ...current.lease,
-        lastCheckInAtMs: nowMs,
-        leaseExpiresAtMs: nowMs + CONVERSATION_WORK_LEASE_TTL_MS
-      },
-      updatedAtMs: nowMs
-    });
-    return true;
-  });
-}
-async function drainConversationMailbox(args) {
-  const nowMs = args.nowMs ?? now();
-  const pending = await withConversationMutation(args, async (state) => {
-    const current = await readWorkState(state, args.conversationId);
-    if (!current || current.lease?.leaseToken !== args.leaseToken) {
-      throw new Error(
-        `Conversation work lease is not held for ${args.conversationId}`
-      );
-    }
-    return pendingMessages(current);
-  });
-  if (pending.length === 0) {
-    return [];
-  }
-  await args.inject(pending);
-  await withConversationMutation(args, async (state) => {
-    const current = await readWorkState(state, args.conversationId);
-    if (!current || current.lease?.leaseToken !== args.leaseToken) {
-      throw new Error(
-        `Conversation work lease is not held for ${args.conversationId}`
-      );
-    }
-    const drainedIds = new Set(
-      pending.map((message) => message.inboundMessageId)
-    );
-    const messages = current.messages.map(
-      (message) => drainedIds.has(message.inboundMessageId) ? { ...message, injectedAtMs: nowMs } : message
-    );
-    const hasPending = messages.some(
-      (message) => message.injectedAtMs === void 0
-    );
-    await writeWorkState(state, {
-      ...current,
-      consecutiveFailureCount: 0,
-      lastFailureAtMs: void 0,
-      messages,
-      needsRun: hasPending,
-      updatedAtMs: nowMs
-    });
-  });
-  return pending;
-}
-async function markConversationMessagesInjected(args) {
-  const nowMs = args.nowMs ?? now();
-  const inboundMessageIds = new Set(args.inboundMessageIds);
-  return await withConversationMutation(args, async (state) => {
-    const current = await readWorkState(state, args.conversationId);
-    if (!current || current.lease?.leaseToken !== args.leaseToken) {
-      return false;
-    }
-    if (inboundMessageIds.size === 0) {
-      return true;
-    }
-    let changed = false;
-    const messages = current.messages.map((message) => {
-      if (!inboundMessageIds.has(message.inboundMessageId) || message.injectedAtMs !== void 0) {
-        return message;
-      }
-      changed = true;
-      return { ...message, injectedAtMs: nowMs };
-    });
-    if (!changed) {
-      return true;
-    }
-    await writeWorkState(state, {
-      ...current,
-      consecutiveFailureCount: 0,
-      lastFailureAtMs: void 0,
-      messages,
-      updatedAtMs: nowMs
-    });
-    return true;
-  });
-}
-async function requestConversationContinuation(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state) => {
-    const current = await readWorkState(state, args.conversationId);
-    if (!current || current.lease?.leaseToken !== args.leaseToken) {
-      return false;
-    }
-    assertSameConversationDestination({
-      conversationId: args.conversationId,
-      current: current.destination,
-      next: args.destination
-    });
-    await writeWorkState(state, {
-      ...current,
-      needsRun: true,
-      updatedAtMs: nowMs
-    });
-    return true;
-  });
-}
-async function releaseConversationWork(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state) => {
-    const current = await readWorkState(state, args.conversationId);
-    if (!current || current.lease?.leaseToken !== args.leaseToken) {
-      return false;
-    }
-    await writeWorkState(state, {
-      ...current,
-      lease: void 0,
-      updatedAtMs: nowMs
-    });
-    return true;
-  });
-}
-async function completeConversationWork(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state) => {
-    const current = await readWorkState(state, args.conversationId);
-    if (!current || current.lease?.leaseToken !== args.leaseToken) {
-      return "lost_lease";
-    }
-    const hasPending = pendingMessages(current).length > 0;
-    const hasRunnableWork2 = current.needsRun || hasPending;
-    await writeWorkState(state, {
-      ...current,
-      consecutiveFailureCount: 0,
-      lastFailureAtMs: void 0,
-      lease: void 0,
-      needsRun: hasRunnableWork2,
-      updatedAtMs: nowMs
-    });
-    return hasRunnableWork2 ? "pending" : "completed";
-  });
-}
-async function clearExpiredConversationLease(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state) => {
-    const current = await readWorkState(state, args.conversationId);
-    if (!current?.lease || current.lease.leaseExpiresAtMs > nowMs) {
-      return false;
-    }
-    await writeWorkState(state, {
-      ...current,
-      lease: void 0,
-      needsRun: true,
-      updatedAtMs: nowMs
-    });
-    return true;
-  });
-}
-async function recordConversationWorkFailure(args) {
-  const nowMs = args.nowMs ?? now();
-  return await withConversationMutation(args, async (state) => {
-    const current = await readWorkState(state, args.conversationId);
-    if (!current) {
-      return {
-        abandoned: false,
-        consecutiveFailureCount: 0,
-        releasedLease: false
-      };
-    }
-    const consecutiveFailureCount = current.consecutiveFailureCount + 1;
-    const abandoned = consecutiveFailureCount >= CONVERSATION_WORK_MAX_CONSECUTIVE_FAILURES;
-    if (!abandoned) {
-      await writeWorkState(state, {
-        ...current,
-        consecutiveFailureCount,
-        lastFailureAtMs: nowMs,
-        updatedAtMs: nowMs
-      });
-      return {
-        abandoned: false,
-        consecutiveFailureCount,
-        releasedLease: false
-      };
-    }
-    const releasedLease = Boolean(current.lease);
-    const drainedMessages = current.messages.filter(
-      (message) => message.injectedAtMs !== void 0
-    );
-    await writeWorkState(state, {
-      ...current,
-      consecutiveFailureCount,
-      lastFailureAtMs: nowMs,
-      lease: void 0,
-      messages: drainedMessages,
-      needsRun: false,
-      terminallyFailedAtMs: nowMs,
-      updatedAtMs: nowMs
-    });
-    return {
-      abandoned: true,
-      consecutiveFailureCount,
-      releasedLease
-    };
-  });
-}
-async function listConversationWorkIds(args = {}) {
-  const state = await getConnectedState(args.state);
-  const ids = uniqueStrings(await state.get(indexKey()) ?? []);
-  return ids.slice(0, args.limit ?? ids.length);
-}
-
-// src/chat/services/timeout-resume.ts
-var TURN_TIMEOUT_RESUME_HMAC_CONTEXT = "junior.turn_timeout_resume.v1";
-var TURN_TIMEOUT_RESUME_SIGNATURE_VERSION = "v1";
-var TURN_TIMEOUT_RESUME_MAX_SKEW_MS = 5 * 60 * 1e3;
-var TURN_TIMEOUT_RESUME_TIMESTAMP_HEADER = "x-junior-resume-timestamp";
-var TURN_TIMEOUT_RESUME_SIGNATURE_HEADER = "x-junior-resume-signature";
-async function getAwaitingTurnContinuationRequest(args) {
-  const sessionRecord = await getAgentTurnSessionRecord(
-    args.conversationId,
-    args.sessionId
-  );
-  if (!sessionRecord || sessionRecord.state !== "awaiting_resume" || sessionRecord.resumeReason !== "timeout" && sessionRecord.resumeReason !== "yield" || sessionRecord.resumeReason === "timeout" && sessionRecord.sliceId < 2) {
-    return void 0;
-  }
-  if (!sessionRecord.destination) {
-    return void 0;
-  }
-  return {
-    conversationId: args.conversationId,
-    destination: sessionRecord.destination,
-    sessionId: args.sessionId,
-    expectedVersion: sessionRecord.version
-  };
-}
-function getTurnTimeoutResumeSecret() {
-  return process.env.JUNIOR_SECRET?.trim() || void 0;
-}
-function buildSignedPayload2(timestamp, body) {
-  return `${TURN_TIMEOUT_RESUME_HMAC_CONTEXT}:${timestamp}:${body}`;
-}
-function signTurnTimeoutResumeBody(secret, timestamp, body) {
-  const digest = createHmac3("sha256", secret).update(buildSignedPayload2(timestamp, body)).digest("hex");
-  return `${TURN_TIMEOUT_RESUME_SIGNATURE_VERSION}=${digest}`;
-}
-function timingSafeMatch3(expected, actual) {
-  const expectedBuffer = Buffer.from(expected);
-  const actualBuffer = Buffer.from(actual);
-  if (expectedBuffer.length !== actualBuffer.length) {
-    return false;
-  }
-  return timingSafeEqual3(expectedBuffer, actualBuffer);
-}
-function parseTurnTimeoutResumeRequest(value) {
-  if (!value || typeof value !== "object") {
-    return void 0;
-  }
-  const record = value;
-  const destination = parseDestination(record.destination);
-  let expectedVersion = record.expectedVersion;
-  if (typeof expectedVersion !== "number") {
-    expectedVersion = record.expectedCheckpointVersion;
-  }
-  if (typeof record.conversationId !== "string" || typeof record.sessionId !== "string" || typeof expectedVersion !== "number" || !destination) {
-    return void 0;
-  }
-  return {
-    conversationId: record.conversationId,
-    destination,
-    sessionId: record.sessionId,
-    expectedVersion
-  };
-}
-async function scheduleTurnTimeoutResume(request, options = {}) {
-  const nowMs = options.nowMs ?? Date.now();
-  await requestConversationWork({
-    conversationId: request.conversationId,
-    destination: request.destination,
-    nowMs,
-    state: options.state
-  });
-  const queue = options.queue ?? getVercelConversationWorkQueue();
-  await queue.send(
-    {
-      conversationId: request.conversationId,
-      destination: request.destination
-    },
-    {
-      idempotencyKey: [
-        "timeout",
-        request.conversationId,
-        request.sessionId,
-        request.expectedVersion
-      ].join(":")
-    }
-  );
-  await markConversationWorkEnqueued({
-    conversationId: request.conversationId,
-    nowMs,
-    state: options.state
-  });
-}
-async function verifyTurnTimeoutResumeRequest(request) {
-  const timestamp = request.headers.get(TURN_TIMEOUT_RESUME_TIMESTAMP_HEADER)?.trim() ?? "";
-  const signature = request.headers.get(TURN_TIMEOUT_RESUME_SIGNATURE_HEADER)?.trim() ?? "";
-  const secret = getTurnTimeoutResumeSecret();
-  if (!timestamp || !signature || !secret) {
-    return void 0;
-  }
-  const parsedTimestamp = Number.parseInt(timestamp, 10);
-  if (!Number.isFinite(parsedTimestamp) || Math.abs(Date.now() - parsedTimestamp) > TURN_TIMEOUT_RESUME_MAX_SKEW_MS) {
-    return void 0;
-  }
-  const body = await request.text();
-  const expectedSignature = signTurnTimeoutResumeBody(secret, timestamp, body);
-  if (!timingSafeMatch3(expectedSignature, signature)) {
-    return void 0;
-  }
-  try {
-    return parseTurnTimeoutResumeRequest(JSON.parse(body));
-  } catch {
-    return void 0;
-  }
-}
-
-// src/chat/task-execution/heartbeat.ts
-var DEFAULT_RECOVERY_LIMIT = 25;
-function heartbeatIdempotencyKey(reason, conversationId, nowMs) {
-  return `heartbeat:${reason}:${conversationId}:${nowMs}`;
-}
-async function sendRecoveryNudge(args) {
-  await args.queue.send(
-    {
-      conversationId: args.conversationId,
-      destination: args.destination
-    },
-    { idempotencyKey: args.idempotencyKey }
-  );
-  await markConversationWorkEnqueued({
-    conversationId: args.conversationId,
-    nowMs: args.nowMs,
-    state: args.state
-  });
-}
-async function recoverConversationWork(args) {
-  const result = {
-    expiredLeaseCount: 0,
-    pendingCount: 0
-  };
-  const ids = await listConversationWorkIds({
+  const staleBeforeMs = args.nowMs - CONVERSATION_WORK_STALE_ENQUEUE_MS;
+  const ids = await listActiveConversationIds({
     limit: args.limit ?? DEFAULT_RECOVERY_LIMIT,
+    staleBeforeMs,
     state: args.state
   });
   for (const conversationId of ids) {
@@ -14763,9 +13860,24 @@ async function recoverConversationWork(args) {
         state: args.state
       });
       if (!work) {
+        await removeActiveConversation({
+          conversationId,
+          state: args.state
+        });
+        continue;
+      }
+      if (work.execution.status === "idle") {
+        await removeActiveConversation({
+          conversationId,
+          state: args.state
+        });
+        continue;
+      }
+      const destination = work.destination;
+      if (!destination) {
         continue;
       }
-      if (work.lease && work.lease.leaseExpiresAtMs <= args.nowMs) {
+      if (work.execution.lease && work.execution.lease.expiresAtMs <= args.nowMs) {
         const cleared = await clearExpiredConversationLease({
           conversationId,
           nowMs: args.nowMs,
@@ -14776,7 +13888,7 @@ async function recoverConversationWork(args) {
         }
         await sendRecoveryNudge({
           conversationId,
-          destination: work.destination,
+          destination,
           idempotencyKey: heartbeatIdempotencyKey(
             "lease",
             conversationId,
@@ -14795,15 +13907,15 @@ async function recoverConversationWork(args) {
         );
         continue;
       }
-      if (work.lease || !hasRunnableConversationWork(work)) {
+      if (work.execution.lease || !hasRunnableConversationWork(work)) {
         continue;
       }
-      if (typeof work.lastEnqueuedAtMs === "number" && work.lastEnqueuedAtMs + CONVERSATION_WORK_STALE_ENQUEUE_MS > args.nowMs) {
+      if (typeof work.execution.lastEnqueuedAtMs === "number" && work.execution.lastEnqueuedAtMs + CONVERSATION_WORK_STALE_ENQUEUE_MS > args.nowMs) {
         continue;
       }
       await sendRecoveryNudge({
         conversationId,
-        destination: work.destination,
+        destination,
         idempotencyKey: heartbeatIdempotencyKey(
           "pending",
           conversationId,
@@ -15016,8 +14128,6 @@ var DEFAULT_RECOVERY_LIMIT2 = 25;
 var DEFAULT_PLUGIN_LIMIT = 25;
 var DISPATCH_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var PLUGIN_HEARTBEAT_TIMEOUT_MS = 25e3;
-var TIMEOUT_RESUME_STALE_MS = 2 * 60 * 1e3;
-var TIMEOUT_RESUME_RECOVERY_SCAN_LIMIT = 500;
 function isStaleDispatch(args) {
   if (args.record.status === "running") {
     return typeof args.record.leaseExpiresAtMs === "number" && args.record.leaseExpiresAtMs <= args.nowMs;
@@ -15062,63 +14172,6 @@ async function runWithTimeout(promise, timeoutMs) {
     }
   }
 }
-async function recoverStaleTimeoutResumes(args) {
-  const summaries = await listAgentTurnSessionSummaries(
-    TIMEOUT_RESUME_RECOVERY_SCAN_LIMIT
-  );
-  let recovered = 0;
-  for (const summary of summaries) {
-    if (recovered >= (args.limit ?? DEFAULT_RECOVERY_LIMIT2)) {
-      break;
-    }
-    if (summary.state !== "awaiting_resume" || summary.resumeReason !== "timeout" && summary.resumeReason !== "yield" || summary.updatedAtMs + TIMEOUT_RESUME_STALE_MS > args.nowMs) {
-      continue;
-    }
-    try {
-      const persistedState = await getPersistedThreadState(
-        summary.conversationId
-      );
-      const conversation = coerceThreadConversationState(persistedState);
-      if (conversation.processing.activeTurnId !== summary.sessionId) {
-        continue;
-      }
-      const request = await getAwaitingTurnContinuationRequest({
-        conversationId: summary.conversationId,
-        sessionId: summary.sessionId
-      });
-      if (!request) {
-        continue;
-      }
-      await scheduleTurnTimeoutResume(request, {
-        queue: args.conversationWorkQueue
-      });
-      recovered += 1;
-      logInfo(
-        "agent_turn_timeout_resume_recovery_scheduled",
-        {},
-        {
-          "app.ai.conversation_id": summary.conversationId,
-          "app.ai.session_id": summary.sessionId,
-          "app.ai.resume_session_version": request.expectedVersion,
-          "app.ai.resume_slice_id": summary.sliceId
-        },
-        "Heartbeat rescheduled stale timeout resume"
-      );
-    } catch (error) {
-      logException(
-        error,
-        "agent_turn_timeout_resume_recovery_failed",
-        {},
-        {
-          "app.ai.conversation_id": summary.conversationId,
-          "app.ai.session_id": summary.sessionId
-        },
-        "Heartbeat timeout resume recovery failed"
-      );
-    }
-  }
-  return recovered;
-}
 async function recoverStaleDispatches(args) {
   const ids = await listIncompleteDispatchIds();
   let recovered = 0;
@@ -15216,10 +14269,6 @@ async function runHeartbeat(args) {
     nowMs: args.nowMs,
     queue: args.conversationWorkQueue ?? getVercelConversationWorkQueue()
   });
-  await recoverStaleTimeoutResumes({
-    conversationWorkQueue: args.conversationWorkQueue,
-    nowMs: args.nowMs
-  });
   await recoverStaleDispatches({ nowMs: args.nowMs });
   await runPluginHeartbeats({ nowMs: args.nowMs });
 }
@@ -15239,7 +14288,7 @@ function verifyHeartbeatRequest(request) {
   }
   const actual = Buffer.from(authorization.slice("Bearer ".length));
   const expected = Buffer.from(secret);
-  return actual.length === expected.length && timingSafeEqual4(actual, expected);
+  return actual.length === expected.length && timingSafeEqual3(actual, expected);
 }
 async function GET2(request, waitUntil, options = {}) {
   if (!verifyHeartbeatRequest(request)) {
@@ -15399,7 +14448,7 @@ var STATUS_UPDATE_DEBOUNCE_MS = 1e3;
 var STATUS_MIN_VISIBLE_MS = 1200;
 var STATUS_ROTATION_INTERVAL_MS = 3e4;
 function createAssistantStatusScheduler(args) {
-  const now3 = args.now ?? (() => Date.now());
+  const now2 = args.now ?? (() => Date.now());
   const setTimer = args.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
   const clearTimer = args.clearTimer ?? ((timer) => clearTimeout(timer));
   const random = args.random ?? Math.random;
@@ -15463,7 +14512,7 @@ function createAssistantStatusScheduler(args) {
     }
     currentVisibleStatus = text;
     currentLoadingMessages = nextLoadingMessages;
-    lastStatusAt = now3();
+    lastStatusAt = now2();
     scheduleRotation();
     await enqueueStatusUpdate(async () => {
       await args.sendStatus(text, nextLoadingMessages);
@@ -15546,7 +14595,7 @@ function createAssistantStatusScheduler(args) {
         }
         return;
       }
-      const elapsed = now3() - lastStatusAt;
+      const elapsed = now2() - lastStatusAt;
       const waitMs = Math.max(
         STATUS_UPDATE_DEBOUNCE_MS - elapsed,
         STATUS_MIN_VISIBLE_MS - elapsed,
@@ -16224,7 +15273,7 @@ async function resumeSlackTurn(args) {
       deferredPauseHandler = async () => {
         await onAuthPause(error);
       };
-    } else if (isRetryableTurnError(error, "turn_timeout_resume") && onTimeoutPause) {
+    } else if (isRetryableTurnError(error, "agent_continue") && onTimeoutPause) {
       deferredPauseKind = "timeout";
       deferredPauseHandler = async () => {
         await onTimeoutPause(error);
@@ -16332,6 +15381,56 @@ async function persistAuthPauseTurnState(args) {
   await persistThreadStateById(args.threadStateId, { conversation });
 }
 
+// src/chat/services/agent-continue.ts
+async function getAwaitingAgentContinueRequest(args) {
+  const sessionRecord = await getAgentTurnSessionRecord(
+    args.conversationId,
+    args.sessionId
+  );
+  if (!sessionRecord || sessionRecord.state !== "awaiting_resume" || sessionRecord.resumeReason !== "timeout" && sessionRecord.resumeReason !== "yield" || sessionRecord.resumeReason === "timeout" && sessionRecord.sliceId < 2) {
+    return void 0;
+  }
+  if (!sessionRecord.destination) {
+    return void 0;
+  }
+  return {
+    conversationId: args.conversationId,
+    destination: sessionRecord.destination,
+    sessionId: args.sessionId,
+    expectedVersion: sessionRecord.version
+  };
+}
+async function scheduleAgentContinue(request, options = {}) {
+  const nowMs = options.nowMs ?? Date.now();
+  await requestConversationWork({
+    conversationId: request.conversationId,
+    destination: request.destination,
+    nowMs,
+    state: options.state
+  });
+  const queue = options.queue ?? getVercelConversationWorkQueue();
+  await queue.send(
+    {
+      conversationId: request.conversationId,
+      destination: request.destination
+    },
+    {
+      idempotencyKey: [
+        "agent-continue",
+        request.conversationId,
+        request.sessionId,
+        request.expectedVersion,
+        nowMs
+      ].join(":")
+    }
+  );
+  await markConversationWorkEnqueued({
+    conversationId: request.conversationId,
+    nowMs,
+    state: options.state
+  });
+}
+
 // src/handlers/oauth-html.ts
 function htmlCallbackResponse(title, message, status) {
   const html = `<!DOCTYPE html>
@@ -16351,87 +15450,6 @@ function htmlCallbackResponse(title, message, status) {
   });
 }
 
-// src/chat/slack/user.ts
-var USER_CACHE_TTL_MS = 5 * 60 * 1e3;
-var userCache = /* @__PURE__ */ new Map();
-function readFromCache(userId) {
-  const hit = userCache.get(userId);
-  if (!hit) return null;
-  if (hit.expiresAt < Date.now()) {
-    userCache.delete(userId);
-    return null;
-  }
-  return hit.value;
-}
-function writeToCache(userId, value) {
-  userCache.set(userId, {
-    value,
-    expiresAt: Date.now() + USER_CACHE_TTL_MS
-  });
-}
-async function lookupSlackUser(userId) {
-  if (!userId) {
-    return null;
-  }
-  const cached = readFromCache(userId);
-  if (cached) {
-    return cached;
-  }
-  const token = getSlackBotToken();
-  if (!token) {
-    return null;
-  }
-  try {
-    const response = await fetch(
-      `https://slack.com/api/users.info?user=${encodeURIComponent(userId)}`,
-      {
-        headers: {
-          authorization: `Bearer ${token}`
-        }
-      }
-    );
-    if (!response.ok) {
-      logWarn(
-        "slack_user_lookup_failed",
-        {},
-        {
-          "enduser.id": userId,
-          "http.response.status_code": response.status
-        },
-        "Slack user lookup request failed"
-      );
-      return null;
-    }
-    const payload = await response.json();
-    if (!payload.ok || !payload.user) {
-      return null;
-    }
-    const userName = payload.user.name?.trim() || void 0;
-    const fullName = payload.user.profile?.display_name?.trim() || payload.user.profile?.real_name?.trim() || payload.user.real_name?.trim() || void 0;
-    const result = {
-      userName,
-      fullName,
-      email: payload.user.profile?.email?.trim() || void 0
-    };
-    writeToCache(userId, result);
-    return result;
-  } catch (error) {
-    logWarn(
-      "slack_user_lookup_failed",
-      {},
-      {
-        "enduser.id": userId,
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Slack user lookup failed with exception"
-    );
-    return null;
-  }
-}
-async function lookupSlackActorIdentity(userId) {
-  return slackActorIdentity(userId, await lookupSlackUser(userId));
-}
-
 // src/handlers/mcp-oauth-callback.ts
 var CALLBACK_PAGES = {
   missing_state: {
@@ -16622,6 +15640,22 @@ async function resumeAuthorizedMcpTurn(args) {
       const lockedChannelConfiguration = getChannelConfigurationServiceById(
         authSession.channelId
       );
+      let requester;
+      try {
+        requester = createRequesterFromStoredSlackRequester({
+          requester: lockedSessionRecord.requester,
+          teamId: destination.teamId,
+          userId: authSession.userId
+        });
+      } catch {
+        await failAgentTurnSessionRecord({
+          conversationId: authSession.conversationId,
+          expectedVersion: lockedSessionRecord.version,
+          sessionId: lockedSessionId,
+          errorMessage: "Stored Slack requester identity did not match OAuth requester"
+        });
+        return false;
+      }
       await recordAuthorizationCompleted({
         conversationId: authSession.conversationId,
         kind: "mcp",
@@ -16633,13 +15667,12 @@ async function resumeAuthorizedMcpTurn(args) {
         }),
         ttlMs: THREAD_STATE_TTL_MS4
       });
-      const requester = await lookupSlackActorIdentity(authSession.userId);
       return {
         messageText: lockedUserMessage.text,
         messageTs: getTurnUserSlackMessageTs(lockedUserMessage),
         replyContext: {
           credentialContext: {
-            actor: { type: "user", userId: authSession.userId }
+            actor: { type: "user", userId: requester.userId }
           },
           requester,
           destination,
@@ -16648,7 +15681,7 @@ async function resumeAuthorizedMcpTurn(args) {
             turnId: lockedSessionId,
             channelId: authSession.channelId,
             threadTs: authSession.threadTs,
-            requesterId: authSession.userId
+            requesterId: requester.userId
           },
           toolChannelId: authSession.toolChannelId ?? lockedArtifacts.assistantContextChannelId ?? authSession.channelId,
           conversationContext: lockedConversationContext,
@@ -16720,16 +15753,16 @@ async function resumeAuthorizedMcpTurn(args) {
           );
         },
         onTimeoutPause: async (error) => {
-          if (!isRetryableTurnError(error, "turn_timeout_resume")) {
+          if (!isRetryableTurnError(error, "agent_continue")) {
             throw error;
           }
           const version = error.metadata?.version;
           if (typeof version !== "number") {
             throw new Error(
-              "Timed-out MCP resume did not include a turn-session version"
+              "MCP OAuth agent continuation did not include a session record version"
             );
           }
-          await scheduleTurnTimeoutResume({
+          await scheduleAgentContinue({
             conversationId: authSession.conversationId,
             destination,
             sessionId: lockedSessionId,
@@ -16920,28 +15953,118 @@ async function buildHomeView(userId, userTokenStore) {
       },
       { type: "divider" },
       {
-        type: "header",
-        text: {
-          type: "plain_text",
-          text: "Connected accounts"
-        }
+        type: "header",
+        text: {
+          type: "plain_text",
+          text: "Connected accounts"
+        }
+      },
+      ...accountBlocks,
+      {
+        type: "context",
+        elements: [
+          {
+            type: "mrkdwn",
+            text: `*junior version:* \`${runtimeMetadata.version ?? "unknown"}\``
+          }
+        ]
+      }
+    ]
+  };
+}
+async function publishAppHomeView(slackClient, userId, userTokenStore) {
+  const view = await buildHomeView(userId, userTokenStore);
+  await slackClient.views.publish({ user_id: userId, view });
+}
+
+// src/chat/slack/user.ts
+var USER_CACHE_TTL_MS = 5 * 60 * 1e3;
+var userCache = /* @__PURE__ */ new Map();
+function userCacheKey(teamId, userId) {
+  return `${teamId}:${userId}`;
+}
+function readFromCache(teamId, userId) {
+  const hit = userCache.get(userCacheKey(teamId, userId));
+  if (!hit) return null;
+  if (hit.expiresAt < Date.now()) {
+    userCache.delete(userCacheKey(teamId, userId));
+    return null;
+  }
+  return hit.value;
+}
+function writeToCache(teamId, userId, value) {
+  userCache.set(userCacheKey(teamId, userId), {
+    value,
+    expiresAt: Date.now() + USER_CACHE_TTL_MS
+  });
+}
+async function lookupSlackUser(teamId, userId) {
+  if (!teamId || !userId) {
+    return null;
+  }
+  const cached = readFromCache(teamId, userId);
+  if (cached) {
+    return cached;
+  }
+  const token = getSlackBotToken();
+  if (!token) {
+    return null;
+  }
+  try {
+    const response = await fetch(
+      `https://slack.com/api/users.info?user=${encodeURIComponent(userId)}`,
+      {
+        headers: {
+          authorization: `Bearer ${token}`
+        }
+      }
+    );
+    if (!response.ok) {
+      logWarn(
+        "slack_user_lookup_failed",
+        {},
+        {
+          "enduser.id": userId,
+          "app.slack.team_id": teamId,
+          "http.response.status_code": response.status
+        },
+        "Slack user lookup request failed"
+      );
+      return null;
+    }
+    const payload = await response.json();
+    if (!payload.ok || !payload.user) {
+      return null;
+    }
+    const userName = payload.user.name?.trim() || void 0;
+    const fullName = payload.user.profile?.display_name?.trim() || payload.user.profile?.real_name?.trim() || payload.user.real_name?.trim() || void 0;
+    const result = {
+      userName,
+      fullName,
+      email: payload.user.profile?.email?.trim() || void 0
+    };
+    writeToCache(teamId, userId, result);
+    return result;
+  } catch (error) {
+    logWarn(
+      "slack_user_lookup_failed",
+      {},
+      {
+        "enduser.id": userId,
+        "app.slack.team_id": teamId,
+        "exception.message": error instanceof Error ? error.message : String(error)
       },
-      ...accountBlocks,
-      {
-        type: "context",
-        elements: [
-          {
-            type: "mrkdwn",
-            text: `*junior version:* \`${runtimeMetadata.version ?? "unknown"}\``
-          }
-        ]
-      }
-    ]
-  };
+      "Slack user lookup failed with exception"
+    );
+    return null;
+  }
 }
-async function publishAppHomeView(slackClient, userId, userTokenStore) {
-  const view = await buildHomeView(userId, userTokenStore);
-  await slackClient.views.publish({ user_id: userId, view });
+async function lookupSlackRequester(teamId, userId) {
+  return createSlackRequester(
+    teamId,
+    userId,
+    await lookupSlackUser(teamId, userId)
+  );
 }
 
 // src/handlers/oauth-callback.ts
@@ -17124,6 +16247,22 @@ async function resumeOAuthSessionRecordTurn(stored) {
       const lockedChannelConfiguration = getChannelConfigurationServiceById(
         stored.channelId
       );
+      let requester;
+      try {
+        requester = createRequesterFromStoredSlackRequester({
+          requester: lockedSessionRecord.requester,
+          teamId: destination.teamId,
+          userId: lockedUserMessage.author.userId
+        });
+      } catch {
+        await failAgentTurnSessionRecord({
+          conversationId: stored.resumeConversationId,
+          expectedVersion: lockedSessionRecord.version,
+          sessionId: lockedSessionId,
+          errorMessage: "Stored Slack requester identity did not match OAuth requester"
+        });
+        return false;
+      }
       await recordAuthorizationCompleted({
         conversationId: stored.resumeConversationId,
         kind: "plugin",
@@ -17135,9 +16274,6 @@ async function resumeOAuthSessionRecordTurn(stored) {
         }),
         ttlMs: THREAD_STATE_TTL_MS5
       });
-      const requester = await lookupSlackActorIdentity(
-        lockedUserMessage.author.userId
-      );
       return {
         messageText: lockedPendingAuth ? lockedUserMessage.text : stored.pendingMessage ?? lockedUserMessage.text,
         messageTs: getTurnUserSlackMessageTs(lockedUserMessage),
@@ -17145,7 +16281,7 @@ async function resumeOAuthSessionRecordTurn(stored) {
           credentialContext: {
             actor: {
               type: "user",
-              userId: lockedUserMessage.author.userId
+              userId: requester.userId
             }
           },
           requester,
@@ -17155,7 +16291,7 @@ async function resumeOAuthSessionRecordTurn(stored) {
             turnId: lockedSessionId,
             channelId: stored.channelId,
             threadTs: stored.threadTs,
-            requesterId: lockedUserMessage.author.userId
+            requesterId: requester.userId
           },
           toolChannelId: lockedArtifacts.assistantContextChannelId ?? stored.channelId,
           artifactState: lockedArtifacts,
@@ -17215,16 +16351,16 @@ async function resumeOAuthSessionRecordTurn(stored) {
           });
         },
         onTimeoutPause: async (error) => {
-          if (!isRetryableTurnError(error, "turn_timeout_resume")) {
+          if (!isRetryableTurnError(error, "agent_continue")) {
             throw error;
           }
           const version = error.metadata?.version;
           if (typeof version !== "number") {
             throw new Error(
-              "Timed-out OAuth resume did not include a turn-session version"
+              "OAuth agent continuation did not include a session record version"
             );
           }
-          await scheduleTurnTimeoutResume({
+          await scheduleAgentContinue({
             conversationId: stored.resumeConversationId,
             destination,
             sessionId: lockedSessionId,
@@ -17248,7 +16384,10 @@ async function resumePendingOAuthMessage(stored) {
   const conversationContext = buildConversationContext(conversation, {
     excludeMessageId: latestUserMessage?.id
   });
-  const requester = await lookupSlackActorIdentity(stored.userId);
+  const requester = await lookupSlackRequester(
+    stored.destination.teamId,
+    stored.userId
+  );
   await resumeAuthorizedRequest({
     messageText: stored.pendingMessage,
     channelId: stored.channelId,
@@ -17325,8 +16464,8 @@ async function GET4(request, provider, waitUntil) {
     );
   }
   const stateAdapter = getStateAdapter();
-  const stateKey2 = `oauth-state:${state}`;
-  const stored = parseOAuthStatePayload(await stateAdapter.get(stateKey2));
+  const stateKey = `oauth-state:${state}`;
+  const stored = parseOAuthStatePayload(await stateAdapter.get(stateKey));
   if (!stored) {
     return htmlErrorResponse(
       "Link expired",
@@ -17341,7 +16480,7 @@ async function GET4(request, provider, waitUntil) {
       400
     );
   }
-  await stateAdapter.delete(stateKey2);
+  await stateAdapter.delete(stateKey);
   const clientId = process.env[providerConfig.clientIdEnv]?.trim();
   const clientSecret = process.env[providerConfig.clientSecretEnv]?.trim();
   if (!clientId || !clientSecret) {
@@ -17648,9 +16787,9 @@ function buildJwksUrl(value) {
   return url;
 }
 async function getJwks(issuer) {
-  const now3 = Date.now();
+  const now2 = Date.now();
   const cached = jwksByIssuer.get(issuer);
-  if (cached && cached.expiresAtMs > now3) {
+  if (cached && cached.expiresAtMs > now2) {
     return cached.jwks;
   }
   if (cached) {
@@ -17675,7 +16814,7 @@ async function getJwks(issuer) {
   }
   jwksByIssuer.set(issuer, {
     jwks,
-    expiresAtMs: now3 + OIDC_DISCOVERY_CACHE_TTL_MS
+    expiresAtMs: now2 + OIDC_DISCOVERY_CACHE_TTL_MS
   });
   return jwks;
 }
@@ -18459,292 +17598,22 @@ async function proxySandboxEgressRequest(request, deps = {}) {
         ...provider === "github" ? githubPermissionHeaders(upstream) : {}
       });
     }
-  }
-  return new Response(upstream.body, {
-    status: upstream.status,
-    statusText: upstream.statusText,
-    headers: responseHeaders(upstream)
-  });
-}
-
-// src/handlers/sandbox-egress-proxy.ts
-async function ALL(request, options = {}) {
-  return await proxySandboxEgressRequest(request, {
-    interceptHttp: options.interceptHttp
-  });
-}
-function isSandboxEgressRequest(request) {
-  return isSandboxEgressForwardedRequest(request);
-}
-
-// src/chat/runtime/timeout-resume-runner.ts
-var TIMEOUT_RESUME_LOCK_RETRY_DELAYS_MS = [250, 1e3, 2e3];
-function sleep4(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function persistCompletedReplyState2(args) {
-  const currentState = await getPersistedThreadState(
-    args.sessionRecord.conversationId
-  );
-  const conversation = coerceThreadConversationState(currentState);
-  const artifacts = coerceThreadArtifactsState(currentState);
-  const userMessage2 = getTurnUserMessage(
-    conversation,
-    args.sessionRecord.sessionId
-  );
-  const statePatch = buildDeliveredTurnStatePatch({
-    artifacts,
-    conversation,
-    reply: args.reply,
-    sessionId: args.sessionRecord.sessionId,
-    userMessageId: userMessage2?.id
-  });
-  await persistThreadStateById(args.sessionRecord.conversationId, {
-    ...statePatch
-  });
-}
-async function failSessionRecordBestEffort3(args) {
-  try {
-    await failAgentTurnSessionRecord({
-      conversationId: args.sessionRecord.conversationId,
-      expectedVersion: args.sessionRecord.version,
-      sessionId: args.sessionRecord.sessionId,
-      errorMessage: args.errorMessage
-    });
-  } catch (error) {
-    logException(
-      error,
-      "timeout_resume_session_record_fail_persist_failed",
-      {},
-      {
-        "app.ai.conversation_id": args.sessionRecord.conversationId,
-        "app.ai.session_id": args.sessionRecord.sessionId
-      },
-      "Failed to mark timed-out turn session record failed"
-    );
-  }
-}
-async function persistFailedReplyState2(sessionRecord) {
-  const currentState = await getPersistedThreadState(
-    sessionRecord.conversationId
-  );
-  const conversation = coerceThreadConversationState(currentState);
-  clearPendingAuth(conversation, sessionRecord.sessionId);
-  markTurnFailed({
-    conversation,
-    nowMs: Date.now(),
-    sessionId: sessionRecord.sessionId,
-    userMessageId: getTurnUserMessage(conversation, sessionRecord.sessionId)?.id,
-    markConversationMessage,
-    updateConversationStats
-  });
-  await failSessionRecordBestEffort3({
-    sessionRecord,
-    errorMessage: "Timed-out turn failed while resuming"
-  });
-  await persistThreadStateById(sessionRecord.conversationId, {
-    conversation
-  });
-}
-async function resumeTimedOutTurn(payload, options = {}) {
-  const thread = parseSlackThreadId(payload.conversationId);
-  if (!thread) {
-    throw new Error(
-      `Timeout resume requires a Slack thread conversation id, got "${payload.conversationId}"`
-    );
-  }
-  const scheduleTurnTimeoutResume2 = options.scheduleTurnTimeoutResume ?? scheduleTurnTimeoutResume;
-  return await resumeSlackTurn({
-    messageText: "",
-    channelId: thread.channelId,
-    threadTs: thread.threadTs,
-    lockKey: payload.conversationId,
-    beforeStart: async () => {
-      const sessionRecord = await getAgentTurnSessionRecord(
-        payload.conversationId,
-        payload.sessionId
-      );
-      if (!sessionRecord || sessionRecord.state !== "awaiting_resume" || sessionRecord.resumeReason !== "timeout" && sessionRecord.resumeReason !== "yield" || sessionRecord.version !== payload.expectedVersion) {
-        return false;
-      }
-      const currentState = await getPersistedThreadState(
-        payload.conversationId
-      );
-      const conversation = coerceThreadConversationState(currentState);
-      const artifacts = coerceThreadArtifactsState(currentState);
-      const userMessage2 = getTurnUserMessage(conversation, payload.sessionId);
-      if (!userMessage2?.author?.userId) {
-        throw new Error(
-          `Unable to locate the persisted user message for timeout resume session "${payload.sessionId}"`
-        );
-      }
-      if (conversation.processing.activeTurnId !== payload.sessionId) {
-        return false;
-      }
-      const channelConfiguration = getChannelConfigurationServiceById(
-        thread.channelId
-      );
-      const conversationContext = buildConversationContext(conversation, {
-        excludeMessageId: userMessage2.id
-      });
-      const sandbox = getPersistedSandboxState(currentState);
-      const requester = await lookupSlackActorIdentity(
-        userMessage2.author.userId
-      );
-      return {
-        messageText: userMessage2.text,
-        messageTs: getTurnUserSlackMessageTs(userMessage2),
-        replyContext: {
-          credentialContext: {
-            actor: {
-              type: "user",
-              userId: userMessage2.author.userId
-            }
-          },
-          requester,
-          destination: payload.destination,
-          correlation: {
-            conversationId: payload.conversationId,
-            turnId: payload.sessionId,
-            channelId: thread.channelId,
-            threadTs: thread.threadTs,
-            requesterId: userMessage2.author.userId
-          },
-          toolChannelId: artifacts.assistantContextChannelId ?? thread.channelId,
-          artifactState: artifacts,
-          pendingAuth: conversation.processing.pendingAuth,
-          conversationContext,
-          channelConfiguration,
-          piMessages: conversation.piMessages,
-          sandbox,
-          onAuthPending: async (nextPendingAuth) => {
-            await applyPendingAuthUpdate({
-              conversation,
-              conversationId: payload.conversationId,
-              nextPendingAuth
-            });
-            await persistThreadStateById(payload.conversationId, {
-              conversation
-            });
-          },
-          ...getTurnUserReplyAttachmentContext(userMessage2)
-        },
-        onSuccess: async (reply) => {
-          await persistCompletedReplyState2({ sessionRecord, reply });
-        },
-        onFailure: async () => {
-          await persistFailedReplyState2(sessionRecord);
-        },
-        onPostDeliveryCommitFailure: async () => {
-          await failAgentTurnSessionRecord({
-            conversationId: sessionRecord.conversationId,
-            expectedVersion: sessionRecord.version,
-            sessionId: sessionRecord.sessionId,
-            errorMessage: "Timed-out turn reply was delivered but completion state did not persist"
-          });
-        },
-        onAuthPause: async () => {
-          await persistAuthPauseTurnState({
-            sessionId: payload.sessionId,
-            threadStateId: payload.conversationId
-          });
-          logWarn(
-            "timeout_resume_reparked_for_auth",
-            {},
-            {
-              "app.ai.conversation_id": payload.conversationId,
-              "app.ai.session_id": payload.sessionId
-            },
-            "Resumed timed-out turn parked for auth"
-          );
-        },
-        onTimeoutPause: async (error) => {
-          if (!isRetryableTurnError(error, "turn_timeout_resume")) {
-            throw error;
-          }
-          const version = error.metadata?.version;
-          if (typeof version !== "number") {
-            throw new Error(
-              "Timed-out resume turn did not include a turn-session version"
-            );
-          }
-          await scheduleTurnTimeoutResume2({
-            conversationId: payload.conversationId,
-            destination: payload.destination,
-            sessionId: payload.sessionId,
-            expectedVersion: version
-          });
-        }
-      };
-    }
-  });
-}
-async function resumeTimedOutTurnWithLockRetry(payload, options = {}) {
-  const scheduleTurnTimeoutResume2 = options.scheduleTurnTimeoutResume ?? scheduleTurnTimeoutResume;
-  for (const [attempt, delayMs] of [
-    ...TIMEOUT_RESUME_LOCK_RETRY_DELAYS_MS,
-    void 0
-  ].entries()) {
-    try {
-      return await resumeTimedOutTurn(payload, options);
-    } catch (error) {
-      if (!(error instanceof ResumeTurnBusyError)) {
-        throw error;
-      }
-      if (typeof delayMs !== "number") {
-        logWarn(
-          "timeout_resume_lock_busy",
-          {},
-          {
-            "app.ai.conversation_id": payload.conversationId,
-            "app.ai.session_id": payload.sessionId,
-            "app.ai.resume_lock_retry_count": attempt
-          },
-          "Rescheduling timeout resume because another turn still owns the thread lock"
-        );
-        await scheduleTurnTimeoutResume2(payload);
-        return true;
-      }
-      logWarn(
-        "timeout_resume_lock_busy_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
-        },
-        "Timeout resume lock was busy; retrying"
-      );
-      await sleep4(delayMs);
-    }
-  }
-  return true;
-}
-
-// src/handlers/turn-resume.ts
-async function POST2(request, waitUntil, options = {}) {
-  const payload = await verifyTurnTimeoutResumeRequest(request);
-  if (!payload) {
-    return new Response("Unauthorized", { status: 401 });
-  }
-  waitUntil(
-    () => runWithTurnRequestDeadline(
-      () => resumeTimedOutTurnWithLockRetry(payload, options).catch((error) => {
-        logException(
-          error,
-          "timeout_resume_handler_failed",
-          {},
-          {
-            "app.ai.conversation_id": payload.conversationId,
-            "app.ai.session_id": payload.sessionId
-          },
-          "Timeout resume handler failed"
-        );
-      })
-    )
-  );
-  return new Response("Accepted", { status: 202 });
+  }
+  return new Response(upstream.body, {
+    status: upstream.status,
+    statusText: upstream.statusText,
+    headers: responseHeaders(upstream)
+  });
+}
+
+// src/handlers/sandbox-egress-proxy.ts
+async function ALL(request, options = {}) {
+  return await proxySandboxEgressRequest(request, {
+    interceptHttp: options.interceptHttp
+  });
+}
+function isSandboxEgressRequest(request) {
+  return isSandboxEgressForwardedRequest(request);
 }
 
 // src/chat/services/subscribed-decision.ts
@@ -19098,44 +17967,46 @@ function combineTurnText(queuedMessages, latestText) {
 
 // src/chat/services/message-actor-identity.ts
 var messageActors = /* @__PURE__ */ new WeakMap();
-function canonicalUserId(author, identity) {
+function canonicalUserId(author, requester) {
   const authorUserId = parseActorUserId(author.userId);
-  const identityUserId = parseActorUserId(identity.userId);
-  if (authorUserId && identityUserId && authorUserId !== identityUserId) {
-    throw new Error("Message actor identity user id mismatch");
+  if (authorUserId && authorUserId !== requester.userId) {
+    throw new Error("Message requester user id mismatch");
   }
-  const userId = authorUserId ?? identityUserId;
+  const userId = authorUserId ?? requester.userId;
   if (!userId) {
-    throw new Error("Message actor identity requires a user id");
+    throw new Error("Message requester requires a user id");
   }
   return userId;
 }
-function actorIdentityFromAuthor(author) {
+function requesterFromAuthor(author) {
   const userId = parseActorUserId(author.userId);
   return userId ? { userId } : void 0;
 }
-function applyIdentityToAuthor(author, identity) {
-  if (!isActorUserId(identity.userId)) {
-    throw new Error("Message actor identity requires a user id");
+function applyRequesterToAuthor(author, requester) {
+  if (!isActorUserId(requester.userId)) {
+    throw new Error("Message requester requires a user id");
   }
-  author.userId = identity.userId;
-  author.userName = identity.userName ?? "";
-  author.fullName = identity.fullName ?? "";
+  author.userId = requester.userId;
+  author.userName = requester.userName ?? "";
+  author.fullName = requester.fullName ?? "";
 }
-function bindMessageActorIdentity(message, identity) {
-  const userId = canonicalUserId(message.author, identity);
-  const actorIdentity = buildActorIdentity(identity, userId);
-  if (!actorIdentity?.userId) {
-    throw new Error("Message actor identity requires a user id");
+function bindMessageActorIdentity(message, requester) {
+  const userId = canonicalUserId(message.author, requester);
+  const actorRequester = createRequester(requester, {
+    teamId: requester.teamId,
+    userId
+  });
+  if (!actorRequester) {
+    throw new Error("Message requester requires a user id");
   }
-  messageActors.set(message, actorIdentity);
-  applyIdentityToAuthor(message.author, actorIdentity);
-  return actorIdentity;
+  messageActors.set(message, actorRequester);
+  applyRequesterToAuthor(message.author, actorRequester);
+  return actorRequester;
 }
 function getMessageActorIdentity(message) {
-  return messageActors.get(message) ?? actorIdentityFromAuthor(message.author);
+  return messageActors.get(message) ?? requesterFromAuthor(message.author);
 }
-async function ensureSlackMessageActorIdentity(message, lookupSlackUser2) {
+async function ensureSlackMessageActorIdentity(message, teamId, lookupSlackUser2) {
   const existing = messageActors.get(message);
   if (existing) {
     return existing;
@@ -19146,7 +18017,7 @@ async function ensureSlackMessageActorIdentity(message, lookupSlackUser2) {
   }
   return bindMessageActorIdentity(
     message,
-    slackActorIdentity(userId, await lookupSlackUser2(userId))
+    createSlackRequester(teamId, userId, await lookupSlackUser2(teamId, userId))
   );
 }
 
@@ -20533,9 +19404,9 @@ function createJuniorRuntimeServices(overrides = {}) {
     replyExecutor: {
       contextCompactor: overrides.replyExecutor?.contextCompactor ?? contextCompactor,
       generateAssistantReply: overrides.replyExecutor?.generateAssistantReply ?? generateAssistantReply,
-      getAwaitingTurnContinuationRequest: overrides.replyExecutor?.getAwaitingTurnContinuationRequest ?? getAwaitingTurnContinuationRequest,
+      getAwaitingAgentContinueRequest: overrides.replyExecutor?.getAwaitingAgentContinueRequest ?? getAwaitingAgentContinueRequest,
       lookupSlackUser: overrides.replyExecutor?.lookupSlackUser ?? lookupSlackUser,
-      scheduleTurnTimeoutResume: overrides.replyExecutor?.scheduleTurnTimeoutResume ?? scheduleTurnTimeoutResume,
+      scheduleAgentContinue: overrides.replyExecutor?.scheduleAgentContinue ?? scheduleAgentContinue,
       generateThreadTitle: conversationMemory.generateThreadTitle
     },
     subscribedReplyPolicy: createSubscribedReplyPolicy({
@@ -20683,14 +19554,8 @@ function collectCanvasUrls(artifacts) {
     ].filter((url) => typeof url === "string" && url !== "")
   );
 }
-function turnRequester(identity) {
-  const requester = {
-    ...identity.email ? { email: identity.email } : {},
-    ...identity.fullName ? { fullName: identity.fullName } : {},
-    ...identity.userId ? { slackUserId: identity.userId } : {},
-    ...identity.userName ? { slackUserName: identity.userName } : {}
-  };
-  return requester;
+function turnRequester(requester) {
+  return toStoredSlackRequester(requester);
 }
 async function resolveChannelName(thread) {
   const existingName = thread.channel.name?.trim();
@@ -20804,12 +19669,14 @@ function createReplyToThread(deps) {
           (options.queuedMessages ?? []).map(
             (queued) => ensureSlackMessageActorIdentity(
               queued.message,
+              teamId,
               deps.services.lookupSlackUser
             )
           )
         );
         const requesterIdentity = await ensureSlackMessageActorIdentity(
           message,
+          teamId,
           deps.services.lookupSlackUser
         );
         const requester = turnRequester(requesterIdentity);
@@ -20878,24 +19745,24 @@ function createReplyToThread(deps) {
           return;
         }
         if (conversationId && activeTurnId) {
-          const resumeRequest = await deps.services.getAwaitingTurnContinuationRequest({
+          const resumeRequest = await deps.services.getAwaitingAgentContinueRequest({
             conversationId,
             sessionId: activeTurnId
           });
           if (resumeRequest) {
             try {
-              await deps.services.scheduleTurnTimeoutResume(resumeRequest);
+              await deps.services.scheduleAgentContinue(resumeRequest);
             } catch (error) {
               logException(
                 error,
-                "agent_turn_continuation_retry_schedule_failed",
+                "agent_continue_schedule_failed",
                 turnTraceContext,
                 {
                   "app.ai.resume_session_version": resumeRequest.expectedVersion,
                   "app.ai.resume_session_id": resumeRequest.sessionId,
                   ...messageTs ? { "messaging.message.id": messageTs } : {}
                 },
-                "Failed to reschedule active turn continuation"
+                "Failed to reschedule active agent continuation"
               );
               throw error;
             }
@@ -20923,7 +19790,7 @@ function createReplyToThread(deps) {
               conversationId,
               expectedVersion: sessionRecord.version,
               sessionId: activeTurnId,
-              errorMessage: "Awaiting turn continuation metadata could not be materialized"
+              errorMessage: "Awaiting agent continuation metadata could not be materialized"
             });
             markTurnFailed({
               conversation: preparedState.conversation,
@@ -21448,13 +20315,13 @@ function createReplyToThread(deps) {
             shouldPersistFailureState = false;
             return;
           }
-          if (isRetryableTurnError(error, "turn_timeout_resume")) {
+          if (isRetryableTurnError(error, "agent_continue")) {
             const conversationIdForResume = error.metadata?.conversationId;
             const sessionIdForResume = error.metadata?.sessionId;
             const version = error.metadata?.version;
             if (conversationIdForResume && sessionIdForResume && typeof version === "number" && destination) {
               try {
-                await deps.services.scheduleTurnTimeoutResume({
+                await deps.services.scheduleAgentContinue({
                   conversationId: conversationIdForResume,
                   destination,
                   sessionId: sessionIdForResume,
@@ -21464,13 +20331,13 @@ function createReplyToThread(deps) {
               } catch (scheduleError) {
                 logException(
                   scheduleError,
-                  "agent_turn_timeout_resume_schedule_failed",
+                  "agent_continue_schedule_failed",
                   turnTraceContext,
                   {
                     ...messageTs ? { "messaging.message.id": messageTs } : {},
                     "app.ai.resume_session_version": version
                   },
-                  "Failed to schedule timeout resume callback"
+                  "Failed to schedule agent continuation"
                 );
                 shouldPersistFailureState = true;
                 throw scheduleError;
@@ -21478,10 +20345,10 @@ function createReplyToThread(deps) {
               return;
             } else {
               logWarn(
-                "agent_turn_timeout_resume_metadata_missing",
+                "agent_continue_metadata_missing",
                 turnTraceContext,
                 messageTs ? { "messaging.message.id": messageTs } : {},
-                "Timed-out turn could not be scheduled for resume because retry metadata was incomplete"
+                "Agent continuation could not be scheduled because retry metadata was incomplete"
               );
             }
           }
@@ -21840,6 +20707,11 @@ async function persistAssistantContextChannelId(args) {
     artifacts: nextArtifacts
   });
 }
+function clearSkippedTurnIfActive(conversation, messageId) {
+  if (conversation.processing.activeTurnId === buildDeterministicTurnId(messageId)) {
+    conversation.processing.activeTurnId = void 0;
+  }
+}
 function createSlackRuntime(options) {
   const services = createJuniorRuntimeServices(options.services);
   const prepareTurnState = createPrepareTurnState({
@@ -21895,7 +20767,7 @@ function createSlackRuntime(options) {
           skippedReason: decision.reason
         }
       });
-      conversation.processing.activeTurnId = void 0;
+      clearSkippedTurnIfActive(conversation, message.id);
       conversation.processing.lastCompletedAtMs = completedAtMs;
       updateConversationStats(conversation);
       await persistThreadState(thread, {
@@ -21904,6 +20776,7 @@ function createSlackRuntime(options) {
     },
     onSubscribedMessageSkipped: async ({
       thread,
+      message,
       preparedState,
       decision,
       completedAtMs
@@ -21919,7 +20792,7 @@ function createSlackRuntime(options) {
           skippedReason: decision.reason
         }
       );
-      preparedState.conversation.processing.activeTurnId = void 0;
+      clearSkippedTurnIfActive(preparedState.conversation, message.id);
       preparedState.conversation.processing.lastCompletedAtMs = completedAtMs;
       updateConversationStats(preparedState.conversation);
       await persistThreadState(thread, {
@@ -22014,7 +20887,7 @@ function rehydrateAttachmentFetchers(message, downloadPrivateSlackFile2 = downlo
 
 // src/chat/slack/adapter-context.ts
 var initializedAdapters = /* @__PURE__ */ new WeakSet();
-async function getConnectedState2(stateAdapter) {
+async function getConnectedState(stateAdapter) {
   const state = stateAdapter ?? getStateAdapter();
   await state.connect();
   return state;
@@ -22023,7 +20896,7 @@ async function ensureSlackAdapterInitialized(args) {
   if (initializedAdapters.has(args.adapter)) {
     return;
   }
-  const state = await getConnectedState2(args.state);
+  const state = await getConnectedState(args.state);
   await args.adapter.initialize({
     getState: () => state
   });
@@ -22086,7 +20959,7 @@ function requireSlackAuthorId(message) {
   }
   return authorId;
 }
-function getConnectedState3(stateAdapter) {
+function getConnectedState2(stateAdapter) {
   return stateAdapter ?? getStateAdapter();
 }
 function isSlackMetadata(value) {
@@ -22118,10 +20991,14 @@ async function bindSlackActorIdentities(args) {
   }
   await Promise.all(
     [...byAuthorId].map(async ([authorId, messages]) => {
-      const profile = await args.lookupSlackUser(authorId);
+      const profile = await args.lookupSlackUser(args.teamId, authorId);
       await Promise.all(
         messages.map(
-          (message) => ensureSlackMessageActorIdentity(message, async () => profile)
+          (message) => ensureSlackMessageActorIdentity(
+            message,
+            args.teamId,
+            async () => profile
+          )
         )
       );
     })
@@ -22147,47 +21024,6 @@ function restoreThread(args) {
     isSubscribedContext: args.isSubscribedContext
   });
 }
-function isContinuationResume(summary) {
-  return summary.state === "awaiting_resume" && (summary.resumeReason === "timeout" || summary.resumeReason === "yield");
-}
-async function failUnresumableContinuation(args) {
-  await failAgentTurnSessionRecord({
-    conversationId: args.conversationId,
-    expectedVersion: args.expectedVersion ?? args.summary.version,
-    sessionId: args.summary.sessionId,
-    errorMessage: args.errorMessage
-  });
-}
-async function resumeAwaitingContinuation(conversationId) {
-  const summaries = await listAgentTurnSessionSummariesForConversation(conversationId);
-  for (const summary of summaries) {
-    if (!isContinuationResume(summary)) {
-      continue;
-    }
-    const request = await getAwaitingTurnContinuationRequest({
-      conversationId,
-      sessionId: summary.sessionId
-    });
-    if (!request) {
-      await failUnresumableContinuation({
-        conversationId,
-        summary,
-        errorMessage: "Awaiting turn continuation metadata could not be materialized"
-      });
-      continue;
-    }
-    if (await resumeTimedOutTurnWithLockRetry(request)) {
-      return true;
-    }
-    await failUnresumableContinuation({
-      conversationId,
-      expectedVersion: request.expectedVersion,
-      summary,
-      errorMessage: "Awaiting turn continuation was stale before resuming"
-    });
-  }
-  return false;
-}
 function getInstallation(records) {
   for (let index = records.length - 1; index >= 0; index -= 1) {
     const metadata = records[index]?.input.metadata;
@@ -22201,18 +21037,14 @@ function getPendingRecords(work) {
   if (!work) {
     return [];
   }
-  return work.messages.filter((message) => message.injectedAtMs === void 0).sort(compareInboundMessages);
+  return work.execution.pendingMessages.sort(compareInboundMessages);
 }
 function createSlackConversationWorker(options) {
   return async (context) => {
     const adapter = options.getSlackAdapter();
     const actorLookup = options.lookupSlackUser ?? lookupSlackUser;
-    const state = getConnectedState3(options.state);
+    const state = getConnectedState2(options.state);
     await state.connect();
-    const resumeContinuation = options.resumeAwaitingContinuation ?? resumeAwaitingContinuation;
-    if (await resumeContinuation(context.conversationId)) {
-      return { status: "completed" };
-    }
     const records = getPendingRecords(
       await getConversationWorkState({
         conversationId: context.conversationId,
@@ -22220,7 +21052,7 @@ function createSlackConversationWorker(options) {
       })
     );
     if (records.length === 0) {
-      await resumeContinuation(context.conversationId);
+      await options.resumeAwaitingContinuation(context.conversationId);
       return { status: "completed" };
     }
     const latestRecord = records[records.length - 1];
@@ -22246,7 +21078,8 @@ function createSlackConversationWorker(options) {
         );
         await bindSlackActorIdentities({
           lookupSlackUser: actorLookup,
-          messages
+          messages,
+          teamId: context.destination.teamId
         });
         const latestMessage = messages[messages.length - 1];
         if (!latestMessage) {
@@ -22295,80 +21128,404 @@ function createSlackConversationWorker(options) {
             const messages2 = pendingRecords.map(
               (record) => restoreMessage({ adapter, record })
             );
-            restoredMessages = messages2;
-            await inject(messages2);
-          });
-          return restoredMessages ?? drained.map((record) => restoreMessage({ adapter, record }));
-        };
-        try {
-          if (route === "mention") {
-            await options.runtime.handleNewMention(thread, latestMessage, {
-              destination: context.destination,
-              messageContext,
-              drainSteeringMessages,
-              onInputCommitted,
-              shouldYield: context.shouldYield
+            restoredMessages = messages2;
+            await inject(messages2);
+          });
+          return restoredMessages ?? drained.map((record) => restoreMessage({ adapter, record }));
+        };
+        try {
+          if (route === "mention") {
+            await options.runtime.handleNewMention(thread, latestMessage, {
+              destination: context.destination,
+              messageContext,
+              drainSteeringMessages,
+              onInputCommitted,
+              shouldYield: context.shouldYield
+            });
+            return;
+          }
+          await options.runtime.handleSubscribedMessage(thread, latestMessage, {
+            destination: context.destination,
+            messageContext,
+            drainSteeringMessages,
+            onInputCommitted,
+            shouldYield: context.shouldYield
+          });
+        } catch (error) {
+          if (isCooperativeTurnYieldError(error)) {
+            return { status: "yielded" };
+          }
+          if (isTurnInputCommitLostError(error)) {
+            return { status: "lost_lease" };
+          }
+          throw error;
+        }
+      }
+    });
+    if (turnResult?.status === "yielded" || turnResult?.status === "lost_lease") {
+      return turnResult;
+    }
+    return { status: "completed" };
+  };
+}
+function buildSlackInboundMessage(args) {
+  const authorId = requireSlackAuthorId(args.message);
+  const destination = createSlackDestination({
+    channelId: args.thread.channelId,
+    teamId: args.installation?.teamId
+  });
+  if (!destination) {
+    throw new Error("Slack inbound message requires destination context");
+  }
+  return {
+    conversationId: args.conversationId,
+    destination,
+    inboundMessageId: [
+      "slack",
+      args.installation?.teamId ?? args.installation?.enterpriseId ?? "unknown",
+      args.conversationId,
+      args.message.id
+    ].join(":"),
+    source: "slack",
+    createdAtMs: args.message.metadata.dateSent.getTime(),
+    receivedAtMs: args.receivedAtMs,
+    input: {
+      text: args.message.text || " ",
+      authorId,
+      attachments: args.message.attachments,
+      metadata: {
+        platform: "slack",
+        route: args.route,
+        installation: args.installation,
+        thread: args.thread.toJSON(),
+        message: args.message.toJSON()
+      }
+    }
+  };
+}
+
+// src/chat/runtime/agent-continue-runner.ts
+var AGENT_CONTINUE_LOCK_RETRY_DELAYS_MS = [250, 1e3, 2e3];
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function persistCompletedReplyState2(args) {
+  const currentState = await getPersistedThreadState(
+    args.sessionRecord.conversationId
+  );
+  const conversation = coerceThreadConversationState(currentState);
+  const artifacts = coerceThreadArtifactsState(currentState);
+  const userMessage2 = getTurnUserMessage(
+    conversation,
+    args.sessionRecord.sessionId
+  );
+  const statePatch = buildDeliveredTurnStatePatch({
+    artifacts,
+    conversation,
+    reply: args.reply,
+    sessionId: args.sessionRecord.sessionId,
+    userMessageId: userMessage2?.id
+  });
+  await persistThreadStateById(args.sessionRecord.conversationId, {
+    ...statePatch
+  });
+}
+async function failSessionRecordBestEffort3(args) {
+  try {
+    await failAgentTurnSessionRecord({
+      conversationId: args.sessionRecord.conversationId,
+      expectedVersion: args.sessionRecord.version,
+      sessionId: args.sessionRecord.sessionId,
+      errorMessage: args.errorMessage
+    });
+  } catch (error) {
+    logException(
+      error,
+      "agent_continue_session_record_fail_persist_failed",
+      {},
+      {
+        "app.ai.conversation_id": args.sessionRecord.conversationId,
+        "app.ai.session_id": args.sessionRecord.sessionId
+      },
+      "Failed to mark paused agent run session record failed"
+    );
+  }
+}
+async function persistFailedReplyState2(sessionRecord) {
+  const currentState = await getPersistedThreadState(
+    sessionRecord.conversationId
+  );
+  const conversation = coerceThreadConversationState(currentState);
+  clearPendingAuth(conversation, sessionRecord.sessionId);
+  markTurnFailed({
+    conversation,
+    nowMs: Date.now(),
+    sessionId: sessionRecord.sessionId,
+    userMessageId: getTurnUserMessage(conversation, sessionRecord.sessionId)?.id,
+    markConversationMessage,
+    updateConversationStats
+  });
+  await failSessionRecordBestEffort3({
+    sessionRecord,
+    errorMessage: "Paused agent run failed while continuing"
+  });
+  await persistThreadStateById(sessionRecord.conversationId, {
+    conversation
+  });
+}
+async function failContinuationStartup(args) {
+  try {
+    await persistFailedReplyState2(args.sessionRecord);
+  } catch (persistError) {
+    await failSessionRecordBestEffort3({
+      sessionRecord: args.sessionRecord,
+      errorMessage: "Paused agent run failed while preparing continuation"
+    });
+    logException(
+      persistError,
+      "agent_continue_startup_failure_persist_failed",
+      {},
+      {
+        "app.ai.conversation_id": args.sessionRecord.conversationId,
+        "app.ai.session_id": args.sessionRecord.sessionId
+      },
+      "Failed to persist paused agent run startup failure"
+    );
+  }
+}
+function isContinuationResume(summary) {
+  return summary.state === "awaiting_resume" && (summary.resumeReason === "timeout" || summary.resumeReason === "yield");
+}
+async function failUnresumableContinuation(args) {
+  await failAgentTurnSessionRecord({
+    conversationId: args.conversationId,
+    expectedVersion: args.expectedVersion ?? args.summary.version,
+    sessionId: args.summary.sessionId,
+    errorMessage: args.errorMessage
+  });
+}
+async function continueSlackAgentRun(payload, options = {}) {
+  const thread = parseSlackThreadId(payload.conversationId);
+  if (!thread) {
+    throw new Error(
+      `Agent continuation requires a Slack thread conversation id, got "${payload.conversationId}"`
+    );
+  }
+  const scheduleAgentContinue2 = options.scheduleAgentContinue ?? scheduleAgentContinue;
+  const resumeTurn = options.resumeTurn ?? resumeSlackTurn;
+  return await resumeTurn({
+    messageText: "",
+    channelId: thread.channelId,
+    threadTs: thread.threadTs,
+    lockKey: payload.conversationId,
+    generateReply: options.generateReply,
+    beforeStart: async () => {
+      let sessionRecord;
+      try {
+        sessionRecord = await getAgentTurnSessionRecord(
+          payload.conversationId,
+          payload.sessionId
+        );
+        if (!sessionRecord || sessionRecord.state !== "awaiting_resume" || sessionRecord.resumeReason !== "timeout" && sessionRecord.resumeReason !== "yield" || sessionRecord.version !== payload.expectedVersion) {
+          return false;
+        }
+        const activeSessionRecord = sessionRecord;
+        const currentState = await getPersistedThreadState(
+          payload.conversationId
+        );
+        const conversation = coerceThreadConversationState(currentState);
+        const artifacts = coerceThreadArtifactsState(currentState);
+        const userMessage2 = getTurnUserMessage(conversation, payload.sessionId);
+        if (!userMessage2?.author?.userId) {
+          throw new Error(
+            `Unable to locate the persisted user message for agent continuation session "${payload.sessionId}"`
+          );
+        }
+        if (conversation.processing.activeTurnId !== payload.sessionId) {
+          return false;
+        }
+        const channelConfiguration = getChannelConfigurationServiceById(
+          thread.channelId
+        );
+        const conversationContext = buildConversationContext(conversation, {
+          excludeMessageId: userMessage2.id
+        });
+        const sandbox = getPersistedSandboxState(currentState);
+        const requester = createRequesterFromStoredSlackRequester({
+          requester: activeSessionRecord.requester,
+          teamId: payload.destination.teamId,
+          userId: userMessage2.author.userId
+        });
+        return {
+          messageText: userMessage2.text,
+          messageTs: getTurnUserSlackMessageTs(userMessage2),
+          replyContext: {
+            credentialContext: {
+              actor: {
+                type: "user",
+                userId: requester.userId
+              }
+            },
+            requester,
+            destination: payload.destination,
+            correlation: {
+              conversationId: payload.conversationId,
+              turnId: payload.sessionId,
+              channelId: thread.channelId,
+              threadTs: thread.threadTs,
+              requesterId: requester.userId
+            },
+            toolChannelId: artifacts.assistantContextChannelId ?? thread.channelId,
+            artifactState: artifacts,
+            pendingAuth: conversation.processing.pendingAuth,
+            conversationContext,
+            channelConfiguration,
+            piMessages: conversation.piMessages,
+            sandbox,
+            onAuthPending: async (nextPendingAuth) => {
+              await applyPendingAuthUpdate({
+                conversation,
+                conversationId: payload.conversationId,
+                nextPendingAuth
+              });
+              await persistThreadStateById(payload.conversationId, {
+                conversation
+              });
+            },
+            ...getTurnUserReplyAttachmentContext(userMessage2)
+          },
+          onSuccess: async (reply) => {
+            await persistCompletedReplyState2({
+              sessionRecord: activeSessionRecord,
+              reply
+            });
+          },
+          onFailure: async () => {
+            await persistFailedReplyState2(activeSessionRecord);
+          },
+          onPostDeliveryCommitFailure: async () => {
+            await failAgentTurnSessionRecord({
+              conversationId: activeSessionRecord.conversationId,
+              expectedVersion: activeSessionRecord.version,
+              sessionId: activeSessionRecord.sessionId,
+              errorMessage: "Continued agent reply was delivered but completion state did not persist"
+            });
+          },
+          onAuthPause: async () => {
+            await persistAuthPauseTurnState({
+              sessionId: payload.sessionId,
+              threadStateId: payload.conversationId
+            });
+            logWarn(
+              "agent_continue_reparked_for_auth",
+              {},
+              {
+                "app.ai.conversation_id": payload.conversationId,
+                "app.ai.session_id": payload.sessionId
+              },
+              "Continued agent run parked for auth"
+            );
+          },
+          onTimeoutPause: async (error) => {
+            if (!isRetryableTurnError(error, "agent_continue")) {
+              throw error;
+            }
+            const version = error.metadata?.version;
+            if (typeof version !== "number") {
+              throw new Error(
+                "Agent continuation did not include a session record version"
+              );
+            }
+            await scheduleAgentContinue2({
+              conversationId: payload.conversationId,
+              destination: payload.destination,
+              sessionId: payload.sessionId,
+              expectedVersion: version
             });
-            return;
           }
-          await options.runtime.handleSubscribedMessage(thread, latestMessage, {
-            destination: context.destination,
-            messageContext,
-            drainSteeringMessages,
-            onInputCommitted,
-            shouldYield: context.shouldYield
+        };
+      } catch (error) {
+        if (sessionRecord) {
+          await failContinuationStartup({
+            sessionRecord
           });
-        } catch (error) {
-          if (isCooperativeTurnYieldError(error)) {
-            return { status: "yielded" };
-          }
-          if (isTurnInputCommitLostError(error)) {
-            return { status: "lost_lease" };
-          }
-          throw error;
         }
+        throw error;
       }
-    });
-    if (turnResult?.status === "yielded" || turnResult?.status === "lost_lease") {
-      return turnResult;
     }
-    return { status: "completed" };
-  };
-}
-function buildSlackInboundMessage(args) {
-  const authorId = requireSlackAuthorId(args.message);
-  const destination = createSlackDestination({
-    channelId: args.thread.channelId,
-    teamId: args.installation?.teamId
   });
-  if (!destination) {
-    throw new Error("Slack inbound message requires destination context");
+}
+async function resumeAwaitingSlackContinuation(conversationId) {
+  const summaries = await listAgentTurnSessionSummariesForConversation(conversationId);
+  for (const summary of summaries) {
+    if (!isContinuationResume(summary)) {
+      continue;
+    }
+    const request = await getAwaitingAgentContinueRequest({
+      conversationId,
+      sessionId: summary.sessionId
+    });
+    if (!request) {
+      await failUnresumableContinuation({
+        conversationId,
+        summary,
+        errorMessage: "Awaiting agent continuation metadata could not be materialized"
+      });
+      continue;
+    }
+    if (await continueSlackAgentRunWithLockRetry(request)) {
+      return true;
+    }
+    await failUnresumableContinuation({
+      conversationId,
+      expectedVersion: request.expectedVersion,
+      summary,
+      errorMessage: "Awaiting agent continuation was stale before it could run"
+    });
   }
-  return {
-    conversationId: args.conversationId,
-    destination,
-    inboundMessageId: [
-      "slack",
-      args.installation?.teamId ?? args.installation?.enterpriseId ?? "unknown",
-      args.conversationId,
-      args.message.id
-    ].join(":"),
-    source: "slack",
-    createdAtMs: args.message.metadata.dateSent.getTime(),
-    receivedAtMs: args.receivedAtMs,
-    input: {
-      text: args.message.text || " ",
-      authorId,
-      attachments: args.message.attachments,
-      metadata: {
-        platform: "slack",
-        route: args.route,
-        installation: args.installation,
-        thread: args.thread.toJSON(),
-        message: args.message.toJSON()
+  return false;
+}
+async function continueSlackAgentRunWithLockRetry(payload, options = {}) {
+  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);
+    } 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
+          },
+          "Rescheduling agent continuation because another run still owns the thread lock"
+        );
+        await scheduleAgentContinue2(payload);
+        return true;
       }
+      logWarn(
+        "agent_continue_lock_busy_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
+        },
+        "Agent continuation lock was busy; retrying"
+      );
+      await sleep3(delayMs);
     }
-  };
+  }
+  return true;
 }
 
 // src/chat/app/production.ts
@@ -22414,6 +21571,7 @@ function getProductionConversationWorkOptions() {
     queue: getVercelConversationWorkQueue(),
     run: createSlackConversationWorker({
       getSlackAdapter: getProductionSlackAdapter,
+      resumeAwaitingContinuation: resumeAwaitingSlackContinuation,
       runtime
     })
   };
@@ -22883,13 +22041,16 @@ async function handleSlashCommandForm(args) {
     args.params.get("user_id"),
     "Slack slash command payload"
   );
-  const userIdentity = buildActorIdentity(
+  const teamId = args.params.get("team_id") ?? void 0;
+  const userIdentity = createRequester(
     {
+      platform: "slack",
+      teamId,
       userId,
       userName: args.params.get("user_name") ?? void 0,
       fullName: args.params.get("user_name") ?? void 0
     },
-    userId
+    { teamId, userId }
   );
   if (!userIdentity?.userId) {
     throw new Error("Slack slash command payload actor identity is invalid");
@@ -23248,7 +22409,7 @@ async function handlePlatformWebhook(request, platform, waitUntil, legacyBot) {
     }
   });
 }
-async function POST3(request, platform, waitUntil) {
+async function POST2(request, platform, waitUntil) {
   return handlePlatformWebhook(request, platform, waitUntil);
 }
 
@@ -23277,7 +22438,7 @@ function isConversationQueueMessageRejectedError(error) {
 // src/chat/task-execution/worker.ts
 var CONVERSATION_WORK_DEFER_DELAY_MS = 15e3;
 var CONVERSATION_WORK_SOFT_YIELD_AFTER_MS = 24e4;
-function now2(options) {
+function now(options) {
   return options.nowMs?.() ?? Date.now();
 }
 function nudgeIdempotencyKey(reason, conversationId, nowMs) {
@@ -23294,21 +22455,11 @@ async function sendWakeNudge(args) {
       idempotencyKey: args.idempotencyKey
     }
   );
-  try {
-    await markConversationWorkEnqueued({
-      conversationId: args.conversationId,
-      nowMs: args.nowMs,
-      state: args.options.state
-    });
-  } catch (error) {
-    logException(
-      error,
-      "conversation_work_enqueue_marker_failed",
-      { conversationId: args.conversationId },
-      {},
-      "Conversation work enqueue marker failed after queue acceptance"
-    );
-  }
+  await markConversationWorkEnqueued({
+    conversationId: args.conversationId,
+    nowMs: args.nowMs,
+    state: args.options.state
+  });
 }
 async function requestLostLeaseRecovery(args) {
   const continuationMarked = await requestConversationContinuation({
@@ -23344,7 +22495,7 @@ async function requestLostLeaseRecovery(args) {
 }
 function startLeaseCheckIn(args) {
   const timer = setInterval(() => {
-    const nowMs = now2(args.options);
+    const nowMs = now(args.options);
     void checkInConversationWork({
       conversationId: args.conversationId,
       leaseToken: args.leaseToken,
@@ -23382,10 +22533,10 @@ async function processConversationWork(message, options) {
     conversationId,
     state: options.state
   });
-  if (!initial || countPendingConversationMessages(initial) === 0 && !initial.needsRun && !initial.lease) {
+  if (!initial || countPendingConversationMessages(initial) === 0 && initial.execution.status === "idle" && !initial.execution.lease) {
     return { status: "no_work" };
   }
-  if (!sameDestination(initial.destination, message.destination)) {
+  if (!initial.destination || !sameDestination(initial.destination, message.destination)) {
     throw new ConversationQueueMessageRejectedError(
       "destination_mismatch",
       `Conversation work queue destination changed for ${conversationId}`,
@@ -23393,50 +22544,24 @@ async function processConversationWork(message, options) {
     );
   }
   const destination = initial.destination;
-  let lease;
-  try {
-    lease = await startConversationWork({
-      conversationId,
-      nowMs: now2(options),
-      state: options.state
-    });
-  } catch (error) {
-    logException(
-      error,
-      "conversation_work_lease_acquire_failed",
-      { conversationId },
-      {},
-      "Conversation work lease acquisition failed; heartbeat will recover"
-    );
-    return { status: "no_work" };
-  }
+  const lease = await startConversationWork({
+    conversationId,
+    nowMs: now(options),
+    state: options.state
+  });
   if (lease.status === "no_work") {
     return { status: "no_work" };
   }
   if (lease.status === "active") {
-    const nudgeNowMs = now2(options);
-    try {
-      await sendWakeNudge({
-        conversationId,
-        destination,
-        delayMs: CONVERSATION_WORK_DEFER_DELAY_MS,
-        idempotencyKey: nudgeIdempotencyKey(
-          "active",
-          conversationId,
-          nudgeNowMs
-        ),
-        nowMs: nudgeNowMs,
-        options
-      });
-    } catch (error) {
-      logException(
-        error,
-        "conversation_work_active_nudge_failed",
-        { conversationId },
-        {},
-        "Conversation work active-lease nudge failed; heartbeat will recover"
-      );
-    }
+    const nudgeNowMs = now(options);
+    await sendWakeNudge({
+      conversationId,
+      destination,
+      delayMs: CONVERSATION_WORK_DEFER_DELAY_MS,
+      idempotencyKey: nudgeIdempotencyKey("active", conversationId, nudgeNowMs),
+      nowMs: nudgeNowMs,
+      options
+    });
     logInfo(
       "conversation_work_nudge_deferred_for_active_lease",
       { conversationId },
@@ -23447,7 +22572,7 @@ async function processConversationWork(message, options) {
     );
     return { status: "active" };
   }
-  const startedAtMs = now2(options);
+  const startedAtMs = now(options);
   const softYieldDeadlineMs = startedAtMs + (options.softYieldAfterMs ?? CONVERSATION_WORK_SOFT_YIELD_AFTER_MS);
   let leaseLost = false;
   const markLeaseLost = () => {
@@ -23472,12 +22597,12 @@ async function processConversationWork(message, options) {
     conversationId,
     destination,
     leaseToken: lease.leaseToken,
-    shouldYield: () => leaseLost || now2(options) >= softYieldDeadlineMs,
+    shouldYield: () => leaseLost || now(options) >= softYieldDeadlineMs,
     checkIn: async () => {
       const checkedIn = await checkInConversationWork({
         conversationId,
         leaseToken: lease.leaseToken,
-        nowMs: now2(options),
+        nowMs: now(options),
         state: options.state
       });
       if (!checkedIn) {
@@ -23489,7 +22614,7 @@ async function processConversationWork(message, options) {
       conversationId,
       leaseToken: lease.leaseToken,
       inject,
-      nowMs: now2(options),
+      nowMs: now(options),
       state: options.state
     })
   };
@@ -23500,7 +22625,7 @@ async function processConversationWork(message, options) {
         conversationId,
         destination,
         leaseToken: lease.leaseToken,
-        nowMs: now2(options),
+        nowMs: now(options),
         options
       });
       return { status: "lost_lease" };
@@ -23510,13 +22635,13 @@ async function processConversationWork(message, options) {
         conversationId,
         destination,
         leaseToken: lease.leaseToken,
-        nowMs: now2(options),
+        nowMs: now(options),
         options
       });
       return { status: "lost_lease" };
     }
     if (result.status === "yielded") {
-      const yieldNowMs = now2(options);
+      const yieldNowMs = now(options);
       const continuationMarked = await requestConversationContinuation({
         conversationId,
         destination,
@@ -23548,7 +22673,7 @@ async function processConversationWork(message, options) {
         "conversation_work_cooperative_yield",
         { conversationId },
         {
-          "app.worker.elapsed_ms": now2(options) - startedAtMs,
+          "app.worker.elapsed_ms": now(options) - startedAtMs,
           "app.worker.soft_yield_deadline_ms": softYieldDeadlineMs
         },
         "Conversation work yielded cooperatively"
@@ -23558,14 +22683,14 @@ async function processConversationWork(message, options) {
     const completion = await completeConversationWork({
       conversationId,
       leaseToken: lease.leaseToken,
-      nowMs: now2(options),
+      nowMs: now(options),
       state: options.state
     });
     if (completion === "lost_lease") {
       return { status: "lost_lease" };
     }
     if (completion === "pending") {
-      const nudgeNowMs = now2(options);
+      const nudgeNowMs = now(options);
       await sendWakeNudge({
         conversationId,
         destination,
@@ -23583,104 +22708,42 @@ async function processConversationWork(message, options) {
       "conversation_work_completed",
       { conversationId },
       {
-        "app.worker.elapsed_ms": now2(options) - startedAtMs
+        "app.worker.elapsed_ms": now(options) - startedAtMs
       },
       "Conversation work completed"
     );
     return { status: "completed" };
   } catch (error) {
-    const errorNowMs = now2(options);
-    let failure2;
+    const errorNowMs = now(options);
     try {
-      failure2 = await recordConversationWorkFailure({
+      const continuationMarked = await requestConversationContinuation({
         conversationId,
+        destination,
+        leaseToken: lease.leaseToken,
         nowMs: errorNowMs,
         state: options.state
       });
-    } catch (recordError) {
-      logException(
-        recordError,
-        "conversation_work_failure_record_failed",
-        { conversationId },
-        {},
-        "Conversation work failure counter update failed"
-      );
-    }
-    if (!isProviderRetryError(error)) {
-      logException(
-        error,
-        "conversation_work_failed",
-        { conversationId },
-        {
-          "app.worker.consecutive_failure_count": failure2?.consecutiveFailureCount ?? null,
-          "app.worker.elapsed_ms": now2(options) - startedAtMs
-        },
-        "Conversation work failed"
-      );
-    }
-    if (failure2?.abandoned) {
-      logWarn(
-        "conversation_work_abandoned",
-        { conversationId },
-        {
-          "app.worker.consecutive_failure_count": failure2.consecutiveFailureCount,
-          "app.worker.max_consecutive_failures": CONVERSATION_WORK_MAX_CONSECUTIVE_FAILURES
-        },
-        "Conversation work abandoned after repeated failures; stopping retries"
-      );
-      if (!failure2.releasedLease) {
-        try {
-          await releaseConversationWork({
-            conversationId,
-            leaseToken: lease.leaseToken,
-            nowMs: errorNowMs,
-            state: options.state
-          });
-        } catch (releaseError) {
-          logException(
-            releaseError,
-            "conversation_work_release_failed",
-            { conversationId },
-            {},
-            "Conversation work release failed after abandoning"
-          );
-        }
-      }
-      return { status: "abandoned" };
-    }
-    let requeueSucceeded = false;
-    if (failure2) {
-      try {
-        const continuationMarked = await requestConversationContinuation({
+      if (continuationMarked) {
+        await sendWakeNudge({
           conversationId,
           destination,
-          leaseToken: lease.leaseToken,
+          idempotencyKey: nudgeIdempotencyKey(
+            "error",
+            conversationId,
+            errorNowMs
+          ),
           nowMs: errorNowMs,
-          state: options.state
+          options
         });
-        if (continuationMarked) {
-          await sendWakeNudge({
-            conversationId,
-            destination,
-            idempotencyKey: nudgeIdempotencyKey(
-              "error",
-              conversationId,
-              errorNowMs
-            ),
-            nowMs: errorNowMs,
-            options
-          });
-          requeueSucceeded = true;
-        }
-      } catch (requeueError) {
-        logException(
-          requeueError,
-          "conversation_work_requeue_failed",
-          { conversationId },
-          {},
-          "Conversation work requeue failed after runner error"
-        );
       }
+    } catch (requeueError) {
+      logException(
+        requeueError,
+        "conversation_work_requeue_failed",
+        { conversationId },
+        {},
+        "Conversation work requeue failed after runner error"
+      );
     }
     try {
       await releaseConversationWork({
@@ -23698,8 +22761,16 @@ async function processConversationWork(message, options) {
         "Conversation work release failed after runner error"
       );
     }
-    if (requeueSucceeded) {
-      return { status: "pending_requeued" };
+    if (!isProviderRetryError(error)) {
+      logException(
+        error,
+        "conversation_work_failed",
+        { conversationId },
+        {
+          "app.worker.elapsed_ms": now(options) - startedAtMs
+        },
+        "Conversation work failed"
+      );
     }
     throw error;
   } finally {
@@ -24044,9 +23115,6 @@ async function createApp(options) {
   app.get("/api/oauth/callback/:provider", (c) => {
     return GET4(c.req.raw, c.req.param("provider"), waitUntil);
   });
-  app.post("/api/internal/turn-resume", (c) => {
-    return POST2(c.req.raw, waitUntil);
-  });
   app.post("/api/internal/agent-dispatch", (c) => {
     return POST(c.req.raw, waitUntil);
   });
@@ -24069,7 +23137,7 @@ async function createApp(options) {
     return GET2(c.req.raw, waitUntil);
   });
   app.post("/api/webhooks/:platform", (c) => {
-    return POST3(c.req.raw, c.req.param("platform"), waitUntil);
+    return POST2(c.req.raw, c.req.param("platform"), waitUntil);
   });
   return app;
 }