@sentry/junior 0.82.0 → 0.84.0

package/dist/{chunk-NC6LR6U4.js → chunk-BFPOSIYV.js}

@@ -10,7 +10,7 @@ import {
   isSnapshotMissingError,
   resolveRuntimeDependencySnapshot,
   runNonInteractiveCommand
-} from "./chunk-3JKTVW4R.js";
+} from "./chunk-MZ4DUVFD.js";
 import {
   pluginTaskId,
   pluginTaskParamsSchema,
@@ -31,7 +31,7 @@ import {
   recordSubagentStarted,
   recordToolExecutionStarted,
   upsertAgentTurnSessionRecord
-} from "./chunk-YA2JCC7G.js";
+} from "./chunk-JUI6XIHU.js";
 import {
   createPluginEmbedder,
   createPluginHookRunner,
@@ -42,14 +42,14 @@ import {
   getPlugins,
   getSlackToolContext,
   resolveChannelCapabilities
-} from "./chunk-TR2G37II.js";
+} from "./chunk-KNVN4HUT.js";
 import {
   createPluginLogger,
   createPluginState
-} from "./chunk-GUO4EE7L.js";
+} from "./chunk-CWMMGUWM.js";
 import {
   getDb
-} from "./chunk-PQ2U2AO3.js";
+} from "./chunk-AAD2D7K3.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -60,7 +60,7 @@ import {
 import {
   acquireActiveLock,
   getStateAdapter
-} from "./chunk-X2FL5ZH5.js";
+} from "./chunk-MJ4E2PK7.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -71,7 +71,7 @@ import {
   normalizeSlackConversationId,
   parseDestination,
   withSlackRetries
