@sentry/junior 0.223.0 → 0.224.0

package/dist/app.js

@@ -1,41 +1,39 @@
-import { $ as AuthorizationFlowDisabledError, B as recordFinishedTurnForAutomatedLimit, C as renderBlockText, D as getNextRunAtMs, E as scheduledAutomationRunAttributes, F as ingestEvent, G as clearSandboxEgressSignals, H as normalizeSandboxEgressTracePropagationDomains, I as EVENT_WAIT_MS, J as parseSandboxEgressCredentialToken, K as consumeSandboxEgressAuthRequiredSignal, L as isEventMailboxMetadata, P as processWorkspaceSnapshotJob, Q as isVisionImageMediaType, R as renderTaskInput, S as renderAttachmentText, T as logScheduledAutomationRunSkipped, U as shouldPropagateSandboxEgressTrace, V as resolveSandboxEgressProviderForHost, W as SANDBOX_EGRESS_PROXY_PATH, X as createUserTokenStore, Z as buildSteeringPiMessage, _ as readPublicArtifact, b as readAttachmentVisionSummary, c as deleteMcpStoredOAuthCredentials, et as shouldEmitDevAgentTrace, f as PluginCredentialFailureError, g as publicArtifactHeaders, m as latestProgressStatus, n as createContextCompactor, nt as setConfigDefaults, o as deleteMcpAuthSessionsForUserProvider, q as consumeSandboxEgressPermissionDeniedSignal, r as executeCredentialedEgressRequest, s as deleteMcpServerSessionId, t as executeAgentRun, tt as getConfigDefaults, v as unpublishedArtifactHeaders, w as listThreadReplies, x as recordSlackAttachment, z as maybePostAutomatedTurnLimitNotice } from "./agent-Bzbf92vv.js";
-import { b as isProviderRetryError, i as completeText, m as escapeXml, r as completeObject } from "./client-DjC6-6iU.js";
-import { A as JUNIOR_WORKSPACE_SNAPSHOT_JOB_CALLBACK_ROUTE, C as withSpan, D as JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE, F as isRecord$1, I as toOptionalNumber, L as toOptionalString, S as withLogContext, _ as setSpanAttributes, d as logInfo, f as logWarn, g as setSentryUser, l as logError, n as createChatSdkLogger, o as getActiveTraceId, r as createRequestContext, t as buildTurnFailureResponse, u as logException, v as setSpanStatus, x as withContext, y as setTags } from "./logging-DiN3o3nB.js";
+import { $ as clearSandboxEgressSignals, A as renderAttachmentText, Ct as shouldEmitDevAgentTrace, E as unpublishedArtifactHeaders, F as getNextRunAtMs, G as isEventMailboxMetadata, H as processWorkspaceSnapshotJob, J as recordFinishedTurnForAutomatedLimit, K as renderTaskInput, M as listThreadReplies, N as logScheduledAutomationRunSkipped, O as readAttachmentVisionSummary, P as scheduledAutomationRunAttributes, Q as SANDBOX_EGRESS_PROXY_PATH, S as latestProgressStatus, St as AuthorizationFlowDisabledError, T as readPublicArtifact, Tt as setConfigDefaults, U as ingestEvent, W as EVENT_WAIT_MS, X as normalizeSandboxEgressTracePropagationDomains, Y as resolveSandboxEgressProviderForHost, Z as shouldPropagateSandboxEgressTrace, _t as buildSteeringPiMessage, a as isExperimentalFeatureEnabled, c as createContextCompactor, ct as escapeSlackMrkdwnText, dt as normalizeSlackStatusText, et as consumeSandboxEgressAuthRequiredSignal, f as deleteMcpAuthSessionsForUserProvider, ft as truncateStatusText, gt as createUserTokenStore, ht as removeReactionFromMessage, i as getExperimentalFeatures, it as formatProviderLabel, j as renderBlockText, k as recordSlackAttachment, l as executeCredentialedEgressRequest, lt as formatSlackLink, m as deleteMcpStoredOAuthCredentials, mt as postSlackMessage, nt as parseSandboxEgressCredentialToken, o as setExperimentalFeatures, p as deleteMcpServerSessionId, pt as addReactionToMessage, q as maybePostAutomatedTurnLimitNotice, s as executeAgentRun, st as startOAuthFlow, t as createAgentRunner, tt as consumeSandboxEgressPermissionDeniedSignal, ut as normalizeSlackReplyMarkdown, v as PluginCredentialFailureError, vt as isVisionImageMediaType, w as publicArtifactHeaders, wt as getConfigDefaults, x as isPendingAuthLatestRequest, y as clearPendingAuth, yt as RetryableDeliveryError } from "./agent-runner-9g6TQk9y.js";
+import { b as isProviderRetryError, i as completeText, m as escapeXml, r as completeObject } from "./client-B27ufhzl.js";
+import { A as JUNIOR_WORKSPACE_SNAPSHOT_JOB_CALLBACK_ROUTE, C as withSpan, D as JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE, F as isRecord$1, I as toOptionalNumber, L as toOptionalString, S as withLogContext, _ as setSpanAttributes, d as logInfo, f as logWarn, g as setSentryUser, l as logError, n as createChatSdkLogger, o as getActiveTraceId, r as createRequestContext, t as buildTurnFailureResponse, u as logException, v as setSpanStatus, x as withContext, y as setTags } from "./logging-iY0ssa2q.js";
 import { r as continueTrace } from "./sentry-CgWZM_kV.js";
-import { t as JUNIOR_VERSION } from "./version-_ZQFlslB.js";
-import { a as getChatConfig, c as getSlackClientId, d as getSlackSigningSecret, f as setBotModelConfig, i as configureFunctionMaxDurationSeconds, l as getSlackClientSecret, m as setSlackReactionConfig, n as botConfig, p as setProfiles, s as getSlackBotToken, u as getSlackReactionConfig } from "./config-CtoUVs72.js";
+import { t as JUNIOR_VERSION } from "./version-C6lA-h_o.js";
+import { a as getChatConfig, c as getSlackClientId, d as getSlackSigningSecret, f as setBotModelConfig, h as normalizeSlackEmojiName, i as configureFunctionMaxDurationSeconds, l as getSlackClientSecret, m as setSlackReactionConfig, n as botConfig, p as setProfiles, s as getSlackBotToken, u as getSlackReactionConfig } from "./config-BAhl7-RC.js";
 import { a as modelIdForProfile, n as defaultModelId } from "./model-profile-CZmVoGdX.js";
-import { _ as parseSlackMessageTs, a as createActor, c as isActorUserId, o as createSlackActor, p as parseSlackChannelId, s as createSlackResumeActor, t as credentialContextForActor, u as parseActorUserId } from "./context-Bplcgypl.js";
-import { B as downloadPrivateSlackFile, F as bindSlackDirectCredentialSubject, G as isDmChannel, I as verifyEventAutomationCredentialSubject, Jt as getSqlExecutor, K as normalizeSlackConversationId, Kt as getConversationStore, L as verifyScheduledAutomationCredentialSubject, Lt as listConversationAnnotations, N as bindEventAutomationCredentialSubject, P as bindScheduledAutomationCredentialSubject, Pt as resolveRootVisibility, Q as readActorIdentity, Qt as withConversationMutationLock, R as verifySlackDirectCredentialSubject, U as getSlackClient, Wt as getConversationEventStore, X as runWithWorkspaceTeamId, Xt as withConversationEventLock, Y as getWorkspaceTeamId, _t as createPluginState, a as getPluginRoutes, bt as createPluginLogger, cn as deleteProviderIdentityForSlackUser, ct as collectEventMatchKeys, d as setPlugins, dn as createSlackDestination, dt as findMatchingWatches, f as validatePlugins, gt as setDashboardConversationLinkOptions, h as setBriefsConfig, ht as getDashboardTaskLink, i as getPluginApiRoutes, mt as getDashboardConversationLink, ot as cancelSubscriptions, pn as requireSlackDestination, pt as JUNIOR_THREAD_STATE_TTL_MS, q as runWithSlackInstallationToken, qt as getDb, u as getPlugins, xt as readConversationAccessFromSql, z as SlackActionError } from "./agent-hooks-DZU5nsd1.js";
+import { _ as parseSlackMessageTs, a as createActor, c as isActorUserId, l as isUserActor, o as createSlackActor, p as parseSlackChannelId, s as createSlackResumeActor, t as credentialContextForActor, u as parseActorUserId } from "./context-Bplcgypl.js";
+import { B as downloadPrivateSlackFile, F as bindSlackDirectCredentialSubject, G as isDmChannel, H as getHeaderString, I as verifyEventAutomationCredentialSubject, Jt as getSqlExecutor, K as normalizeSlackConversationId, Kt as getConversationStore, L as verifyScheduledAutomationCredentialSubject, Lt as listConversationAnnotations, N as bindEventAutomationCredentialSubject, Nt as buildSentryConversationUrl, P as bindScheduledAutomationCredentialSubject, Pt as resolveRootVisibility, Q as readActorIdentity, Qt as withConversationMutationLock, R as verifySlackDirectCredentialSubject, U as getSlackClient, Wt as getConversationEventStore, X as runWithWorkspaceTeamId, Xt as withConversationEventLock, Y as getWorkspaceTeamId, _t as createPluginState, a as getPluginRoutes, bt as createPluginLogger, cn as deleteProviderIdentityForSlackUser, ct as collectEventMatchKeys, d as setPlugins, dn as createSlackDestination, dt as findMatchingWatches, f as validatePlugins, gt as setDashboardConversationLinkOptions, h as setBriefsConfig, ht as getDashboardTaskLink, i as getPluginApiRoutes, mt as getDashboardConversationLink, o as getPluginSlackConversationLink, ot as cancelSubscriptions, pn as requireSlackDestination, pt as JUNIOR_THREAD_STATE_TTL_MS, q as runWithSlackInstallationToken, qt as getDb, u as getPlugins, xt as readConversationAccessFromSql, z as SlackActionError } from "./agent-hooks-DNLBwmsh.js";
 import { n as juniorDestinations } from "./destinations-BeBiJeEM.js";
-import { E as juniorConversations, a as juniorSchedulerRuns, f as juniorAgentBindings, g as juniorConversationBriefs, o as juniorSchedulerTasks, p as juniorAgentInvocations, y as juniorConversationEvents } from "./executor-AOhG9X1t.js";
+import { E as juniorConversations, a as juniorSchedulerRuns, f as juniorAgentBindings, g as juniorConversationBriefs, o as juniorSchedulerTasks, p as juniorAgentInvocations, y as juniorConversationEvents } from "./executor-BG2Armby.js";
 import { Y as instructionProvenanceFor, k as annotationCard } from "./conversation-1HUoZr2l.js";
