@sentry/junior 0.114.0 → 0.115.0

package/dist/chunk-YCLO7D7M.js

@@ -0,0 +1,4267 @@
+import {
+  relayLocalOAuthCallback
+} from "./chunk-FA6POGLH.js";
+import {
+  ConversationTurnLifecycleService,
+  buildDeliveredTurnStatePatch,
+  finalizeFailedTurnReplyWithEvent,
+  getTurnUserMessage,
+  getTurnUserMessageId,
+  getTurnUserReplyAttachmentContext,
+  getTurnUserSlackMessageTs,
+  persistAuthPauseTurnState,
+  requireTurnFailureEventId,
+  scheduleSessionCompletedPluginTasks
+} from "./chunk-AGLQYELI.js";
+import {
+  buildSentryConversationUrl
+} from "./chunk-4CODA7P5.js";
+import {
+  getVercelConversationWorkQueue
+} from "./chunk-MIAKQNYX.js";
+import {
+  RetryableDeliveryError,
+  addReactionToMessage,
+  createUserTokenStore,
+  deleteMcpAuthSession,
+  escapeSlackMrkdwnText,
+  finalizeMcpAuthorization,
+  formatProviderLabel,
+  formatSlackLink,
+  getMcpAuthSession,
+  getMcpStoredOAuthCredentials,
+  normalizeSlackStatusText,
+  parseOAuthStatePayload,
+  postSlackMessage,
+  removeReactionFromMessage,
+  resolveBaseUrl,
+  resolvePluginOAuthAccount,
+  splitSlackReplyText,
+  truncateStatusText
+} from "./chunk-LYA2AB5G.js";
+import {
+  JUNIOR_THREAD_STATE_TTL_MS,
+  TurnSliceLimitExceededError,
+  abandonAgentTurnSessionRecord,
+  buildConversationContext,
+  buildTurnLimitResponse,
+  clearPendingAuth,
+  coerceThreadArtifactsState,
+  coerceThreadConversationState,
+  failAgentTurnSessionRecord,
+  getAgentTurnSessionRecord,
+  getChannelConfigurationServiceById,
+  getConversationPendingAuth,
+  getPersistedSandboxState,
+  getPersistedThreadState,
+  hydrateConversationMessages,
+  isPendingAuthLatestRequest,
+  loadProjection,
+  markConversationMessage,
+  markTurnFailed,
+  persistCompletedSessionRecord,
+  persistConversationMessages,
+  persistThreadStateById,
+  persistWithRetry,
+  recordAuthorizationCompleted,
+  recordDeliveredAssistantMessage,
+  turnHasReply,
+  updateConversationStats
+} from "./chunk-CEYOL62C.js";
+import {
+  getDashboardConversationLink,
+  getPluginSlackConversationLink
+} from "./chunk-RAVKCKXA.js";
+import {
+  acquireActiveLock,
+  getDefaultRedisStateAdapterFor,
+  getStateAdapter
+} from "./chunk-67CVNDJ7.js";
+import {
+  SlackActionError,
+  getHeaderString,
+  getSlackClient,
+  isDmChannel,
+  normalizeSlackConversationId
+} from "./chunk-CWEZEPD4.js";
+import {
+  getConversationEventStore,
+  getConversationStore,
+  parseDestination,
+  requireSlackDestination,
+  sameDestination
+} from "./chunk-HWCQRGLL.js";
+import {
+  FUNCTION_TIMEOUT_BUFFER_SECONDS,
+  botConfig,
+  escapeXml,
+  getChatConfig,
+  getRuntimeMetadata,
+  normalizeSlackEmojiName,
+  standardModelId
+} from "./chunk-SYJT7AKB.js";
+import {
+  parseSlackThreadId,
+  readSlackRawMessageContext,
+  resolveSlackChannelIdFromMessage,
+  resolveSlackChannelIdFromThreadId
+} from "./chunk-FXOYURO4.js";
+import {
+  discoverSkills
+} from "./chunk-2QG4MZQ7.js";
+import {
+  pluginCatalogRuntime
+} from "./chunk-6FKLPVF3.js";
+import {
+  buildOAuthTokenRequest,
+  hasRequiredOAuthScope,
+  parseOAuthTokenResponse
+} from "./chunk-EW5MLKT5.js";
+import {
+  createSlackResumeActor,
+  isUserActor,
+  parseStoredSlackActor
+} from "./chunk-HZF5P5UN.js";
+import {
+  buildTurnFailureResponse,
+  logException,
+  logInfo,
+  logWarn
+} from "./chunk-NVUQSFWX.js";
+import {
+  isRecord,
+  toOptionalNumber,
+  toOptionalString
+} from "./chunk-OB42YVAE.js";
+import {
+  parseSlackMessageTs
+} from "./chunk-F3B2YJ76.js";
+import {
+  homeDir
+} from "./chunk-3V7OFJZC.js";
+
+// src/chat/slack/assistant-thread/status-render.ts
+var DEFAULT_STATUS_CONTEXTS = {
+  thinking: "\u2026",
+  searching: "sources",
+  reading: "task",
+  reviewing: "results",
+  drafting: "reply",
+  running: "tasks"
+};
+function formatAssistantStatusText(verb, context) {
+  const normalizedVerb = normalizeSlackStatusText(verb).trim().toLowerCase();
+  const normalizedContext = normalizeSlackStatusText(context ?? "") || DEFAULT_STATUS_CONTEXTS[normalizedVerb] || "";
+  if (!normalizedVerb) {
+    return truncateStatusText(normalizedContext || "Working");
+  }
+  const displayVerb = `${normalizedVerb[0]?.toUpperCase() ?? ""}${normalizedVerb.slice(1)}`;
+  return truncateStatusText(
+    normalizedContext ? `${displayVerb} ${normalizedContext}` : displayVerb
+  );
+}
+function makeAssistantStatus(verb, context) {
+  return {
+    text: formatAssistantStatusText(verb, context)
+  };
+}
+function renderAssistantStatus(args) {
+  const visible = truncateStatusText(
+    normalizeSlackStatusText(args.status.text)
+  );
+  return {
+    key: visible,
+    visible
+  };
+}
+function selectAssistantLoadingMessages(args) {
+  const random = args.random ?? Math.random;
+  const normalized = Array.from(
+    new Set(
+      args.messages.map((message) => truncateStatusText(normalizeSlackStatusText(message))).filter((message) => message.length > 0)
+    )
+  );
+  if (normalized.length === 0) {
+    return void 0;
+  }
+  const shuffled = [...normalized];
+  for (let index = shuffled.length - 1; index > 0; index -= 1) {
+    const otherIndex = Math.floor(random() * (index + 1));
+    [shuffled[index], shuffled[otherIndex]] = [
+      shuffled[otherIndex],
+      shuffled[index]
+    ];
+  }
+  return shuffled.slice(0, 10);
+}
+
+// src/chat/slack/assistant-thread/status-scheduler.ts
+var STATUS_UPDATE_DEBOUNCE_MS = 1e3;
+var STATUS_MIN_VISIBLE_MS = 1200;
+var STATUS_ROTATION_INTERVAL_MS = 3e4;
+function createAssistantStatusScheduler(args) {
+  const now3 = args.now ?? (() => Date.now());
+  const setTimer = args.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+  const clearTimer = args.clearTimer ?? ((timer) => clearTimeout(timer));
+  const random = args.random ?? Math.random;
+  const loadingMessages = selectAssistantLoadingMessages({
+    messages: args.loadingMessages ?? [],
+    random
+  });
+  const defaultStatus = makeAssistantStatus("thinking");
+  let active = false;
+  let currentKey = "";
+  let currentVisibleStatus = "";
+  let currentLoadingMessages;
+  let lastStatusAt = 0;
+  let pendingStatus = null;
+  let pendingKey = "";
+  let pendingTimer = null;
+  let rotationTimer = null;
+  let inflightStatusUpdate = Promise.resolve();
+  const enqueueStatusUpdate = (task) => {
+    const request = inflightStatusUpdate.catch(() => void 0).then(async () => {
+      await task();
+    });
+    inflightStatusUpdate = request.catch(() => void 0);
+    return request;
+  };
+  const scheduleRotation = () => {
+    if (rotationTimer) {
+      clearTimer(rotationTimer);
+      rotationTimer = null;
+    }
+    if (!active || !currentVisibleStatus) {
+      return;
+    }
+    rotationTimer = setTimer(() => {
+      rotationTimer = null;
+      if (!active || !currentVisibleStatus) {
+        return;
+      }
+      void postStatus(currentVisibleStatus, currentLoadingMessages);
+    }, STATUS_ROTATION_INTERVAL_MS);
+  };
+  const getLoadingMessagesForVisibleStatus = (visible) => visible ? [visible] : void 0;
+  const getInitialStatusText = () => {
+    if (loadingMessages?.length) {
+      return loadingMessages[0];
+    }
+    return defaultStatus.text;
+  };
+  const haveSameLoadingMessages = (left, right) => {
+    if (left === right) {
+      return true;
+    }
+    if (!left || !right || left.length !== right.length) {
+      return false;
+    }
+    return left.every((message, index) => message === right[index]);
+  };
+  const postStatus = async (text, nextLoadingMessages) => {
+    if (!text && !currentVisibleStatus) {
+      return;
+    }
+    currentVisibleStatus = text;
+    currentLoadingMessages = nextLoadingMessages;
+    lastStatusAt = now3();
+    scheduleRotation();
+    await enqueueStatusUpdate(async () => {
+      await args.sendStatus(text, nextLoadingMessages);
+    });
+  };
+  const postRenderedStatus = async (status) => {
+    const presentation = renderAssistantStatus({
+      status
+    });
+    const nextLoadingMessages = getLoadingMessagesForVisibleStatus(
+      presentation.visible
+    );
+    currentKey = presentation.key;
+    await postStatus(presentation.visible, nextLoadingMessages);
+  };
+  const clearPending = () => {
+    if (pendingTimer) {
+      clearTimer(pendingTimer);
+      pendingTimer = null;
+    }
+    pendingStatus = null;
+    pendingKey = "";
+  };
+  const flushPending = async () => {
+    if (!active || !pendingStatus) {
+      clearPending();
+      return;
+    }
+    const next = pendingStatus;
+    clearPending();
+    const nextPresentation = renderAssistantStatus({
+      status: next
+    });
+    if (nextPresentation.key !== currentKey) {
+      await postRenderedStatus(next);
+    }
+  };
+  return {
+    async clear() {
+      active = false;
+      clearPending();
+      if (rotationTimer) {
+        clearTimer(rotationTimer);
+        rotationTimer = null;
+      }
+      currentKey = "";
+      await postStatus("");
+    },
+    update(status) {
+      if (!active) {
+        active = true;
+        clearPending();
+        if (status) {
+          void postRenderedStatus(status);
+          return;
+        }
+        currentKey = "initial";
+        void postStatus(getInitialStatusText(), loadingMessages);
+        return;
+      }
+      if (!status) {
+        clearPending();
+        currentKey = "initial";
+        void postStatus(getInitialStatusText(), loadingMessages);
+        return;
+      }
+      const presentation = renderAssistantStatus({
+        status
+      });
+      if (!presentation.visible) {
+        return;
+      }
+      if (presentation.key === currentKey || presentation.key === pendingKey) {
+        return;
+      }
+      if (presentation.visible === currentVisibleStatus) {
+        clearPending();
+        currentKey = presentation.key;
+        const nextLoadingMessages = getLoadingMessagesForVisibleStatus(
+          presentation.visible
+        );
+        if (!haveSameLoadingMessages(currentLoadingMessages, nextLoadingMessages)) {
+          void postStatus(presentation.visible, nextLoadingMessages);
+        }
+        return;
+      }
+      const elapsed = now3() - lastStatusAt;
+      const waitMs = Math.max(
+        STATUS_UPDATE_DEBOUNCE_MS - elapsed,
+        STATUS_MIN_VISIBLE_MS - elapsed,
+        0
+      );
+      if (waitMs <= 0) {
+        clearPending();
+        void postRenderedStatus(status);
+        return;
+      }
+      pendingStatus = status;
+      pendingKey = presentation.key;
+      if (pendingTimer) {
+        return;
+      }
+      pendingTimer = setTimer(
+        () => {
+          pendingTimer = null;
+          void flushPending();
+        },
+        Math.max(1, waitMs)
+      );
+    }
+  };
+}
+
+// src/chat/slack/assistant-thread/status-send.ts
+var SLACK_ASSISTANT_ACTIVE_STATUS = "is working on your request...";
+function createSlackAdapterStatusSender(args) {
+  const adapter = args.getSlackAdapter();
+  const boundToken = getSlackAdapterRequestToken(adapter);
+  return async (text, loadingMessages) => {
+    const channelId = args.channelId;
+    const threadTs = args.threadTs;
+    if (!channelId || !threadTs) {
+      return;
+    }
+    const normalizedChannelId = normalizeSlackConversationId(channelId);
+    if (!normalizedChannelId) {
+      return;
+    }
+    const nextLoadingMessages = text ? loadingMessages ?? [text] : void 0;
+    try {
+      await runWithBoundSlackToken(
+        adapter,
+        boundToken,
+        () => adapter.setAssistantStatus(
+          normalizedChannelId,
+          threadTs,
+          text ? SLACK_ASSISTANT_ACTIVE_STATUS : "",
+          nextLoadingMessages
+        )
+      );
+    } catch (error) {
+      logAssistantStatusFailure({
+        status: text,
+        error,
+        channelId,
+        normalizedChannelId,
+        threadTs
+      });
+    }
+  };
+}
+function createSlackWebApiStatusSender(args) {
+  const getClient = args.getSlackClient ?? getSlackClient;
+  return async (text, loadingMessages) => {
+    const channelId = args.channelId;
+    const threadTs = args.threadTs;
+    if (!channelId || !threadTs) {
+      return;
+    }
+    const normalizedChannelId = normalizeSlackConversationId(channelId);
+    if (!normalizedChannelId) {
+      return;
+    }
+    const nextLoadingMessages = text ? loadingMessages ?? [text] : void 0;
+    try {
+      await getClient().assistant.threads.setStatus({
+        channel_id: normalizedChannelId,
+        thread_ts: threadTs,
+        status: text ? SLACK_ASSISTANT_ACTIVE_STATUS : "",
+        ...nextLoadingMessages ? { loading_messages: nextLoadingMessages } : {}
+      });
+    } catch (error) {
+      logAssistantStatusFailure({
+        status: text,
+        error,
+        channelId,
+        normalizedChannelId,
+        threadTs
+      });
+    }
+  };
+}
+function getSlackAdapterRequestToken(adapter) {
+  const token = adapter.requestContext?.getStore()?.token;
+  if (typeof token !== "string") {
+    return void 0;
+  }
+  const trimmed = token.trim();
+  return trimmed || void 0;
+}
+async function runWithBoundSlackToken(adapter, token, task) {
+  if (!token) {
+    return await task();
+  }
+  return await adapter.withBotToken(token, task);
+}
+function logAssistantStatusFailure(args) {
+  logWarn(
+    "assistant_status_update_failed",
+    {},
+    {
+      "app.slack.status_text": args.status || "(clear)",
+      "app.slack.channel_id_raw": args.channelId,
+      "app.slack.channel_id": args.normalizedChannelId,
+      "app.slack.thread_ts": args.threadTs,
+      "exception.message": args.error instanceof Error ? args.error.message : String(args.error)
+    },
+    `Failed to update assistant status channel=${args.normalizedChannelId} raw=${args.channelId} thread=${args.threadTs}`
+  );
+}
+
+// src/chat/slack/assistant-thread/status.ts
+function createSlackAdapterAssistantStatusSession(args) {
+  return createAssistantStatusScheduler({
+    sendStatus: createSlackAdapterStatusSender({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      getSlackAdapter: args.getSlackAdapter
+    }),
+    loadingMessages: args.loadingMessages ?? botConfig.loadingMessages,
+    now: args.now,
+    setTimer: args.setTimer,
+    clearTimer: args.clearTimer,
+    random: args.random
+  });
+}
+function createSlackWebApiAssistantStatusSession(args) {
+  return createAssistantStatusScheduler({
+    sendStatus: createSlackWebApiStatusSender({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      getSlackClient: args.getSlackClient
+    }),
+    loadingMessages: args.loadingMessages ?? botConfig.loadingMessages,
+    now: args.now,
+    setTimer: args.setTimer,
+    clearTimer: args.clearTimer,
+    random: args.random
+  });
+}
+
+// src/chat/slack/footer.ts
+function buildSlackReplyFooter(args) {
+  const items = [];
+  const conversationId = args.conversationId?.trim();
+  if (conversationId) {
+    const idItem = {
+      label: "ID",
+      value: conversationId
+    };
+    const conversationUrl = getPluginSlackConversationLink(conversationId)?.url ?? getDashboardConversationLink(conversationId) ?? buildSentryConversationUrl(conversationId);
+    if (conversationUrl) {
+      idItem.url = conversationUrl;
+    }
+    items.push(idItem);
+  }
+  return items.length > 0 ? { items } : void 0;
+}
+function buildSlackReplyBlocks(text, footer) {
+  if (!text.trim()) {
+    return void 0;
+  }
+  const blocks = [
+    {
+      type: "markdown",
+      text
+    }
+  ];
+  if (footer?.items.length) {
+    blocks.push({
+      type: "context",
+      elements: footer.items.map((item) => ({
+        type: "mrkdwn",
+        text: item.url ? `*${escapeSlackMrkdwnText(item.label)}:* ${formatSlackLink(item.url, item.value)}` : `*${escapeSlackMrkdwnText(item.label)}:* ${escapeSlackMrkdwnText(item.value)}`
+      }))
+    });
+  }
+  return blocks;
+}
+
+// src/chat/slack/reply.ts
+async function sendSlackReply(args) {
+  const chunks = splitSlackReplyText(args.text);
+  const footer = buildSlackReplyFooter({
+    conversationId: args.conversationId
+  });
+  let lastMessageTs;
+  for (const [index, text] of chunks.entries()) {
+    const blocks = buildSlackReplyBlocks(
+      text,
+      index === chunks.length - 1 ? footer : void 0
+    );
+    const response = await postSlackMessage({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      text,
+      ...blocks ? { blocks } : {}
+    });
+    lastMessageTs = response.ts;
+  }
+  return lastMessageTs;
+}
+
+// src/chat/slack/errors.ts
+function getSlackApiErrorCode(error) {
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  const candidate = error;
+  if (typeof candidate.data?.error === "string" && candidate.data.error.trim().length > 0) {
+    return candidate.data.error;
+  }
+  if (typeof candidate.code === "string" && candidate.code.trim().length > 0) {
+    return candidate.code;
+  }
+  return void 0;
+}
+function getSlackErrorObservabilityAttributes(error) {
+  if (!error || typeof error !== "object") {
+    return {};
+  }
+  const candidate = error;
+  const attributes = {};
+  if (typeof candidate.code === "string" && candidate.code.trim().length > 0) {
+    attributes["app.slack.error_code"] = candidate.code;
+  }
+  if (typeof candidate.data?.error === "string" && candidate.data.error.trim().length > 0) {
+    attributes["app.slack.api_error"] = candidate.data.error;
+  }
+  const requestId = getHeaderString(candidate.headers, "x-slack-req-id");
+  if (requestId) {
+    attributes["app.slack.request_id"] = requestId;
+  }
+  if (typeof candidate.statusCode === "number" && Number.isFinite(candidate.statusCode)) {
+    attributes["http.response.status_code"] = candidate.statusCode;
+  }
+  return attributes;
+}
+var TRANSIENT_SLACK_API_ERRORS = /* @__PURE__ */ new Set([
+  "fatal_error",
+  "internal_error",
+  // chat.postMessage documents both spellings.
+  "rate_limited",
+  "ratelimited",
+  "request_timeout",
+  "service_unavailable"
+]);
+function isRetryableSlackPostError(error) {
+  if (!error || typeof error !== "object") {
+    return true;
+  }
+  const candidate = error;
+  if (typeof candidate.statusCode === "number") {
+    if (candidate.statusCode === 429 || candidate.statusCode >= 500) {
+      return true;
+    }
+    if (candidate.statusCode >= 400) {
+      return false;
+    }
+  }
+  const apiError = error instanceof SlackActionError ? error.apiError : typeof candidate.data?.error === "string" ? candidate.data.error : void 0;
+  if (apiError) {
+    return TRANSIENT_SLACK_API_ERRORS.has(apiError);
+  }
+  if (error instanceof SlackActionError) {
+    return error.code === "rate_limited" || error.code === "internal_error";
+  }
+  return true;
+}
+function isSlackTitlePermissionError(error) {
+  const code = getSlackApiErrorCode(error);
+  return code === "no_permission" || code === "missing_scope" || code === "not_allowed_token_type";
+}
+
+// src/chat/runtime/thread-context.ts
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function readObjectField(value, key) {
+  return value[key];
+}
+function readOptionalStringField(value, key) {
+  return toOptionalString(readObjectField(value, key));
+}
+function stripLeadingBotMention(text, options = {}) {
+  if (!text.trim()) return text;
+  let next = text;
+  if (options.stripLeadingSlackMentionToken) {
+    if (options.botUserId) {
+      const botUserId = escapeRegExp(options.botUserId);
+      const mentionByBotUserIdRe = new RegExp(
+        `^\\s*(?:<@${botUserId}(?:\\|[^>]+)?>|@${botUserId})[\\s,:-]*`,
+        "i"
+      );
+      next = next.replace(mentionByBotUserIdRe, "").trim();
+    } else {
+      next = next.replace(/^\s*<@[^>]+>[\s,:-]*/, "").trim();
+    }
+  }
+  const mentionByNameRe = new RegExp(
+    `^\\s*@${escapeRegExp(botConfig.userName)}\\b[\\s,:-]*`,
+    "i"
+  );
+  next = next.replace(mentionByNameRe, "").trim();
+  const mentionByLabeledEntityRe = new RegExp(
+    `^\\s*<@[^>|]+\\|${escapeRegExp(botConfig.userName)}>[\\s,:-]*`,
+    "i"
+  );
+  next = next.replace(mentionByLabeledEntityRe, "").trim();
+  return next;
+}
+function getThreadId(thread, _message) {
+  return toOptionalString(thread.id);
+}
+function getRunId(thread, message) {
+  return readOptionalStringField(thread, "runId") ?? readOptionalStringField(message, "runId");
+}
+function getChannelId(thread, message) {
+  return resolveSlackChannelIdFromThreadId(toOptionalString(thread.id)) ?? normalizeSlackConversationId(toOptionalString(thread.channelId)) ?? resolveSlackChannelIdFromMessage(message);
+}
+function getThreadTs(threadId) {
+  return parseSlackThreadId(threadId)?.threadTs;
+}
+function getAssistantThreadContext(message) {
+  const rawContext = readSlackRawMessageContext(message);
+  const channelId = rawContext?.channelId;
+  if (channelId) {
+    const threadTs = isDmChannel(channelId) ? rawContext.threadTs : rawContext.threadTs ?? rawContext.messageTs;
+    if (threadTs) {
+      return { channelId, threadTs };
+    }
+  }
+  const parsedThreadId = parseSlackThreadId(
+    readOptionalStringField(message, "threadId")
+  );
+  if (!parsedThreadId || isDmChannel(parsedThreadId.channelId)) {
+    return void 0;
+  }
+  return parsedThreadId;
+}
+function getMessageTs(message) {
+  const directTs = readOptionalStringField(message, "ts");
+  const parsedDirectTs = parseSlackMessageTs(directTs);
+  if (parsedDirectTs) {
+    return parsedDirectTs;
+  }
+  const rawContext = readSlackRawMessageContext(message);
+  if (!rawContext) {
+    return void 0;
+  }
+  const candidates = [rawContext.messageTs, rawContext.nestedMessageTs];
+  for (const candidate of candidates) {
+    const ts = parseSlackMessageTs(candidate);
+    if (ts) {
+      return ts;
+    }
+  }
+  return void 0;
+}
+
+// src/chat/runtime/processing-reaction.ts
+var noProcessingReaction = {
+  complete: async () => void 0,
+  keep: () => void 0,
+  stop: async () => void 0
+};
+function isProcessingReactionEmoji(value) {
+  return typeof value === "string" && normalizeSlackEmojiName(value) === getChatConfig().slack.processingReactionEmoji;
+}
+function shouldKeepProcessingReactionForToolInvocation(input) {
+  return input.toolName === "addReaction" && isProcessingReactionEmoji(input.params.emoji);
+}
+async function startSlackProcessingReaction(args) {
+  if (args.message.author.isMe) {
+    return noProcessingReaction;
+  }
+  const channelId = getChannelId(args.thread, args.message);
+  const messageTs = getMessageTs(args.message);
+  if (!channelId || !messageTs) {
+    return noProcessingReaction;
+  }
+  return startSlackProcessingReactionForMessage({
+    channelId,
+    timestamp: messageTs,
+    logException: args.logException,
+    logContext: args.logContext
+  });
+}
+async function startSlackProcessingReactionForMessage(args) {
+  try {
+    await addReactionToMessage({
+      channelId: args.channelId,
+      timestamp: args.timestamp,
+      emoji: getChatConfig().slack.processingReactionEmoji
+    });
+  } catch (error) {
+    args.logException(
+      error,
+      "slack_processing_reaction_add_failed",
+      args.logContext,
+      {
+        "app.slack.action": "reactions.add",
+        "messaging.message.id": args.timestamp,
+        ...getSlackErrorObservabilityAttributes(error)
+      },
+      "Failed to add Slack processing reaction"
+    );
+    return noProcessingReaction;
+  }
+  let shouldRemove = true;
+  const removeProcessingReaction = async () => {
+    if (!shouldRemove) {
+      return false;
+    }
+    try {
+      await removeReactionFromMessage({
+        channelId: args.channelId,
+        timestamp: args.timestamp,
+        emoji: getChatConfig().slack.processingReactionEmoji
+      });
+      return true;
+    } catch (error) {
+      args.logException(
+        error,
+        "slack_processing_reaction_remove_failed",
+        args.logContext,
+        {
+          "app.slack.action": "reactions.remove",
+          "messaging.message.id": args.timestamp,
+          ...getSlackErrorObservabilityAttributes(error)
+        },
+        "Failed to remove Slack processing reaction"
+      );
+      return false;
+    }
+  };
+  return {
+    complete: async () => {
+      const shouldAddCompleted = shouldRemove;
+      await removeProcessingReaction();
+      if (!shouldAddCompleted) {
+        return;
+      }
+      try {
+        await addReactionToMessage({
+          channelId: args.channelId,
+          timestamp: args.timestamp,
+          emoji: getChatConfig().slack.completedReactionEmoji
+        });
+      } catch (error) {
+        args.logException(
+          error,
+          "slack_processing_reaction_complete_failed",
+          args.logContext,
+          {
+            "app.slack.action": "reactions.add",
+            "messaging.message.id": args.timestamp,
+            ...getSlackErrorObservabilityAttributes(error)
+          },
+          "Failed to add Slack completed reaction"
+        );
+      }
+    },
+    keep: () => {
+      shouldRemove = false;
+    },
+    stop: async () => {
+      await removeProcessingReaction();
+    }
+  };
+}
+
+// src/chat/services/auth-pause-response.ts
+var MAX_AUTH_REQUEST_LENGTH = 200;
+function formatAuthRequest(requestText) {
+  const normalized = requestText.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return void 0;
+  }
+  const bounded = normalized.length > MAX_AUTH_REQUEST_LENGTH ? `${normalized.slice(0, MAX_AUTH_REQUEST_LENGTH - 1).trimEnd()}\u2026` : normalized;
+  return bounded.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function buildAuthPauseResponse(slackUserId, providerDisplayName, requestText) {
+  const mention = slackUserId ? `<@${slackUserId}> ` : "";
+  const request = requestText ? formatAuthRequest(requestText) : void 0;
+  if (!request) {
+    return `${mention}I'll need you to authorize ${providerDisplayName}. I sent you a link.`;
+  }
+  return `${mention}I need access to ${providerDisplayName} to continue.
+
+*Why:* ${request}
+
+I sent you a link.`;
+}
+
+// src/chat/runtime/request-deadline.ts
+import { AsyncLocalStorage } from "async_hooks";
+var requestDeadlineStorage = new AsyncLocalStorage();
+function createTurnRequestDeadline(startedAtMs) {
+  const requestBudgetMs = Math.max(
+    1,
+    getChatConfig().functionMaxDurationSeconds * 1e3 - FUNCTION_TIMEOUT_BUFFER_SECONDS * 1e3
+  );
+  return {
+    startedAtMs,
+    deadlineAtMs: startedAtMs + requestBudgetMs
+  };
+}
+function getTurnRequestDeadline() {
+  return requestDeadlineStorage.getStore();
+}
+function runWithTurnRequestDeadline(callback, startedAtMs = Date.now()) {
+  const existingDeadline = requestDeadlineStorage.getStore();
+  if (existingDeadline) {
+    return callback();
+  }
+  return requestDeadlineStorage.run(
+    createTurnRequestDeadline(startedAtMs),
+    callback
+  );
+}
+
+// src/chat/runtime/slack-resume.ts
+function resolveReplyTimeoutMs(explicitTimeoutMs) {
+  if (typeof explicitTimeoutMs === "number" && explicitTimeoutMs > 0) {
+    return explicitTimeoutMs;
+  }
+  const raw = process.env.EVAL_AGENT_REPLY_TIMEOUT_MS?.trim();
+  if (!raw) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+async function postSlackMessageBestEffort(channelId, threadTs, text, conversationId) {
+  try {
+    if (conversationId) {
+      await sendSlackReply({
+        channelId,
+        conversationId,
+        text,
+        threadTs
+      });
+      return;
+    }
+    await postSlackMessage({ channelId, threadTs, text });
+  } catch {
+  }
+}
+function createReadOnlyConfigService(values) {
+  const entries = Object.entries(values).map(([key, value]) => ({
+    key,
+    value,
+    scope: "conversation",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+  return {
+    get: async (key) => entries.find((entry) => entry.key === key),
+    set: async () => {
+      throw new Error("Read-only configuration in resumed context");
+    },
+    unset: async () => false,
+    list: async ({ prefix } = {}) => entries.filter((entry) => !prefix || entry.key.startsWith(prefix)),
+    resolve: async (key) => values[key],
+    resolveValues: async ({ keys, prefix } = {}) => {
+      const filtered = {};
+      for (const [key, value] of Object.entries(values)) {
+        if (prefix && !key.startsWith(prefix)) continue;
+        if (keys && !keys.includes(key)) continue;
+        filtered[key] = value;
+      }
+      return filtered;
+    }
+  };
+}
+var ResumeTurnBusyError = class extends Error {
+  constructor(lockKey) {
+    super(`A turn already owns resume lock "${lockKey}"`);
+    this.name = "ResumeTurnBusyError";
+  }
+};
+function getDefaultLockKey(channelId, threadTs) {
+  return `slack:${channelId}:${threadTs}`;
+}
+function getResumeLogContext(args, lockKey) {
+  const routing = args.replyContext?.routing;
+  const actor = routing?.actor;
+  return {
+    conversationId: args.conversationId,
+    messageConversationId: lockKey,
+    userId: isUserActor(actor) ? actor.userId : void 0,
+    userName: isUserActor(actor) ? actor.userName : void 0,
+    destinationName: args.channelId,
+    assistantUserName: botConfig.userName,
+    modelId: standardModelId(botConfig)
+  };
+}
+async function postResumeFailureReply(args) {
+  await postSlackMessage({
+    channelId: args.channelId,
+    threadTs: args.threadTs,
+    text: args.error instanceof TurnSliceLimitExceededError ? buildTurnLimitResponse(args.eventId) : buildTurnFailureResponse(args.eventId)
+  });
+}
+async function handleResumeFailure(args) {
+  const logContext = getResumeLogContext(args.resumeArgs, args.lockKey);
+  const capturedEventId = logException(
+    args.error,
+    args.eventName,
+    logContext,
+    {},
+    args.body
+  );
+  const eventId = requireTurnFailureEventId(capturedEventId, args.eventName);
+  let failureStatePersistError;
+  try {
+    await args.resumeArgs.onFailure?.(args.error);
+  } catch (persistError) {
+    const persistEventId = logException(
+      persistError,
+      "slack_resume_failure_state_persist_failed",
+      logContext,
+      { "app.error.original_event_id": eventId },
+      "Failed to persist resumed turn failure state"
+    );
+    try {
+      await args.turnLifecycle.fail({
+        conversationId: args.resumeArgs.conversationId,
+        turnId: args.resumeArgs.turnId,
+        createdAtMs: Date.now(),
+        failureCode: "persistence_failed",
+        ...persistEventId ? { eventId: persistEventId } : {}
+      });
+    } catch (lifecycleError) {
+      logException(
+        lifecycleError,
+        "slack_resume_failure_lifecycle_persist_failed",
+        logContext,
+        { "app.error.original_event_id": eventId },
+        "Failed to record resumed turn persistence failure"
+      );
+    }
+    failureStatePersistError = persistError;
+  }
+  try {
+    await postResumeFailureReply({
+      channelId: args.resumeArgs.channelId,
+      threadTs: args.resumeArgs.threadTs,
+      eventId,
+      error: args.error
+    });
+  } catch (deliveryError) {
+    const deliveryEventId = logException(
+      deliveryError,
+      "slack_resume_failure_delivery_failed",
+      logContext,
+      { "app.error.original_event_id": eventId },
+      "Failed to deliver resumed turn failure state"
+    );
+    try {
+      await args.turnLifecycle.fail({
+        conversationId: args.resumeArgs.conversationId,
+        turnId: args.resumeArgs.turnId,
+        createdAtMs: Date.now(),
+        failureCode: "delivery_failed",
+        ...deliveryEventId ? { eventId: deliveryEventId } : {}
+      });
+    } catch (lifecycleError) {
+      logException(
+        lifecycleError,
+        "slack_resume_failure_lifecycle_persist_failed",
+        logContext,
+        { "app.error.original_event_id": eventId },
+        "Failed to record resumed turn delivery failure"
+      );
+    }
+    throw deliveryError;
+  }
+  if (failureStatePersistError) {
+    throw failureStatePersistError;
+  }
+  await args.turnLifecycle.fail({
+    conversationId: args.resumeArgs.conversationId,
+    turnId: args.resumeArgs.turnId,
+    createdAtMs: Date.now(),
+    failureCode: args.failureCode,
+    eventId
+  });
+}
+function createResumeReplyContext(args, statusSession, delivery) {
+  const replyContext = args.replyContext;
+  if (!replyContext) {
+    throw new TypeError("Slack resume requires a reply context");
+  }
+  if (!replyContext.routing.source) {
+    throw new TypeError("Slack resume requires a reply context source");
+  }
+  const source = replyContext.routing.source;
+  if (source.platform !== "slack") {
+    throw new TypeError("Slack resume requires a Slack source");
+  }
+  if (replyContext.routing.destination.platform !== "slack") {
+    throw new TypeError("Slack resume requires a Slack destination");
+  }
+  const requestDeadline = getTurnRequestDeadline();
+  const threadId = args.lockKey ?? getDefaultLockKey(args.channelId, args.threadTs);
+  const persistedChannelConfiguration = replyContext.policy?.channelConfiguration ?? (replyContext.policy?.configuration ? createReadOnlyConfigService(replyContext.policy.configuration) : void 0);
+  return {
+    conversationId: args.conversationId,
+    turnId: args.turnId,
+    input: {
+      ...replyContext.input ?? {},
+      messageText: args.messageText
+    },
+    routing: {
+      ...replyContext.routing,
+      source: {
+        ...source,
+        channelId: args.channelId,
+        threadTs: args.threadTs
+      }
+    },
+    policy: {
+      ...replyContext.policy,
+      turnDeadlineAtMs: replyContext.policy?.turnDeadlineAtMs ?? requestDeadline?.deadlineAtMs,
+      channelConfiguration: persistedChannelConfiguration
+    },
+    state: replyContext.state,
+    observers: {
+      ...replyContext.observers,
+      onStatus: async (nextStatus) => {
+        statusSession.update(nextStatus);
+        await replyContext.observers?.onStatus?.(nextStatus);
+      }
+    },
+    delivery,
+    durability: {
+      ...replyContext.durability,
+      onSandboxRefChanged: async (sandboxRef) => {
+        await persistThreadStateById(threadId, {
+          sandboxRef
+        });
+        await replyContext.durability?.onSandboxRefChanged?.(sandboxRef);
+      },
+      onArtifactStateUpdated: async (artifacts) => {
+        await persistThreadStateById(threadId, { artifacts });
+        await replyContext.durability?.onArtifactStateUpdated?.(artifacts);
+      }
+    }
+  };
+}
+async function resumeSlackTurn(args) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const lockKey = args.lockKey ?? getDefaultLockKey(args.channelId, args.threadTs);
+  const lock = await acquireActiveLock(stateAdapter, lockKey);
+  if (!lock) {
+    throw new ResumeTurnBusyError(lockKey);
+  }
+  const status = createSlackWebApiAssistantStatusSession({
+    channelId: args.channelId,
+    threadTs: args.threadTs
+  });
+  let processingReaction;
+  let deferredAuthInfo;
+  let deferredPauseHandler;
+  let deferredFailureHandler;
+  let runResultHandled = false;
+  let assistantMessageDelivered = false;
+  let postDeliveryCommitError;
+  const turnLifecycle = args.turnLifecycle ?? new ConversationTurnLifecycleService(getConversationEventStore());
+  let failureCode = "agent_run_failed";
+  let runArgs = args;
+  try {
+    const preparedArgs = await args.beforeStart?.();
+    if (preparedArgs === false) {
+      return false;
+    }
+    if (preparedArgs) {
+      runArgs = { ...args, ...preparedArgs };
+    }
+    const activeReplyContext = runArgs.replyContext;
+    if (!activeReplyContext) {
+      throw new Error("Resumed turn requires replyContext");
+    }
+    const credentialContext = activeReplyContext.routing.credentialContext;
+    if (!credentialContext) {
+      throw new Error("Resumed turn requires replyContext.credentialContext");
+    }
+    const routingActor = activeReplyContext.routing.actor;
+    let resumeActor;
+    if ("type" in credentialContext.actor) {
+      if (!isUserActor(routingActor) || credentialContext.actor.userId !== routingActor.userId) {
+        throw new Error(
+          "Resumed turn credential actor must match replyContext.routing.actor.userId"
+        );
+      }
+      resumeActor = routingActor;
+    } else {
+      if (routingActor && (routingActor.platform !== "system" || routingActor.name !== credentialContext.actor.name)) {
+        throw new Error(
+          "Resumed turn system credential actor must match replyContext.routing.actor"
+        );
+      }
+      resumeActor = credentialContext.actor;
+    }
+    if (runArgs.messageTs) {
+      processingReaction = await startSlackProcessingReactionForMessage({
+        channelId: runArgs.channelId,
+        timestamp: runArgs.messageTs,
+        logException,
+        logContext: { ...getResumeLogContext(runArgs, lockKey) }
+      });
+    }
+    if (runArgs.initialText) {
+      await postSlackMessageBestEffort(
+        runArgs.channelId,
+        runArgs.threadTs,
+        runArgs.initialText
+      );
+    }
+    status.update(runArgs.initialStatus);
+    const conversationId = runArgs.conversationId;
+    const visibleConversationId = lockKey;
+    const sessionId = runArgs.turnId;
+    let deliveryConversation;
+    const getDeliveryConversation = async () => {
+      if (deliveryConversation) {
+        const userMessageId2 = getTurnUserMessage(
+          deliveryConversation,
+          sessionId
+        )?.id;
+        return {
+          conversation: deliveryConversation,
+          sessionId,
+          ...userMessageId2 ? { userMessageId: userMessageId2 } : {}
+        };
+      }
+      const persistedState = await getPersistedThreadState(
+        visibleConversationId
+      );
+      const conversation = coerceThreadConversationState(persistedState);
+      await hydrateConversationMessages({
+        conversation,
+        conversationId
+      });
+      deliveryConversation = conversation;
+      const userMessageId = getTurnUserMessage(conversation, sessionId)?.id;
+      return {
+        conversation,
+        sessionId,
+        ...userMessageId ? { userMessageId } : {}
+      };
+    };
+    const deliverAssistantMessage = async (assistantMessage) => {
+      if (!assistantMessage.text.trim()) {
+        return;
+      }
+      failureCode = "delivery_failed";
+      const deliveryState2 = await getDeliveryConversation();
+      let messageTs;
+      try {
+        messageTs = await sendSlackReply({
+          channelId: runArgs.channelId,
+          conversationId: runArgs.conversationId,
+          text: assistantMessage.text,
+          threadTs: runArgs.threadTs
+        });
+      } catch (error) {
+        if (isRetryableSlackPostError(error)) {
+          throw new RetryableDeliveryError(error);
+        }
+        throw error;
+      }
+      assistantMessageDelivered = true;
+      const recordedMessageId = recordDeliveredAssistantMessage({
+        conversation: deliveryState2.conversation,
+        sessionId: deliveryState2.sessionId,
+        text: assistantMessage.text,
+        userMessageId: deliveryState2.userMessageId
+      });
+      if (messageTs) {
+        markConversationMessage(deliveryState2.conversation, recordedMessageId, {
+          slackTs: messageTs
+        });
+      }
+      try {
+        await persistWithRetry(
+          () => persistConversationMessages({
+            conversation: deliveryState2.conversation,
+            conversationId
+          })
+        );
+      } catch (error) {
+        logException(
+          new Error("Accepted assistant message persistence failed"),
+          "slack_resume_assistant_message_post_delivery_persist_failed",
+          getResumeLogContext(runArgs, lockKey),
+          { "error.type": error instanceof Error ? error.name : typeof error },
+          "Failed to persist an accepted resumed assistant message"
+        );
+      }
+      failureCode = "agent_run_failed";
+    };
+    const deliveryState = await getDeliveryConversation();
+    assistantMessageDelivered = turnHasReply(
+      deliveryState.conversation,
+      sessionId
+    );
+    const replyContext = createResumeReplyContext(runArgs, status, {
+      onAssistantMessage: deliverAssistantMessage
+    });
+    if (runArgs.inputMessageIds?.length) {
+      await turnLifecycle.start({
+        conversationId: runArgs.conversationId,
+        turnId: runArgs.turnId,
+        createdAtMs: Date.now(),
+        inputMessageIds: [...new Set(runArgs.inputMessageIds)],
+        surface: "slack"
+      });
+    }
+    const replyPromise = runArgs.agentRunner.run(replyContext);
+    const replyTimeoutMs = resolveReplyTimeoutMs(runArgs.replyTimeoutMs);
+    const outcome = typeof replyTimeoutMs === "number" ? await Promise.race([
+      replyPromise,
+      new Promise(
+        (_, reject) => setTimeout(
+          () => reject(
+            new Error(
+              `executeAgentRun timed out after ${replyTimeoutMs}ms`
+            )
+          ),
+          replyTimeoutMs
+        )
+      )
+    ]) : await replyPromise;
+    if (outcome.status !== "completed") {
+      await status.clear();
+      const onAuthPause = runArgs.onAuthPause;
+      const onSuspend = runArgs.onSuspend;
+      if (outcome.status === "awaiting_auth" && onAuthPause) {
+        deferredAuthInfo = {
+          providerDisplayName: outcome.providerDisplayName,
+          actorId: isUserActor(resumeActor) ? resumeActor.userId : void 0,
+          ...outcome.requestText ? { requestText: outcome.requestText } : {}
+        };
+        deferredPauseHandler = async () => {
+          await onAuthPause({
+            providerDisplayName: outcome.providerDisplayName
+          });
+        };
+      } else if (outcome.status === "suspended" && onSuspend) {
+        deferredPauseHandler = async () => {
+          await onSuspend(outcome.resumeVersion);
+        };
+      } else {
+        deferredFailureHandler = async () => {
+          await handleResumeFailure({
+            body: "Failed to resume Slack turn",
+            error: new Error(
+              `Resumed run ended ${outcome.status} without a pause handler`
+            ),
+            eventName: "slack_resume_turn_failed",
+            failureCode: "agent_run_failed",
+            turnLifecycle,
+            lockKey,
+            resumeArgs: runArgs
+          });
+        };
+      }
+    } else {
+      const finalized = finalizeFailedTurnReplyWithEvent({
+        reply: outcome.result,
+        logException,
+        context: getResumeLogContext(runArgs, lockKey)
+      });
+      const reply = finalized.reply;
+      if (reply.diagnostics.outcome !== "success") {
+        await deliverAssistantMessage({ text: reply.text });
+      }
+      runResultHandled = true;
+      await status.clear();
+      failureCode = "persistence_failed";
+      if (reply.piMessages?.length) {
+        await persistCompletedSessionRecord({
+          conversationId: runArgs.conversationId,
+          sessionId: runArgs.turnId,
+          allMessages: reply.piMessages,
+          modelId: reply.diagnostics.modelId,
+          currentDurationMs: reply.diagnostics.durationMs,
+          currentUsage: reply.diagnostics.usage,
+          destination: replyContext.routing.destination,
+          source: replyContext.routing.source,
+          actor: resumeActor,
+          surface: "slack"
+        });
+      }
+      await runArgs.commitResult?.(reply);
+      if (reply.diagnostics.outcome === "success") {
+        await turnLifecycle.complete({
+          conversationId: runArgs.conversationId,
+          turnId: runArgs.turnId,
+          createdAtMs: Date.now(),
+          outcome: assistantMessageDelivered ? "success" : "no_reply"
+        });
+      } else {
+        await turnLifecycle.fail({
+          conversationId: runArgs.conversationId,
+          turnId: runArgs.turnId,
+          createdAtMs: Date.now(),
+          failureCode: "model_execution_failed",
+          ...finalized.eventId ? { eventId: finalized.eventId } : {}
+        });
+      }
+      if (reply.diagnostics.outcome === "success") {
+        try {
+          const params = {
+            conversationId: runArgs.conversationId,
+            sessionId: runArgs.turnId
+          };
+          if (runArgs.scheduleSessionCompletedPluginTasks) {
+            await runArgs.scheduleSessionCompletedPluginTasks(params);
+          } else {
+            await scheduleSessionCompletedPluginTasks(params);
+          }
+        } catch (scheduleError) {
+          logException(
+            scheduleError,
+            "plugin_session_completed_task_schedule_failed",
+            getResumeLogContext(runArgs, lockKey),
+            {},
+            "Plugin session.completed task scheduling failed"
+          );
+        }
+      }
+    }
+  } catch (error) {
+    await status.clear();
+    if (runResultHandled) {
+      postDeliveryCommitError = error;
+      try {
+        await runArgs.onPostDeliveryCommitFailure?.(error);
+      } catch (terminalizeError) {
+        logException(
+          terminalizeError,
+          "slack_resume_post_delivery_terminalize_failed",
+          getResumeLogContext(runArgs, lockKey),
+          {},
+          "Failed to terminalize resumed turn after post-delivery commit failure"
+        );
+      }
+    } else {
+      deferredFailureHandler = async () => {
+        await handleResumeFailure({
+          body: "Failed to resume Slack turn",
+          error,
+          eventName: "slack_resume_turn_failed",
+          failureCode,
+          turnLifecycle,
+          lockKey,
+          resumeArgs: runArgs
+        });
+      };
+    }
+  } finally {
+    if (runResultHandled) {
+      await processingReaction?.complete();
+    } else {
+      await processingReaction?.stop();
+    }
+    await stateAdapter.releaseLock(lock);
+  }
+  if (postDeliveryCommitError) {
+    const eventId = logException(
+      postDeliveryCommitError,
+      "slack_resume_success_handler_failed",
+      getResumeLogContext(runArgs, lockKey),
+      {},
+      "Failed to persist resumed turn state after assistant output handling"
+    );
+    await turnLifecycle.fail({
+      conversationId: runArgs.conversationId,
+      turnId: runArgs.turnId,
+      createdAtMs: Date.now(),
+      failureCode: "persistence_failed",
+      ...eventId ? { eventId } : {}
+    });
+    throw postDeliveryCommitError;
+  }
+  if (deferredPauseHandler) {
+    try {
+      await deferredPauseHandler();
+      if (deferredAuthInfo) {
+        await postSlackMessageBestEffort(
+          runArgs.channelId,
+          runArgs.threadTs,
+          buildAuthPauseResponse(
+            deferredAuthInfo.actorId,
+            deferredAuthInfo.providerDisplayName,
+            deferredAuthInfo.requestText
+          ),
+          runArgs.conversationId
+        );
+      }
+      return true;
+    } catch (pauseError) {
+      await handleResumeFailure({
+        body: "Failed to handle resumed turn pause",
+        error: pauseError,
+        eventName: "slack_resume_pause_handler_failed",
+        failureCode: "persistence_failed",
+        turnLifecycle,
+        lockKey,
+        resumeArgs: runArgs
+      });
+      return true;
+    }
+  }
+  if (deferredFailureHandler) {
+    await deferredFailureHandler();
+  }
+  return true;
+}
+
+// src/chat/task-execution/state.ts
+import { randomUUID } from "crypto";
+import { destinationSchema } from "@sentry/junior-plugin-api";
+import { z } from "zod";
+var CONVERSATION_PREFIX = "junior:conversation";
+var CONVERSATION_SCHEMA_VERSION = 2;
+var CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH = 1e4;
+var CONVERSATION_INDEX_LOCK_TTL_MS = 1e4;
+var CONVERSATION_INDEX_LOCK_WAIT_MS = 2e3;
+var CONVERSATION_INDEX_LOCK_RETRY_MS = 25;
+var CONVERSATION_MUTATION_LOCK_TTL_MS = 1e4;
+var CONVERSATION_MUTATION_WAIT_MS = 1e4;
+var CONVERSATION_MUTATION_RETRY_MS = 25;
+var InvalidConversationRecordError = class extends Error {
+  constructor(conversationId) {
+    super(`Conversation record is invalid for ${conversationId}`);
+    this.name = "InvalidConversationRecordError";
+  }
+};
+function isInvalidConversationRecordError(error) {
+  return error instanceof InvalidConversationRecordError;
+}
+var ConversationMutationFencedError = class extends Error {
+  constructor(conversationId) {
+    super(
+      `Conversation mutation lock was lost before write for ${conversationId}`
+    );
+    this.name = "ConversationMutationFencedError";
+  }
+};
+var CONVERSATION_BY_ACTIVITY_INDEX_KEY = `${CONVERSATION_PREFIX}:by-activity`;
+var CONVERSATION_ACTIVE_INDEX_KEY = `${CONVERSATION_PREFIX}:active`;
+var CONVERSATION_WORK_LEASE_TTL_MS = 9e4;
+var CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15e3;
+var CONVERSATION_WORK_STALE_ENQUEUE_MS = 6e4;
+var CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS = 5;
+var inboundMessageSourceSchema = z.enum([
+  "api",
+  "internal",
+  "local",
+  "plugin",
+  "resource_event",
+  "scheduler",
+  "slack"
+]);
+var agentInputSchema = z.object({
+  attachments: z.array(z.unknown()).optional(),
+  authorId: z.string().min(1).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  text: z.string()
+}).strict().refine((input) => input.text.trim() || input.attachments?.length, {
+  message: "agent input requires text or attachments"
+});
+var inboundMessageDeliverySchema = z.enum(["defer", "interrupt"]);
+var inboundMessageSchema = z.object({
+  attemptCount: z.number().finite().optional(),
+  conversationId: z.string().refine((value) => value.trim().length > 0),
+  createdAtMs: z.number().finite(),
+  delivery: inboundMessageDeliverySchema,
+  destination: destinationSchema,
+  inboundMessageId: z.string().refine((value) => value.trim().length > 0),
+  injectedAtMs: z.number().finite().optional(),
+  input: agentInputSchema,
+  receivedAtMs: z.number().finite(),
+  source: inboundMessageSourceSchema
+}).strict();
+function conversationKey(conversationId) {
+  return `${CONVERSATION_PREFIX}:${conversationId}`;
+}
+function indexLockKey(indexKey) {
+  return `${indexKey}:lock`;
+}
+function mutationLockKey(conversationId) {
+  return `${CONVERSATION_PREFIX}:mutation:${conversationId}`;
+}
+function now() {
+  return Date.now();
+}
+function compareMessages(left, right) {
+  return left.createdAtMs - right.createdAtMs || left.receivedAtMs - right.receivedAtMs || left.inboundMessageId.localeCompare(right.inboundMessageId);
+}
+function inputHasAttachments(input) {
+  return Array.isArray(input.attachments) && input.attachments.length > 0;
+}
+function upgradedPendingMessage(stored, duplicate) {
+  const promotesInterrupt = stored.delivery === "defer" && duplicate.delivery === "interrupt";
+  const delivery = promotesInterrupt ? "interrupt" : stored.delivery;
+  const input = promotesInterrupt ? {
+    ...duplicate.input,
+    ...inputHasAttachments(duplicate.input) || !inputHasAttachments(stored.input) ? {} : { attachments: stored.input.attachments }
+  } : inputHasAttachments(duplicate.input) && !inputHasAttachments(stored.input) ? duplicate.input : stored.input;
+  if (input === stored.input && delivery === stored.delivery) {
+    return stored;
+  }
+  return { ...stored, delivery, input };
+}
+function compareIndexDescending(left, right) {
+  return right.score - left.score || right.conversationId.localeCompare(left.conversationId);
+}
+function compareIndexAscending(left, right) {
+  return left.score - right.score || left.conversationId.localeCompare(right.conversationId);
+}
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
+function normalizeSource(value) {
+  const parsed = inboundMessageSourceSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+function normalizeExecutionStatus(value) {
+  if (value === "awaiting_resume" || value === "failed" || value === "idle" || value === "pending" || value === "running") {
+    return value;
+  }
+  return void 0;
+}
+function normalizeMessage(value, schemaVersion) {
+  const candidate = schemaVersion === 1 && isRecord(value) && value.delivery === void 0 ? {
+    ...value,
+    delivery: "defer"
+  } : value;
+  const parsed = inboundMessageSchema.safeParse(candidate);
+  return parsed.success ? parsed.data : void 0;
+}
+function isFinalAttempt(message) {
+  return (message.attemptCount ?? 0) >= CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS - 1;
+}
+function normalizeActor(value) {
+  return parseStoredSlackActor(value);
+}
+function normalizeLease(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const token = toOptionalString(value.token);
+  const acquiredAtMs = toOptionalNumber(value.acquiredAtMs);
+  const lastCheckInAtMs = toOptionalNumber(value.lastCheckInAtMs);
+  const expiresAtMs = toOptionalNumber(value.expiresAtMs);
+  if (!token || typeof acquiredAtMs !== "number" || typeof lastCheckInAtMs !== "number" || typeof expiresAtMs !== "number") {
+    return void 0;
+  }
+  return {
+    token,
+    acquiredAtMs,
+    lastCheckInAtMs,
+    expiresAtMs
+  };
+}
+function normalizeExecution(conversationId, value, schemaVersion) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const status = normalizeExecutionStatus(value.status);
+  if (!status) {
+    return void 0;
+  }
+  const pendingMessages2 = [];
+  if (Array.isArray(value.pendingMessages)) {
+    for (const rawMessage of value.pendingMessages) {
+      const message = normalizeMessage(rawMessage, schemaVersion);
+      if (!message || message.conversationId !== conversationId) {
+        return void 0;
+      }
+      if (message.injectedAtMs !== void 0) {
+        continue;
+      }
+      pendingMessages2.push(message);
+    }
+    pendingMessages2.sort(compareMessages);
+  }
+  const inboundMessageIds = Array.isArray(value.inboundMessageIds) ? uniqueStrings(
+    value.inboundMessageIds.map((id) => typeof id === "string" ? id : void 0).filter((id) => Boolean(id))
+  ) : [];
+  const lease = normalizeLease(value.lease);
+  const normalizedStatus = status === "idle" && lease ? "running" : status === "idle" && pendingMessages2.length > 0 ? "pending" : status;
+  return {
+    status: normalizedStatus,
+    inboundMessageIds: uniqueStrings([
+      ...inboundMessageIds,
+      ...pendingMessages2.map((message) => message.inboundMessageId)
+    ]),
+    pendingCount: pendingMessages2.length,
+    pendingMessages: pendingMessages2,
+    lease,
+    lastCheckpointAtMs: toOptionalNumber(value.lastCheckpointAtMs),
+    lastEnqueuedAtMs: toOptionalNumber(value.lastEnqueuedAtMs),
+    runId: toOptionalString(value.runId),
+    updatedAtMs: toOptionalNumber(value.updatedAtMs)
+  };
+}
+function normalizeConversation(conversationId, value) {
+  if (!isRecord(value) || value.schemaVersion !== 1 && value.schemaVersion !== CONVERSATION_SCHEMA_VERSION) {
+    return void 0;
+  }
+  const schemaVersion = value.schemaVersion;
+  const storedConversationId = toOptionalString(value.conversationId);
+  const createdAtMs = toOptionalNumber(value.createdAtMs);
+  const lastActivityAtMs = toOptionalNumber(value.lastActivityAtMs);
+  const updatedAtMs = toOptionalNumber(value.updatedAtMs);
+  const execution = normalizeExecution(
+    conversationId,
+    value.execution,
+    schemaVersion
+  );
+  const destination = value.destination === void 0 ? void 0 : parseDestination(value.destination);
+  if (storedConversationId !== conversationId || typeof createdAtMs !== "number" || typeof lastActivityAtMs !== "number" || typeof updatedAtMs !== "number" || !execution || value.destination !== void 0 && !destination) {
+    return void 0;
+  }
+  if (execution.pendingMessages.length > 0 && (!destination || execution.pendingMessages.some(
+    (message) => !sameDestination(message.destination, destination)
+  ))) {
+    return void 0;
+  }
+  return {
+    schemaVersion: CONVERSATION_SCHEMA_VERSION,
+    conversationId,
+    createdAtMs,
+    lastActivityAtMs,
+    updatedAtMs,
+    execution,
+    ...destination ? { destination } : {},
+    ...toOptionalString(value.title) ? { title: toOptionalString(value.title) } : {},
+    ...toOptionalString(value.channelName) ? { channelName: toOptionalString(value.channelName) } : {},
+    ...normalizeActor(value.actor) ? { actor: normalizeActor(value.actor) } : {},
+    ...normalizeSource(value.source) ? { source: normalizeSource(value.source) } : {}
+  };
+}
+function emptyConversation(args) {
+  return {
+    schemaVersion: CONVERSATION_SCHEMA_VERSION,
+    conversationId: args.conversationId,
+    createdAtMs: args.nowMs,
+    lastActivityAtMs: args.nowMs,
+    updatedAtMs: args.nowMs,
+    ...args.destination ? { destination: args.destination } : {},
+    ...args.source ? { source: args.source } : {},
+    execution: {
+      status: "idle",
+      inboundMessageIds: [],
+      pendingCount: 0,
+      pendingMessages: [],
+      updatedAtMs: args.nowMs
+    }
+  };
+}
+function isLeaseActive(lease, nowMs) {
+  return Boolean(lease && lease.expiresAtMs > nowMs);
+}
+function pendingMessages(conversation) {
+  return [...conversation.execution.pendingMessages].sort(compareMessages);
+}
+function isRunnableStatus(status) {
+  return status !== "failed" && status !== "idle";
+}
+function hasRunnableWork(conversation) {
+  return isRunnableStatus(conversation.execution.status) || pendingMessages(conversation).length > 0;
+}
+function executionWithPendingMessages(execution, pending) {
+  const pendingMessages2 = [...pending].sort(compareMessages);
+  const status = execution.status === "idle" && execution.lease ? "running" : execution.status === "idle" && pendingMessages2.length > 0 ? "pending" : execution.status;
+  return {
+    ...execution,
+    status,
+    inboundMessageIds: uniqueStrings([
+      ...execution.inboundMessageIds,
+      ...pendingMessages2.map((message) => message.inboundMessageId)
+    ]),
+    pendingMessages: pendingMessages2,
+    pendingCount: pendingMessages2.length
+  };
+}
+function withExecutionUpdate(conversation, execution, nowMs) {
+  return {
+    ...conversation,
+    updatedAtMs: nowMs,
+    execution: {
+      ...executionWithPendingMessages(execution, execution.pendingMessages),
+      updatedAtMs: nowMs
+    }
+  };
+}
+async function getConnectedState(stateAdapter) {
+  const state = stateAdapter ?? getStateAdapter();
+  await state.connect();
+  return state;
+}
+async function sleep(ms) {
+  await new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+async function withIndexLock(state, indexKey, callback) {
+  const startedAtMs = now();
+  let lock;
+  while (true) {
+    lock = await state.acquireLock(
+      indexLockKey(indexKey),
+      CONVERSATION_INDEX_LOCK_TTL_MS
+    );
+    if (lock) {
+      break;
+    }
+    if (now() - startedAtMs >= CONVERSATION_INDEX_LOCK_WAIT_MS) {
+      throw new Error(
+        `Could not acquire conversation index lock for ${indexKey}`
+      );
+    }
+    await sleep(CONVERSATION_INDEX_LOCK_RETRY_MS);
+  }
+  try {
+    return await callback();
+  } finally {
+    await state.releaseLock(lock);
+  }
+}
+function normalizeIndexEntry(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const conversationId = toOptionalString(value.conversationId);
+  const score = toOptionalNumber(value.score);
+  if (!conversationId || typeof score !== "number") {
+    return void 0;
+  }
+  return { conversationId, score };
+}
+function uniqueIndexEntries(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const entries = /* @__PURE__ */ new Map();
+  for (const item of value) {
+    const entry = normalizeIndexEntry(item);
+    if (!entry) {
+      continue;
+    }
+    const existing = entries.get(entry.conversationId);
+    if (!existing || entry.score > existing.score) {
+      entries.set(entry.conversationId, entry);
+    }
+  }
+  return [...entries.values()];
+}
+function retainedIndexEntries(indexKey, entries) {
+  if (indexKey === CONVERSATION_BY_ACTIVITY_INDEX_KEY) {
+    return entries.sort(compareIndexDescending).slice(0, CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH);
+  }
+  if (indexKey === CONVERSATION_ACTIVE_INDEX_KEY) {
+    return entries.sort(compareIndexAscending);
+  }
+  throw new Error(`Unknown conversation index ${indexKey}`);
+}
+function redisIndexKey(indexKey) {
+  const prefix = getChatConfig().state.keyPrefix;
+  return [...prefix ? [prefix] : [], indexKey].join(":");
+}
+function parseRedisIndexEntries(values) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  const entries = [];
+  for (let index = 0; index < values.length; index += 2) {
+    const conversationId = toOptionalString(values[index]);
+    const score = typeof values[index + 1] === "number" ? values[index + 1] : Number(values[index + 1]);
+    if (!conversationId || !Number.isFinite(score)) {
+      continue;
+    }
+    entries.push({ conversationId, score });
+  }
+  return entries;
+}
+function redisConversationIndexStore(client) {
+  const upsertBoundedActivityScript = `
+    redis.call("ZADD", KEYS[1], ARGV[1], ARGV[2])
+    redis.call("PEXPIRE", KEYS[1], ARGV[3])
+    local extra = redis.call("ZCARD", KEYS[1]) - tonumber(ARGV[4])
+    if extra > 0 then
+      redis.call("ZREMRANGEBYRANK", KEYS[1], 0, extra - 1)
+    end
+    return 1
+  `;
+  return {
+    async list(args) {
+      const key = redisIndexKey(args.indexKey);
+      const limit = args.limit;
+      const offset = Math.max(0, args.offset ?? 0);
+      if (limit === 0) {
+        return [];
+      }
+      const values = args.scoreMax !== void 0 ? await client.sendCommand([
+        "ZRANGEBYSCORE",
+        key,
+        "-inf",
+        String(args.scoreMax),
+        "WITHSCORES",
+        ...limit !== void 0 || offset > 0 ? ["LIMIT", String(offset), String(limit ?? 1e9)] : []
+      ]) : await client.sendCommand([
+        args.order === "asc" ? "ZRANGE" : "ZREVRANGE",
+        key,
+        String(offset),
+        String(
+          limit === void 0 ? -1 : offset + Math.max(0, limit - 1)
+        ),
+        "WITHSCORES"
+      ]);
+      return parseRedisIndexEntries(values);
+    },
+    async remove(args) {
+      await client.sendCommand([
+        "ZREM",
+        redisIndexKey(args.indexKey),
+        args.conversationId
+      ]);
+    },
+    async upsert(args) {
+      const key = redisIndexKey(args.indexKey);
+      if (args.indexKey === CONVERSATION_BY_ACTIVITY_INDEX_KEY) {
+        await client.sendCommand([
+          "EVAL",
+          upsertBoundedActivityScript,
+          "1",
+          key,
+          String(args.score),
+          args.conversationId,
+          String(JUNIOR_THREAD_STATE_TTL_MS),
+          String(CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH)
+        ]);
+        return;
+      }
+      if (args.indexKey === CONVERSATION_ACTIVE_INDEX_KEY) {
+        await client.sendCommand([
+          "ZADD",
+          key,
+          String(args.score),
+          args.conversationId
+        ]);
+        await client.sendCommand([
+          "PEXPIRE",
+          key,
+          String(JUNIOR_THREAD_STATE_TTL_MS)
+        ]);
+        return;
+      }
+      throw new Error(`Unknown conversation index ${args.indexKey}`);
+    }
+  };
+}
+function emulatedConversationIndexStore(state) {
+  const readIndex = async (indexKey) => uniqueIndexEntries(await state.get(indexKey));
+  const writeIndex = async (indexKey, entries) => {
+    await state.set(indexKey, entries, JUNIOR_THREAD_STATE_TTL_MS);
+  };
+  return {
+    async list(args) {
+      const entries = (await readIndex(args.indexKey)).filter(
+        (entry) => args.scoreMax === void 0 ? true : entry.score <= args.scoreMax
+      ).sort(
+        args.order === "asc" ? compareIndexAscending : compareIndexDescending
+      );
+      const offset = Math.max(0, args.offset ?? 0);
+      return entries.slice(
+        offset,
+        args.limit === void 0 ? entries.length : offset + args.limit
+      );
+    },
+    async remove(args) {
+      await withIndexLock(state, args.indexKey, async () => {
+        const entries = await readIndex(args.indexKey);
+        const next = entries.filter(
+          (entry) => entry.conversationId !== args.conversationId
+        );
+        if (next.length === entries.length) {
+          return;
+        }
+        await writeIndex(args.indexKey, next);
+      });
+    },
+    async upsert(args) {
+      await withIndexLock(state, args.indexKey, async () => {
+        const entries = await readIndex(args.indexKey);
+        const withoutCurrent = entries.filter(
+          (entry) => entry.conversationId !== args.conversationId
+        );
+        const next = retainedIndexEntries(args.indexKey, [
+          ...withoutCurrent,
+          { conversationId: args.conversationId, score: args.score }
+        ]);
+        await writeIndex(args.indexKey, next);
+      });
+    }
+  };
+}
+async function getConversationIndexStore(state) {
+  const redisStateAdapter = await getDefaultRedisStateAdapterFor(state);
+  if (redisStateAdapter) {
+    return redisConversationIndexStore(redisStateAdapter.getClient());
+  }
+  return emulatedConversationIndexStore(state);
+}
+async function upsertIndexEntry(args) {
+  const index = await getConversationIndexStore(args.state);
+  await index.upsert({
+    conversationId: args.conversationId,
+    indexKey: args.indexKey,
+    score: args.score
+  });
+}
+async function removeIndexEntry(args) {
+  const index = await getConversationIndexStore(args.state);
+  await index.remove({
+    conversationId: args.conversationId,
+    indexKey: args.indexKey
+  });
+}
+async function acquireMutationLock(state, conversationId) {
+  const startedAtMs = now();
+  while (true) {
+    const lock = await state.acquireLock(
+      mutationLockKey(conversationId),
+      CONVERSATION_MUTATION_LOCK_TTL_MS
+    );
+    if (lock) {
+      return lock;
+    }
+    if (now() - startedAtMs >= CONVERSATION_MUTATION_WAIT_MS) {
+      throw new Error(
+        `Could not acquire conversation mutation lock for ${conversationId}`
+      );
+    }
+    await sleep(CONVERSATION_MUTATION_RETRY_MS);
+  }
+}
+async function withConversationMutation(args, callback) {
+  const state = await getConnectedState(args.state);
+  const lock = await acquireMutationLock(state, args.conversationId);
+  try {
+    return await callback(state, lock);
+  } finally {
+    await state.releaseLock(lock);
+  }
+}
+async function readConversation(state, conversationId) {
+  const raw = await state.get(conversationKey(conversationId));
+  if (raw == null) {
+    return void 0;
+  }
+  const conversation = normalizeConversation(conversationId, raw);
+  if (!conversation) {
+    throw new InvalidConversationRecordError(conversationId);
+  }
+  return conversation;
+}
+async function writeConversation(state, lock, conversation) {
+  const execution = executionWithPendingMessages(
+    conversation.execution,
+    conversation.execution.pendingMessages
+  );
+  const next = {
+    ...conversation,
+    execution
+  };
+  const fenced = await state.extendLock(
+    lock,
+    CONVERSATION_MUTATION_LOCK_TTL_MS
+  );
+  if (!fenced) {
+    throw new ConversationMutationFencedError(next.conversationId);
+  }
+  await state.set(
+    conversationKey(next.conversationId),
+    next,
+    JUNIOR_THREAD_STATE_TTL_MS
+  );
+  await upsertIndexEntry({
+    state,
+    indexKey: CONVERSATION_BY_ACTIVITY_INDEX_KEY,
+    conversationId: next.conversationId,
+    score: next.lastActivityAtMs
+  });
+  if (!hasRunnableWork(next)) {
+    await removeIndexEntry({
+      state,
+      indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
+      conversationId: next.conversationId
+    });
+    return;
+  }
+  await upsertIndexEntry({
+    state,
+    indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
+    conversationId: next.conversationId,
+    score: next.execution.updatedAtMs ?? next.updatedAtMs
+  });
+}
+function assertSameConversationDestination(args) {
+  if (!args.current || sameDestination(args.current, args.next)) {
+    return;
+  }
+  throw new Error(
+    `Conversation destination changed for ${args.conversationId}`
+  );
+}
+function conversationWorkState(conversation) {
+  const lease = conversation.execution.lease;
+  return {
+    ...conversation,
+    lastEnqueuedAtMs: conversation.execution.lastEnqueuedAtMs,
+    ...lease ? {
+      lease: {
+        acquiredAtMs: lease.acquiredAtMs,
+        lastCheckInAtMs: lease.lastCheckInAtMs,
+        leaseExpiresAtMs: lease.expiresAtMs,
+        leaseToken: lease.token
+      }
+    } : {},
+    messages: pendingMessages(conversation),
+    needsRun: hasRunnableWork(conversation)
+  };
+}
+async function getConversation(args) {
+  const state = await getConnectedState(args.state);
+  return await readConversation(state, args.conversationId);
+}
+async function getConversationWorkState(args) {
+  const conversation = await getConversation(args);
+  return conversation ? conversationWorkState(conversation) : void 0;
+}
+async function appendInboundMessage(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(
+    { conversationId: args.message.conversationId, state: args.state },
+    async (state, lock) => {
+      const current = await readConversation(state, args.message.conversationId) ?? emptyConversation({
+        conversationId: args.message.conversationId,
+        destination: args.message.destination,
+        nowMs,
+        source: args.message.source
+      });
+      assertSameConversationDestination({
+        conversationId: args.message.conversationId,
+        current: current.destination,
+        next: args.message.destination
+      });
+      const existingPending = current.execution.pendingMessages.some(
+        (message) => message.inboundMessageId === args.message.inboundMessageId
+      );
+      const existing = current.execution.inboundMessageIds.includes(
+        args.message.inboundMessageId
+      );
+      if (existing) {
+        if (!existingPending) {
+          return { status: "duplicate" };
+        }
+        const nextStatus = current.execution.status === "idle" ? "pending" : current.execution.status;
+        await writeConversation(
+          state,
+          lock,
+          withExecutionUpdate(
+            current,
+            {
+              ...current.execution,
+              status: nextStatus,
+              pendingMessages: current.execution.pendingMessages.map(
+                (message) => message.inboundMessageId === args.message.inboundMessageId ? upgradedPendingMessage(message, args.message) : message
+              )
+            },
+            nowMs
+          )
+        );
+        return { status: "duplicate" };
+      }
+      const status = current.execution.lease && current.execution.status === "running" ? "running" : current.execution.lease ? "awaiting_resume" : "pending";
+      const next = {
+        ...current,
+        destination: current.destination ?? args.message.destination,
+        source: current.source ?? args.message.source,
+        lastActivityAtMs: nowMs
+      };
+      await writeConversation(
+        state,
+        lock,
+        withExecutionUpdate(
+          next,
+          {
+            ...current.execution,
+            status,
+            inboundMessageIds: [
+              ...current.execution.inboundMessageIds,
+              args.message.inboundMessageId
+            ],
+            pendingMessages: [
+              ...current.execution.pendingMessages,
+              args.message
+            ].sort(compareMessages)
+          },
+          nowMs
+        )
+      );
+      return { status: "appended" };
+    }
+  );
+}
+async function requestConversationWork(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const existing = await readConversation(state, args.conversationId);
+    if (existing) {
+      assertSameConversationDestination({
+        conversationId: args.conversationId,
+        current: existing.destination,
+        next: args.destination
+      });
+    }
+    const current = existing ?? emptyConversation({
+      conversationId: args.conversationId,
+      destination: args.destination,
+      nowMs
+    });
+    const status = current.execution.lease ? "awaiting_resume" : "pending";
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        {
+          ...current,
+          destination: current.destination ?? args.destination
+        },
+        {
+          ...current.execution,
+          status
+        },
+        nowMs
+      )
+    );
+    return { status: existing === void 0 ? "created" : "updated" };
+  });
+}
+async function markConversationWorkEnqueued(args) {
+  const nowMs = args.nowMs ?? now();
+  await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current) {
+      return;
+    }
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lastEnqueuedAtMs: nowMs
+        },
+        nowMs
+      )
+    );
+  });
+}
+async function clearConsumedConversationWake(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || hasRunnableWork(current) || current.execution.lastEnqueuedAtMs === void 0) {
+      return false;
+    }
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lastEnqueuedAtMs: void 0
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function startConversationWork(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current) {
+      return { status: "no_work" };
+    }
+    if (isLeaseActive(current.execution.lease, nowMs)) {
+      return {
+        status: "active",
+        leaseExpiresAtMs: current.execution.lease.expiresAtMs
+      };
+    }
+    if (!hasRunnableWork(current)) {
+      return { status: "no_work" };
+    }
+    const lease = {
+      token: randomUUID(),
+      acquiredAtMs: nowMs,
+      lastCheckInAtMs: nowMs,
+      expiresAtMs: nowMs + CONVERSATION_WORK_LEASE_TTL_MS
+    };
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease,
+          status: current.execution.status === "awaiting_resume" ? "awaiting_resume" : "running",
+          runId: current.execution.runId ?? randomUUID(),
+          lastEnqueuedAtMs: void 0
+        },
+        nowMs
+      )
+    );
+    return {
+      status: "acquired",
+      leaseToken: lease.token,
+      leaseExpiresAtMs: lease.expiresAtMs
+    };
+  });
+}
+async function checkInConversationWork(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return false;
+    }
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease: {
+            ...current.execution.lease,
+            lastCheckInAtMs: nowMs,
+            expiresAtMs: nowMs + CONVERSATION_WORK_LEASE_TTL_MS
+          }
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function drainConversationMailbox(args) {
+  const nowMs = args.nowMs ?? now();
+  const pending = await withConversationMutation(args, async (state) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      throw new Error(
+        `Conversation lease is not held for ${args.conversationId}`
+      );
+    }
+    return pendingMessages(current);
+  });
+  if (pending.length === 0) {
+    return { changed: false, messages: [] };
+  }
+  const result = await args.handle(pending);
+  const pendingIds = new Set(
+    pending.map((message) => message.inboundMessageId)
+  );
+  const acknowledgedIds = new Set(
+    result ?? pending.map((message) => message.inboundMessageId)
+  );
+  for (const inboundMessageId of acknowledgedIds) {
+    if (!pendingIds.has(inboundMessageId)) {
+      throw new Error(
+        `Conversation mailbox drain result is not pending for ${args.conversationId}`
+      );
+    }
+  }
+  if (acknowledgedIds.size === 0) {
+    return { changed: false, messages: [] };
+  }
+  await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      throw new Error(
+        `Conversation lease is not held for ${args.conversationId}`
+      );
+    }
+    const pendingMessages2 = current.execution.pendingMessages.filter(
+      (message) => !acknowledgedIds.has(message.inboundMessageId)
+    );
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          status: current.execution.status === "pending" && pendingMessages2.length === 0 ? "running" : current.execution.status,
+          pendingMessages: pendingMessages2
+        },
+        nowMs
+      )
+    );
+  });
+  return {
+    changed: true,
+    messages: pending.filter(
+      (message) => acknowledgedIds.has(message.inboundMessageId)
+    )
+  };
+}
+async function ackMessages(args) {
+  const nowMs = args.nowMs ?? now();
+  const inboundMessageIds = new Set(args.inboundMessageIds);
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return false;
+    }
+    if (inboundMessageIds.size === 0) {
+      return true;
+    }
+    const pendingMessages2 = current.execution.pendingMessages.filter(
+      (message) => !inboundMessageIds.has(message.inboundMessageId)
+    );
+    if (pendingMessages2.length === current.execution.pendingMessages.length) {
+      return true;
+    }
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          pendingMessages: pendingMessages2
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function requestConversationContinuation(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return false;
+    }
+    assertSameConversationDestination({
+      conversationId: args.conversationId,
+      current: current.destination,
+      next: args.destination
+    });
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          status: "awaiting_resume"
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function beginConversationResume(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken || current.execution.status !== "awaiting_resume") {
+      return false;
+    }
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          status: "running"
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function releaseConversationWork(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return false;
+    }
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease: void 0,
+          status: current.execution.status === "running" ? "pending" : current.execution.status
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function completeConversationWork(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return "lost_lease";
+    }
+    const hasPending = pendingMessages(current).length > 0;
+    const needsRun = current.execution.status === "awaiting_resume";
+    const runnable = needsRun || hasPending;
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease: void 0,
+          status: needsRun ? "awaiting_resume" : hasPending ? "pending" : "idle",
+          runId: runnable ? current.execution.runId : void 0
+        },
+        nowMs
+      )
+    );
+    return runnable ? "pending" : "completed";
+  });
+}
+async function recordAttemptFailure(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return {
+        status: "lost_lease",
+        pendingCount: 0,
+        deadLetteredMessages: []
+      };
+    }
+    const pendingIds = new Set(
+      current.execution.pendingMessages.map(
+        (message) => message.inboundMessageId
+      )
+    );
+    if (args.inboundMessageIds.length === 0 || args.inboundMessageIds.some((id) => !pendingIds.has(id))) {
+      return {
+        status: "skipped",
+        pendingCount: current.execution.pendingMessages.length,
+        deadLetteredMessages: []
+      };
+    }
+    const attemptedIds = new Set(args.inboundMessageIds);
+    const deadLetteredMessages = [];
+    const pendingMessages2 = [];
+    for (const message of current.execution.pendingMessages) {
+      if (!attemptedIds.has(message.inboundMessageId)) {
+        pendingMessages2.push(message);
+        continue;
+      }
+      const attempted = {
+        ...message,
+        attemptCount: (message.attemptCount ?? 0) + 1
+      };
+      if (attempted.attemptCount >= CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS) {
+        deadLetteredMessages.push(attempted);
+        continue;
+      }
+      pendingMessages2.push(attempted);
+    }
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          pendingMessages: pendingMessages2
+        },
+        nowMs
+      )
+    );
+    return {
+      status: "recorded",
+      pendingCount: pendingMessages2.length,
+      deadLetteredMessages
+    };
+  });
+}
+async function deadLetterAttempt(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return "lost_lease";
+    }
+    const runnable = pendingMessages(current).length > 0;
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease: void 0,
+          status: runnable ? "pending" : "failed",
+          runId: runnable ? current.execution.runId : void 0
+        },
+        nowMs
+      )
+    );
+    return runnable ? "pending" : "failed";
+  });
+}
+async function clearExpiredConversationLease(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current?.execution.lease || current.execution.lease.expiresAtMs > nowMs) {
+      return false;
+    }
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease: void 0,
+          status: "awaiting_resume"
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function removeActiveConversation(args) {
+  const state = await getConnectedState(args.state);
+  await removeIndexEntry({
+    state,
+    indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
+    conversationId: args.conversationId
+  });
+}
+async function listActiveConversationIds(args = {}) {
+  const state = await getConnectedState(args.state);
+  const index = await getConversationIndexStore(state);
+  const entries = await index.list({
+    indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
+    limit: args.limit,
+    order: "asc",
+    scoreMax: args.staleBeforeMs
+  });
+  return entries.map((entry) => entry.conversationId);
+}
+
+// src/chat/task-execution/store.ts
+function metadataStore(options) {
+  return options.conversationStore ?? getConversationStore();
+}
+function duplicateInboundNudgeIdempotencyKey(message, nowMs) {
+  return `duplicate:${message.conversationId}:${message.inboundMessageId}:${nowMs}`;
+}
+function hasRecentEnqueueMarker(conversation, nowMs) {
+  const lastEnqueuedAtMs = conversation.execution.lastEnqueuedAtMs;
+  return typeof lastEnqueuedAtMs === "number" && lastEnqueuedAtMs + CONVERSATION_WORK_STALE_ENQUEUE_MS > nowMs;
+}
+function now2() {
+  return Date.now();
+}
+async function recordExecutionMetadata(args) {
+  const conversation = await getConversation({
+    conversationId: args.conversationId,
+    state: args.state
+  });
+  if (!conversation) {
+    return;
+  }
+  await metadataStore(args).recordExecution({
+    channelName: conversation.channelName,
+    conversationId: conversation.conversationId,
+    createdAtMs: conversation.createdAtMs,
+    destination: conversation.destination,
+    execution: {
+      lastCheckpointAtMs: conversation.execution.lastCheckpointAtMs,
+      lastEnqueuedAtMs: conversation.execution.lastEnqueuedAtMs,
+      runId: conversation.execution.runId,
+      status: conversation.execution.status,
+      updatedAtMs: conversation.execution.updatedAtMs
+    },
+    lastActivityAtMs: conversation.lastActivityAtMs,
+    metrics: null,
+    actor: conversation.actor,
+    source: conversation.source,
+    title: conversation.title,
+    updatedAtMs: conversation.updatedAtMs
+  });
+}
+async function getConversationWorkState2(args) {
+  return await getConversationWorkState(args);
+}
+function countPendingConversationMessages(conversation) {
+  return conversation.execution.pendingMessages.length;
+}
+function hasRunnableConversationWork(conversation) {
+  return conversation.execution.status !== "idle" || countPendingConversationMessages(conversation) > 0;
+}
+async function ensureConversationWake(args) {
+  const nowMs = args.nowMs ?? now2();
+  const conversation = await getConversation({
+    conversationId: args.conversationId,
+    state: args.state
+  });
+  if (!conversation || !hasRunnableConversationWork(conversation)) {
+    return { status: "no_work" };
+  }
+  if (!conversation.destination) {
+    return { status: "no_work" };
+  }
+  if (args.replaceExistingWake !== true && conversation.execution.lease && conversation.execution.lease.expiresAtMs > nowMs) {
+    return { status: "lease_active" };
+  }
+  if (args.replaceExistingWake !== true && hasRecentEnqueueMarker(conversation, nowMs)) {
+    return { status: "already_enqueued" };
+  }
+  const queueResult = await args.queue.send(
+    {
+      conversationId: args.conversationId
+    },
+    {
+      delayMs: args.delayMs,
+      idempotencyKey: args.idempotencyKey
+    }
+  );
+  await markConversationWorkEnqueued2({
+    conversationId: args.conversationId,
+    conversationStore: args.conversationStore,
+    nowMs,
+    state: args.state
+  });
+  return { status: "enqueued", queueMessageId: queueResult?.messageId };
+}
+async function appendAndEnqueueInboundMessage(args) {
+  const nowMs = args.nowMs ?? now2();
+  const appendResult = await appendInboundMessage({
+    message: args.message,
+    nowMs,
+    state: args.state
+  });
+  let idempotencyKey = args.message.inboundMessageId;
+  if (appendResult.status === "duplicate") {
+    const conversation = await getConversation({
+      conversationId: args.message.conversationId,
+      state: args.state
+    });
+    if (!conversation) {
+      return appendResult;
+    }
+    if (hasRecentEnqueueMarker(conversation, nowMs)) {
+      await recordExecutionMetadata({
+        conversationId: args.message.conversationId,
+        conversationStore: args.conversationStore,
+        state: args.state
+      });
+      return appendResult;
+    }
+    const duplicateStillPending = conversation.execution.pendingMessages.some(
+      (message) => message.inboundMessageId === args.message.inboundMessageId
+    );
+    if (!duplicateStillPending) {
+      await recordExecutionMetadata({
+        conversationId: args.message.conversationId,
+        conversationStore: args.conversationStore,
+        state: args.state
+      });
+      return appendResult;
+    }
+    idempotencyKey = duplicateInboundNudgeIdempotencyKey(args.message, nowMs);
+  }
+  const wake = await ensureConversationWake({
+    conversationId: args.message.conversationId,
+    conversationStore: args.conversationStore,
+    idempotencyKey,
+    nowMs,
+    queue: args.queue,
+    state: args.state
+  });
+  if (wake.status !== "enqueued") {
+    await recordExecutionMetadata({
+      conversationId: args.message.conversationId,
+      conversationStore: args.conversationStore,
+      state: args.state
+    });
+  }
+  return {
+    ...appendResult,
+    ...wake.status === "enqueued" ? { queueMessageId: wake.queueMessageId } : {}
+  };
+}
+async function clearConsumedConversationWake2(args) {
+  const result = await clearConsumedConversationWake(args);
+  if (result) {
+    await recordExecutionMetadata(args);
+  }
+  return result;
+}
+async function requestConversationWork2(args) {
+  const result = await requestConversationWork(args);
+  await recordExecutionMetadata({
+    conversationId: args.conversationId,
+    conversationStore: args.conversationStore,
+    state: args.state
+  });
+  return result;
+}
+async function markConversationWorkEnqueued2(args) {
+  await markConversationWorkEnqueued(args);
+  await recordExecutionMetadata(args);
+}
+async function startConversationWork2(args) {
+  const result = await startConversationWork(args);
+  await recordExecutionMetadata(args);
+  return result;
+}
+async function checkInConversationWork2(args) {
+  const result = await checkInConversationWork(args);
+  if (result) {
+    await recordExecutionMetadata(args);
+  }
+  return result;
+}
+async function drainConversationMailbox2(args) {
+  const result = await drainConversationMailbox(args);
+  if (result.changed) {
+    await recordExecutionMetadata(args);
+  }
+  return result.messages;
+}
+async function ackMessages2(args) {
+  const result = await ackMessages(args);
+  await recordExecutionMetadata(args);
+  return result;
+}
+async function requestConversationContinuation2(args) {
+  const result = await requestConversationContinuation(args);
+  await recordExecutionMetadata(args);
+  return result;
+}
+async function beginConversationResume2(args) {
+  const result = await beginConversationResume(args);
+  if (result) {
+    await recordExecutionMetadata(args);
+  }
+  return result;
+}
+async function releaseConversationWork2(args) {
+  const result = await releaseConversationWork(args);
+  await recordExecutionMetadata(args);
+  return result;
+}
+async function completeConversationWork2(args) {
+  const result = await completeConversationWork(args);
+  await recordExecutionMetadata(args);
+  return result;
+}
+async function recordAttemptFailure2(args) {
+  const result = await recordAttemptFailure(args);
+  if (result.status === "recorded") {
+    await recordExecutionMetadata(args);
+  }
+  return result;
+}
+async function deadLetterAttempt2(args) {
+  const result = await deadLetterAttempt(args);
+  await recordExecutionMetadata(args);
+  return result;
+}
+async function clearExpiredConversationLease2(args) {
+  const result = await clearExpiredConversationLease(args);
+  await recordExecutionMetadata(args);
+  return result;
+}
+async function removeActiveConversation2(args) {
+  return await removeActiveConversation(args);
+}
+async function listActiveConversationIds2(args = {}) {
+  return await listActiveConversationIds(args);
+}
+
+// src/chat/services/agent-continue.ts
+async function getAwaitingAgentContinueRequest(args) {
+  const sessionRecord = await getAgentTurnSessionRecord(
+    args.conversationId,
+    args.sessionId
+  );
+  if (!sessionRecord || sessionRecord.state !== "awaiting_resume" || sessionRecord.resumeReason !== "timeout" && sessionRecord.resumeReason !== "yield" && sessionRecord.resumeReason !== "retry" || sessionRecord.resumeReason === "timeout" && sessionRecord.sliceId < 2) {
+    return void 0;
+  }
+  if (!sessionRecord.destination) {
+    return void 0;
+  }
+  return {
+    conversationId: args.conversationId,
+    destination: sessionRecord.destination,
+    sessionId: args.sessionId,
+    expectedVersion: sessionRecord.version
+  };
+}
+async function scheduleAgentContinue(request, options = {}) {
+  const nowMs = options.nowMs ?? Date.now();
+  await requestConversationWork2({
+    conversationId: request.conversationId,
+    destination: request.destination,
+    nowMs,
+    state: options.state
+  });
+  const queue = options.queue ?? getVercelConversationWorkQueue();
+  await ensureConversationWake({
+    conversationId: request.conversationId,
+    idempotencyKey: [
+      "agent-continue",
+      request.conversationId,
+      request.sessionId,
+      request.expectedVersion,
+      nowMs
+    ].join(":"),
+    nowMs,
+    queue,
+    state: options.state
+  });
+}
+
+// src/handlers/oauth-html.ts
+function htmlCallbackResponse(title, message, status) {
+  const html = `<!DOCTYPE html>
+<html>
+<head><title>${title}</title></head>
+<body style="font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0;">
+  <div style="text-align: center; max-width: 480px;">
+    <h1>${title}</h1>
+    <p>${message}</p>
+    <p style="margin-top: 2rem; color: #666; font-size: 0.9em;">You can close this tab and return to Junior.</p>
+  </div>
+</body>
+</html>`;
+  return new Response(html, {
+    status,
+    headers: { "Content-Type": "text/html; charset=utf-8" }
+  });
+}
+
+// src/handlers/mcp-oauth-callback.ts
+var CALLBACK_PAGES = {
+  missing_state: {
+    title: "Authorization failed",
+    message: "Missing state parameter.",
+    status: 400
+  },
+  provider_error: {
+    title: "Authorization failed",
+    message: "The provider returned an authorization error.",
+    status: 400
+  },
+  missing_code: {
+    title: "Authorization failed",
+    message: "Missing code parameter.",
+    status: 400
+  },
+  expired: {
+    title: "Authorization expired",
+    message: "This authorization link is no longer active. Return to Junior and retry the original request.",
+    status: 400
+  },
+  success: {
+    title: "Authorization complete",
+    message: "Your MCP access is connected. Junior will continue the paused request in Slack.",
+    status: 200
+  },
+  failure: {
+    title: "Authorization failed",
+    message: "Junior could not finish the authorization callback. Return to Junior and retry the original request.",
+    status: 500
+  }
+};
+var McpOAuthAttemptExpiredError = class extends Error {
+  constructor() {
+    super("MCP OAuth authorization attempt is no longer current");
+    this.name = "McpOAuthAttemptExpiredError";
+  }
+};
+function mcpAuthorizationId(args) {
+  return `${args.sessionId}:mcp:${args.provider}`;
+}
+function htmlResponse(kind, options) {
+  const page = kind === "success" && options?.local ? {
+    ...CALLBACK_PAGES.success,
+    message: "Your MCP access is connected. Junior will continue the paused request in the local client."
+  } : CALLBACK_PAGES[kind];
+  return htmlCallbackResponse(page.title, page.message, page.status);
+}
+async function persistCompletedReplyState(channelId, threadTs, sessionId, reply) {
+  const threadId = `slack:${channelId}:${threadTs}`;
+  const currentState = await getPersistedThreadState(threadId);
+  const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({ conversation, conversationId: threadId });
+  const artifacts = coerceThreadArtifactsState(currentState);
+  const userMessage = getTurnUserMessage(conversation, sessionId);
+  const statePatch = buildDeliveredTurnStatePatch({
+    artifacts,
+    conversation,
+    reply,
+    sessionId,
+    userMessageId: userMessage?.id
+  });
+  await persistThreadStateById(threadId, {
+    ...statePatch
+  });
+}
+async function failSessionRecordBestEffort(args) {
+  try {
+    await failAgentTurnSessionRecord({
+      conversationId: args.conversationId,
+      sessionId: args.sessionId,
+      errorMessage: args.errorMessage,
+      expectedVersion: args.expectedVersion
+    });
+  } catch (error) {
+    logException(
+      error,
+      "mcp_oauth_callback_session_record_fail_persist_failed",
+      {},
+      {
+        "app.ai.conversation_id": args.conversationId,
+        "app.ai.session_id": args.sessionId
+      },
+      "Failed to mark MCP OAuth-resumed turn session record failed"
+    );
+  }
+}
+async function persistFailedReplyState(channelId, threadTs, sessionId, expectedVersion) {
+  const threadId = `slack:${channelId}:${threadTs}`;
+  const currentState = await getPersistedThreadState(threadId);
+  const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({ conversation, conversationId: threadId });
+  clearPendingAuth(conversation, sessionId);
+  markTurnFailed({
+    conversation,
+    nowMs: Date.now(),
+    sessionId,
+    userMessageId: getTurnUserMessageId(conversation, sessionId),
+    markConversationMessage,
+    updateConversationStats
+  });
+  await failSessionRecordBestEffort({
+    conversationId: threadId,
+    sessionId,
+    errorMessage: "OAuth-resumed MCP turn failed",
+    expectedVersion
+  });
+  await persistThreadStateById(threadId, {
+    conversation
+  });
+}
+async function resumeAuthorizedMcpTurn(args) {
+  const { authSession, agentRunner, provider } = args;
+  if (!authSession.channelId || !authSession.destination || !authSession.threadTs) {
+    return;
+  }
+  const destination = requireSlackDestination(
+    authSession.destination,
+    "MCP OAuth resume"
+  );
+  const threadId = `slack:${authSession.channelId}:${authSession.threadTs}`;
+  const currentState = await getPersistedThreadState(threadId);
+  const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({ conversation, conversationId: threadId });
+  const pendingAuth = getConversationPendingAuth({
+    conversation,
+    kind: "mcp",
+    provider,
+    actorId: authSession.userId
+  });
+  if (pendingAuth?.authSessionId !== authSession.authSessionId) {
+    return;
+  }
+  const resolvedSessionId = pendingAuth.sessionId;
+  const userMessage = getTurnUserMessage(conversation, resolvedSessionId);
+  if (!isPendingAuthLatestRequest(conversation, pendingAuth)) {
+    clearPendingAuth(conversation, pendingAuth.sessionId);
+    await persistThreadStateById(threadId, { conversation });
+    await abandonAgentTurnSessionRecord({
+      conversationId: authSession.conversationId,
+      sessionId: pendingAuth.sessionId,
+      errorMessage: "Auth completed after a newer thread message abandoned this blocked request."
+    });
+    return;
+  }
+  if (!userMessage) {
+    return;
+  }
+  await resumeSlackTurn({
+    messageText: userMessage.text,
+    conversationId: authSession.conversationId,
+    turnId: resolvedSessionId,
+    channelId: authSession.channelId,
+    threadTs: authSession.threadTs,
+    messageTs: getTurnUserSlackMessageTs(userMessage),
+    lockKey: threadId,
+    initialText: "",
+    agentRunner,
+    beforeStart: async () => {
+      const lockedState = await getPersistedThreadState(threadId);
+      const lockedConversation = coerceThreadConversationState(lockedState);
+      await hydrateConversationMessages({
+        conversation: lockedConversation,
+        conversationId: threadId
+      });
+      const lockedArtifacts = coerceThreadArtifactsState(lockedState);
+      const lockedPendingAuth = getConversationPendingAuth({
+        conversation: lockedConversation,
+        kind: "mcp",
+        provider,
+        actorId: authSession.userId
+      });
+      if (lockedPendingAuth?.authSessionId !== authSession.authSessionId) {
+        return false;
+      }
+      const lockedSessionId = lockedPendingAuth.sessionId;
+      if (lockedSessionId !== resolvedSessionId) {
+        return false;
+      }
+      if (!isPendingAuthLatestRequest(lockedConversation, lockedPendingAuth)) {
+        clearPendingAuth(lockedConversation, lockedPendingAuth.sessionId);
+        await persistThreadStateById(threadId, {
+          conversation: lockedConversation
+        });
+        await abandonAgentTurnSessionRecord({
+          conversationId: authSession.conversationId,
+          sessionId: lockedPendingAuth.sessionId,
+          errorMessage: "Auth completed after a newer thread message abandoned this blocked request."
+        });
+        return false;
+      }
+      const lockedUserMessage = getTurnUserMessage(
+        lockedConversation,
+        lockedSessionId
+      );
+      if (!lockedUserMessage) {
+        return false;
+      }
+      const lockedSessionRecord = await getAgentTurnSessionRecord(
+        authSession.conversationId,
+        lockedSessionId
+      );
+      if (!lockedSessionRecord || lockedSessionRecord.state !== "awaiting_resume" || lockedSessionRecord.resumeReason !== "auth") {
+        return false;
+      }
+      const lockedConversationContext = buildConversationContext(
+        lockedConversation,
+        {
+          excludeMessageId: lockedUserMessage.id
+        }
+      );
+      const lockedChannelConfiguration = getChannelConfigurationServiceById(
+        authSession.channelId
+      );
+      let actor;
+      try {
+        actor = createSlackResumeActor({
+          actor: isUserActor(lockedSessionRecord.actor) ? lockedSessionRecord.actor : void 0,
+          teamId: destination.teamId,
+          userId: authSession.userId
+        });
+      } catch {
+        await failAgentTurnSessionRecord({
+          conversationId: authSession.conversationId,
+          expectedVersion: lockedSessionRecord.version,
+          sessionId: lockedSessionId,
+          errorMessage: "Stored Slack actor identity did not match OAuth actor"
+        });
+        return false;
+      }
+      if (!lockedSessionRecord.source) {
+        await failAgentTurnSessionRecord({
+          conversationId: authSession.conversationId,
+          expectedVersion: lockedSessionRecord.version,
+          sessionId: lockedSessionId,
+          errorMessage: "Stored Slack source missing for MCP OAuth resume"
+        });
+        return false;
+      }
+      await recordAuthorizationCompleted({
+        conversationId: authSession.conversationId,
+        kind: "mcp",
+        provider,
+        actorId: authSession.userId,
+        authorizationId: mcpAuthorizationId({
+          provider,
+          sessionId: lockedSessionId
+        })
+      });
+      const lockedMessageTs = getTurnUserSlackMessageTs(lockedUserMessage);
+      return {
+        messageText: lockedUserMessage.text,
+        messageTs: lockedMessageTs,
+        inputMessageIds: [lockedUserMessage.id],
+        replyContext: {
+          input: {
+            conversationContext: lockedConversationContext,
+            // Pi history is SQL-authoritative: the resumed run reads its
+            // session record first and falls back to the step projection.
+            piMessages: await loadProjection({ conversationId: threadId }),
+            ...getTurnUserReplyAttachmentContext(lockedUserMessage)
+          },
+          routing: {
+            credentialContext: {
+              actor: { type: "user", userId: actor.userId }
+            },
+            actor,
+            destination,
+            source: lockedSessionRecord.source,
+            toolChannelId: authSession.toolChannelId ?? lockedArtifacts.assistantContextChannelId ?? authSession.channelId
+          },
+          policy: {
+            configuration: authSession.configuration,
+            channelConfiguration: lockedChannelConfiguration
+          },
+          state: {
+            artifactState: lockedArtifacts,
+            pendingAuth: lockedPendingAuth,
+            sandboxRef: getPersistedSandboxState(lockedState)
+          },
+          durability: {
+            recordPendingAuth: async (nextPendingAuth) => {
+              lockedConversation.processing.pendingAuth = nextPendingAuth;
+              await persistThreadStateById(threadId, {
+                conversation: lockedConversation
+              });
+            }
+          }
+        },
+        commitResult: async (reply) => {
+          await persistCompletedReplyState(
+            authSession.channelId,
+            authSession.threadTs,
+            lockedSessionId,
+            reply
+          );
+        },
+        onPostDeliveryCommitFailure: async () => {
+          await failAgentTurnSessionRecord({
+            conversationId: authSession.conversationId,
+            expectedVersion: lockedSessionRecord.version,
+            sessionId: lockedSessionId,
+            errorMessage: "OAuth-resumed MCP reply was delivered but completion state did not persist"
+          });
+        },
+        onFailure: async () => {
+          try {
+            await persistFailedReplyState(
+              authSession.channelId,
+              authSession.threadTs,
+              lockedSessionId,
+              lockedSessionRecord.version
+            );
+          } catch (persistError) {
+            logException(
+              persistError,
+              "mcp_oauth_callback_resume_failure_persist_failed",
+              {},
+              { "app.credential.provider": provider },
+              "Failed to persist failed MCP resume state"
+            );
+          }
+        },
+        onAuthPause: async () => {
+          await persistAuthPauseTurnState({
+            sessionId: lockedSessionId,
+            threadStateId: threadId
+          });
+          logWarn(
+            "mcp_oauth_callback_resume_reparked_for_auth",
+            {},
+            { "app.credential.provider": provider },
+            "Resumed MCP turn requested another authorization flow"
+          );
+        },
+        onSuspend: async (resumeVersion) => {
+          await scheduleAgentContinue({
+            conversationId: authSession.conversationId,
+            destination,
+            sessionId: lockedSessionId,
+            expectedVersion: resumeVersion
+          });
+        }
+      };
+    }
+  });
+}
+async function isCurrentMcpAuthorizationAttempt(authSession, provider) {
+  const conversationId = mcpConversationId(authSession);
+  if (!conversationId) {
+    return false;
+  }
+  const currentState = await getPersistedThreadState(conversationId);
+  const conversation = coerceThreadConversationState(currentState);
+  const pendingAuth = getConversationPendingAuth({
+    conversation,
+    kind: "mcp",
+    provider,
+    actorId: authSession.userId
+  });
+  return pendingAuth?.authSessionId === authSession.authSessionId && pendingAuth.sessionId === authSession.sessionId;
+}
+function mcpConversationId(authSession) {
+  if (authSession.destination?.platform === "local") {
+    return authSession.conversationId;
+  }
+  if (authSession.channelId && authSession.threadTs) {
+    return `slack:${authSession.channelId}:${authSession.threadTs}`;
+  }
+  return void 0;
+}
+async function runCurrentMcpCredentialMutation(authSession, provider, mutation) {
+  const conversationId = mcpConversationId(authSession);
+  if (!conversationId) {
+    throw new McpOAuthAttemptExpiredError();
+  }
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const lock = await acquireActiveLock(stateAdapter, conversationId);
+  if (!lock) {
+    throw new Error(
+      `Could not acquire MCP OAuth callback lock for ${conversationId}`
+    );
+  }
+  try {
+    if (!await isCurrentMcpAuthorizationAttempt(authSession, provider)) {
+      throw new McpOAuthAttemptExpiredError();
+    }
+    return await mutation();
+  } finally {
+    await stateAdapter.releaseLock(lock);
+  }
+}
+async function GET(request, provider, waitUntil, options) {
+  const localRelay = await relayLocalOAuthCallback(request);
+  if (localRelay) {
+    return localRelay;
+  }
+  const url = new URL(request.url);
+  const state = url.searchParams.get("state")?.trim();
+  const code = url.searchParams.get("code")?.trim();
+  const error = url.searchParams.get("error")?.trim();
+  if (!state) {
+    return htmlResponse("missing_state");
+  }
+  if (error) {
+    return htmlResponse("provider_error");
+  }
+  if (!code) {
+    return htmlResponse("missing_code");
+  }
+  try {
+    const pendingSession = await getMcpAuthSession(state);
+    if (!pendingSession || pendingSession.provider !== provider || !await isCurrentMcpAuthorizationAttempt(pendingSession, provider)) {
+      if (pendingSession) {
+        await deleteMcpAuthSession(pendingSession.authSessionId);
+      }
+      return htmlResponse("expired");
+    }
+    const authSession = await finalizeMcpAuthorization(
+      provider,
+      state,
+      code,
+      async (mutation) => await runCurrentMcpCredentialMutation(
+        pendingSession,
+        provider,
+        mutation
+      )
+    );
+    try {
+      await deleteMcpAuthSession(authSession.authSessionId);
+    } catch (cleanupError) {
+      logException(
+        cleanupError,
+        "mcp_oauth_callback_session_cleanup_failed",
+        {},
+        { "app.credential.provider": provider },
+        "Failed to delete completed MCP auth session"
+      );
+    }
+    if (authSession.destination?.platform !== "local") {
+      waitUntil(
+        () => resumeAuthorizedMcpTurn({
+          authSession,
+          agentRunner: options.agentRunner,
+          provider
+        })
+      );
+    }
+    return htmlResponse("success", {
+      local: authSession.destination?.platform === "local"
+    });
+  } catch (callbackError) {
+    if (callbackError instanceof McpOAuthAttemptExpiredError) {
+      await deleteMcpAuthSession(state);
+      return htmlResponse("expired");
+    }
+    logException(
+      callbackError,
+      "mcp_oauth_callback_failed",
+      {},
+      { "app.credential.provider": provider },
+      "Failed to process MCP OAuth callback"
+    );
+    return htmlResponse("failure");
+  }
+}
+
+// src/chat/slack/app-home.ts
+import fs from "fs";
+import path from "path";
+var DEFAULT_DESCRIPTION_TEXT = "I help your team investigate, summarize, and act on work in Slack.";
+var MAX_HOME_SKILLS = 6;
+var MAX_SECTION_TEXT_CHARS = 3e3;
+var HIDDEN_HOME_SKILLS = /* @__PURE__ */ new Set(["jr-rpc"]);
+function clampSectionText(text) {
+  if (text.length <= MAX_SECTION_TEXT_CHARS) {
+    return text;
+  }
+  return `${text.slice(0, MAX_SECTION_TEXT_CHARS - 1)}\u2026`;
+}
+function loadDescriptionText() {
+  const descriptionPath = path.join(homeDir(), "DESCRIPTION.md");
+  try {
+    const raw = fs.readFileSync(descriptionPath, "utf8").trim();
+    if (raw.length > 0) {
+      return clampSectionText(raw);
+    }
+  } catch {
+  }
+  return DEFAULT_DESCRIPTION_TEXT;
+}
+async function buildSkillsSummaryText() {
+  const skills = (await discoverSkills()).filter(
+    (skill) => !HIDDEN_HOME_SKILLS.has(skill.name)
+  );
+  if (skills.length === 0) {
+    return "No skills installed.";
+  }
+  const visible = skills.slice(0, MAX_HOME_SKILLS);
+  const lines = visible.map(
+    (skill) => `\u2022 *${skill.name}* \u2014 ${skill.description}`
+  );
+  if (skills.length > visible.length) {
+    lines.push(`\u2022 \u2026and ${skills.length - visible.length} more`);
+  }
+  return lines.join("\n");
+}
+function accountLabel(account) {
+  const label = account.label ?? account.id;
+  return account.url ? `<${account.url}|${label}>` : label;
+}
+function connectedAccountText(plugin, account) {
+  return account ? `*${plugin.manifest.name}*
+Connected as ${accountLabel(account)}` : `*${plugin.manifest.name}*
+${plugin.manifest.description}`;
+}
+async function connectedOAuthTokens(userId, plugin, userTokenStore) {
+  if (plugin.manifest.oauth || plugin.manifest.credentials) {
+    const stored = await userTokenStore.get(userId, plugin.manifest.name);
+    return stored && hasRequiredOAuthScope(stored.scope, plugin.manifest.oauth?.scope) ? stored : void 0;
+  }
+  return void 0;
+}
+async function hasConnectedMcpAccount(userId, plugin) {
+  if (plugin.manifest.mcp) {
+    return Boolean(
+      (await getMcpStoredOAuthCredentials(userId, plugin.manifest.name))?.tokens
+    );
+  }
+  return false;
+}
+async function buildHomeView(userId, userTokenStore) {
+  const runtimeMetadata = getRuntimeMetadata();
+  const descriptionText = loadDescriptionText();
+  const skillsSummaryText = await buildSkillsSummaryText();
+  const providers = pluginCatalogRuntime.getProviders();
+  const connectedSections = [];
+  for (const plugin of providers) {
+    const tokens = await connectedOAuthTokens(userId, plugin, userTokenStore);
+    if (!tokens && !await hasConnectedMcpAccount(userId, plugin)) continue;
+    connectedSections.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: connectedAccountText(plugin, tokens?.account)
+      },
+      accessory: {
+        type: "button",
+        text: { type: "plain_text", text: "Unlink" },
+        action_id: "app_home_disconnect",
+        value: plugin.manifest.name,
+        style: "danger"
+      }
+    });
+  }
+  const accountBlocks = connectedSections.length > 0 ? connectedSections : [
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: "No connected accounts"
+      }
+    }
+  ];
+  return {
+    type: "home",
+    blocks: [
+      {
+        type: "header",
+        text: {
+          type: "plain_text",
+          text: "Junior"
+        }
+      },
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: descriptionText
+        }
+      },
+      { type: "divider" },
+      {
+        type: "header",
+        text: {
+          type: "plain_text",
+          text: "What I can help with"
+        }
+      },
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: skillsSummaryText
+        }
+      },
+      { type: "divider" },
+      {
+        type: "header",
+        text: {
+          type: "plain_text",
+          text: "Connected accounts"
+        }
+      },
+      ...accountBlocks,
+      {
+        type: "context",
+        elements: [
+          {
+            type: "mrkdwn",
+            text: `*junior version:* \`${runtimeMetadata.version ?? "unknown"}\``
+          }
+        ]
+      }
+    ]
+  };
+}
+async function publishAppHomeView(slackClient, userId, userTokenStore) {
+  const view = await buildHomeView(userId, userTokenStore);
+  await slackClient.views.publish({ user_id: userId, view });
+}
+
+// src/handlers/oauth-callback.ts
+function htmlErrorResponse(title, message, status) {
+  return htmlCallbackResponse(escapeXml(title), escapeXml(message), status);
+}
+async function persistCompletedOAuthReplyState(args) {
+  const currentState = await getPersistedThreadState(args.conversationId);
+  const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({
+    conversation,
+    conversationId: args.conversationId
+  });
+  const artifacts = coerceThreadArtifactsState(currentState);
+  const userMessage = getTurnUserMessage(conversation, args.sessionId);
+  const statePatch = buildDeliveredTurnStatePatch({
+    artifacts,
+    conversation,
+    reply: args.reply,
+    sessionId: args.sessionId,
+    userMessageId: userMessage?.id
+  });
+  await persistThreadStateById(args.conversationId, {
+    ...statePatch
+  });
+}
+function pluginAuthorizationId(args) {
+  return `${args.sessionId}:plugin:${args.provider}`;
+}
+async function failSessionRecordBestEffort2(args) {
+  try {
+    await failAgentTurnSessionRecord({
+      conversationId: args.conversationId,
+      expectedVersion: args.expectedVersion,
+      sessionId: args.sessionId,
+      errorMessage: args.errorMessage
+    });
+  } catch (error) {
+    logException(
+      error,
+      "oauth_callback_session_record_fail_persist_failed",
+      {},
+      {
+        "app.ai.conversation_id": args.conversationId,
+        "app.ai.session_id": args.sessionId
+      },
+      "Failed to mark OAuth-resumed turn session record failed"
+    );
+  }
+}
+async function persistFailedOAuthReplyState(args) {
+  const currentState = await getPersistedThreadState(args.conversationId);
+  const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({
+    conversation,
+    conversationId: args.conversationId
+  });
+  clearPendingAuth(conversation, args.sessionId);
+  markTurnFailed({
+    conversation,
+    nowMs: Date.now(),
+    sessionId: args.sessionId,
+    userMessageId: getTurnUserMessage(conversation, args.sessionId)?.id,
+    markConversationMessage,
+    updateConversationStats
+  });
+  await failSessionRecordBestEffort2({
+    conversationId: args.conversationId,
+    expectedVersion: args.expectedVersion,
+    sessionId: args.sessionId,
+    errorMessage: "OAuth-resumed turn failed"
+  });
+  await persistThreadStateById(args.conversationId, {
+    conversation
+  });
+}
+async function resumeOAuthSessionRecordTurn(stored, options) {
+  if (!stored.resumeConversationId || !stored.resumeSessionId || !stored.channelId || !stored.destination || !stored.source || !stored.threadTs) {
+    return;
+  }
+  const destination = requireSlackDestination(
+    stored.destination,
+    "OAuth resume"
+  );
+  const currentState = await getPersistedThreadState(
+    stored.resumeConversationId
+  );
+  const conversation = coerceThreadConversationState(currentState);
+  await hydrateConversationMessages({
+    conversation,
+    conversationId: stored.resumeConversationId
+  });
+  const pendingAuth = getConversationPendingAuth({
+    conversation,
+    kind: "plugin",
+    provider: stored.provider,
+    actorId: stored.userId,
+    ...stored.scope ? { scope: stored.scope } : {}
+  });
+  const resolvedSessionId = pendingAuth?.sessionId ?? stored.resumeSessionId;
+  const userMessage = resolvedSessionId ? getTurnUserMessage(conversation, resolvedSessionId) : void 0;
+  if (pendingAuth) {
+    if (!isPendingAuthLatestRequest(conversation, pendingAuth)) {
+      clearPendingAuth(conversation, pendingAuth.sessionId);
+      await persistThreadStateById(stored.resumeConversationId, {
+        conversation
+      });
+      await abandonAgentTurnSessionRecord({
+        conversationId: stored.resumeConversationId,
+        sessionId: pendingAuth.sessionId,
+        errorMessage: "Auth completed after a newer thread message abandoned this blocked request."
+      });
+      return;
+    }
+  }
+  const sessionRecord = await getAgentTurnSessionRecord(
+    stored.resumeConversationId,
+    resolvedSessionId
+  );
+  if (!sessionRecord) {
+    return;
+  }
+  if (sessionRecord.state === "completed" || sessionRecord.state === "failed" || sessionRecord.state === "abandoned") {
+    return;
+  }
+  if (sessionRecord.state !== "awaiting_resume" || sessionRecord.resumeReason !== "auth") {
+    return;
+  }
+  if (!userMessage?.author?.userId) {
+    return;
+  }
+  if (!pendingAuth && conversation.processing.activeTurnId !== stored.resumeSessionId) {
+    return;
+  }
+  await resumeSlackTurn({
+    messageText: userMessage.text,
+    conversationId: stored.resumeConversationId,
+    turnId: resolvedSessionId,
+    channelId: stored.channelId,
+    threadTs: stored.threadTs,
+    messageTs: getTurnUserSlackMessageTs(userMessage),
+    lockKey: stored.resumeConversationId,
+    initialText: "",
+    agentRunner: options.agentRunner,
+    beforeStart: async () => {
+      const lockedState = await getPersistedThreadState(
+        stored.resumeConversationId
+      );
+      const lockedConversation = coerceThreadConversationState(lockedState);
+      await hydrateConversationMessages({
+        conversation: lockedConversation,
+        conversationId: stored.resumeConversationId
+      });
+      const lockedArtifacts = coerceThreadArtifactsState(lockedState);
+      const lockedPendingAuth = getConversationPendingAuth({
+        conversation: lockedConversation,
+        kind: "plugin",
+        provider: stored.provider,
+        actorId: stored.userId,
+        ...stored.scope ? { scope: stored.scope } : {}
+      });
+      const lockedSessionId = lockedPendingAuth?.sessionId ?? stored.resumeSessionId;
+      if (lockedSessionId !== resolvedSessionId) {
+        return false;
+      }
+      const lockedSessionRecord = await getAgentTurnSessionRecord(
+        stored.resumeConversationId,
+        lockedSessionId
+      );
+      if (!lockedSessionRecord || lockedSessionRecord.state !== "awaiting_resume" || lockedSessionRecord.resumeReason !== "auth") {
+        return false;
+      }
+      if (lockedPendingAuth) {
+        if (!isPendingAuthLatestRequest(lockedConversation, lockedPendingAuth)) {
+          clearPendingAuth(lockedConversation, lockedPendingAuth.sessionId);
+          await persistThreadStateById(stored.resumeConversationId, {
+            conversation: lockedConversation
+          });
+          await abandonAgentTurnSessionRecord({
+            conversationId: stored.resumeConversationId,
+            sessionId: lockedPendingAuth.sessionId,
+            errorMessage: "Auth completed after a newer thread message abandoned this blocked request."
+          });
+          return false;
+        }
+      } else if (lockedConversation.processing.activeTurnId !== stored.resumeSessionId) {
+        return false;
+      }
+      const lockedUserMessage = getTurnUserMessage(
+        lockedConversation,
+        lockedSessionId
+      );
+      if (!lockedUserMessage?.author?.userId) {
+        return false;
+      }
+      const lockedConversationContext = buildConversationContext(
+        lockedConversation,
+        {
+          excludeMessageId: lockedUserMessage.id
+        }
+      );
+      const lockedChannelConfiguration = getChannelConfigurationServiceById(
+        stored.channelId
+      );
+      let actor;
+      try {
+        actor = createSlackResumeActor({
+          actor: isUserActor(lockedSessionRecord.actor) ? lockedSessionRecord.actor : void 0,
+          teamId: destination.teamId,
+          userId: lockedUserMessage.author.userId
+        });
+      } catch {
+        await failAgentTurnSessionRecord({
+          conversationId: stored.resumeConversationId,
+          expectedVersion: lockedSessionRecord.version,
+          sessionId: lockedSessionId,
+          errorMessage: "Stored Slack actor identity did not match OAuth actor"
+        });
+        return false;
+      }
+      if (!lockedSessionRecord.source) {
+        await failAgentTurnSessionRecord({
+          conversationId: stored.resumeConversationId,
+          expectedVersion: lockedSessionRecord.version,
+          sessionId: lockedSessionId,
+          errorMessage: "Stored Slack source missing for OAuth resume"
+        });
+        return false;
+      }
+      await recordAuthorizationCompleted({
+        conversationId: stored.resumeConversationId,
+        kind: "plugin",
+        provider: stored.provider,
+        actorId: stored.userId,
+        authorizationId: pluginAuthorizationId({
+          provider: stored.provider,
+          sessionId: lockedSessionId
+        })
+      });
+      const lockedMessageTs = getTurnUserSlackMessageTs(lockedUserMessage);
+      return {
+        messageText: lockedUserMessage.text,
+        messageTs: lockedMessageTs,
+        inputMessageIds: [lockedUserMessage.id],
+        replyContext: {
+          input: {
+            conversationContext: lockedConversationContext,
+            // Pi history is SQL-authoritative: the resumed run reads its
+            // session record first and falls back to the step projection.
+            piMessages: await loadProjection({
+              conversationId: stored.resumeConversationId
+            }),
+            ...getTurnUserReplyAttachmentContext(lockedUserMessage)
+          },
+          routing: {
+            credentialContext: {
+              actor: {
+                type: "user",
+                userId: actor.userId
+              }
+            },
+            actor,
+            destination,
+            source: lockedSessionRecord.source,
+            toolChannelId: lockedArtifacts.assistantContextChannelId ?? stored.channelId
+          },
+          policy: {
+            channelConfiguration: lockedChannelConfiguration
+          },
+          state: {
+            artifactState: lockedArtifacts,
+            pendingAuth: lockedPendingAuth,
+            sandboxRef: getPersistedSandboxState(lockedState)
+          },
+          durability: {
+            recordPendingAuth: async (nextPendingAuth) => {
+              lockedConversation.processing.pendingAuth = nextPendingAuth;
+              await persistThreadStateById(stored.resumeConversationId, {
+                conversation: lockedConversation
+              });
+            }
+          }
+        },
+        commitResult: async (reply) => {
+          logInfo(
+            "oauth_callback_resume_complete",
+            {},
+            {
+              "app.credential.provider": stored.provider,
+              "app.ai.outcome": reply.diagnostics.outcome,
+              "app.ai.tool_calls": reply.diagnostics.toolCalls.length
+            },
+            "OAuth callback auto-resumed session record finished replying"
+          );
+          await persistCompletedOAuthReplyState({
+            conversationId: stored.resumeConversationId,
+            sessionId: lockedSessionId,
+            reply
+          });
+        },
+        onPostDeliveryCommitFailure: async () => {
+          await failAgentTurnSessionRecord({
+            conversationId: stored.resumeConversationId,
+            expectedVersion: lockedSessionRecord.version,
+            sessionId: lockedSessionId,
+            errorMessage: "OAuth-resumed reply was delivered but completion state did not persist"
+          });
+        },
+        onFailure: async () => {
+          await persistFailedOAuthReplyState({
+            conversationId: stored.resumeConversationId,
+            expectedVersion: lockedSessionRecord.version,
+            sessionId: lockedSessionId
+          });
+        },
+        onAuthPause: async () => {
+          await persistAuthPauseTurnState({
+            sessionId: lockedSessionId,
+            threadStateId: stored.resumeConversationId
+          });
+        },
+        onSuspend: async (resumeVersion) => {
+          await scheduleAgentContinue({
+            conversationId: stored.resumeConversationId,
+            destination,
+            sessionId: lockedSessionId,
+            expectedVersion: resumeVersion
+          });
+        }
+      };
+    }
+  });
+}
+async function GET2(request, provider, waitUntil, options) {
+  const localRelay = await relayLocalOAuthCallback(request);
+  if (localRelay) {
+    return localRelay;
+  }
+  const providerConfig = pluginCatalogRuntime.getOAuthConfig(provider);
+  if (!providerConfig) {
+    return htmlErrorResponse(
+      "Unknown provider",
+      "The OAuth provider in this link is not recognized.",
+      404
+    );
+  }
+  const providerLabel = formatProviderLabel(provider);
+  const url = new URL(request.url);
+  const errorParam = url.searchParams.get("error");
+  const code = url.searchParams.get("code");
+  const state = url.searchParams.get("state");
+  if (errorParam) {
+    if (state) {
+      const cleanupAdapter = getStateAdapter();
+      await cleanupAdapter.delete(`oauth-state:${state}`);
+    }
+    if (errorParam === "access_denied") {
+      return htmlErrorResponse(
+        "Authorization declined",
+        `You declined the ${providerLabel} authorization request. Return to Junior and connect your ${providerLabel} account again if you change your mind.`,
+        400
+      );
+    }
+    return htmlErrorResponse(
+      "Authorization failed",
+      `${providerLabel} returned an error: ${errorParam}. Return to Junior and try again.`,
+      400
+    );
+  }
+  if (!code || !state) {
+    return htmlErrorResponse(
+      "Invalid request",
+      "This authorization link is missing required parameters.",
+      400
+    );
+  }
+  const stateAdapter = getStateAdapter();
+  const stateKey = `oauth-state:${state}`;
+  const stored = parseOAuthStatePayload(await stateAdapter.get(stateKey));
+  if (!stored) {
+    return htmlErrorResponse(
+      "Link expired",
+      `This authorization link has expired (links are valid for 10 minutes). Return to Junior and connect your ${providerLabel} account again to get a new link.`,
+      400
+    );
+  }
+  if (stored.provider !== provider) {
+    return htmlErrorResponse(
+      "Provider mismatch",
+      "This authorization link does not match the expected provider.",
+      400
+    );
+  }
+  await stateAdapter.delete(stateKey);
+  const clientId = process.env[providerConfig.clientIdEnv]?.trim();
+  const clientSecret = process.env[providerConfig.clientSecretEnv]?.trim();
+  if (!clientId || !clientSecret) {
+    return htmlErrorResponse(
+      "Configuration error",
+      "OAuth client credentials are not configured on the server.",
+      500
+    );
+  }
+  const baseUrl = resolveBaseUrl();
+  if (!baseUrl) {
+    return htmlErrorResponse(
+      "Configuration error",
+      "The server cannot determine its base URL.",
+      500
+    );
+  }
+  const redirectUri = `${baseUrl}${providerConfig.callbackPath}`;
+  const requestedScope = stored.scope ?? providerConfig.scope;
+  let tokenResponse;
+  try {
+    const tokenRequest = buildOAuthTokenRequest({
+      clientId,
+      clientSecret,
+      payload: {
+        grant_type: "authorization_code",
+        code,
+        redirect_uri: redirectUri
+      },
+      tokenAuthMethod: providerConfig.tokenAuthMethod,
+      tokenExtraHeaders: providerConfig.tokenExtraHeaders
+    });
+    tokenResponse = await fetch(providerConfig.tokenEndpoint, {
+      method: "POST",
+      headers: tokenRequest.headers,
+      body: tokenRequest.body
+    });
+  } catch {
+    return htmlErrorResponse(
+      "Connection failed",
+      "Failed to exchange the authorization code. Please try again.",
+      500
+    );
+  }
+  if (!tokenResponse.ok) {
+    return htmlErrorResponse(
+      "Connection failed",
+      "The token exchange with the provider failed. Please try again.",
+      500
+    );
+  }
+  let parsedTokenResponse;
+  try {
+    const tokenData = await tokenResponse.json();
+    parsedTokenResponse = parseOAuthTokenResponse(tokenData, requestedScope, {
+      treatEmptyScopeAsUnreported: providerConfig.treatEmptyScopeAsUnreported
+    });
+  } catch {
+    return htmlErrorResponse(
+      "Connection failed",
+      "The provider returned an incomplete token response. Please try again.",
+      500
+    );
+  }
+  if (!hasRequiredOAuthScope(parsedTokenResponse.scope, requestedScope)) {
+    return htmlErrorResponse(
+      "Connection failed",
+      `The ${providerLabel} authorization did not grant the access Junior requires. Return to Junior and connect your ${providerLabel} account again.`,
+      400
+    );
+  }
+  const userTokenStore = createUserTokenStore();
+  let account;
+  try {
+    account = await resolvePluginOAuthAccount({
+      provider,
+      tokens: parsedTokenResponse
+    });
+  } catch {
+    return htmlErrorResponse(
+      "Connection failed",
+      `Junior could not verify the connected ${providerLabel} account. Please try again.`,
+      500
+    );
+  }
+  await userTokenStore.set(stored.userId, provider, {
+    ...parsedTokenResponse,
+    ...account ? { account } : {}
+  });
+  if (stored.destination?.platform !== "local") {
+    waitUntil(async () => {
+      try {
+        await publishAppHomeView(
+          getSlackClient(),
+          stored.userId,
+          userTokenStore
+        );
+      } catch {
+      }
+    });
+  }
+  const resumesAgentTurn = Boolean(
+    stored.destination?.platform !== "local" && stored.resumeConversationId && stored.resumeSessionId
+  );
+  if (resumesAgentTurn) {
+    waitUntil(async () => {
+      try {
+        await resumeOAuthSessionRecordTurn(stored, options);
+      } catch (error) {
+        if (error instanceof ResumeTurnBusyError) {
+          logWarn(
+            "oauth_callback_resume_busy",
+            {
+              ...stored.resumeConversationId && {
+                conversationId: stored.resumeConversationId
+              },
+              ...stored.userId && { actorId: stored.userId },
+              ...stored.channelId && { channelId: stored.channelId }
+            },
+            {
+              "app.credential.provider": stored.provider,
+              ...stored.resumeSessionId && {
+                "app.ai.session_id": stored.resumeSessionId
+              }
+            },
+            "OAuth callback resume was busy; user must send another message to continue"
+          );
+          return;
+        }
+        throw error;
+      }
+    });
+  } else if (stored.channelId && stored.threadTs) {
+    const { channelId, threadTs } = stored;
+    waitUntil(
+      () => postSlackMessage({
+        channelId,
+        threadTs,
+        text: `Your ${providerLabel} account is now connected. You can start using ${providerLabel} commands.`
+      })
+    );
+  }
+  const statusMessage = stored.destination?.platform === "local" ? "Your request is continuing in the local Junior client." : resumesAgentTurn ? "Your request is being processed in Slack." : "You can close this tab and return to Slack.";
+  const html = `<!DOCTYPE html>
+<html>
+<head><title>${providerLabel} Connected</title></head>
+<body style="font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0;">
+  <div style="text-align: center;">
+    <h1>${providerLabel} account connected</h1>
+    <p>${statusMessage}</p>
+  </div>
+</body>
+</html>`;
+  return new Response(html, {
+    status: 200,
+    headers: { "Content-Type": "text/html; charset=utf-8" }
+  });
+}
+
+// src/chat/local/credential-sync.ts
+import { createHmac, createSecretKey, timingSafeEqual } from "crypto";
+import {
+  pluginStoredTokensSchema
+} from "@sentry/junior-plugin-api";
+import { z as z2 } from "zod";
+var LOCAL_CREDENTIAL_SYNC_CONTEXT = "junior.local-credential-sync.v1";
+var LOCAL_CREDENTIAL_SYNC_MAX_AGE_MS = 6e4;
+var localCredentialSyncSchema = z2.object({
+  createdAtMs: z2.number().finite(),
+  provider: z2.string().regex(/^[a-z][a-z0-9-]*$/),
+  tokens: pluginStoredTokensSchema
+}).strict();
+function syncSecret() {
+  const secret = process.env.JUNIOR_SECRET?.trim();
+  if (!secret) {
+    throw new Error("Local credential sync requires JUNIOR_SECRET");
+  }
+  return secret;
+}
+function signature(body) {
+  const signingKey = createSecretKey(Buffer.from(syncSecret(), "utf8"));
+  return createHmac("sha256", signingKey).update(`${LOCAL_CREDENTIAL_SYNC_CONTEXT}:${body}`).digest("base64url");
+}
+function signaturesMatch(expected, actual) {
+  const expectedBuffer = Buffer.from(expected);
+  const actualBuffer = Buffer.from(actual);
+  return expectedBuffer.length === actualBuffer.length && timingSafeEqual(expectedBuffer, actualBuffer);
+}
+async function syncLocalOAuthCredential(provider, tokens) {
+  const body = JSON.stringify({
+    createdAtMs: Date.now(),
+    provider,
+    tokens
+  });
+  const port = process.env.PORT?.trim() || "3000";
+  const response = await fetch(
+    `http://127.0.0.1:${port}/api/internal/local-oauth-credentials`,
+    {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-junior-local-credential-signature": signature(body)
+      },
+      body
+    }
+  );
+  if (!response.ok) {
+    throw new Error(
+      `Could not sync local OAuth credential: HTTP ${response.status}`
+    );
+  }
+}
+async function receiveLocalOAuthCredential(request) {
+  const hostname = new URL(request.url).hostname;
+  if (process.env.NODE_ENV !== "development" || hostname !== "127.0.0.1" && hostname !== "localhost") {
+    return new Response(null, { status: 404 });
+  }
+  const body = await request.text();
+  const actualSignature = request.headers.get(
+    "x-junior-local-credential-signature"
+  );
+  if (!actualSignature || !signaturesMatch(signature(body), actualSignature)) {
+    return Response.json({ error: "Unauthorized" }, { status: 401 });
+  }
+  let value;
+  try {
+    value = JSON.parse(body);
+  } catch {
+    return Response.json({ error: "Invalid request" }, { status: 400 });
+  }
+  const payload = localCredentialSyncSchema.safeParse(value);
+  if (!payload.success || Math.abs(Date.now() - payload.data.createdAtMs) > LOCAL_CREDENTIAL_SYNC_MAX_AGE_MS) {
+    return Response.json({ error: "Invalid request" }, { status: 400 });
+  }
+  await createUserTokenStore().set(
+    "local-cli",
+    payload.data.provider,
+    payload.data.tokens
+  );
+  return new Response(null, { status: 204 });
+}
+
+export {
+  sendSlackReply,
+  getSlackApiErrorCode,
+  getSlackErrorObservabilityAttributes,
+  isRetryableSlackPostError,
+  isSlackTitlePermissionError,
+  isInvalidConversationRecordError,
+  CONVERSATION_WORK_CHECK_IN_INTERVAL_MS,
+  CONVERSATION_WORK_STALE_ENQUEUE_MS,
+  isFinalAttempt,
+  getConversationWorkState2 as getConversationWorkState,
+  countPendingConversationMessages,
+  hasRunnableConversationWork,
+  ensureConversationWake,
+  appendAndEnqueueInboundMessage,
+  clearConsumedConversationWake2 as clearConsumedConversationWake,
+  startConversationWork2 as startConversationWork,
+  checkInConversationWork2 as checkInConversationWork,
+  drainConversationMailbox2 as drainConversationMailbox,
+  ackMessages2 as ackMessages,
+  requestConversationContinuation2 as requestConversationContinuation,
+  beginConversationResume2 as beginConversationResume,
+  releaseConversationWork2 as releaseConversationWork,
+  completeConversationWork2 as completeConversationWork,
+  recordAttemptFailure2 as recordAttemptFailure,
+  deadLetterAttempt2 as deadLetterAttempt,
+  clearExpiredConversationLease2 as clearExpiredConversationLease,
+  removeActiveConversation2 as removeActiveConversation,
+  listActiveConversationIds2 as listActiveConversationIds,
+  createSlackAdapterAssistantStatusSession,
+  stripLeadingBotMention,
+  getThreadId,
+  getRunId,
+  getChannelId,
+  getThreadTs,
+  getAssistantThreadContext,
+  getMessageTs,
+  shouldKeepProcessingReactionForToolInvocation,
+  startSlackProcessingReaction,
+  buildAuthPauseResponse,
+  getTurnRequestDeadline,
+  runWithTurnRequestDeadline,
+  ResumeTurnBusyError,
+  resumeSlackTurn,
+  getAwaitingAgentContinueRequest,
+  scheduleAgentContinue,
+  GET,
+  publishAppHomeView,
+  GET2,
+  syncLocalOAuthCredential,
+  receiveLocalOAuthCredential
+};