@sentry/junior 0.85.0 → 0.87.0

package/dist/app.js

@@ -3,27 +3,31 @@ import {
   PluginCredentialFailureError,
   SANDBOX_EGRESS_PROXY_PATH,
   TurnInputCommitLostError,
+  TurnInputDeferredError,
   addReactionToMessage,
   appendSlackLegacyAttachmentText,
   applyPendingAuthUpdate,
   buildConversationContext,
   buildDeliveredTurnStatePatch,
   buildDeterministicTurnId,
+  buildSteeringPiMessage,
   clearPendingAuth,
   coerceThreadArtifactsState,
+  completeDeliveredTurn,
   createConversationMemoryService,
   createUserTokenStore,
   deleteMcpAuthSession,
-  deleteSlackMessage,
   deliverResourceEventSubscription,
   estimateTextTokens,
   executeCredentialedEgressRequest,
+  finalizeFailedTurnReply,
   finalizeMcpAuthorization,
   findMatchingResourceEventSubscriptions,
   formatProviderLabel,
   generateAssistantReply,
   generateConversationId,
   getAgentContextCompactionTriggerTokens,
+  getAgentTurnDiagnosticsAttributes,
   getChannelConfigurationService,
   getChannelConfigurationServiceById,
   getConfigDefaults,
@@ -37,9 +41,9 @@ import {
   isCooperativeTurnYieldError,
   isHumanConversationMessage,
   isPendingAuthLatestRequest,
-  isRedundantReactionAckText,
   isRetryableTurnError,
   isTurnInputCommitLostError,
+  isTurnInputDeferredError,
   listThreadReplies,
   markConversationMessage,
   markTurnClosed,
@@ -49,12 +53,15 @@ import {
   normalizeSandboxEgressTracePropagationDomains,
   parseOAuthStatePayload,
   parseSandboxEgressCredentialToken,
+  persistCompletedSessionRecord,
   persistThreadState,
   persistThreadStateById,
+  persistYieldSessionRecord,
   postSlackMessage,
   processPluginTask,
   removeReactionFromMessage,
   renderSlackLegacyAttachmentText,
+  requireTurnFailureEventId,
   resolveBaseUrl,
   resolvePluginOAuthAccount,
   resolveSandboxEgressProviderForHost,
@@ -68,37 +75,41 @@ import {
   updateConversationStats,
   uploadFilesToThread,
   upsertConversationMessage
-} from "./chunk-MHEV3T2Y.js";
+} from "./chunk-B6FQPS7A.js";
 import {
   CONVERSATION_WORK_CHECK_IN_INTERVAL_MS,
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
+  ackMessages,
   appendInboundMessage,
   checkInConversationWork,
   clearConsumedConversationWake,
   clearExpiredConversationLease,
   completeConversationWork,
+  deadLetterAttempt,
   drainConversationMailbox,
   getConversation,
   getConversationWorkState,
+  isFinalAttempt,
+  isInvalidConversationRecordError,
   listActiveConversationIds,
-  markConversationMessagesInjected,
   markConversationWorkEnqueued,
+  recordAttemptFailure,
   releaseConversationWork,
   removeActiveConversation,
   requestConversationContinuation,
   requestConversationWork,
   startConversationWork
-} from "./chunk-EENOFKDN.js";
+} from "./chunk-ENPSU7L7.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS,
   coerceThreadConversationState
 } from "./chunk-66NX7MNW.js";
-import "./chunk-FYPO4K7C.js";
+import "./chunk-RIB3M6YA.js";
 import {
   getVercelConversationWorkQueue,
   resolveConversationWorkQueueTopic,
   verifyConversationQueueMessage
-} from "./chunk-ENEWQMRJ.js";
+} from "./chunk-6O5UI3RG.js";
 import {
   PLUGIN_TASK_QUEUE_TOPIC,
   createVercelQueueClient,
@@ -107,18 +118,18 @@ import {
 import {
   GET,
   buildSentryConversationUrl,
+  conversationVisibilityFromSlackChannelType,
   initConversationContext,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext,
   setConversationTitle
-} from "./chunk-SSUEWAVS.js";
+} from "./chunk-JRXCSSSU.js";
 import {
   abandonAgentTurnSessionRecord,
   buildSlackOutputMessage,
   commitMessages,
   failAgentTurnSessionRecord,
   getAgentTurnSessionRecord,
-  getInterruptionMarker,
   listAgentTurnSessionSummariesForConversation,
   loadProjection,
   normalizeSlackStatusText,
@@ -126,7 +137,7 @@ import {
   recordAuthorizationCompleted,
   splitSlackReplyText,
   truncateStatusText
-} from "./chunk-GY7L6VCT.js";
+} from "./chunk-ACJJJEGG.js";
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
@@ -146,20 +157,20 @@ import {
   setPlugins,
   validatePlugins,
   verifySlackDirectCredentialSubject
-} from "./chunk-UVNV67EC.js";
+} from "./chunk-2NFV5FMB.js";
 import {
   createPluginLogger,
   createPluginState
-} from "./chunk-MTE5NRPJ.js";
+} from "./chunk-BRSQQRG6.js";
 import {
   getConversationStore,
   getDb
-} from "./chunk-QTTTRBNB.js";
+} from "./chunk-6I6HBOQM.js";
 import "./chunk-G3E7SCME.js";
 import {
   acquireActiveLock,
   getStateAdapter
-} from "./chunk-RUB77TGS.js";
+} from "./chunk-GB5DFM4D.js";
 import {
   SlackActionError,
   createSlackDestination,
@@ -167,15 +178,17 @@ import {
   downloadPrivateSlackFile,
   getHeaderString,
   getSlackClient,
+  getWorkspaceTeamId,
   isDmChannel,
   normalizeSlackConversationId,
   parseDestination,
   requireSlackDestination,
+  runWithSlackInstallationToken,
+  runWithWorkspaceTeamId,
   sameDestination
-} from "./chunk-C2PSUWK3.js";
+} from "./chunk-GGD6WK6V.js";
 import {
   FUNCTION_TIMEOUT_BUFFER_SECONDS,
-  GEN_AI_PROVIDER_NAME,
   botConfig,
   completeObject,
   completeText,
@@ -193,12 +206,12 @@ import {
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   unwrapCurrentInstruction
-} from "./chunk-BU2AWPEN.js";
+} from "./chunk-ZU2ALUVQ.js";
 import {
   parseSlackThreadId,
   resolveSlackChannelIdFromMessage,
   resolveSlackChannelIdFromThreadId
-} from "./chunk-DR75T7J3.js";
+} from "./chunk-L7OHKDOX.js";
 import {
   discoverSkills
 } from "./chunk-64ACM6AP.js";
@@ -495,96 +508,25 @@ async function postSlackApiReplyPosts(args) {
   return lastPostedMessageTs;
 }
 
