@sentry/junior 0.184.0 → 0.186.0

package/dist/app.js

@@ -1,20 +1,21 @@
 import {
   processConversationWork
-} from "./chunk-4RONS3WR.js";
+} from "./chunk-2U7EPTRZ.js";
 import {
   bindSpawnAgent
-} from "./chunk-QABCY33S.js";
+} from "./chunk-QBL2AVFF.js";
 import {
   createAgentInvocationWorker,
   enqueueAgentInvocation,
   listPendingAgentInvocationMailboxAppends,
   routeAgentInvocationWork
-} from "./chunk-BT53RIGJ.js";
+} from "./chunk-EWRPUXE3.js";
 import {
   GET as GET2,
   GET2 as GET3,
   buildAuthPauseResponse,
   buildSlackOutputMessage,
+  createPausedTurns,
   createSlackAdapterAssistantStatusSession,
   getAssistantThreadContext,
   getChannelId,
@@ -33,10 +34,10 @@ import {
   sendSlackReply,
   shouldKeepProcessingReactionForToolInvocation,
   splitSlackReplyText,
-  startSlackProcessingReaction,
+  startProcessingReaction,
   stripLeadingBotMention,
   wakePausedTurn
-} from "./chunk-ACPDVEJO.js";
+} from "./chunk-O6GQO7VP.js";
 import "./chunk-FA6POGLH.js";
 import {
   GET,
@@ -47,14 +48,19 @@ import {
   createApiTurnWorker,
   createVercelAttachmentStorage,
   getAuthPausedApiTurnId,
+  lookupSlackUser,
   readConversationAccessFromSql,
   recordApiConversationActivity,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext,
   routeApiTurnWork,
   webActorFromEmail
-} from "./chunk-UBOIHNTH.js";
-import "./chunk-LCP4EDKR.js";
+} from "./chunk-7EU4YSZ4.js";
+import "./chunk-PZZOGHVR.js";
+import {
+  AgentRunError,
+  executeTurn
+} from "./chunk-GQMQCY7H.js";
 import {
   buildDeliveredTurnStatePatch,
   completeAuthPauseTurn,
@@ -65,7 +71,7 @@ import {
   getTurnUserSlackMessageTs,
   persistAuthPauseTurnState,
   requireTurnFailureEventId
-} from "./chunk-M5YWNMTE.js";
+} from "./chunk-OZG7E22Y.js";
 import {
   claimDispatchMailboxAppend,
   confirmDispatchMailboxAppend,
@@ -83,12 +89,13 @@ import {
   markDispatchFailed,
   markDispatchRunning,
   recordTaskExecution,
+  resolveConversationRouting,
   resolveTurnSessionRouting,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-6WGC3SO4.js";
+} from "./chunk-MCLWOBPN.js";
 import {
-  ConversationTurnLifecycleService
-} from "./chunk-M3QYTBQ6.js";
+  getTurnLifecycle
+} from "./chunk-STOCCPWH.js";
 import {
   coerceThreadConversationState,
   getLocationConfigurationService,
@@ -97,17 +104,17 @@ import {
   persistThreadRuntimeState,
   persistThreadState,
   persistThreadStateById
-} from "./chunk-E57WPXWY.js";
+} from "./chunk-CM6RTYSO.js";
 import "./chunk-UTL3MHPC.js";
 import {
   createVercelPluginTaskCallback,
   queueCallback,
   registerVercelPluginTaskDevConsumer
-} from "./chunk-UF6BUA5W.js";
+} from "./chunk-ACGWTJ74.js";
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-HUXFMDBZ.js";
+} from "./chunk-VQIWBJOP.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -115,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,
@@ -146,50 +145,41 @@ import {
   renderBlockText,
   resolveDestinationVisibility,
   resolveSandboxEgressProviderForHost,
-  runWithSlackInstallation,
   scheduledTaskRunAttributes,
   setConfigDefaults,
   shouldEmitDevAgentTrace,
   shouldPropagateSandboxEgressTrace,
-  stripLeadingSteeringOverride,
-  unpublishedArtifactHeaders,
-  verifySlackSignature,
-  withNormalizedThreadId
-} from "./chunk-JNO2GUDS.js";
+  unpublishedArtifactHeaders
+} from "./chunk-GSB3NTNS.js";
 import {
   AuthorizationFlowDisabledError,
   PluginCredentialFailureError
-} from "./chunk-K7VDC2QW.js";
+} from "./chunk-TXLBLGNQ.js";
 import "./chunk-6Y5B5PEX.js";
 import "./chunk-DIB4GX3G.js";
 import {
-  createAgentRunner,
   createUserTokenStore,
   deleteMcpAuthSessionsForUserProvider,
   deleteMcpServerSessionId,
   deleteMcpStoredOAuthCredentials
-} from "./chunk-FKEZZMXS.js";
-import {
-  RetryableDeliveryError
-} from "./chunk-RF6J3DIO.js";
+} from "./chunk-QU3URVWG.js";
 import {
   formatProviderLabel,
   postSlackMessage,
   startOAuthFlow
-} from "./chunk-JM2COLGC.js";
-import {
-  getExperimentalFeatures,
-  isExperimentalFeatureEnabled,
-  setExperimentalFeatures
-} from "./chunk-2LYHWMR4.js";
+} from "./chunk-VQZYIVYN.js";
 import {
+  RESOURCE_EVENT_AUTHOR_ID,
+  RESOURCE_EVENT_SYSTEM_ACTOR,
   collectAttachmentGarbage,
   collectEventTaskMatchKeys,
   findMatchingEventTasks,
   getResourceEventCatalog,
+  isResourceEventConversationMessage,
+  isResourceEventMailboxMetadata,
+  isResourceEventSlackMessage,
   listScheduledTasks,
   listScheduledTasksForTeam,
-  lookupSlackUser,
   readScheduledTask,
   requestAttachmentDeletion,
   resourceEventGuidance,
@@ -197,10 +187,14 @@ import {
   scheduledRunId,
   scheduledRunSchema,
   withScheduledTaskLock
-} from "./chunk-HIPUIPJM.js";
+} from "./chunk-DHYZ4VKG.js";
 import {
   parseSlackThreadId
-} from "./chunk-YKX6MTLU.js";
+} from "./chunk-7EOWT62G.js";
+import {
+  RetryableDeliveryError,
+  createAgentRunner
+} from "./chunk-INQHUE72.js";
 import {
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
   appendAndEnqueueInboundMessage,
@@ -215,7 +209,7 @@ import {
   removeActiveConversation,
   requestConversationWork,
   stopConversationWork
-} from "./chunk-Z3QAXJR7.js";
+} from "./chunk-2IBDVE62.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
@@ -233,7 +227,7 @@ import {
   markTurnCompleted,
   markTurnFailed,
   startActiveTurn
-} from "./chunk-JA43DV4Y.js";
+} from "./chunk-VOGOTEW7.js";
 import {
   abandonTurnRecord,
   appendThreadContextMessages,
@@ -269,11 +263,16 @@ import {
   trimTrailingAssistantMessages,
   turnHasReply,
   upsertConversationMessage
-} from "./chunk-2ZQPVX7C.js";
+} from "./chunk-H7X2G2KS.js";
+import {
+  getExperimentalFeatures,
+  isExperimentalFeatureEnabled,
+  setExperimentalFeatures
+} from "./chunk-2LYHWMR4.js";
 import {
   getSandboxResourceConfig,
   setSandboxResourceConfig
-} from "./chunk-MAPJFUMV.js";
+} from "./chunk-CV5CPRVG.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
 import {
@@ -292,7 +291,7 @@ import {
 import "./chunk-7H2VZTWN.js";
 import {
   getTurnRequestDeadline
-} from "./chunk-MLSQX2EX.js";
+} from "./chunk-BRKB5R7P.js";
 import {
   SlackActionError,
   bindEventTaskCredentialSubject,
@@ -302,7 +301,6 @@ import {
   collectResourceEventMatchKeys,
   createPluginLogger,
   createPluginState,
-  createResourceEventTeamIdResolver,
   downloadPrivateSlackFile,
   getPluginApiRoutes,
   getPluginRoutes,
@@ -311,6 +309,7 @@ import {
   getWorkspaceTeamId,
   isDmChannel,
   normalizeSlackConversationId,
+  runWithSlackInstallationToken,
   runWithWorkspaceTeamId,
   setDashboardConversationLinkOptions,
   setPlugins,
@@ -318,20 +317,19 @@ import {
   verifyEventTaskCredentialSubject,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-4CNDGK25.js";
+} from "./chunk-JFPY6XFF.js";
 import "./chunk-3Y47VMHV.js";
 import {
-  contextProvenance,
+  createSlackDestination,
   deleteProviderIdentityForSlackUser,
   getConversationEventStore,
   getConversationStore,
   getDb,
   getSqlExecutor,
-  instructionProvenanceFor,
   requireSlackDestination,
   withConversationEventLock,
   withConversationMutationLock
-} from "./chunk-IZDYYYGP.js";
+} from "./chunk-43LODHJM.js";
 import {
   juniorAgentBindings,
   juniorAgentInvocations,
@@ -339,13 +337,17 @@ import {
   juniorConversations,
   juniorSchedulerRuns,
   juniorSchedulerTasks
-} from "./chunk-BCHYQS4B.js";
-import "./chunk-SHJK75Z2.js";
+} from "./chunk-VXL2LBPK.js";
+import "./chunk-HWXP6RHG.js";
 import {
   acquireActiveLock,
   getStateAdapter,
   withActiveLock
-} from "./chunk-DUKIDPF6.js";
+} from "./chunk-DOP3FIQC.js";
+import {
+  contextProvenance,
+  instructionProvenanceFor
+} from "./chunk-GFBR4S3Q.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
@@ -354,7 +356,6 @@ import {
   completeObject,
   completeText,
   configureFunctionMaxDurationSeconds,
-  defaultModelId,
   escapeXml,
   getChatConfig,
   getSlackBotToken,
@@ -363,16 +364,19 @@ import {
   getSlackReactionConfig,
   getSlackSigningSecret,
   isProviderRetryError,
-  modelIdForProfile,
   setProfiles,
   setSlackReactionConfig
-} from "./chunk-6UDPINOX.js";
-import "./chunk-BHYRYYLY.js";
-import "./chunk-WQFEWULF.js";
+} from "./chunk-AD64YMEC.js";
+import {
+  defaultModelId,
+  modelIdForProfile
+} from "./chunk-D4YV5TDV.js";
+import "./chunk-FFYDRLXW.js";
+import "./chunk-HKFLRIBD.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-PJPRXO2T.js";
-import "./chunk-LHXIZLFF.js";
+} from "./chunk-NRMAOGRS.js";
+import "./chunk-64WF2GQ3.js";
 import {
   credentialContextForActor
 } from "./chunk-CEMMLV5L.js";
@@ -380,6 +384,7 @@ import {
   createActor,
   createSlackActor,
   createSlackResumeActor,
+  isActorUserId,
   parseActorUserId,
   parseSlackChannelId,
   parseSlackMessageTs
@@ -407,13 +412,13 @@ import {
   withContext,
   withLogContext,
   withSpan
-} from "./chunk-3S7ULUWW.js";
+} from "./chunk-3CVEE6LA.js";
 import {
   continueTrace
 } from "./chunk-PEQXYSSE.js";
 import {
   JUNIOR_VERSION
-} from "./chunk-6VOYP4M6.js";
+} from "./chunk-YXSBZRP7.js";
 
 // src/app.ts
 import { createRequire } from "module";
