@sentry/junior 0.26.0 → 0.27.0

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"),
@@ -3472,7 +3483,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 when you start a major new phase of work, such as researching, reading, executing, reviewing, or drafting. 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 +3493,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 +3508,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 +3526,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 +5189,33 @@ 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 when you start a major new phase of work. Use for sparse phase changes such as researching, reading, executing, reviewing, or drafting. Do not call this for every tool or minor substep.",
+    inputSchema: Type6.Object({
+      phase: Type6.Union([
+        Type6.Literal("thinking"),
+        Type6.Literal("researching"),
+        Type6.Literal("reading"),
+        Type6.Literal("executing"),
+        Type6.Literal("reviewing"),
+        Type6.Literal("drafting")
+      ]),
+      detail: Type6.Optional(
+        Type6.String({
+          minLength: 1,
+          maxLength: 40,
+          description: "Optional short user-facing detail, such as docs, tests, source files, or reply."
+        })
+      )
+    })
+  });
+}
+
+// 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 +5247,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 +5286,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 +5375,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 +5429,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 +5461,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 +5483,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 +5527,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 +5590,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 +5609,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 +5623,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 +5637,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 +5650,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 +5733,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 +5806,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 +5878,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 +5963,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 +6191,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 +6227,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 +6289,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 +6316,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 +6378,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 +6397,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 +6745,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 +6811,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 +6854,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 +6927,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 +6992,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 +7004,7 @@ function createTools(availableSkills, hooks = {}, context) {
       hooks,
       hooks.toolOverrides?.imageGenerate
     ),
+    slackCanvasRead: createSlackCanvasReadTool(),
     slackCanvasUpdate: createSlackCanvasUpdateTool(state, context),
     slackListCreate: createSlackListCreateTool(state),
     slackListAddItems: createSlackListAddItemsTool(state),
@@ -7102,6 +7272,10 @@ var STATUS_PATTERNS = {
     defaultContext: "results",
     variants: ["Reviewing", "Checking", "Inspecting", "Auditing"]
   },
+  drafting: {
+    defaultContext: "reply",
+    variants: ["Drafting", "Writing", "Composing", "Shaping"]
+  },
   loading: {
     defaultContext: "task",
     variants: ["Loading", "Priming", "Booting", "Spinning up"]
@@ -7135,24 +7309,46 @@ var STATUS_PATTERNS = {
     variants: ["Running", "Executing", "Launching", "Processing"]
   }
 };
-function makeAssistantStatus(kind, context) {
-  return { kind, ...context ? { context } : {} };
+function makeAssistantStatus(kind, context, options) {
+  return {
+    kind,
+    ...context ? { context } : {},
+    ...options?.source ? { source: options.source } : {}
+  };
 }
 function renderAssistantStatus(args) {
   const random = args.random ?? Math.random;
   const pattern = STATUS_PATTERNS[args.status.kind];
+  const source = args.status.source ?? "fallback";
   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]))
+    key: `${source}:${args.status.kind}:${context}`,
+    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;
@@ -7163,10 +7359,16 @@ function createAssistantStatusScheduler(args) {
   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 currentStatus = makeAssistantStatus("thinking");
+  let currentStatus = defaultStatus;
   let currentVisibleStatus = "";
+  let currentLoadingMessages;
   let lastStatusAt = 0;
   let pendingStatus = null;
   let pendingKey = "";
@@ -7193,18 +7395,43 @@ function createAssistantStatusScheduler(args) {
       if (!active || !currentVisibleStatus) {
         return;
       }
-      void postRenderedStatus(currentStatus);
+      void postStatus(currentVisibleStatus, currentLoadingMessages);
     }, STATUS_ROTATION_INTERVAL_MS);
   };
-  const postStatus = async (text, suggestions) => {
+  const getLoadingMessagesForStatus = (_status, visible) => {
+    if (!visible) {
+      return void 0;
+    }
+    return [visible];
+  };
+  const getInitialStatusText = () => {
+    if (loadingMessages?.length) {
+      return loadingMessages[0];
+    }
+    return renderAssistantStatus({
+      status: defaultStatus,
+      random
+    }).visible;
+  };
+  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, suggestions);
+      await args.sendStatus(text, nextLoadingMessages);
     });
   };
   const postRenderedStatus = async (status) => {
@@ -7212,9 +7439,13 @@ function createAssistantStatusScheduler(args) {
       status,
       random
     });
+    const nextLoadingMessages = getLoadingMessagesForStatus(
+      status,
+      presentation.visible
+    );
     currentStatus = status;
     currentKey = presentation.key;
