@sentry/junior 0.174.0 → 0.176.0

package/dist/{chunk-GX2ISGLH.js → chunk-GYRGJVWR.js}

@@ -7,7 +7,7 @@ import {
   PluginCredentialFailureError,
   agentNameSchema,
   createPluginAuthOrchestration
-} from "./chunk-W6HVH5JJ.js";
+} from "./chunk-RSIHA3XC.js";
 import {
   authorizationId
 } from "./chunk-DIB4GX3G.js";
@@ -32,7 +32,7 @@ import {
   searchSlackUsers,
   selectPluginGrant,
   toMcpProviderError
-} from "./chunk-7V25DLCB.js";
+} from "./chunk-Q374NKGS.js";
 import {
   RetryableDeliveryError,
   actorFromRun,
@@ -48,7 +48,7 @@ import {
   getSlackMessagePermalink,
   resolveBaseUrl,
   uploadFilesToConversation
-} from "./chunk-DIW6IQYK.js";
+} from "./chunk-665JOQEP.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
@@ -87,10 +87,10 @@ import {
   scheduledTaskAttributes,
   storeAttachments,
   writableEventTask
-} from "./chunk-OTAPFODZ.js";
+} from "./chunk-IPOB6IL5.js";
 import {
   parseSlackThreadId
-} from "./chunk-5EWBGDW2.js";
+} from "./chunk-AJEZETLT.js";
 import {
   AGENTS_REMOVAL_NOTICE,
   AGENTS_REPLACEMENT_NOTICE,
@@ -101,7 +101,6 @@ import {
   RIPGREP_EXCLUDED_GLOBS,
   SHORT_TITLE_MAX_LENGTH,
   TURN_CONTEXT_TAG,
-  ToolInputError,
   TurnInputCommitLostError,
   TurnSliceLimitExceededError,
   abandonReplacedPendingAuth,
@@ -161,10 +160,7 @@ import {
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   truncateText
-} from "./chunk-2BNKQSPC.js";
-import {
-  JUNIOR_THREAD_STATE_TTL_MS
-} from "./chunk-3Y47VMHV.js";
+} from "./chunk-64EGCW34.js";
 import {
   bindSandboxFileSystem,
   createSandboxSession,
@@ -180,15 +176,24 @@ import {
   stopSession,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-BFNNCBTK.js";
+} from "./chunk-FNOLPLXJ.js";
 import {
   privateTraceResultAttributes
 } from "./chunk-UIE3R5XU.js";
 import {
+  RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS,
+  RESOURCE_SUBSCRIPTION_MAX_TTL_MS,
+  RESOURCE_WATCH_TOOL_SOURCE,
   SANDBOX_RUNTIME,
+  STOP_WATCHING_TOOL_NAME,
   SlackActionError,
+  ToolInputError,
   WorkspaceValidationError,
+  canUseResourceEventSubscriptionTools,
+  cancelResourceEventSubscription,
+  cancelSubscriptions,
   createPluginHookRunner,
+  createResourceEventSubscription,
   createWorkspace,
   deleteWorkspace,
   downloadPrivateSlackFile,
@@ -203,16 +208,18 @@ import {
   getWorkspace,
   getWorkspaceByName,
   isConversationScopedChannel,
+  listResourceEventSubscriptions,
   listWorkspaces,
   normalizeSlackConversationId,
   readActorIdentity,
   recordResolvedWorkspaceSnapshot,
+  requireResourceWatchConversation,
   resolveChannelCapabilities,
   tryWorkspaceRepoCheckoutPath,
   updateWorkspace,
   withSlackRetries,
   workspaceRepoCheckoutPath
-} from "./chunk-BLBKORDG.js";
+} from "./chunk-JIZ3RFER.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
@@ -224,11 +231,11 @@ import {
   instructionActors,
   instructionProvenanceFor,
   sameActorIdentity
-} from "./chunk-JVORBSUR.js";
+} from "./chunk-JHCAX7XY.js";
 import {
   juniorArtifacts,
   juniorIdentities
-} from "./chunk-VZFLAGFK.js";
+} from "./chunk-CUA5SZR5.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_REPOS_ROOT,
@@ -243,10 +250,10 @@ import {
   sandboxSkillFile,
   sandboxSkillPathResolution,
   sleep
-} from "./chunk-XOXKL2DL.js";
+} from "./chunk-CNC65LIX.js";
 import {
   getStateAdapter
-} from "./chunk-HJFWO72I.js";
+} from "./chunk-B6IOTX7W.js";
 import {
   ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
@@ -279,7 +286,7 @@ import {
   resolveGatewayCredential,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-OXYAEFKS.js";
+} from "./chunk-Z2YZ6QLG.js";
 import {
   canExposeConversationPayload,
   resolveConversationPrivacy,
@@ -289,16 +296,16 @@ import {
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes
-} from "./chunk-FFUNPZA2.js";
+} from "./chunk-H7KTMGNI.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-GWZBBIV6.js";
+} from "./chunk-B65VEBJV.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-RL23S5DG.js";
+} from "./chunk-5JB5JJO5.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -306,7 +313,7 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-IYI7RPHU.js";
+} from "./chunk-CI4JX64I.js";
 import {
   credentialUserSubjectId
 } from "./chunk-CGA4ERJ5.js";
@@ -336,7 +343,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-Z23POK2V.js";
+} from "./chunk-SBIQ5MZW.js";
 import {
   startInactiveSpan,
   withActiveSpan
@@ -7555,452 +7562,19 @@ function createSpawnAgentTool(spawnAgent) {
   });
 }
 
-// src/chat/resource-events/tool-support.ts
-var STOP_WATCHING_TOOL_NAME = "stopWatchingResources";
-var RESOURCE_WATCH_TOOL_SOURCE = {
-  id: "resource-watches",
-  description: "Inspect or stop resource watches for the current conversation."
-};
-function requireResourceWatchConversation(context) {
-  if (!context.conversationId) {
-    throw new ToolInputError(
-      "Resource event subscriptions require a conversation"
-    );
-  }
-  if (context.destination.platform !== "slack") {
-    throw new ToolInputError(
-      "Resource event subscriptions currently require Slack delivery"
-    );
-  }
-  if (!isSlackThreadConversationId(context.conversationId)) {
-    throw new ToolInputError(
-      "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]);
-}
-
 // src/chat/tools/list-resource-event-subscriptions.ts
-import { z as z19 } from "zod";
-
-// src/chat/resource-events/store.ts
-import { createHash } from "crypto";
-import {
-  destinationSchema,
-  resourceEventTypeSchema
-} from "@sentry/junior-plugin-api";
 import { z as z18 } from "zod";
-var RESOURCE_EVENT_PREFIX = "junior:resource_event_subscription:v3";
-var INDEX_LOCK_TTL_MS = 1e4;
-var SUBSCRIPTION_LOCK_TTL_MS = 1e4;
-var SUBSCRIPTION_LOCK_WAIT_MS = 1e4;
-var SUBSCRIPTION_LOCK_RETRY_MS = 25;
-var SUBSCRIPTION_LOCK_HEARTBEAT_MS = 3e3;
-var subscriptionStatusSchema = z18.enum(["active", "cancelled", "completed"]);
-var subscriptionIdIndexSchema = z18.array(z18.string().min(1));
-var subscriptionSchema = z18.object({
-  conversationId: z18.string().min(1),
-  createdAtMs: z18.number().finite(),
-  destination: destinationSchema,
-  events: z18.array(resourceEventTypeSchema).min(1),
-  expiresAtMs: z18.number().finite(),
+var listedResourceWatchSchema = z18.object({
   id: z18.string().min(1),
-  intent: z18.string().min(1),
   label: z18.string().min(1),
-  namespace: z18.string().min(1),
   identifier: z18.string().min(1),
+  namespace: z18.string().min(1),
   resourceType: z18.string().min(1),
-  status: subscriptionStatusSchema,
-  updatedAtMs: z18.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(teamId, namespace, identifier) {
-  return `${RESOURCE_EVENT_PREFIX}:resource:${digest(`${teamId}\0${namespace}\0${identifier}`)}`;
-}
-function subscriptionTeamId(destination) {
-  if (destination.platform !== "slack") {
-    throw new Error("Resource event subscriptions require a Slack destination");
-  }
-  return destination.teamId;
-}
-function conversationIndexKey(conversationId) {
-  return `${RESOURCE_EVENT_PREFIX}:conversation:${digest(conversationId)}`;
-}
-function indexLockKey(key) {
-  return `${key}:lock`;
-}
-async function sleep2(ms) {
-  await new Promise((resolve2) => {
-    const timer = setTimeout(resolve2, ms);
-    timer.unref?.();
-  });
-}
-async function acquireSubscriptionLock(state, subscriptionId, waitDeadlineMs = Date.now() + SUBSCRIPTION_LOCK_WAIT_MS) {
-  while (true) {
-    const lock = await state.acquireLock(
-      subscriptionLockKey(subscriptionId),
-      SUBSCRIPTION_LOCK_TTL_MS
-    );
-    if (lock) {
-      return lock;
-    }
-    if (Date.now() >= waitDeadlineMs) {
-      throw new Error(
-        `Could not acquire resource event subscription lock for ${subscriptionId}`
-      );
-    }
-    await sleep2(SUBSCRIPTION_LOCK_RETRY_MS);
-  }
-}
-async function withSubscriptionLock(state, subscriptionId, callback, waitDeadlineMs) {
-  const lock = await acquireSubscriptionLock(
-    state,
-    subscriptionId,
-    waitDeadlineMs
-  );
-  let lockLostError;
-  let heartbeatError;
-  let heartbeat;
-  const timer = setInterval(() => {
-    if (heartbeat) {
-      return;
-    }
-    heartbeat = state.extendLock(lock, SUBSCRIPTION_LOCK_TTL_MS).then((extended) => {
-      if (extended) {
-        heartbeatError = void 0;
-      } else {
-        lockLostError = new Error(
-          `Resource event subscription lock was lost for ${subscriptionId}`
-        );
-      }
-    }).catch((error) => {
-      heartbeatError = error instanceof Error ? error : new Error(`Failed to extend subscription lock: ${String(error)}`);
-    }).finally(() => {
-      heartbeat = void 0;
-    });
-  }, SUBSCRIPTION_LOCK_HEARTBEAT_MS);
-  timer.unref?.();
-  let result;
-  try {
-    result = await callback();
-  } finally {
-    clearInterval(timer);
-    await heartbeat;
-    await state.releaseLock(lock);
-  }
-  const lockError = lockLostError ?? heartbeatError;
-  if (lockError) {
-    throw lockError;
-  }
-  return result;
-}
-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.teamId}\0${input.namespace}\0${input.identifier}\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(
-      (record2) => record2 !== void 0 && activeAt(record2, nowMs)
-    ).map((record2) => record2.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.namespace === input.namespace && subscription.identifier === input.identifier && subscriptionTeamId(subscription.destination) === input.teamId && 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,
-    namespace: input.namespace,
-    identifier: input.identifier,
-    teamId: subscriptionTeamId(input.destination)
-  });
-  const record2 = {
-    conversationId: input.conversationId,
-    createdAtMs: nowMs,
-    destination: input.destination,
-    events,
-    expiresAtMs: input.expiresAtMs,
-    id,
-    intent: input.intent,
-    label: input.label,
-    namespace: input.namespace,
-    identifier: input.identifier,
-    resourceType: input.resourceType,
-    status: "active",
-    updatedAtMs: nowMs
-  };
-  const parsed = subscriptionSchema.parse(record2);
-  await state.set(
-    subscriptionKey(id),
-    parsed,
-    ttlUntil(parsed.expiresAtMs, nowMs)
-  );
-  await addToIndex(
-    state,
-    resourceIndexKey(
-      subscriptionTeamId(parsed.destination),
-      input.namespace,
-      input.identifier
-    ),
-    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(
-    (record2) => record2 !== void 0 && record2.conversationId === input.conversationId && activeAt(record2, nowMs)
-  ).sort((left, right) => left.createdAtMs - right.createdAtMs);
-}
-async function cancelResourceEventSubscription(input) {
-  const state = input.state ?? getStateAdapter();
-  await state.connect();
-  return await withSubscriptionLock(state, input.id, async () => {
-    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(
-        subscriptionTeamId(current.destination),
-        current.namespace,
-        current.identifier
-      ),
-      input.id,
-      nowMs
-    );
-    await removeFromIndex(
-      state,
-      conversationIndexKey(current.conversationId),
-      input.id,
-      nowMs
-    );
-    return next;
-  });
-}
-async function cancelSubscriptions(input) {
-  const subscriptions = await listResourceEventSubscriptions(input);
-  for (const subscription of subscriptions) {
-    await cancelResourceEventSubscription({
-      conversationId: input.conversationId,
-      id: subscription.id,
-      nowMs: input.nowMs,
-      state: input.state
-    });
-  }
-}
-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.teamId, input.namespace, input.identifier)
-  );
-  const records = await Promise.all(
-    ids.map(
-      async (id) => parseSubscription(await state.get(subscriptionKey(id)))
-    )
-  );
-  return records.filter(
-    (record2) => record2 !== void 0 && matchesEvent(record2, {
-      eventType: input.eventType,
-      nowMs,
-      namespace: input.namespace,
-      identifier: input.identifier,
-      teamId: input.teamId
-    })
-  );
-}
-async function deliverResourceEventSubscription(input) {
-  const state = input.state ?? getStateAdapter();
-  await state.connect();
-  return await withSubscriptionLock(
-    state,
-    input.subscription.id,
-    async () => {
-      const nowMs = input.nowMs ?? Date.now();
-      const current = parseSubscription(
-        await state.get(subscriptionKey(input.subscription.id))
-      );
-      if (!current || !matchesEvent(current, {
-        eventType: input.eventType,
-        nowMs,
-        namespace: input.namespace,
-        identifier: input.identifier,
-        teamId: input.teamId
-      })) {
-        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(
-            subscriptionTeamId(current.destination),
-            current.namespace,
-            current.identifier
-          ),
-          current.id,
-          nowMs
-        );
-        await removeFromIndex(
-          state,
-          conversationIndexKey(current.conversationId),
-          current.id,
-          nowMs
-        );
-      }
-      return delivered;
-    },
-    input.waitDeadlineMs
-  );
-}
-
-// src/chat/tools/list-resource-event-subscriptions.ts
-var listedResourceWatchSchema = z19.object({
-  id: z19.string().min(1),
-  label: z19.string().min(1),
-  identifier: z19.string().min(1),
-  namespace: z19.string().min(1),
-  resourceType: z19.string().min(1),
-  events: z19.array(z19.string().min(1)).min(1),
-  intent: z19.string().min(1),
-  expiresAtMs: z19.number().finite()
+  events: z18.array(z18.string().min(1)).min(1),
+  intent: z18.string().min(1),
+  expiresAtMs: z18.number().finite()
 }).strict();