@@ -2741,9 +2746,831 @@ 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) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -2810,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`;
 }
@@ -2877,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,
@@ -3116,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,
@@ -3745,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) {
@@ -3790,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;
@@ -4218,9 +5045,10 @@ function shouldRethrowTurnControlError(error) {
 function getQueuedMessages(context, options) {
   return (context?.skipped ?? []).map((message) => {
     const content = parseContent(message);
-    const stripped = options.stripLeadingBotMention(
+    const stripped = stripLeadingBotMention(
       stripLeadingSteeringOverride(content.topLevelText),
       {
+        botUserId: options.botUserId,
         stripLeadingSlackMentionToken: options.explicitMention || Boolean(message.isMention)
       }
     );
@@ -4283,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) {
@@ -4295,11 +5124,11 @@ function createSlackTurnRuntime(deps) {
     return true;
   };
   const failConversationTurn = async (args) => {
-    const conversationId = deps.getThreadId(args.thread, args.message) ?? deps.getRunId(args.thread, args.message);
+    const conversationId = getThreadId(args.thread, args.message) ?? getRunId(args.thread, args.message);
     if (!conversationId) {
       return;
     }
-    await deps.failConversationTurn({
+    await turnLifecycle.fail({
       conversationId,
       createdAtMs: deps.now(),
       eventId: args.eventId,
@@ -4328,7 +5157,7 @@ function createSlackTurnRuntime(deps) {
     const processingReactionByMessage = /* @__PURE__ */ new Map();
     return {
       start: async (context, targetMessage) => {
-        const channelId = deps.getChannelId(thread, targetMessage);
+        const channelId = getChannelId(thread, targetMessage);
         const messageTs = getMessageTs(targetMessage);
         const reactionKey = channelId && messageTs ? `${channelId}:${messageTs}` : void 0;
         if (reactionKey) {
@@ -4337,10 +5166,9 @@ function createSlackTurnRuntime(deps) {
             return existing;
           }
         }
-        const started = await startSlackProcessingReaction({
+        const started = await startProcessingReaction({
           thread,
-          message: targetMessage,
-          logException: deps.logException
+          message: targetMessage
         });
         processingReactions.push(started);
         if (reactionKey) {
@@ -4356,7 +5184,7 @@ function createSlackTurnRuntime(deps) {
     try {
       await args.thread.post(buildTurnFailureResponse(args.eventId));
     } catch (postError) {
-      deps.logException(postError, args.postFailureEventName, {
+      logException(postError, args.postFailureEventName, {
         "app.slack.reply_stage": "error_fallback_post",
         "app.error.original_event_id": args.eventId,
         ...getSlackErrorObservabilityAttributes(postError)
@@ -4367,15 +5195,16 @@ function createSlackTurnRuntime(deps) {
   const decideSteeringMessage = async (thread, candidate, conversationContext) => {
     const { message } = candidate;
     const context = {
-      threadId: deps.getThreadId(thread, message),
+      threadId: getThreadId(thread, message),
       actorId: message.author.userId,
-      channelId: deps.getChannelId(thread, message),
-      runId: deps.getRunId(thread, message)
+      channelId: getChannelId(thread, message),
+      runId: getRunId(thread, message)
     };
     const content = parseContent(message);
-    const strippedUserText = deps.stripLeadingBotMention(
+    const strippedUserText = stripLeadingBotMention(
       stripLeadingSteeringOverride(content.topLevelText),
       {
+        botUserId: deps.getBotUserId(),
         stripLeadingSlackMentionToken: Boolean(message.isMention)
       }
     );
@@ -4407,7 +5236,7 @@ function createSlackTurnRuntime(deps) {
         runId: args.context.runId
       }),
       () => {
-        deps.logWarn("subscribed_message.reply.skipped", {
+        logWarn("subscribed_message.reply.skipped", {
           "app.decision.reason": args.decision.reason
         });
       }
@@ -4503,7 +5332,7 @@ function createSlackTurnRuntime(deps) {
       }
     } catch (error) {
       withLogContext(args.context, () => {
-        deps.logException(error, "agent.turn.steering_flush.failed");
+        logException(error, "agent.turn.steering_flush.failed");
       });
     }
   };
@@ -4520,18 +5349,18 @@ function createSlackTurnRuntime(deps) {
           thread,
           pending: skippedSteeringMessages,
           context: logContext({
-            threadId: deps.getThreadId(thread, message),
+            threadId: getThreadId(thread, message),
             actorId: message.author.userId,
             actorUserName: actorUserName(message),
-            channelId: deps.getChannelId(thread, message),
-            runId: deps.getRunId(thread, message)
+            channelId: getChannelId(thread, message),
+            runId: getRunId(thread, message)
           })
         });
       };
       try {
-        const threadId = deps.getThreadId(thread, message);
-        const channelId = deps.getChannelId(thread, message);
-        const runId = deps.getRunId(thread, message);
+        const threadId = getThreadId(thread, message);
+        const channelId = getChannelId(thread, message);
+        const runId = getRunId(thread, message);
         const context = logContext({
           threadId,
           channelId,
@@ -4544,11 +5373,11 @@ function createSlackTurnRuntime(deps) {
           processingReaction,
           hooks
         );
-        await deps.withSpan("chat.turn", "chat.turn", context, async () => {
+        await withSpan("chat.turn", "chat.turn", context, async () => {
           await thread.subscribe();
           const queuedMessages = getQueuedMessages(hooks.messageContext, {
-            explicitMention: true,
-            stripLeadingBotMention: deps.stripLeadingBotMention
+            botUserId: deps.getBotUserId(),
+            explicitMention: true
           });
           let queuedProcessingReactionsStarted = false;
           const startQueuedProcessingReactions = async () => {
@@ -4568,6 +5397,7 @@ function createSlackTurnRuntime(deps) {
             await startQueuedProcessingReactions();
           };
           const drainSteeringMessages = createAcceptedSteeringDrain(hooks, {
+            botUserId: deps.getBotUserId(),
             explicitMention: true,
             onAcceptedForProcessing: async (messages) => {
               await Promise.all(
@@ -4586,8 +5416,7 @@ function createSlackTurnRuntime(deps) {
               conversationContext: drainContext?.conversationContext,
               messages,
               thread
-            }),
-            stripLeadingBotMention: deps.stripLeadingBotMention
+            })
           });
           await deps.executeSlackTurn(thread, message, {
             explicitMention: true,
@@ -4606,11 +5435,11 @@ function createSlackTurnRuntime(deps) {
         });
       } catch (error) {
         const failureLogContext = logContext({
-          threadId: deps.getThreadId(thread, message),
+          threadId: getThreadId(thread, message),
           actorId: message.author.userId,
           actorUserName: actorUserName(message),
-          channelId: deps.getChannelId(thread, message),
-          runId: deps.getRunId(thread, message)
+          channelId: getChannelId(thread, message),
+          runId: getRunId(thread, message)
         });
         const classifiedFailure = getConversationTurnBoundaryError(error);
         const failureCause = classifiedFailure?.cause ?? error;
@@ -4623,7 +5452,7 @@ function createSlackTurnRuntime(deps) {
         const failureCode = classifiedFailure?.failureCode ?? "agent_run_failed";
         if (failureCause instanceof SlackActionError && failureCause.code === "read_only_channel") {
           withLogContext(failureLogContext, () => {
-            deps.logWarn("mention.handler.skipped", {
+            logWarn("mention.handler.skipped", {
               "app.decision.reason": "read_only_channel"
             });
           });
@@ -4631,7 +5460,7 @@ function createSlackTurnRuntime(deps) {
         }
         const eventId = classifiedFailure?.eventId ?? withLogContext(
           failureLogContext,
-          () => deps.logException(failureCause, "mention.handler.failed")
+          () => logException(failureCause, "mention.handler.failed")
         );
         if (!acked && hooks.isFinalAttempt === false) {
           return;
@@ -4669,11 +5498,11 @@ function createSlackTurnRuntime(deps) {
             thread,
             pending: skippedSteeringMessages,
             context: logContext({
-              threadId: deps.getThreadId(thread, message),
+              threadId: getThreadId(thread, message),
               actorId: message.author.userId,
               actorUserName: actorUserName(message),
-              channelId: deps.getChannelId(thread, message),
-              runId: deps.getRunId(thread, message)
+              channelId: getChannelId(thread, message),
+              runId: getRunId(thread, message)
             })
           });
           await processingReactions.stopAll();
@@ -4692,18 +5521,18 @@ function createSlackTurnRuntime(deps) {
           thread,
           pending: skippedSteeringMessages,
           context: logContext({
-            threadId: deps.getThreadId(thread, message),
+            threadId: getThreadId(thread, message),
             actorId: message.author.userId,
             actorUserName: actorUserName(message),
-            channelId: deps.getChannelId(thread, message),
-            runId: deps.getRunId(thread, message)
+            channelId: getChannelId(thread, message),
+            runId: getRunId(thread, message)
           })
         });
       };
       try {
-        const threadId = deps.getThreadId(thread, message);
-        const channelId = deps.getChannelId(thread, message);
-        const runId = deps.getRunId(thread, message);
+        const threadId = getThreadId(thread, message);
+        const channelId = getChannelId(thread, message);
+        const runId = getRunId(thread, message);
         const isResourceEventNotification = isResourceEventSlackMessage(message);
         const actorId = isResourceEventNotification ? void 0 : message.author.userId;
         const turnContext = logContext({
@@ -4713,11 +5542,12 @@ function createSlackTurnRuntime(deps) {
           channelId,
           runId
         });
-        await deps.withSpan("chat.turn", "chat.turn", turnContext, async () => {
+        await withSpan("chat.turn", "chat.turn", turnContext, async () => {
           const content = parseContent(message);
-          const strippedUserText = deps.stripLeadingBotMention(
+          const strippedUserText = stripLeadingBotMention(
             stripLeadingSteeringOverride(content.topLevelText),
             {
+              botUserId: deps.getBotUserId(),
               stripLeadingSlackMentionToken: Boolean(message.isMention)
             }
           );
@@ -4732,8 +5562,8 @@ function createSlackTurnRuntime(deps) {
             runId
           };
           const queuedMessages = getQueuedMessages(hooks.messageContext, {
-            explicitMention: Boolean(message.isMention),
-            stripLeadingBotMention: deps.stripLeadingBotMention
+            botUserId: deps.getBotUserId(),
+            explicitMention: Boolean(message.isMention)
           });
           const combinedText = combineTurnText(queuedMessages, currentText);
           const turnIsExplicitMention = Boolean(message.isMention) || queuedMessages.some((queued) => queued.explicitMention);
@@ -4833,6 +5663,7 @@ function createSlackTurnRuntime(deps) {
           }
           const conversationContext = deps.getPreparedConversationContext(preparedState);
           const drainSteeringMessages = createAcceptedSteeringDrain(hooks, {
+            botUserId: deps.getBotUserId(),
             explicitMention: Boolean(message.isMention),
             onAcceptedForProcessing: async (messages) => {
               await Promise.all(
@@ -4851,8 +5682,7 @@ function createSlackTurnRuntime(deps) {
               conversationContext: drainContext?.conversationContext ?? conversationContext,
               messages,
               thread
-            }),
-            stripLeadingBotMention: deps.stripLeadingBotMention
+            })
           });
           processingReaction = await processingReactions.start(
             turnContext,
@@ -4897,11 +5727,11 @@ function createSlackTurnRuntime(deps) {
         });
       } catch (error) {
         const failureLogContext = logContext({
-          threadId: deps.getThreadId(thread, message),
+          threadId: getThreadId(thread, message),
           actorId: message.author.userId,
           actorUserName: actorUserName(message),
-          channelId: deps.getChannelId(thread, message),
-          runId: deps.getRunId(thread, message)
+          channelId: getChannelId(thread, message),
+          runId: getRunId(thread, message)
         });
         const classifiedFailure = getConversationTurnBoundaryError(error);
         const failureCause = classifiedFailure?.cause ?? error;
@@ -4914,7 +5744,7 @@ function createSlackTurnRuntime(deps) {
         const failureCode = classifiedFailure?.failureCode ?? "agent_run_failed";
         if (failureCause instanceof SlackActionError && failureCause.code === "read_only_channel") {
           withLogContext(failureLogContext, () => {
-            deps.logWarn("subscribed_message.handler.skipped", {
+            logWarn("subscribed_message.handler.skipped", {
               "app.decision.reason": "read_only_channel"
             });
           });
@@ -4922,10 +5752,7 @@ function createSlackTurnRuntime(deps) {
         }
         const eventId = classifiedFailure?.eventId ?? withLogContext(
           failureLogContext,
-          () => deps.logException(
-            failureCause,
-            "subscribed_message.handler.failed"
-          )
+          () => logException(failureCause, "subscribed_message.handler.failed")
         );
         if (!acked && hooks.isFinalAttempt === false) {
           return;
@@ -4963,11 +5790,11 @@ function createSlackTurnRuntime(deps) {
             thread,
             pending: skippedSteeringMessages,
             context: logContext({
-              threadId: deps.getThreadId(thread, message),
+              threadId: getThreadId(thread, message),
               actorId: message.author.userId,
               actorUserName: actorUserName(message),
-              channelId: deps.getChannelId(thread, message),
-              runId: deps.getRunId(thread, message)
+              channelId: getChannelId(thread, message),
+              runId: getRunId(thread, message)
             })
           });
           await processingReactions.stopAll();
@@ -4990,7 +5817,7 @@ function createSlackTurnRuntime(deps) {
               sourceChannelId: event.context?.channelId
             });
           } catch (error) {
-            deps.logException(error, "assistant.thread.initialization.failed");
+            logException(error, "assistant.thread.initialization.failed");
           }
         }
       );
@@ -5011,7 +5838,7 @@ function createSlackTurnRuntime(deps) {
               sourceChannelId: event.context?.channelId
             });
           } catch (error) {
-            deps.logException(error, "assistant.context.refresh.failed");
+            logException(error, "assistant.context.refresh.failed");
           }
         }
       );
@@ -5493,24 +6320,14 @@ function createJuniorRuntimeServices(overrides = {}) {
     listThreadReplies: overrides.visionContext?.listThreadReplies ?? listThreadReplies,
     downloadFile: overrides.visionContext?.downloadFile ?? downloadPrivateSlackFile
   });
-  const agentRunner = overrides.replyExecutor?.agentRunner ?? createAgentRunner(executeAgentRun, {
+  const agentRunner = overrides.agentRunner ?? createAgentRunner(executeAgentRun, {
     bindSpawnAgent: (request) => bindSpawnAgent(request, { queue: getVercelConversationWorkQueue }),
     tracePropagation: overrides.sandbox?.tracePropagation
   });
   return {
     conversationMemory,
     contextCompactor,
-    replyExecutor: {
-      contextCompactor: overrides.replyExecutor?.contextCompactor ?? contextCompactor,
-      agentRunner,
-      getPausedTurnRequest: overrides.replyExecutor?.getPausedTurnRequest ?? getPausedTurnRequest,
-      lookupSlackUser: overrides.replyExecutor?.lookupSlackUser ?? lookupSlackUser,
-      wakePausedTurn: overrides.replyExecutor?.wakePausedTurn ?? wakePausedTurn,
-      scheduleSessionCompletedPluginTasks: overrides.replyExecutor?.scheduleSessionCompletedPluginTasks ?? (async (params) => {
-        await scheduleSessionCompletedPluginTasks(params);
-      }),
-      turnLifecycle: overrides.replyExecutor?.turnLifecycle ?? new ConversationTurnLifecycleService(getConversationEventStore())
-    },
+    executeTurn: async (run, saveResult, timeoutMs) => await executeTurn(agentRunner, run, saveResult, timeoutMs),
     subscribedReplyPolicy: createSubscribedReplyPolicy({
       completeObject: overrides.subscribedReplyPolicy?.completeObject ?? completeObject
     }),
@@ -5534,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) {
@@ -5616,11 +6433,8 @@ async function maybeApplyProviderDefaultConfigRequest(args) {
   };
 }
 
-// src/chat/providers/slack/turn.ts
-async function persistThreadRuntimeStateWithRetry(thread, patch) {
-  await persistWithRetry(() => persistThreadRuntimeState(thread, patch));
-}
-function parkedInputKey(message) {
+// src/chat/providers/slack/input.ts
+function steeringMessageKey(message) {
   if (message.role !== "user") {
     return void 0;
   }
@@ -5629,19 +6443,19 @@ function parkedInputKey(message) {
   return `${message.timestamp}:${text}`;
 }
 function renderRecentThreadMessageLines(conversationContext, messages) {
-  const passiveMessages = messages.filter((queued) => {
+  const messagesForContext = messages.filter((queued) => {
     if (queued.explicitMention) {
       return false;
     }
-    const slackTs = queuedInstructionActor(queued)?.slackTs;
+    const slackTs = inboundMessageActor(queued)?.slackTs;
     return !slackTs || !conversationContext?.includes(`slack_ts="${slackTs}"`);
   });
-  if (passiveMessages.length === 0) {
+  if (messagesForContext.length === 0) {
     return [];
   }
   const lines = [];
-  for (const queued of passiveMessages) {
-    const actor = queuedInstructionActor(queued);
+  for (const queued of messagesForContext) {
+    const actor = inboundMessageActor(queued);
     const author = escapeXml(actor?.authorName ?? "user");
     const attrs = [
       `role="user"`,
@@ -5658,14 +6472,13 @@ function renderRecentThreadMessageLines(conversationContext, messages) {
   }
   return lines;
 }
-function appendRecentThreadMessagesToContext(conversationContext, messages, options) {
-  const baseContext = options?.includeConversationContext === false ? void 0 : conversationContext;
+function appendRecentMessagesToContext(conversationContext, messages) {
   return appendThreadContextMessages(
-    baseContext,
+    conversationContext,
     renderRecentThreadMessageLines(conversationContext, messages)
   );
 }
-function queuedInstructionActor(queued) {
+function inboundMessageActor(queued) {
   const actor = getMessageActorIdentity(queued.message);
   const authorId = actor?.userId ?? parseActorUserId(queued.message.author.userId);
   const authorName = actor?.fullName ?? actor?.userName;
@@ -5676,7 +6489,7 @@ function queuedInstructionActor(queued) {
     ...slackTs ? { slackTs } : void 0
   };
 }
-function queuedInstructionProvenance(queued, teamId) {
+function inboundMessageProvenance(queued, teamId) {
   if (isResourceEventSlackMessage(queued.message)) {
     return contextProvenance;
   }
@@ -5703,12 +6516,57 @@ async function resolveChannelName(thread) {
     return void 0;
   }
 }
-function collectTurnAttachments(message, queuedMessages) {
+function collectAttachments(message, batchedMessages) {
   return [
-    ...(queuedMessages ?? []).flatMap((queued) => queued.message.attachments),
+    ...(batchedMessages ?? []).flatMap((queued) => queued.message.attachments),
     ...message.attachments
   ];
 }
+async function saveSteeringMessages(args) {
+  if (args.messages.length === 0) {
+    return true;
+  }
+  const state = getStateAdapter();
+  await state.connect();
+  const lock = await acquireActiveLock(state, args.conversationId);
+  if (!lock) {
+    return false;
+  }
+  try {
+    const projection = await loadConversationProjection({
+      conversationId: args.conversationId
+    });
+    const savedKeys = new Set(
+      projection.messages.map(steeringMessageKey).filter((key) => key !== void 0)
+    );
+    const missing = args.messages.filter((entry) => {
+      const key = steeringMessageKey(entry.message);
+      return key === void 0 || !savedKeys.has(key);
+    });
+    if (missing.length === 0) {
+      return true;
+    }
+    await commitMessages({
+      conversationId: args.conversationId,
+      messages: [
+        ...projection.messages,
+        ...missing.map((entry) => entry.message)
+      ],
+      provenance: [
+        ...projection.provenance,
+        ...missing.map((entry) => entry.provenance)
+      ]
+    });
+    return true;
+  } finally {
+    await state.releaseLock(lock);
+  }
+}
+
+// src/chat/providers/slack/turn.ts
+async function persistThreadRuntimeStateWithRetry(thread, patch) {
+  await persistWithRetry(() => persistThreadRuntimeState(thread, patch));
+}
 async function loadPiMessagesForTurn(args) {
   if (!args.conversationId) {
     return {};
@@ -5742,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;
@@ -5810,7 +6669,7 @@ function createSlackTurn(deps) {
             (queued) => ensureSlackMessageActorIdentity(
               queued.message,
               teamId,
-              deps.services.lookupSlackUser
+              lookupSlackUser
             )
           )
         );
@@ -5827,7 +6686,7 @@ function createSlackTurn(deps) {
           executionActor = await ensureSlackMessageActorIdentity(
             message,
             teamId,
-            deps.services.lookupSlackUser
+            lookupSlackUser
           );
           if (executionActor) {
             credentialContext = credentialContextForActor(executionActor);
@@ -5905,8 +6764,8 @@ function createSlackTurn(deps) {
             queuedMessages.map(async (queued) => {
               const attachments = queued.message.attachments;
               return {
-                actor: queuedInstructionActor(queued),
-                provenance: queuedInstructionProvenance(queued, teamId),
+                actor: inboundMessageActor(queued),
+                provenance: inboundMessageProvenance(queued, teamId),
                 text: queued.userText,
                 timestampMs: queued.message.metadata.dateSent.getTime(),
                 omittedImageAttachmentCount: !isVisionEnabled() && hasPotentialImageAttachment(attachments) ? countPotentialImageAttachments(attachments) : 0,
@@ -5922,51 +6781,11 @@ function createSlackTurn(deps) {
             })
           );
         };
-        const drainParkedInputToEventLog = async (pairs) => {
-          if (!conversationId || pairs.length === 0) {
-            return true;
-          }
-          const stateAdapter = getStateAdapter();
-          await stateAdapter.connect();
-          const lock = await acquireActiveLock(stateAdapter, conversationId);
-          if (!lock) {
-            return false;
-          }
-          try {
-            const projection = await loadConversationProjection({
-              conversationId
-            });
-            const appendedKeys = new Set(
-              projection.messages.map(parkedInputKey).filter((key) => key !== void 0)
-            );
-            const missing = pairs.filter((pair) => {
-              const key = parkedInputKey(pair.message);
-              return key === void 0 || !appendedKeys.has(key);
-            });
-            if (missing.length === 0) {
-              return true;
-            }
-            await commitMessages({
-              conversationId,
-              messages: [
-                ...projection.messages,
-                ...missing.map((pair) => pair.message)
-              ],
-              provenance: [
-                ...projection.provenance,
-                ...missing.map((pair) => pair.provenance)
-              ]
-            });
-            return true;
-          } finally {
-            await stateAdapter.releaseLock(lock);
-          }
-        };
-        const appendParkedTurnInput = async (parkedSessionId) => {
+        const saveMessagesForPausedTurn = async (pausedTurnId) => {
           if (!conversationId) {
             return true;
           }
-          const parkedMessages = [
+          const messagesForPausedTurn = [
             ...options.queuedMessages ?? [],
             {
               explicitMention: Boolean(
@@ -5977,18 +6796,21 @@ function createSlackTurn(deps) {
               userText: currentText.userText
             }
           ].filter(
-            // Redelivery of the parked turn's own message must not duplicate
+            // Redelivery of the paused Turn's own message must not duplicate
             // the prompt that already started the session.
-            (queued) => buildDeterministicTurnId(queued.message.id) !== parkedSessionId
+            (queued) => buildDeterministicTurnId(queued.message.id) !== pausedTurnId
           );
-          if (parkedMessages.length === 0) {
+          if (messagesForPausedTurn.length === 0) {
             return true;
           }
-          const parkedPairs = (await resolveSteeringMessages(parkedMessages)).map((steering) => ({
+          const steeringMessages = (await resolveSteeringMessages(messagesForPausedTurn)).map((steering) => ({
             message: buildSteeringPiMessage(steering),
             provenance: steering.provenance
           }));
-          return drainParkedInputToEventLog(parkedPairs);
+          return saveSteeringMessages({
+            conversationId,
+            messages: steeringMessages
+          });
         };
         if (preparedState.userMessageAlreadyReplied) {
           const deliveredMessage = [...preparedState.conversation.messages].reverse().find(
@@ -6005,16 +6827,16 @@ function createSlackTurn(deps) {
           return;
         }
         if (conversationId && activeTurnId) {
-          const pausedTurn = await deps.services.getPausedTurnRequest({
+          const pausedTurn = await deps.pausedTurns.get({
             conversationId,
             turnId: activeTurnId
           });
           if (pausedTurn) {
-            if (!await appendParkedTurnInput(pausedTurn.turnId)) {
+            if (!await saveMessagesForPausedTurn(pausedTurn.turnId)) {
               throw new TurnInputDeferredError();
             }
             try {
-              await deps.services.wakePausedTurn(pausedTurn);
+              await deps.pausedTurns.wake(pausedTurn);
             } catch (error) {
               logException(error, "agent.continue.schedule.failed", {
                 "app.ai.resume_session_version": pausedTurn.expectedVersion,
@@ -6039,6 +6861,7 @@ function createSlackTurn(deps) {
               await abandonTurnRecord({
                 conversationId,
                 turnId: activeTurnId,
+                // TODO(dcramer): Rename this legacy text in Slack and Conversation API Turn records together.
                 errorMessage: "Auth-parked session superseded by a new user message"
               });
               markTurnClosed({
@@ -6108,7 +6931,7 @@ function createSlackTurn(deps) {
           nextTurnId: turnId
         });
         if (conversationId && preparedState.userMessageId) {
-          await deps.services.turnLifecycle.start({
+          await turnLifecycle.start({
             conversationId,
             createdAtMs: Date.now(),
             inputMessageIds: [
@@ -6168,7 +6991,7 @@ function createSlackTurn(deps) {
         if (actor?.userName) {
           setTags({ userName: actor.userName });
         }
-        const turnAttachments = collectTurnAttachments(
+        const turnAttachments = collectAttachments(
           message,
           options.queuedMessages
         );
@@ -6197,7 +7020,6 @@ function createSlackTurn(deps) {
         let runResultHandled = false;
         let assistantMessageDelivered = false;
         let acceptedDeliveryId;
-        let lifecycleTerminalized = false;
         let turnCompletionNotified = false;
         const recordDispatchOutcome = async (dispatchOutcome, state) => {
           const dispatchId = options.execution?.dispatch?.id;
@@ -6222,7 +7044,6 @@ function createSlackTurn(deps) {
         };
         let turnWakeError;
         let boundaryFailureCode = "agent_run_failed";
-        let finalizedFailureEventId;
         let terminalDispatchFailureOutcome;
         const notifyTurnCompleted = async () => {
           if (turnCompletionNotified) {
@@ -6354,7 +7175,7 @@ function createSlackTurn(deps) {
           });
           let piMessages = loadedPiMessages.piMessages;
           if (conversationId && loadedPiMessages.canCompact && piMessages?.length) {
-            const compaction = await deps.services.contextCompactor.maybeCompact({
+            const compaction = await deps.contextCompactor.maybeCompact({
               conversation: preparedState.conversation,
               conversationContext: preparedState.conversationContext,
               conversationId,
@@ -6379,7 +7200,7 @@ function createSlackTurn(deps) {
             }
           }
           const hasDurablePromptHistory = Boolean(piMessages?.length);
-          const batchedInstructions = (await resolveSteeringMessages(
+          const batchedSteeringMessages = (await resolveSteeringMessages(
             (options.queuedMessages ?? []).filter(
               (queued) => queued.explicitMention
             )
@@ -6387,20 +7208,23 @@ function createSlackTurn(deps) {
             message: buildSteeringPiMessage(steering),
             provenance: steering.provenance
           }));
-          if (!await drainParkedInputToEventLog(batchedInstructions)) {
+          if (!await saveSteeringMessages({
+            conversationId,
+            messages: batchedSteeringMessages
+          })) {
             shouldPersistFailureState = false;
             throw new TurnInputDeferredError();
           }
-          if (batchedInstructions.length > 0) {
+          if (batchedSteeringMessages.length > 0) {
             const presentKeys = new Set(
-              (piMessages ?? []).map(parkedInputKey).filter((key) => key !== void 0)
+              (piMessages ?? []).map(steeringMessageKey).filter((key) => key !== void 0)
             );
-            const newlyBatched = batchedInstructions.map((entry) => entry.message).filter((batchedMessage) => {
-              const key = parkedInputKey(batchedMessage);
+            const newSteeringMessages = batchedSteeringMessages.map((entry) => entry.message).filter((batchedMessage) => {
+              const key = steeringMessageKey(batchedMessage);
               return key === void 0 || !presentKeys.has(key);
             });
-            if (newlyBatched.length > 0) {
-              piMessages = [...piMessages ?? [], ...newlyBatched];
+            if (newSteeringMessages.length > 0) {
+              piMessages = [...piMessages ?? [], ...newSteeringMessages];
             }
           }
           status.update();
@@ -6420,7 +7244,7 @@ function createSlackTurn(deps) {
           const toolChannelId = channelId;
           const activeInstructionAuthorId = actor?.userId ?? parseActorUserId(message.author.userId);
           const activeInstructionAuthorName = actor?.fullName ?? actor?.userName;
-          const promptConversationContext = appendRecentThreadMessagesToContext(
+          const promptConversationContext = appendRecentMessagesToContext(
             preparedState.conversationContext,
             options.queuedMessages ?? []
           );
@@ -6435,7 +7259,7 @@ function createSlackTurn(deps) {
             );
             return acceptedMessages ?? await resolveSteeringMessages(drained);
           } : void 0;
-          const outcome = await deps.services.agentRunner.run({
+          const run = {
             conversationId,
             turnId,
             ...runId ? { runId } : void 0,
@@ -6507,7 +7331,121 @@ function createSlackTurn(deps) {
                 });
               }
             }
-          });
+          };
+          let completedResult;
+          const saveResult = async (result) => {
+            let finalResult = result;
+            setTags({ modelId: finalResult.diagnostics.modelId });
+            const diagnosticsAttributes = getAgentTurnDiagnosticsAttributes(finalResult);
+            setSpanAttributes(diagnosticsAttributes);
+            let failureEventId;
+            let failureReason;
+            if (finalResult.diagnostics.outcome !== "success") {
+              const finalized = finalizeFailedTurnReplyWithEvent({
+                reply: finalResult,
+                logException
+              });
+              finalResult = finalized.reply;
+              failureEventId = finalized.eventId;
+              failureReason = finalized.failureReason;
+              await deliverAssistantMessage(finalResult.text);
+            }
+            const turnResult = finalResult.diagnostics.outcome === "success" ? { outcome: "completed" } : {
+              errorMessage: finalResult.diagnostics.errorMessage ?? `Agent turn ended with ${finalResult.diagnostics.outcome}.`,
+              outcome: "failed"
+            };
+            runResultHandled = true;
+            shouldPersistFailureState = false;
+            boundaryFailureCode = "agent_run_failed";
+            const completedState = buildDeliveredTurnStatePatch({
+              conversation: preparedState.conversation,
+              reply: finalResult,
+              sessionId: turnId,
+              userMessageId: preparedState.userMessageId
+            });
+            let saveFailed = false;
+            let saveFailureEventId;
+            try {
+              if (conversationId && finalResult.piMessages?.length) {
+                await saveTurnCheckpoint({
+                  mode: "completed",
+                  channelName,
+                  conversationId,
+                  turnId,
+                  durationMs: finalResult.diagnostics.durationMs,
+                  usage: finalResult.diagnostics.usage,
+                  destination,
+                  destinationVisibility,
+                  source,
+                  sliceId: 1,
+                  dispatchOutcome: finalResult.diagnostics.outcome === "success" ? "completed" : "failed",
+                  ...options.execution?.dispatch && turnResult.errorMessage ? { errorMessage: turnResult.errorMessage } : void 0,
+                  ...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : void 0,
+                  messages: finalResult.piMessages,
+                  actor: executionActor,
+                  surface: options.execution?.surface ?? "slack",
+                  dispatchId: options.execution?.dispatch?.id
+                });
+              } else if (conversationId) {
+                await recordTurnSummary({
+                  channelName,
+                  conversationId,
+                  cumulativeDurationMs: finalResult.diagnostics.durationMs,
+                  cumulativeUsage: finalResult.diagnostics.usage,
+                  turnId,
+                  sliceId: 1,
+                  startedAtMs: message.metadata.dateSent.getTime(),
+                  state: "completed",
+                  actor: executionActor,
+                  destination,
+                  destinationVisibility,
+                  source,
+                  surface: options.execution?.surface ?? "slack",
+                  dispatchId: options.execution?.dispatch?.id,
+                  dispatchOutcome: finalResult.diagnostics.outcome === "success" ? "completed" : "failed",
+                  ...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : void 0,
+                  traceId: getActiveTraceId()
+                });
+              }
+              await persistWithRetry(
+                () => persistConversationMessages({
+                  conversation: completedState.conversation,
+                  conversationId
+                })
+              );
+              await persistThreadRuntimeStateWithRetry(thread, completedState);
+            } catch (saveError) {
+              saveFailed = true;
+              saveFailureEventId = logException(
+                saveError,
+                "slack.reply.post_delivery_commit.failed",
+                messageTs ? { "messaging.message.id": messageTs } : {}
+              );
+            }
+            preparedState.conversation = completedState.conversation;
+            persistedAtLeastOnce = true;
+            options.onTurnOutcome?.(turnResult);
+            completedResult = finalResult;
+            if (saveFailed) {
+              return {
+                ...saveFailureEventId ? { eventId: saveFailureEventId } : void 0,
+                failureCode: "persistence_failed",
+                outcome: "failed"
+              };
+            }
+            if (finalResult.diagnostics.outcome === "success") {
+              return {
+                outcome: assistantMessageDelivered ? "success" : "no_reply"
+              };
+            }
+            return {
+              ...failureEventId ? { eventId: failureEventId } : void 0,
+              failureCode: "model_execution_failed",
+              ...failureReason ? { failureReason } : void 0,
+              outcome: "failed"
+            };
+          };
+          const outcome = await deps.executeTurn(run, saveResult);
           if (outcome.status === "awaiting_auth") {
             await recordDispatchOutcome("blocked", "failed");
             options.onTurnOutcome?.({ outcome: "blocked" });
@@ -6530,14 +7468,13 @@ function createSlackTurn(deps) {
                 conversation: preparedState.conversation
               });
               if (conversationId) {
-                await deps.services.turnLifecycle.fail({
+                await turnLifecycle.fail({
                   conversationId,
                   createdAtMs: Date.now(),
                   ...authFailureEventId ? { eventId: authFailureEventId } : void 0,
                   failureCode: "agent_run_failed",
                   turnId
                 });
-                lifecycleTerminalized = true;
               }
               persistedAtLeastOnce = true;
               shouldPersistFailureState = false;
@@ -6570,7 +7507,7 @@ function createSlackTurn(deps) {
               );
             }
             try {
-              await deps.services.wakePausedTurn({
+              await deps.pausedTurns.wake({
                 conversationId,
                 destination,
                 turnId,
@@ -6588,134 +7525,26 @@ function createSlackTurn(deps) {
             }
             return;
           }
-          let reply = outcome.result;
-          setTags({ modelId: reply.diagnostics.modelId });
-          const diagnosticsAttributes = getAgentTurnDiagnosticsAttributes(reply);
-          setSpanAttributes(diagnosticsAttributes);
-          if (reply.diagnostics.outcome !== "success") {
-            const finalized = finalizeFailedTurnReplyWithEvent({
-              reply,
-              logException
-            });
-            reply = finalized.reply;
-            finalizedFailureEventId = finalized.eventId;
-            await deliverAssistantMessage(reply.text);
-          }
-          const turnResult = reply.diagnostics.outcome === "success" ? { outcome: "completed" } : {
-            errorMessage: reply.diagnostics.errorMessage ?? `Agent turn ended with ${reply.diagnostics.outcome}.`,
-            outcome: "failed"
-          };
-          runResultHandled = true;
-          shouldPersistFailureState = false;
-          boundaryFailureCode = "agent_run_failed";
-          const completedState = buildDeliveredTurnStatePatch({
-            conversation: preparedState.conversation,
-            reply,
-            sessionId: turnId,
-            userMessageId: preparedState.userMessageId
-          });
-          try {
-            if (conversationId && reply.piMessages?.length) {
-              await saveTurnCheckpoint({
-                mode: "completed",
-                channelName,
-                conversationId,
-                turnId,
-                durationMs: reply.diagnostics.durationMs,
-                usage: reply.diagnostics.usage,
-                destination,
-                destinationVisibility,
-                source,
-                sliceId: 1,
-                dispatchOutcome: reply.diagnostics.outcome === "success" ? "completed" : "failed",
-                ...options.execution?.dispatch && turnResult.errorMessage ? { errorMessage: turnResult.errorMessage } : void 0,
-                ...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : void 0,
-                messages: reply.piMessages,
-                actor: executionActor,
-                surface: options.execution?.surface ?? "slack",
-                dispatchId: options.execution?.dispatch?.id
-              });
-            } else if (conversationId) {
-              await recordTurnSummary({
-                channelName,
-                conversationId,
-                cumulativeDurationMs: reply.diagnostics.durationMs,
-                cumulativeUsage: reply.diagnostics.usage,
-                turnId,
-                sliceId: 1,
-                startedAtMs: message.metadata.dateSent.getTime(),
-                state: "completed",
-                actor: executionActor,
-                destination,
-                destinationVisibility,
-                source,
-                surface: options.execution?.surface ?? "slack",
-                dispatchId: options.execution?.dispatch?.id,
-                dispatchOutcome: reply.diagnostics.outcome === "success" ? "completed" : "failed",
-                ...acceptedDeliveryId ? { resultMessageId: acceptedDeliveryId } : void 0,
-                traceId: getActiveTraceId()
-              });
-            }
-            await persistWithRetry(
-              () => persistConversationMessages({
-                conversation: completedState.conversation,
-                conversationId
-              })
-            );
-            await persistThreadRuntimeStateWithRetry(thread, completedState);
-          } catch (commitError) {
-            const persistenceEventId = logException(
-              commitError,
-              "slack.reply.post_delivery_commit.failed",
-              messageTs ? { "messaging.message.id": messageTs } : {}
-            );
-            if (conversationId && !lifecycleTerminalized) {
-              await deps.services.turnLifecycle.fail({
-                conversationId,
-                createdAtMs: Date.now(),
-                ...persistenceEventId ? { eventId: persistenceEventId } : void 0,
-                failureCode: "persistence_failed",
-                turnId
-              });
-              lifecycleTerminalized = true;
-            }
-          }
-          preparedState.conversation = completedState.conversation;
-          persistedAtLeastOnce = true;
-          options.onTurnOutcome?.(turnResult);
-          if (!lifecycleTerminalized && conversationId) {
-            if (reply.diagnostics.outcome === "success") {
-              await deps.services.turnLifecycle.complete({
-                conversationId,
-                createdAtMs: Date.now(),
-                outcome: assistantMessageDelivered ? "success" : "no_reply",
-                turnId
-              });
-            } else {
-              await deps.services.turnLifecycle.fail({
-                conversationId,
-                createdAtMs: Date.now(),
-                ...finalizedFailureEventId ? { eventId: finalizedFailureEventId } : void 0,
-                failureCode: "model_execution_failed",
-                turnId
-              });
-            }
-            lifecycleTerminalized = true;
+          if (!completedResult) {
+            throw new Error("Completed Turn did not save a result");
           }
           if (shouldEmitDevAgentTrace()) {
             logInfo("agent.turn.completed", {
-              "app.ai.outcome": reply.diagnostics.outcome,
-              "app.ai.tool_call_count": reply.diagnostics.toolCalls.length,
-              "app.ai.tool_error_results": reply.diagnostics.toolErrorCount
+              "app.ai.outcome": completedResult.diagnostics.outcome,
+              "app.ai.tool_call_count": completedResult.diagnostics.toolCalls.length,
+              "app.ai.tool_error_results": completedResult.diagnostics.toolErrorCount
             });
           }
           await notifyTurnCompleted();
-          if (reply.diagnostics.outcome === "success" && conversationId) {
+          if (completedResult.diagnostics.outcome === "success" && conversationId) {
             try {
-              await deps.services.scheduleSessionCompletedPluginTasks({
-                conversationId,
-                sessionId: turnId
-              });
+              await scheduleSessionCompletedPluginTasks(
+                {
+                  conversationId,
+                  sessionId: turnId
+                },
+                deps.sendPluginTask ? { send: deps.sendPluginTask } : void 0
+              );
             } catch (error) {
               logException(
                 error,
@@ -6754,8 +7583,9 @@ function createSlackTurn(deps) {
             shouldPersistFailureState = true;
           }
           shouldPersistFailureState = true;
-          const classifiedFailure = getConversationTurnBoundaryError(error);
-          const failureCause = classifiedFailure?.cause ?? error;
+          const runFailure = error instanceof AgentRunError ? error.cause : error;
+          const classifiedFailure = getConversationTurnBoundaryError(runFailure);
+          const failureCause = classifiedFailure?.cause ?? runFailure;
           if (failureCause instanceof AuthorizationFlowDisabledError || failureCause instanceof PluginCredentialFailureError) {
             terminalDispatchFailureOutcome = "blocked";
           }
@@ -7105,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,
@@ -7135,7 +7965,7 @@ function createSlackDispatchTurnRunner(options) {
       }
     });
     message.isMention = true;
-    const thread = new ThreadImpl2({
+    const thread = new ThreadImpl4({
       adapter,
       stateAdapter: state,
       id: conversationId,
@@ -7224,34 +8054,27 @@ function createSlackRuntime(options) {
           (message) => ensureSlackMessageActorIdentity(
             message,
             destination.teamId,
-            services.replyExecutor.lookupSlackUser
+            lookupSlackUser
           )
         )
       );
     }
   });
   const executeSlackTurn = createSlackTurn({
+    contextCompactor: services.contextCompactor,
+    executeTurn: services.executeTurn,
     getSlackAdapter: options.getSlackAdapter,
+    pausedTurns: options.pausedTurns ?? createPausedTurns(),
     prepareTurnState,
     resolveUserAttachments: services.visionContext.resolveUserAttachments,
-    services: services.replyExecutor
+    sendPluginTask: options.sendPluginTask
   });
   const runtime = createSlackTurnRuntime({
     assistantUserName: botConfig.userName,
     cancelEventSubscriptions: cancelSubscriptions,
+    getBotUserId: () => options.getSlackAdapter().botUserId,
     modelId: defaultModelId(botConfig),
     now: options.now ?? (() => Date.now()),
-    getThreadId,
-    getChannelId,
-    getRunId,
-    stripLeadingBotMention: (text, stripOptions) => stripLeadingBotMention(text, {
-      ...stripOptions,
-      botUserId: options.getSlackAdapter().botUserId
-    }),
-    withSpan,
-    logWarn,
-    logException,
-    failConversationTurn: (input) => services.replyExecutor.turnLifecycle.fail(input),
     prepareTurnState,
     persistPreparedState: async ({ thread, preparedState }) => {
       await persistThreadState(thread, {
@@ -7552,8 +8375,7 @@ async function runPausedTurnInContext(payload, options, runOptions) {
     "Paused turn"
   );
   const wakePausedTurn2 = options.wakePausedTurn ?? wakePausedTurn;
-  const resumeTurn = options.resumeTurn ?? resumeSlackTurn;
-  return await resumeTurn({
+  return await resumeSlackTurn({
     messageText: "",
     conversationId: payload.conversationId,
     turnId: payload.turnId,
@@ -7562,7 +8384,7 @@ async function runPausedTurnInContext(payload, options, runOptions) {
     lockKey: payload.conversationId,
     // Queue continue runs under the conversation work lease already.
     ownsConversationLease: true,
-    agentRunner: options.agentRunner,
+    executeTurn: async (run, saveResult, timeoutMs) => await executeTurn(options.agentRunner, run, saveResult, timeoutMs),
     scheduleSessionCompletedPluginTasks: options.scheduleSessionCompletedPluginTasks,
     beforeStart: async () => {
       let turn;
@@ -7650,7 +8472,7 @@ async function runPausedTurnInContext(payload, options, runOptions) {
           messageTs: getTurnUserSlackMessageTs(userMessage),
           inputMessageIds: [userMessage.id],
           initialStatus: latestReportedProgress(turnMessages),
-          replyContext: {
+          run: {
             instruction: {
               ...conversationContext ? { context: conversationContext } : void 0,
               // Attachment fields come from the turn user message context helper.
@@ -7888,24 +8710,18 @@ async function runNextPausedTurnInContext(conversationId, options, runOptions) {
 // src/chat/app/conversation-work.ts
 function createConversationWork(options) {
   const apiTurnCancellation = createApiTurnCancellation();
-  const services = {
-    ...options.services,
-    replyExecutor: {
-      ...options.services?.replyExecutor,
-      agentRunner: options.agentRunner,
-      getPausedTurnRequest: options.services?.replyExecutor?.getPausedTurnRequest ?? (async (request) => await getPausedTurnRequest({
-        ...request,
-        conversationStore: options.conversationStore
-      })),
-      wakePausedTurn: options.services?.replyExecutor?.wakePausedTurn ?? (async (request) => await wakePausedTurn(request, {
-        queue: options.queue,
-        state: options.state
-      }))
-    }
-  };
+  const pausedTurns = createPausedTurns({
+    conversationStore: options.conversationStore,
+    queue: options.queue,
+    ...options.state ? { state: options.state } : void 0
+  });
   const runtime = createSlackRuntime({
     getSlackAdapter: options.getSlackAdapter,
-    services
+    pausedTurns,
+    services: {
+      ...options.services,
+      agentRunner: options.agentRunner
+    }
   });
   const slackWorker = createSlackConversationWorker({
     getSlackAdapter: options.getSlackAdapter,
@@ -7914,8 +8730,7 @@ function createConversationWork(options) {
       conversationId,
       {
         agentRunner: options.agentRunner,
-        scheduleSessionCompletedPluginTasks: services.replyExecutor?.scheduleSessionCompletedPluginTasks,
-        wakePausedTurn: services.replyExecutor?.wakePausedTurn
+        wakePausedTurn: pausedTurns.wake
       },
       runOptions
     ),
@@ -7930,28 +8745,40 @@ function createConversationWork(options) {
           agentRunner: options.agentRunner,
           inputMessageIds: [getDispatchInputMessageId(dispatch2.id)],
           routingContext: buildDispatchRoutingContext(dispatch2),
-          scheduleSessionCompletedPluginTasks: services.replyExecutor?.scheduleSessionCompletedPluginTasks,
-          wakePausedTurn: services.replyExecutor?.wakePausedTurn
+          wakePausedTurn: pausedTurns.wake
         },
         { shouldYield: hooks.shouldYield }
       );
     },
     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,
     conversationStore: options.conversationStore,
     queue: options.queue,
     run: routeApiTurnWork({
-      apiTurnWorker: createApiTurnWorker({
-        agentRunner: options.agentRunner,
-        cancellation: apiTurnCancellation,
-        turnLifecycle: services.replyExecutor?.turnLifecycle
-      }),
+      apiTurnWorker: createApiTurnWorker(
+        options.agentRunner,
+        apiTurnCancellation
+      ),
       fallbackWorker: routeAgentInvocationWork({
         invocationWorker: createAgentInvocationWorker(options.agentRunner),
         fallbackWorker: providerWorker
@@ -8151,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();
@@ -8353,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";
@@ -8394,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,
@@ -8411,78 +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: z6.array(z6.enum(["assistant", "user"])).nullable().optional(),
+  lastModified: z6.string().nullable().optional(),
+  priority: z6.number().finite().nullable().optional()
+}).strict();
+var textContentBlockSchema = 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()
+  annotations: annotationsSchema.nullable().optional(),
+  text: z6.string(),
+  type: z6.literal("text")
 }).strict();
-var textContentBlockSchema = z5.object({
+var resourceLinkContentBlockSchema = z6.object({
   _meta: metaSchema.optional(),
   annotations: annotationsSchema.nullable().optional(),
-  text: z5.string(),
-  type: z5.literal("text")
+  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(textContentBlockSchema),
+  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();
@@ -8520,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);
 }
@@ -9163,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 = {
@@ -9502,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) {
@@ -9619,15 +10522,30 @@ function rejectUnsupportedMcpServers(mcpServers) {
     );
   }
 }
+function resourceLinkText(block) {
+  return [
+    "Resource link:",
+    `Name: ${block.name}`,
+    `URI: ${block.uri}`,
+    ...block.title ? [`Title: ${block.title}`] : [],
+    ...block.description ? [`Description: ${block.description}`] : [],
+    ...block.mimeType ? [`MIME type: ${block.mimeType}`] : [],
+    ...block.size !== void 0 && block.size !== null ? [`Size: ${block.size} bytes`] : []
+  ].join("\n");
+}
 function promptText(prompt) {
   if (prompt.length === 0) {
     throw acp4.RequestError.invalidParams(
       { field: "prompt" },
-      "Junior accepts one or more text blocks only"
+      "Junior accepts one or more text or resource link blocks"
     );
   }
   const blocks = [];
   for (const block of prompt) {
+    if (block.type === "resource_link") {
+      blocks.push(resourceLinkText(block));
+      continue;
+    }
     if (!block.text.trim()) {
       throw acp4.RequestError.invalidParams(
         { field: "prompt" },
@@ -10623,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(
@@ -10710,7 +11584,7 @@ async function createApp(options) {
     tracePropagation
   });
   const runtimeServiceOverrides = {
-    replyExecutor: { agentRunner },
+    agentRunner,
     sandbox: { tracePropagation }
   };
   let conversationWorkOptions;