@sentry/junior 0.147.0 → 0.149.0

package/dist/app.js

@@ -1,15 +1,15 @@
 import {
   processConversationWork
-} from "./chunk-PVNG6UMU.js";
+} from "./chunk-TFBNBXPU.js";
 import {
   bindSpawnAgent
-} from "./chunk-745QJ3ZA.js";
+} from "./chunk-ALJG73MQ.js";
 import {
   createAgentInvocationWorker,
   enqueueAgentInvocation,
   listPendingAgentInvocationMailboxAppends,
   routeAgentInvocationWork
-} from "./chunk-YEO3VX72.js";
+} from "./chunk-W7UONUIZ.js";
 import {
   GET as GET2,
   GET2 as GET3,
@@ -25,21 +25,36 @@ import {
   getSlackErrorObservabilityAttributes,
   getThreadId,
   getThreadTs,
-  getTurnRequestDeadline,
   isRetryableSlackPostError,
   isSlackTitlePermissionError,
   publishAppHomeView,
   receiveLocalOAuthCredential,
   resumeSlackTurn,
-  runWithTurnRequestDeadline,
   sendSlackReply,
   shouldKeepProcessingReactionForToolInvocation,
   splitSlackReplyText,
   startSlackProcessingReaction,
   stripLeadingBotMention,
   wakePausedTurn
-} from "./chunk-AYU72WO7.js";
+} from "./chunk-75DSYFFB.js";
 import "./chunk-FA6POGLH.js";
