@sentry/junior 0.126.1 → 0.127.0

package/dist/{chunk-SD2VFSN6.js → chunk-Z5LLJNTL.js}

@@ -30,7 +30,7 @@ import {
   toMcpProviderError,
   toolInvocationDestination,
   uploadFilesToConversation
-} from "./chunk-7VF3JAVF.js";
+} from "./chunk-6DU2ZNF7.js";
 import {
   CooperativeTurnYieldError,
   JUNIOR_THREAD_STATE_TTL_MS,
@@ -80,7 +80,7 @@ import {
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   updateConversationStats
-} from "./chunk-KBW6J5GA.js";
+} from "./chunk-WXP2ZXC7.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
@@ -104,13 +104,13 @@ import {
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-QVSYR5CV.js";
+} from "./chunk-YSOZT72W.js";
 import {
   incrementStat
-} from "./chunk-YFE6VNHU.js";
+} from "./chunk-VHUMNUJL.js";
 import {
   parseSlackThreadId
-} from "./chunk-QMK2VF6K.js";
+} from "./chunk-2M6LYDTB.js";
 import {
   addAgentTurnUsage,
   hasAgentTurnUsage
@@ -126,13 +126,14 @@ import {
   getPluginSystemPromptContributions,
   getPluginTools,
   getPluginUserPromptContributions,
+  getPlugins,
   getSlackClient,
   getSlackToolContext,
   isConversationScopedChannel,
   normalizeSlackConversationId,
   resolveChannelCapabilities,
   withSlackRetries
-} from "./chunk-YZHA2L7P.js";
+} from "./chunk-TLMI3Q4Q.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
@@ -142,7 +143,7 @@ import {
   instructionActors,
   instructionProvenanceFor,
   sameActorIdentity
-} from "./chunk-S4LM6UB7.js";
+} from "./chunk-PDG3BSOD.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -152,7 +153,7 @@ import {
   sandboxSkillFile,
   sandboxSkillPathResolution,
   sleep
-} from "./chunk-F2ARYRKC.js";
+} from "./chunk-SH7HDO2D.js";
 import {
   ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
@@ -186,7 +187,7 @@ import {
   renderCurrentInstruction,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-WIIPHGJY.js";
+} from "./chunk-L7L7RYJM.js";
 import {
   canExposeConversationPayload,
   resolveConversationPrivacy,
@@ -196,16 +197,16 @@ import {
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes
-} from "./chunk-U36WL4OL.js";
+} from "./chunk-NK7QVIMJ.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-R3GXQJEE.js";
+} from "./chunk-JNYR4G7A.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-JKV244BI.js";
+} from "./chunk-2N6EL22B.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -213,7 +214,7 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-HXWOZ4HG.js";
+} from "./chunk-FVIU6NQO.js";
 import {
   credentialUserSubjectId
 } from "./chunk-W3U3YQYI.js";