-} from "./chunk-4XHCVBXH.js";
+} from "./chunk-BAPRSWNW.js";
 import {
   GEN_AI_PROVIDER_NAME,
   GEN_AI_SERVER_ADDRESS,
@@ -104,7 +104,7 @@ import {
   toObservablePromptPart,
   trimTrailingAssistantMessages,
   upsertActiveSkill
-} from "./chunk-ABRNFE3N.js";
+} from "./chunk-ALL7GG6U.js";
 import {
   parseSlackThreadId,
   resolveConversationPrivacy,
@@ -777,8 +777,8 @@ var StateAdapterTokenStore = class {
   async set(userId, provider, tokens) {
     const parsed = storedTokensSchema.parse(tokens);
     const expiresAt = parsed.refreshTokenExpiresAt ?? parsed.expiresAt;
-    const ttlMs = expiresAt ? Math.max(expiresAt - Date.now() + BUFFER_MS, BUFFER_MS) : LONG_LIVED_TTL_MS;
-    await this.state.set(tokenKey(userId, provider), parsed, ttlMs);
+    const ttlMs2 = expiresAt ? Math.max(expiresAt - Date.now() + BUFFER_MS, BUFFER_MS) : LONG_LIVED_TTL_MS;
+    await this.state.set(tokenKey(userId, provider), parsed, ttlMs2);
   }
   async delete(userId, provider) {
     await this.state.delete(tokenKey(userId, provider));
@@ -3770,9 +3770,476 @@ function createReportProgressTool() {
   });
 }
 
-// src/chat/tools/slack/channel-list-messages.ts
+// src/chat/tools/resource-events.ts
 import { Type as Type13 } from "@sinclair/typebox";
 
+// src/chat/resource-events/store.ts
+import { createHash } from "crypto";
+import { destinationSchema } from "@sentry/junior-plugin-api";
+import { z } from "zod";
+var RESOURCE_EVENT_PREFIX = "junior:resource_event_subscription";
+var INDEX_LOCK_TTL_MS = 1e4;
+var SUBSCRIPTION_LOCK_TTL_MS = 1e4;
+var subscriptionStatusSchema = z.enum(["active", "cancelled", "completed"]);
+var subscriptionIdIndexSchema = z.array(z.string().min(1));
+var subscriptionSchema = z.object({
+  conversationId: z.string().min(1),
+  createdAtMs: z.number().finite(),
+  destination: destinationSchema,
+  events: z.array(z.string().min(1)).min(1),
+  expiresAtMs: z.number().finite(),
+  id: z.string().min(1),
+  intent: z.string().min(1),
+  label: z.string().min(1),
+  provider: z.string().min(1),
+  resourceRef: z.string().min(1),
+  resourceType: z.string().min(1),
+  status: subscriptionStatusSchema,
+  updatedAtMs: z.number().finite()
+}).strict();
+function digest(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 32);
+}
+function subscriptionKey(id) {
+  return `${RESOURCE_EVENT_PREFIX}:record:${id}`;
+}
+function subscriptionLockKey(id) {
+  return `${RESOURCE_EVENT_PREFIX}:lock:${id}`;
+}
+function resourceIndexKey(provider, resourceRef) {
+  return `${RESOURCE_EVENT_PREFIX}:resource:${digest(`${provider}\0${resourceRef}`)}`;
+}
+function conversationIndexKey(conversationId) {
+  return `${RESOURCE_EVENT_PREFIX}:conversation:${digest(conversationId)}`;
+}
+function indexLockKey(key) {
+  return `${key}:lock`;
+}
+function ttlUntil(expiresAtMs, nowMs) {
+  return Math.max(1, expiresAtMs - nowMs);
+}
+async function readSubscriptionIdIndex(state, key) {
+  const value = await state.get(key);
+  if (value === void 0 || value === null) {
+    return [];
+  }
+  return subscriptionIdIndexSchema.parse(value);
+}
+function buildSubscriptionId(input) {
+  const eventKey = [...new Set(input.events)].sort().join("\0");
+  return `resub_${digest(
+    `${input.provider}\0${input.resourceRef}\0${input.conversationId}\0${eventKey}`
+  )}`;
+}
+async function withIndexLock(state, key, callback) {
+  const lock = await state.acquireLock(indexLockKey(key), INDEX_LOCK_TTL_MS);
+  if (!lock) {
+    throw new Error(`Could not acquire resource event index lock for ${key}`);
+  }
+  try {
+    return await callback();
+  } finally {
+    await state.releaseLock(lock);
+  }
+}
+async function addToIndex(state, key, subscriptionId, nowMs) {
+  await withIndexLock(state, key, async () => {
+    const ids = [...new Set(await readSubscriptionIdIndex(state, key))];
+    const next = ids.includes(subscriptionId) ? ids : [...ids, subscriptionId];
+    await state.set(key, next, await indexTtlMs(state, next, nowMs));
+  });
+}
+async function removeFromIndex(state, key, subscriptionId, nowMs) {
+  await withIndexLock(state, key, async () => {
+    const existing = await readSubscriptionIdIndex(state, key);
+    const next = existing.filter((id) => id !== subscriptionId);
+    await state.set(key, next, await indexTtlMs(state, next, nowMs));
+  });
+}
+async function indexTtlMs(state, subscriptionIds, nowMs) {
+  const records = await Promise.all(
+    subscriptionIds.map(
+      async (id) => parseSubscription(await state.get(subscriptionKey(id)))
+    )
+  );
+  const latestExpiresAtMs = Math.max(
+    nowMs,
+    ...records.filter(
+      (record) => record !== void 0 && activeAt(record, nowMs)
+    ).map((record) => record.expiresAtMs)
+  );
+  return ttlUntil(latestExpiresAtMs, nowMs);
+}
+function parseSubscription(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  return subscriptionSchema.parse(value);
+}
+function activeAt(subscription, nowMs) {
+  return subscription.status === "active" && subscription.expiresAtMs > nowMs;
+}
+function matchesEvent(subscription, input) {
+  return subscription.provider === input.provider && subscription.resourceRef === input.resourceRef && subscription.events.includes(input.eventType) && activeAt(subscription, input.nowMs);
+}
+async function createResourceEventSubscription(input, options = {}) {
+  const state = options.state ?? getStateAdapter();
+  await state.connect();
+  const nowMs = options.nowMs ?? Date.now();
+  const events = [...new Set(input.events.map((event) => event.trim()))].filter(
+    Boolean
+  );
+  if (events.length === 0) {
+    throw new Error("Resource event subscription requires at least one event");
+  }
+  if (input.expiresAtMs <= nowMs) {
+    throw new Error("Resource event subscription expiry must be in the future");
+  }
+  const id = buildSubscriptionId({
+    conversationId: input.conversationId,
+    events,
+    provider: input.provider,
+    resourceRef: input.resourceRef
+  });
+  const record = {
+    conversationId: input.conversationId,
+    createdAtMs: nowMs,
+    destination: input.destination,
+    events,
+    expiresAtMs: input.expiresAtMs,
+    id,
+    intent: input.intent,
+    label: input.label,
+    provider: input.provider,
+    resourceRef: input.resourceRef,
+    resourceType: input.resourceType,
+    status: "active",
+    updatedAtMs: nowMs
+  };
+  const parsed = subscriptionSchema.parse(record);
+  await state.set(
+    subscriptionKey(id),
+    parsed,
+    ttlUntil(parsed.expiresAtMs, nowMs)
+  );
+  await addToIndex(
+    state,
+    resourceIndexKey(input.provider, input.resourceRef),
+    id,
+    nowMs
+  );
+  await addToIndex(
+    state,
+    conversationIndexKey(input.conversationId),
+    id,
+    nowMs
+  );
+  return parsed;
+}
+async function listResourceEventSubscriptions(input) {
+  const state = input.state ?? getStateAdapter();
+  await state.connect();
+  const nowMs = input.nowMs ?? Date.now();
+  const ids = await readSubscriptionIdIndex(
+    state,
+    conversationIndexKey(input.conversationId)
+  );
+  const records = await Promise.all(
+    ids.map(
+      async (id) => parseSubscription(await state.get(subscriptionKey(id)))
+    )
+  );
+  return records.filter(
+    (record) => record !== void 0 && record.conversationId === input.conversationId && activeAt(record, nowMs)
+  ).sort((left, right) => left.createdAtMs - right.createdAtMs);
+}
+async function cancelResourceEventSubscription(input) {
+  const state = input.state ?? getStateAdapter();
+  await state.connect();
+  const lock = await state.acquireLock(
+    subscriptionLockKey(input.id),
+    SUBSCRIPTION_LOCK_TTL_MS
+  );
+  if (!lock) {
+    throw new Error(`Could not acquire subscription lock for ${input.id}`);
+  }
+  try {
+    const current = parseSubscription(
+      await state.get(subscriptionKey(input.id))
+    );
+    if (!current || current.conversationId !== input.conversationId) {
+      return void 0;
+    }
+    const nowMs = input.nowMs ?? Date.now();
+    const next = {
+      ...current,
+      status: "cancelled",
+      updatedAtMs: nowMs
+    };
+    await state.set(
+      subscriptionKey(input.id),
+      next,
+      JUNIOR_THREAD_STATE_TTL_MS
+    );
+    await removeFromIndex(
+      state,
+      resourceIndexKey(current.provider, current.resourceRef),
+      input.id,
+      nowMs
+    );
+    await removeFromIndex(
+      state,
+      conversationIndexKey(current.conversationId),
+      input.id,
+      nowMs
+    );
+    return next;
+  } finally {
+    await state.releaseLock(lock);
+  }
+}
+async function findMatchingResourceEventSubscriptions(input) {
+  const state = input.state ?? getStateAdapter();
+  await state.connect();
+  const nowMs = input.nowMs ?? Date.now();
+  const ids = await readSubscriptionIdIndex(
+    state,
+    resourceIndexKey(input.provider, input.resourceRef)
+  );
+  const records = await Promise.all(
+    ids.map(
+      async (id) => parseSubscription(await state.get(subscriptionKey(id)))
+    )
+  );
+  return records.filter(
+    (record) => record !== void 0 && matchesEvent(record, {
+      eventType: input.eventType,
+      nowMs,
+      provider: input.provider,
+      resourceRef: input.resourceRef
+    })
+  );
+}
+async function deliverResourceEventSubscription(input) {
+  const state = input.state ?? getStateAdapter();
+  await state.connect();
+  const lock = await state.acquireLock(
+    subscriptionLockKey(input.subscription.id),
+    SUBSCRIPTION_LOCK_TTL_MS
+  );
+  if (!lock) {
+    throw new Error(
+      `Resource event subscription delivery lock busy: ${input.subscription.id}`
+    );
+  }
+  try {
+    const nowMs = input.nowMs ?? Date.now();
+    const current = parseSubscription(
+      await state.get(subscriptionKey(input.subscription.id))
+    );
+    if (!current || !matchesEvent(current, {
+      eventType: input.eventType,
+      nowMs,
+      provider: input.provider,
+      resourceRef: input.resourceRef
+    })) {
+      return false;
+    }
+    const delivered = await input.deliver(current);
+    if (input.terminal) {
+      const latest = parseSubscription(
+        await state.get(subscriptionKey(current.id))
+      );
+      if (!latest || latest.status !== current.status || latest.updatedAtMs !== current.updatedAtMs) {
+        return delivered;
+      }
+      const next = {
+        ...current,
+        status: "completed",
+        updatedAtMs: nowMs
+      };
+      await state.set(
+        subscriptionKey(current.id),
+        next,
+        JUNIOR_THREAD_STATE_TTL_MS
+      );
+      await removeFromIndex(
+        state,
+        resourceIndexKey(current.provider, current.resourceRef),
+        current.id,
+        nowMs
+      );
+      await removeFromIndex(
+        state,
+        conversationIndexKey(current.conversationId),
+        current.id,
+        nowMs
+      );
+    }
+    return delivered;
+  } finally {
+    await state.releaseLock(lock);
+  }
+}
+
+// src/chat/tools/resource-events.ts
+var DEFAULT_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
+var MAX_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+var subscribeInputSchema = Type13.Object(
+  {
+    resourceRef: Type13.String({
+      description: "Opaque resource ref copied from a subscribable tool result."
+    }),
+    provider: Type13.String({
+      description: "Provider that owns the resource ref."
+    }),
+    resourceType: Type13.String({
+      description: "Provider-defined resource type from the subscribable hint."
+    }),
+    label: Type13.String({
+      description: "Human-readable resource label from the subscribable hint."
+    }),
+    events: Type13.Array(Type13.String(), {
+      description: "High-signal event names to deliver to this conversation when they occur.",
+      minItems: 1
+    }),
+    intent: Type13.String({
+      description: "Concise reason this conversation wants these events, used when an event arrives."
+    }),
+    ttlMs: Type13.Optional(
+      Type13.Number({
+        description: "How long to keep the subscription active. Defaults to 14 days and is capped at 30 days."
+      })
+    )
+  },
+  { additionalProperties: false }
+);
+var cancelInputSchema = Type13.Object(
+  {
+    subscriptionId: Type13.String({
+      description: "Subscription id returned by subscribeToResourceEvents or listResourceEventSubscriptions."
+    })
+  },
+  { additionalProperties: false }
+);
+function requireConversationContext(context) {
+  if (!context.conversationId) {
+    throw new Error("Resource event subscriptions require a conversation");
+  }
+  if (context.destination.platform !== "slack") {
+    throw new Error(
+      "Resource event subscriptions currently require Slack delivery"
+    );
+  }
+  if (!isSlackThreadConversationId(context.conversationId)) {
+    throw new Error(
+      "Resource event subscriptions require a Slack thread conversation"
+    );
+  }
+  return context.conversationId;
+}
+function canUseResourceEventSubscriptionTools(context) {
+  return context.destination.platform === "slack" && Boolean(
+    context.conversationId && isSlackThreadConversationId(context.conversationId)
+  );
+}
+function isSlackThreadConversationId(conversationId) {
+  const parts = conversationId.split(":");
+  return parts.length === 3 && parts[0] === "slack" && Boolean(parts[1]) && Boolean(parts[2]);
+}
+function cleanStrings(values) {
+  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function ttlMs(input) {
+  if (input.ttlMs === void 0) {
+    return DEFAULT_TTL_MS;
+  }
+  if (!Number.isFinite(input.ttlMs) || input.ttlMs <= 0) {
+    throw new Error("ttlMs must be a positive finite number");
+  }
+  return Math.min(input.ttlMs, MAX_TTL_MS);
+}
+function createSubscribeToResourceEventsTool(context) {
+  return tool({
+    description: "Subscribe the current conversation to high-signal events for a resource returned by a subscribable tool result. Matching events are queued as normal conversation messages; they do not interrupt active work.",
+    inputSchema: subscribeInputSchema,
+    async execute(input) {
+      const conversationId = requireConversationContext(context);
+      const events = cleanStrings(input.events);
+      const intent = input.intent.trim();
+      if (!intent) {
+        throw new Error("intent is required");
+      }
+      const nowMs = Date.now();
+      const subscription = await createResourceEventSubscription({
+        conversationId,
+        destination: context.destination,
+        events,
+        expiresAtMs: nowMs + ttlMs(input),
+        intent,
+        label: input.label.trim(),
+        provider: input.provider.trim(),
+        resourceRef: input.resourceRef.trim(),
+        resourceType: input.resourceType.trim()
+      });
+      return {
+        id: subscription.id,
+        status: subscription.status,
+        resourceRef: subscription.resourceRef,
+        events: subscription.events,
+        expiresAtMs: subscription.expiresAtMs
+      };
+    }
+  });
+}
+function createListResourceEventSubscriptionsTool(context) {
+  return tool({
+    description: "List active resource event subscriptions for the current conversation.",
+    inputSchema: Type13.Object({}, { additionalProperties: false }),
+    async execute() {
+      const conversationId = requireConversationContext(context);
+      const subscriptions = await listResourceEventSubscriptions({
+        conversationId
+      });
+      return {
+        subscriptions: subscriptions.map((subscription) => ({
+          id: subscription.id,
+          label: subscription.label,
+          resourceRef: subscription.resourceRef,
+          provider: subscription.provider,
+          resourceType: subscription.resourceType,
+          events: subscription.events,
+          intent: subscription.intent,
+          expiresAtMs: subscription.expiresAtMs
+        }))
+      };
+    }
+  });
+}
+function createCancelResourceEventSubscriptionTool(context) {
+  return tool({
+    description: "Cancel a resource event subscription for the current conversation.",
+    inputSchema: cancelInputSchema,
+    async execute(input) {
+      const conversationId = requireConversationContext(context);
+      const subscription = await cancelResourceEventSubscription({
+        conversationId,
+        id: input.subscriptionId
+      });
+      if (!subscription) {
+        throw new Error("Resource event subscription was not found");
+      }
+      return {
+        id: subscription.id,
+        status: subscription.status
+      };
+    }
+  });
+}
+
+// src/chat/tools/slack/channel-list-messages.ts
+import { Type as Type14 } from "@sinclair/typebox";
+
 // src/chat/slack/channel.ts
 async function listChannelMessages(input) {
   const client = getSlackClient();
@@ -3862,39 +4329,39 @@ function createSlackChannelListMessagesTool(context) {
   return tool({
     description: "List channel messages from Slack history in the active channel context. Use when the user asks for recent or historical channel context outside this thread. Do not use for live monitoring or when current thread context already answers the question.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: Type13.Object({
-      limit: Type13.Optional(
-        Type13.Integer({
+    inputSchema: Type14.Object({
+      limit: Type14.Optional(
+        Type14.Integer({
           minimum: 1,
           maximum: 1e3,
           description: "Maximum number of messages to return across pages."
         })
       ),
-      cursor: Type13.Optional(
-        Type13.String({
+      cursor: Type14.Optional(
+        Type14.String({
           minLength: 1,
           description: "Optional cursor to continue from a prior call."
         })
       ),
-      oldest: Type13.Optional(
-        Type13.String({
+      oldest: Type14.Optional(
+        Type14.String({
           minLength: 1,
           description: "Optional oldest message timestamp (Slack ts) for range filtering."
         })
       ),
-      latest: Type13.Optional(
-        Type13.String({
+      latest: Type14.Optional(
+        Type14.String({
           minLength: 1,
           description: "Optional latest message timestamp (Slack ts) for range filtering."
         })
       ),
-      inclusive: Type13.Optional(
-        Type13.Boolean({
+      inclusive: Type14.Optional(
+        Type14.Boolean({
           description: "Whether oldest/latest bounds should be inclusive."
         })
       ),
-      max_pages: Type13.Optional(
-        Type13.Integer({
+      max_pages: Type14.Optional(
+        Type14.Integer({
           minimum: 1,
           maximum: 10,
           description: "Maximum number of API pages to traverse in a single call."
@@ -3954,7 +4421,7 @@ function createSlackChannelListMessagesTool(context) {
 }
 
 // src/chat/tools/slack/channel-post-message.ts
-import { Type as Type14 } from "@sinclair/typebox";
+import { Type as Type15 } from "@sinclair/typebox";
 
 // src/chat/slack/outbound.ts
 var MAX_SLACK_MESSAGE_TEXT_CHARS = 4e4;
@@ -3998,7 +4465,13 @@ async function getPermalinkBestEffort(args) {
         message_ts: args.messageTs
       }),
       3,
-      { action: "chat.getPermalink" }
+      {
+        action: "chat.getPermalink",
+        spanAttributes: {
+          "app.slack.channel_id": args.channelId,
+          "app.slack.message_ts": args.messageTs
+        }
+      }
     );
     return response.permalink;
   } catch {
@@ -4025,7 +4498,13 @@ async function postSlackMessage(input) {
       ...threadTs ? { thread_ts: threadTs } : {}
     }),
     3,
-    { action: "chat.postMessage" }
+    {
+      action: "chat.postMessage",
+      spanAttributes: {
+        "app.slack.channel_id": channelId,
+        ...threadTs ? { "app.slack.thread_ts": threadTs } : {}
+      }
+    }
   );
   if (!response.ts) {
     throw new Error("Slack message posted without ts");
@@ -4055,7 +4534,13 @@ async function deleteSlackMessage(input) {
       ts: timestamp
     }),
     3,
-    { action: "chat.delete" }
+    {
+      action: "chat.delete",
+      spanAttributes: {
+        "app.slack.channel_id": channelId,
+        "app.slack.message_ts": timestamp
+      }
+    }
   );
 }
 async function postSlackEphemeralMessage(input) {
@@ -4083,7 +4568,14 @@ async function postSlackEphemeralMessage(input) {
       ...threadTs ? { thread_ts: threadTs } : {}
     }),
     3,
-    { action: "chat.postEphemeral" }
+    {
+      action: "chat.postEphemeral",
+      spanAttributes: {
+        "app.slack.channel_id": channelId,
+        "app.slack.user_id": userId,
+        ...threadTs ? { "app.slack.thread_ts": threadTs } : {}
+      }
+    }
   );
   return {
     messageTs: response.message_ts
@@ -4120,7 +4612,13 @@ async function uploadFilesToThread(input) {
       file_uploads: fileUploads
     }),
     3,
-    { action: "filesUploadV2" }
+    {
+      action: "filesUploadV2",
+      spanAttributes: {
+        "app.slack.channel_id": channelId,
+        "app.slack.thread_ts": threadTs
+      }
+    }
   );
 }
 async function addReactionToMessage(input) {
@@ -4144,7 +4642,14 @@ async function addReactionToMessage(input) {
         name: emoji
       }),
       3,
-      { action: "reactions.add" }
+      {
+        action: "reactions.add",
+        spanAttributes: {
+          "app.slack.channel_id": channelId,
+          "app.slack.message_ts": timestamp,
+          "app.slack.reaction": emoji
+        }
+      }
     );
   } catch (error) {
     if (error instanceof SlackActionError && error.code === "already_reacted") {
@@ -4175,7 +4680,14 @@ async function removeReactionFromMessage(input) {
         name: emoji
       }),
       3,
-      { action: "reactions.remove" }
+      {
+        action: "reactions.remove",
+        spanAttributes: {
+          "app.slack.channel_id": channelId,
+          "app.slack.message_ts": timestamp,
+          "app.slack.reaction": emoji
+        }
+      }
     );
   } catch (error) {
     if (error instanceof SlackActionError && error.code === "no_reaction") {
@@ -4206,8 +4718,8 @@ function createOperationKey(toolName, input) {
 function createSlackChannelPostMessageTool(context, state) {
   return tool({
     description: "Post a new top-level message to the current Slack channel. Use only when the user explicitly asks to post/send/share/say something to the channel. Do not use for thread replies, inline @mentions, or pinging mentioned users.",
-    inputSchema: Type14.Object({
-      text: Type14.String({
+    inputSchema: Type15.Object({
+      text: Type15.String({
         minLength: 1,
         maxLength: 4e4,
         description: "Slack mrkdwn text to post."
@@ -4247,12 +4759,12 @@ function createSlackChannelPostMessageTool(context, state) {
 }
 
 // src/chat/tools/slack/message-add-reaction.ts
-import { Type as Type15 } from "@sinclair/typebox";
+import { Type as Type16 } from "@sinclair/typebox";
 function createSlackMessageAddReactionTool(context, state) {
   return tool({
     description: "Add an emoji reaction to the current inbound Slack message. Use sparingly for lightweight acknowledgements. Provide a Slack emoji alias name (for example `thumbsup`, `white_check_mark`, or `thumbsup::skin-tone-6`), not a unicode emoji glyph. The target message is injected by runtime context; do not use this for arbitrary historical messages.",
-    inputSchema: Type15.Object({
-      emoji: Type15.String({
+    inputSchema: Type16.Object({
+      emoji: Type16.String({
         minLength: 1,
         maxLength: 64,
         description: "Slack emoji alias name to react with (for example `thumbsup`, `white_check_mark`, or `thumbsup::skin-tone-6`). Optional surrounding colons are allowed."
@@ -4304,7 +4816,7 @@ function createSlackMessageAddReactionTool(context, state) {
 }
 
 // src/chat/tools/slack/canvas-tools.ts
-import { Type as Type16 } from "@sinclair/typebox";
+import { Type as Type17 } from "@sinclair/typebox";
 
 // src/chat/slack/canvas-references.ts
 var SLACK_FILE_ID_PATTERN = /^F[A-Z0-9]{4,}$/i;
@@ -4549,13 +5061,13 @@ function resolveCanvasTarget(canvas) {
   }
   return { ok: true, canvasId };
 }
-var editReplacementSchema2 = Type16.Object(
+var editReplacementSchema2 = Type17.Object(
   {
-    oldText: Type16.String({
+    oldText: Type17.String({
       minLength: 1,
       description: "Exact Canvas markdown to replace. It must be unique in the current Canvas body and must not overlap another edit."
     }),
-    newText: Type16.String({
+    newText: Type17.String({
       description: "Replacement Canvas markdown for this edit."
     })
   },
@@ -4564,13 +5076,13 @@ var editReplacementSchema2 = Type16.Object(
 function createSlackCanvasCreateTool(context, state) {
   return tool({
     description: "Create a Slack canvas for long-form output in the active assistant context channel. Use when the answer is better as a reusable document than a thread reply: long-form research, timelines, bios/profiles, structured notes, plans, comparisons, or anything likely to exceed one compact Slack reply. After creating it, reply with one or two short sentences plus the canvas link; do not recap the canvas contents. Do not use for short answers that fit cleanly in one normal thread reply.",
-    inputSchema: Type16.Object({
-      title: Type16.String({
+    inputSchema: Type17.Object({
+      title: Type17.String({
         minLength: 1,
         maxLength: 160,
         description: "Canvas title."
       }),
-      markdown: Type16.String({
+      markdown: Type17.String({
         minLength: 1,
         description: "Canvas markdown body content."
       })
@@ -4636,20 +5148,20 @@ function createSlackCanvasReadTool() {
   return tool({
     description: "Read a bounded line range from a Slack canvas as markdown. Use when you need exact Canvas contents to verify facts or make edits safely. Do not use for generic web pages \u2014 use webFetch for those.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: Type16.Object(
+    inputSchema: Type17.Object(
       {
-        canvas: Type16.String({
+        canvas: Type17.String({
           minLength: 1,
           description: "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL (e.g. `https://team.slack.com/docs/T.../F...`)."
         }),
-        offset: Type16.Optional(
-          Type16.Integer({
+        offset: Type17.Optional(
+          Type17.Integer({
             minimum: 1,
             description: "1-indexed line number to start reading from."
           })
         ),
-        limit: Type16.Optional(
-          Type16.Integer({
+        limit: Type17.Optional(
+          Type17.Integer({
             minimum: 1,
             description: "Maximum number of lines to read. Defaults to 1000."
           })
@@ -4710,13 +5222,13 @@ function createSlackCanvasEditTool(state) {
     description: "Edit one Slack canvas with exact markdown replacements. Use for precise changes to existing Canvas content; prefer this over slackCanvasWrite for targeted changes. Each oldText must match exactly, be unique, and not overlap another edit. Returns a diff. Multiple changes to the same canvas: use one edits[] call.",
     prepareArguments: prepareCanvasEditArguments,
     executionMode: "sequential",
-    inputSchema: Type16.Object(
+    inputSchema: Type17.Object(
       {
-        canvas: Type16.String({
+        canvas: Type17.String({
           minLength: 1,
           description: "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."
         }),
-        edits: Type16.Array(editReplacementSchema2, {
+        edits: Type17.Array(editReplacementSchema2, {
           minItems: 1,
           description: "Exact replacements matched against the current Canvas body, not incrementally."
         })
@@ -4796,13 +5308,13 @@ function createSlackCanvasWriteTool(state) {
   return tool({
     description: "Write UTF-8 markdown content to a Slack canvas. Use for deliberate full-Canvas replacement after validation; use slackCanvasEdit for targeted changes to existing canvas content.",
     executionMode: "sequential",
-    inputSchema: Type16.Object(
+    inputSchema: Type17.Object(
       {
-        canvas: Type16.String({
+        canvas: Type17.String({
           minLength: 1,
           description: "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."
         }),
-        content: Type16.String({
+        content: Type17.String({
           description: "UTF-8 markdown content to write."
         })
       },
@@ -4863,7 +5375,7 @@ function createSlackCanvasWriteTool(state) {
 }
 
 // src/chat/tools/slack/list-tools.ts
-import { Type as Type17 } from "@sinclair/typebox";
+import { Type as Type18 } from "@sinclair/typebox";
 
 // src/chat/tools/slack/lists.ts
 function normalizeKey(value) {
@@ -4919,7 +5431,9 @@ async function createTodoList(name) {
       name,
       schema: DEFAULT_TODO_SCHEMA,
       todo_mode: true
-    })
+    }),
+    3,
+    { action: "slackLists.create" }
   );
   if (!result.list_id) {
     throw new Error("Slack list was created without list_id");
@@ -4965,7 +5479,9 @@ async function addListItems(input) {
       () => client.slackLists.items.create({
         list_id: input.listId,
         initial_fields: initialFields
-      })
+      }),
+      3,
+      { action: "slackLists.items.create" }
     );
     if (response.item?.id) {
       createdItemIds.push(response.item.id);
@@ -4987,7 +5503,9 @@ async function listItems(listId, limit = 100) {
         list_id: listId,
         limit: cappedLimit,
         cursor
-      })
+      }),
+      3,
+      { action: "slackLists.items.list" }
     );
     const remaining = cappedLimit - items.length;
     if (remaining <= 0) {
@@ -5029,7 +5547,9 @@ async function updateListItem(input) {
     () => client.slackLists.items.update({
       list_id: input.listId,
       cells
-    })
+    }),
+    3,
+    { action: "slackLists.items.update" }
   );
 }
 
@@ -5037,8 +5557,8 @@ async function updateListItem(input) {
 function createSlackListCreateTool(state) {
   return tool({
     description: "Create a Slack todo list for action tracking. Use when the user needs structured tasks with ownership/completion tracking. Do not use for one-off notes without task management needs.",
-    inputSchema: Type17.Object({
-      name: Type17.String({
+    inputSchema: Type18.Object({
+      name: Type18.String({
         minLength: 1,
         maxLength: 160,
         description: "Name for the new Slack list."
@@ -5073,20 +5593,20 @@ function createSlackListCreateTool(state) {
 function createSlackListAddItemsTool(state) {
   return tool({
     description: "Add tasks to the active Slack list tracked in artifact context. Use when the user wants actionable items recorded in the current thread list. Do not use when no list exists and list creation was not requested.",
-    inputSchema: Type17.Object({
-      items: Type17.Array(Type17.String({ minLength: 1 }), {
+    inputSchema: Type18.Object({
+      items: Type18.Array(Type18.String({ minLength: 1 }), {
         minItems: 1,
         maxItems: 25,
         description: "List item titles to create."
       }),
-      assignee_user_id: Type17.Optional(
-        Type17.String({
+      assignee_user_id: Type18.Optional(
+        Type18.String({
           minLength: 1,
           description: "Optional Slack user ID assigned to all created items."
         })
       ),
-      due_date: Type17.Optional(
-        Type17.String({
+      due_date: Type18.Optional(
+        Type18.String({
           pattern: "^\\d{4}-\\d{2}-\\d{2}$",
           description: "Optional due date in YYYY-MM-DD format."
         })
@@ -5136,9 +5656,9 @@ function createSlackListGetItemsTool(state) {
   return tool({
     description: "Read items from the active Slack list tracked in artifact context. Use when the user asks for task status, open items, or list contents. Do not use when list state is already known from the immediately prior result.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: Type17.Object({
-      limit: Type17.Optional(
-        Type17.Integer({
+    inputSchema: Type18.Object({
+      limit: Type18.Optional(
+        Type18.Integer({
           minimum: 1,
           maximum: 200,
           description: "Maximum number of list items to return."
@@ -5163,19 +5683,19 @@ function createSlackListGetItemsTool(state) {
 function createSlackListUpdateItemTool(state) {
   return tool({
     description: "Update an item in the active Slack list tracked in artifact context (title/completion). Use when the user asks to mark progress or rename a tracked task. Do not use to add new tasks.",
-    inputSchema: Type17.Object(
+    inputSchema: Type18.Object(
       {
-        item_id: Type17.String({
+        item_id: Type18.String({
           minLength: 1,
           description: "ID of the Slack list item to update."
         }),
-        completed: Type17.Optional(
-          Type17.Boolean({
+        completed: Type18.Optional(
+          Type18.Boolean({
             description: "Optional completion status update."
           })
         ),
-        title: Type17.Optional(
-          Type17.String({
+        title: Type18.Optional(
+          Type18.String({
             minLength: 1,
             description: "Optional new item title."
           })
@@ -5225,7 +5745,7 @@ function createSlackListUpdateItemTool(state) {
 }
 
 // src/chat/tools/slack/thread-read.ts
-import { Type as Type18 } from "@sinclair/typebox";
+import { Type as Type19 } from "@sinclair/typebox";
 
 // src/chat/tools/slack/slack-message-url.ts
 var SLACK_HOST_PATTERN = /^[a-z0-9-]+\.slack(?:-gov)?\.com$/;
@@ -5407,34 +5927,34 @@ function createSlackThreadReadTool(context) {
   return tool({
     description: "Read a Slack thread from a shared Slack message archive URL or explicit channel + timestamp. Use when the user shares a Slack message link (https://*.slack.com/archives/...) and you need the referenced message and its thread context. Public channel links can be read if the bot has access; private channels and DMs are only readable when they are the current conversation.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: Type18.Object({
-      url: Type18.Optional(
-        Type18.String({
+    inputSchema: Type19.Object({
+      url: Type19.Optional(
+        Type19.String({
           minLength: 1,
           description: "Slack message archive URL, e.g. https://workspace.slack.com/archives/C123/p1700000000123456"
         })
       ),
-      channel_id: Type18.Optional(
-        Type18.String({
+      channel_id: Type19.Optional(
+        Type19.String({
           minLength: 1,
           description: "Slack channel/conversation ID (e.g. C123). Use with `ts` as an alternative to `url`."
         })
       ),
-      ts: Type18.Optional(
-        Type18.String({
+      ts: Type19.Optional(
+        Type19.String({
           minLength: 1,
           description: "Slack message timestamp (e.g. 1700000000.123456). May be the thread root or any message in the thread."
         })
       ),
-      limit: Type18.Optional(
-        Type18.Integer({
+      limit: Type19.Optional(
+        Type19.Integer({
           minimum: 1,
           maximum: 1e3,
           description: "Maximum number of thread messages to fetch."
         })
       ),
-      max_pages: Type18.Optional(
-        Type18.Integer({
+      max_pages: Type19.Optional(
+        Type19.Integer({
           minimum: 1,
           maximum: 10,
           description: "Maximum number of Slack API pages to traverse."
@@ -5529,7 +6049,7 @@ function createSlackThreadReadTool(context) {
 }
 
 // src/chat/tools/slack/user-lookup.ts
-import { Type as Type19 } from "@sinclair/typebox";
+import { Type as Type20 } from "@sinclair/typebox";
 
 // src/chat/slack/users.ts
 function normalizeUser(raw) {
@@ -5675,41 +6195,41 @@ function createSlackUserLookupTool() {
   return tool({
     description: "Look up Slack user profiles by user ID, email, or name search. Use when you need to identify a user, resolve cross-platform identity, or look up profile details like title or status. Returns profile fields including custom fields. For user ID lookup, pass a Slack user ID (e.g. U039RR91S). For search, pass a name query.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: Type19.Object({
-      user_id: Type19.Optional(
-        Type19.String({
+    inputSchema: Type20.Object({
+      user_id: Type20.Optional(
+        Type20.String({
           minLength: 1,
           description: "Slack user ID to look up (e.g. U039RR91S). Mutually exclusive with email and query."
         })
       ),
-      email: Type19.Optional(
-        Type19.String({
+      email: Type20.Optional(
+        Type20.String({
           minLength: 3,
           description: "Email address to look up. Mutually exclusive with user_id and query."
         })
       ),
-      query: Type19.Optional(
-        Type19.String({
+      query: Type20.Optional(
+        Type20.String({
           minLength: 2,
           description: "Name to search for (matches against username, display name, real name). Mutually exclusive with user_id and email."
         })
       ),
-      limit: Type19.Optional(
-        Type19.Integer({
+      limit: Type20.Optional(
+        Type20.Integer({
           minimum: 1,
           maximum: 20,
           description: "Maximum number of results to return for name search. Defaults to 10."
         })
       ),
-      max_pages: Type19.Optional(
-        Type19.Integer({
+      max_pages: Type20.Optional(
+        Type20.Integer({
           minimum: 1,
           maximum: 5,
           description: "Maximum number of Slack API pages to scan for name search. Defaults to 3."
         })
       ),
-      include_bots: Type19.Optional(
-        Type19.Boolean({
+      include_bots: Type20.Optional(
+        Type20.Boolean({
           description: "Include bot accounts in name search results. Defaults to false."
         })
       )
@@ -5788,12 +6308,12 @@ function createSlackUserLookupTool() {
 }
 
 // src/chat/tools/system-time.ts
-import { Type as Type20 } from "@sinclair/typebox";
+import { Type as Type21 } from "@sinclair/typebox";
 function createSystemTimeTool() {
   return tool({
     description: "Return current system time in UTC and local ISO formats. Use when the user asks for current time/date context. Do not use as a substitute for historical or timezone-conversion research.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: Type20.Object({}),
+    inputSchema: Type21.Object({}),
     execute: async () => {
       const now = /* @__PURE__ */ new Date();
       return {
@@ -5811,7 +6331,7 @@ function createSystemTimeTool() {
 import {
   Agent
 } from "@earendil-works/pi-agent-core";
-import { Type as Type21 } from "@sinclair/typebox";
+import { Type as Type22 } from "@sinclair/typebox";
 import { THREAD_STATE_TTL_MS } from "chat";
 
 // src/chat/tools/advisor/session-store.ts
@@ -5899,12 +6419,12 @@ function createAdvisorTool(context) {
   const spanContext = context.logContext ?? {};
   return tool({
     description: ADVISOR_TOOL_DESCRIPTION,
-    inputSchema: Type21.Object({
-      question: Type21.String({
+    inputSchema: Type22.Object({
+      question: Type22.String({
         minLength: 1,
         description: "Focused advisor question or decision point."
       }),
-      context: Type21.String({
+      context: Type22.String({
         minLength: 1,
         description: "Curated evidence packet: relevant requirements, constraints, current plan, alternatives, code snippets, diffs, command output, and open questions."
       })
@@ -5933,12 +6453,16 @@ function createAdvisorTool(context) {
       const conversationId = context.conversationId;
       const advisorSessionKey = getAdvisorSessionKey(conversationId);
       const subagentInvocationId = typeof toolCallId === "string" && toolCallId.length > 0 ? toolCallId : `advisor:${Date.now()}`;
-      const endSubagent = async (outcome, errorCode) => recordSubagentEnded({
+      const endSubagent = async (outcome, errorCode, transcriptRange) => recordSubagentEnded({
         conversationId,
         sessionId: context.parentSessionId,
         subagentInvocationId,
         outcome,
         ...errorCode ? { errorCode } : {},
+        ...transcriptRange ? {
+          transcriptEndMessageIndex: transcriptRange.endMessageIndex,
+          transcriptStartMessageIndex: transcriptRange.startMessageIndex
+        } : {},
         ttlMs: THREAD_STATE_TTL_MS
       });
       await recordSubagentStarted({
@@ -6057,7 +6581,10 @@ function createAdvisorTool(context) {
               "Advisor guidance is unavailable because advisor history could not be saved. Retry the advisor call or continue without assuming advisor history."
             );
           }
-          await endSubagent("success");
+          await endSubagent("success", void 0, {
+            endMessageIndex: advisorAgent.state.messages.length,
+            startMessageIndex: beforeMessageCount
+          });
           setSpanStatus("ok");
           return success(memo);
         },
@@ -6080,7 +6607,7 @@ function createAdvisorTool(context) {
 }
 
 // src/chat/tools/web/fetch-tool.ts
-import { Type as Type22 } from "@sinclair/typebox";
+import { Type as Type23 } from "@sinclair/typebox";
 
 // src/chat/tools/web/constants.ts
 var USER_AGENT = "junior-bot/0.1";
@@ -6525,13 +7052,13 @@ function createWebFetchTool(hooks) {
       destructiveHint: false,
       openWorldHint: true
     },
-    inputSchema: Type22.Object({
-      url: Type22.String({
+    inputSchema: Type23.Object({
+      url: Type23.String({
         minLength: 1,
         description: "HTTP(S) URL to fetch."
       }),
-      max_chars: Type22.Optional(
-        Type22.Integer({
+      max_chars: Type23.Optional(
+        Type23.Integer({
           minimum: 500,
           maximum: MAX_FETCH_CHARS,
           description: "Optional maximum number of extracted characters to return."
@@ -6595,7 +7122,7 @@ function createWebFetchTool(hooks) {
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
 import { getModel } from "@earendil-works/pi-ai";
-import { Type as Type23 } from "@sinclair/typebox";
+import { Type as Type24 } from "@sinclair/typebox";
 var SEARCH_TIMEOUT_MS = 6e4;
 var MAX_RESULTS2 = 5;
 var DEFAULT_SEARCH_MODEL = getModel("vercel-ai-gateway", "openai/gpt-5.4").id;
@@ -6643,14 +7170,14 @@ function createWebSearchTool(override) {
       destructiveHint: false,
       openWorldHint: true
     },
-    inputSchema: Type23.Object({
-      query: Type23.String({
+    inputSchema: Type24.Object({
+      query: Type24.String({
         minLength: 1,
         maxLength: 500,
         description: "Search query."
       }),
-      max_results: Type23.Optional(
-        Type23.Integer({
+      max_results: Type24.Optional(
+        Type24.Integer({
           minimum: 1,
           maximum: MAX_RESULTS2,
           description: "Max results to return."
@@ -6722,18 +7249,18 @@ function createWebSearchTool(override) {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { Type as Type24 } from "@sinclair/typebox";
+import { Type as Type25 } from "@sinclair/typebox";
 function createWriteFileTool() {
   return tool({
     description: "Write UTF-8 content to a file in the sandbox workspace. Use for intentional file creation or deliberate full-file replacement after validation; use editFile instead for targeted changes to existing files. Do not use for exploratory analysis-only turns.",
     executionMode: "sequential",
-    inputSchema: Type24.Object(
+    inputSchema: Type25.Object(
       {
-        path: Type24.String({
+        path: Type25.String({
           minLength: 1,
           description: "Path to write in the sandbox workspace."
         }),
-        content: Type24.String({
+        content: Type25.String({
           description: "UTF-8 file content to write."
         })
       },
@@ -6802,6 +7329,11 @@ function createTools(availableSkills, hooks = {}, context) {
   if (context.advisor) {
     tools.advisor = createAdvisorTool(context.advisor);
   }
+  if (canUseResourceEventSubscriptionTools(context)) {
+    tools.subscribeToResourceEvents = createSubscribeToResourceEventsTool(context);
+    tools.listResourceEventSubscriptions = createListResourceEventSubscriptionsTool(context);
+    tools.cancelResourceEventSubscription = createCancelResourceEventSubscriptionTool(context);
+  }
   if (context.mcpToolManager) {
     tools.searchMcpTools = createSearchMcpToolsTool(context.mcpToolManager);
     tools.callMcpTool = createCallMcpToolTool(context.mcpToolManager);
@@ -7063,7 +7595,14 @@ async function deliverPrivateMessage(input) {
     }
   }
   try {
-    const dmChannelId = (await client.conversations.open({ users: input.userId })).channel?.id;
+    const dmChannelId = (await withSlackRetries(
+      () => client.conversations.open({ users: input.userId }),
+      3,
+      {
+        action: "conversations.open",
+        spanAttributes: { "app.slack.user_id": input.userId }
+      }
+    )).channel?.id;
     if (!dmChannelId) {
       logWarn(
         "oauth_dm_fallback_failed",
@@ -7167,59 +7706,59 @@ async function startOAuthFlow(provider, input) {
 import { createHmac, randomUUID, timingSafeEqual } from "crypto";
 
 // src/chat/sandbox/egress/schemas.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 import {
   pluginAuthorizationSchema,
   pluginCredentialHeaderTransformSchema,
   pluginGrantSchema,
   pluginProviderAccountSchema
 } from "@sentry/junior-plugin-api";
-var finiteNumberSchema = z.number().refine(Number.isFinite);
-var httpStatusSchema = z.number().int().min(100).max(599);
-var providerNameSchema = z.string().regex(/^[a-z][a-z0-9-]*$/);
-var credentialSignalKindSchema = z.enum(["auth_required", "unavailable"]);
+var finiteNumberSchema = z2.number().refine(Number.isFinite);
+var httpStatusSchema = z2.number().int().min(100).max(599);
+var providerNameSchema = z2.string().regex(/^[a-z][a-z0-9-]*$/);
+var credentialSignalKindSchema = z2.enum(["auth_required", "unavailable"]);
 var sandboxEgressGrantSchema = pluginGrantSchema;
-var sandboxEgressCredentialContextSchema = z.object({
+var sandboxEgressCredentialContextSchema = z2.object({
   credentials: credentialContextSchema,
-  egressId: z.string().min(1),
+  egressId: z2.string().min(1),
   expiresAtMs: finiteNumberSchema,
-  contextId: z.string().min(1)
+  contextId: z2.string().min(1)
 }).strict();
-var sandboxEgressCredentialLeaseSchema = z.object({
+var sandboxEgressCredentialLeaseSchema = z2.object({
   account: pluginProviderAccountSchema.optional(),
   authorization: pluginAuthorizationSchema.optional(),
   grant: sandboxEgressGrantSchema,
   provider: providerNameSchema,
-  expiresAt: z.string().min(1),
-  headerTransforms: z.array(pluginCredentialHeaderTransformSchema).min(1)
+  expiresAt: z2.string().min(1),
+  headerTransforms: z2.array(pluginCredentialHeaderTransformSchema).min(1)
 }).strict();
-var sandboxEgressAuthRequiredSignalSchema = z.object({
+var sandboxEgressAuthRequiredSignalSchema = z2.object({
   authorization: pluginAuthorizationSchema.optional(),
   grant: sandboxEgressGrantSchema,
   kind: credentialSignalKindSchema.default("auth_required"),
   provider: providerNameSchema,
-  message: z.string().optional(),
+  message: z2.string().optional(),
   createdAtMs: finiteNumberSchema
 }).strict().superRefine((signal, ctx) => {
   if (signal.authorization && signal.authorization.provider !== signal.provider) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: z2.ZodIssueCode.custom,
       message: "Auth signal authorization provider must match provider",
       path: ["authorization", "provider"]
     });
   }
 });
-var sandboxEgressPermissionDeniedSignalSchema = z.object({
+var sandboxEgressPermissionDeniedSignalSchema = z2.object({
   account: pluginProviderAccountSchema.optional(),
-  acceptedPermissions: z.string().optional(),
+  acceptedPermissions: z2.string().optional(),
   grant: sandboxEgressGrantSchema,
-  message: z.string().min(1),
+  message: z2.string().min(1),
   provider: providerNameSchema,
-  source: z.literal("upstream"),
-  sso: z.string().optional(),
+  source: z2.literal("upstream"),
+  sso: z2.string().optional(),
   status: httpStatusSchema,
-  upstreamHost: z.string().min(1),
-  upstreamPath: z.string().min(1),
+  upstreamHost: z2.string().min(1),
+  upstreamPath: z2.string().min(1),
   createdAtMs: finiteNumberSchema
 }).strict();
 function parseSandboxEgressAuthRequiredSignal(value) {
@@ -7296,12 +7835,12 @@ function getSandboxEgressSecret() {
   throw new Error("Cannot determine sandbox egress secret (set JUNIOR_SECRET)");
 }
 function createSandboxEgressCredentialToken(input) {
-  const ttlMs = Math.max(1, input.ttlMs ?? DEFAULT_SESSION_TTL_MS);
+  const ttlMs2 = Math.max(1, input.ttlMs ?? DEFAULT_SESSION_TTL_MS);
   const now = Date.now();
   const context = {
     credentials: input.credentials,
     egressId: input.egressId,
-    expiresAtMs: now + ttlMs,
+    expiresAtMs: now + ttlMs2,
     contextId: randomUUID()
   };
   const payload = `${SANDBOX_EGRESS_TOKEN_VERSION}.${base64Url(
@@ -7337,7 +7876,7 @@ async function setSandboxEgressCredentialLease(context, lease) {
   if (!Number.isFinite(leaseExpiresAtMs) || leaseExpiresAtMs <= Date.now()) {
     return;
   }
-  const ttlMs = Math.max(
+  const ttlMs2 = Math.max(
     1,
     Math.min(leaseExpiresAtMs, context.expiresAtMs) - Date.now()
   );
@@ -7346,7 +7885,7 @@ async function setSandboxEgressCredentialLease(context, lease) {
   await state.set(
     leaseKey(lease.provider, lease.grant.name, context),
     lease,
-    ttlMs
+    ttlMs2
   );
 }
 async function getSandboxEgressCredentialLease(provider, grantName, context) {
@@ -7360,7 +7899,7 @@ async function clearSandboxEgressCredentialLease(provider, grantName, context) {
   await state.delete(leaseKey(provider, grantName, context));
 }
 async function setSandboxEgressAuthRequiredSignal(context, signal) {
-  const ttlMs = Math.max(1, context.expiresAtMs - Date.now());
+  const ttlMs2 = Math.max(1, context.expiresAtMs - Date.now());
   const state = getStateAdapter();
   await state.connect();
   await state.set(
@@ -7369,11 +7908,11 @@ async function setSandboxEgressAuthRequiredSignal(context, signal) {
       ...signal,
       createdAtMs: Date.now()
     },
-    ttlMs
+    ttlMs2
   );
 }
 async function setSandboxEgressPermissionDeniedSignal(context, signal) {
-  const ttlMs = Math.max(1, context.expiresAtMs - Date.now());
+  const ttlMs2 = Math.max(1, context.expiresAtMs - Date.now());
   const state = getStateAdapter();
   await state.connect();
   await state.set(
@@ -7382,7 +7921,7 @@ async function setSandboxEgressPermissionDeniedSignal(context, signal) {
       ...signal,
       createdAtMs: Date.now()
     },
-    ttlMs
+    ttlMs2
   );
 }
 async function clearSandboxEgressSignals(egressId) {
@@ -9383,12 +9922,12 @@ async function getMcpAuthSession(authSessionId) {
   const stateAdapter = await getConnectedStateAdapter();
   return parseMcpAuthSession(await stateAdapter.get(sessionKey(authSessionId)));
 }
-async function putMcpAuthSession(session, ttlMs = MCP_AUTH_SESSION_TTL_MS) {
+async function putMcpAuthSession(session, ttlMs2 = MCP_AUTH_SESSION_TTL_MS) {
   const stateAdapter = await getConnectedStateAdapter();
   await stateAdapter.set(
     sessionKey(session.authSessionId),
     JSON.stringify(session),
-    ttlMs
+    ttlMs2
   );
   const nextIndex = parseSessionIndex(
     await stateAdapter.get(sessionIndexKey(session.userId, session.provider))
@@ -9399,7 +9938,7 @@ async function putMcpAuthSession(session, ttlMs = MCP_AUTH_SESSION_TTL_MS) {
   await stateAdapter.set(
     sessionIndexKey(session.userId, session.provider),
     JSON.stringify(nextIndex),
-    ttlMs
+    ttlMs2
   );
 }
 async function patchMcpAuthSession(authSessionId, patch) {
@@ -9479,12 +10018,12 @@ async function getMcpStoredOAuthCredentials(userId, provider) {
     await stateAdapter.get(credentialsKey(userId, provider))
   );
 }
-async function putMcpStoredOAuthCredentials(userId, provider, value, ttlMs = MCP_AUTH_CREDENTIALS_TTL_MS) {
+async function putMcpStoredOAuthCredentials(userId, provider, value, ttlMs2 = MCP_AUTH_CREDENTIALS_TTL_MS) {
   const stateAdapter = await getConnectedStateAdapter();
   await stateAdapter.set(
     credentialsKey(userId, provider),
     JSON.stringify(value),
-    ttlMs
+    ttlMs2
   );
 }
 async function deleteMcpStoredOAuthCredentials(userId, provider) {
@@ -9497,7 +10036,7 @@ async function getMcpServerSessionId(userId, provider) {
     await stateAdapter.get(serverSessionKey(userId, provider))
   )?.sessionId;
 }
-async function putMcpServerSessionId(userId, provider, sessionId, ttlMs = MCP_SERVER_SESSION_TTL_MS) {
+async function putMcpServerSessionId(userId, provider, sessionId, ttlMs2 = MCP_SERVER_SESSION_TTL_MS) {
   const stateAdapter = await getConnectedStateAdapter();
   await stateAdapter.set(
     serverSessionKey(userId, provider),
@@ -9505,7 +10044,7 @@ async function putMcpServerSessionId(userId, provider, sessionId, ttlMs = MCP_SE
       sessionId,
       updatedAtMs: Date.now()
     }),
-    ttlMs
+    ttlMs2
   );
 }
 async function deleteMcpServerSessionId(userId, provider) {
@@ -9525,6 +10064,15 @@ async function unlinkProvider(userId, provider, userTokenStore) {
 
 // src/chat/services/pending-auth.ts
 var AUTH_LINK_REUSE_WINDOW_MS = 10 * 60 * 1e3;
+var NON_REQUEST_SKIPPED_REASON_PREFIXES = [
+  "directed_to_other_party:",
+  "side_conversation:"
+];
+function isSkippedNonRequest(reason) {
+  return NON_REQUEST_SKIPPED_REASON_PREFIXES.some(
+    (prefix) => reason?.startsWith(prefix)
+  );
+}
 function canReusePendingAuthLink(args) {
   const { pendingAuth } = args;
   if (!pendingAuth) {
@@ -9568,6 +10116,12 @@ function isPendingAuthLatestRequest(conversation, pendingAuth) {
     if (message?.role !== "user") {
       continue;
     }
+    if (message.author?.isBot) {
+      continue;
+    }
+    if (isSkippedNonRequest(message.meta?.skippedReason)) {
+      continue;
+    }
     return buildDeterministicTurnId(message.id) === pendingAuth.sessionId;
   }
   return false;
@@ -10207,7 +10761,7 @@ function buildTurnResult(input) {
 }
 
 // src/chat/services/turn-thinking-level.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var CLASSIFIER_CONFIDENCE_THRESHOLD = 0.75;
 var MAX_ROUTER_CONTEXT_CHARS = 8e3;
 var ROUTER_CONTEXT_HEAD_CHARS = 3e3;
@@ -10239,13 +10793,13 @@ function coerceClassifierConfidence(value) {
   }
   return CONFIDENCE_LABELS[trimmed] ?? value;
 }
-var turnExecutionProfileSchema = z2.object({
-  thinking_level: z2.enum(TURN_THINKING_LEVELS),
-  confidence: z2.preprocess(
+var turnExecutionProfileSchema = z3.object({
+  thinking_level: z3.enum(TURN_THINKING_LEVELS),
+  confidence: z3.preprocess(
     coerceClassifierConfidence,
-    z2.number().min(0).max(1)
+    z3.number().min(0).max(1)
   ),
-  reason: z2.string().min(1)
+  reason: z3.string().min(1)
 });
 var DEFAULT_THINKING_LEVEL = "medium";
 var THINKING_LEVEL_RANK = {
@@ -14215,6 +14769,8 @@ export {
   setConfigDefaults,
   getConfigDefaults,
   createUserTokenStore,
+  findMatchingResourceEventSubscriptions,
+  deliverResourceEventSubscription,
   listThreadReplies,
   postSlackMessage,
   deleteSlackMessage,