@sentry/junior 0.107.1 → 0.109.0

package/dist/app.js

@@ -6,31 +6,7 @@ import {
   processPluginTask,
   requireTurnFailureEventId,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-CQ7KSO2B.js";
-import {
-  CONVERSATION_WORK_CHECK_IN_INTERVAL_MS,
-  CONVERSATION_WORK_STALE_ENQUEUE_MS,
-  ackMessages,
-  appendInboundMessage,
-  checkInConversationWork,
-  clearConsumedConversationWake,
-  clearExpiredConversationLease,
-  completeConversationWork,
-  deadLetterAttempt,
-  drainConversationMailbox,
-  getConversation,
-  getConversationWorkState,
-  isFinalAttempt,
-  isInvalidConversationRecordError,
-  listActiveConversationIds,
-  markConversationWorkEnqueued,
-  recordAttemptFailure,
-  releaseConversationWork,
-  removeActiveConversation,
-  requestConversationContinuation,
-  requestConversationWork,
-  startConversationWork
-} from "./chunk-YNP2ATQX.js";
+} from "./chunk-MXW4GL53.js";
 import {
   GET,
   buildSentryConversationUrl,
@@ -38,13 +14,13 @@ import {
   resolveRootVisibility,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext
-} from "./chunk-IGHMVDWI.js";
+} from "./chunk-FWJRXN4F.js";
 import "./chunk-CEA3A3UA.js";
 import {
   getVercelConversationWorkQueue,
   resolveConversationWorkQueueTopic,
   verifyConversationQueueMessage
-} from "./chunk-2XXEKR44.js";
+} from "./chunk-7Q6WCISF.js";
 import {
   PLUGIN_TASK_QUEUE_TOPIC,
   createVercelQueueClient,
@@ -53,7 +29,7 @@ import {
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-DY7TRYB5.js";
+} from "./chunk-MGUMR35T.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -69,6 +45,7 @@ import {
   appendSlackLegacyAttachmentText,
   buildSlackOutputMessage,
   buildSteeringPiMessage,
+  cancelSubscriptions,
   createAgentRunner,
   createContextCompactor,
   createUserTokenStore,
@@ -105,21 +82,28 @@ import {
   splitSlackReplyText,
   startOAuthFlow,
   truncateStatusText
-} from "./chunk-EDLNHZH3.js";
+} from "./chunk-IXKSQGIO.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
+  JUNIOR_THREAD_STATE_TTL_MS,
   TurnInputCommitLostError,
   TurnInputDeferredError,
   TurnSliceLimitExceededError,
+  abandonAgentTurnSessionRecord,
   buildConversationContext,
   buildDeterministicAssistantMessageId,
   buildDeterministicTurnId,
   buildTurnLimitResponse,
   clearPendingAuth,
   coerceThreadArtifactsState,
+  coerceThreadConversationState,
+  commitMessages,
   completeDeliveredTurn,
   createConversationMemoryService,
+  failAgentTurnSessionRecord,
+  getAgentTurnSessionRecord,
+  getAgentTurnSessionRecordForResume,
   getChannelConfigurationService,
   getChannelConfigurationServiceById,
   getConversationMessageSlackTs,
@@ -134,6 +118,9 @@ import {
   isPendingAuthLatestRequest,
   isTurnInputCommitLostError,
   isTurnInputDeferredError,
+  listAgentTurnSessionSummariesForConversation,
+  loadConversationProjection,
+  loadProjection,
   markConversationMessage,
   markTurnClosed,
   markTurnFailed,
@@ -147,33 +134,23 @@ import {
   persistThreadStateById,
   persistWithRetry,
   persistYieldSessionRecord,
+  recordAgentTurnSessionSummary,
+  recordAuthorizationCompleted,
   recordDeliveredAssistantMessage,
   startActiveTurn,
   turnHasReply,
   updateConversationStats,
   upsertConversationMessage
-} from "./chunk-YFQ7CQDE.js";
-import {
-  JUNIOR_THREAD_STATE_TTL_MS,
-  abandonAgentTurnSessionRecord,
-  coerceThreadConversationState,
-  commitMessages,
-  failAgentTurnSessionRecord,
-  getAgentTurnSessionRecord,
-  getAgentTurnSessionRecordForResume,
-  listAgentTurnSessionSummariesForConversation,
-  loadConversationProjection,
-  loadProjection,
-  recordAgentTurnSessionSummary,
-  recordAuthorizationCompleted
-} from "./chunk-4YF7Z6IA.js";
-import "./chunk-SPUAJVVH.js";
+} from "./chunk-72OMGPDS.js";
+import "./chunk-HO5NT6OE.js";
 import "./chunk-MU6HHZEN.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
 import {
   bindScheduledTaskCredentialSubject,
   bindSlackDirectCredentialSubject,
+  createPluginLogger,
+  createPluginState,
   getDashboardConversationLink,
   getPluginApiRoutes,
   getPluginRoutes,
@@ -184,16 +161,12 @@ import {
   validatePlugins,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-RMVOAJRL.js";
-import {
-  createPluginLogger,
-  createPluginState
-} from "./chunk-AUUOHQAT.js";
-import "./chunk-G3E7SCME.js";
+} from "./chunk-QY636HZU.js";
 import {
   acquireActiveLock,
+  getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-B2Z2H66D.js";
+} from "./chunk-OUHNWH46.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -204,7 +177,7 @@ import {
   normalizeSlackConversationId,
   runWithSlackInstallationToken,
   runWithWorkspaceTeamId
-} from "./chunk-VH6KWKG2.js";
+} from "./chunk-RGX4V75M.js";
 import {
   contextProvenance,
   getConversationEventStore,
@@ -212,10 +185,12 @@ import {
   getDb,
   getSqlExecutor,
   instructionProvenanceFor,
-  juniorConversationEvents,
-  juniorConversations,
   withConversationEventLock
-} from "./chunk-NVOTGWYX.js";
+} from "./chunk-FENLIFJD.js";
+import {
+  juniorConversationEvents,
+  juniorConversations
+} from "./chunk-TMBRFULF.js";
 import {
   sleep
 } from "./chunk-4ZNGQH7C.js";
@@ -239,7 +214,7 @@ import {
   standardModelId,
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages
-} from "./chunk-SS67LUOK.js";
+} from "./chunk-JNAVF45E.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
@@ -248,32 +223,35 @@ import {
   readSlackRawMessageContext,
   resolveSlackChannelIdFromMessage,
   resolveSlackChannelIdFromThreadId
-} from "./chunk-RT5BUHR5.js";
+} from "./chunk-O3JMSZLI.js";
 import {
   createSlackDestination,
   destinationKey,
   parseDestination,
   requireSlackDestination,
   sameDestination
-} from "./chunk-B7PUBQQM.js";
+} from "./chunk-SYAQIR5Z.js";
 import {
   discoverSkills
-} from "./chunk-YT72TOEK.js";
+} from "./chunk-WHMOBKT7.js";
+import {
+  pluginCatalogRuntime
+} from "./chunk-3SXUV423.js";
 import {
   buildOAuthTokenRequest,
   credentialSubjectSchema,
   hasRequiredOAuthScope,
-  parseOAuthTokenResponse,
-  pluginCatalogRuntime
-} from "./chunk-YIPD3L6L.js";
+  parseOAuthTokenResponse
+} from "./chunk-TT6GMXNA.js";
 import {
   createActor,
   createSlackActor,
   createSlackResumeActor,
   isActorUserId,
   isUserActor,
-  parseActorUserId
-} from "./chunk-VIXFG2VC.js";
+  parseActorUserId,
+  parseStoredSlackActor
+} from "./chunk-PLB7MRCQ.js";
 import {
   buildTurnFailureResponse,
   createChatSdkLogger,
@@ -289,22 +267,27 @@ import {
   setTags,
   withContext,
   withSpan
-} from "./chunk-O24R4DCK.js";
+} from "./chunk-ISMWX44P.js";
 import {
+  isRecord,
+  toOptionalNumber,
   toOptionalString
 } from "./chunk-OB42YVAE.js";
 import {
   continueTrace
 } from "./chunk-6GWA276C.js";
 import "./chunk-B3IT5END.js";
+import {
+  homeDir
+} from "./chunk-3V7OFJZC.js";
 import {
   JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE,
   parseSlackChannelId,
   parseSlackMessageTs
-} from "./chunk-7FBGKXPE.js";
+} from "./chunk-IVVGFRQQ.js";
 import {
-  homeDir
-} from "./chunk-3V7OFJZC.js";
+  JUNIOR_VERSION
+} from "./chunk-OCD3OZRK.js";
 import "./chunk-MLKGABMK.js";
 
 // src/app.ts
@@ -352,53 +335,26 @@ function buildSlackReplyBlocks(text, footer) {
 }
 
 // src/chat/slack/reply.ts