-import { n as pluginCatalogRuntime } from "./catalog-runtime-BthunUDD.js";
-import { $ as resolveConversationTitle, F as loadProjection, G as recordSubscribedReplyRoute, J as appendConversationMessages, M as commitMessages, P as loadConversationProjection, Q as persistConversationMessageSummaries, X as persistConversationMessages, Y as hydrateConversationMessages, Z as projectConversationMessages, a as completeTurnRecord, at as isHumanConversationMessage, c as getTurnRecordForResume, ct as recordDeliveredAssistantMessage, d as persistWithRetry, dt as estimateTextTokens, et as appendThreadContextMessages, i as abandonTurnRecord, it as getConversationMessageSlackTs, j as commitAcceptedReply, k as trimTrailingAssistantMessages, l as listTurnSummaries, lt as turnHasReply, m as buildTurnErrorResponse, n as loadTurnCheckpoint, nt as createConversationMemoryService, o as failTurnRecord, ot as markConversationMessage, r as saveTurnCheckpoint, rt as estimateConversationContextTokens, s as getTurnRecord, st as normalizeConversationText, tt as buildConversationContext, u as recordTurnSummary, ut as upsertConversationMessage } from "./checkpoint-Deu-OVb3.js";
-import { E as acquireActiveLock, O as withActiveLock, T as MUTATION_LOCK_TTL_MS$1, k as withLock$1, w as getStateAdapter } from "./profile-BsNrw8lj.js";
-import { Bt as hasRunnableConversationWork$1, Dt as hasRunnableConversationWork, Et as getConversationWorkState, F as effectiveTaskOutcomes, Ht as isInvalidConversationRecordError, It as stopConversationWork, Kt as buildDeterministicAssistantMessageId, Mt as removeActiveConversation, Ot as listActiveConversationIds, Pt as requestConversationWork, Rt as CONVERSATION_WORK_STALE_ENQUEUE_MS, S as withScheduledAutomationLock, Tt as getConversation, U as findMatchingEventAutomations, X as getEventCatalog, a as requestAttachmentDeletion, b as saveScheduledAutomationInLock, c as parseSlackThreadId, g as listScheduledAutomationsForTeam, h as listScheduledAutomations, o as storeAttachment, pt as appendAndEnqueueInboundMessage, qt as buildDeterministicTurnId, r as collectAttachmentGarbage, tt as eventGuidance, v as readScheduledAutomation, vt as clearExpiredConversationLease, w as scheduledRunSchema, wt as ensureConversationWake, x as scheduledRunId, z as collectEventAutomationMatchKeys } from "./stats-pNGp3G5q.js";
-import { S as startActiveTurn, _ as isTurnInputCommitLostError, b as markTurnCompleted, d as ConversationTurnBoundaryError, f as CooperativeTurnYieldError, g as isCooperativeTurnYieldError, h as getConversationTurnBoundaryError, m as TurnInputDeferredError, p as TurnInputCommitLostError, r as clearPendingAuth, s as getAssistantReplyText, v as isTurnInputDeferredError, x as markTurnFailed, y as markTurnClosed } from "./pending-auth-D7vmttn_.js";
-import { h as postSlackMessage, i as formatProviderLabel, s as startOAuthFlow, t as createAgentRunner, v as RetryableDeliveryError } from "./agent-runner-2VQ9WhkG.js";
+import { n as pluginCatalogRuntime } from "./catalog-runtime-CVZ9TEuK.js";
+import { $ as appendThreadContextMessages, A as commitAcceptedReply, B as recordAuthorizationCompleted, J as hydrateConversationMessages, N as loadConversationProjection, O as trimTrailingAssistantMessages, P as loadProjection, Q as resolveConversationTitle, W as recordSubscribedReplyRoute, X as projectConversationMessages, Y as persistConversationMessages, Z as persistConversationMessageSummaries, a as completeTurnRecord, at as markConversationMessage, c as listTurnSummaries, ct as turnHasReply, et as buildConversationContext, i as abandonTurnRecord, it as isHumanConversationMessage, j as commitMessages, l as recordTurnSummary, lt as upsertConversationMessage, n as loadTurnCheckpoint, nt as estimateConversationContextTokens, o as failTurnRecord, ot as normalizeConversationText, p as buildTurnErrorResponse, q as appendConversationMessages, r as saveTurnCheckpoint, rt as getConversationMessageSlackTs, s as getTurnRecord, st as recordDeliveredAssistantMessage, tt as createConversationMemoryService, u as persistWithRetry, ut as estimateTextTokens } from "./checkpoint-Ceck_fLO.js";
+import { E as acquireActiveLock, O as withLock$1, T as MUTATION_LOCK_TTL_MS$1, w as getStateAdapter } from "./profile-6KWhg_-U.js";
+import { Bt as hasRunnableConversationWork$1, Dt as hasRunnableConversationWork, Et as getConversationWorkState, F as effectiveTaskOutcomes, Ht as isInvalidConversationRecordError, It as stopConversationWork, Kt as buildDeterministicAssistantMessageId, Mt as removeActiveConversation, Ot as listActiveConversationIds, Pt as requestConversationWork, Rt as CONVERSATION_WORK_STALE_ENQUEUE_MS, S as withScheduledAutomationLock, Tt as getConversation, U as findMatchingEventAutomations, X as getEventCatalog, a as requestAttachmentDeletion, b as saveScheduledAutomationInLock, c as parseSlackThreadId, d as resolveSlackChannelIdFromThreadId, g as listScheduledAutomationsForTeam, h as listScheduledAutomations, l as readSlackRawMessageContext, o as storeAttachment, pt as appendAndEnqueueInboundMessage, qt as buildDeterministicTurnId, r as collectAttachmentGarbage, tt as eventGuidance, u as resolveSlackChannelIdFromMessage, v as readScheduledAutomation, vt as clearExpiredConversationLease, w as scheduledRunSchema, wt as ensureConversationWake, x as scheduledRunId, z as collectEventAutomationMatchKeys } from "./stats-DP9zl3Jg.js";
+import { _ as markTurnFailed, c as CooperativeTurnYieldError, d as getConversationTurnBoundaryError, f as isCooperativeTurnYieldError, g as markTurnCompleted, h as markTurnClosed, l as TurnInputCommitLostError, m as isTurnInputDeferredError, p as isTurnInputCommitLostError, r as getAssistantReplyText, s as ConversationTurnBoundaryError, u as TurnInputDeferredError, v as startActiveTurn } from "./oauth-authorization-BIijVS2N.js";
 import { a as EVENT_SYSTEM_ACTOR, i as EVENT_MESSAGE_AUTHOR, o as isEventConversationMessage } from "./prompt-90miy8VV.js";
-import { f as setSandboxResourceConfig, u as getSandboxResourceConfig } from "./resolve-B38CpJe2.js";
+import { f as setSandboxResourceConfig, u as getSandboxResourceConfig } from "./resolve-CB45ZukQ.js";
 import { l as conversationQueueMessageSchema, n as resolveConversationWorkQueueTopic, r as verifyConversationQueueMessage, t as getVercelConversationWorkQueue, u as isConversationQueueMessageRejectedError } from "./vercel-queue-DIkVcfK4.js";
-import { a as getTurnRequestDeadline, i as verifyWorkspaceSnapshotJobMessage, t as WORKSPACE_SNAPSHOT_JOB_QUEUE_TOPIC } from "./job-queue-CNd9cpIy.js";
-import { i as setExperimentalFeatures, n as getExperimentalFeatures, r as isExperimentalFeatureEnabled } from "./experimental-CIXf7Uye.js";
-import { n as validatePluginRegistrations, t as validatePluginEgressCredentialHooks } from "./validation-D5CIslEu.js";
+import { a as getTurnRequestDeadline, i as verifyWorkspaceSnapshotJobMessage, t as WORKSPACE_SNAPSHOT_JOB_QUEUE_TOPIC } from "./job-queue-D4oAVrL9.js";
+import { n as validatePluginRegistrations, t as validatePluginEgressCredentialHooks } from "./validation-CnZkCN7o.js";
 import { a as pluginRuntimeRegistrationsFromPluginSet, n as pluginCatalogConfigFromEnv, r as pluginCatalogConfigFromPluginSet, t as defineJuniorPlugins } from "./plugins-egKWjgue.js";
-import { S as GET$3, _ as readViewerAutomationSummary, a as webActorFromEmail, b as legacyWebMailboxMetadataSchema, i as recordWebConversationActivity, l as resolveSlackChannelTypeFromMessage, n as conversationTurnIdForMessage, o as resolveConversationDestination, s as conversationVisibilityFromSlackChannelType, t as appendAndEnqueueWebMessage, u as resolveSlackConversationContext, x as createVercelAttachmentStorage, y as lookupSlackUser } from "./web-input-BJpWm6go.js";
-import { u as recordAutomationExecution } from "./execution-stats-CrXs9vSH.js";
-import { _ as markDispatchCompleted, a as claimDispatchMailboxAppend, c as getDispatchConversationId, d as getDispatchTurnId, f as getPluginDispatchProjection, g as markDispatchBlocked, h as markDispatchAwaitingResume, i as resolveTurnSessionRouting, l as getDispatchInputMessageId, m as listPendingDispatchMailboxAppends, n as scheduleSessionCompletedPluginTasks, o as confirmDispatchMailboxAppend, p as isTerminalDispatchStatus, s as createOrGetDispatch, t as processPluginTask, u as getDispatchRecord, v as markDispatchFailed, y as markDispatchRunning } from "./task-runner-DI1FBJFJ.js";
-import { i as resolveAgentInvocationId, o as listPendingAgentInvocationMailboxAppends, r as enqueueAgentInvocation, t as createAgentInvocationWorker } from "./work-DvIlJR3C.js";
-import { n as getTurnLifecycle, t as ConversationTurnLifecycleService } from "./turn-lifecycle-Bjf6y2GO.js";
-import { n as executeTurn, t as AgentRunError } from "./turn-execution-BNOXrZ-M.js";
-import { a as persistThreadState, i as persistThreadRuntimeState, n as getPersistedSandboxState, o as persistThreadStateById, r as getPersistedThreadState, s as coerceThreadConversationState, t as getLocationConfigurationService } from "./thread-state-DXgxOYpZ.js";
-import { a as requireTurnFailureEventId, c as getTurnUserMessage, d as getTurnUserSlackMessageTs, f as buildDeliveredTurnStatePatch, i as getAgentTurnDiagnosticsAttributes, n as persistAuthPauseTurnState, r as finalizeFailedTurnReplyWithEvent, s as loadPendingMessageCards, t as completeAuthPauseTurn, u as getTurnUserReplyAttachmentContext } from "./auth-pause-state-Bn2vX4PA.js";
-import { a as registerVercelPluginTaskDevConsumer, n as createVercelPluginTaskCallback, s as queueCallback } from "./task-queue-Cy9y1foT.js";
-import { C as isSlackTitlePermissionError, D as createSlackAdapterAssistantStatusSession, E as renderSlackObjectCard, S as isRetryableSlackPostError, T as buildSlackOutputMessage, _ as getThreadId, a as GET$4, b as getSlackApiErrorCode, c as wakePausedTurn, d as shouldKeepProcessingReactionForToolInvocation, f as startProcessingReaction, g as getRunId, h as getMessageTs, i as publishAppHomeView, l as resumeSlackTurn, m as getChannelId, o as createPausedTurns, p as getAssistantThreadContext, r as GET$5, s as getPausedTurnRequest, t as receiveLocalOAuthCredential, u as buildAuthPauseResponse, v as getThreadTs, w as sendSlackReply, x as getSlackErrorObservabilityAttributes, y as stripLeadingBotMention } from "./credential-sync-CKdXEUDO.js";
-import { n as deleteWebAuthorization, t as createWebAuthorization } from "./web-authorization-6mmfS_o-.js";
-import { t as processConversationWork } from "./worker-D1qidg-Y.js";
-import { t as bindSpawnAgent } from "./spawn-DzXc_PKO.js";
+import { S as GET$3, _ as readViewerAutomationSummary, a as webActorFromEmail, b as legacyWebMailboxMetadataSchema, i as recordWebConversationActivity, l as resolveSlackChannelTypeFromMessage, n as conversationTurnIdForMessage, o as resolveConversationDestination, s as conversationVisibilityFromSlackChannelType, t as appendAndEnqueueWebMessage, u as resolveSlackConversationContext, x as createVercelAttachmentStorage, y as lookupSlackUser } from "./web-input-BoE1xE-K.js";
+import { u as recordAutomationExecution } from "./execution-stats-DikPOxJ1.js";
+import { _ as markDispatchFailed, a as confirmDispatchMailboxAppend, c as getDispatchInputMessageId, d as getPluginDispatchProjection, f as isTerminalDispatchStatus, g as markDispatchCompleted, h as markDispatchBlocked, i as claimDispatchMailboxAppend, l as getDispatchRecord, m as markDispatchAwaitingResume, n as scheduleSessionCompletedPluginTasks, o as createOrGetDispatch, p as listPendingDispatchMailboxAppends, s as getDispatchConversationId, t as processPluginTask, u as getDispatchTurnId, v as markDispatchRunning } from "./task-runner-fntmnqzx.js";
+import { c as listPendingAgentInvocationMailboxAppends, i as resolveAgentInvocationId, o as AgentRunError, r as enqueueAgentInvocation, s as executeTurn, t as createAgentInvocationWorker } from "./work-4Nhz9mVv.js";
+import { n as getTurnLifecycle, t as ConversationTurnLifecycleService } from "./turn-lifecycle-5_jvLqRz.js";
+import { a as persistThreadState, c as configValueSchema, i as persistThreadRuntimeState, n as getPersistedSandboxState, o as persistThreadStateById, r as getPersistedThreadState, s as coerceThreadConversationState, t as getLocationConfigurationService } from "./thread-state-Wfr0GdKS.js";
+import { a as GET$4, c as wakePausedTurn, i as publishAppHomeView, l as getTurnAuthorization, o as createPausedTurns, r as GET$5, s as getPausedTurnRequest, t as receiveLocalOAuthCredential } from "./credential-sync-BXHIxbtS.js";
+import { n as resolveTurnSessionRouting } from "./turn-session-routing-CQaysLoe.js";
+import { n as deleteWebAuthorization, t as createWebAuthorization } from "./web-authorization-Bbx999_q.js";
+import { a as registerVercelPluginTaskDevConsumer, n as createVercelPluginTaskCallback, s as queueCallback } from "./task-queue-SL4uLfBB.js";
+import { t as processConversationWork } from "./worker-CdWPsNL2.js";
+import { t as bindSpawnAgent } from "./spawn-Cg6lyjE7.js";
+import { a as persistAuthPauseTurnState, c as getTurnUserSlackMessageTs, d as loadPendingMessageCards, i as completeAuthPauseTurn, l as buildDeliveredTurnStatePatch, n as getAgentTurnDiagnosticsAttributes, o as getTurnUserMessage, r as requireTurnFailureEventId, s as getTurnUserReplyAttachmentContext, t as finalizeFailedTurnReplyWithEvent, u as getInterruptionMarker } from "./turn-failure-response-DLjSEm-R.js";
 import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
 import { Hono } from "hono";