+import {
+  getTurnRequestDeadline,
+  runWithTurnRequestDeadline
+} from "./chunk-EXW76GW4.js";
+import {
+  completeAuthPauseTurn,
+  persistAuthPauseTurnState
+} from "./chunk-ART7P442.js";
+import {
+  GET,
+  conversationVisibilityFromSlackChannelType,
+  createApiTurnWorker,
+  resolveSlackChannelTypeFromMessage,
+  resolveSlackConversationContext,
+  routeApiTurnWork
+} from "./chunk-5CWUQXXT.js";
+import "./chunk-4CODA7P5.js";
 import {
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
   appendAndEnqueueInboundMessage,
@@ -50,48 +65,36 @@ import {
   isInvalidConversationRecordError,
   listActiveConversationIds,
   removeActiveConversation
-} from "./chunk-CWP5RHVX.js";
+} from "./chunk-JMSMXXED.js";
 import {
-  buildConversationContext,
   buildDeliveredTurnStatePatch,
   claimDispatchMailboxAppend,
-  completeAuthPauseTurn,
   confirmDispatchMailboxAppend,
-  createConversationMemoryService,
   createOrGetDispatch,
-  estimateConversationContextTokens,
   finalizeFailedTurnReplyWithEvent,
   getAgentTurnDiagnosticsAttributes,
-  getConversationMessageSlackTs,
   getDispatchConversationId,
   getDispatchInputMessageId,
   getDispatchInputMessageIds,
   getDispatchRecord,
   getDispatchTurnId,
   getPluginDispatchProjection,
-  getThreadTitleSourceMessage,
   getTurnUserMessage,
   getTurnUserReplyAttachmentContext,
   getTurnUserSlackMessageTs,
-  isHumanConversationMessage,
   isTerminalDispatchStatus,
   listPendingDispatchMailboxAppends,
-  markConversationMessage,
   markDispatchAwaitingResume,
   markDispatchBlocked,
   markDispatchCompleted,
   markDispatchFailed,
   markDispatchRunning,
-  normalizeConversationText,
-  persistAuthPauseTurnState,
   processPluginTask,
-  recordDeliveredAssistantMessage,
+  recordTaskExecution,
   requireTurnFailureEventId,
   resolveTurnSessionRouting,
-  scheduleSessionCompletedPluginTasks,
-  turnHasReply,
-  upsertConversationMessage
-} from "./chunk-6H5SZR24.js";
+  scheduleSessionCompletedPluginTasks
+} from "./chunk-UZGASGOD.js";
 import {
   ConversationTurnLifecycleService,
   coerceThreadConversationState,
@@ -101,17 +104,7 @@ import {
   persistThreadRuntimeState,
   persistThreadState,
   persistThreadStateById
-} from "./chunk-AZ7EAOBE.js";
-import {
-  GET,
-  conversationVisibilityFromSlackChannelType,
-  resolveSlackChannelTypeFromMessage,
-  resolveSlackConversationContext
-} from "./chunk-34GS7B6L.js";
-import "./chunk-4CODA7P5.js";
-import {
-  recordTaskExecution
-} from "./chunk-AVOCH2Z5.js";
+} from "./chunk-4YKPOYRV.js";
 import "./chunk-UTL3MHPC.js";
 import {
   getVercelConversationWorkQueue,
@@ -130,7 +123,7 @@ import {
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-YNTTROJT.js";
+} from "./chunk-QIW7OQEO.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -163,88 +156,95 @@ import {
   setConfigDefaults,
   shouldEmitDevAgentTrace,
   shouldPropagateSandboxEgressTrace
-} from "./chunk-7A4M7PCV.js";
+} from "./chunk-DK5UT6PQ.js";
 import {
   AuthorizationFlowDisabledError,
   PluginCredentialFailureError
-} from "./chunk-X5UY34KT.js";
+} from "./chunk-XPYWWMHR.js";
 import "./chunk-DIB4GX3G.js";
 import {
   createUserTokenStore,
   deleteMcpAuthSessionsForUserProvider,
   deleteMcpServerSessionId,
   deleteMcpStoredOAuthCredentials
-} from "./chunk-Q4R73I43.js";
+} from "./chunk-RB26T3LU.js";
 import {
   RetryableDeliveryError
-} from "./chunk-R776HKPK.js";
+} from "./chunk-GDFF3BQG.js";
 import {
   formatProviderLabel,
   postSlackMessage,
   startOAuthFlow
-} from "./chunk-7UQIVT6G.js";
+} from "./chunk-JMH3DBM5.js";
+import "./chunk-HUO3UTAQ.js";
 import {
-  estimateTextTokens
-} from "./chunk-K4SZAP3K.js";
+  getExperimentalFeatures,
+  setExperimentalFeatures
+} from "./chunk-5IDFPCON.js";
+import {
+  getSandboxResourceConfig,
+  setSandboxResourceConfig
+} from "./chunk-2P6BQQER.js";
+import {
+  createSchedulerSqlStore,
+  findMatchingEventTasks,
+  logScheduledTaskRunSkipped,
+  scheduledTaskRunAttributes
+} from "./chunk-URDCZAL4.js";
+import {
+  parseSlackThreadId
+} from "./chunk-MEMURSBG.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
   TurnInputCommitLostError,
   TurnInputDeferredError,
   abandonTurnRecord,
+  buildConversationContext,
   buildDeterministicAssistantMessageId,
   buildDeterministicTurnId,
   clearPendingAuth,
   commitAcceptedReply,
   commitMessages,
   completeTurnRecord,
+  createConversationMemoryService,
+  estimateConversationContextTokens,
+  estimateTextTokens,
   failTurnRecord,
   getAssistantReplyText,
+  getConversationMessageSlackTs,
   getConversationTurnBoundaryError,
   getTurnRecord,
   getTurnRecordForResume,
   hydrateConversationMessages,
   isCooperativeTurnYieldError,
+  isHumanConversationMessage,
   isTurnInputCommitLostError,
   isTurnInputDeferredError,
   listTurnSummaries,
   loadConversationProjection,
   loadProjection,
   loadTurnCheckpoint,
+  markConversationMessage,
   markTurnClosed,
   markTurnCompleted,
   markTurnFailed,
+  normalizeConversationText,
   persistConversationMessageSummaries,
   persistConversationMessages,
   persistWithRetry,
+  recordDeliveredAssistantMessage,
   recordSubscribedReplyRoute,
   recordTurnSummary,
+  resolveConversationTitle,
   saveTurnCheckpoint,
   startActiveTurn,
   stripRuntimeTurnContext,
