@sentry/junior 0.107.1 → 0.108.0

package/dist/{agent-hooks-ICPIJAFY.js → agent-hooks-NU5HK3PS.js}

@@ -11,12 +11,12 @@ import {
   getPlugins,
   setPlugins,
   validatePlugins
-} from "./chunk-RMVOAJRL.js";
-import "./chunk-AUUOHQAT.js";
+} from "./chunk-UD6THJ2I.js";
+import "./chunk-AHJR2IFF.js";
 import "./chunk-G3E7SCME.js";
-import "./chunk-B2Z2H66D.js";
+import "./chunk-H3QYZL7K.js";
 import "./chunk-VH6KWKG2.js";
-import "./chunk-NVOTGWYX.js";
+import "./chunk-TE4QHJH4.js";
 import "./chunk-4ZNGQH7C.js";
 import "./chunk-SS67LUOK.js";
 import "./chunk-VFUK3X5B.js";

package/dist/api/conversations/list.d.ts

@@ -84,6 +84,7 @@ declare function conversationRows(db: JuniorDatabase, limit: number, actorEmail?
     identityProvider: string | null;
     identitySubjectId: string | null;
     identityTenantId: string | null;
+    userDisplayName: string | null;
 }[]>;
 type ConversationRow = Awaited<ReturnType<typeof conversationRows>>[number];
 /** Read one normalized conversation record directly from its SQL row. */

package/dist/api.js