-function planSlackAssistantMessagePosts(text) {
-  return splitSlackReplyText(text).map((chunk, index) => ({
-    text: chunk,
-    stage: index === 0 ? "thread_reply" : "thread_reply_continuation"
-  }));
-}
-function findLastTextPostIndex(posts) {
-  for (let index = posts.length - 1; index >= 0; index -= 1) {
-    if (posts[index]?.text.trim().length) {
-      return index;
-    }
-  }
-  return -1;
-}
-async function postSlackApiReplyPosts(args) {
-  const lastTextPostIndex = findLastTextPostIndex(args.posts);
-  let lastPostedMessageTs;
-  for (const [index, post] of args.posts.entries()) {
-    const hasVisibleDelivery = post.text.trim().length > 0;
-    if (hasVisibleDelivery) {
-      await args.beforePost?.();
-    }
-    let messageTs;
-    try {
-      if (post.text.trim().length > 0) {
-        const footer = index === lastTextPostIndex ? args.footer : void 0;
-        const blocks = buildSlackReplyBlocks(post.text, footer);
-        const response = await postSlackMessage({
-          channelId: args.channelId,
-          threadTs: args.threadTs,
-          text: post.text,
-          ...blocks ? { blocks } : {}
-        });
-        messageTs = response.ts;
-        lastPostedMessageTs = response.ts;
-      }
-      continue;
-    } catch (error) {
-      await args.onPostError?.({
-        error,
-        messageTs,
-        stage: post.stage
-      });
-      throw error;
-    }
+async function sendSlackReply(args) {
+  const chunks = splitSlackReplyText(args.text);
+  const footer = buildSlackReplyFooter({
+    conversationId: args.conversationId
+  });
+  let lastMessageTs;
+  for (const [index, text] of chunks.entries()) {
+    const blocks = buildSlackReplyBlocks(
+      text,
+      index === chunks.length - 1 ? footer : void 0
+    );
+    const response = await postSlackMessage({
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      text,
+      ...blocks ? { blocks } : {}
+    });
+    lastMessageTs = response.ts;
   }
-  return lastPostedMessageTs;
+  return lastMessageTs;
 }
 
 // src/chat/slack/errors.ts
@@ -583,6 +539,7 @@ var DEFAULT_MAX_ATTEMPTS = 5;
 var nonEmptyExactStringSchema = z.string().min(1).refine(
   (value) => value === value.trim() && value.toLowerCase() !== "unknown"
 );
+var incompleteDispatchIndexSchema = z.array(nonEmptyExactStringSchema);
 var dispatchStatusSchema = z.enum([
   "pending",
   "running",
@@ -664,6 +621,9 @@ function incompleteDispatchIndexKey() {
 function incompleteDispatchIndexLockKey() {
   return `${DISPATCH_PREFIX}:incomplete:lock`;
 }
+function parseIncompleteDispatchIndex(value) {
+  return value === void 0 || value === null ? [] : incompleteDispatchIndexSchema.parse(value);
+}
 function dispatchLockKey(id) {
   return `${DISPATCH_PREFIX}:lock:${id}`;
 }
@@ -736,9 +696,12 @@ async function withIncompleteDispatchIndexLock(state, callback) {
 }
 async function syncIncompleteDispatchIndex(state, record) {
   await withIncompleteDispatchIndexLock(state, async () => {
-    const existing = await state.get(incompleteDispatchIndexKey()) ?? [];
     const ids = [
-      ...new Set(existing.filter((id) => typeof id === "string"))
+      ...new Set(
+        parseIncompleteDispatchIndex(
+          await state.get(incompleteDispatchIndexKey())
+        )
+      )
     ];
     const next = isTerminalDispatchStatus(record.status) ? ids.filter((id) => id !== record.id) : ids.includes(record.id) ? ids : [...ids, record.id];
     if (next.length === ids.length && next.every((id, index) => id === ids[index])) {
@@ -815,8 +778,13 @@ async function updateDispatchRecord(state, record) {
 async function listIncompleteDispatchIds() {
   const state = getStateAdapter();
   await state.connect();
-  const ids = await state.get(incompleteDispatchIndexKey()) ?? [];
-  return [...new Set(ids.filter((id) => typeof id === "string"))];
+  return [
+    ...new Set(
+      parseIncompleteDispatchIndex(
+        await state.get(incompleteDispatchIndexKey())
+      )
+    )
+  ];
 }
 async function getPluginDispatchProjection(args) {
   const record = await getDispatchRecord(args.id);
@@ -914,8 +882,8 @@ async function runAgentDispatchSlice(callback, deps) {
   const turnId = getDispatchTurnId(dispatch.id);
   const logContext = {
     conversationId,
-    slackThreadId: conversationId,
-    slackChannelId: dispatch.destination.channelId,
+    messageConversationId: conversationId,
+    destinationName: dispatch.destination.channelId,
     runId: dispatch.id,
     actorType: dispatch.actor.platform,
     actorId: dispatch.actor.name,
@@ -1005,15 +973,15 @@ async function runAgentDispatchSlice(callback, deps) {
     let resultMessageTs;
     let assistantMessageDelivered = turnHasReply(conversation, turnId);
     const deliverAssistantMessage = async (assistantMessage) => {
-      const posts = planSlackAssistantMessagePosts(assistantMessage.text);
-      if (posts.length === 0) {
+      if (!assistantMessage.text.trim()) {
         return;
       }
       failureCode = "delivery_failed";
       try {
-        resultMessageTs = await postSlackApiReplyPosts({
+        resultMessageTs = await sendSlackReply({
           channelId: dispatch.destination.channelId,
-          posts
+          conversationId,
+          text: assistantMessage.text
         });
       } catch (error) {
         if (isRetryableSlackPostError(error)) {
@@ -1209,13 +1177,7 @@ async function runAgentDispatchSlice(callback, deps) {
         destinationVisibility: dispatch.destinationVisibility,
         source: dispatch.source,
         actor: dispatch.actor,
-        surface: "api",
-        logContext: {
-          threadId: conversationId,
-          channelId: dispatch.destination.channelId,
-          runId: dispatch.id,
-          assistantUserName: botConfig.userName
-        }
+        surface: "api"
       });
     }
     if (statePersisted) {
@@ -1237,117 +1199,1244 @@ async function runAgentDispatchSlice(callback, deps) {
       }
       lifecycleTerminalized = true;
     }
-    dispatch = await markDispatch({
-      dispatch,
-      status: failure ? "failed" : "completed",
-      ...failure ? { errorMessage: failure } : {},
-      resultMessageTs
-    });
-    if (!failure) {
-      try {
-        await scheduleCompletedTasks({
-          conversationId,
-          sessionId: turnId
-        });
-      } catch (error) {
-        logException(
-          error,
-          "plugin_session_completed_task_schedule_failed",
-          logContext,
-          {},
-          "Plugin session.completed task scheduling failed"
-        );
-      }
+    dispatch = await markDispatch({
+      dispatch,
+      status: failure ? "failed" : "completed",
+      ...failure ? { errorMessage: failure } : {},
+      resultMessageTs
+    });
+    if (!failure) {
+      try {
+        await scheduleCompletedTasks({
+          conversationId,
+          sessionId: turnId
+        });
+      } catch (error) {
+        logException(
+          error,
+          "plugin_session_completed_task_schedule_failed",
+          logContext,
+          {},
+          "Plugin session.completed task scheduling failed"
+        );
+      }
+    }
+  } catch (error) {
+    if (error instanceof AuthorizationFlowDisabledError) {
+      if (lifecycleStarted && !lifecycleTerminalized) {
+        await turnLifecycle.fail({
+          conversationId,
+          turnId,
+          createdAtMs: Date.now(),
+          failureCode: "agent_run_failed"
+        });
+        lifecycleTerminalized = true;
+      }
+      await markDispatch({
+        dispatch,
+        status: "blocked",
+        errorMessage: `Dispatch requires ${error.provider} authorization.`
+      });
+      return;
+    }
+    if (error instanceof PluginCredentialFailureError) {
+      if (lifecycleStarted && !lifecycleTerminalized) {
+        await turnLifecycle.fail({
+          conversationId,
+          turnId,
+          createdAtMs: Date.now(),
+          failureCode: "agent_run_failed"
+        });
+        lifecycleTerminalized = true;
+      }
+      await markDispatch({
+        dispatch,
+        status: "blocked",
+        errorMessage: error.message
+      });
+      return;
+    }
+    const eventId = logException(
+      error,
+      "agent_dispatch_run_failed",
+      {
+        ...logContext,
+        modelId: standardModelId(botConfig)
+      },
+      {},
+      "Agent dispatch failed"
+    );
+    if (lifecycleStarted && !lifecycleTerminalized) {
+      await turnLifecycle.fail({
+        conversationId,
+        turnId,
+        createdAtMs: Date.now(),
+        failureCode,
+        ...eventId ? { eventId } : {}
+      });
+      lifecycleTerminalized = true;
+    }
+    await markDispatch({
+      dispatch,
+      status: "failed",
+      errorMessage: error instanceof Error ? error.message : String(error)
+    });
+  } finally {
+    await stateAdapter.releaseLock(destinationLock);
+  }
+}
+
+// src/handlers/agent-dispatch.ts
+async function POST(request, waitUntil, options) {
+  const payload = await verifyDispatchCallbackRequest(request);
+  if (!payload) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+  waitUntil(
+    () => runAgentDispatchSlice(payload, {
+      agentRunner: options.agentRunner
+    }).catch((error) => {
+      logException(
+        error,
+        "agent_dispatch_handler_failed",
+        {},
+        { "app.dispatch.id": payload.id },
+        "Agent dispatch handler failed"
+      );
+    })
+  );
+  return new Response("Accepted", { status: 202 });
+}
+
+// src/handlers/heartbeat.ts
+import { timingSafeEqual as timingSafeEqual2 } from "crypto";
+
+// src/chat/task-execution/state.ts
+import { randomUUID } from "crypto";
+var CONVERSATION_PREFIX = "junior:conversation";
+var CONVERSATION_SCHEMA_VERSION = 1;
+var CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH = 1e4;
+var CONVERSATION_INDEX_LOCK_TTL_MS = 1e4;
+var CONVERSATION_INDEX_LOCK_WAIT_MS = 2e3;
+var CONVERSATION_INDEX_LOCK_RETRY_MS = 25;
+var CONVERSATION_MUTATION_LOCK_TTL_MS = 1e4;
+var CONVERSATION_MUTATION_WAIT_MS = 1e4;
+var CONVERSATION_MUTATION_RETRY_MS = 25;
+var InvalidConversationRecordError = class extends Error {
+  constructor(conversationId) {
+    super(`Conversation record is invalid for ${conversationId}`);
+    this.name = "InvalidConversationRecordError";
+  }
+};
+function isInvalidConversationRecordError(error) {
+  return error instanceof InvalidConversationRecordError;
+}
+var ConversationMutationFencedError = class extends Error {
+  constructor(conversationId) {
+    super(
+      `Conversation mutation lock was lost before write for ${conversationId}`
+    );
+    this.name = "ConversationMutationFencedError";
+  }
+};
+var CONVERSATION_BY_ACTIVITY_INDEX_KEY = `${CONVERSATION_PREFIX}:by-activity`;
+var CONVERSATION_ACTIVE_INDEX_KEY = `${CONVERSATION_PREFIX}:active`;
+var CONVERSATION_WORK_LEASE_TTL_MS = 9e4;
+var CONVERSATION_WORK_CHECK_IN_INTERVAL_MS = 15e3;
+var CONVERSATION_WORK_STALE_ENQUEUE_MS = 6e4;
+var CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS = 5;
+function conversationKey(conversationId) {
+  return `${CONVERSATION_PREFIX}:${conversationId}`;
+}
+function indexLockKey(indexKey) {
+  return `${indexKey}:lock`;
+}
+function mutationLockKey(conversationId) {
+  return `${CONVERSATION_PREFIX}:mutation:${conversationId}`;
+}
+function now() {
+  return Date.now();
+}
+function compareMessages(left, right) {
+  return left.createdAtMs - right.createdAtMs || left.receivedAtMs - right.receivedAtMs || left.inboundMessageId.localeCompare(right.inboundMessageId);
+}
+function inputHasAttachments(input) {
+  return Array.isArray(input.attachments) && input.attachments.length > 0;
+}
+function upgradedPendingMessage(stored, duplicate) {
+  if (!inputHasAttachments(duplicate.input) || inputHasAttachments(stored.input)) {
+    return stored;
+  }
+  return { ...stored, input: duplicate.input };
+}
+function compareIndexDescending(left, right) {
+  return right.score - left.score || right.conversationId.localeCompare(left.conversationId);
+}
+function compareIndexAscending(left, right) {
+  return left.score - right.score || left.conversationId.localeCompare(right.conversationId);
+}
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
+function normalizeSource(value) {
+  if (value === "api" || value === "internal" || value === "local" || value === "plugin" || value === "resource_event" || value === "scheduler" || value === "slack") {
+    return value;
+  }
+  return void 0;
+}
+function normalizeExecutionStatus(value) {
+  if (value === "awaiting_resume" || value === "failed" || value === "idle" || value === "pending" || value === "running") {
+    return value;
+  }
+  return void 0;
+}
+function normalizeMetadata2(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  return value;
+}
+function normalizeInput(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const text = typeof value.text === "string" ? value.text : void 0;
+  const attachments = Array.isArray(value.attachments) ? [...value.attachments] : void 0;
+  if (text === void 0 || !text.trim() && !attachments?.length) {
+    return void 0;
+  }
+  return {
+    text,
+    authorId: toOptionalString(value.authorId),
+    attachments,
+    metadata: normalizeMetadata2(value.metadata)
+  };
+}
+function normalizeMessage(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const conversationId = toOptionalString(value.conversationId);
+  const inboundMessageId = toOptionalString(value.inboundMessageId);
+  const source = normalizeSource(value.source);
+  const destination = parseDestination(value.destination);
+  const createdAtMs = toOptionalNumber(value.createdAtMs);
+  const receivedAtMs = toOptionalNumber(value.receivedAtMs);
+  const input = normalizeInput(value.input);
+  if (!conversationId || !destination || !inboundMessageId || !source || typeof createdAtMs !== "number" || typeof receivedAtMs !== "number" || !input) {
+    return void 0;
+  }
+  return {
+    conversationId,
+    destination,
+    inboundMessageId,
+    source,
+    createdAtMs,
+    receivedAtMs,
+    input,
+    injectedAtMs: toOptionalNumber(value.injectedAtMs),
+    attemptCount: toOptionalNumber(value.attemptCount)
+  };
+}
+function isFinalAttempt(message) {
+  return (message.attemptCount ?? 0) >= CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS - 1;
+}
+function normalizeActor(value) {
+  return parseStoredSlackActor(value);
+}
+function normalizeLease(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const token = toOptionalString(value.token);
+  const acquiredAtMs = toOptionalNumber(value.acquiredAtMs);
+  const lastCheckInAtMs = toOptionalNumber(value.lastCheckInAtMs);
+  const expiresAtMs = toOptionalNumber(value.expiresAtMs);
+  if (!token || typeof acquiredAtMs !== "number" || typeof lastCheckInAtMs !== "number" || typeof expiresAtMs !== "number") {
+    return void 0;
+  }
+  return {
+    token,
+    acquiredAtMs,
+    lastCheckInAtMs,
+    expiresAtMs
+  };
+}
+function normalizeExecution(conversationId, value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const status = normalizeExecutionStatus(value.status);
+  if (!status) {
+    return void 0;
+  }
+  const pendingMessages2 = Array.isArray(value.pendingMessages) ? value.pendingMessages.map(normalizeMessage).filter((message) => Boolean(message)).filter((message) => message.conversationId === conversationId).filter((message) => message.injectedAtMs === void 0).sort(compareMessages) : [];
+  const inboundMessageIds = Array.isArray(value.inboundMessageIds) ? uniqueStrings(
+    value.inboundMessageIds.map((id) => typeof id === "string" ? id : void 0).filter((id) => Boolean(id))
+  ) : [];
+  const lease = normalizeLease(value.lease);
+  const normalizedStatus = status === "idle" && lease ? "running" : status === "idle" && pendingMessages2.length > 0 ? "pending" : status;
+  return {
+    status: normalizedStatus,
+    inboundMessageIds: uniqueStrings([
+      ...inboundMessageIds,
+      ...pendingMessages2.map((message) => message.inboundMessageId)
+    ]),
+    pendingCount: pendingMessages2.length,
+    pendingMessages: pendingMessages2,
+    lease,
+    lastCheckpointAtMs: toOptionalNumber(value.lastCheckpointAtMs),
+    lastEnqueuedAtMs: toOptionalNumber(value.lastEnqueuedAtMs),
+    runId: toOptionalString(value.runId),
+    updatedAtMs: toOptionalNumber(value.updatedAtMs)
+  };
+}
+function normalizeConversation(conversationId, value) {
+  if (!isRecord(value) || value.schemaVersion !== CONVERSATION_SCHEMA_VERSION) {
+    return void 0;
+  }
+  const storedConversationId = toOptionalString(value.conversationId);
+  const createdAtMs = toOptionalNumber(value.createdAtMs);
+  const lastActivityAtMs = toOptionalNumber(value.lastActivityAtMs);
+  const updatedAtMs = toOptionalNumber(value.updatedAtMs);
+  const execution = normalizeExecution(conversationId, value.execution);
+  const destination = value.destination === void 0 ? void 0 : parseDestination(value.destination);
+  if (storedConversationId !== conversationId || typeof createdAtMs !== "number" || typeof lastActivityAtMs !== "number" || typeof updatedAtMs !== "number" || !execution || value.destination !== void 0 && !destination) {
+    return void 0;
+  }
+  if (execution.pendingMessages.length > 0 && (!destination || execution.pendingMessages.some(
+    (message) => !sameDestination(message.destination, destination)
+  ))) {
+    return void 0;
+  }
+  return {
+    schemaVersion: CONVERSATION_SCHEMA_VERSION,
+    conversationId,
+    createdAtMs,
+    lastActivityAtMs,
+    updatedAtMs,
+    execution,
+    ...destination ? { destination } : {},
+    ...toOptionalString(value.title) ? { title: toOptionalString(value.title) } : {},
+    ...toOptionalString(value.channelName) ? { channelName: toOptionalString(value.channelName) } : {},
+    ...normalizeActor(value.actor) ? { actor: normalizeActor(value.actor) } : {},
+    ...normalizeSource(value.source) ? { source: normalizeSource(value.source) } : {}
+  };
+}
+function emptyConversation(args) {
+  return {
+    schemaVersion: CONVERSATION_SCHEMA_VERSION,
+    conversationId: args.conversationId,
+    createdAtMs: args.nowMs,
+    lastActivityAtMs: args.nowMs,
+    updatedAtMs: args.nowMs,
+    ...args.destination ? { destination: args.destination } : {},
+    ...args.source ? { source: args.source } : {},
+    execution: {
+      status: "idle",
+      inboundMessageIds: [],
+      pendingCount: 0,
+      pendingMessages: [],
+      updatedAtMs: args.nowMs
+    }
+  };
+}
+function isLeaseActive(lease, nowMs) {
+  return Boolean(lease && lease.expiresAtMs > nowMs);
+}
+function pendingMessages(conversation) {
+  return [...conversation.execution.pendingMessages].sort(compareMessages);
+}
+function isRunnableStatus(status) {
+  return status !== "failed" && status !== "idle";
+}
+function hasRunnableWork(conversation) {
+  return isRunnableStatus(conversation.execution.status) || pendingMessages(conversation).length > 0;
+}
+function executionWithPendingMessages(execution, pending) {
+  const pendingMessages2 = [...pending].sort(compareMessages);
+  const status = execution.status === "idle" && execution.lease ? "running" : execution.status === "idle" && pendingMessages2.length > 0 ? "pending" : execution.status;
+  return {
+    ...execution,
+    status,
+    inboundMessageIds: uniqueStrings([
+      ...execution.inboundMessageIds,
+      ...pendingMessages2.map((message) => message.inboundMessageId)
+    ]),
+    pendingMessages: pendingMessages2,
+    pendingCount: pendingMessages2.length
+  };
+}
+function withExecutionUpdate(conversation, execution, nowMs) {
+  return {
+    ...conversation,
+    updatedAtMs: nowMs,
+    execution: {
+      ...executionWithPendingMessages(execution, execution.pendingMessages),
+      updatedAtMs: nowMs
+    }
+  };
+}
+async function getConnectedState(stateAdapter) {
+  const state = stateAdapter ?? getStateAdapter();
+  await state.connect();
+  return state;
+}
+async function sleep2(ms) {
+  await new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+async function withIndexLock(state, indexKey, callback) {
+  const startedAtMs = now();
+  let lock;
+  while (true) {
+    lock = await state.acquireLock(
+      indexLockKey(indexKey),
+      CONVERSATION_INDEX_LOCK_TTL_MS
+    );
+    if (lock) {
+      break;
+    }
+    if (now() - startedAtMs >= CONVERSATION_INDEX_LOCK_WAIT_MS) {
+      throw new Error(
+        `Could not acquire conversation index lock for ${indexKey}`
+      );
+    }
+    await sleep2(CONVERSATION_INDEX_LOCK_RETRY_MS);
+  }
+  try {
+    return await callback();
+  } finally {
+    await state.releaseLock(lock);
+  }
+}
+function normalizeIndexEntry(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const conversationId = toOptionalString(value.conversationId);
+  const score = toOptionalNumber(value.score);
+  if (!conversationId || typeof score !== "number") {
+    return void 0;
+  }
+  return { conversationId, score };
+}
+function uniqueIndexEntries(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const entries = /* @__PURE__ */ new Map();
+  for (const item of value) {
+    const entry = normalizeIndexEntry(item);
+    if (!entry) {
+      continue;
+    }
+    const existing = entries.get(entry.conversationId);
+    if (!existing || entry.score > existing.score) {
+      entries.set(entry.conversationId, entry);
+    }
+  }
+  return [...entries.values()];
+}
+function retainedIndexEntries(indexKey, entries) {
+  if (indexKey === CONVERSATION_BY_ACTIVITY_INDEX_KEY) {
+    return entries.sort(compareIndexDescending).slice(0, CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH);
+  }
+  if (indexKey === CONVERSATION_ACTIVE_INDEX_KEY) {
+    return entries.sort(compareIndexAscending);
+  }
+  throw new Error(`Unknown conversation index ${indexKey}`);
+}
+function redisIndexKey(indexKey) {
+  const prefix = getChatConfig().state.keyPrefix;
+  return [...prefix ? [prefix] : [], indexKey].join(":");
+}
+function parseRedisIndexEntries(values) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  const entries = [];
+  for (let index = 0; index < values.length; index += 2) {
+    const conversationId = toOptionalString(values[index]);
+    const score = typeof values[index + 1] === "number" ? values[index + 1] : Number(values[index + 1]);
+    if (!conversationId || !Number.isFinite(score)) {
+      continue;
+    }
+    entries.push({ conversationId, score });
+  }
+  return entries;
+}
+function redisConversationIndexStore(client) {
+  const upsertBoundedActivityScript = `
+    redis.call("ZADD", KEYS[1], ARGV[1], ARGV[2])
+    redis.call("PEXPIRE", KEYS[1], ARGV[3])
+    local extra = redis.call("ZCARD", KEYS[1]) - tonumber(ARGV[4])
+    if extra > 0 then
+      redis.call("ZREMRANGEBYRANK", KEYS[1], 0, extra - 1)
+    end
+    return 1
+  `;
+  return {
+    async list(args) {
+      const key = redisIndexKey(args.indexKey);
+      const limit = args.limit;
+      const offset = Math.max(0, args.offset ?? 0);
+      if (limit === 0) {
+        return [];
+      }
+      const values = args.scoreMax !== void 0 ? await client.sendCommand([
+        "ZRANGEBYSCORE",
+        key,
+        "-inf",
+        String(args.scoreMax),
+        "WITHSCORES",
+        ...limit !== void 0 || offset > 0 ? ["LIMIT", String(offset), String(limit ?? 1e9)] : []
+      ]) : await client.sendCommand([
+        args.order === "asc" ? "ZRANGE" : "ZREVRANGE",
+        key,
+        String(offset),
+        String(
+          limit === void 0 ? -1 : offset + Math.max(0, limit - 1)
+        ),
+        "WITHSCORES"
+      ]);
+      return parseRedisIndexEntries(values);
+    },
+    async remove(args) {
+      await client.sendCommand([
+        "ZREM",
+        redisIndexKey(args.indexKey),
+        args.conversationId
+      ]);
+    },
+    async upsert(args) {
+      const key = redisIndexKey(args.indexKey);
+      if (args.indexKey === CONVERSATION_BY_ACTIVITY_INDEX_KEY) {
+        await client.sendCommand([
+          "EVAL",
+          upsertBoundedActivityScript,
+          "1",
+          key,
+          String(args.score),
+          args.conversationId,
+          String(JUNIOR_THREAD_STATE_TTL_MS),
+          String(CONVERSATION_ACTIVITY_INDEX_MAX_LENGTH)
+        ]);
+        return;
+      }
+      if (args.indexKey === CONVERSATION_ACTIVE_INDEX_KEY) {
+        await client.sendCommand([
+          "ZADD",
+          key,
+          String(args.score),
+          args.conversationId
+        ]);
+        await client.sendCommand([
+          "PEXPIRE",
+          key,
+          String(JUNIOR_THREAD_STATE_TTL_MS)
+        ]);
+        return;
+      }
+      throw new Error(`Unknown conversation index ${args.indexKey}`);
+    }
+  };
+}
+function emulatedConversationIndexStore(state) {
+  const readIndex = async (indexKey) => uniqueIndexEntries(await state.get(indexKey));
+  const writeIndex = async (indexKey, entries) => {
+    await state.set(indexKey, entries, JUNIOR_THREAD_STATE_TTL_MS);
+  };
+  return {
+    async list(args) {
+      const entries = (await readIndex(args.indexKey)).filter(
+        (entry) => args.scoreMax === void 0 ? true : entry.score <= args.scoreMax
+      ).sort(
+        args.order === "asc" ? compareIndexAscending : compareIndexDescending
+      );
+      const offset = Math.max(0, args.offset ?? 0);
+      return entries.slice(
+        offset,
+        args.limit === void 0 ? entries.length : offset + args.limit
+      );
+    },
+    async remove(args) {
+      await withIndexLock(state, args.indexKey, async () => {
+        const entries = await readIndex(args.indexKey);
+        const next = entries.filter(
+          (entry) => entry.conversationId !== args.conversationId
+        );
+        if (next.length === entries.length) {
+          return;
+        }
+        await writeIndex(args.indexKey, next);
+      });
+    },
+    async upsert(args) {
+      await withIndexLock(state, args.indexKey, async () => {
+        const entries = await readIndex(args.indexKey);
+        const withoutCurrent = entries.filter(
+          (entry) => entry.conversationId !== args.conversationId
+        );
+        const next = retainedIndexEntries(args.indexKey, [
+          ...withoutCurrent,
+          { conversationId: args.conversationId, score: args.score }
+        ]);
+        await writeIndex(args.indexKey, next);
+      });
+    }
+  };
+}
+async function getConversationIndexStore(state) {
+  const redisStateAdapter = await getDefaultRedisStateAdapterFor(state);
+  if (redisStateAdapter) {
+    return redisConversationIndexStore(redisStateAdapter.getClient());
+  }
+  return emulatedConversationIndexStore(state);
+}
+async function upsertIndexEntry(args) {
+  const index = await getConversationIndexStore(args.state);
+  await index.upsert({
+    conversationId: args.conversationId,
+    indexKey: args.indexKey,
+    score: args.score
+  });
+}
+async function removeIndexEntry(args) {
+  const index = await getConversationIndexStore(args.state);
+  await index.remove({
+    conversationId: args.conversationId,
+    indexKey: args.indexKey
+  });
+}
+async function acquireMutationLock(state, conversationId) {
+  const startedAtMs = now();
+  while (true) {
+    const lock = await state.acquireLock(
+      mutationLockKey(conversationId),
+      CONVERSATION_MUTATION_LOCK_TTL_MS
+    );
+    if (lock) {
+      return lock;
+    }
+    if (now() - startedAtMs >= CONVERSATION_MUTATION_WAIT_MS) {
+      throw new Error(
+        `Could not acquire conversation mutation lock for ${conversationId}`
+      );
+    }
+    await sleep2(CONVERSATION_MUTATION_RETRY_MS);
+  }
+}
+async function withConversationMutation(args, callback) {
+  const state = await getConnectedState(args.state);
+  const lock = await acquireMutationLock(state, args.conversationId);
+  try {
+    return await callback(state, lock);
+  } finally {
+    await state.releaseLock(lock);
+  }
+}
+async function readConversation(state, conversationId) {
+  const raw = await state.get(conversationKey(conversationId));
+  if (raw == null) {
+    return void 0;
+  }
+  const conversation = normalizeConversation(conversationId, raw);
+  if (!conversation) {
+    throw new InvalidConversationRecordError(conversationId);
+  }
+  return conversation;
+}
+async function writeConversation(state, lock, conversation) {
+  const execution = executionWithPendingMessages(
+    conversation.execution,
+    conversation.execution.pendingMessages
+  );
+  const next = {
+    ...conversation,
+    execution
+  };
+  const fenced = await state.extendLock(
+    lock,
+    CONVERSATION_MUTATION_LOCK_TTL_MS
+  );
+  if (!fenced) {
+    throw new ConversationMutationFencedError(next.conversationId);
+  }
+  await state.set(
+    conversationKey(next.conversationId),
+    next,
+    JUNIOR_THREAD_STATE_TTL_MS
+  );
+  await upsertIndexEntry({
+    state,
+    indexKey: CONVERSATION_BY_ACTIVITY_INDEX_KEY,
+    conversationId: next.conversationId,
+    score: next.lastActivityAtMs
+  });
+  if (!hasRunnableWork(next)) {
+    await removeIndexEntry({
+      state,
+      indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
+      conversationId: next.conversationId
+    });
+    return;
+  }
+  await upsertIndexEntry({
+    state,
+    indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
+    conversationId: next.conversationId,
+    score: next.execution.updatedAtMs ?? next.updatedAtMs
+  });
+}
+function assertSameConversationDestination(args) {
+  if (!args.current || sameDestination(args.current, args.next)) {
+    return;
+  }
+  throw new Error(
+    `Conversation destination changed for ${args.conversationId}`
+  );
+}
+function conversationWorkState(conversation) {
+  const lease = conversation.execution.lease;
+  return {
+    ...conversation,
+    lastEnqueuedAtMs: conversation.execution.lastEnqueuedAtMs,
+    ...lease ? {
+      lease: {
+        acquiredAtMs: lease.acquiredAtMs,
+        lastCheckInAtMs: lease.lastCheckInAtMs,
+        leaseExpiresAtMs: lease.expiresAtMs,
+        leaseToken: lease.token
+      }
+    } : {},
+    messages: pendingMessages(conversation),
+    needsRun: hasRunnableWork(conversation)
+  };
+}
+async function getConversation(args) {
+  const state = await getConnectedState(args.state);
+  return await readConversation(state, args.conversationId);
+}
+async function getConversationWorkState(args) {
+  const conversation = await getConversation(args);
+  return conversation ? conversationWorkState(conversation) : void 0;
+}
+async function appendInboundMessage(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(
+    { conversationId: args.message.conversationId, state: args.state },
+    async (state, lock) => {
+      const current = await readConversation(state, args.message.conversationId) ?? emptyConversation({
+        conversationId: args.message.conversationId,
+        destination: args.message.destination,
+        nowMs,
+        source: args.message.source
+      });
+      assertSameConversationDestination({
+        conversationId: args.message.conversationId,
+        current: current.destination,
+        next: args.message.destination
+      });
+      const existingPending = current.execution.pendingMessages.some(
+        (message) => message.inboundMessageId === args.message.inboundMessageId
+      );
+      const existing = current.execution.inboundMessageIds.includes(
+        args.message.inboundMessageId
+      );
+      if (existing) {
+        if (!existingPending) {
+          return { status: "duplicate" };
+        }
+        const nextStatus = current.execution.status === "idle" ? "pending" : current.execution.status;
+        await writeConversation(
+          state,
+          lock,
+          withExecutionUpdate(
+            current,
+            {
+              ...current.execution,
+              status: nextStatus,
+              pendingMessages: current.execution.pendingMessages.map(
+                (message) => message.inboundMessageId === args.message.inboundMessageId ? upgradedPendingMessage(message, args.message) : message
+              )
+            },
+            nowMs
+          )
+        );
+        return { status: "duplicate" };
+      }
+      const status = current.execution.lease && current.execution.status === "running" ? "running" : current.execution.lease ? "awaiting_resume" : "pending";
+      const next = {
+        ...current,
+        destination: current.destination ?? args.message.destination,
+        source: current.source ?? args.message.source,
+        lastActivityAtMs: nowMs
+      };
+      await writeConversation(
+        state,
+        lock,
+        withExecutionUpdate(
+          next,
+          {
+            ...current.execution,
+            status,
+            inboundMessageIds: [
+              ...current.execution.inboundMessageIds,
+              args.message.inboundMessageId
+            ],
+            pendingMessages: [
+              ...current.execution.pendingMessages,
+              args.message
+            ].sort(compareMessages)
+          },
+          nowMs
+        )
+      );
+      return { status: "appended" };
+    }
+  );
+}
+async function requestConversationWork(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const existing = await readConversation(state, args.conversationId);
+    if (existing) {
+      assertSameConversationDestination({
+        conversationId: args.conversationId,
+        current: existing.destination,
+        next: args.destination
+      });
+    }
+    const current = existing ?? emptyConversation({
+      conversationId: args.conversationId,
+      destination: args.destination,
+      nowMs
+    });
+    const status = current.execution.lease ? "awaiting_resume" : "pending";
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        {
+          ...current,
+          destination: current.destination ?? args.destination
+        },
+        {
+          ...current.execution,
+          status
+        },
+        nowMs
+      )
+    );
+    return { status: existing === void 0 ? "created" : "updated" };
+  });
+}
+async function markConversationWorkEnqueued(args) {
+  const nowMs = args.nowMs ?? now();
+  await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current) {
+      return;
+    }
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lastEnqueuedAtMs: nowMs
+        },
+        nowMs
+      )
+    );
+  });
+}
+async function clearConsumedConversationWake(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || hasRunnableWork(current) || current.execution.lastEnqueuedAtMs === void 0) {
+      return false;
+    }
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lastEnqueuedAtMs: void 0
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function startConversationWork(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current) {
+      return { status: "no_work" };
+    }
+    if (isLeaseActive(current.execution.lease, nowMs)) {
+      return {
+        status: "active",
+        leaseExpiresAtMs: current.execution.lease.expiresAtMs
+      };
+    }
+    if (!hasRunnableWork(current)) {
+      return { status: "no_work" };
+    }
+    const lease = {
+      token: randomUUID(),
+      acquiredAtMs: nowMs,
+      lastCheckInAtMs: nowMs,
+      expiresAtMs: nowMs + CONVERSATION_WORK_LEASE_TTL_MS
+    };
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease,
+          status: "running",
+          runId: current.execution.runId ?? randomUUID(),
+          lastEnqueuedAtMs: void 0
+        },
+        nowMs
+      )
+    );
+    return {
+      status: "acquired",
+      leaseToken: lease.token,
+      leaseExpiresAtMs: lease.expiresAtMs
+    };
+  });
+}
+async function checkInConversationWork(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return false;
+    }
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease: {
+            ...current.execution.lease,
+            lastCheckInAtMs: nowMs,
+            expiresAtMs: nowMs + CONVERSATION_WORK_LEASE_TTL_MS
+          }
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function drainConversationMailbox(args) {
+  const nowMs = args.nowMs ?? now();
+  const pending = await withConversationMutation(args, async (state) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      throw new Error(
+        `Conversation lease is not held for ${args.conversationId}`
+      );
+    }
+    return pendingMessages(current);
+  });
+  if (pending.length === 0) {
+    return [];
+  }
+  const acknowledgedIds = await args.handle(pending);
+  const pendingIds = new Set(
+    pending.map((message) => message.inboundMessageId)
+  );
+  for (const inboundMessageId of acknowledgedIds ?? []) {
+    if (!pendingIds.has(inboundMessageId)) {
+      throw new Error(
+        `Conversation mailbox acknowledgement is not pending for ${args.conversationId}`
+      );
+    }
+  }
+  const drainedIds = new Set(
+    acknowledgedIds ?? pending.map((message) => message.inboundMessageId)
+  );
+  await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      throw new Error(
+        `Conversation lease is not held for ${args.conversationId}`
+      );
+    }
+    const pendingMessages2 = current.execution.pendingMessages.filter(
+      (message) => !drainedIds.has(message.inboundMessageId)
+    );
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          status: current.execution.status === "pending" && pendingMessages2.length === 0 ? "running" : current.execution.status,
+          pendingMessages: pendingMessages2
+        },
+        nowMs
+      )
+    );
+  });
+  return pending.filter((message) => drainedIds.has(message.inboundMessageId));
+}
+async function ackMessages(args) {
+  const nowMs = args.nowMs ?? now();
+  const inboundMessageIds = new Set(args.inboundMessageIds);
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return false;
+    }
+    if (inboundMessageIds.size === 0) {
+      return true;
+    }
+    const pendingMessages2 = current.execution.pendingMessages.filter(
+      (message) => !inboundMessageIds.has(message.inboundMessageId)
+    );
+    if (pendingMessages2.length === current.execution.pendingMessages.length) {
+      return true;
+    }
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          pendingMessages: pendingMessages2
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function requestConversationContinuation(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return false;
+    }
+    assertSameConversationDestination({
+      conversationId: args.conversationId,
+      current: current.destination,
+      next: args.destination
+    });
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          status: "awaiting_resume"
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function releaseConversationWork(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return false;
+    }
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease: void 0,
+          status: current.execution.status === "running" ? "pending" : current.execution.status
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function completeConversationWork(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return "lost_lease";
+    }
+    const hasPending = pendingMessages(current).length > 0;
+    const needsRun = current.execution.status === "awaiting_resume";
+    const runnable = needsRun || hasPending;
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease: void 0,
+          status: runnable ? "pending" : "idle",
+          runId: runnable ? current.execution.runId : void 0
+        },
+        nowMs
+      )
+    );
+    return runnable ? "pending" : "completed";
+  });
+}
+async function recordAttemptFailure(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return {
+        status: "lost_lease",
+        pendingCount: 0,
+        deadLetteredMessages: []
+      };
+    }
+    const pendingIds = new Set(
+      current.execution.pendingMessages.map(
+        (message) => message.inboundMessageId
+      )
+    );
+    if (args.inboundMessageIds.length === 0 || args.inboundMessageIds.some((id) => !pendingIds.has(id))) {
+      return {
+        status: "skipped",
+        pendingCount: current.execution.pendingMessages.length,
+        deadLetteredMessages: []
+      };
     }
