@sentry/junior 0.108.0 → 0.110.0

package/dist/app.js

@@ -6,45 +6,23 @@ import {
   processPluginTask,
   requireTurnFailureEventId,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-A5CO2EHL.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-TWINAEZQ.js";
+} from "./chunk-3UBQI73J.js";
 import {
   GET,
   buildSentryConversationUrl,
   conversationVisibilityFromSlackChannelType,
-  resolveRootVisibility,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext
-} from "./chunk-XKB7LGIW.js";
-import "./chunk-CEA3A3UA.js";
+} from "./chunk-3S7YYHBI.js";
+import "./chunk-2ZTTXTSZ.js";
 import {
+  ConversationQueueMessageRejectedError,
+  conversationQueueMessageSchema,
   getVercelConversationWorkQueue,
+  isConversationQueueMessageRejectedError,
   resolveConversationWorkQueueTopic,
   verifyConversationQueueMessage
-} from "./chunk-2XXEKR44.js";
+} from "./chunk-MIAKQNYX.js";
 import {
   PLUGIN_TASK_QUEUE_TOPIC,
   createVercelQueueClient,
@@ -53,7 +31,7 @@ import {
 import {
   validatePluginEgressCredentialHooks,
   validatePluginRegistrations
-} from "./chunk-DY7TRYB5.js";
+} from "./chunk-Y5FK3CNG.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
@@ -106,21 +84,28 @@ import {
   splitSlackReplyText,
   startOAuthFlow,
   truncateStatusText
-} from "./chunk-KPMPQ6AA.js";
+} from "./chunk-RHHRKSPI.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,
@@ -135,6 +120,9 @@ import {
   isPendingAuthLatestRequest,
   isTurnInputCommitLostError,
   isTurnInputDeferredError,
+  listAgentTurnSessionSummariesForConversation,
+  loadConversationProjection,
+  loadProjection,
   markConversationMessage,
   markTurnClosed,
   markTurnFailed,
@@ -148,33 +136,23 @@ import {
   persistThreadStateById,
   persistWithRetry,
   persistYieldSessionRecord,
+  recordAgentTurnSessionSummary,
+  recordAuthorizationCompleted,
   recordDeliveredAssistantMessage,
   startActiveTurn,
   turnHasReply,
   updateConversationStats,
   upsertConversationMessage
-} from "./chunk-3RGQLX2F.js";
-import {
-  JUNIOR_THREAD_STATE_TTL_MS,
-  abandonAgentTurnSessionRecord,
-  coerceThreadConversationState,
-  commitMessages,
-  failAgentTurnSessionRecord,
-  getAgentTurnSessionRecord,
-  getAgentTurnSessionRecordForResume,
-  listAgentTurnSessionSummariesForConversation,
-  loadConversationProjection,
-  loadProjection,
-  recordAgentTurnSessionSummary,
-  recordAuthorizationCompleted
-} from "./chunk-J3B3FPP2.js";
-import "./chunk-B5I5LMSP.js";
+} from "./chunk-C5XAFTHY.js";
+import "./chunk-W6RJZG7F.js";
 import "./chunk-MU6HHZEN.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
 import {
   bindScheduledTaskCredentialSubject,
   bindSlackDirectCredentialSubject,
+  createPluginLogger,
+  createPluginState,
   getDashboardConversationLink,
   getPluginApiRoutes,
   getPluginRoutes,
@@ -185,16 +163,12 @@ import {
   validatePlugins,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-UD6THJ2I.js";
-import {
-  createPluginLogger,
-  createPluginState
-} from "./chunk-AHJR2IFF.js";
-import "./chunk-G3E7SCME.js";
+} from "./chunk-2T7TIEXI.js";
 import {
   acquireActiveLock,
+  getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-H3QYZL7K.js";
+} from "./chunk-GK47NBDE.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -205,18 +179,25 @@ import {
   normalizeSlackConversationId,
   runWithSlackInstallationToken,
   runWithWorkspaceTeamId
-} from "./chunk-VH6KWKG2.js";
+} from "./chunk-L5XQPJ7T.js";
 import {
   contextProvenance,
+  createSlackDestination,
+  destinationKey,
   getConversationEventStore,
   getConversationStore,
   getDb,
   getSqlExecutor,
   instructionProvenanceFor,
-  juniorConversationEvents,
-  juniorConversations,
+  parseDestination,
+  requireSlackDestination,
+  sameDestination,
   withConversationEventLock
-} from "./chunk-TE4QHJH4.js";
+} from "./chunk-4QU44P7Q.js";
+import {
+  juniorConversationEvents,
+  juniorConversations
+} from "./chunk-JQFJO5WH.js";
 import {
   sleep
 } from "./chunk-4ZNGQH7C.js";