@@ -242,7 +243,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-PD6J33TO.js";
+} from "./chunk-AYICPT5T.js";
 import {
   startInactiveSpan,
   withActiveSpan
@@ -1818,7 +1819,8 @@ var TOOL_POLICY_RULES = [
   "- After changing files, name the changed paths and summarize the completed result in the final answer.",
   "- If a sandbox-backed tool reports that sandbox execution is unavailable, treat that as a blocker for local file/shell inspection; do not pretend host files were inspected.",
   "- For user-provided URLs, use `webFetch`; for discovery, use `webSearch` then fetch/read promising sources; for current time/date context, use `systemTime`.",
-  "- When a tool result includes a subscribable resource, use resource-event subscriptions for high-signal provider changes that serve the user's current intent; do not create scheduled polling tasks for events the subscription can deliver. Use the suggested events when they fit and write a concise intent summary.",
+  "- When searchResourceEventTypes is exposed, use it only when the user asks what resource events are supported or the required resource type or event name is unclear. It discovers options but does not watch a resource.",
+  "- When a tool result includes a subscribable resource, use watchResourceEvents for high-signal provider changes that serve the user's current intent; do not create scheduled polling tasks for events the watch can deliver. Use the suggested events when they fit, write a concise intent summary, and tell the user when the temporary watch expires. Stop only the requested watch by id unless the user explicitly asks to stop every watch in the thread.",
   "- For code changes, debugging or root-cause analysis, broad refactors, and software architecture decisions, use `handoff` before substantive analysis only when it offers a profile that better matches the task. Do not switch merely because the task involves code.",
   "- Run `jr-rpc config get|set|unset|list` for provider defaults and `jr-rpc plugins list` for installed plugin introspection as standalone bash commands; do not chain them with `cd`, `&&`, pipes, or provider commands.",
   "- If the first result is empty, stale, ambiguous, or incomplete, try a focused alternate query, path, command, or source before concluding the answer cannot be verified."
@@ -4345,10 +4347,10 @@ function parseToolInput(schema, args) {
   return result.data;
 }
 function zodTool(definition) {
-  const { inputSchema, outputSchema, prepareArguments, execute, ...toolDef } = definition;
+  const { inputSchema: inputSchema2, outputSchema: outputSchema5, prepareArguments, execute, ...toolDef } = definition;
   let modelInputSchema;
   try {
-    modelInputSchema = z4.toJSONSchema(inputSchema);
+    modelInputSchema = z4.toJSONSchema(inputSchema2);
   } catch (error) {
     throw new TypeError(
       "zodTool() inputSchema must be representable as JSON Schema.",
@@ -4356,9 +4358,9 @@ function zodTool(definition) {
     );
   }
   let modelOutputSchema;
-  if (outputSchema) {
+  if (outputSchema5) {
     try {
-      modelOutputSchema = z4.toJSONSchema(outputSchema);
+      modelOutputSchema = z4.toJSONSchema(outputSchema5);
     } catch (error) {
       throw new TypeError(
         "zodTool() outputSchema must be representable as JSON Schema.",
@@ -4372,7 +4374,7 @@ function zodTool(definition) {
     ...modelOutputSchema ? { outputSchema: modelOutputSchema } : {},
     prepareArguments(args) {
       return parseToolInput(
-        inputSchema,
+        inputSchema2,
         prepareArguments ? prepareArguments(args) : args
       );
     },
@@ -4382,7 +4384,7 @@ function zodTool(definition) {
           input,
           options
         );
-        if (!outputSchema) {
+        if (!outputSchema5) {
           if (isContentOnlyToolResult(result)) {
             return result;
           }
@@ -4393,12 +4395,12 @@ function zodTool(definition) {
         if (isStructuredToolResultEnvelope(result)) {
           return {
             content: parseToolContent(result.content),
-            details: outputSchema.parse(
+            details: outputSchema5.parse(
               juniorToolResultSchema.parse(result.details)
             )
           };
         }
-        return outputSchema.parse(juniorToolResultSchema.parse(result));
+        return outputSchema5.parse(juniorToolResultSchema.parse(result));
       }
     } : {}
   };
@@ -6727,7 +6729,7 @@ var McpToolManager = class {
     return client;
   }
   toManagedTool(plugin, client, tool) {
-    const outputSchema = toOptionalRecord(tool.outputSchema);
+    const outputSchema5 = toOptionalRecord(tool.outputSchema);
     const annotations = tool.annotations;
     const missingAnnotationKeys = missingToolAnnotationKeys(annotations);
     if (missingAnnotationKeys.length > 0) {
@@ -6744,7 +6746,7 @@ var McpToolManager = class {
       provider: plugin.manifest.name,
       rawName: tool.name,
       ...tool.title?.trim() ? { title: tool.title.trim() } : {},
-      ...outputSchema ? { outputSchema } : {},
+      ...outputSchema5 ? { outputSchema: outputSchema5 } : {},
       ...annotations ? { annotations } : {},
       execute: async (args, options) => {
         const resolvedArgs = typeof args === "object" && args !== null ? args : {};
@@ -7627,14 +7629,51 @@ function createReportProgressTool() {
   });
 }
 
-// src/chat/tools/resource-events.ts
+// 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 } from "@sentry/junior-plugin-api";
+import {
+  destinationSchema,
+  resourceEventTypeSchema
+} from "@sentry/junior-plugin-api";
 import { z as z18 } from "zod";
-var RESOURCE_EVENT_PREFIX = "junior:resource_event_subscription";
+var RESOURCE_EVENT_PREFIX = "junior:resource_event_subscription:v2";
 var INDEX_LOCK_TTL_MS = 1e4;
 var SUBSCRIPTION_LOCK_TTL_MS = 1e4;
 var SUBSCRIPTION_LOCK_WAIT_MS = 1e4;
@@ -7646,13 +7685,13 @@ var subscriptionSchema = z18.object({
   conversationId: z18.string().min(1),
   createdAtMs: z18.number().finite(),
   destination: destinationSchema,
-  events: z18.array(z18.string().min(1)).min(1),
+  events: z18.array(resourceEventTypeSchema).min(1),
   expiresAtMs: z18.number().finite(),
   id: z18.string().min(1),
   intent: z18.string().min(1),
   label: z18.string().min(1),
-  provider: z18.string().min(1),
-  resourceRef: z18.string().min(1),
+  namespace: z18.string().min(1),
+  identifier: z18.string().min(1),
   resourceType: z18.string().min(1),
   status: subscriptionStatusSchema,
   updatedAtMs: z18.number().finite()
@@ -7666,8 +7705,8 @@ function subscriptionKey(id) {
 function subscriptionLockKey(id) {
   return `${RESOURCE_EVENT_PREFIX}:lock:${id}`;
 }
-function resourceIndexKey(provider, resourceRef) {
-  return `${RESOURCE_EVENT_PREFIX}:resource:${digest(`${provider}\0${resourceRef}`)}`;
+function resourceIndexKey(namespace, identifier) {
+  return `${RESOURCE_EVENT_PREFIX}:resource:${digest(`${namespace}\0${identifier}`)}`;
 }
 function conversationIndexKey(conversationId) {
   return `${RESOURCE_EVENT_PREFIX}:conversation:${digest(conversationId)}`;
@@ -7753,7 +7792,7 @@ async function readSubscriptionIdIndex(state, key) {
 function buildSubscriptionId(input) {
   const eventKey = [...new Set(input.events)].sort().join("\0");
   return `resub_${digest(
-    `${input.provider}\0${input.resourceRef}\0${input.conversationId}\0${eventKey}`
+    `${input.namespace}\0${input.identifier}\0${input.conversationId}\0${eventKey}`
   )}`;
 }
 async function withIndexLock(state, key, callback) {
@@ -7805,7 +7844,7 @@ function activeAt(subscription, nowMs) {
   return subscription.status === "active" && subscription.expiresAtMs > nowMs;
 }
 function matchesEvent(subscription, input) {
-  return subscription.provider === input.provider && subscription.resourceRef === input.resourceRef && subscription.events.includes(input.eventType) && activeAt(subscription, input.nowMs);
+  return subscription.namespace === input.namespace && subscription.identifier === input.identifier && subscription.events.includes(input.eventType) && activeAt(subscription, input.nowMs);
 }
 async function createResourceEventSubscription(input, options = {}) {
   const state = options.state ?? getStateAdapter();
@@ -7823,8 +7862,8 @@ async function createResourceEventSubscription(input, options = {}) {
   const id = buildSubscriptionId({
     conversationId: input.conversationId,
     events,
-    provider: input.provider,
-    resourceRef: input.resourceRef
+    namespace: input.namespace,
+    identifier: input.identifier
   });
   const record = {
     conversationId: input.conversationId,
@@ -7835,8 +7874,8 @@ async function createResourceEventSubscription(input, options = {}) {
     id,
     intent: input.intent,
     label: input.label,
-    provider: input.provider,
-    resourceRef: input.resourceRef,
+    namespace: input.namespace,
+    identifier: input.identifier,
     resourceType: input.resourceType,
     status: "active",
     updatedAtMs: nowMs
@@ -7849,7 +7888,7 @@ async function createResourceEventSubscription(input, options = {}) {
   );
   await addToIndex(
     state,
-    resourceIndexKey(input.provider, input.resourceRef),
+    resourceIndexKey(input.namespace, input.identifier),
     id,
     nowMs
   );
@@ -7901,7 +7940,7 @@ async function cancelResourceEventSubscription(input) {
     );
     await removeFromIndex(
       state,
-      resourceIndexKey(current.provider, current.resourceRef),
+      resourceIndexKey(current.namespace, current.identifier),
       input.id,
       nowMs
     );
@@ -7931,7 +7970,7 @@ async function findMatchingResourceEventSubscriptions(input) {
   const nowMs = input.nowMs ?? Date.now();
   const ids = await readSubscriptionIdIndex(
     state,
-    resourceIndexKey(input.provider, input.resourceRef)
+    resourceIndexKey(input.namespace, input.identifier)
   );
   const records = await Promise.all(
     ids.map(
@@ -7942,8 +7981,8 @@ async function findMatchingResourceEventSubscriptions(input) {
     (record) => record !== void 0 && matchesEvent(record, {
       eventType: input.eventType,
       nowMs,
-      provider: input.provider,
-      resourceRef: input.resourceRef
+      namespace: input.namespace,
+      identifier: input.identifier
     })
   );
 }
@@ -7961,8 +8000,8 @@ async function deliverResourceEventSubscription(input) {
       if (!current || !matchesEvent(current, {
         eventType: input.eventType,
         nowMs,
-        provider: input.provider,
-        resourceRef: input.resourceRef
+        namespace: input.namespace,
+        identifier: input.identifier
       })) {
         return false;
       }
@@ -7986,7 +8025,7 @@ async function deliverResourceEventSubscription(input) {
         );
         await removeFromIndex(
           state,
-          resourceIndexKey(current.provider, current.resourceRef),
+          resourceIndexKey(current.namespace, current.identifier),
           current.id,
           nowMs
         );
@@ -8003,119 +8042,24 @@ async function deliverResourceEventSubscription(input) {
   );
 }
 
-// src/chat/tools/resource-events.ts
-var DEFAULT_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
-var MAX_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
-var STOP_WATCHING_TOOL_NAME = "stopWatchingResources";
-var RESOURCE_WATCH_TOOL_SOURCE = {
-  id: "resource-watches",
-  description: "Inspect or stop resource watches for the current conversation."
-};
-var subscribeInputSchema = z19.object({
-  resourceRef: z19.string().describe("Opaque resource ref copied from a subscribable tool result."),
-  provider: z19.string().describe("Provider that owns the resource ref."),
-  resourceType: z19.string().describe("Provider-defined resource type from the subscribable hint."),
-  label: z19.string().describe("Human-readable resource label from the subscribable hint."),
-  events: z19.array(z19.string()).min(1).describe(
-    "High-signal event names to deliver to this conversation when they occur."
-  ),
-  intent: z19.string().describe(
-    "Concise reason this conversation wants these events, used when an event arrives."
-  ),
-  ttlMs: z19.coerce.number().describe(
-    "How long to keep the subscription active. Defaults to 14 days and is capped at 30 days."
-  ).optional()
-});
-function requireConversationContext(context) {
-  if (!context.conversationId) {
-    throw new Error("Resource event subscriptions require a conversation");
-  }
-  if (context.destination.platform !== "slack") {
-    throw new Error(
-      "Resource event subscriptions currently require Slack delivery"
-    );
-  }
-  if (!isSlackThreadConversationId(context.conversationId)) {
-    throw new Error(
-      "Resource event subscriptions require a Slack thread conversation"
-    );
-  }
-  return context.conversationId;
-}
-function canUseResourceEventSubscriptionTools(context) {
-  return context.destination.platform === "slack" && Boolean(
-    context.conversationId && isSlackThreadConversationId(context.conversationId)
-  );
-}
-function isSlackThreadConversationId(conversationId) {
-  const parts = conversationId.split(":");
-  return parts.length === 3 && parts[0] === "slack" && Boolean(parts[1]) && Boolean(parts[2]);
-}
-function cleanStrings(values) {
-  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
-}
-function ttlMs(input) {
-  if (input.ttlMs === void 0) {
-    return DEFAULT_TTL_MS;
-  }
-  if (!Number.isFinite(input.ttlMs) || input.ttlMs <= 0) {
-    throw new Error("ttlMs must be a positive finite number");
-  }
-  return Math.min(input.ttlMs, MAX_TTL_MS);
-}
-function createSubscribeToResourceEventsTool(context) {
-  return zodTool({
-    annotations: {
-      destructiveHint: false,
-      idempotentHint: false,
-      openWorldHint: true,
-      readOnlyHint: false
-    },
-    description: "Subscribe the current conversation to high-signal events for a resource returned by a subscribable tool result. Matching events are queued as normal conversation messages; they do not interrupt active work.",
-    inputSchema: subscribeInputSchema,
-    outputSchema: juniorToolResultSchema,
-    async execute(input) {
-      const conversationId = requireConversationContext(context);
-      const events = cleanStrings(input.events);
-      const intent = input.intent.trim();
-      if (!intent) {
-        throw new Error("intent is required");
-      }
-      const nowMs = Date.now();
-      const subscription = await createResourceEventSubscription({
-        conversationId,
-        destination: context.destination,
-        events,
-        expiresAtMs: nowMs + ttlMs(input),
-        intent,
-        label: input.label.trim(),
-        provider: input.provider.trim(),
-        resourceRef: input.resourceRef.trim(),
-        resourceType: input.resourceType.trim()
-      });
-      const details = {
-        id: subscription.id,
-        subscription_status: subscription.status,
-        resourceRef: subscription.resourceRef,
-        events: subscription.events,
-        expiresAtMs: subscription.expiresAtMs,
-        stop_watching: {
-          execution_tool: "executeTool",
-          execution_example: {
-            tool_name: STOP_WATCHING_TOOL_NAME,
-            arguments: {}
-          }
-        }
-      };
-      return {
-        ok: true,
-        status: "success",
-        data: details,
-        ...details
-      };
-    }
-  });
-}
+// 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()
+}).strict();
+var resultDataSchema = z19.object({ subscriptions: z19.array(listedResourceWatchSchema) }).strict();
+var outputSchema = juniorToolResultSchema.extend({
+  ok: z19.literal(true),
+  status: z19.literal("success"),
+  data: resultDataSchema,
+  subscriptions: z19.array(listedResourceWatchSchema)
+}).strict();
 function createListResourceEventSubscriptionsTool(context) {
   return zodTool({
     annotations: {
@@ -8127,10 +8071,10 @@ function createListResourceEventSubscriptionsTool(context) {
     description: "List active resource event subscriptions for the current conversation.",
     exposure: "deferred",
     source: RESOURCE_WATCH_TOOL_SOURCE,
-    inputSchema: z19.object({}),
-    outputSchema: juniorToolResultSchema,
+    inputSchema: z19.object({}).strict(),
+    outputSchema,
     async execute() {
-      const conversationId = requireConversationContext(context);
+      const conversationId = requireResourceWatchConversation(context);
       const subscriptions = await listResourceEventSubscriptions({
         conversationId
       });
@@ -8138,8 +8082,8 @@ function createListResourceEventSubscriptionsTool(context) {
         subscriptions: subscriptions.map((subscription) => ({
           id: subscription.id,
           label: subscription.label,
-          resourceRef: subscription.resourceRef,
-          provider: subscription.provider,
+          identifier: subscription.identifier,
+          namespace: subscription.namespace,
           resourceType: subscription.resourceType,
           events: subscription.events,
           intent: subscription.intent,
@@ -8155,6 +8099,157 @@ function createListResourceEventSubscriptionsTool(context) {
     }
   });
 }
+
+// src/chat/tools/search-resource-event-types.ts
+import { z as z21 } from "zod";
+
+// src/chat/resource-events/catalog.ts
+import {
+  normalizeResourceEventIdentifier
+} from "@sentry/junior-plugin-api";
+import { z as z20 } from "zod";
+function enumSchema(values, unavailableMessage) {
+  if (values.length === 0) {
+    return z20.string().refine(() => false, unavailableMessage);
+  }
+  return z20.enum(values);
+}
+function eventNamespaceSchema(catalog) {
+  return enumSchema(
+    Object.keys(catalog).sort(),
+    "No resource event namespaces are enabled."
+  );
+}
+function registeredEventTypeSchema(catalog) {
+  return enumSchema(
+    [
+      ...new Set(
+        Object.values(catalog).flatMap(
+          (registration) => registration.resourceTypes.flatMap(
+            (resourceType) => resourceType.supportedEvents
+          )
+        )
+      )
+    ].sort(),
+    "No resource event types are enabled."
+  );
+}
+function registeredResourceTypeSchema(catalog) {
+  return enumSchema(
+    [
+      ...new Set(
+        Object.values(catalog).flatMap(
+          (registration) => registration.resourceTypes.map((resourceType) => resourceType.type)
+        )
+      )
+    ].sort(),
+    "No resource types are enabled."
+  );
+}
+function pluginSupportsEvent(catalog, namespace, resourceType, eventType) {
+  return catalog[namespace]?.resourceTypes.find((candidate) => candidate.type === resourceType)?.supportedEvents.includes(eventType) ?? false;
+}
+function normalizeEventIdentifier(catalog, namespace, identifier) {
+  return normalizeResourceEventIdentifier(catalog[namespace], identifier);
+}
+
+// src/chat/tools/search-resource-event-types.ts
+var DEFAULT_SEARCH_RESULTS = 10;
+var MAX_SEARCH_RESULTS = 20;
+var searchedResourceTypeSchema = z21.object({
+  namespace: z21.string(),
+  type: z21.string(),
+  supportedEvents: z21.array(z21.string()),
+  suggestedEvents: z21.array(z21.string()).optional()
+}).strict();
+var outputSchema2 = juniorToolResultSchema.extend({
+  query: z21.string().nullable(),
+  namespace: z21.string().nullable(),
+  totalMatches: z21.number().int().nonnegative(),
+  resourceTypes: z21.array(searchedResourceTypeSchema)
+}).strict();
+function normalizeSearchText(value) {
+  return value.toLowerCase().replace(/[^a-z0-9_.-]+/g, " ").trim();
+}
+function searchableResourceTypes(catalog) {
+  return Object.entries(catalog).flatMap(
+    ([namespace, registration]) => registration.resourceTypes.map((resourceType) => ({
+      namespace,
+      type: resourceType.type,
+      supportedEvents: [...resourceType.supportedEvents].sort(),
+      ...resourceType.suggestedEvents ? { suggestedEvents: [...resourceType.suggestedEvents].sort() } : {}
+    }))
+  ).sort(
+    (left, right) => left.namespace.localeCompare(right.namespace) || left.type.localeCompare(right.type)
+  );
+}
+function createSearchResourceEventTypesTool(catalog) {
+  return zodTool({
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+      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. This tool does not watch a resource or enumerate concrete resources.",
+    inputSchema: z21.object({
+      query: z21.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: z21.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 }) {
+      const normalizedQuery = normalizeSearchText(query ?? "");
+      const terms = normalizedQuery.split(/\s+/).filter(Boolean);
+      const matches = searchableResourceTypes(catalog).filter(
+        (resourceType) => {
+          if (namespace && resourceType.namespace !== namespace) return false;
+          const text = normalizeSearchText(
+            [
+              resourceType.namespace,
+              resourceType.type,
+              ...resourceType.supportedEvents,
+              ...resourceType.suggestedEvents ?? []
+            ].join(" ")
+          );
+          return terms.every((term) => text.includes(term));
+        }
+      );
+      const resourceTypes = matches.slice(
+        0,
+        maxResults ?? DEFAULT_SEARCH_RESULTS
+      );
+      const details = {
+        query: query ?? null,
+        namespace: namespace ?? null,
+        totalMatches: matches.length,
+        resourceTypes
+      };
+      return {
+        ok: true,
+        status: "success",
+        data: details,
+        ...details
+      };
+    }
+  });
+}
+
+// src/chat/tools/stop-watching-resources.ts
+import { z as z22 } from "zod";
+var resultDataSchema2 = z22.object({
+  watching_status: z22.literal("stopped"),
+  stoppedIds: z22.array(z22.string().min(1))
+}).strict();
+var outputSchema3 = juniorToolResultSchema.extend({
+  ok: z22.literal(true),
+  status: z22.literal("success"),
+  data: resultDataSchema2,
+  watching_status: z22.literal("stopped"),
+  stoppedIds: z22.array(z22.string().min(1))
+}).strict();
 function createStopWatchingResourcesTool(context) {
   return zodTool({
     annotations: {
@@ -8163,16 +8258,182 @@ function createStopWatchingResourcesTool(context) {
       openWorldHint: false,
       readOnlyHint: false
     },
-    description: "Stop every resource watch for the current conversation. Infer the user's intent from context instead of requiring a special command, and call this tool before confirming that watching stopped.",
+    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: z19.object({}),
-    outputSchema: juniorToolResultSchema,
-    async execute() {
-      const conversationId = requireConversationContext(context);
-      await cancelSubscriptions({ conversationId });
+    inputSchema: z22.object({ id: z22.string().min(1).nullable().optional() }).strict(),
+    outputSchema: outputSchema3,
+    async execute({ id }) {
+      const conversationId = requireResourceWatchConversation(context);
+      let stoppedIds;
+      if (id) {
+        const stopped = await cancelResourceEventSubscription({
+          conversationId,
+          id
+        });
+        if (!stopped) {
+          throw new ToolInputError(
+            "Resource watch was not found in the current Slack thread."
+          );
+        }
+        stoppedIds = [stopped.id];
+      } else {
+        const subscriptions = await listResourceEventSubscriptions({
+          conversationId
+        });
+        await cancelSubscriptions({ conversationId });
+        stoppedIds = subscriptions.map((subscription) => subscription.id);
+      }
+      const details = {
+        watching_status: "stopped",
+        stoppedIds
+      };
+      return {
+        ok: true,
+        status: "success",
+        data: details,
+        ...details
+      };
+    }
+  });
+}
+
+// src/chat/tools/watch-resource-events.ts
+import { z as z23 } from "zod";
+var DEFAULT_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
+var MAX_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+function inputSchema(catalog) {
+  return z23.object({
+    identifier: z23.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: z23.string().trim().min(1).max(500).describe("Human-readable resource label."),
+    events: z23.array(registeredEventTypeSchema(catalog)).min(1).describe(
+      "High-signal event names to deliver to this conversation when they occur."
+    ),
+    intent: z23.string().trim().min(1).max(4e3).describe(
+      "Concise reason this conversation wants these events, used when an event arrives."
+    ),
+    ttlMs: z23.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) => {
+    subscription.events.forEach((eventType, index) => {
+      if (!pluginSupportsEvent(
+        catalog,
+        subscription.namespace,
+        subscription.resourceType,
+        eventType
+      )) {
+        context.addIssue({
+          code: "custom",
+          message: `Resource type "${subscription.namespace}:${subscription.resourceType}" does not support event "${eventType}".`,
+          path: ["events", index]
+        });
+      }
+    });
+  });
+}
+var stopWatchingActionSchema = z23.object({
+  execution_tool: z23.literal("executeTool"),
+  execution_example: z23.object({
+    tool_name: z23.literal(STOP_WATCHING_TOOL_NAME),
+    arguments: z23.object({ id: z23.string().min(1) }).strict()
+  }).strict()
+}).strict();
+var resultDataSchema3 = z23.object({
+  id: z23.string().min(1),
+  subscription_status: z23.enum(["active", "cancelled", "completed"]),
+  identifier: z23.string().min(1),
+  events: z23.array(z23.string().min(1)).min(1),
+  expiresAtMs: z23.number().finite(),
+  stop_watching: stopWatchingActionSchema
+}).strict();
+var outputSchema4 = juniorToolResultSchema.extend({
+  ok: z23.literal(true),
+  status: z23.literal("success"),
+  data: resultDataSchema3,
+  id: resultDataSchema3.shape.id,
+  subscription_status: resultDataSchema3.shape.subscription_status,
+  identifier: resultDataSchema3.shape.identifier,
+  events: resultDataSchema3.shape.events,
+  expiresAtMs: resultDataSchema3.shape.expiresAtMs,
+  stop_watching: stopWatchingActionSchema
+}).strict();
+function cleanStrings(values) {
+  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function ttlMs(input) {
+  if (input.ttlMs === void 0) return DEFAULT_TTL_MS;
+  if (!Number.isFinite(input.ttlMs) || input.ttlMs <= 0) {
+    throw new ToolInputError("ttlMs must be a positive finite number");
+  }
+  if (input.ttlMs > MAX_TTL_MS) {
+    throw new ToolInputError("Resource watches cannot exceed 30 days");
+  }
+  return input.ttlMs;
+}
+function createWatchResourceEventsTool(context, catalog) {
+  return zodTool({
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true,
+      readOnlyHint: false
+    },
+    description: "Watch one plugin resource in the current Slack thread for a limited time; matching events return to this conversation as updates. Use for watch, notify, or tell-me-when requests. This does not create a scheduled polling task. Prefer a subscribable tool result when available.",
+    inputSchema: inputSchema(catalog),
+    outputSchema: outputSchema4,
+    async execute(input) {
+      const conversationId = requireResourceWatchConversation(context);
+      const events = cleanStrings(input.events);
+      for (const eventType of events) {
+        if (!pluginSupportsEvent(
+          catalog,
+          input.namespace,
+          input.resourceType,
+          eventType
+        )) {
+          throw new ToolInputError(
+            `Resource type "${input.namespace}:${input.resourceType}" does not support event "${eventType}".`
+          );
+        }
+      }
+      const intent = input.intent.trim();
+      if (!intent) throw new ToolInputError("intent is required");
+      const nowMs = Date.now();
+      const subscription = await createResourceEventSubscription({
+        conversationId,
+        destination: context.destination,
+        events,
+        expiresAtMs: nowMs + ttlMs(input),
+        intent,
+        label: input.label.trim(),
+        namespace: input.namespace.trim(),
+        identifier: normalizeEventIdentifier(
+          catalog,
+          input.namespace,
+          input.identifier
+        ),
+        resourceType: input.resourceType.trim()
+      });
       const details = {
-        watching_status: "stopped"
+        id: subscription.id,
+        subscription_status: subscription.status,
+        identifier: subscription.identifier,
+        events: subscription.events,
+        expiresAtMs: subscription.expiresAtMs,
+        stop_watching: {
+          execution_tool: "executeTool",
+          execution_example: {
+            tool_name: STOP_WATCHING_TOOL_NAME,
+            arguments: { id: subscription.id }
+          }
+        }
       };
       return {
         ok: true,
@@ -8183,14 +8444,23 @@ function createStopWatchingResourcesTool(context) {
     }
   });
 }
-function createResourceEventTools(context) {
+
+// src/chat/tools/resource-events.ts
+function createResourceEventTools(context, catalog) {
+  const enabled = Object.keys(catalog).length > 0;
+  const discoveryTools = context.destination.platform === "slack" && enabled ? {
+    searchResourceEventTypes: createSearchResourceEventTypesTool(catalog)
+  } : {};
   if (!canUseResourceEventSubscriptionTools(context)) {
-    return {};
+    return discoveryTools;
   }
   return {
-    subscribeToResourceEvents: createSubscribeToResourceEventsTool(context),
+    ...discoveryTools,
+    ...enabled ? {
+      watchResourceEvents: createWatchResourceEventsTool(context, catalog)
+    } : {},
     listResourceEventSubscriptions: createListResourceEventSubscriptionsTool(context),
-    [STOP_WATCHING_TOOL_NAME]: createStopWatchingResourcesTool(context)
+    stopWatchingResources: createStopWatchingResourcesTool(context)
   };
 }
 
@@ -8273,11 +8543,11 @@ async function listThreadReplies(input) {
 }
 
 // src/chat/slack/timestamp-param.ts
-import { z as z20 } from "zod";
+import { z as z24 } from "zod";
 function slackTimestampParam(description) {
-  return z20.preprocess(
+  return z24.preprocess(
     (value) => typeof value === "number" && Number.isFinite(value) ? String(value) : value,
-    z20.string().min(1)
+    z24.string().min(1)
   ).describe(description);
 }
 function optionalSlackTimestampParam(description) {
@@ -8308,10 +8578,10 @@ function parseRequiredSlackTimestampParam(field, value) {
 }
 
 // src/chat/slack/tools/channel-list-messages.ts
-import { z as z21 } from "zod";
-var booleanInput2 = (description) => z21.preprocess(
+import { z as z25 } from "zod";
+var booleanInput2 = (description) => z25.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z21.boolean()
+  z25.boolean()
 ).describe(description);
 function normalizeRangeTimestamp(field, value, targetChannelId) {
   if (value === void 0) {
@@ -8343,9 +8613,9 @@ function createSlackChannelListMessagesTool(context) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z21.object({
-      limit: z21.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
-      cursor: z21.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
+    inputSchema: z25.object({
+      limit: z25.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
+      cursor: z25.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
       oldest: optionalSlackTimestampParam(
         "Optional oldest message timestamp (Slack ts) for range filtering."
       ),
@@ -8355,7 +8625,7 @@ function createSlackChannelListMessagesTool(context) {
       inclusive: booleanInput2(
         "Whether oldest/latest bounds should be inclusive."
       ).optional(),
-      max_pages: z21.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
+      max_pages: z25.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({
@@ -8429,20 +8699,20 @@ function createSlackChannelListMessagesTool(context) {
 }
 
 // src/chat/slack/tools/conversation-search.ts
-import { z as z22 } from "zod";
+import { z as z26 } from "zod";
 var DEFAULT_LIMIT = 5;
 var conversationSearchOutputSchema = juniorToolResultSchema.extend({
-  query: z22.string(),
-  count: z22.number().int().nonnegative(),
-  threads: z22.array(
-    z22.object({
-      conversation_id: z22.string().min(1),
-      thread_ts: z22.string().min(1),
-      message_id: z22.string().min(1),
-      message_role: z22.enum(["assistant", "user"]),
-      message_timestamp: z22.string().datetime(),
-      excerpt: z22.string(),
-      permalink: z22.string().url().optional()
+  query: z26.string(),
+  count: z26.number().int().nonnegative(),
+  threads: z26.array(
+    z26.object({
+      conversation_id: z26.string().min(1),
+      thread_ts: z26.string().min(1),
+      message_id: z26.string().min(1),
+      message_role: z26.enum(["assistant", "user"]),
+      message_timestamp: z26.string().datetime(),
+      excerpt: z26.string(),
+      permalink: z26.string().url().optional()
     }).strict()
   )
 });
@@ -8460,9 +8730,9 @@ function createSlackConversationSearchTool(scope, currentConversationId, deps =
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z22.object({
-      query: z22.string().trim().min(1).max(200).describe("Words or a short phrase to find in prior conversations."),
-      limit: z22.number().int().min(1).max(10).describe("Maximum number of prior conversation threads to return.").nullable().optional()
+    inputSchema: z26.object({
+      query: z26.string().trim().min(1).max(200).describe("Words or a short phrase to find in prior conversations."),
+      limit: z26.number().int().min(1).max(10).describe("Maximum number of prior conversation threads to return.").nullable().optional()
     }),
     outputSchema: conversationSearchOutputSchema,
     execute: async ({ query, limit }) => {
@@ -8509,27 +8779,27 @@ function createSlackConversationSearchTool(scope, currentConversationId, deps =
 }
 
 // src/chat/slack/tools/public-search.ts
-import { z as z23 } from "zod";
+import { z as z27 } from "zod";
 var DEFAULT_LIMIT2 = 10;
-var optionalTimestampSchema = z23.preprocess(
+var optionalTimestampSchema = z27.preprocess(
   (value) => typeof value === "string" && value.trim() === "" ? void 0 : value,
-  z23.coerce.number().int().nonnegative().describe("Optional Unix timestamp bound.").optional()
+  z27.coerce.number().int().nonnegative().describe("Optional Unix timestamp bound.").optional()
 );
-var searchMessageSchema = z23.object({
-  author_name: z23.string().optional(),
-  author_user_id: z23.string().optional(),
-  channel_id: z23.string().min(1),
-  channel_name: z23.string().optional(),
-  message_ts: z23.string().min(1),
-  content: z23.string(),
-  is_author_bot: z23.boolean().optional(),
-  permalink: z23.string().url()
+var searchMessageSchema = z27.object({
+  author_name: z27.string().optional(),
+  author_user_id: z27.string().optional(),
+  channel_id: z27.string().min(1),
+  channel_name: z27.string().optional(),
+  message_ts: z27.string().min(1),
+  content: z27.string(),
+  is_author_bot: z27.boolean().optional(),
+  permalink: z27.string().url()
 });
 var publicSearchOutputSchema = juniorToolResultSchema.extend({
-  query: z23.string(),
-  count: z23.number().int().nonnegative(),
-  messages: z23.array(searchMessageSchema),
-  next_cursor: z23.string().optional()
+  query: z27.string(),
+  count: z27.number().int().nonnegative(),
+  messages: z27.array(searchMessageSchema),
+  next_cursor: z27.string().optional()
 });
 function normalizeMessage(value) {
   const parsed = searchMessageSchema.safeParse(value);
@@ -8556,8 +8826,8 @@ function createSlackPublicSearchTool(actionToken) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z23.object({
-      query: z23.string().trim().min(1).max(500).describe(
+    inputSchema: z27.object({
+      query: z27.string().trim().min(1).max(500).describe(
         "A focused Slack search query, including Slack search filters when useful."
       ),
       after: optionalTimestampSchema.describe(
@@ -8566,10 +8836,10 @@ function createSlackPublicSearchTool(actionToken) {
       before: optionalTimestampSchema.describe(
         "Optional Unix timestamp upper bound."
       ),
-      cursor: z23.string().min(1).describe("Cursor for the next result page.").optional(),
-      limit: z23.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
-      sort: z23.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
-      sort_dir: z23.enum(["asc", "desc"]).describe("Sort direction.").optional()
+      cursor: z27.string().min(1).describe("Cursor for the next result page.").optional(),
+      limit: z27.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
+      sort: z27.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
+      sort_dir: z27.enum(["asc", "desc"]).describe("Sort direction.").optional()
     }),
     outputSchema: publicSearchOutputSchema,
     execute: async ({
@@ -8635,7 +8905,7 @@ function createSlackPublicSearchTool(actionToken) {
 }
 
 // src/chat/slack/tools/message-add-reaction.ts
-import { z as z24 } from "zod";
+import { z as z28 } from "zod";
 
 // src/chat/tools/idempotency.ts
 function stableSerialize(value) {
@@ -8665,8 +8935,8 @@ function createSlackMessageAddReactionTool(context, state) {
       readOnlyHint: false
     },
     description: "Add an emoji reaction to the current inbound Slack message. Use when the user asks for a reaction on the current message without another target. Provide a Slack emoji alias name (for example `thumbsup`, `white_check_mark`, or `thumbsup::skin-tone-6`), not a unicode emoji glyph. The target message is injected by runtime context; do not use this for arbitrary historical messages.",
-    inputSchema: z24.object({
-      emoji: z24.string().min(1).max(64).describe(
+    inputSchema: z28.object({
+      emoji: z28.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."
       )
     }),
@@ -8717,18 +8987,18 @@ function createSlackMessageAddReactionTool(context, state) {
 
 // src/chat/slack/tools/send-files.ts
 import { createHash as createHash2 } from "crypto";
-import { z as z25 } from "zod";
-var sendFilesDataSchema = z25.object({
-  channel_id: z25.string().min(1),
-  deduplicated: z25.boolean().optional(),
-  file_count: z25.number().int().nonnegative(),
-  file_ids: z25.array(z25.string().min(1)).optional(),
-  thread_ts: z25.string().min(1)
+import { z as z29 } from "zod";
+var sendFilesDataSchema = z29.object({
+  channel_id: z29.string().min(1),
+  deduplicated: z29.boolean().optional(),
+  file_count: z29.number().int().nonnegative(),
+  file_ids: z29.array(z29.string().min(1)).optional(),
+  thread_ts: z29.string().min(1)
 });
 var sendFilesResultSchema = juniorToolResultSchema.extend({
-  ok: z25.literal(true),
-  status: z25.literal("success"),
-  target: z25.string().min(1),
+  ok: z29.literal(true),
+  status: z29.literal("success"),
+  target: z29.string().min(1),
   data: sendFilesDataSchema
 });
 function normalizeFiles(files) {
@@ -8759,8 +9029,8 @@ function createSendFilesTool(context, state, materializeFile) {
       readOnlyHint: false
     },
     description: "Send one or more sandbox files into the active Slack conversation. Use when the user asks to attach, send, or share files here, in this conversation, or in this thread. Do not use for ordinary assistant text, top-level channel posts, other named channels, inline @mentions, or pinging mentioned users.",
-    inputSchema: z25.object({
-      files: z25.array(sandboxFileReferenceSchema).min(1).describe(
+    inputSchema: z29.object({
+      files: z29.array(sandboxFileReferenceSchema).min(1).describe(
         "One or more existing sandbox files. Objects returned by imageGenerate or webFetch can be passed unchanged."
       )
     }),
@@ -9199,7 +9469,7 @@ function storedCanvasUrl(state, canvasId) {
 }
 
 // src/chat/slack/tools/canvas/create.ts
-import { z as z26 } from "zod";
+import { z as z30 } from "zod";
 function createSlackCanvasCreateTool(context, state) {
   return zodTool({
     annotations: {
@@ -9209,9 +9479,9 @@ function createSlackCanvasCreateTool(context, state) {
       readOnlyHint: false
     },
     description: "Create a Slack canvas for long-form output in the active assistant context channel. Use when the answer is better as a reusable document than a thread reply: long-form research, timelines, bios/profiles, structured notes, plans, comparisons, or anything likely to exceed one compact Slack reply. After creating it, reply with one or two short sentences plus the canvas link; do not recap the canvas contents. Do not use for short answers that fit cleanly in one normal thread reply.",
-    inputSchema: z26.object({
-      title: z26.string().min(1).max(160).describe("Canvas title."),
-      markdown: z26.string().min(1).describe("Canvas markdown body content.")
+    inputSchema: z30.object({
+      title: z30.string().min(1).max(160).describe("Canvas title."),
+      markdown: z30.string().min(1).describe("Canvas markdown body content.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ title, markdown }) => {
@@ -9269,26 +9539,26 @@ function createSlackCanvasCreateTool(context, state) {
 }
 
 // src/chat/slack/tools/canvas/edit.ts
-import { z as z27 } from "zod";
+import { z as z31 } from "zod";
 function prepareCanvasEditArguments(input) {
   return prepareTextReplacementArguments(input);
 }
-var editReplacementSchema2 = z27.object({
-  oldText: z27.string().min(1).describe(
+var editReplacementSchema2 = z31.object({
+  oldText: z31.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: z27.string().describe("Replacement Canvas markdown for this edit.")
+  newText: z31.string().describe("Replacement Canvas markdown for this edit.")
 });
 var slackCanvasEditOutputSchema = juniorToolResultSchema.extend({
-  canvas_id: z27.string().optional(),
-  title: z27.string().optional(),
-  permalink: z27.string().optional(),
-  diff: z27.string().optional(),
-  first_changed_line: z27.number().int().positive().optional(),
-  replacements: z27.number().int().nonnegative().optional(),
-  normalized_heading_count: z27.number().int().nonnegative().optional(),
-  summary: z27.string().optional(),
-  deduplicated: z27.boolean().optional()
+  canvas_id: z31.string().optional(),
+  title: z31.string().optional(),
+  permalink: z31.string().optional(),
+  diff: z31.string().optional(),
+  first_changed_line: z31.number().int().positive().optional(),
+  replacements: z31.number().int().nonnegative().optional(),
+  normalized_heading_count: z31.number().int().nonnegative().optional(),
+  summary: z31.string().optional(),
+  deduplicated: z31.boolean().optional()
 }).strict();
 function createSlackCanvasEditTool(state) {
   return zodTool({
@@ -9301,9 +9571,9 @@ function createSlackCanvasEditTool(state) {
     description: "Edit one Slack canvas with exact markdown replacements. Use for precise changes to existing Canvas content; prefer this over slackCanvasWrite for targeted changes. Each oldText must match exactly, be unique, and not overlap another edit. Returns a diff. Multiple changes to the same canvas: use one edits[] call.",
     prepareArguments: prepareCanvasEditArguments,
     executionMode: "sequential",
-    inputSchema: z27.object({
-      canvas: z27.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
-      edits: z27.array(editReplacementSchema2).min(1).describe(
+    inputSchema: z31.object({
+      canvas: z31.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
+      edits: z31.array(editReplacementSchema2).min(1).describe(
         "Exact replacements matched against the current Canvas body, not incrementally."
       )
     }),
@@ -9376,18 +9646,18 @@ function createSlackCanvasEditTool(state) {
 }
 
 // src/chat/slack/tools/canvas/read.ts
-import { z as z28 } from "zod";
+import { z as z32 } from "zod";
 var slackCanvasReadOutputSchema = juniorToolResultSchema.extend({
-  canvas_id: z28.string().optional(),
-  title: z28.string().optional(),
-  permalink: z28.string().optional(),
-  mimetype: z28.string().optional(),
-  filetype: z28.string().optional(),
-  original_byte_length: z28.number().int().nonnegative().optional(),
-  content: z28.string().optional(),
-  start_line: z28.number().int().positive().optional(),
-  end_line: z28.number().int().nonnegative().optional(),
-  total_lines: z28.number().int().nonnegative().optional()
+  canvas_id: z32.string().optional(),
+  title: z32.string().optional(),
+  permalink: z32.string().optional(),
+  mimetype: z32.string().optional(),
+  filetype: z32.string().optional(),
+  original_byte_length: z32.number().int().nonnegative().optional(),
+  content: z32.string().optional(),
+  start_line: z32.number().int().positive().optional(),
+  end_line: z32.number().int().nonnegative().optional(),
+  total_lines: z32.number().int().nonnegative().optional()
 }).strict();
 function createSlackCanvasReadTool() {
   return zodTool({
@@ -9398,12 +9668,12 @@ function createSlackCanvasReadTool() {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z28.object({
-      canvas: z28.string().min(1).describe(
+    inputSchema: z32.object({
+      canvas: z32.string().min(1).describe(
         "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL (e.g. `https://team.slack.com/docs/T.../F...`)."
       ),
-      offset: z28.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
-      limit: z28.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
+      offset: z32.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
+      limit: z32.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
     }),
     outputSchema: slackCanvasReadOutputSchema,
     execute: async ({ canvas, offset, limit }) => {
@@ -9455,7 +9725,7 @@ function createSlackCanvasReadTool() {
 }
 
 // src/chat/slack/tools/canvas/write.ts
-import { z as z29 } from "zod";
+import { z as z33 } from "zod";
 function createSlackCanvasWriteTool(state) {
   return zodTool({
     annotations: {
@@ -9466,9 +9736,9 @@ function createSlackCanvasWriteTool(state) {
     },
     description: "Write UTF-8 markdown content to a Slack canvas. Use for deliberate full-Canvas replacement after validation; use slackCanvasEdit for targeted changes to existing canvas content.",
     executionMode: "sequential",
-    inputSchema: z29.object({
-      canvas: z29.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
-      content: z29.string().describe("UTF-8 markdown content to write.")
+    inputSchema: z33.object({
+      canvas: z33.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
+      content: z33.string().describe("UTF-8 markdown content to write.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ canvas, content }) => {
@@ -9699,12 +9969,12 @@ async function updateListItem(input) {
 }
 
 // src/chat/slack/id-param.ts
-import { z as z30 } from "zod";
+import { z as z34 } from "zod";
 function slackChannelIdParam(description) {
-  return z30.string().min(1).describe(description);
+  return z34.string().min(1).describe(description);
 }
 function slackUserIdParam(description) {
-  return z30.string().min(1).describe(description);
+  return z34.string().min(1).describe(description);
 }
 function parseRequiredSlackChannelIdParam(field, value) {
   const channelId = parseSlackChannelId(value);
@@ -9728,7 +9998,7 @@ function parseRequiredSlackUserIdParam(field, value) {
 }
 
 // src/chat/slack/tools/list/add-items.ts
-import { z as z31 } from "zod";
+import { z as z35 } from "zod";
 function createSlackListAddItemsTool(state) {
   return zodTool({
     annotations: {
@@ -9738,12 +10008,12 @@ function createSlackListAddItemsTool(state) {
       readOnlyHint: false
     },
     description: "Add tasks to the active Slack list tracked in artifact context. Use when the user wants actionable items recorded in the current thread list. Do not use when no list exists and list creation was not requested.",
-    inputSchema: z31.object({
-      items: z31.array(z31.string().min(1)).min(1).max(25).describe("List item titles to create."),
+    inputSchema: z35.object({
+      items: z35.array(z35.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: z31.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
+      due_date: z35.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ items, assignee_user_id, due_date }) => {
@@ -9797,7 +10067,7 @@ function createSlackListAddItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/create.ts
-import { z as z32 } from "zod";
+import { z as z36 } from "zod";
 function createSlackListCreateTool(state) {
   return zodTool({
     annotations: {
@@ -9807,8 +10077,8 @@ function createSlackListCreateTool(state) {
       readOnlyHint: false
     },
     description: "Create a Slack todo list for action tracking. Use when the user needs structured tasks with ownership/completion tracking. Do not use for one-off notes without task management needs.",
-    inputSchema: z32.object({
-      name: z32.string().min(1).max(160).describe("Name for the new Slack list.")
+    inputSchema: z36.object({
+      name: z36.string().min(1).max(160).describe("Name for the new Slack list.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ name }) => {
@@ -9840,7 +10110,7 @@ function createSlackListCreateTool(state) {
 }
 
 // src/chat/slack/tools/list/get-items.ts
-import { z as z33 } from "zod";
+import { z as z37 } from "zod";
 function createSlackListGetItemsTool(state) {
   return zodTool({
     description: "Read items from the active Slack list tracked in artifact context. Use when the user asks for task status, open items, or list contents. Do not use when list state is already known from the immediately prior result.",
@@ -9850,8 +10120,8 @@ function createSlackListGetItemsTool(state) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z33.object({
-      limit: z33.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
+    inputSchema: z37.object({
+      limit: z37.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ limit }) => {
@@ -9876,21 +10146,21 @@ function createSlackListGetItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/update-item.ts
-import { z as z34 } from "zod";
-var booleanInput3 = (description) => z34.preprocess(
+import { z as z38 } from "zod";
+var booleanInput3 = (description) => z38.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z34.boolean()
+  z38.boolean()
 ).describe(description);
-var updateListItemInputSchema = z34.union([
-  z34.object({
-    item_id: z34.string().min(1).describe("ID of the Slack list item to update."),
+var updateListItemInputSchema = z38.union([
+  z38.object({
+    item_id: z38.string().min(1).describe("ID of the Slack list item to update."),
     completed: booleanInput3("Optional completion status update."),
-    title: z34.string().min(1).describe("Optional new item title.").optional()
+    title: z38.string().min(1).describe("Optional new item title.").optional()
   }),
-  z34.object({
-    item_id: z34.string().min(1).describe("ID of the Slack list item to update."),
+  z38.object({
+    item_id: z38.string().min(1).describe("ID of the Slack list item to update."),
     completed: booleanInput3("Optional completion status update.").optional(),
-    title: z34.string().min(1).describe("Optional new item title.")
+    title: z38.string().min(1).describe("Optional new item title.")
   })
 ]);
 function createSlackListUpdateItemTool(state) {
@@ -9972,7 +10242,7 @@ async function checkSlackChannelReadAccess(args) {
 }
 
 // src/chat/slack/tools/thread-read.ts
-import { z as z35 } from "zod";
+import { z as z39 } from "zod";
 
 // src/chat/slack/tools/slack-message-url.ts
 var SLACK_HOST_PATTERN = /^[a-z0-9-]+\.slack(?:-gov)?\.com$/;
@@ -10150,8 +10420,8 @@ function createSlackThreadReadTool(context, deps = {}) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z35.object({
-      url: z35.string().min(1).describe(
+    inputSchema: z39.object({
+      url: z39.string().min(1).describe(
         "Slack message archive URL, e.g. https://workspace.slack.com/archives/C123/p1700000000123456"
       ).optional(),
       channel_id: slackChannelIdParam(
@@ -10160,8 +10430,8 @@ function createSlackThreadReadTool(context, deps = {}) {
       ts: slackTimestampParam(
         "Slack message timestamp (e.g. 1700000000.123456). May be the thread root or any message in the thread."
       ).optional(),
-      limit: z35.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
-      max_pages: z35.coerce.number().int().min(1).max(10).describe("Maximum number of Slack API pages to traverse.").optional()
+      limit: z39.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
+      max_pages: z39.coerce.number().int().min(1).max(10).describe("Maximum number of Slack API pages to traverse.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ url, channel_id, ts, limit, max_pages }) => {
@@ -10417,10 +10687,10 @@ async function searchSlackUsers(options) {
 }
 
 // src/chat/slack/tools/user-lookup.ts
-import { z as z36 } from "zod";
-var booleanInput4 = (description) => z36.preprocess(
+import { z as z40 } from "zod";
+var booleanInput4 = (description) => z40.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z36.boolean()
+  z40.boolean()
 ).describe(description);
 function createSlackUserLookupTool() {
   return zodTool({
@@ -10431,20 +10701,20 @@ function createSlackUserLookupTool() {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z36.object({
+    inputSchema: z40.object({
       user_id: slackUserIdParam(
         "Slack user ID to look up (e.g. U039RR91S). Mutually exclusive with email and query."
       ).optional(),
-      email: z36.string().min(3).describe(
+      email: z40.string().min(3).describe(
         "Email address to look up. Mutually exclusive with user_id and query."
       ).optional(),
-      query: z36.string().min(2).describe(
+      query: z40.string().min(2).describe(
         "Name to search for (matches against username, display name, real name). Mutually exclusive with user_id and email."
       ).optional(),
-      limit: z36.coerce.number().int().min(1).max(20).describe(
+      limit: z40.coerce.number().int().min(1).max(20).describe(
         "Maximum number of results to return for name search. Defaults to 10."
       ).optional(),
-      max_pages: z36.coerce.number().int().min(1).max(5).describe(
+      max_pages: z40.coerce.number().int().min(1).max(5).describe(
         "Maximum number of Slack API pages to scan for name search. Defaults to 3."
       ).optional(),
       include_bots: booleanInput4(
@@ -10548,12 +10818,12 @@ function createSlackUserLookupTool() {
 }
 
 // src/chat/tools/system-time.ts
-import { z as z37 } from "zod";
+import { z as z41 } from "zod";
 var systemTimeOutputSchema = juniorToolResultSchema.extend({
-  unix_ms: z37.number(),
-  iso_utc: z37.string(),
-  iso_local: z37.string(),
-  timezone_offset_minutes: z37.number()
+  unix_ms: z41.number(),
+  iso_utc: z41.string(),
+  iso_local: z41.string(),
+  timezone_offset_minutes: z41.number()
 });
 function createSystemTimeTool() {
   return zodTool({
@@ -10564,7 +10834,7 @@ function createSystemTimeTool() {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z37.object({}),
+    inputSchema: z41.object({}),
     outputSchema: systemTimeOutputSchema,
     privateTraceResult: (result) => ({
       ok: result.ok,
@@ -10593,7 +10863,7 @@ function createSystemTimeTool() {
 }
 
 // src/chat/tools/query-conversation-events.ts
-import { z as z38 } from "zod";
+import { z as z42 } from "zod";
 var DEFAULT_LIMIT3 = 25;
 var MAX_LIMIT = 100;
 var MAX_EVENT_DATA_BYTES = 4e3;
@@ -10604,28 +10874,28 @@ var CONVERSATION_EVENTS_TOOL_SOURCE = {
   id: "conversation-events",
   description: "Inspect Junior's durable conversation event log for debugging runtime behavior."
 };
-var knownEventTypeSchema = z38.enum(KNOWN_CONVERSATION_EVENT_TYPES);
-var projectedEventSchema = z38.object({
-  seq: z38.number().int().nonnegative().describe("Stable event position; use it for pagination bounds."),
-  history_version: z38.number().int().nonnegative().describe(
+var knownEventTypeSchema = z42.enum(KNOWN_CONVERSATION_EVENT_TYPES);
+var projectedEventSchema = z42.object({
+  seq: z42.number().int().nonnegative().describe("Stable event position; use it for pagination bounds."),
+  history_version: z42.number().int().nonnegative().describe(
     "Model-history generation. It increments when handoff or compaction replaces active model context."
   ),
-  created_at: z38.iso.datetime().describe("When the event was recorded."),
-  idempotency_key: z38.string().min(1).optional().describe("Retry-stable event identity, when one was assigned."),
-  data: z38.record(z38.string(), z38.unknown()).describe(
+  created_at: z42.iso.datetime().describe("When the event was recorded."),
+  idempotency_key: z42.string().min(1).optional().describe("Retry-stable event identity, when one was assigned."),
+  data: z42.record(z42.string(), z42.unknown()).describe(
     "Event data. Oversized payloads are replaced by identifying fields, payload_omitted, and payload_json_bytes."
   )
 }).strict();
 var queryConversationEventsOutputSchema = juniorToolResultSchema.extend({
-  conversation_id: z38.string().min(1),
-  events: z38.array(projectedEventSchema),
-  has_older: z38.boolean().describe(
+  conversation_id: z42.string().min(1),
+  events: z42.array(projectedEventSchema),
+  has_older: z42.boolean().describe(
     "Whether matching events exist before this page; request them with before_seq set to the first returned seq."
   ),
-  has_newer: z38.boolean().describe(
+  has_newer: z42.boolean().describe(
     "Whether matching events exist after this page; request them with after_seq set to the last returned seq."
   ),
-  omitted_event_count: z38.number().int().nonnegative().optional().describe(
+  omitted_event_count: z42.number().int().nonnegative().optional().describe(
     "Fetched events omitted to keep this response bounded. Continue with the pagination cursor for the omitted direction."
   )
 });
@@ -10640,20 +10910,20 @@ function createQueryConversationEventsTool(context) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z38.object({
-      conversation_id: z38.string().trim().min(1).describe(
+    inputSchema: z42.object({
+      conversation_id: z42.string().trim().min(1).describe(
         "Conversation ID to inspect, such as slack:{channelId}:{threadTs} or a child conversation id."
       ),
-      after_seq: z38.number().int().nonnegative().nullable().describe(
+      after_seq: z42.number().int().nonnegative().nullable().describe(
         "Exclusive lower bound on event seq. When set, returns the next newer page in ascending order."
       ).optional(),
-      before_seq: z38.number().int().nonnegative().nullable().describe(
+      before_seq: z42.number().int().nonnegative().nullable().describe(
         "Exclusive upper bound on event seq. Combine with defaults or after_seq to page older or bounded ranges."
       ).optional(),
-      limit: z38.number().int().min(1).max(MAX_LIMIT).nullable().describe(
+      limit: z42.number().int().min(1).max(MAX_LIMIT).nullable().describe(
         `Maximum events to return. Defaults to ${DEFAULT_LIMIT3}; max ${MAX_LIMIT}.`
       ).optional(),
-      types: z38.array(knownEventTypeSchema).min(1).nullable().describe(
+      types: z42.array(knownEventTypeSchema).min(1).nullable().describe(
         "Optional event-type filter. Omit to return every durable event type."
       ).optional()
     }).strict(),
@@ -10903,10 +11173,10 @@ function stripReplacementHistoryField(value) {
 }
 
 // src/chat/tools/handoff/tool.ts
-import { z as z39 } from "zod";
+import { z as z43 } from "zod";
 var HANDOFF_TOOL_NAME = "handoff";
 function createHandoffTool(handoff) {
-  const profileSchema = z39.enum(handoff.profiles);
+  const profileSchema = z43.enum(handoff.profiles);
   const handoffResultSchema = juniorToolResultSchema.extend({
     model_profile: modelProfileSchema
   });
@@ -10920,7 +11190,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: z39.object({
+    inputSchema: z43.object({
       profile: profileSchema.describe("Target execution profile")
     }).strict(),
     outputSchema: handoffResultSchema,
@@ -10943,7 +11213,7 @@ function createHandoffTool(handoff) {
 }
 
 // src/chat/tools/web/fetch-tool.ts
-import { z as z40 } from "zod";
+import { z as z44 } from "zod";
 
 // src/chat/tools/web/constants.ts
 var USER_AGENT = "junior-bot/0.1";
@@ -11394,9 +11664,9 @@ function createWebFetchTool(hooks, options = {}) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z40.object({
-      url: z40.string().min(1).describe("HTTP(S) URL to fetch."),
-      max_chars: z40.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
+    inputSchema: z44.object({
+      url: z44.string().min(1).describe("HTTP(S) URL to fetch."),
+      max_chars: z44.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ url, max_chars }) => {
@@ -11457,7 +11727,7 @@ function createWebFetchTool(hooks, options = {}) {
 }
 
 // src/chat/tools/web/search.ts
-import { z as z41 } from "zod";
+import { z as z45 } from "zod";
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
 var SEARCH_TIMEOUT_MS = 6e4;
@@ -11507,9 +11777,9 @@ function createWebSearchTool(modelId, override) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z41.object({
-      query: z41.string().min(1).max(500).describe("Search query."),
-      max_results: z41.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
+    inputSchema: z45.object({
+      query: z45.string().min(1).max(500).describe("Search query."),
+      max_results: z45.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ query, max_results }) => {
@@ -11572,7 +11842,7 @@ function createWebSearchTool(modelId, override) {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { z as z42 } from "zod";
+import { z as z46 } from "zod";
 function createWriteFileTool() {
   return zodTool({
     annotations: {
@@ -11583,9 +11853,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: z42.object({
-      path: z42.string().min(1).describe("Path to write in the sandbox workspace."),
-      content: z42.string().describe("UTF-8 file content to write.")
+    inputSchema: z46.object({
+      path: z46.string().min(1).describe("Path to write in the sandbox workspace."),
+      content: z46.string().describe("UTF-8 file content to write.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async () => {
@@ -11632,6 +11902,15 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
   const canSendFilesToActiveConversation = Boolean(
     slackContext && slackSourceCapabilities?.canSendFiles
   );
+  const resourceEventCatalog = Object.fromEntries(
+    getPlugins().flatMap((plugin) => {
+      const registration = plugin.resourceEvents;
+      if (!registration || registration.isEnabled?.() === false) {
+        return [];
+      }
+      return [[plugin.manifest.name, registration]];
+    })
+  );
   const tools = {
     ...options.includeLoadSkill === false ? {} : {
       loadSkill: createLoadSkillTool(availableSkills, {
@@ -11654,7 +11933,7 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
     webFetch: createWebFetchTool(hooks, {
       canSendFilesToActiveConversation
     }),
-    ...createResourceEventTools(context)
+    ...createResourceEventTools(context, resourceEventCatalog)
   };
   if (context.conversationId) {
     tools.queryConversationEvents = createQueryConversationEventsTool(context);
@@ -12629,7 +12908,7 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, conv
 }
 
 // src/chat/tools/execute-tool.ts
-import { z as z43 } from "zod";
+import { z as z47 } from "zod";
 var EXECUTE_TOOL_NAME = "executeTool";
 function createExecuteToolTool() {
   return zodTool({
@@ -12641,11 +12920,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: z43.object({
-      tool_name: z43.string().min(1).describe(
+    inputSchema: z47.object({
+      tool_name: z47.string().min(1).describe(
         "Exact catalog tool_name returned by searchTools or a tool-result execution hint."
       ),
-      arguments: z43.record(z43.string(), z43.unknown()).describe(
+      arguments: z47.record(z47.string(), z47.unknown()).describe(
         'Arguments matching the selected catalog tool schema, for example { "query": "..." }.'
       ).optional()
     }).strict(),
@@ -12685,34 +12964,34 @@ function planToolExposure(tools) {
 }
 
 // src/chat/tools/search-tools.ts
-import { z as z44 } from "zod";
+import { z as z48 } from "zod";
 var SEARCH_TOOLS_NAME = "searchTools";
 var DEFAULT_MAX_RESULTS2 = 5;
 var MAX_RESULTS3 = 20;
 var MODEL_VISIBLE_DESCRIPTION_CAP = 180;
-var searchToolsSourceSchema = z44.object({
-  id: z44.string(),
-  description: z44.string()
+var searchToolsSourceSchema = z48.object({
+  id: z48.string(),
+  description: z48.string()
 }).strict();
-var searchToolsToolSchema = z44.object({
-  tool_name: z44.string(),
-  description: z44.string(),
-  exposure: z44.enum(["direct", "deferred", "modelOnly", "hidden"]),
-  source: z44.string().optional(),
-  input_schema: z44.unknown(),
-  call_notes: z44.array(z44.string()),
-  annotations: z44.record(z44.string(), z44.unknown())
+var searchToolsToolSchema = z48.object({
+  tool_name: z48.string(),
+  description: z48.string(),
+  exposure: z48.enum(["direct", "deferred", "modelOnly", "hidden"]),
+  source: z48.string().optional(),
+  input_schema: z48.unknown(),
+  call_notes: z48.array(z48.string()),
+  annotations: z48.record(z48.string(), z48.unknown())
 }).strict();
 var searchToolsOutputSchema = juniorToolResultSchema.extend({
-  query: z44.string().nullable(),
-  source: z44.string().nullable(),
-  sources: z44.array(searchToolsSourceSchema),
-  total_catalog_tools: z44.number().int().nonnegative(),
-  total_eligible_tools: z44.number().int().nonnegative(),
-  total_matches: z44.number().int().nonnegative(),
-  returned_tools: z44.number().int().nonnegative(),
-  execution_tool: z44.literal("executeTool"),
-  tools: z44.array(searchToolsToolSchema)
+  query: z48.string().nullable(),
+  source: z48.string().nullable(),
+  sources: z48.array(searchToolsSourceSchema),
+  total_catalog_tools: z48.number().int().nonnegative(),
+  total_eligible_tools: z48.number().int().nonnegative(),
+  total_matches: z48.number().int().nonnegative(),
+  returned_tools: z48.number().int().nonnegative(),
+  execution_tool: z48.literal("executeTool"),
+  tools: z48.array(searchToolsToolSchema)
 }).strict();
 function normalize2(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]+/g, " ").trim();
@@ -12827,14 +13106,14 @@ function createSearchToolsTool(catalogTools) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z44.object({
-      query: z44.string().nullable().describe(
+    inputSchema: z48.object({
+      query: z48.string().nullable().describe(
         "Optional search terms describing the tool, owner, action, or arguments needed. Empty string lists catalog tools."
       ).optional(),
-      source: z44.string().nullable().describe(
+      source: z48.string().nullable().describe(
         "Optional source id to search within, such as a plugin source returned in sources."
       ).optional(),
-      max_results: z44.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
+      max_results: z48.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
     }).strict(),
     outputSchema: searchToolsOutputSchema,
     privateTraceResult: (result) => ({
@@ -14091,7 +14370,7 @@ function createPluginEgress(deps) {
 }
 
 // src/chat/services/guardian-action-review.ts
-import { z as z45 } from "zod";
+import { z as z49 } from "zod";
 
 // src/chat/services/guardian-action-policy.ts
 var GUARDIAN_ACTION_POLICY = `You are judging one planned Junior agent action.
@@ -14155,17 +14434,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 = z45.object({
-  decision: z45.enum(["allow", "ask", "deny"]),
-  reason: z45.string().trim().min(1).max(500),
-  riskLevel: z45.enum(["low", "medium", "high", "critical"]),
-  userAuthorization: z45.enum(["high", "medium", "low", "unknown"])
+var guardianDecisionSchema = z49.object({
+  decision: z49.enum(["allow", "ask", "deny"]),
+  reason: z49.string().trim().min(1).max(500),
+  riskLevel: z49.enum(["low", "medium", "high", "critical"]),
+  userAuthorization: z49.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(z45.json().parse(proposal), null, 2);
+  const proposalJson = JSON.stringify(z49.json().parse(proposal), null, 2);
   if (proposalJson.length > MAX_PROPOSAL_CHARS) {
     throw new Error(
       `Guardian action proposal exceeds ${MAX_PROPOSAL_CHARS} characters.`