-  trimTrailingAssistantMessages
-} from "./chunk-AIOK6LAG.js";
+  trimTrailingAssistantMessages,
+  turnHasReply,
+  upsertConversationMessage
+} from "./chunk-EW2LNCRL.js";
 import "./chunk-3Y47VMHV.js";
-import "./chunk-HUO3UTAQ.js";
-import {
-  getExperimentalFeatures,
-  setExperimentalFeatures
-} from "./chunk-5IDFPCON.js";
-import {
-  getSandboxResourceConfig,
-  setSandboxResourceConfig
-} from "./chunk-AVZDSUFB.js";
-import {
-  createSchedulerSqlStore,
-  findMatchingEventTasks,
-  logScheduledTaskRunSkipped,
-  scheduledTaskRunAttributes
-} from "./chunk-EFLJ2WJH.js";
-import {
-  parseSlackThreadId
-} from "./chunk-CSZINQJ2.js";
-import "./chunk-Z4YU7Z4L.js";
-import "./chunk-HLXXQI5Q.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
 import {
@@ -263,7 +263,7 @@ import {
   verifyEventTaskCredentialSubject,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-YHDERDRO.js";
+} from "./chunk-7BH46NB4.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -273,7 +273,7 @@ import {
   normalizeSlackConversationId,
   runWithSlackInstallationToken,
   runWithWorkspaceTeamId
-} from "./chunk-SGZO7UWH.js";
+} from "./chunk-SWHPVZBV.js";
 import {
   contextProvenance,
   createSlackDestination,
@@ -286,19 +286,19 @@ import {
   requireSlackDestination,
   withConversationEventLock,
   withConversationMutationLock
-} from "./chunk-YSB2N563.js";
+} from "./chunk-3GYZ5YEH.js";
 import {
   juniorAgentBindings,
   juniorAgentInvocations,
   juniorConversationEvents,
   juniorConversations
-} from "./chunk-DU74WPIC.js";
+} from "./chunk-3I2IVWSZ.js";
 import "./chunk-EM225ITJ.js";
 import {
   acquireActiveLock,
   getStateAdapter,
   withActiveLock
-} from "./chunk-ORO3PWKQ.js";
+} from "./chunk-25SC7D6Z.js";
 import {
   STANDARD_MODEL_PROFILE,
   botConfig,
@@ -316,16 +316,16 @@ import {
   modelIdForProfile,
   setSlackReactionConfig,
   standardModelId
-} from "./chunk-7NVJVJID.js";
+} from "./chunk-32CXPIZE.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
-import "./chunk-RXBVB2JM.js";
-import "./chunk-YBVXBNSV.js";
+import "./chunk-3KGQOKIG.js";
+import "./chunk-4JGM7FXO.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-JUUKWRBE.js";
-import "./chunk-GGB4WL5A.js";
+} from "./chunk-X22XXSZA.js";
+import "./chunk-2JHKISQA.js";
 import {
   credentialContextForActor
 } from "./chunk-RUIXF3YQ.js";
@@ -359,7 +359,7 @@ import {
   withContext,
   withLogContext,
   withSpan
-} from "./chunk-4LJO56OJ.js";
+} from "./chunk-RLVZIWNQ.js";
 import {
   continueTrace
 } from "./chunk-6GWA276C.js";
@@ -367,10 +367,10 @@ import "./chunk-OOUNJNMR.js";
 import "./chunk-H4HBKISO.js";
 import {
   JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE
-} from "./chunk-DLDRQHG5.js";
+} from "./chunk-6G5RCDKP.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-IIOOO4FQ.js";
+} from "./chunk-ZYMYLLWG.js";
 import "./chunk-MLKGABMK.js";
 
 // src/app.ts
@@ -474,6 +474,7 @@ function buildAgentDispatchInboundMessage(dispatch2, nowMs = Date.now()) {
       }
     },
     receivedAtMs: nowMs,
+    publishExternally: true,
     source: "plugin"
   };
 }