@@ -240,7 +221,7 @@ import {
   standardModelId,
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages
-} from "./chunk-SS67LUOK.js";
+} from "./chunk-WNOVRQ67.js";
 import {
   juniorDestinations
 } from "./chunk-VFUK3X5B.js";
@@ -249,32 +230,28 @@ import {
   readSlackRawMessageContext,
   resolveSlackChannelIdFromMessage,
   resolveSlackChannelIdFromThreadId
-} from "./chunk-RT5BUHR5.js";
-import {
-  createSlackDestination,
-  destinationKey,
-  parseDestination,
-  requireSlackDestination,
-  sameDestination
-} from "./chunk-B7PUBQQM.js";
+} from "./chunk-6Y5L4BOM.js";
 import {
   discoverSkills
-} from "./chunk-YT72TOEK.js";
+} from "./chunk-SBOBTS27.js";
+import {
+  pluginCatalogRuntime
+} from "./chunk-3TV7OEHL.js";
 import {
   buildOAuthTokenRequest,
   credentialSubjectSchema,
   hasRequiredOAuthScope,
-  parseOAuthTokenResponse,
-  pluginCatalogRuntime
-} from "./chunk-YIPD3L6L.js";
+  parseOAuthTokenResponse
+} from "./chunk-Y3H2DN6F.js";
 import {
   createActor,
   createSlackActor,
   createSlackResumeActor,
   isActorUserId,
   isUserActor,
-  parseActorUserId
-} from "./chunk-VIXFG2VC.js";
+  parseActorUserId,
+  parseStoredSlackActor
+} from "./chunk-C4MZ3GP5.js";
 import {
   buildTurnFailureResponse,
   createChatSdkLogger,
@@ -290,22 +267,27 @@ import {
   setTags,
   withContext,
   withSpan
-} from "./chunk-O24R4DCK.js";
+} from "./chunk-IYKPU7H6.js";
 import {
+  isRecord,
+  parseSlackChannelId,
+  parseSlackMessageTs,
+  toOptionalNumber,
   toOptionalString
-} from "./chunk-OB42YVAE.js";
+} from "./chunk-42WRQLJ6.js";
 import {
   continueTrace
 } from "./chunk-6GWA276C.js";
 import "./chunk-B3IT5END.js";
-import {
-  JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE,
-  parseSlackChannelId,
-  parseSlackMessageTs
-} from "./chunk-7FBGKXPE.js";
 import {
   homeDir
 } from "./chunk-3V7OFJZC.js";
+import {
+  JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE
+} from "./chunk-W75ZPAGG.js";
+import {
+  JUNIOR_VERSION
+} from "./chunk-ZKIOWEFL.js";
 import "./chunk-MLKGABMK.js";
 
 // src/app.ts
@@ -353,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
@@ -927,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,
@@ -1018,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)) {
@@ -1222,145 +1177,1266 @@ 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) {
+      if (failure) {
+        await turnLifecycle.fail({
+          conversationId,
+          turnId,
+          createdAtMs: Date.now(),
+          failureCode: "model_execution_failed",
+          ...modelFailureEventId ? { eventId: modelFailureEventId } : {}
+        });
+      } else {
+        await turnLifecycle.complete({
+          conversationId,
+          turnId,
+          createdAtMs: Date.now(),
+          outcome: assistantMessageDelivered ? "success" : "no_reply"
+        });
+      }
+      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"
+        );
+      }
+    }
+  } 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: []
+      };
     }
