@sentry/junior 0.21.0 → 0.22.0

package/dist/app.js

@@ -6,7 +6,7 @@ import {
   loadSkillsByName,
   logCapabilityCatalogLoadedOnce,
   parseSkillInvocation
-} from "./chunk-NRSP2MLC.js";
+} from "./chunk-JWBWBJYJ.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -27,10 +27,11 @@ import {
   sandboxSkillDir,
   sandboxSkillFile,
   toOptionalTrimmed
-} from "./chunk-Z43DS7XN.js";
+} from "./chunk-THPM7NSG.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
+  createChatSdkLogger,
   createPluginBroker,
   createRequestContext,
   extractGenAiUsageAttributes,
@@ -57,7 +58,7 @@ import {
   toOptionalString,
   withContext,
   withSpan
-} from "./chunk-N4ICA2BC.js";
+} from "./chunk-MCJJKEB3.js";
 import "./chunk-Z3YD6NHK.js";
 import {
   discoverInstalledPluginPackageContent,
@@ -1786,7 +1787,7 @@ function validateConfigKey(key) {
     return "Configuration key must not be empty";
   }
   if (!CONFIG_KEY_RE.test(trimmed)) {
-    return `Invalid configuration key "${key}"; expected dotted lowercase namespace (for example "github.repo")`;
+    return `Invalid configuration key "${key}"; expected dotted lowercase namespace (for example "provider.repo")`;
   }
   if (SECRET_KEY_RE.test(trimmed)) {
     return `Configuration key "${key}" appears to be secret-related and is not allowed`;
@@ -1808,7 +1809,9 @@ function collectStringValues(value, output, depth = 0) {
     return;
   }
   if (value && typeof value === "object") {
-    for (const [key, nested] of Object.entries(value)) {
+    for (const [key, nested] of Object.entries(
+      value
+    )) {
       output.push(key);
       collectStringValues(nested, output, depth + 1);
     }
@@ -2016,6 +2019,9 @@ function buildArtifactStatePatch(patch) {
 function threadStateKey(threadId) {
   return `thread-state:${threadId}`;
 }
+function channelStateKey(channelId) {
+  return `channel-state:${channelId}`;
+}
 function buildThreadStatePayload(patch) {
   const payload = {};
   if (patch.artifacts) {
@@ -2045,6 +2051,14 @@ function mergeArtifactsState(artifacts, patch) {
     }
   };
 }
+function getPersistedSandboxState(state) {
+  return {
+    sandboxId: toOptionalString(state.app_sandbox_id),
+    sandboxDependencyProfileHash: toOptionalString(
+      state.app_sandbox_dependency_profile_hash
+    )
+  };
+}
 async function persistThreadState(thread, patch) {
   const payload = buildThreadStatePayload(patch);
   if (Object.keys(payload).length === 0) {
@@ -2059,6 +2073,13 @@ async function getPersistedThreadState(threadId) {
     threadStateKey(threadId)
   ) ?? {};
 }
+async function getPersistedChannelState(channelId) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  return await stateAdapter.get(
+    channelStateKey(channelId)
+  ) ?? {};
+}
 async function persistThreadStateById(threadId, patch) {
   const payload = buildThreadStatePayload(patch);
   if (Object.keys(payload).length === 0) {
@@ -2081,6 +2102,115 @@ function getChannelConfigurationService(thread) {
     }
   });
 }
+function getChannelConfigurationServiceById(channelId) {
+  return createChannelConfigurationService({
+    load: async () => await getPersistedChannelState(channelId),
+    save: async (state) => {
+      const stateAdapter = getStateAdapter();
+      await stateAdapter.connect();
+      const key = channelStateKey(channelId);
+      const existing = await stateAdapter.get(key) ?? {};
+      await stateAdapter.set(
+        key,
+        { ...existing, configuration: state },
+        THREAD_STATE_TTL_MS
+      );
+    }
+  });
+}
+
+// src/chat/runtime/thread-participants.ts
+function buildThreadParticipants(messages) {
+  const seen = /* @__PURE__ */ new Set();
+  const participants = [];
+  for (const message of messages) {
+    const { userId, userName, fullName } = message.author ?? {};
+    if (!userId || message.author?.isBot) continue;
+    if (seen.has(userId)) continue;
+    seen.add(userId);
+    participants.push({ userId, userName, fullName });
+  }
+  return participants;
+}
+
+// src/chat/runtime/turn.ts
+function buildDeterministicTurnId(messageId) {
+  const sanitized = messageId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return `turn_${sanitized}`;
+}
+var RetryableTurnError = class extends Error {
+  code = "retryable_turn";
+  metadata;
+  reason;
+  constructor(reason, message, metadata) {
+    super(message);
+    this.name = "RetryableTurnError";
+    this.reason = reason;
+    this.metadata = metadata;
+  }
+};
+function isRetryableTurnError(error, reason) {
+  if (!(error instanceof RetryableTurnError)) {
+    return false;
+  }
+  if (!reason) {
+    return true;
+  }
+  return error.reason === reason;
+}
+function startActiveTurn(args) {
+  args.conversation.processing.activeTurnId = args.nextTurnId;
+  args.updateConversationStats(args.conversation);
+}
+function markTurnCompleted(args) {
+  args.conversation.processing.activeTurnId = void 0;
+  args.conversation.processing.lastCompletedAtMs = args.nowMs;
+  args.updateConversationStats(args.conversation);
+}
+function markTurnFailed(args) {
+  args.conversation.processing.activeTurnId = void 0;
+  args.conversation.processing.lastCompletedAtMs = args.nowMs;
+  args.markConversationMessage(args.conversation, args.userMessageId, {
+    replied: false,
+    skippedReason: "reply failed"
+  });
+  args.updateConversationStats(args.conversation);
+}
+function resolveReplyDelivery(args) {
+  const replyHasFiles = Boolean(
+    args.reply.files && args.reply.files.length > 0
+  );
+  const deliveryPlan = args.reply.deliveryPlan ?? {
+    mode: args.reply.deliveryMode ?? "thread",
+    postThreadText: (args.reply.deliveryMode ?? "thread") !== "channel_only",
+    attachFiles: replyHasFiles ? args.hasStreamedThreadReply ? "followup" : "inline" : "none"
+  };
+  let attachFiles = replyHasFiles ? deliveryPlan.attachFiles : "none";
+  if (attachFiles === "followup" && !args.hasStreamedThreadReply) {
+    attachFiles = "inline";
+  }
+  return {
+    shouldPostThreadReply: deliveryPlan.postThreadText,
+    attachFiles
+  };
+}
+
+// src/chat/runtime/turn-user-message.ts
+function getTurnUserMessage(conversation, sessionId) {
+  for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
+    const message = conversation.messages[index];
+    if (message?.role !== "user") {
+      continue;
+    }
+    if (buildDeterministicTurnId(message.id) === sessionId) {
+      return message;
+    }
+  }
+  return void 0;
+}
+function getTurnUserMessageId(conversation, sessionId) {
+  return getTurnUserMessage(conversation, sessionId)?.id;
+}
 
 // src/chat/pi/client.ts
 import {
@@ -3055,14 +3185,14 @@ function buildSystemPrompt(params) {
         "- Use `slackMessageAddReaction` for rare lightweight acknowledgements. It reacts to the current inbound message via runtime context; never pick a target message yourself.",
         "- If the user explicitly asks for an emoji reaction instead of text, use `slackMessageAddReaction` with a Slack emoji alias name (for example `thumbsup`, `white_check_mark`, or `eyes`, not unicode emoji), and avoid redundant acknowledgment text.",
         "- Suggested acknowledgement reactions include `wave`, `white_check_mark`, `thumbsup`, and `eyes`, but choose what best fits the request.",
-        "- If a loaded skill or `loadSkill` result declares `requires_capabilities`, run `jr-rpc issue-credential <capability> [--repo <owner/repo>]` as a bash command before authenticated bash/API work for that skill.",
+        "- If a loaded skill or `loadSkill` result declares `requires_capabilities`, run `jr-rpc issue-credential <capability> [--target <value>]` as a bash command before authenticated bash/API work for that skill.",
         "- Use the minimum declared capability needed for the current operation.",
         "- If `jr-rpc issue-credential` returns `oauth_started`, relay its `message` to the user and stop. The runtime will resume after authorization.",
         "- For disconnect + reconnect requests, run `jr-rpc delete-token <provider>` first, then `jr-rpc issue-credential` \u2014 the system handles the reconnect without auto-resuming the reconnect message.",
         "- Use `jr-rpc oauth-start <provider>` only when the user explicitly asks to connect a provider and there is no task to resume after authorization.",
-        "- GitHub capabilities need repository context, which can come from `--repo` or a configured `github.repo` default.",
-        "- To persist or read conversation defaults (for example `github.repo`), run `jr-rpc config get|set|unset|list ...` as a bash command.",
-        "- Capabilities are provider-qualified (for example `github.issues.write`).",
+        "- Provider-targeted capabilities may need `--target <value>` or a provider-specific configured default target key when the provider catalog shows one.",
+        "- To persist or read conversation defaults, choose a config key from the provider catalog or active skill metadata and run `jr-rpc config get|set|unset|list ...` as a bash command.",
+        "- Capabilities must match the exact provider-qualified tokens declared by the loaded skill or provider catalog.",
         "- When your work is complete, provide the exact user-facing markdown response.",
         "- Do not use reaction-based progress signals; Assistants API status already covers in-progress UX.",
         "- Prefer `webSearch` before `webFetch` when the user gave no URL.",
@@ -3134,40 +3264,49 @@ var ProviderCredentialRouter = class {
 };
 
 // src/chat/capabilities/target.ts
-var REPO_FLAG_RE = /(?:^|\s)--repo(?:\s+|=)([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+(?:#[0-9]+)?)/;
-function parseRepoTarget(value) {
-  const trimmed = value.trim();
-  if (!trimmed) {
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeTargetValue(value) {
+  let normalized = value.trim();
+  if (normalized.startsWith('"') && normalized.endsWith('"') || normalized.startsWith("'") && normalized.endsWith("'")) {
+    normalized = normalized.slice(1, -1).trim();
+  }
+  return normalized || void 0;
+}
+function extractFlagValue(text, flags) {
+  if (flags.length === 0) {
     return void 0;
   }
-  const [repoRef] = trimmed.split("#");
-  const [owner, repo] = repoRef.split("/");
-  if (!owner || !repo) {
+  const pattern = flags.map(escapeRegExp).join("|");
+  const match = new RegExp(
+    String.raw`(?:^|\s)(?:${pattern})(?:\s+|=)([^\s]+)`
+  ).exec(text);
+  return match ? normalizeTargetValue(match[1] ?? "") : void 0;
+}
+function createCapabilityTarget(type, value) {
+  const normalizedType = type.trim();
+  const normalizedValue = normalizeTargetValue(value);
+  if (!normalizedType || !normalizedValue) {
     return void 0;
   }
   return {
-    owner: owner.toLowerCase(),
-    repo: repo.toLowerCase()
+    type: normalizedType,
+    value: normalizedValue
   };
 }
-function extractRepoRef(text) {
-  const byFlag = REPO_FLAG_RE.exec(text);
-  if (byFlag) {
-    return parseRepoTarget(byFlag[1]);
-  }
-  return void 0;
-}
 function extractCapabilityTarget(params) {
+  const flags = params.target.commandFlags ?? [];
   if (params.commandText) {
-    const commandRepo = extractRepoRef(params.commandText);
-    if (commandRepo) {
-      return commandRepo;
+    const value = extractFlagValue(params.commandText, flags);
+    if (value) {
+      return createCapabilityTarget(params.target.type, value);
     }
   }
   if (params.invocationArgs) {
-    const invocationRepo = extractRepoRef(params.invocationArgs);
-    if (invocationRepo) {
-      return invocationRepo;
+    const value = extractFlagValue(params.invocationArgs, flags);
+    if (value) {
+      return createCapabilityTarget(params.target.type, value);
     }
   }
   return void 0;
@@ -3198,44 +3337,50 @@ var SkillCapabilityRuntime = class {
   }
   async resolveCapabilityTarget(input) {
     const activeSkill = input.activeSkill;
-    const explicitTarget = input.repoRef ? parseRepoTarget(input.repoRef) : void 0;
+    const explicitTarget = input.targetRef ? createCapabilityTarget(input.target.type, input.targetRef) : void 0;
     if (explicitTarget) {
       return explicitTarget;
     }
     const inferredTarget = extractCapabilityTarget({
-      invocationArgs: this.invocationArgs
+      invocationArgs: this.invocationArgs,
+      target: input.target
     });
     if (inferredTarget) {
       return inferredTarget;
     }
-    if (!input.configKey || !this.resolveConfiguration) {
+    if (!this.resolveConfiguration) {
       return void 0;
     }
-    const configuredRepo = await this.resolveConfiguration(input.configKey);
-    if (typeof configuredRepo !== "string" || configuredRepo.trim().length === 0) {
+    const configuredValue = await this.resolveConfiguration(
+      input.target.configKey
+    );
+    if (typeof configuredValue !== "string" || configuredValue.trim().length === 0) {
       return void 0;
     }
-    const configuredTarget = parseRepoTarget(configuredRepo);
+    const configuredTarget = createCapabilityTarget(
+      input.target.type,
+      configuredValue
+    );
     if (!configuredTarget) {
       logWarn(
         "config_value_invalid_for_capability_target",
         {},
         {
           "app.skill.name": activeSkill?.name,
-          "app.config.key": input.configKey
+          "app.config.key": input.target.configKey
         },
-        `Configured ${input.configKey} is invalid for capability target resolution`
+        `Configured ${input.target.configKey} is invalid for capability target resolution`
       );
       return void 0;
     }
     const declaredConfig = activeSkill?.usesConfig ?? [];
-    if (activeSkill && !declaredConfig.includes(input.configKey)) {
+    if (activeSkill && !declaredConfig.includes(input.target.configKey)) {
       logWarn(
         "config_key_not_declared_for_skill",
         {},
         {
           "app.skill.name": activeSkill.name,
-          "app.config.key": input.configKey
+          "app.config.key": input.target.configKey
         },
         "Configuration key used by runtime is not declared in active skill frontmatter (soft enforcement)"
       );
@@ -3243,9 +3388,7 @@ var SkillCapabilityRuntime = class {
     return configuredTarget;
   }
   capabilityCacheKey(capability, target) {
-    const owner = target?.owner?.trim().toLowerCase();
-    const repo = target?.repo?.trim().toLowerCase();
-    const scope = owner && repo ? `${owner}/${repo}` : "none";
+    const scope = target ? `${target.type}:${target.value.trim()}` : "none";
     return `${capability}:${scope}`;
   }
   async issueCapabilityLease(input) {
@@ -3256,10 +3399,10 @@ var SkillCapabilityRuntime = class {
       );
     }
     const activeSkill = input.activeSkill;
-    const target = capabilityProvider.target?.type === "repo" ? await this.resolveCapabilityTarget({
+    const target = capabilityProvider.target ? await this.resolveCapabilityTarget({
       activeSkill,
-      repoRef: input.repoRef,
-      configKey: capabilityProvider.target.configKey
+      target: capabilityProvider.target,
+      targetRef: input.targetRef
     }) : void 0;
     return await this.router.issue({
       capability: input.capability,
@@ -3294,14 +3437,14 @@ var SkillCapabilityRuntime = class {
       );
     }
     const activeSkill = input.activeSkill;
-    const capabilityTarget = capabilityProvider.target?.type === "repo" ? await this.resolveCapabilityTarget({
+    const capabilityTarget = capabilityProvider.target ? await this.resolveCapabilityTarget({
       activeSkill,
-      repoRef: input.repoRef,
-      configKey: capabilityProvider.target.configKey
+      target: capabilityProvider.target,
+      targetRef: input.targetRef
     }) : void 0;
-    if (capabilityProvider.target?.type === "repo" && (!capabilityTarget?.owner || !capabilityTarget?.repo)) {
+    if (capabilityProvider.target && !capabilityTarget?.value.trim()) {
       throw new Error(
-        "jr-rpc issue-credential requires repository context; use --repo <owner/repo>"
+        `jr-rpc issue-credential requires ${capabilityProvider.target.type} target context; use --target <value>`
       );
     }
     const declared = activeSkill?.requiresCapabilities ?? [];
@@ -3338,7 +3481,7 @@ var SkillCapabilityRuntime = class {
       const lease = await this.issueCapabilityLease({
         activeSkill,
         capability,
-        repoRef: input.repoRef,
+        targetRef: input.targetRef,
         reason: input.reason
       });
       const transforms = this.toHeaderTransforms(lease);
@@ -3465,7 +3608,7 @@ var TestCredentialBroker = class {
       expiresAt,
       metadata: {
         reason: input.reason,
-        target: input.target?.owner && input.target?.repo ? `${input.target.owner}/${input.target.repo}` : "none"
+        target: input.target ? `${input.target.type}:${input.target.value}` : "none"
       }
     };
   }
@@ -3568,24 +3711,24 @@ async function handleIssueCredentialCommand(args, deps) {
       exitCode: 2
     });
   }
-  let repoRef;
+  let targetRef;
   const extras = args.slice(1);
   if (extras.length > 0) {
-    if (extras.length === 2 && extras[0] === "--repo") {
-      repoRef = extras[1];
-    } else if (extras.length === 1 && extras[0].startsWith("--repo=")) {
-      repoRef = extras[0].slice("--repo=".length);
+    if (extras.length === 2 && extras[0] === "--target") {
+      targetRef = extras[1]?.trim();
+    } else if (extras.length === 1 && extras[0].startsWith("--target=")) {
+      targetRef = extras[0].slice("--target=".length).trim();
     } else {
       return {
         stdout: "",
-        stderr: "jr-rpc issue-credential requires exactly one capability argument and optional --repo <owner/repo>\n",
+        stderr: "jr-rpc issue-credential requires exactly one capability argument and optional --target <value>\n",
         exitCode: 2
       };
     }
-    if (!parseRepoTarget(repoRef ?? "")) {
+    if (!targetRef) {
       return {
         stdout: "",
-        stderr: "jr-rpc issue-credential --repo must be in owner/repo format\n",
+        stderr: "jr-rpc issue-credential --target requires a non-empty value\n",
         exitCode: 2
       };
     }
@@ -3595,7 +3738,7 @@ async function handleIssueCredentialCommand(args, deps) {
     outcome = await deps.capabilityRuntime.enableCapabilityForTurn({
       activeSkill: deps.activeSkill,
       capability,
-      ...repoRef ? { repoRef } : {},
+      ...targetRef ? { targetRef } : {},
       reason: `skill:${deps.activeSkill?.name ?? "unknown"}:jr-rpc:issue-credential`
     });
   } catch (error) {
@@ -3985,7 +4128,7 @@ async function handleDeleteTokenCommand(args, deps) {
 function createJrRpcCommand(deps) {
   return defineCommand("jr-rpc", async (args) => {
     const usage = [
-      "jr-rpc issue-credential <capability> [--repo <owner/repo>]",
+      "jr-rpc issue-credential <capability> [--target <value>]",
       "jr-rpc oauth-start <provider>",
       "jr-rpc delete-token <provider>",
       "jr-rpc config get <key>",
@@ -5778,7 +5921,7 @@ function createSlackCanvasCreateTool(context, state) {
         channelId: targetChannelId
       });
       state.setTurnCreatedCanvasId(created.canvasId);
-      state.patchArtifactState({
+      await state.patchArtifactState({
         lastCanvasId: created.canvasId,
         lastCanvasUrl: created.permalink,
         recentCanvases: mergeRecentCanvases(
@@ -5877,7 +6020,7 @@ function createSlackCanvasUpdateTool(state, _context) {
         operation: resolvedOperation,
         sectionId
       });
-      state.patchArtifactState({ lastCanvasId: targetCanvasId });
+      await state.patchArtifactState({ lastCanvasId: targetCanvasId });
       const response = {
         ok: true,
         canvas_id: targetCanvasId,
@@ -6082,7 +6225,7 @@ function createSlackListCreateTool(state) {
         };
       }
       const list = await createTodoList(name);
-      state.patchArtifactState({
+      await state.patchArtifactState({
         lastListId: list.listId,
         lastListUrl: list.permalink,
         listColumnMap: list.listColumnMap
@@ -6145,7 +6288,7 @@ function createSlackListAddItemsTool(state) {
         assigneeUserId: assignee_user_id,
         dueDate: due_date
       });
-      state.patchArtifactState({
+      await state.patchArtifactState({
         lastListId: targetListId,
         listColumnMap: result.listColumnMap
       });
@@ -6237,7 +6380,7 @@ function createSlackListUpdateItemTool(state) {
         title,
         listColumnMap: state.artifactState.listColumnMap ?? {}
       });
-      state.patchArtifactState({ lastListId: targetListId });
+      await state.patchArtifactState({ lastListId: targetListId });
       const response = {
         ok: true,
         list_id: targetListId,
@@ -6838,7 +6981,7 @@ function createToolState(hooks, context) {
       ...context.artifactState?.listColumnMap ?? {}
     }
   };
-  const patchArtifactState = (patch) => {
+  const patchArtifactState = async (patch) => {
     Object.assign(artifactState, patch);
     if (patch.listColumnMap) {
       artifactState.listColumnMap = {
@@ -6846,7 +6989,7 @@ function createToolState(hooks, context) {
         ...patch.listColumnMap
       };
     }
-    hooks.onArtifactStatePatch?.(patch);
+    await hooks.onArtifactStatePatch?.(patch);
   };
   return {
     artifactState,
@@ -7955,10 +8098,14 @@ function createSandboxSessionManager(options) {
     sandboxIdHint = void 0;
     toolExecutors = void 0;
   };
-  const rememberSandbox = (nextSandbox) => {
+  const rememberSandbox = async (nextSandbox) => {
     sandbox = nextSandbox;
     sandboxIdHint = nextSandbox.sandboxId;
     toolExecutors = void 0;
+    await options?.onSandboxAcquired?.({
+      sandboxId: nextSandbox.sandboxId,
+      ...dependencyProfileHash ? { sandboxDependencyProfileHash: dependencyProfileHash } : {}
+    });
     return nextSandbox;
   };
   const failSetup = (error) => {
@@ -8148,7 +8295,7 @@ function createSandboxSessionManager(options) {
     } catch (error) {
       return failSetup(error);
     }
-    return rememberSandbox(createdSandbox);
+    return await rememberSandbox(createdSandbox);
   };
   const discardHintIfProfileChanged = () => {
     if (sandbox || !sandboxIdHint || dependencyProfileHash === options?.sandboxDependencyProfileHash) {
@@ -8203,7 +8350,7 @@ function createSandboxSessionManager(options) {
     }
     try {
       await syncSkills(hintedSandbox);
-      return rememberSandbox(hintedSandbox);
+      return await rememberSandbox(hintedSandbox);
     } catch (error) {
       if (isSandboxUnavailableError(error)) {
         return await recreateUnavailableSandbox("id_hint");
@@ -8450,7 +8597,8 @@ function createSandboxExecutor(options) {
     sandboxDependencyProfileHash: options?.sandboxDependencyProfileHash,
     timeoutMs: options?.timeoutMs,
     traceContext,
-    onStatus: options?.onStatus
+    onStatus: options?.onStatus,
+    onSandboxAcquired: options?.onSandboxAcquired
   });
   const withSandboxSpan = (name, op, attributes, callback) => withSpan(name, op, traceContext, callback, attributes);
   const logSandboxBootRequest = (trigger, details = {}) => {
@@ -8964,66 +9112,6 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
   }));
 }
 
-// src/chat/runtime/turn.ts
-function buildDeterministicTurnId(messageId) {
-  const sanitized = messageId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return `turn_${sanitized}`;
-}
-var RetryableTurnError = class extends Error {
-  code = "retryable_turn";
-  reason;
-  constructor(reason, message) {
-    super(message);
-    this.name = "RetryableTurnError";
-    this.reason = reason;
-  }
-};
-function isRetryableTurnError(error, reason) {
-  if (!(error instanceof RetryableTurnError)) {
-    return false;
-  }
-  if (!reason) {
-    return true;
-  }
-  return error.reason === reason;
-}
-function startActiveTurn(args) {
-  args.conversation.processing.activeTurnId = args.nextTurnId;
-  args.updateConversationStats(args.conversation);
-}
-function markTurnCompleted(args) {
-  args.conversation.processing.activeTurnId = void 0;
-  args.conversation.processing.lastCompletedAtMs = args.nowMs;
-  args.updateConversationStats(args.conversation);
-}
-function markTurnFailed(args) {
-  args.conversation.processing.activeTurnId = void 0;
-  args.conversation.processing.lastCompletedAtMs = args.nowMs;
-  args.markConversationMessage(args.conversation, args.userMessageId, {
-    replied: false,
-    skippedReason: "reply failed"
-  });
-  args.updateConversationStats(args.conversation);
-}
-function resolveReplyDelivery(args) {
-  const replyHasFiles = Boolean(
-    args.reply.files && args.reply.files.length > 0
-  );
-  const deliveryPlan = args.reply.deliveryPlan ?? {
-    mode: args.reply.deliveryMode ?? "thread",
-    postThreadText: (args.reply.deliveryMode ?? "thread") !== "channel_only",
-    attachFiles: replyHasFiles ? args.hasStreamedThreadReply ? "followup" : "inline" : "none"
-  };
-  let attachFiles = replyHasFiles ? deliveryPlan.attachFiles : "none";
-  if (attachFiles === "followup" && !args.hasStreamedThreadReply) {
-    attachFiles = "inline";
-  }
-  return {
-    shouldPostThreadReply: deliveryPlan.postThreadText,
-    attachFiles
-  };
-}
-
 // src/chat/services/reply-delivery-plan.ts
 var REACTION_ONLY_ACK_RE = /^(?::[a-z0-9_+-]+:|[\p{Extended_Pictographic}\uFE0F\u200D]+)$/u;
 var REDUNDANT_REACTION_ACK_TEXT = ["done", "got it", "ok", "okay"];
@@ -9372,6 +9460,50 @@ async function persistAuthPauseCheckpoint(args) {
   }
   return nextSliceId;
 }
+async function persistTimeoutCheckpoint(args) {
+  const nextSliceId = args.currentSliceId + 1;
+  try {
+    const latestCheckpoint = await getAgentTurnSessionCheckpoint(
+      args.conversationId,
+      args.sessionId
+    );
+    const piMessages = trimTrailingAssistantMessages(
+      args.messages.length > 0 ? args.messages : latestCheckpoint?.piMessages ?? []
+    );
+    return await upsertAgentTurnSessionCheckpoint({
+      conversationId: args.conversationId,
+      sessionId: args.sessionId,
+      sliceId: nextSliceId,
+      state: "awaiting_resume",
+      piMessages,
+      loadedSkillNames: args.loadedSkillNames,
+      resumeReason: "timeout",
+      resumedFromSliceId: args.currentSliceId,
+      errorMessage: args.errorMessage
+    });
+  } catch (checkpointError) {
+    logException(
+      checkpointError,
+      "agent_turn_timeout_resume_checkpoint_failed",
+      {
+        slackThreadId: args.logContext.threadId,
+        slackUserId: args.logContext.requesterId,
+        slackChannelId: args.logContext.channelId,
+        runId: args.logContext.runId,
+        assistantUserName: args.logContext.assistantUserName,
+        modelId: args.logContext.modelId
+      },
+      {
+        "app.ai.resume_conversation_id": args.conversationId,
+        "app.ai.resume_session_id": args.sessionId,
+        "app.ai.resume_from_slice_id": args.currentSliceId,
+        "app.ai.resume_next_slice_id": nextSliceId
+      },
+      "Failed to persist timeout checkpoint before scheduling resume"
+    );
+    return void 0;
+  }
+}
 
 // src/chat/services/mcp-auth-orchestration.ts
 var McpAuthorizationPauseError = class extends Error {
@@ -9462,21 +9594,6 @@ function mcpToolsToDefinitions(mcpTools) {
   }
   return defs;
 }
-async function maybeReplaceAgentMessages(agent, messages) {
-  const resumable = agent;
-  if (typeof resumable.replaceMessages !== "function") {
-    return false;
-  }
-  await resumable.replaceMessages(messages);
-  return true;
-}
-async function runAgentContinuation(agent) {
-  const resumable = agent;
-  if (typeof resumable.continue !== "function") {
-    throw new Error("Agent continuation is unavailable in this runtime");
-  }
-  return await resumable.continue();
-}
 async function generateAssistantReply(messageText, context = {}) {
   let timeoutResumeConversationId;
   let timeoutResumeSessionId;
@@ -9487,6 +9604,7 @@ async function generateAssistantReply(messageText, context = {}) {
   let loadedSkillNamesForResume = [];
   let mcpToolManager;
   let sandboxExecutor;
+  let timedOut = false;
   const getSandboxMetadata = () => sandboxExecutor ? {
     sandboxId: sandboxExecutor.getSandboxId(),
     sandboxDependencyProfileHash: sandboxExecutor.getDependencyProfileHash()
@@ -9529,9 +9647,8 @@ async function generateAssistantReply(messageText, context = {}) {
         "Discovered startup SOUL/skills/plugins"
       );
     }
-    const configurationValues = {
-      ...context.configuration ?? {}
-    };
+    let baseInstructions = "";
+    let configurationValues;
     const userInput = messageText;
     if (shouldTrace) {
       logInfo(
@@ -9560,6 +9677,11 @@ async function generateAssistantReply(messageText, context = {}) {
     timeoutResumeConversationId = sessionConversationId;
     timeoutResumeSessionId = sessionId;
     timeoutResumeSliceId = currentSliceId;
+    const persistedConfigurationValues = context.channelConfiguration ? await context.channelConfiguration.resolveValues() : {};
+    configurationValues = {
+      ...context.configuration ?? {},
+      ...persistedConfigurationValues
+    };
     const capabilityRuntime = createSkillCapabilityRuntime({
       invocationArgs: skillInvocation?.args,
       requesterId: context.requester?.userId,
@@ -9571,6 +9693,11 @@ async function generateAssistantReply(messageText, context = {}) {
       sandboxDependencyProfileHash: context.sandbox?.sandboxDependencyProfileHash,
       traceContext: spanContext,
       onStatus: context.onStatus,
+      onSandboxAcquired: async (sandbox2) => {
+        lastKnownSandboxId = sandbox2.sandboxId;
+        lastKnownSandboxDependencyProfileHash = sandbox2.sandboxDependencyProfileHash;
+        await context.onSandboxAcquired?.(sandbox2);
+      },
       runBashCustomCommand: async (command) => {
         const result = await maybeExecuteJrRpcCustomCommand(command, {
           capabilityRuntime,
@@ -9710,8 +9837,14 @@ async function generateAssistantReply(messageText, context = {}) {
         onGeneratedFiles: (files) => {
           replyFiles.push(...files);
         },
-        onArtifactStatePatch: (patch) => {
+        onArtifactStatePatch: async (patch) => {
           Object.assign(artifactStatePatch, patch);
+          await context.onArtifactStateUpdated?.(
+            mergeArtifactsState(
+              context.artifactState ?? {},
+              artifactStatePatch
+            )
+          );
         },
         toolOverrides: context.toolOverrides,
         onSkillLoaded: async (loadedSkill) => {
@@ -9761,7 +9894,7 @@ async function generateAssistantReply(messageText, context = {}) {
     }
     syncResumeState();
     const activeToolSummaries = turnMcpToolManager.getActiveToolCatalog(activeSkills).map(toExposedToolSummary);
-    const baseInstructions = buildSystemPrompt({
+    baseInstructions = buildSystemPrompt({
       availableSkills,
       activeSkills,
       activeTools: activeToolSummaries,
@@ -9889,15 +10022,7 @@ async function generateAssistantReply(messageText, context = {}) {
     let completedAssistantTurn = false;
     try {
       if (resumedFromCheckpoint) {
-        const didReplace = await maybeReplaceAgentMessages(
-          agent,
-          existingCheckpoint.piMessages
-        );
-        if (!didReplace) {
-          throw new Error(
-            "Agent session resume requested but replaceMessages is unavailable"
-          );
-        }
+        agent.replaceMessages(existingCheckpoint.piMessages);
       }
       beforeMessageCount = agent.state.messages.length;
       await withSpan(
@@ -9906,16 +10031,15 @@ async function generateAssistantReply(messageText, context = {}) {
         spanContext,
         async () => {
           let promptResult;
-          const promptPromise = resumedFromCheckpoint ? runAgentContinuation(agent) : agent.prompt({
+          const promptPromise = resumedFromCheckpoint ? agent.continue() : agent.prompt({
             role: "user",
             content: userContentParts,
             timestamp: Date.now()
           });
           let timeoutId;
-          let didTimeout = false;
           const timeoutPromise = new Promise((_, reject) => {
             timeoutId = setTimeout(() => {
-              didTimeout = true;
+              timedOut = true;
               agent.abort();
               reject(
                 new Error(
@@ -9927,7 +10051,7 @@ async function generateAssistantReply(messageText, context = {}) {
           try {
             promptResult = await Promise.race([promptPromise, timeoutPromise]);
           } catch (error) {
-            if (didTimeout) {
+            if (timedOut) {
               logWarn(
                 "agent_turn_timeout",
                 {},
@@ -9953,9 +10077,7 @@ async function generateAssistantReply(messageText, context = {}) {
               clearTimeout(timeoutId);
             }
           }
-          newMessages = agent.state.messages.slice(
-            beforeMessageCount
-          );
+          newMessages = agent.state.messages.slice(beforeMessageCount);
           completedAssistantTurn = hasCompletedAssistantTurn(newMessages);
           if (mcpAuth.getPendingPause() && !completedAssistantTurn) {
             timeoutResumeMessages = [...agent.state.messages];
@@ -10011,6 +10133,36 @@ async function generateAssistantReply(messageText, context = {}) {
       assistantUserName: context.assistant?.userName
     });
   } catch (error) {
+    if (timedOut && timeoutResumeConversationId && timeoutResumeSessionId) {
+      const checkpoint = await persistTimeoutCheckpoint({
+        conversationId: timeoutResumeConversationId,
+        sessionId: timeoutResumeSessionId,
+        currentSliceId: timeoutResumeSliceId,
+        messages: timeoutResumeMessages,
+        loadedSkillNames: loadedSkillNamesForResume,
+        errorMessage: error instanceof Error ? error.message : String(error),
+        logContext: {
+          threadId: context.correlation?.threadId,
+          requesterId: context.correlation?.requesterId,
+          channelId: context.correlation?.channelId,
+          runId: context.correlation?.runId,
+          assistantUserName: context.assistant?.userName,
+          modelId: botConfig.modelId
+        }
+      });
+      if (checkpoint) {
+        throw new RetryableTurnError(
+          "turn_timeout_resume",
+          `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${checkpoint.sliceId} version=${checkpoint.checkpointVersion}`,
+          {
+            conversationId: timeoutResumeConversationId,
+            sessionId: timeoutResumeSessionId,
+            sliceId: checkpoint.sliceId,
+            checkpointVersion: checkpoint.checkpointVersion
+          }
+        );
+      }
+    }
     if (error instanceof McpAuthorizationPauseError && timeoutResumeConversationId && timeoutResumeSessionId) {
       const nextSliceId = await persistAuthPauseCheckpoint({
         conversationId: timeoutResumeConversationId,
@@ -10030,7 +10182,12 @@ async function generateAssistantReply(messageText, context = {}) {
       });
       throw new RetryableTurnError(
         "mcp_auth_resume",
-        `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${nextSliceId}`
+        `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${nextSliceId}`,
+        {
+          conversationId: timeoutResumeConversationId,
+          sessionId: timeoutResumeSessionId,
+          sliceId: nextSliceId
+        }
       );
     }
     if (isRetryableTurnError(error)) {
@@ -10241,12 +10398,15 @@ function resolveReplyTimeoutMs(explicitTimeoutMs) {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
 }
 async function postSlackMessage(channelId, threadTs, text) {
+  await getSlackClient().chat.postMessage({
+    channel: channelId,
+    thread_ts: threadTs,
+    text
+  });
+}
+async function postSlackMessageBestEffort(channelId, threadTs, text) {
   try {
-    await getSlackClient().chat.postMessage({
-      channel: channelId,
-      thread_ts: threadTs,
-      text
-    });
+    await postSlackMessage(channelId, threadTs, text);
   } catch {
   }
 }
@@ -10276,32 +10436,85 @@ function createReadOnlyConfigService(values) {
     }
   };
 }
-async function resumeAuthorizedRequest(args) {
-  const progress = createProgressReporter({
-    channelId: args.channelId,
-    threadTs: args.threadTs,
-    transport: createSlackWebApiAssistantStatusTransport()
+var ResumeTurnBusyError = class extends Error {
+  constructor(lockKey) {
+    super(`A turn already owns resume lock "${lockKey}"`);
+    this.name = "ResumeTurnBusyError";
+  }
+};
+function getDefaultLockKey(channelId, threadTs) {
+  return `slack:${channelId}:${threadTs}`;
+}
+function createResumeReplyContext(args, progress) {
+  const replyContext = args.replyContext ?? {};
+  const threadId = args.lockKey ?? getDefaultLockKey(args.channelId, args.threadTs);
+  const persistedChannelConfiguration = replyContext.channelConfiguration ?? (replyContext.configuration ? createReadOnlyConfigService(replyContext.configuration) : void 0);
+  return {
+    ...replyContext,
+    assistant: {
+      userName: botConfig.userName,
+      ...replyContext.assistant
+    },
+    correlation: {
+      ...replyContext.correlation,
+      threadId: replyContext.correlation?.threadId ?? threadId,
+      channelId: replyContext.correlation?.channelId ?? args.channelId,
+      threadTs: replyContext.correlation?.threadTs ?? args.threadTs,
+      requesterId: replyContext.correlation?.requesterId ?? replyContext.requester?.userId
+    },
+    channelConfiguration: persistedChannelConfiguration,
+    onSandboxAcquired: async (sandbox) => {
+      await persistThreadStateById(threadId, {
+        sandboxId: sandbox.sandboxId,
+        sandboxDependencyProfileHash: sandbox.sandboxDependencyProfileHash
+      });
+      await replyContext.onSandboxAcquired?.(sandbox);
+    },
+    onArtifactStateUpdated: async (artifacts) => {
+      await persistThreadStateById(threadId, { artifacts });
+      await replyContext.onArtifactStateUpdated?.(artifacts);
+    },
+    onStatus: async (status) => {
+      await progress.setStatus(status);
+      await replyContext.onStatus?.(status);
+    }
+  };
+}
+async function resumeSlackTurn(args) {
+  const requesterUserId = args.replyContext?.requester?.userId;
+  if (!requesterUserId) {
+    throw new Error("Resumed turn requires replyContext.requester.userId");
+  }
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const lockKey = args.lockKey ?? getDefaultLockKey(args.channelId, args.threadTs);
+  const lock = await stateAdapter.acquireLock(
+    lockKey,
+    botConfig.turnTimeoutMs + 6e4
+  );
+  if (!lock) {
+    throw new ResumeTurnBusyError(lockKey);
+  }
+  const progress = createProgressReporter({
+    channelId: args.channelId,
+    threadTs: args.threadTs,
+    transport: createSlackWebApiAssistantStatusTransport()
   });
-  await postSlackMessage(args.channelId, args.threadTs, args.connectedText);
-  await progress.start();
+  let deferredPauseHandler;
+  let deferredFailureHandler;
   try {
+    if (args.initialText) {
+      await postSlackMessageBestEffort(
+        args.channelId,
+        args.threadTs,
+        args.initialText
+      );
+    }
+    await progress.start();
     const generateReply = args.generateReply ?? generateAssistantReply;
+    const replyContext = createResumeReplyContext(args, progress);
     const replyPromise = generateReply(args.messageText, {
-      assistant: { userName: botConfig.userName },
-      requester: { userId: args.requesterUserId },
-      correlation: {
-        conversationId: args.correlation?.conversationId,
-        turnId: args.correlation?.turnId,
-        channelId: args.correlation?.channelId ?? args.channelId,
-        threadTs: args.correlation?.threadTs ?? args.threadTs,
-        requesterId: args.correlation?.requesterId ?? args.requesterUserId
-      },
-      toolChannelId: args.toolChannelId,
-      conversationContext: args.conversationContext,
-      artifactState: args.artifactState,
-      configuration: args.configuration,
-      channelConfiguration: args.configuration ? createReadOnlyConfigService(args.configuration) : void 0,
-      onStatus: (status) => progress.setStatus(status)
+      ...replyContext
     });
     const replyTimeoutMs = resolveReplyTimeoutMs(args.replyTimeoutMs);
     const reply = typeof replyTimeoutMs === "number" ? await Promise.race([
@@ -10327,11 +10540,168 @@ async function resumeAuthorizedRequest(args) {
   } catch (error) {
     await progress.stop();
     if (isRetryableTurnError(error, "mcp_auth_resume") && args.onAuthPause) {
-      await args.onAuthPause(error);
+      deferredPauseHandler = async () => {
+        await args.onAuthPause?.(error);
+      };
+    } else if (isRetryableTurnError(error, "turn_timeout_resume") && args.onTimeoutPause) {
+      deferredPauseHandler = async () => {
+        await args.onTimeoutPause?.(error);
+      };
+    } else {
+      deferredFailureHandler = async () => {
+        await args.onFailure?.(error);
+        if (args.failureText) {
+          await postSlackMessageBestEffort(
+            args.channelId,
+            args.threadTs,
+            args.failureText
+          );
+        }
+      };
+    }
+  } finally {
+    await stateAdapter.releaseLock(lock);
+  }
+  if (deferredPauseHandler) {
+    try {
+      await deferredPauseHandler();
+      return;
+    } catch (pauseError) {
+      await args.onFailure?.(pauseError);
+      if (args.failureText) {
+        await postSlackMessageBestEffort(
+          args.channelId,
+          args.threadTs,
+          args.failureText
+        );
+      }
       return;
     }
-    await args.onFailure?.(error);
-    await postSlackMessage(args.channelId, args.threadTs, args.failureText);
+  }
+  if (deferredFailureHandler) {
+    await deferredFailureHandler();
+  }
+}
+async function resumeAuthorizedRequest(args) {
+  await resumeSlackTurn({
+    messageText: args.messageText,
+    channelId: args.channelId,
+    threadTs: args.threadTs,
+    replyContext: args.replyContext,
+    lockKey: args.lockKey,
+    initialText: args.connectedText,
+    failureText: args.failureText,
+    generateReply: args.generateReply,
+    onReply: args.onReply,
+    onSuccess: args.onSuccess,
+    onFailure: args.onFailure,
+    onAuthPause: args.onAuthPause,
+    onTimeoutPause: args.onTimeoutPause,
+    replyTimeoutMs: args.replyTimeoutMs
+  });
+}
+
+// src/chat/services/timeout-resume.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var TURN_TIMEOUT_RESUME_PATH = "/api/internal/turn-resume";
+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";
+var MAX_TURN_TIMEOUT_RESUME_SLICE_ID = 5;
+function canScheduleTurnTimeoutResume(nextSliceId) {
+  return typeof nextSliceId === "number" && nextSliceId > 1 && nextSliceId <= MAX_TURN_TIMEOUT_RESUME_SLICE_ID;
+}
+function getTurnTimeoutResumeSecret() {
+  const explicit = process.env.JUNIOR_INTERNAL_RESUME_SECRET?.trim();
+  if (explicit) {
+    return explicit;
+  }
+  return getSlackSigningSecret();
+}
+function buildSignedPayload(timestamp, body) {
+  return `${timestamp}:${body}`;
+}
+function signTurnTimeoutResumeBody(secret, timestamp, body) {
+  const digest = createHmac("sha256", secret).update(buildSignedPayload(timestamp, body)).digest("hex");
+  return `${TURN_TIMEOUT_RESUME_SIGNATURE_VERSION}=${digest}`;
+}
+function timingSafeMatch(expected, actual) {
+  const expectedBuffer = Buffer.from(expected);
+  const actualBuffer = Buffer.from(actual);
+  if (expectedBuffer.length !== actualBuffer.length) {
+    return false;
+  }
+  return timingSafeEqual(expectedBuffer, actualBuffer);
+}
+function parseTurnTimeoutResumeRequest(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const record = value;
+  if (typeof record.conversationId !== "string" || typeof record.sessionId !== "string" || typeof record.expectedCheckpointVersion !== "number") {
+    return void 0;
+  }
+  return {
+    conversationId: record.conversationId,
+    sessionId: record.sessionId,
+    expectedCheckpointVersion: record.expectedCheckpointVersion
+  };
+}
+async function scheduleTurnTimeoutResume(request) {
+  const baseUrl = resolveBaseUrl();
+  if (!baseUrl) {
+    throw new Error(
+      "Cannot determine base URL for timeout resume callback (set JUNIOR_BASE_URL or deploy to Vercel)"
+    );
+  }
+  const secret = getTurnTimeoutResumeSecret();
+  if (!secret) {
+    throw new Error(
+      "Cannot determine timeout resume secret (set JUNIOR_INTERNAL_RESUME_SECRET or SLACK_SIGNING_SECRET)"
+    );
+  }
+  const body = JSON.stringify(request);
+  const timestamp = Date.now().toString();
+  const response = await fetch(`${baseUrl}${TURN_TIMEOUT_RESUME_PATH}`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      [TURN_TIMEOUT_RESUME_TIMESTAMP_HEADER]: timestamp,
+      [TURN_TIMEOUT_RESUME_SIGNATURE_HEADER]: signTurnTimeoutResumeBody(
+        secret,
+        timestamp,
+        body
+      )
+    },
+    body
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Timeout resume callback failed with status ${response.status}`
+    );
+  }
+}
+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 (!timingSafeMatch(expectedSignature, signature)) {
+    return void 0;
+  }
+  try {
+    return parseTurnTimeoutResumeRequest(JSON.parse(body));
+  } catch {
+    return void 0;
   }
 }
 
@@ -10445,28 +10815,12 @@ async function deliverReplyToThread(channelId, threadTs, reply) {
   } catch {
   }
 }
-function buildDeterministicTurnId2(messageId) {
-  const sanitized = messageId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return `turn_${sanitized}`;
-}
-function getUserMessageIdForTurn(conversation, sessionId) {
-  for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
-    const message = conversation.messages[index];
-    if (message?.role !== "user") {
-      continue;
-    }
-    if (buildDeterministicTurnId2(message.id) === sessionId) {
-      return message.id;
-    }
-  }
-  return void 0;
-}
 async function buildResumeConversationContext(channelId, threadTs, sessionId) {
   const threadId = `slack:${channelId}:${threadTs}`;
   const conversation = coerceThreadConversationState(
     await getPersistedThreadState(threadId)
   );
-  const userMessageId = getUserMessageIdForTurn(conversation, sessionId);
+  const userMessageId = getTurnUserMessageId(conversation, sessionId);
   return buildConversationContext(conversation, {
     excludeMessageId: userMessageId
   });
@@ -10477,7 +10831,7 @@ async function persistCompletedReplyState(channelId, threadTs, sessionId, reply)
   const conversation = coerceThreadConversationState(currentState);
   const artifacts = coerceThreadArtifactsState(currentState);
   const nextArtifacts = reply.artifactStatePatch ? mergeArtifactsState(artifacts, reply.artifactStatePatch) : void 0;
-  const userMessageId = getUserMessageIdForTurn(conversation, sessionId);
+  const userMessageId = getTurnUserMessageId(conversation, sessionId);
   markConversationMessage(conversation, userMessageId, {
     replied: true,
     skippedReason: void 0
@@ -10514,7 +10868,7 @@ async function persistFailedReplyState(channelId, threadTs, sessionId) {
   markTurnFailed({
     conversation,
     nowMs: Date.now(),
-    userMessageId: getUserMessageIdForTurn(conversation, sessionId),
+    userMessageId: getTurnUserMessageId(conversation, sessionId),
     markConversationMessage,
     updateConversationStats
   });
@@ -10527,6 +10881,17 @@ async function resumeAuthorizedMcpTurn(args) {
   if (!authSession.channelId || !authSession.threadTs) {
     return;
   }
+  const threadId = `slack:${authSession.channelId}:${authSession.threadTs}`;
+  const currentState = await getPersistedThreadState(threadId);
+  const conversation = coerceThreadConversationState(currentState);
+  const artifacts = coerceThreadArtifactsState(currentState);
+  const userMessage = getTurnUserMessage(conversation, authSession.sessionId);
+  if (conversation.processing.activeTurnId !== authSession.sessionId) {
+    return;
+  }
+  const channelConfiguration = getChannelConfigurationServiceById(
+    authSession.channelId
+  );
   const conversationContext = await buildResumeConversationContext(
     authSession.channelId,
     authSession.threadTs,
@@ -10534,23 +10899,34 @@ async function resumeAuthorizedMcpTurn(args) {
   );
   await resumeAuthorizedRequest({
     messageText: authSession.userMessage,
-    requesterUserId: authSession.userId,
     provider,
     channelId: authSession.channelId,
     threadTs: authSession.threadTs,
+    lockKey: authSession.conversationId,
     connectedText: `Your ${provider} MCP access is now connected. Continuing the original request...`,
     failureText: "MCP authorization completed, but resuming the request failed. Please retry the original command.",
-    correlation: {
-      conversationId: authSession.conversationId,
-      turnId: authSession.sessionId,
-      channelId: authSession.channelId,
-      threadTs: authSession.threadTs,
-      requesterId: authSession.userId
+    replyContext: {
+      assistant: { userName: botConfig.userName },
+      requester: {
+        userId: authSession.userId,
+        userName: userMessage?.author?.userName,
+        fullName: userMessage?.author?.fullName
+      },
+      correlation: {
+        conversationId: authSession.conversationId,
+        turnId: authSession.sessionId,
+        channelId: authSession.channelId,
+        threadTs: authSession.threadTs,
+        requesterId: authSession.userId
+      },
+      toolChannelId: authSession.toolChannelId ?? artifacts.assistantContextChannelId ?? authSession.channelId,
+      conversationContext,
+      artifactState: artifacts,
+      configuration: authSession.configuration,
+      channelConfiguration,
+      sandbox: getPersistedSandboxState(currentState),
+      threadParticipants: buildThreadParticipants(conversation.messages)
     },
-    toolChannelId: authSession.toolChannelId ?? authSession.artifactState?.assistantContextChannelId ?? authSession.channelId,
-    conversationContext,
-    artifactState: authSession.artifactState,
-    configuration: authSession.configuration,
     onReply: async (reply) => {
       await deliverReplyToThread(
         authSession.channelId,
@@ -10607,6 +10983,37 @@ async function resumeAuthorizedMcpTurn(args) {
         { "app.credential.provider": provider },
         "Resumed MCP turn requested another authorization flow"
       );
+    },
+    onTimeoutPause: async (error) => {
+      if (!isRetryableTurnError(error, "turn_timeout_resume")) {
+        throw error;
+      }
+      const checkpointVersion = error.metadata?.checkpointVersion;
+      const nextSliceId = error.metadata?.sliceId;
+      if (typeof checkpointVersion !== "number") {
+        throw new Error(
+          "Timed-out MCP resume did not include a checkpoint version"
+        );
+      }
+      if (!canScheduleTurnTimeoutResume(nextSliceId)) {
+        logWarn(
+          "mcp_oauth_callback_resume_slice_limit_reached",
+          {},
+          {
+            "app.credential.provider": provider,
+            ...typeof nextSliceId === "number" ? { "app.ai.resume_slice_id": nextSliceId } : {}
+          },
+          "Skipped automatic timeout resume because the turn exceeded the slice limit"
+        );
+        throw new Error(
+          "Timed-out turn exceeded the automatic resume slice limit"
+        );
+      }
+      await scheduleTurnTimeoutResume({
+        conversationId: authSession.conversationId,
+        sessionId: authSession.sessionId,
+        expectedCheckpointVersion: checkpointVersion
+      });
     }
   });
 }
@@ -10823,14 +11230,16 @@ async function resumePendingOAuthMessage(stored) {
   );
   await resumeAuthorizedRequest({
     messageText: stored.pendingMessage,
-    requesterUserId: stored.userId,
     provider: stored.provider,
     channelId: stored.channelId,
     threadTs: stored.threadTs,
     connectedText: `Your ${providerLabel} account is now connected. Processing your request...`,
     failureText: `I connected your account but hit an error processing your request. Please try \`${stored.pendingMessage}\` again.`,
-    conversationContext,
-    configuration: stored.configuration,
+    replyContext: {
+      requester: { userId: stored.userId },
+      conversationContext,
+      configuration: stored.configuration
+    },
     onSuccess: async (reply) => {
       logInfo(
         "oauth_callback_resume_complete",
@@ -11019,6 +11428,344 @@ async function GET5(request, provider, waitUntil) {
   });
 }
 
+// src/handlers/turn-resume.ts
+import { Buffer as Buffer3 } from "buffer";
+
+// src/chat/slack/context.ts
+function toTrimmedSlackString(value) {
+  const normalized = toOptionalString(value);
+  return normalized?.trim() || void 0;
+}
+function parseSlackThreadId(threadId) {
+  const normalizedThreadId = toTrimmedSlackString(threadId);
+  if (!normalizedThreadId) {
+    return void 0;
+  }
+  const parts = normalizedThreadId.split(":");
+  if (parts.length !== 3 || parts[0] !== "slack") {
+    return void 0;
+  }
+  const channelId = toTrimmedSlackString(parts[1]);
+  const threadTs = toTrimmedSlackString(parts[2]);
+  if (!channelId || !threadTs) {
+    return void 0;
+  }
+  return { channelId, threadTs };
+}
+function resolveSlackChannelIdFromThreadId(threadId) {
+  return parseSlackThreadId(threadId)?.channelId;
+}
+function resolveSlackChannelIdFromMessage(message) {
+  const messageChannelId = toTrimmedSlackString(
+    message.channelId
+  );
+  if (messageChannelId) {
+    return messageChannelId;
+  }
+  const raw = message.raw;
+  if (raw && typeof raw === "object") {
+    const rawChannel = toTrimmedSlackString(
+      raw.channel
+    );
+    if (rawChannel) {
+      return rawChannel;
+    }
+  }
+  const threadId = toTrimmedSlackString(
+    message.threadId
+  );
+  return resolveSlackChannelIdFromThreadId(threadId);
+}
+
+// src/handlers/turn-resume.ts
+function extractSlackText2(text, files) {
+  const message = buildSlackOutputMessage(text, files);
+  if (typeof message === "object" && message !== null && "markdown" in message && typeof message.markdown === "string") {
+    return message.markdown;
+  }
+  if (typeof message === "object" && message !== null && "raw" in message && typeof message.raw === "string") {
+    return message.raw;
+  }
+  return text;
+}
+async function normalizeFileUploads2(files) {
+  const normalized = [];
+  for (const file of files) {
+    let data;
+    if (Buffer3.isBuffer(file.data)) {
+      data = file.data;
+    } else if (file.data instanceof ArrayBuffer) {
+      data = Buffer3.from(file.data);
+    } else {
+      data = Buffer3.from(await file.data.arrayBuffer());
+    }
+    normalized.push({
+      data,
+      filename: file.filename
+    });
+  }
+  return normalized;
+}
+async function deliverReplyToThread2(args) {
+  const replyFiles = args.reply.files && args.reply.files.length > 0 ? args.reply.files : void 0;
+  const { shouldPostThreadReply, attachFiles } = resolveReplyDelivery({
+    reply: args.reply,
+    hasStreamedThreadReply: false
+  });
+  if (shouldPostThreadReply) {
+    const text = extractSlackText2(
+      args.reply.text,
+      attachFiles === "inline" ? replyFiles : void 0
+    );
+    if (text.trim().length > 0) {
+      await postSlackMessage(args.channelId, args.threadTs, text);
+    }
+  }
+  if (!replyFiles || attachFiles === "none") {
+    return;
+  }
+  const files = await normalizeFileUploads2(replyFiles);
+  if (files.length === 0) {
+    return;
+  }
+  try {
+    await uploadFilesToThread({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      files
+    });
+  } catch {
+  }
+}
+async function persistCompletedReplyState2(args) {
+  const currentState = await getPersistedThreadState(
+    args.checkpoint.conversationId
+  );
+  const conversation = coerceThreadConversationState(currentState);
+  const artifacts = coerceThreadArtifactsState(currentState);
+  const nextArtifacts = args.reply.artifactStatePatch ? mergeArtifactsState(artifacts, args.reply.artifactStatePatch) : void 0;
+  const userMessage = getTurnUserMessage(
+    conversation,
+    args.checkpoint.sessionId
+  );
+  markConversationMessage(conversation, userMessage?.id, {
+    replied: true,
+    skippedReason: void 0
+  });
+  upsertConversationMessage(conversation, {
+    id: generateConversationId("assistant"),
+    role: "assistant",
+    text: normalizeConversationText(args.reply.text) || "[empty response]",
+    createdAtMs: Date.now(),
+    author: {
+      userName: botConfig.userName,
+      isBot: true
+    },
+    meta: {
+      replied: true
+    }
+  });
+  markTurnCompleted({
+    conversation,
+    nowMs: Date.now(),
+    updateConversationStats
+  });
+  await persistThreadStateById(args.checkpoint.conversationId, {
+    artifacts: nextArtifacts,
+    conversation,
+    sandboxId: args.reply.sandboxId,
+    sandboxDependencyProfileHash: args.reply.sandboxDependencyProfileHash
+  });
+}
+async function persistFailedReplyState2(checkpoint) {
+  const currentState = await getPersistedThreadState(checkpoint.conversationId);
+  const conversation = coerceThreadConversationState(currentState);
+  markTurnFailed({
+    conversation,
+    nowMs: Date.now(),
+    userMessageId: getTurnUserMessage(conversation, checkpoint.sessionId)?.id,
+    markConversationMessage,
+    updateConversationStats
+  });
+  await persistThreadStateById(checkpoint.conversationId, {
+    conversation
+  });
+}
+async function resumeTimedOutTurn(payload) {
+  const checkpoint = await getAgentTurnSessionCheckpoint(
+    payload.conversationId,
+    payload.sessionId
+  );
+  if (!checkpoint || checkpoint.state !== "awaiting_resume" || checkpoint.resumeReason !== "timeout" || checkpoint.checkpointVersion !== payload.expectedCheckpointVersion) {
+    return;
+  }
+  const thread = parseSlackThreadId(payload.conversationId);
+  if (!thread) {
+    throw new Error(
+      `Timeout resume requires a Slack thread conversation id, got "${payload.conversationId}"`
+    );
+  }
+  const currentState = await getPersistedThreadState(payload.conversationId);
+  const conversation = coerceThreadConversationState(currentState);
+  const artifacts = coerceThreadArtifactsState(currentState);
+  const userMessage = getTurnUserMessage(conversation, payload.sessionId);
+  if (!userMessage?.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;
+  }
+  const channelConfiguration = getChannelConfigurationServiceById(
+    thread.channelId
+  );
+  const conversationContext = buildConversationContext(conversation, {
+    excludeMessageId: userMessage.id
+  });
+  const sandbox = getPersistedSandboxState(currentState);
+  await resumeSlackTurn({
+    messageText: userMessage.text,
+    channelId: thread.channelId,
+    threadTs: thread.threadTs,
+    lockKey: payload.conversationId,
+    failureText: "I hit an error while resuming that request. Please try the command again.",
+    replyContext: {
+      assistant: { userName: botConfig.userName },
+      requester: {
+        userId: userMessage.author.userId,
+        userName: userMessage.author.userName,
+        fullName: userMessage.author.fullName
+      },
+      correlation: {
+        conversationId: payload.conversationId,
+        turnId: payload.sessionId,
+        channelId: thread.channelId,
+        threadTs: thread.threadTs,
+        requesterId: userMessage.author.userId
+      },
+      toolChannelId: artifacts.assistantContextChannelId ?? thread.channelId,
+      artifactState: artifacts,
+      conversationContext,
+      channelConfiguration,
+      sandbox,
+      threadParticipants: buildThreadParticipants(conversation.messages)
+    },
+    onReply: async (reply) => {
+      await deliverReplyToThread2({
+        channelId: thread.channelId,
+        threadTs: thread.threadTs,
+        reply
+      });
+    },
+    onSuccess: async (reply) => {
+      try {
+        await persistCompletedReplyState2({ checkpoint, reply });
+      } catch (persistError) {
+        logException(
+          persistError,
+          "timeout_resume_complete_persist_failed",
+          {},
+          {
+            "app.ai.conversation_id": payload.conversationId,
+            "app.ai.session_id": payload.sessionId
+          },
+          "Failed to persist completed timeout-resume state after reply delivery"
+        );
+      }
+    },
+    onFailure: async (error) => {
+      logException(
+        error,
+        "timeout_resume_failed",
+        {},
+        {
+          "app.ai.conversation_id": payload.conversationId,
+          "app.ai.session_id": payload.sessionId
+        },
+        "Failed to resume timed-out turn"
+      );
+      await persistFailedReplyState2(checkpoint);
+    },
+    onAuthPause: async () => {
+      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 checkpointVersion = error.metadata?.checkpointVersion;
+      const nextSliceId = error.metadata?.sliceId;
+      if (typeof checkpointVersion !== "number") {
+        throw new Error(
+          "Timed-out resume turn did not include a checkpoint version"
+        );
+      }
+      if (!canScheduleTurnTimeoutResume(nextSliceId)) {
+        logWarn(
+          "timeout_resume_slice_limit_reached",
+          {},
+          {
+            "app.ai.conversation_id": payload.conversationId,
+            "app.ai.session_id": payload.sessionId,
+            ...typeof nextSliceId === "number" ? { "app.ai.resume_slice_id": nextSliceId } : {}
+          },
+          "Skipped automatic timeout resume because the turn exceeded the slice limit"
+        );
+        throw new Error(
+          "Timed-out turn exceeded the automatic resume slice limit"
+        );
+      }
+      await scheduleTurnTimeoutResume({
+        conversationId: payload.conversationId,
+        sessionId: payload.sessionId,
+        expectedCheckpointVersion: checkpointVersion
+      });
+    }
+  });
+}
+async function POST(request, waitUntil) {
+  const payload = await verifyTurnTimeoutResumeRequest(request);
+  if (!payload) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+  waitUntil(
+    () => resumeTimedOutTurn(payload).catch((error) => {
+      if (error instanceof ResumeTurnBusyError) {
+        logWarn(
+          "timeout_resume_lock_busy",
+          {},
+          {
+            "app.ai.conversation_id": payload.conversationId,
+            "app.ai.session_id": payload.sessionId
+          },
+          "Skipped timeout resume because another turn owns the thread lock"
+        );
+        return;
+      }
+      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 });
+}
+
 // src/chat/app/production.ts
 import { createSlackAdapter } from "@chat-adapter/slack";
 
@@ -11048,11 +11795,11 @@ var DIRECTED_FOLLOW_UP_CUE_RE = /\b(?:you said|you just said|your last response|
 var TERSE_CLARIFICATION_RE = /^(?:which one|which ones|why|how so|what do you mean|what did you mean|say more|explain that|clarify that|expand on that|elaborate on that)\??$/i;
 var GENERIC_IMMEDIATE_SIDE_CONVERSATION_RE = /^(?:is that (?:the )?right (?:approach|call|move)|(?:can|could|would) you check on this)\??$/i;
 var RECENT_THREAD_WINDOW = 6;
-function escapeRegExp(value) {
+function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function containsAssistantInvocation(text, botUserName) {
-  const escapedUserName = escapeRegExp(botUserName);
+  const escapedUserName = escapeRegExp2(botUserName);
   const plainNameMentionRe = new RegExp(`(^|\\s)@${escapedUserName}\\b`, "i");
   const labeledEntityMentionRe = new RegExp(
     `<@[^>|]+\\|${escapedUserName}>`,
@@ -11340,54 +12087,8 @@ async function decideSubscribedThreadReply(args) {
   }
 }
 
-// src/chat/slack/context.ts
-function toTrimmedSlackString(value) {
-  const normalized = toOptionalString(value);
-  return normalized?.trim() || void 0;
-}
-function parseSlackThreadId(threadId) {
-  const normalizedThreadId = toTrimmedSlackString(threadId);
-  if (!normalizedThreadId) {
-    return void 0;
-  }
-  const parts = normalizedThreadId.split(":");
-  if (parts.length !== 3 || parts[0] !== "slack") {
-    return void 0;
-  }
-  const channelId = toTrimmedSlackString(parts[1]);
-  const threadTs = toTrimmedSlackString(parts[2]);
-  if (!channelId || !threadTs) {
-    return void 0;
-  }
-  return { channelId, threadTs };
-}
-function resolveSlackChannelIdFromThreadId(threadId) {
-  return parseSlackThreadId(threadId)?.channelId;
-}
-function resolveSlackChannelIdFromMessage(message) {
-  const messageChannelId = toTrimmedSlackString(
-    message.channelId
-  );
-  if (messageChannelId) {
-    return messageChannelId;
-  }
-  const raw = message.raw;
-  if (raw && typeof raw === "object") {
-    const rawChannel = toTrimmedSlackString(
-      raw.channel
-    );
-    if (rawChannel) {
-      return rawChannel;
-    }
-  }
-  const threadId = toTrimmedSlackString(
-    message.threadId
-  );
-  return resolveSlackChannelIdFromThreadId(threadId);
-}
-
 // src/chat/runtime/thread-context.ts
-function escapeRegExp2(value) {
+function escapeRegExp3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function stripLeadingBotMention(text, options = {}) {
@@ -11397,12 +12098,12 @@ function stripLeadingBotMention(text, options = {}) {
     next = next.replace(/^\s*<@[^>]+>[\s,:-]*/, "").trim();
   }
   const mentionByNameRe = new RegExp(
-    `^\\s*@${escapeRegExp2(botConfig.userName)}\\b[\\s,:-]*`,
+    `^\\s*@${escapeRegExp3(botConfig.userName)}\\b[\\s,:-]*`,
     "i"
   );
   next = next.replace(mentionByNameRe, "").trim();
   const mentionByLabeledEntityRe = new RegExp(
-    `^\\s*<@[^>|]+\\|${escapeRegExp2(botConfig.userName)}>[\\s,:-]*`,
+    `^\\s*<@[^>|]+\\|${escapeRegExp3(botConfig.userName)}>[\\s,:-]*`,
     "i"
   );
   next = next.replace(mentionByLabeledEntityRe, "").trim();
@@ -12430,6 +13131,7 @@ function createJuniorRuntimeServices(overrides = {}) {
     replyExecutor: {
       generateAssistantReply: overrides.replyExecutor?.generateAssistantReply ?? generateAssistantReply,
       lookupSlackUser: overrides.replyExecutor?.lookupSlackUser ?? lookupSlackUser,
+      scheduleTurnTimeoutResume: overrides.replyExecutor?.scheduleTurnTimeoutResume ?? scheduleTurnTimeoutResume,
       generateThreadTitle: conversationMemory.generateThreadTitle
     },
     subscribedReplyPolicy: createSubscribedReplyPolicy({
@@ -12494,19 +13196,6 @@ function getExecutionFailureReason(reply) {
   }
   return "empty assistant turn";
 }
-function buildParticipants(messages) {
-  const seen = /* @__PURE__ */ new Set();
-  const participants = [];
-  for (const message of messages) {
-    const { userId, userName, fullName } = message.author ?? {};
-    if (!userId || message.author?.isBot) continue;
-    if (!seen.has(userId)) {
-      seen.add(userId);
-      participants.push({ userId, userName, fullName });
-    }
-  }
-  return participants;
-}
 function createReplyToThread(deps) {
   return async function replyToThread(thread, message, options = {}) {
     if (message.author.isMe) {
@@ -12666,7 +13355,7 @@ function createReplyToThread(deps) {
         let shouldPersistFailureState = true;
         try {
           const toolChannelId = preparedState.artifacts.assistantContextChannelId ?? channelId;
-          const threadParticipants = buildParticipants(
+          const threadParticipants = buildThreadParticipants(
             preparedState.conversation.messages
           );
           const reply = await deps.services.generateAssistantReply(userText, {
@@ -12698,6 +13387,15 @@ function createReplyToThread(deps) {
               sandboxId: preparedState.sandboxId,
               sandboxDependencyProfileHash: preparedState.sandboxDependencyProfileHash
             },
+            onSandboxAcquired: async (sandbox) => {
+              await persistThreadState(thread, {
+                sandboxId: sandbox.sandboxId,
+                sandboxDependencyProfileHash: sandbox.sandboxDependencyProfileHash
+              });
+            },
+            onArtifactStateUpdated: async (artifacts) => {
+              await persistThreadState(thread, { artifacts });
+            },
             threadParticipants,
             onStatus: (status) => progress.setStatus(status),
             onTextDelta: (deltaText) => {
@@ -12894,10 +13592,66 @@ function createReplyToThread(deps) {
             );
           }
         } catch (error) {
-          shouldPersistFailureState = !isRetryableTurnError(
-            error,
-            "mcp_auth_resume"
-          );
+          if (isRetryableTurnError(error, "mcp_auth_resume")) {
+            shouldPersistFailureState = false;
+            throw error;
+          }
+          if (isRetryableTurnError(error, "turn_timeout_resume")) {
+            textStream.end();
+            const hasVisibleAssistantOutput = Boolean(streamedReplyPromise);
+            if (hasVisibleAssistantOutput) {
+              logWarn(
+                "agent_turn_timeout_resume_skipped_after_visible_output",
+                turnTraceContext,
+                messageTs ? { "messaging.message.id": messageTs } : {},
+                "Skipped automatic timeout resume because assistant text had already started streaming"
+              );
+            }
+            const conversationIdForResume = error.metadata?.conversationId;
+            const sessionIdForResume = error.metadata?.sessionId;
+            const checkpointVersion = error.metadata?.checkpointVersion;
+            const nextSliceId = error.metadata?.sliceId;
+            if (!hasVisibleAssistantOutput && conversationIdForResume && sessionIdForResume && typeof checkpointVersion === "number" && canScheduleTurnTimeoutResume(nextSliceId)) {
+              try {
+                await deps.services.scheduleTurnTimeoutResume({
+                  conversationId: conversationIdForResume,
+                  sessionId: sessionIdForResume,
+                  expectedCheckpointVersion: checkpointVersion
+                });
+                shouldPersistFailureState = false;
+                return;
+              } catch (scheduleError) {
+                logException(
+                  scheduleError,
+                  "agent_turn_timeout_resume_schedule_failed",
+                  turnTraceContext,
+                  {
+                    ...messageTs ? { "messaging.message.id": messageTs } : {},
+                    "app.ai.resume_checkpoint_version": checkpointVersion
+                  },
+                  "Failed to schedule timeout resume callback"
+                );
+              }
+            } else if (!hasVisibleAssistantOutput && conversationIdForResume && sessionIdForResume && typeof checkpointVersion === "number") {
+              logWarn(
+                "agent_turn_timeout_resume_slice_limit_reached",
+                turnTraceContext,
+                {
+                  ...messageTs ? { "messaging.message.id": messageTs } : {},
+                  ...typeof nextSliceId === "number" ? { "app.ai.resume_slice_id": nextSliceId } : {}
+                },
+                "Skipped automatic timeout resume because the turn exceeded the slice limit"
+              );
+            } else {
+              logWarn(
+                "agent_turn_timeout_resume_metadata_missing",
+                turnTraceContext,
+                messageTs ? { "messaging.message.id": messageTs } : {},
+                "Timed-out turn could not be scheduled for resume because retry metadata was incomplete"
+              );
+            }
+          }
+          shouldPersistFailureState = true;
           throw error;
         } finally {
           textStream.end();
@@ -13493,8 +14247,10 @@ async function handleSlashCommand(event) {
 var productionBot;
 var productionSlackRuntime;
 function createProductionBot() {
+  const logger = createChatSdkLogger();
   return new JuniorChat({
     userName: botConfig.userName,
+    logger,
     concurrency: {
       strategy: "queue",
       // The SDK's default queueEntryTtlMs is 90s, but Junior turns can
@@ -13514,6 +14270,7 @@ function createProductionBot() {
           throw new Error("SLACK_SIGNING_SECRET is required");
         }
         return createSlackAdapter({
+          logger: logger.child("slack"),
           signingSecret,
           ...botToken ? { botToken } : {},
           ...clientId ? { clientId } : {},
@@ -13660,11 +14417,13 @@ function extractMessageChangedMention(body, botUserId, adapter) {
   const threadTs = event.message.thread_ts ?? messageTs;
   const userId = event.message.user ?? "unknown";
   const threadId = `slack:${channelId}:${threadTs}`;
+  const teamId = typeof body.team_id === "string" ? body.team_id : void 0;
   const raw = {
     channel: channelId,
     ts: messageTs,
     thread_ts: threadTs,
-    user: userId
+    user: userId,
+    ...teamId ? { team_id: teamId } : {}
   };
   const message = new Message({
     id: getEditedMentionMessageId(messageTs),
@@ -13845,7 +14604,7 @@ async function handlePlatformWebhook(request, platform, waitUntil, bot = getProd
     }
   });
 }
-async function POST(request, platform, waitUntil) {
+async function POST2(request, platform, waitUntil) {
   return handlePlatformWebhook(request, platform, waitUntil);
 }
 
@@ -13898,8 +14657,11 @@ async function createApp(options) {
   app.get("/api/oauth/callback/:provider", (c) => {
     return GET5(c.req.raw, c.req.param("provider"), waitUntil);
   });
+  app.post("/api/internal/turn-resume", (c) => {
+    return POST(c.req.raw, waitUntil);
+  });
   app.post("/api/webhooks/:platform", (c) => {
-    return POST(c.req.raw, c.req.param("platform"), waitUntil);
+    return POST2(c.req.raw, c.req.param("platform"), waitUntil);
   });
   return app;
 }