-  } catch (error) {
-    if (error instanceof AuthorizationFlowDisabledError) {
-      if (lifecycleStarted && !lifecycleTerminalized) {
-        await turnLifecycle.fail({
-          conversationId,
-          turnId,
-          createdAtMs: Date.now(),
-          failureCode: "agent_run_failed"
-        });
-        lifecycleTerminalized = true;
+    const attemptedIds = new Set(args.inboundMessageIds);
+    const deadLetteredMessages = [];
+    const pendingMessages2 = [];
+    for (const message of current.execution.pendingMessages) {
+      if (!attemptedIds.has(message.inboundMessageId)) {
+        pendingMessages2.push(message);
+        continue;
       }
-      await markDispatch({
-        dispatch,
-        status: "blocked",
-        errorMessage: `Dispatch requires ${error.provider} authorization.`
-      });
-      return;
-    }
-    if (error instanceof PluginCredentialFailureError) {
-      if (lifecycleStarted && !lifecycleTerminalized) {
-        await turnLifecycle.fail({
-          conversationId,
-          turnId,
-          createdAtMs: Date.now(),
-          failureCode: "agent_run_failed"
-        });
-        lifecycleTerminalized = true;
+      const attempted = {
+        ...message,
+        attemptCount: (message.attemptCount ?? 0) + 1
+      };
+      if (attempted.attemptCount >= CONVERSATION_WORK_MAX_DELIVERY_ATTEMPTS) {
+        deadLetteredMessages.push(attempted);
+        continue;
       }
-      await markDispatch({
-        dispatch,
-        status: "blocked",
-        errorMessage: error.message
-      });
-      return;
+      pendingMessages2.push(attempted);
     }
-    const eventId = logException(
-      error,
-      "agent_dispatch_run_failed",
-      {
-        ...logContext,
-        modelId: standardModelId(botConfig)
-      },
-      {},
-      "Agent dispatch failed"
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          pendingMessages: pendingMessages2
+        },
+        nowMs
+      )
     );
-    if (lifecycleStarted && !lifecycleTerminalized) {
-      await turnLifecycle.fail({
-        conversationId,
-        turnId,
-        createdAtMs: Date.now(),
-        failureCode,
-        ...eventId ? { eventId } : {}
-      });
-      lifecycleTerminalized = true;
+    return {
+      status: "recorded",
+      pendingCount: pendingMessages2.length,
+      deadLetteredMessages
+    };
+  });
+}
+async function deadLetterAttempt(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current || current.execution.lease?.token !== args.leaseToken) {
+      return "lost_lease";
     }