@@ -1214,13 +1215,23 @@ var SCHEDULE_FREQUENCY_COPY = {
 function singleLineMetadataValue(value) {
   return value.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
 }
+function buildDispatchInput(task) {
+  const creator = sanitizeScheduledTaskPrincipal(task.createdBy);
+  return [
+    "You are executing a scheduled task.",
+    "",
+    "Task:",
+    `- creator: <@${creator.slackUserId}>`,
+    "",
+    "Stored user instruction:",
+    task.task.text
+  ].join("\n");
+}
 function buildDispatchMetadata(args) {
-  const creator = sanitizeScheduledTaskPrincipal(args.task.createdBy);
   if (!args.task.task.text?.trim()) {
     throw new Error("Scheduled task text is required");
   }
   return {
-    creatorSlackUserId: creator.slackUserId,
     runId: args.run.id,
     schedule: singleLineMetadataValue(args.task.schedule.description),
     scheduleKind: args.task.schedule.kind,
@@ -1507,7 +1518,7 @@ async function runScheduledTaskHeartbeat(args) {
           } : {},
           destination: task.destination,
           destinationVisibility: task.conversationAccess.visibility,
-          input: task.task.text,
+          input: buildDispatchInput(task),
           metadata,
           replyAttribution: replyAttribution(task),
           source: dispatchSource(task)
@@ -2976,6 +2987,7 @@ function createSlackResourceEventInboundMessage(input) {
     delivery: "defer",
     source: "resource_event",
     receivedAtMs: Date.now(),
+    publishExternally: true,
     input: {
       text: input.text,
       authorId: RESOURCE_EVENT_SLACK_AUTHOR_ID,
@@ -3180,7 +3192,9 @@ function createSlackConversationWorker(options) {
         };
         const drainSteeringMessages = async (accept) => {
           await context.attempt.drain(async (pendingRecords) => {
-            const candidates = pendingRecords.map((record) => ({
+            const candidates = pendingRecords.filter(
+              (record) => record.publishExternally === context.publishExternally
+            ).map((record) => ({
               inboundMessageId: record.inboundMessageId,
               message: restoreMessage({ adapter, record })
             })).filter(
@@ -3194,6 +3208,7 @@ function createSlackConversationWorker(options) {
             await options.runtime.handleNewMention(thread, latestMessage, {
               conversationId: context.conversationId,
               destination,
+              publishExternally: context.publishExternally,
               messageContext,
               drainSteeringMessages,
               ack,
@@ -3207,6 +3222,7 @@ function createSlackConversationWorker(options) {
               {
                 conversationId: context.conversationId,
                 destination,
+                publishExternally: context.publishExternally,
                 messageContext,
                 drainSteeringMessages,
                 ack,
@@ -3258,6 +3274,7 @@ function buildSlackInboundMessage(args) {
     source: "slack",
     createdAtMs: args.message.metadata.dateSent.getTime(),
     receivedAtMs: args.receivedAtMs,
+    publishExternally: true,
     input: {
       text: args.message.text || " ",
       authorId,
@@ -4800,6 +4817,9 @@ function buildLogContext(deps, args) {
 function actorUserName(message) {
   return getMessageActorIdentity(message)?.userName;
 }
+function shouldPublishExternally(publishExternally) {
+  return publishExternally !== false;
+}
 function createSlackTurnRuntime(deps) {
   const logContext = (args) => buildLogContext(deps, args);
   const maybeHandleThreadOptOutDecision = async (args) => {
@@ -5113,6 +5133,7 @@ function createSlackTurnRuntime(deps) {
             conversationId: hooks.conversationId,
             destination: hooks.destination,
             queuedMessages,
+            publishExternally: shouldPublishExternally(hooks.publishExternally),
             ack,
             onToolInvocation: toolInvocationHook,
             onTurnCompleted,
@@ -5170,11 +5191,13 @@ function createSlackTurnRuntime(deps) {
           lifecycleError = error2;
         }
         await hooks.beforeFirstResponsePost?.();
-        await postFallbackErrorReplyWithLogging({
-          thread,
-          eventId,
-          postFailureEventName: "mention.handler.failure_reply_post.failed"
-        });
+        if (shouldPublishExternally(hooks.publishExternally)) {
+          await postFallbackErrorReplyWithLogging({
+            thread,
+            eventId,
+            postFailureEventName: "mention.handler.failure_reply_post.failed"
+          });
+        }
         if (lifecycleError) throw lifecycleError;
       } finally {
         if (completed) {
@@ -5374,6 +5397,7 @@ function createSlackTurnRuntime(deps) {
             conversationId: hooks.conversationId,
             destination: hooks.destination,
             preparedState,
+            publishExternally: shouldPublishExternally(hooks.publishExternally),
             beforeFirstResponsePost: hooks.beforeFirstResponsePost,
             queuedMessages,
             ack,
@@ -5436,11 +5460,13 @@ function createSlackTurnRuntime(deps) {
           lifecycleError = error2;
         }
         await hooks.beforeFirstResponsePost?.();
-        await postFallbackErrorReplyWithLogging({
-          thread,
-          eventId,
-          postFailureEventName: "subscribed_message.handler.failure_reply_post.failed"
-        });
+        if (shouldPublishExternally(hooks.publishExternally)) {
+          await postFallbackErrorReplyWithLogging({
+            thread,
+            eventId,
+            postFailureEventName: "subscribed_message.handler.failure_reply_post.failed"
+          });
+        }
         if (lifecycleError) throw lifecycleError;
       } finally {
         if (completed) {
@@ -5996,8 +6022,7 @@ function createJuniorRuntimeServices(overrides = {}) {
       scheduleSessionCompletedPluginTasks: overrides.replyExecutor?.scheduleSessionCompletedPluginTasks ?? (async (params) => {
         await scheduleSessionCompletedPluginTasks(params);
       }),
-      turnLifecycle: overrides.replyExecutor?.turnLifecycle ?? new ConversationTurnLifecycleService(getConversationEventStore()),
-      generateThreadTitle: conversationMemory.generateThreadTitle
+      turnLifecycle: overrides.replyExecutor?.turnLifecycle ?? new ConversationTurnLifecycleService(getConversationEventStore())
     },
     subscribedReplyPolicy: createSubscribedReplyPolicy({
       completeObject: overrides.subscribedReplyPolicy?.completeObject ?? completeObject
@@ -6041,56 +6066,44 @@ function readSlackActionToken(message) {
 }
 
 // src/chat/slack/assistant-thread/title.ts
-function maybeUpdateAssistantTitle(args) {
-  const assistantThreadContext = args.assistantThreadContext;
-  if (!assistantThreadContext?.channelId || !assistantThreadContext.threadTs) {
-    return Promise.resolve(void 0);
-  }
-  const titleSourceMessage = getThreadTitleSourceMessage(args.conversation);
-  if (!titleSourceMessage) {
-    return Promise.resolve(void 0);
-  }
-  const isDm = isDmChannel(assistantThreadContext.channelId);
-  return (async () => {
-    let title;
-    try {
-      title = await args.generateThreadTitle(titleSourceMessage.text);
-    } catch (error) {
-      logWarn("thread.title.generation.failed", {
-        "exception.message": error instanceof Error ? error.message : String(error)
-      });
-      return void 0;
-    }
-    if (isDm) {
-      try {
-        await args.getSlackAdapter().setAssistantTitle(
-          assistantThreadContext.channelId,
-          assistantThreadContext.threadTs,
-          title
-        );
-      } catch (error) {
-        const slackErrorCode = getSlackApiErrorCode(error);
-        const assistantTitleErrorAttributes = {
-          "app.slack.assistant_title.outcome": "permission_denied",
-          ...slackErrorCode ? {
-            "app.slack.assistant_title.error_code": slackErrorCode
-          } : {}
-        };
-        if (isSlackTitlePermissionError(error)) {
-          setSpanAttributes(assistantTitleErrorAttributes);
-          logError(
-            "thread.title.generation_permission.denied",
-            assistantTitleErrorAttributes
-          );
-        } else {
-          logWarn("thread.title.slack_update.failed", {
-            "exception.message": error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
+var projectedAssistantTitles = /* @__PURE__ */ new Set();
+function assistantTitleKey(channelId, threadTs) {
+  return `${channelId}:${threadTs}`;
+}
+async function maybeSyncAssistantTitle(args) {
+  const channelId = args.channelId;
+  const threadTs = args.threadTs;
+  if (!channelId || !threadTs || !isDmChannel(channelId)) {
+    return;
+  }
+  const key = assistantTitleKey(channelId, threadTs);
+  if (projectedAssistantTitles.has(key)) {
+    return;
+  }
+  projectedAssistantTitles.add(key);
+  try {
+    await args.getSlackAdapter().setAssistantTitle(channelId, threadTs, args.title);
+  } catch (error) {
+    const slackErrorCode = getSlackApiErrorCode(error);
+    if (isSlackTitlePermissionError(error)) {
+      const assistantTitleErrorAttributes = {
+        "app.slack.assistant_title.outcome": "permission_denied",
+        ...slackErrorCode ? {
+          "app.slack.assistant_title.error_code": slackErrorCode
+        } : {}
+      };
+      setSpanAttributes(assistantTitleErrorAttributes);
+      logError(
+        "thread.title.generation_permission.denied",
+        assistantTitleErrorAttributes
+      );
+      return;
     }
-    return { title };
-  })();
+    projectedAssistantTitles.delete(key);
+    logWarn("thread.title.slack_update.failed", {
+      "exception.message": error instanceof Error ? error.message : String(error)
+    });
+  }
 }
 
 // src/chat/services/provider-default-config.ts
@@ -6240,6 +6253,9 @@ async function loadPiMessagesForTurn(args) {
   }
   return {};
 }
+function shouldPublishExternally2(publishExternally) {
+  return publishExternally !== false;
+}
 function createReplyToThread(deps) {
   return async function replyToThread(thread, message, options) {
     if (message.author.isMe) {
@@ -6376,6 +6392,9 @@ function createReplyToThread(deps) {
           );
           try {
             await beforeFirstResponsePost();
+            if (!shouldPublishExternally2(options.publishExternally)) {
+              return;
+            }
             if (channelId && threadTs) {
               await sendSlackReply({
                 channelId,
@@ -6570,7 +6589,9 @@ function createReplyToThread(deps) {
         });
         if (configReply) {
           await beforeFirstResponsePost();
-          await thread.post(buildSlackOutputMessage(configReply.text));
+          if (shouldPublishExternally2(options.publishExternally)) {
+            await thread.post(buildSlackOutputMessage(configReply.text));
+          }
           markConversationMessage(
             preparedState.conversation,
             preparedState.userMessageId,
@@ -6737,19 +6758,21 @@ function createReplyToThread(deps) {
           let slackMessageTs2 = [];
           await beforeFirstResponsePost();
           try {
-            if (channelId && thread.adapter.name === "slack") {
-              slackMessageTs2 = await sendSlackReply({
-                channelId,
-                conversationId,
-                replyAttribution: options.execution?.dispatch?.replyAttribution,
-                text,
-                ...threadTs ? { threadTs } : {}
-              });
-            } else {
-              for (const part of splitSlackReplyText(text)) {
-                const postedMessageTs = (await thread.post(buildSlackOutputMessage(part))).id;
-                if (postedMessageTs) {
-                  slackMessageTs2.push(postedMessageTs);
+            if (shouldPublishExternally2(options.publishExternally)) {
+              if (channelId && thread.adapter.name === "slack") {
+                slackMessageTs2 = await sendSlackReply({
+                  channelId,
+                  conversationId,
+                  replyAttribution: options.execution?.dispatch?.replyAttribution,
+                  text,
+                  ...threadTs ? { threadTs } : {}
+                });
+              } else {
+                for (const part of splitSlackReplyText(text)) {
+                  const postedMessageTs = (await thread.post(buildSlackOutputMessage(part))).id;
+                  if (postedMessageTs) {
+                    slackMessageTs2.push(postedMessageTs);
+                  }
                 }
               }
             }
@@ -6897,44 +6920,18 @@ function createReplyToThread(deps) {
             }
           }
           status.update();
-          const assistantTitleTask = (async () => {
-            if (conversationId) {
-              const storedConversation = await getConversationStore().get({
-                conversationId
-              });
-              if (storedConversation?.title) {
-                return void 0;
-              }
+          void resolveConversationTitle({ conversationId }).then(async (title) => {
+            if (!title) {
+              return;
             }
-            return maybeUpdateAssistantTitle({
-              assistantThreadContext,
-              assistantUserName: botConfig.userName,
-              channelId,
-              conversation: preparedState.conversation,
-              generateThreadTitle: deps.services.generateThreadTitle,
+            await maybeSyncAssistantTitle({
+              channelId: assistantThreadContext?.channelId,
               getSlackAdapter: deps.getSlackAdapter,
-              modelId: botConfig.fastModelId,
-              actorId: slackActorId,
-              runId,
-              threadId
+              threadTs: assistantThreadContext?.threadTs,
+              title
             });
-          })();
-          void assistantTitleTask.then(async (titleUpdateResult) => {
-            if (!titleUpdateResult) return;
-            if (conversationId && titleUpdateResult.title) {
-              try {
-                await getConversationStore().recordActivity({
-                  activityAtMs: message.metadata.dateSent.getTime(),
-                  conversationId,
-                  nowMs: Date.now(),
-                  title: titleUpdateResult.title
-                });
-              } catch (error) {
-                logException(error, "conversation.title.persist.failed");
-              }
-            }
           }).catch((error) => {
-            logException(error, "assistant.title.task.failed");
+            logException(error, "conversation.title.task.failed");
           });
           const toolChannelId = channelId;
           const activeInstructionAuthorId = actor?.userId ?? parseActorUserId(message.author.userId);
@@ -6980,6 +6977,7 @@ function createReplyToThread(deps) {
               slackConversation,
               source,
               destination,
+              publishExternally: shouldPublishExternally2(options.publishExternally),
               ...destinationVisibility ? { destinationVisibility } : {},
               surface: options.execution?.surface ?? "slack",
               dispatch: options.execution?.dispatch,
@@ -7465,21 +7463,26 @@ function getBackfillText(entry) {
   const text = normalizeConversationText(parseContent(entry).text);
   return text || void 0;
 }
-async function seedConversationBackfill(thread, conversation, currentTurn) {
+async function seedConversationBackfill(thread, conversation, currentTurn, resolveMessageActors) {
   if (conversation.messages.length > 0 || conversation.compactions.length > 0) {
     return "recent_messages";
   }
   const seeded = [];
   let source = "recent_messages";
+  let fetchedNewestFirst;
   try {
-    const fetchedNewestFirst = [];
+    const fetched = [];
     for await (const entry of thread.messages) {
-      fetchedNewestFirst.push(entry);
-      if (fetchedNewestFirst.length >= BACKFILL_MESSAGE_LIMIT) {
+      fetched.push(entry);
+      if (fetched.length >= BACKFILL_MESSAGE_LIMIT) {
         break;
       }
     }
-    fetchedNewestFirst.reverse();
+    fetchedNewestFirst = fetched.reverse();
+  } catch {
+  }
+  if (fetchedNewestFirst) {
+    await resolveMessageActors(fetchedNewestFirst);
     for (const entry of fetchedNewestFirst) {
       const text = getBackfillText(entry);
       if (text) {
@@ -7489,7 +7492,6 @@ async function seedConversationBackfill(thread, conversation, currentTurn) {
     if (seeded.length > 0) {
       source = "thread_fetch";
     }
-  } catch {
   }
   if (seeded.length === 0) {
     try {
@@ -7497,6 +7499,7 @@ async function seedConversationBackfill(thread, conversation, currentTurn) {
     } catch {
     }
     const fromRecent = thread.recentMessages.slice(-BACKFILL_MESSAGE_LIMIT);
+    await resolveMessageActors(fromRecent);
     for (const entry of fromRecent) {
       const text = getBackfillText(entry);
       if (text) {
@@ -7528,10 +7531,15 @@ function createPrepareTurnState(deps) {
     await hydrateConversationMessages({ conversation, conversationId });
     const locationConfiguration = args.locationConfiguration ?? getLocationConfigurationService(args.destination);
     const configuration = await locationConfiguration.resolveValues();
-    const backfillSource = args.skipBackfill ? void 0 : await seedConversationBackfill(args.thread, conversation, {
-      messageId: args.message.id,
-      messageCreatedAtMs: args.message.metadata.dateSent.getTime()
-    });
+    const backfillSource = args.skipBackfill ? void 0 : await seedConversationBackfill(
+      args.thread,
+      conversation,
+      {
+        messageId: args.message.id,
+        messageCreatedAtMs: args.message.metadata.dateSent.getTime()
+      },
+      (messages) => deps.resolveBackfillMessageActors(messages, args.destination)
+    );
     for (const queued of args.queuedMessages ?? []) {
       const queuedMessage = toConversationMessage({
         entry: queued.message,
@@ -7565,7 +7573,10 @@ function createPrepareTurnState(deps) {
         threadTs: getThreadTs(args.context.threadId)
       });
       if (conversationId) {
-        await persistConversationVisionCache(conversationId, conversation.vision);
+        await persistConversationVisionCache(
+          conversationId,
+          conversation.vision
+        );
       }
     }
     await persistConversationMessages({ conversation, conversationId });
@@ -7650,6 +7661,7 @@ function createSlackDispatchTurnRunner(options) {
       ack: hooks.ack,
       conversationId,
       destination: dispatch2.destination,
+      publishExternally: true,
       execution: {
         disabledFeatures: ["interactive-auth"],
         locationConfiguration: options.getLocationConfiguration(
@@ -7706,7 +7718,24 @@ function createSlackRuntime(options) {
   const services = createJuniorRuntimeServices(options.services);
   const prepareTurnState = createPrepareTurnState({
     compactConversationIfNeeded: services.conversationMemory.compactConversationIfNeeded,
-    hydrateConversationVisionContext: services.visionContext.hydrateConversationVisionContext
+    hydrateConversationVisionContext: services.visionContext.hydrateConversationVisionContext,
+    resolveBackfillMessageActors: async (messages, destination) => {
+      if (destination.platform !== "slack") {
+        throw new Error("Slack turn backfill requires a Slack destination");
+      }
+      await Promise.all(
+        messages.filter((message) => {
+          const actor = getMessageActorIdentity(message);
+          return !message.author.isMe && Boolean(actor?.userId) && !actor?.fullName && !actor?.userName;
+        }).map(
+          (message) => ensureSlackMessageActorIdentity(
+            message,
+            destination.teamId,
+            services.replyExecutor.lookupSlackUser
+          )
+        )
+      );
+    }
   });
   const replyToThread = createReplyToThread({
     getSlackAdapter: options.getSlackAdapter,
@@ -8145,6 +8174,9 @@ async function runPausedTurnInContext(payload, options, runOptions) {
               credentialContext,
               actor,
               destination: routingDestination,
+              // Slack resume publishes unless the checkpoint opted out.
+              // Missing means legacy/in-flight Slack turns still post.
+              publishExternally: activeTurn.publishExternally !== false,
               source,
               toolChannelId: destination.channelId
             },
@@ -8419,11 +8451,16 @@ function createConversationWork(options) {
   return {
     conversationStore: options.conversationStore,
     queue: options.queue,
-    run: routeAgentInvocationWork({
-      invocationWorker: createAgentInvocationWorker({
+    run: routeApiTurnWork({
+      apiTurnWorker: createApiTurnWorker({
         agentRunner: options.agentRunner
       }),
-      fallbackWorker: providerWorker
+      fallbackWorker: routeAgentInvocationWork({
+        invocationWorker: createAgentInvocationWorker({
+          agentRunner: options.agentRunner
+        }),
+        fallbackWorker: providerWorker
+      })
     }),
     runtime,
     state: options.state