@sentry/junior 0.23.0 → 0.24.1

package/dist/app.js

@@ -6,7 +6,7 @@ import {
   loadSkillsByName,
   logCapabilityCatalogLoadedOnce,
   parseSkillInvocation
-} from "./chunk-JWBWBJYJ.js";
+} from "./chunk-O5N42P7K.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -27,7 +27,7 @@ import {
   sandboxSkillDir,
   sandboxSkillFile,
   toOptionalTrimmed
-} from "./chunk-THPM7NSG.js";
+} from "./chunk-RMVXZMXQ.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -35,6 +35,7 @@ import {
   createPluginBroker,
   createRequestContext,
   extractGenAiUsageAttributes,
+  extractGenAiUsageSummary,
   getActiveTraceId,
   getPluginDefinition,
   getPluginMcpProviders,
@@ -58,7 +59,7 @@ import {
   toOptionalString,
   withContext,
   withSpan
-} from "./chunk-MCJJKEB3.js";
+} from "./chunk-I3WA75AD.js";
 import "./chunk-Z3YD6NHK.js";
 import {
   discoverInstalledPluginPackageContent,
@@ -333,9 +334,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;
   }
@@ -356,7 +365,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;
@@ -868,13 +877,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") {
@@ -974,19 +989,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) {
@@ -1006,6 +1008,217 @@ 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,
+      ...input.blocks?.length ? {
+        blocks: input.blocks
+      } : {},
+      ...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 deleteSlackMessage(input) {
+  const channelId = requireSlackConversationId(
+    input.channelId,
+    "Slack message deletion"
+  );
+  const timestamp = requireSlackMessageTimestamp(
+    input.timestamp,
+    "Slack message deletion"
+  );
+  await withSlackRetries(
+    () => getSlackClient().chat.delete({
+      channel: channelId,
+      ts: timestamp
+    }),
+    3,
+    { action: "chat.delete" }
+  );
+}
+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) {
@@ -1182,16 +1395,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);
@@ -1257,17 +1477,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";
@@ -1294,7 +1514,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(
@@ -1914,6 +2134,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,
@@ -2115,6 +2336,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 {
@@ -2535,7 +2765,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,
@@ -2543,17 +2773,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;
@@ -2598,7 +2852,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({
@@ -2704,104 +2958,257 @@ import { Agent } from "@mariozechner/pi-agent-core";
 import fs from "fs";
 import path2 from "path";
 
-// src/chat/slack/output.ts
-var MAX_INLINE_CHARS = 2200;
-var MAX_INLINE_LINES = 45;
-var CONTINUED_MARKER = "\n\n[Continued below]";
-var INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
-var STREAMING_FENCE_CLOSE_GUARD = "\n```";
-function ensureBlockSpacing(text) {
-  const codeBlockPattern = /^```/;
-  const listItemPattern = /^[-*•]\s|^\d+\.\s/;
-  const lines = text.split("\n");
-  const result = [];
-  let inCodeBlock = false;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const isCodeFence = codeBlockPattern.test(line.trimStart());
-    if (isCodeFence) {
-      if (!inCodeBlock) {
-        const prev2 = result.length > 0 ? result[result.length - 1] : void 0;
-        if (prev2 !== void 0 && prev2.trim() !== "") {
-          result.push("");
-        }
-      }
-      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);
+// src/chat/runtime/status-format.ts
+var SLACK_STATUS_MAX_LENGTH = 50;
+function truncateWithEllipsis(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
   }
-  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();
+  return `${text.slice(0, Math.max(1, maxLength - 3)).trimEnd()}...`;
 }
-function countSlackLines(text) {
-  if (!text) {
-    return 0;
+function truncateStatusText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return "";
   }
-  return text.split("\n").length;
-}
-function fitsInlineBudget(text, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
-  return text.length <= maxChars && countSlackLines(text) <= maxLines;
+  return truncateWithEllipsis(trimmed, SLACK_STATUS_MAX_LENGTH);
 }
-function findSplitIndex(text, maxChars) {
-  if (text.length <= maxChars) {
-    return text.length;
+function compactStatusPath(value) {
+  if (typeof value !== "string") {
+    return void 0;
   }
-  const bounded = text.slice(0, maxChars);
-  const newlineIndex = bounded.lastIndexOf("\n");
-  if (newlineIndex > 0) {
-    return newlineIndex;
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
   }
-  const spaceIndex = bounded.lastIndexOf(" ");
-  if (spaceIndex > 0) {
-    return spaceIndex;
+  if (trimmed.length <= 80) {
+    return trimmed;
   }
-  return maxChars;
+  return `...${trimmed.slice(-77)}`;
 }
-function splitByLineBudget(text, maxLines) {
-  if (maxLines <= 0) {
-    return "";
+function compactStatusText(value, maxLength = 80) {
+  if (typeof value !== "string") {
+    return void 0;
   }
-  const lines = text.split("\n");
-  if (lines.length <= maxLines) {
-    return text;
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
   }
-  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
-  };
+  return truncateWithEllipsis(trimmed, maxLength);
 }
-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;
-    }
+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],
@@ -2827,6 +3234,9 @@ function appendSlackSuffix(text, marker) {
   const carryover = getFenceContinuation(text);
   return `${text}${carryover?.closeSuffix ?? ""}${marker}`;
 }
+function stripTrailingContinuationMarker(text) {
+  return text.endsWith(CONTINUED_MARKER) ? text.slice(0, -CONTINUED_MARKER.length) : text;
+}
 function takeSlackContinuationChunk(text, budget) {
   let { prefix, rest } = takeSlackInlinePrefix(text, budget);
   if (!rest) {
@@ -2902,7 +3312,7 @@ function takeSlackInlinePrefix(text, options) {
   };
 }
 function splitSlackReplyText(text, options) {
-  const normalized = normalizeForSlack(text);
+  const normalized = renderSlackMrkdwn(text);
   if (!normalized) {
     return [];
   }
@@ -2924,21 +3334,16 @@ function splitSlackReplyText(text, options) {
     chunks.push(renderedPrefix);
     remaining = rest;
   }
+  if (chunks.length === 2) {
+    chunks[0] = stripTrailingContinuationMarker(chunks[0] ?? "");
+  }
   return chunks;
 }
-function getSlackInterruptionMarker() {
-  return INTERRUPTED_MARKER;
-}
 function getSlackContinuationBudget() {
   return reserveInlineBudgetForSuffix(CONTINUED_MARKER);
 }
-function getSlackStreamingContinuationBudget() {
-  return reserveInlineBudgetForSuffix(
-    `${STREAMING_FENCE_CLOSE_GUARD}${CONTINUED_MARKER}`
-  );
-}
 function buildSlackOutputMessage(text, files) {
-  const normalized = normalizeForSlack(text);
+  const normalized = renderSlackMrkdwn(text);
   const fileCount = files?.length ?? 0;
   if (!normalized) {
     if (fileCount > 0) {
@@ -3401,12 +3806,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.",
         "- For tool-heavy research, discovery, or source-checking requests, do not send an initial acknowledgment. Start the visible reply only once you can present the actual answer.",
         "- Do not narrate tool execution or repeated status updates in the visible reply.",
-        "- Avoid tables unless explicitly requested.",
+        "- 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")
@@ -5557,103 +5962,29 @@ 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) {
+async function listChannelMessages(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");
+    throw new Error("Slack channel history lookup requires a valid channel ID");
   }
-  let permalink;
-  try {
-    const permalinkResponse = await withSlackRetries(
-      () => client2.chat.getPermalink({
+  const targetLimit = Math.max(1, Math.min(input.limit, 1e3));
+  const maxPages = Math.max(1, Math.min(input.maxPages ?? 5, 10));
+  const messages = [];
+  let cursor = input.cursor;
+  let pages = 0;
+  while (messages.length < targetLimit && pages < maxPages) {
+    pages += 1;
+    const pageLimit = Math.max(1, Math.min(200, targetLimit - messages.length));
+    const response = await withSlackRetries(
+      () => client2.conversations.history({
         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);
-  if (!channelId) {
-    throw new Error("Slack channel history lookup requires a valid channel ID");
-  }
-  const targetLimit = Math.max(1, Math.min(input.limit, 1e3));
-  const maxPages = Math.max(1, Math.min(input.maxPages ?? 5, 10));
-  const messages = [];
-  let cursor = input.cursor;
-  let pages = 0;
-  while (messages.length < targetLimit && pages < maxPages) {
-    pages += 1;
-    const pageLimit = Math.max(1, Math.min(200, targetLimit - messages.length));
-    const response = await withSlackRetries(
-      () => client2.conversations.history({
-        channel: channelId,
-        limit: pageLimit,
-        cursor,
-        oldest: input.oldest,
-        latest: input.latest,
-        inclusive: input.inclusive
+        limit: pageLimit,
+        cursor,
+        oldest: input.oldest,
+        latest: input.latest,
+        inclusive: input.inclusive
       }),
       3,
       { action: "conversations.history" }
@@ -5841,9 +6172,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,
@@ -7450,152 +7782,7 @@ function throwSandboxOperationError(action, error, includeMissingPath = false) {
 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;
-    }
-    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/runtime/assistant-status.ts
+// src/chat/slack/assistant-thread/status-render.ts
 var STATUS_PATTERNS = {
   thinking: {
     defaultContext: "\u2026",
@@ -7649,17 +7836,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}`);
@@ -7671,46 +7851,274 @@ function buildAssistantStatusPresentation(args) {
     suggestions: Array.from(/* @__PURE__ */ new Set([visible, hint]))
   };
 }
-function createSlackAdapterAssistantStatusTransport(args) {
+
+// 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 {
-    async setStatus(channelId, threadTs, status, suggestions) {
-      try {
-        await args.getSlackAdapter().setAssistantStatus(channelId, threadTs, status, suggestions);
-      } catch (error) {
-        logAssistantStatusFailure(status, error);
+    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 createSlackWebApiStatusSender(args) {
+  const getClient2 = args.getSlackClient ?? getSlackClient;
+  return async (text, suggestions) => {
+    const channelId = args.channelId;
+    const threadTs = args.threadTs;
+    if (!channelId || !threadTs) {
+      return;
     }
-  };
-}
-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);
-      }
+    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";
@@ -7832,7 +8240,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() {
@@ -7848,12 +8260,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);
 }
 
@@ -7877,7 +8289,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);
 }
@@ -7929,7 +8341,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);
   }
