@sentry/junior 0.21.1 → 0.23.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,
@@ -310,9 +311,6 @@ async function GET3() {
   });
 }
 
-// src/handlers/mcp-oauth-callback.ts
-import { Buffer as Buffer2 } from "buffer";
-
 // src/chat/state/conversation.ts
 function coerceRole(value) {
   return value === "assistant" || value === "system" || value === "user" ? value : "user";
@@ -728,81 +726,6 @@ async function deleteMcpServerSessionId(userId, provider) {
   await stateAdapter.delete(serverSessionKey(userId, provider));
 }
 
-// src/chat/slack/output.ts
-var MAX_INLINE_CHARS = 2200;
-var MAX_INLINE_LINES = 45;
-function ensureBlockSpacing(text) {
-  const codeBlockPattern = /^```/;
-  const listItemPattern = /^[-*•]\s|^\d+\.\s/;
-  const lines = text.split("\n");
-  const result = [];
-  let inCodeBlock = false;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const isCodeFence = codeBlockPattern.test(line.trimStart());
-    if (isCodeFence) {
-      if (!inCodeBlock) {
-        const prev2 = result.length > 0 ? result[result.length - 1] : void 0;
-        if (prev2 !== void 0 && prev2.trim() !== "") {
-          result.push("");
-        }
-      }
-      inCodeBlock = !inCodeBlock;
-      result.push(line);
-      continue;
-    }
-    if (inCodeBlock) {
-      result.push(line);
-      continue;
-    }
-    const prev = result.length > 0 ? result[result.length - 1] : void 0;
-    if (prev !== void 0 && prev.trim() !== "" && line.trim() !== "" && !(listItemPattern.test(prev.trimStart()) && listItemPattern.test(line.trimStart()))) {
-      result.push("");
-    }
-    result.push(line);
-  }
-  return result.join("\n");
-}
-function normalizeForSlack(text) {
-  let normalized = text.replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "");
-  normalized = ensureBlockSpacing(normalized);
-  return normalized.replace(/\n{3,}/g, "\n\n").trim();
-}
-function buildSlackOutputMessage(text, files) {
-  const normalized = normalizeForSlack(text);
-  const fileCount = files?.length ?? 0;
-  if (!normalized) {
-    if (fileCount > 0) {
-      return {
-        raw: "",
-        files
-      };
-    }
-    logWarn(
-      "slack_output_normalized_empty",
-      {},
-      {
-        "app.output.original_length": text.length,
-        "app.output.parsed_length": normalized.length,
-        "app.output.file_count": fileCount
-      },
-      "Slack output normalized to empty content"
-    );
-    return {
-      markdown: "I couldn't produce a response.",
-      files
-    };
-  }
-  return {
-    markdown: normalized,
-    files
-  };
-}
-var slackOutputPolicy = {
-  maxInlineChars: MAX_INLINE_CHARS,
-  maxInlineLines: MAX_INLINE_LINES
-};
-
 // src/chat/mcp/oauth.ts
 import { randomUUID } from "crypto";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
@@ -1786,7 +1709,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 +1731,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 +1941,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 +1973,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 +1995,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 +2024,97 @@ 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);
+}
+
+// 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 {
@@ -2669,80 +2703,350 @@ import { Agent } from "@mariozechner/pi-agent-core";
 // src/chat/prompt.ts
 import fs from "fs";
 import path2 from "path";
-var DEFAULT_SOUL = "You are Junior, a practical and concise assistant.";
-function getLoggedMarkdownFiles() {
-  const globalState = globalThis;
-  globalState.__juniorLoggedMarkdownFiles ??= /* @__PURE__ */ new Set();
-  return globalState.__juniorLoggedMarkdownFiles;
-}
-function loadOptionalMarkdownFile(candidates, fileName) {
-  for (const resolved of candidates) {
-    try {
-      const raw = fs.readFileSync(resolved, "utf8").trim();
-      if (raw.length > 0) {
-        const loggedMarkdownFiles = getLoggedMarkdownFiles();
-        const logKey = `${fileName}:${resolved}`;
-        if (!loggedMarkdownFiles.has(logKey)) {
-          loggedMarkdownFiles.add(logKey);
-          logInfo(
-            `${fileName.toLowerCase()}_loaded`,
-            {},
-            {
-              "file.path": resolved
-            },
-            `Loaded ${fileName}`
-          );
+
+// src/chat/slack/output.ts
+var MAX_INLINE_CHARS = 2200;
+var MAX_INLINE_LINES = 45;
+var CONTINUED_MARKER = "\n\n[Continued below]";
+var INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
+var STREAMING_FENCE_CLOSE_GUARD = "\n```";
+function ensureBlockSpacing(text) {
+  const codeBlockPattern = /^```/;
+  const listItemPattern = /^[-*•]\s|^\d+\.\s/;
+  const lines = text.split("\n");
+  const result = [];
+  let inCodeBlock = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const isCodeFence = codeBlockPattern.test(line.trimStart());
+    if (isCodeFence) {
+      if (!inCodeBlock) {
+        const prev2 = result.length > 0 ? result[result.length - 1] : void 0;
+        if (prev2 !== void 0 && prev2.trim() !== "") {
+          result.push("");
         }
-        return raw;
       }
-    } catch {
+      inCodeBlock = !inCodeBlock;
+      result.push(line);
+      continue;
+    }
+    if (inCodeBlock) {
+      result.push(line);
       continue;
     }
+    const prev = result.length > 0 ? result[result.length - 1] : void 0;
+    if (prev !== void 0 && prev.trim() !== "" && line.trim() !== "" && !(listItemPattern.test(prev.trimStart()) && listItemPattern.test(line.trimStart()))) {
+      result.push("");
+    }
+    result.push(line);
   }
-  return null;
+  return result.join("\n");
 }
-function loadSoul() {
-  const soul = loadOptionalMarkdownFile(soulPathCandidates(), "SOUL.md");
-  if (soul) {
-    return soul;
+function normalizeForSlack(text) {
+  let normalized = text.replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "");
+  normalized = ensureBlockSpacing(normalized);
+  return normalized.replace(/\n{3,}/g, "\n\n").trim();
+}
+function countSlackLines(text) {
+  if (!text) {
+    return 0;
   }
-  logWarn(
-    "soul_load_fallback",
-    {},
-    {
-      "file.candidates": soulPathCandidates()
-    },
-    "SOUL.md not found; using built-in default personality"
-  );
-  return DEFAULT_SOUL;
+  return text.split("\n").length;
 }
-function loadWorld() {
-  return loadOptionalMarkdownFile(worldPathCandidates(), "WORLD.md");
+function fitsInlineBudget(text, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
+  return text.length <= maxChars && countSlackLines(text) <= maxLines;
 }
-var JUNIOR_PERSONALITY = (() => {
-  try {
-    return loadSoul();
-  } catch (error) {
-    logWarn(
-      "soul_load_failed",
-      {},
-      {
-        "error.message": error instanceof Error ? error.message : String(error)
-      },
-      "Failed to load SOUL.md; using built-in default personality"
-    );
-    return DEFAULT_SOUL;
+function findSplitIndex(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text.length;
   }
-})();
-var JUNIOR_WORLD = (() => {
-  try {
-    return loadWorld();
-  } catch (error) {
-    logWarn(
-      "world_load_failed",
-      {},
-      {
-        "error.message": error instanceof Error ? error.message : String(error)
+  const bounded = text.slice(0, maxChars);
+  const newlineIndex = bounded.lastIndexOf("\n");
+  if (newlineIndex > 0) {
+    return newlineIndex;
+  }
+  const spaceIndex = bounded.lastIndexOf(" ");
+  if (spaceIndex > 0) {
+    return spaceIndex;
+  }
+  return maxChars;
+}
+function splitByLineBudget(text, maxLines) {
+  if (maxLines <= 0) {
+    return "";
+  }
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) {
+    return text;
+  }
+  return lines.slice(0, maxLines).join("\n");
+}
+function reserveInlineBudgetForSuffix(suffix, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
+  return {
+    maxChars: Math.max(1, maxChars - suffix.length),
+    maxLines: Math.max(1, maxLines - Math.max(0, countSlackLines(suffix) - 1))
+  };
+}
+function forceSplitBudget(text, budget) {
+  const lineCount = countSlackLines(text);
+  return {
+    maxChars: text.length <= budget.maxChars ? Math.max(1, text.length - 1) : budget.maxChars,
+    maxLines: lineCount <= budget.maxLines ? Math.max(1, lineCount - 1) : budget.maxLines
+  };
+}
+function getFenceContinuation(text) {
+  let open;
+  for (const line of text.split("\n")) {
+    const trimmed = line.trimStart();
+    const openerMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
+    if (!openerMatch) {
+      continue;
+    }
+    if (!open) {
+      open = {
+        fence: openerMatch[1],
+        openerLine: trimmed
+      };
+      continue;
+    }
+    if (new RegExp(`^${open.fence}\\s*$`).test(trimmed)) {
+      open = void 0;
+    }
+  }
+  if (!open) {
+    return null;
+  }
+  return {
+    closeSuffix: text.endsWith("\n") ? open.fence : `
+${open.fence}`,
+    reopenPrefix: `${open.openerLine}
+`
+  };
+}
+function appendSlackSuffix(text, marker) {
+  const carryover = getFenceContinuation(text);
+  return `${text}${carryover?.closeSuffix ?? ""}${marker}`;
+}
+function takeSlackContinuationChunk(text, budget) {
+  let { prefix, rest } = takeSlackInlinePrefix(text, budget);
+  if (!rest) {
+    ({ prefix, rest } = takeSlackInlinePrefix(
+      text,
+      forceSplitBudget(text, budget)
+    ));
+  }
+  let carryover = rest ? getFenceContinuation(prefix) : null;
+  if (!carryover) {
+    return { prefix, rest };
+  }
+  const carryoverBudget = reserveInlineBudgetForSuffix(
+    `${carryover.closeSuffix}${CONTINUED_MARKER}`
+  );
+  ({ prefix, rest } = takeSlackInlinePrefix(text, carryoverBudget));
+  if (!rest) {
+    ({ prefix, rest } = takeSlackInlinePrefix(
+      text,
+      forceSplitBudget(text, carryoverBudget)
+    ));
+  }
+  carryover = rest ? getFenceContinuation(prefix) : null;
+  if (!carryover) {
+    return { prefix, rest };
+  }
+  return {
+    prefix,
+    rest: `${carryover.reopenPrefix}${rest}`
+  };
+}
+function takeSlackContinuationPrefix(text, options) {
+  const budget = {
+    maxChars: options?.maxChars ?? getSlackContinuationBudget().maxChars,
+    maxLines: options?.maxLines ?? getSlackContinuationBudget().maxLines
+  };
+  const { prefix, rest } = (() => {
+    if (options?.forceSplit) {
+      return takeSlackContinuationChunk(text, budget);
+    }
+    const initial = takeSlackInlinePrefix(text, budget);
+    return initial.rest ? takeSlackContinuationChunk(text, budget) : initial;
+  })();
+  return {
+    prefix,
+    renderedPrefix: rest ? appendSlackSuffix(prefix, CONTINUED_MARKER) : prefix,
+    rest
+  };
+}
+function takeSlackInlinePrefix(text, options) {
+  const maxChars = options?.maxChars ?? MAX_INLINE_CHARS;
+  const maxLines = options?.maxLines ?? MAX_INLINE_LINES;
+  const normalized = text.replace(/\r\n?/g, "\n");
+  if (!normalized) {
+    return { prefix: "", rest: "" };
+  }
+  if (fitsInlineBudget(normalized, maxChars, maxLines)) {
+    return { prefix: normalized, rest: "" };
+  }
+  const lineBounded = splitByLineBudget(normalized, maxLines);
+  const cutIndex = findSplitIndex(lineBounded, maxChars);
+  const prefix = lineBounded.slice(0, cutIndex).trimEnd();
+  if (prefix) {
+    return {
+      prefix,
+      rest: normalized.slice(prefix.length).trimStart()
+    };
+  }
+  const hardPrefix = normalized.slice(0, Math.max(1, maxChars)).trimEnd();
+  return {
+    prefix: hardPrefix || normalized.slice(0, Math.max(1, maxChars)),
+    rest: normalized.slice(hardPrefix.length || Math.max(1, maxChars)).trimStart()
+  };
+}
+function splitSlackReplyText(text, options) {
+  const normalized = normalizeForSlack(text);
+  if (!normalized) {
+    return [];
+  }
+  const chunks = [];
+  const continuationBudget = reserveInlineBudgetForSuffix(CONTINUED_MARKER);
+  let remaining = normalized;
+  while (remaining) {
+    const fitsFinalChunk = options?.interrupted ? fitsInlineBudget(appendSlackSuffix(remaining, INTERRUPTED_MARKER)) : fitsInlineBudget(remaining);
+    if (fitsFinalChunk) {
+      chunks.push(
+        options?.interrupted ? appendSlackSuffix(remaining, INTERRUPTED_MARKER) : remaining
+      );
+      break;
+    }
+    const { renderedPrefix, rest } = takeSlackContinuationPrefix(remaining, {
+      ...continuationBudget,
+      forceSplit: true
+    });
+    chunks.push(renderedPrefix);
+    remaining = rest;
+  }
+  return chunks;
+}
+function getSlackInterruptionMarker() {
+  return INTERRUPTED_MARKER;
+}
+function getSlackContinuationBudget() {
+  return reserveInlineBudgetForSuffix(CONTINUED_MARKER);
+}
+function getSlackStreamingContinuationBudget() {
+  return reserveInlineBudgetForSuffix(
+    `${STREAMING_FENCE_CLOSE_GUARD}${CONTINUED_MARKER}`
+  );
+}
+function buildSlackOutputMessage(text, files) {
+  const normalized = normalizeForSlack(text);
+  const fileCount = files?.length ?? 0;
+  if (!normalized) {
+    if (fileCount > 0) {
+      return {
+        raw: "",
+        files
+      };
+    }
+    logWarn(
+      "slack_output_normalized_empty",
+      {},
+      {
+        "app.output.original_length": text.length,
+        "app.output.parsed_length": normalized.length,
+        "app.output.file_count": fileCount
+      },
+      "Slack output normalized to empty content"
+    );
+    return {
+      markdown: "I couldn't produce a response.",
+      files
+    };
+  }
+  return {
+    markdown: normalized,
+    files
+  };
+}
+var slackOutputPolicy = {
+  maxInlineChars: MAX_INLINE_CHARS,
+  maxInlineLines: MAX_INLINE_LINES
+};
+
+// src/chat/prompt.ts
+var DEFAULT_SOUL = "You are Junior, a practical and concise assistant.";
+function getLoggedMarkdownFiles() {
+  const globalState = globalThis;
+  globalState.__juniorLoggedMarkdownFiles ??= /* @__PURE__ */ new Set();
+  return globalState.__juniorLoggedMarkdownFiles;
+}
+function loadOptionalMarkdownFile(candidates, fileName) {
+  for (const resolved of candidates) {
+    try {
+      const raw = fs.readFileSync(resolved, "utf8").trim();
+      if (raw.length > 0) {
+        const loggedMarkdownFiles = getLoggedMarkdownFiles();
+        const logKey = `${fileName}:${resolved}`;
+        if (!loggedMarkdownFiles.has(logKey)) {
+          loggedMarkdownFiles.add(logKey);
+          logInfo(
+            `${fileName.toLowerCase()}_loaded`,
+            {},
+            {
+              "file.path": resolved
+            },
+            `Loaded ${fileName}`
+          );
+        }
+        return raw;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function loadSoul() {
+  const soul = loadOptionalMarkdownFile(soulPathCandidates(), "SOUL.md");
+  if (soul) {
+    return soul;
+  }
+  logWarn(
+    "soul_load_fallback",
+    {},
+    {
+      "file.candidates": soulPathCandidates()
+    },
+    "SOUL.md not found; using built-in default personality"
+  );
+  return DEFAULT_SOUL;
+}
+function loadWorld() {
+  return loadOptionalMarkdownFile(worldPathCandidates(), "WORLD.md");
+}
+var JUNIOR_PERSONALITY = (() => {
+  try {
+    return loadSoul();
+  } catch (error) {
+    logWarn(
+      "soul_load_failed",
+      {},
+      {
+        "error.message": error instanceof Error ? error.message : String(error)
+      },
+      "Failed to load SOUL.md; using built-in default personality"
+    );
+    return DEFAULT_SOUL;
+  }
+})();
+var JUNIOR_WORLD = (() => {
+  try {
+    return loadWorld();
+  } catch (error) {
+    logWarn(
+      "world_load_failed",
+      {},
+      {
+        "error.message": error instanceof Error ? error.message : String(error)
       },
       "Failed to load WORLD.md; omitting world prompt context"
     );
@@ -3039,6 +3343,9 @@ function buildSystemPrompt(params) {
         "- Keep routine setup and research steps silent in user-facing replies. Do not narrate duplicate checks, credential issuance, file writes, or similar internal progress unless the result is user-relevant.",
         "- If a routine prerequisite check finds nothing notable, omit it entirely from the final reply and report only the user-relevant outcome.",
         "- Prefer a single result-focused reply after tool work completes. Only send an interim reply when you need user input or have a concrete blocking problem to report.",
+        "- For external/factual research requests that require tools, do not send any preliminary conclusion, 'let me check', or progress narration before the evidence-gathering work is done. Use assistant status for in-progress work and make the first visible reply the researched answer.",
+        "- For evidence-gathering tasks, never state a factual conclusion before you have actually gathered and checked the sources.",
+        "- Do not include internal process chatter such as 'let me find', 'fetching now', 'good, I have sources', 'trying smaller limits', or 'I now have sufficient context' in the final user-facing reply.",
         "- Use `attachFile` for files that actually exist in the sandbox (for example screenshots, PDFs, logs), or for `attachment_path` values returned by `imageGenerate`.",
         "- If the user asks to see/share/show a screenshot or file, attach the file with `attachFile` instead of only reporting its path.",
         "- Never claim a screenshot/file is attached unless `attachFile` succeeded in this turn.",
@@ -3055,14 +3362,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.",
@@ -3097,7 +3404,8 @@ function buildSystemPrompt(params) {
         "- Use plain Slack-safe markdown (headings, bullets, short code blocks).",
         "- Keep normal responses brief and scannable.",
         "- If depth is needed, start with a concise summary and then provide fuller detail.",
-        "- A brief initial acknowledgment before significant tool work is fine; avoid extended process chatter or repeated status updates.",
+        "- For tool-heavy research, discovery, or source-checking requests, do not send an initial acknowledgment. Start the visible reply only once you can present the actual answer.",
+        "- Do not narrate tool execution or repeated status updates in the visible reply.",
         "- Avoid tables unless explicitly requested.",
         "- End every turn with a final user-facing markdown response.",
         "</output>"
@@ -3134,40 +3442,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 +3515,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 +3566,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 +3577,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 +3615,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 +3659,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 +3786,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 +3889,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 +3916,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 +4306,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 +6099,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 +6198,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 +6403,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 +6466,7 @@ function createSlackListAddItemsTool(state) {
         assigneeUserId: assignee_user_id,
         dueDate: due_date
       });
-      state.patchArtifactState({
+      await state.patchArtifactState({
         lastListId: targetListId,
         listColumnMap: result.listColumnMap
       });
@@ -6237,7 +6558,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 +7159,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 +7167,7 @@ function createToolState(hooks, context) {
         ...patch.listColumnMap
       };
     }
-    hooks.onArtifactStatePatch?.(patch);
+    await hooks.onArtifactStatePatch?.(patch);
   };
   return {
     artifactState,
@@ -7955,10 +8276,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 +8473,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 +8528,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 +8775,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 = {}) => {
@@ -8699,13 +9025,13 @@ function buildToolStatus(toolName, input) {
     return makeAssistantStatus("loading", skillName);
   }
   if (query && toolName === "webSearch") {
-    return makeAssistantStatus("searching", `"${query}"`);
-  }
-  if (query && provider && toolName === "searchTools") {
-    return makeAssistantStatus("searching", `${provider} "${query}"`);
+    return makeAssistantStatus("searching", "sources");
   }
   if (query && toolName === "searchTools") {
-    return makeAssistantStatus("searching", `"${query}"`);
+    return makeAssistantStatus(
+      "searching",
+      provider ? `${provider} tools` : "tools"
+    );
   }
   if (domain && toolName === "webFetch") {
     return makeAssistantStatus("fetching", domain);
@@ -8964,66 +9290,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"];
@@ -9069,8 +9335,29 @@ function buildReplyDeliveryPlan(args) {
     attachFiles
   };
 }
-
-// src/chat/services/channel-intent.ts
+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";
+  }
+  if (attachFiles === "inline" && args.hasStreamedThreadReply) {
+    attachFiles = "followup";
+  }
+  return {
+    shouldPostThreadReply: deliveryPlan.postThreadText,
+    attachFiles
+  };
+}
+
+// src/chat/services/channel-intent.ts
 function isExplicitChannelPostIntent(text) {
   if (!/\bchannel\b/i.test(text)) {
     return false;
@@ -9372,6 +9659,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 +9793,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 +9803,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 +9846,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 +9876,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 +9892,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 +10036,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 +10093,7 @@ async function generateAssistantReply(messageText, context = {}) {
     }
     syncResumeState();
     const activeToolSummaries = turnMcpToolManager.getActiveToolCatalog(activeSkills).map(toExposedToolSummary);
-    const baseInstructions = buildSystemPrompt({
+    baseInstructions = buildSystemPrompt({
       availableSkills,
       activeSkills,
       activeTools: activeToolSummaries,
@@ -9821,6 +10153,17 @@ async function generateAssistantReply(messageText, context = {}) {
     const agentToolHooks = {
       onToolCall: (toolName) => {
         toolCalls.push(toolName);
+        Promise.resolve(context.onToolCall?.(toolName)).catch((error) => {
+          logWarn(
+            "streaming_tool_call_error",
+            {},
+            {
+              "error.message": error instanceof Error ? error.message : String(error),
+              "gen_ai.tool.name": toolName
+            },
+            "Failed to deliver tool call event to stream coordinator"
+          );
+        });
       }
     };
     const baseAgentTools = createAgentTools(
@@ -9861,6 +10204,16 @@ async function generateAssistantReply(messageText, context = {}) {
     let needsSeparator = false;
     const unsubscribe = agent.subscribe((event) => {
       if (event.type === "message_start") {
+        Promise.resolve(context.onAssistantMessageStart?.()).catch((error) => {
+          logWarn(
+            "streaming_message_start_error",
+            {},
+            {
+              "error.message": error instanceof Error ? error.message : String(error)
+            },
+            "Failed to deliver assistant message start to stream coordinator"
+          );
+        });
         if (hasEmittedText) {
           needsSeparator = true;
         }
@@ -9889,15 +10242,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 +10251,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 +10271,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 +10297,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 +10353,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 +10402,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)) {
@@ -10228,7 +10605,194 @@ function createProgressReporter(args) {
   };
 }
 
-// src/handlers/oauth-resume.ts
+// src/chat/slack/reply.ts
+import { Buffer as Buffer2 } from "buffer";
+function isInterruptedVisibleReply(reply) {
+  return reply.diagnostics.outcome === "provider_error";
+}
+function buildChunkMessage(chunk, files) {
+  return {
+    markdown: chunk,
+    ...files ? { files } : {}
+  };
+}
+function buildTextPosts(args) {
+  const chunks = splitSlackReplyText(args.text, {
+    interrupted: args.interrupted
+  });
+  return chunks.map((chunk, index) => ({
+    message: buildChunkMessage(
+      chunk,
+      index === 0 ? args.firstFiles : void 0
+    ),
+    stage: index === 0 ? args.firstStage ?? "thread_reply" : "thread_reply_continuation"
+  }));
+}
+async function normalizeFileUploads(files) {
+  return await Promise.all(
+    files.map(async (file) => {
+      let data;
+      if (Buffer2.isBuffer(file.data)) {
+        data = file.data;
+      } else if (file.data instanceof ArrayBuffer) {
+        data = Buffer2.from(file.data);
+      } else {
+        data = Buffer2.from(await file.data.arrayBuffer());
+      }
+      return {
+        data,
+        filename: file.filename
+      };
+    })
+  );
+}
+async function uploadReplyFilesBestEffort(args) {
+  try {
+    await uploadFilesToThread({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      files: await normalizeFileUploads(args.files)
+    });
+  } catch {
+  }
+}
+function getReplyMessageText(message) {
+  if (typeof message !== "object" || message === null) {
+    return void 0;
+  }
+  if ("markdown" in message && typeof message.markdown === "string") {
+    return message.markdown;
+  }
+  if ("raw" in message && typeof message.raw === "string") {
+    return message.raw;
+  }
+  return void 0;
+}
+function getReplyMessageFiles(message) {
+  if (typeof message === "object" && message !== null && "files" in message && Array.isArray(message.files)) {
+    return message.files;
+  }
+  return void 0;
+}
+function createSlackStreamAccumulator() {
+  let pendingCarriageReturn = false;
+  let streamedVisibleText = "";
+  let streamedRenderedText = "";
+  let overflowText = "";
+  let streamOverflowed = false;
+  const continuationBudget = getSlackStreamingContinuationBudget();
+  const normalizeDelta = (deltaText) => {
+    let text = deltaText;
+    if (pendingCarriageReturn) {
+      text = `\r${text}`;
+      pendingCarriageReturn = false;
+    }
+    if (text.endsWith("\r")) {
+      text = text.slice(0, -1);
+      pendingCarriageReturn = true;
+    }
+    return text.replace(/\r\n?/g, "\n");
+  };
+  return {
+    append(deltaText) {
+      const normalizedDeltaText = normalizeDelta(deltaText);
+      if (!normalizedDeltaText) {
+        return "";
+      }
+      if (streamOverflowed) {
+        overflowText += normalizedDeltaText;
+        return "";
+      }
+      const candidate = `${streamedVisibleText}${normalizedDeltaText}`;
+      const { prefix, renderedPrefix, rest } = takeSlackContinuationPrefix(
+        candidate,
+        continuationBudget
+      );
+      const additional = renderedPrefix.length > streamedRenderedText.length ? renderedPrefix.slice(streamedRenderedText.length) : "";
+      streamedVisibleText = prefix;
+      streamedRenderedText = renderedPrefix;
+      if (rest) {
+        overflowText += rest;
+        streamOverflowed = true;
+      }
+      return additional;
+    },
+    getOverflowText() {
+      return overflowText;
+    }
+  };
+}
+function planSlackReplyPosts(args) {
+  const replyFiles = args.reply.files && args.reply.files.length > 0 ? args.reply.files : void 0;
+  const { shouldPostThreadReply, attachFiles } = resolveReplyDelivery({
+    reply: args.reply,
+    hasStreamedThreadReply: args.hasStreamedThreadReply
+  });
+  const interrupted = isInterruptedVisibleReply(args.reply);
+  const posts = [];
+  if (args.hasStreamedThreadReply) {
+    if (shouldPostThreadReply && args.streamedOverflowText) {
+      posts.push(
+        ...buildTextPosts({
+          text: args.streamedOverflowText,
+          interrupted,
+          firstStage: "thread_reply_continuation"
+        })
+      );
+    } else if (shouldPostThreadReply && interrupted) {
+      posts.push({
+        message: buildSlackOutputMessage(
+          getSlackInterruptionMarker().trimStart()
+        ),
+        stage: "thread_reply_continuation"
+      });
+    }
+  } else {
+    const textPosts = shouldPostThreadReply ? buildTextPosts({
+      text: args.reply.text,
+      interrupted,
+      firstFiles: attachFiles === "inline" ? replyFiles : void 0
+    }) : [];
+    posts.push(...textPosts);
+    if (attachFiles === "inline" && replyFiles && textPosts.length === 0) {
+      posts.push({
+        message: buildSlackOutputMessage("", replyFiles),
+        stage: "thread_reply"
+      });
+    } else if (shouldPostThreadReply && textPosts.length === 0) {
+      posts.push({
+        message: buildSlackOutputMessage(args.reply.text),
+        stage: "thread_reply"
+      });
+    }
+  }
+  if (attachFiles === "followup" && replyFiles) {
+    posts.push({
+      message: buildSlackOutputMessage("", replyFiles),
+      stage: "thread_reply_files_followup"
+    });
+  }
+  return posts;
+}
+async function postSlackApiReplyPosts(args) {
+  for (const post of args.posts) {
+    const text = getReplyMessageText(post.message);
+    if (text && text.trim().length > 0) {
+      await args.postMessage(args.channelId, args.threadTs, text);
+    }
+    const files = getReplyMessageFiles(post.message);
+    if (!files?.length) {
+      continue;
+    }
+    await uploadReplyFilesBestEffort({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      files
+    });
+  }
+}
+
+// src/chat/slack/resume.ts
 function resolveReplyTimeoutMs(explicitTimeoutMs) {
   if (typeof explicitTimeoutMs === "number" && explicitTimeoutMs > 0) {
     return explicitTimeoutMs;
@@ -10241,12 +10805,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 +10843,85 @@ function createReadOnlyConfigService(values) {
     }
   };
 }
-async function resumeAuthorizedRequest(args) {
+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([
@@ -10318,20 +10938,180 @@ async function resumeAuthorizedRequest(args) {
       )
     ]) : await replyPromise;
     await progress.stop();
-    if (args.onReply) {
-      await args.onReply(reply);
-    } else if (reply.text) {
-      await postSlackMessage(args.channelId, args.threadTs, reply.text);
-    }
+    await postSlackApiReplyPosts({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      posts: planSlackReplyPosts({
+        reply,
+        hasStreamedThreadReply: false
+      }),
+      postMessage: postSlackMessage
+    });
     await args.onSuccess?.(reply);
   } 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,
+    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;
   }
 }
 
@@ -10386,87 +11166,12 @@ function htmlResponse(kind) {
   const page = CALLBACK_PAGES[kind];
   return htmlCallbackResponse(page.title, page.message, page.status);
 }
-function extractSlackText(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 normalizeFileUploads(files) {
-  const normalized = [];
-  for (const file of files) {
-    let data;
-    if (Buffer2.isBuffer(file.data)) {
-      data = file.data;
-    } else if (file.data instanceof ArrayBuffer) {
-      data = Buffer2.from(file.data);
-    } else {
-      data = Buffer2.from(await file.data.arrayBuffer());
-    }
-    normalized.push({
-      data,
-      filename: file.filename
-    });
-  }
-  return normalized;
-}
-async function deliverReplyToThread(channelId, threadTs, reply) {
-  const replyFiles = reply.files && reply.files.length > 0 ? reply.files : void 0;
-  const { shouldPostThreadReply, attachFiles } = resolveReplyDelivery({
-    reply,
-    hasStreamedThreadReply: false
-  });
-  if (shouldPostThreadReply) {
-    const text = extractSlackText(
-      reply.text,
-      attachFiles === "inline" ? replyFiles : void 0
-    );
-    if (text.trim().length > 0) {
-      await postSlackMessage(channelId, threadTs, text);
-    }
-  }
-  if (!replyFiles || attachFiles === "none") {
-    return;
-  }
-  const files = await normalizeFileUploads(replyFiles);
-  if (files.length === 0) {
-    return;
-  }
-  try {
-    await uploadFilesToThread({
-      channelId,
-      threadTs,
-      files
-    });
-  } 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 +11182,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 +11219,7 @@ async function persistFailedReplyState(channelId, threadTs, sessionId) {
   markTurnFailed({
     conversation,
     nowMs: Date.now(),
-    userMessageId: getUserMessageIdForTurn(conversation, sessionId),
+    userMessageId: getTurnUserMessageId(conversation, sessionId),
     markConversationMessage,
     updateConversationStats
   });
@@ -10527,6 +11232,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,29 +11250,32 @@ 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
-    },
-    toolChannelId: authSession.toolChannelId ?? authSession.artifactState?.assistantContextChannelId ?? authSession.channelId,
-    conversationContext,
-    artifactState: authSession.artifactState,
-    configuration: authSession.configuration,
-    onReply: async (reply) => {
-      await deliverReplyToThread(
-        authSession.channelId,
-        authSession.threadTs,
-        reply
-      );
+    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)
     },
     onSuccess: async (reply) => {
       try {
@@ -10607,6 +11326,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 +11573,15 @@ 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",
@@ -10990,38 +11741,304 @@ async function GET5(request, provider, waitUntil) {
     } catch {
     }
   });
-  if (stored.pendingMessage && stored.channelId && stored.threadTs) {
-    waitUntil(() => resumePendingOAuthMessage(stored));
-  } else if (stored.channelId && stored.threadTs) {
-    const { channelId, threadTs } = stored;
-    waitUntil(
-      () => postSlackMessage(
-        channelId,
-        threadTs,
-        `Your ${providerLabel} account is now connected. You can start using ${providerLabel} commands.`
-      )
-    );
+  if (stored.pendingMessage && stored.channelId && stored.threadTs) {
+    waitUntil(() => resumePendingOAuthMessage(stored));
+  } else if (stored.channelId && stored.threadTs) {
+    const { channelId, threadTs } = stored;
+    waitUntil(
+      () => postSlackMessage(
+        channelId,
+        threadTs,
+        `Your ${providerLabel} account is now connected. You can start using ${providerLabel} commands.`
+      )
+    );
+  }
+  const statusMessage = stored.pendingMessage ? "Your request is being processed in Slack." : "You can close this tab and return to Slack.";
+  const html = `<!DOCTYPE html>
+<html>
+<head><title>${providerLabel} Connected</title></head>
+<body style="font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0;">
+  <div style="text-align: center;">
+    <h1>${providerLabel} account connected</h1>
+    <p>${statusMessage}</p>
+  </div>
+</body>
+</html>`;
+  return new Response(html, {
+    status: 200,
+    headers: { "Content-Type": "text/html; charset=utf-8" }
+  });
+}
+
+// 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
+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)
+    },
+    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 });
   }
-  const statusMessage = stored.pendingMessage ? "Your request is being processed in Slack." : "You can close this tab and return to Slack.";
-  const html = `<!DOCTYPE html>
-<html>
-<head><title>${providerLabel} Connected</title></head>
-<body style="font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0;">
-  <div style="text-align: center;">
-    <h1>${providerLabel} account connected</h1>
-    <p>${statusMessage}</p>
-  </div>
-</body>
-</html>`;
-  return new Response(html, {
-    status: 200,
-    headers: { "Content-Type": "text/html; charset=utf-8" }
-  });
+  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";
-
 // src/chat/services/subscribed-decision.ts
 import { z } from "zod";
 var replyDecisionSchema = z.object({
@@ -11048,11 +12065,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 +12357,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 +12368,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();
@@ -11914,6 +12885,15 @@ var MAX_USER_ATTACHMENTS = 3;
 var MAX_USER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 var MAX_MESSAGE_IMAGE_ATTACHMENTS = 3;
 var MAX_VISION_SUMMARY_CHARS = 500;
+function hasPotentialImageAttachment(attachments) {
+  return attachments?.some((attachment) => {
+    if (attachment.type === "image") {
+      return true;
+    }
+    const mimeType = attachment.mimeType ?? "";
+    return attachment.type === "file" && mimeType.startsWith("image/");
+  }) ?? false;
+}
 function isVisionEnabled() {
   return Boolean(botConfig.visionModelId);
 }
@@ -12256,6 +13236,7 @@ async function hydrateConversationVisionContextWithDeps(conversation, context, d
       continue;
     }
     hydratedMessageIds.add(conversationMessage.id);
+    const existingMeta = conversationMessage.meta ?? {};
     const imageFiles = (reply.files ?? []).filter((file) => {
       const mimeType = toOptionalString(file.mimetype);
       return Boolean(
@@ -12263,10 +13244,15 @@ async function hydrateConversationVisionContextWithDeps(conversation, context, d
       );
     }).slice(0, MAX_MESSAGE_IMAGE_ATTACHMENTS);
     if (imageFiles.length === 0) {
+      conversationMessage.meta = {
+        ...existingMeta,
+        slackTs: existingMeta.slackTs ?? ts,
+        imagesHydrated: true
+      };
+      mutated = true;
       continue;
     }
     const imageFileIds = imageFiles.map((file) => toOptionalString(file.id)).filter((fileId) => Boolean(fileId));
-    const existingMeta = conversationMessage.meta ?? {};
     conversationMessage.meta = {
       ...existingMeta,
       slackTs: existingMeta.slackTs ?? ts,
@@ -12430,6 +13416,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,18 +13481,13 @@ 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 });
-    }
+function shouldAutoStartStreaming(args) {
+  const { text, deltaCount } = args;
+  const trimmed = text.trim();
+  if (!trimmed || isPotentialRedundantReactionAckText(trimmed)) {
+    return false;
   }
-  return participants;
+  return deltaCount >= 2;
 }
 function createReplyToThread(deps) {
   return async function replyToThread(thread, message, options = {}) {
@@ -12615,7 +13597,10 @@ function createReplyToThread(deps) {
         const textStream = createTextStreamBridge();
         let streamedReplyPromise;
         let pendingStreamText = "";
+        let pendingStreamDeltaCount = 0;
+        let awaitingPostToolAssistantMessage = false;
         let beforeFirstResponsePostCalled = false;
+        let streamedReplyState = createSlackStreamAccumulator();
         const beforeFirstResponsePost = async () => {
           if (beforeFirstResponsePostCalled) {
             return;
@@ -12641,6 +13626,51 @@ function createReplyToThread(deps) {
           startStreamingReply();
           textStream.push(pendingStreamText);
           pendingStreamText = "";
+          pendingStreamDeltaCount = 0;
+        };
+        const clearPendingStreamText = () => {
+          pendingStreamText = "";
+          pendingStreamDeltaCount = 0;
+        };
+        const discardPendingStreamPreview = () => {
+          clearPendingStreamText();
+          streamedReplyState = createSlackStreamAccumulator();
+        };
+        const finalizePendingStreamText = () => {
+          if (!pendingStreamText || streamedReplyPromise || isPotentialRedundantReactionAckText(pendingStreamText)) {
+            return;
+          }
+          flushPendingStreamText();
+        };
+        const queueVisibleStreamText = (text) => {
+          if (!text) {
+            return;
+          }
+          if (awaitingPostToolAssistantMessage) {
+            return;
+          }
+          if (streamedReplyPromise) {
+            textStream.push(text);
+            return;
+          }
+          pendingStreamText += text;
+          pendingStreamDeltaCount += 1;
+          if (isPotentialRedundantReactionAckText(pendingStreamText)) {
+            return;
+          }
+          if (!shouldAutoStartStreaming({
+            text: pendingStreamText,
+            deltaCount: pendingStreamDeltaCount
+          })) {
+            return;
+          }
+          flushPendingStreamText();
+        };
+        const appendVisibleStreamDelta = (deltaText) => {
+          if (awaitingPostToolAssistantMessage && !streamedReplyPromise) {
+            return;
+          }
+          queueVisibleStreamText(streamedReplyState.append(deltaText));
         };
         const postThreadReply = async (payload, stage) => {
           await beforeFirstResponsePost();
@@ -12666,7 +13696,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,25 +13728,41 @@ 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) => {
               if (explicitChannelPostIntent) {
                 return;
               }
-              if (streamedReplyPromise) {
-                textStream.push(deltaText);
+              appendVisibleStreamDelta(deltaText);
+            },
+            onAssistantMessageStart: () => {
+              if (!awaitingPostToolAssistantMessage) {
                 return;
               }
-              pendingStreamText += deltaText;
-              if (isPotentialRedundantReactionAckText(pendingStreamText)) {
-                return;
+              awaitingPostToolAssistantMessage = false;
+              discardPendingStreamPreview();
+            },
+            onToolCall: () => {
+              if (!streamedReplyPromise) {
+                awaitingPostToolAssistantMessage = true;
+                discardPendingStreamPreview();
               }
-              flushPendingStreamText();
             }
           });
           if (streamedReplyPromise) {
             flushPendingStreamText();
+          } else {
+            finalizePendingStreamText();
           }
           textStream.end();
           const diagnosticsContext = {
@@ -12790,28 +13836,32 @@ function createReplyToThread(deps) {
             }
           });
           const artifactStatePatch = reply.artifactStatePatch ? { ...reply.artifactStatePatch } : {};
-          const replyFiles = reply.files && reply.files.length > 0 ? reply.files : void 0;
-          const { shouldPostThreadReply, attachFiles: resolvedAttachFiles } = resolveReplyDelivery({
-            reply,
-            hasStreamedThreadReply: Boolean(streamedReplyPromise)
-          });
           const reactionPerformed = reply.diagnostics.toolCalls.includes(
             "slackMessageAddReaction"
           );
-          if (shouldPostThreadReply) {
+          const plannedPosts = planSlackReplyPosts({
+            reply,
+            hasStreamedThreadReply: Boolean(streamedReplyPromise),
+            streamedOverflowText: streamedReplyState.getOverflowText()
+          });
+          if (streamedReplyPromise) {
+            await streamedReplyPromise;
+          }
+          if (plannedPosts.length > 0) {
             if (!streamedReplyPromise) {
-              const sent = await postThreadReply(
-                buildSlackOutputMessage(
-                  reply.text,
-                  resolvedAttachFiles === "inline" ? replyFiles : void 0
-                ),
-                "thread_reply"
-              );
-              if (reactionPerformed && isRedundantReactionAckText(reply.text)) {
+              let sent;
+              for (const post of plannedPosts) {
+                sent = await postThreadReply(post.message, post.stage);
+              }
+              const firstPlannedMessage = plannedPosts[0]?.message;
+              const firstPlannedMessageHasFiles = typeof firstPlannedMessage === "object" && firstPlannedMessage !== null && "files" in firstPlannedMessage && Array.isArray(firstPlannedMessage.files) && firstPlannedMessage.files.length > 0;
+              if (sent && reactionPerformed && plannedPosts.length === 1 && !firstPlannedMessageHasFiles && isRedundantReactionAckText(reply.text)) {
                 await sent.delete();
               }
             } else {
-              await streamedReplyPromise;
+              for (const post of plannedPosts) {
+                await postThreadReply(post.message, post.stage);
+              }
             }
           }
           const shouldPersistArtifacts = Object.keys(artifactStatePatch).length > 0;
@@ -12887,17 +13937,67 @@ function createReplyToThread(deps) {
               );
             });
           }
-          if (shouldPostThreadReply && resolvedAttachFiles === "followup" && replyFiles) {
-            await postThreadReply(
-              buildSlackOutputMessage("", replyFiles),
-              "thread_reply_files_followup"
-            );
-          }
         } 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();
@@ -12968,6 +14068,11 @@ async function initializeAssistantThread(event) {
 }
 
 // src/chat/runtime/turn-preparation.ts
+function hasPendingImageHydration(conversation) {
+  return conversation.messages.some(
+    (message) => isHumanConversationMessage(message) && !message.meta?.imagesHydrated
+  );
+}
 function createPrepareTurnState(deps) {
   return async function prepareTurnState(args) {
     const existingState = await args.thread.state;
@@ -12985,14 +14090,8 @@ function createPrepareTurnState(deps) {
       messageId: args.message.id,
       messageCreatedAtMs: args.message.metadata.dateSent.getTime()
     });
-    const messageHasPotentialImageAttachment = args.message.attachments.some(
-      (attachment) => {
-        if (attachment.type === "image") {
-          return true;
-        }
-        const mimeType = attachment.mimeType ?? "";
-        return attachment.type === "file" && mimeType.startsWith("image/");
-      }
+    const messageHasPotentialImageAttachment = hasPotentialImageAttachment(
+      args.message.attachments
     );
     const normalizedUserText = normalizeConversationText(args.userText) || "[non-text message]";
     const slackTs = getSlackMessageTs(args.message);
@@ -13017,7 +14116,8 @@ function createPrepareTurnState(deps) {
       conversation,
       incomingUserMessage
     );
-    if (isVisionEnabled() && (!conversation.vision.backfillCompletedAtMs || messageHasPotentialImageAttachment)) {
+    const shouldHydrateVisionContext = !conversation.vision.backfillCompletedAtMs || messageHasPotentialImageAttachment || hasPendingImageHydration(conversation);
+    if (isVisionEnabled() && shouldHydrateVisionContext) {
       await deps.hydrateConversationVisionContext(conversation, {
         threadId: args.context.threadId,
         channelId: args.context.channelId,
@@ -13113,7 +14213,7 @@ function createSlackRuntime(options) {
           slackTs,
           replied: false,
           skippedReason: decision.reason,
-          imagesHydrated: true
+          imagesHydrated: !hasPotentialImageAttachment(message.attachments)
         }
       });
       conversation.processing.activeTurnId = void 0;
@@ -13397,6 +14497,166 @@ var JuniorChat = class extends Chat {
   }
 };
 
+// src/chat/slack/adapter.ts
+import {
+  createSlackAdapter
+} from "@chat-adapter/slack";
+import {
+  StreamingMarkdownRenderer
+} from "chat";
+var STREAM_BUFFER_SIZE = 64;
+var CLIENT_STREAM_PATCHED = /* @__PURE__ */ Symbol("junior.slack.client_stream_patched");
+var ADAPTER_STREAM_PATCHED = /* @__PURE__ */ Symbol("junior.slack.adapter_stream_patched");
+function assertSlackAdapterInternals(internals) {
+  if (!internals.client || typeof internals.client.chatStream !== "function") {
+    throw new Error("Slack adapter client does not expose chatStream()");
+  }
+  if (typeof internals.stream !== "function") {
+    throw new Error("Slack adapter does not expose stream()");
+  }
+  if (typeof internals.decodeThreadId !== "function") {
+    throw new Error("Slack adapter does not expose decodeThreadId()");
+  }
+  if (typeof internals.getToken !== "function") {
+    throw new Error("Slack adapter does not expose getToken()");
+  }
+  if (!internals.logger || typeof internals.logger.debug !== "function" || typeof internals.logger.warn !== "function") {
+    throw new Error("Slack adapter does not expose logger debug/warn methods");
+  }
+}
+function shouldEagerFlushPlainText(text) {
+  return text.length > 0 && !text.includes("\n") && !/[`*~[\]|]/.test(text);
+}
+function getNextRenderableDelta(renderer, lastAppended) {
+  const committable = renderer.getCommittableText();
+  if (committable.startsWith(lastAppended)) {
+    const delta = committable.slice(lastAppended.length);
+    if (delta) {
+      return { delta, nextAppended: committable };
+    }
+  }
+  const rawText = renderer.getText();
+  if (shouldEagerFlushPlainText(rawText) && rawText.startsWith(lastAppended) && rawText.length > lastAppended.length) {
+    return {
+      delta: rawText.slice(lastAppended.length),
+      nextAppended: rawText
+    };
+  }
+  return { delta: "", nextAppended: lastAppended };
+}
+function patchSlackClientStream(adapter) {
+  const internals = adapter;
+  const { client: client2 } = internals;
+  if (client2[CLIENT_STREAM_PATCHED]) {
+    return;
+  }
+  const originalChatStream = client2.chatStream.bind(client2);
+  client2.chatStream = (params) => originalChatStream({
+    ...params,
+    buffer_size: STREAM_BUFFER_SIZE
+  });
+  client2[CLIENT_STREAM_PATCHED] = true;
+}
+function patchSlackAdapterStream(adapter) {
+  const internals = adapter;
+  if (internals[ADAPTER_STREAM_PATCHED]) {
+    return;
+  }
+  const originalStream = internals.stream.bind(adapter);
+  internals.stream = async function(threadId, textStream, options) {
+    if (!(options?.recipientUserId && options?.recipientTeamId)) {
+      return originalStream(threadId, textStream, options);
+    }
+    const { channel, threadTs } = internals.decodeThreadId(threadId);
+    internals.logger.debug("Slack: starting stream", { channel, threadTs });
+    const token = internals.getToken();
+    const streamer = internals.client.chatStream({
+      channel,
+      thread_ts: threadTs,
+      recipient_user_id: options.recipientUserId,
+      recipient_team_id: options.recipientTeamId,
+      ...options.taskDisplayMode ? { task_display_mode: options.taskDisplayMode } : {}
+    });
+    let first = true;
+    let lastAppended = "";
+    let structuredChunksSupported = true;
+    const renderer = new StreamingMarkdownRenderer();
+    const flushMarkdownDelta = async (delta) => {
+      if (delta.length === 0) {
+        return;
+      }
+      if (first) {
+        await streamer.append({ markdown_text: delta, token, chunks: [] });
+        first = false;
+        return;
+      }
+      await streamer.append({ markdown_text: delta });
+    };
+    const flushText = async () => {
+      const { delta, nextAppended } = getNextRenderableDelta(
+        renderer,
+        lastAppended
+      );
+      await flushMarkdownDelta(delta);
+      lastAppended = nextAppended;
+    };
+    const sendStructuredChunk = async (chunk) => {
+      if (!structuredChunksSupported) {
+        return;
+      }
+      await flushText();
+      try {
+        if (first) {
+          await streamer.append({ chunks: [chunk], token });
+          first = false;
+          return;
+        }
+        await streamer.append({ chunks: [chunk] });
+      } catch (error) {
+        structuredChunksSupported = false;
+        internals.logger.warn(
+          "Structured streaming chunk failed, falling back to text-only streaming. Ensure your Slack app manifest includes assistant_view, assistant:write scope, and @slack/web-api >= 7.14.0",
+          { chunkType: chunk.type, error }
+        );
+      }
+    };
+    const pushTextAndFlush = async (text) => {
+      renderer.push(text);
+      await flushText();
+    };
+    for await (const chunk of textStream) {
+      if (typeof chunk === "string") {
+        await pushTextAndFlush(chunk);
+      } else if (chunk.type === "markdown_text") {
+        await pushTextAndFlush(chunk.text);
+      } else {
+        await sendStructuredChunk(chunk);
+      }
+    }
+    renderer.finish();
+    await flushText();
+    const result = await streamer.stop(
+      options?.stopBlocks ? { blocks: options.stopBlocks } : void 0
+    );
+    const messageTs = result.message?.ts ?? result.ts;
+    internals.logger.debug("Slack: stream complete", { messageId: messageTs });
+    return {
+      id: messageTs,
+      threadId,
+      raw: result
+    };
+  };
+  internals[ADAPTER_STREAM_PATCHED] = true;
+}
+function createJuniorSlackAdapter(config) {
+  const adapter = createSlackAdapter(config);
+  const internals = adapter;
+  assertSlackAdapterInternals(internals);
+  patchSlackClientStream(adapter);
+  patchSlackAdapterStream(adapter);
+  return adapter;
+}
+
 // src/chat/queue/thread-message-dispatcher.ts
 function rehydrateAttachmentFetchers(message, downloadPrivateSlackFile2 = downloadPrivateSlackFile) {
   for (const attachment of message.attachments) {
@@ -13493,8 +14753,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
@@ -13513,7 +14775,8 @@ function createProductionBot() {
         if (!signingSecret) {
           throw new Error("SLACK_SIGNING_SECRET is required");
         }
-        return createSlackAdapter({
+        return createJuniorSlackAdapter({
+          logger: logger.child("slack"),
           signingSecret,
           ...botToken ? { botToken } : {},
           ...clientId ? { clientId } : {},
@@ -13648,6 +14911,32 @@ function isMessageChangedEnvelope(value) {
 function textMentionsBot(text, botUserId) {
   return text.includes(`<@${botUserId}>`);
 }
+function getAttachmentType(mimeType) {
+  if (mimeType?.startsWith("image/")) {
+    return "image";
+  }
+  if (mimeType?.startsWith("video/")) {
+    return "video";
+  }
+  if (mimeType?.startsWith("audio/")) {
+    return "audio";
+  }
+  return "file";
+}
+function extractEditedMessageAttachments(files) {
+  if (!files || files.length === 0) {
+    return [];
+  }
+  return files.map((file) => ({
+    type: getAttachmentType(file.mimetype),
+    url: file.url_private_download ?? file.url_private,
+    name: file.name,
+    mimeType: file.mimetype,
+    size: file.size,
+    width: file.original_w,
+    height: file.original_h
+  }));
+}
 function extractMessageChangedMention(body, botUserId, adapter) {
   if (!isMessageChangedEnvelope(body)) return null;
   const { event } = body;
@@ -13673,7 +14962,7 @@ function extractMessageChangedMention(body, botUserId, adapter) {
     threadId,
     text: newText,
     isMention: true,
-    attachments: [],
+    attachments: extractEditedMessageAttachments(event.message.files),
     metadata: { dateSent: new Date(Number(messageTs) * 1e3), edited: true },
     formatted: { type: "root", children: [] },
     raw,
@@ -13726,6 +15015,7 @@ async function handleAuthenticatedSlackMessageChangedMention(args) {
     if (!result) {
       return false;
     }
+    rehydrateAttachmentFetchers(result.message);
     args.bot.processMessage(
       slackAdapter,
       result.threadId,
@@ -13847,7 +15137,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);
 }
 
@@ -13900,8 +15190,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;
 }