@@ -1920,6 +1918,110 @@ async function GET(request) {
 	});
 }
 //#endregion
+//#region src/chat/slack/automation-card.ts
+function preview(text, length) {
+	const compact = text.replace(/\s+/g, " ").trim();
+	return compact.length > length ? `${compact.slice(0, length - 1)}…` : compact;
+}
+/** Show an Automation as a native Work Object, not an operation receipt. */
+function renderSlackAutomationCard(card) {
+	const title = preview(card.title, 160);
+	const trigger = preview(card.trigger, 500);
+	const warning = card.warning ? preview(card.warning, 500) : null;
+	const text = [
+		card.url ? formatSlackLink(card.url, title) : escapeSlackMrkdwnText(title),
+		escapeSlackMrkdwnText(trigger),
+		warning ? escapeSlackMrkdwnText(warning) : null
+	].filter(Boolean).join("\n");
+	if (!card.url) return {
+		entity: null,
+		text
+	};
+	return {
+		text,
+		entity: {
+			entity_type: "slack#/entities/item",
+			external_ref: {
+				id: card.id,
+				type: "automation"
+			},
+			url: card.url,
+			entity_payload: {
+				attributes: {
+					title: { text: title },
+					display_type: "Automation"
+				},
+				custom_fields: [{
+					key: "trigger",
+					label: "When",
+					type: "string",
+					value: trigger,
+					long: true
+				}, ...warning ? [{
+					key: "warning",
+					label: "Needs attention",
+					type: "string",
+					value: warning,
+					long: true
+				}] : []]
+			}
+		}
+	};
+}
+//#endregion
+//#region src/chat/slack/object-card.ts
+/** Render verified annotation facts as a native Task or Item preview. */
+function renderSlackObjectCard(card, conversationId) {
+	if (card.objectType === "automation" && card.plugin === "junior") return renderSlackAutomationCard({
+		id: card.key,
+		title: card.title,
+		url: card.url,
+		trigger: card.trigger ?? "",
+		warning: card.warning ?? null
+	});
+	const title = card.title.slice(0, 160);
+	const text = [
+		card.url ? formatSlackLink(card.url, title) : escapeSlackMrkdwnText(title),
+		escapeSlackMrkdwnText(card.label),
+		card.status ? escapeSlackMrkdwnText(card.status) : null
+	].filter(Boolean).join("\n");
+	if (!card.url) return {
+		entity: null,
+		text
+	};
+	const task = card.objectType === "task";
+	return {
+		text,
+		entity: {
+			entity_type: task ? "slack#/entities/task" : "slack#/entities/item",
+			external_ref: {
+				id: JSON.stringify([
+					conversationId,
+					card.plugin,
+					card.key
+				]),
+				type: "annotation"
+			},
+			url: card.url,
+			entity_payload: {
+				attributes: {
+					title: { text: title },
+					display_id: card.label,
+					display_type: card.objectType === "code_change" ? "Pull request" : task ? "Issue" : "Item",
+					product_name: card.plugin
+				},
+				fields: task && card.status ? { status: { value: card.status } } : void 0,
+				custom_fields: !task && card.status ? [{
+					key: "status",
+					label: "Status",
+					type: "string",
+					value: card.status
+				}] : []
+			}
+		}
+	};
+}
+//#endregion
 //#region src/chat/slack/annotation-details.ts
 const eventSchema$1 = z.object({
 	trigger_id: z.string().min(1),
@@ -2076,11 +2178,11 @@ const BARE_STOP_RE = /^stop(?:\s*[.!…]+)?$/i;
 const ACKNOWLEDGMENT_ONLY_RE = /^(?:thanks(?: you)?|thank you|thx|ty|got it|sounds good|sgtm|lgtm|ok(?:ay)?|cool|nice|perfect|awesome|great|makes sense|understood|roger|yep|yup|kk|on it|will do)(?:[.!]+)?$/i;
 const DIRECTED_FOLLOW_UP_CUE_RE = /\b(?:you said|you just said|your last response|your last answer|what did you just say|what do you mean|what did you mean|explain(?: that| this| it| more)?|clarify(?: that| this| it)?|expand(?: on)?(?: that| this| it)?|elaborate(?: on)?(?: that| this| it)?|say more)\b/i;
 const TERSE_CLARIFICATION_RE = /^(?:which one|which ones|why|how so|what do you mean|what did you mean|say more|explain that|clarify that|expand on that|elaborate on that)\??$/i;
-function escapeRegExp$1(value) {
+function escapeRegExp$2(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function containsAssistantInvocation(text, botUserName) {
-	const escapedUserName = escapeRegExp$1(botUserName);
+	const escapedUserName = escapeRegExp$2(botUserName);
 	const plainNameMentionRe = new RegExp(`(^|\\s)@${escapedUserName}\\b`, "i");
 	const labeledEntityMentionRe = new RegExp(`<@[^>|]+\\|${escapedUserName}>`, "i");
 	return plainNameMentionRe.test(text) || labeledEntityMentionRe.test(text);
@@ -2371,6 +2473,53 @@ async function decideSubscribedThreadReply(args) {
 	}
 }
 //#endregion
+//#region src/chat/slack/errors.ts
+/** Extract Slack's stable API error code from Web API errors. */
+function getSlackApiErrorCode(error) {
+	if (!error || typeof error !== "object") return;
+	const candidate = error;
+	if (typeof candidate.data?.error === "string" && candidate.data.error.trim().length > 0) return candidate.data.error;
+	if (typeof candidate.code === "string" && candidate.code.trim().length > 0) return candidate.code;
+}
+/** Convert Slack Web API error details into the repository's trace attributes. */
+function getSlackErrorObservabilityAttributes(error) {
+	if (!error || typeof error !== "object") return {};
+	const candidate = error;
+	const attributes = {};
+	if (typeof candidate.code === "string" && candidate.code.trim().length > 0) attributes["app.slack.error_code"] = candidate.code;
+	if (typeof candidate.data?.error === "string" && candidate.data.error.trim().length > 0) attributes["app.slack.api_error"] = candidate.data.error;
+	const requestId = getHeaderString(candidate.headers, "x-slack-req-id");
+	if (requestId) attributes["app.slack.request_id"] = requestId;
+	if (typeof candidate.statusCode === "number" && Number.isFinite(candidate.statusCode)) attributes["http.response.status_code"] = candidate.statusCode;
+	return attributes;
+}
+const TRANSIENT_SLACK_API_ERRORS = /* @__PURE__ */ new Set([
+	"fatal_error",
+	"internal_error",
+	"rate_limited",
+	"ratelimited",
+	"request_timeout",
+	"service_unavailable"
+]);
+/** Recover transient or ambiguous Slack failures, but stop on explicit rejection. */
+function isRetryableSlackPostError(error) {
+	if (!error || typeof error !== "object") return true;
+	const candidate = error;
+	if (typeof candidate.statusCode === "number") {
+		if (candidate.statusCode === 429 || candidate.statusCode >= 500) return true;
+		if (candidate.statusCode >= 400) return false;
+	}
+	const apiError = error instanceof SlackActionError ? error.apiError : typeof candidate.data?.error === "string" ? candidate.data.error : void 0;
+	if (apiError) return TRANSIENT_SLACK_API_ERRORS.has(apiError);
+	if (error instanceof SlackActionError) return error.code === "rate_limited" || error.code === "internal_error";
+	return true;
+}
+/** Report whether Slack rejected assistant title updates for stable auth reasons. */
+function isSlackTitlePermissionError(error) {
+	const code = getSlackApiErrorCode(error);
+	return code === "no_permission" || code === "missing_scope" || code === "not_allowed_token_type";
+}
+//#endregion
 //#region src/chat/slack/message/content.ts
 /**
 * Slack message content projection.
@@ -2411,6 +2560,166 @@ function parseContent(message) {
 	};
 }
 //#endregion
+//#region src/chat/runtime/thread-context.ts
+function escapeRegExp$1(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function readOptionalStringField(value, key) {
+	if (!(key in value)) return;
+	return toOptionalString(value[key]);
+}
+function stripLeadingBotMention(text, options = {}) {
+	if (!text.trim()) return text;
+	let next = text;
+	if (options.stripLeadingSlackMentionToken) {
+		if (options.botUserId) {
+			const botUserId = escapeRegExp$1(options.botUserId);
+			const mentionByBotUserIdRe = new RegExp(`^\\s*(?:<@${botUserId}(?:\\|[^>]+)?>|@${botUserId})[\\s,:-]*`, "i");
+			next = next.replace(mentionByBotUserIdRe, "").trim();
+		} else next = next.replace(/^\s*<@[^>]+>[\s,:-]*/, "").trim();
+	}
+	const mentionByNameRe = new RegExp(`^\\s*@${escapeRegExp$1(botConfig.userName)}\\b[\\s,:-]*`, "i");
+	next = next.replace(mentionByNameRe, "").trim();
+	const mentionByLabeledEntityRe = new RegExp(`^\\s*<@[^>|]+\\|${escapeRegExp$1(botConfig.userName)}>[\\s,:-]*`, "i");
+	next = next.replace(mentionByLabeledEntityRe, "").trim();
+	return next;
+}
+function getThreadId(thread, _message) {
+	return toOptionalString(thread.id);
+}
+function getRunId(thread, message) {
+	return readOptionalStringField(thread, "runId") ?? readOptionalStringField(message, "runId");
+}
+function getChannelId(thread, message) {
+	return resolveSlackChannelIdFromThreadId(toOptionalString(thread.id)) ?? normalizeSlackConversationId(toOptionalString(thread.channelId)) ?? resolveSlackChannelIdFromMessage(message);
+}
+function getThreadTs(threadId) {
+	return parseSlackThreadId(threadId)?.threadTs;
+}
+/**
+* Resolve Slack assistant-thread API context for the current turn.
+*
+* Slack assistant-thread methods must use the live inbound thread context
+* Slack provided on the current message. Slack's assistant utilities build
+* `setStatus`/`setTitle` from `message.channel` plus `message.thread_ts ?? message.ts`
+* for non-DM message events, while `message.im` still requires an explicit
+* `thread_ts`. Do not synthesize assistant-thread roots from persisted state.
+*/
+function getAssistantThreadContext(message) {
+	const rawContext = readSlackRawMessageContext(message);
+	const channelId = rawContext?.channelId;
+	if (channelId) {
+		const threadTs = isDmChannel(channelId) ? rawContext.threadTs : rawContext.threadTs ?? rawContext.messageTs;
+		if (threadTs) return {
+			channelId,
+			threadTs
+		};
+	}
+	const parsedThreadId = parseSlackThreadId(readOptionalStringField(message, "threadId"));
+	if (!parsedThreadId || isDmChannel(parsedThreadId.channelId)) return;
+	return parsedThreadId;
+}
+/** Resolve the native Slack timestamp for a message that can target Slack APIs. */
+function getMessageTs(message) {
+	const directTs = readOptionalStringField(message, "ts");
+	const parsedDirectTs = parseSlackMessageTs(directTs);
+	if (parsedDirectTs) return parsedDirectTs;
+	const rawContext = readSlackRawMessageContext(message);
+	if (!rawContext) return;
+	const candidates = [rawContext.messageTs, rawContext.nestedMessageTs];
+	for (const candidate of candidates) {
+		const ts = parseSlackMessageTs(candidate);
+		if (ts) return ts;
+	}
+}
+//#endregion
+//#region src/chat/providers/slack/processing-reaction.ts
+const noProcessingReaction = {
+	complete: async () => void 0,
+	keep: () => void 0,
+	stop: async () => void 0
+};
+function isProcessingReactionEmoji(value) {
+	return typeof value === "string" && normalizeSlackEmojiName(value) === getChatConfig().slack.processingReactionEmoji;
+}
+/** Return true when a Slack reaction tool invocation keeps the processing reaction. */
+function shouldKeepProcessingReactionForToolInvocation(input) {
+	return input.toolName === "addReaction" && isProcessingReactionEmoji(input.params.emoji);
+}
+/** Start Junior's automatic Slack processing reaction for one inbound message. */
+async function startProcessingReaction(args) {
+	if (args.message.author.isMe) return noProcessingReaction;
+	const channelId = getChannelId(args.thread, args.message);
+	const messageTs = getMessageTs(args.message);
+	if (!channelId || !messageTs) return noProcessingReaction;
+	return startProcessingReactionForMessage({
+		channelId,
+		timestamp: messageTs
+	});
+}
+/** Start Junior's automatic Slack processing reaction for a known Slack message. */
+async function startProcessingReactionForMessage(args) {
+	try {
+		await addReactionToMessage({
+			channelId: args.channelId,
+			timestamp: args.timestamp,
+			emoji: getChatConfig().slack.processingReactionEmoji
+		});
+	} catch (error) {
+		logException(error, "slack.processing.reaction_add.failed", {
+			"app.slack.action": "reactions.add",
+			"messaging.message.id": args.timestamp,
+			...getSlackErrorObservabilityAttributes(error)
+		});
+		return noProcessingReaction;
+	}
+	let shouldRemove = true;
+	const removeProcessingReaction = async () => {
+		if (!shouldRemove) return false;
+		try {
+			await removeReactionFromMessage({
+				channelId: args.channelId,
+				timestamp: args.timestamp,
+				emoji: getChatConfig().slack.processingReactionEmoji
+			});
+			return true;
+		} catch (error) {
+			logException(error, "slack.processing.reaction_remove.failed", {
+				"app.slack.action": "reactions.remove",
+				"messaging.message.id": args.timestamp,
+				...getSlackErrorObservabilityAttributes(error)
+			});
+			return false;
+		}
+	};
+	return {
+		complete: async () => {
+			const shouldAddCompleted = shouldRemove;
+			await removeProcessingReaction();
+			if (!shouldAddCompleted) return;
+			try {
+				await addReactionToMessage({
+					channelId: args.channelId,
+					timestamp: args.timestamp,
+					emoji: getChatConfig().slack.completedReactionEmoji
+				});
+			} catch (error) {
+				logException(error, "slack.processing.reaction_complete.failed", {
+					"app.slack.action": "reactions.add",
+					"messaging.message.id": args.timestamp,
+					...getSlackErrorObservabilityAttributes(error)
+				});
+			}
+		},
+		keep: () => {
+			shouldRemove = false;
+		},
+		stop: async () => {
+			await removeProcessingReaction();
+		}
+	};
+}
+//#endregion
 //#region src/chat/slack/message-control.ts
 /** Leading Slack mention forms that may precede an explicit steering marker. */
 const LEADING_MENTION_BEFORE_STEERING_RE = /^(\s*(?:<@[^>]+>|@[A-Za-z0-9._-]+\b)[\s,:-]*)!!\s*/;
@@ -5443,6 +5752,616 @@ function readSlackActionToken(message) {
 	return token.success ? token.data : void 0;
 }
 //#endregion
+//#region src/chat/slack/cards.ts
+/** Select the Slack object renderer for a built-in card. */
+function renderSlackCard(card, conversationId) {
+	switch (card.kind) {
+		case "object": return renderSlackObjectCard(card, conversationId);
+		case "automation": return renderSlackAutomationCard(card);
+	}
+}
+//#endregion
+//#region src/chat/slack/footer.ts
+/** Render compact reply attribution for the Slack footer. */
+function formatReplyAttribution(attribution) {
+	return attribution.detail ? `${attribution.label} · ${attribution.detail}` : attribution.label;
+}
+/**
+* Build the compact conversation footer for visible Slack reply surfaces.
+*
+* Detailed turn metrics stay in the dashboard instead of Slack-visible copy.
+*/
+function buildSlackReplyFooter(args) {
+	const items = [];
+	const conversationId = args.conversationId?.trim();
+	if (conversationId) {
+		const idItem = {
+			label: "ID",
+			value: conversationId
+		};
+		const conversationUrl = getPluginSlackConversationLink(conversationId)?.url ?? getDashboardConversationLink(conversationId) ?? buildSentryConversationUrl(conversationId);
+		if (conversationUrl) idItem.url = conversationUrl;
+		items.push(idItem);
+	}
+	return items.length > 0 || args.replyAttribution ? {
+		...args.replyAttribution ? { attribution: args.replyAttribution } : void 0,
+		items
+	} : void 0;
+}
+/** Build Slack blocks for a reply chunk using the Slack-flavored markdown block for the body. */
+function buildSlackReplyBlocks(text, footer) {
+	const blocks = text.trim() ? [{
+		type: "markdown",
+		text
+	}] : [];
+	if (footer && (footer.attribution || footer.items.length > 0)) {
+		const attributionElements = footer.attribution ? [{
+			type: "plain_text",
+			text: formatReplyAttribution(footer.attribution)
+		}] : [];
+		blocks.push({
+			type: "context",
+			elements: [...attributionElements, ...footer.items.map((item) => ({
+				type: "mrkdwn",
+				text: item.url ? `*${escapeSlackMrkdwnText(item.label)}:* ${formatSlackLink(item.url, item.value)}` : `*${escapeSlackMrkdwnText(item.label)}:* ${escapeSlackMrkdwnText(item.value)}`
+			}))]
+		});
+	}
+	return blocks.length ? blocks : void 0;
+}
+//#endregion
+//#region src/chat/slack/output.ts
+const MAX_INLINE_CHARS = 2200;
+const MAX_INLINE_LINES = 45;
+const CONTINUED_MARKER = "\n\n[Continued below]";
+function countSlackLines(text) {
+	if (!text) return 0;
+	return text.split("\n").length;
+}
+function fitsInlineBudget(text, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
+	return text.length <= maxChars && countSlackLines(text) <= maxLines;
+}
+function findSplitIndex(text, maxChars) {
+	if (text.length <= maxChars) return text.length;
+	const bounded = text.slice(0, maxChars);
+	const newlineIndex = bounded.lastIndexOf("\n");
+	if (newlineIndex > 0) return newlineIndex;
+	const spaceIndex = bounded.lastIndexOf(" ");
+	if (spaceIndex > 0) return spaceIndex;
+	return maxChars;
+}
+function splitByLineBudget(text, maxLines) {
+	if (maxLines <= 0) return "";
+	const lines = text.split("\n");
+	if (lines.length <= maxLines) return text;
+	return lines.slice(0, maxLines).join("\n");
+}
+function reserveInlineBudgetForSuffix(suffix, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
+	return {
+		maxChars: Math.max(1, maxChars - suffix.length),
+		maxLines: Math.max(1, maxLines - Math.max(0, countSlackLines(suffix) - 1))
+	};
+}
+function forceSplitBudget(text, budget) {
+	const lineCount = countSlackLines(text);
+	return {
+		maxChars: text.length <= budget.maxChars ? Math.max(1, text.length - 1) : budget.maxChars,
+		maxLines: lineCount <= budget.maxLines ? Math.max(1, lineCount - 1) : budget.maxLines
+	};
+}
+function getFenceContinuation(text) {
+	let open;
+	for (const line of text.split("\n")) {
+		const trimmed = line.trimStart();
+		const openerMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
+		if (!openerMatch) continue;
+		if (!open) {
+			open = {
+				fence: openerMatch[1],
+				openerLine: trimmed
+			};
+			continue;
+		}
+		if (new RegExp(`^${open.fence}\\s*$`).test(trimmed)) open = void 0;
+	}
+	if (!open) return null;
+	return {
+		closeSuffix: text.endsWith("\n") ? open.fence : `\n${open.fence}`,
+		reopenPrefix: `${open.openerLine}\n`
+	};
+}
+function appendSlackSuffix(text, marker) {
+	return `${text}${getFenceContinuation(text)?.closeSuffix ?? ""}${marker}`;
+}
+function stripTrailingContinuationMarker(text) {
+	return text.endsWith(CONTINUED_MARKER) ? text.slice(0, -19) : text;
+}
+function takeSlackContinuationChunk(text, budget) {
+	let { prefix, rest } = takeSlackInlinePrefix(text, budget);
+	if (!rest) ({prefix, rest} = takeSlackInlinePrefix(text, forceSplitBudget(text, budget)));
+	let carryover = rest ? getFenceContinuation(prefix) : null;
+	if (!carryover) return {
+		prefix,
+		rest
+	};
+	const carryoverBudget = reserveInlineBudgetForSuffix(`${carryover.closeSuffix}${CONTINUED_MARKER}`);
+	({prefix, rest} = takeSlackInlinePrefix(text, carryoverBudget));
+	if (!rest) ({prefix, rest} = takeSlackInlinePrefix(text, forceSplitBudget(text, carryoverBudget)));
+	carryover = rest ? getFenceContinuation(prefix) : null;
+	if (!carryover) return {
+		prefix,
+		rest
+	};
+	return {
+		prefix,
+		rest: `${carryover.reopenPrefix}${rest}`
+	};
+}
+/** Return the first continuation-safe chunk plus any remaining text. */
+function takeSlackContinuationPrefix(text, options) {
+	const budget = {
+		maxChars: options?.maxChars ?? getSlackContinuationBudget().maxChars,
+		maxLines: options?.maxLines ?? getSlackContinuationBudget().maxLines
+	};
+	const { prefix, rest } = (() => {
+		if (options?.forceSplit) return takeSlackContinuationChunk(text, budget);
+		const initial = takeSlackInlinePrefix(text, budget);
+		return initial.rest ? takeSlackContinuationChunk(text, budget) : initial;
+	})();
+	return {
+		prefix,
+		renderedPrefix: rest ? appendSlackSuffix(prefix, CONTINUED_MARKER) : prefix,
+		rest
+	};
+}
+/**
+* Take the largest Slack-safe inline prefix from `text` under the configured
+* character and line budgets. Returns the consumed prefix plus remaining text.
+*/
+function takeSlackInlinePrefix(text, options) {
+	const maxChars = options?.maxChars ?? MAX_INLINE_CHARS;
+	const maxLines = options?.maxLines ?? MAX_INLINE_LINES;
+	const normalized = text.replace(/\r\n?/g, "\n");
+	if (!normalized) return {
+		prefix: "",
+		rest: ""
+	};
+	if (fitsInlineBudget(normalized, maxChars, maxLines)) return {
+		prefix: normalized,
+		rest: ""
+	};
+	const lineBounded = splitByLineBudget(normalized, maxLines);
+	const cutIndex = findSplitIndex(lineBounded, maxChars);
+	const prefix = lineBounded.slice(0, cutIndex).trimEnd();
+	if (prefix) return {
+		prefix,
+		rest: normalized.slice(prefix.length).trimStart()
+	};
+	const hardPrefix = normalized.slice(0, Math.max(1, maxChars)).trimEnd();
+	return {
+		prefix: hardPrefix || normalized.slice(0, Math.max(1, maxChars)),
+		rest: normalized.slice(hardPrefix.length || Math.max(1, maxChars)).trimStart()
+	};
+}
+/**
+* Split a normalized Slack reply into multiple inline-safe thread messages.
+*
+* Replies split across more than two messages receive explicit continuation
+* markers on non-final chunks. When
+* `interrupted` is true, the final chunk receives an interruption marker.
+*/
+function splitSlackReplyText(text, options) {
+	const normalized = normalizeSlackReplyMarkdown(text);
+	if (!normalized) return [];
+	const chunks = [];
+	const continuationBudget = reserveInlineBudgetForSuffix(CONTINUED_MARKER);
+	let remaining = normalized;
+	while (remaining) {
+		if (options?.interrupted ? fitsInlineBudget(appendSlackSuffix(remaining, getInterruptionMarker())) : fitsInlineBudget(remaining)) {
+			chunks.push(options?.interrupted ? appendSlackSuffix(remaining, getInterruptionMarker()) : remaining);
+			break;
+		}
+		const { renderedPrefix, rest } = takeSlackContinuationPrefix(remaining, {
+			...continuationBudget,
+			forceSplit: true
+		});
+		chunks.push(renderedPrefix);
+		remaining = rest;
+	}
+	if (chunks.length === 2) chunks[0] = stripTrailingContinuationMarker(chunks[0] ?? "");
+	return chunks;
+}
+/**
+* Reserve enough inline budget for a continuation suffix on the current chunk.
+*/
+function getSlackContinuationBudget() {
+	return reserveInlineBudgetForSuffix(CONTINUED_MARKER);
+}
+/** Normalize text for Slack and wrap it as a PostableMessage. */
+function buildSlackOutputMessage(text) {
+	const normalized = normalizeSlackReplyMarkdown(text);
+	if (!normalized) throw new Error(`Slack output normalized to empty content: original_length=${text.length} parsed_length=${normalized.length}`);
+	return { markdown: normalized };
+}
+//#endregion
+//#region src/chat/slack/reply.ts
+/**
+* Send one destination-visible Slack reply.
+*
+* Chunks oversized text, builds compact attribution and conversation footer
+* context, and posts through the shared Slack outbound boundary.
+*/
+async function sendSlackReply(args) {
+	const posts = splitSlackReplyText(args.text).map((text) => ({
+		text,
+		cards: []
+	}));
+	const cards = (args.cards ?? []).map((card) => renderSlackCard(card, args.conversationId));
+	for (let index = 0; index < cards.length; index += 5) {
+		const group = cards.slice(index, index + 5);
+		const lastPost = posts.at(-1);
+		if (index === 0 && lastPost) lastPost.cards = group;
+		else posts.push({
+			text: "",
+			cards: group
+		});
+	}
+	const footer = buildSlackReplyFooter({
+		conversationId: args.conversationId,
+		replyAttribution: args.replyAttribution
+	});
+	const messageTs = [];
+	let threadTs = args.threadTs;
+	for (const [index, post] of posts.entries()) {
+		const { text, cards } = post;
+		const isFinalChunk = index === posts.length - 1;
+		const blocks = buildSlackReplyBlocks(text, void 0) ?? [];
+		for (const card of cards) if (!card.entity) blocks.push({
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: card.text
+			}
+		});
+		if (isFinalChunk || !text.trim()) blocks.push(...buildSlackReplyBlocks("", footer) ?? []);
+		const entities = cards.flatMap((card) => card.entity ? [card.entity] : []);
+		const accessibleText = [text, ...cards.map((card) => card.text)].filter(Boolean).join("\n\n");
+		const fallbackText = isFinalChunk && args.replyAttribution ? `${accessibleText}\n\n${escapeSlackMrkdwnText(formatReplyAttribution(args.replyAttribution))}` : accessibleText;
+		const response = await postSlackMessage({
+			channelId: args.channelId,
+			threadTs,
+			text: fallbackText,
+			...blocks.length ? { blocks } : void 0,
+			...entities.length ? { entities } : void 0
+		});
+		if (response.ts) {
+			messageTs.push(response.ts);
+			threadTs ??= response.ts;
+		}
+	}
+	return messageTs;
+}
+//#endregion
+//#region src/chat/slack/assistant-thread/status-render.ts
+const DEFAULT_STATUS_CONTEXTS = {
+	thinking: "…",
+	searching: "sources",
+	reading: "task",
+	reviewing: "results",
+	drafting: "reply",
+	running: "tasks"
+};
+function formatAssistantStatusText(verb, context) {
+	const normalizedVerb = normalizeSlackStatusText(verb).trim().toLowerCase();
+	const normalizedContext = normalizeSlackStatusText(context ?? "") || DEFAULT_STATUS_CONTEXTS[normalizedVerb] || "";
+	if (!normalizedVerb) return truncateStatusText(normalizedContext || "Working");
+	const displayVerb = `${normalizedVerb[0]?.toUpperCase() ?? ""}${normalizedVerb.slice(1)}`;
+	return truncateStatusText(normalizedContext ? `${displayVerb} ${normalizedContext}` : displayVerb);
+}
+/** Build assistant progress text from a verb and optional context. */
+function makeAssistantStatus(verb, context) {
+	return { text: formatAssistantStatusText(verb, context) };
+}
+/** Normalize a progress update into the visible Slack loading copy. */
+function renderAssistantStatus(args) {
+	const visible = truncateStatusText(normalizeSlackStatusText(args.status.text));
+	return {
+		key: visible,
+		visible
+	};
+}
+/** Select and normalize the loading messages used for Slack status rotation. */
+function selectAssistantLoadingMessages(args) {
+	const random = args.random ?? Math.random;
+	const normalized = Array.from(new Set(args.messages.map((message) => truncateStatusText(normalizeSlackStatusText(message))).filter((message) => message.length > 0)));
+	if (normalized.length === 0) return;
+	const shuffled = [...normalized];
+	for (let index = shuffled.length - 1; index > 0; index -= 1) {
+		const otherIndex = Math.floor(random() * (index + 1));
+		[shuffled[index], shuffled[otherIndex]] = [shuffled[otherIndex], shuffled[index]];
+	}
+	return shuffled.slice(0, 10);
+}
+//#endregion
+//#region src/chat/slack/assistant-thread/status-scheduler.ts
+const STATUS_UPDATE_DEBOUNCE_MS = 1e3;
+const STATUS_MIN_VISIBLE_MS = 1200;
+const STATUS_ROTATION_INTERVAL_MS = 3e4;
+/**
+* Pace assistant loading-state writes for a single turn.
+*
+* This layer owns only local scheduling policy: debounce, minimum visible
+* duration, refresh cadence, and write ordering. It deals in user-visible
+* progress copy; the transport decides how that maps onto Slack's `status`
+* versus `loading_messages` fields.
+*/
+function createAssistantStatusScheduler(args) {
+	const now = args.now ?? (() => Date.now());
+	const setTimer = args.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+	const clearTimer = args.clearTimer ?? ((timer) => clearTimeout(timer));
+	const random = args.random ?? Math.random;
+	const loadingMessages = selectAssistantLoadingMessages({
+		messages: args.loadingMessages ?? [],
+		random
+	});
+	const defaultStatus = makeAssistantStatus("thinking");
+	let active = false;
+	let currentKey = "";
+	let currentVisibleStatus = "";
+	let currentLoadingMessages;
+	let lastStatusAt = 0;
+	let pendingStatus = null;
+	let pendingKey = "";
+	let pendingTimer = null;
+	let rotationTimer = null;
+	let inflightStatusUpdate = Promise.resolve();
+	const enqueueStatusUpdate = (task) => {
+		const request = inflightStatusUpdate.catch(() => void 0).then(async () => {
+			await task();
+		});
+		inflightStatusUpdate = request.catch(() => void 0);
+		return request;
+	};
+	const scheduleRotation = () => {
+		if (rotationTimer) {
+			clearTimer(rotationTimer);
+			rotationTimer = null;
+		}
+		if (!active || !currentVisibleStatus) return;
+		rotationTimer = setTimer(() => {
+			rotationTimer = null;
+			if (!active || !currentVisibleStatus) return;
+			postStatus(currentVisibleStatus, currentLoadingMessages);
+		}, STATUS_ROTATION_INTERVAL_MS);
+	};
+	const getLoadingMessagesForVisibleStatus = (visible) => visible ? [visible] : void 0;
+	const getInitialStatusText = () => {
+		if (loadingMessages?.length) return loadingMessages[0];
+		return defaultStatus.text;
+	};
+	const haveSameLoadingMessages = (left, right) => {
+		if (left === right) return true;
+		if (!left || !right || left.length !== right.length) return false;
+		return left.every((message, index) => message === right[index]);
+	};
+	const postStatus = async (text, nextLoadingMessages) => {
+		if (!text && !currentVisibleStatus) return;
+		currentVisibleStatus = text;
+		currentLoadingMessages = nextLoadingMessages;
+		lastStatusAt = now();
+		scheduleRotation();
+		await enqueueStatusUpdate(async () => {
+			await args.sendStatus(text, nextLoadingMessages);
+		});
+	};
+	const postRenderedStatus = async (status) => {
+		const presentation = renderAssistantStatus({ status });
+		const nextLoadingMessages = getLoadingMessagesForVisibleStatus(presentation.visible);
+		currentKey = presentation.key;
+		await postStatus(presentation.visible, nextLoadingMessages);
+	};
+	const clearPending = () => {
+		if (pendingTimer) {
+			clearTimer(pendingTimer);
+			pendingTimer = null;
+		}
+		pendingStatus = null;
+		pendingKey = "";
+	};
+	const flushPending = async () => {
+		if (!active || !pendingStatus) {
+			clearPending();
+			return;
+		}
+		const next = pendingStatus;
+		clearPending();
+		if (renderAssistantStatus({ status: next }).key !== currentKey) await postRenderedStatus(next);
+	};
+	return {
+		async clear() {
+			active = false;
+			clearPending();
+			if (rotationTimer) {
+				clearTimer(rotationTimer);
+				rotationTimer = null;
+			}
+			currentKey = "";
+			await postStatus("");
+		},
+		update(status) {
+			if (!active) {
+				active = true;
+				clearPending();
+				if (status) {
+					postRenderedStatus(status);
+					return;
+				}
+				currentKey = "initial";
+				postStatus(getInitialStatusText(), loadingMessages);
+				return;
+			}
+			if (!status) {
+				clearPending();
+				currentKey = "initial";
+				postStatus(getInitialStatusText(), loadingMessages);
+				return;
+			}
+			const presentation = renderAssistantStatus({ status });
+			if (!presentation.visible) return;
+			if (presentation.key === currentKey || presentation.key === pendingKey) return;
+			if (presentation.visible === currentVisibleStatus) {
+				clearPending();
+				currentKey = presentation.key;
+				const nextLoadingMessages = getLoadingMessagesForVisibleStatus(presentation.visible);
+				if (!haveSameLoadingMessages(currentLoadingMessages, nextLoadingMessages)) postStatus(presentation.visible, nextLoadingMessages);
+				return;
+			}
+			const elapsed = now() - lastStatusAt;
+			const waitMs = Math.max(STATUS_UPDATE_DEBOUNCE_MS - elapsed, STATUS_MIN_VISIBLE_MS - elapsed, 0);
+			if (waitMs <= 0) {
+				clearPending();
+				postRenderedStatus(status);
+				return;
+			}
+			pendingStatus = status;
+			pendingKey = presentation.key;
+			if (pendingTimer) return;
+			pendingTimer = setTimer(() => {
+				pendingTimer = null;
+				flushPending();
+			}, Math.max(1, waitMs));
+		}
+	};
+}
+//#endregion
+//#region src/chat/slack/assistant-thread/status-send.ts
+/**
+* Slack's assistant loading UI accepts both `status` and `loading_messages`,
+* but product policy keeps `status` stable and generic. User-visible progress
+* copy belongs in `loading_messages`.
+*/
+const SLACK_ASSISTANT_ACTIVE_STATUS = "is working on your request...";
+/**
+* Build a best-effort sender for Slack's assistant loading state.
+*
+* The `text` argument is internal progress copy. This transport maps it onto
+* Slack's loading surface and keeps the raw Slack `status` field fixed.
+*/
+function createSlackAdapterStatusSender(args) {
+	const adapter = args.getSlackAdapter();
+	const boundToken = getSlackAdapterRequestToken(adapter);
+	return async (text, loadingMessages) => {
+		const channelId = args.channelId;
+		const threadTs = args.threadTs;
+		if (!channelId || !threadTs) return;
+		const normalizedChannelId = normalizeSlackConversationId(channelId);
+		if (!normalizedChannelId) return;
+		const nextLoadingMessages = text ? loadingMessages ?? [text] : void 0;
+		try {
+			await runWithBoundSlackToken(adapter, boundToken, () => adapter.setAssistantStatus(normalizedChannelId, threadTs, text ? SLACK_ASSISTANT_ACTIVE_STATUS : "", nextLoadingMessages));
+		} catch (error) {
+			logAssistantStatusFailure({
+				status: text,
+				error,
+				channelId,
+				normalizedChannelId,
+				threadTs
+			});
+		}
+	};
+}
+/**
+* Build a best-effort sender for Slack's assistant loading state over raw Web
+* API calls. As with the adapter-backed path, the dynamic copy goes to
+* `loading_messages` while `status` stays fixed and generic.
+*/
+function createSlackWebApiStatusSender(args) {
+	const getClient = args.getSlackClient ?? getSlackClient;
+	return async (text, loadingMessages) => {
+		const channelId = args.channelId;
+		const threadTs = args.threadTs;
+		if (!channelId || !threadTs) return;
+		const normalizedChannelId = normalizeSlackConversationId(channelId);
+		if (!normalizedChannelId) return;
+		const nextLoadingMessages = text ? loadingMessages ?? [text] : void 0;
+		try {
+			await getClient().assistant.threads.setStatus({
+				channel_id: normalizedChannelId,
+				thread_ts: threadTs,
+				status: text ? SLACK_ASSISTANT_ACTIVE_STATUS : "",
+				...nextLoadingMessages ? { loading_messages: nextLoadingMessages } : void 0
+			});
+		} catch (error) {
+			logAssistantStatusFailure({
+				status: text,
+				error,
+				channelId,
+				normalizedChannelId,
+				threadTs
+			});
+		}
+	};
+}
+function getSlackAdapterRequestToken(adapter) {
+	const token = adapter.requestContext?.getStore()?.token;
+	if (typeof token !== "string") return;
+	return token.trim() || void 0;
+}
+async function runWithBoundSlackToken(adapter, token, task) {
+	if (!token) return await task();
+	return await adapter.withBotToken(token, task);
+}
+function logAssistantStatusFailure(args) {
+	logWarn("assistant.status.update.failed", {
+		"app.slack.status_text": args.status || "(clear)",
+		"app.slack.channel_id_raw": args.channelId,
+		"app.slack.channel_id": args.normalizedChannelId,
+		"app.slack.thread_ts": args.threadTs,
+		"exception.message": args.error instanceof Error ? args.error.message : String(args.error)
+	});
+}
+//#endregion
+//#region src/chat/slack/assistant-thread/status.ts
+/**
+* Create a Slack adapter-backed session for Slack's assistant loading state.
+*
+* The session accepts internal progress updates and leaves it to the sender to
+* map them onto Slack's fixed generic `status` field plus dynamic
+* `loading_messages`.
+*/
+function createSlackAdapterAssistantStatusSession(args) {
+	return createAssistantStatusScheduler({
+		sendStatus: createSlackAdapterStatusSender({
+			channelId: args.channelId,
+			threadTs: args.threadTs,
+			getSlackAdapter: args.getSlackAdapter
+		}),
+		loadingMessages: args.loadingMessages ?? botConfig.loadingMessages,
+		now: args.now,
+		setTimer: args.setTimer,
+		clearTimer: args.clearTimer,
+		random: args.random
+	});
+}
+/**
+* Create a Web API-backed session for Slack's assistant loading state in
+* resume/callback flows that do not use the adapter thread object.
+*/
+function createSlackWebApiAssistantStatusSession(args) {
+	return createAssistantStatusScheduler({
+		sendStatus: createSlackWebApiStatusSender({
+			channelId: args.channelId,
+			threadTs: args.threadTs,
+			getSlackClient: args.getSlackClient
+		}),
+		loadingMessages: args.loadingMessages ?? botConfig.loadingMessages,
+		now: args.now,
+		setTimer: args.setTimer,
+		clearTimer: args.clearTimer,
+		random: args.random
+	});
+}
+//#endregion
 //#region src/chat/slack/assistant-thread/title.ts
 /** Set-once DM title projection for the current process. */
 const projectedAssistantTitles = /* @__PURE__ */ new Set();