@@ -7945,7 +8357,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);
   }
@@ -7962,7 +8374,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);
   }
 
@@ -9293,7 +9705,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, "");
 }
@@ -9310,24 +9721,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,
@@ -9335,27 +9733,6 @@ function buildReplyDeliveryPlan(args) {
     attachFiles
   };
 }
-function resolveReplyDelivery(args) {
-  const replyHasFiles = Boolean(
-    args.reply.files && args.reply.files.length > 0
-  );
-  const deliveryPlan = args.reply.deliveryPlan ?? {
-    mode: args.reply.deliveryMode ?? "thread",
-    postThreadText: (args.reply.deliveryMode ?? "thread") !== "channel_only",
-    attachFiles: replyHasFiles ? args.hasStreamedThreadReply ? "followup" : "inline" : "none"
-  };
-  let attachFiles = replyHasFiles ? deliveryPlan.attachFiles : "none";
-  if (attachFiles === "followup" && !args.hasStreamedThreadReply) {
-    attachFiles = "inline";
-  }
-  if (attachFiles === "inline" && args.hasStreamedThreadReply) {
-    attachFiles = "followup";
-  }
-  return {
-    shouldPostThreadReply: deliveryPlan.postThreadText,
-    attachFiles
-  };
-}
 
 // src/chat/services/channel-intent.ts
 function isExplicitChannelPostIntent(text) {
@@ -9381,6 +9758,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;
@@ -9409,15 +9790,17 @@ function buildTurnResult(input) {
     toolCalls,
     sandboxId,
     sandboxDependencyProfileHash,
-    hasTextDeltaCallback,
+    durationMs,
     shouldTrace,
     spanContext,
+    usage,
     correlation,
     assistantUserName
   } = 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);
