@sentry/junior 0.22.0 → 0.24.0

package/dist/app.js

@@ -6,7 +6,7 @@ import {
   loadSkillsByName,
   logCapabilityCatalogLoadedOnce,
   parseSkillInvocation
-} from "./chunk-JWBWBJYJ.js";
+} from "./chunk-DGN3WLA4.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -27,7 +27,7 @@ import {
   sandboxSkillDir,
   sandboxSkillFile,
   toOptionalTrimmed
-} from "./chunk-THPM7NSG.js";
+} from "./chunk-B5O2EJUV.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -58,7 +58,7 @@ import {
   toOptionalString,
   withContext,
   withSpan
-} from "./chunk-MCJJKEB3.js";
+} from "./chunk-J7JEFMVD.js";
 import "./chunk-Z3YD6NHK.js";
 import {
   discoverInstalledPluginPackageContent,
@@ -311,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";
@@ -336,9 +333,17 @@ function coerceAuthor(value) {
 function coerceMessageMeta(value) {
   if (!isRecord(value)) return void 0;
   const meta = {};
+  const attachmentCount = toOptionalNumber(value.attachmentCount);
+  if (typeof attachmentCount === "number" && attachmentCount > 0) {
+    meta.attachmentCount = attachmentCount;
+  }
   if (typeof value.explicitMention === "boolean") {
     meta.explicitMention = value.explicitMention;
   }
+  const imageAttachmentCount = toOptionalNumber(value.imageAttachmentCount);
+  if (typeof imageAttachmentCount === "number" && imageAttachmentCount > 0) {
+    meta.imageAttachmentCount = imageAttachmentCount;
+  }
   if (typeof value.replied === "boolean") {
     meta.replied = value.replied;
   }
@@ -359,7 +364,7 @@ function coerceMessageMeta(value) {
   if (typeof value.imagesHydrated === "boolean") {
     meta.imagesHydrated = value.imagesHydrated;
   }
-  if (meta.explicitMention === void 0 && meta.replied === void 0 && meta.skippedReason === void 0 && meta.slackTs === void 0 && meta.imageFileIds === void 0 && meta.imagesHydrated === void 0) {
+  if (meta.attachmentCount === void 0 && meta.explicitMention === void 0 && meta.imageAttachmentCount === void 0 && meta.replied === void 0 && meta.skippedReason === void 0 && meta.slackTs === void 0 && meta.imageFileIds === void 0 && meta.imagesHydrated === void 0) {
     return void 0;
   }
   return meta;
@@ -729,81 +734,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";
@@ -946,13 +876,19 @@ function mapSlackError(error) {
   if (apiError === "not_in_channel") {
     return new SlackActionError(message, "not_in_channel", baseOptions);
   }
+  if (apiError === "already_reacted") {
+    return new SlackActionError(message, "already_reacted", baseOptions);
+  }
+  if (apiError === "no_reaction") {
+    return new SlackActionError(message, "no_reaction", baseOptions);
+  }
   if (apiError === "invalid_arguments") {
     return new SlackActionError(message, "invalid_arguments", baseOptions);
   }
   if (apiError === "invalid_name") {
     return new SlackActionError(message, "invalid_arguments", baseOptions);
   }
-  if (apiError === "not_found") {
+  if (apiError === "not_found" || apiError === "channel_not_found" || apiError === "message_not_found") {
     return new SlackActionError(message, "not_found", baseOptions);
   }
   if (apiError === "feature_not_enabled" || apiError === "not_allowed_token_type") {
@@ -1052,19 +988,6 @@ async function getFilePermalink(fileId) {
   );
   return response.file?.permalink;
 }
-async function uploadFilesToThread(args) {
-  const client2 = getClient();
-  await withSlackRetries(
-    () => client2.filesUploadV2({
-      channel_id: args.channelId,
-      thread_ts: args.threadTs,
-      file_uploads: args.files.map((f) => ({
-        file: f.data,
-        filename: f.filename
-      }))
-    })
-  );
-}
 async function downloadPrivateSlackFile(url) {
   const token = getSlackBotToken();
   if (!token) {
@@ -1084,6 +1007,196 @@ async function downloadPrivateSlackFile(url) {
   return Buffer.from(await response.arrayBuffer());
 }
 
+// src/chat/slack/emoji.ts
+var SLACK_EMOJI_NAME_RE = /^(?:[a-z0-9_+-]+)(?:::(?:skin-tone-[2-6]))?$/;
+function normalizeSlackEmojiName(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (!trimmed) {
+    return null;
+  }
+  const normalized = trimmed.startsWith(":") && trimmed.endsWith(":") ? trimmed.slice(1, -1) : trimmed;
+  return SLACK_EMOJI_NAME_RE.test(normalized) ? normalized : null;
+}
+
+// src/chat/slack/outbound.ts
+var MAX_SLACK_MESSAGE_TEXT_CHARS = 4e4;
+function requireSlackConversationId(channelId, action) {
+  const normalized = normalizeSlackConversationId(channelId);
+  if (!normalized) {
+    throw new Error(`${action} requires a valid channel ID`);
+  }
+  return normalized;
+}
+function requireSlackThreadTimestamp(threadTs, action) {
+  const normalized = threadTs.trim();
+  if (!normalized) {
+    throw new Error(`${action} requires a thread timestamp`);
+  }
+  return normalized;
+}
+function requireSlackMessageTimestamp(timestamp, action) {
+  const normalized = timestamp.trim();
+  if (!normalized) {
+    throw new Error(`${action} requires a target message timestamp`);
+  }
+  return normalized;
+}
+function requireSlackMessageText(text, action) {
+  if (text.trim().length === 0) {
+    throw new Error(`${action} requires non-empty text`);
+  }
+  if (text.length > MAX_SLACK_MESSAGE_TEXT_CHARS) {
+    throw new Error(
+      `${action} text exceeds Slack's 40000 character truncation limit`
+    );
+  }
+  return text;
+}
+async function getPermalinkBestEffort(args) {
+  try {
+    const response = await withSlackRetries(
+      () => getSlackClient().chat.getPermalink({
+        channel: args.channelId,
+        message_ts: args.messageTs
+      }),
+      3,
+      { action: "chat.getPermalink" }
+    );
+    return response.permalink;
+  } catch {
+    return void 0;
+  }
+}
+async function postSlackMessage(input) {
+  const channelId = requireSlackConversationId(
+    input.channelId,
+    "Slack message posting"
+  );
+  const text = requireSlackMessageText(input.text, "Slack message posting");
+  const threadTs = input.threadTs ? requireSlackThreadTimestamp(
+    input.threadTs,
+    "Slack thread message posting"
+  ) : void 0;
+  const response = await withSlackRetries(
+    () => getSlackClient().chat.postMessage({
+      channel: channelId,
+      text,
+      mrkdwn: true,
+      ...threadTs ? { thread_ts: threadTs } : {}
+    }),
+    3,
+    { action: "chat.postMessage" }
+  );
+  if (!response.ts) {
+    throw new Error("Slack message posted without ts");
+  }
+  return {
+    ts: response.ts,
+    ...input.includePermalink ? {
+      permalink: await getPermalinkBestEffort({
+        channelId,
+        messageTs: response.ts
+      })
+    } : {}
+  };
+}
+async function postSlackEphemeralMessage(input) {
+  const channelId = requireSlackConversationId(
+    input.channelId,
+    "Slack ephemeral message posting"
+  );
+  const userId = input.userId.trim();
+  if (!userId) {
+    throw new Error("Slack ephemeral message posting requires a user ID");
+  }
+  const text = requireSlackMessageText(
+    input.text,
+    "Slack ephemeral message posting"
+  );
+  const threadTs = input.threadTs ? requireSlackThreadTimestamp(
+    input.threadTs,
+    "Slack ephemeral thread message posting"
+  ) : void 0;
+  const response = await withSlackRetries(
+    () => getSlackClient().chat.postEphemeral({
+      channel: channelId,
+      user: userId,
+      text,
+      ...threadTs ? { thread_ts: threadTs } : {}
+    }),
+    3,
+    { action: "chat.postEphemeral" }
+  );
+  return {
+    messageTs: response.message_ts
+  };
+}
+async function uploadFilesToThread(input) {
+  const channelId = requireSlackConversationId(
+    input.channelId,
+    "Slack file upload"
+  );
+  const threadTs = requireSlackThreadTimestamp(
+    input.threadTs,
+    "Slack file upload"
+  );
+  if (input.files.length === 0) {
+    throw new Error("Slack file upload requires at least one file");
+  }
+  const fileUploads = input.files.map((file) => {
+    const filename = file.filename.trim();
+    if (!filename) {
+      throw new Error(
+        "Slack file upload requires every file to have a filename"
+      );
+    }
+    return {
+      file: file.data,
+      filename
+    };
+  });
+  await withSlackRetries(
+    () => getSlackClient().filesUploadV2({
+      channel_id: channelId,
+      thread_ts: threadTs,
+      file_uploads: fileUploads
+    }),
+    3,
+    { action: "filesUploadV2" }
+  );
+}
+async function addReactionToMessage(input) {
+  const channelId = requireSlackConversationId(
+    input.channelId,
+    "Slack reaction"
+  );
+  const timestamp = requireSlackMessageTimestamp(
+    input.timestamp,
+    "Slack reaction"
+  );
+  const emoji = normalizeSlackEmojiName(input.emoji);
+  if (!emoji) {
+    throw new Error("Slack reaction requires a valid emoji alias name");
+  }
+  try {
+    await withSlackRetries(
+      () => getSlackClient().reactions.add({
+        channel: channelId,
+        timestamp,
+        name: emoji
+      }),
+      3,
+      { action: "reactions.add" }
+    );
+  } catch (error) {
+    if (error instanceof SlackActionError && error.code === "already_reacted") {
+      return { ok: true };
+    }
+    throw error;
+  }
+  return { ok: true };
+}
+
 // src/chat/respond-helpers.ts
 var MAX_INLINE_ATTACHMENT_BASE64_CHARS = 12e4;
 function getSessionIdentifiers(context) {
@@ -1260,16 +1373,23 @@ function extractAssistantText(message) {
     (part) => part.type === "text" && typeof part.text === "string"
   ).map((part) => part.text).join("\n");
 }
-function hasCompletedAssistantTurn(messages) {
+function getTerminalAssistantMessages(messages) {
+  let lastToolResultIndex = -1;
   for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const message = messages[index];
-    if (!isAssistantMessage(message)) {
-      continue;
+    if (isToolResultMessage(messages[index])) {
+      lastToolResultIndex = index;
+      break;
     }
-    const stopReason = message.stopReason;
-    return typeof stopReason === "string" && stopReason !== "error" && extractAssistantText(message).trim().length > 0;
   }
-  return false;
+  return messages.slice(lastToolResultIndex + 1).filter(isAssistantMessage);
+}
+function hasCompletedAssistantTurn(messages) {
+  const message = getTerminalAssistantMessages(messages).at(-1);
+  if (!message) {
+    return false;
+  }
+  const stopReason = message.stopReason;
+  return typeof stopReason === "string" && stopReason !== "error" && extractAssistantText(message).trim().length > 0;
 }
 function upsertActiveSkill(activeSkills, next) {
   const existing = activeSkills.find((skill) => skill.name === next.name);
@@ -1335,17 +1455,17 @@ async function deliverPrivateMessage(input) {
   if (input.channelId) {
     try {
       if (isDmChannel(input.channelId)) {
-        await client2.chat.postMessage({
-          channel: input.channelId,
+        await postSlackMessage({
+          channelId: input.channelId,
           text: input.text,
-          ...input.threadTs ? { thread_ts: input.threadTs } : {}
+          threadTs: input.threadTs
         });
       } else {
-        await client2.chat.postEphemeral({
-          channel: input.channelId,
-          user: input.userId,
+        await postSlackEphemeralMessage({
+          channelId: input.channelId,
+          userId: input.userId,
           text: input.text,
-          ...input.threadTs ? { thread_ts: input.threadTs } : {}
+          threadTs: input.threadTs
         });
       }
       return "in_context";
@@ -1372,7 +1492,7 @@ async function deliverPrivateMessage(input) {
       );
       return false;
     }
-    await client2.chat.postMessage({ channel: dmChannelId, text: input.text });
+    await postSlackMessage({ channelId: dmChannelId, text: input.text });
     return "fallback_dm";
   } catch (error) {
     logWarn(
@@ -1992,6 +2112,7 @@ function coerceThreadArtifactsState(value) {
   }
   return {
     assistantContextChannelId: typeof artifacts.assistantContextChannelId === "string" ? artifacts.assistantContextChannelId : void 0,
+    assistantTitleSourceMessageId: typeof artifacts.assistantTitleSourceMessageId === "string" ? artifacts.assistantTitleSourceMessageId : void 0,
     lastCanvasId: typeof artifacts.lastCanvasId === "string" ? artifacts.lastCanvasId : void 0,
     lastCanvasUrl: typeof artifacts.lastCanvasUrl === "string" ? artifacts.lastCanvasUrl : void 0,
     recentCanvases,
@@ -2176,24 +2297,6 @@ function markTurnFailed(args) {
   });
   args.updateConversationStats(args.conversation);
 }
-function resolveReplyDelivery(args) {
-  const replyHasFiles = Boolean(
-    args.reply.files && args.reply.files.length > 0
-  );
-  const deliveryPlan = args.reply.deliveryPlan ?? {
-    mode: args.reply.deliveryMode ?? "thread",
-    postThreadText: (args.reply.deliveryMode ?? "thread") !== "channel_only",
-    attachFiles: replyHasFiles ? args.hasStreamedThreadReply ? "followup" : "inline" : "none"
-  };
-  let attachFiles = replyHasFiles ? deliveryPlan.attachFiles : "none";
-  if (attachFiles === "followup" && !args.hasStreamedThreadReply) {
-    attachFiles = "inline";
-  }
-  return {
-    shouldPostThreadReply: deliveryPlan.postThreadText,
-    attachFiles
-  };
-}
 
 // src/chat/runtime/turn-user-message.ts
 function getTurnUserMessage(conversation, sessionId) {
@@ -2211,6 +2314,15 @@ function getTurnUserMessage(conversation, sessionId) {
 function getTurnUserMessageId(conversation, sessionId) {
   return getTurnUserMessage(conversation, sessionId)?.id;
 }
+function getTurnUserReplyAttachmentContext(message) {
+  const inboundAttachmentCount = message?.meta?.attachmentCount ?? 0;
+  const imageAttachmentCount = message?.meta?.imageAttachmentCount ?? 0;
+  const imagesHydrated = message?.meta?.imagesHydrated === true;
+  return {
+    ...inboundAttachmentCount > 0 ? { inboundAttachmentCount } : {},
+    ...!imagesHydrated && imageAttachmentCount > 0 ? { omittedImageAttachmentCount: imageAttachmentCount } : {}
+  };
+}
 
 // src/chat/pi/client.ts
 import {
@@ -2631,7 +2743,7 @@ async function summarizeConversationChunk(messages, conversation, context, deps)
   }
   return transcript.slice(0, 2800);
 }
-async function generateThreadTitleWithDeps(userText, assistantText, deps) {
+async function generateThreadTitleWithDeps(sourceText, deps) {
   const result = await deps.completeText({
     modelId: botConfig.fastModelId,
     temperature: 0,
@@ -2639,17 +2751,41 @@ async function generateThreadTitleWithDeps(userText, assistantText, deps) {
       {
         role: "user",
         content: [
-          "Generate a concise 5-8 word title for this conversation. Reply with ONLY the title, no quotes or punctuation.",
+          "Generate a concise 5-8 word Slack conversation title from the first user message below.",
+          "Capture the user's main request.",
+          "Reply with ONLY the title, with no quotes or trailing punctuation.",
           "",
-          `User: ${userText.slice(0, 500)}`,
-          `Assistant: ${assistantText.slice(0, 500)}`
+          `First user message: ${sourceText.slice(0, 500)}`
         ].join("\n"),
         timestamp: Date.now()
       }
-    ]
+    ],
+    metadata: {
+      modelId: botConfig.fastModelId
+    }
   });
   return result.text.trim().slice(0, 60);
 }
+function getThreadTitleSourceMessage(conversation) {
+  let firstMessage;
+  for (const message of conversation.messages) {
+    if (!isHumanConversationMessage(message)) {
+      continue;
+    }
+    if (!firstMessage) {
+      firstMessage = message;
+      continue;
+    }
+    if (message.createdAtMs < firstMessage.createdAtMs) {
+      firstMessage = message;
+      continue;
+    }
+    if (message.createdAtMs === firstMessage.createdAtMs && message.id < firstMessage.id) {
+      firstMessage = message;
+    }
+  }
+  return firstMessage;
+}
 async function compactConversationIfNeededWithDeps(conversation, context, deps) {
   updateConversationStats(conversation);
   let estimatedTokens = conversation.stats.estimatedContextTokens;
@@ -2694,7 +2830,7 @@ async function compactConversationIfNeededWithDeps(conversation, context, deps)
 function createConversationMemoryService(deps) {
   return {
     compactConversationIfNeeded: async (conversation, context) => await compactConversationIfNeededWithDeps(conversation, context, deps),
-    generateThreadTitle: async (userText, assistantText) => await generateThreadTitleWithDeps(userText, assistantText, deps)
+    generateThreadTitle: async (sourceText) => await generateThreadTitleWithDeps(sourceText, deps)
   };
 }
 var defaultConversationMemoryService = createConversationMemoryService({
@@ -2799,33 +2935,448 @@ 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;
+
+// src/chat/runtime/status-format.ts
+var SLACK_STATUS_MAX_LENGTH = 50;
+function truncateWithEllipsis(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return `${text.slice(0, Math.max(1, maxLength - 3)).trimEnd()}...`;
 }
-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 {
+function truncateStatusText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return "";
+  }
+  return truncateWithEllipsis(trimmed, SLACK_STATUS_MAX_LENGTH);
+}
+function compactStatusPath(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  if (trimmed.length <= 80) {
+    return trimmed;
+  }
+  return `...${trimmed.slice(-77)}`;
+}
+function compactStatusText(value, maxLength = 80) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  return truncateWithEllipsis(trimmed, maxLength);
+}
+function readShellToken(command, startIndex) {
+  let index = startIndex;
+  while (index < command.length && /\s/.test(command[index] ?? "")) {
+    index += 1;
+  }
+  if (index >= command.length) {
+    return void 0;
+  }
+  let token = "";
+  let quote;
+  while (index < command.length) {
+    const char = command[index];
+    if (!char) {
+      break;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = void 0;
+        index += 1;
+        continue;
+      }
+      if (char === "\\" && quote === '"' && index + 1 < command.length) {
+        token += command[index + 1];
+        index += 2;
+        continue;
+      }
+      token += char;
+      index += 1;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      break;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      index += 1;
+      continue;
+    }
+    if (char === "\\" && index + 1 < command.length) {
+      token += command[index + 1];
+      index += 2;
+      continue;
+    }
+    token += char;
+    index += 1;
+  }
+  return { token, nextIndex: index };
+}
+function compactStatusCommand(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  let index = 0;
+  while (index < trimmed.length) {
+    const parsed = readShellToken(trimmed, index);
+    if (!parsed) {
+      return void 0;
+    }
+    index = parsed.nextIndex;
+    if (!parsed.token) {
+      continue;
+    }
+    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(parsed.token)) {
+      continue;
+    }
+    const normalized = parsed.token.replace(/[\\/]+$/g, "");
+    if (!normalized) {
+      return void 0;
+    }
+    const parts = normalized.split(/[\\/]/).filter((part) => part.length > 0);
+    const command = parts.length > 0 ? parts[parts.length - 1] : normalized;
+    return compactStatusText(command, 40);
+  }
+  return void 0;
+}
+function compactStatusFilename(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim().replace(/[\\/]+$/g, "");
+  if (!trimmed) {
+    return void 0;
+  }
+  const parts = trimmed.split(/[\\/]/).filter((part) => part.length > 0);
+  const filename = parts.length > 0 ? parts[parts.length - 1] : trimmed;
+  return compactStatusText(filename, 80);
+}
+function extractStatusUrlDomain(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  try {
+    const parsed = new URL(trimmed);
+    return parsed.hostname || void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/chat/slack/mrkdwn.ts
+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 renderSlackMrkdwn(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 normalizeSlackStatusText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return "";
+  }
+  return truncateStatusText(trimmed.replace(/(?:\.\s*)+$/, "").trim());
+}
+
+// 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]";
+function countSlackLines(text) {
+  if (!text) {
+    return 0;
+  }
+  return text.split("\n").length;
+}
+function fitsInlineBudget(text, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
+  return text.length <= maxChars && countSlackLines(text) <= maxLines;
+}
+function findSplitIndex(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text.length;
+  }
+  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 = renderSlackMrkdwn(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 getSlackContinuationBudget() {
+  return reserveInlineBudgetForSuffix(CONTINUED_MARKER);
+}
+function buildSlackOutputMessage(text, files) {
+  const normalized = renderSlackMrkdwn(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;
     }
   }
@@ -3169,6 +3720,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.",
@@ -3224,11 +3778,12 @@ function buildSystemPrompt(params) {
       [
         "Always produce output that follows this contract:",
         `<output format="slack-mrkdwn" max_inline_chars="${slackOutputPolicy.maxInlineChars}" max_inline_lines="${slackOutputPolicy.maxInlineLines}">`,
-        "- Use plain Slack-safe markdown (headings, bullets, short code blocks).",
+        "- Use Slack-friendly markdown, not full CommonMark. Prefer bold section labels over markdown headings, and use bullets and short code blocks when helpful.",
         "- 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.",
-        "- Avoid tables unless explicitly requested.",
+        "- 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 and markdown links like `[label](url)` unless explicitly requested. Prefer plain URLs or Slack-native entities when exact rendering matters.",
         "- End every turn with a final user-facing markdown response.",
         "</output>"
       ].join("\n")
@@ -5379,81 +5934,7 @@ function createSearchToolsTool(mcpToolManager, getActiveSkills) {
 // src/chat/tools/slack/channel-list-messages.ts
 import { Type as Type7 } from "@sinclair/typebox";
 
-// src/chat/slack/emoji.ts
-var SLACK_EMOJI_NAME_RE = /^(?:[a-z0-9_+-]+)(?:::(?:skin-tone-[2-6]))?$/;
-function normalizeSlackEmojiName(value) {
-  const trimmed = value.trim().toLowerCase();
-  if (!trimmed) {
-    return null;
-  }
-  const normalized = trimmed.startsWith(":") && trimmed.endsWith(":") ? trimmed.slice(1, -1) : trimmed;
-  return SLACK_EMOJI_NAME_RE.test(normalized) ? normalized : null;
-}
-
 // src/chat/slack/channel.ts
-async function postMessageToChannel(input) {
-  const client2 = getSlackClient();
-  const channelId = normalizeSlackConversationId(input.channelId);
-  if (!channelId) {
-    throw new Error(
-      "Slack channel message posting requires a valid channel ID"
-    );
-  }
-  const response = await withSlackRetries(
-    () => client2.chat.postMessage({
-      channel: channelId,
-      text: input.text,
-      mrkdwn: true
-    }),
-    3,
-    { action: "chat.postMessage" }
-  );
-  if (!response.ts) {
-    throw new Error("Slack channel message posted without ts");
-  }
-  let permalink;
-  try {
-    const permalinkResponse = await withSlackRetries(
-      () => client2.chat.getPermalink({
-        channel: channelId,
-        message_ts: response.ts
-      }),
-      3,
-      { action: "chat.getPermalink" }
-    );
-    permalink = permalinkResponse.permalink;
-  } catch {
-  }
-  return {
-    ts: response.ts,
-    permalink
-  };
-}
-async function addReactionToMessage(input) {
-  const client2 = getSlackClient();
-  const channelId = normalizeSlackConversationId(input.channelId);
-  if (!channelId) {
-    throw new Error("Slack reaction requires a valid channel ID");
-  }
-  const timestamp = input.timestamp.trim();
-  if (!timestamp) {
-    throw new Error("Slack reaction requires a target message timestamp");
-  }
-  const emoji = normalizeSlackEmojiName(input.emoji);
-  if (!emoji) {
-    throw new Error("Slack reaction requires a valid emoji alias name");
-  }
-  await withSlackRetries(
-    () => client2.reactions.add({
-      channel: channelId,
-      timestamp,
-      name: emoji
-    }),
-    3,
-    { action: "reactions.add" }
-  );
-  return { ok: true };
-}
 async function listChannelMessages(input) {
   const client2 = getSlackClient();
   const channelId = normalizeSlackConversationId(input.channelId);
@@ -5663,9 +6144,10 @@ function createSlackChannelPostMessageTool(context, state) {
           deduplicated: true
         };
       }
-      const posted = await postMessageToChannel({
+      const posted = await postSlackMessage({
         channelId: targetChannelId,
-        text
+        text,
+        includePermalink: true
       });
       const response = {
         ok: true,
@@ -7181,243 +7663,98 @@ function getSandboxErrorDetails(error) {
   return extractHttpErrorDetails(error, {
     attributePrefix: "app.sandbox.api_error",
     extraFields: [...SANDBOX_ERROR_FIELDS]
-  });
-}
-function findInErrorChain(error, predicate) {
-  const seen = /* @__PURE__ */ new Set();
-  let current = error;
-  while (current && !seen.has(current)) {
-    if (predicate(current)) {
-      return true;
-    }
-    seen.add(current);
-    current = typeof current === "object" ? current.cause : void 0;
-  }
-  return false;
-}
-function getFirstErrorMessage(error) {
-  const seen = /* @__PURE__ */ new Set();
-  let current = error;
-  while (current && !seen.has(current)) {
-    if (current instanceof Error) {
-      const message = current.message.trim();
-      if (message) {
-        return message;
-      }
-    }
-    seen.add(current);
-    current = typeof current === "object" ? current.cause : void 0;
-  }
-  return void 0;
-}
-function isAlreadyExistsError(error) {
-  const details = getSandboxErrorDetails(error);
-  return details.searchableText.includes("already exists") || details.searchableText.includes("file exists") || details.searchableText.includes("eexist");
-}
-function isSandboxUnavailableError(error) {
-  return findInErrorChain(error, (candidate) => {
-    const details = getSandboxErrorDetails(candidate);
-    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
-    return searchable.includes("sandbox_stopped") || searchable.includes("status=410") || searchable.includes("status code 410") || searchable.includes("no longer available");
-  });
-}
-function isSnapshottingError(error) {
-  return findInErrorChain(error, (candidate) => {
-    const details = getSandboxErrorDetails(candidate);
-    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
-    return searchable.includes("sandbox_snapshotting") || searchable.includes("creating a snapshot") || searchable.includes("stopped shortly");
-  });
-}
-function wrapSandboxSetupError(error) {
-  try {
-    const details = getSandboxErrorDetails(error);
-    if (details.summary) {
-      return new Error(`sandbox setup failed (${details.summary})`, {
-        cause: error
-      });
-    }
-  } catch {
-  }
-  let causeMessage;
-  try {
-    causeMessage = getFirstErrorMessage(error);
-  } catch (cause) {
-    causeMessage = cause instanceof Error ? cause.message : void 0;
-  }
-  if (causeMessage && causeMessage.trim() && causeMessage !== "sandbox setup failed") {
-    const oneLine = causeMessage.replace(/\s+/g, " ").trim();
-    return new Error(`sandbox setup failed (${oneLine})`, { cause: error });
-  }
-  return new Error("sandbox setup failed", { cause: error });
-}
-function throwSandboxOperationError(action, error, includeMissingPath = false) {
-  const details = getSandboxErrorDetails(error);
-  setSpanAttributes({
-    ...details.attributes,
-    ...includeMissingPath ? {
-      "app.sandbox.api_error.missing_path": details.searchableText.includes("no such file") || details.searchableText.includes("enoent")
-    } : {},
-    "app.sandbox.success": false
-  });
-  setSpanStatus("error");
-  throw new Error(
-    details.summary ? `${action} failed (${details.summary})` : `${action} failed`,
-    {
-      cause: error
-    }
-  );
-}
-
-// src/chat/sandbox/session.ts
-import { Sandbox } from "@vercel/sandbox";
-import { createBashTool as createBashTool2 } from "bash-tool";
-
-// src/chat/runtime/status-format.ts
-var SLACK_STATUS_MAX_LENGTH = 50;
-function truncateWithEllipsis(text, maxLength) {
-  if (text.length <= maxLength) {
-    return text;
-  }
-  return `${text.slice(0, Math.max(1, maxLength - 3)).trimEnd()}...`;
-}
-function truncateStatusText(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return "";
-  }
-  return truncateWithEllipsis(trimmed, SLACK_STATUS_MAX_LENGTH);
-}
-function compactStatusPath(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  if (trimmed.length <= 80) {
-    return trimmed;
-  }
-  return `...${trimmed.slice(-77)}`;
-}
-function compactStatusText(value, maxLength = 80) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  return truncateWithEllipsis(trimmed, maxLength);
-}
-function readShellToken(command, startIndex) {
-  let index = startIndex;
-  while (index < command.length && /\s/.test(command[index] ?? "")) {
-    index += 1;
-  }
-  if (index >= command.length) {
-    return void 0;
-  }
-  let token = "";
-  let quote;
-  while (index < command.length) {
-    const char = command[index];
-    if (!char) {
-      break;
-    }
-    if (quote) {
-      if (char === quote) {
-        quote = void 0;
-        index += 1;
-        continue;
-      }
-      if (char === "\\" && quote === '"' && index + 1 < command.length) {
-        token += command[index + 1];
-        index += 2;
-        continue;
-      }
-      token += char;
-      index += 1;
-      continue;
-    }
-    if (/\s/.test(char)) {
-      break;
-    }
-    if (char === '"' || char === "'") {
-      quote = char;
-      index += 1;
-      continue;
-    }
-    if (char === "\\" && index + 1 < command.length) {
-      token += command[index + 1];
-      index += 2;
-      continue;
+  });
+}
+function findInErrorChain(error, predicate) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && !seen.has(current)) {
+    if (predicate(current)) {
+      return true;
     }
-    token += char;
-    index += 1;
+    seen.add(current);
+    current = typeof current === "object" ? current.cause : void 0;
   }
-  return { token, nextIndex: index };
+  return false;
 }
-function compactStatusCommand(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  let index = 0;
-  while (index < trimmed.length) {
-    const parsed = readShellToken(trimmed, index);
-    if (!parsed) {
-      return void 0;
-    }
-    index = parsed.nextIndex;
-    if (!parsed.token) {
-      continue;
-    }
-    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(parsed.token)) {
-      continue;
-    }
-    const normalized = parsed.token.replace(/[\\/]+$/g, "");
-    if (!normalized) {
-      return void 0;
+function getFirstErrorMessage(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current && !seen.has(current)) {
+    if (current instanceof Error) {
+      const message = current.message.trim();
+      if (message) {
+        return message;
+      }
     }
-    const parts = normalized.split(/[\\/]/).filter((part) => part.length > 0);
-    const command = parts.length > 0 ? parts[parts.length - 1] : normalized;
-    return compactStatusText(command, 40);
+    seen.add(current);
+    current = typeof current === "object" ? current.cause : void 0;
   }
   return void 0;
 }
-function compactStatusFilename(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim().replace(/[\\/]+$/g, "");
-  if (!trimmed) {
-    return void 0;
-  }
-  const parts = trimmed.split(/[\\/]/).filter((part) => part.length > 0);
-  const filename = parts.length > 0 ? parts[parts.length - 1] : trimmed;
-  return compactStatusText(filename, 80);
+function isAlreadyExistsError(error) {
+  const details = getSandboxErrorDetails(error);
+  return details.searchableText.includes("already exists") || details.searchableText.includes("file exists") || details.searchableText.includes("eexist");
 }
-function extractStatusUrlDomain(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
-  }
+function isSandboxUnavailableError(error) {
+  return findInErrorChain(error, (candidate) => {
+    const details = getSandboxErrorDetails(candidate);
+    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
+    return searchable.includes("sandbox_stopped") || searchable.includes("status=410") || searchable.includes("status code 410") || searchable.includes("no longer available");
+  });
+}
+function isSnapshottingError(error) {
+  return findInErrorChain(error, (candidate) => {
+    const details = getSandboxErrorDetails(candidate);
+    const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
+    return searchable.includes("sandbox_snapshotting") || searchable.includes("creating a snapshot") || searchable.includes("stopped shortly");
+  });
+}
+function wrapSandboxSetupError(error) {
   try {
-    const parsed = new URL(trimmed);
-    return parsed.hostname || void 0;
+    const details = getSandboxErrorDetails(error);
+    if (details.summary) {
+      return new Error(`sandbox setup failed (${details.summary})`, {
+        cause: error
+      });
+    }
   } catch {
-    return void 0;
   }
+  let causeMessage;
+  try {
+    causeMessage = getFirstErrorMessage(error);
+  } catch (cause) {
+    causeMessage = cause instanceof Error ? cause.message : void 0;
+  }
+  if (causeMessage && causeMessage.trim() && causeMessage !== "sandbox setup failed") {
+    const oneLine = causeMessage.replace(/\s+/g, " ").trim();
+    return new Error(`sandbox setup failed (${oneLine})`, { cause: error });
+  }
+  return new Error("sandbox setup failed", { cause: error });
+}
+function throwSandboxOperationError(action, error, includeMissingPath = false) {
+  const details = getSandboxErrorDetails(error);
+  setSpanAttributes({
+    ...details.attributes,
+    ...includeMissingPath ? {
+      "app.sandbox.api_error.missing_path": details.searchableText.includes("no such file") || details.searchableText.includes("enoent")
+    } : {},
+    "app.sandbox.success": false
+  });
+  setSpanStatus("error");
+  throw new Error(
+    details.summary ? `${action} failed (${details.summary})` : `${action} failed`,
+    {
+      cause: error
+    }
+  );
 }
 
-// src/chat/runtime/assistant-status.ts
+// src/chat/sandbox/session.ts
+import { Sandbox } from "@vercel/sandbox";
+import { createBashTool as createBashTool2 } from "bash-tool";
+
+// src/chat/slack/assistant-thread/status-render.ts
 var STATUS_PATTERNS = {
   thinking: {
     defaultContext: "\u2026",
@@ -7471,17 +7808,10 @@ var STATUS_PATTERNS = {
 function makeAssistantStatus(kind, context) {
   return { kind, ...context ? { context } : {} };
 }
-function normalizeAssistantStatusText(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return "";
-  }
-  return truncateStatusText(trimmed.replace(/(?:\.\s*)+$/, "").trim());
-}
-function buildAssistantStatusPresentation(args) {
+function renderAssistantStatus(args) {
   const random = args.random ?? Math.random;
   const pattern = STATUS_PATTERNS[args.status.kind];
-  const context = normalizeAssistantStatusText(args.status.context ?? "") || pattern.defaultContext;
+  const context = normalizeSlackStatusText(args.status.context ?? "") || pattern.defaultContext;
   const index = Math.floor(random() * pattern.variants.length);
   const verb = pattern.variants[index] ?? pattern.variants[0];
   const visible = truncateStatusText(`${verb} ${context}`);
@@ -7493,46 +7823,274 @@ function buildAssistantStatusPresentation(args) {
     suggestions: Array.from(/* @__PURE__ */ new Set([visible, hint]))
   };
 }
-function createSlackAdapterAssistantStatusTransport(args) {
-  return {
-    async setStatus(channelId, threadTs, status, suggestions) {
-      try {
-        await args.getSlackAdapter().setAssistantStatus(channelId, threadTs, status, suggestions);
-      } catch (error) {
-        logAssistantStatusFailure(status, error);
-      }
+
+// src/chat/slack/assistant-thread/status-scheduler.ts
+var STATUS_UPDATE_DEBOUNCE_MS = 1e3;
+var STATUS_MIN_VISIBLE_MS = 1200;
+var STATUS_ROTATION_INTERVAL_MS = 3e4;
+function createAssistantStatusScheduler(args) {
+  const now = args.now ?? (() => Date.now());
+  const setTimer = args.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+  const clearTimer = args.clearTimer ?? ((timer) => clearTimeout(timer));
+  const random = args.random ?? Math.random;
+  let active = false;
+  let currentKey = "";
+  let currentStatus = makeAssistantStatus("thinking");
+  let currentVisibleStatus = "";
+  let lastStatusAt = 0;
+  let pendingStatus = null;
+  let pendingKey = "";
+  let pendingTimer = null;
+  let rotationTimer = null;
+  let inflightStatusUpdate = Promise.resolve();
+  const enqueueStatusUpdate = (task) => {
+    const request = inflightStatusUpdate.catch(() => void 0).then(async () => {
+      await task();
+    });
+    inflightStatusUpdate = request.catch(() => void 0);
+    return request;
+  };
+  const scheduleRotation = () => {
+    if (rotationTimer) {
+      clearTimer(rotationTimer);
+      rotationTimer = null;
+    }
+    if (!active || !currentVisibleStatus) {
+      return;
+    }
+    rotationTimer = setTimer(() => {
+      rotationTimer = null;
+      if (!active || !currentVisibleStatus) {
+        return;
+      }
+      void postRenderedStatus(currentStatus);
+    }, STATUS_ROTATION_INTERVAL_MS);
+  };
+  const postStatus = async (text, suggestions) => {
+    if (!text && !currentVisibleStatus) {
+      return;
+    }
+    currentVisibleStatus = text;
+    lastStatusAt = now();
+    scheduleRotation();
+    await enqueueStatusUpdate(async () => {
+      await args.sendStatus(text, suggestions);
+    });
+  };
+  const postRenderedStatus = async (status) => {
+    const presentation = renderAssistantStatus({
+      status,
+      random
+    });
+    currentStatus = status;
+    currentKey = presentation.key;
+    await postStatus(presentation.visible, presentation.suggestions);
+  };
+  const clearPending = () => {
+    if (pendingTimer) {
+      clearTimer(pendingTimer);
+      pendingTimer = null;
+    }
+    pendingStatus = null;
+    pendingKey = "";
+  };
+  const flushPending = async () => {
+    if (!active || !pendingStatus) {
+      clearPending();
+      return;
+    }
+    const next = pendingStatus;
+    clearPending();
+    const nextPresentation = renderAssistantStatus({
+      status: next,
+      random
+    });
+    if (nextPresentation.key !== currentKey) {
+      await postRenderedStatus(next);
+    }
+  };
+  return {
+    start() {
+      active = true;
+      clearPending();
+      currentStatus = makeAssistantStatus("thinking");
+      currentKey = "";
+      void postRenderedStatus(currentStatus);
+    },
+    async stop() {
+      active = false;
+      clearPending();
+      if (rotationTimer) {
+        clearTimer(rotationTimer);
+        rotationTimer = null;
+      }
+      currentKey = "";
+      await postStatus("");
+    },
+    update(status) {
+      if (!active) {
+        return;
+      }
+      const presentation = renderAssistantStatus({
+        status,
+        random
+      });
+      if (!presentation.visible) {
+        return;
+      }
+      if (presentation.key === currentKey || presentation.key === pendingKey) {
+        return;
+      }
+      const elapsed = now() - lastStatusAt;
+      const waitMs = Math.max(
+        STATUS_UPDATE_DEBOUNCE_MS - elapsed,
+        STATUS_MIN_VISIBLE_MS - elapsed,
+        0
+      );
+      if (waitMs <= 0) {
+        clearPending();
+        void postRenderedStatus(status);
+        return;
+      }
+      pendingStatus = status;
+      pendingKey = presentation.key;
+      if (pendingTimer) {
+        return;
+      }
+      pendingTimer = setTimer(
+        () => {
+          pendingTimer = null;
+          void flushPending();
+        },
+        Math.max(1, waitMs)
+      );
+    }
+  };
+}
+
+// src/chat/slack/assistant-thread/status-send.ts
+function createSlackAdapterStatusSender(args) {
+  const adapter = args.getSlackAdapter();
+  const boundToken = getSlackAdapterRequestToken(adapter);
+  return async (text, suggestions) => {
+    const channelId = args.channelId;
+    const threadTs = args.threadTs;
+    if (!channelId || !threadTs) {
+      return;
+    }
+    const normalizedChannelId = normalizeSlackConversationId(channelId);
+    if (!normalizedChannelId) {
+      return;
+    }
+    try {
+      await runWithBoundSlackToken(
+        adapter,
+        boundToken,
+        () => adapter.setAssistantStatus(
+          normalizedChannelId,
+          threadTs,
+          text,
+          suggestions
+        )
+      );
+    } catch (error) {
+      logAssistantStatusFailure({
+        status: text,
+        error,
+        channelId,
+        normalizedChannelId,
+        threadTs
+      });
     }
   };
 }
-function createSlackWebApiAssistantStatusTransport(args) {
-  const getClient2 = args?.getSlackClient ?? getSlackClient;
-  return {
-    async setStatus(channelId, threadTs, status, suggestions) {
-      try {
-        await getClient2().assistant.threads.setStatus({
-          channel_id: channelId,
-          thread_ts: threadTs,
-          status,
-          ...suggestions ? { loading_messages: suggestions } : {}
-        });
-      } catch (error) {
-        logAssistantStatusFailure(status, error);
-      }
+function createSlackWebApiStatusSender(args) {
+  const getClient2 = args.getSlackClient ?? getSlackClient;
+  return async (text, suggestions) => {
+    const channelId = args.channelId;
+    const threadTs = args.threadTs;
+    if (!channelId || !threadTs) {
+      return;
+    }
+    const normalizedChannelId = normalizeSlackConversationId(channelId);
+    if (!normalizedChannelId) {
+      return;
+    }
+    try {
+      await getClient2().assistant.threads.setStatus({
+        channel_id: normalizedChannelId,
+        thread_ts: threadTs,
+        status: text,
+        ...suggestions ? { loading_messages: suggestions } : {}
+      });
+    } catch (error) {
+      logAssistantStatusFailure({
+        status: text,
+        error,
+        channelId,
+        normalizedChannelId,
+        threadTs
+      });
     }
   };
 }
-function logAssistantStatusFailure(status, error) {
+function getSlackAdapterRequestToken(adapter) {
+  const token = adapter.requestContext?.getStore()?.token;
+  if (typeof token !== "string") {
+    return void 0;
+  }
+  const trimmed = token.trim();
+  return trimmed || void 0;
+}
+async function runWithBoundSlackToken(adapter, token, task) {
+  if (!token) {
+    return await task();
+  }
+  return await adapter.withBotToken(token, task);
+}
+function logAssistantStatusFailure(args) {
   logWarn(
     "assistant_status_update_failed",
     {},
     {
-      "app.slack.status_text": status || "(clear)",
-      "error.message": error instanceof Error ? error.message : String(error)
+      "app.slack.status_text": args.status || "(clear)",
+      "app.slack.channel_id_raw": args.channelId,
+      "app.slack.channel_id": args.normalizedChannelId,
+      "app.slack.thread_ts": args.threadTs,
+      "error.message": args.error instanceof Error ? args.error.message : String(args.error)
     },
-    "Failed to update assistant status"
+    `Failed to update assistant status channel=${args.normalizedChannelId} raw=${args.channelId} thread=${args.threadTs}`
   );
 }
 
+// src/chat/slack/assistant-thread/status.ts
+function createSlackAdapterAssistantStatusSession(args) {
+  return createAssistantStatusScheduler({
+    sendStatus: createSlackAdapterStatusSender({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      getSlackAdapter: args.getSlackAdapter
+    }),
+    now: args.now,
+    setTimer: args.setTimer,
+    clearTimer: args.clearTimer,
+    random: args.random
+  });
+}
+function createSlackWebApiAssistantStatusSession(args) {
+  return createAssistantStatusScheduler({
+    sendStatus: createSlackWebApiStatusSender({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      getSlackClient: args.getSlackClient
+    }),
+    now: args.now,
+    setTimer: args.setTimer,
+    clearTimer: args.clearTimer,
+    random: args.random
+  });
+}
+
 // src/chat/sandbox/skill-sync.ts
 import fs3 from "fs/promises";
 import path5 from "path";
@@ -7654,7 +8212,11 @@ function pickFields(record, csv) {
 }
 
 function outputJson(value) {
-  process.stdout.write(JSON.stringify(value, null, 2) + "\\n");
+  fs.writeFileSync(process.stdout.fd, JSON.stringify(value, null, 2) + "\\n");
+}
+
+function outputText(value) {
+  fs.writeFileSync(process.stdout.fd, value);
 }
 
 function fallbackToRealGh() {
@@ -7670,12 +8232,12 @@ function fallbackToRealGh() {
 }
 
 if (args.length === 0 || args[0] === "--version" || args[0] === "version") {
-  process.stdout.write("gh version 2.0.0 (junior-eval)\\n");
+  outputText("gh version 2.0.0 (junior-eval)\\n");
   process.exit(0);
 }
 
 if (args[0] === "auth" && args[1] === "status") {
-  process.stdout.write("github.com\\n  \u2713 Logged in to github.com as junior-eval\\n");
+  outputText("github.com\\n  \u2713 Logged in to github.com as junior-eval\\n");
   process.exit(0);
 }
 
@@ -7699,7 +8261,7 @@ if (args[0] === "repo" && args[1] === "view") {
   if (jsonFields) {
     outputJson(pickFields(record, jsonFields));
   } else {
-    process.stdout.write(record.url + "\\n");
+    outputText(record.url + "\\n");
   }
   process.exit(0);
 }
@@ -7751,7 +8313,7 @@ if (args[0] === "issue") {
     if (jsonFields) {
       outputJson(pickFields(record, jsonFields));
     } else {
-      process.stdout.write(record.url + "\\n");
+      outputText(record.url + "\\n");
     }
     process.exit(0);
   }
@@ -7767,7 +8329,7 @@ if (args[0] === "issue") {
     if (jsonFields) {
       outputJson(pickFields(record, jsonFields));
     } else {
-      process.stdout.write(record.url + "\\n");
+      outputText(record.url + "\\n");
     }
     process.exit(0);
   }
@@ -7784,7 +8346,7 @@ if (args[0] === "issue") {
   }
 
   if (subcommand === "comment") {
-    process.stdout.write(record.url + "#issuecomment-1\\n");
+    outputText(record.url + "#issuecomment-1\\n");
     process.exit(0);
   }
 
@@ -8847,13 +9409,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);
@@ -9115,7 +9677,6 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
 // 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"];
-var REACTION_ALIAS_PREFIX_RE = /^:[a-z0-9_+-]*$/i;
 function normalizeReactionAckText(text) {
   return text.trim().toLowerCase().replace(/[!.]+$/g, "");
 }
@@ -9132,24 +9693,11 @@ function isRedundantReactionAckText(text) {
     normalized
   );
 }
-function isPotentialRedundantReactionAckText(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return true;
-  }
-  if (REACTION_ONLY_ACK_RE.test(trimmed) || REACTION_ALIAS_PREFIX_RE.test(trimmed)) {
-    return true;
-  }
-  const normalized = normalizeReactionAckText(text);
-  return REDUNDANT_REACTION_ACK_TEXT.some(
-    (candidate) => candidate.startsWith(normalized)
-  );
-}
 function buildReplyDeliveryPlan(args) {
   const mode = args.explicitChannelPostIntent && args.channelPostPerformed ? "channel_only" : "thread";
   let attachFiles = "none";
   if (args.hasFiles && mode === "thread") {
-    attachFiles = args.streamingThreadReply ? "followup" : "inline";
+    attachFiles = "inline";
   }
   return {
     mode,
@@ -9182,6 +9730,10 @@ function sentenceClaimsAttachment(sentence) {
   if (!hasAttachmentNoun) {
     return false;
   }
+  const hasNegativeAttachmentPhrase = /\bno (?:screenshot|image|file|attachment)\b/i.test(sentence) || /\b(?:isn['’]t|is not|wasn['’]t|was not)\s+attached\b/i.test(sentence) || /\bwithout (?:an? )?(?:screenshot|image|file|attachment)\b/i.test(sentence);
+  if (hasNegativeAttachmentPhrase) {
+    return false;
+  }
   const hasPositiveAttachmentVerb = /\b(attached|shared|uploaded|included)\b/i.test(sentence);
   const hasDeicticSharePhrase = /\bhere(?:'s| is)\b/i.test(sentence);
   return hasPositiveAttachmentVerb || hasDeicticSharePhrase;
@@ -9210,7 +9762,6 @@ function buildTurnResult(input) {
     toolCalls,
     sandboxId,
     sandboxDependencyProfileHash,
-    hasTextDeltaCallback,
     shouldTrace,
     spanContext,
     correlation,
@@ -9218,7 +9769,8 @@ function buildTurnResult(input) {
   } = input;
   const toolResults = newMessages.filter(isToolResultMessage);
   const assistantMessages = newMessages.filter(isAssistantMessage);
-  const primaryText = assistantMessages.map((message) => extractAssistantText(message)).join("\n\n").trim();
+  const terminalAssistantMessages = getTerminalAssistantMessages(newMessages);
+  const primaryText = terminalAssistantMessages.map((message) => extractAssistantText(message)).join("\n\n").trim();
   const oauthStartedMessage = extractOAuthStartedMessageFromToolResults(toolResults);
   const toolErrorCount = toolResults.filter((result) => result.isError).length;
   const explicitChannelPostIntent = isExplicitChannelPostIntent(userInput);
@@ -9231,8 +9783,7 @@ function buildTurnResult(input) {
   const deliveryPlan = buildReplyDeliveryPlan({
     explicitChannelPostIntent,
     channelPostPerformed,
-    hasFiles: replyFiles.length > 0,
-    streamingThreadReply: hasTextDeltaCallback
+    hasFiles: replyFiles.length > 0
   });
   const deliveryMode = deliveryPlan.mode;
   if (!primaryText && !oauthStartedMessage) {
@@ -9254,7 +9805,7 @@ function buildTurnResult(input) {
       "Model returned empty text response"
     );
   }
-  const lastAssistant = assistantMessages.at(-1);
+  const lastAssistant = terminalAssistantMessages.at(-1);
   const stopReason = typeof lastAssistant?.stopReason === "string" ? lastAssistant.stopReason : void 0;
   const errorMessage = typeof lastAssistant?.errorMessage === "string" ? lastAssistant.errorMessage : void 0;
   const usedPrimaryText = Boolean(primaryText);
@@ -9580,6 +10131,16 @@ function createMcpAuthOrchestration(deps, abortAgent) {
 
 // src/chat/respond.ts
 var startupDiscoveryLogged = false;
+function buildOmittedImageAttachmentNotice(count) {
+  return [
+    "<omitted-image-attachments>",
+    `count: ${count}`,
+    "Slack included image attachments with this turn, but this runtime cannot analyze images because no vision model is configured.",
+    "Do not claim that no image was attached.",
+    "If the user asks about image contents, explain that image analysis is unavailable in this runtime and continue with any text or non-image files that are still available.",
+    "</omitted-image-attachments>"
+  ].join("\n");
+}
 function mcpToolsToDefinitions(mcpTools) {
   const defs = {};
   for (const tool2 of mcpTools) {
@@ -9651,6 +10212,8 @@ async function generateAssistantReply(messageText, context = {}) {
     let configurationValues;
     const userInput = messageText;
     if (shouldTrace) {
+      const inboundAttachmentCount = context.inboundAttachmentCount ?? 0;
+      const promptAttachmentCount = context.userAttachments?.length ?? 0;
       logInfo(
         "agent_message_in",
         spanContext,
@@ -9658,7 +10221,10 @@ async function generateAssistantReply(messageText, context = {}) {
           "app.message.kind": "user_inbound",
           "app.message.length": userInput.length,
           "app.message.input": summarizeMessageText(userInput),
-          "app.message.attachment_count": context.userAttachments?.length ?? 0,
+          // Log both counts so image uploads filtered by vision/config do not
+          // look indistinguishable from Slack ingress dropping attachments.
+          "app.message.attachment_count": inboundAttachmentCount,
+          "app.message.prompt_attachment_count": promptAttachmentCount,
           "messaging.message.id": context.correlation?.messageTs ?? ""
         },
         "Agent message received"
@@ -9911,6 +10477,13 @@ async function generateAssistantReply(messageText, context = {}) {
       threadParticipants: context.threadParticipants
     });
     const userContentParts = [{ type: "text", text: userTurnText }];
+    const omittedImageAttachmentCount = context.omittedImageAttachmentCount ?? 0;
+    if (omittedImageAttachmentCount > 0) {
+      userContentParts.push({
+        type: "text",
+        text: buildOmittedImageAttachmentNotice(omittedImageAttachmentCount)
+      });
+    }
     for (const attachment of context.userAttachments ?? []) {
       if (attachment.promptText) {
         userContentParts.push({
@@ -9954,6 +10527,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(
@@ -9994,6 +10578,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;
         }
@@ -10031,7 +10625,12 @@ async function generateAssistantReply(messageText, context = {}) {
         spanContext,
         async () => {
           let promptResult;
-          const promptPromise = resumedFromCheckpoint ? agent.continue() : agent.prompt({
+          const promptPromise = resumedFromCheckpoint ? (
+            // Checkpoint resumes continue from the persisted Pi message
+            // state. Any reconstructed replyContext only matters when the
+            // turn parked before the initial user prompt was recorded.
+            agent.continue()
+          ) : agent.prompt({
             role: "user",
             content: userContentParts,
             timestamp: Date.now()
@@ -10126,7 +10725,6 @@ async function generateAssistantReply(messageText, context = {}) {
       sandboxId: currentSandboxExecutor.getSandboxId(),
       sandboxDependencyProfileHash: currentSandboxExecutor.getDependencyProfileHash(),
       generatedFileCount: generatedFiles.length,
-      hasTextDeltaCallback: Boolean(context.onTextDelta),
       shouldTrace,
       spanContext,
       correlation: context.correlation,
@@ -10239,153 +10837,122 @@ async function generateAssistantReply(messageText, context = {}) {
   }
 }
 
-// src/chat/runtime/progress-reporter.ts
-var STATUS_UPDATE_DEBOUNCE_MS = 1e3;
-var STATUS_MIN_VISIBLE_MS = 1200;
-var STATUS_ROTATION_INTERVAL_MS = 3e4;
-function createProgressReporter(args) {
-  const now = args.now ?? (() => Date.now());
-  const setTimer = args.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
-  const clearTimer = args.clearTimer ?? ((timer) => clearTimeout(timer));
-  const random = args.random ?? Math.random;
-  let active = false;
-  let currentKey = "";
-  let currentStatus = makeAssistantStatus("thinking");
-  let currentVisibleStatus = "";
-  let lastStatusAt = 0;
-  let pendingStatus = null;
-  let pendingKey = "";
-  let pendingTimer = null;
-  let rotationTimer = null;
-  let inflightStatusUpdate = Promise.resolve();
-  const scheduleRotation = () => {
-    if (rotationTimer) {
-      clearTimer(rotationTimer);
-      rotationTimer = null;
-    }
-    if (!active || !currentVisibleStatus) {
-      return;
-    }
-    rotationTimer = setTimer(() => {
-      rotationTimer = null;
-      if (!active || !currentVisibleStatus) {
-        return;
-      }
-      void postRenderedStatus(currentStatus);
-    }, STATUS_ROTATION_INTERVAL_MS);
-  };
-  const postStatus = async (text, suggestions) => {
-    const channelId = args.channelId;
-    const threadTs = args.threadTs;
-    if (!channelId || !threadTs) {
-      return;
-    }
-    if (!text && !currentVisibleStatus) {
-      return;
-    }
-    currentVisibleStatus = text;
-    lastStatusAt = now();
-    scheduleRotation();
-    const previous = inflightStatusUpdate;
-    const request = (async () => {
-      await previous;
-      await args.transport.setStatus(channelId, threadTs, text, suggestions);
-    })();
-    inflightStatusUpdate = request;
-    await request;
-  };
-  const postRenderedStatus = async (status) => {
-    const presentation = buildAssistantStatusPresentation({
-      status,
-      random
-    });
-    currentStatus = status;
-    currentKey = presentation.key;
-    await postStatus(presentation.visible, presentation.suggestions);
-  };
-  const clearPending = () => {
-    if (pendingTimer) {
-      clearTimer(pendingTimer);
-      pendingTimer = null;
-    }
-    pendingStatus = null;
-    pendingKey = "";
-  };
-  const flushPending = async () => {
-    if (!active || !pendingStatus) {
-      clearPending();
-      return;
-    }
-    const next = pendingStatus;
-    clearPending();
-    const nextPresentation = buildAssistantStatusPresentation({
-      status: next,
-      random
-    });
-    if (nextPresentation.key !== currentKey) {
-      await postRenderedStatus(next);
-    }
+// src/chat/slack/reply.ts
+import { Buffer as Buffer2 } from "buffer";
+function isInterruptedVisibleReply(reply) {
+  return reply.diagnostics.outcome === "provider_error";
+}
+function resolveReplyDelivery(reply) {
+  const replyHasFiles = Boolean(reply.files && reply.files.length > 0);
+  const deliveryPlan = reply.deliveryPlan ?? {
+    mode: reply.deliveryMode ?? "thread",
+    postThreadText: (reply.deliveryMode ?? "thread") !== "channel_only",
+    attachFiles: replyHasFiles ? "inline" : "none"
   };
   return {
-    async start() {
-      active = true;
-      clearPending();
-      currentStatus = makeAssistantStatus("thinking");
-      currentKey = "";
-      void postRenderedStatus(currentStatus);
-    },
-    async stop() {
-      active = false;
-      clearPending();
-      if (rotationTimer) {
-        clearTimer(rotationTimer);
-        rotationTimer = null;
-      }
-      currentKey = "";
-      await postStatus("");
-    },
-    async setStatus(status) {
-      if (!active) {
-        return;
-      }
-      const presentation = buildAssistantStatusPresentation({
-        status,
-        random
-      });
-      if (!presentation.visible) {
-        return;
-      }
-      if (presentation.key === currentKey || presentation.key === pendingKey) {
-        return;
-      }
-      const elapsed = now() - lastStatusAt;
-      const waitMs = Math.max(
-        STATUS_UPDATE_DEBOUNCE_MS - elapsed,
-        STATUS_MIN_VISIBLE_MS - elapsed,
-        0
-      );
-      if (waitMs <= 0) {
-        clearPending();
-        void postRenderedStatus(status);
-        return;
-      }
-      pendingStatus = status;
-      pendingKey = presentation.key;
-      if (pendingTimer) {
-        return;
+    shouldPostThreadReply: deliveryPlan.postThreadText,
+    attachFiles: replyHasFiles && deliveryPlan.attachFiles !== "none" ? "inline" : "none"
+  };
+}
+function buildReplyText(text) {
+  const message = buildSlackOutputMessage(text);
+  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 "";
+}
+function buildTextPosts(args) {
+  const chunks = splitSlackReplyText(args.text, {
+    interrupted: args.interrupted
+  });
+  return chunks.map((chunk, index) => ({
+    text: chunk,
+    ...index === 0 && args.firstFiles ? { files: args.firstFiles } : {},
+    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());
       }
-      pendingTimer = setTimer(
-        () => {
-          pendingTimer = null;
-          void flushPending();
-        },
-        Math.max(1, waitMs)
-      );
+      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 planSlackReplyPosts(args) {
+  const replyFiles = args.reply.files && args.reply.files.length > 0 ? args.reply.files : void 0;
+  const { shouldPostThreadReply, attachFiles } = resolveReplyDelivery(
+    args.reply
+  );
+  const interrupted = isInterruptedVisibleReply(args.reply);
+  const posts = [];
+  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({
+      files: replyFiles,
+      stage: "thread_reply",
+      text: ""
+    });
+  } else if (shouldPostThreadReply && textPosts.length === 0) {
+    posts.push({
+      text: buildReplyText(args.reply.text),
+      stage: "thread_reply"
+    });
+  }
+  if (attachFiles === "followup" && replyFiles) {
+    posts.push({
+      files: replyFiles,
+      stage: "thread_reply_files_followup",
+      text: ""
+    });
+  }
+  return posts;
+}
+async function postSlackApiReplyPosts(args) {
+  for (const post of args.posts) {
+    if (post.text.trim().length > 0) {
+      await args.postMessage(args.channelId, args.threadTs, post.text);
     }
-  };
+    if (!post.files?.length) {
+      continue;
+    }
+    await uploadReplyFilesBestEffort({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      files: post.files
+    });
+  }
 }
 
-// src/handlers/oauth-resume.ts
+// src/chat/slack/resume.ts
 function resolveReplyTimeoutMs(explicitTimeoutMs) {
   if (typeof explicitTimeoutMs === "number" && explicitTimeoutMs > 0) {
     return explicitTimeoutMs;
@@ -10397,16 +10964,16 @@ function resolveReplyTimeoutMs(explicitTimeoutMs) {
   const parsed = Number.parseInt(raw, 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
 }
-async function postSlackMessage(channelId, threadTs, text) {
-  await getSlackClient().chat.postMessage({
-    channel: channelId,
-    thread_ts: threadTs,
+async function postSlackMessage2(channelId, threadTs, text) {
+  await postSlackMessage({
+    channelId,
+    threadTs,
     text
   });
 }
 async function postSlackMessageBestEffort(channelId, threadTs, text) {
   try {
-    await postSlackMessage(channelId, threadTs, text);
+    await postSlackMessage2(channelId, threadTs, text);
   } catch {
   }
 }
@@ -10445,7 +11012,7 @@ var ResumeTurnBusyError = class extends Error {
 function getDefaultLockKey(channelId, threadTs) {
   return `slack:${channelId}:${threadTs}`;
 }
-function createResumeReplyContext(args, progress) {
+function createResumeReplyContext(args, statusSession) {
   const replyContext = args.replyContext ?? {};
   const threadId = args.lockKey ?? getDefaultLockKey(args.channelId, args.threadTs);
   const persistedChannelConfiguration = replyContext.channelConfiguration ?? (replyContext.configuration ? createReadOnlyConfigService(replyContext.configuration) : void 0);
@@ -10474,9 +11041,9 @@ function createResumeReplyContext(args, progress) {
       await persistThreadStateById(threadId, { artifacts });
       await replyContext.onArtifactStateUpdated?.(artifacts);
     },
-    onStatus: async (status) => {
-      await progress.setStatus(status);
-      await replyContext.onStatus?.(status);
+    onStatus: async (nextStatus) => {
+      statusSession.update(nextStatus);
+      await replyContext.onStatus?.(nextStatus);
     }
   };
 }
@@ -10495,10 +11062,9 @@ async function resumeSlackTurn(args) {
   if (!lock) {
     throw new ResumeTurnBusyError(lockKey);
   }
-  const progress = createProgressReporter({
+  const status = createSlackWebApiAssistantStatusSession({
     channelId: args.channelId,
-    threadTs: args.threadTs,
-    transport: createSlackWebApiAssistantStatusTransport()
+    threadTs: args.threadTs
   });
   let deferredPauseHandler;
   let deferredFailureHandler;
@@ -10510,9 +11076,9 @@ async function resumeSlackTurn(args) {
         args.initialText
       );
     }
-    await progress.start();
+    status.start();
     const generateReply = args.generateReply ?? generateAssistantReply;
-    const replyContext = createResumeReplyContext(args, progress);
+    const replyContext = createResumeReplyContext(args, status);
     const replyPromise = generateReply(args.messageText, {
       ...replyContext
     });
@@ -10530,15 +11096,16 @@ async function resumeSlackTurn(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 status.stop();
+    await postSlackApiReplyPosts({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      posts: planSlackReplyPosts({ reply }),
+      postMessage: postSlackMessage2
+    });
     await args.onSuccess?.(reply);
   } catch (error) {
-    await progress.stop();
+    await status.stop();
     if (isRetryableTurnError(error, "mcp_auth_resume") && args.onAuthPause) {
       deferredPauseHandler = async () => {
         await args.onAuthPause?.(error);
@@ -10592,7 +11159,6 @@ async function resumeAuthorizedRequest(args) {
     initialText: args.connectedText,
     failureText: args.failureText,
     generateReply: args.generateReply,
-    onReply: args.onReply,
     onSuccess: args.onSuccess,
     onFailure: args.onFailure,
     onAuthPause: args.onAuthPause,
@@ -10756,65 +11322,6 @@ 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 {
-  }
-}
 async function buildResumeConversationContext(channelId, threadTs, sessionId) {
   const threadId = `slack:${channelId}:${threadTs}`;
   const conversation = coerceThreadConversationState(
@@ -10899,7 +11406,6 @@ async function resumeAuthorizedMcpTurn(args) {
   );
   await resumeAuthorizedRequest({
     messageText: authSession.userMessage,
-    provider,
     channelId: authSession.channelId,
     threadTs: authSession.threadTs,
     lockKey: authSession.conversationId,
@@ -10925,14 +11431,8 @@ async function resumeAuthorizedMcpTurn(args) {
       configuration: authSession.configuration,
       channelConfiguration,
       sandbox: getPersistedSandboxState(currentState),
-      threadParticipants: buildThreadParticipants(conversation.messages)
-    },
-    onReply: async (reply) => {
-      await deliverReplyToThread(
-        authSession.channelId,
-        authSession.threadTs,
-        reply
-      );
+      threadParticipants: buildThreadParticipants(conversation.messages),
+      ...getTurnUserReplyAttachmentContext(userMessage)
     },
     onSuccess: async (reply) => {
       try {
@@ -11230,7 +11730,6 @@ async function resumePendingOAuthMessage(stored) {
   );
   await resumeAuthorizedRequest({
     messageText: stored.pendingMessage,
-    provider: stored.provider,
     channelId: stored.channelId,
     threadTs: stored.threadTs,
     connectedText: `Your ${providerLabel} account is now connected. Processing your request...`,
@@ -11404,7 +11903,7 @@ async function GET5(request, provider, waitUntil) {
   } else if (stored.channelId && stored.threadTs) {
     const { channelId, threadTs } = stored;
     waitUntil(
-      () => postSlackMessage(
+      () => postSlackMessage2(
         channelId,
         threadTs,
         `Your ${providerLabel} account is now connected. You can start using ${providerLabel} commands.`
@@ -11428,9 +11927,6 @@ async function GET5(request, provider, waitUntil) {
   });
 }
 
-// src/handlers/turn-resume.ts
-import { Buffer as Buffer3 } from "buffer";
-
 // src/chat/slack/context.ts
 function toTrimmedSlackString(value) {
   const normalized = toOptionalString(value);
@@ -11478,65 +11974,6 @@ function resolveSlackChannelIdFromMessage(message) {
 }
 
 // src/handlers/turn-resume.ts
-function extractSlackText2(text, files) {
-  const message = buildSlackOutputMessage(text, files);
-  if (typeof message === "object" && message !== null && "markdown" in message && typeof message.markdown === "string") {
-    return message.markdown;
-  }
-  if (typeof message === "object" && message !== null && "raw" in message && typeof message.raw === "string") {
-    return message.raw;
-  }
-  return text;
-}
-async function normalizeFileUploads2(files) {
-  const normalized = [];
-  for (const file of files) {
-    let data;
-    if (Buffer3.isBuffer(file.data)) {
-      data = file.data;
-    } else if (file.data instanceof ArrayBuffer) {
-      data = Buffer3.from(file.data);
-    } else {
-      data = Buffer3.from(await file.data.arrayBuffer());
-    }
-    normalized.push({
-      data,
-      filename: file.filename
-    });
-  }
-  return normalized;
-}
-async function deliverReplyToThread2(args) {
-  const replyFiles = args.reply.files && args.reply.files.length > 0 ? args.reply.files : void 0;
-  const { shouldPostThreadReply, attachFiles } = resolveReplyDelivery({
-    reply: args.reply,
-    hasStreamedThreadReply: false
-  });
-  if (shouldPostThreadReply) {
-    const text = extractSlackText2(
-      args.reply.text,
-      attachFiles === "inline" ? replyFiles : void 0
-    );
-    if (text.trim().length > 0) {
-      await postSlackMessage(args.channelId, args.threadTs, text);
-    }
-  }
-  if (!replyFiles || attachFiles === "none") {
-    return;
-  }
-  const files = await normalizeFileUploads2(replyFiles);
-  if (files.length === 0) {
-    return;
-  }
-  try {
-    await uploadFilesToThread({
-      channelId: args.channelId,
-      threadTs: args.threadTs,
-      files
-    });
-  } catch {
-  }
-}
 async function persistCompletedReplyState2(args) {
   const currentState = await getPersistedThreadState(
     args.checkpoint.conversationId
@@ -11649,14 +12086,8 @@ async function resumeTimedOutTurn(payload) {
       conversationContext,
       channelConfiguration,
       sandbox,
-      threadParticipants: buildThreadParticipants(conversation.messages)
-    },
-    onReply: async (reply) => {
-      await deliverReplyToThread2({
-        channelId: thread.channelId,
-        threadTs: thread.threadTs,
-        reply
-      });
+      threadParticipants: buildThreadParticipants(conversation.messages),
+      ...getTurnUserReplyAttachmentContext(userMessage)
     },
     onSuccess: async (reply) => {
       try {
@@ -11766,9 +12197,6 @@ async function POST(request, waitUntil) {
   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({
@@ -12116,11 +12544,21 @@ function getRunId(thread, message) {
   return toOptionalString(thread.runId) ?? toOptionalString(message.runId);
 }
 function getChannelId(thread, message) {
-  return thread.channelId ?? resolveSlackChannelIdFromMessage(message);
+  return resolveSlackChannelIdFromThreadId(toOptionalString(thread.id)) ?? normalizeSlackConversationId(toOptionalString(thread.channelId)) ?? resolveSlackChannelIdFromMessage(message);
 }
 function getThreadTs(threadId) {
   return parseSlackThreadId(threadId)?.threadTs;
 }
+function getAssistantThreadContext(message) {
+  const raw = message.raw;
+  const rawRecord = raw && typeof raw === "object" ? raw : void 0;
+  const channelId = toOptionalString(rawRecord?.channel);
+  const threadTs = toOptionalString(rawRecord?.thread_ts);
+  if (!channelId || !threadTs) {
+    return void 0;
+  }
+  return { channelId, threadTs };
+}
 function getMessageTs(message) {
   const directTs = toOptionalString(
     message.ts
@@ -12473,7 +12911,7 @@ function createSlackTurnRuntime(deps) {
     },
     async handleAssistantContextChanged(event) {
       try {
-        await deps.initializeAssistantThread({
+        await deps.refreshAssistantThreadContext({
           threadId: event.threadId,
           channelId: event.channelId,
           threadTs: event.threadTs,
@@ -12615,6 +13053,18 @@ 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 countPotentialImageAttachments(attachments) > 0;
+}
+function countPotentialImageAttachments(attachments) {
+  return attachments?.filter((attachment) => {
+    if (attachment.type === "image") {
+      return true;
+    }
+    const mimeType = attachment.mimeType ?? "";
+    return attachment.type === "file" && mimeType.startsWith("image/");
+  }).length ?? 0;
+}
 function isVisionEnabled() {
   return Boolean(botConfig.visionModelId);
 }
@@ -12957,6 +13407,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(
@@ -12964,10 +13415,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,
@@ -13141,45 +13597,71 @@ function createJuniorRuntimeServices(overrides = {}) {
   };
 }
 
-// src/chat/runtime/streaming.ts
-function createTextStreamBridge() {
-  const queue = [];
-  let ended = false;
-  let wakeConsumer = null;
-  const iterable = {
-    async *[Symbol.asyncIterator]() {
-      while (!ended || queue.length > 0) {
-        if (queue.length > 0) {
-          yield queue.shift();
-          continue;
-        }
-        await new Promise((resolve) => {
-          wakeConsumer = resolve;
-        });
-      }
-    }
-  };
-  return {
-    iterable,
-    push(delta) {
-      if (!delta || ended) {
-        return;
-      }
-      queue.push(delta);
-      const wake = wakeConsumer;
-      wakeConsumer = null;
-      wake?.();
-    },
-    end() {
-      if (ended) {
-        return;
+// src/chat/slack/assistant-thread/title.ts
+function maybeUpdateAssistantTitle(args) {
+  const assistantThreadContext = args.assistantThreadContext;
+  if (!assistantThreadContext?.channelId || !assistantThreadContext.threadTs || !isDmChannel(assistantThreadContext.channelId)) {
+    return Promise.resolve(void 0);
+  }
+  const titleSourceMessage = getThreadTitleSourceMessage(args.conversation);
+  if (!titleSourceMessage) {
+    return Promise.resolve(void 0);
+  }
+  if (args.artifacts.assistantTitleSourceMessageId === titleSourceMessage.id) {
+    return Promise.resolve(void 0);
+  }
+  return (async () => {
+    try {
+      const title = await args.generateThreadTitle(titleSourceMessage.text);
+      await args.getSlackAdapter().setAssistantTitle(
+        assistantThreadContext.channelId,
+        assistantThreadContext.threadTs,
+        title
+      );
+      return titleSourceMessage.id;
+    } catch (error) {
+      const slackErrorCode = getSlackApiErrorCode(error);
+      const assistantTitleErrorAttributes = {
+        "app.slack.assistant_title.outcome": "permission_denied",
+        ...slackErrorCode ? {
+          "app.slack.assistant_title.error_code": slackErrorCode
+        } : {}
+      };
+      if (isSlackTitlePermissionError(error)) {
+        setSpanAttributes(assistantTitleErrorAttributes);
+        logError(
+          "thread_title_generation_permission_denied",
+          {
+            slackThreadId: args.threadId,
+            slackUserId: args.requesterId,
+            slackChannelId: args.channelId,
+            runId: args.runId,
+            assistantUserName: args.assistantUserName,
+            modelId: args.modelId
+          },
+          assistantTitleErrorAttributes,
+          "Skipping thread title update due to Slack permission error"
+        );
+        return titleSourceMessage.id;
       }
-      ended = true;
-      const wake = wakeConsumer;
-      wakeConsumer = null;
-      wake?.();
+      logWarn(
+        "thread_title_generation_failed",
+        {
+          slackThreadId: args.threadId,
+          slackUserId: args.requesterId,
+          slackChannelId: args.channelId,
+          runId: args.runId,
+          assistantUserName: args.assistantUserName,
+          modelId: args.modelId
+        },
+        {
+          "error.message": error instanceof Error ? error.message : String(error)
+        },
+        "Thread title generation failed"
+      );
+      return void 0;
     }
-  };
+  })();
 }
 
 // src/chat/runtime/reply-executor.ts
@@ -13204,6 +13686,7 @@ function createReplyToThread(deps) {
     const threadId = getThreadId(thread, message);
     const channelId = getChannelId(thread, message);
     const threadTs = getThreadTs(threadId);
+    const assistantThreadContext = getAssistantThreadContext(message);
     const messageTs = getMessageTs(message);
     const runId = getRunId(thread, message);
     const conversationId = threadId ?? runId;
@@ -13223,7 +13706,6 @@ function createReplyToThread(deps) {
         const userText = stripLeadingBotMention(message.text, {
           stripLeadingSlackMentionToken: options.explicitMention || Boolean(message.isMention)
         });
-        const explicitChannelPostIntent = isExplicitChannelPostIntent(userText);
         const preparedState = options.preparedState ?? await deps.prepareTurnState({
           thread,
           message,
@@ -13294,16 +13776,12 @@ function createReplyToThread(deps) {
             messageTs: slackMessageTs
           }
         );
-        const progress = createProgressReporter({
-          channelId,
-          threadTs,
-          transport: createSlackAdapterAssistantStatusTransport({
-            getSlackAdapter: deps.getSlackAdapter
-          })
+        const omittedImageAttachmentCount = !isVisionEnabled() && hasPotentialImageAttachment(message.attachments) ? countPotentialImageAttachments(message.attachments) : 0;
+        const status = createSlackAdapterAssistantStatusSession({
+          channelId: assistantThreadContext?.channelId,
+          threadTs: assistantThreadContext?.threadTs,
+          getSlackAdapter: deps.getSlackAdapter
         });
-        const textStream = createTextStreamBridge();
-        let streamedReplyPromise;
-        let pendingStreamText = "";
         let beforeFirstResponsePostCalled = false;
         const beforeFirstResponsePost = async () => {
           if (beforeFirstResponsePostCalled) {
@@ -13312,25 +13790,6 @@ function createReplyToThread(deps) {
           beforeFirstResponsePostCalled = true;
           await options.beforeFirstResponsePost?.();
         };
-        const startStreamingReply = () => {
-          if (!streamedReplyPromise) {
-            const streamingReply = (async () => {
-              return await postThreadReply(
-                textStream.iterable,
-                "streaming_initial_post"
-              );
-            })();
-            streamedReplyPromise = streamingReply;
-          }
-        };
-        const flushPendingStreamText = () => {
-          if (!pendingStreamText) {
-            return;
-          }
-          startStreamingReply();
-          textStream.push(pendingStreamText);
-          pendingStreamText = "";
-        };
         const postThreadReply = async (payload, stage) => {
           await beforeFirstResponsePost();
           try {
@@ -13350,7 +13809,20 @@ function createReplyToThread(deps) {
             throw error;
           }
         };
-        await progress.start();
+        status.start();
+        const assistantTitleTask = maybeUpdateAssistantTitle({
+          assistantThreadContext,
+          assistantUserName: botConfig.userName,
+          artifacts: preparedState.artifacts,
+          channelId,
+          conversation: preparedState.conversation,
+          generateThreadTitle: deps.services.generateThreadTitle,
+          getSlackAdapter: deps.getSlackAdapter,
+          modelId: botConfig.fastModelId,
+          requesterId: message.author.userId,
+          runId,
+          threadId
+        });
         let persistedAtLeastOnce = false;
         let shouldPersistFailureState = true;
         try {
@@ -13371,6 +13843,8 @@ function createReplyToThread(deps) {
             artifactState: preparedState.artifacts,
             configuration: preparedState.configuration,
             channelConfiguration: preparedState.channelConfiguration,
+            inboundAttachmentCount: message.attachments.length,
+            omittedImageAttachmentCount,
             userAttachments,
             correlation: {
               conversationId,
@@ -13397,26 +13871,8 @@ function createReplyToThread(deps) {
               await persistThreadState(thread, { artifacts });
             },
             threadParticipants,
-            onStatus: (status) => progress.setStatus(status),
-            onTextDelta: (deltaText) => {
-              if (explicitChannelPostIntent) {
-                return;
-              }
-              if (streamedReplyPromise) {
-                textStream.push(deltaText);
-                return;
-              }
-              pendingStreamText += deltaText;
-              if (isPotentialRedundantReactionAckText(pendingStreamText)) {
-                return;
-              }
-              flushPendingStreamText();
-            }
+            onStatus: (nextStatus) => status.update(nextStatus)
           });
-          if (streamedReplyPromise) {
-            flushPendingStreamText();
-          }
-          textStream.end();
           const diagnosticsContext = {
             slackThreadId: threadId,
             slackUserId: message.author.userId,
@@ -13488,30 +13944,27 @@ 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) {
-            if (!streamedReplyPromise) {
-              const sent = await postThreadReply(
-                buildSlackOutputMessage(
-                  reply.text,
-                  resolvedAttachFiles === "inline" ? replyFiles : void 0
-                ),
-                "thread_reply"
+          const plannedPosts = planSlackReplyPosts({ reply });
+          if (plannedPosts.length > 0) {
+            let sent;
+            for (const post of plannedPosts) {
+              sent = await postThreadReply(
+                buildSlackOutputMessage(post.text, post.files),
+                post.stage
               );
-              if (reactionPerformed && isRedundantReactionAckText(reply.text)) {
-                await sent.delete();
-              }
-            } else {
-              await streamedReplyPromise;
+            }
+            const firstPlannedMessageHasFiles = (plannedPosts[0]?.files?.length ?? 0) > 0;
+            if (sent && reactionPerformed && plannedPosts.length === 1 && !firstPlannedMessageHasFiles && isRedundantReactionAckText(reply.text)) {
+              await sent.delete();
             }
           }
+          const titleUpdateResult = await assistantTitleTask;
+          if (titleUpdateResult) {
+            artifactStatePatch.assistantTitleSourceMessageId = titleUpdateResult;
+          }
           const shouldPersistArtifacts = Object.keys(artifactStatePatch).length > 0;
           const nextArtifacts = shouldPersistArtifacts ? mergeArtifactsState(preparedState.artifacts, artifactStatePatch) : void 0;
           markTurnCompleted({
@@ -13539,79 +13992,17 @@ function createReplyToThread(deps) {
               "Agent turn completed"
             );
           }
-          const isFirstAssistantReply = preparedState.conversation.stats.compactedMessageCount === 0 && preparedState.conversation.messages.filter(
-            (m) => m.role === "assistant"
-          ).length === 1;
-          if (isFirstAssistantReply && channelId && isDmChannel(channelId) && threadTs) {
-            void deps.services.generateThreadTitle(userText, reply.text).then(
-              (title) => deps.getSlackAdapter().setAssistantTitle(channelId, threadTs, title)
-            ).catch((error) => {
-              const slackErrorCode = getSlackApiErrorCode(error);
-              const assistantTitleErrorAttributes = {
-                "app.slack.assistant_title.outcome": "permission_denied",
-                ...slackErrorCode ? { "app.slack.assistant_title.error_code": slackErrorCode } : {}
-              };
-              if (isSlackTitlePermissionError(error)) {
-                setSpanAttributes(assistantTitleErrorAttributes);
-                logError(
-                  "thread_title_generation_permission_denied",
-                  {
-                    slackThreadId: threadId,
-                    slackUserId: message.author.userId,
-                    slackChannelId: channelId,
-                    runId,
-                    assistantUserName: botConfig.userName,
-                    modelId: botConfig.fastModelId
-                  },
-                  assistantTitleErrorAttributes,
-                  "Skipping thread title update due to Slack permission error"
-                );
-                return;
-              }
-              logWarn(
-                "thread_title_generation_failed",
-                {
-                  slackThreadId: threadId,
-                  slackUserId: message.author.userId,
-                  slackChannelId: channelId,
-                  runId,
-                  assistantUserName: botConfig.userName,
-                  modelId: botConfig.fastModelId
-                },
-                {
-                  "error.message": error instanceof Error ? error.message : String(error)
-                },
-                "Thread title generation failed"
-              );
-            });
-          }
-          if (shouldPostThreadReply && resolvedAttachFiles === "followup" && replyFiles) {
-            await postThreadReply(
-              buildSlackOutputMessage("", replyFiles),
-              "thread_reply_files_followup"
-            );
-          }
         } catch (error) {
           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)) {
+            if (conversationIdForResume && sessionIdForResume && typeof checkpointVersion === "number" && canScheduleTurnTimeoutResume(nextSliceId)) {
               try {
                 await deps.services.scheduleTurnTimeoutResume({
                   conversationId: conversationIdForResume,
@@ -13632,7 +14023,7 @@ function createReplyToThread(deps) {
                   "Failed to schedule timeout resume callback"
                 );
               }
-            } else if (!hasVisibleAssistantOutput && conversationIdForResume && sessionIdForResume && typeof checkpointVersion === "number") {
+            } else if (conversationIdForResume && sessionIdForResume && typeof checkpointVersion === "number") {
               logWarn(
                 "agent_turn_timeout_resume_slice_limit_reached",
                 turnTraceContext,
@@ -13654,7 +14045,6 @@ function createReplyToThread(deps) {
           shouldPersistFailureState = true;
           throw error;
         } finally {
-          textStream.end();
           if (!persistedAtLeastOnce && shouldPersistFailureState) {
             markTurnFailed({
               conversation: preparedState.conversation,
@@ -13679,19 +14069,26 @@ function createReplyToThread(deps) {
               );
             }
           }
-          await progress.stop();
+          await status.stop();
         }
       }
     );
   };
 }
 
-// src/chat/runtime/assistant-lifecycle.ts
+// src/chat/slack/assistant-thread/lifecycle.ts
 import { ThreadImpl } from "chat";
-async function initializeAssistantThread(event) {
+async function syncAssistantThreadContext(event, options) {
+  const channelId = normalizeSlackConversationId(event.channelId);
+  if (!channelId) {
+    throw new Error("Assistant thread initialization requires a channel ID");
+  }
+  const sourceChannelId = event.sourceChannelId ? normalizeSlackConversationId(event.sourceChannelId) : void 0;
   const slack = event.getSlackAdapter();
-  await slack.setAssistantTitle(event.channelId, event.threadTs, "Junior");
-  await slack.setSuggestedPrompts(event.channelId, event.threadTs, [
+  if (options.setInitialTitle) {
+    await slack.setAssistantTitle(channelId, event.threadTs, "Junior");
+  }
+  await slack.setSuggestedPrompts(channelId, event.threadTs, [
     {
       title: "Summarize thread",
       message: "Summarize the latest discussion in this thread."
@@ -13702,26 +14099,37 @@ async function initializeAssistantThread(event) {
       message: "Generate an image based on this conversation."
     }
   ]);
-  if (!event.sourceChannelId) {
+  if (!sourceChannelId) {
     return;
   }
   const thread = ThreadImpl.fromJSON({
     _type: "chat:Thread",
     adapterName: "slack",
-    channelId: event.channelId,
+    channelId,
     id: event.threadId,
-    isDM: event.channelId.startsWith("D")
+    isDM: channelId.startsWith("D")
   });
   const currentArtifacts = coerceThreadArtifactsState(await thread.state);
   const nextArtifacts = mergeArtifactsState(currentArtifacts, {
-    assistantContextChannelId: event.sourceChannelId
+    assistantContextChannelId: sourceChannelId
   });
   await persistThreadState(thread, {
     artifacts: nextArtifacts
   });
 }
+async function initializeAssistantThread(event) {
+  await syncAssistantThreadContext(event, { setInitialTitle: true });
+}
+async function refreshAssistantThreadContext(event) {
+  await syncAssistantThreadContext(event, { setInitialTitle: false });
+}
 
 // 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;
@@ -13739,15 +14147,10 @@ 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 imageAttachmentCount = messageHasPotentialImageAttachment ? countPotentialImageAttachments(args.message.attachments) : 0;
     const normalizedUserText = normalizeConversationText(args.userText) || "[non-text message]";
     const slackTs = getSlackMessageTs(args.message);
     const incomingUserMessage = {
@@ -13762,7 +14165,9 @@ function createPrepareTurnState(deps) {
         isBot: typeof args.message.author.isBot === "boolean" ? args.message.author.isBot : void 0
       },
       meta: {
+        attachmentCount: args.message.attachments.length,
         explicitMention: args.explicitMention,
+        imageAttachmentCount: imageAttachmentCount > 0 ? imageAttachmentCount : void 0,
         slackTs,
         imagesHydrated: !messageHasPotentialImageAttachment
       }
@@ -13771,7 +14176,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,
@@ -13867,7 +14273,7 @@ function createSlackRuntime(options) {
           slackTs,
           replied: false,
           skippedReason: decision.reason,
-          imagesHydrated: true
+          imagesHydrated: !hasPotentialImageAttachment(message.attachments)
         }
       });
       conversation.processing.activeTurnId = void 0;
@@ -13915,6 +14321,20 @@ function createSlackRuntime(options) {
         sourceChannelId,
         getSlackAdapter: options.getSlackAdapter
       });
+    },
+    refreshAssistantThreadContext: async ({
+      threadId,
+      channelId,
+      threadTs,
+      sourceChannelId
+    }) => {
+      await refreshAssistantThreadContext({
+        threadId,
+        channelId,
+        threadTs,
+        sourceChannelId,
+        getSlackAdapter: options.getSlackAdapter
+      });
     }
   });
 }
@@ -13987,14 +14407,14 @@ var JuniorChat = class extends Chat {
         (async () => {
           try {
             const message = await messageOrFactory();
-            const normalized2 = normalizeIncomingSlackThreadId(
+            const normalized = normalizeIncomingSlackThreadId(
               threadId,
               message
             );
-            if (normalized2 !== threadId && "threadId" in message) {
-              message.threadId = normalized2;
+            if (normalized !== threadId && "threadId" in message) {
+              message.threadId = normalized;
             }
-            super.processMessage(adapter, normalized2, message, options);
+            super.processMessage(adapter, normalized, message, options);
           } catch (error) {
             runtime.logger?.error?.("Message factory resolution error", {
               error,
@@ -14005,14 +14425,19 @@ var JuniorChat = class extends Chat {
       );
       return;
     }
-    const normalized = normalizeIncomingSlackThreadId(
-      threadId,
-      messageOrFactory
+    enqueueBackgroundTask(
+      options,
+      (async () => {
+        const normalized = normalizeIncomingSlackThreadId(
+          threadId,
+          messageOrFactory
+        );
+        if (normalized !== threadId && "threadId" in messageOrFactory) {
+          messageOrFactory.threadId = normalized;
+        }
+        super.processMessage(adapter, normalized, messageOrFactory, options);
+      })()
     );
-    if (normalized !== threadId && "threadId" in messageOrFactory) {
-      messageOrFactory.threadId = normalized;
-    }
-    super.processMessage(adapter, normalized, messageOrFactory, options);
   }
   processReaction(event, options) {
     const runtime = this;
@@ -14033,20 +14458,19 @@ var JuniorChat = class extends Chat {
   }
   processAction(event, options) {
     const runtime = this;
-    enqueueBackgroundTask(
-      options,
-      (async () => {
-        try {
-          await runtime.handleActionEvent(event);
-        } catch (error) {
-          runtime.logger?.error?.("Action processing error", {
-            error,
-            actionId: event.actionId,
-            messageId: event.messageId
-          });
-        }
-      })()
-    );
+    const task = (async () => {
+      try {
+        await runtime.handleActionEvent(event, options);
+      } catch (error) {
+        runtime.logger?.error?.("Action processing error", {
+          error,
+          actionId: event.actionId,
+          messageId: event.messageId
+        });
+      }
+    })();
+    enqueueBackgroundTask(options, task);
+    return task;
   }
   processModalClose(event, contextId, options) {
     const runtime = this;
@@ -14084,7 +14508,7 @@ var JuniorChat = class extends Chat {
       options,
       (async () => {
         try {
-          await runtime.handleSlashCommandEvent(event);
+          await runtime.handleSlashCommandEvent(event, options);
         } catch (error) {
           runtime.logger?.error?.("Slash command processing error", {
             error,
@@ -14151,6 +14575,14 @@ var JuniorChat = class extends Chat {
   }
 };
 
+// src/chat/slack/adapter.ts
+import {
+  createSlackAdapter
+} from "@chat-adapter/slack";
+function createJuniorSlackAdapter(config) {
+  return createSlackAdapter(config);
+}
+
 // src/chat/queue/thread-message-dispatcher.ts
 function rehydrateAttachmentFetchers(message, downloadPrivateSlackFile2 = downloadPrivateSlackFile) {
   for (const attachment of message.attachments) {
@@ -14269,7 +14701,7 @@ function createProductionBot() {
         if (!signingSecret) {
           throw new Error("SLACK_SIGNING_SECRET is required");
         }
-        return createSlackAdapter({
+        return createJuniorSlackAdapter({
           logger: logger.child("slack"),
           signingSecret,
           ...botToken ? { botToken } : {},
@@ -14405,6 +14837,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;
@@ -14430,7 +14888,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,
@@ -14483,6 +14941,7 @@ async function handleAuthenticatedSlackMessageChangedMention(args) {
     if (!result) {
       return false;
     }
+    rehydrateAttachmentFetchers(result.message);
     args.bot.processMessage(
       slackAdapter,
       result.threadId,