@sentry/junior 0.43.0 → 0.45.0

package/dist/app.js

@@ -31,7 +31,7 @@ import {
   runNonInteractiveCommand,
   sandboxSkillDir,
   sandboxSkillFile
-} from "./chunk-YSXHRIWR.js";
+} from "./chunk-QAMTCT2R.js";
 import {
   CredentialUnavailableError,
   buildOAuthTokenRequest,
@@ -1274,6 +1274,37 @@ async function addReactionToMessage(input) {
   }
   return { ok: true };
 }
+async function removeReactionFromMessage(input) {
+  const channelId = requireSlackConversationId(
+    input.channelId,
+    "Slack reaction removal"
+  );
+  const timestamp = requireSlackMessageTimestamp(
+    input.timestamp,
+    "Slack reaction removal"
+  );
+  const emoji = normalizeSlackEmojiName(input.emoji);
+  if (!emoji) {
+    throw new Error("Slack reaction removal requires a valid emoji alias name");
+  }
+  try {
+    await withSlackRetries(
+      () => getSlackClient().reactions.remove({
+        channel: channelId,
+        timestamp,
+        name: emoji
+      }),
+      3,
+      { action: "reactions.remove" }
+    );
+  } catch (error) {
+    if (error instanceof SlackActionError && error.code === "no_reaction") {
+      return { ok: true };
+    }
+    throw error;
+  }
+  return { ok: true };
+}
 
 // src/chat/oauth-flow.ts
 var OAUTH_STATE_TTL_MS = 10 * 60 * 1e3;
@@ -8622,26 +8653,28 @@ function resolveSandboxEgressProviderForHost(host) {
     (entry) => entry.domains.some((domain) => matchesSandboxEgressDomain(host, domain))
   )?.provider;
 }