@@ -9430,8 +9813,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) {
@@ -9453,7 +9835,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);
@@ -9486,6 +9868,8 @@ function buildTurnResult(input) {
     toolResultCount: toolResults.length,
     toolErrorCount,
     usedPrimaryText,
+    durationMs,
+    usage,
     stopReason,
     errorMessage,
     providerError: void 0
@@ -9779,6 +10163,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) {
@@ -9794,6 +10188,7 @@ function mcpToolsToDefinitions(mcpTools) {
   return defs;
 }
 async function generateAssistantReply(messageText, context = {}) {
+  const replyStartedAtMs = Date.now();
   let timeoutResumeConversationId;
   let timeoutResumeSessionId;
   let timeoutResumeSliceId = 1;
@@ -9804,6 +10199,7 @@ async function generateAssistantReply(messageText, context = {}) {
   let mcpToolManager;
   let sandboxExecutor;
   let timedOut = false;
+  let turnUsage;
   const getSandboxMetadata = () => sandboxExecutor ? {
     sandboxId: sandboxExecutor.getSandboxId(),
     sandboxDependencyProfileHash: sandboxExecutor.getDependencyProfileHash()
@@ -9850,6 +10246,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,
@@ -9857,7 +10255,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"
@@ -10110,6 +10511,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({
@@ -10251,7 +10659,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()
@@ -10305,14 +10718,16 @@ async function generateAssistantReply(messageText, context = {}) {
           }
           const outputMessages = newMessages.filter(isAssistantMessage);
           const outputMessagesAttribute = serializeGenAiAttribute(outputMessages);
-          const usageAttributes = extractGenAiUsageAttributes(
+          const usageSummary = extractGenAiUsageSummary(
             promptResult,
             agent.state,
             ...outputMessages
           );
+          turnUsage = usageSummary.inputTokens !== void 0 || usageSummary.outputTokens !== void 0 || usageSummary.totalTokens !== void 0 ? usageSummary : void 0;
           setSpanAttributes({
             ...outputMessagesAttribute ? { "gen_ai.output.messages": outputMessagesAttribute } : {},
-            ...usageAttributes
+            ...usageSummary.inputTokens !== void 0 ? { "gen_ai.usage.input_tokens": usageSummary.inputTokens } : {},
+            ...usageSummary.outputTokens !== void 0 ? { "gen_ai.usage.output_tokens": usageSummary.outputTokens } : {}
           });
         },
         {
@@ -10345,10 +10760,11 @@ async function generateAssistantReply(messageText, context = {}) {
       toolCalls,
       sandboxId: currentSandboxExecutor.getSandboxId(),
       sandboxDependencyProfileHash: currentSandboxExecutor.getDependencyProfileHash(),
+      durationMs: Date.now() - replyStartedAtMs,
       generatedFileCount: generatedFiles.length,
-      hasTextDeltaCallback: Boolean(context.onTextDelta),
       shouldTrace,
       spanContext,
+      usage: turnUsage,
       correlation: context.correlation,
       assistantUserName: context.assistant?.userName
     });
@@ -10439,6 +10855,7 @@ async function generateAssistantReply(messageText, context = {}) {
         toolResultCount: 0,
         toolErrorCount: 0,
         usedPrimaryText: false,
+        durationMs: Date.now() - replyStartedAtMs,
         errorMessage: message,
         providerError: error
       }
@@ -10459,150 +10876,84 @@ 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
+// src/chat/slack/footer.ts
+function escapeSlackMrkdwn(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function formatSlackTokenCount(value) {
+  return new Intl.NumberFormat("en-US").format(value);
+}
+function formatSlackDuration(durationMs) {
+  if (durationMs < 1e3) {
+    return `${durationMs}ms`;
+  }
+  const durationSeconds = durationMs / 1e3;
+  if (durationSeconds < 10) {
+    return `${durationSeconds.toFixed(1).replace(/\.0$/, "")}s`;
+  }
+  return `${Math.round(durationSeconds)}s`;
+}
+function resolveTotalTokens(usage) {
+  if (usage?.totalTokens !== void 0) {
+    return usage.totalTokens;
+  }
+  if (usage?.inputTokens !== void 0 && usage.outputTokens !== void 0) {
+    return usage.inputTokens + usage.outputTokens;
+  }
+  return void 0;
+}
+function buildSlackReplyFooter(args) {
+  const items = [];
+  const conversationId = args.conversationId?.trim();
+  if (conversationId) {
+    items.push({
+      label: "ID",
+      value: conversationId
     });
-    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
+  }
+  const totalTokens = resolveTotalTokens(args.usage);
+  if (totalTokens !== void 0) {
+    items.push({
+      label: "Tokens",
+      value: formatSlackTokenCount(totalTokens)
     });
-    if (nextPresentation.key !== currentKey) {
-      await postRenderedStatus(next);
-    }
-  };
-  return {
-    async start() {
-      active = true;
-      clearPending();
-      currentStatus = makeAssistantStatus("thinking");
-      currentKey = "";
-      void postRenderedStatus(currentStatus);
-    },
-    async stop() {
-      active = false;
-      clearPending();
-      if (rotationTimer) {
-        clearTimer(rotationTimer);
-        rotationTimer = null;
+  }
+  if (typeof args.durationMs === "number" && Number.isFinite(args.durationMs)) {
+    const durationMs = Math.max(0, Math.floor(args.durationMs));
+    items.push({
+      label: "Time",
+      value: formatSlackDuration(durationMs)
+    });
+  }
+  const traceId = args.traceId?.trim();
+  if (traceId) {
+    items.push({
+      label: "Trace",
+      value: traceId
+    });
+  }
+  return items.length > 0 ? { items } : void 0;
+}
+function buildSlackReplyBlocks(text, footer) {
+  if (!text.trim() || !footer?.items.length) {
+    return void 0;
+  }
+  return [
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text
       }
-      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;
-      }
-      pendingTimer = setTimer(
-        () => {
-          pendingTimer = null;
-          void flushPending();
-        },
-        Math.max(1, waitMs)
-      );
+    {
+      type: "context",
+      elements: footer.items.map((item) => ({
+        type: "mrkdwn",
+        text: `*${escapeSlackMrkdwn(item.label)}:* ${escapeSlackMrkdwn(item.value)}`
+      }))
     }
-  };
+  ];
 }
 
 // src/chat/slack/reply.ts
@@ -10610,21 +10961,35 @@ import { Buffer as Buffer2 } from "buffer";
 function isInterruptedVisibleReply(reply) {
   return reply.diagnostics.outcome === "provider_error";
 }
-function buildChunkMessage(chunk, files) {
+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 {
-    markdown: chunk,
-    ...files ? { files } : {}
+    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) => ({
-    message: buildChunkMessage(
-      chunk,
-      index === 0 ? args.firstFiles : void 0
-    ),
+    text: chunk,
+    ...index === 0 && args.firstFiles ? { files: args.firstFiles } : {},
     stage: index === 0 ? args.firstStage ?? "thread_reply" : "thread_reply_continuation"
   }));
 }
@@ -10646,150 +11011,100 @@ async function normalizeFileUploads(files) {
     })
   );
 }
-async function uploadReplyFilesBestEffort(args) {
+function findLastTextPostIndex(posts) {
+  for (let index = posts.length - 1; index >= 0; index -= 1) {
+    if (posts[index]?.text.trim().length) {
+      return index;
+    }
+  }
+  return -1;
+}
+async function uploadReplyFiles(args) {
   try {
     await uploadFilesToThread({
       channelId: args.channelId,
       threadTs: args.threadTs,
       files: await normalizeFileUploads(args.files)
     });
-  } catch {
-  }
-}
-function getReplyMessageText(message) {
-  if (typeof message !== "object" || message === null) {
-    return void 0;
-  }
-  if ("markdown" in message && typeof message.markdown === "string") {
-    return message.markdown;
-  }
-  if ("raw" in message && typeof message.raw === "string") {
-    return message.raw;
-  }
-  return void 0;
-}
-function getReplyMessageFiles(message) {
-  if (typeof message === "object" && message !== null && "files" in message && Array.isArray(message.files)) {
-    return message.files;
-  }
-  return void 0;
-}
-function createSlackStreamAccumulator() {
-  let pendingCarriageReturn = false;
-  let streamedVisibleText = "";
-  let streamedRenderedText = "";
-  let overflowText = "";
-  let streamOverflowed = false;
-  const continuationBudget = getSlackStreamingContinuationBudget();
-  const normalizeDelta = (deltaText) => {
-    let text = deltaText;
-    if (pendingCarriageReturn) {
-      text = `\r${text}`;
-      pendingCarriageReturn = false;
-    }
-    if (text.endsWith("\r")) {
-      text = text.slice(0, -1);
-      pendingCarriageReturn = true;
-    }
-    return text.replace(/\r\n?/g, "\n");
-  };
-  return {
-    append(deltaText) {
-      const normalizedDeltaText = normalizeDelta(deltaText);
-      if (!normalizedDeltaText) {
-        return "";
-      }
-      if (streamOverflowed) {
-        overflowText += normalizedDeltaText;
-        return "";
-      }
-      const candidate = `${streamedVisibleText}${normalizedDeltaText}`;
-      const { prefix, renderedPrefix, rest } = takeSlackContinuationPrefix(
-        candidate,
-        continuationBudget
-      );
-      const additional = renderedPrefix.length > streamedRenderedText.length ? renderedPrefix.slice(streamedRenderedText.length) : "";
-      streamedVisibleText = prefix;
-      streamedRenderedText = renderedPrefix;
-      if (rest) {
-        overflowText += rest;
-        streamOverflowed = true;
-      }
-      return additional;
-    },
-    getOverflowText() {
-      return overflowText;
+  } catch (error) {
+    if (args.failureMode === "strict") {
+      throw error;
     }
-  };
+  }
 }
 function planSlackReplyPosts(args) {
   const replyFiles = args.reply.files && args.reply.files.length > 0 ? args.reply.files : void 0;
-  const { shouldPostThreadReply, attachFiles } = resolveReplyDelivery({
-    reply: args.reply,
-    hasStreamedThreadReply: args.hasStreamedThreadReply
-  });
+  const { shouldPostThreadReply, attachFiles } = resolveReplyDelivery(
+    args.reply
+  );
   const interrupted = isInterruptedVisibleReply(args.reply);
   const posts = [];
-  if (args.hasStreamedThreadReply) {
-    if (shouldPostThreadReply && args.streamedOverflowText) {
-      posts.push(
-        ...buildTextPosts({
-          text: args.streamedOverflowText,
-          interrupted,
-          firstStage: "thread_reply_continuation"
-        })
-      );
-    } else if (shouldPostThreadReply && interrupted) {
-      posts.push({
-        message: buildSlackOutputMessage(
-          getSlackInterruptionMarker().trimStart()
-        ),
-        stage: "thread_reply_continuation"
-      });
-    }
-  } else {
-    const textPosts = shouldPostThreadReply ? buildTextPosts({
-      text: args.reply.text,
-      interrupted,
-      firstFiles: attachFiles === "inline" ? replyFiles : void 0
-    }) : [];
-    posts.push(...textPosts);
-    if (attachFiles === "inline" && replyFiles && textPosts.length === 0) {
-      posts.push({
-        message: buildSlackOutputMessage("", replyFiles),
-        stage: "thread_reply"
-      });
-    } else if (shouldPostThreadReply && textPosts.length === 0) {
-      posts.push({
-        message: buildSlackOutputMessage(args.reply.text),
-        stage: "thread_reply"
-      });
-    }
+  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({
-      message: buildSlackOutputMessage("", replyFiles),
-      stage: "thread_reply_files_followup"
+      files: replyFiles,
+      stage: "thread_reply_files_followup",
+      text: ""
     });
   }
   return posts;
 }
 async function postSlackApiReplyPosts(args) {
-  for (const post of args.posts) {
-    const text = getReplyMessageText(post.message);
-    if (text && text.trim().length > 0) {
-      await args.postMessage(args.channelId, args.threadTs, text);
-    }
-    const files = getReplyMessageFiles(post.message);
-    if (!files?.length) {
-      continue;
+  const lastTextPostIndex = findLastTextPostIndex(args.posts);
+  let lastPostedMessageTs;
+  for (const [index, post] of args.posts.entries()) {
+    const hasVisibleDelivery = post.text.trim().length > 0 || post.files?.length;
+    if (hasVisibleDelivery) {
+      await args.beforePost?.();
+    }
+    let messageTs;
+    try {
+      if (post.text.trim().length > 0) {
+        const response = await postSlackMessage({
+          channelId: args.channelId,
+          threadTs: args.threadTs,
+          text: post.text,
+          ...index === lastTextPostIndex && args.footer ? { blocks: buildSlackReplyBlocks(post.text, args.footer) } : {}
+        });
+        messageTs = response.ts;
+        lastPostedMessageTs = response.ts;
+      }
+      if (!post.files?.length) {
+        continue;
+      }
+      await uploadReplyFiles({
+        channelId: args.channelId,
+        failureMode: args.fileUploadFailureMode ?? "best_effort",
+        threadTs: args.threadTs,
+        files: post.files
+      });
+    } catch (error) {
+      await args.onPostError?.({
+        error,
+        messageTs,
+        stage: post.stage
+      });
+      throw error;
     }
-    await uploadReplyFilesBestEffort({
-      channelId: args.channelId,
-      threadTs: args.threadTs,
-      files
-    });
   }
+  return lastPostedMessageTs;
 }
 
 // src/chat/slack/resume.ts
@@ -10804,16 +11119,13 @@ 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,
-    text
-  });
-}
 async function postSlackMessageBestEffort(channelId, threadTs, text) {
   try {
-    await postSlackMessage(channelId, threadTs, text);
+    await postSlackMessage({
+      channelId,
+      threadTs,
+      text
+    });
   } catch {
   }
 }
@@ -10852,7 +11164,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);
@@ -10881,9 +11193,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);
     }
   };
 }
