@sentry/junior 0.26.0 → 0.27.1

package/dist/app.js

@@ -25,7 +25,7 @@ import {
   sandboxSkillDir,
   sandboxSkillFile,
   toOptionalTrimmed
-} from "./chunk-A75TWGF2.js";
+} from "./chunk-4PVJHUEV.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -884,6 +884,9 @@ function mapSlackError(error) {
   if (apiError === "invalid_arguments") {
     return new SlackActionError(message, "invalid_arguments", baseOptions);
   }
+  if (apiError === "invalid_cursor") {
+    return new SlackActionError(message, "invalid_arguments", baseOptions);
+  }
   if (apiError === "invalid_name") {
     return new SlackActionError(message, "invalid_arguments", baseOptions);
   }
@@ -2396,20 +2399,23 @@ function buildConversationContext(conversation, options = {}) {
     lines.push("<thread-compactions>");
     for (const [index, compaction] of conversation.compactions.entries()) {
       lines.push(
-        [
-          `summary_${index + 1}:`,
-          compaction.summary,
-          `covered_messages: ${compaction.coveredMessageIds.length}`,
-          `created_at: ${new Date(compaction.createdAtMs).toISOString()}`
-        ].join(" ")
+        `  <compaction index="${index + 1}" covered_messages="${compaction.coveredMessageIds.length}" created_at="${new Date(compaction.createdAtMs).toISOString()}">`,
+        compaction.summary,
+        "  </compaction>"
       );
     }
-    lines.push("</thread-compactions>");
-    lines.push("");
+    lines.push("</thread-compactions>", "");
   }
   lines.push("<thread-transcript>");
-  for (const message of messages) {
-    lines.push(renderConversationMessageLine(message, conversation));
+  for (const [index, message] of messages.entries()) {
+    const author = escapeXml(message.author?.userName ?? message.role);
+    const ts = new Date(message.createdAtMs).toISOString();
+    const slackTsAttr = message.meta?.slackTs ? ` slack_ts="${escapeXml(message.meta.slackTs)}"` : "";
+    lines.push(
+      `  <message index="${index + 1}" ts="${ts}" role="${message.role}" author="${author}"${slackTsAttr}>`,
+      renderConversationMessageLine(message, conversation),
+      "  </message>"
+    );
   }
   lines.push("</thread-transcript>");
   return lines.join("\n");
@@ -2441,9 +2447,14 @@ async function summarizeConversationChunk(messages, conversation, context, deps)
           role: "user",
           content: [
             "Summarize the following older Slack thread transcript segment for future assistant turns.",
-            "Keep the summary factual and concise.",
-            "Preserve decisions, commitments, constraints, locations, hiring criteria, and unresolved asks.",
-            "Do not invent details.",
+            "Keep the summary factual and concise. Do not invent details.",
+            "",
+            "Output exactly three XML sections in this order:",
+            "<active-asks> one bullet per outstanding user ask that has not been narrowed, answered, or superseded by a later turn. Omit the section body if none. </active-asks>",
+            "<superseded-or-completed-asks> one bullet per ask that has been rescoped, narrowed, answered, or already acted on in this segment. Include the replacement/outcome inline. Omit the section body if none. </superseded-or-completed-asks>",
+            "<facts> one bullet per durable fact useful regardless of scope: names, ids, URLs, decisions, locations, preferences, constraints that remain true. Omit the section body if none. </facts>",
+            "",
+            "Do not output any text outside the three sections.",
             "",
             transcript
           ].join("\n"),
@@ -2690,135 +2701,6 @@ function truncateStatusText(text) {
   }
   return truncateWithEllipsis(trimmed, SLACK_STATUS_MAX_LENGTH);
 }
-function compactStatusPath(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  if (trimmed.length <= 80) {
-    return trimmed;
-  }
-  return `...${trimmed.slice(-77)}`;
-}
-function compactStatusText(value, maxLength = 80) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  return truncateWithEllipsis(trimmed, maxLength);
-}
-function readShellToken(command, startIndex) {
-  let index = startIndex;
-  while (index < command.length && /\s/.test(command[index] ?? "")) {
-    index += 1;
-  }
-  if (index >= command.length) {
-    return void 0;
-  }
-  let token = "";
-  let quote;
-  while (index < command.length) {
-    const char = command[index];
-    if (!char) {
-      break;
-    }
-    if (quote) {
-      if (char === quote) {
-        quote = void 0;
-        index += 1;
-        continue;
-      }
-      if (char === "\\" && quote === '"' && index + 1 < command.length) {
-        token += command[index + 1];
-        index += 2;
-        continue;
-      }
-      token += char;
-      index += 1;
-      continue;
-    }
-    if (/\s/.test(char)) {
-      break;
-    }
-    if (char === '"' || char === "'") {
-      quote = char;
-      index += 1;
-      continue;
-    }
-    if (char === "\\" && index + 1 < command.length) {
-      token += command[index + 1];
-      index += 2;
-      continue;
-    }
-    token += char;
-    index += 1;
-  }
-  return { token, nextIndex: index };
-}
-function compactStatusCommand(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  let index = 0;
-  while (index < trimmed.length) {
-    const parsed = readShellToken(trimmed, index);
-    if (!parsed) {
-      return void 0;
-    }
-    index = parsed.nextIndex;
-    if (!parsed.token) {
-      continue;
-    }
-    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(parsed.token)) {
-      continue;
-    }
-    const normalized = parsed.token.replace(/[\\/]+$/g, "");
-    if (!normalized) {
-      return void 0;
-    }
-    const parts = normalized.split(/[\\/]/).filter((part) => part.length > 0);
-    const command = parts.length > 0 ? parts[parts.length - 1] : normalized;
-    return compactStatusText(command, 40);
-  }
-  return void 0;
-}
-function compactStatusFilename(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim().replace(/[\\/]+$/g, "");
-  if (!trimmed) {
-    return void 0;
-  }
-  const parts = trimmed.split(/[\\/]/).filter((part) => part.length > 0);
-  const filename = parts.length > 0 ? parts[parts.length - 1] : trimmed;
-  return compactStatusText(filename, 80);
-}
-function extractStatusUrlDomain(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  try {
-    const parsed = new URL(trimmed);
-    return parsed.hostname || void 0;
-  } catch {
-    return void 0;
-  }
-}
 
 // src/chat/slack/mrkdwn.ts
 function ensureBlockSpacing(text) {
@@ -3472,7 +3354,7 @@ function buildSystemPrompt(params) {
       [
         "- For factual or external questions, run tools/skills first, then answer from evidence.",
         "- Use tool descriptions as the source of truth for when each tool should or should not be called.",
-        "- Use `bash` to inspect skill files from `skill_dir` and run shell commands inside the sandbox workspace.",
+        "- Use `reportProgress` only for sparse, meaningful progress updates. Pass a short user-facing status message, and do not call it for every tool or small substep.",
         "- When using CLI tools through `bash`, prefer deterministic non-interactive flags and avoid commands that wait for prompts or editors.",
         "- Keep routine setup and research steps silent in user-facing replies. Do not narrate duplicate checks, credential issuance, file writes, or similar internal progress unless the result is user-relevant.",
         "- If a routine prerequisite check finds nothing notable, omit it entirely from the final reply and report only the user-relevant outcome.",
@@ -3482,22 +3364,11 @@ function buildSystemPrompt(params) {
         "- When the user provides multiple sources, synthesize them explicitly as one combined answer instead of anchoring the reply on a single page or API call.",
         "- When the user provides explicit URLs or named sources, briefly anchor the answer to those provided sources (for example, 'Across the provided Slack docs...') so the summary reads as researched rather than generic memory.",
         "- Do not include internal process chatter such as 'let me find', 'fetching now', 'good, I have sources', 'trying smaller limits', or 'I now have sufficient context' in the final user-facing reply.",
-        "- Use `attachFile` for files that actually exist in the sandbox (for example screenshots, PDFs, logs), or for `attachment_path` values returned by `imageGenerate`.",
-        "- If the user asks to see/share/show a screenshot or file, attach the file with `attachFile` instead of only reporting its path.",
         "- Never claim a screenshot/file is attached unless `attachFile` succeeded in this turn.",
         "- If `attachFile` fails, explain the failure and do not say the file was shared.",
-        "- Use `imageGenerate` when the user asks for image creation.",
-        "- `imageGenerate` returns generated image metadata, including `attachment_path` values you can pass to `attachFile` when the user should receive the image.",
-        "- Use `slackCanvasCreate` for long-form docs/specs and `slackCanvasUpdate` for doc follow-ups.",
-        "- `slackCanvasUpdate` targets the active artifact-context canvas automatically; do not ask the user for `canvas_id`.",
         "- When you create or update a Slack artifact in this turn (for example a canvas, list, posted message, or attached file), mention it explicitly in the final reply and include its link when the tool returned one.",
-        "- Use `slackListCreate`, `slackListAddItems`, and `slackListUpdateItem` for actionable task tracking.",
-        "- `slackListAddItems`, `slackListGetItems`, and `slackListUpdateItem` target the active artifact-context list automatically; do not ask the user for `list_id`.",
-        "- If the user explicitly asks to post/send/share/say/show/announce/broadcast in the channel (outside this thread), call `slackChannelPostMessage` with the requested text instead of only replying in-thread.",
         "- For explicit in-channel post requests, prefer no thread text reply after a successful channel post. A reaction-only acknowledgment is acceptable when useful.",
-        "- Use `slackMessageAddReaction` for rare lightweight acknowledgements. It reacts to the current inbound message via runtime context; never pick a target message yourself.",
-        "- If the user explicitly asks for an emoji reaction instead of text, use `slackMessageAddReaction` with a Slack emoji alias name (for example `thumbsup`, `white_check_mark`, or `eyes`, not unicode emoji), and avoid redundant acknowledgment text.",
-        "- Suggested acknowledgement reactions include `wave`, `white_check_mark`, `thumbsup`, and `eyes`, but choose what best fits the request.",
+        "- When the user explicitly asks for an emoji reaction instead of text, react and skip the text reply.",
         "- After the matching plugin-owned skill is loaded, authenticated bash commands for that skill get provider credentials injected automatically for the current turn.",
         "- Resolve repo/project/org defaults before authenticated provider commands so the runtime can narrow injected credentials correctly.",
         "- If no loaded skill clearly owns the authenticated command, load the matching skill first instead of guessing from the provider catalog.",
@@ -3508,10 +3379,7 @@ function buildSystemPrompt(params) {
         "- `jr-rpc` config commands are built into the bash runtime for conversation-scoped config work; they do not require a separate helper binary in the sandbox.",
         "- When your work is complete, provide the exact user-facing markdown response.",
         "- Do not use reaction-based progress signals; Assistants API status already covers in-progress UX.",
-        "- Prefer `webSearch` before `webFetch` when the user gave no URL.",
         "- Never call side-effecting tools when the user only asked for analysis or options.",
-        "- `loadSkill` activates MCP tools when the loaded skill exposes them. After loading, call them directly by name (for example `mcp__provider__tool_name`).",
-        "- `searchTools` searches active MCP tools exposed by currently loaded skills when you need to rediscover or filter them.",
         "- When the user asks for their conversation ID, trace ID, or a reference for Sentry lookup, use the IDs from `<session-context>` and `<turn-context>` in the user turn."
       ].join("\n")
     ),
@@ -3529,8 +3397,7 @@ function buildSystemPrompt(params) {
         "- Never apply skill-specific behavior unless the skill is present in <loaded_skills> or `loadSkill` succeeded in this turn.",
         "- Load only the best matching skill first; do not load multiple skills upfront.",
         "- After `loadSkill`, use `skill_dir` as the root for any referenced files you read via `bash`.",
-        "- If a loaded skill exposes MCP tools, they are registered as callable tools after `loadSkill` returns. Call them directly by name.",
-        "- Use `searchTools` only when you need to rediscover or filter the currently exposed MCP tools.",
+        "- If a loaded skill exposes MCP tools, they are registered as callable tools after `loadSkill` returns. Call them directly by name (for example `mcp__provider__tool_name`).",
         "- If no skill is a clear fit, continue with normal tool usage."
       ].join("\n")
     ),
@@ -5193,8 +5060,22 @@ function createReadFileTool() {
   });
 }
 