@@ -19,7 +19,7 @@ import {
   readConversationEventPrivacySnapshot,
   readHealthReport,
   resolveSlackConversationContextFromThreadId
-} from "./chunk-IGHMVDWI.js";
+} from "./chunk-XKB7LGIW.js";
 import {
   pluginOperationalReportFeedSchema,
   pluginReportsSchema,
@@ -40,7 +40,7 @@ import {
   juniorConversations,
   juniorIdentities,
   juniorUsers
-} from "./chunk-NVOTGWYX.js";
+} from "./chunk-TE4QHJH4.js";
 import "./chunk-4ZNGQH7C.js";
 import "./chunk-SS67LUOK.js";
 import {
@@ -516,14 +516,15 @@ async function conversationRows(db, limit, actorEmail) {
     identityHandle: juniorIdentities.handle,
     identityProvider: juniorIdentities.provider,
     identitySubjectId: juniorIdentities.providerSubjectId,
-    identityTenantId: juniorIdentities.providerTenantId
+    identityTenantId: juniorIdentities.providerTenantId,
+    userDisplayName: juniorUsers.displayName
   }).from(juniorConversations).leftJoin(
     juniorDestinations,
     eq3(juniorDestinations.id, juniorConversations.destinationId)
   ).leftJoin(
     juniorIdentities,
     eq3(juniorIdentities.id, juniorConversations.actorIdentityId)
-  ).where(
+  ).leftJoin(juniorUsers, eq3(juniorUsers.id, juniorIdentities.userId)).where(
     and3(
       isNull(juniorConversations.parentConversationId),
       isNull(juniorConversations.archivedAt),
@@ -539,10 +540,11 @@ async function conversationRows(db, limit, actorEmail) {
 }
 function conversationFromRow(row) {
   const value = row.conversation;
+  const actorFullName = row.userDisplayName?.trim() ? row.userDisplayName : row.identityDisplayName;
   const actor = row.identityProvider === "slack" ? {
     platform: "slack",
     ...row.identityEmail ? { email: row.identityEmail } : {},
-    ...row.identityDisplayName ? { fullName: row.identityDisplayName } : {},
+    ...actorFullName ? { fullName: actorFullName } : {},
     ...row.identitySubjectId ? { slackUserId: row.identitySubjectId } : {},
     ...row.identityHandle ? { slackUserName: row.identityHandle } : {},
     ...row.identityTenantId ? { teamId: row.identityTenantId } : {}
@@ -580,14 +582,15 @@ async function readConversationRecordFromSql(conversationId) {
     identityHandle: juniorIdentities.handle,
     identityProvider: juniorIdentities.provider,
     identitySubjectId: juniorIdentities.providerSubjectId,
-    identityTenantId: juniorIdentities.providerTenantId
+    identityTenantId: juniorIdentities.providerTenantId,
+    userDisplayName: juniorUsers.displayName
   }).from(juniorConversations).leftJoin(
     juniorDestinations,
     eq3(juniorDestinations.id, juniorConversations.destinationId)
   ).leftJoin(
     juniorIdentities,
     eq3(juniorIdentities.id, juniorConversations.actorIdentityId)
-  ).where(eq3(juniorConversations.conversationId, conversationId)).limit(1);
+  ).leftJoin(juniorUsers, eq3(juniorUsers.id, juniorIdentities.userId)).where(eq3(juniorConversations.conversationId, conversationId)).limit(1);
   const row = rows[0];
   return row ? {
     conversation: conversationFromRow(row),
@@ -1848,7 +1851,7 @@ async function readRuntimeInfoReport() {
 }
 async function readPluginOperationalReportFeed() {
   const nowMs = Date.now();
-  const { getPluginOperationalReports } = await import("./agent-hooks-ICPIJAFY.js");
+  const { getPluginOperationalReports } = await import("./agent-hooks-NU5HK3PS.js");
   return pluginOperationalReportFeedSchema.parse({
     source: "plugins",
     generatedAt: new Date(nowMs).toISOString(),

package/dist/app.js

@@ -6,7 +6,7 @@ import {
   processPluginTask,
   requireTurnFailureEventId,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-CQ7KSO2B.js";
+} from "./chunk-A5CO2EHL.js";
 import {
   CONVERSATION_WORK_CHECK_IN_INTERVAL_MS,
   CONVERSATION_WORK_STALE_ENQUEUE_MS,
@@ -30,7 +30,7 @@ import {
   requestConversationContinuation,
   requestConversationWork,
   startConversationWork
-} from "./chunk-YNP2ATQX.js";
+} from "./chunk-TWINAEZQ.js";
 import {
   GET,
   buildSentryConversationUrl,
@@ -38,7 +38,7 @@ import {
   resolveRootVisibility,
   resolveSlackChannelTypeFromMessage,
   resolveSlackConversationContext
-} from "./chunk-IGHMVDWI.js";
+} from "./chunk-XKB7LGIW.js";
 import "./chunk-CEA3A3UA.js";
 import {
   getVercelConversationWorkQueue,
@@ -69,6 +69,7 @@ import {
   appendSlackLegacyAttachmentText,
   buildSlackOutputMessage,
   buildSteeringPiMessage,
+  cancelSubscriptions,
   createAgentRunner,
   createContextCompactor,
   createUserTokenStore,
@@ -105,7 +106,7 @@ import {
   splitSlackReplyText,
   startOAuthFlow,
   truncateStatusText
-} from "./chunk-EDLNHZH3.js";
+} from "./chunk-KPMPQ6AA.js";
 import {
   ConversationTurnBoundaryError,
   CooperativeTurnYieldError,
@@ -152,7 +153,7 @@ import {
   turnHasReply,
   updateConversationStats,
   upsertConversationMessage
-} from "./chunk-YFQ7CQDE.js";
+} from "./chunk-3RGQLX2F.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS,
   abandonAgentTurnSessionRecord,
@@ -166,8 +167,8 @@ import {
   loadProjection,
   recordAgentTurnSessionSummary,
   recordAuthorizationCompleted
-} from "./chunk-4YF7Z6IA.js";
-import "./chunk-SPUAJVVH.js";
+} from "./chunk-J3B3FPP2.js";
+import "./chunk-B5I5LMSP.js";
 import "./chunk-MU6HHZEN.js";
 import "./chunk-PDO5BLNM.js";
 import "./chunk-UIE3R5XU.js";
@@ -184,16 +185,16 @@ import {
   validatePlugins,
   verifyScheduledTaskCredentialSubject,
   verifySlackDirectCredentialSubject
-} from "./chunk-RMVOAJRL.js";
+} from "./chunk-UD6THJ2I.js";
 import {
   createPluginLogger,
   createPluginState
-} from "./chunk-AUUOHQAT.js";
+} from "./chunk-AHJR2IFF.js";
 import "./chunk-G3E7SCME.js";
 import {
   acquireActiveLock,
   getStateAdapter
-} from "./chunk-B2Z2H66D.js";
+} from "./chunk-H3QYZL7K.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -215,7 +216,7 @@ import {
   juniorConversationEvents,
   juniorConversations,
   withConversationEventLock
-} from "./chunk-NVOTGWYX.js";
+} from "./chunk-TE4QHJH4.js";
 import {
   sleep
 } from "./chunk-4ZNGQH7C.js";
@@ -583,6 +584,7 @@ var DEFAULT_MAX_ATTEMPTS = 5;
 var nonEmptyExactStringSchema = z.string().min(1).refine(
   (value) => value === value.trim() && value.toLowerCase() !== "unknown"
 );
+var incompleteDispatchIndexSchema = z.array(nonEmptyExactStringSchema);
 var dispatchStatusSchema = z.enum([
   "pending",
   "running",
@@ -664,6 +666,9 @@ function incompleteDispatchIndexKey() {
 function incompleteDispatchIndexLockKey() {
   return `${DISPATCH_PREFIX}:incomplete:lock`;
 }
+function parseIncompleteDispatchIndex(value) {
+  return value === void 0 || value === null ? [] : incompleteDispatchIndexSchema.parse(value);
+}
 function dispatchLockKey(id) {
   return `${DISPATCH_PREFIX}:lock:${id}`;
 }
@@ -736,9 +741,12 @@ async function withIncompleteDispatchIndexLock(state, callback) {
 }
 async function syncIncompleteDispatchIndex(state, record) {
   await withIncompleteDispatchIndexLock(state, async () => {
-    const existing = await state.get(incompleteDispatchIndexKey()) ?? [];
     const ids = [
-      ...new Set(existing.filter((id) => typeof id === "string"))
+      ...new Set(
+        parseIncompleteDispatchIndex(
+          await state.get(incompleteDispatchIndexKey())
+        )
+      )
     ];
     const next = isTerminalDispatchStatus(record.status) ? ids.filter((id) => id !== record.id) : ids.includes(record.id) ? ids : [...ids, record.id];
     if (next.length === ids.length && next.every((id, index) => id === ids[index])) {
@@ -815,8 +823,13 @@ async function updateDispatchRecord(state, record) {
 async function listIncompleteDispatchIds() {
   const state = getStateAdapter();
   await state.connect();
-  const ids = await state.get(incompleteDispatchIndexKey()) ?? [];
-  return [...new Set(ids.filter((id) => typeof id === "string"))];
+  return [
+    ...new Set(
+      parseIncompleteDispatchIndex(
+        await state.get(incompleteDispatchIndexKey())
+      )
+    )
+  ];
 }
 async function getPluginDispatchProjection(args) {
   const record = await getDispatchRecord(args.id);
@@ -5188,6 +5201,7 @@ import {
   Message,
   ThreadImpl
 } from "chat";
+import { z as z3 } from "zod";
 
 // src/chat/ingress/message-router.ts
 function normalizeIncomingSlackThreadId(threadId, message) {
@@ -5453,6 +5467,211 @@ async function lookupSlackUser(teamId, userId) {
 }
 
 // src/chat/task-execution/slack-work.ts
+var slackConversationRouteSchema = z3.enum(["mention", "subscribed"]);
+var serializedDateSchema = z3.iso.datetime();
+var mdastPointSchema = z3.object({
+  column: z3.number().int().positive(),
+  line: z3.number().int().positive(),
+  offset: z3.number().int().nonnegative().optional()
+}).strict();
+var mdastPositionSchema = z3.object({
+  end: mdastPointSchema,
+  start: mdastPointSchema
+}).strict();
+function isOptionalNullableString(value) {
+  return value === void 0 || value === null || typeof value === "string";
+}
+function isOptionalNullableBoolean(value) {
+  return value === void 0 || value === null || typeof value === "boolean";
+}
+function hasValidMdastBase(node, fields) {
+  const allowed = /* @__PURE__ */ new Set(["data", "position", "type", ...fields]);
+  return Object.keys(node).every((key) => allowed.has(key)) && (node.data === void 0 || typeof node.data === "object" && node.data !== null && !Array.isArray(node.data)) && (node.position === void 0 || mdastPositionSchema.safeParse(node.position).success);
+}
+var mdastPhrasingTypes = /* @__PURE__ */ new Set([
+  "break",
+  "delete",
+  "emphasis",
+  "footnoteReference",
+  "html",
+  "image",
+  "imageReference",
+  "inlineCode",
+  "link",
+  "linkReference",
+  "strong",
+  "text"
+]);
+var mdastBlockOrDefinitionTypes = /* @__PURE__ */ new Set([
+  "blockquote",
+  "code",
+  "definition",
+  "footnoteDefinition",
+  "heading",
+  "html",
+  "list",
+  "paragraph",
+  "table",
+  "thematicBreak"
+]);
+var mdastListItemTypes = /* @__PURE__ */ new Set(["listItem"]);
+var mdastTableCellTypes = /* @__PURE__ */ new Set(["tableCell"]);
+var mdastTableRowTypes = /* @__PURE__ */ new Set(["tableRow"]);
+function hasMdastChildren(node, allowedTypes) {
+  return Array.isArray(node.children) && node.children.every(
+    (child) => isFormattedContentNode(child) && (!allowedTypes || typeof child === "object" && child !== null && !Array.isArray(child) && allowedTypes.has(String(child.type)))
+  );
+}
+function isFormattedContentNode(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const node = value;
+  switch (node.type) {
+    case "break":
+    case "thematicBreak":
+      return hasValidMdastBase(node, []);
+    case "html":
+    case "inlineCode":
+    case "text":
+    case "yaml":
+      return hasValidMdastBase(node, ["value"]) && typeof node.value === "string";
+    case "code":
+      return hasValidMdastBase(node, ["lang", "meta", "value"]) && typeof node.value === "string" && isOptionalNullableString(node.lang) && isOptionalNullableString(node.meta);
+    case "delete":
+    case "emphasis":
+    case "paragraph":
+    case "strong":
+    case "tableCell":
+      return hasValidMdastBase(node, ["children"]) && hasMdastChildren(node, mdastPhrasingTypes);
+    case "blockquote":
+      return hasValidMdastBase(node, ["children"]) && hasMdastChildren(node, mdastBlockOrDefinitionTypes);
+    case "tableRow":
+      return hasValidMdastBase(node, ["children"]) && hasMdastChildren(node, mdastTableCellTypes);
+    case "heading":
+      return hasValidMdastBase(node, ["children", "depth"]) && hasMdastChildren(node, mdastPhrasingTypes) && Number.isInteger(node.depth) && Number(node.depth) >= 1 && Number(node.depth) <= 6;
+    case "list":
+      return hasValidMdastBase(node, ["children", "ordered", "spread", "start"]) && hasMdastChildren(node, mdastListItemTypes) && isOptionalNullableBoolean(node.ordered) && isOptionalNullableBoolean(node.spread) && (node.start === void 0 || node.start === null || typeof node.start === "number" && Number.isFinite(node.start));
+    case "listItem":
+      return hasValidMdastBase(node, ["checked", "children", "spread"]) && hasMdastChildren(node, mdastBlockOrDefinitionTypes) && isOptionalNullableBoolean(node.checked) && isOptionalNullableBoolean(node.spread);
+    case "table":
+      return hasValidMdastBase(node, ["align", "children"]) && hasMdastChildren(node, mdastTableRowTypes) && (node.align === void 0 || node.align === null || Array.isArray(node.align) && node.align.every(
+        (align) => align === null || align === "center" || align === "left" || align === "right"
+      ));
+    case "definition":
+      return hasValidMdastBase(node, ["identifier", "label", "title", "url"]) && typeof node.identifier === "string" && typeof node.url === "string" && isOptionalNullableString(node.label) && isOptionalNullableString(node.title);
+    case "footnoteDefinition":
+      return hasValidMdastBase(node, ["children", "identifier", "label"]) && hasMdastChildren(node, mdastBlockOrDefinitionTypes) && typeof node.identifier === "string" && isOptionalNullableString(node.label);
+    case "footnoteReference":
+      return hasValidMdastBase(node, ["identifier", "label"]) && typeof node.identifier === "string" && isOptionalNullableString(node.label);
+    case "image":
+      return hasValidMdastBase(node, ["alt", "title", "url"]) && typeof node.url === "string" && isOptionalNullableString(node.alt) && isOptionalNullableString(node.title);
+    case "imageReference":
+      return hasValidMdastBase(node, [
+        "alt",
+        "identifier",
+        "label",
+        "referenceType"
+      ]) && typeof node.identifier === "string" && isOptionalNullableString(node.alt) && isOptionalNullableString(node.label) && (node.referenceType === "collapsed" || node.referenceType === "full" || node.referenceType === "shortcut");
+    case "link":
+      return hasValidMdastBase(node, ["children", "title", "url"]) && hasMdastChildren(node, mdastPhrasingTypes) && typeof node.url === "string" && isOptionalNullableString(node.title);
+    case "linkReference":
+      return hasValidMdastBase(node, [
+        "children",
+        "identifier",
+        "label",
+        "referenceType"
+      ]) && hasMdastChildren(node, mdastPhrasingTypes) && typeof node.identifier === "string" && isOptionalNullableString(node.label) && (node.referenceType === "collapsed" || node.referenceType === "full" || node.referenceType === "shortcut");
+    default:
+      return false;
+  }
+}
+var formattedContentSchema = z3.custom(
+  (value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return false;
+    }
+    const root = value;
+    return root.type === "root" && hasValidMdastBase(root, ["children"]) && hasMdastChildren(root);
+  },
+  "must be a valid formatted-content root"
+);
+var serializedMessageSchema = z3.object({
+  _type: z3.literal("chat:Message"),
+  attachments: z3.array(
+    z3.object({
+      type: z3.enum(["image", "file", "video", "audio"]),
+      url: z3.string().optional(),
+      name: z3.string().optional(),
+      mimeType: z3.string().optional(),
+      size: z3.number().finite().optional(),
+      width: z3.number().finite().optional(),
+      height: z3.number().finite().optional(),
+      fetchMetadata: z3.record(z3.string(), z3.string()).optional()
+    }).strict()
+  ),
+  author: z3.object({
+    userId: z3.string(),
+    userName: z3.string(),
+    fullName: z3.string(),
+    isBot: z3.union([z3.boolean(), z3.literal("unknown")]),
+    isMe: z3.boolean()
+  }).strict(),
+  formatted: formattedContentSchema,
+  id: z3.string().min(1),
+  isMention: z3.boolean().optional(),
+  links: z3.array(
+    z3.object({
+      url: z3.string(),
+      title: z3.string().optional(),
+      description: z3.string().optional(),
+      imageUrl: z3.string().optional(),
+      siteName: z3.string().optional()
+    }).strict()
+  ).optional(),
+  metadata: z3.object({
+    dateSent: serializedDateSchema,
+    edited: z3.boolean(),
+    editedAt: serializedDateSchema.optional()
+  }).strict(),
+  raw: z3.unknown(),
+  text: z3.string(),
+  threadId: z3.string().min(1)
+}).strict();
+var serializedThreadSchema = z3.object({
+  _type: z3.literal("chat:Thread"),
+  adapterName: z3.literal("slack"),
+  channelId: z3.string().min(1),
+  channelVisibility: z3.enum(["private", "workspace", "external", "unknown"]).optional(),
+  currentMessage: serializedMessageSchema.optional(),
+  id: z3.string().min(1),
+  isDM: z3.boolean()
+}).strict();
+var slackInstallationSchema = z3.object({
+  enterpriseId: z3.string().optional(),
+  isEnterpriseInstall: z3.boolean().optional(),
+  teamId: z3.string().optional()
+}).strict();
+var slackConversationMessageMetadataBaseSchema = z3.object({
+  installation: slackInstallationSchema.optional(),
+  message: serializedMessageSchema,
+  platform: z3.literal("slack"),
+  route: slackConversationRouteSchema,
+  thread: serializedThreadSchema
+});
+var slackConversationMessageMetadataSchema = z3.union([
+  slackConversationMessageMetadataBaseSchema.strict(),
+  slackConversationMessageMetadataBaseSchema.extend({
+    kind: z3.literal("resource_event"),
+    resourceEvent: z3.object({
+      eventKey: z3.string(),
+      eventType: z3.string(),
+      provider: z3.string(),
+      resourceRef: z3.string(),
+      subscriptionId: z3.string()
+    }).strict()
+  }).strict()
+]);
 function requireSlackAuthorId(message) {
   const authorId = parseActorUserId(message.author.userId);
   if (!authorId) {
@@ -5565,16 +5784,17 @@ function createSlackResourceEventInboundMessage(input) {
 function getConnectedState2(stateAdapter) {
   return stateAdapter ?? getStateAdapter();
 }
-function isSlackMetadata(value) {
-  return Boolean(value) && value?.platform === "slack" && (value.route === "mention" || value.route === "subscribed") && Boolean(value.thread) && Boolean(value.message);
+function parseSlackMetadata(value) {
+  const parsed = slackConversationMessageMetadataSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
 }
 function compareInboundMessages(left, right) {
   return left.createdAtMs - right.createdAtMs || left.receivedAtMs - right.receivedAtMs || left.inboundMessageId.localeCompare(right.inboundMessageId);
 }
 function routeForRecords(records) {
   return records.some((record) => {
-    const metadata = record.input.metadata;
-    if (!isSlackMetadata(metadata)) {
+    const metadata = parseSlackMetadata(record.input.metadata);
+    if (!metadata) {
       throw new Error("Conversation mailbox record is not Slack metadata");
     }
     return metadata.route === "mention";
@@ -5589,8 +5809,8 @@ function isResourceEventNotificationMessage(message) {
   return raw?.event_type === "resource_event";
 }
 function restoreMessage(args) {
-  const metadata = args.record.input.metadata;
-  if (!isSlackMetadata(metadata)) {
+  const metadata = parseSlackMetadata(args.record.input.metadata);
+  if (!metadata) {
     throw new Error("Conversation mailbox record is not a Slack message");
   }
   const message = Message.fromJSON(metadata.message);
@@ -5646,8 +5866,8 @@ function restoreThread(args) {
 }
 function getInstallation(records) {
   for (let index = records.length - 1; index >= 0; index -= 1) {
-    const metadata = records[index]?.input.metadata;
-    if (isSlackMetadata(metadata) && metadata.installation) {
+    const metadata = parseSlackMetadata(records[index]?.input.metadata);
+    if (metadata?.installation) {
       return metadata.installation;
     }
   }
@@ -5687,8 +5907,8 @@ function createSlackConversationWorker(options) {
     if (!latestRecord) {
       return { status: "completed" };
     }
-    const latestMetadata = latestRecord.input.metadata;
-    if (!isSlackMetadata(latestMetadata)) {
+    const latestMetadata = parseSlackMetadata(latestRecord.input.metadata);
+    if (!latestMetadata) {
       throw new Error(
         "Latest conversation mailbox record is not Slack metadata"
       );
@@ -5747,8 +5967,8 @@ function createSlackConversationWorker(options) {
         const drainSteeringMessages = async (accept) => {
           await context.attempt.drain(async (pendingRecords) => {
             const messages2 = pendingRecords.map((record) => {
-              const metadata = record.input.metadata;
-              if (!isSlackMetadata(metadata)) {
+              const metadata = parseSlackMetadata(record.input.metadata);
+              if (!metadata) {
                 throw new Error(
                   "Conversation mailbox record is not Slack metadata"
                 );
@@ -5832,7 +6052,7 @@ function buildSlackInboundMessage(args) {
         platform: "slack",
         route: args.route,
         installation: args.installation,
-        thread: args.thread.toJSON(),
+        thread: serializedThreadSchema.parse(args.thread.toJSON()),
         message: args.message.toJSON()
       }
     }
@@ -7279,14 +7499,14 @@ function registerVercelPluginTaskDevConsumer() {
 }
 
 // src/chat/services/subscribed-decision.ts
-import { z as z3 } from "zod";
-var replyDecisionSchema = z3.object({
-  should_reply: z3.boolean().describe("Whether Junior should respond to this thread message."),
-  should_unsubscribe: z3.boolean().describe(
+import { z as z4 } from "zod";
+var replyDecisionSchema = z4.object({
+  should_reply: z4.boolean().describe("Whether Junior should respond to this thread message."),
+  should_unsubscribe: z4.boolean().describe(
     "Whether Junior should unsubscribe from this thread because the user clearly asked it to stop participating."
   ),
-  confidence: z3.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
-  reason: z3.string().describe("Short reason for the decision; use an empty string if none.")
+  confidence: z4.number().min(0).max(1).describe("Classifier confidence from 0 to 1."),
+  reason: z4.string().describe("Short reason for the decision; use an empty string if none.")
 }).strict();
 var ROUTER_CONFIDENCE_THRESHOLD = 0.8;
 var ROUTER_CLASSIFIER_MAX_TOKENS = 240;
@@ -7632,15 +7852,6 @@ var THREAD_OPTOUT_ACK = "Understood. I'll stay out of this thread unless someone
 function shouldRethrowTurnControlError(error) {
   return isCooperativeTurnYieldError(error) || isTurnInputCommitLostError(error) || isTurnInputDeferredError(error) || isProviderRetryError(error);
 }
-async function maybeHandleThreadOptOutDecision(args) {
-  if (!args.decision?.shouldUnsubscribe) {
-    return false;
-  }
-  await args.thread.unsubscribe();
-  await args.beforeFirstResponsePost?.();
-  await args.thread.post(THREAD_OPTOUT_ACK);
-  return true;
-}
 function getQueuedMessages(context, options) {
   return (context?.skipped ?? []).map((message) => {
     const stripped = options.stripLeadingBotMention(message.text, {
@@ -7705,6 +7916,16 @@ function isResourceEventNotificationMessage2(message) {
 }
 function createSlackTurnRuntime(deps) {
   const logContext = (args) => buildLogContext(deps, args);
+  const maybeHandleThreadOptOutDecision = async (args) => {
+    if (!args.decision?.shouldUnsubscribe) {
+      return false;
+    }
+    await deps.cancelEventSubscriptions({ conversationId: args.thread.id });
+    await args.thread.unsubscribe();
+    await args.beforeFirstResponsePost?.();
+    await args.thread.post(THREAD_OPTOUT_ACK);
+    return true;
+  };
   const failConversationTurn = async (args) => {
     const conversationId = deps.getThreadId(args.thread, args.message) ?? deps.getRunId(args.thread, args.message);
     if (!conversationId) {
@@ -9052,11 +9273,11 @@ function getSlackMessageTs(message) {
 }
 
 // src/chat/slack/action-token.ts
-import { z as z4 } from "zod";
-var slackActionTokenSchema = z4.string().trim().min(1).brand();
-var slackMessageEnvelopeSchema = z4.object({
-  raw: z4.object({
-    action_token: z4.unknown().optional()
+import { z as z5 } from "zod";
+var slackActionTokenSchema = z5.string().trim().min(1).brand();
+var slackMessageEnvelopeSchema = z5.object({
+  raw: z5.object({
+    action_token: z5.unknown().optional()
   }).optional()
 });
 function readSlackActionToken(message) {
@@ -10766,6 +10987,7 @@ function createSlackRuntime(options) {
   });
   return createSlackTurnRuntime({
     assistantUserName: botConfig.userName,
+    cancelEventSubscriptions: cancelSubscriptions,
     modelId: standardModelId(botConfig),
     now: options.now ?? (() => Date.now()),
     getThreadId,

package/dist/chat/conversations/history.d.ts

@@ -596,6 +596,20 @@ export declare const conversationEventSchema: z.ZodUnion<readonly [z.ZodObject<{
 }, z.core.$strict>]>;
 /** One versioned event read from the durable conversation log. */
 export type ConversationEvent = z.output<typeof conversationEventSchema>;
+/** A decoded message-summary event and its readable history boundary. */
+export type MessagesSummarizedEvent = Omit<Extract<ConversationEvent, {
+    schemaVersion: 1;
+}>, "data"> & {
+    data: Extract<ConversationEventData, {
+        type: "messages_summarized";
+    }>;
+};
+/** Projection-ready message events paired with their authoritative boundary. */
+export interface MessageHistory {
+    events: ConversationEvent[];
+    compaction: MessagesSummarizedEvent | undefined;
+    historyFromSeq: number;
+}
 declare const storedConversationEventSchema: z.ZodObject<{
     schemaVersion: z.ZodNumber;
     seq: z.ZodNumber;
@@ -746,11 +760,8 @@ export interface ConversationEventStore {
     loadCurrentHistory(conversationId: string): Promise<ConversationEvent[]>;
     /** Events in the history version containing `seq`, when it exists. */
     loadHistoryContaining(conversationId: string, seq: number, throughSeq?: number): Promise<ConversationEvent[] | undefined>;
-    /** Current source/destination messages and their latest summary snapshot. */
-    loadMessageHistory(conversationId: string): Promise<{
-        events: ConversationEvent[];
-        compaction: ConversationEvent | undefined;
-    }>;
+    /** Projection-ready message suffix, summary snapshot, and readable boundary. */
+    loadMessageHistory(conversationId: string): Promise<MessageHistory>;
     /** All events across every history version in `seq` order. */
     loadHistory(conversationId: string): Promise<ConversationEvent[]>;
 }

package/dist/chat/conversations/message-projection.d.ts

@@ -1,6 +1,4 @@
-import type { ConversationEvent } from "./history";
+import type { MessageHistory } from "./history";
 import type { ConversationMessage } from "@/chat/state/conversation";
-/** Reduce canonical message facts into destination-facing history. */
-export declare function projectConversationMessages(events: ConversationEvent[], options?: {
-    historyFromSeq?: number;
-}): ConversationMessage[];
+/** Reduce a boundary-bearing message-history suffix into destination history. */
+export declare function projectConversationMessages(history: Pick<MessageHistory, "events" | "historyFromSeq">): ConversationMessage[];

package/dist/chat/resource-events/store.d.ts

@@ -57,6 +57,12 @@ export declare function cancelResourceEventSubscription(input: {
     nowMs?: number;
     state?: StateAdapter;
 }): Promise<ResourceEventSubscription | undefined>;
+/** Cancel every active resource event subscription bound to one conversation. */
+export declare function cancelSubscriptions(input: {
+    conversationId: string;
+    nowMs?: number;
+    state?: StateAdapter;
+}): Promise<void>;
 /** Find active subscriptions interested in a normalized provider event. */
 export declare function findMatchingResourceEventSubscriptions(input: {
     eventType: string;