@@ -10902,10 +11214,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;
@@ -10917,9 +11228,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
     });
@@ -10937,19 +11248,23 @@ async function resumeSlackTurn(args) {
         )
       )
     ]) : await replyPromise;
-    await progress.stop();
+    await status.stop();
+    const footer = buildSlackReplyFooter({
+      conversationId: args.replyContext?.correlation?.conversationId ?? lockKey,
+      durationMs: reply.diagnostics.durationMs,
+      traceId: getActiveTraceId(),
+      usage: reply.diagnostics.usage
+    });
     await postSlackApiReplyPosts({
       channelId: args.channelId,
       threadTs: args.threadTs,
-      posts: planSlackReplyPosts({
-        reply,
-        hasStreamedThreadReply: false
-      }),
-      postMessage: postSlackMessage
+      posts: planSlackReplyPosts({ reply }),
+      fileUploadFailureMode: "best_effort",
+      footer
     });
     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);
@@ -11275,7 +11590,8 @@ async function resumeAuthorizedMcpTurn(args) {
       configuration: authSession.configuration,
       channelConfiguration,
       sandbox: getPersistedSandboxState(currentState),
-      threadParticipants: buildThreadParticipants(conversation.messages)
+      threadParticipants: buildThreadParticipants(conversation.messages),
+      ...getTurnUserReplyAttachmentContext(userMessage)
     },
     onSuccess: async (reply) => {
       try {
@@ -11746,11 +12062,11 @@ async function GET5(request, provider, waitUntil) {
   } else if (stored.channelId && stored.threadTs) {
     const { channelId, threadTs } = stored;
     waitUntil(
-      () => postSlackMessage(
+      () => postSlackMessage({
         channelId,
         threadTs,
-        `Your ${providerLabel} account is now connected. You can start using ${providerLabel} commands.`
-      )
+        text: `Your ${providerLabel} account is now connected. You can start using ${providerLabel} commands.`
+      })
     );
   }
   const statusMessage = stored.pendingMessage ? "Your request is being processed in Slack." : "You can close this tab and return to Slack.";
@@ -11929,7 +12245,8 @@ async function resumeTimedOutTurn(payload) {
       conversationContext,
       channelConfiguration,
       sandbox,
-      threadParticipants: buildThreadParticipants(conversation.messages)
+      threadParticipants: buildThreadParticipants(conversation.messages),
+      ...getTurnUserReplyAttachmentContext(userMessage)
     },
     onSuccess: async (reply) => {
       try {
@@ -12386,11 +12703,30 @@ 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);
+  if (channelId) {
+    const rawThreadTs = toOptionalString(rawRecord?.thread_ts);
+    const threadTs = isDmChannel(channelId) ? rawThreadTs : rawThreadTs ?? toOptionalString(rawRecord?.ts);
+    if (threadTs) {
+      return { channelId, threadTs };
+    }
+  }
+  const parsedThreadId = parseSlackThreadId(
+    toOptionalString(message.threadId)
+  );
+  if (!parsedThreadId || isDmChannel(parsedThreadId.channelId)) {
+    return void 0;
+  }
+  return parsedThreadId;
+}
 function getMessageTs(message) {
   const directTs = toOptionalString(
     message.ts
@@ -12743,7 +13079,7 @@ function createSlackTurnRuntime(deps) {
     },
     async handleAssistantContextChanged(event) {
       try {
-        await deps.initializeAssistantThread({
+        await deps.refreshAssistantThreadContext({
           threadId: event.threadId,
           channelId: event.channelId,
           threadTs: event.threadTs,
@@ -12886,13 +13222,16 @@ var MAX_USER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 var MAX_MESSAGE_IMAGE_ATTACHMENTS = 3;
 var MAX_VISION_SUMMARY_CHARS = 500;
 function hasPotentialImageAttachment(attachments) {
-  return attachments?.some((attachment) => {
+  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/");
-  }) ?? false;
+  }).length ?? 0;
 }
 function isVisionEnabled() {
   return Boolean(botConfig.visionModelId);
@@ -13426,45 +13765,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
@@ -13481,14 +13846,6 @@ function getExecutionFailureReason(reply) {
   }
   return "empty assistant turn";
 }
-function shouldAutoStartStreaming(args) {
-  const { text, deltaCount } = args;
-  const trimmed = text.trim();
-  if (!trimmed || isPotentialRedundantReactionAckText(trimmed)) {
-    return false;
-  }
-  return deltaCount >= 2;
-}
 function createReplyToThread(deps) {
   return async function replyToThread(thread, message, options = {}) {
     if (message.author.isMe) {
@@ -13497,6 +13854,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;
@@ -13516,7 +13874,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,
@@ -13587,20 +13944,13 @@ 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 pendingStreamDeltaCount = 0;
-        let awaitingPostToolAssistantMessage = false;
         let beforeFirstResponsePostCalled = false;
-        let streamedReplyState = createSlackStreamAccumulator();
         const beforeFirstResponsePost = async () => {
           if (beforeFirstResponsePostCalled) {
             return;
@@ -13608,70 +13958,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 = "";
-          pendingStreamDeltaCount = 0;
-        };
-        const clearPendingStreamText = () => {
-          pendingStreamText = "";
-          pendingStreamDeltaCount = 0;
-        };
-        const discardPendingStreamPreview = () => {
-          clearPendingStreamText();
-          streamedReplyState = createSlackStreamAccumulator();
-        };
-        const finalizePendingStreamText = () => {
-          if (!pendingStreamText || streamedReplyPromise || isPotentialRedundantReactionAckText(pendingStreamText)) {
-            return;
-          }
-          flushPendingStreamText();
-        };
-        const queueVisibleStreamText = (text) => {
-          if (!text) {
-            return;
-          }
-          if (awaitingPostToolAssistantMessage) {
-            return;
-          }
-          if (streamedReplyPromise) {
-            textStream.push(text);
-            return;
-          }
-          pendingStreamText += text;
-          pendingStreamDeltaCount += 1;
-          if (isPotentialRedundantReactionAckText(pendingStreamText)) {
-            return;
-          }
-          if (!shouldAutoStartStreaming({
-            text: pendingStreamText,
-            deltaCount: pendingStreamDeltaCount
-          })) {
-            return;
-          }
-          flushPendingStreamText();
-        };
-        const appendVisibleStreamDelta = (deltaText) => {
-          if (awaitingPostToolAssistantMessage && !streamedReplyPromise) {
-            return;
-          }
-          queueVisibleStreamText(streamedReplyState.append(deltaText));
-        };
         const postThreadReply = async (payload, stage) => {
           await beforeFirstResponsePost();
           try {
@@ -13691,7 +13977,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 {
@@ -13712,6 +14011,8 @@ function createReplyToThread(deps) {
             artifactState: preparedState.artifacts,
             configuration: preparedState.configuration,
             channelConfiguration: preparedState.channelConfiguration,
+            inboundAttachmentCount: message.attachments.length,
+            omittedImageAttachmentCount,
             userAttachments,
             correlation: {
               conversationId,
@@ -13738,33 +14039,8 @@ function createReplyToThread(deps) {
               await persistThreadState(thread, { artifacts });
             },
             threadParticipants,
-            onStatus: (status) => progress.setStatus(status),
-            onTextDelta: (deltaText) => {
-              if (explicitChannelPostIntent) {
-                return;
-              }
-              appendVisibleStreamDelta(deltaText);
-            },
-            onAssistantMessageStart: () => {
-              if (!awaitingPostToolAssistantMessage) {
-                return;
-              }
-              awaitingPostToolAssistantMessage = false;
-              discardPendingStreamPreview();
-            },
-            onToolCall: () => {
-              if (!streamedReplyPromise) {
-                awaitingPostToolAssistantMessage = true;
-                discardPendingStreamPreview();
-              }
-            }
+            onStatus: (nextStatus) => status.update(nextStatus)
           });
-          if (streamedReplyPromise) {
-            flushPendingStreamText();
-          } else {
-            finalizePendingStreamText();
-          }
-          textStream.end();
           const diagnosticsContext = {
             slackThreadId: threadId,
             slackUserId: message.author.userId,
@@ -13839,30 +14115,73 @@ function createReplyToThread(deps) {
           const reactionPerformed = reply.diagnostics.toolCalls.includes(
             "slackMessageAddReaction"
           );
-          const plannedPosts = planSlackReplyPosts({
-            reply,
-            hasStreamedThreadReply: Boolean(streamedReplyPromise),
-            streamedOverflowText: streamedReplyState.getOverflowText()
+          const plannedPosts = planSlackReplyPosts({ reply });
+          const replyFooter = buildSlackReplyFooter({
+            conversationId,
+            durationMs: reply.diagnostics.durationMs,
+            traceId: getActiveTraceId(),
+            usage: reply.diagnostics.usage
           });
-          if (streamedReplyPromise) {
-            await streamedReplyPromise;
-          }
+          const shouldUseSlackFooter = Boolean(replyFooter) && Boolean(channelId && threadTs) && thread.adapter?.name === "slack";
           if (plannedPosts.length > 0) {
-            if (!streamedReplyPromise) {
-              let sent;
-              for (const post of plannedPosts) {
-                sent = await postThreadReply(post.message, post.stage);
+            let sent;
+            if (shouldUseSlackFooter) {
+              const slackChannelId = channelId;
+              const slackThreadTs = threadTs;
+              if (!slackChannelId || !slackThreadTs) {
+                throw new Error(
+                  "Slack footer delivery requires a concrete channel and thread timestamp"
+                );
               }
-              const firstPlannedMessage = plannedPosts[0]?.message;
-              const firstPlannedMessageHasFiles = typeof firstPlannedMessage === "object" && firstPlannedMessage !== null && "files" in firstPlannedMessage && Array.isArray(firstPlannedMessage.files) && firstPlannedMessage.files.length > 0;
-              if (sent && reactionPerformed && plannedPosts.length === 1 && !firstPlannedMessageHasFiles && isRedundantReactionAckText(reply.text)) {
-                await sent.delete();
+              const sentMessageTs = await postSlackApiReplyPosts({
+                beforePost: beforeFirstResponsePost,
+                channelId: slackChannelId,
+                threadTs: slackThreadTs,
+                posts: plannedPosts,
+                fileUploadFailureMode: "strict",
+                footer: replyFooter,
+                onPostError: ({ error, messageTs: messageTs2, stage }) => {
+                  logException(
+                    error,
+                    "slack_thread_post_failed",
+                    turnTraceContext,
+                    {
+                      "app.slack.reply_stage": stage,
+                      ...messageTs2 ? { "messaging.message.id": messageTs2 } : {},
+                      ...getSlackErrorObservabilityAttributes(error)
+                    },
+                    "Failed to post Slack thread reply"
+                  );
+                }
+              });
+              if (sentMessageTs) {
+                sent = {
+                  id: sentMessageTs,
+                  text: reply.text,
+                  delete: async () => {
+                    await deleteSlackMessage({
+                      channelId: slackChannelId,
+                      timestamp: sentMessageTs
+                    });
+                  }
+                };
               }
             } else {
               for (const post of plannedPosts) {
-                await postThreadReply(post.message, post.stage);
+                sent = await postThreadReply(
+                  buildSlackOutputMessage(post.text, post.files),
+                  post.stage
+                );
               }
             }
+            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;
@@ -13891,73 +14210,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"
-              );
-            });
-          }
         } 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,
@@ -13978,7 +14241,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,
@@ -14000,7 +14263,6 @@ function createReplyToThread(deps) {
           shouldPersistFailureState = true;
           throw error;
         } finally {
-          textStream.end();
           if (!persistedAtLeastOnce && shouldPersistFailureState) {
             markTurnFailed({
               conversation: preparedState.conversation,
@@ -14025,19 +14287,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."
@@ -14048,24 +14317,30 @@ 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) {
@@ -14093,6 +14368,7 @@ function createPrepareTurnState(deps) {
     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 = {
@@ -14107,7 +14383,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
       }
@@ -14261,6 +14539,20 @@ function createSlackRuntime(options) {
         sourceChannelId,
         getSlackAdapter: options.getSlackAdapter
       });
+    },
+    refreshAssistantThreadContext: async ({
+      threadId,
+      channelId,
+      threadTs,
+      sourceChannelId
+    }) => {
+      await refreshAssistantThreadContext({
+        threadId,
+        channelId,
+        threadTs,
+        sourceChannelId,
+        getSlackAdapter: options.getSlackAdapter
+      });
     }
   });
 }
@@ -14333,14 +14625,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,
@@ -14351,14 +14643,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;
@@ -14379,20 +14676,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;
@@ -14430,7 +14726,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,
@@ -14501,160 +14797,8 @@ var JuniorChat = class extends Chat {
 import {
   createSlackAdapter
 } from "@chat-adapter/slack";
-import {
-  StreamingMarkdownRenderer
-} from "chat";
-var STREAM_BUFFER_SIZE = 64;
-var CLIENT_STREAM_PATCHED = /* @__PURE__ */ Symbol("junior.slack.client_stream_patched");
-var ADAPTER_STREAM_PATCHED = /* @__PURE__ */ Symbol("junior.slack.adapter_stream_patched");
-function assertSlackAdapterInternals(internals) {
-  if (!internals.client || typeof internals.client.chatStream !== "function") {
-    throw new Error("Slack adapter client does not expose chatStream()");
-  }
-  if (typeof internals.stream !== "function") {
-    throw new Error("Slack adapter does not expose stream()");
-  }
-  if (typeof internals.decodeThreadId !== "function") {
-    throw new Error("Slack adapter does not expose decodeThreadId()");
-  }
-  if (typeof internals.getToken !== "function") {
-    throw new Error("Slack adapter does not expose getToken()");
-  }
-  if (!internals.logger || typeof internals.logger.debug !== "function" || typeof internals.logger.warn !== "function") {
-    throw new Error("Slack adapter does not expose logger debug/warn methods");
-  }
-}
-function shouldEagerFlushPlainText(text) {
-  return text.length > 0 && !text.includes("\n") && !/[`*~[\]|]/.test(text);
-}
-function getNextRenderableDelta(renderer, lastAppended) {
-  const committable = renderer.getCommittableText();
-  if (committable.startsWith(lastAppended)) {
-    const delta = committable.slice(lastAppended.length);
-    if (delta) {
-      return { delta, nextAppended: committable };
-    }
-  }
-  const rawText = renderer.getText();
-  if (shouldEagerFlushPlainText(rawText) && rawText.startsWith(lastAppended) && rawText.length > lastAppended.length) {
-    return {
-      delta: rawText.slice(lastAppended.length),
-      nextAppended: rawText
-    };
-  }
-  return { delta: "", nextAppended: lastAppended };
-}
-function patchSlackClientStream(adapter) {
-  const internals = adapter;
-  const { client: client2 } = internals;
-  if (client2[CLIENT_STREAM_PATCHED]) {
-    return;
-  }
-  const originalChatStream = client2.chatStream.bind(client2);
-  client2.chatStream = (params) => originalChatStream({
-    ...params,
-    buffer_size: STREAM_BUFFER_SIZE
-  });
-  client2[CLIENT_STREAM_PATCHED] = true;
-}
-function patchSlackAdapterStream(adapter) {
-  const internals = adapter;
-  if (internals[ADAPTER_STREAM_PATCHED]) {
-    return;
-  }
-  const originalStream = internals.stream.bind(adapter);
-  internals.stream = async function(threadId, textStream, options) {
-    if (!(options?.recipientUserId && options?.recipientTeamId)) {
-      return originalStream(threadId, textStream, options);
-    }
-    const { channel, threadTs } = internals.decodeThreadId(threadId);
-    internals.logger.debug("Slack: starting stream", { channel, threadTs });
-    const token = internals.getToken();
-    const streamer = internals.client.chatStream({
-      channel,
-      thread_ts: threadTs,
-      recipient_user_id: options.recipientUserId,
-      recipient_team_id: options.recipientTeamId,
-      ...options.taskDisplayMode ? { task_display_mode: options.taskDisplayMode } : {}
-    });
-    let first = true;
-    let lastAppended = "";
-    let structuredChunksSupported = true;
-    const renderer = new StreamingMarkdownRenderer();
-    const flushMarkdownDelta = async (delta) => {
-      if (delta.length === 0) {
-        return;
-      }
-      if (first) {
-        await streamer.append({ markdown_text: delta, token, chunks: [] });
-        first = false;
-        return;
-      }
-      await streamer.append({ markdown_text: delta });
-    };
-    const flushText = async () => {
-      const { delta, nextAppended } = getNextRenderableDelta(
-        renderer,
-        lastAppended
-      );
-      await flushMarkdownDelta(delta);
-      lastAppended = nextAppended;
-    };
-    const sendStructuredChunk = async (chunk) => {
-      if (!structuredChunksSupported) {
-        return;
-      }
-      await flushText();
-      try {
-        if (first) {
-          await streamer.append({ chunks: [chunk], token });
-          first = false;
-          return;
-        }
-        await streamer.append({ chunks: [chunk] });
-      } catch (error) {
-        structuredChunksSupported = false;
-        internals.logger.warn(
-          "Structured streaming chunk failed, falling back to text-only streaming. Ensure your Slack app manifest includes assistant_view, assistant:write scope, and @slack/web-api >= 7.14.0",
-          { chunkType: chunk.type, error }
-        );
-      }
-    };
-    const pushTextAndFlush = async (text) => {
-      renderer.push(text);
-      await flushText();
-    };
-    for await (const chunk of textStream) {
-      if (typeof chunk === "string") {
-        await pushTextAndFlush(chunk);
-      } else if (chunk.type === "markdown_text") {
-        await pushTextAndFlush(chunk.text);
-      } else {
-        await sendStructuredChunk(chunk);
-      }
-    }
-    renderer.finish();
-    await flushText();
-    const result = await streamer.stop(
-      options?.stopBlocks ? { blocks: options.stopBlocks } : void 0
-    );
-    const messageTs = result.message?.ts ?? result.ts;
-    internals.logger.debug("Slack: stream complete", { messageId: messageTs });
-    return {
-      id: messageTs,
-      threadId,
-      raw: result
-    };
-  };
-  internals[ADAPTER_STREAM_PATCHED] = true;
-}
 function createJuniorSlackAdapter(config) {
-  const adapter = createSlackAdapter(config);
-  const internals = adapter;
-  assertSlackAdapterInternals(internals);
-  patchSlackClientStream(adapter);
-  patchSlackAdapterStream(adapter);
-  return adapter;
+  return createSlackAdapter(config);
 }
 
 // src/chat/queue/thread-message-dispatcher.ts