-// src/chat/tools/skill/search-tools.ts
+// src/chat/tools/runtime/report-progress.ts
 import { Type as Type6 } from "@sinclair/typebox";
+function createReportProgressTool() {
+  return tool({
+    description: "Update assistant status with a short user-facing progress message. Use this sparingly for meaningful progress changes, not for every tool call or minor substep.",
+    inputSchema: Type6.Object({
+      message: Type6.String({
+        minLength: 1,
+        description: "Short user-facing progress message. The UI truncates it if needed."
+      })
+    })
+  });
+}
+
+// src/chat/tools/skill/search-tools.ts
+import { Type as Type7 } from "@sinclair/typebox";
 
 // src/chat/tools/skill/mcp-tool-summary.ts
 function summarizeInputSchema(schema) {
@@ -5226,20 +5107,20 @@ var MAX_LIMIT = 20;
 function createSearchToolsTool(mcpToolManager, getActiveSkills) {
   return tool({
     description: "Search active MCP tools exposed by the currently loaded skills. Use when you need to rediscover or filter active tools.",
-    inputSchema: Type6.Object(
+    inputSchema: Type7.Object(
       {
-        query: Type6.String({
+        query: Type7.String({
           minLength: 1,
           description: "Search query for matching MCP tool names or descriptions."
         }),
-        provider: Type6.Optional(
-          Type6.String({
+        provider: Type7.Optional(
+          Type7.String({
             minLength: 1,
             description: "Optional MCP provider filter, for example notion or sentry."
           })
         ),
-        limit: Type6.Optional(
-          Type6.Integer({
+        limit: Type7.Optional(
+          Type7.Integer({
             minimum: 1,
             maximum: MAX_LIMIT,
             description: "Maximum number of matching tools to return."
@@ -5265,7 +5146,7 @@ function createSearchToolsTool(mcpToolManager, getActiveSkills) {
 }
 
 // src/chat/tools/slack/channel-list-messages.ts
-import { Type as Type7 } from "@sinclair/typebox";
+import { Type as Type8 } from "@sinclair/typebox";
 
 // src/chat/slack/channel.ts
 async function listChannelMessages(input) {
@@ -5354,39 +5235,39 @@ async function listThreadReplies(input) {
 function createSlackChannelListMessagesTool(context) {
   return tool({
     description: "List channel messages from Slack history in the active channel context. Use when the user asks for recent or historical channel context outside this thread. Do not use for live monitoring or when current thread context already answers the question.",
-    inputSchema: Type7.Object({
-      limit: Type7.Optional(
-        Type7.Integer({
+    inputSchema: Type8.Object({
+      limit: Type8.Optional(
+        Type8.Integer({
           minimum: 1,
           maximum: 1e3,
           description: "Maximum number of messages to return across pages."
         })
       ),
-      cursor: Type7.Optional(
-        Type7.String({
+      cursor: Type8.Optional(
+        Type8.String({
           minLength: 1,
           description: "Optional cursor to continue from a prior call."
         })
       ),
-      oldest: Type7.Optional(
-        Type7.String({
+      oldest: Type8.Optional(
+        Type8.String({
           minLength: 1,
           description: "Optional oldest message timestamp (Slack ts) for range filtering."
         })
       ),
-      latest: Type7.Optional(
-        Type7.String({
+      latest: Type8.Optional(
+        Type8.String({
           minLength: 1,
           description: "Optional latest message timestamp (Slack ts) for range filtering."
         })
       ),
-      inclusive: Type7.Optional(
-        Type7.Boolean({
+      inclusive: Type8.Optional(
+        Type8.Boolean({
           description: "Whether oldest/latest bounds should be inclusive."
         })
       ),
-      max_pages: Type7.Optional(
-        Type7.Integer({
+      max_pages: Type8.Optional(
+        Type8.Integer({
           minimum: 1,
           maximum: 10,
           description: "Maximum number of API pages to traverse in a single call."
@@ -5408,15 +5289,26 @@ function createSlackChannelListMessagesTool(context) {
           error: "No active channel context is available for history lookup"
         };
       }
-      const result = await listChannelMessages({
-        channelId: targetChannelId,
-        limit: limit ?? 100,
-        cursor,
-        oldest,
-        latest,
-        inclusive,
-        maxPages: max_pages
-      });
+      let result;
+      try {
+        result = await listChannelMessages({
+          channelId: targetChannelId,
+          limit: limit ?? 100,
+          cursor,
+          oldest,
+          latest,
+          inclusive,
+          maxPages: max_pages
+        });
+      } catch (error) {
+        if (error instanceof SlackActionError && error.apiError === "invalid_cursor") {
+          return {
+            ok: false,
+            error: "The supplied Slack history cursor is no longer valid. Retry the lookup without `cursor` to start from the newest page again."
+          };
+        }
+        throw error;
+      }
       return {
         ok: true,
         channel_id: targetChannelId,
@@ -5429,7 +5321,7 @@ function createSlackChannelListMessagesTool(context) {
 }
 
 // src/chat/tools/slack/channel-post-message.ts
-import { Type as Type8 } from "@sinclair/typebox";
+import { Type as Type9 } from "@sinclair/typebox";
 
 // src/chat/tools/idempotency.ts
 function stableSerialize(value) {
@@ -5451,8 +5343,8 @@ function createOperationKey(toolName, input) {
 function createSlackChannelPostMessageTool(context, state) {
   return tool({
     description: "Post a message in the active Slack channel context (outside the thread). Use this when the user explicitly asks to post/send/share/say something in the channel. Do not use for normal thread replies or speculative broadcasts. Do not claim a channel message was posted unless this tool succeeds in this turn.",
-    inputSchema: Type8.Object({
-      text: Type8.String({
+    inputSchema: Type9.Object({
+      text: Type9.String({
         minLength: 1,
         maxLength: 4e4,
         description: "Slack mrkdwn text to post."
@@ -5495,12 +5387,12 @@ function createSlackChannelPostMessageTool(context, state) {
 }
 
 // src/chat/tools/slack/message-add-reaction.ts
-import { Type as Type9 } from "@sinclair/typebox";
+import { Type as Type10 } from "@sinclair/typebox";
 function createSlackMessageAddReactionTool(context, state) {
   return tool({
     description: "Add an emoji reaction to the current inbound Slack message. Use sparingly for lightweight acknowledgements. Provide a Slack emoji alias name (for example `thumbsup`, `white_check_mark`, or `thumbsup::skin-tone-6`), not a unicode emoji glyph. The target message is injected by runtime context; do not use this for arbitrary historical messages.",
-    inputSchema: Type9.Object({
-      emoji: Type9.String({
+    inputSchema: Type10.Object({
+      emoji: Type10.String({
         minLength: 1,
         maxLength: 64,
         description: "Slack emoji alias name to react with (for example `thumbsup`, `white_check_mark`, or `thumbsup::skin-tone-6`). Optional surrounding colons are allowed."
@@ -5558,7 +5450,7 @@ function createSlackMessageAddReactionTool(context, state) {
 }
 
 // src/chat/tools/slack/canvas-tools.ts
-import { Type as Type10 } from "@sinclair/typebox";
+import { Type as Type11 } from "@sinclair/typebox";
 
 // src/chat/tools/slack/canvases.ts
 function normalizeCanvasMarkdown(markdown) {
@@ -5577,19 +5469,11 @@ function normalizeCanvasMarkdown(markdown) {
 async function createCanvas(input) {
   const client2 = getSlackClient();
   const normalizedChannelId = normalizeSlackConversationId(input.channelId);
-  const isConversationScoped = isConversationScopedChannel(normalizedChannelId);
-  if (!isConversationScoped) {
-    throw new Error(
-      "Canvas creation requires an active Slack conversation context (C/G/D)."
-    );
-  }
   const channelPrefix = normalizedChannelId?.slice(0, 1) ?? "none";
-  const action = "conversations.canvases.create";
   const normalizedContent = normalizeCanvasMarkdown(input.markdown);
   const result = await withSlackRetries(
     async () => {
-      return client2.conversations.canvases.create({
-        channel_id: normalizedChannelId,
+      return client2.canvases.create({
         title: input.title,
         document_content: {
           type: "markdown",
@@ -5599,7 +5483,7 @@ async function createCanvas(input) {
     },
     3,
     {
-      action,
+      action: "canvases.create",
       attributes: {
         "app.slack.canvas.channel_id_prefix": channelPrefix,
         "app.slack.canvas.has_channel_id": Boolean(input.channelId),
@@ -5613,6 +5497,9 @@ async function createCanvas(input) {
   if (!result.canvas_id) {
     throw new Error("Slack canvas was created without canvas_id");
   }
+  if (normalizedChannelId && isConversationScopedChannel(normalizedChannelId)) {
+    await grantChannelCanvasAccess(result.canvas_id, normalizedChannelId);
+  }
   let permalink;
   try {
     permalink = await getFilePermalink(result.canvas_id);
@@ -5623,6 +5510,39 @@ async function createCanvas(input) {
     permalink
   };
 }
+async function grantChannelCanvasAccess(canvasId, channelId) {
+  const client2 = getSlackClient();
+  try {
+    await withSlackRetries(
+      () => client2.canvases.access.set({
+        canvas_id: canvasId,
+        access_level: "write",
+        channel_ids: [channelId]
+      }),
+      3,
+      {
+        action: "canvases.access.set",
+        attributes: {
+          "app.slack.canvas.canvas_id_prefix": canvasId.slice(0, 1),
+          "app.slack.canvas.channel_id_prefix": channelId.slice(0, 1),
+          "app.slack.canvas.access_level": "write"
+        }
+      }
+    );
+  } catch (error) {
+    logWarn(
+      "slack_canvas_access_set_failed",
+      {},
+      {
+        "app.slack.action": "canvases.access.set",
+        "app.slack.canvas.canvas_id_prefix": canvasId.slice(0, 1),
+        "app.slack.canvas.channel_id_prefix": channelId.slice(0, 1),
+        "app.slack.canvas.access_level": "write"
+      },
+      error instanceof Error ? error.message : "Failed to grant channel access to canvas"
+    );
+  }
+}
 async function lookupCanvasSection(canvasId, containsText) {
   const client2 = getSlackClient();
   const response = await withSlackRetries(
@@ -5673,8 +5593,64 @@ async function updateCanvas(input) {
     }
   );
 }
+var CANVAS_ID_PATTERN = /^F[A-Z0-9]+$/i;
+var CANVAS_URL_FILE_ID_PATTERN = /\/(?:docs|canvas|files)\/(?:T[A-Z0-9]+\/)?(?:U[A-Z0-9]+\/)?(F[A-Z0-9]+)/i;
+function extractCanvasId(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return void 0;
+  if (CANVAS_ID_PATTERN.test(trimmed)) {
+    return trimmed.toUpperCase();
+  }
+  const urlMatch = trimmed.match(CANVAS_URL_FILE_ID_PATTERN);
+  if (urlMatch?.[1]) {
+    return urlMatch[1].toUpperCase();
+  }
+  return void 0;
+}
+async function readCanvas(canvasIdOrUrl) {
+  const canvasId = extractCanvasId(canvasIdOrUrl);
+  if (!canvasId) {
+    throw new Error(
+      "Could not parse a Slack canvas/file ID from the provided input."
+    );
+  }
+  const client2 = getSlackClient();
+  const info = await withSlackRetries(
+    () => client2.files.info({
+      file: canvasId
+    }),
+    3,
+    {
+      action: "files.info",
+      attributes: {
+        "app.slack.canvas.canvas_id_prefix": canvasId.slice(0, 1)
+      }
+    }
+  );
+  const file = info.file;
+  if (!file) {
+    throw new Error("Slack returned no file metadata for canvas.");
+  }
+  const downloadUrl = file.url_private_download ?? file.url_private;
+  if (!downloadUrl) {
+    throw new Error(
+      "Canvas has no downloadable URL; bot token may lack file access."
+    );
+  }
+  const buffer = await downloadPrivateSlackFile(downloadUrl);
+  return {
+    canvasId,
+    title: file.title ?? file.name,
+    permalink: file.permalink,
+    mimetype: file.mimetype,
+    filetype: file.filetype,
+    content: buffer.toString("utf-8"),
+    byteLength: buffer.byteLength
+  };
+}
 
 // src/chat/tools/slack/canvas-tools.ts
+var MAX_CANVAS_READ_CHARS = 4e4;
 var MAX_RECENT_CANVASES = 5;
 function mergeRecentCanvases(existing, created) {
   const nextEntry = {
@@ -5690,13 +5666,13 @@ function mergeRecentCanvases(existing, created) {
 function createSlackCanvasCreateTool(context, state) {
   return tool({
     description: "Create a Slack canvas for long-form output in the active assistant context channel. Use when content is too long for a thread reply or needs a persistent document. Do not use for short answers that fit in-thread.",
-    inputSchema: Type10.Object({
-      title: Type10.String({
+    inputSchema: Type11.Object({
+      title: Type11.String({
         minLength: 1,
         maxLength: 160,
         description: "Canvas title."
       }),
-      markdown: Type10.String({
+      markdown: Type11.String({
         minLength: 1,
         description: "Canvas markdown body content."
       })
@@ -5762,29 +5738,29 @@ function createSlackCanvasCreateTool(context, state) {
 function createSlackCanvasUpdateTool(state, _context) {
   return tool({
     description: "Update the active Slack canvas tracked in artifact context. Use when continuing or correcting a document already tracked in this thread. Do not use to create a brand-new long-form artifact.",
-    inputSchema: Type10.Object({
-      markdown: Type10.String({
+    inputSchema: Type11.Object({
+      markdown: Type11.String({
         minLength: 1,
         description: "Markdown content to insert or use as replacement text."
       }),
-      operation: Type10.Optional(
-        Type10.Union(
+      operation: Type11.Optional(
+        Type11.Union(
           [
-            Type10.Literal("insert_at_end"),
-            Type10.Literal("insert_at_start"),
-            Type10.Literal("replace")
+            Type11.Literal("insert_at_end"),
+            Type11.Literal("insert_at_start"),
+            Type11.Literal("replace")
           ],
           { description: "Canvas update mode." }
         )
       ),
-      section_id: Type10.Optional(
-        Type10.String({
+      section_id: Type11.Optional(
+        Type11.String({
           minLength: 1,
           description: "Optional section ID required for targeted replace operations."
         })
       ),
-      section_contains_text: Type10.Optional(
-        Type10.String({
+      section_contains_text: Type11.Optional(
+        Type11.String({
           minLength: 1,
           description: "Optional helper text used to find the target section when section_id is not provided."
         })
@@ -5847,9 +5823,61 @@ function createSlackCanvasUpdateTool(state, _context) {
     }
   });
 }
+function createSlackCanvasReadTool() {
+  return tool({
+    description: "Read a Slack canvas the bot has access to (including canvases the bot created) by canvas ID or Slack canvas/docs URL. Use when the user shares a Slack canvas link (https://*.slack.com/docs/... or /canvas/...) or references a canvas ID and you need its contents. Do not use for generic web pages \u2014 use webFetch for those.",
+    inputSchema: Type11.Object({
+      canvas: Type11.String({
+        minLength: 1,
+        description: "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL (e.g. `https://team.slack.com/docs/T.../F...`)."
+      })
+    }),
+    execute: async ({ canvas }) => {
+      const canvasId = extractCanvasId(canvas);
+      if (!canvasId) {
+        return {
+          ok: false,
+          error: "Could not parse a Slack canvas/file ID from input. Provide an F-prefixed ID or a Slack canvas/docs URL."
+        };
+      }
+      try {
+        const result = await readCanvas(canvas);
+        const truncated = result.content.length > MAX_CANVAS_READ_CHARS;
+        const content = truncated ? result.content.slice(0, MAX_CANVAS_READ_CHARS) : result.content;
+        return {
+          ok: true,
+          canvas_id: result.canvasId,
+          title: result.title,
+          permalink: result.permalink,
+          mimetype: result.mimetype,
+          filetype: result.filetype,
+          original_byte_length: result.byteLength,
+          truncated,
+          content
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "canvas read failed";
+        logWarn(
+          "slack_canvas_read_failed",
+          {},
+          {
+            "gen_ai.tool.name": "slackCanvasRead",
+            "app.slack.canvas.canvas_id_prefix": canvasId.slice(0, 1)
+          },
+          message
+        );
+        return {
+          ok: false,
+          canvas_id: canvasId,
+          error: message
+        };
+      }
+    }
+  });
+}
 
 // src/chat/tools/slack/list-tools.ts
-import { Type as Type11 } from "@sinclair/typebox";
+import { Type as Type12 } from "@sinclair/typebox";
 
 // src/chat/tools/slack/lists.ts
 function normalizeKey(value) {
@@ -6023,8 +6051,8 @@ async function updateListItem(input) {
 function createSlackListCreateTool(state) {
   return tool({
     description: "Create a Slack todo list for action tracking. Use when the user needs structured tasks with ownership/completion tracking. Do not use for one-off notes without task management needs.",
-    inputSchema: Type11.Object({
-      name: Type11.String({
+    inputSchema: Type12.Object({
+      name: Type12.String({
         minLength: 1,
         maxLength: 160,
         description: "Name for the new Slack list."
@@ -6059,20 +6087,20 @@ function createSlackListCreateTool(state) {
 function createSlackListAddItemsTool(state) {
   return tool({
     description: "Add tasks to the active Slack list tracked in artifact context. Use when the user wants actionable items recorded in the current thread list. Do not use when no list exists and list creation was not requested.",
-    inputSchema: Type11.Object({
-      items: Type11.Array(Type11.String({ minLength: 1 }), {
+    inputSchema: Type12.Object({
+      items: Type12.Array(Type12.String({ minLength: 1 }), {
         minItems: 1,
         maxItems: 25,
         description: "List item titles to create."
       }),
-      assignee_user_id: Type11.Optional(
-        Type11.String({
+      assignee_user_id: Type12.Optional(
+        Type12.String({
           minLength: 1,
           description: "Optional Slack user ID assigned to all created items."
         })
       ),
-      due_date: Type11.Optional(
-        Type11.String({
+      due_date: Type12.Optional(
+        Type12.String({
           pattern: "^\\d{4}-\\d{2}-\\d{2}$",
           description: "Optional due date in YYYY-MM-DD format."
         })
@@ -6121,9 +6149,9 @@ function createSlackListAddItemsTool(state) {
 function createSlackListGetItemsTool(state) {
   return tool({
     description: "Read items from the active Slack list tracked in artifact context. Use when the user asks for task status, open items, or list contents. Do not use when list state is already known from the immediately prior result.",
-    inputSchema: Type11.Object({
-      limit: Type11.Optional(
-        Type11.Integer({
+    inputSchema: Type12.Object({
+      limit: Type12.Optional(
+        Type12.Integer({
           minimum: 1,
           maximum: 200,
           description: "Maximum number of list items to return."
@@ -6148,19 +6176,19 @@ function createSlackListGetItemsTool(state) {
 function createSlackListUpdateItemTool(state) {
   return tool({
     description: "Update an item in the active Slack list tracked in artifact context (title/completion). Use when the user asks to mark progress or rename a tracked task. Do not use to add new tasks.",
-    inputSchema: Type11.Object(
+    inputSchema: Type12.Object(
       {
-        item_id: Type11.String({
+        item_id: Type12.String({
           minLength: 1,
           description: "ID of the Slack list item to update."
         }),
-        completed: Type11.Optional(
-          Type11.Boolean({
+        completed: Type12.Optional(
+          Type12.Boolean({
             description: "Optional completion status update."
           })
         ),
-        title: Type11.Optional(
-          Type11.String({
+        title: Type12.Optional(
+          Type12.String({
             minLength: 1,
             description: "Optional new item title."
           })
@@ -6210,11 +6238,11 @@ function createSlackListUpdateItemTool(state) {
 }
 
 // src/chat/tools/system-time.ts
-import { Type as Type12 } from "@sinclair/typebox";
+import { Type as Type13 } from "@sinclair/typebox";
 function createSystemTimeTool() {
   return tool({
     description: "Return current system time in UTC and local ISO formats. Use when the user asks for current time/date context. Do not use as a substitute for historical or timezone-conversion research.",
-    inputSchema: Type12.Object({}),
+    inputSchema: Type13.Object({}),
     execute: async () => {
       const now = /* @__PURE__ */ new Date();
       return {
@@ -6229,7 +6257,7 @@ function createSystemTimeTool() {
 }
 
 // src/chat/tools/web/fetch-tool.ts
-import { Type as Type13 } from "@sinclair/typebox";
+import { Type as Type14 } from "@sinclair/typebox";
 
 // src/chat/tools/web/constants.ts
 var USER_AGENT = "junior-bot/0.1";
@@ -6577,13 +6605,13 @@ function extractHttpStatusFromMessage(message) {
 function createWebFetchTool(hooks) {
   return tool({
     description: "Fetch and extract readable content from a specific URL. Use when you need details from a known page or document. Do not use for discovery when search is the first step.",
-    inputSchema: Type13.Object({
-      url: Type13.String({
+    inputSchema: Type14.Object({
+      url: Type14.String({
         minLength: 1,
         description: "HTTP(S) URL to fetch."
       }),
-      max_chars: Type13.Optional(
-        Type13.Integer({
+      max_chars: Type14.Optional(
+        Type14.Integer({
           minimum: 500,
           maximum: MAX_FETCH_CHARS,
           description: "Optional maximum number of extracted characters to return."
@@ -6643,7 +6671,7 @@ function createWebFetchTool(hooks) {
 // src/chat/tools/web/search.ts
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
-import { Type as Type14 } from "@sinclair/typebox";
+import { Type as Type15 } from "@sinclair/typebox";
 var SEARCH_TIMEOUT_MS = 6e4;
 var MAX_RESULTS = 5;
 var DEFAULT_SEARCH_MODEL = "xai/grok-4-fast-reasoning";
@@ -6686,14 +6714,14 @@ function isAuthFailure(message) {
 function createWebSearchTool() {
   return tool({
     description: "Search public web sources and return top snippets/URLs. Use when you need discovery or source candidates. Do not use when the user already provided a specific URL to inspect.",
-    inputSchema: Type14.Object({
-      query: Type14.String({
+    inputSchema: Type15.Object({
+      query: Type15.String({
         minLength: 1,
         maxLength: 500,
         description: "Search query."
       }),
-      max_results: Type14.Optional(
-        Type14.Integer({
+      max_results: Type15.Optional(
+        Type15.Integer({
           minimum: 1,
           maximum: MAX_RESULTS,
           description: "Max results to return."
@@ -6759,17 +6787,17 @@ function createWebSearchTool() {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { Type as Type15 } from "@sinclair/typebox";
+import { Type as Type16 } from "@sinclair/typebox";
 function createWriteFileTool() {
   return tool({
     description: "Write UTF-8 content to a file in the sandbox workspace. Use for intentional file creation or replacement after validation. Do not use for exploratory analysis-only turns.",
-    inputSchema: Type15.Object(
+    inputSchema: Type16.Object(
       {
-        path: Type15.String({
+        path: Type16.String({
           minLength: 1,
           description: "Path to write in the sandbox workspace."
         }),
-        content: Type15.String({
+        content: Type16.String({
           description: "UTF-8 file content to write."
         })
       },
@@ -6824,6 +6852,7 @@ function createTools(availableSkills, hooks = {}, context) {
     loadSkill: createLoadSkillTool(availableSkills, {
       onSkillLoaded: hooks.onSkillLoaded
     }),
+    reportProgress: createReportProgressTool(),
     systemTime: createSystemTimeTool(),
     bash: createBashTool(),
     attachFile: createAttachFileTool(context.sandbox, hooks),
@@ -6835,6 +6864,7 @@ function createTools(availableSkills, hooks = {}, context) {
       hooks,
       hooks.toolOverrides?.imageGenerate
     ),
+    slackCanvasRead: createSlackCanvasReadTool(),
     slackCanvasUpdate: createSlackCanvasUpdateTool(state, context),
     slackListCreate: createSlackListCreateTool(state),
     slackListAddItems: createSlackListAddItemsTool(state),
@@ -7084,346 +7114,9 @@ function throwSandboxOperationError(action, error, includeMissingPath = false) {
 import { Sandbox } from "@vercel/sandbox";
 import { createBashTool as createBashTool2 } from "bash-tool";
 
-// src/chat/slack/assistant-thread/status-render.ts
-var STATUS_PATTERNS = {
-  thinking: {
-    defaultContext: "\u2026",
-    variants: ["Thinking", "Reasoning", "Considering", "Working through"]
-  },
-  searching: {
-    defaultContext: "sources",
-    variants: ["Searching", "Scanning", "Probing", "Trawling"]
-  },
-  reading: {
-    defaultContext: "task",
-    variants: ["Reading", "Inspecting", "Parsing", "Skimming"]
-  },
-  reviewing: {
-    defaultContext: "results",
-    variants: ["Reviewing", "Checking", "Inspecting", "Auditing"]
-  },
-  loading: {
-    defaultContext: "task",
-    variants: ["Loading", "Priming", "Booting", "Spinning up"]
-  },
-  updating: {
-    defaultContext: "state",
-    variants: ["Updating", "Patching", "Refreshing", "Adjusting"]
-  },
-  fetching: {
-    defaultContext: "sources",
-    variants: ["Fetching", "Pulling", "Retrieving", "Loading"]
-  },
-  creating: {
-    defaultContext: "draft",
-    variants: ["Creating", "Building", "Assembling", "Generating"]
-  },
-  listing: {
-    defaultContext: "items",
-    variants: ["Listing", "Gathering", "Collecting", "Enumerating"]
-  },
-  posting: {
-    defaultContext: "reply",
-    variants: ["Posting", "Sending", "Delivering", "Dispatching"]
-  },
-  adding: {
-    defaultContext: "details",
-    variants: ["Adding", "Applying", "Attaching", "Dropping in"]
-  },
-  running: {
-    defaultContext: "tasks",
-    variants: ["Running", "Executing", "Launching", "Processing"]
-  }
-};
-function makeAssistantStatus(kind, context) {
-  return { kind, ...context ? { context } : {} };
-}
-function renderAssistantStatus(args) {
-  const random = args.random ?? Math.random;
-  const pattern = STATUS_PATTERNS[args.status.kind];
-  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}`);
-  const hint = truncateStatusText(`${pattern.variants[0]} ${context}`);
-  return {
-    key: `${args.status.kind}:${context}`,
-    hint,
-    visible,
-    suggestions: Array.from(/* @__PURE__ */ new Set([visible, hint]))
-  };
-}
-
-// src/chat/slack/assistant-thread/status-scheduler.ts
-var STATUS_UPDATE_DEBOUNCE_MS = 1e3;
-var STATUS_MIN_VISIBLE_MS = 1200;
-var STATUS_ROTATION_INTERVAL_MS = 3e4;
-function createAssistantStatusScheduler(args) {
-  const now = args.now ?? (() => Date.now());
-  const setTimer = args.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
-  const clearTimer = args.clearTimer ?? ((timer) => clearTimeout(timer));
-  const random = args.random ?? Math.random;
-  let active = false;
-  let currentKey = "";
-  let currentStatus = makeAssistantStatus("thinking");
-  let currentVisibleStatus = "";
-  let lastStatusAt = 0;
-  let pendingStatus = null;
-  let pendingKey = "";
-  let pendingTimer = null;
-  let rotationTimer = null;
-  let inflightStatusUpdate = Promise.resolve();
-  const enqueueStatusUpdate = (task) => {
-    const request = inflightStatusUpdate.catch(() => void 0).then(async () => {
-      await task();
-    });
-    inflightStatusUpdate = request.catch(() => void 0);
-    return request;
-  };
-  const scheduleRotation = () => {
-    if (rotationTimer) {
-      clearTimer(rotationTimer);
-      rotationTimer = null;
-    }
-    if (!active || !currentVisibleStatus) {
-      return;
-    }
-    rotationTimer = setTimer(() => {
-      rotationTimer = null;
-      if (!active || !currentVisibleStatus) {
-        return;
-      }
-      void postRenderedStatus(currentStatus);
-    }, STATUS_ROTATION_INTERVAL_MS);
-  };
-  const postStatus = async (text, suggestions) => {
-    if (!text && !currentVisibleStatus) {
-      return;
-    }
-    currentVisibleStatus = text;
-    lastStatusAt = now();
-    scheduleRotation();
-    await enqueueStatusUpdate(async () => {
-      await args.sendStatus(text, suggestions);
-    });
-  };
-  const postRenderedStatus = async (status) => {
-    const presentation = renderAssistantStatus({
-      status,
-      random
-    });
-    currentStatus = status;
-    currentKey = presentation.key;
-    await postStatus(presentation.visible, presentation.suggestions);
-  };
-  const clearPending = () => {
-    if (pendingTimer) {
-      clearTimer(pendingTimer);
-      pendingTimer = null;
-    }
-    pendingStatus = null;
-    pendingKey = "";
-  };
-  const flushPending = async () => {
-    if (!active || !pendingStatus) {
-      clearPending();
-      return;
-    }
-    const next = pendingStatus;
-    clearPending();
-    const nextPresentation = renderAssistantStatus({
-      status: next,
-      random
-    });
-    if (nextPresentation.key !== currentKey) {
-      await postRenderedStatus(next);
-    }
-  };
-  return {
-    start() {
-      active = true;
-      clearPending();
-      currentStatus = makeAssistantStatus("thinking");
-      currentKey = "";
-      void postRenderedStatus(currentStatus);
-    },
-    async stop() {
-      active = false;
-      clearPending();
-      if (rotationTimer) {
-        clearTimer(rotationTimer);
-        rotationTimer = null;
-      }
-      currentKey = "";
-      await postStatus("");
-    },
-    update(status) {
-      if (!active) {
-        return;
-      }
-      const presentation = renderAssistantStatus({
-        status,
-        random
-      });
-      if (!presentation.visible) {
-        return;
-      }
-      if (presentation.key === currentKey || presentation.key === pendingKey) {
-        return;
-      }
-      const elapsed = now() - lastStatusAt;
-      const waitMs = Math.max(
-        STATUS_UPDATE_DEBOUNCE_MS - elapsed,
-        STATUS_MIN_VISIBLE_MS - elapsed,
-        0
-      );
-      if (waitMs <= 0) {
-        clearPending();
-        void postRenderedStatus(status);
-        return;
-      }
-      pendingStatus = status;
-      pendingKey = presentation.key;
-      if (pendingTimer) {
-        return;
-      }
-      pendingTimer = setTimer(
-        () => {
-          pendingTimer = null;
-          void flushPending();
-        },
-        Math.max(1, waitMs)
-      );
-    }
-  };
-}
-
-// src/chat/slack/assistant-thread/status-send.ts
-function createSlackAdapterStatusSender(args) {
-  const adapter = args.getSlackAdapter();
-  const boundToken = getSlackAdapterRequestToken(adapter);
-  return async (text, suggestions) => {
-    const channelId = args.channelId;
-    const threadTs = args.threadTs;
-    if (!channelId || !threadTs) {
-      return;
-    }
-    const normalizedChannelId = normalizeSlackConversationId(channelId);
-    if (!normalizedChannelId) {
-      return;
-    }
-    try {
-      await runWithBoundSlackToken(
-        adapter,
-        boundToken,
-        () => adapter.setAssistantStatus(
-          normalizedChannelId,
-          threadTs,
-          text,
-          suggestions
-        )
-      );
-    } catch (error) {
-      logAssistantStatusFailure({
-        status: text,
-        error,
-        channelId,
-        normalizedChannelId,
-        threadTs
-      });
-    }
-  };
-}
-function createSlackWebApiStatusSender(args) {
-  const getClient2 = args.getSlackClient ?? getSlackClient;
-  return async (text, suggestions) => {
-    const channelId = args.channelId;
-    const threadTs = args.threadTs;
-    if (!channelId || !threadTs) {
-      return;
-    }
-    const normalizedChannelId = normalizeSlackConversationId(channelId);
-    if (!normalizedChannelId) {
-      return;
-    }
-    try {
-      await getClient2().assistant.threads.setStatus({
-        channel_id: normalizedChannelId,
-        thread_ts: threadTs,
-        status: text,
-        ...suggestions ? { loading_messages: suggestions } : {}
-      });
-    } catch (error) {
-      logAssistantStatusFailure({
-        status: text,
-        error,
-        channelId,
-        normalizedChannelId,
-        threadTs
-      });
-    }
-  };
-}
-function 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": 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 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";
+// src/chat/sandbox/skill-sync.ts
+import fs3 from "fs/promises";
+import path5 from "path";
 
 // src/chat/sandbox/eval-gh-stub.ts
 function buildEvalGitHubCliStub() {
@@ -7981,12 +7674,6 @@ var SANDBOX_RUNTIME = "node22";
 var SANDBOX_RUNTIME_BIN_DIR = `${SANDBOX_WORKSPACE_ROOT}/.junior/bin`;
 var SNAPSHOT_BOOT_RETRY_COUNT = 3;
 var SNAPSHOT_BOOT_RETRY_DELAY_MS = 1e3;
-var SNAPSHOT_PHASE_STATUS = {
-  resolve_start: { kind: "loading", context: "sandbox snapshot cache" },
-  waiting_for_lock: { kind: "loading", context: "sandbox snapshot build" },
-  building_snapshot: { kind: "creating", context: "sandbox snapshot" },
-  cache_hit: { kind: "loading", context: "sandbox snapshot" }
-};
 function mergeNetworkPolicyWithHeaderTransforms(networkPolicy, headerTransforms) {
   const basePolicy = networkPolicy && typeof networkPolicy === "object" && !Array.isArray(networkPolicy) ? { ...networkPolicy } : {};
   const existingAllowRaw = basePolicy.allow;
@@ -8027,26 +7714,6 @@ function sleep2(ms) {
     setTimeout(resolve, ms);
   });
 }
-function createStatusEmitter(emitStatus) {
-  let statusCount = 0;
-  const sentStatuses = /* @__PURE__ */ new Set();
-  const emit = async (status) => {
-    const statusKey = `${status.kind}:${status.context ?? ""}`;
-    if (!emitStatus || statusCount >= 4 || sentStatuses.has(statusKey)) {
-      return;
-    }
-    sentStatuses.add(statusKey);
-    statusCount += 1;
-    await emitStatus(status);
-  };
-  const reportSnapshotPhase = async (phase) => {
-    const status = SNAPSHOT_PHASE_STATUS[phase];
-    if (status) {
-      await emit(makeAssistantStatus(status.kind, status.context));
-    }
-  };
-  return { emit, reportSnapshotPhase };
-}
 function parseKeepAliveMs() {
   const parsed = Number.parseInt(
     process.env.VERCEL_SANDBOX_KEEPALIVE_MS ?? "0",
@@ -8064,23 +7731,6 @@ function createSandboxSessionManager(options) {
   const traceContext = options?.traceContext ?? {};
   const dependencyProfileHash = getRuntimeDependencyProfileHash(SANDBOX_RUNTIME);
   const withSandboxSpan = (name, op, attributes, callback) => withSpan(name, op, traceContext, callback, attributes);
-  const emitSandboxStatus = async (source, statusEmitter, status) => {
-    logInfo(
-      "sandbox_status_emitted",
-      traceContext,
-      {
-        "app.sandbox.status.source": source,
-        "app.sandbox.status.kind": status.kind,
-        ...status.context ? { "app.sandbox.status.context": status.context } : {}
-      },
-      "Sandbox status emitted"
-    );
-    if (typeof statusEmitter === "function") {
-      await statusEmitter(status);
-      return;
-    }
-    await statusEmitter.emit(status);
-  };
   const clearSession = () => {
     sandbox = null;
     sandboxIdHint = void 0;
@@ -8156,16 +7806,9 @@ function createSandboxSessionManager(options) {
     });
     return replacement;
   };
-  const createSandboxFromSnapshot = async (snapshotId, sandboxCredentials, emitStatus) => {
+  const createSandboxFromSnapshot = async (snapshotId, sandboxCredentials) => {
     for (let attempt = 0; attempt < SNAPSHOT_BOOT_RETRY_COUNT; attempt += 1) {
       try {
-        if (emitStatus) {
-          await emitSandboxStatus(
-            "snapshot_boot",
-            emitStatus,
-            makeAssistantStatus("loading", "sandbox")
-          );
-        }
         return await Sandbox.create({
           timeout: timeoutMs,
           source: {
@@ -8198,13 +7841,8 @@ function createSandboxSessionManager(options) {
     });
   };
   const createSandboxFromResolvedSnapshot = async (params) => {
-    const { runtime, snapshot, sandboxCredentials, status } = params;
+    const { runtime, snapshot, sandboxCredentials } = params;
     if (!snapshot.snapshotId) {
-      await emitSandboxStatus(
-        "fresh_runtime_boot",
-        status,
-        makeAssistantStatus("loading", "sandbox")
-      );
       return await Sandbox.create({
         timeout: timeoutMs,
         runtime,
@@ -8214,8 +7852,7 @@ function createSandboxSessionManager(options) {
     try {
       return await createSandboxFromSnapshot(
         snapshot.snapshotId,
-        sandboxCredentials,
-        status.emit
+        sandboxCredentials
       );
     } catch (error) {
       if (!isSnapshotMissingError(error)) {
@@ -8228,23 +7865,20 @@ function createSandboxSessionManager(options) {
         runtime,
         timeoutMs,
         forceRebuild: true,
-        staleSnapshotId: snapshot.snapshotId,
-        onProgress: status.reportSnapshotPhase
+        staleSnapshotId: snapshot.snapshotId
       });
       if (!rebuiltSnapshot.snapshotId) {
         throw error;
       }
       return await createSandboxFromSnapshot(
         rebuiltSnapshot.snapshotId,
-        sandboxCredentials,
-        status.emit
+        sandboxCredentials
       );
     }
   };
   const createFreshSandbox = async () => {
     const runtime = SANDBOX_RUNTIME;
     const sandboxCredentials = getVercelSandboxCredentials();
-    const status = createStatusEmitter(options?.onStatus);
     let createdSandbox;
     try {
       createdSandbox = await withSandboxSpan(
@@ -8256,22 +7890,15 @@ function createSandboxSessionManager(options) {
           "app.sandbox.runtime": runtime
         },
         async () => {
-          await emitSandboxStatus(
-            "runtime_dependency_resolve",
-            status,
-            makeAssistantStatus("loading", "sandbox runtime")
-          );
           const snapshot = await resolveRuntimeDependencySnapshot({
             runtime,
-            timeoutMs,
-            onProgress: status.reportSnapshotPhase
+            timeoutMs
           });
           setSnapshotAttributes(snapshot);
           return await createSandboxFromResolvedSnapshot({
             runtime,
             snapshot,
-            sandboxCredentials,
-            status
+            sandboxCredentials
           });
         }
       );
@@ -8585,7 +8212,6 @@ function createSandboxExecutor(options) {
     sandboxDependencyProfileHash: options?.sandboxDependencyProfileHash,
     timeoutMs: options?.timeoutMs,
     traceContext,
-    onStatus: options?.onStatus,
     onSandboxAcquired: options?.onSandboxAcquired
   });
   const withSandboxSpan = (name, op, attributes, callback) => withSpan(name, op, traceContext, callback, attributes);
@@ -8938,74 +8564,20 @@ function createPluginAuthOrchestration(deps, abortAgent) {
   };
 }
 
-// src/chat/runtime/tool-status.ts
-function buildToolStatus(toolName, input) {
-  const obj = input && typeof input === "object" ? input : void 0;
-  const command = obj ? compactStatusCommand(obj.command) : void 0;
-  const path7 = obj ? compactStatusPath(obj.path) : void 0;
-  const filename = obj ? compactStatusFilename(obj.path) : void 0;
-  const query = obj ? compactStatusText(obj.query, 70) : void 0;
-  const domain = obj ? extractStatusUrlDomain(obj.url) : void 0;
-  const skillName = obj ? compactStatusText(obj.skill_name ?? obj.skillName, 40) : void 0;
-  const provider = obj ? compactStatusText(obj.provider, 20) : void 0;
-  if (command && toolName === "bash") {
-    return makeAssistantStatus("running", command);
-  }
-  if (filename && toolName === "readFile") {
-    return makeAssistantStatus("reading", filename);
-  }
-  if (filename && toolName === "writeFile") {
-    return makeAssistantStatus("updating", filename);
-  }
-  if (path7 && toolName === "writeFile") {
-    return makeAssistantStatus("updating", path7);
-  }
-  if (skillName && toolName === "loadSkill") {
-    return makeAssistantStatus("loading", skillName);
-  }
-  if (query && toolName === "webSearch") {
-    return makeAssistantStatus("searching", "sources");
-  }
-  if (query && toolName === "searchTools") {
-    return makeAssistantStatus(
-      "searching",
-      provider ? `${provider} tools` : "tools"
-    );
-  }
-  if (domain && toolName === "webFetch") {
-    return makeAssistantStatus("fetching", domain);
-  }
-  const known = {
-    loadSkill: makeAssistantStatus("loading", "skill instructions"),
-    systemTime: makeAssistantStatus("reading", "system time"),
-    bash: makeAssistantStatus("running", "shell"),
-    readFile: makeAssistantStatus("reading", "file"),
-    writeFile: makeAssistantStatus("updating", "file"),
-    webSearch: makeAssistantStatus("searching", "sources"),
-    webFetch: makeAssistantStatus("fetching", "pages"),
-    slackChannelPostMessage: makeAssistantStatus("posting", "channel"),
-    slackMessageAddReaction: makeAssistantStatus("adding", "reaction"),
-    slackChannelListMessages: makeAssistantStatus("listing", "messages"),
-    slackCanvasCreate: makeAssistantStatus("creating", "brief"),
-    slackCanvasUpdate: makeAssistantStatus("updating", "brief"),
-    slackListCreate: makeAssistantStatus("creating", "tracking list"),
-    slackListAddItems: makeAssistantStatus("updating", "tracking list"),
-    slackListUpdateItem: makeAssistantStatus("updating", "tracking list"),
-    imageGenerate: makeAssistantStatus("creating", "image"),
-    searchTools: makeAssistantStatus(
-      "searching",
-      provider ? `${provider} tools` : "tools"
-    )
-  };
-  if (known[toolName]) {
-    return known[toolName];
+// src/chat/runtime/report-progress.ts
+function buildReportedProgressStatus(input) {
+  if (!input || typeof input !== "object") {
+    return void 0;
   }
-  const mcpMatch = /^mcp__([^_]+)__(.+)$/.exec(toolName);
-  if (mcpMatch) {
-    return makeAssistantStatus("running", `${mcpMatch[1]}/${mcpMatch[2]}`);
+  const message = input.message;
+  if (typeof message !== "string") {
+    return void 0;
+  }
+  const text = message.trim();
+  if (!text) {
+    return void 0;
   }
-  const readable = toolName.replaceAll("_", " ").trim();
-  return makeAssistantStatus("running", readable || "tool");
+  return { text };
 }
 
 // src/chat/tools/execution/build-sandbox-input.ts
@@ -9156,7 +8728,12 @@ function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor
         turnId: spanContext.turnId,
         agentId: spanContext.agentId
       };
-      await onStatus?.(buildToolStatus(toolName, params));
+      if (toolName === "reportProgress") {
+        const status = buildReportedProgressStatus(params);
+        if (status) {
+          await onStatus?.(status);
+        }
+      }
       return withSpan(
         `execute_tool ${toolName}`,
         "gen_ai.execute_tool",
@@ -9322,41 +8899,41 @@ function summarizeMessageText(text) {
 }
 function buildUserTurnText(userInput, conversationContext, metadata) {
   const trimmedContext = conversationContext?.trim();
-  const hasSessionContext = Boolean(metadata?.sessionContext?.conversationId);
-  const hasTurnContext = Boolean(metadata?.turnContext?.traceId);
-  if (!trimmedContext && !hasSessionContext && !hasTurnContext) {
+  const conversationId = metadata?.sessionContext?.conversationId;
+  const traceId = metadata?.turnContext?.traceId;
+  if (!trimmedContext && !conversationId && !traceId) {
     return userInput;
   }
-  const sections = [
-    "<current-message>",
-    userInput,
-    "</current-message>"
-  ];
+  const sections = [];
   if (trimmedContext) {
     sections.push(
-      "",
-      "<thread-conversation-context>",
-      "Use this context for continuity across prior thread turns.",
+      "<thread-background>",
       trimmedContext,
-      "</thread-conversation-context>"
+      "</thread-background>",
+      ""
     );
   }
-  if (metadata?.sessionContext?.conversationId) {
+  if (conversationId) {
     sections.push(
-      "",
       "<session-context>",
-      `- gen_ai.conversation.id: ${metadata.sessionContext.conversationId}`,
-      "</session-context>"
+      `- gen_ai.conversation.id: ${conversationId}`,
+      "</session-context>",
+      ""
     );
   }
-  if (metadata?.turnContext?.traceId) {
+  if (traceId) {
     sections.push(
-      "",
       "<turn-context>",
-      `- trace_id: ${metadata.turnContext.traceId}`,
-      "</turn-context>"
+      `- trace_id: ${traceId}`,
+      "</turn-context>",
+      ""
     );
   }
+  sections.push(
+    '<current-instruction priority="highest">',
+    userInput,
+    "</current-instruction>"
+  );
   return sections.join("\n");
 }
 function encodeNonImageAttachmentForPrompt(attachment) {
@@ -10059,7 +9636,6 @@ async function generateAssistantReply(messageText, context = {}) {
       sandboxId: context.sandbox?.sandboxId,
       sandboxDependencyProfileHash: context.sandbox?.sandboxDependencyProfileHash,
       traceContext: spanContext,
-      onStatus: context.onStatus,
       onSandboxAcquired: async (sandbox2) => {
         lastKnownSandboxId = sandbox2.sandboxId;
         lastKnownSandboxDependencyProfileHash = sandbox2.sandboxDependencyProfileHash;
@@ -10679,6 +10255,364 @@ async function generateAssistantReply(messageText, context = {}) {
   }
 }
 
+// src/chat/slack/assistant-thread/status-render.ts
+var DEFAULT_STATUS_CONTEXTS = {
+  thinking: "\u2026",
+  searching: "sources",
+  reading: "task",
+  reviewing: "results",
+  drafting: "reply",
+  running: "tasks"
+};
+function formatAssistantStatusText(verb, context) {
+  const normalizedVerb = normalizeSlackStatusText(verb).trim().toLowerCase();
+  const normalizedContext = normalizeSlackStatusText(context ?? "") || DEFAULT_STATUS_CONTEXTS[normalizedVerb] || "";
+  if (!normalizedVerb) {
+    return truncateStatusText(normalizedContext || "Working");
+  }
+  const displayVerb = `${normalizedVerb[0]?.toUpperCase() ?? ""}${normalizedVerb.slice(1)}`;
+  return truncateStatusText(
+    normalizedContext ? `${displayVerb} ${normalizedContext}` : displayVerb
+  );
+}
+function makeAssistantStatus(verb, context) {
+  return {
+    text: formatAssistantStatusText(verb, context)
+  };
+}
+function renderAssistantStatus(args) {
+  const visible = truncateStatusText(
+    normalizeSlackStatusText(args.status.text)
+  );
+  return {
+    key: visible,
+    visible
+  };
+}
+function selectAssistantLoadingMessages(args) {
+  const random = args.random ?? Math.random;
+  const normalized = Array.from(
+    new Set(
+      args.messages.map((message) => truncateStatusText(normalizeSlackStatusText(message))).filter((message) => message.length > 0)
+    )
+  );
+  if (normalized.length === 0) {
+    return void 0;
+  }
+  const shuffled = [...normalized];
+  for (let index = shuffled.length - 1; index > 0; index -= 1) {
+    const otherIndex = Math.floor(random() * (index + 1));
+    [shuffled[index], shuffled[otherIndex]] = [
+      shuffled[otherIndex],
+      shuffled[index]
+    ];
+  }
+  return shuffled.slice(0, 10);
+}
+
+// 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;
+  const loadingMessages = selectAssistantLoadingMessages({
+    messages: args.loadingMessages ?? [],
+    random
+  });
+  const defaultStatus = makeAssistantStatus("thinking");
+  let active = false;
+  let currentKey = "";
+  let currentVisibleStatus = "";
+  let currentLoadingMessages;
+  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 postStatus(currentVisibleStatus, currentLoadingMessages);
+    }, STATUS_ROTATION_INTERVAL_MS);
+  };
+  const getLoadingMessagesForVisibleStatus = (visible) => visible ? [visible] : void 0;
+  const getInitialStatusText = () => {
+    if (loadingMessages?.length) {
+      return loadingMessages[0];
+    }
+    return defaultStatus.text;
+  };
+  const haveSameLoadingMessages = (left, right) => {
+    if (left === right) {
+      return true;
+    }
+    if (!left || !right || left.length !== right.length) {
+      return false;
+    }
+    return left.every((message, index) => message === right[index]);
+  };
+  const postStatus = async (text, nextLoadingMessages) => {
+    if (!text && !currentVisibleStatus) {
+      return;
+    }
+    currentVisibleStatus = text;
+    currentLoadingMessages = nextLoadingMessages;
+    lastStatusAt = now();
+    scheduleRotation();
+    await enqueueStatusUpdate(async () => {
+      await args.sendStatus(text, nextLoadingMessages);
+    });
+  };
+  const postRenderedStatus = async (status) => {
+    const presentation = renderAssistantStatus({
+      status
+    });
+    const nextLoadingMessages = getLoadingMessagesForVisibleStatus(
+      presentation.visible
+    );
+    currentKey = presentation.key;
+    await postStatus(presentation.visible, nextLoadingMessages);
+  };
+  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
+    });
+    if (nextPresentation.key !== currentKey) {
+      await postRenderedStatus(next);
+    }
+  };
+  return {
+    start() {
+      active = true;
+      clearPending();
+      currentKey = "initial";
+      void postStatus(getInitialStatusText(), loadingMessages);
+    },
+    async stop() {
+      active = false;
+      clearPending();
+      if (rotationTimer) {
+        clearTimer(rotationTimer);
+        rotationTimer = null;
+      }
+      currentKey = "";
+      await postStatus("");
+    },
+    update(status) {
+      if (!active) {
+        return;
+      }
+      const presentation = renderAssistantStatus({
+        status
+      });
+      if (!presentation.visible) {
+        return;
+      }
+      if (presentation.key === currentKey || presentation.key === pendingKey) {
+        return;
+      }
+      if (presentation.visible === currentVisibleStatus) {
+        clearPending();
+        currentKey = presentation.key;
+        const nextLoadingMessages = getLoadingMessagesForVisibleStatus(
+          presentation.visible
+        );
+        if (!haveSameLoadingMessages(currentLoadingMessages, nextLoadingMessages)) {
+          void postStatus(presentation.visible, nextLoadingMessages);
+        }
+        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
+var SLACK_ASSISTANT_ACTIVE_STATUS = "is working on your request...";
+function createSlackAdapterStatusSender(args) {
+  const adapter = args.getSlackAdapter();
+  const boundToken = getSlackAdapterRequestToken(adapter);
+  return async (text, loadingMessages) => {
+    const channelId = args.channelId;
+    const threadTs = args.threadTs;
+    if (!channelId || !threadTs) {
+      return;
+    }
+    const normalizedChannelId = normalizeSlackConversationId(channelId);
+    if (!normalizedChannelId) {
+      return;
+    }
+    const nextLoadingMessages = text ? loadingMessages ?? [text] : void 0;
+    try {
+      await runWithBoundSlackToken(
+        adapter,
+        boundToken,
+        () => adapter.setAssistantStatus(
+          normalizedChannelId,
+          threadTs,
+          text ? SLACK_ASSISTANT_ACTIVE_STATUS : "",
+          nextLoadingMessages
+        )
+      );
+    } catch (error) {
+      logAssistantStatusFailure({
+        status: text,
+        error,
+        channelId,
+        normalizedChannelId,
+        threadTs
+      });
+    }
+  };
+}
+function createSlackWebApiStatusSender(args) {
+  const getClient2 = args.getSlackClient ?? getSlackClient;
+  return async (text, loadingMessages) => {
+    const channelId = args.channelId;
+    const threadTs = args.threadTs;
+    if (!channelId || !threadTs) {
+      return;
+    }
+    const normalizedChannelId = normalizeSlackConversationId(channelId);
+    if (!normalizedChannelId) {
+      return;
+    }
+    const nextLoadingMessages = text ? loadingMessages ?? [text] : void 0;
+    try {
+      await getClient2().assistant.threads.setStatus({
+        channel_id: normalizedChannelId,
+        thread_ts: threadTs,
+        status: text ? SLACK_ASSISTANT_ACTIVE_STATUS : "",
+        ...nextLoadingMessages ? { loading_messages: nextLoadingMessages } : {}
+      });
+    } catch (error) {
+      logAssistantStatusFailure({
+        status: text,
+        error,
+        channelId,
+        normalizedChannelId,
+        threadTs
+      });
+    }
+  };
+}
+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": 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 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
+    }),
+    loadingMessages: args.loadingMessages ?? botConfig.loadingMessages,
+    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
+    }),
+    loadingMessages: args.loadingMessages ?? botConfig.loadingMessages,
+    now: args.now,
+    setTimer: args.setTimer,
+    clearTimer: args.clearTimer,
+    random: args.random
+  });
+}
+
 // src/chat/slack/footer.ts
 function escapeSlackMrkdwn(text) {
   return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");