@sentry/junior 0.188.0 → 0.189.0

package/dist/app.js

@@ -1,15 +1,15 @@
 import {
   processConversationWork
-} from "./chunk-CDSLOYOR.js";
+} from "./chunk-UCWO5MKP.js";
 import {
   bindSpawnAgent
-} from "./chunk-CZRWU4ZM.js";
+} from "./chunk-ZUPDSJUE.js";
 import {
   createAgentInvocationWorker,
   enqueueAgentInvocation,
   listPendingAgentInvocationMailboxAppends,
-  routeAgentInvocationWork
-} from "./chunk-SC67CH3C.js";
+  resolveAgentInvocationId
+} from "./chunk-YNZPOFF3.js";
 import {
   GET as GET2,
   GET2 as GET3,
@@ -37,30 +37,12 @@ import {
   startProcessingReaction,
   stripLeadingBotMention,
   wakePausedTurn
-} from "./chunk-WW2Y7JIA.js";
+} from "./chunk-WMUAKAIF.js";
 import "./chunk-FA6POGLH.js";
-import {
-  GET,
-  apiTurnIdForMessage,
-  appendAndEnqueueApiConversationMessage,
-  conversationVisibilityFromSlackChannelType,
-  createApiTurnCancellation,
-  createApiTurnWorker,
-  createVercelAttachmentStorage,
-  getAuthPausedApiTurnId,
-  lookupSlackUser,
-  readConversationAccessFromSql,
-  recordApiConversationActivity,
-  resolveSlackChannelTypeFromMessage,
-  resolveSlackConversationContext,
-  routeApiTurnWork,
-  webActorFromEmail
-} from "./chunk-LODJKINF.js";
-import "./chunk-PSHMPRIU.js";
 import {
   AgentRunError,
   executeTurn
-} from "./chunk-ERZMACYA.js";
+} from "./chunk-WYDF6PGK.js";
 import {
   buildDeliveredTurnStatePatch,
   completeAuthPauseTurn,
@@ -71,7 +53,7 @@ import {
   getTurnUserSlackMessageTs,
   persistAuthPauseTurnState,
   requireTurnFailureEventId
-} from "./chunk-QDHJTKPE.js";
+} from "./chunk-7R5JRPCY.js";
 import {
   claimDispatchMailboxAppend,
   confirmDispatchMailboxAppend,
@@ -88,14 +70,14 @@ import {
   markDispatchCompleted,
   markDispatchFailed,
   markDispatchRunning,
-  recordTaskExecution,
-  resolveConversationRouting,
+  processPluginTask,
   resolveTurnSessionRouting,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-AW77HH54.js";
+} from "./chunk-4RHJ3CXR.js";
 import {
+  ConversationTurnLifecycleService,
   getTurnLifecycle
-} from "./chunk-W42ENMJW.js";
+} from "./chunk-WWYUYKKV.js";
 import {
   coerceThreadConversationState,
   getLocationConfigurationService,
@@ -104,17 +86,39 @@ import {
   persistThreadRuntimeState,
   persistThreadState,
   persistThreadStateById
-} from "./chunk-CIG6WI7Q.js";
+} from "./chunk-MRXMFB4L.js";
+import {
+  GET,
+  appendAndEnqueueWebMessage,
+  conversationTurnIdForMessage,
+  conversationVisibilityFromSlackChannelType,
+  createVercelAttachmentStorage,
+  legacyWebMailboxMetadataSchema,
+  lookupSlackUser,
+  readConversationAccessFromSql,
+  recordWebConversationActivity,
+  resolveConversationDestination,
+  resolveSlackChannelTypeFromMessage,
+  resolveSlackConversationContext,
+  webActorFromEmail
+} from "./chunk-SR6OMO5C.js";
+import {
+  createWebAuthorization,
+  deleteWebAuthorization
+} from "./chunk-VKQWU4PO.js";
+import {
+  recordTaskExecution
+} from "./chunk-LHKZKAZ4.js";
 import "./chunk-UTL3MHPC.js";
 import {
   createVercelPluginTaskCallback,
   queueCallback,
   registerVercelPluginTaskDevConsumer
-} from "./chunk-XI4PVY2T.js";
+} from "./chunk-KN32OWL2.js";
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-HCIVBCP5.js";
+} from "./chunk-OEIITG5F.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -122,6 +126,8 @@ import {
   pluginRuntimeRegistrationsFromPluginSet
 } from "./chunk-CM5HNV2W.js";
 import {
+  RESOURCE_EVENT_MESSAGE_AUTHOR,
+  RESOURCE_EVENT_SYSTEM_ACTOR,
   SANDBOX_EGRESS_PROXY_PATH,
   buildSteeringPiMessage,
   clearSandboxEgressSignals,
@@ -133,6 +139,8 @@ import {
   getConfigDefaults,
   getNextRunAtMs,
   ingestResourceEvent,
+  isResourceEventConversationMessage,
+  isResourceEventMailboxMetadata,
   latestReportedProgress,
   listThreadReplies,
   logScheduledTaskRunSkipped,
@@ -143,18 +151,18 @@ import {
   readPublicArtifact,
   renderAttachmentText,
   renderBlockText,
-  resolveDestinationVisibility,
+  renderTaskInput,
   resolveSandboxEgressProviderForHost,
   scheduledTaskRunAttributes,
   setConfigDefaults,
   shouldEmitDevAgentTrace,
   shouldPropagateSandboxEgressTrace,
   unpublishedArtifactHeaders
-} from "./chunk-RMB7CERI.js";
+} from "./chunk-QNIOBNOY.js";
 import {
   AuthorizationFlowDisabledError,
   PluginCredentialFailureError
-} from "./chunk-6JZGXLL2.js";
+} from "./chunk-AC7MDOJW.js";
 import "./chunk-6Y5B5PEX.js";
 import "./chunk-DIB4GX3G.js";
 import {
@@ -162,63 +170,19 @@ import {
   deleteMcpAuthSessionsForUserProvider,
   deleteMcpServerSessionId,
   deleteMcpStoredOAuthCredentials
-} from "./chunk-W2DDJCPS.js";
+} from "./chunk-YYZNESC3.js";
 import {
+  RetryableDeliveryError,
+  createAgentRunner,
   formatProviderLabel,
   postSlackMessage,
   startOAuthFlow
-} from "./chunk-UVUXFRYN.js";
-import {
-  RESOURCE_EVENT_AUTHOR_ID,
-  RESOURCE_EVENT_MESSAGE_AUTHOR,
-  RESOURCE_EVENT_SYSTEM_ACTOR,
-  collectAttachmentGarbage,
-  collectEventTaskMatchKeys,
-  findMatchingEventTasks,
-  getResourceEventCatalog,
-  isResourceEventConversationMessage,
-  isResourceEventMailboxMetadata,
-  isResourceEventSlackMessage,
-  listScheduledTasks,
-  listScheduledTasksForTeam,
-  readScheduledTask,
-  renderTaskInput,
-  requestAttachmentDeletion,
-  resourceEventGuidance,
-  saveScheduledTaskInLock,
-  scheduledRunId,
-  scheduledRunSchema,
-  withScheduledTaskLock
-} from "./chunk-VFZAUQ5V.js";
-import {
-  parseSlackThreadId
-} from "./chunk-CVBDVIF4.js";
-import {
-  RetryableDeliveryError,
-  createAgentRunner
-} from "./chunk-6FGN7ZEG.js";
-import {
-  CONVERSATION_WORK_STALE_ENQUEUE_MS,
-  appendAndEnqueueInboundMessage,
-  clearExpiredConversationLease,
-  ensureConversationWake,
-  getConversation,
-  getConversationWorkState,
-  hasRunnableConversationWork,
-  hasRunnableConversationWork2,
-  isInvalidConversationRecordError,
-  listActiveConversationIds,
-  removeActiveConversation,
-  requestConversationWork,
-  stopConversationWork
-} from "./chunk-MQDIIFZM.js";
+} from "./chunk-PCPSX4ES.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
   TurnInputCommitLostError,
   TurnInputDeferredError,
-  buildDeterministicAssistantMessageId,
-  buildDeterministicTurnId,
   clearPendingAuth,
   getAssistantReplyText,
   getConversationTurnBoundaryError,
@@ -229,7 +193,7 @@ import {
   markTurnCompleted,
   markTurnFailed,
   startActiveTurn
-} from "./chunk-Z5SKZE5B.js";
+} from "./chunk-GP32KD2J.js";
 import {
   abandonTurnRecord,
   appendThreadContextMessages,
@@ -265,22 +229,63 @@ import {
   trimTrailingAssistantMessages,
   turnHasReply,
   upsertConversationMessage
-} from "./chunk-6YGFBU3A.js";
+} from "./chunk-MFSET7Q7.js";
 import {
   getExperimentalFeatures,
   isExperimentalFeatureEnabled,
   setExperimentalFeatures
 } from "./chunk-2LYHWMR4.js";
