@sentry/junior 0.9.4 → 0.10.0

package/dist/{chunk-FLP5I4NM.js → chunk-7RM2Y52T.js}

@@ -1,9 +1,19 @@
+import {
+  discoverSkills,
+  findSkillByName,
+  getCapabilityProvider,
+  listCapabilityProviders,
+  loadSkillsByName,
+  logCapabilityCatalogLoadedOnce,
+  parseSkillInvocation,
+  stripFrontmatter
+} from "./chunk-WM66QDLA.js";
 import {
   SANDBOX_SKILLS_ROOT,
   SANDBOX_WORKSPACE_ROOT,
   botConfig,
   buildNonInteractiveShellScript,
-  getConnectedStateContext,
+  getChatConfig,
   getRuntimeDependencyProfileHash,
   getRuntimeMetadata,
   getSlackBotToken,
@@ -17,20 +27,11 @@ import {
   runNonInteractiveCommand,
   sandboxSkillDir,
   toOptionalTrimmed
-} from "./chunk-FS5Y4CF2.js";
-import {
-  discoverSkills,
-  findSkillByName,
-  getCapabilityProvider,
-  listCapabilityProviders,
-  loadSkillsByName,
-  logCapabilityCatalogLoadedOnce,
-  parseSkillInvocation,
-  stripFrontmatter
-} from "./chunk-WM66QDLA.js";
+} from "./chunk-BJ4EBVQK.js";
 import {
   CredentialUnavailableError,
   createPluginBroker,
+  createRequestContext,
   extractGenAiUsageAttributes,
   getPluginDefinition,
   getPluginMcpProviders,
@@ -57,102 +58,9 @@ import {
   soulPathCandidates
 } from "./chunk-KCLEEKYX.js";
 
-// src/chat/queue/errors.ts
-var DeferredThreadMessageError = class extends Error {
-  code = "deferred_thread_message";
-  reason;
-  constructor(reason, threadId, details) {
-    if (reason === "thread_locked") {
-      super(
-        `Queue message deferred because thread ${threadId} is already locked`
-      );
-    } else {
-      super(
-        `Queue message deferred for thread ${threadId} because activeTurnId=${details?.activeTurnId ?? "unknown"} is still in progress for currentTurnId=${details?.currentTurnId ?? "unknown"}`
-      );
-    }
-    this.name = "DeferredThreadMessageError";
-    this.reason = reason;
-  }
-};
-function isDeferredThreadMessageError(error, reason) {
-  if (!(error instanceof DeferredThreadMessageError)) {
-    return false;
-  }
-  if (!reason) {
-    return true;
-  }
-  return error.reason === reason;
-}
-
-// src/chat/queue/transport.ts
-import { handleCallback, send } from "@vercel/queue";
-async function sendQueueMessage(topicName, payload, options) {
-  const result = await send(topicName, payload, {
-    ...options?.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}
-  });
-  return result.messageId ?? void 0;
-}
-function createTransportCallbackHandler(handler, options) {
-  return handleCallback(
-    async (message, metadata) => {
-      await handler(message, {
-        messageId: metadata.messageId,
-        deliveryCount: metadata.deliveryCount,
-        topicName: metadata.topicName
-      });
-    },
-    options ? {
-      retry: options.retry ? (error, metadata) => options.retry?.(error, {
-        messageId: metadata.messageId,
-        deliveryCount: metadata.deliveryCount,
-        topicName: metadata.topicName
-      }) : void 0
-    } : void 0
-  );
-}
-
-// src/chat/queue/client.ts
-var THREAD_MESSAGE_TOPIC = "junior-thread-message";
-var MAX_DELIVERY_ATTEMPTS = 10;
-var THREAD_LOCK_RETRY_MAX_SECONDS = 30;
-var ACTIVE_TURN_RETRY_MAX_SECONDS = 300;
-function getThreadMessageTopic() {
-  return THREAD_MESSAGE_TOPIC;
-}
-async function enqueueThreadMessage(payload, options) {
-  return await sendQueueMessage(getThreadMessageTopic(), payload, options);
-}
-function createQueueCallbackHandler(handler) {
-  return createTransportCallbackHandler(handler, {
-    retry: (error, metadata) => {
-      if (isDeferredThreadMessageError(error, "thread_locked")) {
-        return {
-          afterSeconds: Math.min(
-            THREAD_LOCK_RETRY_MAX_SECONDS,
-            Math.max(5, metadata.deliveryCount * 5)
-          )
-        };
-      }
-      if (isDeferredThreadMessageError(error, "active_turn")) {
-        return {
-          afterSeconds: Math.min(
-            ACTIVE_TURN_RETRY_MAX_SECONDS,
-            Math.max(30, metadata.deliveryCount * 30)
-          )
-        };
-      }
-      if (metadata.deliveryCount >= MAX_DELIVERY_ATTEMPTS) {
-        return { acknowledge: true };
-      }
-      const backoffSeconds = Math.min(
-        300,
-        Math.max(5, metadata.deliveryCount * 5)
-      );
-      return { afterSeconds: backoffSeconds };
-    }
-  });
-}
+// src/handlers/webhooks.ts
+import { after } from "next/server";
+import * as Sentry from "@sentry/nextjs";
 
 // src/chat/app/production.ts
 import { createSlackAdapter } from "@chat-adapter/slack";