-var resultDataSchema = z19.object({ subscriptions: z19.array(listedResourceWatchSchema) }).strict();
+var resultDataSchema = z18.object({ subscriptions: z18.array(listedResourceWatchSchema) }).strict();
 var outputSchema = juniorToolOutputSchema.extend({
   ...resultDataSchema.shape
 }).strict();
@@ -8015,7 +7589,7 @@ function createListResourceEventSubscriptionsTool(context) {
     description: "List active resource event subscriptions for the current conversation.",
     exposure: "deferred",
     source: RESOURCE_WATCH_TOOL_SOURCE,
-    inputSchema: z19.object({}).strict(),
+    inputSchema: z18.object({}).strict(),
     outputSchema,
     async execute() {
       const conversationId = requireResourceWatchConversation(context);
@@ -8042,20 +7616,20 @@ function createListResourceEventSubscriptionsTool(context) {
 }
 
 // src/chat/tools/search-resource-event-types.ts
-import { z as z20 } from "zod";
+import { z as z19 } from "zod";
 var DEFAULT_SEARCH_RESULTS = 10;
 var MAX_SEARCH_RESULTS = 20;
-var searchedResourceTypeSchema = z20.object({
-  namespace: z20.string(),
-  type: z20.string(),
-  supportedEvents: z20.array(z20.string()),
-  suggestedEvents: z20.array(z20.string()).optional()
+var searchedResourceTypeSchema = z19.object({
+  namespace: z19.string(),
+  type: z19.string(),
+  supportedEvents: z19.array(z19.string()),
+  suggestedEvents: z19.array(z19.string()).optional()
 }).strict();
 var outputSchema2 = juniorToolOutputSchema.extend({
-  query: z20.string().nullable(),
-  namespace: z20.string().nullable(),
-  totalMatches: z20.number().int().nonnegative(),
-  resourceTypes: z20.array(searchedResourceTypeSchema)
+  query: z19.string().nullable(),
+  namespace: z19.string().nullable(),
+  totalMatches: z19.number().int().nonnegative(),
+  resourceTypes: z19.array(searchedResourceTypeSchema)
 }).strict();
 function normalizeSearchText(value) {
   return value.toLowerCase().replace(/[^a-z0-9_.-]+/g, " ").trim();
@@ -8081,12 +7655,12 @@ function createSearchResourceEventTypesTool(catalog) {
       readOnlyHint: true
     },
     description: "Search the resource event types currently enabled by plugins without creating anything. Use watchResourceEvents to receive temporary updates in the current Slack thread; use createEventTask to execute a durable instruction for matching events. When explaining results, preserve that distinction. This tool does not watch a resource, create a task, or enumerate concrete resources.",
-    inputSchema: z20.object({
-      query: z20.string().nullable().describe(
+    inputSchema: z19.object({
+      query: z19.string().nullable().describe(
         "Optional terms matching a namespace, resource type, or event name. Empty lists all enabled resource event types."
       ).optional(),
       namespace: eventNamespaceSchema(catalog).nullable().describe("Optional enabled plugin namespace to search within.").optional(),
-      maxResults: z20.number().int().min(1).max(MAX_SEARCH_RESULTS).nullable().describe("Maximum matching resource types to return.").optional()
+      maxResults: z19.number().int().min(1).max(MAX_SEARCH_RESULTS).nullable().describe("Maximum matching resource types to return.").optional()
     }).strict(),
     outputSchema: outputSchema2,
     async execute({ query, namespace, maxResults }) {
@@ -8124,10 +7698,10 @@ function createSearchResourceEventTypesTool(catalog) {
 }
 
 // src/chat/tools/stop-watching-resources.ts
-import { z as z21 } from "zod";
-var resultDataSchema2 = z21.object({
-  watching_status: z21.literal("stopped"),
-  stoppedIds: z21.array(z21.string().min(1))
+import { z as z20 } from "zod";
+var resultDataSchema2 = z20.object({
+  watching_status: z20.literal("stopped"),
+  stoppedIds: z20.array(z20.string().min(1))
 }).strict();
 var outputSchema3 = juniorToolOutputSchema.extend({
   ...resultDataSchema2.shape
@@ -8143,7 +7717,7 @@ function createStopWatchingResourcesTool(context) {
     description: "Stop one resource watch in the current Slack thread by id. Omit id only when the user explicitly asks to stop every watch in this thread. Infer terse stop requests from context, inspect active watches when the target is unclear, and call this tool before confirming that watching stopped.",
     exposure: "deferred",
     source: RESOURCE_WATCH_TOOL_SOURCE,
-    inputSchema: z21.object({ id: z21.string().min(1).nullable().optional() }).strict(),
+    inputSchema: z20.object({ id: z20.string().min(1).nullable().optional() }).strict(),
     outputSchema: outputSchema3,
     async execute({ id }) {
       const conversationId = requireResourceWatchConversation(context);
@@ -8178,26 +7752,24 @@ function createStopWatchingResourcesTool(context) {
 }
 
 // src/chat/tools/watch-resource-events.ts
-import { z as z22 } from "zod";
-var DEFAULT_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
-var MAX_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+import { z as z21 } from "zod";
 function inputSchema(catalog) {
-  return z22.object({
-    identifier: z22.string().trim().min(1).describe("Plugin-defined resource identifier."),
+  return z21.object({
+    identifier: z21.string().trim().min(1).describe("Plugin-defined resource identifier."),
     namespace: eventNamespaceSchema(catalog).describe(
       "Enabled plugin namespace for this resource."
     ),
     resourceType: registeredResourceTypeSchema(catalog).describe(
       "Plugin-defined resource type."
     ),
-    label: z22.string().trim().min(1).max(500).describe("Human-readable resource label."),
-    events: z22.array(registeredEventTypeSchema(catalog)).min(1).describe(
+    label: z21.string().trim().min(1).max(500).describe("Human-readable resource label."),
+    events: z21.array(registeredEventTypeSchema(catalog)).min(1).describe(
       "High-signal event names to deliver to this conversation when they occur."
     ),
-    intent: z22.string().trim().min(1).max(4e3).describe(
+    intent: z21.string().trim().min(1).max(4e3).describe(
       "Concise reason this conversation wants these events, used when an event arrives."
     ),
-    ttlMs: z22.coerce.number().describe(
+    ttlMs: z21.coerce.number().describe(
       "How long to keep the subscription active. Defaults to 14 days and must not exceed 30 days."
     ).optional()
   }).strict().superRefine((subscription, context) => {
@@ -8217,19 +7789,19 @@ function inputSchema(catalog) {
     });
   });
 }
-var stopWatchingActionSchema = z22.object({
-  execution_tool: z22.literal("executeTool"),
-  execution_example: z22.object({
-    tool_name: z22.literal(STOP_WATCHING_TOOL_NAME),
-    arguments: z22.object({ id: z22.string().min(1) }).strict()
+var stopWatchingActionSchema = z21.object({
+  execution_tool: z21.literal("executeTool"),
+  execution_example: z21.object({
+    tool_name: z21.literal(STOP_WATCHING_TOOL_NAME),
+    arguments: z21.object({ id: z21.string().min(1) }).strict()
   }).strict()
 }).strict();
-var resultDataSchema3 = z22.object({
-  id: z22.string().min(1),
-  subscription_status: z22.enum(["active", "cancelled", "completed"]),
-  identifier: z22.string().min(1),
-  events: z22.array(z22.string().min(1)).min(1),
-  expiresAtMs: z22.number().finite(),
+var resultDataSchema3 = z21.object({
+  id: z21.string().min(1),
+  subscription_status: z21.enum(["active", "cancelled", "completed"]),
+  identifier: z21.string().min(1),
+  events: z21.array(z21.string().min(1)).min(1),
+  expiresAtMs: z21.number().finite(),
   stop_watching: stopWatchingActionSchema
 }).strict();
 var outputSchema4 = juniorToolOutputSchema.extend({
@@ -8239,11 +7811,11 @@ 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 (input.ttlMs === void 0) return RESOURCE_SUBSCRIPTION_DEFAULT_TTL_MS;
   if (!Number.isFinite(input.ttlMs) || input.ttlMs <= 0) {
     throw new ToolInputError("ttlMs must be a positive finite number");
   }
-  if (input.ttlMs > MAX_TTL_MS) {
+  if (input.ttlMs > RESOURCE_SUBSCRIPTION_MAX_TTL_MS) {
     throw new ToolInputError("Resource watches cannot exceed 30 days");
   }
   return input.ttlMs;
@@ -8333,14 +7905,14 @@ function createResourceEventTools(context, catalog) {
 }
 
 // src/chat/tools/create-event-task.ts
-import { createHash as createHash2 } from "crypto";
-import { z as z23 } from "zod";
+import { createHash } from "crypto";
+import { z as z22 } from "zod";
 function buildEventTaskId(args) {
   const toolCallId = args.toolCallId?.trim();
   if (!toolCallId) {
     throw new Error("Event task creation requires a tool-call identity.");
   }
-  const digest2 = createHash2("sha256").update(
+  const digest = createHash("sha256").update(
     JSON.stringify({
       actor: args.userId,
       channel: args.channelId,
@@ -8348,7 +7920,7 @@ function buildEventTaskId(args) {
       team: args.teamId
     })
   ).digest("hex").slice(0, 32);
-  return `evt_${digest2}`;
+  return `evt_${digest}`;
 }
 function createEventTaskTool(context, catalog) {
   const trigger = registeredEventTaskTriggerSchema(catalog);
@@ -8362,13 +7934,13 @@ function createEventTaskTool(context, catalog) {
     },
     executionMode: "sequential",
     description: "Create a durable event task that executes the supplied instruction for every matching resource event. Use for whenever-this-happens-do-X automation; ordinary watch, notify, or tell-me-when requests use watchResourceEvents instead. The task remains configured for this Slack channel or DM until deleted and may use the creator's connected credentials. Prefer a subscribable tool result when available.",
-    inputSchema: z23.object({
-      task: z23.string().trim().min(1).max(4e3),
-      title: z23.string().trim().min(1).max(SHORT_TITLE_MAX_LENGTH).nullable().describe(
+    inputSchema: z22.object({
+      task: z22.string().trim().min(1).max(4e3),
+      title: z22.string().trim().min(1).max(SHORT_TITLE_MAX_LENGTH).nullable().describe(
         "Optional short display title. Omit or use null to generate one from the task instruction."
       ).optional(),
       trigger,
-      credentialMode: z23.enum(["creator", "system"]).nullable().describe(
+      credentialMode: z22.enum(["creator", "system"]).nullable().describe(
         "Use creator to make the task creator's connected credentials available, or system when the creator says not to use them. Omit or use null for the creator default."
       ).optional()
     }).strict(),
@@ -8437,7 +8009,7 @@ function createEventTaskTool(context, catalog) {
 }
 
 // src/chat/tools/delete-event-task.ts
-import { z as z24 } from "zod";
+import { z as z23 } from "zod";
 function createDeleteEventTaskTool(context, catalog) {
   return zodTool({
     approvalMode: "review",
@@ -8449,7 +8021,7 @@ function createDeleteEventTaskTool(context, catalog) {
     },
     executionMode: "sequential",
     description: "Delete an event task from this Slack channel or DM, including a task created from another thread in the same destination.",
-    inputSchema: z24.object({ taskId: z24.string().min(1) }).strict(),
+    inputSchema: z23.object({ taskId: z23.string().min(1) }).strict(),
     outputSchema: eventTaskToolResultSchema,
     async execute({ taskId }) {
       const current = await writableEventTask(context, taskId);
@@ -8465,7 +8037,7 @@ function createDeleteEventTaskTool(context, catalog) {
 }
 
 // src/chat/tools/list-event-tasks.ts
-import { z as z25 } from "zod";
+import { z as z24 } from "zod";
 var MAX_LISTED_EVENT_TASKS = 50;
 function createListEventTasksTool(context, catalog) {
   return zodTool({
@@ -8476,7 +8048,7 @@ function createListEventTasksTool(context, catalog) {
       readOnlyHint: true
     },
     description: "List event tasks for this Slack channel or DM, including tasks created from other threads in the same destination. A false triggerAvailable value means the task remains stored but its plugin event is not currently enabled.",
-    inputSchema: z25.object({}).strict(),
+    inputSchema: z24.object({}).strict(),
     outputSchema: eventTaskListToolResultSchema,
     async execute() {
       const { destination } = requireEventTaskSlackContext(context);
@@ -8491,7 +8063,7 @@ function createListEventTasksTool(context, catalog) {
 }
 
 // src/chat/tools/update-event-task.ts
-import { z as z26 } from "zod";
+import { z as z25 } from "zod";
 function changesEventTaskTrigger(current, next) {
   const currentEvents = [...current.events].sort();
   const nextEvents = [...next.events].sort();
@@ -8508,11 +8080,11 @@ function createUpdateEventTaskTool(context, catalog) {
     },
     executionMode: "sequential",
     description: "Update the instruction, registered trigger, or credential use for an event task in this Slack channel or DM. Event tasks created from other threads in the same destination are manageable here.",
-    inputSchema: z26.object({
-      taskId: z26.string().min(1),
-      task: z26.string().trim().min(1).max(4e3).nullable().optional(),
+    inputSchema: z25.object({
+      taskId: z25.string().min(1),
+      task: z25.string().trim().min(1).max(4e3).nullable().optional(),
       trigger: registeredEventTaskTriggerSchema(catalog).nullable().optional(),
-      credentialMode: z26.enum(["system", "creator"]).nullable().describe(
+      credentialMode: z25.enum(["system", "creator"]).nullable().describe(
         "Set creator to make the task's original creator credentials available, or system to disable them. Creator always means the task's createdBy actor, never the current requester. Only that original creator may enable creator mode. Omit or use null to leave unchanged."
       ).optional()
     }).strict(),
@@ -8597,16 +8169,16 @@ function createEventTaskTools(context, catalog) {
 }
 
 // src/chat/scheduled-tasks/tools/create.ts
-import { z as z29 } from "zod";
+import { z as z28 } from "zod";
 
 // src/chat/scheduled-tasks/schedule-intent.ts
-import { z as z27 } from "zod";
-var localDateSchema = z27.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Use a local date in YYYY-MM-DD format.");
-var localTimeSchema = z27.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "Use local time in HH:MM format.");
-var timezoneSchema = z27.string().min(1).max(80).describe(
+import { z as z26 } from "zod";
+var localDateSchema = z26.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Use a local date in YYYY-MM-DD format.");
+var localTimeSchema = z26.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "Use local time in HH:MM format.");
+var timezoneSchema = z26.string().min(1).max(80).describe(
   "IANA timezone, for example America/Los_Angeles. Omit or use null for the scheduler default."
 ).nullable().optional();
-var weekdaySchema = z27.enum([
+var weekdaySchema = z26.enum([
   "sunday",
   "monday",
   "tuesday",
@@ -8615,17 +8187,17 @@ var weekdaySchema = z27.enum([
   "friday",
   "saturday"
 ]);
-var oneOffScheduleIntentSchema = z27.object({
-  kind: z27.literal("one_off").describe("A schedule that runs once."),
+var oneOffScheduleIntentSchema = z26.object({
+  kind: z26.literal("one_off").describe("A schedule that runs once."),
   timezone: timezoneSchema,
-  timing: z27.discriminatedUnion("type", [
-    z27.object({
-      type: z27.literal("after").describe("Run after a relative delay from the server clock."),
-      value: z27.number().int().positive().max(1e5),
-      unit: z27.enum(["second", "minute", "hour", "day", "week"])
+  timing: z26.discriminatedUnion("type", [
+    z26.object({
+      type: z26.literal("after").describe("Run after a relative delay from the server clock."),
+      value: z26.number().int().positive().max(1e5),
+      unit: z26.enum(["second", "minute", "hour", "day", "week"])
     }).strict(),
-    z27.object({
-      type: z27.literal("at").describe("Run at an explicit local calendar date and time."),
+    z26.object({
+      type: z26.literal("at").describe("Run at an explicit local calendar date and time."),
       date: localDateSchema.describe(
         "Requested local calendar date in YYYY-MM-DD format."
       ),
@@ -8635,16 +8207,16 @@ var oneOffScheduleIntentSchema = z27.object({
     }).strict()
   ]).describe("Relative delay or explicit local time for the one-off run.")
 }).strict();
-var recurringScheduleIntentSchema = z27.object({
-  kind: z27.literal("recurring").describe("A repeating calendar schedule."),
-  frequency: z27.enum(["daily", "weekly", "monthly", "yearly"]).describe("Recurring tasks can run at most once per day."),
-  interval: z27.number().int().positive().max(365).describe("Repeat every N frequency units. Defaults to 1.").nullable().optional(),
+var recurringScheduleIntentSchema = z26.object({
+  kind: z26.literal("recurring").describe("A repeating calendar schedule."),
+  frequency: z26.enum(["daily", "weekly", "monthly", "yearly"]).describe("Recurring tasks can run at most once per day."),
+  interval: z26.number().int().positive().max(365).describe("Repeat every N frequency units. Defaults to 1.").nullable().optional(),
   time: localTimeSchema.describe(
     "Local wall-clock time for each occurrence in HH:MM format."
   ),
-  weekdays: z27.array(weekdaySchema).min(1).max(7).describe("Required for weekly schedules.").nullable().optional(),
-  day_of_month: z27.number().int().min(1).max(31).describe("Required for monthly and yearly schedules.").nullable().optional(),
-  month: z27.number().int().min(1).max(12).describe("Required for yearly schedules, where January is 1.").nullable().optional(),
+  weekdays: z26.array(weekdaySchema).min(1).max(7).describe("Required for weekly schedules.").nullable().optional(),
+  day_of_month: z26.number().int().min(1).max(31).describe("Required for monthly and yearly schedules.").nullable().optional(),
+  month: z26.number().int().min(1).max(12).describe("Required for yearly schedules, where January is 1.").nullable().optional(),
   start_date: localDateSchema.describe(
     "Optional local calendar date that anchors the recurrence. Omit to start with the next matching occurrence."
   ).nullable().optional(),
@@ -8693,7 +8265,7 @@ var recurringScheduleIntentSchema = z27.object({
     });
   }
 });
-var scheduleIntentSchema = z27.union([
+var scheduleIntentSchema = z26.union([
   oneOffScheduleIntentSchema,
   recurringScheduleIntentSchema
 ]);
@@ -8849,11 +8421,11 @@ function compileScheduleIntent(args) {
 }
 
 // src/chat/scheduled-tasks/tool-support.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import {
   sourceSchema
 } from "@sentry/junior-plugin-api";
-import { z as z28 } from "zod";
+import { z as z27 } from "zod";
 
 // src/chat/scheduled-tasks/identity.ts
 var SLACK_USER_ID_PATTERN = /^[UW][A-Z0-9]{5,}$/;
@@ -8890,36 +8462,36 @@ function sanitizeScheduledTaskPrincipal(principal) {
 var TASK_ID_PREFIX = "sched";
 var MAX_LISTED_TASKS = 50;
 var DEFAULT_SCHEDULE_TIMEZONE = "America/Los_Angeles";
-var compactTaskResultSchema = z28.object({
-  id: z28.string(),
-  status: z28.enum(["active", "blocked", "completed", "deleted"]),
-  task: z28.string(),
-  schedule: z28.string(),
-  timezone: z28.string(),
-  recurrence: z28.unknown().nullable(),
-  next_run_at: z28.string().nullable(),
-  destination: z28.object({
-    platform: z28.literal("slack"),
-    team_id: z28.string().min(1),
-    channel_id: z28.string().min(1)
+var compactTaskResultSchema = z27.object({
+  id: z27.string(),
+  status: z27.enum(["active", "blocked", "completed", "deleted"]),
+  task: z27.string(),
+  schedule: z27.string(),
+  timezone: z27.string(),
+  recurrence: z27.unknown().nullable(),
+  next_run_at: z27.string().nullable(),
+  destination: z27.object({
+    platform: z27.literal("slack"),
+    team_id: z27.string().min(1),
+    channel_id: z27.string().min(1)
   }).strict(),
-  conversation_access: z28.object({
-    audience: z28.enum(["direct", "group", "channel"]),
-    visibility: z28.enum(["private", "public"])
+  conversation_access: z27.object({
+    audience: z27.enum(["direct", "group", "channel"]),
+    visibility: z27.enum(["private", "public"])
   }).strict(),
-  credential_mode: z28.enum(["system", "creator"]),
-  dashboard_url: z28.string().url().nullable(),
-  last_run_at: z28.string().nullable(),
-  run_now_at: z28.string().nullable()
+  credential_mode: z27.enum(["system", "creator"]),
+  dashboard_url: z27.string().url().nullable(),
+  last_run_at: z27.string().nullable(),
+  run_now_at: z27.string().nullable()
 }).strict();
 var scheduleTaskToolResultSchema = juniorToolOutputSchema.extend({
-  target: z28.string(),
+  target: z27.string(),
   task: compactTaskResultSchema
 }).strict();
 var scheduleListToolResultSchema = juniorToolOutputSchema.extend({
-  target: z28.string(),
-  tasks: z28.array(compactTaskResultSchema),
-  truncated: z28.boolean()
+  target: z27.string(),
+  tasks: z27.array(compactTaskResultSchema),
+  truncated: z27.boolean()
 }).strict();
 function throwToolInputError(error) {
   throw new ToolInputError(error);
@@ -9049,7 +8621,7 @@ function buildTaskId(args) {
   if (!toolCallId) {
     throw new Error("Scheduler task creation requires a tool-call identity.");
   }
-  const digest2 = createHash3("sha256").update(
+  const digest = createHash2("sha256").update(
     JSON.stringify({
       actor: args.actor.slackUserId,
       channel: args.destination.channelId,
@@ -9058,7 +8630,7 @@ function buildTaskId(args) {
       team: args.destination.teamId
     })
   ).digest("hex").slice(0, 32);
-  return `${TASK_ID_PREFIX}_${digest2}`;
+  return `${TASK_ID_PREFIX}_${digest}`;
 }
 function schedulerStore(context) {
   return context.store;
@@ -9085,15 +8657,15 @@ function createSlackScheduleCreateTaskTool(context) {
     },
     description: "Create a one-time or recurring Junior task in the active Slack conversation when the user asks Junior to do work later or repeatedly.",
     executionMode: "sequential",
-    inputSchema: z29.object({
-      task: z29.string().min(1).max(4e3),
-      title: z29.string().trim().min(1).max(SHORT_TITLE_MAX_LENGTH).nullable().describe(
+    inputSchema: z28.object({
+      task: z28.string().min(1).max(4e3),
+      title: z28.string().trim().min(1).max(SHORT_TITLE_MAX_LENGTH).nullable().describe(
         "Optional short display title. Omit or use null to generate one from the task instruction."
       ).optional(),
       schedule: scheduleIntentSchema.describe(
         "When the task runs. The scheduler computes the exact next run from this intent and the server clock."
       ),
-      credential_mode: z29.enum(["creator", "system"]).nullable().describe(
+      credential_mode: z28.enum(["creator", "system"]).nullable().describe(
         "Use creator to make the task creator's connected credentials available, or system when the creator says not to use them. Omit or use null for the creator default."
       ).optional()
     }).strict(),
@@ -9192,7 +8764,7 @@ function createSlackScheduleCreateTaskTool(context) {
 }
 
 // src/chat/scheduled-tasks/tools/delete.ts
-import { z as z30 } from "zod";
+import { z as z29 } from "zod";
 function createSlackScheduleDeleteTaskTool(context) {
   return zodTool({
     approvalMode: "review",
@@ -9204,8 +8776,8 @@ function createSlackScheduleDeleteTaskTool(context) {
     },
     description: "Delete one scheduled Junior task from the active Slack conversation. Use only task IDs returned for this conversation. Do not delete schedules from threads, other channels, or another user's DM.",
     executionMode: "sequential",
-    inputSchema: z30.object({
-      task_id: z30.string().min(1).describe(
+    inputSchema: z29.object({
+      task_id: z29.string().min(1).describe(
         "ID of the task to delete. Must be from this active Slack conversation."
       )
     }),
@@ -9229,12 +8801,12 @@ function createSlackScheduleDeleteTaskTool(context) {
 }
 
 // src/chat/slack/id-param.ts
-import { z as z31 } from "zod";
+import { z as z30 } from "zod";
 function slackChannelIdParam(description) {
-  return z31.string().min(1).describe(description);
+  return z30.string().min(1).describe(description);
 }
 function slackUserIdParam(description) {
-  return z31.string().min(1).describe(description);
+  return z30.string().min(1).describe(description);
 }
 function parseRequiredSlackChannelIdParam(field, value) {
   const channelId = parseSlackChannelId(value);
@@ -9258,7 +8830,7 @@ function parseRequiredSlackUserIdParam(field, value) {
 }
 
 // src/chat/scheduled-tasks/tools/list.ts
-import { z as z32 } from "zod";
+import { z as z31 } from "zod";
 function taskMatchesQuery(task, query) {
   const normalized = query.toLowerCase();
   return [
@@ -9278,11 +8850,11 @@ function createSlackScheduleListTasksTool(context) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z32.object({
+    inputSchema: z31.object({
       channel_id: slackChannelIdParam(
         "Current destination channel ID to filter by. Use the ID from a channel mention; do not guess."
       ).nullable().optional(),
-      query: z32.string().trim().min(1).max(200).nullable().describe("Text to match in the requester's scheduled tasks.").optional()
+      query: z31.string().trim().min(1).max(200).nullable().describe("Text to match in the requester's scheduled tasks.").optional()
     }).strict(),
     outputSchema: scheduleListToolResultSchema,
     execute: async (input) => {
@@ -9330,7 +8902,7 @@ function createSlackScheduleListTasksTool(context) {
 }
 
 // src/chat/scheduled-tasks/tools/run-now.ts
-import { z as z33 } from "zod";
+import { z as z32 } from "zod";
 function createSlackScheduleRunTaskNowTool(context) {
   return zodTool({
     approvalMode: "review",
@@ -9342,8 +8914,8 @@ function createSlackScheduleRunTaskNowTool(context) {
     },
     description: "Queue an existing active scheduled Junior task to run as soon as possible, without changing its cadence. Use when the user asks to run an existing scheduled task now. Use only task IDs returned for this conversation.",
     executionMode: "sequential",
-    inputSchema: z33.object({
-      task_id: z33.string().min(1).describe(
+    inputSchema: z32.object({
+      task_id: z32.string().min(1).describe(
         "ID of the active task to run now. Must be from this active Slack conversation."
       )
     }),
@@ -9371,7 +8943,7 @@ function createSlackScheduleRunTaskNowTool(context) {
 }
 
 // src/chat/scheduled-tasks/tools/update.ts
-import { z as z34 } from "zod";
+import { z as z33 } from "zod";
 function createSlackScheduleUpdateTaskTool(context) {
   return zodTool({
     approvalMode: "review",
@@ -9383,17 +8955,17 @@ function createSlackScheduleUpdateTaskTool(context) {
     },
     description: `Update a scheduled task. To move the requester's task into this Slack conversation, set destination to "here".`,
     executionMode: "sequential",
-    inputSchema: z34.object({
-      task_id: z34.string().min(1).describe("Scheduled task ID returned by slackScheduleListTasks."),
-      task: z34.string().min(1).max(4e3).optional(),
+    inputSchema: z33.object({
+      task_id: z33.string().min(1).describe("Scheduled task ID returned by slackScheduleListTasks."),
+      task: z33.string().min(1).max(4e3).optional(),
       schedule: scheduleIntentSchema.describe("Complete replacement schedule. Omit to keep it unchanged.").nullable().optional(),
-      status: z34.enum(["active", "blocked"]).describe(
+      status: z33.enum(["active", "blocked"]).describe(
         "Set active to resume a blocked task, or blocked to stop dispatch."
       ).optional(),
-      destination: z34.literal("here").nullable().describe(
+      destination: z33.literal("here").nullable().describe(
         `Set to "here" to move the creator's task into this Slack conversation. Omit to keep its destination.`
       ).optional(),
-      credential_mode: z34.enum(["system", "creator"]).nullable().describe(
+      credential_mode: z33.enum(["system", "creator"]).nullable().describe(
         "Use creator credentials or system credentials. Only the task creator may enable creator mode. Omit to keep unchanged."
       ).optional()
     }).strict(),
@@ -9755,9 +9327,9 @@ async function joinPublicChannelForRead(args) {
 }
 
 // src/chat/slack/tool-support/channel-target.ts
-import { z as z35 } from "zod";
+import { z as z34 } from "zod";
 var SLACK_CHANNEL_REF_MAX_LENGTH = 160;
-var slackChannelRefParam = z35.string().trim().min(1).max(SLACK_CHANNEL_REF_MAX_LENGTH).describe(
+var slackChannelRefParam = z34.string().trim().min(1).max(SLACK_CHANNEL_REF_MAX_LENGTH).describe(
   "Slack channel id (`C123`), mention (`<#C123>` / `<#C123|name>`), Junior slack reference (`slack:C123`), or a channel name Junior already knows in this workspace."
 );
 async function resolveSlackChannelRef(input) {
@@ -9805,7 +9377,7 @@ async function resolveOptionalSlackChannelRef(input) {
 }
 
 // src/chat/slack/tools/channel-join.ts
-import { z as z36 } from "zod";
+import { z as z35 } from "zod";
 function createSlackChannelJoinTool(context) {
   return zodTool({
     description: "Join a public Slack channel.",
@@ -9815,7 +9387,7 @@ function createSlackChannelJoinTool(context) {
       openWorldHint: true,
       readOnlyHint: false
     },
-    inputSchema: z36.object({
+    inputSchema: z35.object({
       channel_id: slackChannelRefParam
     }),
     outputSchema: juniorToolOutputSchema,
@@ -9872,11 +9444,11 @@ function createSlackChannelJoinTool(context) {
 }
 
 // src/chat/slack/timestamp-param.ts
-import { z as z37 } from "zod";
+import { z as z36 } from "zod";
 function slackTimestampParam(description) {
-  return z37.preprocess(
+  return z36.preprocess(
     (value) => typeof value === "number" && Number.isFinite(value) ? String(value) : value,
-    z37.string().min(1)
+    z36.string().min(1)
   ).describe(description);
 }
 function parseSlackTimestampParam(field, value) {
@@ -9904,10 +9476,10 @@ function parseRequiredSlackTimestampParam(field, value) {
 }
 
 // src/chat/slack/tools/channel-list-messages.ts
-import { z as z38 } from "zod";
-var booleanInput2 = (description) => z38.preprocess(
+import { z as z37 } from "zod";
+var booleanInput2 = (description) => z37.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z38.boolean()
+  z37.boolean()
 ).describe(description);
 function normalizeRangeTimestamp(field, value, targetChannelId) {
   if (value === void 0) {
@@ -9939,10 +9511,10 @@ function createSlackChannelListMessagesTool(context) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z38.object({
+    inputSchema: z37.object({
       channel_id: slackChannelRefParam.optional(),
-      limit: z38.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
-      cursor: z38.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
+      limit: z37.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
+      cursor: z37.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
       oldest: slackTimestampParam(
         "Oldest message timestamp (Slack ts) for range filtering."
       ).optional(),
@@ -9952,7 +9524,7 @@ function createSlackChannelListMessagesTool(context) {
       inclusive: booleanInput2(
         "Whether oldest/latest bounds should be inclusive."
       ).optional(),
-      max_pages: z38.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
+      max_pages: z37.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({
@@ -10075,7 +9647,7 @@ function createSlackChannelListMessagesTool(context) {
 }
 
 // src/chat/slack/tools/conversation-message-search.ts
-import { z as z39 } from "zod";
+import { z as z38 } from "zod";
 
 // src/chat/conversations/tool-source.ts
 var CONVERSATIONS_TOOL_SOURCE = {
@@ -10087,23 +9659,23 @@ var CONVERSATIONS_TOOL_SOURCE = {
 var DEFAULT_LIMIT = 20;
 var MAX_LIMIT = 50;
 var conversationMessageSearchOutputSchema = juniorToolOutputSchema.extend({
-  after: z39.string().datetime().optional(),
-  annotation: z39.string().min(1).optional(),
-  before: z39.string().datetime().optional(),
-  channel_id: z39.string().min(1).optional(),
-  count: z39.number().int().nonnegative(),
-  query: z39.string().optional(),
-  matches: z39.array(
-    z39.object({
-      channel_id: z39.string().min(1),
-      channel_name: z39.string().min(1).optional(),
-      conversation_id: z39.string().min(1),
-      excerpt: z39.string(),
-      message_id: z39.string().min(1),
-      message_role: z39.enum(["assistant", "user"]),
-      message_timestamp: z39.string().datetime(),
-      permalink: z39.string().url().optional(),
-      thread_ts: z39.string().min(1)
+  after: z38.string().datetime().optional(),
+  annotation: z38.string().min(1).optional(),
+  before: z38.string().datetime().optional(),
+  channel_id: z38.string().min(1).optional(),
+  count: z38.number().int().nonnegative(),
+  query: z38.string().optional(),
+  matches: z38.array(
+    z38.object({
+      channel_id: z38.string().min(1),
+      channel_name: z38.string().min(1).optional(),
+      conversation_id: z38.string().min(1),
+      excerpt: z38.string(),
+      message_id: z38.string().min(1),
+      message_role: z38.enum(["assistant", "user"]),
+      message_timestamp: z38.string().datetime(),
+      permalink: z38.string().url().optional(),
+      thread_ts: z38.string().min(1)
     }).strict()
   )
 });
@@ -10158,15 +9730,15 @@ function createSlackConversationMessageSearchTool(scope, currentConversationId)
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z39.object({
-      after: z39.string().datetime().nullable().describe("Include conversations active at or after this timestamp.").optional(),
-      annotation: z39.string().trim().min(1).max(256).nullable().describe(
+    inputSchema: z38.object({
+      after: z38.string().datetime().nullable().describe("Include conversations active at or after this timestamp.").optional(),
+      annotation: z38.string().trim().min(1).max(256).nullable().describe(
         "Linked resource key. Matches that key, or nested children that continue with #."
       ).optional(),
-      before: z39.string().datetime().nullable().describe("Include conversations active before this timestamp.").optional(),
+      before: z38.string().datetime().nullable().describe("Include conversations active before this timestamp.").optional(),
       channel_id: slackChannelRefParam.nullable().optional(),
-      query: z39.string().trim().min(1).max(200).nullable().describe("Words or phrase to match in message text.").optional(),
-      limit: z39.number().int().min(1).max(MAX_LIMIT).describe(
+      query: z38.string().trim().min(1).max(200).nullable().describe("Words or phrase to match in message text.").optional(),
+      limit: z38.number().int().min(1).max(MAX_LIMIT).describe(
         `Maximum conversations. Default ${DEFAULT_LIMIT}; max ${MAX_LIMIT}.`
       ).nullable().optional()
     }).strict(),
@@ -10225,13 +9797,13 @@ function createSlackConversationMessageSearchTool(scope, currentConversationId)
 }
 
 // src/chat/slack/tools/public-search.ts
-import { z as z40 } from "zod";
+import { z as z39 } from "zod";
 var DEFAULT_LIMIT2 = 10;
 var DEFAULT_CONTENT_TYPES = ["messages"];
 var CONTENT_TYPES = ["messages", "files", "channels", "users"];
-var unixTimestampParam = z40.coerce.number().int().nonnegative();
+var unixTimestampParam = z39.coerce.number().int().nonnegative();
 function optionalUnixTimestampParam(description) {
-  return z40.preprocess(
+  return z39.preprocess(
     (value) => typeof value === "string" && value.trim() === "" ? void 0 : value,
     unixTimestampParam.optional()
   ).describe(description);
@@ -10245,64 +9817,64 @@ function normalizeOptionalUnixTimestamp(value) {
   }
   return unixTimestampParam.parse(value);
 }
-var searchMessageSchema = z40.object({
-  author_name: z40.string().min(1).optional().describe("Author display name."),
-  author_user_id: z40.string().min(1).optional().describe("Author user ID."),
-  channel_id: z40.string().min(1).describe("Channel ID."),
-  channel_name: z40.string().min(1).optional().describe("Channel name."),
-  message_ts: z40.string().min(1).describe("Message timestamp."),
-  content: z40.string().describe("Message text."),
-  is_author_bot: z40.boolean().optional().describe("Whether the author is a bot."),
-  permalink: z40.string().url().describe("Message permalink.")
+var searchMessageSchema = z39.object({
+  author_name: z39.string().min(1).optional().describe("Author display name."),
+  author_user_id: z39.string().min(1).optional().describe("Author user ID."),
+  channel_id: z39.string().min(1).describe("Channel ID."),
+  channel_name: z39.string().min(1).optional().describe("Channel name."),
+  message_ts: z39.string().min(1).describe("Message timestamp."),
+  content: z39.string().describe("Message text."),
+  is_author_bot: z39.boolean().optional().describe("Whether the author is a bot."),
+  permalink: z39.string().url().describe("Message permalink.")
 });
-var searchFileSchema = z40.object({
-  file_id: z40.string().min(1).describe("File ID."),
-  title: z40.string().min(1).optional().describe("File title."),
-  name: z40.string().min(1).optional().describe("File name."),
-  filetype: z40.string().min(1).optional().describe("File type."),
-  user_id: z40.string().min(1).optional().describe("Uploader user ID."),
-  user_name: z40.string().min(1).optional().describe("Uploader user name."),
-  channel_id: z40.string().min(1).optional().describe("Channel ID."),
-  channel_name: z40.string().min(1).optional().describe("Channel name."),
-  permalink: z40.string().url().optional().describe("File permalink."),
-  content: z40.string().min(1).optional().describe("File preview or content snippet.")
+var searchFileSchema = z39.object({
+  file_id: z39.string().min(1).describe("File ID."),
+  title: z39.string().min(1).optional().describe("File title."),
+  name: z39.string().min(1).optional().describe("File name."),
+  filetype: z39.string().min(1).optional().describe("File type."),
+  user_id: z39.string().min(1).optional().describe("Uploader user ID."),
+  user_name: z39.string().min(1).optional().describe("Uploader user name."),
+  channel_id: z39.string().min(1).optional().describe("Channel ID."),
+  channel_name: z39.string().min(1).optional().describe("Channel name."),
+  permalink: z39.string().url().optional().describe("File permalink."),
+  content: z39.string().min(1).optional().describe("File preview or content snippet.")
 });
-var searchChannelSchema = z40.object({
-  channel_id: z40.string().min(1).describe("Channel ID."),
-  channel_name: z40.string().min(1).optional().describe("Channel name."),
-  is_private: z40.boolean().optional().describe("Whether the channel is private."),
-  is_member: z40.boolean().optional().describe("Whether the bot is a member."),
-  topic: z40.string().min(1).optional().describe("Channel topic."),
-  purpose: z40.string().min(1).optional().describe("Channel purpose."),
-  permalink: z40.string().url().optional().describe("Channel permalink.")
+var searchChannelSchema = z39.object({
+  channel_id: z39.string().min(1).describe("Channel ID."),
+  channel_name: z39.string().min(1).optional().describe("Channel name."),
+  is_private: z39.boolean().optional().describe("Whether the channel is private."),
+  is_member: z39.boolean().optional().describe("Whether the bot is a member."),
+  topic: z39.string().min(1).optional().describe("Channel topic."),
+  purpose: z39.string().min(1).optional().describe("Channel purpose."),
+  permalink: z39.string().url().optional().describe("Channel permalink.")
 });
-var searchUserSchema = z40.object({
-  user_id: z40.string().min(1).describe("User ID."),
-  user_name: z40.string().min(1).optional().describe("Username."),
-  real_name: z40.string().min(1).optional().describe("Real name."),
-  display_name: z40.string().min(1).optional().describe("Display name."),
-  title: z40.string().min(1).optional().describe("Profile title."),
-  permalink: z40.string().url().optional().describe("Profile permalink.")
+var searchUserSchema = z39.object({
+  user_id: z39.string().min(1).describe("User ID."),
+  user_name: z39.string().min(1).optional().describe("Username."),
+  real_name: z39.string().min(1).optional().describe("Real name."),
+  display_name: z39.string().min(1).optional().describe("Display name."),
+  title: z39.string().min(1).optional().describe("Profile title."),
+  permalink: z39.string().url().optional().describe("Profile permalink.")
 });
 var publicSearchOutputSchema = juniorToolOutputSchema.extend({
-  query: z40.string().describe("Search query."),
-  content_types: z40.array(z40.enum(CONTENT_TYPES)).describe("Content types included in the search."),
-  count: z40.number().int().nonnegative().describe("Total matched results."),
-  messages: z40.array(searchMessageSchema).describe("Matched messages."),
-  files: z40.array(searchFileSchema).describe("Matched files."),
-  channels: z40.array(searchChannelSchema).describe("Matched channels."),
-  users: z40.array(searchUserSchema).describe("Matched users."),
-  next_cursor: z40.string().min(1).optional().describe("Cursor for the next result page.")
+  query: z39.string().describe("Search query."),
+  content_types: z39.array(z39.enum(CONTENT_TYPES)).describe("Content types included in the search."),
+  count: z39.number().int().nonnegative().describe("Total matched results."),
+  messages: z39.array(searchMessageSchema).describe("Matched messages."),
+  files: z39.array(searchFileSchema).describe("Matched files."),
+  channels: z39.array(searchChannelSchema).describe("Matched channels."),
+  users: z39.array(searchUserSchema).describe("Matched users."),
+  next_cursor: z39.string().min(1).optional().describe("Cursor for the next result page.")
 });
-var nonEmptyString = z40.string().trim().min(1);
-var optionalWireString = z40.preprocess((value) => {
+var nonEmptyString = z39.string().trim().min(1);
+var optionalWireString = z39.preprocess((value) => {
   if (typeof value !== "string") {
     return void 0;
   }
   const trimmed = value.trim();
   return trimmed === "" ? void 0 : trimmed;
 }, nonEmptyString.optional());
-var optionalWireUrl = z40.preprocess((value) => {
+var optionalWireUrl = z39.preprocess((value) => {
   if (typeof value !== "string") {
     return void 0;
   }
@@ -10316,20 +9888,20 @@ var optionalWireUrl = z40.preprocess((value) => {
   } catch {
     return void 0;
   }
-}, z40.string().url().optional());
-var optionalWireBoolean = z40.preprocess(
+}, z39.string().url().optional());
+var optionalWireBoolean = z39.preprocess(
   (value) => typeof value === "boolean" ? value : void 0,
-  z40.boolean().optional()
+  z39.boolean().optional()
 );
-var slackSearchMessageWireSchema = z40.object({
+var slackSearchMessageWireSchema = z39.object({
   author_name: optionalWireString,
   author_user_id: optionalWireString,
   channel_id: nonEmptyString,
   channel_name: optionalWireString,
   message_ts: nonEmptyString,
-  content: z40.string(),
+  content: z39.string(),
   is_author_bot: optionalWireBoolean,
-  permalink: z40.string().url()
+  permalink: z39.string().url()
 }).transform(
   (value) => ({
     channel_id: value.channel_id,
@@ -10342,7 +9914,7 @@ var slackSearchMessageWireSchema = z40.object({
     ...value.is_author_bot !== void 0 ? { is_author_bot: value.is_author_bot } : {}
   })
 );
-var slackSearchFileWireSchema = z40.object({
+var slackSearchFileWireSchema = z39.object({
   id: optionalWireString,
   file_id: optionalWireString,
   title: optionalWireString,
@@ -10376,7 +9948,7 @@ var slackSearchFileWireSchema = z40.object({
     ...value.content ?? value.preview ? { content: value.content ?? value.preview } : {}
   };
 });
-var slackSearchChannelWireSchema = z40.object({
+var slackSearchChannelWireSchema = z39.object({
   id: optionalWireString,
   channel_id: optionalWireString,
   name: optionalWireString,
@@ -10401,7 +9973,7 @@ var slackSearchChannelWireSchema = z40.object({
     ...value.permalink ? { permalink: value.permalink } : {}
   };
 });
-var slackSearchUserWireSchema = z40.object({
+var slackSearchUserWireSchema = z39.object({
   id: optionalWireString,
   user_id: optionalWireString,
   name: optionalWireString,
@@ -10425,12 +9997,12 @@ var slackSearchUserWireSchema = z40.object({
     ...value.permalink ? { permalink: value.permalink } : {}
   };
 });
-var slackSearchResponseSchema = z40.object({
-  results: z40.object({
-    messages: z40.array(z40.unknown()).default([]),
-    files: z40.array(z40.unknown()).default([]),
-    channels: z40.array(z40.unknown()).default([]),
-    users: z40.array(z40.unknown()).default([]),
+var slackSearchResponseSchema = z39.object({
+  results: z39.object({
+    messages: z39.array(z39.unknown()).default([]),
+    files: z39.array(z39.unknown()).default([]),
+    channels: z39.array(z39.unknown()).default([]),
+    users: z39.array(z39.unknown()).default([]),
     // Slack often returns "" on the final page; omit rather than fail the parse.
     next_cursor: optionalWireString
   }).default({
@@ -10479,15 +10051,15 @@ function createSlackPublicSearchTool(actionToken) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z40.object({
-      query: z40.string().trim().min(1).max(500).describe("Slack search query."),
-      content_types: z40.array(z40.enum(CONTENT_TYPES)).min(1).max(4).describe("Content types to include. Defaults to messages.").optional(),
+    inputSchema: z39.object({
+      query: z39.string().trim().min(1).max(500).describe("Slack search query."),
+      content_types: z39.array(z39.enum(CONTENT_TYPES)).min(1).max(4).describe("Content types to include. Defaults to messages.").optional(),
       after: optionalUnixTimestampParam("Unix timestamp lower bound."),
       before: optionalUnixTimestampParam("Unix timestamp upper bound."),
-      cursor: z40.string().min(1).describe("Cursor for the next result page.").optional(),
-      limit: z40.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
-      sort: z40.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
-      sort_dir: z40.enum(["asc", "desc"]).describe("Sort direction.").optional()
+      cursor: z39.string().min(1).describe("Cursor for the next result page.").optional(),
+      limit: z39.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
+      sort: z39.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
+      sort_dir: z39.enum(["asc", "desc"]).describe("Sort direction.").optional()
     }),
     outputSchema: publicSearchOutputSchema,
     execute: async ({
@@ -10572,7 +10144,7 @@ function createSlackPublicSearchTool(actionToken) {
 }
 
 // src/chat/slack/tools/message-add-reaction.ts
-import { z as z41 } from "zod";
+import { z as z40 } from "zod";
 
 // src/chat/tools/idempotency.ts
 function stableSerialize(value) {
@@ -10603,8 +10175,8 @@ function createSlackMessageAddReactionTool(context, state) {
       readOnlyHint: false
     },
     description: "Add an emoji reaction to the current inbound Slack message.",
-    inputSchema: z41.object({
-      emoji: z41.string().min(1).max(64).describe(
+    inputSchema: z40.object({
+      emoji: z40.string().min(1).max(64).describe(
         "Slack emoji alias name to react with (for example `thumbsup`, `white_check_mark`, or `thumbsup::skin-tone-6`). Optional surrounding colons are allowed."
       )
     }),
@@ -10652,15 +10224,15 @@ function createSlackMessageAddReactionTool(context, state) {
 }
 
 // src/chat/slack/tools/send-files.ts
-import { createHash as createHash4 } from "crypto";
-import { z as z42 } from "zod";
+import { createHash as createHash3 } from "crypto";
+import { z as z41 } from "zod";
 var sendFilesResultSchema = juniorToolOutputSchema.extend({
-  deduplicated: z42.boolean().optional(),
-  attachment_refs: z42.array(
-    z42.object({
-      id: z42.string().min(1),
+  deduplicated: z41.boolean().optional(),
+  attachment_refs: z41.array(
+    z41.object({
+      id: z41.string().min(1),
       // Same noun as storage, delivery events, and the report API.
-      filename: z42.string().min(1)
+      filename: z41.string().min(1)
     })
   )
 });
@@ -10672,7 +10244,7 @@ function normalizeFiles(files) {
   }));
 }
 function fileContentDigest(data) {
-  return createHash4("sha256").update(data).digest("hex");
+  return createHash3("sha256").update(data).digest("hex");
 }
 function fileOperationInput(files) {
   return files.map((file) => ({
@@ -10692,8 +10264,8 @@ function createSendFilesTool(context, state, materializeFile, attachments) {
       readOnlyHint: false
     },
     description: "Send one or more sandbox files into the active Slack conversation.",
-    inputSchema: z42.object({
-      files: z42.array(sandboxFileReferenceSchema).min(1).describe(
+    inputSchema: z41.object({
+      files: z41.array(sandboxFileReferenceSchema).min(1).describe(
         "One or more existing sandbox files. Objects returned by imageGenerate or webFetch can be passed unchanged."
       )
     }),
@@ -11120,7 +10692,7 @@ async function readCanvas(canvasIdOrUrl) {
 }
 
 // src/chat/slack/tools/canvas/create.ts
-import { z as z43 } from "zod";
+import { z as z42 } from "zod";
 function createSlackCanvasCreateTool(context, state) {
   return zodTool({
     annotations: {
@@ -11130,9 +10702,9 @@ function createSlackCanvasCreateTool(context, state) {
       readOnlyHint: false
     },
     description: "Create a Slack canvas in the active channel.",
-    inputSchema: z43.object({
-      title: z43.string().min(1).max(160).describe("Canvas title."),
-      markdown: z43.string().min(1).describe("Canvas markdown body content.")
+    inputSchema: z42.object({
+      title: z42.string().min(1).max(160).describe("Canvas title."),
+      markdown: z42.string().min(1).describe("Canvas markdown body content.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ title, markdown }) => {
@@ -11176,8 +10748,8 @@ function createSlackCanvasCreateTool(context, state) {
 }
 
 // src/chat/slack/tool-support/canvas/context.ts
-import { z as z44 } from "zod";
-var slackCanvasRefParam = z44.string().min(1).describe("Slack canvas/file ID or canvas/docs URL.");
+import { z as z43 } from "zod";
+var slackCanvasRefParam = z43.string().min(1).describe("Slack canvas/file ID or canvas/docs URL.");
 function resolveCanvasTarget(canvas) {
   const canvasId = extractCanvasId(canvas);
   if (!canvasId) {
@@ -11190,26 +10762,26 @@ function resolveCanvasTarget(canvas) {
 }
 
 // src/chat/slack/tools/canvas/edit.ts
-import { z as z45 } from "zod";
+import { z as z44 } from "zod";
 function prepareCanvasEditArguments(input) {
   return prepareTextReplacementArguments(input);
 }
-var editReplacementSchema2 = z45.object({
-  oldText: z45.string().min(1).describe(
+var editReplacementSchema2 = z44.object({
+  oldText: z44.string().min(1).describe(
     "Exact Canvas markdown to replace. It must be unique in the current Canvas body and must not overlap another edit."
   ),
-  newText: z45.string().describe("Replacement Canvas markdown for this edit.")
+  newText: z44.string().describe("Replacement Canvas markdown for this edit.")
 });
 var slackCanvasEditOutputSchema = juniorToolOutputSchema.extend({
-  canvas_id: z45.string().optional(),
-  title: z45.string().optional(),
-  permalink: z45.string().optional(),
-  diff: z45.string().optional(),
-  first_changed_line: z45.number().int().positive().optional(),
-  replacements: z45.number().int().nonnegative().optional(),
-  normalized_heading_count: z45.number().int().nonnegative().optional(),
-  summary: z45.string().optional(),
-  deduplicated: z45.boolean().optional()
+  canvas_id: z44.string().optional(),
+  title: z44.string().optional(),
+  permalink: z44.string().optional(),
+  diff: z44.string().optional(),
+  first_changed_line: z44.number().int().positive().optional(),
+  replacements: z44.number().int().nonnegative().optional(),
+  normalized_heading_count: z44.number().int().nonnegative().optional(),
+  summary: z44.string().optional(),
+  deduplicated: z44.boolean().optional()
 }).strict();
 function createSlackCanvasEditTool(state) {
   return zodTool({
@@ -11222,9 +10794,9 @@ function createSlackCanvasEditTool(state) {
     description: "Edit a Slack canvas with exact markdown replacements. Returns a diff.",
     prepareArguments: prepareCanvasEditArguments,
     executionMode: "sequential",
-    inputSchema: z45.object({
+    inputSchema: z44.object({
       canvas: slackCanvasRefParam,
-      edits: z45.array(editReplacementSchema2).min(1).describe(
+      edits: z44.array(editReplacementSchema2).min(1).describe(
         "Exact replacements matched against the current Canvas body, not incrementally."
       )
     }),
@@ -11277,18 +10849,18 @@ function createSlackCanvasEditTool(state) {
 }
 
 // src/chat/slack/tools/canvas/read.ts
-import { z as z46 } from "zod";
+import { z as z45 } from "zod";
 var slackCanvasReadOutputSchema = juniorToolOutputSchema.extend({
-  canvas_id: z46.string().optional(),
-  title: z46.string().optional(),
-  permalink: z46.string().optional(),
-  mimetype: z46.string().optional(),
-  filetype: z46.string().optional(),
-  original_byte_length: z46.number().int().nonnegative().optional(),
-  content: z46.string().optional(),
-  start_line: z46.number().int().positive().optional(),
-  end_line: z46.number().int().nonnegative().optional(),
-  total_lines: z46.number().int().nonnegative().optional()
+  canvas_id: z45.string().optional(),
+  title: z45.string().optional(),
+  permalink: z45.string().optional(),
+  mimetype: z45.string().optional(),
+  filetype: z45.string().optional(),
+  original_byte_length: z45.number().int().nonnegative().optional(),
+  content: z45.string().optional(),
+  start_line: z45.number().int().positive().optional(),
+  end_line: z45.number().int().nonnegative().optional(),
+  total_lines: z45.number().int().nonnegative().optional()
 }).strict();
 function createSlackCanvasReadTool() {
   return zodTool({
@@ -11299,10 +10871,10 @@ function createSlackCanvasReadTool() {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z46.object({
+    inputSchema: z45.object({
       canvas: slackCanvasRefParam,
-      offset: z46.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
-      limit: z46.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
+      offset: z45.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
+      limit: z45.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
     }),
     outputSchema: slackCanvasReadOutputSchema,
     execute: async ({ canvas, offset, limit }) => {
@@ -11338,7 +10910,7 @@ function createSlackCanvasReadTool() {
 }
 
 // src/chat/slack/tools/canvas/write.ts
-import { z as z47 } from "zod";
+import { z as z46 } from "zod";
 function createSlackCanvasWriteTool(state) {
   return zodTool({
     annotations: {
@@ -11349,9 +10921,9 @@ function createSlackCanvasWriteTool(state) {
     },
     description: "Replace the full markdown body of a Slack canvas.",
     executionMode: "sequential",
-    inputSchema: z47.object({
+    inputSchema: z46.object({
       canvas: slackCanvasRefParam,
-      content: z47.string().describe("UTF-8 markdown content to write.")
+      content: z46.string().describe("UTF-8 markdown content to write.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ canvas, content }) => {
@@ -11573,12 +11145,12 @@ async function updateListItem(input) {
 }
 
 // src/chat/slack/tool-support/list/params.ts
-import { z as z48 } from "zod";
-var slackListIdParam = z48.string().min(1).describe("Slack list ID.");
-var slackListItemIdParam = z48.string().min(1).describe("Slack list item ID.");
+import { z as z47 } from "zod";
+var slackListIdParam = z47.string().min(1).describe("Slack list ID.");
+var slackListItemIdParam = z47.string().min(1).describe("Slack list item ID.");
 
 // src/chat/slack/tools/list/add-items.ts
-import { z as z49 } from "zod";
+import { z as z48 } from "zod";
 function createSlackListAddItemsTool(state) {
   return zodTool({
     annotations: {
@@ -11588,13 +11160,13 @@ function createSlackListAddItemsTool(state) {
       readOnlyHint: false
     },
     description: "Add tasks to a Slack list.",
-    inputSchema: z49.object({
+    inputSchema: z48.object({
       list_id: slackListIdParam,
-      items: z49.array(z49.string().min(1)).min(1).max(25).describe("List item titles to create."),
+      items: z48.array(z48.string().min(1)).min(1).max(25).describe("List item titles to create."),
       assignee_user_id: slackUserIdParam(
         "Optional Slack user ID assigned to all created items."
       ).optional(),
-      due_date: z49.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
+      due_date: z48.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ list_id, items, assignee_user_id, due_date }) => {
@@ -11633,7 +11205,7 @@ function createSlackListAddItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/create.ts
-import { z as z50 } from "zod";
+import { z as z49 } from "zod";
 function createSlackListCreateTool(state) {
   return zodTool({
     annotations: {
@@ -11643,8 +11215,8 @@ function createSlackListCreateTool(state) {
       readOnlyHint: false
     },
     description: "Create a Slack todo list.",
-    inputSchema: z50.object({
-      name: z50.string().min(1).max(160).describe("Name for the new Slack list.")
+    inputSchema: z49.object({
+      name: z49.string().min(1).max(160).describe("Name for the new Slack list.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ name }) => {
@@ -11669,7 +11241,7 @@ function createSlackListCreateTool(state) {
 }
 
 // src/chat/slack/tools/list/get-items.ts
-import { z as z51 } from "zod";
+import { z as z50 } from "zod";
 function createSlackListGetItemsTool() {
   return zodTool({
     description: "Read items from a Slack list.",
@@ -11679,9 +11251,9 @@ function createSlackListGetItemsTool() {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z51.object({
+    inputSchema: z50.object({
       list_id: slackListIdParam,
-      limit: z51.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
+      limit: z50.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ list_id, limit }) => {
@@ -11696,23 +11268,23 @@ function createSlackListGetItemsTool() {
 }
 
 // src/chat/slack/tools/list/update-item.ts
-import { z as z52 } from "zod";
-var booleanInput3 = (description) => z52.preprocess(
+import { z as z51 } from "zod";
+var booleanInput3 = (description) => z51.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z52.boolean()
+  z51.boolean()
 ).describe(description);
-var updateListItemInputSchema = z52.union([
-  z52.object({
+var updateListItemInputSchema = z51.union([
+  z51.object({
     list_id: slackListIdParam,
     item_id: slackListItemIdParam,
     completed: booleanInput3("Optional completion status update."),
-    title: z52.string().min(1).describe("Optional new item title.").optional()
+    title: z51.string().min(1).describe("Optional new item title.").optional()
   }),
-  z52.object({
+  z51.object({
     list_id: slackListIdParam,
     item_id: slackListItemIdParam,
     completed: booleanInput3("Optional completion status update.").optional(),
-    title: z52.string().min(1).describe("Optional new item title.")
+    title: z51.string().min(1).describe("Optional new item title.")
   })
 ]);
 function createSlackListUpdateItemTool(state) {
@@ -11760,7 +11332,7 @@ function createSlackListUpdateItemTool(state) {
 }
 
 // src/chat/slack/tools/thread-read.ts
-import { z as z53 } from "zod";
+import { z as z52 } from "zod";
 
 // src/chat/slack/tool-support/slack-message-url.ts
 var SLACK_HOST_PATTERN = /^[a-z0-9-]+\.slack(?:-gov)?\.com$/;
@@ -12026,14 +11598,14 @@ function createSlackThreadReadTool(context) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z53.object({
-      url: z53.string().min(1).describe("Slack message archive URL.").optional(),
+    inputSchema: z52.object({
+      url: z52.string().min(1).describe("Slack message archive URL.").optional(),
       channel_id: slackChannelRefParam.optional(),
       ts: slackTimestampParam(
         "Slack message timestamp. May be the thread root or any message in the thread."
       ).optional(),
-      limit: z53.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
-      max_pages: z53.coerce.number().int().min(1).max(10).describe("Maximum number of Slack API pages to traverse.").optional()
+      limit: z52.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
+      max_pages: z52.coerce.number().int().min(1).max(10).describe("Maximum number of Slack API pages to traverse.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ url, channel_id, ts, limit, max_pages }) => {
@@ -12160,7 +11732,7 @@ function createSlackThreadReadTool(context) {
 // src/chat/tools/user-lookup.ts
 import { and, eq, or, sql } from "drizzle-orm";
 import { alias } from "drizzle-orm/pg-core";
-import { z as z54 } from "zod";
+import { z as z53 } from "zod";
 var linkedSlackIdentity = alias(juniorIdentities, "user_lookup_slack_identity");
 function explicitUserLookupError(error) {
   if (error.apiError === "user_not_found" || error.code === "not_found") {
@@ -12309,9 +11881,9 @@ function createUserLookupTool(teamId, providers) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z54.object({
-      provider: z54.enum(providers).describe("Enabled identity provider to query."),
-      query: z54.string().trim().min(1).describe("Provider subject ID, handle, Slack email, or Slack name.")
+    inputSchema: z53.object({
+      provider: z53.enum(providers).describe("Enabled identity provider to query."),
+      query: z53.string().trim().min(1).describe("Provider subject ID, handle, Slack email, or Slack name.")
     }).strict(),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ provider, query }) => {
@@ -12331,18 +11903,18 @@ function createUserLookupTool(teamId, providers) {
 }
 
 // src/chat/tools/system-time.ts
-import { z as z55 } from "zod";
-var systemTimeInputSchema = z55.object({
-  timezone: z55.string().trim().min(1).optional().describe(
+import { z as z54 } from "zod";
+var systemTimeInputSchema = z54.object({
+  timezone: z54.string().trim().min(1).optional().describe(
     "Optional IANA timezone, for example America/Los_Angeles. When set, iso_local and timezone_offset_minutes are for that zone."
   )
 });
 var systemTimeOutputSchema = juniorToolOutputSchema.extend({
-  unix_ms: z55.number(),
-  iso_utc: z55.string(),
-  iso_local: z55.string(),
-  timezone: z55.string().nullable(),
-  timezone_offset_minutes: z55.number()
+  unix_ms: z54.number(),
+  iso_utc: z54.string(),
+  iso_local: z54.string(),
+  timezone: z54.string().nullable(),
+  timezone_offset_minutes: z54.number()
 });
 function createSystemTimeTool() {
   return zodTool({
@@ -12422,10 +11994,10 @@ function getTimeZoneOffsetMinutes(timestampMs, timezone) {
 }
 
 // src/chat/tools/publish-image.ts
-import { z as z56 } from "zod";
+import { z as z55 } from "zod";
 
 // src/chat/artifacts/store.ts
-import { createHash as createHash5, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
 import { and as and2, eq as eq2, isNull } from "drizzle-orm";
 var MAX_IMAGE_BYTES = 10 * 1024 * 1024;
 var IMAGE_TYPES = {
@@ -12508,7 +12080,7 @@ async function publishImage(args) {
     );
   }
   const baseUrl = resolvePublicBaseUrl(args.publicBaseUrl);
-  const sha256 = createHash5("sha256").update(args.body).digest("hex");
+  const sha256 = createHash4("sha256").update(args.body).digest("hex");
   const now = args.now ?? /* @__PURE__ */ new Date();
   const [existing] = await args.db.db().select({
     id: juniorArtifacts.id
@@ -12623,10 +12195,10 @@ function unpublishedArtifactHeaders() {
 
 // src/chat/tools/publish-image.ts
 var outputSchema5 = juniorToolOutputSchema.extend({
-  bytes: z56.number().int().positive(),
-  content_type: z56.string().min(1),
-  public: z56.literal(true),
-  url: z56.string().url()
+  bytes: z55.number().int().positive(),
+  content_type: z55.string().min(1),
+  public: z55.literal(true),
+  url: z55.string().url()
 });
 function createPublishImageTool(args) {
   return zodTool({
@@ -12640,8 +12212,8 @@ function createPublishImageTool(args) {
     description: "Publish one sandbox image to a durable public HTTPS URL. Anyone on the internet with the URL can view the image. Use only when an external destination needs a public image URL. Do not use for private file sharing or private conversation storage. Supports PNG, JPEG, GIF, and WebP up to 10 MB.",
     describeProposal: ({ path: path8 }) => `Publish sandbox image ${path8} to a public internet URL.`,
     executionMode: "sequential",
-    inputSchema: z56.object({
-      path: z56.string().min(1).describe("Exact sandbox path of an existing image file.")
+    inputSchema: z55.object({
+      path: z55.string().min(1).describe("Exact sandbox path of an existing image file.")
     }).strict(),
     outputSchema: outputSchema5,
     async execute({ path: path8 }) {
@@ -12674,10 +12246,10 @@ function createPublishImageTool(args) {
 }
 
 // src/chat/tools/unpublish-image.ts
-import { z as z57 } from "zod";
+import { z as z56 } from "zod";
 var outputSchema6 = juniorToolOutputSchema.extend({
-  filename: z57.string().min(1),
-  unpublished: z57.literal(true)
+  filename: z56.string().min(1),
+  unpublished: z56.literal(true)
 });
 function createUnpublishImageTool(args) {
   return zodTool({
@@ -12691,8 +12263,8 @@ function createUnpublishImageTool(args) {
     description: "Unpublish one public image previously published in this conversation so its public URL stops serving. Pass the public artifact URL or `<id>.<ext>` filename. Only images owned by this conversation can be unpublished. Republishing the same image bytes later in this conversation restores a live URL for this conversation. Does not remove copies already fetched by browsers or GitHub.",
     describeProposal: ({ ref }) => `Unpublish public image ${ref}.`,
     executionMode: "sequential",
-    inputSchema: z57.object({
-      ref: z57.string().min(1).describe(
+    inputSchema: z56.object({
+      ref: z56.string().min(1).describe(
         "Public artifact URL or artifact filename (`<id>.<ext>`)."
       )
     }).strict(),
@@ -12712,27 +12284,27 @@ function createUnpublishImageTool(args) {
 }
 
 // src/chat/tools/search-conversation-events.ts
-import { z as z58 } from "zod";
+import { z as z57 } from "zod";
 var DEFAULT_LIMIT3 = 25;
 var MAX_LIMIT2 = 100;
 var MAX_EVENT_DATA_BYTES = 4e3;
 var MAX_EVENTS_JSON_BYTES = 2e4;
 var MAX_IDENTITY_CHARS = 256;
 var textEncoder = new TextEncoder();
-var knownEventTypeSchema = z58.enum(KNOWN_CONVERSATION_EVENT_TYPES);
-var projectedEventSchema = z58.object({
-  seq: z58.number().int().nonnegative().describe("Stable event position for pagination."),
-  history_version: z58.number().int().nonnegative().describe("Agent history generation after replacement."),
-  created_at: z58.iso.datetime().describe("When the event was recorded."),
-  idempotency_key: z58.string().min(1).optional().describe("Retry-stable event identity, when assigned."),
-  data: z58.record(z58.string(), z58.unknown()).describe("Bounded event data.")
+var knownEventTypeSchema = z57.enum(KNOWN_CONVERSATION_EVENT_TYPES);
+var projectedEventSchema = z57.object({
+  seq: z57.number().int().nonnegative().describe("Stable event position for pagination."),
+  history_version: z57.number().int().nonnegative().describe("Agent history generation after replacement."),
+  created_at: z57.iso.datetime().describe("When the event was recorded."),
+  idempotency_key: z57.string().min(1).optional().describe("Retry-stable event identity, when assigned."),
+  data: z57.record(z57.string(), z57.unknown()).describe("Bounded event data.")
 }).strict();
 var searchConversationEventsOutputSchema = juniorToolOutputSchema.extend({
-  conversation_id: z58.string().min(1),
-  events: z58.array(projectedEventSchema),
-  has_older: z58.boolean().describe("Whether matching older events exist."),
-  has_newer: z58.boolean().describe("Whether matching newer events exist."),
-  omitted_event_count: z58.number().int().nonnegative().optional().describe("Events omitted by the response byte limit.")
+  conversation_id: z57.string().min(1),
+  events: z57.array(projectedEventSchema),
+  has_older: z57.boolean().describe("Whether matching older events exist."),
+  has_newer: z57.boolean().describe("Whether matching newer events exist."),
+  omitted_event_count: z57.number().int().nonnegative().optional().describe("Events omitted by the response byte limit.")
 });
 function createSearchConversationEventsTool(context) {
   return zodTool({
@@ -12745,16 +12317,16 @@ function createSearchConversationEventsTool(context) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z58.object({
-      conversation_id: z58.string().trim().min(1).nullable().describe(
+    inputSchema: z57.object({
+      conversation_id: z57.string().trim().min(1).nullable().describe(
         "Conversation ID to search. Omit or null for the current conversation."
       ).optional(),
-      after_seq: z58.number().int().nonnegative().nullable().describe("Exclusive event sequence lower bound; returns ascending.").optional(),
-      before_seq: z58.number().int().nonnegative().nullable().describe("Exclusive event sequence upper bound.").optional(),
-      limit: z58.number().int().min(1).max(MAX_LIMIT2).nullable().describe(
+      after_seq: z57.number().int().nonnegative().nullable().describe("Exclusive event sequence lower bound; returns ascending.").optional(),
+      before_seq: z57.number().int().nonnegative().nullable().describe("Exclusive event sequence upper bound.").optional(),
+      limit: z57.number().int().min(1).max(MAX_LIMIT2).nullable().describe(
         `Maximum events. Default ${DEFAULT_LIMIT3}; max ${MAX_LIMIT2}.`
       ).optional(),
-      types: z58.array(knownEventTypeSchema).min(1).nullable().describe("Event types to include; omit for all types.").optional()
+      types: z57.array(knownEventTypeSchema).min(1).nullable().describe("Event types to include; omit for all types.").optional()
     }).strict(),
     outputSchema: searchConversationEventsOutputSchema,
     execute: async (input) => {
@@ -13000,10 +12572,10 @@ function stripReplacementHistoryField(value) {
 }
 
 // src/chat/tools/handoff/tool.ts
-import { z as z59 } from "zod";
+import { z as z58 } from "zod";
 var HANDOFF_TOOL_NAME = "handoff";
 function createHandoffTool(handoff) {
-  const profileSchema = z59.enum(handoff.profiles);
+  const profileSchema = z58.enum(handoff.profiles);
   const handoffResultSchema = juniorToolOutputSchema.extend({
     model_profile: modelProfileSchema
   });
@@ -13017,7 +12589,7 @@ function createHandoffTool(handoff) {
     },
     description: `Switch to another execution profile and continue the same task. Profiles: ${profileNames}. Call this as the only tool.`,
     executionMode: "sequential",
-    inputSchema: z59.object({
+    inputSchema: z58.object({
       profile: profileSchema.describe("Target execution profile")
     }).strict(),
     outputSchema: handoffResultSchema,
@@ -13038,7 +12610,7 @@ function createHandoffTool(handoff) {
 }
 
 // src/chat/tools/web/fetch-tool.ts
-import { z as z60 } from "zod";
+import { z as z59 } from "zod";
 
 // src/chat/tools/web/constants.ts
 var USER_AGENT = "junior-bot/0.1";
@@ -13487,9 +13059,9 @@ function createWebFetchTool(hooks, options = {}) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z60.object({
-      url: z60.string().min(1).describe("HTTP(S) URL to fetch."),
-      max_chars: z60.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
+    inputSchema: z59.object({
+      url: z59.string().min(1).describe("HTTP(S) URL to fetch."),
+      max_chars: z59.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ url, max_chars }) => {
@@ -13534,7 +13106,7 @@ function createWebFetchTool(hooks, options = {}) {
 }
 
 // src/chat/tools/web/search.ts
-import { z as z61 } from "zod";
+import { z as z60 } from "zod";
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
 var SEARCH_TIMEOUT_MS = 6e4;
@@ -13576,9 +13148,9 @@ function createWebSearchTool(modelId, override) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z61.object({
-      query: z61.string().min(1).max(500).describe("Search query."),
-      max_results: z61.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
+    inputSchema: z60.object({
+      query: z60.string().min(1).max(500).describe("Search query."),
+      max_results: z60.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ query, max_results }) => {
@@ -13620,7 +13192,7 @@ function createWebSearchTool(modelId, override) {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { z as z62 } from "zod";
+import { z as z61 } from "zod";
 function createWriteFileTool() {
   return zodTool({
     annotations: {
@@ -13631,9 +13203,9 @@ function createWriteFileTool() {
     },
     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: z62.object({
-      path: z62.string().min(1).describe("Path to write in the sandbox workspace."),
-      content: z62.string().describe("UTF-8 file content to write.")
+    inputSchema: z61.object({
+      path: z61.string().min(1).describe("Path to write in the sandbox workspace."),
+      content: z61.string().describe("UTF-8 file content to write.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async () => {
@@ -13645,7 +13217,7 @@ function createWriteFileTool() {
 }
 
 // src/chat/workspaces/tools.ts
-import { z as z63 } from "zod";
+import { z as z62 } from "zod";
 async function tryRecordWorkspaceSwitchStat(workspace) {
   if (!process.env.DATABASE_URL) return;
   try {
@@ -13662,16 +13234,16 @@ async function tryRecordWorkspaceSwitchStat(workspace) {
     });
   }
 }
-var repoSchema = z63.object({
-  provider: z63.string(),
-  repo: z63.string(),
-  checkout_path: z63.string()
+var repoSchema = z62.object({
+  provider: z62.string(),
+  repo: z62.string(),
+  checkout_path: z62.string()
 });
-var workspaceSchema = z63.object({
-  id: z63.string(),
-  name: z63.string(),
-  setup_script: z63.string(),
-  repos: z63.array(repoSchema)
+var workspaceSchema = z62.object({
+  id: z62.string(),
+  name: z62.string(),
+  setup_script: z62.string(),
+  repos: z62.array(repoSchema)
 });
 function view(workspace) {
   return {
@@ -13692,18 +13264,18 @@ function workspaceProviderNames() {
 }
 function workspaceWriteSchemas(providers) {
   const providerNames = providers.map((provider) => `\`${provider}\``).join(", ");
-  const repoInputSchema = z63.object({
-    provider: z63.enum(providers).describe(`Repository provider. Supported: ${providerNames}.`),
-    repo: z63.string().trim().min(1).describe("Repository in owner/name format.")
+  const repoInputSchema = z62.object({
+    provider: z62.enum(providers).describe(`Repository provider. Supported: ${providerNames}.`),
+    repo: z62.string().trim().min(1).describe("Repository in owner/name format.")
   }).strict();
-  const workspaceInputSchema = z63.object({
-    name: z63.string().trim().min(1).describe(
+  const workspaceInputSchema = z62.object({
+    name: z62.string().trim().min(1).describe(
       "Workspace name. Use lowercase letters, digits, underscores, or hyphens."
     ),
-    setup_script: z63.string().nullable().describe(
+    setup_script: z62.string().nullable().describe(
       "Optional shell script to run after repository checkout whenever this Workspace starts. Omit or use null for no setup script."
     ).optional(),
-    repos: z63.array(repoInputSchema).max(32).describe("Complete repository list.")
+    repos: z62.array(repoInputSchema).max(32).describe("Complete repository list.")
   }).strict();
   return { providerNames, workspaceInputSchema };
 }
@@ -13778,7 +13350,7 @@ function createWorkspaceWriteTools(providers) {
       },
       description: `Replace an install-wide Workspace recipe. Repository providers: ${providerNames}. Use the Workspace ID returned by listWorkspaces.`,
       inputSchema: workspaceInputSchema.extend({
-        id: z63.string().uuid().describe("Workspace ID from listWorkspaces.")
+        id: z62.string().uuid().describe("Workspace ID from listWorkspaces.")
       }).strict(),
       prepareArguments(args) {
         const input = args;
@@ -13811,11 +13383,11 @@ function createWorkspaceWriteTools(providers) {
         readOnlyHint: false
       },
       description: "Delete one install-wide Workspace recipe. Use the Workspace ID returned by listWorkspaces.",
-      inputSchema: z63.object({
-        id: z63.string().uuid().describe("Workspace ID from listWorkspaces.")
+      inputSchema: z62.object({
+        id: z62.string().uuid().describe("Workspace ID from listWorkspaces.")
       }).strict(),
       outputSchema: juniorToolOutputSchema.extend({
-        deleted: z63.literal(true)
+        deleted: z62.literal(true)
       }),
       async execute({ id }) {
         const deleted = await workspaceWrite(() => deleteWorkspace(id));
@@ -13840,10 +13412,10 @@ function createWorkspaceTools(context) {
         readOnlyHint: true
       },
       description: "List named repository workspaces that can replace the current sandbox.",
-      inputSchema: z63.object({}).strict(),
+      inputSchema: z62.object({}).strict(),
       outputSchema: juniorToolOutputSchema.extend({
-        active_workspace_id: z63.string().nullable(),
-        workspaces: z63.array(workspaceSchema)
+        active_workspace_id: z62.string().nullable(),
+        workspaces: z62.array(workspaceSchema)
       }),
       async execute() {
         return {
@@ -13861,8 +13433,8 @@ function createWorkspaceTools(context) {
         readOnlyHint: false
       },
       description: "Replace the current sandbox with a named preconfigured repository workspace. Files in the prior sandbox do not carry over.",
-      inputSchema: z63.object({
-        name: z63.string().trim().min(1).describe("Exact workspace name.")
+      inputSchema: z62.object({
+        name: z62.string().trim().min(1).describe("Exact workspace name.")
       }).strict(),
       outputSchema: juniorToolOutputSchema.extend({
         workspace: workspaceSchema
@@ -14604,7 +14176,7 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, conv
 }
 
 // src/chat/tools/execute-tool.ts
-import { z as z64 } from "zod";
+import { z as z63 } from "zod";
 var EXECUTE_TOOL_NAME = "executeTool";
 function createExecuteToolTool() {
   return zodTool({
@@ -14616,11 +14188,11 @@ function createExecuteToolTool() {
     },
     description: "Execute any catalog tool by exact tool_name from searchTools or a tool-result execution hint. Put tool-specific parameters inside arguments.",
     executionMode: "sequential",
-    inputSchema: z64.object({
-      tool_name: z64.string().min(1).describe(
+    inputSchema: z63.object({
+      tool_name: z63.string().min(1).describe(
         "Exact catalog tool_name returned by searchTools or a tool-result execution hint."
       ),
-      arguments: z64.record(z64.string(), z64.unknown()).describe(
+      arguments: z63.record(z63.string(), z63.unknown()).describe(
         'Arguments matching the selected catalog tool schema, for example { "query": "..." }.'
       ).optional()
     }).strict(),
@@ -14660,7 +14232,7 @@ function planToolExposure(tools) {
 }
 
 // src/chat/tools/search-tools.ts
-import { z as z65 } from "zod";
+import { z as z64 } from "zod";
 var SEARCH_TOOLS_NAME = "searchTools";
 var DEFAULT_MAX_RESULTS2 = 5;
 var MAX_RESULTS3 = 20;
@@ -14705,29 +14277,29 @@ var SEARCH_STOP_WORDS = /* @__PURE__ */ new Set([
   "you",
   "your"
 ]);
-var searchToolsSourceSchema = z65.object({
-  id: z65.string(),
-  description: z65.string()
+var searchToolsSourceSchema = z64.object({
+  id: z64.string(),
+  description: z64.string()
 }).strict();
-var searchToolsToolSchema = z65.object({
-  tool_name: z65.string(),
-  description: z65.string(),
-  exposure: z65.enum(["direct", "deferred", "modelOnly", "hidden"]),
-  source: z65.string().optional(),
-  input_schema: z65.unknown(),
-  call_notes: z65.array(z65.string()),
-  annotations: z65.record(z65.string(), z65.unknown())
+var searchToolsToolSchema = z64.object({
+  tool_name: z64.string(),
+  description: z64.string(),
+  exposure: z64.enum(["direct", "deferred", "modelOnly", "hidden"]),
+  source: z64.string().optional(),
+  input_schema: z64.unknown(),
+  call_notes: z64.array(z64.string()),
+  annotations: z64.record(z64.string(), z64.unknown())
 }).strict();
 var searchToolsOutputSchema = juniorToolOutputSchema.extend({
-  query: z65.string().nullable(),
-  source: z65.string().nullable(),
-  sources: z65.array(searchToolsSourceSchema),
-  total_catalog_tools: z65.number().int().nonnegative(),
-  total_eligible_tools: z65.number().int().nonnegative(),
-  total_matches: z65.number().int().nonnegative(),
-  returned_tools: z65.number().int().nonnegative(),
-  execution_tool: z65.literal("executeTool"),
-  tools: z65.array(searchToolsToolSchema)
+  query: z64.string().nullable(),
+  source: z64.string().nullable(),
+  sources: z64.array(searchToolsSourceSchema),
+  total_catalog_tools: z64.number().int().nonnegative(),
+  total_eligible_tools: z64.number().int().nonnegative(),
+  total_matches: z64.number().int().nonnegative(),
+  returned_tools: z64.number().int().nonnegative(),
+  execution_tool: z64.literal("executeTool"),
+  tools: z64.array(searchToolsToolSchema)
 }).strict();
 function terms(value) {
   const chunks = value.match(/[\p{L}\p{N}]+/gu) ?? [];
@@ -14938,14 +14510,14 @@ function createSearchToolsTool(catalogTools) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z65.object({
-      query: z65.string().nullable().describe(
+    inputSchema: z64.object({
+      query: z64.string().nullable().describe(
         "Optional search terms describing the tool, owner, action, or arguments needed. Empty string lists catalog tools."
       ).optional(),
-      source: z65.string().nullable().describe(
+      source: z64.string().nullable().describe(
         "Optional source id to search within, such as a plugin source returned in sources."
       ).optional(),
-      max_results: z65.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
+      max_results: z64.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
     }).strict(),
     outputSchema: searchToolsOutputSchema,
     privateTraceResult: (result) => ({
@@ -16204,7 +15776,7 @@ function createPluginEgress(deps) {
 }
 
 // src/chat/services/guardian-action-review.ts
-import { z as z66 } from "zod";
+import { z as z65 } from "zod";
 
 // src/chat/services/guardian-action-policy.ts
 var GUARDIAN_ACTION_POLICY = `You are judging one planned Junior agent action.
@@ -16272,17 +15844,17 @@ Assess the exact action's intrinsic risk and whether the user's intent authorize
 - Keep the reason to one concise, specific sentence grounded in the main risk or authorization fact. For ask, name the exact action, target, and material side effects the user must confirm.`;
 
 // src/chat/services/guardian-action-review.ts
-var guardianDecisionSchema = z66.object({
-  decision: z66.enum(["allow", "ask", "deny"]),
-  reason: z66.string().trim().min(1).max(500),
-  riskLevel: z66.enum(["low", "medium", "high", "critical"]),
-  userAuthorization: z66.enum(["high", "medium", "low", "unknown"])
+var guardianDecisionSchema = z65.object({
+  decision: z65.enum(["allow", "ask", "deny"]),
+  reason: z65.string().trim().min(1).max(500),
+  riskLevel: z65.enum(["low", "medium", "high", "critical"]),
+  userAuthorization: z65.enum(["high", "medium", "low", "unknown"])
 }).strict();
 var GUARDIAN_REVIEW_TIMEOUT_MS = 6e4;
 var GUARDIAN_REVIEW_MAX_TOKENS = 2e3;
 var MAX_PROPOSAL_CHARS = 192e3;
 function guardianPrompt(proposal) {
-  const proposalJson = JSON.stringify(z66.json().parse(proposal), null, 2);
+  const proposalJson = JSON.stringify(z65.json().parse(proposal), null, 2);
   if (proposalJson.length > MAX_PROPOSAL_CHARS) {
     throw new Error(
       `Guardian action proposal exceeds ${MAX_PROPOSAL_CHARS} characters.`
@@ -18878,9 +18450,6 @@ export {
   normalizeSandboxEgressTracePropagationDomains,
   shouldPropagateSandboxEgressTrace,
   resolveSandboxEgressProviderForHost,
-  cancelSubscriptions,
-  findMatchingResourceEventSubscriptions,
-  deliverResourceEventSubscription,
   sanitizeScheduledTaskPrincipal,
   listThreadReplies,
   renderBlockText,