+import {
+  collectAttachmentGarbage,
+  collectEventTaskMatchKeys,
+  findMatchingEventTasks,
+  getResourceEventCatalog,
+  listScheduledTasks,
+  listScheduledTasksForTeam,
+  readScheduledTask,
+  requestAttachmentDeletion,
+  resourceEventGuidance,
+  saveScheduledTaskInLock,
+  scheduledRunId,
+  scheduledRunSchema,
+  withScheduledTaskLock
+} from "./chunk-CMWIMFM6.js";
+import {
+  parseSlackThreadId
+} from "./chunk-MVPLEPSI.js";
+import {
+  CONVERSATION_WORK_STALE_ENQUEUE_MS,
+  appendAndEnqueueInboundMessage,
+  clearExpiredConversationLease,
+  ensureConversationWake,
+  getConversation,
+  getConversationWorkState,
+  hasRunnableConversationWork,
+  hasRunnableConversationWork2,
+  isInvalidConversationRecordError,
+  listActiveConversationIds,
+  removeActiveConversation,
+  requestConversationWork,
+  stopConversationWork
+} from "./chunk-WN6VLHOU.js";
+import {
+  buildDeterministicAssistantMessageId,
+  buildDeterministicTurnId
+} from "./chunk-DA2KGZZI.js";
+import "./chunk-O35GZCKL.js";
 import {
   getSandboxResourceConfig,
   setSandboxResourceConfig
-} from "./chunk-XJIPMHKI.js";
+} from "./chunk-6AUR6PWR.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
 import {
   WORKSPACE_SNAPSHOT_JOB_QUEUE_TOPIC,
   verifyWorkspaceSnapshotJobMessage
 } from "./chunk-X6GDDWQH.js";
+import {
+  getTurnRequestDeadline
+} from "./chunk-S3SGZUOI.js";
 import {
   getVercelConversationWorkQueue,
   resolveConversationWorkQueueTopic,
@@ -291,9 +296,6 @@ import {
   isConversationQueueMessageRejectedError
 } from "./chunk-JAL3CH4G.js";
 import "./chunk-7H2VZTWN.js";
-import {
-  getTurnRequestDeadline
-} from "./chunk-WGZJ5SU4.js";
 import {
   SlackActionError,
   bindEventTaskCredentialSubject,
@@ -319,7 +321,7 @@ import {
   verifyEventTaskCredentialSubject,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-QCGNHSMA.js";
+} from "./chunk-MI6ZBDTS.js";
 import "./chunk-3Y47VMHV.js";
 import {
   createSlackDestination,
@@ -331,7 +333,7 @@ import {
   requireSlackDestination,
   withConversationEventLock,
   withConversationMutationLock
-} from "./chunk-IUUQWIG2.js";
+} from "./chunk-CUYFCI4G.js";
 import {
   juniorAgentBindings,
   juniorAgentInvocations,
@@ -339,15 +341,14 @@ import {
   juniorConversations,
   juniorSchedulerRuns,
   juniorSchedulerTasks
-} from "./chunk-QVH6FW3T.js";
-import "./chunk-X55FOVZO.js";
+} from "./chunk-5VWAY27R.js";
+import "./chunk-WDHPN2GH.js";
 import {
   acquireActiveLock,
   getStateAdapter,
   withActiveLock
-} from "./chunk-ZX7RSBQ6.js";
+} from "./chunk-5CXCGDIL.js";
 import {
-  contextProvenance,
   instructionProvenanceFor
 } from "./chunk-GFBR4S3Q.js";
 import {
@@ -368,17 +369,17 @@ import {
   isProviderRetryError,
   setProfiles,
   setSlackReactionConfig
-} from "./chunk-Q7O74WOO.js";
+} from "./chunk-BYBSI5TI.js";
 import {
   defaultModelId,
   modelIdForProfile
 } from "./chunk-D4YV5TDV.js";
-import "./chunk-FIUCHYT6.js";
-import "./chunk-3HEZWDS5.js";
+import "./chunk-DYXVAO2E.js";
+import "./chunk-YYSEH2WC.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-NZLZ4KYZ.js";
-import "./chunk-QIOUTXTZ.js";
+} from "./chunk-E3PDZPGV.js";
+import "./chunk-ZV6PFUA4.js";
 import {
   credentialContextForActor
 } from "./chunk-CEMMLV5L.js";
@@ -414,13 +415,13 @@ import {
   withContext,
   withLogContext,
   withSpan
-} from "./chunk-QIMN3FXL.js";
+} from "./chunk-PY3EIEAF.js";
 import {
   continueTrace
 } from "./chunk-PEQXYSSE.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-32XSSFZV.js";
+} from "./chunk-NY2F7BZA.js";
 
 // src/app.ts
 import { createRequire } from "module";
@@ -569,7 +570,6 @@ function buildDispatchRoutingContext(dispatch2) {
       dispatch2.actor,
       dispatch2.credentialSubject
     ),