-    await markDispatch({
-      dispatch,
-      status: "failed",
-      errorMessage: error instanceof Error ? error.message : String(error)
-    });
-  } finally {
-    await stateAdapter.releaseLock(destinationLock);
-  }
+    const runnable = pendingMessages(current).length > 0;
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease: void 0,
+          status: runnable ? "pending" : "failed",
+          runId: runnable ? current.execution.runId : void 0
+        },
+        nowMs
+      )
+    );
+    return runnable ? "pending" : "failed";
+  });
 }
-
-// src/handlers/agent-dispatch.ts
-async function POST(request, waitUntil, options) {
-  const payload = await verifyDispatchCallbackRequest(request);
-  if (!payload) {
-    return new Response("Unauthorized", { status: 401 });
-  }
-  waitUntil(
-    () => runAgentDispatchSlice(payload, {
-      agentRunner: options.agentRunner
-    }).catch((error) => {
-      logException(
-        error,
-        "agent_dispatch_handler_failed",
-        {},
-        { "app.dispatch.id": payload.id },
-        "Agent dispatch handler failed"
-      );
-    })
-  );
-  return new Response("Accepted", { status: 202 });
+async function clearExpiredConversationLease(args) {
+  const nowMs = args.nowMs ?? now();
+  return await withConversationMutation(args, async (state, lock) => {
+    const current = await readConversation(state, args.conversationId);
+    if (!current?.execution.lease || current.execution.lease.expiresAtMs > nowMs) {
+      return false;
+    }
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease: void 0,
+          status: "pending"
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
+}
+async function removeActiveConversation(args) {
+  const state = await getConnectedState(args.state);
+  await removeIndexEntry({
+    state,
+    indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
+    conversationId: args.conversationId
+  });
+}
+async function listActiveConversationIds(args = {}) {
+  const state = await getConnectedState(args.state);
+  const index = await getConversationIndexStore(state);
+  const entries = await index.list({
+    indexKey: CONVERSATION_ACTIVE_INDEX_KEY,
+    limit: args.limit,
+    order: "asc",
+    scoreMax: args.staleBeforeMs
+  });
+  return entries.map((entry) => entry.conversationId);
 }
-
-// src/handlers/heartbeat.ts
-import { timingSafeEqual as timingSafeEqual2 } from "crypto";
 
 // src/chat/task-execution/store.ts
 function metadataStore(options) {
@@ -1360,7 +2449,7 @@ function hasRecentEnqueueMarker(conversation, nowMs) {
   const lastEnqueuedAtMs = conversation.execution.lastEnqueuedAtMs;
   return typeof lastEnqueuedAtMs === "number" && lastEnqueuedAtMs + CONVERSATION_WORK_STALE_ENQUEUE_MS > nowMs;
 }
-function now() {
+function now2() {
   return Date.now();
 }
 async function recordExecutionMetadata(args) {
@@ -1401,7 +2490,7 @@ function hasRunnableConversationWork(conversation) {
   return conversation.execution.status !== "idle" || countPendingConversationMessages(conversation) > 0;
 }
 async function ensureConversationWake(args) {
-  const nowMs = args.nowMs ?? now();
+  const nowMs = args.nowMs ?? now2();
   const conversation = await getConversation({
     conversationId: args.conversationId,
     state: args.state
@@ -1434,7 +2523,7 @@ async function ensureConversationWake(args) {
   return { status: "enqueued", queueMessageId: queueResult?.messageId };
 }
 async function appendAndEnqueueInboundMessage(args) {
-  const nowMs = args.nowMs ?? now();
+  const nowMs = args.nowMs ?? now2();
   const appendResult = await appendInboundMessage({
     message: args.message,
     nowMs,
@@ -2432,7 +3521,7 @@ var STATUS_UPDATE_DEBOUNCE_MS = 1e3;
 var STATUS_MIN_VISIBLE_MS = 1200;
 var STATUS_ROTATION_INTERVAL_MS = 3e4;
 function createAssistantStatusScheduler(args) {
-  const now3 = args.now ?? (() => Date.now());
+  const now4 = args.now ?? (() => Date.now());
   const setTimer = args.setTimer ?? ((callback, delayMs) => setTimeout(callback, delayMs));
   const clearTimer = args.clearTimer ?? ((timer) => clearTimeout(timer));
   const random = args.random ?? Math.random;
@@ -2496,7 +3585,7 @@ function createAssistantStatusScheduler(args) {
     }
     currentVisibleStatus = text;
     currentLoadingMessages = nextLoadingMessages;
-    lastStatusAt = now3();
+    lastStatusAt = now4();
     scheduleRotation();
     await enqueueStatusUpdate(async () => {
       await args.sendStatus(text, nextLoadingMessages);
@@ -2583,7 +3672,7 @@ function createAssistantStatusScheduler(args) {
         }
         return;
       }
-      const elapsed = now3() - lastStatusAt;
+      const elapsed = now4() - lastStatusAt;
       const waitMs = Math.max(
         STATUS_UPDATE_DEBOUNCE_MS - elapsed,
         STATUS_MIN_VISIBLE_MS - elapsed,
@@ -2981,19 +4070,14 @@ function resolveReplyTimeoutMs(explicitTimeoutMs) {
   const parsed = Number.parseInt(raw, 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
 }
-async function postSlackMessageBestEffort(channelId, threadTs, text, footer) {
+async function postSlackMessageBestEffort(channelId, threadTs, text, conversationId) {
   try {
-    if (footer) {
-      await postSlackApiReplyPosts({
+    if (conversationId) {
+      await sendSlackReply({
         channelId,
-        threadTs,
-        posts: [
-          {
-            text,
-            stage: "thread_reply"
-          }
-        ],
-        footer
+        conversationId,
+        text,
+        threadTs
       });
       return;
     }
@@ -3041,10 +4125,10 @@ function getResumeLogContext(args, lockKey) {
   const actor = routing?.actor;
   return {
     conversationId: args.conversationId,
-    slackThreadId: lockKey,
-    slackUserId: isUserActor(actor) ? actor.userId : void 0,
-    slackUserName: isUserActor(actor) ? actor.userName : void 0,
-    slackChannelId: args.channelId,
+    messageConversationId: lockKey,
+    userId: isUserActor(actor) ? actor.userId : void 0,
+    userName: isUserActor(actor) ? actor.userName : void 0,
+    destinationName: args.channelId,
     assistantUserName: botConfig.userName,
     modelId: standardModelId(botConfig)
   };
@@ -3308,18 +4392,18 @@ async function resumeSlackTurn(args) {
       };
     };
     const deliverAssistantMessage = async (assistantMessage) => {
-      const posts = planSlackAssistantMessagePosts(assistantMessage.text);
-      if (posts.length === 0) {
+      if (!assistantMessage.text.trim()) {
         return;
       }
       failureCode = "delivery_failed";
       const deliveryState2 = await getDeliveryConversation();
       let messageTs;
       try {
-        messageTs = await postSlackApiReplyPosts({
+        messageTs = await sendSlackReply({
           channelId: runArgs.channelId,
-          threadTs: runArgs.threadTs,
-          posts
+          conversationId: runArgs.conversationId,
+          text: assistantMessage.text,
+          threadTs: runArgs.threadTs
         });
       } catch (error) {
         if (isRetryableSlackPostError(error)) {
@@ -3446,16 +4530,10 @@ async function resumeSlackTurn(args) {
           destination: replyContext.routing.destination,
           source: replyContext.routing.source,
           actor: resumeActor,
-          surface: "slack",
-          logContext: {
-            threadId: runArgs.conversationId,
-            actorId: isUserActor(replyContext.routing.actor) ? replyContext.routing.actor.userId : void 0,
-            channelId: runArgs.channelId,
-            assistantUserName: botConfig.userName
-          }
+          surface: "slack"
         });
       }
-      await runArgs.onSuccess?.(reply);
+      await runArgs.commitResult?.(reply);
       if (reply.diagnostics.outcome === "success") {
         await turnLifecycle.complete({
           conversationId: runArgs.conversationId,
@@ -3551,9 +4629,6 @@ async function resumeSlackTurn(args) {
     try {
       await deferredPauseHandler();
       if (deferredAuthInfo) {
-        const footer = buildSlackReplyFooter({
-          conversationId: runArgs.conversationId
-        });
         await postSlackMessageBestEffort(
           runArgs.channelId,
           runArgs.threadTs,
@@ -3561,7 +4636,7 @@ async function resumeSlackTurn(args) {
             deferredAuthInfo.actorId,
             deferredAuthInfo.providerDisplayName
           ),
-          footer
+          runArgs.conversationId
         );
       }
       return true;
@@ -3964,7 +5039,7 @@ async function resumeAuthorizedMcpTurn(args) {
             }
           }
         },
-        onSuccess: async (reply) => {
+        commitResult: async (reply) => {
           await persistCompletedReplyState(
             authSession.channelId,
             authSession.threadTs,
@@ -4562,7 +5637,7 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
             }
           }
         },
-        onSuccess: async (reply) => {
+        commitResult: async (reply) => {
           logInfo(
             "oauth_callback_resume_complete",
             {},
@@ -4849,9 +5924,9 @@ function buildJwksUrl(value) {
   return url;
 }
 async function getJwks(issuer) {
-  const now3 = Date.now();
+  const now4 = Date.now();
   const cached = jwksByIssuer.get(issuer);
-  if (cached && cached.expiresAtMs > now3) {
+  if (cached && cached.expiresAtMs > now4) {
     return cached.jwks;
   }
   if (cached) {
@@ -4876,7 +5951,7 @@ async function getJwks(issuer) {
   }
   jwksByIssuer.set(issuer, {
     jwks,
-    expiresAtMs: now3 + OIDC_DISCOVERY_CACHE_TTL_MS
+    expiresAtMs: now4 + OIDC_DISCOVERY_CACHE_TTL_MS
   });
   return jwks;
 }
@@ -5188,6 +6263,7 @@ import {
   Message,
   ThreadImpl
 } from "chat";
+import { z as z3 } from "zod";
 
 // src/chat/ingress/message-router.ts
 function normalizeIncomingSlackThreadId(threadId, message) {
@@ -5225,7 +6301,7 @@ function rehydrateAttachmentFetchers(message, downloadPrivateSlackFile2 = downlo
 
 // src/chat/slack/adapter-context.ts
 var initializedAdapters = /* @__PURE__ */ new WeakSet();
-async function getConnectedState(stateAdapter) {
+async function getConnectedState2(stateAdapter) {
   const state = stateAdapter ?? getStateAdapter();
   await state.connect();
   return state;
@@ -5234,7 +6310,7 @@ async function ensureSlackAdapterInitialized(args) {
   if (initializedAdapters.has(args.adapter)) {
     return;
   }
-  const state = await getConnectedState(args.state);
+  const state = await getConnectedState2(args.state);
   await args.adapter.initialize({
     getState: () => state
   });
@@ -5453,6 +6529,211 @@ async function lookupSlackUser(teamId, userId) {
 }
 
 // src/chat/task-execution/slack-work.ts
+var slackConversationRouteSchema = z3.enum(["mention", "subscribed"]);
+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(),
+      provider: z3.string(),
+      resourceRef: z3.string(),
+      subscriptionId: z3.string()
+    }).strict()
+  }).strict()
+]);
 function requireSlackAuthorId(message) {
   const authorId = parseActorUserId(message.author.userId);
   if (!authorId) {
@@ -5497,6 +6778,7 @@ function slackSerializedResourceEventMessage(input) {
     raw: {
       channel: input.channelId,
       event_type: "resource_event",
+      resource_event_type: input.eventType,
       thread_ts: input.threadTs,
       type: "message",
       user: "UJRNEVENT"
@@ -5522,6 +6804,7 @@ function createSlackResourceEventInboundMessage(input) {
   const timestampIso = new Date(input.event.occurredAtMs).toISOString();
   const message = slackSerializedResourceEventMessage({
     channelId: slack.channelId,
+    eventType: input.event.eventType,
     id: messageId,
     text: input.text,
     threadTs: slack.threadTs,
@@ -5562,19 +6845,20 @@ function createSlackResourceEventInboundMessage(input) {
     }
   };
 }
-function getConnectedState2(stateAdapter) {
+function getConnectedState3(stateAdapter) {
   return stateAdapter ?? getStateAdapter();
 }
-function isSlackMetadata(value) {
-  return Boolean(value) && value?.platform === "slack" && (value.route === "mention" || value.route === "subscribed") && Boolean(value.thread) && Boolean(value.message);
+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) => {
-    const metadata = record.input.metadata;
-    if (!isSlackMetadata(metadata)) {
+    const metadata = parseSlackMetadata(record.input.metadata);
+    if (!metadata) {
       throw new Error("Conversation mailbox record is not Slack metadata");
     }
     return metadata.route === "mention";
@@ -5589,8 +6873,8 @@ function isResourceEventNotificationMessage(message) {
   return raw?.event_type === "resource_event";
 }
 function restoreMessage(args) {
-  const metadata = args.record.input.metadata;
-  if (!isSlackMetadata(metadata)) {
+  const metadata = parseSlackMetadata(args.record.input.metadata);
+  if (!metadata) {
     throw new Error("Conversation mailbox record is not a Slack message");
   }
   const message = Message.fromJSON(metadata.message);
@@ -5646,8 +6930,8 @@ function restoreThread(args) {
 }
 function getInstallation(records) {
   for (let index = records.length - 1; index >= 0; index -= 1) {
-    const metadata = records[index]?.input.metadata;
-    if (isSlackMetadata(metadata) && metadata.installation) {
+    const metadata = parseSlackMetadata(records[index]?.input.metadata);
+    if (metadata?.installation) {
       return metadata.installation;
     }
   }
@@ -5663,7 +6947,7 @@ function createSlackConversationWorker(options) {
   return async (context) => {
     const adapter = options.getSlackAdapter();
     const actorLookup = options.lookupSlackUser ?? lookupSlackUser;
-    const state = getConnectedState2(options.state);
+    const state = getConnectedState3(options.state);
     await state.connect();
     const records = getPendingRecords({
       execution: { pendingMessages: [...context.attempt.messages] }
@@ -5687,8 +6971,8 @@ function createSlackConversationWorker(options) {
     if (!latestRecord) {
       return { status: "completed" };
     }
-    const latestMetadata = latestRecord.input.metadata;
-    if (!isSlackMetadata(latestMetadata)) {
+    const latestMetadata = parseSlackMetadata(latestRecord.input.metadata);
+    if (!latestMetadata) {
       throw new Error(
         "Latest conversation mailbox record is not Slack metadata"
       );
@@ -5747,8 +7031,8 @@ function createSlackConversationWorker(options) {
         const drainSteeringMessages = async (accept) => {
           await context.attempt.drain(async (pendingRecords) => {
             const messages2 = pendingRecords.map((record) => {
-              const metadata = record.input.metadata;
-              if (!isSlackMetadata(metadata)) {
+              const metadata = parseSlackMetadata(record.input.metadata);
+              if (!metadata) {
                 throw new Error(
                   "Conversation mailbox record is not Slack metadata"
                 );
@@ -5832,7 +7116,7 @@ function buildSlackInboundMessage(args) {
         platform: "slack",
         route: args.route,
         installation: args.installation,
-        thread: args.thread.toJSON(),
+        thread: serializedThreadSchema.parse(args.thread.toJSON()),
         message: args.message.toJSON()
       }
     }
@@ -6015,7 +7299,7 @@ async function handleUnlink(event, actorId, provider) {
   await tokenStore.delete(actorId, provider);
   logInfo(
     "slash_command_unlink",
-    { slackUserId: actorId },
+    { userId: actorId },
     { "app.credential.provider": provider },
     `Unlinked ${formatProviderLabel(provider)} account via ${getCommandName()} slash command`
   );
@@ -6237,7 +7521,7 @@ async function handleSlackEvent(args) {
       );
     } catch (error) {
       logException(error, "slack_app_home_publish_failed", {
-        slackUserId: userId
+        userId
       });
     }
   }
@@ -6348,7 +7632,7 @@ async function handleSlashCommandForm(args) {
   await withSpan(
     "chat.slash_command",
     "chat.slash_command",
-    { slackUserId: userId },
+    { userId },
     async () => {
       await handleSlashCommand({
         adapter: args.adapter,
@@ -6387,7 +7671,7 @@ async function handleInteractivePayload(args) {
   await withSpan(
     "chat.app_home_disconnect",
     "chat.app_home_disconnect",
-    { slackUserId: userId },
+    { userId },
     async () => {
       try {
         await unlinkProvider(userId, provider, args.userTokenStore);
@@ -6395,7 +7679,7 @@ async function handleInteractivePayload(args) {
         logException(
           error,
           "app_home_disconnect_unlink_failed",
-          { slackUserId: userId },
+          { userId },
           { "app.credential.provider": provider }
         );
       }
@@ -6405,7 +7689,7 @@ async function handleInteractivePayload(args) {
         logException(
           error,
           "app_home_disconnect_publish_failed",
-          { slackUserId: userId },
+          { userId },
           { "app.credential.provider": provider }
         );
       }
@@ -6448,7 +7732,7 @@ async function handleSlackForm(args) {
         })
       ).catch((error) => {
         logException(error, "slash_command_failed", {
-          slackUserId: params.get("user_id") ?? void 0
+          userId: params.get("user_id") ?? void 0
         });
       })
     );
@@ -6478,7 +7762,7 @@ async function handleSlackForm(args) {
       })
     ).catch((error) => {
       logException(error, "slack_interactive_payload_failed", {
-        slackUserId: payload.user?.id?.trim() || void 0
+        userId: payload.user?.id?.trim() || void 0
       });
     })
   );
@@ -6628,7 +7912,7 @@ function isConversationQueueMessageRejectedError(error) {
 // src/chat/task-execution/worker.ts
 var CONVERSATION_WORK_DEFER_DELAY_MS = 15e3;
 var CONVERSATION_WORK_SOFT_YIELD_AFTER_MS = 24e4;
-function now2(options) {
+function now3(options) {
   return options.nowMs?.() ?? Date.now();
 }
 function nudgeIdempotencyKey(reason, conversationId, nowMs) {
@@ -6699,7 +7983,7 @@ function isTerminalFailure(failure) {
 }
 function startLeaseCheckIn(args) {
   const timer = setInterval(() => {
-    const nowMs = now2(args.options);
+    const nowMs = now3(args.options);
     void checkInConversationWork2({
       conversationId: args.conversationId,
       leaseToken: args.leaseToken,
@@ -6755,7 +8039,7 @@ async function processConversationWork(message, options) {
       await clearConsumedConversationWake2({
         conversationId,
         conversationStore: options.conversationStore,
-        nowMs: now2(options),
+        nowMs: now3(options),
         state: options.state
       });
     }
@@ -6772,20 +8056,20 @@ async function processConversationWork(message, options) {
   const lease = await startConversationWork2({
     conversationId,
     conversationStore: options.conversationStore,
-    nowMs: now2(options),
+    nowMs: now3(options),
     state: options.state
   });
   if (lease.status === "no_work") {
     await clearConsumedConversationWake2({
       conversationId,
       conversationStore: options.conversationStore,
-      nowMs: now2(options),
+      nowMs: now3(options),
       state: options.state
     });
     return { status: "no_work" };
   }
   if (lease.status === "active") {
-    const nudgeNowMs = now2(options);
+    const nudgeNowMs = now3(options);
     await ensureConversationWake({
       conversationId,
       conversationStore: options.conversationStore,
@@ -6806,7 +8090,7 @@ async function processConversationWork(message, options) {
     );
     return { status: "active" };
   }
-  const startedAtMs = now2(options);
+  const startedAtMs = now3(options);
   const softYieldDeadlineMs = startedAtMs + (options.softYieldAfterMs ?? CONVERSATION_WORK_SOFT_YIELD_AFTER_MS);
   const leasedWork = await getConversationWorkState2({
     conversationId,
@@ -6840,7 +8124,7 @@ async function processConversationWork(message, options) {
     leaseToken: lease.leaseToken,
     conversationStore: options.conversationStore,
     handle,
-    nowMs: now2(options),
+    nowMs: now3(options),
     state: options.state
   });
   const ack = async () => {
@@ -6849,7 +8133,7 @@ async function processConversationWork(message, options) {
       inboundMessageIds: attemptMessageIds,
       leaseToken: lease.leaseToken,
       conversationStore: options.conversationStore,
-      nowMs: now2(options),
+      nowMs: now3(options),
       state: options.state
     });
     if (!acknowledged) {
@@ -6872,13 +8156,13 @@ async function processConversationWork(message, options) {
     },
     conversationId,
     destination,
-    shouldYield: () => leaseLost || now2(options) >= softYieldDeadlineMs,
+    shouldYield: () => leaseLost || now3(options) >= softYieldDeadlineMs,
     checkIn: async () => {
       const checkedIn = await checkInConversationWork2({
         conversationId,
         leaseToken: lease.leaseToken,
         conversationStore: options.conversationStore,
-        nowMs: now2(options),
+        nowMs: now3(options),
         state: options.state
       });
       if (!checkedIn) {
@@ -6894,7 +8178,7 @@ async function processConversationWork(message, options) {
         conversationId,
         destination,
         leaseToken: lease.leaseToken,
-        nowMs: now2(options),
+        nowMs: now3(options),
         options
       });
       return { status: "lost_lease" };
@@ -6904,13 +8188,13 @@ async function processConversationWork(message, options) {
         conversationId,
         destination,
         leaseToken: lease.leaseToken,
-        nowMs: now2(options),
+        nowMs: now3(options),
         options
       });
       return { status: "lost_lease" };
     }
     if (result.status === "yielded") {
-      const yieldNowMs = now2(options);
+      const yieldNowMs = now3(options);
       const continuationMarked = await requestConversationContinuation2({
         conversationId,
         destination,
@@ -6945,7 +8229,7 @@ async function processConversationWork(message, options) {
         "conversation_work_cooperative_yield",
         { conversationId },
         {
-          "app.worker.elapsed_ms": now2(options) - startedAtMs,
+          "app.worker.elapsed_ms": now3(options) - startedAtMs,
           "app.worker.soft_yield_deadline_ms": softYieldDeadlineMs
         },
         "Conversation work yielded cooperatively"
@@ -6953,7 +8237,7 @@ async function processConversationWork(message, options) {
       return { status: "yielded" };
     }
     if (result.status === "deferred") {
-      const deferredNowMs = now2(options);
+      const deferredNowMs = now3(options);
       const released = await releaseConversationWork2({
         conversationId,
         leaseToken: lease.leaseToken,
@@ -6982,7 +8266,7 @@ async function processConversationWork(message, options) {
       const failure = await recordFailedDeliveryAttempt({
         conversationId,
         leaseToken: lease.leaseToken,
-        nowMs: now2(options),
+        nowMs: now3(options),
         messageIds: attemptMessageIds,
         options
       });
@@ -6991,7 +8275,7 @@ async function processConversationWork(message, options) {
           conversationId,
           leaseToken: lease.leaseToken,
           conversationStore: options.conversationStore,
-          nowMs: now2(options),
+          nowMs: now3(options),
           state: options.state
         });
         return { status: "failed" };
@@ -7001,14 +8285,14 @@ async function processConversationWork(message, options) {
       conversationId,
       leaseToken: lease.leaseToken,
       conversationStore: options.conversationStore,
-      nowMs: now2(options),
+      nowMs: now3(options),
       state: options.state
     });
     if (completion === "lost_lease") {
       return { status: "lost_lease" };
     }
     if (completion === "pending") {
-      const nudgeNowMs = now2(options);
+      const nudgeNowMs = now3(options);
       const wake = await ensureConversationWake({
         conversationId,
         conversationStore: options.conversationStore,
@@ -7027,13 +8311,13 @@ async function processConversationWork(message, options) {
       "conversation_work_completed",
       { conversationId },
       {
-        "app.worker.elapsed_ms": now2(options) - startedAtMs
+        "app.worker.elapsed_ms": now3(options) - startedAtMs
       },
       "Conversation work completed"
     );
     return { status: "completed" };
   } catch (error) {
-    const errorNowMs = now2(options);
+    const errorNowMs = now3(options);
     let recoveryRecorded = false;
     try {
       const failure = attemptMessageIds.length > 0 ? await recordFailedDeliveryAttempt({
@@ -7098,7 +8382,7 @@ async function processConversationWork(message, options) {
         "conversation_work_failed",
         { conversationId },
         {
-          "app.worker.elapsed_ms": now2(options) - startedAtMs
+          "app.worker.elapsed_ms": now3(options) - startedAtMs
         },
         "Conversation work failed"
       );
@@ -7279,14 +8563,14 @@ function registerVercelPluginTaskDevConsumer() {
 }
 
 // src/chat/services/subscribed-decision.ts
-import { z as z3 } from "zod";
-var replyDecisionSchema = z3.object({
-  should_reply: z3.boolean().describe("Whether Junior should respond to this thread message."),
-  should_unsubscribe: z3.boolean().describe(
+import { z as z4 } from "zod";
+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.8;
 var ROUTER_CLASSIFIER_MAX_TOKENS = 240;
@@ -7632,15 +8916,6 @@ var THREAD_OPTOUT_ACK = "Understood. I'll stay out of this thread unless someone
 function shouldRethrowTurnControlError(error) {
   return isCooperativeTurnYieldError(error) || isTurnInputCommitLostError(error) || isTurnInputDeferredError(error) || isProviderRetryError(error);
 }
-async function maybeHandleThreadOptOutDecision(args) {
-  if (!args.decision?.shouldUnsubscribe) {
-    return false;
-  }
-  await args.thread.unsubscribe();
-  await args.beforeFirstResponsePost?.();
-  await args.thread.post(THREAD_OPTOUT_ACK);
-  return true;
-}
 function getQueuedMessages(context, options) {
   return (context?.skipped ?? []).map((message) => {
     const stripped = options.stripLeadingBotMention(message.text, {
@@ -7687,10 +8962,10 @@ function createAcceptedSteeringDrain(hooks, options) {
 function buildLogContext(deps, args) {
   return {
     conversationId: args.threadId ?? args.runId,
-    slackThreadId: args.threadId,
-    slackUserId: args.actorId,
-    slackUserName: args.actorUserName,
-    slackChannelId: args.channelId,
+    messageConversationId: args.threadId,
+    userId: args.actorId,
+    userName: args.actorUserName,
+    destinationName: args.channelId,
     runId: args.runId,
     assistantUserName: deps.assistantUserName,
     modelId: deps.modelId
@@ -7705,6 +8980,16 @@ function isResourceEventNotificationMessage2(message) {
 }
 function createSlackTurnRuntime(deps) {
   const logContext = (args) => buildLogContext(deps, args);
+  const maybeHandleThreadOptOutDecision = async (args) => {
+    if (!args.decision?.shouldUnsubscribe) {
+      return false;
+    }
+    await deps.cancelEventSubscriptions({ conversationId: args.thread.id });
+    await args.thread.unsubscribe();
+    await args.beforeFirstResponsePost?.();
+    await args.thread.post(THREAD_OPTOUT_ACK);
+    return true;
+  };
   const failConversationTurn = async (args) => {
     const conversationId = deps.getThreadId(args.thread, args.message) ?? deps.getRunId(args.thread, args.message);
     if (!conversationId) {
@@ -8399,9 +9684,9 @@ function createSlackTurnRuntime(deps) {
           error,
           "assistant_thread_started_handler_failed",
           {
-            slackThreadId: event.threadId,
-            slackUserId: event.userId,
-            slackChannelId: event.channelId,
+            messageConversationId: event.threadId,
+            userId: event.userId,
+            destinationName: event.channelId,
             assistantUserName: deps.assistantUserName,
             modelId: deps.modelId
           },
@@ -8423,9 +9708,9 @@ function createSlackTurnRuntime(deps) {
           error,
           "assistant_context_changed_handler_failed",
           {
-            slackThreadId: event.threadId,
-            slackUserId: event.userId,
-            slackChannelId: event.channelId,
+            messageConversationId: event.threadId,
+            userId: event.userId,
+            destinationName: event.channelId,
             assistantUserName: deps.assistantUserName,
             modelId: deps.modelId
           },
@@ -8449,9 +9734,9 @@ function createSubscribedReplyPolicy(deps) {
         logWarn(
           "subscribed_message_classifier_failed",
           {
-            slackThreadId: input.context.threadId,
-            slackUserId: input.context.actorId,
-            slackChannelId: input.context.channelId,
+            messageConversationId: input.context.threadId,
+            userId: input.context.actorId,
+            destinationName: input.context.channelId,
             runId: input.context.runId,
             assistantUserName: botConfig.userName,
             modelId: botConfig.fastModelId
@@ -8660,9 +9945,9 @@ async function resolveUserAttachmentsWithDeps(attachments, context, deps) {
         logWarn(
           "attachment_skipped_size_limit",
           {
-            slackThreadId: context.threadId,
-            slackUserId: context.actorId,
-            slackChannelId: context.channelId,
+            messageConversationId: context.threadId,
+            userId: context.actorId,
+            destinationName: context.channelId,
             runId: context.runId,
             assistantUserName: botConfig.userName,
             modelId: standardModelId(botConfig)
@@ -8685,9 +9970,9 @@ async function resolveUserAttachmentsWithDeps(attachments, context, deps) {
         logWarn(
           "image_attachment_processing_failed",
           {
-            slackThreadId: context.threadId,
-            slackUserId: context.actorId,
-            slackChannelId: context.channelId,
+            messageConversationId: context.threadId,
+            userId: context.actorId,
+            destinationName: context.channelId,
             runId: context.runId,
             assistantUserName: botConfig.userName,
             modelId: botConfig.visionModelId ?? standardModelId(botConfig)
@@ -8704,9 +9989,9 @@ async function resolveUserAttachmentsWithDeps(attachments, context, deps) {
       logWarn(
         "attachment_resolution_failed",
         {
-          slackThreadId: context.threadId,
-          slackUserId: context.actorId,
-          slackChannelId: context.channelId,
+          messageConversationId: context.threadId,
+          userId: context.actorId,
+          destinationName: context.channelId,
           runId: context.runId,
           assistantUserName: botConfig.userName,
           modelId: standardModelId(botConfig)
@@ -8754,9 +10039,9 @@ async function summarizeConversationImage(args, deps) {
     logWarn(
       "conversation_image_vision_failed",
       {
-        slackThreadId: args.context.threadId,
-        slackUserId: args.context.actorId,
-        slackChannelId: args.context.channelId,
+        messageConversationId: args.context.threadId,
+        userId: args.context.actorId,
+        destinationName: args.context.channelId,
         runId: args.context.runId,
         assistantUserName: botConfig.userName,
         modelId: visionModelId
@@ -8810,9 +10095,9 @@ async function hydrateConversationVisionContextWithDeps(conversation, context, d
     logWarn(
       "conversation_image_replies_fetch_failed",
       {
-        slackThreadId: context.threadId,
-        slackUserId: context.actorId,
-        slackChannelId: context.channelId,
+        messageConversationId: context.threadId,
+        userId: context.actorId,
+        destinationName: context.channelId,
         runId: context.runId,
         assistantUserName: botConfig.userName,
         modelId: standardModelId(botConfig)
@@ -8877,9 +10162,9 @@ async function hydrateConversationVisionContextWithDeps(conversation, context, d
         logWarn(
           "conversation_image_skipped_size_limit",
           {
-            slackThreadId: context.threadId,
-            slackUserId: context.actorId,
-            slackChannelId: context.channelId,
+            messageConversationId: context.threadId,
+            userId: context.actorId,
+            destinationName: context.channelId,
             runId: context.runId,
             assistantUserName: botConfig.userName,
             modelId: standardModelId(botConfig)
@@ -8904,9 +10189,9 @@ async function hydrateConversationVisionContextWithDeps(conversation, context, d
         logWarn(
           "conversation_image_download_failed",
           {
-            slackThreadId: context.threadId,
-            slackUserId: context.actorId,
-            slackChannelId: context.channelId,
+            messageConversationId: context.threadId,
+            userId: context.actorId,
+            destinationName: context.channelId,
             runId: context.runId,
             assistantUserName: botConfig.userName,
             modelId: standardModelId(botConfig)
@@ -8924,9 +10209,9 @@ async function hydrateConversationVisionContextWithDeps(conversation, context, d
         logWarn(
           "conversation_image_skipped_size_limit",
           {
-            slackThreadId: context.threadId,
-            slackUserId: context.actorId,
-            slackChannelId: context.channelId,
+            messageConversationId: context.threadId,
+            userId: context.actorId,
+            destinationName: context.channelId,
             runId: context.runId,
             assistantUserName: botConfig.userName,
             modelId: standardModelId(botConfig)
@@ -8967,9 +10252,9 @@ async function hydrateConversationVisionContextWithDeps(conversation, context, d
     logInfo(
       "conversation_image_context_hydrated",
       {
-        slackThreadId: context.threadId,
-        slackUserId: context.actorId,
-        slackChannelId: context.channelId,
+        messageConversationId: context.threadId,
+        userId: context.actorId,
+        destinationName: context.channelId,
         runId: context.runId,
         assistantUserName: botConfig.userName,
         modelId: standardModelId(botConfig)
@@ -9052,11 +10337,11 @@ function getSlackMessageTs(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) {
@@ -9092,9 +10377,9 @@ function maybeUpdateAssistantTitle(args) {
       logWarn(
         "thread_title_generation_failed",
         {
-          slackThreadId: args.threadId,
-          slackUserId: args.actorId,
-          slackChannelId: args.channelId,
+          messageConversationId: args.threadId,
+          userId: args.actorId,
+          destinationName: args.channelId,
           runId: args.runId,
           assistantUserName: args.assistantUserName,
           modelId: args.modelId
@@ -9126,9 +10411,9 @@ function maybeUpdateAssistantTitle(args) {
           logError(
             "thread_title_generation_permission_denied",
             {
-              slackThreadId: args.threadId,
-              slackUserId: args.actorId,
-              slackChannelId: args.channelId,
+              messageConversationId: args.threadId,
+              userId: args.actorId,
+              destinationName: args.channelId,
               runId: args.runId,
               assistantUserName: args.assistantUserName,
               modelId: args.modelId
@@ -9140,9 +10425,9 @@ function maybeUpdateAssistantTitle(args) {
           logWarn(
             "thread_title_slack_update_failed",
             {
-              slackThreadId: args.threadId,
-              slackUserId: args.actorId,
-              slackChannelId: args.channelId,
+              messageConversationId: args.threadId,
+              userId: args.actorId,
+              destinationName: args.channelId,
               runId: args.runId,
               assistantUserName: args.assistantUserName,
               modelId: args.modelId
@@ -9374,9 +10659,9 @@ function createReplyToThread(deps) {
       "chat.reply",
       {
         conversationId,
-        slackThreadId: threadId,
-        slackUserId: message.author.userId,
-        slackChannelId: channelId,
+        messageConversationId: threadId,
+        userId: message.author.userId,
+        destinationName: channelId,
         runId,
         assistantUserName: botConfig.userName,
         modelId: standardModelId(botConfig)
@@ -9432,9 +10717,9 @@ function createReplyToThread(deps) {
         const turnId = buildDeterministicTurnId(message.id);
         const turnTraceContext = {
           conversationId,
-          slackThreadId: threadId,
-          slackUserId: message.author.userId,
-          slackChannelId: channelId,
+          messageConversationId: threadId,
+          userId: message.author.userId,
+          destinationName: channelId,
           runId,
           assistantUserName: botConfig.userName,
           modelId: standardModelId(botConfig)
@@ -9455,23 +10740,16 @@ function createReplyToThread(deps) {
             actor.userId,
             providerDisplayName
           );
-          const footer = buildSlackReplyFooter({ conversationId });
           try {
+            await beforeFirstResponsePost();
             if (channelId && threadTs) {
-              await postSlackApiReplyPosts({
-                beforePost: beforeFirstResponsePost,
+              await sendSlackReply({
                 channelId,
-                threadTs,
-                posts: [
-                  {
-                    text,
-                    stage: "thread_reply"
-                  }
-                ],
-                footer
+                conversationId,
+                text,
+                threadTs
               });
             } else {
-              await beforeFirstResponsePost();
               await thread.post(buildSlackOutputMessage(text));
             }
           } catch (error) {
@@ -9767,7 +11045,7 @@ function createReplyToThread(deps) {
           });
         }
         if (actor?.userName) {
-          setTags({ slackUserName: actor.userName });
+          setTags({ userName: actor.userName });
         }
         const turnAttachments = collectTurnAttachments(
           message,
@@ -9793,32 +11071,6 @@ function createReplyToThread(deps) {
         const compactingStatus = {
           text: "Compacting context"
         };
-        const postThreadReply = async (payload, stage) => {
-          await beforeFirstResponsePost();
-          try {
-            return await thread.post(payload);
-          } catch (error) {
-            if (isRetryableSlackPostError(error)) {
-              throw new RetryableDeliveryError(error);
-            }
-            const eventId = logException(
-              error,
-              "slack_thread_post_failed",
-              turnTraceContext,
-              {
-                "app.slack.reply_stage": stage,
-                ...messageTs ? { "messaging.message.id": messageTs } : {},
-                ...getSlackErrorObservabilityAttributes(error)
-              },
-              "Failed to post Slack thread reply"
-            );
-            throw new ConversationTurnBoundaryError({
-              cause: error,
-              ...eventId ? { eventId } : {},
-              failureCode: "delivery_failed"
-            });
-          }
-        };
         let persistedAtLeastOnce = false;
         let shouldPersistFailureState = true;
         let runResultHandled = false;
@@ -9838,18 +11090,45 @@ function createReplyToThread(deps) {
           turnCompletionNotified = true;
         };
         const deliverAssistantMessage = async (assistantMessage) => {
-          const posts = planSlackAssistantMessagePosts(assistantMessage.text);
-          if (posts.length === 0) {
+          if (!assistantMessage.text.trim()) {
             return;
           }
           boundaryFailureCode = "delivery_failed";
           let slackTs;
-          for (const post of posts) {
-            const sentMessage = await postThreadReply(
-              buildSlackOutputMessage(post.text),
-              post.stage
+          await beforeFirstResponsePost();
+          try {
+            if (channelId && threadTs && thread.adapter.name === "slack") {
+              slackTs = await sendSlackReply({
+                channelId,
+                conversationId,
+                text: assistantMessage.text,
+                threadTs
+              });
+            } else {
+              for (const text of splitSlackReplyText(assistantMessage.text)) {
+                slackTs = (await thread.post(buildSlackOutputMessage(text))).id;
+              }
+            }
+          } catch (error) {
+            if (isRetryableSlackPostError(error)) {
+              throw new RetryableDeliveryError(error);
+            }
+            const eventId = logException(
+              error,
+              "slack_thread_post_failed",
+              turnTraceContext,
+              {
+                "app.slack.reply_stage": "thread_reply",
+                ...messageTs ? { "messaging.message.id": messageTs } : {},
+                ...getSlackErrorObservabilityAttributes(error)
+              },
+              "Failed to post Slack thread reply"
             );
-            slackTs = sentMessage.id;
+            throw new ConversationTurnBoundaryError({
+              cause: error,
+              ...eventId ? { eventId } : {},
+              failureCode: "delivery_failed"
+            });
           }
           assistantMessageDelivered = true;
           const recordedMessageId = recordDeliveredAssistantMessage({
@@ -10181,9 +11460,9 @@ function createReplyToThread(deps) {
           }
           let reply = outcome.result;
           const diagnosticsContext = {
-            slackThreadId: threadId,
-            slackUserId: message.author.userId,
-            slackChannelId: channelId,
+            messageConversationId: threadId,
+            userId: message.author.userId,
+            destinationName: channelId,
             runId,
             assistantUserName: botConfig.userName,
             modelId: reply.diagnostics.modelId
@@ -10233,13 +11512,6 @@ function createReplyToThread(deps) {
                 sliceId: 1,
                 messages: reply.piMessages,
                 modelId: reply.diagnostics.modelId,
-                logContext: {
-                  threadId,
-                  actorId: slackActorId,
-                  channelId,
-                  runId,
-                  assistantUserName: botConfig.userName
-                },
                 actor: executionActor,
                 surface: "slack"
               });
@@ -10526,6 +11798,11 @@ async function refreshAssistantThreadContext(event) {
 
 // src/chat/runtime/conversation-message.ts
 var NON_TEXT_MESSAGE_TEXT = "[non-text message]";
+function resourceEventType(entry) {
+  if (!entry.raw || typeof entry.raw !== "object") return void 0;
+  const raw = entry.raw;
+  return raw.event_type === "resource_event" && typeof raw.resource_event_type === "string" ? raw.resource_event_type : void 0;
+}
 function resolveMessageText(args) {
   const text = normalizeConversationText(args.text);
   return text || NON_TEXT_MESSAGE_TEXT;
@@ -10550,6 +11827,7 @@ function toConversationMessage(args) {
     },
     meta: {
       attachmentCount: args.entry.attachments.length,
+      eventType: resourceEventType(args.entry),
       explicitMention: args.explicitMention,
       imageAttachmentCount: imageAttachmentCount > 0 ? imageAttachmentCount : void 0,
       imagesHydrated: !messageHasPotentialImageAttachment,
@@ -10766,6 +12044,7 @@ function createSlackRuntime(options) {
   });
   return createSlackTurnRuntime({
     assistantUserName: botConfig.userName,
+    cancelEventSubscriptions: cancelSubscriptions,
     modelId: standardModelId(botConfig),
     now: options.now ?? (() => Date.now()),
     getThreadId,
@@ -11155,7 +12434,7 @@ async function continueSlackAgentRun(payload, options) {
               }
             }
           },
-          onSuccess: async (reply) => {
+          commitResult: async (reply) => {
             await persistCompletedReplyState2({
               sessionRecord: activeSessionRecord,
               reply
@@ -11482,6 +12761,9 @@ function renderResourceEventNotificationText(subscription, event) {
     "Handling:",
     "- This is a subscribed conversation update, not a user-authored command.",
     "- Use the subscription intent to decide whether this event warrants action or a visible reply. Otherwise, stay silent.",
+    "- Treat the trusted summary as sufficient evidence for the facts it reports. Do not verify or expand those facts with tools.",
+    "- Use tools only when the subscription intent explicitly requires missing details or an action.",
+    "- When replying, state what changed and the useful next step, if any.",
     "",
     "Subscription:",
     `- resource: ${subscription.label}`,
@@ -11988,6 +13270,7 @@ async function createApp(options) {
   return app;
 }
 export {
+  JUNIOR_VERSION,
   createApp,
   defineJuniorPlugins
 };