-    if (statePersisted) {
-      if (failure) {
-        await turnLifecycle.fail({
-          conversationId,
-          turnId,
-          createdAtMs: Date.now(),
-          failureCode: "model_execution_failed",
-          ...modelFailureEventId ? { eventId: modelFailureEventId } : {}
-        });
-      } else {
-        await turnLifecycle.complete({
-          conversationId,
-          turnId,
-          createdAtMs: Date.now(),
-          outcome: assistantMessageDelivered ? "success" : "no_reply"
-        });
-      }
-      lifecycleTerminalized = true;
+    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: []
+      };
     }
-    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"
-        );
+    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;
       }
-    }
-  } catch (error) {
-    if (error instanceof AuthorizationFlowDisabledError) {
-      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: `Dispatch requires ${error.provider} authorization.`
-      });
-      return;
+      pendingMessages2.push(attempted);
     }
-    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;
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          pendingMessages: pendingMessages2
+        },
+        nowMs
+      )
+    );
+    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";
     }
-    const eventId = logException(
-      error,
-      "agent_dispatch_run_failed",
-      {
-        ...logContext,
-        modelId: standardModelId(botConfig)
-      },
-      {},
-      "Agent dispatch failed"
+    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
+      )
     );
-    if (lifecycleStarted && !lifecycleTerminalized) {
-      await turnLifecycle.fail({
-        conversationId,
-        turnId,
-        createdAtMs: Date.now(),
-        failureCode,
-        ...eventId ? { eventId } : {}
-      });
-      lifecycleTerminalized = true;
+    return runnable ? "pending" : "failed";
+  });
+}
+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 markDispatch({
-      dispatch,
-      status: "failed",
-      errorMessage: error instanceof Error ? error.message : String(error)
-    });
-  } finally {
-    await stateAdapter.releaseLock(destinationLock);
-  }
+    await writeConversation(
+      state,
+      lock,
+      withExecutionUpdate(
+        current,
+        {
+          ...current.execution,
+          lease: void 0,
+          status: "pending"
+        },
+        nowMs
+      )
+    );
+    return true;
+  });
 }