-    destinationVisibility: dispatch2.destinationVisibility,
     dispatch: {
       actor: dispatch2.actor,
       id: dispatch2.id,
@@ -689,12 +689,6 @@ async function resolveAgentDispatchId(context) {
   const dispatch2 = await getDispatchRecord(durableDispatchId);
   return dispatch2 && !isTerminalDispatchStatus(dispatch2.status) ? durableDispatchId : void 0;
 }
-function createAgentDispatchWorkRouter(options) {
-  return async (context) => {
-    const dispatchId = await resolveAgentDispatchId(context);
-    return dispatchId ? await options.dispatchWorker(context, dispatchId) : await options.fallbackWorker(context);
-  };
-}
 async function readDispatchTurnResult(dispatch2) {
   const conversationId = getDispatchConversationId(dispatch2);
   const turnId = getDispatchTurnId(dispatch2.id);
@@ -2742,13 +2736,13 @@ async function GET6(request) {
 // src/chat/ingress/slack-webhook.ts
 import {
   ChannelImpl,
-  ThreadImpl as ThreadImpl3
+  ThreadImpl as ThreadImpl2
 } from "chat";
 
 // src/chat/task-execution/slack-work.ts
 import {
-  Message as Message3,
-  ThreadImpl as ThreadImpl2
+  Message as Message2,
+  ThreadImpl
 } from "chat";
 import { z as z3 } from "zod";
 
@@ -2938,85 +2932,6 @@ async function ensureSlackMessageActorIdentity(message, teamId, lookupSlackUser2
   return actor;
 }
 
-// src/chat/task-execution/slack-resource-event.ts
-import { Message as Message2, ThreadImpl } from "chat";
-async function resolveSlackResourceEventThread(args) {
-  const routing = await resolveConversationRouting({
-    conversationId: args.conversationId,
-    conversationStore: args.conversationStore
-  });
-  const destination = requireSlackDestination(
-    routing?.destination ?? args.destination,
-    "Slack resource-event turn"
-  );
-  const threadTs = routing?.source?.platform === "slack" ? routing.source.threadTs?.trim() : void 0;
-  if (!threadTs) {
-    return void 0;
-  }
-  return { destination, threadTs };
-}
-function isPlainResourceEventRecord(record) {
-  return record.source === "resource_event" && isResourceEventMailboxMetadata(record.input.metadata) && !hasSlackConversationMetadata(record.input.metadata);
-}
-function hasSlackConversationMetadata(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-  const record = value;
-  return record.platform === "slack" && typeof record.thread === "object" && record.thread !== null && typeof record.message === "object" && record.message !== null;
-}
-function buildResourceEventSlackMessage(args) {
-  if (!isResourceEventMailboxMetadata(args.record.input.metadata)) {
-    throw new Error(
-      "Resource-event Slack turn requires resource-event metadata"
-    );
-  }
-  const event = args.record.input.metadata.resourceEvent;
-  const messageId = `resource-event-${event.subscriptionId}-${event.eventKey}`;
-  const threadId = `slack:${args.channelId}:${args.threadTs}`;
-  return new Message2({
-    id: messageId,
-    threadId,
-    text: args.record.input.text,
-    author: {
-      ...RESOURCE_EVENT_MESSAGE_AUTHOR,
-      isMe: false
-    },
-    isMention: false,
-    attachments: [],
-    metadata: {
-      dateSent: new Date(args.record.createdAtMs),
-      edited: false
-    },
-    formatted: { type: "root", children: [] },
-    raw: {
-      channel: args.channelId,
-      event_type: "resource_event",
-      resource_event_type: event.eventType,
-      thread_ts: args.threadTs,
-      type: "message",
-      user: RESOURCE_EVENT_AUTHOR_ID
-    }
-  });
-}
-function buildResourceEventSlackThread(args) {
-  const threadId = normalizeIncomingSlackThreadId(
-    `slack:${args.channelId}:${args.threadTs}`,
-    args.message
-  );
-  const message = withNormalizedThreadId(args.message, threadId);
-  return new ThreadImpl({
-    adapter: args.adapter,
-    stateAdapter: args.state,
-    id: threadId,
-    channelId: args.channelId,
-    currentMessage: message,
-    initialMessage: message,
-    isDM: args.channelId.startsWith("D"),
-    isSubscribedContext: true
-  });
-}
-
 // src/chat/slack/message-control.ts
 var LEADING_MENTION_BEFORE_STEERING_RE = /^(\s*(?:<@[^>]+>|@[A-Za-z0-9._-]+\b)[\s,:-]*)!!\s*/;
 function stripLeadingSteeringOverride(text) {
@@ -3251,9 +3166,6 @@ function compareInboundMessages(left, right) {
 }
 function routeForRecords(records) {
   return records.some((record) => {
-    if (isPlainResourceEventRecord(record)) {
-      return false;
-    }
     const metadata = parseSlackMetadata(record.input.metadata);
     if (!metadata) {
       throw new Error("Conversation mailbox record is not Slack metadata");
@@ -3262,23 +3174,11 @@ function routeForRecords(records) {
   }) ? "mention" : "subscribed";
 }
 function restoreMessage(args) {
-  if (isPlainResourceEventRecord(args.record)) {
-    if (!args.threadTs) {
-      throw new Error(
-        "Resource-event Slack turn requires a thread timestamp"
-      );
-    }
-    return buildResourceEventSlackMessage({
-      channelId: args.channelId,
-      record: args.record,
-      threadTs: args.threadTs
-    });
-  }
   const metadata = parseSlackMetadata(args.record.input.metadata);
   if (!metadata) {
     throw new Error("Conversation mailbox record is not a Slack message");
   }
-  const message = Message3.fromJSON(metadata.message);
+  const message = Message2.fromJSON(metadata.message);
   message.attachments = message.attachments.map(
     (attachment) => args.adapter.rehydrateAttachment(attachment)
   );
@@ -3288,9 +3188,6 @@ function restoreMessage(args) {
 async function bindSlackActorIdentities(args) {
   const byAuthorId = /* @__PURE__ */ new Map();
   for (const message of args.messages) {
-    if (isResourceEventSlackMessage(message)) {
-      continue;
-    }
     const authorId = requireSlackAuthorId(message);
     byAuthorId.set(authorId, [...byAuthorId.get(authorId) ?? [], message]);
   }
@@ -3315,7 +3212,7 @@ function restoreThread(args) {
     args.message
   );
   const message = withNormalizedThreadId(args.message, threadId);
-  return new ThreadImpl2({
+  return new ThreadImpl({
     adapter: args.adapter,
     stateAdapter: args.state,
     id: threadId,
@@ -3380,10 +3277,9 @@ function createSlackConversationWorker(options) {
     if (!latestRecord) {
       return { status: "completed" };
     }
-    const hasPlainResourceEvent = records.some(isPlainResourceEventRecord);
-    const publishExternally = hasPlainResourceEvent ? true : latestRecord.publishExternally ?? context.publishExternally;
-    const latestMetadata = isPlainResourceEventRecord(latestRecord) ? void 0 : parseSlackMetadata(latestRecord.input.metadata);
-    if (!isPlainResourceEventRecord(latestRecord) && !latestMetadata) {
+    const publishExternally = latestRecord.publishExternally ?? context.publishExternally;
+    const latestMetadata = parseSlackMetadata(latestRecord.input.metadata);
+    if (!latestMetadata) {
       throw new Error(
         "Latest conversation mailbox record is not Slack metadata"
       );
@@ -3391,34 +3287,19 @@ function createSlackConversationWorker(options) {
     if (!await context.checkIn()) {
       return { status: "lost_lease" };
     }
-    const resourceEventThread = hasPlainResourceEvent ? await resolveSlackResourceEventThread({
-      conversationId: context.conversationId,
-      conversationStore: options.conversationStore,
-      destination: context.destination
-    }) : void 0;
-    if (hasPlainResourceEvent && !resourceEventThread) {
-      logWarn("conversation.work.resource_event.missing_thread", {
-        "app.inbound.message_count": records.length
-      });
-      await context.attempt.ack();
-      return { status: "completed" };
-    }
     const turnResult = await runWithSlackInstallation({
       adapter,
-      installation: resourceEventThread ? { teamId: resourceEventThread.destination.teamId } : getInstallation(records),
+      installation: getInstallation(records),
       state,
       task: async () => {
-        const destination = resourceEventThread?.destination ?? requireSlackDestination(
+        const destination = requireSlackDestination(
           context.destination,
           "Slack conversation work"
         );
-        const threadTs = resourceEventThread?.threadTs;
         const messages = records.map(
           (record) => restoreMessage({
             adapter,
-            channelId: destination.channelId,
-            record,
-            ...threadTs ? { threadTs } : void 0
+            record
           })
         );
         await bindSlackActorIdentities({
@@ -3431,13 +3312,7 @@ function createSlackConversationWorker(options) {
           return;
         }
         const route = routeForRecords(records);
-        const thread = isPlainResourceEventRecord(latestRecord) && threadTs ? buildResourceEventSlackThread({
-          adapter,
-          channelId: destination.channelId,
-          message: latestMessage,
-          state,
-          threadTs
-        }) : restoreThread({
+        const thread = restoreThread({
           adapter,
           isSubscribedContext: route === "subscribed",
           message: latestMessage,
@@ -3449,7 +3324,7 @@ function createSlackConversationWorker(options) {
           skipped,
           totalSinceLastHandler: messages.length
         };
-        const activeAuthorId = isResourceEventSlackMessage(latestMessage) ? RESOURCE_EVENT_AUTHOR_ID : requireSlackAuthorId(latestMessage);
+        const activeAuthorId = requireSlackAuthorId(latestMessage);
         let initialMessagesAcked = false;
         const ack = async () => {
           if (initialMessagesAcked) {
@@ -3467,17 +3342,15 @@ function createSlackConversationWorker(options) {
         const drainSteeringMessages = async (accept) => {
           await context.attempt.drain(async (pendingRecords) => {
             const candidates = pendingRecords.filter(
-              (record) => isPlainResourceEventRecord(record) ? publishExternally : record.publishExternally === publishExternally
+              (record) => record.publishExternally === publishExternally
             ).map((record) => ({
               inboundMessageId: record.inboundMessageId,
               message: restoreMessage({
                 adapter,
-                channelId: destination.channelId,
-                record,
-                ...threadTs ? { threadTs } : void 0
+                record
               })
             })).filter(
-              (candidate) => crossActorMidRunMode === "steer" || isResourceEventSlackMessage(candidate.message) || requireSlackAuthorId(candidate.message) === activeAuthorId || hasSteeringOverride(candidate.message.text)
+              (candidate) => crossActorMidRunMode === "steer" || requireSlackAuthorId(candidate.message) === activeAuthorId || hasSteeringOverride(candidate.message.text)
             );
             return candidates.length > 0 ? await accept(candidates) : [];
           });
@@ -3635,7 +3508,7 @@ function textMentionsBot(text, botUserId) {
 }
 
 // src/chat/ingress/message-changed.ts
-import { Message as Message4 } from "chat";
+import { Message as Message3 } from "chat";
 function getEditedMentionMessageId(messageTs) {
   return `${messageTs}:message_changed_mention`;
 }
@@ -3702,7 +3575,7 @@ function extractMessageChangedMention(body, botUserId, adapter) {
     ...sourceTeam ? { source_team: sourceTeam } : void 0,
     ...botId ? { bot_id: botId } : void 0
   };
-  const message = new Message4({
+  const message = new Message3({
     id: getEditedMentionMessageId(messageTs),
     threadId,
     text: newText,
@@ -3941,7 +3814,7 @@ function normalizeMessageThreadId(message) {
 }
 async function buildThread(args) {
   const normalized = normalizeMessageThreadId(args.message);
-  return new ThreadImpl3({
+  return new ThreadImpl2({
     adapter: args.adapter,
     stateAdapter: args.state,
     id: normalized.threadId,
@@ -5531,8 +5404,7 @@ function createSlackTurnRuntime(deps) {
         const threadId = getThreadId(thread, message);
         const channelId = getChannelId(thread, message);
         const runId = getRunId(thread, message);
-        const isResourceEventNotification = isResourceEventSlackMessage(message);
-        const actorId = isResourceEventNotification ? void 0 : message.author.userId;
+        const actorId = message.author.userId;
         const turnContext = logContext({
           threadId,
           actorId,
@@ -5565,7 +5437,7 @@ function createSlackTurnRuntime(deps) {
           });
           const combinedText = combineTurnText(queuedMessages, currentText);
           const turnIsExplicitMention = Boolean(message.isMention) || queuedMessages.some((queued) => queued.explicitMention);
-          const preflightDecision = isResourceEventNotification ? void 0 : getSubscribedReplyPreflightDecision({
+          const preflightDecision = getSubscribedReplyPreflightDecision({
             botUserName: deps.assistantUserName,
             rawText: combinedText.rawText,
             text: combinedText.userText,
@@ -5583,7 +5455,7 @@ function createSlackTurnRuntime(deps) {
             });
             return;
           }
-          if (!isResourceEventNotification && !turnIsExplicitMention && !isExperimentalFeatureEnabled("passive-routing")) {
+          if (!turnIsExplicitMention && !isExperimentalFeatureEnabled("passive-routing")) {
             const decision2 = await deps.decideSubscribedReply({
               rawText: combinedText.rawText,
               text: combinedText.userText,
@@ -5621,7 +5493,7 @@ function createSlackTurnRuntime(deps) {
             thread,
             preparedState
           });
-          const decision = isResourceEventNotification ? { shouldReply: true, reason: "resource_event" } : await deps.decideSubscribedReply({
+          const decision = await deps.decideSubscribedReply({
             rawText: combinedText.rawText,
             text: combinedText.userText,
             conversationContext: deps.getPreparedConversationContext(preparedState),
@@ -6431,6 +6303,21 @@ async function maybeApplyProviderDefaultConfigRequest(args) {
   };
 }
 
+// src/chat/conversations/destination-visibility.ts
+async function resolveDestinationVisibility(args) {
+  if (args.visibility) {
+    return args.visibility;
+  }
+  if (args.destination.platform === "local") {
+    return "private";
+  }
+  return await getConversationStore().getDestinationVisibility({
+    provider: "slack",
+    providerDestinationId: args.destination.channelId,
+    providerTenantId: args.destination.teamId
+  });
+}
+
 // src/chat/providers/slack/input.ts
 function steeringMessageKey(message) {
   if (message.role !== "user") {
@@ -6488,9 +6375,6 @@ function inboundMessageActor(queued) {
   };
 }
 function inboundMessageProvenance(queued, teamId) {
-  if (isResourceEventSlackMessage(queued.message)) {
-    return contextProvenance;
-  }
   const identity = getMessageActorIdentity(queued.message);
   const author = identity && "platform" in identity ? identity : createActor(
     { userId: parseActorUserId(queued.message.author.userId) },
@@ -6650,6 +6534,15 @@ function createSlackTurn(deps) {
         modelId: defaultModelId(botConfig)
       },
       async () => {
+        await getConversationStore().recordActivity({
+          activityAtMs: message.metadata.dateSent.getTime(),
+          channelName,
+          conversationId,
+          destination,
+          sessionSource: source,
+          source: "slack",
+          visibility: destinationVisibility
+        });
         const content = parseContent(message);
         const strippedUserText = stripLeadingBotMention(
           stripLeadingSteeringOverride(content.topLevelText),
@@ -6663,7 +6556,7 @@ function createSlackTurn(deps) {
           userText: replaceTopLevelText(content, strippedUserText)
         };
         await Promise.all(
-          (options.queuedMessages ?? []).filter((queued) => !isResourceEventSlackMessage(queued.message)).map(
+          (options.queuedMessages ?? []).map(
             (queued) => ensureSlackMessageActorIdentity(
               queued.message,
               teamId,
@@ -6677,9 +6570,6 @@ function createSlackTurn(deps) {
         if (options.execution) {
           executionActor = options.execution.dispatch.actor;
           credentialContext = options.execution.credentialContext;
-        } else if (isResourceEventSlackMessage(message)) {
-          executionActor = RESOURCE_EVENT_SYSTEM_ACTOR;
-          credentialContext = credentialContextForActor(executionActor);
         } else {
           executionActor = await ensureSlackMessageActorIdentity(
             message,
@@ -6769,7 +6659,7 @@ function createSlackTurn(deps) {
                 omittedImageAttachmentCount: !isVisionEnabled() && hasPotentialImageAttachment(attachments) ? countPotentialImageAttachments(attachments) : 0,
                 attachments: await deps.resolveUserAttachments(attachments, {
                   threadId,
-                  actorId: isResourceEventSlackMessage(queued.message) ? void 0 : queued.message.author.userId,
+                  actorId: queued.message.author.userId,
                   channelId,
                   runId,
                   conversation: preparedState.conversation,
@@ -6859,8 +6749,7 @@ function createSlackTurn(deps) {
               await abandonTurnRecord({
                 conversationId,
                 turnId: activeTurnId,
-                // TODO(dcramer): Rename this legacy text in Slack and Conversation API Turn records together.
-                errorMessage: "Auth-parked session superseded by a new user message"
+                errorMessage: "Auth-paused Turn superseded by new input"
               });
               markTurnClosed({
                 conversation: preparedState.conversation,
@@ -7277,16 +7166,15 @@ function createSlackTurn(deps) {
             },
             history: piMessages,
             credentialContext,
-            // Always set the execution actor when known. Resource-event turns
-            // carry the system principal; interactive turns carry the Slack user.
+            // Always set the execution Actor when known.
             actor: executionActor,
             slackConversation,
-            source: location ? { ...source, location } : source,
+            source,
+            ...location ? { location } : void 0,
             destination,
             publishExternally: shouldPublishExternally2(
               options.publishExternally
             ),
-            ...destinationVisibility ? { destinationVisibility } : void 0,
             surface: options.execution?.surface ?? "slack",
             dispatch: options.execution?.dispatch,
             toolChannelId,
@@ -7313,10 +7201,7 @@ function createSlackTurn(deps) {
                 });
               }
             },
-            delivery: {
-              ...location && shouldPublishExternally2(options.publishExternally) ? { location } : void 0,
-              send: deliverAssistantMessage
-            },
+            delivery: deliverAssistantMessage,
             durability: {
               onInputCommitted: options.ack,
               drainSteeringMessages,
@@ -7738,11 +7623,6 @@ async function persistConversationVisionCache(conversationId, vision) {
 
 // src/chat/runtime/conversation-message.ts
 var NON_TEXT_MESSAGE_TEXT = "[non-text message]";
-function resourceEventType(entry) {
-  if (!entry.raw || typeof entry.raw !== "object") return void 0;
-  const raw = entry.raw;
-  return raw.event_type === "resource_event" && typeof raw.resource_event_type === "string" ? raw.resource_event_type : void 0;
-}
 function resolveMessageText(args) {
   const text = normalizeConversationText(args.text);
   return text || NON_TEXT_MESSAGE_TEXT;
@@ -7767,7 +7647,6 @@ function toConversationMessage(args) {
     },
     meta: {
       attachmentCount: args.entry.attachments.length,
-      eventType: resourceEventType(args.entry),
       explicitMention: args.explicitMention,
       imageAttachmentCount: imageAttachmentCount > 0 ? imageAttachmentCount : void 0,
       imagesHydrated: !messageHasPotentialImageAttachment,
@@ -7937,14 +7816,14 @@ function createPrepareTurnState(deps) {
 }
 
 // src/chat/slack/dispatch-turn.ts
-import { Message as Message5, ThreadImpl as ThreadImpl4 } from "chat";
+import { Message as Message4, ThreadImpl as ThreadImpl3 } from "chat";
 function createSlackDispatchTurnRunner(options) {
   return async function runSlackDispatchTurn(dispatch2, hooks) {
     const state = getStateAdapter();
     await state.connect();
     const conversationId = getDispatchConversationId(dispatch2);
     const adapter = options.getSlackAdapter();
-    const message = new Message5({
+    const message = new Message4({
       id: getDispatchInputMessageId(dispatch2.id),
       threadId: conversationId,
       text: dispatch2.input,
@@ -7967,7 +7846,7 @@ function createSlackDispatchTurnRunner(options) {
       }
     });
     message.isMention = true;
-    const thread = new ThreadImpl4({
+    const thread = new ThreadImpl3({
       adapter,
       stateAdapter: state,
       id: conversationId,
@@ -8400,6 +8279,7 @@ async function runPausedTurnInContext(payload, options, runOptions) {
           return false;
         }
         const activeTurn = turn;
+        const { dispatch: dispatch2, surface } = options.routingContext ?? {};
         const currentState = await getPersistedThreadState(
           payload.conversationId
         );
@@ -8408,7 +8288,7 @@ async function runPausedTurnInContext(payload, options, runOptions) {
           conversation,
           conversationId: payload.conversationId
         });
-        const dispatchId = activeTurn.dispatchId ?? options.routingContext?.dispatch?.id;
+        const dispatchId = activeTurn.dispatchId ?? dispatch2?.id;
         const dispatchUserMessage = dispatchId ? conversation.messages.find(
           (message) => message.role === "user" && options.inputMessageIds?.includes(message.id)
         ) : void 0;
@@ -8451,21 +8331,19 @@ async function runPausedTurnInContext(payload, options, runOptions) {
         const routingDestination = routing.destination;
         const turnMessages = activeTurn.turnStartMessageIndex === void 0 ? [] : activeTurn.piMessages.slice(activeTurn.turnStartMessageIndex);
         const recordDispatchOutcome = async (dispatchOutcome) => {
-          const dispatchId2 = options.routingContext?.dispatch?.id;
-          if (!dispatchId2) {
+          if (!dispatch2) {
             return;
           }
           await recordTurnSummary({
             conversationId: payload.conversationId,
             destination: routingDestination,
-            destinationVisibility: options.routingContext?.destinationVisibility,
-            dispatchId: dispatchId2,
+            dispatchId: dispatch2.id,
             dispatchOutcome,
             turnId: payload.turnId,
             sliceId: activeTurn.sliceId,
             source,
             state: "failed",
-            surface: options.routingContext?.surface ?? "slack"
+            surface: surface ?? "slack"
           });
         };
         return {
@@ -8481,21 +8359,24 @@ async function runPausedTurnInContext(payload, options, runOptions) {
               ...getTurnUserReplyAttachmentContext(userMessage),
               text: userMessage.text
             },
-            // Pi history is SQL-authoritative: the resumed run reads its
-            // exact dispatch session so unrelated conversation input cannot
-            // gain system authority. Interactive turns retain their merged
-            // projection so queued steering remains visible.
+            // A dispatch reads only history saved for this Turn. Other input
+            // must not become part of a system Turn. Other Turns read
+            // Conversation history. This keeps queued steering visible.
             history: dispatchId ? activeTurn.piMessages : await loadProjection({
               conversationId: payload.conversationId
             }),
-            ...options.routingContext,
-            credentialContext,
             actor,
+            credentialContext,
             destination: routingDestination,
+            ...dispatch2 ? { dispatch: dispatch2 } : void 0,
+            ...routing.location ? { location: routing.location } : void 0,
             // Slack resume publishes unless the checkpoint opted out.
             // Missing means legacy/in-flight Slack turns still post.
+            // TODO(dcramer): Remove this missing-as-publish fallback after no
+            // stored Turn checkpoint can omit publishExternally.
             publishExternally: activeTurn.publishExternally !== false,
             source,
+            ...surface ? { surface } : void 0,
             toolChannelId: destination.channelId,
             environment: {
               locationConfiguration
@@ -8709,30 +8590,794 @@ async function runNextPausedTurnInContext(conversationId, options, runOptions) {
   return false;
 }
 
+// src/chat/task-execution/conversation-turn.ts
+import { createHash } from "crypto";
+
+// src/chat/task-execution/assistant-message.ts
+async function commitAssistantMessage(args) {
+  const conversationMessageId = recordDeliveredAssistantMessage({
+    conversation: args.conversation,
+    sessionId: args.sessionId,
+    source: args.source,
+    text: args.text,
+    userMessageId: args.userMessageId
+  });
+  if (args.publishedMessage?.providerMessageId) {
+    markConversationMessage(args.conversation, conversationMessageId, {
+      slackTs: args.publishedMessage.providerMessageId
+    });
+  }
+  try {
+    await persistWithRetry(
+      () => commitAcceptedReply({
+        ...args.agentMessage ? { agentMessage: args.agentMessage } : void 0,
+        conversation: args.conversation,
+        conversationMessageId,
+        conversationId: args.conversationId,
+        providerConversationBindings: args.publishedMessage?.providerConversationBindings
+      })
+    );
+  } catch (error) {
+    logException(
+      new Error("Assistant message persistence failed"),
+      "conversation.assistant.message_persist.failed",
+      {
+        "error.type": error instanceof Error ? error.name : typeof error
+      }
+    );
+  }
+}
+
+// src/chat/task-execution/mailbox-turn.ts
+import {
+  createLocalSource,
+  createWebSource
+} from "@sentry/junior-plugin-api";
+function turnInputFactsFromConversationMessage(message) {
+  if (isResourceEventConversationMessage(message)) {
+    return {
+      actor: RESOURCE_EVENT_SYSTEM_ACTOR,
+      author: message.author ?? RESOURCE_EVENT_MESSAGE_AUTHOR,
+      source: "resource_event"
+    };
+  }
+  const actor = createActor(message.author, {
+    platform: "web",
+    userId: message.author?.userId
+  });
+  if (actor?.platform !== "web") {
+    return void 0;
+  }
+  return {
+    actor,
+    author: message.author ?? { userId: actor.userId },
+    source: "web"
+  };
+}
+function sourceFromTurnInput(args) {
+  switch (args.source) {
+    case "resource_event":
+      return args.location ? createWebSource(
+        args.conversationId,
+        args.visibility === "private" ? "private" : "public"
+      ) : createLocalSource(args.conversationId);
+    case "web":
+      return createWebSource(
+        args.conversationId,
+        args.visibility === "private" ? "private" : "public"
+      );
+  }
+}
+function hasResourceEventActor(actors) {
+  return Boolean(
+    actors?.some(
+      (actor) => actor.platform === "system" && actor.name === RESOURCE_EVENT_SYSTEM_ACTOR.name
+    )
+  );
+}
+async function getActiveConversationTurnId(conversationId) {
+  const summaries = await listTurnSummaries(conversationId);
+  const active = summaries.filter(
+    (summary) => summary.surface === "api" && !summary.dispatchId && (summary.state === "paused" || summary.state === "running")
+  );
+  if (active.length > 1) {
+    throw new Error(
+      `Conversation ${conversationId} has multiple active web turns`
+    );
+  }
+  const turnId = active[0]?.turnId;
+  if (!turnId) return void 0;
+  const record = await getTurnRecord(conversationId, turnId);
+  return record && record.surface === "api" && !record.dispatchId && (record.state === "paused" || record.state === "running") ? turnId : void 0;
+}
+async function getActiveMailboxTurnId(conversationId) {
+  const summaries = await listTurnSummaries(conversationId);
+  const active = (await Promise.all(
+    summaries.filter(
+      (summary) => !summary.dispatchId && (summary.state === "paused" || summary.state === "running")
+    ).map((summary) => getTurnRecord(conversationId, summary.turnId))
+  )).filter(
+    (record) => record && !record.dispatchId && (record.surface === "api" || hasResourceEventActor(record.actors)) && (record.state === "paused" || record.state === "running")
+  );
+  if (active.length > 1) {
+    throw new Error(
+      `Conversation ${conversationId} has multiple active mailbox Turns`
+    );
+  }
+  return active[0]?.turnId;
+}
+async function getAuthPausedConversationTurnId(conversationId) {
+  const turnId = await getActiveConversationTurnId(conversationId);
+  if (!turnId) return void 0;
+  const record = await getTurnRecord(conversationId, turnId);
+  return record?.state === "paused" && record.resumeReason === "auth" ? turnId : void 0;
+}
+function parseWebMessages(messages) {
+  if (messages.length === 0) {
+    return [];
+  }
+  const parsed = messages.map((message) => ({
+    message,
+    metadata: legacyWebMailboxMetadataSchema.safeParse(message.input.metadata)
+  }));
+  if (parsed.every((entry) => !entry.metadata.success)) {
+    return [];
+  }
+  if (parsed.some((entry) => !entry.metadata.success)) {
+    throw new Error("A Turn cannot combine different kinds of input");
+  }
+  return parsed.map((entry) => {
+    if (!entry.metadata.success) {
+      throw new Error("User message has invalid metadata");
+    }
+    const metadata = entry.metadata.data;
+    const actor = {
+      platform: "web",
+      userId: metadata.authorUserId,
+      email: metadata.authorEmail.trim().toLowerCase(),
+      ...metadata.authorFullName ? { fullName: metadata.authorFullName } : void 0,
+      ...metadata.authorUserName ? { userName: metadata.authorUserName } : void 0
+    };
+    return {
+      actor,
+      author: {
+        email: actor.email,
+        ...actor.fullName ? { fullName: actor.fullName } : void 0,
+        userId: actor.userId,
+        ...actor.userName ? { userName: actor.userName } : void 0
+      },
+      message: entry.message,
+      source: "web"
+    };
+  });
+}
+function parseResourceEventMessages(messages) {
+  if (messages.length === 0) {
+    return [];
+  }
+  if (!messages.every(
+    (message) => message.source === "resource_event" && isResourceEventMailboxMetadata(message.input.metadata)
+  )) {
+    return [];
+  }
+  return messages.map((message) => {
+    if (!isResourceEventMailboxMetadata(message.input.metadata)) {
+      throw new Error("Resource event has invalid metadata");
+    }
+    return {
+      actor: RESOURCE_EVENT_SYSTEM_ACTOR,
+      author: RESOURCE_EVENT_MESSAGE_AUTHOR,
+      message,
+      source: "resource_event"
+    };
+  });
+}
+async function resolveMailboxTurnWork(context) {
+  const batch = parseWebMessages(context.attempt.messages);
+  if (batch.length > 0) {
+    return { kind: "mailbox", batch };
+  }
+  const resourceBatch = parseResourceEventMessages(context.attempt.messages);
+  if (resourceBatch.length > 0) {
+    return { kind: "mailbox", batch: resourceBatch };
+  }
+  if (context.attempt.messages.length > 0) {
+    return void 0;
+  }
+  const turnId = await getActiveMailboxTurnId(context.conversationId);
+  return turnId ? { kind: "resume", turnId } : void 0;
+}
+
+// src/chat/task-execution/mailbox-input.ts
+function joinMailboxText(messages) {
+  return messages.map((message) => message.input.text.trim()).filter(Boolean).join("\n\n");
+}
+
+// src/chat/task-execution/conversation-turn.ts
+function stableHex(...parts) {
+  return createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 24);
+}
+function captureConversationTurnFailure(args) {
+  const eventId = logException(
+    args.error,
+    `conversation.turn.${args.failureCode}`,
+    {
+      conversationId: args.conversationId,
+      ...args.runId ? { runId: args.runId } : void 0,
+      turnId: args.turnId
+    }
+  );
+  return typeof eventId === "string" ? eventId : void 0;
+}
+function hasLostTurnInputCommit(error) {
+  const cause = getConversationTurnBoundaryError(error)?.cause ?? error;
+  return isTurnInputCommitLostError(error) || isTurnInputCommitLostError(cause);
+}
+async function completeCancelledConversationTurn(args) {
+  const pendingAuthorization = args.conversation.processing.pendingAuth?.sessionId === args.turnId ? args.conversation.processing.pendingAuth : void 0;
+  await abandonTurnRecord({
+    conversationId: args.conversationId,
+    turnId: args.turnId,
+    errorMessage: "Turn cancelled"
+  });
+  clearPendingAuth(args.conversation, args.turnId);
+  markConversationMessage(args.conversation, args.userMessageId, {
+    replied: false,
+    skippedReason: "turn cancelled"
+  });
+  markTurnClosed({
+    conversation: args.conversation,
+    nowMs: Date.now(),
+    sessionId: args.turnId
+  });
+  if (pendingAuthorization) {
+    await deleteWebAuthorization({
+      actorId: pendingAuthorization.actorId,
+      conversationId: args.conversationId
+    });
+  }
+  await persistThreadStateById(args.conversationId, {
+    conversation: args.conversation,
+    sandboxRef: args.sandboxRef
+  });
+  await new ConversationTurnLifecycleService(
+    getConversationEventStore()
+  ).complete({
+    conversationId: args.conversationId,
+    createdAtMs: Date.now(),
+    outcome: "cancelled",
+    turnId: args.turnId
+  });
+  await args.acknowledge();
+}
+function createConversationTurnWorker(agentRunner, publishMessage) {
+  return async (context, resolved) => {
+    const lifecycle = new ConversationTurnLifecycleService(
+      getConversationEventStore()
+    );
+    const isResume = resolved.kind === "resume";
+    let turnInputFacts;
+    let text = "";
+    let turnId = "";
+    let userMessageId = "";
+    let startedAtMs = Date.now();
+    let inputMessageIds = [];
+    const storedConversation = await getConversationStore().get({
+      conversationId: context.conversationId
+    });
+    const mailboxDestination = resolved.kind === "mailbox" ? resolved.batch[0]?.message.destination : void 0;
+    const destination = resolveConversationDestination({
+      conversationId: context.conversationId,
+      existing: context.destination ?? mailboxDestination ?? storedConversation?.destination
+    });
+    if (resolved.kind === "mailbox") {
+      const first = resolved.batch[0];
+      text = joinMailboxText(resolved.batch.map((entry) => entry.message));
+      startedAtMs = first.message.createdAtMs;
+      userMessageId = first.message.inboundMessageId;
+      turnId = buildDeterministicTurnId(userMessageId);
+      inputMessageIds = resolved.batch.map(
+        (entry) => entry.message.inboundMessageId
+      );
+      turnInputFacts = first;
+    } else {
+      turnId = resolved.turnId;
+    }
+    const persisted = await getPersistedThreadState(context.conversationId);
+    const conversation = coerceThreadConversationState(persisted);
+    await hydrateConversationMessages({
+      conversation,
+      conversationId: context.conversationId
+    });
+    if (isResume) {
+      const userMessage = getTurnUserMessage(conversation, turnId);
+      if (!userMessage) {
+        throw new Error(
+          `Unable to locate the persisted user message for Turn "${turnId}"`
+        );
+      }
+      turnInputFacts = turnInputFactsFromConversationMessage(userMessage);
+      userMessageId = userMessage.id;
+      text = userMessage.text;
+      startedAtMs = userMessage.createdAtMs;
+      inputMessageIds = [userMessageId];
+    }
+    if (!turnInputFacts) {
+      throw new Error(
+        `Resumed Turn is missing an Actor for Conversation ${context.conversationId}`
+      );
+    }
+    const { actor, author } = turnInputFacts;
+    const source = sourceFromTurnInput({
+      conversationId: context.conversationId,
+      location: storedConversation?.location,
+      source: turnInputFacts.source,
+      visibility: storedConversation?.visibility
+    });
+    const webActor = actor.platform === "web" ? actor : void 0;
+    const savedTurn = isResume ? await getTurnRecord(context.conversationId, turnId) : void 0;
+    const publish = turnInputFacts.source === "resource_event" && storedConversation?.location ? savedTurn?.publishExternally ?? true : false;
+    const surface = publish ? "slack" : "api";
+    return await withLogContext(
+      {
+        conversationId: context.conversationId,
+        platform: actor.platform,
+        ...webActor ? {
+          userId: webActor.userId,
+          ...webActor.userName ? { userName: webActor.userName } : void 0
+        } : void 0
+      },
+      async () => {
+        let acknowledged = isResume || context.attempt.messages.length === 0;
+        const acknowledge = async () => {
+          if (acknowledged) {
+            return;
+          }
+          try {
+            await context.attempt.ack();
+          } catch {
+            throw new TurnInputCommitLostError(
+              `Conversation work lease lost before mailbox Message acknowledgement for ${context.conversationId}`
+            );
+          }
+          acknowledged = true;
+        };
+        let sandboxRef = getPersistedSandboxState(persisted);
+        const initialSandboxRef = sandboxRef;
+        const stopSignal = context.stopSignal?.();
+        const completeCancelledTurn = async () => {
+          try {
+            await completeCancelledConversationTurn({
+              acknowledge,
+              conversation,
+              conversationId: context.conversationId,
+              sandboxRef,
+              turnId,
+              userMessageId
+            });
+          } catch (error) {
+            if (hasLostTurnInputCommit(error)) {
+              return { status: "lost_lease" };
+            }
+            throw error;
+          }
+          return { status: "completed" };
+        };
+        if (isResume) {
+          if (stopSignal?.aborted) {
+            return await completeCancelledTurn();
+          }
+        } else {
+          upsertConversationMessage(conversation, {
+            id: userMessageId,
+            role: "user",
+            text: normalizeConversationText(text),
+            createdAtMs: startedAtMs,
+            author,
+            meta: {
+              explicitMention: true,
+              replied: false,
+              ...turnInputFacts.source === "web" ? { source: "web" } : void 0
+            }
+          });
+          await persistConversationMessages({
+            conversation,
+            conversationId: context.conversationId
+          });
+          await lifecycle.start({
+            conversationId: context.conversationId,
+            createdAtMs: Date.now(),
+            inputMessageIds,
+            surface,
+            turnId
+          });
+          if (stopSignal?.aborted) {
+            return await completeCancelledTurn();
+          }
+          startActiveTurn({
+            conversation,
+            nextTurnId: turnId
+          });
+        }
+        let currentRunId;
+        let assistantMessageDelivered = false;
+        let failureCode = "persistence_failed";
+        let modelFailureEventId;
+        let modelFailureCaptureAttempted = false;
+        let completedSuccessfully = false;
+        const deliverAssistantMessage = async (value) => {
+          const agentMessage = typeof value === "string" ? void 0 : value;
+          const replyText = typeof value === "string" ? value : getAssistantReplyText(value);
+          if (!replyText?.trim()) {
+            return;
+          }
+          failureCode = "delivery_failed";
+          const location = storedConversation?.location;
+          if (publish && (!location || !publishMessage)) {
+            throw new Error(
+              `Conversation ${context.conversationId} cannot publish its system Turn`
+            );
+          }
+          const publishedMessage = publish && location && publishMessage ? await publishMessage({
+            conversationId: context.conversationId,
+            location,
+            text: replyText
+          }) : void 0;
+          await commitAssistantMessage({
+            ...agentMessage ? { agentMessage } : void 0,
+            conversation,
+            conversationId: context.conversationId,
+            ...publishedMessage ? { publishedMessage } : void 0,
+            sessionId: turnId,
+            ...publishedMessage ? { source: "slack" } : turnInputFacts.source === "web" ? { source: "web" } : void 0,
+            text: replyText,
+            userMessageId
+          });
+          assistantMessageDelivered = true;
+          failureCode = "agent_run_failed";
+        };
+        try {
+          if (stopSignal?.aborted) {
+            return await completeCancelledTurn();
+          }
+          if (!isResume) {
+            const pendingAuthorizationActorId = conversation.processing.pendingAuth?.actorId;
+            const authParked = (await listTurnSummaries(context.conversationId)).filter(
+              (summary) => summary.surface === "api" && !summary.dispatchId && summary.state === "paused" && summary.resumeReason === "auth"
+            );
+            for (const parked of authParked) {
+              if (stopSignal?.aborted) {
+                return await completeCancelledTurn();
+              }
+              await abandonTurnRecord({
+                conversationId: context.conversationId,
+                turnId: parked.turnId,
+                errorMessage: "Auth-paused Turn superseded by new input"
+              });
+              markTurnClosed({
+                conversation,
+                nowMs: Date.now(),
+                sessionId: parked.turnId
+              });
+            }
+            if (authParked.length > 0 && pendingAuthorizationActorId) {
+              await deleteWebAuthorization({
+                actorId: pendingAuthorizationActorId,
+                conversationId: context.conversationId
+              });
+            }
+          }
+          await persistThreadStateById(context.conversationId, {
+            conversation
+          });
+          if (stopSignal?.aborted) {
+            return await completeCancelledTurn();
+          }
+          const piMessages = await loadProjection({
+            conversationId: context.conversationId
+          });
+          failureCode = "agent_run_failed";
+          currentRunId = `conversation-run:${stableHex(turnId, String(startedAtMs))}`;
+          setTags({ runId: currentRunId });
+          const outcome = await executeTurn(
+            agentRunner,
+            {
+              conversationId: context.conversationId,
+              turnId,
+              runId: currentRunId,
+              instruction: {
+                text,
+                context: buildConversationContext(conversation, {
+                  excludeMessageId: userMessageId
+                })
+              },
+              history: piMessages,
+              actor,
+              credentialContext: credentialContextForActor(actor),
+              // TODO(dcramer): Remove AgentRun.destination after agent and tool
+              // code reads AgentRun.location and no Run consumer needs it.
+              destination,
+              // TODO(dcramer): Remove AgentRun.publishExternally after the
+              // saved Turn publish choice controls optional Delivery.
+              publishExternally: publish,
+              source,
+              ...storedConversation?.location ? { location: storedConversation.location } : void 0,
+              surface,
+              ...stopSignal ? { signal: stopSignal } : void 0,
+              ...webActor ? {
+                authorization: createWebAuthorization({
+                  actorId: webActor.userId,
+                  conversationId: context.conversationId
+                })
+              } : { disabledFeatures: ["interactive-auth"] },
+              state: {
+                pendingAuth: conversation.processing.pendingAuth,
+                sandboxRef
+              },
+              delivery: deliverAssistantMessage,
+              durability: {
+                onInputCommitted: acknowledge,
+                shouldYield: context.shouldYield,
+                onSandboxRefChanged: async (nextSandboxRef) => {
+                  sandboxRef = nextSandboxRef;
+                  await persistThreadStateById(context.conversationId, {
+                    conversation,
+                    sandboxRef
+                  });
+                },
+                recordPendingAuth: async (pendingAuth) => {
+                  conversation.processing.pendingAuth = pendingAuth;
+                  await persistThreadStateById(context.conversationId, {
+                    conversation,
+                    sandboxRef
+                  });
+                }
+              }
+            },
+            async (result) => {
+              if (stopSignal?.aborted) {
+                throw stopSignal.reason ?? new DOMException("Turn cancelled", "AbortError");
+              }
+              modelFailureCaptureAttempted = result.diagnostics.outcome !== "success";
+              const finalized = finalizeFailedTurnReplyWithEvent({
+                reply: result,
+                logException
+              });
+              const modelFailureReason = finalized.failureReason;
+              const reply = finalized.reply;
+              modelFailureEventId = finalized.eventId;
+              if (reply.diagnostics.outcome !== "success") {
+                await deliverAssistantMessage(reply.text);
+              }
+              const completedState = buildDeliveredTurnStatePatch({
+                conversation,
+                reply,
+                sessionId: turnId,
+                userMessageId
+              });
+              await persistThreadStateById(context.conversationId, {
+                conversation: completedState.conversation,
+                sandboxRef: reply.sandboxRef ?? sandboxRef
+              });
+              if (reply.piMessages?.length) {
+                const latest = await getTurnRecord(
+                  context.conversationId,
+                  turnId
+                );
+                await saveTurnCheckpoint({
+                  mode: "completed",
+                  conversationId: context.conversationId,
+                  turnId,
+                  sliceId: latest?.sliceId ?? 1,
+                  messages: reply.piMessages,
+                  durationMs: reply.diagnostics.durationMs,
+                  usage: reply.diagnostics.usage,
+                  // TODO(dcramer): Remove checkpoint Destination after resume
+                  // reads the Conversation Location.
+                  destination,
+                  publishExternally: publish,
+                  source,
+                  actor,
+                  surface
+                });
+              }
+              completedSuccessfully = reply.diagnostics.outcome === "success";
+              return completedSuccessfully ? {
+                outcome: assistantMessageDelivered ? "success" : "no_reply"
+              } : {
+                ...modelFailureEventId ? { eventId: modelFailureEventId } : void 0,
+                failureCode: "model_execution_failed",
+                ...modelFailureReason ? { failureReason: modelFailureReason } : void 0,
+                outcome: "failed"
+              };
+            }
+          );
+          if (outcome.status !== "completed" && stopSignal?.aborted) {
+            return await completeCancelledTurn();
+          }
+          if (outcome.status === "suspended") {
+            return { status: "yielded" };
+          }
+          if (outcome.status === "awaiting_auth") {
+            completeAuthPauseTurn({
+              conversation,
+              sessionId: turnId
+            });
+            await persistThreadStateById(context.conversationId, {
+              conversation,
+              sandboxRef
+            });
+            await acknowledge();
+            return { status: "paused" };
+          }
+          if (completedSuccessfully) {
+            try {
+              await scheduleSessionCompletedPluginTasks(
+                {
+                  conversationId: context.conversationId,
+                  sessionId: turnId
+                },
+                {
+                  send: async (message) => {
+                    try {
+                      await processPluginTask(message);
+                    } catch (error) {
+                      logException(
+                        error,
+                        "conversation.plugin.session_completion_task.failed",
+                        {
+                          conversationId: context.conversationId,
+                          pluginName: message.plugin,
+                          taskName: message.name,
+                          turnId
+                        }
+                      );
+                    }
+                  }
+                }
+              );
+            } catch (error) {
+              logException(
+                error,
+                "conversation.plugin.session_completion_task.failed",
+                {
+                  conversationId: context.conversationId,
+                  turnId
+                }
+              );
+            }
+          }
+          await acknowledge();
+          return { status: "completed" };
+        } catch (error) {
+          const failure = error instanceof AgentRunError ? error.cause : error;
+          if (hasLostTurnInputCommit(failure)) {
+            return { status: "lost_lease" };
+          }
+          if (stopSignal?.aborted) {
+            return await completeCancelledTurn();
+          }
+          if (!context.attempt.isFinalAttempt) {
+            throw failure;
+          }
+          const failureEventId = modelFailureCaptureAttempted && failureCode === "agent_run_failed" ? modelFailureEventId : captureConversationTurnFailure({
+            conversationId: context.conversationId,
+            error: failure,
+            failureCode,
+            runId: currentRunId,
+            turnId
+          });
+          try {
+            markTurnFailed({
+              conversation,
+              nowMs: Date.now(),
+              sessionId: turnId,
+              userMessageId,
+              markConversationMessage
+            });
+            await persistThreadStateById(context.conversationId, {
+              conversation,
+              sandboxRef: initialSandboxRef ?? null
+            });
+          } catch (persistenceError) {
+            captureConversationTurnFailure({
+              conversationId: context.conversationId,
+              error: persistenceError,
+              failureCode: "persistence_failed",
+              runId: currentRunId,
+              turnId
+            });
+          }
+          await lifecycle.fail({
+            conversationId: context.conversationId,
+            createdAtMs: Date.now(),
+            ...failureEventId ? { eventId: failureEventId } : void 0,
+            failureCode,
+            turnId
+          });
+          await acknowledge();
+          return { status: "completed" };
+        }
+      }
+    );
+  };
+}
+
+// src/chat/providers/slack/system-turn.ts
+function createSlackSystemTurnPublisher(args) {
+  return async ({ conversationId, location, text }) => {
+    if (location.provider !== "slack") {
+      throw new Error(
+        `Slack system Turn cannot publish to ${location.provider} Location`
+      );
+    }
+    let messageIds;
+    try {
+      messageIds = await runWithSlackInstallation({
+        adapter: args.getSlackAdapter(),
+        installation: { teamId: location.teamId },
+        state: args.state,
+        task: async () => await sendSlackReply({
+          channelId: location.channelId,
+          conversationId,
+          text,
+          ...location.threadTs ? { threadTs: location.threadTs } : void 0
+        })
+      });
+    } catch (error) {
+      if (isRetryableSlackPostError(error)) {
+        throw new RetryableDeliveryError(error);
+      }
+      throw error;
+    }
+    const providerMessageId = messageIds.at(-1);
+    const providerConversationId = location.threadTs ?? messageIds[0];
+    return {
+      ...providerMessageId ? { providerMessageId } : void 0,
+      ...providerConversationId ? {
+        providerConversationBindings: [
+          {
+            provider: "slack",
+            providerDestinationId: location.channelId,
+            providerTenantId: location.teamId,
+            providerConversationId
+          }
+        ]
+      } : void 0
+    };
+  };
+}
+
 // src/chat/app/conversation-work.ts
 function createConversationWork(options) {
-  const apiTurnCancellation = createApiTurnCancellation();
   const pausedTurns = createPausedTurns({
     conversationStore: options.conversationStore,
     queue: options.queue,
     ...options.state ? { state: options.state } : void 0
   });
-  const runtime = createSlackRuntime({
+  const baseRuntime = createSlackRuntime({
     getSlackAdapter: options.getSlackAdapter,
     pausedTurns,
+    ...options.sendPluginTask ? { sendPluginTask: options.sendPluginTask } : void 0,
     services: {
       ...options.services,
       agentRunner: options.agentRunner
     }
   });
+  const runtime = options.wrapRuntime?.(baseRuntime) ?? baseRuntime;
+  const scheduleCompletedPluginTasks = options.sendPluginTask ? async (params) => await scheduleSessionCompletedPluginTasks(params, {
+    send: options.sendPluginTask
+  }) : void 0;
   const slackWorker = createSlackConversationWorker({
     getSlackAdapter: options.getSlackAdapter,
-    conversationStore: options.conversationStore,
     runNextPausedTurn: async (conversationId, runOptions) => await runNextPausedTurn(
       conversationId,
       {
         agentRunner: options.agentRunner,
-        wakePausedTurn: pausedTurns.wake
+        wakePausedTurn: pausedTurns.wake,
+        ...scheduleCompletedPluginTasks ? {
+          scheduleSessionCompletedPluginTasks: scheduleCompletedPluginTasks
+        } : void 0
       },
       runOptions
     ),
@@ -8747,13 +9392,24 @@ function createConversationWork(options) {
           agentRunner: options.agentRunner,
           inputMessageIds: [getDispatchInputMessageId(dispatch2.id)],
           routingContext: buildDispatchRoutingContext(dispatch2),
-          wakePausedTurn: pausedTurns.wake
+          wakePausedTurn: pausedTurns.wake,
+          ...scheduleCompletedPluginTasks ? {
+            scheduleSessionCompletedPluginTasks: scheduleCompletedPluginTasks
+          } : void 0
         },
         { shouldYield: hooks.shouldYield }
       );
     },
     runTurn: runtime.runDispatchTurn
   });
+  const invocationWorker = createAgentInvocationWorker(options.agentRunner);
+  const conversationTurnWorker = createConversationTurnWorker(
+    options.agentRunner,
+    createSlackSystemTurnPublisher({
+      getSlackAdapter: options.getSlackAdapter,
+      state: options.state
+    })
+  );
   const destinationWorker = async (context) => {
     const destination = context.destination;
     if (!destination) {
@@ -8768,24 +9424,25 @@ function createConversationWork(options) {
       `Conversation ${context.conversationId} has a ${destination.platform} destination but no matching conversation worker`
     );
   };
-  const providerWorker = createAgentDispatchWorkRouter({
-    dispatchWorker,
-    fallbackWorker: destinationWorker
-  });
+  const run = async (context) => {
+    const mailboxTurn = await resolveMailboxTurnWork(context);
+    if (mailboxTurn) {
+      return await conversationTurnWorker(context, mailboxTurn);
+    }
+    const invocationId = await resolveAgentInvocationId(context);
+    if (invocationId) {
+      return await invocationWorker(context, invocationId);
+    }
+    const dispatchId = await resolveAgentDispatchId(context);
+    if (dispatchId) {
+      return await dispatchWorker(context, dispatchId);
+    }
+    return await destinationWorker(context);
+  };
   return {
-    apiTurnCancellation,
     conversationStore: options.conversationStore,
     queue: options.queue,
-    run: routeApiTurnWork({
-      apiTurnWorker: createApiTurnWorker(
-        options.agentRunner,
-        apiTurnCancellation
-      ),
-      fallbackWorker: routeAgentInvocationWork({
-        invocationWorker: createAgentInvocationWorker(options.agentRunner),
-        fallbackWorker: providerWorker
-      })
-    }),
+    run,
     runtime,
     state: options.state
   };
@@ -8865,7 +9522,7 @@ async function publicArtifactGET(args) {
 }
 
 // src/chat/event-tasks/ingest.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import {
   createSlackSource as createSlackSource3,
   RESOURCE_EVENT_SUMMARY_MAX_LENGTH,
@@ -8873,7 +9530,7 @@ import {
   resourceEventSchema
 } from "@sentry/junior-plugin-api";
 function eventTaskDispatchKey(taskId, namespace, eventKey) {
-  return `event-task:${createHash("sha256").update(`${taskId}\0${namespace}\0${eventKey}`).digest("hex").slice(0, 32)}`;
+  return `event-task:${createHash2("sha256").update(`${taskId}\0${namespace}\0${eventKey}`).digest("hex").slice(0, 32)}`;
 }
 function oneLine(value) {
   return value.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 512);
@@ -9014,8 +9671,8 @@ function createResourceEventAppPublisher(args) {
   };
 }
 
-// src/chat/api-turns/stop.ts
-async function stopApiConversationTurn(args) {
+// src/chat/conversations/stop.ts
+async function stopConversationTurn(args) {
   const nowMs = args.nowMs ?? Date.now();
   const stop = async () => await stopConversationWork({
     conversationId: args.conversationId,
@@ -9024,7 +9681,7 @@ async function stopApiConversationTurn(args) {
     state: args.state
   });
   let result = await stop();
-  if (result.status === "no_work" && await getAuthPausedApiTurnId(args.conversationId)) {
+  if (result.status === "no_work" && await getAuthPausedConversationTurnId(args.conversationId)) {
     const conversation = await getConversation({
       conversationId: args.conversationId,
       state: args.state
@@ -9042,7 +9699,7 @@ async function stopApiConversationTurn(args) {
     await ensureConversationWake({
       conversationId: args.conversationId,
       conversationStore: args.conversationStore,
-      idempotencyKey: `api-stop:${args.conversationId}:${result.runId}`,
+      idempotencyKey: `conversation-stop:${args.conversationId}:${result.runId}`,
       nowMs,
       queue: args.queue,
       replaceExistingWake: true,
@@ -9096,7 +9753,7 @@ function createAcpConversations(options) {
       if (!await hasConversationAccess(conversationId, user)) {
         return "not_found";
       }
-      await stopApiConversationTurn({
+      await stopConversationTurn({
         conversationId,
         conversationStore: options.conversationStore,
         queue: options.queue,
@@ -9105,7 +9762,7 @@ function createAcpConversations(options) {
       return "cancelled";
     },
     async create({ conversationId, user }) {
-      await recordApiConversationActivity({
+      await recordWebConversationActivity({
         actor: actorFromUser(user),
         conversationId,
         conversationStore: options.conversationStore,
@@ -9124,10 +9781,10 @@ function createAcpConversations(options) {
         options.eventStore,
         conversationId
       );
-      if (await getAuthPausedApiTurnId(conversationId)) {
+      if (await getAuthPausedConversationTurnId(conversationId)) {
         return { status: "active" };
       }
-      const admission = await appendAndEnqueueApiConversationMessage(
+      const result = await appendAndEnqueueWebMessage(
         {
           actor: actorFromUser(user),
           conversationId,
@@ -9141,12 +9798,12 @@ function createAcpConversations(options) {
           state: options.state
         }
       );
-      if (admission.status === "active") return { status: "active" };
+      if (result.status === "active") return { status: "active" };
       return {
-        afterCursor: admission.status === "duplicate" ? 0 : currentCursor,
-        messageId: admission.messageId,
+        afterCursor: result.status === "duplicate" ? 0 : currentCursor,
+        messageId: result.messageId,
         status: "accepted",
-        turnId: apiTurnIdForMessage(admission.messageId)
+        turnId: conversationTurnIdForMessage(result.messageId)
       };
     },
     async readMessages(conversationId) {
@@ -9204,12 +9861,12 @@ function createAcpConversations(options) {
 }
 
 // src/api/acp/route.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 import * as acp4 from "@agentclientprotocol/sdk";
 
 // src/api/acp/auth.ts
 import {
-  createHash as createHash3,
+  createHash as createHash4,
   randomBytes,
   randomUUID as randomUUID2,
   timingSafeEqual as timingSafeEqual3
@@ -9254,7 +9911,7 @@ async function fenceLock(state, lock, ttlMs = MUTATION_LOCK_TTL_MS) {
 }
 
 // src/api/acp/transport.ts
-import { createHash as createHash2, randomUUID } from "crypto";
+import { createHash as createHash3, randomUUID } from "crypto";
 import * as acp2 from "@agentclientprotocol/sdk";
 import { userSchema } from "@sentry/junior-plugin-api";
 import { z as z7 } from "zod";
@@ -9434,8 +10091,8 @@ var acpRequestReceiptSchema = z7.object({
   sessionId: z7.string().min(1).optional()
 }).strict();
 var acpStreamCursorSchema = z7.object({ itemId: z7.string().min(1) }).strict();
-function stableHex(value) {
-  return createHash2("sha256").update(value).digest("hex").slice(0, 32);
+function stableHex2(value) {
+  return createHash3("sha256").update(value).digest("hex").slice(0, 32);
 }
 function connectionKey(connectionId) {
   return `junior:acp:v1:connection:${connectionId}`;
@@ -9450,7 +10107,7 @@ function connectionLockKey(connectionId) {
   return `${connectionKey(connectionId)}:lock`;
 }
 function streamKey(route) {
-  const suffix = route.sessionId ? `session:${stableHex(route.sessionId)}` : "connection";
+  const suffix = route.sessionId ? `session:${stableHex2(route.sessionId)}` : "connection";
   return `${connectionKey(route.connectionId)}:stream:${suffix}`;
 }
 function streamListKey(route) {
@@ -9466,7 +10123,7 @@ function streamAppendLockKey(route) {
   return `${streamKey(route)}:append`;
 }
 function requestStreamItemId(requestKey2, index) {
-  return `acp-item:${stableHex(`${requestKey2}:${index}`)}`;
+  return `acp-item:${stableHex2(`${requestKey2}:${index}`)}`;
 }
 function parseStreamItem(value) {
   return storedAcpStreamItemSchema.parse(value);
@@ -10075,7 +10732,7 @@ function authorizationPointerLockKey(connectionId) {
   return `${authorizationPointerKey(connectionId)}:lock`;
 }
 function credentialHash(value) {
-  return createHash3("sha256").update(value).digest("hex");
+  return createHash4("sha256").update(value).digest("hex");
 }
 function createUserCode() {
   const value = randomBytes(6).toString("hex").toUpperCase();
@@ -10539,8 +11196,8 @@ function promptText(prompt) {
   }
   return text;
 }
-function stableHex2(value, length = 32) {
-  return createHash4("sha256").update(value).digest("hex").slice(0, length);
+function stableHex3(value, length = 32) {
+  return createHash5("sha256").update(value).digest("hex").slice(0, length);
 }
 function canonicalJson(value) {
   if (Array.isArray(value)) return value.map(canonicalJson);
@@ -10550,11 +11207,11 @@ function canonicalJson(value) {
   );
 }
 function requestKey(call) {
-  const id = call.id === null ? "null" : `${typeof call.id}:${stableHex2(String(call.id))}`;
+  const id = call.id === null ? "null" : `${typeof call.id}:${stableHex3(String(call.id))}`;
   const payload = JSON.stringify(
     canonicalJson({ method: call.method, params: call.params ?? null })
   );
-  return `${id}:${stableHex2(payload)}`;
+  return `${id}:${stableHex3(payload)}`;
 }
 function sessionIdFromCall(call) {
   if (!call) return void 0;
@@ -10607,7 +11264,7 @@ async function createSession(args) {
     args.call.params
   );
   rejectUnsupportedMcpServers(params.mcpServers);
-  const sessionId = `${ACP_CONVERSATION_PREFIX}${stableHex2(
+  const sessionId = `${ACP_CONVERSATION_PREFIX}${stableHex3(
     `${args.connection.nonce}:${args.requestKey}`
   )}`;
   await args.conversations.create({
@@ -10621,16 +11278,16 @@ async function acceptPrompt(args) {
     promptParamsSchema,
     args.call.params
   );
-  const admission = await args.conversations.prompt({
+  const result = await args.conversations.prompt({
     conversationId: params.sessionId,
     idempotencyKey: `${args.connection.nonce}:${args.requestKey}`,
     text: promptText(params.prompt),
     user: args.user
   });
-  if (admission.status === "not_found") {
+  if (result.status === "not_found") {
     throw acp4.RequestError.resourceNotFound(params.sessionId);
   }
-  if (admission.status === "active") {
+  if (result.status === "active") {
     throw acp4.RequestError.invalidParams(
       { field: "sessionId" },
       "This ACP session already has an active prompt"
@@ -10638,11 +11295,11 @@ async function acceptPrompt(args) {
   }
   return {
     output: {
-      afterSeq: admission.afterCursor,
+      afterSeq: result.afterCursor,
       kind: "prompt",
-      messageId: admission.messageId,
+      messageId: result.messageId,
       requestId: args.requestId,
-      turnId: admission.turnId
+      turnId: result.turnId
     },
     sessionId: params.sessionId
   };