@sentry/junior 0.6.0 → 0.7.0

package/dist/{bot-HXAROQ33.js → bot-ZKMCCT3D.js}

@@ -4,9 +4,9 @@ import {
   createNormalizingStream,
   resetBotDepsForTests,
   setBotDepsForTests
-} from "./chunk-QNOV65P4.js";
+} from "./chunk-JRKU55W5.js";
 import "./chunk-KT5HARSN.js";
-import "./chunk-5UJSQX4R.js";
+import "./chunk-RKOO42TW.js";
 import "./chunk-Z5E25LRN.js";
 import "./chunk-PY4AI2GZ.js";
 import "./chunk-VW26MOSO.js";

package/dist/{chunk-VPCCZ3PK.js → chunk-56WI5Q7P.js}

@@ -4,7 +4,7 @@ import {
   downloadPrivateSlackFile,
   getThreadMessageTopic,
   removeReactionFromMessage
-} from "./chunk-QNOV65P4.js";
+} from "./chunk-JRKU55W5.js";
 import {
   acquireQueueMessageProcessingOwnership,
   completeQueueMessageProcessingOwnership,
@@ -12,11 +12,12 @@ import {
   getQueueMessageProcessingState,
   getStateAdapter,
   refreshQueueMessageProcessingOwnership
-} from "./chunk-5UJSQX4R.js";
+} from "./chunk-RKOO42TW.js";
 import {
   createRequestContext,
   logError,
   logException,
+  logInfo,
   logWarn,
   setSpanStatus,
   withContext,
@@ -77,7 +78,9 @@ function createMessageOwnerToken() {
 }
 var QueueMessageOwnershipError = class extends Error {
   constructor(stage, dedupKey) {
-    super(`Queue message ownership lost during ${stage} for dedupKey=${dedupKey}`);
+    super(
+      `Queue message ownership lost during ${stage} for dedupKey=${dedupKey}`
+    );
     this.name = "QueueMessageOwnershipError";
   }
 };
@@ -89,6 +92,7 @@ var defaultProcessQueuedThreadMessageDeps = {
       emoji: "eyes"
     });
   },
+  logInfo,
   logWarn,
   processRuntime: processThreadMessageRuntime
 };
@@ -122,8 +126,25 @@ async function logThreadMessageFailure(payload, errorMessage) {
   );
 }
 async function processQueuedThreadMessage(payload, deps = defaultProcessQueuedThreadMessageDeps) {
-  const existingMessageState = await getQueueMessageProcessingState(payload.dedupKey);
+  const existingMessageState = await getQueueMessageProcessingState(
+    payload.dedupKey
+  );
   if (existingMessageState?.status === "completed") {
+    deps.logInfo(
+      "queue_message_skipped_completed",
+      {
+        slackThreadId: payload.normalizedThreadId,
+        slackChannelId: getPayloadChannelId(payload),
+        slackUserId: getPayloadUserId(payload)
+      },
+      {
+        "messaging.message.id": payload.message.id,
+        "app.queue.message_kind": payload.kind,
+        "app.queue.message_id": payload.queueMessageId,
+        "app.queue.processing_state": existingMessageState.status
+      },
+      "Skipping queue message because it is already completed"
+    );
     return;
   }
   const ownerToken = createMessageOwnerToken();
@@ -133,6 +154,22 @@ async function processQueuedThreadMessage(payload, deps = defaultProcessQueuedTh
     queueMessageId: payload.queueMessageId
   });
   if (claimResult === "blocked") {
+    deps.logInfo(
+      "queue_message_skipped_blocked",
+      {
+        slackThreadId: payload.normalizedThreadId,
+        slackChannelId: getPayloadChannelId(payload),
+        slackUserId: getPayloadUserId(payload)
+      },
+      {
+        "messaging.message.id": payload.message.id,
+        "app.queue.message_kind": payload.kind,
+        "app.queue.message_id": payload.queueMessageId,
+        "app.queue.claim_result": claimResult,
+        "app.queue.processing_state": "processing"
+      },
+      "Skipping queue message because another worker owns it"
+    );
     return;
   }
   const threadWasSerialized = isSerializedThread(payload.thread);
@@ -209,42 +246,62 @@ async function processQueuedThreadMessage(payload, deps = defaultProcessQueuedTh
       queueMessageId: payload.queueMessageId
     });
     if (!failed && !(error instanceof QueueMessageOwnershipError)) {
-      throw new Error(`Failed to persist queue message failure state for dedupKey=${payload.dedupKey}: ${errorMessage}`);
+      throw new Error(
+        `Failed to persist queue message failure state for dedupKey=${payload.dedupKey}: ${errorMessage}`
+      );
     }
     throw error;
   }
 }
 
 // src/handlers/queue-callback.ts