@@ -174,9 +82,10 @@ var replyDecisionSchema = z.object({
   confidence: z.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
   reason: z.string().optional().describe("Short reason for the decision.")
 });
-var ROUTER_CONFIDENCE_THRESHOLD = 0.9;
+var ROUTER_CONFIDENCE_THRESHOLD = 0.8;
 var LEADING_SLACK_MENTION_RE = /^\s*<@([A-Z0-9]+)(?:\|([^>]+))?>[\s,:-]*/i;
 var LEADING_NAMED_MENTION_RE = /^\s*@([a-z0-9._-]+)\b[\s,:-]*/i;
+var TRANSCRIPT_MESSAGE_LINE_RE = /^\[(assistant|system|user)\]\s+[^:]+:\s+([\s\S]+)$/i;
 var THREAD_OPTOUT_PATTERNS = [
   /\bstop (?:watching|replying|participating)\b/i,
   /\bstay out\b/i,
@@ -220,6 +129,36 @@ function isThreadOptOutInstruction(rawText, text) {
     (pattern) => pattern.test(rawText) || pattern.test(text)
   );
 }
+function getTranscriptMessageHints(conversationContext) {
+  if (!conversationContext) {
+    return {
+      latestPriorMessageRole: "[none]",
+      latestPriorAssistantMessage: "[none]"
+    };
+  }
+  const lines = conversationContext.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  let latestPriorMessageRole = "[none]";
+  let latestPriorAssistantMessage = "[none]";
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const match = lines[index]?.match(TRANSCRIPT_MESSAGE_LINE_RE);
+    if (!match) {
+      continue;
+    }
+    if (latestPriorMessageRole === "[none]") {
+      latestPriorMessageRole = match[1].toLowerCase();
+    }
+    if (latestPriorAssistantMessage === "[none]" && match[1].toLowerCase() === "assistant") {
+      latestPriorAssistantMessage = match[2];
+    }
+    if (latestPriorMessageRole !== "[none]" && latestPriorAssistantMessage !== "[none]") {
+      break;
+    }
+  }
+  return {
+    latestPriorMessageRole,
+    latestPriorAssistantMessage
+  };
+}
 function getSubscribedReplyPreflightDecision(args) {
   const text = args.text.trim();
   const rawText = args.rawText.trim();
@@ -241,6 +180,7 @@ function getSubscribedReplyPreflightDecision(args) {
   };
 }
 function buildRouterSystemPrompt(botUserName, conversationContext, isExplicitMention) {
+  const { latestPriorMessageRole, latestPriorAssistantMessage } = getTranscriptMessageHints(conversationContext);
   return [
     "You are a message router for a Slack assistant named Junior in a subscribed Slack thread.",
     "Decide whether Junior should reply to the latest message.",
@@ -264,8 +204,14 @@ function buildRouterSystemPrompt(botUserName, conversationContext, isExplicitMen
     "",
     "Examples of messages Junior SHOULD reply to (should_reply=true):",
     "- Direct follow-ups to Junior's response: 'Can you explain that last point in more detail?'",
+    "- Self-referential follow-ups after Junior just answered: 'What did you just say about the budget?', 'Can you explain your last response in more detail?'",
     "- Explicit requests for Junior's help: 'Junior, what's causing this error?'",
     "",
+    "Treat a message as directed at Junior when it explicitly refers to Junior's immediately previous reply",
+    "using language like 'you just said', 'your last response', 'your last answer', or similar self-reference.",
+    "Do not confuse that with general topic continuation. A message like 'What about the billing worker timeline?'",
+    "still should_reply=false unless it clearly asks Junior for help.",
+    "",
     "When in doubt, should_reply=false. Most messages in a thread are human-to-human conversation.",
     "",
     "If the user is clearly telling Junior to stop watching, replying, or participating in the thread,",
@@ -278,6 +224,8 @@ function buildRouterSystemPrompt(botUserName, conversationContext, isExplicitMen
     "",
     `<assistant-name>${escapeXml(botUserName)}</assistant-name>`,
     `<explicit-mention>${isExplicitMention ? "true" : "false"}</explicit-mention>`,
+    `<latest-prior-message-role>${escapeXml(latestPriorMessageRole)}</latest-prior-message-role>`,
+    `<latest-prior-assistant-message>${escapeXml(latestPriorAssistantMessage)}</latest-prior-assistant-message>`,
     `<thread-context>${escapeXml(conversationContext?.trim() || "[none]")}</thread-context>`
   ].join("\n");
 }
@@ -710,16 +658,6 @@ function createSlackTurnRuntime(deps) {
           );
           return;
         }
-        if (isRetryableTurnError(error)) {
-          deps.logException(
-            error,
-            "mention_handler_retryable_failure",
-            errorContext,
-            { "app.turn.retryable_reason": error.reason },
-            "onNewMention failed with retryable error"
-          );
-          throw error;
-        }
         const eventId = deps.logException(
           error,
           "mention_handler_failed",
@@ -852,16 +790,6 @@ function createSlackTurnRuntime(deps) {
           );
           return;
         }
-        if (isRetryableTurnError(error)) {
-          deps.logException(
-            error,
-            "subscribed_message_handler_retryable_failure",
-            errorContext,
-            { "app.turn.retryable_reason": error.reason },
-            "onSubscribedMessage failed with retryable error"
-          );
-          throw error;
-        }
         const eventId = deps.logException(
           error,
           "subscribed_message_handler_failed",
@@ -2592,6 +2520,7 @@ function buildSystemPrompt(params) {
         "- Use `bash` to inspect skill files from `skill_dir` and run shell commands inside the sandbox workspace.",
         "- 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.",
         "- Prefer a single result-focused reply after tool work completes. Only send an interim reply when you need user input or have a concrete blocking problem to report.",
         "- 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.",
@@ -4893,31 +4822,6 @@ async function addReactionToMessage(input) {
   );
   return { ok: true };
 }
-async function removeReactionFromMessage(input) {
-  const client2 = getSlackClient();
-  const channelId = normalizeSlackConversationId(input.channelId);
-  if (!channelId) {
-    throw new Error("Slack reaction requires a valid channel ID");
-  }
-  const timestamp = input.timestamp.trim();
-  if (!timestamp) {
-    throw new Error("Slack reaction requires a target message timestamp");
-  }
-  const emoji = normalizeSlackEmojiName(input.emoji);
-  if (!emoji) {
-    throw new Error("Slack reaction requires a valid emoji alias name");
-  }
-  await withSlackRetries(
-    () => client2.reactions.remove({
-      channel: channelId,
-      timestamp,
-      name: emoji
-    }),
-    3,
-    { action: "reactions.remove" }
-  );
-  return { ok: true };
-}
 async function listChannelMessages(input) {
   const client2 = getSlackClient();
   const channelId = normalizeSlackConversationId(input.channelId);
@@ -8391,6 +8295,9 @@ function enforceAttachmentClaimTruth(text, hasAttachedFiles) {
 Note: No file was attached in this turn. I need to attach the file before claiming it is shared.`;
 }
 
+// src/chat/runtime/thread-state.ts
+import { THREAD_STATE_TTL_MS } from "chat";
+
 // src/chat/configuration/validation.ts
 var CONFIG_KEY_RE = /^[a-z0-9]+(?:\.[a-z0-9-]+)+$/;
 var SECRET_KEY_RE = /(?:^|[_.-])(token|secret|password|passphrase|api[-_]?key|private[-_]?key|credential|auth)(?:$|[_.-])/i;
@@ -8823,6 +8730,25 @@ function buildArtifactStatePatch(patch) {
 }
 
 // src/chat/runtime/thread-state.ts
+function threadStateKey(threadId) {
+  return `thread-state:${threadId}`;
+}
+function buildThreadStatePayload(patch) {
+  const payload = {};
+  if (patch.artifacts) {
+    Object.assign(payload, buildArtifactStatePatch(patch.artifacts));
+  }
+  if (patch.conversation) {
+    Object.assign(payload, buildConversationStatePatch(patch.conversation));
+  }
+  if (patch.sandboxId !== void 0) {
+    payload.app_sandbox_id = patch.sandboxId;
+  }
+  if (patch.sandboxDependencyProfileHash !== void 0) {
+    payload.app_sandbox_dependency_profile_hash = patch.sandboxDependencyProfileHash;
+  }
+  return payload;
+}
 function mergeArtifactsState(artifacts, patch) {
   if (!patch) {
     return artifacts;
@@ -8837,24 +8763,30 @@ function mergeArtifactsState(artifacts, patch) {
   };
 }
 async function persistThreadState(thread, patch) {
-  const payload = {};
-  if (patch.artifacts) {
-    Object.assign(payload, buildArtifactStatePatch(patch.artifacts));
-  }
-  if (patch.conversation) {
-    Object.assign(payload, buildConversationStatePatch(patch.conversation));
-  }
-  if (patch.sandboxId) {
-    payload.app_sandbox_id = patch.sandboxId;
-  }
-  if (patch.sandboxDependencyProfileHash) {
-    payload.app_sandbox_dependency_profile_hash = patch.sandboxDependencyProfileHash;
-  }
+  const payload = buildThreadStatePayload(patch);
   if (Object.keys(payload).length === 0) {
     return;
   }
   await thread.setState(payload);
 }
+async function getPersistedThreadState(threadId) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  return await stateAdapter.get(
+    threadStateKey(threadId)
+  ) ?? {};
+}
+async function persistThreadStateById(threadId, patch) {
+  const payload = buildThreadStatePayload(patch);
+  if (Object.keys(payload).length === 0) {
+    return;
+  }
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const key = threadStateKey(threadId);
+  const existing = await stateAdapter.get(key) ?? {};
+  await stateAdapter.set(key, { ...existing, ...payload }, THREAD_STATE_TTL_MS);
+}
 function getChannelConfigurationService(thread) {
   const channel = thread.channel;
   return createChannelConfigurationService({
@@ -8876,14 +8808,6 @@ function getSessionIdentifiers(context) {
     sessionId: context.correlation?.turnId
   };
 }
-var AgentTurnTimeoutError = class extends Error {
-  timeoutMs;
-  constructor(timeoutMs) {
-    super(`Agent turn timed out after ${timeoutMs}ms`);
-    this.name = "AgentTurnTimeoutError";
-    this.timeoutMs = timeoutMs;
-  }
-};
 var McpAuthorizationPauseError = class extends Error {
   provider;
   constructor(provider) {
@@ -9502,7 +9426,11 @@ async function generateAssistantReply(messageText, context = {}) {
             timeoutId = setTimeout(() => {
               didTimeout = true;
               agent.abort();
-              reject(new AgentTurnTimeoutError(botConfig.turnTimeoutMs));
+              reject(
+                new Error(
+                  `Agent turn timed out after ${botConfig.turnTimeoutMs}ms`
+                )
+              );
             }, botConfig.turnTimeoutMs);
           });
           try {
@@ -9737,71 +9665,6 @@ async function generateAssistantReply(messageText, context = {}) {
         `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${nextSliceId}`
       );
     }
-    if (error instanceof AgentTurnTimeoutError && timeoutResumeConversationId && timeoutResumeSessionId) {
-      const nextSliceId = timeoutResumeSliceId + 1;
-      logException(
-        error,
-        "agent_turn_timeout_resume_triggered",
-        {
-          slackThreadId: context.correlation?.threadId,
-          slackUserId: context.correlation?.requesterId,
-          slackChannelId: context.correlation?.channelId,
-          runId: context.correlation?.runId,
-          assistantUserName: context.assistant?.userName,
-          modelId: botConfig.modelId
-        },
-        {
-          "app.ai.turn_timeout_ms": error.timeoutMs,
-          "app.ai.resume_conversation_id": timeoutResumeConversationId,
-          "app.ai.resume_session_id": timeoutResumeSessionId,
-          "app.ai.resume_from_slice_id": timeoutResumeSliceId,
-          "app.ai.resume_next_slice_id": nextSliceId
-        },
-        "Agent turn timed out and will be resumed"
-      );
-      try {
-        const latestCheckpoint = await getAgentTurnSessionCheckpoint(
-          timeoutResumeConversationId,
-          timeoutResumeSessionId
-        );
-        const piMessages = timeoutResumeMessages.length > 0 ? timeoutResumeMessages : latestCheckpoint?.piMessages ?? [];
-        await upsertAgentTurnSessionCheckpoint({
-          conversationId: timeoutResumeConversationId,
-          sessionId: timeoutResumeSessionId,
-          sliceId: nextSliceId,
-          state: "awaiting_resume",
-          piMessages,
-          loadedSkillNames: loadedSkillNamesForResume,
-          resumeReason: "timeout",
-          resumedFromSliceId: timeoutResumeSliceId,
-          errorMessage: error.message
-        });
-      } catch (checkpointError) {
-        logException(
-          checkpointError,
-          "agent_turn_timeout_resume_checkpoint_failed",
-          {
-            slackThreadId: context.correlation?.threadId,
-            slackUserId: context.correlation?.requesterId,
-            slackChannelId: context.correlation?.channelId,
-            runId: context.correlation?.runId,
-            assistantUserName: context.assistant?.userName,
-            modelId: botConfig.modelId
-          },
-          {
-            "app.ai.resume_conversation_id": timeoutResumeConversationId,
-            "app.ai.resume_session_id": timeoutResumeSessionId,
-            "app.ai.resume_from_slice_id": timeoutResumeSliceId,
-            "app.ai.resume_next_slice_id": nextSliceId
-          },
-          "Failed to persist timeout checkpoint before retry"
-        );
-      }
-      throw new RetryableTurnError(
-        "agent_turn_timeout_resume",
-        `conversation=${timeoutResumeConversationId} session=${timeoutResumeSessionId} slice=${nextSliceId}`
-      );
-    }
     if (isRetryableTurnError(error)) {
       throw error;
     }
@@ -11236,7 +11099,10 @@ function createReplyToThread(deps) {
             );
           }
         } catch (error) {
-          shouldPersistFailureState = !isRetryableTurnError(error);
+          shouldPersistFailureState = !isRetryableTurnError(
+            error,
+            "mcp_auth_resume"
+          );
           throw error;
         } finally {
           textStream.end();
@@ -11510,57 +11376,7 @@ import {
   Chat
 } from "chat";
 
-// src/chat/state/queue-ingress-store.ts
-var QUEUE_INGRESS_DEDUP_PREFIX = "junior:queue_ingress";
-function queueIngressDedupKey(rawKey) {
-  return `${QUEUE_INGRESS_DEDUP_PREFIX}:${rawKey}`;
-}
-async function claimQueueIngressDedup(rawKey, ttlMs) {
-  const { stateAdapter, redisStateAdapter } = await getConnectedStateContext();
-  const key = queueIngressDedupKey(rawKey);
-  if (redisStateAdapter) {
-    const result = await redisStateAdapter.getClient().set(key, "1", {
-      NX: true,
-      PX: ttlMs
-    });
-    return result === "OK";
-  }
-  return await stateAdapter.setIfNotExists(key, "1", ttlMs);
-}
-async function hasQueueIngressDedup(rawKey) {
-  const { stateAdapter, redisStateAdapter } = await getConnectedStateContext();
-  const key = queueIngressDedupKey(rawKey);
-  const value = redisStateAdapter ? await redisStateAdapter.getClient().get(key) : await stateAdapter.get(key);
-  return typeof value === "string" && value.length > 0;
-}
-
 // src/chat/ingress/message-router.ts
-var QUEUE_INGRESS_DEDUP_TTL_MS = 24 * 60 * 60 * 1e3;
-function nonEmptyString(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed || void 0;
-}
-function serializeMessageForQueue(message) {
-  const candidate = message;
-  if (typeof candidate.toJSON === "function") {
-    return candidate.toJSON();
-  }
-  return {
-    _type: "chat:Message",
-    ...message
-  };
-}
-function serializeThreadForQueue(thread) {
-  const candidate = thread;
-  if (typeof candidate.toJSON === "function") {
-    return candidate.toJSON();
-  }
-  return {
-    _type: "chat:Thread",
-    ...thread
-  };
-}
 function normalizeIncomingSlackThreadId(threadId, message) {
   if (!threadId.startsWith("slack:")) {
     return threadId;
@@ -11579,260 +11395,10 @@ function normalizeIncomingSlackThreadId(threadId, message) {
   }
   return `slack:${channelId}:${threadTs}`;
 }
-function buildQueueIngressDedupKey(normalizedThreadId, messageId) {
-  return `${normalizedThreadId}:${messageId}`;
-}
-function isSlackDirectMessageThreadId(threadId) {
-  const parts = threadId.split(":");
-  return parts.length === 3 && parts[0] === "slack" && parts[1]?.startsWith("D");
-}
-function determineThreadMessageKind(args) {
-  if (args.isDirectMessage) {
-    return "new_mention";
-  }
-  if (args.isSubscribed) {
-    return "subscribed_message";
-  }
-  if (args.isMention) {
-    return "new_mention";
-  }
-  return void 0;
-}
-function getMessageLogContext(args) {
-  return {
-    slackThreadId: args.normalizedThreadId,
-    slackChannelId: nonEmptyString(args.message.raw?.channel),
-    slackUserId: args.message.author?.userId
-  };
-}
-function logIgnoredIngressResult(args) {
-  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
-  );
-}
-async function enqueueQueueIngressMessage(args) {
-  if (args.enqueueThreadMessage) {
-    return await args.enqueueThreadMessage(args.payload, args.dedupKey);
-  }
-  return await enqueueThreadMessage(args.payload, {
-    idempotencyKey: args.dedupKey
-  });
-}
-async function routeIncomingMessageToQueue(args) {
-  const { adapter, runtime } = args;
-  const message = args.message;
-  if (!message || typeof message !== "object") {
-    return "ignored_non_object";
-  }
-  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({
-      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({
-      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 getStateAdapter().isSubscribed(normalizedThreadId);
-  const mentionSource = typedMessage.isMention ? "sdk_flag" : runtime.detectMention?.(adapter, message) ? "fallback_detector" : void 0;
-  const isMention = mentionSource !== void 0;
-  if (isMention && !typedMessage.isMention) {
-    typedMessage.isMention = true;
-  }
-  const isDirectMessage = isSlackDirectMessageThreadId(normalizedThreadId);
-  const kind = determineThreadMessageKind({
-    isDirectMessage,
-    isSubscribed,
-    isMention
-  });
-  if (!kind) {
-    logIgnoredIngressResult({
-      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);
-  const alreadyDeduped = await hasQueueIngressDedup(dedupKey);
-  if (alreadyDeduped) {
-    logInfo(
-      "queue_ingress_dedup_hit",
-      baseLogContext,
-      {
-        "messaging.message.id": messageId,
-        "app.queue.message_kind": kind,
-        "app.queue.dedup_key": dedupKey,
-        "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 serializedMessage = serializeMessageForQueue(message);
-  const serializedThread = serializeThreadForQueue(thread);
-  const payload = {
-    dedupKey,
-    kind,
-    message: serializedMessage,
-    normalizedThreadId,
-    thread: serializedThread
-  };
-  await withContext(
-    {
-      slackThreadId: normalizedThreadId,
-      slackChannelId: thread.channelId,
-      slackUserId: message.author.userId
-    },
-    async () => {
-      let processingReactionAdded = false;
-      let queueMessageId;
-      try {
-        await addReactionToMessage({
-          channelId: thread.channelId,
-          timestamp: messageId,
-          emoji: "eyes"
-        });
-        processingReactionAdded = true;
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logWarn(
-          "queue_ingress_reaction_add_failed",
-          {},
-          {
-            "messaging.message.id": messageId,
-            "app.queue.message_kind": kind,
-            ...mentionSource ? { "app.slack.mention_source": mentionSource } : {},
-            "error.message": errorMessage
-          },
-          "Failed to add ingress processing reaction"
-        );
-      }
-      try {
-        await withSpan(
-          "queue.enqueue_message",
-          "queue.enqueue_message",
-          {
-            slackThreadId: normalizedThreadId,
-            slackChannelId: thread.channelId,
-            slackUserId: message.author.userId
-          },
-          async () => {
-            queueMessageId = await enqueueQueueIngressMessage({
-              dedupKey,
-              enqueueThreadMessage: args.enqueueThreadMessage,
-              payload
-            });
-            if (queueMessageId) {
-              setSpanAttributes({
-                "app.queue.message_id": queueMessageId
-              });
-            }
-          },
-          {
-            "messaging.message.id": messageId,
-            "app.queue.message_kind": kind
-          }
-        );
-      } catch (error) {
-        if (processingReactionAdded) {
-          try {
-            await removeReactionFromMessage({
-              channelId: thread.channelId,
-              timestamp: messageId,
-              emoji: "eyes"
-            });
-          } catch (cleanupError) {
-            const cleanupErrorMessage = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
-            logWarn(
-              "queue_ingress_reaction_cleanup_failed",
-              {},
-              {
-                "messaging.message.id": messageId,
-                "app.queue.message_kind": kind,
-                "error.message": cleanupErrorMessage
-              },
-              "Failed to remove ingress processing reaction after enqueue failure"
-            );
-          }
-        }
-        throw error;
-      }
-      logInfo(
-        "queue_ingress_enqueued",
-        {},
-        {
-          "messaging.message.id": messageId,
-          "app.queue.message_kind": kind,
-          ...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"
-      );
-      const marked = await claimQueueIngressDedup(
-        dedupKey,
-        QUEUE_INGRESS_DEDUP_TTL_MS
-      );
-      if (!marked) {
-        logInfo(
-          "queue_ingress_dedup_mark_failed",
-          {},
-          {
-            "messaging.message.id": messageId,
-            "app.queue.message_kind": kind,
-            "app.queue.dedup_key": dedupKey
-          },
-          "Queue ingress dedup state write failed after enqueue"
-        );
-      }
-    }
-  );
-  return "routed";
+function nonEmptyString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed || void 0;
 }
 
 // src/chat/ingress/junior-chat.ts
@@ -11843,42 +11409,62 @@ function enqueueBackgroundTask(options, task) {
   options.waitUntil(task);
 }
 var JuniorChat = class extends Chat {
+  /**
+   * Normalize Slack thread IDs before the SDK's concurrency queue.
+   *
+   * The SDK uses the `threadId` parameter as the lock/queue key
+   * (Chat.handleIncomingMessage → getLockKey). @chat-adapter/slack
+   * (as of 4.22.0) builds DM thread IDs as `slack:<channel>:` (empty
+   * thread_ts) when the Slack event has no `thread_ts` field — it uses
+   * `event.thread_ts || ""` instead of falling back to `event.ts`.
+   * See @chat-adapter/slack/dist/index.js:1466.
+   *
+   * A DM root event arrives as `slack:D123:` while a reply in the same
+   * thread carries `slack:D123:<ts>`, splitting the lock/state/subscription
+   * keys and breaking conversation continuity.
+   *
+   * We fix this by resolving the message eagerly (even when the adapter
+   * provides a factory), deriving the canonical thread ID from
+   * `raw.channel` + `raw.thread_ts ?? raw.ts`, and passing both the
+   * normalized threadId and concrete message to super.processMessage.
+   *
+   * Remove this override when @chat-adapter/slack uses `event.ts` as
+   * the DM thread_ts fallback.
+   */
   processMessage(adapter, threadId, messageOrFactory, options) {
-    const runtime = this;
-    enqueueBackgroundTask(
-      options,
-      (async () => {
-        try {
-          const message = typeof messageOrFactory === "function" ? await messageOrFactory() : messageOrFactory;
-          const result = await routeIncomingMessageToQueue({
-            adapter,
-            threadId,
-            message,
-            runtime: {
-              createThread: runtime.createThread.bind(
-                this
-              ),
-              detectMention: runtime.detectMention?.bind(this)
-            }
-          });
-          if (result === "ignored_missing_message_id") {
-            const normalizedThreadId = normalizeIncomingSlackThreadId(
+    if (typeof messageOrFactory === "function") {
+      const runtime = this;
+      enqueueBackgroundTask(
+        options,
+        (async () => {
+          try {
+            const message = await messageOrFactory();
+            const normalized2 = normalizeIncomingSlackThreadId(
               threadId,
               message
             );
-            runtime.logger?.error?.("Message processing error", {
-              threadId: normalizedThreadId,
-              reason: "missing_message_id"
+            if (normalized2 !== threadId && "threadId" in message) {
+              message.threadId = normalized2;
+            }
+            super.processMessage(adapter, normalized2, message, options);
+          } catch (error) {
+            runtime.logger?.error?.("Message factory resolution error", {
+              error,
+              threadId
             });
           }
-        } catch (error) {
-          runtime.logger?.error?.("Message processing error", {
-            error,
-            threadId
-          });
-        }
-      })()
+        })()
+      );
+      return;
+    }
+    const normalized = normalizeIncomingSlackThreadId(
+      threadId,
+      messageOrFactory
     );
+    if (normalized !== threadId && "threadId" in messageOrFactory) {
+      messageOrFactory.threadId = normalized;
+    }
+    super.processMessage(adapter, normalized, messageOrFactory, options);
   }
   processReaction(event, options) {
     const runtime = this;
@@ -12159,6 +11745,15 @@ async function publishAppHomeView(slackClient, userId, userTokenStore) {
   await slackClient.views.publish({ user_id: userId, view });
 }
 
+// src/chat/queue/thread-message-dispatcher.ts
+function rehydrateAttachmentFetchers(message, downloadPrivateSlackFile2 = downloadPrivateSlackFile) {
+  for (const attachment of message.attachments) {
+    if (!attachment.fetchData && attachment.url) {
+      attachment.fetchData = () => downloadPrivateSlackFile2(attachment.url);
+    }
+  }
+}
+
 // src/chat/ingress/slash-command.ts
 async function postEphemeral(event, text) {
   await event.channel.postEphemeral(event.user, text, { fallbackToDM: false });
@@ -12248,6 +11843,15 @@ var productionSlackRuntime;
 function createProductionBot() {
   return new JuniorChat({
     userName: botConfig.userName,
+    concurrency: {
+      strategy: "queue",
+      // The SDK's default queueEntryTtlMs is 90s, but Junior turns can
+      // run up to botConfig.turnTimeoutMs (default 12min). A follow-up
+      // message that arrives during a long turn would expire in the
+      // queue before the lock is released. Set the TTL to exceed the
+      // maximum turn duration so queued messages survive.
+      queueEntryTtlMs: botConfig.turnTimeoutMs + 6e4
+    },
     adapters: {
       slack: (() => {
         const signingSecret = getSlackSigningSecret();
@@ -12268,9 +11872,22 @@ function createProductionBot() {
     state: getStateAdapter()
   });
 }
+function rehydrateAttachments(message) {
+  rehydrateAttachmentFetchers(message);
+}
 function registerProductionHandlers(bot, slackRuntime) {
-  bot.onNewMention(slackRuntime.handleNewMention);
-  bot.onSubscribedMessage(slackRuntime.handleSubscribedMessage);
+  bot.onNewMention((thread, message) => {
+    rehydrateAttachments(message);
+    return slackRuntime.handleNewMention(thread, message);
+  });
+  bot.onDirectMessage((thread, message) => {
+    rehydrateAttachments(message);
+    return slackRuntime.handleNewMention(thread, message);
+  });
+  bot.onSubscribedMessage((thread, message) => {
+    rehydrateAttachments(message);
+    return slackRuntime.handleSubscribedMessage(thread, message);
+  });
   bot.onAssistantThreadStarted(
     (event) => slackRuntime.handleAssistantThreadStarted(event)
   );
@@ -12365,9 +11982,91 @@ function getProductionBot() {
   initializeProductionApp();
   return productionBot;
 }
-function getProductionSlackRuntime() {
-  initializeProductionApp();
-  return productionSlackRuntime;
+
+// src/handlers/webhooks.ts
+var maxDuration = getChatConfig().functionMaxDurationSeconds;
+async function POST(request, context) {
+  const bot = getProductionBot();
+  const { platform } = await context.params;
+  const handler = bot.webhooks[platform];
+  const requestContext = createRequestContext(request, { platform });
+  const requestUrl = new URL(request.url);
+  return withContext(requestContext, async () => {
+    if (!handler) {
+      const error = new Error(`Unknown platform: ${platform}`);
+      logException(
+        error,
+        "webhook_platform_unknown",
+        {},
+        {
+          "http.response.status_code": 404
+        },
+        `Unknown platform: ${platform}`
+      );
+      return new Response(`Unknown platform: ${platform}`, { status: 404 });
+    }
+    try {
+      return await withSpan(
+        "http.server.request",
+        "http.server",
+        requestContext,
+        async () => {
+          try {
+            const activeSpan = Sentry.getActiveSpan();
+            const response = await handler(request, {
+              waitUntil: (task) => after(() => {
+                const runTask = () => {
+                  const taskOrFactory = task;
+                  return typeof taskOrFactory === "function" ? taskOrFactory() : taskOrFactory;
+                };
+                if (activeSpan) {
+                  return Sentry.withActiveSpan(activeSpan, runTask);
+                }
+                return runTask();
+              })
+            });
+            if (response.status >= 400) {
+              let responseBodySnippet;
+              try {
+                responseBodySnippet = (await response.clone().text()).slice(
+                  0,
+                  300
+                );
+              } catch {
+                responseBodySnippet = void 0;
+              }
+              logWarn(
+                "webhook_non_success_response",
+                {},
+                {
+                  "http.response.status_code": response.status,
+                  "http.request.header.x_slack_signature": request.headers.get("x-slack-signature") ?? void 0,
+                  "http.request.header.x_slack_request_timestamp": request.headers.get("x-slack-request-timestamp") ?? void 0,
+                  ...responseBodySnippet ? { "app.webhook.response_body": responseBodySnippet } : {}
+                },
+                `Webhook ${platform} returned ${response.status}`
+              );
+            }
+            setSpanAttributes({
+              "http.response.status_code": response.status
+            });
+            setSpanStatus(response.status >= 500 ? "error" : "ok");
+            return response;
+          } catch (error) {
+            setSpanStatus("error");
+            throw error;
+          }
+        },
+        {
+          "http.request.method": request.method,
+          "url.path": requestUrl.pathname
+        }
+      );
+    } catch (error) {
+      logException(error, "webhook_handler_failed");
+      throw error;
+    }
+  });
 }
 
 export {
@@ -12376,13 +12075,13 @@ export {
   buildSlackOutputMessage,
   getSlackClient,
   uploadFilesToThread,
-  downloadPrivateSlackFile,
   formatProviderLabel,
   resolveBaseUrl,
   finalizeMcpAuthorization,
   coerceThreadArtifactsState,
   mergeArtifactsState,
-  persistThreadState,
+  getPersistedThreadState,
+  persistThreadStateById,
   generateConversationId,
   normalizeConversationText,
   updateConversationStats,
@@ -12391,18 +12090,13 @@ export {
   buildConversationContext,
   escapeXml,
   createUserTokenStore,
-  removeReactionFromMessage,
   truncateStatusText,
-  buildDeterministicTurnId,
   isRetryableTurnError,
   markTurnCompleted,
   markTurnFailed,
   resolveReplyDelivery,
   generateAssistantReply,
   publishAppHomeView,
-  DeferredThreadMessageError,
-  getThreadMessageTopic,
-  createQueueCallbackHandler,
-  getProductionBot,
-  getProductionSlackRuntime
+  maxDuration,
+  POST
 };