-    await postStatus(presentation.visible, presentation.suggestions);
+    await postStatus(presentation.visible, nextLoadingMessages);
   };
   const clearPending = () => {
     if (pendingTimer) {
@@ -7243,9 +7474,9 @@ function createAssistantStatusScheduler(args) {
     start() {
       active = true;
       clearPending();
-      currentStatus = makeAssistantStatus("thinking");
-      currentKey = "";
-      void postRenderedStatus(currentStatus);
+      currentStatus = defaultStatus;
+      currentKey = "initial";
+      void postStatus(getInitialStatusText(), loadingMessages);
     },
     async stop() {
       active = false;
@@ -7268,9 +7499,25 @@ function createAssistantStatusScheduler(args) {
       if (!presentation.visible) {
         return;
       }
+      if (status.source !== "major" && (currentStatus.source === "major" || pendingStatus?.source === "major")) {
+        return;
+      }
       if (presentation.key === currentKey || presentation.key === pendingKey) {
         return;
       }
+      if (presentation.visible === currentVisibleStatus) {
+        clearPending();
+        currentStatus = status;
+        currentKey = presentation.key;
+        const nextLoadingMessages = getLoadingMessagesForStatus(
+          status,
+          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,
@@ -7299,10 +7546,11 @@ function createAssistantStatusScheduler(args) {
 }
 
 // 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, suggestions) => {
+  return async (text, loadingMessages) => {
     const channelId = args.channelId;
     const threadTs = args.threadTs;
     if (!channelId || !threadTs) {
@@ -7312,6 +7560,7 @@ function createSlackAdapterStatusSender(args) {
     if (!normalizedChannelId) {
       return;
     }
+    const nextLoadingMessages = text ? loadingMessages ?? [text] : void 0;
     try {
       await runWithBoundSlackToken(
         adapter,
@@ -7319,8 +7568,8 @@ function createSlackAdapterStatusSender(args) {
         () => adapter.setAssistantStatus(
           normalizedChannelId,
           threadTs,
-          text,
-          suggestions
+          text ? SLACK_ASSISTANT_ACTIVE_STATUS : "",
+          nextLoadingMessages
         )
       );
     } catch (error) {
@@ -7336,7 +7585,7 @@ function createSlackAdapterStatusSender(args) {
 }
 function createSlackWebApiStatusSender(args) {
   const getClient2 = args.getSlackClient ?? getSlackClient;
-  return async (text, suggestions) => {
+  return async (text, loadingMessages) => {
     const channelId = args.channelId;
     const threadTs = args.threadTs;
     if (!channelId || !threadTs) {
@@ -7346,12 +7595,13 @@ function createSlackWebApiStatusSender(args) {
     if (!normalizedChannelId) {
       return;
     }
+    const nextLoadingMessages = text ? loadingMessages ?? [text] : void 0;
     try {
       await getClient2().assistant.threads.setStatus({
         channel_id: normalizedChannelId,
         thread_ts: threadTs,
-        status: text,
-        ...suggestions ? { loading_messages: suggestions } : {}
+        status: text ? SLACK_ASSISTANT_ACTIVE_STATUS : "",
+        ...nextLoadingMessages ? { loading_messages: nextLoadingMessages } : {}
       });
     } catch (error) {
       logAssistantStatusFailure({
@@ -7401,6 +7651,7 @@ function createSlackAdapterAssistantStatusSession(args) {
       threadTs: args.threadTs,
       getSlackAdapter: args.getSlackAdapter
     }),
+    loadingMessages: args.loadingMessages ?? botConfig.loadingMessages,
     now: args.now,
     setTimer: args.setTimer,
     clearTimer: args.clearTimer,
@@ -7414,6 +7665,7 @@ function createSlackWebApiAssistantStatusSession(args) {
       threadTs: args.threadTs,
       getSlackClient: args.getSlackClient
     }),
+    loadingMessages: args.loadingMessages ?? botConfig.loadingMessages,
     now: args.now,
     setTimer: args.setTimer,
     clearTimer: args.clearTimer,
@@ -8938,6 +9190,34 @@ function createPluginAuthOrchestration(deps, abortAgent) {
   };
 }
 
+// src/chat/runtime/report-progress.ts
+function buildReportedProgressStatus(input) {
+  if (!input || typeof input !== "object") {
+    return void 0;
+  }
+  const phase = input.phase;
+  if (typeof phase !== "string") {
+    return void 0;
+  }
+  const detail = compactStatusText(input.detail, 40);
+  switch (phase) {
+    case "thinking":
+      return makeAssistantStatus("thinking", detail, { source: "major" });
+    case "researching":
+      return makeAssistantStatus("searching", detail, { source: "major" });
+    case "reading":
+      return makeAssistantStatus("reading", detail, { source: "major" });
+    case "executing":
+      return makeAssistantStatus("running", detail, { source: "major" });
+    case "reviewing":
+      return makeAssistantStatus("reviewing", detail, { source: "major" });
+    case "drafting":
+      return makeAssistantStatus("drafting", detail, { source: "major" });
+    default:
+      return void 0;
+  }
+}
+
 // src/chat/runtime/tool-status.ts
 function buildToolStatus(toolName, input) {
   const obj = input && typeof input === "object" ? input : void 0;
@@ -8948,6 +9228,10 @@ function buildToolStatus(toolName, input) {
   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;
+  const reportedProgress = buildReportedProgressStatus(obj);
+  if (toolName === "reportProgress" && reportedProgress) {
+    return reportedProgress;
+  }
   if (command && toolName === "bash") {
     return makeAssistantStatus("running", command);
   }
@@ -8988,6 +9272,7 @@ function buildToolStatus(toolName, input) {
     slackChannelListMessages: makeAssistantStatus("listing", "messages"),
     slackCanvasCreate: makeAssistantStatus("creating", "brief"),
     slackCanvasUpdate: makeAssistantStatus("updating", "brief"),
+    slackCanvasRead: makeAssistantStatus("reading", "brief"),
     slackListCreate: makeAssistantStatus("creating", "tracking list"),
     slackListAddItems: makeAssistantStatus("updating", "tracking list"),
     slackListUpdateItem: makeAssistantStatus("updating", "tracking list"),
@@ -9322,41 +9607,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) {

package/dist/{chunk-A75TWGF2.js → chunk-4PVJHUEV.js}

@@ -22,6 +22,20 @@ var MIN_AGENT_TURN_TIMEOUT_MS = 10 * 1e3;
 var DEFAULT_AGENT_TURN_TIMEOUT_MS = 12 * 60 * 1e3;
 var DEFAULT_FUNCTION_MAX_DURATION_SECONDS = 800;
 var FUNCTION_TIMEOUT_BUFFER_SECONDS = 20;
+var DEFAULT_ASSISTANT_LOADING_MESSAGES = [
+  "Consulting the orb",
+  "Bribing the gremlins",
+  "Shuffling the papers dramatically",
+  "Summoning the right stack trace",
+  "Negotiating with the mutex",
+  "Poking the internet with a stick",
+  "Asking the docs nicely",
+  "Searching for the least cursed path",
+  "Pretending this was obvious",
+  "Waking up the test suite",
+  "Untangling the spaghetti carefully",
+  "Rattling the command line"
+];
 function parseAgentTurnTimeoutMs(rawValue, maxTimeoutMs) {
   const value = Number.parseInt(rawValue ?? "", 10);
   if (Number.isNaN(value)) {
@@ -44,6 +58,27 @@ function resolveMaxTurnTimeoutMs(functionMaxDurationSeconds) {
   const budgetSeconds = functionMaxDurationSeconds - FUNCTION_TIMEOUT_BUFFER_SECONDS;
   return Math.max(MIN_AGENT_TURN_TIMEOUT_MS, budgetSeconds * 1e3);
 }
+function parseLoadingMessages(rawValue) {
+  const trimmed = rawValue?.trim();
+  if (!trimmed) {
+    return [...DEFAULT_ASSISTANT_LOADING_MESSAGES];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    throw new Error("JUNIOR_LOADING_MESSAGES must be a JSON array of strings");
+  }
+  if (!Array.isArray(parsed)) {
+    throw new Error("JUNIOR_LOADING_MESSAGES must be a JSON array of strings");
+  }
+  return parsed.map((value, index) => {
+    if (typeof value !== "string") {
+      throw new Error(`JUNIOR_LOADING_MESSAGES[${index}] must be a string`);
+    }
+    return value.trim();
+  });
+}
 function readBotConfig(env) {
   const functionMaxDurationSeconds = resolveFunctionMaxDurationSeconds(env);
   const maxTurnTimeoutMs = resolveMaxTurnTimeoutMs(functionMaxDurationSeconds);
@@ -51,6 +86,7 @@ function readBotConfig(env) {
     userName: env.JUNIOR_BOT_NAME ?? "junior",
     modelId: env.AI_MODEL ?? "anthropic/claude-sonnet-4.6",
     fastModelId: env.AI_FAST_MODEL ?? env.AI_MODEL ?? "anthropic/claude-haiku-4.5",
+    loadingMessages: parseLoadingMessages(env.JUNIOR_LOADING_MESSAGES),
     visionModelId: toOptionalTrimmed(env.AI_VISION_MODEL),
     turnTimeoutMs: parseAgentTurnTimeoutMs(
       env.AGENT_TURN_TIMEOUT_MS,

package/dist/cli/snapshot-warmup.js

@@ -1,7 +1,7 @@
 import {
   disconnectStateAdapter,
   resolveRuntimeDependencySnapshot
-} from "../chunk-A75TWGF2.js";
+} from "../chunk-4PVJHUEV.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "private": false,
   "publishConfig": {
     "access": "public"