@@ -5481,6 +6400,21 @@ async function maybeSyncAssistantTitle(args) {
 	}
 }
 //#endregion
+//#region src/chat/services/auth-pause-response.ts
+const MAX_AUTH_REQUEST_LENGTH = 200;
+function formatAuthRequest(requestText) {
+	const normalized = requestText.replace(/\s+/g, " ").trim();
+	if (!normalized) return;
+	return (normalized.length > MAX_AUTH_REQUEST_LENGTH ? `${normalized.slice(0, 199).trimEnd()}…` : normalized).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+/** Build the visible Slack thread note for an auth-paused turn. */
+function buildAuthPauseResponse(slackUserId, providerDisplayName, requestText) {
+	const mention = slackUserId ? `<@${slackUserId}> ` : "";
+	const request = requestText ? formatAuthRequest(requestText) : void 0;
+	if (!request) return `${mention}I'll need you to authorize ${providerDisplayName}. I sent you a link.`;
+	return `${mention}I need access to ${providerDisplayName} to continue.\n\n*Why:* ${request}\n\nI sent you a link.`;
+}
+//#endregion
 //#region src/chat/services/provider-default-config.ts
 const GITHUB_REPO_PART = String.raw`[A-Za-z0-9_.-]*[A-Za-z0-9_-]`;
 const GITHUB_REPO_RE = new RegExp(String.raw`^\s*(?:set|use)\s+(?:the\s+)?default\s+(?:github\s+)?repo(?:sitory)?\s+(?:to|as)\s+(${GITHUB_REPO_PART}/${GITHUB_REPO_PART})(?:\s+for\s+this\s+channel)?[.!?]?\s*$`, "i");
@@ -6930,6 +7864,506 @@ function createJuniorSlackAdapter(config) {
 	return createSlackAdapter(config);
 }
 //#endregion
+//#region src/chat/providers/slack/resume.ts
+/**
+* Resume a Slack Turn from saved Run state.
+*
+* Resumed Turns load their saved Run while holding the Slack thread lock.
+* Status notices are best effort. Completed assistant replies and
+* authorization pause notices use `sendSlackReply` so the footer stays
+* consistent.
+*/
+function resolveReplyTimeoutMs() {
+	const raw = process.env.EVAL_AGENT_REPLY_TIMEOUT_MS?.trim();
+	if (!raw) return;
+	const parsed = Number.parseInt(raw, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+async function postSlackMessageBestEffort(channelId, threadTs, text, conversationId, replyAttribution) {
+	try {
+		if (conversationId) {
+			await sendSlackReply({
+				channelId,
+				conversationId,
+				replyAttribution,
+				text,
+				threadTs
+			});
+			return;
+		}
+		await postSlackMessage({
+			channelId,
+			threadTs,
+			text
+		});
+	} catch {}
+}
+/** Create a read-only configuration service from persisted values. */
+function createReadOnlyConfigService(rawValues) {
+	const values = Object.fromEntries(Object.entries(rawValues).map(([key, value]) => [key, configValueSchema.parse(value)]));
+	const entries = Object.entries(values).map(([key, value]) => ({
+		key,
+		value,
+		scope: "location",
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	}));
+	return {
+		get: async (key) => entries.find((entry) => entry.key === key),
+		set: async () => {
+			throw new Error("Configuration is read-only for a resumed Run");
+		},
+		unset: async () => false,
+		list: async ({ prefix } = {}) => entries.filter((entry) => !prefix || entry.key.startsWith(prefix)),
+		resolve: async (key) => values[key],
+		resolveValues: async ({ keys, prefix } = {}) => {
+			const filtered = {};
+			for (const [key, value] of Object.entries(values)) {
+				if (prefix && !key.startsWith(prefix)) continue;
+				if (keys && !keys.includes(key)) continue;
+				filtered[key] = value;
+			}
+			return filtered;
+		}
+	};
+}
+function getResumeLogContext(args) {
+	const actor = args.run?.actor;
+	return {
+		conversationId: args.conversationId,
+		messageConversationId: args.conversationId,
+		userId: isUserActor(actor) ? actor.userId : void 0,
+		userName: isUserActor(actor) ? actor.userName : void 0,
+		destinationName: args.channelId,
+		assistantUserName: botConfig.userName,
+		modelId: defaultModelId(botConfig)
+	};
+}
+async function postResumeFailureReply(args) {
+	await postSlackMessage({
+		channelId: args.channelId,
+		threadTs: args.threadTs,
+		text: buildTurnErrorResponse(args.error, args.eventId)
+	});
+}
+async function handleResumeFailure(args) {
+	const turnLifecycle = getTurnLifecycle();
+	const capturedEventId = logException(args.error, args.eventName);
+	const eventId = requireTurnFailureEventId(capturedEventId, args.eventName);
+	let failureStatePersistError;
+	try {
+		await args.resume.onFailure?.(args.error);
+	} catch (persistError) {
+		const persistEventId = logException(persistError, "slack.resume.failure_state_persist.failed", { "app.error.original_event_id": eventId });
+		try {
+			await turnLifecycle.fail({
+				conversationId: args.resume.conversationId,
+				turnId: args.resume.turnId,
+				createdAtMs: Date.now(),
+				failureCode: "persistence_failed",
+				...persistEventId ? { eventId: persistEventId } : void 0
+			});
+		} catch (lifecycleError) {
+			logException(lifecycleError, "slack.resume.failure_lifecycle_persist.failed", { "app.error.original_event_id": eventId });
+		}
+		failureStatePersistError = persistError;
+	}
+	try {
+		await postResumeFailureReply({
+			channelId: args.resume.channelId,
+			threadTs: args.resume.threadTs,
+			eventId,
+			error: args.error
+		});
+	} catch (deliveryError) {
+		const deliveryEventId = logException(deliveryError, "slack.resume.failure_delivery.failed", { "app.error.original_event_id": eventId });
+		try {
+			await turnLifecycle.fail({
+				conversationId: args.resume.conversationId,
+				turnId: args.resume.turnId,
+				createdAtMs: Date.now(),
+				failureCode: "delivery_failed",
+				...deliveryEventId ? { eventId: deliveryEventId } : void 0
+			});
+		} catch (lifecycleError) {
+			logException(lifecycleError, "slack.resume.failure_lifecycle_persist.failed", { "app.error.original_event_id": eventId });
+		}
+		throw deliveryError;
+	}
+	if (failureStatePersistError) throw failureStatePersistError;
+	await turnLifecycle.fail({
+		conversationId: args.resume.conversationId,
+		turnId: args.resume.turnId,
+		createdAtMs: Date.now(),
+		failureCode: args.failureCode,
+		eventId
+	});
+}
+function buildResumedRun(args, statusSession, delivery) {
+	const savedRun = args.run;
+	if (!savedRun) throw new TypeError("Slack resume requires a saved Run");
+	if (!savedRun.source) throw new TypeError("Slack resume requires a Run Source");
+	const source = savedRun.source;
+	if (savedRun.destination.platform !== "slack") throw new TypeError("Slack resume requires a Slack Destination");
+	const requestDeadline = getTurnRequestDeadline();
+	const threadId = args.conversationId;
+	const persistedLocationConfiguration = savedRun.environment?.locationConfiguration ?? (savedRun.environment?.configuration ? createReadOnlyConfigService(savedRun.environment.configuration) : void 0);
+	const priorOnEvent = savedRun.onEvent;
+	return {
+		...savedRun,
+		conversationId: args.conversationId,
+		turnId: args.turnId,
+		instruction: {
+			...savedRun.instruction ?? { text: args.messageText },
+			text: args.messageText
+		},
+		source: source.kind === "slack" ? {
+			...source,
+			channelId: args.channelId,
+			...args.threadTs ? { threadTs: args.threadTs } : void 0
+		} : source,
+		deadlineAtMs: savedRun.deadlineAtMs ?? requestDeadline?.deadlineAtMs,
+		environment: {
+			...savedRun.environment,
+			locationConfiguration: persistedLocationConfiguration
+		},
+		onEvent: async (event) => {
+			if (event.type === "status") statusSession.update({ text: event.text });
+			await priorOnEvent?.(event);
+		},
+		...savedRun.dispatch?.outcomes?.length === 0 ? void 0 : { delivery },
+		durability: {
+			...savedRun.durability,
+			onSandboxRefChanged: async (sandboxRef) => {
+				await persistThreadStateById(threadId, { sandboxRef });
+				await savedRun.durability?.onSandboxRefChanged?.(sandboxRef);
+			}
+		}
+	};
+}
+/**
+* Resume a paused Slack Turn.
+*
+* The caller must hold the conversation work lease. This function does not
+* acquire another execution lock. A started resume owns its completion work.
+* Returns false only when `beforeStart` proves the resume is stale before
+* generation begins.
+*/
+async function resumeSlackTurn(args) {
+	return withLogContext(getResumeLogContext(args), () => resumeSlackTurnInContext(args));
+}
+async function resumeSlackTurnInContext(args) {
+	const status = createSlackWebApiAssistantStatusSession({
+		channelId: args.channelId,
+		threadTs: args.threadTs
+	});
+	let processingReaction;
+	let deferredAuthInfo;
+	let deferredPauseHandler;
+	let deferredFailureHandler;
+	let runResultHandled = false;
+	let assistantMessageDelivered = false;
+	let shouldScheduleCompletedPluginTasks = false;
+	let postDeliveryCommitError;
+	const turnLifecycle = getTurnLifecycle();
+	let failureCode = "agent_run_failed";
+	let runArgs = args;
+	try {
+		const preparedArgs = await args.beforeStart?.();
+		if (preparedArgs === false) return false;
+		if (preparedArgs) runArgs = {
+			...args,
+			...preparedArgs
+		};
+		setTags(getResumeLogContext(runArgs));
+		const savedRun = runArgs.run;
+		if (!savedRun) throw new Error("Resumed Turn requires a saved Run");
+		const credentialContext = savedRun.credentialContext;
+		if (!credentialContext) throw new Error("Resumed Run requires a credential context");
+		const routingActor = savedRun.actor;
+		let resumeActor;
+		if ("type" in credentialContext.actor) {
+			if (!isUserActor(routingActor) || credentialContext.actor.userId !== routingActor.userId) throw new Error("Resumed Run credential actor must match its Actor");
+			resumeActor = routingActor;
+		} else {
+			if (routingActor && (routingActor.platform !== "system" || routingActor.name !== credentialContext.actor.name)) throw new Error("Resumed Run system credential actor must match its Actor");
+			resumeActor = credentialContext.actor;
+		}
+		if (runArgs.messageTs) processingReaction = await startProcessingReactionForMessage({
+			channelId: runArgs.channelId,
+			timestamp: runArgs.messageTs
+		});
+		if (runArgs.initialText) await postSlackMessageBestEffort(runArgs.channelId, runArgs.threadTs, runArgs.initialText);
+		status.update(runArgs.initialStatus);
+		const conversationId = runArgs.conversationId;
+		const visibility = (await getConversationStore().get({ conversationId }))?.visibility;
+		const visibleConversationId = args.conversationId;
+		const sessionId = runArgs.turnId;
+		let deliveryConversation;
+		let acceptedDeliveryId;
+		/** Load the resumed conversation once for ordered delivery recording. */
+		const getDeliveryConversation = async () => {
+			if (deliveryConversation) {
+				const userMessageId = getTurnUserMessage(deliveryConversation, sessionId)?.id;
+				return {
+					conversation: deliveryConversation,
+					sessionId,
+					...userMessageId ? { userMessageId } : void 0
+				};
+			}
+			const persistedState = await getPersistedThreadState(visibleConversationId);
+			const conversation = coerceThreadConversationState(persistedState);
+			await hydrateConversationMessages({
+				conversation,
+				conversationId
+			});
+			deliveryConversation = conversation;
+			const userMessageId = getTurnUserMessage(conversation, sessionId)?.id;
+			return {
+				conversation,
+				sessionId,
+				...userMessageId ? { userMessageId } : void 0
+			};
+		};
+		/** Post and record one completed assistant message for the resumed turn. */
+		const deliverAssistantMessage = async (reply) => {
+			const message = typeof reply === "string" ? void 0 : reply;
+			const text = typeof reply === "string" ? reply : getAssistantReplyText(reply);
+			if (!text?.trim()) return;
+			failureCode = "delivery_failed";
+			const cards = await loadPendingMessageCards(conversationId);
+			const deliveryState = await getDeliveryConversation();
+			let slackMessageTs = [];
+			try {
+				const outcomes = runArgs.run?.dispatch?.outcomes;
+				if (outcomes) for (const outcome of outcomes) slackMessageTs.push(...await sendSlackReply({
+					cards,
+					channelId: outcome.destination.channelId,
+					conversationId: runArgs.conversationId,
+					replyAttribution: runArgs.run?.dispatch?.replyAttribution,
+					text,
+					threadTs: outcome.destination.threadTs
+				}));
+				else slackMessageTs = await sendSlackReply({
+					cards,
+					channelId: runArgs.channelId,
+					conversationId: runArgs.conversationId,
+					replyAttribution: runArgs.run?.dispatch?.replyAttribution,
+					text,
+					threadTs: runArgs.threadTs
+				});
+			} catch (error) {
+				if (isRetryableSlackPostError(error)) throw new RetryableDeliveryError(error);
+				throw error;
+			}
+			const messageTs = slackMessageTs.at(-1);
+			assistantMessageDelivered = true;
+			acceptedDeliveryId = messageTs;
+			const recordedMessageId = recordDeliveredAssistantMessage({
+				cards,
+				conversation: deliveryState.conversation,
+				sessionId: deliveryState.sessionId,
+				source: "slack",
+				text,
+				userMessageId: deliveryState.userMessageId
+			});
+			if (messageTs) markConversationMessage(deliveryState.conversation, recordedMessageId, { slackTs: messageTs });
+			try {
+				const destination = runArgs.run?.destination;
+				const providerConversationIds = runArgs.threadTs ? [runArgs.threadTs] : slackMessageTs;
+				await persistWithRetry(() => commitAcceptedReply({
+					...message ? { agentMessage: message } : void 0,
+					conversation: deliveryState.conversation,
+					conversationMessageId: recordedMessageId,
+					conversationId,
+					...runArgs.run?.dispatch && destination?.platform === "slack" && providerConversationIds.length > 0 ? { providerConversationBindings: providerConversationIds.map((providerConversationId) => ({
+						provider: "slack",
+						providerDestinationId: destination.channelId,
+						providerTenantId: destination.teamId,
+						providerConversationId
+					})) } : void 0
+				}));
+			} catch (error) {
+				logException(error, "slack.resume.assistant_message_post_delivery_persist.failed");
+			}
+			const dispatchId = savedRun.dispatch?.id;
+			if (messageTs && dispatchId) try {
+				await persistWithRetry(() => recordTurnSummary({
+					conversationId: runArgs.conversationId,
+					destination: savedRun.destination,
+					destinationVisibility: visibility,
+					dispatchId,
+					resultMessageId: messageTs,
+					turnId: runArgs.turnId,
+					sliceId: runArgs.sliceId ?? 1,
+					source: savedRun.source,
+					state: "running",
+					surface: savedRun.surface ?? "slack"
+				}));
+			} catch (error) {
+				logException(error, "agent.turn.delivery_receipt_persist.failed");
+			}
+			failureCode = "agent_run_failed";
+		};
+		const deliveryState = await getDeliveryConversation();
+		assistantMessageDelivered = turnHasReply(deliveryState.conversation, sessionId);
+		const run = buildResumedRun(runArgs, status, deliverAssistantMessage);
+		if (runArgs.inputMessageIds?.length) await turnLifecycle.start({
+			conversationId: runArgs.conversationId,
+			turnId: runArgs.turnId,
+			createdAtMs: Date.now(),
+			inputMessageIds: [...new Set(runArgs.inputMessageIds)],
+			surface: "slack"
+		});
+		const replyTimeoutMs = resolveReplyTimeoutMs();
+		const outcome = await runArgs.executeTurn(run, async (result) => {
+			const finalized = finalizeFailedTurnReplyWithEvent({
+				reply: result,
+				logException
+			});
+			const reply = finalized.reply;
+			const dispatchErrorMessage = run.dispatch && reply.diagnostics.outcome !== "success" ? reply.diagnostics.errorMessage ?? `Agent turn ended with ${reply.diagnostics.outcome}.` : void 0;
+			if (reply.diagnostics.outcome !== "success") await deliverAssistantMessage(reply.text);
+			runResultHandled = true;
+			await status.clear();
+			failureCode = "persistence_failed";
+			if (reply.piMessages?.length) await saveTurnCheckpoint({
+				mode: "completed",
+				conversationId: runArgs.conversationId,
+				turnId: runArgs.turnId,
+				messages: reply.piMessages,
+				durationMs: reply.diagnostics.durationMs,
+				usage: reply.diagnostics.usage,
+				destination: run.destination,
+				destinationVisibility: visibility,
+				dispatchId: run.dispatch?.id,
+				dispatchOutcome: reply.diagnostics.outcome === "success" ? "completed" : "failed",
+				...dispatchErrorMessage ? { errorMessage: dispatchErrorMessage } : void 0,
+				...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : void 0,
+				source: run.source,
+				actor: resumeActor,
+				surface: run.surface ?? "slack",
+				sliceId: runArgs.sliceId
+			});
+			else if (run.dispatch?.id) await recordTurnSummary({
+				conversationId: runArgs.conversationId,
+				destination: run.destination,
+				destinationVisibility: visibility,
+				dispatchId: run.dispatch?.id,
+				dispatchOutcome: reply.diagnostics.outcome === "success" ? "completed" : "failed",
+				...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : void 0,
+				turnId: runArgs.turnId,
+				sliceId: runArgs.sliceId ?? 1,
+				source: run.source,
+				state: reply.diagnostics.outcome === "success" ? "completed" : "failed",
+				surface: run.surface ?? "slack"
+			});
+			await runArgs.commitResult?.(reply);
+			if (reply.diagnostics.outcome === "success") {
+				shouldScheduleCompletedPluginTasks = true;
+				return { outcome: assistantMessageDelivered ? "success" : "no_reply" };
+			}
+			return {
+				outcome: "failed",
+				failureCode: "model_execution_failed",
+				...finalized.eventId ? { eventId: finalized.eventId } : void 0,
+				...finalized.failureReason ? { failureReason: finalized.failureReason } : void 0
+			};
+		}, replyTimeoutMs);
+		if (outcome.status !== "completed") {
+			await status.clear();
+			const onAuthPause = runArgs.onAuthPause;
+			const onSuspend = runArgs.onSuspend;
+			if (outcome.status === "awaiting_auth" && onAuthPause) {
+				deferredAuthInfo = {
+					providerDisplayName: outcome.providerDisplayName,
+					actorId: isUserActor(resumeActor) ? resumeActor.userId : void 0,
+					...outcome.requestText ? { requestText: outcome.requestText } : void 0
+				};
+				deferredPauseHandler = async () => {
+					await onAuthPause({ providerDisplayName: outcome.providerDisplayName });
+				};
+			} else if (outcome.status === "suspended") {
+				if (outcome.reason === "timeout" || savedRun.durability?.shouldYield?.()) throw new CooperativeTurnYieldError();
+				if (onSuspend) deferredPauseHandler = async () => {
+					await onSuspend(outcome.resumeVersion);
+				};
+				else deferredFailureHandler = async () => {
+					await handleResumeFailure({
+						error: /* @__PURE__ */ new Error("Resumed Run ended suspended without onSuspend"),
+						eventName: "slack.resume.turn.failed",
+						failureCode: "agent_run_failed",
+						resume: runArgs
+					});
+				};
+			} else deferredFailureHandler = async () => {
+				await handleResumeFailure({
+					error: /* @__PURE__ */ new Error(`Resumed Run ended ${outcome.status} without its required callback`),
+					eventName: "slack.resume.turn.failed",
+					failureCode: "agent_run_failed",
+					resume: runArgs
+				});
+			};
+		}
+		if (shouldScheduleCompletedPluginTasks) try {
+			const params = {
+				conversationId: runArgs.conversationId,
+				sessionId: runArgs.turnId
+			};
+			await (runArgs.scheduleSessionCompletedPluginTasks ?? scheduleSessionCompletedPluginTasks)(params);
+		} catch (scheduleError) {
+			logException(scheduleError, "plugin.session.completed_task_schedule.failed");
+		}
+	} catch (error) {
+		await status.clear();
+		const runError = error instanceof AgentRunError ? error.cause : error;
+		if (isCooperativeTurnYieldError(runError)) throw runError;
+		if (runResultHandled) {
+			postDeliveryCommitError = error;
+			try {
+				await runArgs.onPostDeliveryCommitFailure?.(error);
+			} catch (terminalizeError) {
+				logException(terminalizeError, "slack.resume.post_delivery_terminalize.failed");
+			}
+		} else deferredFailureHandler = async () => {
+			await handleResumeFailure({
+				error: runError,
+				eventName: "slack.resume.turn.failed",
+				failureCode,
+				resume: runArgs
+			});
+		};
+	} finally {
+		if (runResultHandled) await processingReaction?.complete();
+		else await processingReaction?.stop();
+	}
+	if (postDeliveryCommitError) {
+		const eventId = logException(postDeliveryCommitError, "slack.resume.success_handler.failed");
+		await turnLifecycle.fail({
+			conversationId: runArgs.conversationId,
+			turnId: runArgs.turnId,
+			createdAtMs: Date.now(),
+			failureCode: "persistence_failed",
+			...eventId ? { eventId } : void 0
+		});
+		throw postDeliveryCommitError;
+	}
+	if (deferredPauseHandler) try {
+		await deferredPauseHandler();
+		if (deferredAuthInfo) await postSlackMessageBestEffort(runArgs.channelId, runArgs.threadTs, buildAuthPauseResponse(deferredAuthInfo.actorId, deferredAuthInfo.providerDisplayName, deferredAuthInfo.requestText), runArgs.conversationId, runArgs.run?.dispatch?.replyAttribution);
+		return true;
+	} catch (pauseError) {
+		await handleResumeFailure({
+			error: pauseError,
+			eventName: "slack.resume.pause_handler.failed",
+			failureCode: "persistence_failed",
+			resume: runArgs
+		});
+		return true;
+	}
+	if (deferredFailureHandler) await deferredFailureHandler();
+	return true;
+}
+//#endregion
 //#region src/chat/task-execution/paused-turn.ts
 /**
 * Worker continue for paused turns under the conversation lease.
@@ -7041,7 +8475,7 @@ async function resolveSlackResumeUserActor(args) {
 *
 * Sources, in order:
 * 1. Actor saved on the Turn.
-* 2. Actor and credentials supplied by dispatch or OAuth.
+* 2. Actor and credentials supplied by dispatch.
 * 3. Legacy Event or Slack Message data.
 *
 * TODO(dcramer): Remove the routing and Message Actor fallbacks after no
@@ -7070,7 +8504,7 @@ async function resolveResumeExecutionIdentity(args) {
 	};
 }
 function isPausedTurn(summary) {
-	return summary.state === "paused" && (summary.resumeReason === "timeout" || summary.resumeReason === "yield" || summary.resumeReason === "retry");
+	return summary.state === "paused" && (summary.resumeReason === "timeout" || summary.resumeReason === "yield" || summary.resumeReason === "retry" || summary.resumeReason === "auth");
 }
 async function failPausedTurn(args) {
 	const failed = await failTurnRecord({
@@ -7118,8 +8552,6 @@ async function runPausedTurnInContext(payload, options, runOptions) {
 		turnId: payload.turnId,
 		channelId: thread?.channelId ?? destination.channelId,
 		...thread?.threadTs ? { threadTs: thread.threadTs } : void 0,
-		lockKey: payload.conversationId,
-		ownsConversationLease: true,
 		executeTurn: async (run, saveResult, timeoutMs) => await executeTurn(options.agentRunner, run, saveResult, timeoutMs),
 		scheduleSessionCompletedPluginTasks: options.scheduleSessionCompletedPluginTasks,
 		beforeStart: async () => {
@@ -7129,7 +8561,7 @@ async function runPausedTurnInContext(payload, options, runOptions) {
 					conversationId: payload.conversationId,
 					turnId: payload.turnId
 				})).record;
-				if (!turn || turn.state !== "paused" || turn.resumeReason !== "timeout" && turn.resumeReason !== "yield" && turn.resumeReason !== "retry" || turn.version !== payload.expectedVersion) return false;
+				if (!turn || turn.state !== "paused" || turn.resumeReason !== "timeout" && turn.resumeReason !== "yield" && turn.resumeReason !== "retry" && turn.resumeReason !== "auth" || turn.version !== payload.expectedVersion) return false;
 				const activeTurn = turn;
 				const { dispatch, surface } = options.routingContext ?? {};
 				const currentState = await getPersistedThreadState(payload.conversationId);
@@ -7149,7 +8581,22 @@ async function runPausedTurnInContext(payload, options, runOptions) {
 					});
 					return false;
 				}
-				if (conversation.processing.activeTurnId !== payload.turnId) return false;
+				const authorization = turn.resumeReason === "auth" ? await getTurnAuthorization(turn) : void 0;
+				if (turn.resumeReason === "auth") {
+					if (!authorization) return false;
+					const pendingAuth = conversation.processing.pendingAuth;
+					if (pendingAuth && (pendingAuth.sessionId !== turn.turnId || pendingAuth.actorId !== authorization.actorId || pendingAuth.provider !== authorization.provider || pendingAuth.kind !== authorization.kind || pendingAuth.scope !== authorization.scope || pendingAuth.kind === "mcp" && pendingAuth.authSessionId !== authorization.authSessionId || !isPendingAuthLatestRequest(conversation, pendingAuth))) {
+						await abandonTurnRecord({
+							conversationId: payload.conversationId,
+							turnId: turn.turnId,
+							errorMessage: "Authorization no longer belongs to the latest request"
+						});
+						clearPendingAuth(conversation, turn.turnId);
+						await persistThreadStateById(payload.conversationId, { conversation });
+						return false;
+					}
+					if (!pendingAuth && conversation.processing.activeTurnId !== turn.turnId) return false;
+				} else if (conversation.processing.activeTurnId !== payload.turnId) return false;
 				const identity = await resolveResumeExecutionIdentity({
 					actor: activeTurn.actor,
 					conversationId: payload.conversationId,
@@ -7166,6 +8613,15 @@ async function runPausedTurnInContext(payload, options, runOptions) {
 					return false;
 				}
 				const { actor, credentialContext } = identity;
+				if (authorization && (!("userId" in actor) || actor.userId !== authorization.actorId)) throw new Error("Authorization actor does not match the paused Turn");
+				if (authorization) {
+					await recordAuthorizationCompleted({
+						conversationId: payload.conversationId,
+						...authorization
+					});
+					conversation.processing.activeTurnId = turn.turnId;
+					await persistThreadStateById(payload.conversationId, { conversation });
+				}
 				const locationConfiguration = getLocationConfigurationService(destination);
 				const conversationContext = dispatchId ? void 0 : buildConversationContext(conversation, { excludeMessageId: userMessage.id });
 				const sandboxRef = getPersistedSandboxState(currentState);
@@ -7207,8 +8663,11 @@ async function runPausedTurnInContext(payload, options, runOptions) {
 						...routing.location ? { location: routing.location } : void 0,
 						source,
 						...surface ? { surface } : void 0,
-						toolChannelId: destination.channelId,
-						environment: { locationConfiguration },
+						toolChannelId: authorization?.toolChannelId ?? destination.channelId,
+						environment: {
+							configuration: authorization?.configuration,
+							locationConfiguration
+						},
 						state: {
 							pendingAuth: conversation.processing.pendingAuth,
 							sandboxRef
@@ -7359,16 +8818,10 @@ async function runNextPausedTurnInContext(conversationId, options, runOptions) {
 			await persistThreadStateById(conversationId, { conversation });
 			return false;
 		}
-		const state = getStateAdapter();
-		await state.connect();
-		await withActiveLock(state, conversationId, async () => {
-			const record = await getTurnRecordForResume(conversationId, running.turnId);
-			if (!record || record.state !== "running") return;
-			await failStrandedTurnWithFallback({
-				conversationId,
-				errorMessage: "Turn lost its worker before reaching a safe boundary",
-				turn: record
-			});
+		await failStrandedTurnWithFallback({
+			conversationId,
+			errorMessage: "Turn lost its worker before reaching a safe boundary",
+			turn: running
 		});
 		return false;
 	}
@@ -7379,6 +8832,7 @@ async function runNextPausedTurnInContext(conversationId, options, runOptions) {
 			turnId: summary.turnId
 		});
 		if (!request) {
+			if (summary.resumeReason === "auth") continue;
 			await failPausedTurn({
 				conversationId,
 				summary,
@@ -10362,16 +11816,10 @@ async function createApp(options) {
 		storage: attachmentStorage
 	}));
 	app.get("/api/oauth/callback/mcp/:provider", (c) => {
-		return GET$4(c.req.raw, c.req.param("provider"), waitUntil, {
-			agentRunner,
-			conversationWorkQueue: getVercelConversationWorkQueue()
-		});
+		return GET$4(c.req.raw, c.req.param("provider"), waitUntil, { conversationWorkQueue: getVercelConversationWorkQueue() });
 	});
 	app.get("/api/oauth/callback/:provider", (c) => {
-		return GET$5(c.req.raw, c.req.param("provider"), waitUntil, {
-			agentRunner,
-			conversationWorkQueue: getVercelConversationWorkQueue()
-		});
+		return GET$5(c.req.raw, c.req.param("provider"), waitUntil, { conversationWorkQueue: getVercelConversationWorkQueue() });
 	});
 	app.get("/api/internal/sandbox-egress/signals", (c) => {
 		return GET(c.req.raw);