-var callbackHandler = createQueueCallbackHandler(async (message, metadata) => {
-  if (metadata.topicName === getThreadMessageTopic()) {
-    const payload = {
-      ...message,
-      queueMessageId: metadata.messageId
-    };
-    await withSpan(
-      "queue.process_message",
-      "queue.process_message",
-      {
-        slackThreadId: payload.normalizedThreadId,
-        slackChannelId: payload.thread.channelId,
-        slackUserId: payload.message.author?.userId
-      },
-      async () => {
-        await processQueuedThreadMessage(payload);
-      },
-      {
-        "messaging.message.id": payload.message.id,
-        "app.queue.message_kind": payload.kind,
-        "app.queue.message_id": payload.queueMessageId,
-        "app.queue.delivery_count": metadata.deliveryCount,
-        "app.queue.topic": metadata.topicName
-      }
-    );
-    return;
+var callbackHandler = createQueueCallbackHandler(
+  async (message, metadata) => {
+    if (metadata.topicName === getThreadMessageTopic()) {
+      const payload = {
+        ...message,
+        queueMessageId: metadata.messageId
+      };
+      logInfo(
+        "queue_callback_received",
+        {
+          slackThreadId: payload.normalizedThreadId,
+          slackChannelId: payload.thread.channelId,
+          slackUserId: payload.message.author?.userId
+        },
+        {
+          "messaging.message.id": payload.message.id,
+          "app.queue.message_kind": payload.kind,
+          "app.queue.message_id": payload.queueMessageId,
+          "app.queue.delivery_count": metadata.deliveryCount,
+          "app.queue.topic": metadata.topicName
+        },
+        "Received queue callback payload"
+      );
+      await withSpan(
+        "queue.process_message",
+        "queue.process_message",
+        {
+          slackThreadId: payload.normalizedThreadId,
+          slackChannelId: payload.thread.channelId,
+          slackUserId: payload.message.author?.userId
+        },
+        async () => {
+          await processQueuedThreadMessage(payload);
+        },
+        {
+          "messaging.message.id": payload.message.id,
+          "app.queue.message_kind": payload.kind,
+          "app.queue.message_id": payload.queueMessageId,
+          "app.queue.delivery_count": metadata.deliveryCount,
+          "app.queue.topic": metadata.topicName
+        }
+      );
+      return;
+    }
+    throw new Error(`Unexpected queue topic: ${metadata.topicName}`);
   }
-  throw new Error(`Unexpected queue topic: ${metadata.topicName}`);
-});
+);
 async function POST(request) {
   const requestContext = createRequestContext(request, { platform: "queue" });
   return withContext(requestContext, async () => {

package/dist/{chunk-QNOV65P4.js → chunk-JRKU55W5.js}

@@ -31,7 +31,7 @@ import {
   skillRoots,
   soulPathCandidates,
   upsertAgentTurnSessionCheckpoint
-} from "./chunk-5UJSQX4R.js";
+} from "./chunk-RKOO42TW.js";
 import {
   logError,
   logException,
@@ -275,7 +275,7 @@ function escapeXml(value) {
 var replyDecisionSchema = z.object({
   should_reply: z.boolean().describe("Whether Junior should respond to this thread message."),
   confidence: z.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
-  reason: z.string().max(160).optional().describe("Short reason for the decision.")
+  reason: z.string().optional().describe("Short reason for the decision.")
 });
 var ROUTER_CONFIDENCE_THRESHOLD = 0.72;
 var ACK_REGEXES = [
@@ -1070,11 +1070,12 @@ 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 `attachFile` to attach files from the sandbox (for example screenshots, PDFs, logs) to the Slack 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.",
@@ -2915,7 +2916,7 @@ async function detectMimeType(sandbox, targetPath) {
 }
 function createAttachFileTool(sandbox, hooks = {}) {
   return tool({
-    description: "Attach a file from the sandbox to the Slack reply. Use this immediately after creating screenshots/reports when the user asks to see/share the actual file, not just its path.",
+    description: "Attach a file to the Slack reply. Use this for files that exist in the sandbox, such as screenshots, PDFs, or logs, or for generated image `attachment_path` values returned earlier in the turn.",
     inputSchema: Type2.Object(
       {
         path: Type2.String({
@@ -2941,6 +2942,20 @@ function createAttachFileTool(sandbox, hooks = {}) {
       const targetPath = normalizeSandboxPath(requestedPath);
       const fileBuffer = await sandbox.readFileToBuffer({ path: targetPath });
       if (!fileBuffer) {
+        const generatedFile = hooks.getGeneratedFile?.(
+          path3.posix.basename(targetPath)
+        );
+        if (generatedFile) {
+          hooks.onGeneratedFiles?.([generatedFile]);
+          return {
+            ok: true,
+            attached: true,
+            path: targetPath,
+            filename: generatedFile.filename,
+            mime_type: generatedFile.mimeType ?? inferMimeType(generatedFile.filename),
+            bytes: Buffer.isBuffer(generatedFile.data) ? generatedFile.data.byteLength : generatedFile.data instanceof ArrayBuffer ? generatedFile.data.byteLength : generatedFile.data.size
+          };
+        }
         throw new Error(`failed to read file: ${targetPath}`);
       }
       if (fileBuffer.byteLength === 0) {
@@ -3224,12 +3239,22 @@ async function enrichImagePrompt(rawPrompt) {
       maxTokens: 1024
     });
     if (text && text.trim().length > 0) {
-      logInfo("image_prompt_enriched", {}, { "app.image.enriched_prompt_length": text.trim().length }, "Image prompt enriched with persona");
+      logInfo(
+        "image_prompt_enriched",
+        {},
+        { "app.image.enriched_prompt_length": text.trim().length },
+        "Image prompt enriched with persona"
+      );
       return text.trim();
     }
     return rawPrompt;
   } catch (error) {
-    logWarn("image_prompt_enrichment_failed", {}, { "error.message": String(error) }, "Image prompt enrichment failed, using raw prompt");
+    logWarn(
+      "image_prompt_enrichment_failed",
+      {},
+      { "error.message": String(error) },
+      "Image prompt enrichment failed, using raw prompt"
+    );
     return rawPrompt;
   }
 }
@@ -3254,7 +3279,7 @@ function parseImageGenerationError(status, body, model) {
     return `image generation failed: ${status} ${body}`;
   }
 }
-function createImageGenerateTool(hooks) {
+function createImageGenerateTool(hooks, deps = {}) {
   return tool({
     description: "Generate images from a prompt. Use when the user wants to visually show or represent something \u2014 feelings, concepts, art, humor, or any visual idea. Also use for explicit image creation requests.",
     inputSchema: Type3.Object({
@@ -3265,27 +3290,35 @@ function createImageGenerateTool(hooks) {
       })
     }),
     execute: async ({ prompt }) => {
+      const fetchImpl = deps.fetch ?? fetch;
       const apiKey = process.env.AI_GATEWAY_API_KEY ?? process.env.VERCEL_OIDC_TOKEN;
       if (!apiKey) {
-        throw new Error("Missing AI gateway credentials (AI_GATEWAY_API_KEY or VERCEL_OIDC_TOKEN)");
+        throw new Error(
+          "Missing AI gateway credentials (AI_GATEWAY_API_KEY or VERCEL_OIDC_TOKEN)"
+        );
       }
       const model = process.env.AI_IMAGE_MODEL ?? DEFAULT_IMAGE_MODEL;
       const enrichedPrompt = await enrichImagePrompt(prompt);
-      const response = await fetch("https://ai-gateway.vercel.sh/v1/chat/completions", {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          authorization: `Bearer ${apiKey}`
-        },
-        body: JSON.stringify({
-          model,
-          messages: [{ role: "user", content: enrichedPrompt }],
-          modalities: ["image"]
-        })
-      });
+      const response = await fetchImpl(
+        "https://ai-gateway.vercel.sh/v1/chat/completions",
+        {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${apiKey}`
+          },
+          body: JSON.stringify({
+            model,
+            messages: [{ role: "user", content: enrichedPrompt }],
+            modalities: ["image"]
+          })
+        }
+      );
       if (!response.ok) {
         const text = await response.text();
-        throw new Error(parseImageGenerationError(response.status, text, model));
+        throw new Error(
+          parseImageGenerationError(response.status, text, model)
+        );
       }
       const payload = await response.json();
       const uploads = [];
@@ -3300,7 +3333,7 @@ function createImageGenerateTool(hooks) {
           mimeType = match[1] ?? mimeType;
           bytes = Buffer.from(match[2] ?? "", "base64");
         } else if (typeof url === "string" && url.length > 0) {
-          const fetched = await fetch(url);
+          const fetched = await fetchImpl(url);
           if (!fetched.ok) continue;
           mimeType = fetched.headers.get("content-type") ?? mimeType;
           bytes = Buffer.from(await fetched.arrayBuffer());
@@ -3314,7 +3347,7 @@ function createImageGenerateTool(hooks) {
         });
       }
       if (uploads.length > 0) {
-        hooks.onGeneratedFiles?.(uploads);
+        hooks.onGeneratedArtifactFiles?.(uploads);
       }
       return {
         ok: true,
@@ -3324,10 +3357,11 @@ function createImageGenerateTool(hooks) {
         image_count: uploads.length,
         images: uploads.map((upload) => ({
           filename: upload.filename,
+          attachment_path: upload.filename,
           media_type: upload.mimeType,
           bytes: upload.data.byteLength
         })),
-        delivery: "Images will be attached to the Slack response as files."
+        delivery: "Generated images are available to attach with attachFile using the returned attachment_path."
       };
     }
   });
@@ -5039,7 +5073,7 @@ function createTools(availableSkills, hooks = {}, context) {
     webFetch: wrapToolExecution("webFetch", createWebFetchTool(hooks), hooks),
     imageGenerate: wrapToolExecution(
       "imageGenerate",
-      createImageGenerateTool(hooks),
+      createImageGenerateTool(hooks, hooks.toolOverrides?.imageGenerate),
       hooks
     ),
     slackCanvasUpdate: wrapToolExecution(
@@ -6785,6 +6819,7 @@ async function generateAssistantReply(messageText, context = {}) {
       };
     }
     const generatedFiles = [];
+    const replyFiles = [];
     const artifactStatePatch = {};
     const toolCalls = [];
     setTags({
@@ -6801,9 +6836,13 @@ async function generateAssistantReply(messageText, context = {}) {
     const tools = createTools(
       availableSkills,
       {
-        onGeneratedFiles: (files) => {
+        getGeneratedFile: (filename) => generatedFiles.find((file) => file.filename === filename),
+        onGeneratedArtifactFiles: (files) => {
           generatedFiles.push(...files);
         },
+        onGeneratedFiles: (files) => {
+          replyFiles.push(...files);
+        },
         onArtifactStatePatch: (patch) => {
           Object.assign(artifactStatePatch, patch);
         },
@@ -6817,6 +6856,7 @@ async function generateAssistantReply(messageText, context = {}) {
             `${formatToolResultStatusWithInput(toolName, input)}...`
           );
         },
+        toolOverrides: context.toolOverrides,
         onSkillLoaded: async (loadedSkill) => {
           const resolvedSkill = await skillSandbox.loadSkill(loadedSkill.name);
           const effective = resolvedSkill ?? loadedSkill;
@@ -6909,9 +6949,7 @@ async function generateAssistantReply(messageText, context = {}) {
           {
             onToolCall: (toolName) => {
               toolCalls.push(toolName);
-            },
-            onGeneratedFiles: (files) => generatedFiles.push(...files),
-            onArtifactStatePatch: (patch) => Object.assign(artifactStatePatch, patch)
+            }
           }
         )
       }
@@ -7063,7 +7101,7 @@ async function generateAssistantReply(messageText, context = {}) {
       explicitChannelPostIntent,
       channelPostPerformed,
       reactionPerformed,
-      hasFiles: generatedFiles.length > 0,
+      hasFiles: replyFiles.length > 0,
       streamingThreadReply: Boolean(context.onTextDelta)
     });
     const deliveryMode = deliveryPlan.mode;
@@ -7094,7 +7132,7 @@ async function generateAssistantReply(messageText, context = {}) {
     const outcome = primaryText ? stopReason === "error" ? "provider_error" : "success" : "execution_failure";
     const candidateText = primaryText || buildExecutionFailureMessage(toolErrorCount);
     const escapedOrRawPayload = isExecutionEscapeResponse(candidateText) || isRawToolPayloadResponse(candidateText);
-    const resolvedText = escapedOrRawPayload ? buildExecutionFailureMessage(toolErrorCount) : enforceAttachmentClaimTruth(candidateText, generatedFiles.length > 0);
+    const resolvedText = escapedOrRawPayload ? buildExecutionFailureMessage(toolErrorCount) : enforceAttachmentClaimTruth(candidateText, replyFiles.length > 0);
     const resolvedOutcome = escapedOrRawPayload ? "execution_failure" : outcome;
     if (shouldTrace) {
       logInfo(
@@ -7114,7 +7152,7 @@ async function generateAssistantReply(messageText, context = {}) {
     if (escapedOrRawPayload) {
       return {
         text: resolvedText,
-        files: generatedFiles.length > 0 ? generatedFiles : void 0,
+        files: replyFiles.length > 0 ? replyFiles : void 0,
         artifactStatePatch: Object.keys(artifactStatePatch).length > 0 ? artifactStatePatch : void 0,
         deliveryPlan,
         deliveryMode,
@@ -7137,7 +7175,7 @@ async function generateAssistantReply(messageText, context = {}) {
     }
     return {
       text: resolvedText,
-      files: generatedFiles.length > 0 ? generatedFiles : void 0,
+      files: replyFiles.length > 0 ? replyFiles : void 0,
       artifactStatePatch: Object.keys(artifactStatePatch).length > 0 ? artifactStatePatch : void 0,
       deliveryPlan,
       deliveryMode,
@@ -7614,6 +7652,27 @@ function determineThreadMessageKind(args) {
   }
   return void 0;
 }
+function getMessageLogContext(args) {
+  return {
+    slackThreadId: args.normalizedThreadId,
+    slackChannelId: nonEmptyString(args.message.raw?.channel),
+    slackUserId: args.message.author?.userId
+  };
+}
+function logIgnoredIngressResult(args) {
+  args.deps.logInfo(
+    args.eventName,
+    args.logContext,
+    {
+      ...args.messageId ? { "messaging.message.id": args.messageId } : {},
+      ...args.kind ? { "app.queue.message_kind": args.kind } : {},
+      ...args.dedupKey ? { "app.queue.dedup_key": args.dedupKey } : {},
+      ...args.decisionReason ? { "app.decision.reason": args.decisionReason } : {},
+      "app.queue.route_result": args.routeResult
+    },
+    args.body
+  );
+}
 var defaultQueueRoutingDeps = {
   hasDedup: (key) => hasQueueIngressDedup(key),
   markDedup: (key, ttlMs) => claimQueueIngressDedup(key, ttlMs),
@@ -7623,7 +7682,11 @@ var defaultQueueRoutingDeps = {
   enqueueThreadMessage: async (payload, dedupKey) => await enqueueThreadMessage(payload, {
     idempotencyKey: dedupKey
   }),
-  shouldReplyInSubscribedThread: async ({ message, normalizedThreadId, thread }) => {
+  shouldReplyInSubscribedThread: async ({
+    message,
+    normalizedThreadId,
+    thread
+  }) => {
     const rawText = message.text;
     const text = stripLeadingBotMention(rawText, {
       stripLeadingSlackMentionToken: Boolean(message.isMention)
@@ -7668,25 +7731,56 @@ async function routeIncomingMessageToQueue(args) {
   if (!message || typeof message !== "object") {
     return "ignored_non_object";
   }
-  const normalizedThreadId = normalizeIncomingSlackThreadId(args.threadId, message);
+  const normalizedThreadId = normalizeIncomingSlackThreadId(
+    args.threadId,
+    message
+  );
+  const baseLogContext = getMessageLogContext({
+    message,
+    normalizedThreadId
+  });
   if ("threadId" in message) {
     message.threadId = normalizedThreadId;
   }
   const typedMessage = message;
   if (typedMessage.author?.isMe) {
+    logIgnoredIngressResult({
+      deps,
+      eventName: "queue_ingress_ignored_self_message",
+      logContext: baseLogContext,
+      messageId: nonEmptyString(typedMessage.id),
+      routeResult: "ignored_self_message",
+      body: "Ignoring self-authored message before queue routing"
+    });
     return "ignored_self_message";
   }
   const messageId = nonEmptyString(typedMessage.id);
   if (!messageId) {
+    logIgnoredIngressResult({
+      deps,
+      eventName: "queue_ingress_ignored_missing_message_id",
+      logContext: baseLogContext,
+      routeResult: "ignored_missing_message_id",
+      body: "Ignoring message without an id before queue routing"
+    });
     return "ignored_missing_message_id";
   }
   const isSubscribed = await deps.getIsSubscribed(normalizedThreadId);
-  const isMention = Boolean(typedMessage.isMention || runtime.detectMention?.(adapter, message));
+  const mentionSource = typedMessage.isMention ? "sdk_flag" : runtime.detectMention?.(adapter, message) ? "fallback_detector" : void 0;
+  const isMention = mentionSource !== void 0;
   const kind = determineThreadMessageKind({
     isSubscribed,
     isMention
   });
   if (!kind) {
+    logIgnoredIngressResult({
+      deps,
+      eventName: "queue_ingress_ignored_unsubscribed_non_mention",
+      logContext: baseLogContext,
+      messageId,
+      routeResult: "ignored_unsubscribed_non_mention",
+      body: "Ignoring unsubscribed non-mention message before queue routing"
+    });
     return "ignored_unsubscribed_non_mention";
   }
   const dedupKey = buildQueueIngressDedupKey(normalizedThreadId, messageId);
@@ -7694,21 +7788,25 @@ async function routeIncomingMessageToQueue(args) {
   if (alreadyDeduped) {
     deps.logInfo(
       "queue_ingress_dedup_hit",
-      {
-        slackThreadId: normalizedThreadId,
-        slackUserId: message.author.userId
-      },
+      baseLogContext,
       {
         "messaging.message.id": messageId,
         "app.queue.message_kind": kind,
         "app.queue.dedup_key": dedupKey,
-        "app.queue.dedup_outcome": "duplicate"
+        "app.queue.dedup_outcome": "duplicate",
+        ...mentionSource ? { "app.slack.mention_source": mentionSource } : {},
+        "app.queue.route_result": "ignored_duplicate"
       },
       "Skipping duplicate incoming message before queue enqueue"
     );
     return "ignored_duplicate";
   }
-  const thread = await runtime.createThread(adapter, normalizedThreadId, message, isSubscribed);
+  const thread = await runtime.createThread(
+    adapter,
+    normalizedThreadId,
+    message,
+    isSubscribed
+  );
   const serializedMessage = serializeMessageForQueue(message);
   const serializedThread = serializeThreadForQueue(thread);
   let payloadKind = kind;
@@ -7719,6 +7817,17 @@ async function routeIncomingMessageToQueue(args) {
       thread
     });
     if (!decision.shouldReply) {
+      logIgnoredIngressResult({
+        deps,
+        eventName: "queue_ingress_ignored_passive_no_reply",
+        logContext: baseLogContext,
+        messageId,
+        dedupKey,
+        kind,
+        routeResult: "ignored_passive_no_reply",
+        decisionReason: decision.reason,
+        body: "Skipping passive subscribed-thread reply before queue enqueue"
+      });
       return "ignored_passive_no_reply";
     }
     payloadKind = "subscribed_reply";
@@ -7753,6 +7862,7 @@ async function routeIncomingMessageToQueue(args) {
           {
             "messaging.message.id": messageId,
             "app.queue.message_kind": payloadKind,
+            ...mentionSource ? { "app.slack.mention_source": mentionSource } : {},
             "error.message": errorMessage
           },
           "Failed to add ingress processing reaction"
@@ -7809,8 +7919,10 @@ async function routeIncomingMessageToQueue(args) {
         {
           "messaging.message.id": messageId,
           "app.queue.message_kind": payloadKind,
+          ...mentionSource ? { "app.slack.mention_source": mentionSource } : {},
           "app.queue.dedup_key": dedupKey,
           "app.queue.dedup_outcome": "primary",
+          "app.queue.route_result": "routed",
           ...queueMessageId ? { "app.queue.message_id": queueMessageId } : {}
         },
         "Routing incoming message to queue"
@@ -7860,14 +7972,20 @@ function installChatBackgroundPatch() {
           }
         });
         if (result === "ignored_missing_message_id") {
-          const normalizedThreadId = normalizeIncomingSlackThreadId(threadId, message);
+          const normalizedThreadId = normalizeIncomingSlackThreadId(
+            threadId,
+            message
+          );
           this.logger?.error?.("Message processing error", {
             threadId: normalizedThreadId,
             reason: "missing_message_id"
           });
         }
       } catch (err) {
-        this.logger?.error?.("Message processing error", { error: err, threadId });
+        this.logger?.error?.("Message processing error", {
+          error: err,
+          threadId
+        });
       }
     };
     scheduleBackgroundWork(options, run);
@@ -7904,7 +8022,12 @@ function installChatBackgroundPatch() {
     const run = async () => {
       try {
         const { relatedThread, relatedMessage, relatedChannel } = await this.retrieveModalContext(event.adapter.name, contextId);
-        const fullEvent = { ...event, relatedThread, relatedMessage, relatedChannel };
+        const fullEvent = {
+          ...event,
+          relatedThread,
+          relatedMessage,
+          relatedChannel
+        };
         for (const { callbackIds, handler } of this.modalCloseHandlers) {
           if (callbackIds.length === 0 || callbackIds.includes(event.callbackId)) {
             await handler(fullEvent);
@@ -9700,7 +9823,7 @@ function resolveReplyDelivery(args) {
     postThreadText: (args.reply.deliveryMode ?? "thread") !== "channel_only",
     attachFiles: replyHasFiles ? args.hasStreamedThreadReply ? "followup" : "inline" : "none"
   };
-  let attachFiles = deliveryPlan.attachFiles;
+  let attachFiles = replyHasFiles ? deliveryPlan.attachFiles : "none";
   if (attachFiles === "followup" && !args.hasStreamedThreadReply) {
     attachFiles = "inline";
   }

package/dist/{chunk-EZ6WIJL2.js → chunk-QHKQ2AWX.js}

@@ -12,7 +12,7 @@ import {
 import { after } from "next/server";
 import * as Sentry from "@sentry/nextjs";
 async function loadBot() {
-  const { bot } = await import("./bot-HXAROQ33.js");
+  const { bot } = await import("./bot-ZKMCCT3D.js");
   return bot;
 }
 async function POST(request, context) {

package/dist/{chunk-5UJSQX4R.js → chunk-RKOO42TW.js}

@@ -935,6 +935,7 @@ function createQueuedStateAdapter(base) {
     return lock;
   };
   return {
+    appendToList: (key, value, options) => base.appendToList(key, value, options),
     connect: () => base.connect(),
     disconnect: () => base.disconnect(),
     subscribe: (threadId) => base.subscribe(threadId),
@@ -943,7 +944,9 @@ function createQueuedStateAdapter(base) {
     acquireLock,
     releaseLock: (lock) => base.releaseLock(lock),
     extendLock: (lock, ttlMs) => base.extendLock(lock, Math.max(ttlMs, MIN_LOCK_TTL_MS)),
+    forceReleaseLock: (threadId) => base.forceReleaseLock(threadId),
     get: (key) => base.get(key),
+    getList: (key) => base.getList(key),
     set: (key, value, ttlMs) => base.set(key, value, ttlMs),
     setIfNotExists: (key, value, ttlMs) => base.setIfNotExists(key, value, ttlMs),
     delete: (key) => base.delete(key)
@@ -1088,7 +1091,11 @@ async function acquireQueueMessageProcessingOwnership(args) {
   });
   const result = await getRedisStateAdapter().getClient().eval(CLAIM_OR_RECLAIM_PROCESSING_SCRIPT, {
     keys: [key],
-    arguments: [String(nowMs), String(QUEUE_MESSAGE_PROCESSING_TTL_MS), payload]
+    arguments: [
+      String(nowMs),
+      String(QUEUE_MESSAGE_PROCESSING_TTL_MS),
+      payload
+    ]
   });
   if (result === 1) {
     return "acquired";
@@ -1112,7 +1119,11 @@ async function refreshQueueMessageProcessingOwnership(args) {
   });
   const result = await getRedisStateAdapter().getClient().eval(UPDATE_PROCESSING_STATE_IF_OWNER_SCRIPT, {
     keys: [queueMessageKey(args.rawKey)],
-    arguments: [args.ownerToken, String(QUEUE_MESSAGE_PROCESSING_TTL_MS), payload]
+    arguments: [
+      args.ownerToken,
+      String(QUEUE_MESSAGE_PROCESSING_TTL_MS),
+      payload
+    ]
   });
   return result === 1;
 }
@@ -1126,7 +1137,11 @@ async function completeQueueMessageProcessingOwnership(args) {
   });
   const result = await getRedisStateAdapter().getClient().eval(UPDATE_PROCESSING_STATE_IF_OWNER_SCRIPT, {
     keys: [queueMessageKey(args.rawKey)],
-    arguments: [args.ownerToken, String(QUEUE_MESSAGE_COMPLETED_TTL_MS), payload]
+    arguments: [
+      args.ownerToken,
+      String(QUEUE_MESSAGE_COMPLETED_TTL_MS),
+      payload
+    ]
   });
   return result === 1;
 }
@@ -1141,18 +1156,27 @@ async function failQueueMessageProcessingOwnership(args) {
   });
   const result = await getRedisStateAdapter().getClient().eval(UPDATE_PROCESSING_STATE_IF_OWNER_SCRIPT, {
     keys: [queueMessageKey(args.rawKey)],
-    arguments: [args.ownerToken, String(QUEUE_MESSAGE_FAILED_TTL_MS), payload]
+    arguments: [
+      args.ownerToken,
+      String(QUEUE_MESSAGE_FAILED_TTL_MS),
+      payload
+    ]
   });
   return result === 1;
 }
 async function getAgentTurnSessionCheckpoint(conversationId, sessionId) {
   await getStateAdapter().connect();
-  const value = await getStateAdapter().get(agentTurnSessionKey(conversationId, sessionId));
+  const value = await getStateAdapter().get(
+    agentTurnSessionKey(conversationId, sessionId)
+  );
   return parseAgentTurnSessionCheckpoint(value);
 }
 async function upsertAgentTurnSessionCheckpoint(args) {
   await getStateAdapter().connect();
-  const existing = await getAgentTurnSessionCheckpoint(args.conversationId, args.sessionId);
+  const existing = await getAgentTurnSessionCheckpoint(
+    args.conversationId,
+    args.sessionId
+  );
   const checkpoint = {
     checkpointVersion: (existing?.checkpointVersion ?? 0) + 1,
     conversationId: args.conversationId,
@@ -1165,7 +1189,11 @@ async function upsertAgentTurnSessionCheckpoint(args) {
     ...typeof args.resumedFromSliceId === "number" ? { resumedFromSliceId: args.resumedFromSliceId } : {}
   };
   const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
-  await getStateAdapter().set(agentTurnSessionKey(args.conversationId, args.sessionId), JSON.stringify(checkpoint), ttlMs);
+  await getStateAdapter().set(
+    agentTurnSessionKey(args.conversationId, args.sessionId),
+    JSON.stringify(checkpoint),
+    ttlMs
+  );
   return checkpoint;
 }
 

package/dist/cli/snapshot-warmup.js

@@ -4,7 +4,7 @@ import {
   getPluginRuntimeDependencies,
   getPluginRuntimePostinstall,
   resolveRuntimeDependencySnapshot
-} from "../chunk-5UJSQX4R.js";
+} from "../chunk-RKOO42TW.js";
 import "../chunk-Z5E25LRN.js";
 import "../chunk-PY4AI2GZ.js";
 import "../chunk-VW26MOSO.js";

package/dist/handlers/queue-callback.js

@@ -1,9 +1,9 @@
 import {
   POST
-} from "../chunk-VPCCZ3PK.js";
-import "../chunk-QNOV65P4.js";
+} from "../chunk-56WI5Q7P.js";
+import "../chunk-JRKU55W5.js";
 import "../chunk-KT5HARSN.js";
-import "../chunk-5UJSQX4R.js";
+import "../chunk-RKOO42TW.js";
 import "../chunk-Z5E25LRN.js";
 import "../chunk-PY4AI2GZ.js";
 import "../chunk-VW26MOSO.js";

package/dist/handlers/router.js

@@ -1,9 +1,9 @@
 import {
   POST as POST2
-} from "../chunk-EZ6WIJL2.js";
+} from "../chunk-QHKQ2AWX.js";
 import {
   POST
-} from "../chunk-VPCCZ3PK.js";
+} from "../chunk-56WI5Q7P.js";
 import {
   escapeXml,
   formatProviderLabel,
@@ -13,7 +13,7 @@ import {
   publishAppHomeView,
   resolveBaseUrl,
   truncateStatusText
-} from "../chunk-QNOV65P4.js";
+} from "../chunk-JRKU55W5.js";
 import {
   GET
 } from "../chunk-4RBEYCOG.js";
@@ -24,7 +24,7 @@ import {
   getPluginOAuthConfig,
   getStateAdapter,
   parseOAuthTokenResponse
-} from "../chunk-5UJSQX4R.js";
+} from "../chunk-RKOO42TW.js";
 import "../chunk-Z5E25LRN.js";
 import {
   logException,

package/dist/handlers/webhooks.js

@@ -1,6 +1,6 @@
 import {
   POST
-} from "../chunk-EZ6WIJL2.js";
+} from "../chunk-QHKQ2AWX.js";
 import "../chunk-PY4AI2GZ.js";
 export {
   POST

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -24,9 +24,9 @@
   ],
   "dependencies": {
     "@ai-sdk/gateway": "^3.0.66",
-    "@chat-adapter/slack": "4.17.0",
-    "@chat-adapter/state-memory": "4.17.0",
-    "@chat-adapter/state-redis": "4.17.0",
+    "@chat-adapter/slack": "4.20.2",
+    "@chat-adapter/state-memory": "4.20.2",
+    "@chat-adapter/state-redis": "4.20.2",
     "@mariozechner/pi-agent-core": "^0.56.3",
     "@mariozechner/pi-ai": "^0.56.3",
     "@sinclair/typebox": "^0.34.48",
@@ -35,7 +35,7 @@
     "@vercel/sandbox": "^1.8.0",
     "ai": "^6.0.116",
     "bash-tool": "^1.3.15",
-    "chat": "4.17.0",
+    "chat": "4.20.2",
     "just-bash": "^2.12.0",
     "node-html-markdown": "^2.0.0",
     "yaml": "^2.8.2",