-
-// 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 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) {
@@ -1373,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) {
@@ -1414,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
@@ -1430,8 +2506,7 @@ async function ensureConversationWake(args) {
   }
   const queueResult = await args.queue.send(
     {
-      conversationId: args.conversationId,
-      destination: conversation.destination
+      conversationId: args.conversationId
     },
     {
       delayMs: args.delayMs,
@@ -1447,7 +2522,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,
@@ -2108,7 +3183,47 @@ async function GET2(request, waitUntil, options = {}) {
 import { timingSafeEqual as timingSafeEqual3 } from "crypto";
 
 // src/chat/conversations/sql/purge.ts
-import { and, asc, eq, inArray, isNull, sql } from "drizzle-orm";
+import { and, asc, eq as eq2, inArray, isNull, sql } from "drizzle-orm";
+
+// src/chat/conversations/sql/privacy.ts
+import { eq } from "drizzle-orm";
+import { alias } from "drizzle-orm/pg-core";
+var privacyRoot = alias(juniorConversations, "privacy_root");
+async function readRootCandidate(executor, conversationId) {
+  const rows = await executor.db().select({
+    requestedConversationId: juniorConversations.conversationId,
+    requestedParentConversationId: juniorConversations.parentConversationId,
+    requestedRootConversationId: juniorConversations.rootConversationId,
+    rootConversationId: privacyRoot.conversationId,
+    rootDestinationId: privacyRoot.destinationId,
+    rootParentConversationId: privacyRoot.parentConversationId,
+    rootRootConversationId: privacyRoot.rootConversationId
+  }).from(juniorConversations).leftJoin(
+    privacyRoot,
+    eq(privacyRoot.conversationId, juniorConversations.rootConversationId)
+  ).where(eq(juniorConversations.conversationId, conversationId));
+  const row = rows[0];
+  return row?.requestedRootConversationId !== null && (row?.requestedParentConversationId !== null || row?.requestedRootConversationId === row?.requestedConversationId) && row?.rootConversationId === row.requestedRootConversationId && row.rootRootConversationId === row.rootConversationId && row.rootParentConversationId === null && row.rootDestinationId !== null ? {
+    destinationId: row.rootDestinationId,
+    rootConversationId: row.rootConversationId
+  } : void 0;
+}
+async function readCandidateVisibility(executor, candidate) {
+  const destinations = await executor.db().select({ visibility: juniorDestinations.visibility }).from(juniorDestinations).where(eq(juniorDestinations.id, candidate.destinationId)).for("share");
+  return {
+    rootConversationId: candidate.rootConversationId,
+    visibility: destinations[0]?.visibility ?? null
+  };
+}
+async function resolveRootVisibility(executor, conversationId) {
+  const candidate = await readRootCandidate(executor, conversationId);
+  if (!candidate) {
+    return { rootConversationId: conversationId, visibility: null };
+  }
+  return readCandidateVisibility(executor, candidate);
+}
+
+// src/chat/conversations/sql/purge.ts
 async function discoverConversationTree(executor, root) {
   const all = /* @__PURE__ */ new Map([
     [root.conversationId, root]
@@ -2177,7 +3292,7 @@ async function selectExpiredRoots(executor, args) {
     visibility: juniorDestinations.visibility
   }).from(juniorConversations).leftJoin(
     juniorDestinations,
-    eq(juniorDestinations.id, juniorConversations.destinationId)
+    eq2(juniorDestinations.id, juniorConversations.destinationId)
   ).where(
     and(
       isNull(juniorConversations.parentConversationId),
@@ -2198,7 +3313,7 @@ async function purgeConversationTree(executor, args) {
     const initialRoots = await executor.db().select({
       conversationId: juniorConversations.conversationId,
       parentConversationId: juniorConversations.parentConversationId
-    }).from(juniorConversations).where(eq(juniorConversations.conversationId, args.rootConversationId));
+    }).from(juniorConversations).where(eq2(juniorConversations.conversationId, args.rootConversationId));
     const initialRoot = initialRoots[0];
     if (!initialRoot || args.retention && initialRoot.parentConversationId !== null) {
       return { purged: false, conversations: 0 };
@@ -2220,14 +3335,14 @@ async function purgeConversationTree(executor, args) {
           destinationId: juniorConversations.destinationId,
           parentConversationId: juniorConversations.parentConversationId
         }).from(juniorConversations).where(
-          eq(juniorConversations.conversationId, args.rootConversationId)
+          eq2(juniorConversations.conversationId, args.rootConversationId)
         ).for("update");
         const root = roots[0];
         if (!root || args.retention && root.parentConversationId !== null) {
           return { purged: false, conversations: 0 };
         }
         const resolvedScrubMetadata = args.scrubMetadataFromRootVisibility ? (await resolveRootVisibility(executor, args.rootConversationId)).visibility !== "public" : args.scrubMetadata;
-        const destinations = root.destinationId ? await executor.db().select({ visibility: juniorDestinations.visibility }).from(juniorDestinations).where(eq(juniorDestinations.id, root.destinationId)).for("share") : [];
+        const destinations = root.destinationId ? await executor.db().select({ visibility: juniorDestinations.visibility }).from(juniorDestinations).where(eq2(juniorDestinations.id, root.destinationId)).for("share") : [];
         const isPublic = destinations[0]?.visibility === "public";
         const ids = tree.map((conversation) => conversation.conversationId);
         if (args.retention) {
@@ -2445,7 +3560,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;
@@ -2509,7 +3624,7 @@ function createAssistantStatusScheduler(args) {
     }
     currentVisibleStatus = text;
     currentLoadingMessages = nextLoadingMessages;
-    lastStatusAt = now3();
+    lastStatusAt = now4();
     scheduleRotation();
     await enqueueStatusUpdate(async () => {
       await args.sendStatus(text, nextLoadingMessages);
@@ -2596,7 +3711,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,
@@ -2994,19 +4109,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;
     }
@@ -3054,10 +4164,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)
   };
@@ -3321,18 +4431,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)) {
@@ -3459,16 +4569,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,
@@ -3564,9 +4668,6 @@ async function resumeSlackTurn(args) {
     try {
       await deferredPauseHandler();
       if (deferredAuthInfo) {
-        const footer = buildSlackReplyFooter({
-          conversationId: runArgs.conversationId
-        });
         await postSlackMessageBestEffort(
           runArgs.channelId,
           runArgs.threadTs,
@@ -3574,7 +4675,7 @@ async function resumeSlackTurn(args) {
             deferredAuthInfo.actorId,
             deferredAuthInfo.providerDisplayName
           ),
-          footer
+          runArgs.conversationId
         );
       }
       return true;
@@ -3977,7 +5078,7 @@ async function resumeAuthorizedMcpTurn(args) {
             }
           }
         },
-        onSuccess: async (reply) => {
+        commitResult: async (reply) => {
           await persistCompletedReplyState(
             authSession.channelId,
             authSession.threadTs,
@@ -4575,7 +5676,7 @@ async function resumeOAuthSessionRecordTurn(stored, options) {
             }
           }
         },
-        onSuccess: async (reply) => {
+        commitResult: async (reply) => {
           logInfo(
             "oauth_callback_resume_complete",
             {},
@@ -4862,9 +5963,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) {
@@ -4889,7 +5990,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;
 }
@@ -5239,7 +6340,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;
@@ -5248,7 +6349,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
   });
@@ -5716,6 +6817,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"
@@ -5741,6 +6843,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,
@@ -5781,7 +6884,7 @@ function createSlackResourceEventInboundMessage(input) {
     }
   };
 }
-function getConnectedState2(stateAdapter) {
+function getConnectedState3(stateAdapter) {
   return stateAdapter ?? getStateAdapter();
 }
 function parseSlackMetadata(value) {
@@ -5883,7 +6986,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] }
@@ -6235,7 +7338,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`
   );
@@ -6457,7 +7560,7 @@ async function handleSlackEvent(args) {
       );
     } catch (error) {
       logException(error, "slack_app_home_publish_failed", {
-        slackUserId: userId
+        userId
       });
     }
   }
@@ -6568,7 +7671,7 @@ async function handleSlashCommandForm(args) {
   await withSpan(
     "chat.slash_command",
     "chat.slash_command",
-    { slackUserId: userId },
+    { userId },
     async () => {
       await handleSlashCommand({
         adapter: args.adapter,
@@ -6607,7 +7710,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);
@@ -6615,7 +7718,7 @@ async function handleInteractivePayload(args) {
         logException(
           error,
           "app_home_disconnect_unlink_failed",
-          { slackUserId: userId },
+          { userId },
           { "app.credential.provider": provider }
         );
       }
@@ -6625,7 +7728,7 @@ async function handleInteractivePayload(args) {
         logException(
           error,
           "app_home_disconnect_publish_failed",
-          { slackUserId: userId },
+          { userId },
           { "app.credential.provider": provider }
         );
       }
@@ -6668,7 +7771,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
         });
       })
     );
@@ -6698,7 +7801,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
       });
     })
   );
@@ -6830,25 +7933,10 @@ import {
   registerDevConsumer
 } from "@vercel/queue";
 
-// src/chat/task-execution/queue.ts
-var ConversationQueueMessageRejectedError = class extends Error {
-  conversationId;
-  reason;
-  constructor(reason, message, options = {}) {
-    super(message);
-    this.name = "ConversationQueueMessageRejectedError";
-    this.reason = reason;
-    this.conversationId = options.conversationId;
-  }
-};
-function isConversationQueueMessageRejectedError(error) {
-  return error instanceof ConversationQueueMessageRejectedError;
-}
-
 // 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) {
@@ -6919,7 +8007,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,
@@ -6975,16 +8063,16 @@ async function processConversationWork(message, options) {
       await clearConsumedConversationWake2({
         conversationId,
         conversationStore: options.conversationStore,
-        nowMs: now2(options),
+        nowMs: now3(options),
         state: options.state
       });
     }
     return { status: "no_work" };
   }
-  if (!initial.destination || !sameDestination(initial.destination, message.destination)) {
+  if (!initial.destination) {
     throw new ConversationQueueMessageRejectedError(
-      "destination_mismatch",
-      `Conversation work queue destination changed for ${conversationId}`,
+      "invalid_record",
+      `Conversation work is missing destination context for ${conversationId}`,
       { conversationId }
     );
   }
@@ -6992,20 +8080,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,
@@ -7026,7 +8114,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,
@@ -7060,7 +8148,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 () => {
@@ -7069,7 +8157,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) {
@@ -7092,13 +8180,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) {
@@ -7114,7 +8202,7 @@ async function processConversationWork(message, options) {
         conversationId,
         destination,
         leaseToken: lease.leaseToken,
-        nowMs: now2(options),
+        nowMs: now3(options),
         options
       });
       return { status: "lost_lease" };
@@ -7124,13 +8212,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,
@@ -7165,7 +8253,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"
@@ -7173,7 +8261,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,
@@ -7202,7 +8290,7 @@ async function processConversationWork(message, options) {
       const failure = await recordFailedDeliveryAttempt({
         conversationId,
         leaseToken: lease.leaseToken,
-        nowMs: now2(options),
+        nowMs: now3(options),
         messageIds: attemptMessageIds,
         options
       });
@@ -7211,7 +8299,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" };
@@ -7221,14 +8309,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,
@@ -7247,13 +8335,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({
@@ -7318,7 +8406,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"
       );
@@ -7336,18 +8424,11 @@ async function processConversationWork(message, options) {
 var CONVERSATION_WORK_VISIBILITY_TIMEOUT_BUFFER_SECONDS = 30;
 var CONVERSATION_WORK_DEV_CONSUMER_GROUP = "junior_conversation_work_dev";
 function parseConversationQueueMessage(message) {
-  const destination = parseDestination(
-    message?.destination
-  );
-  if (!message || typeof message !== "object" || typeof message.conversationId !== "string" || !message.conversationId.trim() || !destination) {
-    throw new Error(
-      "Conversation queue message is missing destination context"
-    );
+  const parsed = conversationQueueMessageSchema.safeParse(message);
+  if (!parsed.success) {
+    throw new Error("Conversation queue message is malformed");
   }
-  return {
-    conversationId: message.conversationId,
-    destination
-  };
+  return parsed.data;
 }
 function resolveConversationWorkVisibilityTimeoutSeconds(functionMaxDurationSeconds = getChatConfig().functionMaxDurationSeconds) {
   return functionMaxDurationSeconds + CONVERSATION_WORK_VISIBILITY_TIMEOUT_BUFFER_SECONDS;
@@ -7898,10 +8979,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
@@ -8620,9 +9701,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
           },
@@ -8644,9 +9725,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
           },
@@ -8670,9 +9751,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
@@ -8881,9 +9962,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)
@@ -8906,9 +9987,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)
@@ -8925,9 +10006,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)
@@ -8975,9 +10056,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
@@ -9031,9 +10112,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)
@@ -9098,9 +10179,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)
@@ -9125,9 +10206,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)
@@ -9145,9 +10226,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)
@@ -9188,9 +10269,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)
@@ -9313,9 +10394,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
@@ -9347,9 +10428,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
@@ -9361,9 +10442,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
@@ -9595,9 +10676,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)
@@ -9653,9 +10734,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)
@@ -9676,23 +10757,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) {
@@ -9988,7 +11062,7 @@ function createReplyToThread(deps) {
           });
         }
         if (actor?.userName) {
-          setTags({ slackUserName: actor.userName });
+          setTags({ userName: actor.userName });
         }
         const turnAttachments = collectTurnAttachments(
           message,
@@ -10014,32 +11088,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;
@@ -10059,18 +11107,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({
@@ -10402,9 +11477,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
@@ -10454,13 +11529,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"
               });
@@ -10747,6 +11815,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;
@@ -10771,6 +11844,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,
@@ -11377,7 +12451,7 @@ async function continueSlackAgentRun(payload, options) {
               }
             }
           },
-          onSuccess: async (reply) => {
+          commitResult: async (reply) => {
             await persistCompletedReplyState2({
               sessionRecord: activeSessionRecord,
               reply
@@ -11704,6 +12778,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}`,
@@ -12210,6 +13287,7 @@ async function createApp(options) {
   return app;
 }
 export {
+  JUNIOR_VERSION,
   createApp,
   defineJuniorPlugins
 };