-function proxyUrl(sandboxId) {
+function proxyUrl(egressId) {
   const baseUrl = resolveBaseUrl();
   if (!baseUrl) {
     return void 0;
   }
   const url = new URL(
-    `${SANDBOX_EGRESS_PROXY_PATH}/${encodeURIComponent(sandboxId)}`,
+    `${SANDBOX_EGRESS_PROXY_PATH}/${encodeURIComponent(egressId)}`,
     baseUrl
   );
   return url.toString();
 }
-function buildSandboxEgressNetworkPolicy(sandboxId) {
-  const forwardURL = proxyUrl(sandboxId);
-  if (!forwardURL) {
-    return void 0;
-  }
+function buildSandboxEgressNetworkPolicy(egressId) {
   const entries = providerEntries();
   if (entries.length === 0) {
     return void 0;
   }
+  const forwardURL = proxyUrl(egressId);
+  if (!forwardURL) {
+    throw new Error(
+      "Cannot determine base URL for sandbox credential egress (set JUNIOR_BASE_URL or deploy to Vercel)"
+    );
+  }
   const allow = {
     "*": []
   };
@@ -8671,11 +8704,11 @@ import { randomUUID as randomUUID3 } from "crypto";
 var SANDBOX_EGRESS_SESSION_PREFIX = "sandbox-egress-session";
 var SANDBOX_EGRESS_LEASE_PREFIX = "sandbox-egress-lease";
 var DEFAULT_SESSION_TTL_MS = 30 * 60 * 1e3;
-function sessionKey2(sandboxId) {
-  return `${SANDBOX_EGRESS_SESSION_PREFIX}:${sandboxId}`;
+function sessionKey2(egressId) {
+  return `${SANDBOX_EGRESS_SESSION_PREFIX}:${egressId}`;
 }
-function leaseKey(sandboxId, provider, session) {
-  return `${SANDBOX_EGRESS_LEASE_PREFIX}:${sandboxId}:${provider}:${session.requesterId}:${session.activationId}`;
+function leaseKey(egressId, provider, session) {
+  return `${SANDBOX_EGRESS_LEASE_PREFIX}:${egressId}:${provider}:${session.requesterId}:${session.activationId}`;
 }
 function parseSession(value) {
   if (!value || typeof value !== "object") {
@@ -8730,19 +8763,19 @@ async function upsertSandboxEgressSession(input) {
     expiresAtMs: now + ttlMs,
     activationId: randomUUID3()
   };
-  await state.set(sessionKey2(input.sandboxId), session, ttlMs);
+  await state.set(sessionKey2(input.egressId), session, ttlMs);
 }
-async function clearSandboxEgressSession(sandboxId) {
+async function clearSandboxEgressSession(egressId) {
   const state = getStateAdapter();
   await state.connect();
-  await state.delete(sessionKey2(sandboxId));
+  await state.delete(sessionKey2(egressId));
 }
-async function getSandboxEgressSession(sandboxId) {
+async function getSandboxEgressSession(egressId) {
   const state = getStateAdapter();
   await state.connect();
-  return parseSession(await state.get(sessionKey2(sandboxId)));
+  return parseSession(await state.get(sessionKey2(egressId)));
 }
-async function setSandboxEgressCredentialLease(sandboxId, session, lease) {
+async function setSandboxEgressCredentialLease(egressId, session, lease) {
   const leaseExpiresAtMs = Date.parse(lease.expiresAt);
   if (!Number.isFinite(leaseExpiresAtMs) || leaseExpiresAtMs <= Date.now()) {
     return;
@@ -8753,17 +8786,17 @@ async function setSandboxEgressCredentialLease(sandboxId, session, lease) {
   );
   const state = getStateAdapter();
   await state.connect();
-  await state.set(leaseKey(sandboxId, lease.provider, session), lease, ttlMs);
+  await state.set(leaseKey(egressId, lease.provider, session), lease, ttlMs);
 }
-async function getSandboxEgressCredentialLease(sandboxId, provider, session) {
+async function getSandboxEgressCredentialLease(egressId, provider, session) {
   const state = getStateAdapter();
   await state.connect();
-  return parseLease(await state.get(leaseKey(sandboxId, provider, session)));
+  return parseLease(await state.get(leaseKey(egressId, provider, session)));
 }
-async function clearSandboxEgressCredentialLease(sandboxId, provider, session) {
+async function clearSandboxEgressCredentialLease(egressId, provider, session) {
   const state = getStateAdapter();
   await state.connect();
-  await state.delete(leaseKey(sandboxId, provider, session));
+  await state.delete(leaseKey(egressId, provider, session));
 }
 
 // src/chat/sandbox/http-error-details.ts
@@ -9620,10 +9653,10 @@ function createSandboxSessionManager(options) {
     appliedNetworkPolicyKey = void 0;
   };
   const createSandboxName = () => `${SANDBOX_NAME_PREFIX}${randomUUID4()}`;
-  const rememberNetworkPolicy = (networkPolicy) => {
-    appliedNetworkPolicyKey = networkPolicy ? JSON.stringify(networkPolicy) : void 0;
+  const preflightNetworkPolicy = (sandboxName) => {
+    return options?.createNetworkPolicy?.(sandboxName);
   };
-  const rememberSandbox = async (nextSandbox, rememberOptions) => {
+  const rememberSandbox = async (nextSandbox) => {
     sandbox = nextSandbox;
     sandboxIdHint = nextSandbox.sandboxId;
     toolExecutors = void 0;
@@ -9632,11 +9665,6 @@ function createSandboxSessionManager(options) {
       ...dependencyProfileHash ? { sandboxDependencyProfileHash: dependencyProfileHash } : {}
     };
     await options?.onSandboxAcquired?.(acquired);
-    if (rememberOptions?.recordNetworkPolicy) {
-      rememberNetworkPolicy(
-        options?.createNetworkPolicy?.(nextSandbox.sandboxId)
-      );
-    }
     return nextSandbox;
   };
   const failSetup = (error) => {
@@ -9653,7 +9681,7 @@ function createSandboxSessionManager(options) {
   };
   const refreshNetworkPolicy = async (targetSandbox) => {
     const networkPolicy = options?.createNetworkPolicy?.(
-      targetSandbox.sandboxId
+      targetSandbox.sandboxEgressId
     );
     if (!networkPolicy) {
       return;
@@ -9709,7 +9737,7 @@ function createSandboxSessionManager(options) {
   const createSandboxFromSnapshot = async (snapshotId, sandboxCredentials, initialSandboxName) => {
     for (let attempt = 0; attempt < SNAPSHOT_BOOT_RETRY_COUNT; attempt += 1) {
       const sandboxName = attempt === 0 ? initialSandboxName : createSandboxName();
-      const networkPolicy = options?.createNetworkPolicy?.(sandboxName);
+      const networkPolicy = preflightNetworkPolicy(sandboxName);
       try {
         return createSandboxInstance(
           await Sandbox.create({
@@ -9748,7 +9776,7 @@ function createSandboxSessionManager(options) {
   const createSandboxFromResolvedSnapshot = async (params) => {
     const { runtime, snapshot, sandboxCredentials, sandboxName } = params;
     if (!snapshot.snapshotId) {
-      const networkPolicy = options?.createNetworkPolicy?.(sandboxName);
+      const networkPolicy = preflightNetworkPolicy(sandboxName);
       return createSandboxInstance(
         await Sandbox.create({
           timeout: timeoutMs,
@@ -9819,11 +9847,12 @@ function createSandboxSessionManager(options) {
       return failSetup(error);
     }
     try {
+      await refreshNetworkPolicy(createdSandbox);
       await syncSkills(createdSandbox);
     } catch (error) {
       return failSetup(error);
     }
-    return await rememberSandbox(createdSandbox, { recordNetworkPolicy: true });
+    return await rememberSandbox(createdSandbox);
   };
   const discardHintIfProfileChanged = () => {
     if (sandbox || !sandboxIdHint || dependencyProfileHash === options?.sandboxDependencyProfileHash) {
@@ -9976,7 +10005,8 @@ function createSandboxSessionManager(options) {
     }
     return {
       bash: async (input) => {
-        await options?.beforeCommand?.(activeSandboxId);
+        const commandEgressId = sandboxInstance.sandboxEgressId;
+        await options?.beforeCommand?.(commandEgressId);
         let timedOut = false;
         let timeoutId;
         let commandFinished = false;
@@ -9985,7 +10015,7 @@ function createSandboxSessionManager(options) {
             return;
           }
           commandFinished = true;
-          await options?.afterCommand?.(activeSandboxId);
+          await options?.afterCommand?.(commandEgressId);
         };
         const finishCommandBestEffort = async () => {
           try {
@@ -10126,15 +10156,15 @@ function createSandboxExecutor(options) {
   let referenceFiles = [];
   const traceContext = options?.traceContext ?? {};
   const credentialEgress = options?.credentialEgress;
-  const syncSandboxEgressSession = credentialEgress ? async (sandboxId) => {
+  const syncSandboxEgressSession = credentialEgress ? async (egressId) => {
     await upsertSandboxEgressSession({
-      sandboxId,
+      egressId,
       requesterId: credentialEgress.requesterId,
       ttlMs: options?.timeoutMs
     });
   } : void 0;
-  const clearSandboxEgressSessionForCommand = credentialEgress ? async (sandboxId) => {
-    await clearSandboxEgressSession(sandboxId);
+  const clearSandboxEgressSessionForCommand = credentialEgress ? async (egressId) => {
+    await clearSandboxEgressSession(egressId);
   } : void 0;
   const sessionManager = createSandboxSessionManager({
     sandboxId: options?.sandboxId,
@@ -10621,77 +10651,468 @@ function normalizeToolResult(result, isSandboxResult) {
   };
 }
 
-// src/chat/tools/execution/tool-error-handler.ts
-function getToolErrorAttributes(error) {
-  if (!(error instanceof SlackActionError)) {
-    return {};
+// src/chat/credentials/unlink-provider.ts
+async function unlinkProvider(userId, provider, userTokenStore) {
+  await Promise.all([
+    userTokenStore.delete(userId, provider),
+    deleteMcpStoredOAuthCredentials(userId, provider),
+    deleteMcpServerSessionId(userId, provider),
+    deleteMcpAuthSessionsForUserProvider(userId, provider)
+  ]);
+}
+
+// src/chat/state/turn-session-store.ts
+var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
+var AGENT_TURN_SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
+function agentTurnSessionKey(conversationId, sessionId) {
+  return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
+}
+function parseAgentTurnSessionCheckpoint(value) {
+  if (typeof value !== "string") {
+    return void 0;
   }
-  return {
-    "app.slack.error_code": error.code,
-    ...error.apiError ? { "app.slack.api_error": error.apiError } : {},
-    ...error.detail ? { "app.slack.detail": error.detail } : {},
-    ...error.detailLine !== void 0 ? { "app.slack.detail_line": error.detailLine } : {},
-    ...error.detailRule ? { "app.slack.detail_rule": error.detailRule } : {}
+  try {
+    const parsed = JSON.parse(value);
+    if (!isRecord(parsed)) {
+      return void 0;
+    }
+    const status = parsed.state;
+    if (status !== "running" && status !== "awaiting_resume" && status !== "completed" && status !== "failed" && status !== "superseded") {
+      return void 0;
+    }
+    const conversationId = parsed.conversationId;
+    const sessionId = parsed.sessionId;
+    const sliceId = parsed.sliceId;
+    const checkpointVersion = parsed.checkpointVersion;
+    const updatedAtMs = parsed.updatedAtMs;
+    if (typeof conversationId !== "string" || typeof sessionId !== "string" || typeof sliceId !== "number" || typeof checkpointVersion !== "number" || typeof updatedAtMs !== "number") {
+      return void 0;
+    }
+    return {
+      checkpointVersion,
+      conversationId,
+      sessionId,
+      sliceId,
+      state: status,
+      updatedAtMs,
+      piMessages: Array.isArray(parsed.piMessages) ? parsed.piMessages : [],
+      ...Array.isArray(parsed.loadedSkillNames) ? {
+        loadedSkillNames: parsed.loadedSkillNames.filter(
+          (value2) => typeof value2 === "string"
+        )
+      } : {},
+      ...parsed.resumeReason === "timeout" || parsed.resumeReason === "auth" ? { resumeReason: parsed.resumeReason } : {},
+      ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {},
+      ...typeof parsed.resumedFromSliceId === "number" ? { resumedFromSliceId: parsed.resumedFromSliceId } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function getAgentTurnSessionCheckpoint(conversationId, sessionId) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const value = await stateAdapter.get(
+    agentTurnSessionKey(conversationId, sessionId)
+  );
+  return parseAgentTurnSessionCheckpoint(value);
+}
+async function upsertAgentTurnSessionCheckpoint(args) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const existing = await getAgentTurnSessionCheckpoint(
+    args.conversationId,
+    args.sessionId
+  );
+  const checkpoint = {
+    checkpointVersion: (existing?.checkpointVersion ?? 0) + 1,
+    conversationId: args.conversationId,
+    sessionId: args.sessionId,
+    sliceId: args.sliceId,
+    state: args.state,
+    updatedAtMs: Date.now(),
+    piMessages: Array.isArray(args.piMessages) ? args.piMessages : [],
+    ...Array.isArray(args.loadedSkillNames) ? {
+      loadedSkillNames: args.loadedSkillNames.filter(
+        (value) => typeof value === "string"
+      )
+    } : {},
+    ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
+    ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
+    ...typeof args.resumedFromSliceId === "number" ? { resumedFromSliceId: args.resumedFromSliceId } : {}
   };
+  const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
+  await stateAdapter.set(
+    agentTurnSessionKey(args.conversationId, args.sessionId),
+    JSON.stringify(checkpoint),
+    ttlMs
+  );
+  return checkpoint;
 }
-function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, traceContext) {
-  const errorType = getMcpAwareErrorType(error, "tool_execution_error");
-  const errorMessage = getMcpAwareErrorMessage(error);
-  setSpanAttributes({
-    "error.type": errorType
+async function supersedeAgentTurnSessionCheckpoint(args) {
+  const existing = await getAgentTurnSessionCheckpoint(
+    args.conversationId,
+    args.sessionId
+  );
+  if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "superseded") {
+    return void 0;
+  }
+  return await upsertAgentTurnSessionCheckpoint({
+    conversationId: existing.conversationId,
+    sessionId: existing.sessionId,
+    sliceId: existing.sliceId,
+    state: "superseded",
+    piMessages: existing.piMessages,
+    loadedSkillNames: existing.loadedSkillNames,
+    resumeReason: existing.resumeReason,
+    resumedFromSliceId: existing.resumedFromSliceId,
+    errorMessage: args.errorMessage ?? existing.errorMessage
   });
-  if (shouldTrace) {
-    logWarn(
-      "agent_tool_call_failed",
-      traceContext,
-      {
-        "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
-        "gen_ai.operation.name": "execute_tool",
-        "gen_ai.tool.name": toolName,
-        ...toolCallId ? { "gen_ai.tool.call.id": toolCallId } : {},
-        "error.type": errorType,
-        "exception.message": errorMessage
-      },
-      "Agent tool call failed"
-    );
+}
+
+// src/chat/services/pending-auth.ts
+var AUTH_LINK_REUSE_WINDOW_MS = 10 * 60 * 1e3;
+function canReusePendingAuthLink(args) {
+  const { pendingAuth } = args;
+  if (!pendingAuth) {
+    return false;
   }
-  if (!(error instanceof McpToolError)) {
-    logException(
-      error,
-      "agent_tool_call_failed",
-      {},
-      {
-        "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
-        "gen_ai.operation.name": "execute_tool",
-        "gen_ai.tool.name": toolName,
-        ...toolCallId ? { "gen_ai.tool.call.id": toolCallId } : {},
-        ...getToolErrorAttributes(error)
-      },
-      "Agent tool call failed"
-    );
+  return pendingAuth.kind === args.kind && pendingAuth.provider === args.provider && pendingAuth.requesterId === args.requesterId && pendingAuth.linkSentAtMs + AUTH_LINK_REUSE_WINDOW_MS > (args.nowMs ?? Date.now());
+}
+function getConversationPendingAuth(args) {
+  const pendingAuth = args.conversation.processing.pendingAuth;
+  if (!pendingAuth) {
+    return void 0;
   }
-  throw error;
+  if (pendingAuth.kind !== args.kind || pendingAuth.provider !== args.provider || pendingAuth.requesterId !== args.requesterId) {
+    return void 0;
+  }
+  return pendingAuth;
+}
+function clearPendingAuth(conversation, sessionId) {
+  if (!conversation.processing.pendingAuth) {
+    return;
+  }
+  if (sessionId && conversation.processing.pendingAuth.sessionId !== sessionId) {
+    return;
+  }
+  conversation.processing.pendingAuth = void 0;
+}
+async function applyPendingAuthUpdate(args) {
+  const previousPendingAuth = args.conversation.processing.pendingAuth;
+  args.conversation.processing.pendingAuth = args.nextPendingAuth;
+  if (previousPendingAuth && previousPendingAuth.sessionId !== args.nextPendingAuth.sessionId && args.conversationId) {
+    await supersedeAgentTurnSessionCheckpoint({
+      conversationId: args.conversationId,
+      sessionId: previousPendingAuth.sessionId,
+      errorMessage: "Superseded by a newer auth-blocked request in the same conversation."
+    });
+  }
+}
+function isPendingAuthLatestRequest(conversation, pendingAuth) {
+  for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
+    const message = conversation.messages[index];
+    if (message?.role !== "user") {
+      continue;
+    }
+    return buildDeterministicTurnId(message.id) === pendingAuth.sessionId;
+  }
+  return false;
 }
 
-// src/chat/tools/agent-tools.ts
-function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor, pluginAuthOrchestration, onToolCall) {
-  const shouldTrace = shouldEmitDevAgentTrace();
-  return Object.entries(tools).map(([toolName, toolDef]) => ({
-    name: toolName,
-    label: toolName,
-    description: toolDef.description,
-    parameters: toolDef.inputSchema,
-    prepareArguments: toolDef.prepareArguments,
-    executionMode: toolDef.executionMode,
-    execute: async (toolCallId, params) => {
-      const normalizedToolCallId = typeof toolCallId === "string" && toolCallId.length > 0 ? toolCallId : void 0;
-      const toolArgumentsAttribute = serializeGenAiAttribute(params);
-      if (toolName === "reportProgress") {
-        const status = buildReportedProgressStatus(params);
-        if (status) {
-          await onStatus?.(status);
-        }
-      }
+// src/chat/services/plugin-auth-orchestration.ts
+var PluginAuthorizationPauseError = class extends AuthorizationPauseError {
+  constructor(provider, disposition) {
+    super("plugin", provider, disposition);
+  }
+};
+var PluginCredentialFailureError = class extends Error {
+  provider;
+  constructor(provider, message) {
+    super(message);
+    this.name = "PluginCredentialFailureError";
+    this.provider = provider;
+  }
+};
+function isCommandAuthFailure(details) {
+  if (!details || typeof details !== "object") {
+    return false;
+  }
+  const result = details;
+  if (typeof result.exit_code !== "number" || result.exit_code === 0) {
+    return false;
+  }
+  const text = `${typeof result.stdout === "string" ? result.stdout : ""}
+${typeof result.stderr === "string" ? result.stderr : ""}`.toLowerCase();
+  if (!text.trim()) {
+    return false;
+  }
+  return [
+    /\bjunior-auth-required\b/,
+    /\b401\b/,
+    /\bunauthorized\b/,
+    /\bbad credentials\b/,
+    /\binvalid token\b/,
+    /\bgithub_token\b.*\binvalid\b/,
+    /\btoken (?:expired|revoked)\b/,
+    /\bexpired token\b/,
+    /\bmissing scopes?\b/,
+    /\binsufficient scope\b/,
+    /\binvalid grant\b/,
+    /\breauthoriz/
+  ].some((pattern) => pattern.test(text));
+}
+function commandText(details) {
+  if (!details || typeof details !== "object") {
+    return "";
+  }
+  const result = details;
+  return `${typeof result.stdout === "string" ? result.stdout : ""}
+${typeof result.stderr === "string" ? result.stderr : ""}`;
+}
+function isGitHubSmartHttpAuthFailure(provider, command, details) {
+  if (provider !== "github" || !/^\s*(?:gh|git)\b/i.test(command)) {
+    return false;
+  }
+  const text = commandText(details).toLowerCase();
+  return /\bgzip:\s*invalid header\b/.test(text);
+}
+function explicitAuthRequiredProvider(details) {
+  const match = /\bjunior-auth-required\s+provider=([a-z0-9-]+)\b/.exec(
+    commandText(details).toLowerCase()
+  );
+  return match?.[1];
+}
+function registeredProviderNames() {
+  const providers = /* @__PURE__ */ new Set();
+  for (const plugin of getPluginProviders()) {
+    const domains = [
+      ...plugin.manifest.credentials?.domains ?? [],
+      ...plugin.manifest.domains ?? []
+    ];
+    if (domains.length > 0) {
+      providers.add(plugin.manifest.name);
+    }
+  }
+  return [...providers].sort((left, right) => left.localeCompare(right));
+}
+function commandTargetsProvider(provider, command, details) {
+  const normalizedCommand = command.trim().toLowerCase();
+  if (!normalizedCommand) {
+    return false;
+  }
+  if (provider === "github" && /^(gh|git)\b/.test(normalizedCommand)) {
+    return true;
+  }
+  const plugin = getPluginDefinition(provider);
+  const candidates = /* @__PURE__ */ new Set([provider.toLowerCase()]);
+  const manifest = plugin?.manifest;
+  const credentials = manifest?.credentials;
+  if (credentials) {
+    candidates.add(credentials.authTokenEnv.toLowerCase());
+    for (const domain of credentials.domains) {
+      candidates.add(domain.toLowerCase());
+    }
+  }
+  for (const domain of manifest?.domains ?? []) {
+    candidates.add(domain.toLowerCase());
+  }
+  const combinedText = `${normalizedCommand}
+${commandText(details).toLowerCase()}`;
+  return [...candidates].some((candidate) => combinedText.includes(candidate));
+}
+function formatCommand(command) {
+  const collapsed = command.replace(/\s+/g, " ").trim();
+  return collapsed.length > 160 ? `${collapsed.slice(0, 157)}...` : collapsed;
+}
+function buildCredentialFailureError(provider, command) {
+  const providerLabel = provider === "github" ? "GitHub" : formatProviderLabel(provider);
+  const plugin = getPluginDefinition(provider);
+  const credentialType = plugin?.manifest.credentials?.type;
+  const commandSummary = formatCommand(command);
+  const remediation = provider === "github" && credentialType === "github-app" ? "Verify the GitHub App installation covers the target repository and the host GitHub App environment variables are current." : `Verify the ${providerLabel} provider credentials before retrying.`;
+  return new PluginCredentialFailureError(
+    provider,
+    `${providerLabel} credentials were rejected while running \`${commandSummary}\`. ${remediation}`
+  );
+}
+function createPluginAuthOrchestration(deps, abortAgent) {
+  let pendingPause;
+  const startAuthorizationPause = async (provider, activeSkill, options) => {
+    if (pendingPause) {
+      throw pendingPause;
+    }
+    if (!deps.requesterId || !getPluginOAuthConfig(provider)) {
+      throw new Error(`Cannot start plugin authorization for ${provider}`);
+    }
+    const providerLabel = formatProviderLabel(provider);
+    const reusingPendingLink = canReusePendingAuthLink({
+      pendingAuth: deps.currentPendingAuth,
+      kind: "plugin",
+      provider,
+      requesterId: deps.requesterId
+    });
+    if (!reusingPendingLink) {
+      const oauthResult = await startOAuthFlow(provider, {
+        requesterId: deps.requesterId,
+        channelId: deps.channelId,
+        threadTs: deps.threadTs,
+        userMessage: deps.userMessage,
+        channelConfiguration: deps.channelConfiguration,
+        activeSkillName: activeSkill?.name ?? void 0,
+        resumeConversationId: deps.conversationId,
+        resumeSessionId: deps.sessionId
+      });
+      if (!oauthResult.ok) {
+        throw new Error(oauthResult.error);
+      }
+      if (!oauthResult.delivery) {
+        throw new Error(
+          `I need to connect your ${providerLabel} account first, but I wasn't able to send you a private authorization link. Please send me a direct message and try again.`
+        );
+      }
+    }
+    if (options?.unlinkExistingProvider && deps.requesterId && deps.userTokenStore) {
+      await unlinkProvider(deps.requesterId, provider, deps.userTokenStore);
+    }
+    if (deps.sessionId) {
+      await deps.onPendingAuth?.({
+        kind: "plugin",
+        provider,
+        requesterId: deps.requesterId,
+        sessionId: deps.sessionId,
+        linkSentAtMs: reusingPendingLink ? deps.currentPendingAuth.linkSentAtMs : Date.now()
+      });
+    }
+    pendingPause = new PluginAuthorizationPauseError(
+      provider,
+      reusingPendingLink ? "link_already_sent" : "link_sent"
+    );
+    abortAgent();
+    throw pendingPause;
+  };
+  return {
+    handleCommandFailure: async (input) => {
+      const providers = registeredProviderNames();
+      const explicitProvider = explicitAuthRequiredProvider(input.details);
+      const provider = explicitProvider && providers.includes(explicitProvider) ? explicitProvider : providers.find(
+        (availableProvider) => commandTargetsProvider(
+          availableProvider,
+          input.command,
+          input.details
+        )
+      );
+      if (!provider) {
+        return;
+      }
+      const authFailure = isCommandAuthFailure(input.details) || isGitHubSmartHttpAuthFailure(provider, input.command, input.details);
+      if (!authFailure) {
+        return;
+      }
+      if (!deps.requesterId || !deps.userTokenStore) {
+        throw buildCredentialFailureError(provider, input.command);
+      }
+      if (!getPluginOAuthConfig(provider)) {
+        throw buildCredentialFailureError(provider, input.command);
+      }
+      await startAuthorizationPause(provider, input.activeSkill, {
+        unlinkExistingProvider: true
+      });
+    },
+    getPendingPause: () => pendingPause
+  };
+}
+
+// src/chat/tools/execution/tool-error-handler.ts
+function getToolErrorAttributes(error) {
+  if (!(error instanceof SlackActionError)) {
+    return {};
+  }
+  return {
+    "app.slack.error_code": error.code,
+    ...error.apiError ? { "app.slack.api_error": error.apiError } : {},
+    ...error.detail ? { "app.slack.detail": error.detail } : {},
+    ...error.detailLine !== void 0 ? { "app.slack.detail_line": error.detailLine } : {},
+    ...error.detailRule ? { "app.slack.detail_rule": error.detailRule } : {}
+  };
+}
+function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, traceContext) {
+  const errorType = getMcpAwareErrorType(error, "tool_execution_error");
+  const errorMessage = getMcpAwareErrorMessage(error);
+  setSpanAttributes({
+    "error.type": errorType,
+    ...error instanceof PluginCredentialFailureError ? { "app.credential.provider": error.provider } : {}
+  });
+  if (error instanceof PluginCredentialFailureError) {
+    if (shouldTrace) {
+      logInfo(
+        "plugin_credential_rejected",
+        traceContext,
+        {
+          "app.credential.provider": error.provider,
+          "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+          "gen_ai.operation.name": "execute_tool",
+          "gen_ai.tool.name": toolName,
+          ...toolCallId ? { "gen_ai.tool.call.id": toolCallId } : {},
+          "error.type": errorType
+        },
+        "Plugin credentials were rejected during tool execution"
+      );
+    }
+    throw error;
+  }
+  if (shouldTrace) {
+    logWarn(
+      "agent_tool_call_failed",
+      traceContext,
+      {
+        "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+        "gen_ai.operation.name": "execute_tool",
+        "gen_ai.tool.name": toolName,
+        ...toolCallId ? { "gen_ai.tool.call.id": toolCallId } : {},
+        "error.type": errorType,
+        "exception.message": errorMessage
+      },
+      "Agent tool call failed"
+    );
+  }
+  if (!(error instanceof McpToolError)) {
+    logException(
+      error,
+      "agent_tool_call_failed",
+      {},
+      {
+        "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
+        "gen_ai.operation.name": "execute_tool",
+        "gen_ai.tool.name": toolName,
+        ...toolCallId ? { "gen_ai.tool.call.id": toolCallId } : {},
+        ...getToolErrorAttributes(error)
+      },
+      "Agent tool call failed"
+    );
+  }
+  throw error;
+}
+
+// src/chat/tools/agent-tools.ts
+function createAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecutor, pluginAuthOrchestration, onToolCall) {
+  const shouldTrace = shouldEmitDevAgentTrace();
+  return Object.entries(tools).map(([toolName, toolDef]) => ({
+    name: toolName,
+    label: toolName,
+    description: toolDef.description,
+    parameters: toolDef.inputSchema,
+    prepareArguments: toolDef.prepareArguments,
+    executionMode: toolDef.executionMode,
+    execute: async (toolCallId, params) => {
+      const normalizedToolCallId = typeof toolCallId === "string" && toolCallId.length > 0 ? toolCallId : void 0;
+      const toolArgumentsAttribute = serializeGenAiAttribute(params);
+      if (toolName === "reportProgress") {
+        const status = buildReportedProgressStatus(params);
+        if (status) {
+          await onStatus?.(status);
+        }
+      }
       return withSpan(
         `execute_tool ${toolName}`,
         "gen_ai.execute_tool",
@@ -10998,9 +11419,31 @@ var TURN_THINKING_LEVELS = [
   "high",
   "xhigh"
 ];
+var CONFIDENCE_LABELS = {
+  low: 0.5,
+  medium: CLASSIFIER_CONFIDENCE_THRESHOLD,
+  high: 0.9
+};
+function coerceClassifierConfidence(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const trimmed = value.trim().toLowerCase();
+  if (!trimmed) {
+    return value;
+  }
+  const numeric = Number.parseFloat(trimmed);
+  if (Number.isFinite(numeric)) {
+    return numeric;
+  }
+  return CONFIDENCE_LABELS[trimmed] ?? value;
+}
 var turnExecutionProfileSchema = z.object({
   thinking_level: z.enum(TURN_THINKING_LEVELS),
-  confidence: z.number().min(0).max(1),
+  confidence: z.preprocess(
+    coerceClassifierConfidence,
+    z.number().min(0).max(1)
+  ),
   reason: z.string().min(1)
 });
 var DEFAULT_THINKING_LEVEL = "medium";
@@ -11045,7 +11488,8 @@ function buildClassifierSystemPrompt() {
     "",
     "Classify based on the substance of the task, not the length of the current message. When the current instruction is a short affirmation (for example: 'go', 'do it', 'yes please', 'proceed') and the thread-background contains a pending task, classify the pending task \u2014 not the affirmation.",
     "",
-    "Return JSON only with thinking_level, confidence, and reason."
+    "Return JSON only with thinking_level, confidence, and reason.",
+    "confidence must be a number from 0 to 1, not a word label."
   ].join("\n");
 }
 function buildClassifierPrompt(args) {
@@ -11167,133 +11611,24 @@ async function classifyTurn(args) {
     };
   } catch {
     return {
-      thinkingLevel: DEFAULT_THINKING_LEVEL,
-      reason: "classifier_error_default"
-    };
-  }
-}
-function toAgentThinkingLevel(level) {
-  switch (level) {
-    case "none":
-      return "off";
-    case "low":
-      return "low";
-    case "medium":
-      return "medium";
-    case "high":
-      return "high";
-    case "xhigh":
-      return "xhigh";
-  }
-}
-
-// src/chat/state/turn-session-store.ts
-var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
-var AGENT_TURN_SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
-function agentTurnSessionKey(conversationId, sessionId) {
-  return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
-}
-function parseAgentTurnSessionCheckpoint(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  try {
-    const parsed = JSON.parse(value);
-    if (!isRecord(parsed)) {
-      return void 0;
-    }
-    const status = parsed.state;
-    if (status !== "running" && status !== "awaiting_resume" && status !== "completed" && status !== "failed" && status !== "superseded") {
-      return void 0;
-    }
-    const conversationId = parsed.conversationId;
-    const sessionId = parsed.sessionId;
-    const sliceId = parsed.sliceId;
-    const checkpointVersion = parsed.checkpointVersion;
-    const updatedAtMs = parsed.updatedAtMs;
-    if (typeof conversationId !== "string" || typeof sessionId !== "string" || typeof sliceId !== "number" || typeof checkpointVersion !== "number" || typeof updatedAtMs !== "number") {
-      return void 0;
-    }
-    return {
-      checkpointVersion,
-      conversationId,
-      sessionId,
-      sliceId,
-      state: status,
-      updatedAtMs,
-      piMessages: Array.isArray(parsed.piMessages) ? parsed.piMessages : [],
-      ...Array.isArray(parsed.loadedSkillNames) ? {
-        loadedSkillNames: parsed.loadedSkillNames.filter(
-          (value2) => typeof value2 === "string"
-        )
-      } : {},
-      ...parsed.resumeReason === "timeout" || parsed.resumeReason === "auth" ? { resumeReason: parsed.resumeReason } : {},
-      ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {},
-      ...typeof parsed.resumedFromSliceId === "number" ? { resumedFromSliceId: parsed.resumedFromSliceId } : {}
-    };
-  } catch {
-    return void 0;
-  }
-}
-async function getAgentTurnSessionCheckpoint(conversationId, sessionId) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const value = await stateAdapter.get(
-    agentTurnSessionKey(conversationId, sessionId)
-  );
-  return parseAgentTurnSessionCheckpoint(value);
-}
-async function upsertAgentTurnSessionCheckpoint(args) {
-  const stateAdapter = getStateAdapter();
-  await stateAdapter.connect();
-  const existing = await getAgentTurnSessionCheckpoint(
-    args.conversationId,
-    args.sessionId
-  );
-  const checkpoint = {
-    checkpointVersion: (existing?.checkpointVersion ?? 0) + 1,
-    conversationId: args.conversationId,
-    sessionId: args.sessionId,
-    sliceId: args.sliceId,
-    state: args.state,
-    updatedAtMs: Date.now(),
-    piMessages: Array.isArray(args.piMessages) ? args.piMessages : [],
-    ...Array.isArray(args.loadedSkillNames) ? {
-      loadedSkillNames: args.loadedSkillNames.filter(
-        (value) => typeof value === "string"
-      )
-    } : {},
-    ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
-    ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
-    ...typeof args.resumedFromSliceId === "number" ? { resumedFromSliceId: args.resumedFromSliceId } : {}
-  };
-  const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
-  await stateAdapter.set(
-    agentTurnSessionKey(args.conversationId, args.sessionId),
-    JSON.stringify(checkpoint),
-    ttlMs
-  );
-  return checkpoint;
-}
-async function supersedeAgentTurnSessionCheckpoint(args) {
-  const existing = await getAgentTurnSessionCheckpoint(
-    args.conversationId,
-    args.sessionId
-  );
-  if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "superseded") {
-    return void 0;
+      thinkingLevel: DEFAULT_THINKING_LEVEL,
+      reason: "classifier_error_default"
+    };
+  }
+}
+function toAgentThinkingLevel(level) {
+  switch (level) {
+    case "none":
+      return "off";
+    case "low":
+      return "low";
+    case "medium":
+      return "medium";
+    case "high":
+      return "high";
+    case "xhigh":
+      return "xhigh";
   }
-  return await upsertAgentTurnSessionCheckpoint({
-    conversationId: existing.conversationId,
-    sessionId: existing.sessionId,
-    sliceId: existing.sliceId,
-    state: "superseded",
-    piMessages: existing.piMessages,
-    loadedSkillNames: existing.loadedSkillNames,
-    resumeReason: existing.resumeReason,
-    resumedFromSliceId: existing.resumedFromSliceId,
-    errorMessage: args.errorMessage ?? existing.errorMessage
-  });
 }
 
 // src/chat/services/turn-checkpoint.ts
@@ -11409,320 +11744,94 @@ async function persistTimeoutCheckpoint(args) {
   }
 }
 
-// src/chat/services/pending-auth.ts
-var AUTH_LINK_REUSE_WINDOW_MS = 10 * 60 * 1e3;
-function canReusePendingAuthLink(args) {
-  const { pendingAuth } = args;
-  if (!pendingAuth) {
-    return false;
-  }
-  return pendingAuth.kind === args.kind && pendingAuth.provider === args.provider && pendingAuth.requesterId === args.requesterId && pendingAuth.linkSentAtMs + AUTH_LINK_REUSE_WINDOW_MS > (args.nowMs ?? Date.now());
-}
-function getConversationPendingAuth(args) {
-  const pendingAuth = args.conversation.processing.pendingAuth;
-  if (!pendingAuth) {
-    return void 0;
-  }
-  if (pendingAuth.kind !== args.kind || pendingAuth.provider !== args.provider || pendingAuth.requesterId !== args.requesterId) {
-    return void 0;
-  }
-  return pendingAuth;
-}
-function clearPendingAuth(conversation, sessionId) {
-  if (!conversation.processing.pendingAuth) {
-    return;
-  }
-  if (sessionId && conversation.processing.pendingAuth.sessionId !== sessionId) {
-    return;
-  }
-  conversation.processing.pendingAuth = void 0;
-}
-async function applyPendingAuthUpdate(args) {
-  const previousPendingAuth = args.conversation.processing.pendingAuth;
-  args.conversation.processing.pendingAuth = args.nextPendingAuth;
-  if (previousPendingAuth && previousPendingAuth.sessionId !== args.nextPendingAuth.sessionId && args.conversationId) {
-    await supersedeAgentTurnSessionCheckpoint({
-      conversationId: args.conversationId,
-      sessionId: previousPendingAuth.sessionId,
-      errorMessage: "Superseded by a newer auth-blocked request in the same conversation."
-    });
-  }
-}
-function isPendingAuthLatestRequest(conversation, pendingAuth) {
-  for (let index = conversation.messages.length - 1; index >= 0; index -= 1) {
-    const message = conversation.messages[index];
-    if (message?.role !== "user") {
-      continue;
-    }
-    return buildDeterministicTurnId(message.id) === pendingAuth.sessionId;
-  }
-  return false;
-}
-
 // src/chat/services/mcp-auth-orchestration.ts
 var McpAuthorizationPauseError = class extends AuthorizationPauseError {
   constructor(provider, disposition) {
     super("mcp", provider, disposition);
   }
-};
-function createMcpAuthOrchestration(deps, abortAgent) {
-  let pendingPause;
-  const authSessionIdsByProvider = /* @__PURE__ */ new Map();
-  const authProviderFactory = async (plugin) => {
-    if (!deps.conversationId || !deps.sessionId || !deps.requesterId) {
-      return void 0;
-    }
-    const provider = await createMcpOAuthClientProvider({
-      provider: plugin.manifest.name,
-      conversationId: deps.conversationId,
-      sessionId: deps.sessionId,
-      userId: deps.requesterId,
-      userMessage: deps.userMessage,
-      ...deps.channelId ? { channelId: deps.channelId } : {},
-      ...deps.threadTs ? { threadTs: deps.threadTs } : {},
-      ...deps.toolChannelId ? { toolChannelId: deps.toolChannelId } : {},
-      configuration: deps.getConfiguration(),
-      artifactState: deps.getArtifactState()
-    });
-    authSessionIdsByProvider.set(plugin.manifest.name, provider.authSessionId);
-    return provider;
-  };
-  const onAuthorizationRequired = async (provider) => {
-    if (pendingPause) {
-      return true;
-    }
-    const authSessionId = authSessionIdsByProvider.get(provider);
-    if (!authSessionId || !deps.requesterId) {
-      throw new Error(
-        `Missing MCP auth session context for plugin "${provider}"`
-      );
-    }
-    const latestArtifactState = deps.getMergedArtifactState();
-    await patchMcpAuthSession(authSessionId, {
-      configuration: { ...deps.getConfiguration() },
-      artifactState: latestArtifactState,
-      toolChannelId: deps.toolChannelId ?? latestArtifactState.assistantContextChannelId ?? deps.channelId
-    });
-    const authSession = await getMcpAuthSession(authSessionId);
-    if (!authSession?.authorizationUrl) {
-      throw new Error(`Missing MCP authorization URL for plugin "${provider}"`);
-    }
-    const reusingPendingLink = canReusePendingAuthLink({
-      pendingAuth: deps.currentPendingAuth,
-      kind: "mcp",
-      provider,
-      requesterId: deps.requesterId
-    });
-    if (!reusingPendingLink) {
-      const delivery = await deliverPrivateMessage({
-        channelId: authSession.channelId,
-        threadTs: authSession.threadTs,
-        userId: authSession.userId,
-        text: `<${authSession.authorizationUrl}|Click here to link your ${formatProviderLabel(provider)} MCP access>. Once you've authorized, this thread will continue automatically.`
-      });
-      if (!delivery) {
-        throw new Error(
-          `Unable to deliver MCP authorization link for plugin "${provider}"`
-        );
-      }
-    } else {
-      await deleteMcpAuthSession(authSessionId);
-    }
-    if (deps.sessionId && deps.requesterId) {
-      await deps.onPendingAuth?.({
-        kind: "mcp",
-        provider,
-        requesterId: deps.requesterId,
-        sessionId: deps.sessionId,
-        linkSentAtMs: reusingPendingLink ? deps.currentPendingAuth.linkSentAtMs : Date.now()
-      });
-    }
-    pendingPause = new McpAuthorizationPauseError(
-      provider,
-      reusingPendingLink ? "link_already_sent" : "link_sent"
-    );
-    abortAgent();
-    return true;
-  };
-  return {
-    authProviderFactory,
-    onAuthorizationRequired,
-    getPendingPause: () => pendingPause
-  };
-}
-
-// src/chat/credentials/unlink-provider.ts
-async function unlinkProvider(userId, provider, userTokenStore) {
-  await Promise.all([
-    userTokenStore.delete(userId, provider),
-    deleteMcpStoredOAuthCredentials(userId, provider),
-    deleteMcpServerSessionId(userId, provider),
-    deleteMcpAuthSessionsForUserProvider(userId, provider)
-  ]);
-}
-
-// src/chat/services/plugin-auth-orchestration.ts
-var PluginAuthorizationPauseError = class extends AuthorizationPauseError {
-  constructor(provider, disposition) {
-    super("plugin", provider, disposition);
-  }
-};
-function isCommandAuthFailure(details) {
-  if (!details || typeof details !== "object") {
-    return false;
-  }
-  const result = details;
-  if (typeof result.exit_code !== "number" || result.exit_code === 0) {
-    return false;
-  }
-  const text = `${typeof result.stdout === "string" ? result.stdout : ""}
-${typeof result.stderr === "string" ? result.stderr : ""}`.toLowerCase();
-  if (!text.trim()) {
-    return false;
-  }
-  return [
-    /\bjunior-auth-required\b/,
-    /\b401\b/,
-    /\bunauthorized\b/,
-    /\bbad credentials\b/,
-    /\binvalid token\b/,
-    /\btoken (?:expired|revoked)\b/,
-    /\bexpired token\b/,
-    /\bmissing scopes?\b/,
-    /\binsufficient scope\b/,
-    /\binvalid grant\b/,
-    /\breauthoriz/
-  ].some((pattern) => pattern.test(text));
-}
-function commandText(details) {
-  if (!details || typeof details !== "object") {
-    return "";
-  }
-  const result = details;
-  return `${typeof result.stdout === "string" ? result.stdout : ""}
-${typeof result.stderr === "string" ? result.stderr : ""}`;
-}
-function explicitAuthRequiredProvider(details) {
-  const match = /\bjunior-auth-required\s+provider=([a-z0-9-]+)\b/.exec(
-    commandText(details).toLowerCase()
-  );
-  return match?.[1];
-}
-function registeredProviderNames() {
-  const providers = /* @__PURE__ */ new Set();
-  for (const plugin of getPluginProviders()) {
-    const domains = [
-      ...plugin.manifest.credentials?.domains ?? [],
-      ...plugin.manifest.domains ?? []
-    ];
-    if (domains.length > 0) {
-      providers.add(plugin.manifest.name);
-    }
-  }
-  return [...providers].sort((left, right) => left.localeCompare(right));
-}
-function commandTargetsProvider(provider, command, details) {
-  const normalizedCommand = command.trim().toLowerCase();
-  if (!normalizedCommand) {
-    return false;
-  }
-  if (provider === "github" && /^(gh|git)\b/.test(normalizedCommand)) {
-    return true;
-  }
-  const plugin = getPluginDefinition(provider);
-  const candidates = /* @__PURE__ */ new Set([provider.toLowerCase()]);
-  const manifest = plugin?.manifest;
-  const credentials = manifest?.credentials;
-  if (credentials) {
-    candidates.add(credentials.authTokenEnv.toLowerCase());
-    for (const domain of credentials.domains) {
-      candidates.add(domain.toLowerCase());
-    }
-  }
-  for (const domain of manifest?.domains ?? []) {
-    candidates.add(domain.toLowerCase());
-  }
-  const combinedText = `${normalizedCommand}
-${commandText(details).toLowerCase()}`;
-  return [...candidates].some((candidate) => combinedText.includes(candidate));
-}
-function createPluginAuthOrchestration(deps, abortAgent) {
+};
+function createMcpAuthOrchestration(deps, abortAgent) {
   let pendingPause;
-  const startAuthorizationPause = async (provider, activeSkill, options) => {
+  const authSessionIdsByProvider = /* @__PURE__ */ new Map();
+  const authProviderFactory = async (plugin) => {
+    if (!deps.conversationId || !deps.sessionId || !deps.requesterId) {
+      return void 0;
+    }
+    const provider = await createMcpOAuthClientProvider({
+      provider: plugin.manifest.name,
+      conversationId: deps.conversationId,
+      sessionId: deps.sessionId,
+      userId: deps.requesterId,
+      userMessage: deps.userMessage,
+      ...deps.channelId ? { channelId: deps.channelId } : {},
+      ...deps.threadTs ? { threadTs: deps.threadTs } : {},
+      ...deps.toolChannelId ? { toolChannelId: deps.toolChannelId } : {},
+      configuration: deps.getConfiguration(),
+      artifactState: deps.getArtifactState()
+    });
+    authSessionIdsByProvider.set(plugin.manifest.name, provider.authSessionId);
+    return provider;
+  };
+  const onAuthorizationRequired = async (provider) => {
     if (pendingPause) {
-      throw pendingPause;
+      return true;
     }
-    if (!deps.requesterId || !getPluginOAuthConfig(provider)) {
-      throw new Error(`Cannot start plugin authorization for ${provider}`);
+    const authSessionId = authSessionIdsByProvider.get(provider);
+    if (!authSessionId || !deps.requesterId) {
+      throw new Error(
+        `Missing MCP auth session context for plugin "${provider}"`
+      );
+    }
+    const latestArtifactState = deps.getMergedArtifactState();
+    await patchMcpAuthSession(authSessionId, {
+      configuration: { ...deps.getConfiguration() },
+      artifactState: latestArtifactState,
+      toolChannelId: deps.toolChannelId ?? latestArtifactState.assistantContextChannelId ?? deps.channelId
+    });
+    const authSession = await getMcpAuthSession(authSessionId);
+    if (!authSession?.authorizationUrl) {
+      throw new Error(`Missing MCP authorization URL for plugin "${provider}"`);
     }
-    const providerLabel = formatProviderLabel(provider);
     const reusingPendingLink = canReusePendingAuthLink({
       pendingAuth: deps.currentPendingAuth,
-      kind: "plugin",
+      kind: "mcp",
       provider,
       requesterId: deps.requesterId
     });
     if (!reusingPendingLink) {
-      const oauthResult = await startOAuthFlow(provider, {
-        requesterId: deps.requesterId,
-        channelId: deps.channelId,
-        threadTs: deps.threadTs,
-        userMessage: deps.userMessage,
-        channelConfiguration: deps.channelConfiguration,
-        activeSkillName: activeSkill?.name ?? void 0,
-        resumeConversationId: deps.conversationId,
-        resumeSessionId: deps.sessionId
+      const delivery = await deliverPrivateMessage({
+        channelId: authSession.channelId,
+        threadTs: authSession.threadTs,
+        userId: authSession.userId,
+        text: `<${authSession.authorizationUrl}|Click here to link your ${formatProviderLabel(provider)} MCP access>. Once you've authorized, this thread will continue automatically.`
       });
-      if (!oauthResult.ok) {
-        throw new Error(oauthResult.error);
-      }
-      if (!oauthResult.delivery) {
+      if (!delivery) {
         throw new Error(
-          `I need to connect your ${providerLabel} account first, but I wasn't able to send you a private authorization link. Please send me a direct message and try again.`
+          `Unable to deliver MCP authorization link for plugin "${provider}"`
         );
       }
+    } else {
+      await deleteMcpAuthSession(authSessionId);
     }
-    if (options?.unlinkExistingProvider && deps.requesterId && deps.userTokenStore) {
-      await unlinkProvider(deps.requesterId, provider, deps.userTokenStore);
-    }
-    if (deps.sessionId) {
+    if (deps.sessionId && deps.requesterId) {
       await deps.onPendingAuth?.({
-        kind: "plugin",
+        kind: "mcp",
         provider,
         requesterId: deps.requesterId,
         sessionId: deps.sessionId,
         linkSentAtMs: reusingPendingLink ? deps.currentPendingAuth.linkSentAtMs : Date.now()
       });
     }
-    pendingPause = new PluginAuthorizationPauseError(
+    pendingPause = new McpAuthorizationPauseError(
       provider,
       reusingPendingLink ? "link_already_sent" : "link_sent"
     );
     abortAgent();
-    throw pendingPause;
+    return true;
   };
   return {
-    handleCommandFailure: async (input) => {
-      const providers = registeredProviderNames();
-      const authFailure = isCommandAuthFailure(input.details);
-      if (!authFailure) {
-        return;
-      }
-      const explicitProvider = explicitAuthRequiredProvider(input.details);
-      const provider = explicitProvider && providers.includes(explicitProvider) ? explicitProvider : providers.find(
-        (availableProvider) => commandTargetsProvider(
-          availableProvider,
-          input.command,
-          input.details
-        )
-      );
-      if (!provider || !deps.requesterId || !deps.userTokenStore || !getPluginOAuthConfig(provider)) {
-        return;
-      }
-      await startAuthorizationPause(provider, input.activeSkill, {
-        unlinkExistingProvider: true
-      });
-    },
+    authProviderFactory,
+    onAuthorizationRequired,
     getPendingPause: () => pendingPause
   };
 }
@@ -12709,6 +12818,12 @@ function finalizeFailedTurnReply(args) {
   };
 }
 
+// src/chat/services/turn-continuation-response.ts
+var TURN_CONTINUATION_RESPONSE = "I'm still working on this in the background. I'll post the final response here when it finishes.";
+function buildTurnContinuationResponse() {
+  return TURN_CONTINUATION_RESPONSE;
+}
+
 // src/chat/slack/assistant-thread/status-render.ts
 var DEFAULT_STATUS_CONTEXTS = {
   thinking: "\u2026",
@@ -13454,6 +13569,25 @@ async function postResumeFailureReply(args) {
     throw error;
   }
 }
+async function postTurnContinuationNoticeBestEffort(args) {
+  try {
+    await postSlackMessage({
+      channelId: args.resumeArgs.channelId,
+      threadTs: args.resumeArgs.threadTs,
+      text: buildTurnContinuationResponse()
+    });
+  } catch (error) {
+    logException(
+      error,
+      "slack_turn_continuation_notice_post_failed",
+      getResumeLogContext(args.resumeArgs, args.lockKey),
+      {
+        "app.slack.reply_stage": "thread_reply_turn_continuation_notice"
+      },
+      "Failed to post turn continuation notice"
+    );
+  }
+}
 async function handleResumeFailure(args) {
   const logContext = getResumeLogContext(args.resumeArgs, args.lockKey);
   const capturedEventId = logException(
@@ -13521,6 +13655,7 @@ async function resumeSlackTurn(args) {
     channelId: args.channelId,
     threadTs: args.threadTs
   });
+  let deferredPauseKind;
   let deferredPauseHandler;
   let deferredFailureHandler;
   try {
@@ -13574,10 +13709,12 @@ async function resumeSlackTurn(args) {
     const onAuthPause = args.onAuthPause;
     const onTimeoutPause = args.onTimeoutPause;
     if ((isRetryableTurnError(error, "mcp_auth_resume") || isRetryableTurnError(error, "plugin_auth_resume")) && onAuthPause) {
+      deferredPauseKind = "auth";
       deferredPauseHandler = async () => {
         await onAuthPause(error);
       };
     } else if (isRetryableTurnError(error, "turn_timeout_resume") && onTimeoutPause) {
+      deferredPauseKind = "timeout";
       deferredPauseHandler = async () => {
         await onTimeoutPause(error);
       };
@@ -13598,6 +13735,12 @@ async function resumeSlackTurn(args) {
   if (deferredPauseHandler) {
     try {
       await deferredPauseHandler();
+      if (deferredPauseKind === "timeout") {
+        await postTurnContinuationNoticeBestEffort({
+          lockKey,
+          resumeArgs: args
+        });
+      }
       return;
     } catch (pauseError) {
       await handleResumeFailure({
@@ -13669,6 +13812,20 @@ var MAX_TURN_TIMEOUT_RESUME_SLICE_ID = 5;
 function canScheduleTurnTimeoutResume(nextSliceId) {
   return typeof nextSliceId === "number" && nextSliceId > 1 && nextSliceId <= MAX_TURN_TIMEOUT_RESUME_SLICE_ID;
 }
+async function getAwaitingTurnContinuationRequest(args) {
+  const checkpoint = await getAgentTurnSessionCheckpoint(
+    args.conversationId,
+    args.sessionId
+  );
+  if (!checkpoint || checkpoint.state !== "awaiting_resume" || checkpoint.resumeReason !== "timeout" || !canScheduleTurnTimeoutResume(checkpoint.sliceId)) {
+    return void 0;
+  }
+  return {
+    conversationId: args.conversationId,
+    sessionId: args.sessionId,
+    expectedCheckpointVersion: checkpoint.checkpointVersion
+  };
+}
 function getTurnTimeoutResumeSecret() {
   const explicit = process.env.JUNIOR_INTERNAL_RESUME_SECRET?.trim();
   if (explicit) {
@@ -14724,41 +14881,21 @@ async function getJwks(issuer) {
   });
   return jwks;
 }
-function expectedVercelOidcAudience() {
-  const audience = process.env.VERCEL_OIDC_AUDIENCE?.trim();
-  if (!audience) {
-    throw new Error("VERCEL_OIDC_AUDIENCE is required for sandbox egress OIDC");
-  }
-  return audience;
-}
-function validateVercelSandboxOidcClaims(payload, sandboxId) {
-  const expectedTeamId = process.env.VERCEL_TEAM_ID?.trim();
-  const expectedProjectId = process.env.VERCEL_PROJECT_ID?.trim();
-  if (!expectedProjectId) {
-    throw new Error("VERCEL_PROJECT_ID is required for sandbox egress OIDC");
-  }
-  if (expectedTeamId && (typeof payload.owner_id !== "string" || payload.owner_id !== expectedTeamId)) {
-    throw new Error("Vercel OIDC token belongs to a different team");
-  }
-  if (typeof payload.project_id !== "string" || payload.project_id !== expectedProjectId) {
-    throw new Error("Vercel OIDC token belongs to a different project");
-  }
-  if (payload.sandbox_id !== sandboxId) {
+function validateSandboxClaim(payload, egressId) {
+  if (payload.sandbox_id !== egressId) {
     throw new Error("Vercel OIDC token belongs to a different sandbox");
   }
 }
-async function verifyVercelSandboxOidcToken(token, sandboxId) {
+async function verifyVercelSandboxOidcToken(token, egressId) {
   const unverified = decodeJwt(token);
   if (typeof unverified.iss !== "string") {
     throw new Error("Vercel OIDC token did not include an issuer");
   }
-  const audience = expectedVercelOidcAudience();
   const jwks = await getJwks(unverified.iss);
   const verified = await jwtVerify(token, jwks, {
-    issuer: unverified.iss,
-    audience
+    issuer: unverified.iss
   });
-  validateVercelSandboxOidcClaims(verified.payload, sandboxId);
+  validateSandboxClaim(verified.payload, egressId);
   return verified.payload;
 }
 
@@ -14785,6 +14922,10 @@ var PROXY_ONLY_HEADERS = /* @__PURE__ */ new Set([
   FORWARDED_SCHEME_HEADER,
   FORWARDED_PORT_HEADER
 ]);
+var DECODED_RESPONSE_HEADERS = /* @__PURE__ */ new Set([
+  "content-encoding",
+  "content-length"
+]);
 var AUTH_REJECTION_STATUS = /* @__PURE__ */ new Set([401, 403]);
 function jsonError(message, status) {
   return Response.json({ error: message }, { status });
@@ -14810,9 +14951,9 @@ function normalizePort(value) {
   const port = Number.parseInt(trimmed, 10);
   return port >= 1 && port <= 65535 ? trimmed : void 0;
 }
-function upstreamPath(request, sandboxId) {
+function upstreamPath(request, egressId) {
   const url = new URL(request.url);
-  const prefix = `${ROUTE_PREFIX}/${encodeURIComponent(sandboxId)}`;
+  const prefix = `${ROUTE_PREFIX}/${encodeURIComponent(egressId)}`;
   if (url.pathname === prefix) {
     return `/${url.search}`;
   }
@@ -14821,7 +14962,7 @@ function upstreamPath(request, sandboxId) {
   }
   return void 0;
 }
-function buildUpstreamUrl(request, sandboxId) {
+function buildUpstreamUrl(request, egressId) {
   const forwardedHost = request.headers.get(FORWARDED_HOST_HEADER);
   if (!forwardedHost?.trim()) {
     return { ok: false, error: "Missing forwarded host" };
@@ -14843,7 +14984,7 @@ function buildUpstreamUrl(request, sandboxId) {
   if (forwardedPort && !port) {
     return { ok: false, error: "Invalid forwarded port" };
   }
-  const path11 = upstreamPath(request, sandboxId);
+  const path11 = upstreamPath(request, egressId);
   if (!path11) {
     return { ok: false, error: "Invalid egress route" };
   }
@@ -14883,15 +15024,15 @@ function responseHeaders(upstream) {
   const headers = new Headers();
   upstream.headers.forEach((value, key) => {
     const normalized = key.toLowerCase();
-    if (!HOP_BY_HOP_HEADERS.has(normalized)) {
+    if (!HOP_BY_HOP_HEADERS.has(normalized) && !DECODED_RESPONSE_HEADERS.has(normalized)) {
       headers.append(key, value);
     }
   });
   return headers;
 }
-async function credentialLease(sandboxId, provider, session) {
+async function credentialLease(egressId, provider, session) {
   const cached = await getSandboxEgressCredentialLease(
-    sandboxId,
+    egressId,
     provider,
     session
   );
@@ -14914,7 +15055,7 @@ async function credentialLease(sandboxId, provider, session) {
     expiresAt: lease.expiresAt,
     headerTransforms
   };
-  await setSandboxEgressCredentialLease(sandboxId, session, cachedLease);
+  await setSandboxEgressCredentialLease(egressId, session, cachedLease);
   return cachedLease;
 }
 function hasTransformForHost(lease, host) {
@@ -14922,7 +15063,7 @@ function hasTransformForHost(lease, host) {
     (transform) => matchesSandboxEgressDomain(host, transform.domain)
   );
 }
-async function proxySandboxEgressRequest(request, sandboxId, deps = {}) {
+async function proxySandboxEgressRequest(request, egressId, deps = {}) {
   const oidcToken = request.headers.get(OIDC_TOKEN_HEADER)?.trim();
   if (!oidcToken) {
     return jsonError("Missing Vercel Sandbox OIDC token", 401);
@@ -14930,7 +15071,7 @@ async function proxySandboxEgressRequest(request, sandboxId, deps = {}) {
   try {
     await (deps.verifyOidc ?? verifyVercelSandboxOidcToken)(
       oidcToken,
-      sandboxId
+      egressId
     );
   } catch (error) {
     logWarn(
@@ -14943,7 +15084,7 @@ async function proxySandboxEgressRequest(request, sandboxId, deps = {}) {
     );
     return jsonError("Invalid Vercel Sandbox OIDC token", 401);
   }
-  const upstreamResult = buildUpstreamUrl(request, sandboxId);
+  const upstreamResult = buildUpstreamUrl(request, egressId);
   if (!upstreamResult.ok) {
     return jsonError(upstreamResult.error, 400);
   }
@@ -14952,13 +15093,13 @@ async function proxySandboxEgressRequest(request, sandboxId, deps = {}) {
   if (!provider) {
     return jsonError("No provider owns forwarded host", 403);
   }
-  const session = await getSandboxEgressSession(sandboxId);
+  const session = await getSandboxEgressSession(egressId);
   if (!session) {
     return jsonError("Sandbox egress session is not authorized", 403);
   }
   let lease;
   try {
-    lease = await credentialLease(sandboxId, provider, session);
+    lease = await credentialLease(egressId, provider, session);
   } catch (error) {
     if (error instanceof CredentialUnavailableError) {
       return new Response(
@@ -14983,7 +15124,18 @@ ${error.message}`,
     redirect: "manual"
   });
   if (AUTH_REJECTION_STATUS.has(upstream.status)) {
-    await clearSandboxEgressCredentialLease(sandboxId, provider, session);
+    logWarn(
+      "sandbox_egress_upstream_auth_rejected",
+      {},
+      {
+        "app.credential.provider": provider,
+        "http.request.method": request.method,
+        "http.response.status_code": upstream.status,
+        "server.address": upstreamUrl.hostname
+      },
+      "Sandbox egress upstream auth rejected"
+    );
+    await clearSandboxEgressCredentialLease(egressId, provider, session);
   }
   return new Response(upstream.body, {
     status: upstream.status,
@@ -14993,8 +15145,8 @@ ${error.message}`,
 }
 
 // src/handlers/sandbox-egress-proxy.ts
-async function ALL(request, sandboxId) {
-  return await proxySandboxEgressRequest(request, sandboxId);
+async function ALL(request, egressId) {
+  return await proxySandboxEgressRequest(request, egressId);
 }
 
 // src/chat/slack/context.ts
@@ -15044,6 +15196,10 @@ function resolveSlackChannelIdFromMessage(message) {
 }
 
 // src/handlers/turn-resume.ts
+var TIMEOUT_RESUME_LOCK_RETRY_DELAYS_MS = [250, 1e3, 2e3];
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 async function persistCompletedReplyState2(args) {
   const currentState = await getPersistedThreadState(
     args.checkpoint.conversationId
@@ -15243,25 +15399,53 @@ async function resumeTimedOutTurn(payload) {
     }
   });
 }
-async function POST(request, waitUntil) {
-  const payload = await verifyTurnTimeoutResumeRequest(request);
-  if (!payload) {
-    return new Response("Unauthorized", { status: 401 });
-  }
-  waitUntil(
-    () => resumeTimedOutTurn(payload).catch((error) => {
-      if (error instanceof ResumeTurnBusyError) {
+async function resumeTimedOutTurnWithLockRetry(payload) {
+  for (const [attempt, delayMs] of [
+    ...TIMEOUT_RESUME_LOCK_RETRY_DELAYS_MS,
+    void 0
+  ].entries()) {
+    try {
+      await resumeTimedOutTurn(payload);
+      return;
+    } catch (error) {
+      if (!(error instanceof ResumeTurnBusyError)) {
+        throw error;
+      }
+      if (typeof delayMs !== "number") {
         logWarn(
           "timeout_resume_lock_busy",
           {},
           {
             "app.ai.conversation_id": payload.conversationId,
-            "app.ai.session_id": payload.sessionId
+            "app.ai.session_id": payload.sessionId,
+            "app.ai.resume_lock_retry_count": attempt
           },
-          "Skipped timeout resume because another turn owns the thread lock"
+          "Skipped timeout resume because another turn still owns the thread lock"
         );
         return;
       }
+      logWarn(
+        "timeout_resume_lock_busy_retrying",
+        {},
+        {
+          "app.ai.conversation_id": payload.conversationId,
+          "app.ai.session_id": payload.sessionId,
+          "app.ai.resume_lock_retry_attempt": attempt + 1,
+          "app.ai.resume_lock_retry_delay_ms": delayMs
+        },
+        "Timeout resume lock was busy; retrying"
+      );
+      await sleep3(delayMs);
+    }
+  }
+}
+async function POST(request, waitUntil) {
+  const payload = await verifyTurnTimeoutResumeRequest(request);
+  if (!payload) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+  waitUntil(
+    () => resumeTimedOutTurnWithLockRetry(payload).catch((error) => {
       logException(
         error,
         "timeout_resume_handler_failed",
@@ -15625,21 +15809,162 @@ function getSlackErrorObservabilityAttributes(error) {
   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;
+  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;
+}
+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 escapeRegExp3(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function stripLeadingBotMention(text, options = {}) {
+  if (!text.trim()) return text;
+  let next = text;
+  if (options.stripLeadingSlackMentionToken) {
+    next = next.replace(/^\s*<@[^>]+>[\s,:-]*/, "").trim();
+  }
+  const mentionByNameRe = new RegExp(
+    `^\\s*@${escapeRegExp3(botConfig.userName)}\\b[\\s,:-]*`,
+    "i"
+  );
+  next = next.replace(mentionByNameRe, "").trim();
+  const mentionByLabeledEntityRe = new RegExp(
+    `^\\s*<@[^>|]+\\|${escapeRegExp3(botConfig.userName)}>[\\s,:-]*`,
+    "i"
+  );
+  next = next.replace(mentionByLabeledEntityRe, "").trim();
+  return next;
+}
+function getThreadId(thread, _message) {
+  return toOptionalString(thread.id);
+}
+function getRunId(thread, message) {
+  return toOptionalString(thread.runId) ?? toOptionalString(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 raw = message.raw;
+  const rawRecord = raw && typeof raw === "object" ? raw : void 0;
+  const channelId = toOptionalString(rawRecord?.channel);
+  if (channelId) {
+    const rawThreadTs = toOptionalString(rawRecord?.thread_ts);
+    const threadTs = isDmChannel(channelId) ? rawThreadTs : rawThreadTs ?? toOptionalString(rawRecord?.ts);
+    if (threadTs) {
+      return { channelId, threadTs };
+    }
+  }
+  const parsedThreadId = parseSlackThreadId(
+    toOptionalString(message.threadId)
+  );
+  if (!parsedThreadId || isDmChannel(parsedThreadId.channelId)) {
+    return void 0;
+  }
+  return parsedThreadId;
+}
+function getMessageTs(message) {
+  const directTs = toOptionalString(
+    message.ts
+  );
+  if (directTs) {
+    return directTs;
+  }
+  const raw = message.raw;
+  if (!raw || typeof raw !== "object") {
+    return void 0;
+  }
+  const rawRecord = raw;
+  return toOptionalString(rawRecord.ts) ?? toOptionalString(rawRecord.event_ts) ?? toOptionalString(rawRecord.message?.ts);
+}
+
+// src/chat/runtime/processing-reaction.ts
+var PROCESSING_REACTION_EMOJI = "eyes";
+var noProcessingReaction = {
+  keep: () => void 0,
+  stop: async () => void 0
+};
+function isProcessingReactionEmoji(value) {
+  return typeof value === "string" && normalizeSlackEmojiName(value) === PROCESSING_REACTION_EMOJI;
+}
+function shouldKeepProcessingReactionForToolInvocation(input) {
+  return input.toolName === "slackMessageAddReaction" && isProcessingReactionEmoji(input.params.emoji);
+}
+async function startSlackProcessingReaction(args) {
+  if (args.message.author.isMe) {
+    return noProcessingReaction;
   }
-  const requestId = getHeaderString(candidate.headers, "x-slack-req-id");
-  if (requestId) {
-    attributes["app.slack.request_id"] = requestId;
+  const channelId = getChannelId(args.thread, args.message);
+  const messageTs = getMessageTs(args.message);
+  if (!channelId || !messageTs) {
+    return noProcessingReaction;
   }
-  if (typeof candidate.statusCode === "number" && Number.isFinite(candidate.statusCode)) {
-    attributes["http.response.status_code"] = candidate.statusCode;
+  try {
+    await addReactionToMessage({
+      channelId,
+      timestamp: messageTs,
+      emoji: PROCESSING_REACTION_EMOJI
+    });
+  } catch (error) {
+    args.logException(
+      error,
+      "slack_processing_reaction_add_failed",
+      args.logContext,
+      {
+        "app.slack.action": "reactions.add",
+        "messaging.message.id": messageTs,
+        ...getSlackErrorObservabilityAttributes(error)
+      },
+      "Failed to add Slack processing reaction"
+    );
+    return noProcessingReaction;
   }
-  return attributes;
-}
-function isSlackTitlePermissionError(error) {
-  const code = getSlackApiErrorCode(error);
-  return code === "no_permission" || code === "missing_scope" || code === "not_allowed_token_type";
+  let shouldRemove = true;
+  return {
+    keep: () => {
+      shouldRemove = false;
+    },
+    stop: async () => {
+      if (!shouldRemove) {
+        return;
+      }
+      try {
+        await removeReactionFromMessage({
+          channelId,
+          timestamp: messageTs,
+          emoji: PROCESSING_REACTION_EMOJI
+        });
+      } catch (error) {
+        args.logException(
+          error,
+          "slack_processing_reaction_remove_failed",
+          args.logContext,
+          {
+            "app.slack.action": "reactions.remove",
+            "messaging.message.id": messageTs,
+            ...getSlackErrorObservabilityAttributes(error)
+          },
+          "Failed to remove Slack processing reaction"
+        );
+      }
+    }
+  };
 }
 
 // src/chat/runtime/slack-runtime.ts
@@ -15667,6 +15992,14 @@ function buildLogContext(deps, args) {
 }
 function createSlackTurnRuntime(deps) {
   const logContext = (args) => buildLogContext(deps, args);
+  const createToolInvocationHook = (processingReaction, hooks) => {
+    return (invocation) => {
+      if (shouldKeepProcessingReactionForToolInvocation(invocation)) {
+        processingReaction.keep();
+      }
+      hooks?.onToolInvocation?.(invocation);
+    };
+  };
   const postFallbackErrorReplyWithLogging = async (args) => {
     try {
       await args.thread.post(buildTurnFailureResponse(args.eventId));
@@ -15720,6 +16053,7 @@ function createSlackTurnRuntime(deps) {
   };
   return {
     async handleNewMention(thread, message, hooks) {
+      let processingReaction;
       try {
         const threadId = deps.getThreadId(thread, message);
         const channelId = deps.getChannelId(thread, message);
@@ -15731,11 +16065,22 @@ function createSlackTurnRuntime(deps) {
           requesterUserName: message.author.userName,
           runId
         });
+        processingReaction = await startSlackProcessingReaction({
+          thread,
+          message,
+          logException: deps.logException,
+          logContext: context
+        });
+        const toolInvocationHook = createToolInvocationHook(
+          processingReaction,
+          hooks
+        );
         await deps.withSpan("chat.turn", "chat.turn", context, async () => {
           await thread.subscribe();
           await deps.replyToThread(thread, message, {
             explicitMention: true,
-            beforeFirstResponsePost: hooks?.beforeFirstResponsePost
+            beforeFirstResponsePost: hooks?.beforeFirstResponsePost,
+            onToolInvocation: toolInvocationHook
           });
         });
       } catch (error) {
@@ -15776,113 +16121,123 @@ function createSlackTurnRuntime(deps) {
           postFailureEventName: "mention_handler_failure_reply_post_failed",
           postFailureBody: "Failed to post fallback error reply for mention handler"
         });
+      } finally {
+        await processingReaction?.stop();
       }
     },
     async handleSubscribedMessage(thread, message, hooks) {
+      let processingReaction;
       try {
         const threadId = deps.getThreadId(thread, message);
         const channelId = deps.getChannelId(thread, message);
         const runId = deps.getRunId(thread, message);
-        await deps.withSpan(
-          "chat.turn",
-          "chat.turn",
-          logContext({
+        const context = logContext({
+          threadId,
+          requesterId: message.author.userId,
+          requesterUserName: message.author.userName,
+          channelId,
+          runId
+        });
+        processingReaction = await startSlackProcessingReaction({
+          thread,
+          message,
+          logException: deps.logException,
+          logContext: context
+        });
+        const toolInvocationHook = createToolInvocationHook(
+          processingReaction,
+          hooks
+        );
+        await deps.withSpan("chat.turn", "chat.turn", context, async () => {
+          const legacyAttachmentText = renderSlackLegacyAttachmentText(
+            message.raw
+          );
+          const rawUserText = appendSlackLegacyAttachmentText(
+            message.text,
+            message.raw
+          );
+          const strippedUserText = deps.stripLeadingBotMention(message.text, {
+            stripLeadingSlackMentionToken: Boolean(message.isMention)
+          });
+          const userText = appendSlackLegacyAttachmentText(
+            strippedUserText,
+            message.raw
+          );
+          const context2 = {
             threadId,
             requesterId: message.author.userId,
-            requesterUserName: message.author.userName,
             channelId,
             runId
-          }),
-          async () => {
-            const legacyAttachmentText = renderSlackLegacyAttachmentText(
-              message.raw
-            );
-            const rawUserText = appendSlackLegacyAttachmentText(
-              message.text,
-              message.raw
-            );
-            const strippedUserText = deps.stripLeadingBotMention(message.text, {
-              stripLeadingSlackMentionToken: Boolean(message.isMention)
-            });
-            const userText = appendSlackLegacyAttachmentText(
-              strippedUserText,
-              message.raw
-            );
-            const context = {
-              threadId,
-              requesterId: message.author.userId,
-              channelId,
-              runId
-            };
-            const preflightDecision = getSubscribedReplyPreflightDecision({
-              botUserName: deps.assistantUserName,
-              rawText: rawUserText,
-              text: userText,
-              isExplicitMention: Boolean(message.isMention)
-            });
-            if (preflightDecision && !preflightDecision.shouldReply) {
-              const reason = preflightDecision.reasonDetail ? `${preflightDecision.reason}:${preflightDecision.reasonDetail}` : preflightDecision.reason;
-              await skipSubscribedMessage({
-                thread,
-                message,
-                decision: { shouldReply: false, reason },
-                context,
-                userText
-              });
-              return;
-            }
-            const preparedState = await deps.prepareTurnState({
+          };
+          const preflightDecision = getSubscribedReplyPreflightDecision({
+            botUserName: deps.assistantUserName,
+            rawText: rawUserText,
+            text: userText,
+            isExplicitMention: Boolean(message.isMention)
+          });
+          if (preflightDecision && !preflightDecision.shouldReply) {
+            const reason = preflightDecision.reasonDetail ? `${preflightDecision.reason}:${preflightDecision.reasonDetail}` : preflightDecision.reason;
+            await skipSubscribedMessage({
               thread,
               message,
-              userText,
-              explicitMention: Boolean(message.isMention),
-              context
+              decision: { shouldReply: false, reason },
+              context: context2,
+              userText
             });
-            await deps.persistPreparedState({
+            return;
+          }
+          const preparedState = await deps.prepareTurnState({
+            thread,
+            message,
+            userText,
+            explicitMention: Boolean(message.isMention),
+            context: context2
+          });
+          await deps.persistPreparedState({
+            thread,
+            preparedState
+          });
+          const decision = await deps.decideSubscribedReply({
+            rawText: rawUserText,
+            text: userText,
+            conversationContext: deps.getPreparedConversationContext(preparedState),
+            hasAttachments: message.attachments.length > 0 || legacyAttachmentText !== "",
+            isExplicitMention: Boolean(message.isMention),
+            context: context2
+          });
+          if (await maybeHandleThreadOptOutDecision({
+            thread,
+            decision,
+            beforeFirstResponsePost: hooks?.beforeFirstResponsePost
+          })) {
+            await skipSubscribedMessage({
               thread,
-              preparedState
-            });
-            const decision = await deps.decideSubscribedReply({
-              rawText: rawUserText,
-              text: userText,
-              conversationContext: deps.getPreparedConversationContext(preparedState),
-              hasAttachments: message.attachments.length > 0 || legacyAttachmentText !== "",
-              isExplicitMention: Boolean(message.isMention),
-              context
+              message,
+              decision,
+              context: context2,
+              preparedState,
+              userText
             });
-            if (await maybeHandleThreadOptOutDecision({
+            return;
+          }
+          if (!decision.shouldReply) {
+            await skipSubscribedMessage({
               thread,
+              message,
               decision,
-              beforeFirstResponsePost: hooks?.beforeFirstResponsePost
-            })) {
-              await skipSubscribedMessage({
-                thread,
-                message,
-                decision,
-                context,
-                preparedState,
-                userText
-              });
-              return;
-            }
-            if (!decision.shouldReply) {
-              await skipSubscribedMessage({
-                thread,
-                message,
-                decision,
-                context,
-                preparedState,
-                userText
-              });
-              return;
-            }
-            await deps.replyToThread(thread, message, {
-              explicitMention: Boolean(message.isMention),
+              context: context2,
               preparedState,
-              beforeFirstResponsePost: hooks?.beforeFirstResponsePost
+              userText
             });
+            return;
           }
-        );
+          await deps.replyToThread(thread, message, {
+            explicitMention: Boolean(message.isMention),
+            preparedState,
+            beforeFirstResponsePost: hooks?.beforeFirstResponsePost,
+            onToolInvocation: toolInvocationHook
+          });
+        });
       } catch (error) {
         const errorContext = logContext({
           threadId: deps.getThreadId(thread, message),
@@ -15921,6 +16276,8 @@ function createSlackTurnRuntime(deps) {
           postFailureEventName: "subscribed_message_handler_failure_reply_post_failed",
           postFailureBody: "Failed to post fallback error reply for subscribed message handler"
         });
+      } finally {
+        await processingReaction?.stop();
       }
     },
     async handleAssistantThreadStarted(event) {
@@ -16618,6 +16975,7 @@ function createJuniorRuntimeServices(overrides = {}) {
     conversationMemory,
     replyExecutor: {
       generateAssistantReply: overrides.replyExecutor?.generateAssistantReply ?? generateAssistantReply,
+      getAwaitingTurnContinuationRequest: overrides.replyExecutor?.getAwaitingTurnContinuationRequest ?? getAwaitingTurnContinuationRequest,
       lookupSlackUser: overrides.replyExecutor?.lookupSlackUser ?? lookupSlackUser,
       scheduleTurnTimeoutResume: overrides.replyExecutor?.scheduleTurnTimeoutResume ?? scheduleTurnTimeoutResume,
       generateThreadTitle: conversationMemory.generateThreadTitle
@@ -16640,74 +16998,6 @@ function getSlackMessageTs(message) {
   return message.id;
 }
 
-// src/chat/runtime/thread-context.ts
-function escapeRegExp3(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function stripLeadingBotMention(text, options = {}) {
-  if (!text.trim()) return text;
-  let next = text;
-  if (options.stripLeadingSlackMentionToken) {
-    next = next.replace(/^\s*<@[^>]+>[\s,:-]*/, "").trim();
-  }
-  const mentionByNameRe = new RegExp(
-    `^\\s*@${escapeRegExp3(botConfig.userName)}\\b[\\s,:-]*`,
-    "i"
-  );
-  next = next.replace(mentionByNameRe, "").trim();
-  const mentionByLabeledEntityRe = new RegExp(
-    `^\\s*<@[^>|]+\\|${escapeRegExp3(botConfig.userName)}>[\\s,:-]*`,
-    "i"
-  );
-  next = next.replace(mentionByLabeledEntityRe, "").trim();
-  return next;
-}
-function getThreadId(thread, _message) {
-  return toOptionalString(thread.id);
-}
-function getRunId(thread, message) {
-  return toOptionalString(thread.runId) ?? toOptionalString(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 raw = message.raw;
-  const rawRecord = raw && typeof raw === "object" ? raw : void 0;
-  const channelId = toOptionalString(rawRecord?.channel);
-  if (channelId) {
-    const rawThreadTs = toOptionalString(rawRecord?.thread_ts);
-    const threadTs = isDmChannel(channelId) ? rawThreadTs : rawThreadTs ?? toOptionalString(rawRecord?.ts);
-    if (threadTs) {
-      return { channelId, threadTs };
-    }
-  }
-  const parsedThreadId = parseSlackThreadId(
-    toOptionalString(message.threadId)
-  );
-  if (!parsedThreadId || isDmChannel(parsedThreadId.channelId)) {
-    return void 0;
-  }
-  return parsedThreadId;
-}
-function getMessageTs(message) {
-  const directTs = toOptionalString(
-    message.ts
-  );
-  if (directTs) {
-    return directTs;
-  }
-  const raw = message.raw;
-  if (!raw || typeof raw !== "object") {
-    return void 0;
-  }
-  const rawRecord = raw;
-  return toOptionalString(rawRecord.ts) ?? toOptionalString(rawRecord.event_ts) ?? toOptionalString(rawRecord.message?.ts);
-}
-
 // src/chat/slack/assistant-thread/title.ts
 function maybeUpdateAssistantTitle(args) {
   const assistantThreadContext = args.assistantThreadContext;
@@ -16824,11 +17114,6 @@ function createReplyToThread(deps) {
         });
         const slackMessageTs = getSlackMessageTs(message);
         const turnId = buildDeterministicTurnId(message.id);
-        startActiveTurn({
-          conversation: preparedState.conversation,
-          nextTurnId: turnId,
-          updateConversationStats
-        });
         const turnTraceContext = {
           conversationId,
           slackThreadId: threadId,
@@ -16838,6 +17123,78 @@ function createReplyToThread(deps) {
           assistantUserName: botConfig.userName,
           modelId: botConfig.modelId
         };
+        let beforeFirstResponsePostCalled = false;
+        const beforeFirstResponsePost = async () => {
+          if (beforeFirstResponsePostCalled) {
+            return;
+          }
+          beforeFirstResponsePostCalled = true;
+          await options.beforeFirstResponsePost?.();
+        };
+        const postTurnContinuationNotice = async () => {
+          try {
+            await beforeFirstResponsePost();
+            await thread.post(
+              buildSlackOutputMessage(buildTurnContinuationResponse())
+            );
+          } catch (error) {
+            logException(
+              error,
+              "slack_turn_continuation_notice_post_failed",
+              turnTraceContext,
+              {
+                "app.slack.reply_stage": "thread_reply_turn_continuation_notice",
+                ...messageTs ? { "messaging.message.id": messageTs } : {},
+                ...getSlackErrorObservabilityAttributes(error)
+              },
+              "Failed to post turn continuation notice"
+            );
+            throw error;
+          }
+        };
+        const activeTurnId = preparedState.conversation.processing.activeTurnId;
+        if (conversationId && activeTurnId) {
+          const resumeRequest = await deps.services.getAwaitingTurnContinuationRequest({
+            conversationId,
+            sessionId: activeTurnId
+          });
+          if (resumeRequest) {
+            try {
+              await deps.services.scheduleTurnTimeoutResume(resumeRequest);
+            } catch (error) {
+              logException(
+                error,
+                "agent_turn_continuation_retry_schedule_failed",
+                turnTraceContext,
+                {
+                  "app.ai.resume_checkpoint_version": resumeRequest.expectedCheckpointVersion,
+                  "app.ai.resume_session_id": resumeRequest.sessionId,
+                  ...messageTs ? { "messaging.message.id": messageTs } : {}
+                },
+                "Failed to reschedule active turn continuation"
+              );
+              throw error;
+            }
+            await postTurnContinuationNotice();
+            markConversationMessage(
+              preparedState.conversation,
+              preparedState.userMessageId,
+              {
+                replied: true,
+                skippedReason: void 0
+              }
+            );
+            await persistThreadState(thread, {
+              conversation: preparedState.conversation
+            });
+            return;
+          }
+        }
+        startActiveTurn({
+          conversation: preparedState.conversation,
+          nextTurnId: turnId,
+          updateConversationStats
+        });
         setTags({
           conversationId
         });
@@ -16879,14 +17236,6 @@ function createReplyToThread(deps) {
           threadTs: assistantThreadContext?.threadTs,
           getSlackAdapter: deps.getSlackAdapter
         });
-        let beforeFirstResponsePostCalled = false;
-        const beforeFirstResponsePost = async () => {
-          if (beforeFirstResponsePostCalled) {
-            return;
-          }
-          beforeFirstResponsePostCalled = true;
-          await options.beforeFirstResponsePost?.();
-        };
         const postThreadReply = async (payload, stage) => {
           await beforeFirstResponsePost();
           try {
@@ -16973,7 +17322,8 @@ function createReplyToThread(deps) {
                 conversation: preparedState.conversation
               });
             },
-            onStatus: (nextStatus) => status.update(nextStatus)
+            onStatus: (nextStatus) => status.update(nextStatus),
+            onToolInvocation: options.onToolInvocation
           });
           const diagnosticsContext = {
             slackThreadId: threadId,
@@ -17140,7 +17490,6 @@ function createReplyToThread(deps) {
                   expectedCheckpointVersion: checkpointVersion
                 });
                 shouldPersistFailureState = false;
-                return;
               } catch (scheduleError) {
                 logException(
                   scheduleError,
@@ -17152,7 +17501,11 @@ function createReplyToThread(deps) {
                   },
                   "Failed to schedule timeout resume callback"
                 );
+                shouldPersistFailureState = true;
+                throw scheduleError;
               }
+              await postTurnContinuationNotice();
+              return;
             } else if (conversationIdForResume && sessionIdForResume && typeof checkpointVersion === "number") {
               logWarn(
                 "agent_turn_timeout_resume_slice_limit_reached",
@@ -17609,75 +17962,53 @@ function enqueueBackgroundTask(options, task) {
     throw new Error("Chat background processing requires waitUntil");
   }
   options.waitUntil(task);
+  return task;
 }
 var JuniorChat = class extends Chat {
   /**
    * Normalize Slack thread IDs before the SDK's concurrency queue.
    *
-   * The SDK uses the `threadId` parameter as the lock/queue key
-   * (Chat.handleIncomingMessage → getLockKey). @chat-adapter/slack
-   * (as of 4.22.0) builds DM thread IDs as `slack:<channel>:` (empty
-   * thread_ts) when the Slack event has no `thread_ts` field — it uses
-   * `event.thread_ts || ""` instead of falling back to `event.ts`.
-   * See @chat-adapter/slack/dist/index.js:1466.
-   *
-   * A DM root event arrives as `slack:D123:` while a reply in the same
-   * thread carries `slack:D123:<ts>`, splitting the lock/state/subscription
-   * keys and breaking conversation continuity.
-   *
-   * We fix this by resolving the message eagerly (even when the adapter
-   * provides a factory), deriving the canonical thread ID from
-   * `raw.channel` + `raw.thread_ts ?? raw.ts`, and passing both the
-   * normalized threadId and concrete message to super.processMessage.
-   *
-   * Remove this override when @chat-adapter/slack uses `event.ts` as
-   * the DM thread_ts fallback.
+   * Slack DM roots can arrive with an empty thread timestamp, while
+   * later replies include the root timestamp. Resolve factories before
+   * delegating so the lock/state/subscription key is canonicalized before
+   * the SDK computes its per-thread queue key.
    */
   processMessage(adapter, threadId, messageOrFactory, options) {
     if (typeof messageOrFactory === "function") {
       const runtime = this;
-      enqueueBackgroundTask(
+      return enqueueBackgroundTask(
         options,
         (async () => {
+          let message2;
           try {
-            const message = await messageOrFactory();
-            if (isExternalSlackUser(message.raw)) {
-              return;
-            }
-            const normalized = normalizeIncomingSlackThreadId(
-              threadId,
-              message
-            );
-            if (normalized !== threadId && "threadId" in message) {
-              message.threadId = normalized;
-            }
-            super.processMessage(adapter, normalized, message, options);
+            message2 = await messageOrFactory();
           } catch (error) {
             runtime.logger?.error?.("Message factory resolution error", {
               error,
               threadId
             });
+            return;
+          }
+          if (isExternalSlackUser(message2.raw)) {
+            return;
           }
+          const normalized2 = normalizeIncomingSlackThreadId(threadId, message2);
+          if (normalized2 !== threadId && "threadId" in message2) {
+            message2.threadId = normalized2;
+          }
+          await super.processMessage(adapter, normalized2, message2, options);
         })()
       );
-      return;
     }
-    if (isExternalSlackUser(messageOrFactory.raw)) {
-      return;
+    const message = messageOrFactory;
+    if (isExternalSlackUser(message.raw)) {
+      return Promise.resolve();
     }
-    enqueueBackgroundTask(
-      options,
-      (async () => {
-        const normalized = normalizeIncomingSlackThreadId(
-          threadId,
-          messageOrFactory
-        );
-        if (normalized !== threadId && "threadId" in messageOrFactory) {
-          messageOrFactory.threadId = normalized;
-        }
-        super.processMessage(adapter, normalized, messageOrFactory, options);
-      })()
-    );
+    const normalized = normalizeIncomingSlackThreadId(threadId, message);
+    if (normalized !== threadId && "threadId" in message) {
+      message.threadId = normalized;
+    }
+    return super.processMessage(adapter, normalized, message, options);
   }
   processReaction(event, options) {
     const runtime = this;
@@ -18373,11 +18704,11 @@ async function createApp(options) {
   app.post("/api/internal/turn-resume", (c) => {
     return POST(c.req.raw, waitUntil);
   });
-  app.all("/api/internal/sandbox-egress/:sandboxId", (c) => {
-    return ALL(c.req.raw, c.req.param("sandboxId"));
+  app.all("/api/internal/sandbox-egress/:egressId", (c) => {
+    return ALL(c.req.raw, c.req.param("egressId"));
   });
-  app.all("/api/internal/sandbox-egress/:sandboxId/*", (c) => {
-    return ALL(c.req.raw, c.req.param("sandboxId"));
+  app.all("/api/internal/sandbox-egress/:egressId/*", (c) => {
+    return ALL(c.req.raw, c.req.param("egressId"));
   });
   app.post("/api/webhooks/:platform", (c) => {
     return POST2(c.req.raw, c.req.param("platform"), waitUntil);