-// src/chat/services/turn-failure-response.ts
-function requireTurnFailureEventId(eventId, eventName) {
-  if (!eventId) {
-    throw new Error(`Sentry did not return an event ID for ${eventName}`);
-  }
-  return eventId;
-}
-function getExecutionFailureReason(reply) {
-  const errorMessage = reply.diagnostics.errorMessage?.trim();
-  if (errorMessage) {
-    return errorMessage;
-  }
-  if (reply.diagnostics.toolErrorCount > 0) {
-    return `${reply.diagnostics.toolErrorCount} tool result error(s)`;
-  }
-  if (reply.diagnostics.assistantMessageCount > 0) {
-    return "assistant returned no text";
-  }
-  return "empty assistant turn";
-}
-function getFailureCapture(reply) {
-  if (reply.diagnostics.outcome === "provider_error") {
-    return {
-      eventName: "agent_turn_provider_error",
-      error: reply.diagnostics.providerError ?? new Error(
-        reply.diagnostics.errorMessage ?? "Provider error without explicit message"
-      ),
-      attributes: {},
-      body: "Agent turn failed with provider error"
-    };
-  }
-  const failureReason = getExecutionFailureReason(reply);
-  return {
-    eventName: "agent_turn_execution_failure",
-    error: new Error(`Agent turn execution failure: ${failureReason}`),
-    attributes: {
-      "app.ai.execution_failure_reason": failureReason
-    },
-    body: "Agent turn completed with execution failure"
-  };
-}
-function getAgentTurnDiagnosticsAttributes(reply) {
-  return {
-    "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
-    "gen_ai.operation.name": "invoke_agent",
-    "app.ai.outcome": reply.diagnostics.outcome,
-    "app.ai.assistant_messages": reply.diagnostics.assistantMessageCount,
-    "app.ai.tool_results": reply.diagnostics.toolResultCount,
-    "app.ai.tool_error_results": reply.diagnostics.toolErrorCount,
-    "app.ai.tool_call_count": reply.diagnostics.toolCalls.length,
-    "app.ai.used_primary_text": reply.diagnostics.usedPrimaryText,
-    ...reply.diagnostics.thinkingLevel ? {
-      "app.ai.reasoning_effort": reply.diagnostics.thinkingLevel
-    } : {},
-    ...reply.diagnostics.stopReason ? {
-      "gen_ai.response.finish_reasons": [reply.diagnostics.stopReason]
-    } : {},
-    ...reply.diagnostics.errorMessage ? { "exception.message": reply.diagnostics.errorMessage } : {}
-  };
+// src/chat/services/persist-retry.ts
+var PERSIST_ATTEMPTS = 3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function finalizeFailedTurnReply(args) {
-  if (args.reply.diagnostics.outcome === "success") {
-    return args.reply;
-  }
-  const capture = getFailureCapture(args.reply);
-  const eventId = requireTurnFailureEventId(
-    args.logException(
-      capture.error,
-      capture.eventName,
-      args.context,
-      {
-        ...getAgentTurnDiagnosticsAttributes(args.reply),
-        ...args.attributes,
-        ...capture.attributes
-      },
-      capture.body
-    ),
-    capture.eventName
-  );
-  const providerPartialText = args.reply.diagnostics.outcome === "provider_error" ? args.reply.text.trim() : "";
-  return {
-    ...args.reply,
-    text: providerPartialText ? `${providerPartialText}${getInterruptionMarker()}` : buildTurnFailureResponse(eventId),
-    deliveryMode: "thread",
-    deliveryPlan: {
-      mode: "thread",
-      postThreadText: true,
-      attachFiles: args.reply.files && args.reply.files.length > 0 ? "inline" : "none"
+async function persistWithRetry(persist) {
+  let lastError;
+  for (let attempt = 1; attempt <= PERSIST_ATTEMPTS; attempt += 1) {
+    try {
+      await persist();
+      return;
+    } catch (error) {
+      lastError = error;
+      if (attempt < PERSIST_ATTEMPTS) {
+        await sleep(attempt * 100);
+      }
     }
-  };
+  }
+  throw lastError;
 }
 
 // src/chat/agent-dispatch/signing.ts
@@ -1035,6 +977,16 @@ async function runAgentDispatchSlice(callback, deps = {}) {
   }
   let dispatch = claimedDispatch;
   const conversationId = getDispatchConversationId(dispatch);
+  const turnId = getDispatchTurnId(dispatch.id);
+  const logContext = {
+    conversationId,
+    slackThreadId: conversationId,
+    slackChannelId: dispatch.destination.channelId,
+    runId: dispatch.id,
+    actorType: dispatch.actor.type,
+    actorId: dispatch.actor.id,
+    assistantUserName: botConfig.userName
+  };
   const destinationLockId = getDispatchDestinationLockId(dispatch.destination);
   const stateAdapter = getStateAdapter();
   await stateAdapter.connect();
@@ -1119,7 +1071,7 @@ async function runAgentDispatchSlice(callback, deps = {}) {
       correlation: {
         conversationId,
         threadId: conversationId,
-        turnId: getDispatchTurnId(dispatch.id),
+        turnId,
         runId: dispatch.id,
         channelId: dispatch.destination.channelId,
         teamId: dispatch.destination.teamId
@@ -1159,13 +1111,7 @@ async function runAgentDispatchSlice(callback, deps = {}) {
         reply,
         logException,
         context: {
-          conversationId,
-          slackThreadId: conversationId,
-          slackChannelId: dispatch.destination.channelId,
-          runId: dispatch.id,
-          actorType: dispatch.actor.type,
-          actorId: dispatch.actor.id,
-          assistantUserName: botConfig.userName,
+          ...logContext,
           modelId: reply.diagnostics.modelId
         }
       });
@@ -1199,13 +1145,45 @@ async function runAgentDispatchSlice(callback, deps = {}) {
     });
     updateConversationStats(conversation);
     const nextArtifacts = reply.artifactStatePatch ? mergeArtifactsState(artifacts, reply.artifactStatePatch) : artifacts;
-    await persistRuntimePatch({
-      threadId: conversationId,
-      conversation,
-      artifacts: nextArtifacts,
-      sandboxId: reply.sandboxId ?? sandboxId,
-      sandboxDependencyProfileHash: reply.sandboxDependencyProfileHash ?? sandboxDependencyProfileHash
-    });
+    try {
+      await persistWithRetry(
+        () => persistRuntimePatch({
+          threadId: conversationId,
+          conversation,
+          artifacts: nextArtifacts,
+          sandboxId: reply.sandboxId ?? sandboxId,
+          sandboxDependencyProfileHash: reply.sandboxDependencyProfileHash ?? sandboxDependencyProfileHash
+        })
+      );
+    } catch (persistError) {
+      logException(
+        persistError,
+        "agent_dispatch_post_delivery_persist_failed",
+        logContext,
+        {},
+        "Failed to persist delivered dispatch state after Slack accepted the reply"
+      );
+    }
+    if (reply.piMessages?.length) {
+      await completeDeliveredTurn({
+        conversationId,
+        sessionId: turnId,
+        sliceId: 1,
+        messages: reply.piMessages,
+        durationMs: reply.diagnostics.durationMs,
+        usage: reply.diagnostics.usage,
+        destination: dispatch.destination,
+        source: dispatch.source,
+        surface: "api",
+        logContext: {
+          threadId: conversationId,
+          channelId: dispatch.destination.channelId,
+          runId: dispatch.id,
+          assistantUserName: botConfig.userName,
+          modelId: reply.diagnostics.modelId
+        }
+      });
+    }
     dispatch = await markDispatch({
       dispatch,
       status: failure ? "failed" : "completed",
@@ -1216,21 +1194,13 @@ async function runAgentDispatchSlice(callback, deps = {}) {
       try {
         await scheduleCompletedTasks({
           conversationId,
-          sessionId: getDispatchTurnId(dispatch.id)
+          sessionId: turnId
         });
       } catch (error) {
         logException(
           error,
           "plugin_session_completed_task_schedule_failed",
-          {
-            conversationId,
-            slackThreadId: conversationId,
-            slackChannelId: dispatch.destination.channelId,
-            runId: dispatch.id,
-            actorType: dispatch.actor.type,
-            actorId: dispatch.actor.id,
-            assistantUserName: botConfig.userName
-          },
+          logContext,
           {},
           "Plugin session.completed task scheduling failed"
         );
@@ -1279,13 +1249,7 @@ async function runAgentDispatchSlice(callback, deps = {}) {
       error,
       "agent_dispatch_run_failed",
       {
-        conversationId,
-        slackThreadId: conversationId,
-        slackChannelId: dispatch.destination.channelId,
-        runId: dispatch.id,
-        actorType: dispatch.actor.type,
-        actorId: dispatch.actor.id,
-        assistantUserName: botConfig.userName,
+        ...logContext,
         modelId: botConfig.modelId
       },
       {},
@@ -1506,8 +1470,8 @@ async function drainConversationMailbox2(args) {
   }
   return result;
 }
-async function markConversationMessagesInjected2(args) {
-  const result = await markConversationMessagesInjected(args);
+async function ackMessages2(args) {
+  const result = await ackMessages(args);
   await recordExecutionMetadata(args);
   return result;
 }
@@ -1526,6 +1490,18 @@ async function completeConversationWork2(args) {
   await recordExecutionMetadata(args);
   return result;
 }
+async function recordAttemptFailure2(args) {
+  const result = await recordAttemptFailure(args);
+  if (result.status === "recorded") {
+    await recordExecutionMetadata(args);
+  }
+  return result;
+}
+async function deadLetterAttempt2(args) {
+  const result = await deadLetterAttempt(args);
+  await recordExecutionMetadata(args);
+  return result;
+}
 async function clearExpiredConversationLease2(args) {
   const result = await clearExpiredConversationLease(args);
   await recordExecutionMetadata(args);
@@ -1593,6 +1569,10 @@ async function ensureSlackAdapterInitialized(args) {
   await args.adapter.initialize({
     getState: () => state
   });
+  const internals = args.adapter;
+  if (internals.defaultBotTokenProvider && !args.adapter.botUserId) {
+    throw new Error("Slack adapter initialized without a resolved bot user id");
+  }
   initializedAdapters.add(args.adapter);
 }
 function verifySlackSignature(args) {
@@ -1640,7 +1620,7 @@ async function runWithSlackInstallation(args) {
       enterpriseId: args.installation.enterpriseId,
       isEnterpriseInstall: args.installation.isEnterpriseInstall
     },
-    args.task
+    () => runWithSlackInstallationToken(tokenContext.token, args.task)
   );
 }
 
@@ -2014,14 +1994,22 @@ function createSlackConversationWorker(options) {
     const actorLookup = options.lookupSlackUser ?? lookupSlackUser;
     const state = getConnectedState2(options.state);
     await state.connect();
-    const records = getPendingRecords(
-      await getConversationWorkState2({
-        conversationId: context.conversationId,
-        state
-      })
-    );
+    const records = getPendingRecords({
+      execution: { pendingMessages: [...context.attempt.messages] }
+    });
     if (records.length === 0) {
-      await options.resumeAwaitingContinuation(context.conversationId);
+      const destination = requireSlackDestination(
+        context.destination,
+        "Slack continuation recovery"
+      );
+      await runWithSlackInstallation({
+        adapter,
+        installation: { teamId: destination.teamId },
+        state,
+        task: async () => {
+          await options.resumeAwaitingContinuation(context.conversationId);
+        }
+      });
       return { status: "completed" };
     }
     const latestRecord = records[records.length - 1];
@@ -2071,33 +2059,22 @@ function createSlackConversationWorker(options) {
           skipped,
           totalSinceLastHandler: messages.length
         };
-        const initialInboundMessageIds = records.map(
-          (record) => record.inboundMessageId
-        );
-        let initialMessagesPersisted = false;
-        const markInitialMessagesInjected = async () => {
-          if (initialMessagesPersisted) {
-            return true;
+        let initialMessagesAcked = false;
+        const ack = async () => {
+          if (initialMessagesAcked) {
+            return;
           }
-          const marked = await markConversationMessagesInjected2({
-            conversationId: context.conversationId,
-            inboundMessageIds: initialInboundMessageIds,
-            leaseToken: context.leaseToken,
-            conversationStore: options.conversationStore,
-            state
-          });
-          initialMessagesPersisted = marked;
-          return marked;
-        };
-        const onInputCommitted = async () => {
-          if (!await markInitialMessagesInjected()) {
+          try {
+            await context.attempt.ack();
+            initialMessagesAcked = true;
+          } catch {
             throw new TurnInputCommitLostError(
-              `Conversation work lease lost before Slack input commit for ${context.conversationId}`
+              `Conversation work lease lost before Slack inbox ack for ${context.conversationId}`
             );
           }
         };
-        const drainSteeringMessages = async (inject) => {
-          await context.drainMailbox(async (pendingRecords) => {
+        const drainSteeringMessages = async (accept) => {
+          await context.attempt.drain(async (pendingRecords) => {
             const messages2 = pendingRecords.map((record) => {
               const metadata = record.input.metadata;
               if (!isSlackMetadata(metadata)) {
@@ -2112,7 +2089,7 @@ function createSlackConversationWorker(options) {
                 message
               };
             });
-            return await inject(messages2);
+            return await accept(messages2);
           });
         };
         try {
@@ -2121,7 +2098,8 @@ function createSlackConversationWorker(options) {
               destination: context.destination,
               messageContext,
               drainSteeringMessages,
-              onInputCommitted,
+              ack,
+              isFinalAttempt: context.attempt.isFinalAttempt,
               shouldYield: context.shouldYield
             });
             return;
@@ -2130,10 +2108,14 @@ function createSlackConversationWorker(options) {
             destination: context.destination,
             messageContext,
             drainSteeringMessages,
-            onInputCommitted,
+            ack,
+            isFinalAttempt: context.attempt.isFinalAttempt,
             shouldYield: context.shouldYield
           });
         } catch (error) {
+          if (isTurnInputDeferredError(error)) {
+            return { status: "deferred" };
+          }
           if (isCooperativeTurnYieldError(error)) {
             return { status: "yielded" };
           }
@@ -2144,7 +2126,7 @@ function createSlackConversationWorker(options) {
         }
       }
     });
-    if (turnResult?.status === "yielded" || turnResult?.status === "lost_lease") {
+    if (turnResult?.status === "deferred" || turnResult?.status === "yielded" || turnResult?.status === "lost_lease") {
       return turnResult;
     }
     return { status: "completed" };
@@ -2616,11 +2598,29 @@ async function recoverConversationWork(args) {
     state: args.state
   });
   for (const conversationId of ids) {
+    let work;
     try {
-      const work = await getConversationWorkState2({
+      work = await getConversationWorkState2({
         conversationId,
         state: args.state
       });
+    } catch (error) {
+      logException(
+        error,
+        "conversation_work_recovery_failed",
+        { conversationId },
+        {},
+        "Conversation work heartbeat recovery failed"
+      );
+      if (isInvalidConversationRecordError(error)) {
+        await removeActiveConversation2({
+          conversationId,
+          state: args.state
+        });
+      }
+      continue;
+    }
+    try {
       if (!work) {
         await removeActiveConversation2({
           conversationId,
@@ -3529,17 +3529,6 @@ function isSlackTitlePermissionError(error) {
   return code === "no_permission" || code === "missing_scope" || code === "not_allowed_token_type";
 }
 
-// src/chat/slack/workspace-context.ts
-import { AsyncLocalStorage } from "async_hooks";
-var workspaceTeamIdStorage = new AsyncLocalStorage();
-function runWithWorkspaceTeamId(teamId, fn) {
-  if (!teamId) return fn();
-  return workspaceTeamIdStorage.run(teamId, fn);
-}
-function getWorkspaceTeamId() {
-  return workspaceTeamIdStorage.getStore();
-}
-
 // src/chat/runtime/thread-context.ts
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -3734,8 +3723,8 @@ function buildAuthPauseResponse(slackUserId, providerDisplayName) {
 }
 
 // src/chat/runtime/request-deadline.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-var requestDeadlineStorage = new AsyncLocalStorage2();
+import { AsyncLocalStorage } from "async_hooks";
+var requestDeadlineStorage = new AsyncLocalStorage();
 function createTurnRequestDeadline(startedAtMs) {
   const requestBudgetMs = Math.max(
     1,
@@ -4014,6 +4003,27 @@ async function resumeSlackTurn(args) {
       footer
     });
     finalReplyDelivered = true;
+    if (replyContext.correlation?.conversationId && replyContext.correlation.turnId && reply.piMessages?.length) {
+      await persistCompletedSessionRecord({
+        conversationId: replyContext.correlation.conversationId,
+        sessionId: replyContext.correlation.turnId,
+        allMessages: reply.piMessages,
+        currentDurationMs: reply.diagnostics.durationMs,
+        currentUsage: reply.diagnostics.usage,
+        destination: replyContext.destination,
+        source: replyContext.source,
+        requester: replyContext.requester,
+        surface: "slack",
+        logContext: {
+          threadId: replyContext.correlation.threadId,
+          requesterId: replyContext.requester?.userId,
+          channelId: runArgs.channelId,
+          runId: replyContext.correlation.runId,
+          assistantUserName: botConfig.userName,
+          modelId: reply.diagnostics.modelId
+        }
+      });
+    }
     await runArgs.onSuccess?.(reply);
     if (reply.diagnostics.outcome === "success" && replyContext.correlation?.conversationId && replyContext.correlation.turnId) {
       try {
@@ -5775,14 +5785,18 @@ function extractMessageChangedMention(body, botUserId, adapter) {
   const teamId = typeof body.team_id === "string" ? body.team_id : void 0;
   const userTeam = typeof event.message.user_team === "string" ? event.message.user_team : void 0;
   const sourceTeam = typeof event.message.source_team === "string" ? event.message.source_team : void 0;
+  const botId = typeof event.message.bot_id === "string" ? event.message.bot_id : void 0;
+  const channelType = typeof event.channel_type === "string" ? event.channel_type : void 0;
   const raw = {
     channel: channelId,
+    ...channelType ? { channel_type: channelType } : {},
     ts: messageTs,
     thread_ts: threadTs,
     user: userId,
     ...teamId ? { team_id: teamId } : {},
     ...userTeam ? { user_team: userTeam } : {},
-    ...sourceTeam ? { source_team: sourceTeam } : {}
+    ...sourceTeam ? { source_team: sourceTeam } : {},
+    ...botId ? { bot_id: botId } : {}
   };
   const message = new Message2({
     id: getEditedMentionMessageId(messageTs),
@@ -5798,8 +5812,11 @@ function extractMessageChangedMention(body, botUserId, adapter) {
       // Raw message_changed payloads do not include profile fields.
       userName: "",
       fullName: "",
-      isBot: false,
-      isMe: false
+      // Mirror the fresh-message parse so the shared ingress author gate
+      // applies: synthesized flags must never launder a bot-authored or
+      // self-authored edit into a routable user message.
+      isBot: Boolean(botId),
+      isMe: userId === botUserId
     }
   });
   Object.defineProperty(message, "adapter", {
@@ -6055,14 +6072,16 @@ async function handleMessageChanged(args) {
   }
   const botUserId = args.adapter.botUserId;
   if (!botUserId) {
-    return false;
+    throw new Error(
+      "Slack bot identity is unresolved; cannot classify message_changed event"
+    );
   }
   const result = extractMessageChangedMention(
     args.body,
     botUserId,
     args.adapter
   );
-  if (!result) {
+  if (!result || shouldIgnoreMessage(result.message)) {
     return true;
   }
   await persistSlackMessage({
@@ -6374,12 +6393,12 @@ async function handleSlackWebhook(args) {
       try {
         await eventTask;
       } catch (error) {
-        if (!(error instanceof SlackEventPersistenceError)) {
-          logException(error, "slack_event_enqueue_failed");
-          return new Response("ok", { status: 200 });
+        if (error instanceof SlackEventPersistenceError) {
+          logException(error.cause, "slack_event_persist_failed");
+        } else {
+          logException(error, "slack_event_routing_failed");
         }
-        logException(error.cause, "slack_event_persist_failed");
-        return new Response("Slack event persistence failed", { status: 503 });
+        return new Response("Slack event handling failed", { status: 503 });
       }
     } else {
       enqueue(
@@ -6529,6 +6548,33 @@ async function requestLostLeaseRecovery(args) {
     state: args.options.state
   });
 }
+async function recordFailedDeliveryAttempt(args) {
+  const failure = await recordAttemptFailure2({
+    conversationId: args.conversationId,
+    inboundMessageIds: args.messageIds,
+    leaseToken: args.leaseToken,
+    conversationStore: args.options.conversationStore,
+    nowMs: args.nowMs,
+    state: args.options.state
+  });
+  for (const message of failure.deadLetteredMessages) {
+    logWarn(
+      "conversation_work_dead_lettered",
+      { conversationId: args.conversationId },
+      {
+        "app.conversation.source": message.source,
+        "app.inbound.attempt_count": message.attemptCount ?? 0,
+        "app.inbound.message_id": message.inboundMessageId,
+        "app.inbound.pending_count": failure.pendingCount
+      },
+      "Conversation work message consumed after exceeding the delivery attempt limit"
+    );
+  }
+  return failure;
+}
+function isTerminalFailure(failure) {
+  return failure.status === "recorded" && failure.deadLetteredMessages.length > 0 && failure.pendingCount === 0;
+}
 function startLeaseCheckIn(args) {
   const timer = setInterval(() => {
     const nowMs = now2(args.options);
@@ -6566,10 +6612,22 @@ function startLeaseCheckIn(args) {
 }
 async function processConversationWork(message, options) {
   const conversationId = message.conversationId;
-  const initial = await getConversationWorkState2({
-    conversationId,
-    state: options.state
-  });
+  let initial;
+  try {
+    initial = await getConversationWorkState2({
+      conversationId,
+      state: options.state
+    });
+  } catch (error) {
+    if (isInvalidConversationRecordError(error)) {
+      throw new ConversationQueueMessageRejectedError(
+        "invalid_record",
+        `Conversation record failed validation for ${conversationId}`,
+        { conversationId }
+      );
+    }
+    throw error;
+  }
   if (!initial || countPendingConversationMessages(initial) === 0 && initial.execution.status === "idle" && !initial.execution.lease) {
     if (initial) {
       await clearConsumedConversationWake2({
@@ -6628,6 +6686,14 @@ async function processConversationWork(message, options) {
   }
   const startedAtMs = now2(options);
   const softYieldDeadlineMs = startedAtMs + (options.softYieldAfterMs ?? CONVERSATION_WORK_SOFT_YIELD_AFTER_MS);
+  const leasedWork = await getConversationWorkState2({
+    conversationId,
+    state: options.state
+  });
+  const attemptMessages = leasedWork?.messages ?? initial.messages;
+  const attemptMessageIds = attemptMessages.map(
+    (message2) => message2.inboundMessageId
+  );
   let leaseLost = false;
   const markLeaseLost = () => {
     leaseLost = true;
@@ -6647,10 +6713,43 @@ async function processConversationWork(message, options) {
     },
     "Conversation work lease acquired"
   );
+  const drainInbox = (handle) => drainConversationMailbox2({
+    conversationId,
+    leaseToken: lease.leaseToken,
+    conversationStore: options.conversationStore,
+    handle,
+    nowMs: now2(options),
+    state: options.state
+  });
+  const ack = async () => {
+    const acknowledged = await ackMessages2({
+      conversationId,
+      inboundMessageIds: attemptMessageIds,
+      leaseToken: lease.leaseToken,
+      conversationStore: options.conversationStore,
+      nowMs: now2(options),
+      state: options.state
+    });
+    if (!acknowledged) {
+      markLeaseLost();
+      throw new Error(
+        `Conversation work lease lost before inbox ack for ${conversationId}`
+      );
+    }
+  };
   const workerContext = {
+    attempt: {
+      ack,
+      conversationId,
+      destination,
+      drain: drainInbox,
+      isFinalAttempt: attemptMessages.some(
+        (message2) => isFinalAttempt(message2)
+      ),
+      messages: attemptMessages
+    },
     conversationId,
     destination,
-    leaseToken: lease.leaseToken,
     shouldYield: () => leaseLost || now2(options) >= softYieldDeadlineMs,
     checkIn: async () => {
       const checkedIn = await checkInConversationWork2({
@@ -6664,15 +6763,7 @@ async function processConversationWork(message, options) {
         markLeaseLost();
       }
       return checkedIn;
-    },
-    drainMailbox: (inject) => drainConversationMailbox2({
-      conversationId,
-      leaseToken: lease.leaseToken,
-      conversationStore: options.conversationStore,
-      inject,
-      nowMs: now2(options),
-      state: options.state
-    })
+    }
   };
   try {
     const result = await options.run(workerContext);
@@ -6739,6 +6830,51 @@ async function processConversationWork(message, options) {
       );
       return { status: "yielded" };
     }
+    if (result.status === "deferred") {
+      const deferredNowMs = now2(options);
+      const released = await releaseConversationWork2({
+        conversationId,
+        leaseToken: lease.leaseToken,
+        conversationStore: options.conversationStore,
+        nowMs: deferredNowMs,
+        state: options.state
+      });
+      if (!released) {
+        return { status: "lost_lease" };
+      }
+      const wake = await ensureConversationWake({
+        conversationId,
+        conversationStore: options.conversationStore,
+        idempotencyKey: nudgeIdempotencyKey(
+          "deferred",
+          conversationId,
+          deferredNowMs
+        ),
+        nowMs: deferredNowMs,
+        queue: options.queue,
+        state: options.state
+      });
+      return wake.status === "enqueued" ? { status: "pending_requeued" } : { status: "completed" };
+    }
+    if (attemptMessageIds.length > 0) {
+      const failure = await recordFailedDeliveryAttempt({
+        conversationId,
+        leaseToken: lease.leaseToken,
+        nowMs: now2(options),
+        messageIds: attemptMessageIds,
+        options
+      });
+      if (isTerminalFailure(failure)) {
+        await deadLetterAttempt2({
+          conversationId,
+          leaseToken: lease.leaseToken,
+          conversationStore: options.conversationStore,
+          nowMs: now2(options),
+          state: options.state
+        });
+        return { status: "failed" };
+      }
+    }
     const completion = await completeConversationWork2({
       conversationId,
       leaseToken: lease.leaseToken,
@@ -6776,53 +6912,62 @@ async function processConversationWork(message, options) {
     return { status: "completed" };
   } catch (error) {
     const errorNowMs = now2(options);
+    let recoveryRecorded = false;
     try {
-      const continuationMarked = await requestConversationContinuation2({
+      const failure = attemptMessageIds.length > 0 ? await recordFailedDeliveryAttempt({
         conversationId,
-        destination,
         leaseToken: lease.leaseToken,
-        conversationStore: options.conversationStore,
         nowMs: errorNowMs,
-        state: options.state
-      });
-      if (continuationMarked) {
-        await ensureConversationWake({
+        messageIds: attemptMessageIds,
+        options
+      }) : void 0;
+      if (failure && isTerminalFailure(failure)) {
+        await deadLetterAttempt2({
           conversationId,
+          leaseToken: lease.leaseToken,
           conversationStore: options.conversationStore,
-          idempotencyKey: nudgeIdempotencyKey(
-            "error",
+          nowMs: errorNowMs,
+          state: options.state
+        });
+      } else {
+        const continuationMarked = await requestConversationContinuation2({
+          conversationId,
+          destination,
+          leaseToken: lease.leaseToken,
+          conversationStore: options.conversationStore,
+          nowMs: errorNowMs,
+          state: options.state
+        });
+        if (continuationMarked) {
+          await ensureConversationWake({
             conversationId,
-            errorNowMs
-          ),
+            conversationStore: options.conversationStore,
+            idempotencyKey: nudgeIdempotencyKey(
+              "error",
+              conversationId,
+              errorNowMs
+            ),
+            nowMs: errorNowMs,
+            queue: options.queue,
+            state: options.state
+          });
+        }
+        await releaseConversationWork2({
+          conversationId,
+          leaseToken: lease.leaseToken,
+          conversationStore: options.conversationStore,
           nowMs: errorNowMs,
-          queue: options.queue,
           state: options.state
         });
       }
-    } catch (requeueError) {
+      recoveryRecorded = true;
+    } catch (recoveryError) {
       logException(
-        requeueError,
+        recoveryError,
         "conversation_work_requeue_failed",
         { conversationId },
         {},
-        "Conversation work requeue failed after runner error"
-      );
-    }
-    try {
-      await releaseConversationWork2({
-        conversationId,
-        leaseToken: lease.leaseToken,
-        conversationStore: options.conversationStore,
-        nowMs: errorNowMs,
-        state: options.state
-      });
-    } catch (releaseError) {
-      logException(
-        releaseError,
-        "conversation_work_release_failed",
-        { conversationId },
-        {},
-        "Conversation work release failed after runner error"
+        "Conversation work recovery failed after runner error"
       );
     }
     if (!isProviderRetryError(error)) {
@@ -6836,7 +6981,10 @@ async function processConversationWork(message, options) {
         "Conversation work failed"
       );
     }
-    throw error;
+    if (!recoveryRecorded) {
+      throw error;
+    }
+    return { status: "failed" };
   } finally {
     clearInterval(timer);
   }
@@ -7360,7 +7508,7 @@ function combineTurnText(queuedMessages, latestText) {
 // src/chat/runtime/slack-runtime.ts
 var THREAD_OPTOUT_ACK = "Understood. I'll stay out of this thread unless someone @mentions me again.";
 function shouldRethrowTurnControlError(error) {
-  return isCooperativeTurnYieldError(error) || isTurnInputCommitLostError(error) || isProviderRetryError(error);
+  return isCooperativeTurnYieldError(error) || isTurnInputCommitLostError(error) || isTurnInputDeferredError(error) || isProviderRetryError(error);
 }
 async function maybeHandleThreadOptOutDecision(args) {
   if (!args.decision?.shouldUnsubscribe) {
@@ -7394,13 +7542,13 @@ function createAcceptedSteeringDrain(hooks, options) {
   if (!hooks.drainSteeringMessages) {
     return void 0;
   }
-  return async (inject, context) => {
+  return async (accept, context) => {
     let interruptedMessages;
     await hooks.drainSteeringMessages(async (messages) => {
       const selection = await options.selectMessages(messages, context);
       await options.onSkipped?.(selection.skipped);
       const interrupted = selection.accepted.filter((accepted) => accepted.mode === "interrupt").map((accepted) => accepted.message);
-      await inject(getQueuedMessagesFromSlackMessages(interrupted, options));
+      await accept(getQueuedMessagesFromSlackMessages(interrupted, options));
       interruptedMessages = interrupted;
       await options.onAcceptedForProcessing?.(interrupted);
       return [
@@ -7567,7 +7715,7 @@ function createSlackTurnRuntime(deps) {
         completedAtMs
       });
     }
-    await args.onInputCommitted?.();
+    await args.ack?.();
   };
   const selectAcceptedSteeringMessages = async (args) => {
     const selected = [];
@@ -7653,6 +7801,7 @@ function createSlackTurnRuntime(deps) {
       let processingReaction;
       const skippedSteeringMessages = [];
       let completed = false;
+      let acked = false;
       const onTurnCompleted = async () => {
         completed = true;
         await flushSkippedSteeringMessagesBestEffort({
@@ -7701,8 +7850,9 @@ function createSlackTurnRuntime(deps) {
               )
             );
           };
-          const onInputCommitted = async () => {
-            await hooks.onInputCommitted?.();
+          const ack = async () => {
+            await hooks.ack?.();
+            acked = true;
             await startQueuedProcessingReactions();
           };
           const drainSteeringMessages = createAcceptedSteeringDrain(hooks, {
@@ -7732,7 +7882,7 @@ function createSlackTurnRuntime(deps) {
             beforeFirstResponsePost: hooks.beforeFirstResponsePost,
             destination: hooks.destination,
             queuedMessages,
-            onInputCommitted,
+            ack,
             onToolInvocation: toolInvocationHook,
             onTurnCompleted,
             drainSteeringMessages,
@@ -7786,6 +7936,9 @@ function createSlackTurnRuntime(deps) {
           {},
           "onNewMention failed"
         );
+        if (!acked && hooks.isFinalAttempt === false) {
+          return;
+        }
         if (!eventId) {
           throw new Error(
             "Sentry did not return an event ID for mention_handler_failed"
@@ -7823,6 +7976,7 @@ function createSlackTurnRuntime(deps) {
       let processingReaction;
       const skippedSteeringMessages = [];
       let completed = false;
+      let acked = false;
       const onTurnCompleted = async () => {
         completed = true;
         await flushSkippedSteeringMessagesBestEffort({
@@ -7889,7 +8043,7 @@ function createSlackTurnRuntime(deps) {
               message,
               decision: { shouldReply: false, reason },
               context: threadContext,
-              onInputCommitted: hooks.onInputCommitted,
+              ack: hooks.ack,
               text: combinedText
             });
             return;
@@ -7926,7 +8080,7 @@ function createSlackTurnRuntime(deps) {
               message,
               decision,
               context: threadContext,
-              onInputCommitted: hooks.onInputCommitted,
+              ack: hooks.ack,
               preparedState,
               text: combinedText
             });
@@ -7938,7 +8092,7 @@ function createSlackTurnRuntime(deps) {
               message,
               decision,
               context: threadContext,
-              onInputCommitted: hooks.onInputCommitted,
+              ack: hooks.ack,
               preparedState,
               text: combinedText
             });
@@ -7983,8 +8137,9 @@ function createSlackTurnRuntime(deps) {
               )
             );
           };
-          const onInputCommitted = async () => {
-            await hooks.onInputCommitted?.();
+          const ack = async () => {
+            await hooks.ack?.();
+            acked = true;
             await startQueuedProcessingReactions();
           };
           const toolInvocationHook = createToolInvocationHook(
@@ -7997,7 +8152,7 @@ function createSlackTurnRuntime(deps) {
             preparedState,
             beforeFirstResponsePost: hooks.beforeFirstResponsePost,
             queuedMessages,
-            onInputCommitted,
+            ack,
             onToolInvocation: toolInvocationHook,
             onTurnCompleted,
             drainSteeringMessages,
@@ -8051,6 +8206,9 @@ function createSlackTurnRuntime(deps) {
           {},
           "onSubscribedMessage failed"
         );
+        if (!acked && hooks.isFinalAttempt === false) {
+          return;
+        }
         if (!eventId) {
           throw new Error(
             "Sentry did not return an event ID for subscribed_message_handler_failed"
@@ -9002,6 +9160,7 @@ function createJuniorRuntimeServices(overrides = {}) {
 }
 
 // src/chat/runtime/reply-executor.ts
+import { THREAD_STATE_TTL_MS as THREAD_STATE_TTL_MS4 } from "chat";
 import { createSlackSource } from "@sentry/junior-plugin-api";
 
 // src/chat/slack/message.ts
@@ -9134,6 +9293,9 @@ async function maybeApplyProviderDefaultConfigRequest(args) {
 }
 
 // src/chat/runtime/reply-executor.ts
+async function persistThreadStateWithRetry(thread, patch) {
+  await persistWithRetry(() => persistThreadState(thread, patch));
+}
 function collectCanvasUrls(artifacts) {
   return new Set(
     [
@@ -9145,6 +9307,14 @@ function collectCanvasUrls(artifacts) {
 function turnRequester(requester) {
   return toStoredSlackRequester(requester);
 }
+function parkedInputKey(message) {
+  if (message.role !== "user") {
+    return void 0;
+  }
+  const first = Array.isArray(message.content) ? message.content[0] : void 0;
+  const text = first && typeof first === "object" && "text" in first ? String(first.text ?? "") : "";
+  return `${message.timestamp}:${text}`;
+}
 function isResourceEventMessage(message) {
   const raw = message.raw && typeof message.raw === "object" ? message.raw : void 0;
   return raw?.event_type === "resource_event";
@@ -9226,6 +9396,7 @@ function createReplyToThread(deps) {
       channelName,
       channelType: slackChannelType
     });
+    const destinationVisibility = conversationVisibilityFromSlackChannelType(slackChannelType);
     const threadTs = getThreadTs(threadId);
     const assistantThreadContext = getAssistantThreadContext(message);
     const messageTs = getMessageTs(message);
@@ -9238,7 +9409,8 @@ function createReplyToThread(deps) {
       channelId: channelId ?? destination.channelId,
       messageTs,
       teamId,
-      threadTs
+      threadTs,
+      type: destinationVisibility === "public" ? "pub" : "priv"
     });
     const runId = getRunId(thread, message);
     const conversationId = threadId ?? runId;
@@ -9365,12 +9537,87 @@ function createReplyToThread(deps) {
           }
         };
         let activeTurnId = preparedState.conversation.processing.activeTurnId;
+        const resolveSteeringMessages = async (queuedMessages) => {
+          return await Promise.all(
+            queuedMessages.map(async (queued) => {
+              const attachments = queued.message.attachments;
+              return {
+                text: queued.userText,
+                timestampMs: queued.message.metadata.dateSent.getTime(),
+                omittedImageAttachmentCount: !isVisionEnabled() && hasPotentialImageAttachment(attachments) ? countPotentialImageAttachments(attachments) : 0,
+                userAttachments: await deps.resolveUserAttachments(
+                  attachments,
+                  {
+                    threadId,
+                    requesterId: isResourceEventMessage(queued.message) ? void 0 : queued.message.author.userId,
+                    channelId,
+                    runId,
+                    conversation: preparedState.conversation,
+                    messageTs: getSlackMessageTs(queued.message)
+                  }
+                )
+              };
+            })
+          );
+        };
+        const appendParkedTurnInput = async (parkedSessionId) => {
+          if (!conversationId) {
+            return true;
+          }
+          const parkedMessages = [
+            ...options.queuedMessages ?? [],
+            {
+              explicitMention: Boolean(
+                options.explicitMention || message.isMention
+              ),
+              message,
+              rawText: currentText.rawText,
+              userText: currentText.userText
+            }
+          ].filter(
+            // Redelivery of the parked turn's own message must not duplicate
+            // the prompt that already started the session.
+            (queued) => buildDeterministicTurnId(queued.message.id) !== parkedSessionId
+          );
+          if (parkedMessages.length === 0) {
+            return true;
+          }
+          const stateAdapter = getStateAdapter();
+          await stateAdapter.connect();
+          const lock = await acquireActiveLock(stateAdapter, conversationId);
+          if (!lock) {
+            return false;
+          }
+          try {
+            const piMessages = (await resolveSteeringMessages(parkedMessages)).map(buildSteeringPiMessage);
+            const projection = await loadProjection({ conversationId });
+            const appendedKeys = new Set(
+              projection.map(parkedInputKey).filter((key) => key !== void 0)
+            );
+            const missing = piMessages.filter((piMessage) => {
+              const key = parkedInputKey(piMessage);
+              return key === void 0 || !appendedKeys.has(key);
+            });
+            if (missing.length === 0) {
+              return true;
+            }
+            await commitMessages({
+              conversationId,
+              messages: [...projection, ...missing],
+              requester: storedRequester,
+              ttlMs: THREAD_STATE_TTL_MS4
+            });
+            return true;
+          } finally {
+            await stateAdapter.releaseLock(lock);
+          }
+        };
         if (preparedState.userMessageAlreadyReplied) {
           await persistThreadState(thread, {
             conversation: preparedState.conversation
           });
           await options.onTurnStatePersisted?.();
-          await options.onInputCommitted?.();
+          await options.ack?.();
           await options.onTurnCompleted?.();
           return;
         }
@@ -9380,6 +9627,9 @@ function createReplyToThread(deps) {
             sessionId: activeTurnId
           });
           if (resumeRequest) {
+            if (!await appendParkedTurnInput(resumeRequest.sessionId)) {
+              throw new TurnInputDeferredError();
+            }
             try {
               await deps.services.scheduleAgentContinue(resumeRequest);
             } catch (error) {
@@ -9400,7 +9650,7 @@ function createReplyToThread(deps) {
               conversation: preparedState.conversation
             });
             await options.onTurnStatePersisted?.();
-            await options.onInputCommitted?.();
+            await options.ack?.();
             return;
           }
           const sessionRecord = await getAgentTurnSessionRecord(
@@ -9409,27 +9659,34 @@ function createReplyToThread(deps) {
           );
           if (sessionRecord?.state === "awaiting_resume") {
             if (sessionRecord.resumeReason === "auth") {
-              await persistThreadState(thread, {
-                conversation: preparedState.conversation
+              await abandonAgentTurnSessionRecord({
+                conversationId,
+                sessionId: activeTurnId,
+                errorMessage: "Auth-parked session superseded by a new user message"
               });
-              await options.onTurnStatePersisted?.();
-              await options.onInputCommitted?.();
-              return;
+              markTurnClosed({
+                conversation: preparedState.conversation,
+                nowMs: Date.now(),
+                sessionId: activeTurnId,
+                updateConversationStats
+              });
+              activeTurnId = void 0;
+            } else {
+              await failAgentTurnSessionRecord({
+                conversationId,
+                expectedVersion: sessionRecord.version,
+                sessionId: activeTurnId,
+                errorMessage: "Awaiting agent continuation metadata could not be materialized"
+              });
+              markTurnFailed({
+                conversation: preparedState.conversation,
+                nowMs: Date.now(),
+                sessionId: activeTurnId,
+                markConversationMessage,
+                updateConversationStats
+              });
+              activeTurnId = void 0;
             }
-            await failAgentTurnSessionRecord({
-              conversationId,
-              expectedVersion: sessionRecord.version,
-              sessionId: activeTurnId,
-              errorMessage: "Awaiting agent continuation metadata could not be materialized"
-            });
-            markTurnFailed({
-              conversation: preparedState.conversation,
-              nowMs: Date.now(),
-              sessionId: activeTurnId,
-              markConversationMessage,
-              updateConversationStats
-            });
-            activeTurnId = void 0;
           }
         }
         const configReply = await maybeApplyProviderDefaultConfigRequest({
@@ -9465,7 +9722,7 @@ function createReplyToThread(deps) {
             conversation: preparedState.conversation
           });
           await options.onTurnStatePersisted?.();
-          await options.onInputCommitted?.();
+          await options.ack?.();
           return;
         }
         startActiveTurn({
@@ -9485,6 +9742,7 @@ function createReplyToThread(deps) {
             surface: "slack",
             requester,
             destination,
+            destinationVisibility,
             source,
             traceId: getActiveTraceId()
           }).catch((error) => {
@@ -9601,8 +9859,10 @@ function createReplyToThread(deps) {
         };
         let persistedAtLeastOnce = false;
         let shouldPersistFailureState = true;
+        let finalReplyDelivered = false;
         let latestArtifacts = preparedState.artifacts;
         let assistantTitleArtifacts = {};
+        const hasVisibleSlackDelivery = (post) => post.text.trim().length > 0 || Boolean(post.files?.length);
         try {
           const loadedPiMessages = await loadPiMessagesForTurn({
             conversationId,
@@ -9694,39 +9954,16 @@ function createReplyToThread(deps) {
             );
           });
           const toolChannelId = preparedState.artifacts.assistantContextChannelId ?? channelId;
-          const resolveSteeringMessages = async (queuedMessages) => {
-            return await Promise.all(
-              queuedMessages.map(async (queued) => {
-                const attachments = queued.message.attachments;
-                return {
-                  text: queued.userText,
-                  timestampMs: queued.message.metadata.dateSent.getTime(),
-                  omittedImageAttachmentCount: !isVisionEnabled() && hasPotentialImageAttachment(attachments) ? countPotentialImageAttachments(attachments) : 0,
-                  userAttachments: await deps.resolveUserAttachments(
-                    attachments,
-                    {
-                      threadId,
-                      requesterId: isResourceEventMessage(queued.message) ? void 0 : queued.message.author.userId,
-                      channelId,
-                      runId,
-                      conversation: preparedState.conversation,
-                      messageTs: getSlackMessageTs(queued.message)
-                    }
-                  )
-                };
-              })
-            );
-          };
-          const drainSteeringMessages = options.drainSteeringMessages ? async (inject) => {
-            let injectedMessages;
+          const drainSteeringMessages = options.drainSteeringMessages ? async (accept) => {
+            let acceptedMessages;
             const drained = await options.drainSteeringMessages(
               async (queuedMessages) => {
-                injectedMessages = await resolveSteeringMessages(queuedMessages);
-                await inject(injectedMessages);
+                acceptedMessages = await resolveSteeringMessages(queuedMessages);
+                await accept(acceptedMessages);
               },
               { conversationContext: preparedState.conversationContext }
             );
-            return injectedMessages ?? await resolveSteeringMessages(drained);
+            return acceptedMessages ?? await resolveSteeringMessages(drained);
           } : void 0;
           let reply = await deps.services.generateAssistantReply(
             effectiveUserText,
@@ -9792,7 +10029,7 @@ function createReplyToThread(deps) {
               },
               onStatus: (nextStatus) => status.update(nextStatus),
               onToolInvocation: options.onToolInvocation,
-              onInputCommitted: options.onInputCommitted,
+              onInputCommitted: options.ack,
               drainSteeringMessages,
               shouldYield: options.shouldYield
             }
@@ -9815,16 +10052,20 @@ function createReplyToThread(deps) {
             });
           }
           const artifactStatePatch = reply.artifactStatePatch ? { ...reply.artifactStatePatch } : {};
-          const reactionPerformed = reply.diagnostics.toolCalls.includes(
-            "slackMessageAddReaction"
-          );
           const plannedPosts = planSlackReplyPosts({ reply });
           const replyFooter = buildSlackReplyFooter({
             conversationId
           });
           const shouldUseSlackFooter = Boolean(replyFooter) && Boolean(channelId && threadTs) && thread.adapter?.name === "slack";
           if (plannedPosts.length > 0) {
-            let sent;
+            const hasVisibleDelivery = plannedPosts.some(
+              hasVisibleSlackDelivery
+            );
+            if (!hasVisibleDelivery) {
+              throw new Error(
+                "Slack final reply plan did not contain visible delivery"
+              );
+            }
             if (shouldUseSlackFooter) {
               const slackChannelId = channelId;
               const slackThreadTs = threadTs;
@@ -9833,7 +10074,7 @@ function createReplyToThread(deps) {
                   "Slack footer delivery requires a concrete channel and thread timestamp"
                 );
               }
-              const sentMessageTs = await postSlackApiReplyPosts({
+              await postSlackApiReplyPosts({
                 beforePost: beforeFirstResponsePost,
                 channelId: slackChannelId,
                 threadTs: slackThreadTs,
@@ -9854,30 +10095,22 @@ function createReplyToThread(deps) {
                   );
                 }
               });
-              if (sentMessageTs) {
-                sent = {
-                  id: sentMessageTs,
-                  text: reply.text,
-                  delete: async () => {
-                    await deleteSlackMessage({
-                      channelId: slackChannelId,
-                      timestamp: sentMessageTs
-                    });
-                  }
-                };
-              }
             } else {
               for (const post of plannedPosts) {
-                sent = await postThreadReply(
+                if (!hasVisibleSlackDelivery(post)) {
+                  continue;
+                }
+                await postThreadReply(
                   buildSlackOutputMessage(post.text, post.files),
                   post.stage
                 );
               }
             }
-            const firstPlannedMessageHasFiles = (plannedPosts[0]?.files?.length ?? 0) > 0;
-            if (sent && reactionPerformed && plannedPosts.length === 1 && !firstPlannedMessageHasFiles && isRedundantReactionAckText(reply.text)) {
-              await sent.delete();
-            }
+            finalReplyDelivered = true;
+            shouldPersistFailureState = false;
+          } else {
+            finalReplyDelivered = true;
+            shouldPersistFailureState = false;
           }
           const completedState = buildDeliveredTurnStatePatch({
             artifactStatePatch: {
@@ -9893,27 +10126,63 @@ function createReplyToThread(deps) {
           if (completedState.artifacts) {
             latestArtifacts = completedState.artifacts;
           }
-          await persistThreadState(thread, {
-            ...completedState
-          });
-          if (completedState.artifacts && (assistantTitleArtifacts.assistantTitle !== void 0 || assistantTitleArtifacts.assistantTitleSourceMessageId !== void 0) && (completedState.artifacts.assistantTitle !== assistantTitleArtifacts.assistantTitle || completedState.artifacts.assistantTitleSourceMessageId !== assistantTitleArtifacts.assistantTitleSourceMessageId)) {
-            await persistThreadState(thread, { artifacts: latestArtifacts });
-          }
-          if (conversationId) {
-            await recordAgentTurnSessionSummary({
-              channelName,
-              conversationId,
-              cumulativeDurationMs: reply.diagnostics.durationMs,
-              cumulativeUsage: reply.diagnostics.usage,
-              sessionId: turnId,
-              sliceId: 1,
-              startedAtMs: message.metadata.dateSent.getTime(),
-              state: "completed",
-              requester,
-              destination,
-              source,
-              traceId: getActiveTraceId()
+          try {
+            if (conversationId && reply.piMessages?.length) {
+              await completeDeliveredTurn({
+                channelName,
+                conversationId,
+                durationMs: reply.diagnostics.durationMs,
+                usage: reply.diagnostics.usage,
+                destination,
+                destinationVisibility,
+                source,
+                sessionId: turnId,
+                sliceId: 1,
+                messages: reply.piMessages,
+                logContext: {
+                  threadId,
+                  requesterId: slackRequesterId,
+                  channelId,
+                  runId,
+                  assistantUserName: botConfig.userName,
+                  modelId: reply.diagnostics.modelId
+                },
+                requester,
+                surface: "slack"
+              });
+            } else if (conversationId) {
+              await recordAgentTurnSessionSummary({
+                channelName,
+                conversationId,
+                cumulativeDurationMs: reply.diagnostics.durationMs,
+                cumulativeUsage: reply.diagnostics.usage,
+                sessionId: turnId,
+                sliceId: 1,
+                startedAtMs: message.metadata.dateSent.getTime(),
+                state: "completed",
+                requester,
+                destination,
+                destinationVisibility,
+                source,
+                traceId: getActiveTraceId()
+              });
+            }
+            await persistThreadStateWithRetry(thread, {
+              ...completedState
             });
+            if (completedState.artifacts && (assistantTitleArtifacts.assistantTitle !== void 0 || assistantTitleArtifacts.assistantTitleSourceMessageId !== void 0) && (completedState.artifacts.assistantTitle !== assistantTitleArtifacts.assistantTitle || completedState.artifacts.assistantTitleSourceMessageId !== assistantTitleArtifacts.assistantTitleSourceMessageId)) {
+              await persistThreadStateWithRetry(thread, {
+                artifacts: latestArtifacts
+              });
+            }
+          } catch (commitError) {
+            logException(
+              commitError,
+              "slack_reply_post_delivery_commit_failed",
+              turnTraceContext,
+              messageTs ? { "messaging.message.id": messageTs } : {},
+              "Post-delivery turn state persistence failed after Slack accepted the reply"
+            );
           }
           preparedState.conversation = completedState.conversation;
           persistedAtLeastOnce = true;
@@ -9947,6 +10216,17 @@ function createReplyToThread(deps) {
             }
           }
         } catch (error) {
+          if (finalReplyDelivered) {
+            shouldPersistFailureState = false;
+            logException(
+              error,
+              "slack_reply_post_delivery_commit_failed",
+              turnTraceContext,
+              messageTs ? { "messaging.message.id": messageTs } : {},
+              "Post-delivery turn work failed after Slack accepted the reply"
+            );
+            return;
+          }
           if (isCooperativeTurnYieldError(error)) {
             shouldPersistFailureState = false;
             throw error;
@@ -10121,6 +10401,7 @@ function createReplyToThread(deps) {
                   state: "failed",
                   requester,
                   destination,
+                  destinationVisibility,
                   source,
                   traceId: getActiveTraceId()
                 });
@@ -10558,7 +10839,7 @@ function createJuniorSlackAdapter(config) {
 
 // src/chat/runtime/agent-continue-runner.ts
 var AGENT_CONTINUE_LOCK_RETRY_DELAYS_MS = [250, 1e3, 2e3];
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function persistCompletedReplyState2(args) {
@@ -10645,6 +10926,28 @@ async function failContinuationStartup(args) {
     );
   }
 }
+async function resolveContinuationRequester(args) {
+  const stored = args.sessionRecordRequester;
+  if (stored?.platform === "slack" && stored.teamId === args.teamId && stored.userId === args.userId) {
+    return createSlackResumeRequester({
+      requester: stored,
+      teamId: args.teamId,
+      userId: args.userId
+    });
+  }
+  const work = await getConversationWorkState2({
+    conversationId: args.conversationId
+  });
+  const workRequester = work?.requester;
+  if (workRequester && workRequester.teamId === args.teamId && workRequester.slackUserId === args.userId) {
+    return createSlackRequester(args.teamId, args.userId, {
+      email: workRequester.email,
+      fullName: workRequester.fullName,
+      userName: workRequester.slackUserName
+    });
+  }
+  return void 0;
+}
 function isContinuationResume(summary) {
   return summary.state === "awaiting_resume" && (summary.resumeReason === "timeout" || summary.resumeReason === "yield");
 }
@@ -10708,11 +11011,20 @@ async function continueSlackAgentRun(payload, options = {}) {
           payload.destination,
           "Slack continuation"
         );
-        const requester = createSlackResumeRequester({
-          requester: activeSessionRecord.requester,
+        const requester = await resolveContinuationRequester({
+          conversationId: payload.conversationId,
+          sessionRecordRequester: activeSessionRecord.requester,
           teamId: destination.teamId,
           userId: userMessage2.author.userId
         });
+        if (!requester) {
+          await failStrandedSessionWithFallback({
+            conversationId: payload.conversationId,
+            errorMessage: "Stored Slack requester missing for continuation",
+            sessionRecord: activeSessionRecord
+          });
+          return false;
+        }
         if (!activeSessionRecord.source) {
           await failAgentTurnSessionRecord({
             conversationId: payload.conversationId,
@@ -10822,8 +11134,119 @@ async function continueSlackAgentRun(payload, options = {}) {
     }
   });
 }
+async function failStrandedSessionWithFallback(args) {
+  await failAgentTurnSessionRecord({
+    conversationId: args.conversationId,
+    expectedVersion: args.sessionRecord.version,
+    sessionId: args.sessionRecord.sessionId,
+    errorMessage: args.errorMessage
+  });
+  const currentState = await getPersistedThreadState(args.conversationId);
+  const conversation = coerceThreadConversationState(currentState);
+  markTurnFailed({
+    conversation,
+    nowMs: Date.now(),
+    sessionId: args.sessionRecord.sessionId,
+    userMessageId: getTurnUserMessage(
+      conversation,
+      args.sessionRecord.sessionId
+    )?.id,
+    markConversationMessage,
+    updateConversationStats
+  });
+  await persistThreadStateById(args.conversationId, { conversation });
+  const thread = parseSlackThreadId(args.conversationId);
+  if (!thread) {
+    return;
+  }
+  const eventName = "agent_turn_stranded_session_failed";
+  const eventId = logException(
+    new Error(args.errorMessage),
+    eventName,
+    { conversationId: args.conversationId },
+    {
+      "app.ai.conversation_id": args.conversationId,
+      "app.ai.session_id": args.sessionRecord.sessionId
+    },
+    "Stranded running agent session terminally failed"
+  );
+  await postSlackMessage({
+    channelId: thread.channelId,
+    threadTs: thread.threadTs,
+    text: buildTurnFailureResponse(
+      requireTurnFailureEventId(eventId, eventName)
+    )
+  });
+}
+async function recoverStrandedRunningSession(args) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const probe = await acquireActiveLock(stateAdapter, args.conversationId);
+  if (!probe) {
+    return false;
+  }
+  await stateAdapter.releaseLock(probe);
+  const sessionRecord = await getAgentTurnSessionRecord(
+    args.conversationId,
+    args.summary.sessionId
+  );
+  if (!sessionRecord || sessionRecord.state !== "running") {
+    return false;
+  }
+  const parked = await persistYieldSessionRecord({
+    channelName: sessionRecord.channelName,
+    conversationId: args.conversationId,
+    sessionId: sessionRecord.sessionId,
+    currentSliceId: sessionRecord.sliceId,
+    destination: sessionRecord.destination,
+    source: sessionRecord.source,
+    messages: sessionRecord.piMessages,
+    errorMessage: "Recovered running session after hard worker death",
+    logContext: { modelId: botConfig.modelId },
+    requester: sessionRecord.requester,
+    surface: sessionRecord.surface
+  });
+  if (!parked) {
+    await failStrandedSessionWithFallback({
+      conversationId: args.conversationId,
+      errorMessage: "Stranded running session had no resumable boundary after worker death",
+      sessionRecord
+    });
+    return false;
+  }
+  const request = await getAwaitingAgentContinueRequest({
+    conversationId: args.conversationId,
+    sessionId: sessionRecord.sessionId
+  });
+  if (!request) {
+    await failStrandedSessionWithFallback({
+      conversationId: args.conversationId,
+      errorMessage: "Stranded running session could not materialize continuation metadata",
+      sessionRecord: parked
+    });
+    return false;
+  }
+  if (await continueSlackAgentRunWithLockRetry(request, args.options)) {
+    return true;
+  }
+  await failUnresumableContinuation({
+    conversationId: args.conversationId,
+    expectedVersion: request.expectedVersion,
+    summary: args.summary,
+    errorMessage: "Awaiting agent continuation was stale before it could run"
+  });
+  return false;
+}
 async function resumeAwaitingSlackContinuation(conversationId, options = {}) {
   const summaries = await listAgentTurnSessionSummariesForConversation(conversationId);
+  const newest = summaries[0];
+  if (newest?.state === "running") {
+    return await recoverStrandedRunningSession({
+      conversationId,
+      options,
+      summary: newest
+    });
+  }
   for (const summary of summaries) {
     if (!isContinuationResume(summary)) {
       continue;
@@ -10889,7 +11312,7 @@ async function continueSlackAgentRunWithLockRetry(payload, options = {}) {
         },
         "Agent continuation lock was busy; retrying"
       );
-      await sleep(delayMs);
+      await sleep2(delayMs);
     }
   }
   return true;