@sentry/junior 0.185.0 → 0.186.0

package/dist/app.js

@@ -1,15 +1,15 @@
 import {
   processConversationWork
-} from "./chunk-C6TS47CQ.js";
+} from "./chunk-2U7EPTRZ.js";
 import {
   bindSpawnAgent
-} from "./chunk-TVVAMOLS.js";
+} from "./chunk-QBL2AVFF.js";
 import {
   createAgentInvocationWorker,
   enqueueAgentInvocation,
   listPendingAgentInvocationMailboxAppends,
   routeAgentInvocationWork
-} from "./chunk-HJPC32TQ.js";
+} from "./chunk-EWRPUXE3.js";
 import {
   GET as GET2,
   GET2 as GET3,
@@ -37,7 +37,7 @@ import {
   startProcessingReaction,
   stripLeadingBotMention,
   wakePausedTurn
-} from "./chunk-X2SS6BF7.js";
+} from "./chunk-O6GQO7VP.js";
 import "./chunk-FA6POGLH.js";
 import {
   GET,
@@ -48,18 +48,19 @@ import {
   createApiTurnWorker,
   createVercelAttachmentStorage,
   getAuthPausedApiTurnId,
+  lookupSlackUser,
   readConversationAccessFromSql,
   recordApiConversationActivity,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext,
   routeApiTurnWork,
   webActorFromEmail
-} from "./chunk-MWOH6CIK.js";
-import "./chunk-UUULGCKK.js";
+} from "./chunk-7EU4YSZ4.js";
+import "./chunk-PZZOGHVR.js";
 import {
   AgentRunError,
   executeTurn
-} from "./chunk-W7GCLNIV.js";
+} from "./chunk-GQMQCY7H.js";
 import {
   buildDeliveredTurnStatePatch,
   completeAuthPauseTurn,
@@ -70,7 +71,7 @@ import {
   getTurnUserSlackMessageTs,
   persistAuthPauseTurnState,
   requireTurnFailureEventId
-} from "./chunk-DAPC2HTM.js";
+} from "./chunk-OZG7E22Y.js";
 import {
   claimDispatchMailboxAppend,
   confirmDispatchMailboxAppend,
@@ -88,12 +89,13 @@ import {
   markDispatchFailed,
   markDispatchRunning,
   recordTaskExecution,
+  resolveConversationRouting,
   resolveTurnSessionRouting,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-FFHXG2FX.js";
+} from "./chunk-MCLWOBPN.js";
 import {
-  ConversationTurnLifecycleService
-} from "./chunk-6Q7YZLCL.js";
+  getTurnLifecycle
+} from "./chunk-STOCCPWH.js";
 import {
   coerceThreadConversationState,
   getLocationConfigurationService,
@@ -102,17 +104,17 @@ import {
   persistThreadRuntimeState,
   persistThreadState,
   persistThreadStateById
-} from "./chunk-Y5G23T2D.js";
+} from "./chunk-CM6RTYSO.js";
 import "./chunk-UTL3MHPC.js";
 import {
   createVercelPluginTaskCallback,
   queueCallback,
   registerVercelPluginTaskDevConsumer
-} from "./chunk-4S47VHJR.js";
+} from "./chunk-ACGWTJ74.js";
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-ZIF2S464.js";
+} from "./chunk-VQIWBJOP.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -120,28 +122,20 @@ import {
   pluginRuntimeRegistrationsFromPluginSet
 } from "./chunk-CM5HNV2W.js";
 import {
-  RESOURCE_EVENT_SYSTEM_ACTOR,
   SANDBOX_EGRESS_PROXY_PATH,
-  buildSlackInboundMessage,
   buildSteeringPiMessage,
   clearSandboxEgressSignals,
   consumeSandboxEgressAuthRequiredSignal,
   consumeSandboxEgressPermissionDeniedSignal,
   createContextCompactor,
-  createSlackConversationWorker,
-  ensureSlackMessageActorIdentity,
   executeAgentRun,
   executeCredentialedEgressRequest,
   getConfigDefaults,
-  getMessageActorIdentity,
   getNextRunAtMs,
   ingestResourceEvent,
-  isResourceEventConversationMessage,
-  isResourceEventSlackMessage,
   latestReportedProgress,
   listThreadReplies,
   logScheduledTaskRunSkipped,
-  normalizeIncomingSlackThreadId,
   normalizeSandboxEgressTracePropagationDomains,
   parseSandboxEgressCredentialToken,
   processWorkspaceSnapshotJob,
@@ -151,20 +145,16 @@ import {
   renderBlockText,
   resolveDestinationVisibility,
   resolveSandboxEgressProviderForHost,
-  runWithSlackInstallation,
   scheduledTaskRunAttributes,
   setConfigDefaults,
   shouldEmitDevAgentTrace,
   shouldPropagateSandboxEgressTrace,
-  stripLeadingSteeringOverride,
-  unpublishedArtifactHeaders,
-  verifySlackSignature,
-  withNormalizedThreadId
-} from "./chunk-6DOAUXLD.js";
+  unpublishedArtifactHeaders
+} from "./chunk-GSB3NTNS.js";
 import {
   AuthorizationFlowDisabledError,
   PluginCredentialFailureError
-} from "./chunk-EWEH2PJW.js";
+} from "./chunk-TXLBLGNQ.js";
 import "./chunk-6Y5B5PEX.js";
 import "./chunk-DIB4GX3G.js";
 import {
@@ -172,21 +162,24 @@ import {
   deleteMcpAuthSessionsForUserProvider,
   deleteMcpServerSessionId,
   deleteMcpStoredOAuthCredentials
-} from "./chunk-4HA36IWS.js";
+} from "./chunk-QU3URVWG.js";
 import {
   formatProviderLabel,
   postSlackMessage,
   startOAuthFlow
-} from "./chunk-ZKKGFUWM.js";
+} from "./chunk-VQZYIVYN.js";
 import {
+  RESOURCE_EVENT_AUTHOR_ID,
+  RESOURCE_EVENT_SYSTEM_ACTOR,
   collectAttachmentGarbage,
   collectEventTaskMatchKeys,
-  createResourceEventTeamIdResolver,
   findMatchingEventTasks,
   getResourceEventCatalog,
+  isResourceEventConversationMessage,
+  isResourceEventMailboxMetadata,
+  isResourceEventSlackMessage,
   listScheduledTasks,
   listScheduledTasksForTeam,
-  lookupSlackUser,
   readScheduledTask,
   requestAttachmentDeletion,
   resourceEventGuidance,
@@ -194,10 +187,10 @@ import {
   scheduledRunId,
   scheduledRunSchema,
   withScheduledTaskLock
-} from "./chunk-QZKHHG3B.js";
+} from "./chunk-DHYZ4VKG.js";
 import {
   parseSlackThreadId
-} from "./chunk-X7NCJQAA.js";
+} from "./chunk-7EOWT62G.js";
 import {
   RetryableDeliveryError,
   createAgentRunner
@@ -216,7 +209,7 @@ import {
   removeActiveConversation,
   requestConversationWork,
   stopConversationWork
-} from "./chunk-D63IUQQE.js";
+} from "./chunk-2IBDVE62.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
@@ -234,7 +227,7 @@ import {
   markTurnCompleted,
   markTurnFailed,
   startActiveTurn
-} from "./chunk-U4CTAVWN.js";
+} from "./chunk-VOGOTEW7.js";
 import {
   abandonTurnRecord,
   appendThreadContextMessages,
@@ -270,7 +263,7 @@ import {
   trimTrailingAssistantMessages,
   turnHasReply,
   upsertConversationMessage
-} from "./chunk-WLKWN4CD.js";
+} from "./chunk-H7X2G2KS.js";
 import {
   getExperimentalFeatures,
   isExperimentalFeatureEnabled,
@@ -279,7 +272,7 @@ import {
 import {
   getSandboxResourceConfig,
   setSandboxResourceConfig
-} from "./chunk-QCT4226Q.js";
+} from "./chunk-CV5CPRVG.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
 import {
@@ -298,7 +291,7 @@ import {
 import "./chunk-7H2VZTWN.js";
 import {
   getTurnRequestDeadline
-} from "./chunk-FTVMXDNN.js";
+} from "./chunk-BRKB5R7P.js";
 import {
   SlackActionError,
   bindEventTaskCredentialSubject,
@@ -316,6 +309,7 @@ import {
   getWorkspaceTeamId,
   isDmChannel,
   normalizeSlackConversationId,
+  runWithSlackInstallationToken,
   runWithWorkspaceTeamId,
   setDashboardConversationLinkOptions,
   setPlugins,
@@ -323,9 +317,10 @@ import {
   verifyEventTaskCredentialSubject,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-VH4IU3UC.js";
+} from "./chunk-JFPY6XFF.js";
 import "./chunk-3Y47VMHV.js";
 import {
+  createSlackDestination,
   deleteProviderIdentityForSlackUser,
   getConversationEventStore,
   getConversationStore,
@@ -334,7 +329,7 @@ import {
   requireSlackDestination,
   withConversationEventLock,
   withConversationMutationLock
-} from "./chunk-ABAX75GG.js";
+} from "./chunk-43LODHJM.js";
 import {
   juniorAgentBindings,
   juniorAgentInvocations,
@@ -342,13 +337,13 @@ import {
   juniorConversations,
   juniorSchedulerRuns,
   juniorSchedulerTasks
-} from "./chunk-LVK4WJKM.js";
-import "./chunk-EJYP3NQ4.js";
+} from "./chunk-VXL2LBPK.js";
+import "./chunk-HWXP6RHG.js";
 import {
   acquireActiveLock,
   getStateAdapter,
   withActiveLock
-} from "./chunk-PNYJOEVV.js";
+} from "./chunk-DOP3FIQC.js";
 import {
   contextProvenance,
   instructionProvenanceFor
@@ -371,17 +366,17 @@ import {
   isProviderRetryError,
   setProfiles,
   setSlackReactionConfig
-} from "./chunk-LRI5IRGY.js";
+} from "./chunk-AD64YMEC.js";
 import {
   defaultModelId,
   modelIdForProfile
 } from "./chunk-D4YV5TDV.js";
-import "./chunk-EIJCPJOY.js";
-import "./chunk-ATUWN6Z3.js";
+import "./chunk-FFYDRLXW.js";
+import "./chunk-HKFLRIBD.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-GJTIZQGJ.js";
-import "./chunk-7MHNIGHP.js";
+} from "./chunk-NRMAOGRS.js";
+import "./chunk-64WF2GQ3.js";
 import {
   credentialContextForActor
 } from "./chunk-CEMMLV5L.js";
@@ -389,6 +384,7 @@ import {
   createActor,
   createSlackActor,
   createSlackResumeActor,
+  isActorUserId,
   parseActorUserId,
   parseSlackChannelId,
   parseSlackMessageTs
@@ -416,13 +412,13 @@ import {
   withContext,
   withLogContext,
   withSpan
-} from "./chunk-OMQ2J6F6.js";
+} from "./chunk-3CVEE6LA.js";
 import {
   continueTrace
 } from "./chunk-PEQXYSSE.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-7GAP2XG4.js";
+} from "./chunk-YXSBZRP7.js";
 
 // src/app.ts
 import { createRequire } from "module";
@@ -2750,8 +2746,830 @@ async function GET6(request) {
 // src/chat/ingress/slack-webhook.ts
 import {
   ChannelImpl,
-  ThreadImpl
+  ThreadImpl as ThreadImpl3
+} from "chat";
+
+// src/chat/task-execution/slack-work.ts
+import {
+  Message as Message3,
+  ThreadImpl as ThreadImpl2
 } from "chat";
+import { z as z3 } from "zod";
+
+// src/chat/ingress/message-router.ts
+import { Message } from "chat";
+function withNormalizedThreadId(message, threadId) {
+  if (message.threadId === threadId) {
+    return message;
+  }
+  return new Message({
+    attachments: message.attachments,
+    author: message.author,
+    formatted: message.formatted,
+    id: message.id,
+    isMention: message.isMention,
+    links: message.links,
+    metadata: message.metadata,
+    raw: message.raw,
+    text: message.text,
+    threadId
+  });
+}
+function normalizeIncomingSlackThreadId(threadId, message) {
+  if (!threadId.startsWith("slack:")) {
+    return threadId;
+  }
+  if (!message || typeof message !== "object") {
+    return threadId;
+  }
+  const raw = message.raw;
+  if (!raw || typeof raw !== "object") {
+    return threadId;
+  }
+  const channelId = nonEmptyString(raw.channel);
+  const threadTs = nonEmptyString(raw.thread_ts) ?? nonEmptyString(raw.ts);
+  if (!channelId || !threadTs) {
+    return threadId;
+  }
+  return `slack:${channelId}:${threadTs}`;
+}
+function nonEmptyString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+
+// src/chat/slack/attachment-fetchers.ts
+function rehydrateAttachmentFetchers(message, downloadPrivateSlackFile2 = downloadPrivateSlackFile) {
+  for (const attachment of message.attachments) {
+    if (!attachment.fetchData && attachment.url) {
+      attachment.fetchData = () => downloadPrivateSlackFile2(attachment.url);
+    }
+  }
+}
+
+// src/chat/slack/adapter-context.ts
+var initializedAdapters = /* @__PURE__ */ new WeakSet();
+async function getConnectedState(stateAdapter) {
+  const state = stateAdapter ?? getStateAdapter();
+  await state.connect();
+  return state;
+}
+async function ensureSlackAdapterInitialized(args) {
+  if (initializedAdapters.has(args.adapter)) {
+    return;
+  }
+  const state = await getConnectedState(args.state);
+  await args.adapter.initialize({
+    getState: () => state
+  });
+  const internals = args.adapter;
+  if (internals.defaultBotTokenProvider && !args.adapter.botUserId) {
+    throw new Error("Slack adapter initialized without a resolved bot user id");
+  }
+  initializedAdapters.add(args.adapter);
+}
+function verifySlackSignature(args) {
+  const internals = args.adapter;
+  const verifySignature = internals.verifySignature;
+  if (!verifySignature) {
+    throw new Error("Slack adapter does not expose signature verification");
+  }
+  return verifySignature.call(
+    args.adapter,
+    args.body,
+    args.request.headers.get("x-slack-request-timestamp"),
+    args.request.headers.get("x-slack-signature")
+  );
+}
+async function runWithSlackInstallation(args) {
+  await ensureSlackAdapterInitialized({
+    adapter: args.adapter,
+    state: args.state
+  });
+  const internals = args.adapter;
+  if (internals.defaultBotTokenProvider) {
+    return await args.task();
+  }
+  const installationId = args.installation.isEnterpriseInstall ? args.installation.enterpriseId : args.installation.teamId;
+  if (!installationId) {
+    throw new Error("Slack installation context is missing team id");
+  }
+  if (!internals.resolveTokenForTeam || !internals.requestContext) {
+    throw new Error("Slack adapter cannot resolve workspace installations");
+  }
+  const tokenContext = await internals.resolveTokenForTeam.call(
+    args.adapter,
+    installationId,
+    args.installation.isEnterpriseInstall
+  );
+  if (!tokenContext) {
+    throw new Error(
+      `Slack installation token was not found for ${installationId}`
+    );
+  }
+  return await internals.requestContext.run(
+    {
+      ...tokenContext,
+      enterpriseId: args.installation.enterpriseId,
+      isEnterpriseInstall: args.installation.isEnterpriseInstall
+    },
+    () => runWithSlackInstallationToken(tokenContext.token, args.task)
+  );
+}
+
+// src/chat/services/message-actor-identity.ts
+var messageActors = /* @__PURE__ */ new WeakMap();
+function canonicalUserId(author, actor) {
+  const authorUserId = parseActorUserId(author.userId);
+  if (authorUserId && authorUserId !== actor.userId) {
+    throw new Error("Message actor user id mismatch");
+  }
+  const userId = authorUserId ?? actor.userId;
+  if (!userId) {
+    throw new Error("Message actor requires a user id");
+  }
+  return userId;
+}
+function actorFromAuthor(author) {
+  const userId = parseActorUserId(author.userId);
+  return userId ? { userId } : void 0;
+}
+function applyActorToAuthor(author, actor) {
+  if (!isActorUserId(actor.userId)) {
+    throw new Error("Message actor requires a user id");
+  }
+  author.userId = actor.userId;
+  author.userName = actor.userName ?? "";
+  author.fullName = actor.fullName ?? "";
+}
+function bindMessageActorIdentity(message, actor) {
+  const userId = canonicalUserId(message.author, actor);
+  const currentActor = createActor(actor, {
+    platform: actor.platform,
+    ...actor.platform === "slack" ? { teamId: actor.teamId } : void 0,
+    userId
+  });
+  if (!currentActor) {
+    throw new Error("Message actor requires a user id");
+  }
+  messageActors.set(message, currentActor);
+  applyActorToAuthor(message.author, currentActor);
+  return currentActor;
+}
+function getMessageActorIdentity(message) {
+  return messageActors.get(message) ?? actorFromAuthor(message.author);
+}
+async function ensureSlackMessageActorIdentity(message, teamId, lookupSlackUser2) {
+  const existing = messageActors.get(message);
+  if (existing) {
+    if (existing.platform !== "slack") {
+      throw new Error("Slack message actor identity requires a Slack actor");
+    }
+    return existing;
+  }
+  const userId = parseActorUserId(message.author.userId);
+  if (!userId) {
+    throw new Error("Slack message actor identity requires a user id");
+  }
+  const actor = bindMessageActorIdentity(
+    message,
+    createSlackActor(teamId, userId, await lookupSlackUser2(teamId, userId))
+  );
+  if (actor.platform !== "slack") {
+    throw new Error("Slack message actor identity requires a Slack actor");
+  }
+  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) {
+    throw new Error(
+      `Conversation ${args.conversationId} is missing a Slack thread for resource-event delivery`
+    );
+  }
+  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: {
+      userId: RESOURCE_EVENT_AUTHOR_ID,
+      userName: "junior-event",
+      fullName: "Junior event",
+      isBot: true,
+      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) {
+  return text.replace(LEADING_MENTION_BEFORE_STEERING_RE, "$1").replace(/^\s*!!\s*/, "");
+}
+
+// src/chat/task-execution/slack-work.ts
+var slackConversationRouteSchema = z3.enum(["mention", "subscribed"]);
+function hasSteeringOverride(text) {
+  return stripLeadingSteeringOverride(text) !== text;
+}
+var serializedDateSchema = z3.iso.datetime();
+var mdastPointSchema = z3.object({
+  column: z3.number().int().positive(),
+  line: z3.number().int().positive(),
+  offset: z3.number().int().nonnegative().optional()
+}).strict();
+var mdastPositionSchema = z3.object({
+  end: mdastPointSchema,
+  start: mdastPointSchema
+}).strict();
+function isOptionalNullableString(value) {
+  return value === void 0 || value === null || typeof value === "string";
+}
+function isOptionalNullableBoolean(value) {
+  return value === void 0 || value === null || typeof value === "boolean";
+}
+function hasValidMdastBase(node, fields) {
+  const allowed = /* @__PURE__ */ new Set(["data", "position", "type", ...fields]);
+  return Object.keys(node).every((key) => allowed.has(key)) && (node.data === void 0 || typeof node.data === "object" && node.data !== null && !Array.isArray(node.data)) && (node.position === void 0 || mdastPositionSchema.safeParse(node.position).success);
+}
+var mdastPhrasingTypes = /* @__PURE__ */ new Set([
+  "break",
+  "delete",
+  "emphasis",
+  "footnoteReference",
+  "html",
+  "image",
+  "imageReference",
+  "inlineCode",
+  "link",
+  "linkReference",
+  "strong",
+  "text"
+]);
+var mdastBlockOrDefinitionTypes = /* @__PURE__ */ new Set([
+  "blockquote",
+  "code",
+  "definition",
+  "footnoteDefinition",
+  "heading",
+  "html",
+  "list",
+  "paragraph",
+  "table",
+  "thematicBreak"
+]);
+var mdastListItemTypes = /* @__PURE__ */ new Set(["listItem"]);
+var mdastTableCellTypes = /* @__PURE__ */ new Set(["tableCell"]);
+var mdastTableRowTypes = /* @__PURE__ */ new Set(["tableRow"]);
+function hasMdastChildren(node, allowedTypes) {
+  return Array.isArray(node.children) && node.children.every(
+    (child) => isFormattedContentNode(child) && (!allowedTypes || typeof child === "object" && child !== null && !Array.isArray(child) && allowedTypes.has(String(child.type)))
+  );
+}
+function isFormattedContentNode(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const node = value;
+  switch (node.type) {
+    case "break":
+    case "thematicBreak":
+      return hasValidMdastBase(node, []);
+    case "html":
+    case "inlineCode":
+    case "text":
+    case "yaml":
+      return hasValidMdastBase(node, ["value"]) && typeof node.value === "string";
+    case "code":
+      return hasValidMdastBase(node, ["lang", "meta", "value"]) && typeof node.value === "string" && isOptionalNullableString(node.lang) && isOptionalNullableString(node.meta);
+    case "delete":
+    case "emphasis":
+    case "paragraph":
+    case "strong":
+    case "tableCell":
+      return hasValidMdastBase(node, ["children"]) && hasMdastChildren(node, mdastPhrasingTypes);
+    case "blockquote":
+      return hasValidMdastBase(node, ["children"]) && hasMdastChildren(node, mdastBlockOrDefinitionTypes);
+    case "tableRow":
+      return hasValidMdastBase(node, ["children"]) && hasMdastChildren(node, mdastTableCellTypes);
+    case "heading":
+      return hasValidMdastBase(node, ["children", "depth"]) && hasMdastChildren(node, mdastPhrasingTypes) && Number.isInteger(node.depth) && Number(node.depth) >= 1 && Number(node.depth) <= 6;
+    case "list":
+      return hasValidMdastBase(node, ["children", "ordered", "spread", "start"]) && hasMdastChildren(node, mdastListItemTypes) && isOptionalNullableBoolean(node.ordered) && isOptionalNullableBoolean(node.spread) && (node.start === void 0 || node.start === null || typeof node.start === "number" && Number.isFinite(node.start));
+    case "listItem":
+      return hasValidMdastBase(node, ["checked", "children", "spread"]) && hasMdastChildren(node, mdastBlockOrDefinitionTypes) && isOptionalNullableBoolean(node.checked) && isOptionalNullableBoolean(node.spread);
+    case "table":
+      return hasValidMdastBase(node, ["align", "children"]) && hasMdastChildren(node, mdastTableRowTypes) && (node.align === void 0 || node.align === null || Array.isArray(node.align) && node.align.every(
+        (align) => align === null || align === "center" || align === "left" || align === "right"
+      ));
+    case "definition":
+      return hasValidMdastBase(node, ["identifier", "label", "title", "url"]) && typeof node.identifier === "string" && typeof node.url === "string" && isOptionalNullableString(node.label) && isOptionalNullableString(node.title);
+    case "footnoteDefinition":
+      return hasValidMdastBase(node, ["children", "identifier", "label"]) && hasMdastChildren(node, mdastBlockOrDefinitionTypes) && typeof node.identifier === "string" && isOptionalNullableString(node.label);
+    case "footnoteReference":
+      return hasValidMdastBase(node, ["identifier", "label"]) && typeof node.identifier === "string" && isOptionalNullableString(node.label);
+    case "image":
+      return hasValidMdastBase(node, ["alt", "title", "url"]) && typeof node.url === "string" && isOptionalNullableString(node.alt) && isOptionalNullableString(node.title);
+    case "imageReference":
+      return hasValidMdastBase(node, [
+        "alt",
+        "identifier",
+        "label",
+        "referenceType"
+      ]) && typeof node.identifier === "string" && isOptionalNullableString(node.alt) && isOptionalNullableString(node.label) && (node.referenceType === "collapsed" || node.referenceType === "full" || node.referenceType === "shortcut");
+    case "link":
+      return hasValidMdastBase(node, ["children", "title", "url"]) && hasMdastChildren(node, mdastPhrasingTypes) && typeof node.url === "string" && isOptionalNullableString(node.title);
+    case "linkReference":
+      return hasValidMdastBase(node, [
+        "children",
+        "identifier",
+        "label",
+        "referenceType"
+      ]) && hasMdastChildren(node, mdastPhrasingTypes) && typeof node.identifier === "string" && isOptionalNullableString(node.label) && (node.referenceType === "collapsed" || node.referenceType === "full" || node.referenceType === "shortcut");
+    default:
+      return false;
+  }
+}
+var formattedContentSchema = z3.custom(
+  (value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return false;
+    }
+    const root = value;
+    return root.type === "root" && hasValidMdastBase(root, ["children"]) && hasMdastChildren(root);
+  },
+  "must be a valid formatted-content root"
+);
+var serializedMessageSchema = z3.object({
+  _type: z3.literal("chat:Message"),
+  attachments: z3.array(
+    z3.object({
+      type: z3.enum(["image", "file", "video", "audio"]),
+      url: z3.string().optional(),
+      name: z3.string().optional(),
+      mimeType: z3.string().optional(),
+      size: z3.number().finite().optional(),
+      width: z3.number().finite().optional(),
+      height: z3.number().finite().optional(),
+      fetchMetadata: z3.record(z3.string(), z3.string()).optional()
+    }).strict()
+  ),
+  author: z3.object({
+    userId: z3.string(),
+    userName: z3.string(),
+    fullName: z3.string(),
+    isBot: z3.union([z3.boolean(), z3.literal("unknown")]),
+    isMe: z3.boolean()
+  }).strict(),
+  formatted: formattedContentSchema,
+  id: z3.string().min(1),
+  isMention: z3.boolean().optional(),
+  links: z3.array(
+    z3.object({
+      url: z3.string(),
+      title: z3.string().optional(),
+      description: z3.string().optional(),
+      imageUrl: z3.string().optional(),
+      siteName: z3.string().optional()
+    }).strict()
+  ).optional(),
+  metadata: z3.object({
+    dateSent: serializedDateSchema,
+    edited: z3.boolean(),
+    editedAt: serializedDateSchema.optional()
+  }).strict(),
+  raw: z3.unknown(),
+  text: z3.string(),
+  threadId: z3.string().min(1)
+}).strict();
+var serializedThreadSchema = z3.object({
+  _type: z3.literal("chat:Thread"),
+  adapterName: z3.literal("slack"),
+  channelId: z3.string().min(1),
+  channelVisibility: z3.enum(["private", "workspace", "external", "unknown"]).optional(),
+  currentMessage: serializedMessageSchema.optional(),
+  id: z3.string().min(1),
+  isDM: z3.boolean()
+}).strict();
+var slackInstallationSchema = z3.object({
+  enterpriseId: z3.string().optional(),
+  isEnterpriseInstall: z3.boolean().optional(),
+  teamId: z3.string().optional()
+}).strict();
+var slackConversationMessageMetadataBaseSchema = z3.object({
+  installation: slackInstallationSchema.optional(),
+  message: serializedMessageSchema,
+  platform: z3.literal("slack"),
+  route: slackConversationRouteSchema,
+  thread: serializedThreadSchema
+});
+var slackConversationMessageMetadataSchema = z3.union([
+  slackConversationMessageMetadataBaseSchema.strict(),
+  slackConversationMessageMetadataBaseSchema.extend({
+    kind: z3.literal("resource_event"),
+    resourceEvent: z3.object({
+      eventKey: z3.string(),
+      eventType: z3.string(),
+      namespace: z3.string(),
+      identifier: z3.string(),
+      subscriptionId: z3.string()
+    }).strict()
+  }).strict()
+]);
+function requireSlackAuthorId(message) {
+  const authorId = parseActorUserId(message.author.userId);
+  if (!authorId) {
+    throw new Error("Slack message requires an actor user id");
+  }
+  return authorId;
+}
+function getConnectedState2(stateAdapter) {
+  return stateAdapter ?? getStateAdapter();
+}
+function parseSlackMetadata(value) {
+  const parsed = slackConversationMessageMetadataSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+function compareInboundMessages(left, right) {
+  return left.createdAtMs - right.createdAtMs || left.receivedAtMs - right.receivedAtMs || left.inboundMessageId.localeCompare(right.inboundMessageId);
+}
+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");
+    }
+    return metadata.route === "mention";
+  }) ? "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);
+  message.attachments = message.attachments.map(
+    (attachment) => args.adapter.rehydrateAttachment(attachment)
+  );
+  rehydrateAttachmentFetchers(message);
+  return message;
+}
+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]);
+  }
+  await Promise.all(
+    [...byAuthorId].map(async ([authorId, messages]) => {
+      const profile = await args.lookupSlackUser(args.teamId, authorId);
+      await Promise.all(
+        messages.map(
+          (message) => ensureSlackMessageActorIdentity(
+            message,
+            args.teamId,
+            async () => profile
+          )
+        )
+      );
+    })
+  );
+}
+function restoreThread(args) {
+  const threadId = normalizeIncomingSlackThreadId(
+    args.threadJson.id,
+    args.message
+  );
+  const message = withNormalizedThreadId(args.message, threadId);
+  return new ThreadImpl2({
+    adapter: args.adapter,
+    stateAdapter: args.state,
+    id: threadId,
+    channelId: args.threadJson.channelId,
+    channelVisibility: args.threadJson.channelVisibility,
+    currentMessage: message,
+    initialMessage: message,
+    isDM: args.threadJson.isDM,
+    isSubscribedContext: args.isSubscribedContext
+  });
+}
+function getInstallation(records) {
+  for (let index = records.length - 1; index >= 0; index -= 1) {
+    const metadata = parseSlackMetadata(records[index]?.input.metadata);
+    if (metadata?.installation) {
+      return metadata.installation;
+    }
+  }
+  return {};
+}
+function getPendingRecords(work) {
+  if (!work) {
+    return [];
+  }
+  return work.execution.pendingMessages.sort(compareInboundMessages);
+}
+function createSlackConversationWorker(options) {
+  const crossActorMidRunMode = options.crossActorMidRunMode ?? botConfig.crossActorMidRunMode;
+  return async (context) => {
+    const adapter = options.getSlackAdapter();
+    const actorLookup = options.lookupSlackUser ?? lookupSlackUser;
+    const state = getConnectedState2(options.state);
+    await state.connect();
+    const records = getPendingRecords({
+      execution: { pendingMessages: [...context.attempt.messages] }
+    });
+    if (records.length === 0) {
+      const destination = requireSlackDestination(
+        context.destination,
+        "Slack paused-turn recovery"
+      );
+      try {
+        await runWithSlackInstallation({
+          adapter,
+          installation: { teamId: destination.teamId },
+          state,
+          task: async () => {
+            await options.runNextPausedTurn(context.conversationId, {
+              shouldYield: context.shouldYield
+            });
+          }
+        });
+      } catch (error) {
+        if (isCooperativeTurnYieldError(error)) {
+          return { status: "yielded" };
+        }
+        throw error;
+      }
+      return { status: "completed" };
+    }
+    const latestRecord = records[records.length - 1];
+    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) {
+      throw new Error(
+        "Latest conversation mailbox record is not Slack metadata"
+      );
+    }
+    if (!await context.checkIn()) {
+      return { status: "lost_lease" };
+    }
+    const resourceEventThread = hasPlainResourceEvent ? await resolveSlackResourceEventThread({
+      conversationId: context.conversationId,
+      conversationStore: options.conversationStore,
+      destination: context.destination
+    }) : void 0;
+    const turnResult = await runWithSlackInstallation({
+      adapter,
+      installation: resourceEventThread ? { teamId: resourceEventThread.destination.teamId } : getInstallation(records),
+      state,
+      task: async () => {
+        const destination = resourceEventThread?.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
+          })
+        );
+        await bindSlackActorIdentities({
+          lookupSlackUser: actorLookup,
+          messages,
+          teamId: destination.teamId
+        });
+        const latestMessage = messages[messages.length - 1];
+        if (!latestMessage) {
+          return;
+        }
+        const route = routeForRecords(records);
+        const thread = isPlainResourceEventRecord(latestRecord) && threadTs ? buildResourceEventSlackThread({
+          adapter,
+          channelId: destination.channelId,
+          message: latestMessage,
+          state,
+          threadTs
+        }) : restoreThread({
+          adapter,
+          isSubscribedContext: route === "subscribed",
+          message: latestMessage,
+          state,
+          threadJson: latestMetadata.thread
+        });
+        const skipped = messages.slice(0, -1);
+        const messageContext = {
+          skipped,
+          totalSinceLastHandler: messages.length
+        };
+        const activeAuthorId = isResourceEventSlackMessage(latestMessage) ? RESOURCE_EVENT_AUTHOR_ID : requireSlackAuthorId(latestMessage);
+        let initialMessagesAcked = false;
+        const ack = async () => {
+          if (initialMessagesAcked) {
+            return;
+          }
+          try {
+            await context.attempt.ack();
+            initialMessagesAcked = true;
+          } catch {
+            throw new TurnInputCommitLostError(
+              `Conversation work lease lost before Slack inbox ack for ${context.conversationId}`
+            );
+          }
+        };
+        const drainSteeringMessages = async (accept) => {
+          await context.attempt.drain(async (pendingRecords) => {
+            const candidates = pendingRecords.filter(
+              (record) => isPlainResourceEventRecord(record) ? publishExternally : record.publishExternally === publishExternally
+            ).map((record) => ({
+              inboundMessageId: record.inboundMessageId,
+              message: restoreMessage({
+                adapter,
+                channelId: destination.channelId,
+                record,
+                ...threadTs ? { threadTs } : void 0
+              })
+            })).filter(
+              (candidate) => crossActorMidRunMode === "steer" || isResourceEventSlackMessage(candidate.message) || requireSlackAuthorId(candidate.message) === activeAuthorId || hasSteeringOverride(candidate.message.text)
+            );
+            return candidates.length > 0 ? await accept(candidates) : [];
+          });
+        };
+        try {
+          if (route === "mention") {
+            await options.runtime.handleNewMention(thread, latestMessage, {
+              conversationId: context.conversationId,
+              destination,
+              publishExternally,
+              messageContext,
+              drainSteeringMessages,
+              ack,
+              isFinalAttempt: context.attempt.isFinalAttempt,
+              shouldYield: context.shouldYield
+            });
+          } else {
+            await options.runtime.handleSubscribedMessage(
+              thread,
+              latestMessage,
+              {
+                conversationId: context.conversationId,
+                destination,
+                publishExternally,
+                messageContext,
+                drainSteeringMessages,
+                ack,
+                isFinalAttempt: context.attempt.isFinalAttempt,
+                shouldYield: context.shouldYield
+              }
+            );
+          }
+        } catch (error) {
+          if (isTurnInputDeferredError(error)) {
+            return { status: "deferred" };
+          }
+          if (isCooperativeTurnYieldError(error)) {
+            return { status: "yielded" };
+          }
+          if (isTurnInputCommitLostError(error)) {
+            return { status: "lost_lease" };
+          }
+          throw error;
+        }
+      }
+    });
+    if (turnResult?.status === "deferred" || turnResult?.status === "yielded" || turnResult?.status === "lost_lease") {
+      return turnResult;
+    }
+    return { status: "completed" };
+  };
+}
+function buildSlackInboundMessage(args) {
+  const authorId = requireSlackAuthorId(args.message);
+  const destination = createSlackDestination({
+    channelId: args.thread.channelId,
+    teamId: args.installation?.teamId
+  });
+  if (!destination) {
+    throw new Error("Slack inbound message requires destination context");
+  }
+  const hasInterruptOverride = hasSteeringOverride(args.message.text);
+  return {
+    conversationId: args.conversationId,
+    destination,
+    inboundMessageId: [
+      "slack",
+      args.installation?.teamId ?? args.installation?.enterpriseId ?? "unknown",
+      args.conversationId,
+      args.message.id
+    ].join(":"),
+    delivery: args.message.isMention || hasInterruptOverride ? "interrupt" : "defer",
+    source: "slack",
+    createdAtMs: args.message.metadata.dateSent.getTime(),
+    receivedAtMs: args.receivedAtMs,
+    publishExternally: true,
+    input: {
+      text: args.message.text || " ",
+      authorId,
+      attachments: args.message.attachments,
+      metadata: {
+        platform: "slack",
+        route: args.route,
+        installation: args.installation,
+        thread: serializedThreadSchema.parse(args.thread.toJSON()),
+        message: args.message.toJSON()
+      }
+    }
+  };
+}
 
 // src/chat/ingress/bot-mention.ts
 function escapeRegExp(value) {
@@ -2819,7 +3637,7 @@ function textMentionsBot(text, botUserId) {
 }
 
 // src/chat/ingress/message-changed.ts
-import { Message } from "chat";
+import { Message as Message4 } from "chat";
 function getEditedMentionMessageId(messageTs) {
   return `${messageTs}:message_changed_mention`;
 }
@@ -2886,7 +3704,7 @@ function extractMessageChangedMention(body, botUserId, adapter) {
     ...sourceTeam ? { source_team: sourceTeam } : void 0,
     ...botId ? { bot_id: botId } : void 0
   };
-  const message = new Message({
+  const message = new Message4({
     id: getEditedMentionMessageId(messageTs),
     threadId,
     text: newText,
@@ -3125,7 +3943,7 @@ function normalizeMessageThreadId(message) {
 }
 async function buildThread(args) {
   const normalized = normalizeMessageThreadId(args.message);
-  return new ThreadImpl({
+  return new ThreadImpl3({
     adapter: args.adapter,
     stateAdapter: args.state,
     id: normalized.threadId,
@@ -3754,7 +4572,7 @@ function registerVercelWorkspaceSnapshotJobDevConsumer() {
 }
 
 // src/chat/services/subscribed-decision.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/chat/services/subscribed-reply-router-policy.ts
 function buildSubscribedReplyRouterPolicy(assistantName) {
@@ -3799,13 +4617,13 @@ Assess conversation floor ownership and whether the latest message continues wor
 }
 
 // src/chat/services/subscribed-decision.ts
-var replyDecisionSchema = z3.object({
-  should_reply: z3.boolean().describe("Whether Junior should respond to this thread message."),
-  should_unsubscribe: z3.boolean().describe(
+var replyDecisionSchema = z4.object({
+  should_reply: z4.boolean().describe("Whether Junior should respond to this thread message."),
+  should_unsubscribe: z4.boolean().describe(
     "Whether Junior should unsubscribe from this thread because the user clearly asked it to stop participating."
   ),
-  confidence: z3.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
-  reason: z3.string().describe("Short reason for the decision; use an empty string if none.")
+  confidence: z4.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
+  reason: z4.string().describe("Short reason for the decision; use an empty string if none.")
 }).strict();
 var ROUTER_CONFIDENCE_THRESHOLD = 0.7;
 var ROUTER_CLASSIFIER_MAX_TOKENS = 400;
@@ -4293,6 +5111,7 @@ function shouldPublishExternally(publishExternally) {
   return publishExternally !== false;
 }
 function createSlackTurnRuntime(deps) {
+  const turnLifecycle = getTurnLifecycle();
   const logContext = (args) => buildLogContext(deps, args);
   const maybeHandleThreadOptOutDecision = async (args) => {
     if (!args.decision?.shouldUnsubscribe) {
@@ -4309,7 +5128,7 @@ function createSlackTurnRuntime(deps) {
     if (!conversationId) {
       return;
     }
-    await deps.failConversationTurn({
+    await turnLifecycle.fail({
       conversationId,
       createdAtMs: deps.now(),
       eventId: args.eventId,
@@ -5532,11 +6351,11 @@ function getMessageTimestamp(message) {
 }
 
 // src/chat/slack/action-token.ts
-import { z as z4 } from "zod";
-var slackActionTokenSchema = z4.string().trim().min(1).brand();
-var slackMessageEnvelopeSchema = z4.object({
-  raw: z4.object({
-    action_token: z4.unknown().optional()
+import { z as z5 } from "zod";
+var slackActionTokenSchema = z5.string().trim().min(1).brand();
+var slackMessageEnvelopeSchema = z5.object({
+  raw: z5.object({
+    action_token: z5.unknown().optional()
   }).optional()
 });
 function readSlackActionToken(message) {
@@ -5781,6 +6600,7 @@ function shouldPublishExternally2(publishExternally) {
   return publishExternally !== false;
 }
 function createSlackTurn(deps) {
+  const turnLifecycle = getTurnLifecycle();
   return async function executeSlackTurn(thread, message, options) {
     if (message.author.isMe) {
       return;
@@ -6111,7 +6931,7 @@ function createSlackTurn(deps) {
           nextTurnId: turnId
         });
         if (conversationId && preparedState.userMessageId) {
-          await deps.turnLifecycle.start({
+          await turnLifecycle.start({
             conversationId,
             createdAtMs: Date.now(),
             inputMessageIds: [
@@ -6648,7 +7468,7 @@ function createSlackTurn(deps) {
                 conversation: preparedState.conversation
               });
               if (conversationId) {
-                await deps.turnLifecycle.fail({
+                await turnLifecycle.fail({
                   conversationId,
                   createdAtMs: Date.now(),
                   ...authFailureEventId ? { eventId: authFailureEventId } : void 0,
@@ -7115,14 +7935,14 @@ function createPrepareTurnState(deps) {
 }
 
 // src/chat/slack/dispatch-turn.ts
-import { Message as Message2, ThreadImpl as ThreadImpl2 } from "chat";
+import { Message as Message5, ThreadImpl as ThreadImpl4 } 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 Message2({
+    const message = new Message5({
       id: getDispatchInputMessageId(dispatch2.id),
       threadId: conversationId,
       text: dispatch2.input,
@@ -7145,7 +7965,7 @@ function createSlackDispatchTurnRunner(options) {
       }
     });
     message.isMention = true;
-    const thread = new ThreadImpl2({
+    const thread = new ThreadImpl4({
       adapter,
       stateAdapter: state,
       id: conversationId,
@@ -7219,9 +8039,6 @@ function upsertSkippedConversationMessage(conversation, args) {
 }
 function createSlackRuntime(options) {
   const services = createJuniorRuntimeServices(options.services);
-  const turnLifecycle = new ConversationTurnLifecycleService(
-    getConversationEventStore()
-  );
   const prepareTurnState = createPrepareTurnState({
     compactConversationIfNeeded: services.conversationMemory.compactConversationIfNeeded,
     hydrateConversationVisionContext: services.visionContext.hydrateConversationVisionContext,
@@ -7250,8 +8067,7 @@ function createSlackRuntime(options) {
     pausedTurns: options.pausedTurns ?? createPausedTurns(),
     prepareTurnState,
     resolveUserAttachments: services.visionContext.resolveUserAttachments,
-    sendPluginTask: options.sendPluginTask,
-    turnLifecycle
+    sendPluginTask: options.sendPluginTask
   });
   const runtime = createSlackTurnRuntime({
     assistantUserName: botConfig.userName,
@@ -7259,7 +8075,6 @@ function createSlackRuntime(options) {
     getBotUserId: () => options.getSlackAdapter().botUserId,
     modelId: defaultModelId(botConfig),
     now: options.now ?? (() => Date.now()),
-    failConversationTurn: (input) => turnLifecycle.fail(input),
     prepareTurnState,
     persistPreparedState: async ({ thread, preparedState }) => {
       await persistThreadState(thread, {
@@ -7937,9 +8752,23 @@ function createConversationWork(options) {
     },
     runTurn: runtime.runDispatchTurn
   });
+  const destinationWorker = async (context) => {
+    const destination = context.destination;
+    if (!destination) {
+      throw new Error(
+        `Conversation ${context.conversationId} is missing a destination`
+      );
+    }
+    if (destination.platform === "slack") {
+      return await slackWorker(context);
+    }
+    throw new Error(
+      `Conversation ${context.conversationId} has a ${destination.platform} destination but no matching conversation worker`
+    );
+  };
   const providerWorker = createAgentDispatchWorkRouter({
     dispatchWorker,
-    fallbackWorker: slackWorker
+    fallbackWorker: destinationWorker
   });
   return {
     apiTurnCancellation,
@@ -8149,6 +8978,66 @@ async function ingestEventTasks(input, options) {
   return { dispatched };
 }
 
+// src/chat/resource-events/workspace.ts
+function createResourceEventTeamIdResolver() {
+  let pending;
+  return async () => {
+    if (!getSlackBotToken()) return void 0;
+    pending ??= getSlackClient().auth.test().then((result) => {
+      const teamId = result.team_id?.trim();
+      if (!teamId) {
+        throw new Error("Slack auth.test did not return a team id");
+      }
+      return teamId;
+    }).catch((error) => {
+      pending = void 0;
+      throw error;
+    });
+    return await pending;
+  };
+}
+
+// src/chat/resource-events/app-publisher.ts
+function createResourceEventAppPublisher(args) {
+  const resolveEventTaskTeamId = createResourceEventTeamIdResolver();
+  return {
+    async neededMatchKeys(input) {
+      const work = args.conversationWork();
+      const eventTaskTeamId = await resolveEventTaskTeamId();
+      const [watchKeys, taskKeys] = await Promise.all([
+        collectResourceEventMatchKeys({
+          eventTypes: input.eventTypes,
+          identifiers: input.identifiers,
+          namespace: input.namespace,
+          state: work.state
+        }),
+        eventTaskTeamId ? collectEventTaskMatchKeys(getDb(), {
+          eventTypes: input.eventTypes,
+          identifiers: input.identifiers,
+          namespace: input.namespace,
+          teamId: eventTaskTeamId
+        }) : Promise.resolve([])
+      ]);
+      return [.../* @__PURE__ */ new Set([...watchKeys, ...taskKeys])].sort();
+    },
+    async publish(event) {
+      const work = args.conversationWork();
+      const queue = work.queue ?? getVercelConversationWorkQueue();
+      const eventTaskTeamId = await resolveEventTaskTeamId();
+      await Promise.all([
+        ingestResourceEvent(event, {
+          queue,
+          state: work.state
+        }),
+        eventTaskTeamId ? ingestEventTasks(event, {
+          queue,
+          teamId: eventTaskTeamId
+        }) : Promise.resolve()
+      ]);
+    }
+  };
+}
+
 // src/chat/api-turns/stop.ts
 async function stopApiConversationTurn(args) {
   const nowMs = args.nowMs ?? Date.now();
@@ -8351,7 +9240,7 @@ import {
 } from "crypto";
 import * as acp3 from "@agentclientprotocol/sdk";
 import { userSchema as userSchema2 } from "@sentry/junior-plugin-api";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/api/acp/state.ts
 import { setTimeout as wait } from "timers/promises";
@@ -8392,14 +9281,14 @@ async function fenceLock(state, lock, ttlMs = MUTATION_LOCK_TTL_MS) {
 import { createHash as createHash2, randomUUID } from "crypto";
 import * as acp2 from "@agentclientprotocol/sdk";
 import { userSchema } from "@sentry/junior-plugin-api";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/api/acp/schema.ts
 import * as acp from "@agentclientprotocol/sdk";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var ACP_SESSION_ID_PATTERN = /^local:acp:[a-f0-9]{32}$/;
-var metaSchema = z5.record(z5.string(), z5.unknown()).nullable();
-var jsonRpcIdSchema = z5.union([z5.string(), z5.number().finite(), z5.null()]);
+var metaSchema = z6.record(z6.string(), z6.unknown()).nullable();
+var jsonRpcIdSchema = z6.union([z6.string(), z6.number().finite(), z6.null()]);
 var SESSION_HEADER_METHODS = /* @__PURE__ */ new Set([
   acp.methods.agent.session.cancel,
   acp.methods.agent.session.close,
@@ -8409,94 +9298,94 @@ var SESSION_HEADER_METHODS = /* @__PURE__ */ new Set([
   acp.methods.agent.session.setConfigOption,
   acp.methods.agent.session.setMode
 ]);
-var acpConnectionIdSchema = z5.string().uuid();
-var acpSessionIdSchema = z5.string().regex(ACP_SESSION_ID_PATTERN);
-var acpCallSchema = z5.object({
+var acpConnectionIdSchema = z6.string().uuid();
+var acpSessionIdSchema = z6.string().regex(ACP_SESSION_ID_PATTERN);
+var acpCallSchema = z6.object({
   id: jsonRpcIdSchema.optional(),
-  jsonrpc: z5.literal("2.0"),
-  method: z5.string().min(1),
-  params: z5.unknown().optional()
+  jsonrpc: z6.literal("2.0"),
+  method: z6.string().min(1),
+  params: z6.unknown().optional()
 }).strict();
-var jsonRpcErrorSchema = z5.object({
-  code: z5.number().int(),
-  data: z5.unknown().optional(),
-  message: z5.string()
+var jsonRpcErrorSchema = z6.object({
+  code: z6.number().int(),
+  data: z6.unknown().optional(),
+  message: z6.string()
 }).strict();
-var acpResponseSchema = z5.union([
-  z5.object({
+var acpResponseSchema = z6.union([
+  z6.object({
     id: jsonRpcIdSchema,
-    jsonrpc: z5.literal("2.0"),
-    result: z5.unknown()
+    jsonrpc: z6.literal("2.0"),
+    result: z6.unknown()
   }).strict(),
-  z5.object({
+  z6.object({
     error: jsonRpcErrorSchema,
     id: jsonRpcIdSchema,
-    jsonrpc: z5.literal("2.0")
+    jsonrpc: z6.literal("2.0")
   }).strict()
 ]);
-var acpInboundMessageSchema = z5.union([
+var acpInboundMessageSchema = z6.union([
   acpCallSchema,
   acpResponseSchema
 ]);
-var implementationSchema = z5.object({
+var implementationSchema = z6.object({
   _meta: metaSchema.optional(),
-  name: z5.string().min(1),
-  title: z5.string().nullable().optional(),
-  version: z5.string()
+  name: z6.string().min(1),
+  title: z6.string().nullable().optional(),
+  version: z6.string()
 }).strict();
-var initializeParamsSchema = z5.object({
+var initializeParamsSchema = z6.object({
   _meta: metaSchema.optional(),
-  clientCapabilities: z5.record(z5.string(), z5.unknown()).optional(),
+  clientCapabilities: z6.record(z6.string(), z6.unknown()).optional(),
   clientInfo: implementationSchema.nullable().optional(),
-  protocolVersion: z5.number().int().min(0).max(65535)
+  protocolVersion: z6.number().int().min(0).max(65535)
 }).strict();
-var authenticateParamsSchema = z5.object({
+var authenticateParamsSchema = z6.object({
   _meta: metaSchema.optional(),
-  methodId: z5.string().min(1)
+  methodId: z6.string().min(1)
 }).strict();
-var newSessionParamsSchema = z5.object({
+var newSessionParamsSchema = z6.object({
   _meta: metaSchema.optional(),
-  additionalDirectories: z5.array(z5.string()).optional(),
-  cwd: z5.string().min(1),
-  mcpServers: z5.array(z5.unknown())
+  additionalDirectories: z6.array(z6.string()).optional(),
+  cwd: z6.string().min(1),
+  mcpServers: z6.array(z6.unknown())
 }).strict();
 var loadSessionParamsSchema = newSessionParamsSchema.extend({
   sessionId: acpSessionIdSchema
 });
-var annotationsSchema = z5.object({
+var annotationsSchema = z6.object({
   _meta: metaSchema.optional(),
-  audience: z5.array(z5.enum(["assistant", "user"])).nullable().optional(),
-  lastModified: z5.string().nullable().optional(),
-  priority: z5.number().finite().nullable().optional()
+  audience: z6.array(z6.enum(["assistant", "user"])).nullable().optional(),
+  lastModified: z6.string().nullable().optional(),
+  priority: z6.number().finite().nullable().optional()
 }).strict();
-var textContentBlockSchema = z5.object({
+var textContentBlockSchema = z6.object({
   _meta: metaSchema.optional(),
   annotations: annotationsSchema.nullable().optional(),
-  text: z5.string(),
-  type: z5.literal("text")
+  text: z6.string(),
+  type: z6.literal("text")
 }).strict();
-var resourceLinkContentBlockSchema = z5.object({
+var resourceLinkContentBlockSchema = z6.object({
   _meta: metaSchema.optional(),
   annotations: annotationsSchema.nullable().optional(),
-  description: z5.string().nullable().optional(),
-  mimeType: z5.string().nullable().optional(),
-  name: z5.string(),
-  size: z5.number().finite().nullable().optional(),
-  title: z5.string().nullable().optional(),
-  type: z5.literal("resource_link"),
-  uri: z5.string()
+  description: z6.string().nullable().optional(),
+  mimeType: z6.string().nullable().optional(),
+  name: z6.string(),
+  size: z6.number().finite().nullable().optional(),
+  title: z6.string().nullable().optional(),
+  type: z6.literal("resource_link"),
+  uri: z6.string()
 }).strict();
-var promptParamsSchema = z5.object({
+var promptParamsSchema = z6.object({
   _meta: metaSchema.optional(),
-  prompt: z5.array(
-    z5.discriminatedUnion("type", [
+  prompt: z6.array(
+    z6.discriminatedUnion("type", [
       textContentBlockSchema,
       resourceLinkContentBlockSchema
     ])
   ),
   sessionId: acpSessionIdSchema
 }).strict();
-var cancelParamsSchema = z5.object({
+var cancelParamsSchema = z6.object({
   _meta: metaSchema.optional(),
   sessionId: acpSessionIdSchema
 }).strict();
@@ -8534,41 +9423,41 @@ var MUTATION_LOCK_OPTIONS = {
 };
 var SSE_KEEP_ALIVE_MS = 15e3;
 var SSE_MAINTENANCE_INTERVAL_MS = 1e3;
-var jsonRpcIdSchema2 = z6.union([z6.string(), z6.number().finite(), z6.null()]);
-var acpConnectionSchema = z6.object({
-  credentialHash: z6.string().length(64),
-  nonce: z6.string().min(1),
+var jsonRpcIdSchema2 = z7.union([z7.string(), z7.number().finite(), z7.null()]);
+var acpConnectionSchema = z7.object({
+  credentialHash: z7.string().length(64),
+  nonce: z7.string().min(1),
   user: userSchema.optional()
 }).strict();
-var acpStreamRouteSchema = z6.object({
-  connectionId: z6.string().min(1),
-  sessionId: z6.string().min(1).optional()
+var acpStreamRouteSchema = z7.object({
+  connectionId: z7.string().min(1),
+  sessionId: z7.string().min(1).optional()
 }).strict();
-var acpPromptStreamOutputSchema = z6.object({
-  afterSeq: z6.number().int().nonnegative(),
-  kind: z6.literal("prompt"),
-  messageId: z6.string().min(1),
+var acpPromptStreamOutputSchema = z7.object({
+  afterSeq: z7.number().int().nonnegative(),
+  kind: z7.literal("prompt"),
+  messageId: z7.string().min(1),
   requestId: jsonRpcIdSchema2,
-  turnId: z6.string().min(1)
+  turnId: z7.string().min(1)
 }).strict();
-var acpStreamOutputSchema = z6.discriminatedUnion("kind", [
-  z6.object({
-    kind: z6.literal("message"),
+var acpStreamOutputSchema = z7.discriminatedUnion("kind", [
+  z7.object({
+    kind: z7.literal("message"),
     message: acpInboundMessageSchema
   }).strict(),
-  z6.object({ kind: z6.literal("replay") }).strict(),
+  z7.object({ kind: z7.literal("replay") }).strict(),
   acpPromptStreamOutputSchema
 ]);
-var storedAcpStreamItemSchema = z6.object({
-  id: z6.string().min(1),
+var storedAcpStreamItemSchema = z7.object({
+  id: z7.string().min(1),
   output: acpStreamOutputSchema
 }).strict();
-var acpRequestReceiptSchema = z6.object({
-  deliveryKey: z6.string().min(1).optional(),
-  outputs: z6.array(acpStreamOutputSchema),
-  sessionId: z6.string().min(1).optional()
+var acpRequestReceiptSchema = z7.object({
+  deliveryKey: z7.string().min(1).optional(),
+  outputs: z7.array(acpStreamOutputSchema),
+  sessionId: z7.string().min(1).optional()
 }).strict();
-var acpStreamCursorSchema = z6.object({ itemId: z6.string().min(1) }).strict();
+var acpStreamCursorSchema = z7.object({ itemId: z7.string().min(1) }).strict();
 function stableHex(value) {
   return createHash2("sha256").update(value).digest("hex").slice(0, 32);
 }
@@ -9177,19 +10066,19 @@ function createSseBody(args) {
 var ACP_AUTHORIZATION_TTL_MS = 10 * 60 * 1e3;
 var ACP_CONNECTION_COOKIE = "junior_acp_connection";
 var LOCK_WAIT_MS2 = 5e3;
-var jsonRpcIdSchema3 = z7.union([z7.string(), z7.number().finite(), z7.null()]);
-var acpAuthorizationSchema = z7.object({
-  connectionId: z7.string().uuid(),
-  credentialHash: z7.string().length(64),
-  elicitationId: z7.string().uuid(),
-  expiresAtMs: z7.number().int().positive(),
+var jsonRpcIdSchema3 = z8.union([z8.string(), z8.number().finite(), z8.null()]);
+var acpAuthorizationSchema = z8.object({
+  connectionId: z8.string().uuid(),
+  credentialHash: z8.string().length(64),
+  elicitationId: z8.string().uuid(),
+  expiresAtMs: z8.number().int().positive(),
   requestId: jsonRpcIdSchema3,
-  requestKey: z7.string().min(1),
-  userCodeHash: z7.string().length(64)
+  requestKey: z8.string().min(1),
+  userCodeHash: z8.string().length(64)
 }).strict();
-var acpAuthorizationPointerSchema = z7.object({
-  expiresAtMs: z7.number().int().positive(),
-  transactionId: z7.string().uuid()
+var acpAuthorizationPointerSchema = z8.object({
+  expiresAtMs: z8.number().int().positive(),
+  transactionId: z8.string().uuid()
 }).strict();
 var ACP_AUTH_METHOD_ID = "junior";
 var ACP_AUTH_METHOD = {
@@ -9516,7 +10405,7 @@ async function completeAcpAuthorization(args) {
 }
 async function handleAcpAuthorizationResponse(args) {
   if (typeof args.response.id !== "string") return "ignored";
-  const parsedId = z7.string().uuid().safeParse(args.response.id);
+  const parsedId = z8.string().uuid().safeParse(args.response.id);
   if (!parsedId.success) return "ignored";
   const authorization = await readAuthorization(args.state, parsedId.data);
   if (!authorization || authorization.connectionId !== args.connectionId) {
@@ -10652,53 +11541,9 @@ async function createApp(options) {
   };
   let pluginRoutes = [];
   let pluginApiRoutes = [];
-  const resolveResourceEventTeamId = createResourceEventTeamIdResolver();
-  const resourceEvents = {
-    async neededMatchKeys(input) {
-      const teamId = await resolveResourceEventTeamId();
-      if (!teamId) return [];
-      const conversationWork = getConversationWorkOptions();
-      const [watchKeys, taskKeys] = await Promise.all([
-        collectResourceEventMatchKeys({
-          eventTypes: input.eventTypes,
-          identifiers: input.identifiers,
-          namespace: input.namespace,
-          state: conversationWork.state,
-          teamId
-        }),
-        collectEventTaskMatchKeys(getDb(), {
-          eventTypes: input.eventTypes,
-          identifiers: input.identifiers,
-          namespace: input.namespace,
-          teamId
-        })
-      ]);
-      return [.../* @__PURE__ */ new Set([...watchKeys, ...taskKeys])].sort();
-    },
-    async publish(event) {
-      const teamId = await resolveResourceEventTeamId();
-      if (!teamId) {
-        logWarn("resource_event.delivery.unavailable", {
-          "app.resource_event.namespace": event.namespace,
-          "app.resource_event.reason": "multi_workspace"
-        });
-        return;
-      }
-      const conversationWork = getConversationWorkOptions();
-      const queue = conversationWork.queue ?? getVercelConversationWorkQueue();
-      await Promise.all([
-        ingestResourceEvent(event, {
-          queue,
-          state: conversationWork.state,
-          teamId
-        }),
-        ingestEventTasks(event, {
-          queue,
-          teamId
-        })
-      ]);
-    }
-  };
+  const resourceEvents = createResourceEventAppPublisher({
+    conversationWork: () => getConversationWorkOptions()
+  });
   let sandboxEgressTracePropagationDomains = [];
   try {
     sandboxEgressTracePropagationDomains = normalizeSandboxEgressTracePropagationDomains(