@sentry/junior 0.128.0 → 0.129.0

package/dist/{chunk-YY6CVET7.js → chunk-6QQOLIJJ.js}

@@ -30,7 +30,7 @@ import {
   toMcpProviderError,
   toolInvocationDestination,
   uploadFilesToConversation
-} from "./chunk-NHWE6Y7G.js";
+} from "./chunk-6CMYU62S.js";
 import {
   CooperativeTurnYieldError,
   JUNIOR_THREAD_STATE_TTL_MS,
@@ -80,7 +80,7 @@ import {
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   updateConversationStats
-} from "./chunk-HBFQLSGV.js";
+} from "./chunk-U23X4ASF.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
@@ -104,13 +104,42 @@ import {
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-2HTHX6XV.js";
+} from "./chunk-XENYUOZG.js";
 import {
-  incrementStat
-} from "./chunk-FJEIX3AH.js";
+  SCHEDULED_TASK_SYSTEM_ACTOR,
+  ToolInputError,
+  compactEventTask,
+  createEventTask,
+  createSchedulerSqlStore,
+  deleteEventTask,
+  eventNamespaceSchema,
+  eventTaskListToolResultSchema,
+  eventTaskMatchesDestination,
+  eventTaskSuccess,
+  eventTaskToolResultSchema,
+  getEventTask,
+  getFirstRunAtMs,
+  getResourceEventCatalog,
+  getZonedDateTimeParts,
+  incrementStat,
+  injectContinuationToolName,
+  juniorToolOutputSchema,
+  listEventTasksForTeam,
+  makeStructuredToolOutput,
+  normalizeEventIdentifier,
+  pluginSupportsEvent,
+  registeredEventTaskTriggerSchema,
+  registeredEventTypeSchema,
+  registeredResourceTypeSchema,
+  requireEventTaskSlackContext,
+  requireSupportedEventTaskTrigger,
+  resolveLocalScheduleAtMs,
+  saveEventTask,
+  writableEventTask
+} from "./chunk-BDIEEZK7.js";
 import {
   parseSlackThreadId
-} from "./chunk-PBWUUVVG.js";
+} from "./chunk-LV2BQ26V.js";
 import {
   addAgentTurnUsage,
   hasAgentTurnUsage
@@ -120,14 +149,12 @@ import {
 } from "./chunk-UIE3R5XU.js";
 import {
   SlackActionError,
-  canRouteResourceEvents,
   createPluginHookRunner,
   downloadPrivateSlackFile,
   getFilePermalink,
   getPluginSystemPromptContributions,
   getPluginTools,
   getPluginUserPromptContributions,
-  getPlugins,
   getSlackClient,
   getSlackToolContext,
   isConversationScopedChannel,
@@ -135,7 +162,7 @@ import {
   readActorIdentity,
   resolveChannelCapabilities,
   withSlackRetries
-} from "./chunk-A76LKS5W.js";
+} from "./chunk-QAOA4GUG.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
@@ -146,10 +173,7 @@ import {
   instructionActors,
   instructionProvenanceFor,
   sameActorIdentity
-} from "./chunk-B7FPRGUJ.js";
-import {
-  juniorEventTasks
-} from "./chunk-SHMHHXD5.js";
+} from "./chunk-PQFNTLZI.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -159,7 +183,7 @@ import {
   sandboxSkillFile,
   sandboxSkillPathResolution,
   sleep
-} from "./chunk-G6XQODHM.js";
+} from "./chunk-3N4MWF3R.js";
 import {
   ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
@@ -193,7 +217,7 @@ import {
   renderCurrentInstruction,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-K5ZB3WWH.js";
+} from "./chunk-2BCQKJTX.js";
 import {
   canExposeConversationPayload,
   resolveConversationPrivacy,
@@ -203,16 +227,16 @@ import {
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes
-} from "./chunk-Z4KTQMWW.js";
+} from "./chunk-GPWHBHAG.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-BY43CEXN.js";
+} from "./chunk-R62DRNKB.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-WZ365SQC.js";
+} from "./chunk-A6QQPVSH.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -220,7 +244,7 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-OLGB5Y7R.js";
+} from "./chunk-CZQ2DSQZ.js";
 import {
   credentialUserSubjectId
 } from "./chunk-77VDLF3Z.js";
@@ -249,7 +273,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-B6E3YA2H.js";
+} from "./chunk-P6I7LFKC.js";
 import {
   startInactiveSpan,
   withActiveSpan
@@ -863,59 +887,6 @@ function getDiscardedRetryUsage(messages, retryMessages) {
   return hasAgentTurnUsage(usage) ? usage : void 0;
 }
 
-// src/chat/tool-support/structured-result.ts
-import { z } from "zod";
-var juniorToolContinuationSchema = z.object({
-  arguments: z.record(z.string(), z.unknown()),
-  reason: z.string().min(1).optional()
-}).strict();
-var juniorToolBoundContinuationSchema = juniorToolContinuationSchema.extend({
-  tool_name: z.string().min(1)
-});
-var juniorToolOutputSchema = z.object({
-  target: z.string().min(1).optional(),
-  truncated: z.boolean().optional(),
-  continuation: juniorToolContinuationSchema.optional()
-}).passthrough();
-function sortJsonValue(value) {
-  if (Array.isArray(value)) {
-    return value.map(sortJsonValue);
-  }
-  if (!value || typeof value !== "object") {
-    return value;
-  }
-  return Object.fromEntries(
-    Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, sortJsonValue(item)])
-  );
-}
-function isRecord(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function injectContinuationToolName(details, toolName) {
-  if (!isRecord(details) || !isRecord(details.continuation)) {
-    return details;
-  }
-  return {
-    ...details,
-    continuation: juniorToolBoundContinuationSchema.parse({
-      ...details.continuation,
-      tool_name: toolName
-    })
-  };
-}
-function makeStructuredToolOutput(details, options = {}) {
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(sortJsonValue(details))
-      },
-      ...options.content ?? []
-    ],
-    details
-  };
-}
-
 // src/chat/tool-support/turn-deadline-result.ts
 var TURN_DEADLINE_INTERRUPTION = {
   cause: "turn_deadline",
@@ -941,7 +912,7 @@ function annotateTurnDeadlineToolResult(result) {
 }
 
 // src/chat/services/turn-router.ts
-import { z as z2 } from "zod";
+import { z } from "zod";
 var CLASSIFIER_CONFIDENCE_THRESHOLD = 0.75;
 var MAX_ROUTER_CONTEXT_CHARS = 8e3;
 var ROUTER_CONTEXT_HEAD_CHARS = 3e3;
@@ -967,17 +938,17 @@ function coerceClassifierConfidence(value) {
   return CONFIDENCE_LABELS[trimmed] ?? value;
 }
 function createTurnRouteSchema(profiles) {
-  return z2.object({
-    reasoning_level: z2.enum(TURN_REASONING_LEVELS),
+  return z.object({
+    reasoning_level: z.enum(TURN_REASONING_LEVELS),
     profile: modelProfileSchema.refine(
       (profile) => Object.hasOwn(profiles, profile),
       "Profile is not configured"
     ),
-    confidence: z2.preprocess(
+    confidence: z.preprocess(
       coerceClassifierConfidence,
-      z2.number().min(0).max(1)
+      z.number().min(0).max(1)
     ),
-    reason: z2.string().min(1)
+    reason: z.string().min(1)
   });
 }
 var CLASSIFIER_FALLBACK_REASONING_LEVEL = "medium";
@@ -1261,44 +1232,44 @@ async function resolveDestinationVisibility(args) {
 }
 
 // src/chat/tool-support/action-review-history.ts
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 var MAX_VISIBLE_HISTORY_CHARS = 12e3;
-var priorRejectionSchema = z3.object({
-  decision: z3.enum(["ask", "deny"]),
-  input: z3.record(z3.string(), z3.unknown()),
-  reason: z3.string().min(1),
-  riskLevel: z3.enum(["low", "medium", "high", "critical"]).optional(),
-  tool: z3.object({
-    annotations: z3.record(z3.string(), z3.unknown()).optional(),
-    description: z3.string(),
-    dispatcherName: z3.string().optional(),
-    identity: z3.object({
-      id: z3.string(),
-      name: z3.string(),
-      plugin: z3.string()
+var priorRejectionSchema = z2.object({
+  decision: z2.enum(["ask", "deny"]),
+  input: z2.record(z2.string(), z2.unknown()),
+  reason: z2.string().min(1),
+  riskLevel: z2.enum(["low", "medium", "high", "critical"]).optional(),
+  tool: z2.object({
+    annotations: z2.record(z2.string(), z2.unknown()).optional(),
+    description: z2.string(),
+    dispatcherName: z2.string().optional(),
+    identity: z2.object({
+      id: z2.string(),
+      name: z2.string(),
+      plugin: z2.string()
     }).strict().optional(),
-    name: z3.string(),
-    proposalDescription: z3.string().optional(),
-    catalogSource: z3.object({
-      description: z3.string(),
-      id: z3.string()
+    name: z2.string(),
+    proposalDescription: z2.string().optional(),
+    catalogSource: z2.object({
+      description: z2.string(),
+      id: z2.string()
     }).strict().optional()
   }).strict(),
-  userAuthorization: z3.enum(["high", "medium", "low", "unknown"]).optional()
+  userAuthorization: z2.enum(["high", "medium", "low", "unknown"]).optional()
 }).strict();
-var rejectionMarkerSchema = z3.object({
-  decision: z3.enum(["ask", "deny"]),
+var rejectionMarkerSchema = z2.object({
+  decision: z2.enum(["ask", "deny"]),
   priorRejection: priorRejectionSchema,
-  reason: z3.string().min(1),
-  riskLevel: z3.enum(["low", "medium", "high", "critical"]).optional(),
-  userAuthorization: z3.enum(["high", "medium", "low", "unknown"]).optional(),
-  version: z3.literal(1)
+  reason: z2.string().min(1),
+  riskLevel: z2.enum(["low", "medium", "high", "critical"]).optional(),
+  userAuthorization: z2.enum(["high", "medium", "low", "unknown"]).optional(),
+  version: z2.literal(1)
 }).strict();
-function isRecord2(value) {
+function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function getToolActionRejectionMarker(message) {
-  if (!isRecord2(message) || !isRecord2(message.details)) {
+  if (!isRecord(message) || !isRecord(message.details)) {
     return void 0;
   }
   const parsed = rejectionMarkerSchema.safeParse(
@@ -1309,7 +1280,7 @@ function getToolActionRejectionMarker(message) {
 function projectToolActionRejection(pending, toolCallId, result) {
   const rejection = pending.get(toolCallId);
   pending.delete(toolCallId);
-  const details = isRecord2(result.details) ? result.details : void 0;
+  const details = isRecord(result.details) ? result.details : void 0;
   const hasReservedMarker = details !== void 0 && "guardianActionRejection" in details;
   if (!rejection && !hasReservedMarker) {
     return result;
@@ -1403,7 +1374,7 @@ function parseMcpProviderFromToolName(toolName) {
 
 // src/chat/pi/derived-state.ts
 var MCP_BRIDGE_TOOLS = /* @__PURE__ */ new Set(["callMcpTool", "searchMcpTools"]);
-function isRecord3(value) {
+function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function providerFromToolName(value) {
@@ -1425,7 +1396,7 @@ function addBridgeToolProvider(toolName, value, providers) {
   if (bridgeTool === "searchMcpTools") {
     for (const argsKey of ["input", "args", "arguments", "params"]) {
       const args = value[argsKey];
-      if (isRecord3(args)) {
+      if (isRecord2(args)) {
         addString(providers, args.provider);
       }
     }
@@ -1434,7 +1405,7 @@ function addBridgeToolProvider(toolName, value, providers) {
   if (bridgeTool === "callMcpTool") {
     for (const argsKey of ["input", "args", "arguments", "params"]) {
       const args = value[argsKey];
-      if (isRecord3(args)) {
+      if (isRecord2(args)) {
         addString(providers, providerFromToolName(args.tool_name));
       }
     }
@@ -1447,18 +1418,18 @@ function addMcpResultProvider(message, providers) {
     return;
   }
   if (toolName === "loadSkill") {
-    if (isRecord3(message.details)) {
+    if (isRecord2(message.details)) {
       addString(providers, message.details.mcp_provider);
     }
     addString(providers, message.mcp_provider);
     return;
   }
   if (toolName === "searchMcpTools") {
-    if (isRecord3(message.details)) {
+    if (isRecord2(message.details)) {
       addString(providers, message.details.provider);
       if (Array.isArray(message.details.tools)) {
         for (const tool of message.details.tools) {
-          if (isRecord3(tool)) {
+          if (isRecord2(tool)) {
             addString(providers, providerFromToolName(tool.tool_name));
           }
         }
@@ -1470,11 +1441,11 @@ function addMcpResultProvider(message, providers) {
   if (toolName === "callMcpTool") {
     for (const argsKey of ["input", "args", "arguments", "params"]) {
       const args = message[argsKey];
-      if (isRecord3(args)) {
+      if (isRecord2(args)) {
         addString(providers, providerFromToolName(args.tool_name));
       }
     }
-    if (isRecord3(message.details)) {
+    if (isRecord2(message.details)) {
       addString(providers, message.details.provider);
       addString(providers, providerFromToolName(message.details.tool_name));
     }
@@ -1482,7 +1453,7 @@ function addMcpResultProvider(message, providers) {
   }
 }
 function scanMcpProviders(message, providers) {
-  if (!isRecord3(message)) {
+  if (!isRecord2(message)) {
     return;
   }
   if (message.role === "toolResult") {
@@ -1494,15 +1465,15 @@ function scanMcpProviders(message, providers) {
     return;
   }
   for (const part of content) {
-    if (!isRecord3(part)) {
+    if (!isRecord2(part)) {
       continue;
     }
     addBridgeToolProvider(getToolName(part), part, providers);
   }
 }
 function scanLoadedSkills(message, skills) {
-  if (isRecord3(message) && message.role === "toolResult" && message.toolName === "loadSkill" && message.isError !== true) {
-    if (isRecord3(message.details)) {
+  if (isRecord2(message) && message.role === "toolResult" && message.toolName === "loadSkill" && message.isError !== true) {
+    if (isRecord2(message.details)) {
       addString(skills, message.details.skill_name);
     }
     addString(skills, message.skill_name);
@@ -1807,6 +1778,7 @@ var TOOL_POLICY_RULES = [
   "- Use createEventTask only when the user explicitly asks for an event task or durable whenever-this-happens-do-X automation. Ordinary watch, notify, and tell-me-when requests use watchResourceEvents. When an event task's resource and events are known, create it without redundant confirmation.",
   "- Event tasks make the task creator's connected credentials available by default when the requested work needs user-bound authorization. Do not ask for separate confirmation merely to use credentials needed for the requested work. On creation, omit credentialMode for the creator default and set system only when the creator explicitly requires it. For later changes, creator always means the task's original createdBy actor, never the current requester. If the requester is not that creator, do not attempt to enable creator credential use or suggest that confirmation could authorize it.",
   "- Event tasks are managed for the current Slack channel or DM, not one thread. When listing them, use createdBy to explain creator-only credential changes and warn when triggerAvailable is false; an unavailable task remains stored but cannot receive events until its plugin event is enabled again.",
+  "- Scheduled tasks make the task creator's connected credentials available by default when the requested work needs user-bound authorization. Do not ask for separate confirmation merely to use credentials needed for the requested work. On creation, omit credential_mode for the creator default and set system only when the creator explicitly requires it. For later changes, creator always means the task's original created_by actor, never the current requester. If the requester is not that creator, do not attempt to enable creator credential use or suggest that confirmation could authorize it.",
   "- 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."
@@ -3874,16 +3846,6 @@ function createSandboxRuntime(options) {
 
 // src/chat/tools/sandbox/file-utils.ts
 import path4 from "path";
-
-// src/chat/tools/execution/tool-input-error.ts
-var ToolInputError = class extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "ToolInputError";
-  }
-};
-
-// src/chat/tools/sandbox/file-utils.ts
 var MAX_TEXT_CHARS = 6e4;
 var RIPGREP_EXCLUDED_GLOBS = [
   "!**/.git/**",
@@ -4260,10 +4222,10 @@ function validateAndApplyTextEdits(content, edits, targetName) {
 }
 
 // src/chat/tools/sandbox/edit-file.ts
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 
 // src/chat/tool-support/zod-tool.ts
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 function isContentOnlyToolResult(value) {
   return value !== null && typeof value === "object" && Array.isArray(value.content) && !("details" in value);
 }
@@ -4300,7 +4262,7 @@ function zodTool(definition) {
   const { inputSchema: inputSchema2, outputSchema: outputSchema5, prepareArguments, execute, ...toolDef } = definition;
   let modelInputSchema;
   try {
-    modelInputSchema = z4.toJSONSchema(inputSchema2);
+    modelInputSchema = z3.toJSONSchema(inputSchema2);
   } catch (error) {
     throw new TypeError(
       "zodTool() inputSchema must be representable as JSON Schema.",
@@ -4310,7 +4272,7 @@ function zodTool(definition) {
   let modelOutputSchema;
   if (outputSchema5) {
     try {
-      modelOutputSchema = z4.toJSONSchema(outputSchema5);
+      modelOutputSchema = z3.toJSONSchema(outputSchema5);
     } catch (error) {
       throw new TypeError(
         "zodTool() outputSchema must be representable as JSON Schema.",
@@ -4395,11 +4357,11 @@ async function editFile(params) {
     truncated: diff.truncated
   });
 }
-var editReplacementSchema = z5.object({
-  oldText: z5.string().min(1).describe(
+var editReplacementSchema = z4.object({
+  oldText: z4.string().min(1).describe(
     "Exact text to replace. It must be unique in the original file and must not overlap another edit."
   ),
-  newText: z5.string().describe("Replacement text for this edit.")
+  newText: z4.string().describe("Replacement text for this edit.")
 });
 function createEditFileTool() {
   return zodTool({
@@ -4412,9 +4374,9 @@ function createEditFileTool() {
     description: "Edit one sandbox workspace file with exact text replacements. Use for precise changes to existing files; prefer this over writeFile for targeted changes. Each oldText must match exactly, be unique, and not overlap another edit. Returns a diff. Multiple changes to the same file: use one edits[] call.",
     prepareArguments: prepareEditFileArguments,
     executionMode: "sequential",
-    inputSchema: z5.object({
-      path: z5.string().min(1).describe("Path to edit in the sandbox workspace."),
-      edits: z5.array(editReplacementSchema).min(1).describe(
+    inputSchema: z4.object({
+      path: z4.string().min(1).describe("Path to edit in the sandbox workspace."),
+      edits: z4.array(editReplacementSchema).min(1).describe(
         "Exact replacements matched against the original file, not incrementally."
       )
     }),
@@ -4429,7 +4391,7 @@ function createEditFileTool() {
 
 // src/chat/tools/sandbox/find-files.ts
 import path5 from "path";
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 var DEFAULT_FIND_LIMIT = 100;
 async function findFiles(params) {
   if (!params.pattern.trim()) {
@@ -4602,14 +4564,14 @@ function createFindFilesTool() {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z6.object({
-      pattern: z6.string().min(1).describe(
+    inputSchema: z5.object({
+      pattern: z5.string().min(1).describe(
         "Glob pattern to match, for example '*.ts', '**/*.json', or 'src/**/*.test.ts'."
       ),
-      path: z6.string().min(1).describe(
+      path: z5.string().min(1).describe(
         "Directory or file path in the sandbox workspace. Defaults to the workspace root."
       ).optional(),
-      limit: z6.coerce.number().int().min(1).describe("Maximum number of file paths to return. Defaults to 100.").optional()
+      limit: z5.coerce.number().int().min(1).describe("Maximum number of file paths to return. Defaults to 100.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async () => {
@@ -4622,12 +4584,12 @@ function createFindFilesTool() {
 
 // src/chat/tools/sandbox/grep.ts
 import path6 from "path";
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 var DEFAULT_GREP_LIMIT = 100;
 var MAX_GREP_LINE_CHARS = 500;
-var booleanInput = (description) => z7.preprocess(
+var booleanInput = (description) => z6.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z7.boolean()
+  z6.boolean()
 ).describe(description);
 function truncateGrepLine(value) {
   if (value.length <= MAX_GREP_LINE_CHARS) {
@@ -4976,20 +4938,20 @@ function createGrepTool() {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z7.object({
-      pattern: z7.string().min(1).describe("Regex pattern or literal text to search for."),
-      path: z7.string().min(1).describe(
+    inputSchema: z6.object({
+      pattern: z6.string().min(1).describe("Regex pattern or literal text to search for."),
+      path: z6.string().min(1).describe(
         "Directory or file path in the sandbox workspace. Defaults to the workspace root."
       ).optional(),
-      glob: z7.string().min(1).describe("Optional glob filter such as '*.ts' or '**/*.test.ts'.").optional(),
+      glob: z6.string().min(1).describe("Optional glob filter such as '*.ts' or '**/*.test.ts'.").optional(),
       ignoreCase: booleanInput(
         "Whether matching should ignore case."
       ).optional(),
       literal: booleanInput(
         "Treat pattern as literal text instead of regex."
       ).optional(),
-      context: z7.coerce.number().int().min(0).describe("Number of surrounding context lines to include.").optional(),
-      limit: z7.coerce.number().int().min(1).describe("Maximum matches to return. Defaults to 100.").optional()
+      context: z6.coerce.number().int().min(0).describe("Number of surrounding context lines to include.").optional(),
+      limit: z6.coerce.number().int().min(1).describe("Maximum matches to return. Defaults to 100.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async () => {
@@ -5000,7 +4962,7 @@ function createGrepTool() {
 
 // src/chat/tools/sandbox/list-dir.ts
 import path7 from "path";
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 var DEFAULT_LIST_LIMIT = 500;
 async function listDir(params) {
   const dirPath = resolveWorkspacePath(params.path);
@@ -5081,11 +5043,11 @@ function createListDirTool() {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z8.object({
-      path: z8.string().min(1).describe(
+    inputSchema: z7.object({
+      path: z7.string().min(1).describe(
         "Directory path in the sandbox workspace. Defaults to the workspace root."
       ).optional(),
-      limit: z8.coerce.number().int().min(1).describe("Maximum entries to return. Defaults to 500.").optional()
+      limit: z7.coerce.number().int().min(1).describe("Maximum entries to return. Defaults to 500.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async () => {
@@ -5097,7 +5059,7 @@ function createListDirTool() {
 }
 
 // src/chat/tools/sandbox/read-file.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 
 // src/chat/tool-support/text-range-result.ts
 var DEFAULT_READ_LIMIT = 1e3;
@@ -5191,10 +5153,10 @@ function createReadFileTool() {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z9.object({
-      path: z9.string().min(1).describe("Path to the file in the sandbox workspace."),
-      offset: z9.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
-      limit: z9.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
+    inputSchema: z8.object({
+      path: z8.string().min(1).describe("Path to the file in the sandbox workspace."),
+      offset: z8.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
+      limit: z8.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async () => {
@@ -5751,25 +5713,25 @@ function createSandbox(options) {
 
 // src/chat/tools/sandbox/file-uploads.ts
 import path8 from "path";
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 var MAX_SANDBOX_FILE_UPLOAD_BYTES = 10 * 1024 * 1024;
 var SANDBOX_ARTIFACTS_DIR = "/tmp/junior/artifacts";
-var sandboxFileReferenceSchema = z10.object({
-  path: z10.string().min(1).describe(
+var sandboxFileReferenceSchema = z9.object({
+  path: z9.string().min(1).describe(
     "Exact source path of an existing sandbox file. Preserve paths returned by other tools unchanged; do not move or rewrite them before sending."
   ),
-  filename: z10.string().min(1).nullable().optional().describe(
+  filename: z9.string().min(1).nullable().optional().describe(
     "Optional filename override shown to the recipient. Null is treated as omitted."
   ),
-  mimeType: z10.string().min(1).nullable().optional().describe("Optional MIME type override. Null is treated as omitted."),
-  bytes: z10.number().int().nonnegative().nullable().optional().describe(
+  mimeType: z9.string().min(1).nullable().optional().describe("Optional MIME type override. Null is treated as omitted."),
+  bytes: z9.number().int().nonnegative().nullable().optional().describe(
     "Optional known file size returned by a producing tool. Null is treated as omitted; sending tools validate the file contents directly."
   )
 });
 var generatedArtifactFileRefSchema = sandboxFileReferenceSchema.extend({
-  filename: z10.string().min(1),
-  mimeType: z10.string().min(1).optional(),
-  bytes: z10.number().int().nonnegative()
+  filename: z9.string().min(1),
+  mimeType: z9.string().min(1).optional(),
+  bytes: z9.number().int().nonnegative()
 }).strict();
 var MIME_BY_EXTENSION = {
   ".png": "image/png",
@@ -6788,7 +6750,7 @@ function serializeMcpPayload(payload, privacy, options = {}) {
 }
 
 // src/chat/tools/sandbox/bash.ts
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 function createBashTool() {
   return zodTool({
     annotations: {
@@ -6798,9 +6760,9 @@ function createBashTool() {
       readOnlyHint: false
     },
     description: "Run a bash command inside the isolated sandbox workspace. Use this for repository inspection/execution tasks that need shell access. Do not use for network-sensitive or destructive actions unless explicitly required.",
-    inputSchema: z11.object({
-      command: z11.string().min(1).describe("Bash command to run inside the sandbox."),
-      timeoutMs: z11.coerce.number().int().min(1e3).describe(
+    inputSchema: z10.object({
+      command: z10.string().min(1).describe("Bash command to run inside the sandbox."),
+      timeoutMs: z10.coerce.number().int().min(1e3).describe(
         "Optional command timeout in milliseconds. Use for commands that may hang."
       ).optional()
     }),
@@ -6814,14 +6776,14 @@ function createBashTool() {
 }
 
 // src/chat/tools/web/image-generate.ts
-import { z as z12 } from "zod";
+import { z as z11 } from "zod";
 var imageGenerateOutputSchema = juniorToolOutputSchema.extend({
-  model: z12.string(),
-  prompt: z12.string(),
-  enrichedPrompt: z12.string(),
-  image_count: z12.number().int().nonnegative(),
-  images: z12.array(generatedArtifactFileRefSchema),
-  delivery: z12.string()
+  model: z11.string(),
+  prompt: z11.string(),
+  enrichedPrompt: z11.string(),
+  image_count: z11.number().int().nonnegative(),
+  images: z11.array(generatedArtifactFileRefSchema),
+  delivery: z11.string()
 }).strict();
 var ENRICHMENT_SYSTEM_PROMPT = `You are an image prompt enrichment agent. Your job is to rewrite image generation requests to reflect a specific visual identity and mood.
 
@@ -6882,8 +6844,8 @@ function createImageGenerateTool(hooks, options, deps = {}) {
       readOnlyHint: false
     },
     description: "Generate images from a prompt. Use when the user wants to visually show or represent something \u2014 feelings, concepts, art, humor, or any visual idea. Also use for explicit image creation requests.",
-    inputSchema: z12.object({
-      prompt: z12.string().min(1).max(4e3).describe("Image generation prompt.")
+    inputSchema: z11.object({
+      prompt: z11.string().min(1).max(4e3).describe("Image generation prompt.")
     }),
     outputSchema: imageGenerateOutputSchema,
     execute: async ({ prompt }) => {
@@ -6965,7 +6927,7 @@ function createImageGenerateTool(hooks, options, deps = {}) {
 }
 
 // src/chat/tools/skill/call-mcp-tool.ts
-import { z as z13 } from "zod";
+import { z as z12 } from "zod";
 function resolveMcpArguments(input) {
   const extraKeys = Object.keys(input).filter(
     (key) => key !== "tool_name" && key !== "arguments"
@@ -7008,9 +6970,9 @@ function createCallMcpToolTool(mcpToolManager) {
       readOnlyHint: false
     },
     description: "Call an active MCP tool by exact tool_name. Use searchMcpTools to discover tool names and schemas; copy required provider fields into arguments. Do not call with only tool_name unless the discovered tool has no arguments. Authorization is handled by the runtime when required.",
-    inputSchema: z13.object({
-      tool_name: z13.string().min(1).describe("Exact MCP tool_name from searchMcpTools."),
-      arguments: z13.record(z13.string(), z13.unknown()).describe(
+    inputSchema: z12.object({
+      tool_name: z12.string().min(1).describe("Exact MCP tool_name from searchMcpTools."),
+      arguments: z12.record(z12.string(), z12.unknown()).describe(
         'Arguments matching the disclosed MCP tool schema, for example { "query": "..." } when searchMcpTools shows query is required.'
       ).optional()
     }).passthrough(),
@@ -7066,7 +7028,7 @@ function createCallMcpToolTool(mcpToolManager) {
 }
 
 // src/chat/tools/skill/load-skill.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 function toLoadedSkill(result, availableSkills) {
   if (typeof result.skill_name !== "string" || typeof result.description !== "string" || typeof result.skill_dir !== "string" || typeof result.instructions !== "string") {
     return null;
@@ -7116,8 +7078,8 @@ function createLoadSkillTool(availableSkills, options) {
       readOnlyHint: false
     },
     description: "Load a skill by name for this turn. The result includes working_directory; resolve skill paths there and run skill-owned bash commands from there or with absolute paths. When the result includes mcp_provider, use searchMcpTools before callMcpTool. Use when a request clearly matches a known skill.",
-    inputSchema: z14.object({
-      skill_name: z14.string().min(1).describe("Skill name to load, without the leading slash.")
+    inputSchema: z13.object({
+      skill_name: z13.string().min(1).describe("Skill name to load, without the leading slash.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ skill_name }) => {
@@ -7135,7 +7097,7 @@ function createLoadSkillTool(availableSkills, options) {
 }
 
 // src/chat/tools/skill/search-mcp-tools.ts
-import { z as z15 } from "zod";
+import { z as z14 } from "zod";
 
 // src/chat/tool-support/skill/mcp-tool-summary.ts
 function toExposedToolSummary(toolDef) {
@@ -7167,29 +7129,29 @@ function toActiveMcpCatalogSummaries(toolDefs) {
 // src/chat/tools/skill/search-mcp-tools.ts
 var DEFAULT_MAX_RESULTS = 5;
 var MAX_RESULTS = 20;
-var providerSummarySchema = z15.object({
-  provider: z15.string(),
-  description: z15.string(),
-  active: z15.boolean()
+var providerSummarySchema = z14.object({
+  provider: z14.string(),
+  description: z14.string(),
+  active: z14.boolean()
 }).strict();
-var exposedToolSummarySchema = z15.object({
-  tool_name: z15.string(),
-  mcp_tool_name: z15.string(),
-  provider: z15.string(),
-  title: z15.string().optional(),
-  description: z15.string(),
-  input_schema: z15.record(z15.string(), z15.unknown()),
-  output_schema: z15.record(z15.string(), z15.unknown()).optional(),
-  annotations: z15.record(z15.string(), z15.unknown()).optional()
+var exposedToolSummarySchema = z14.object({
+  tool_name: z14.string(),
+  mcp_tool_name: z14.string(),
+  provider: z14.string(),
+  title: z14.string().optional(),
+  description: z14.string(),
+  input_schema: z14.record(z14.string(), z14.unknown()),
+  output_schema: z14.record(z14.string(), z14.unknown()).optional(),
+  annotations: z14.record(z14.string(), z14.unknown()).optional()
 }).strict();
 var searchMcpToolsOutputSchema = juniorToolOutputSchema.extend({
-  query: z15.string().nullable(),
-  provider: z15.string().nullable(),
-  total_active_tools: z15.number().int().nonnegative(),
-  returned_tools: z15.number().int().nonnegative(),
-  execution_tool: z15.literal("callMcpTool"),
-  available_providers: z15.array(providerSummarySchema),
-  tools: z15.array(exposedToolSummarySchema)
+  query: z14.string().nullable(),
+  provider: z14.string().nullable(),
+  total_active_tools: z14.number().int().nonnegative(),
+  returned_tools: z14.number().int().nonnegative(),
+  execution_tool: z14.literal("callMcpTool"),
+  available_providers: z14.array(providerSummarySchema),
+  tools: z14.array(exposedToolSummarySchema)
 }).strict();
 function normalize(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]+/g, " ").trim();
@@ -7315,14 +7277,14 @@ function createSearchMcpToolsTool(mcpToolManager) {
       readOnlyHint: true
     },
     description: "List or search MCP providers and active MCP tools. When provider is supplied and not yet active, Junior connects to it on demand and returns tool descriptors including schemas. Without provider, returns active tools plus matching configured providers without connecting. Use when choosing a provider tool or when callMcpTool arguments are unclear.",
-    inputSchema: z15.object({
-      query: z15.string().min(1).describe(
+    inputSchema: z14.object({
+      query: z14.string().min(1).describe(
         "Optional search terms describing the MCP tool or arguments needed."
       ).optional(),
-      provider: z15.string().min(1).describe(
+      provider: z14.string().min(1).describe(
         "Optional provider name to list or search within. If configured but not yet connected, Junior activates it on demand."
       ).optional(),
-      max_results: z15.number().int().min(1).max(MAX_RESULTS).describe("Maximum matching tool descriptors to return.").optional()
+      max_results: z14.number().int().min(1).max(MAX_RESULTS).describe("Maximum matching tool descriptors to return.").optional()
     }).strict(),
     outputSchema: searchMcpToolsOutputSchema,
     privateTraceResult: (result) => ({
@@ -7362,10 +7324,10 @@ function createSearchMcpToolsTool(mcpToolManager) {
 }
 
 // src/chat/tools/sandbox/view-image.ts
-import { z as z16 } from "zod";
+import { z as z15 } from "zod";
 var MAX_VIEW_IMAGE_BYTES = 5 * 1024 * 1024;
-var viewImageInputSchema = z16.object({
-  path: z16.string().min(1).describe("Path to an image file in the sandbox workspace.")
+var viewImageInputSchema = z15.object({
+  path: z15.string().min(1).describe("Path to an image file in the sandbox workspace.")
 }).strict();
 function detectImageMimeType(data) {
   if (data.length >= 8 && data.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
@@ -7432,7 +7394,7 @@ function createViewImageTool(sandbox, supportsImageInput, deps = {}) {
 }
 
 // src/chat/tools/runtime/report-progress.ts
-import { z as z17 } from "zod";
+import { z as z16 } from "zod";
 function createReportProgressTool() {
   return zodTool({
     annotations: {
@@ -7442,8 +7404,8 @@ function createReportProgressTool() {
       readOnlyHint: false
     },
     description: "Update the user-visible assistant loading message with a short progress phase. Use this only for work with multiple substantive phases or a materially long wait. Skip short lookups, routine commands, generic filler, and minor substeps. After an initial update, call it again only when the major phase meaningfully changes. Messages must be written in sentence case with a present-participle verb (e.g. 'Searching docs', 'Reviewing results', 'Running checks').",
-    inputSchema: z17.object({
-      message: z17.string().min(1).describe("Short user-facing progress message.")
+    inputSchema: z16.object({
+      message: z16.string().min(1).describe("Short user-facing progress message.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async () => ({})
@@ -7485,7 +7447,7 @@ function isSlackThreadConversationId(conversationId) {
 }
 
 // src/chat/tools/list-resource-event-subscriptions.ts
-import { z as z19 } from "zod";
+import { z as z18 } from "zod";
 
 // src/chat/resource-events/store.ts
 import { createHash } from "crypto";
@@ -7493,29 +7455,29 @@ import {
   destinationSchema,
   resourceEventTypeSchema
 } from "@sentry/junior-plugin-api";
-import { z as z18 } from "zod";
+import { z as z17 } 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(),
+var subscriptionStatusSchema = z17.enum(["active", "cancelled", "completed"]);
+var subscriptionIdIndexSchema = z17.array(z17.string().min(1));
+var subscriptionSchema = z17.object({
+  conversationId: z17.string().min(1),
+  createdAtMs: z17.number().finite(),
   destination: destinationSchema,
-  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),
-  namespace: z18.string().min(1),
-  identifier: z18.string().min(1),
-  resourceType: z18.string().min(1),
+  events: z17.array(resourceEventTypeSchema).min(1),
+  expiresAtMs: z17.number().finite(),
+  id: z17.string().min(1),
+  intent: z17.string().min(1),
+  label: z17.string().min(1),
+  namespace: z17.string().min(1),
+  identifier: z17.string().min(1),
+  resourceType: z17.string().min(1),
   status: subscriptionStatusSchema,
-  updatedAtMs: z18.number().finite()
+  updatedAtMs: z17.number().finite()
 }).strict();
 function digest(value) {
   return createHash("sha256").update(value).digest("hex").slice(0, 32);
@@ -7885,17 +7847,17 @@ async function deliverResourceEventSubscription(input) {
 }
 
 // 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()
+var listedResourceWatchSchema = z18.object({
+  id: z18.string().min(1),
+  label: z18.string().min(1),
+  identifier: z18.string().min(1),
+  namespace: z18.string().min(1),
+  resourceType: z18.string().min(1),
+  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();
@@ -7910,7 +7872,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);
@@ -7937,72 +7899,20 @@ 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
+import { z as z19 } from "zod";
 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()
+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: z21.string().nullable(),
-  namespace: z21.string().nullable(),
-  totalMatches: z21.number().int().nonnegative(),
-  resourceTypes: z21.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();
@@ -8028,12 +7938,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: z21.object({
-      query: z21.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: z21.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 }) {
@@ -8071,10 +7981,10 @@ function createSearchResourceEventTypesTool(catalog) {
 }
 
 // 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))
+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
@@ -8090,7 +8000,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: z22.object({ id: z22.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);
@@ -8125,26 +8035,26 @@ function createStopWatchingResourcesTool(context) {
 }
 
 // src/chat/tools/watch-resource-events.ts
-import { z as z23 } from "zod";
+import { z as z21 } 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."),
+  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: z23.string().trim().min(1).max(500).describe("Human-readable resource label."),
-    events: z23.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: z23.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: z23.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) => {
@@ -8164,19 +8074,19 @@ function inputSchema(catalog) {
     });
   });
 }
-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()
+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 = 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(),
+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({
@@ -8281,195 +8191,7 @@ function createResourceEventTools(context, catalog) {
 
 // src/chat/tools/create-event-task.ts
 import { createHash as createHash2 } from "crypto";
-import { z as z26 } from "zod";
-
-// src/chat/event-tasks/store.ts
-import { and, asc, eq } from "drizzle-orm";
-
-// src/chat/event-tasks/types.ts
-import {
-  destinationVisibilitySchema,
-  resourceEventTypeSchema as resourceEventTypeSchema2,
-  slackActorSchema,
-  slackDestinationSchema
-} from "@sentry/junior-plugin-api";
-import { z as z24 } from "zod";
-var EVENT_TASK_IDENTIFIER_MAX_LENGTH = 300;
-var eventTaskPrincipalSchema = z24.object({
-  slackUserId: slackActorSchema.shape.userId,
-  fullName: z24.string().optional(),
-  userName: z24.string().optional()
-}).strict();
-var eventTaskTriggerSchema = z24.object({
-  events: z24.array(resourceEventTypeSchema2).min(1),
-  label: z24.string().min(1),
-  namespace: z24.string().min(1),
-  identifier: z24.string().min(1).max(EVENT_TASK_IDENTIFIER_MAX_LENGTH),
-  resourceType: z24.string().min(1)
-}).strict();
-var eventTaskSchema = z24.object({
-  id: z24.string().min(1),
-  createdAtMs: z24.number().finite(),
-  createdBy: eventTaskPrincipalSchema,
-  credentialMode: z24.enum(["system", "creator"]),
-  destination: slackDestinationSchema,
-  destinationVisibility: destinationVisibilitySchema,
-  task: z24.object({ text: z24.string().min(1) }).strict(),
-  trigger: eventTaskTriggerSchema
-}).strict();
-
-// src/chat/event-tasks/store.ts
-function parseTask(value) {
-  return eventTaskSchema.parse(value);
-}
-async function getEventTask(db, id) {
-  const rows = await db.select({ task: juniorEventTasks.task }).from(juniorEventTasks).where(eq(juniorEventTasks.id, id)).limit(1);
-  return rows[0] ? parseTask(rows[0].task) : void 0;
-}
-async function createEventTask(db, task) {
-  const parsed = eventTaskSchema.parse(task);
-  await db.insert(juniorEventTasks).values({
-    id: parsed.id,
-    teamId: parsed.destination.teamId,
-    namespace: parsed.trigger.namespace,
-    identifier: parsed.trigger.identifier,
-    createdAtMs: parsed.createdAtMs,
-    task: parsed
-  }).onConflictDoNothing();
-  return await getEventTask(db, parsed.id) ?? parsed;
-}
-async function saveEventTask(db, task) {
-  const parsed = eventTaskSchema.parse(task);
-  const rows = await db.update(juniorEventTasks).set({
-    namespace: parsed.trigger.namespace,
-    identifier: parsed.trigger.identifier,
-    task: parsed
-  }).where(eq(juniorEventTasks.id, parsed.id)).returning({ task: juniorEventTasks.task });
-  return rows[0] ? parseTask(rows[0].task) : void 0;
-}
-async function deleteEventTask(db, id) {
-  const rows = await db.delete(juniorEventTasks).where(eq(juniorEventTasks.id, id)).returning({ task: juniorEventTasks.task });
-  return rows[0] ? parseTask(rows[0].task) : void 0;
-}
-async function listEventTasksForTeam(db, teamId) {
-  const rows = await db.select({ task: juniorEventTasks.task }).from(juniorEventTasks).where(eq(juniorEventTasks.teamId, teamId)).orderBy(asc(juniorEventTasks.createdAtMs), asc(juniorEventTasks.id));
-  return rows.map((row) => parseTask(row.task));
-}
-async function findMatchingEventTasks(db, event, teamId) {
-  const rows = await db.select({ task: juniorEventTasks.task }).from(juniorEventTasks).where(
-    and(
-      eq(juniorEventTasks.teamId, teamId),
-      eq(juniorEventTasks.namespace, event.namespace),
-      eq(juniorEventTasks.identifier, event.identifier)
-    )
-  ).orderBy(asc(juniorEventTasks.createdAtMs), asc(juniorEventTasks.id));
-  return rows.map((row) => parseTask(row.task)).filter((task) => task.trigger.events.includes(event.eventType));
-}
-
-// src/chat/event-tasks/tool-support.ts
-import { z as z25 } from "zod";
-var compactEventTaskResultSchema = z25.object({
-  id: z25.string().min(1),
-  task: z25.string().min(1),
-  namespace: z25.string().min(1),
-  identifier: z25.string().min(1),
-  resourceType: z25.string().min(1),
-  label: z25.string().min(1),
-  events: z25.array(z25.string().min(1)).min(1),
-  credentialMode: z25.enum(["system", "creator"]),
-  createdBy: eventTaskPrincipalSchema,
-  triggerAvailable: z25.boolean()
-}).strict();
-var eventTaskToolResultSchema = juniorToolOutputSchema.extend({
-  task: compactEventTaskResultSchema
-}).strict();
-var eventTaskListToolResultSchema = juniorToolOutputSchema.extend({
-  tasks: z25.array(compactEventTaskResultSchema),
-  truncated: z25.boolean()
-}).strict();
-function registeredEventTaskTriggerSchema(catalog) {
-  return z25.object({
-    namespace: eventNamespaceSchema(catalog),
-    identifier: z25.string().trim().min(1).max(EVENT_TASK_IDENTIFIER_MAX_LENGTH),
-    resourceType: registeredResourceTypeSchema(catalog),
-    label: z25.string().trim().min(1).max(500),
-    events: z25.array(registeredEventTypeSchema(catalog)).min(1)
-  }).strict();
-}
-function requireSupportedEventTaskTrigger(catalog, trigger) {
-  for (const eventType of trigger.events) {
-    if (!pluginSupportsEvent(
-      catalog,
-      trigger.namespace,
-      trigger.resourceType,
-      eventType
-    )) {
-      throw new ToolInputError(
-        `Resource type "${trigger.namespace}:${trigger.resourceType}" does not support event "${eventType}".`
-      );
-    }
-  }
-}
-function requireEventTaskSlackContext(context) {
-  if (context.source.platform !== "slack" || context.destination.platform !== "slack" || context.actor?.platform !== "slack" || context.actor.teamId !== context.source.teamId) {
-    throw new ToolInputError(
-      "Event tasks require an active Slack channel or DM and actor."
-    );
-  }
-  return {
-    actor: context.actor,
-    destination: {
-      platform: "slack",
-      teamId: context.source.teamId,
-      channelId: context.source.channelId
-    },
-    source: context.source
-  };
-}
-function eventTaskMatchesDestination(task, destination) {
-  return task.destination.teamId === destination.teamId && task.destination.channelId === destination.channelId;
-}
-async function writableEventTask(context, id) {
-  const { destination } = requireEventTaskSlackContext(context);
-  const task = await getEventTask(getDb(), id);
-  if (!task || !eventTaskMatchesDestination(task, destination)) {
-    throw new ToolInputError(
-      "Event task was not found in this Slack channel or DM."
-    );
-  }
-  return task;
-}
-function triggerAvailable(task, catalog) {
-  const registration = catalog[task.trigger.namespace];
-  return Boolean(
-    registration && task.trigger.events.every(
-      (eventType) => registration.resourceTypes.some(
-        (resourceType) => resourceType.supportedEvents.includes(eventType)
-      )
-    )
-  );
-}
-function compactEventTask(task, catalog) {
-  return compactEventTaskResultSchema.parse({
-    id: task.id,
-    task: task.task.text,
-    namespace: task.trigger.namespace,
-    identifier: task.trigger.identifier,
-    resourceType: task.trigger.resourceType,
-    label: task.trigger.label,
-    events: task.trigger.events,
-    credentialMode: task.credentialMode,
-    createdBy: task.createdBy,
-    triggerAvailable: triggerAvailable(task, catalog)
-  });
-}
-function eventTaskSuccess(task, catalog) {
-  return {
-    task: compactEventTask(task, catalog)
-  };
-}
-
-// src/chat/tools/create-event-task.ts
+import { z as z22 } from "zod";
 function buildEventTaskId(args) {
   const toolCallId = args.toolCallId?.trim();
   if (!toolCallId) {
@@ -8497,10 +8219,10 @@ 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: z26.object({
-      task: z26.string().trim().min(1).max(4e3),
+    inputSchema: z22.object({
+      task: z22.string().trim().min(1).max(4e3),
       trigger,
-      credentialMode: z26.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(),
@@ -8561,7 +8283,7 @@ function createEventTaskTool(context, catalog) {
 }
 
 // src/chat/tools/delete-event-task.ts
-import { z as z27 } from "zod";
+import { z as z23 } from "zod";
 function createDeleteEventTaskTool(context, catalog) {
   return zodTool({
     approvalMode: "review",
@@ -8573,7 +8295,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: z27.object({ taskId: z27.string().min(1) }).strict(),
+    inputSchema: z23.object({ taskId: z23.string().min(1) }).strict(),
     outputSchema: eventTaskToolResultSchema,
     async execute({ taskId }) {
       const current = await writableEventTask(context, taskId);
@@ -8589,7 +8311,7 @@ function createDeleteEventTaskTool(context, catalog) {
 }
 
 // src/chat/tools/list-event-tasks.ts
-import { z as z28 } from "zod";
+import { z as z24 } from "zod";
 var MAX_LISTED_EVENT_TASKS = 50;
 function createListEventTasksTool(context, catalog) {
   return zodTool({
@@ -8600,7 +8322,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: z28.object({}).strict(),
+    inputSchema: z24.object({}).strict(),
     outputSchema: eventTaskListToolResultSchema,
     async execute() {
       const { destination } = requireEventTaskSlackContext(context);
@@ -8615,7 +8337,7 @@ function createListEventTasksTool(context, catalog) {
 }
 
 // src/chat/tools/update-event-task.ts
-import { z as z29 } from "zod";
+import { z as z25 } from "zod";
 function changesEventTaskTrigger(current, next) {
   const currentEvents = [...current.events].sort();
   const nextEvents = [...next.events].sort();
@@ -8632,11 +8354,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: z29.object({
-      taskId: z29.string().min(1),
-      task: z29.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: z29.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(),
@@ -8709,45 +8431,834 @@ function createEventTaskTools(context, catalog) {
   };
 }
 
-// src/chat/slack/channel.ts
-async function listChannelMessages(input) {
-  const client = getSlackClient();
-  const channelId = input.channelId;
-  const targetLimit = Math.max(1, Math.min(input.limit, 1e3));
-  const maxPages = Math.max(1, Math.min(input.maxPages ?? 5, 10));
-  const messages = [];
-  let cursor = input.cursor;
-  let pages = 0;
-  while (messages.length < targetLimit && pages < maxPages) {
-    pages += 1;
-    const pageLimit = Math.max(1, Math.min(200, targetLimit - messages.length));
-    const response = await withSlackRetries(
-      () => client.conversations.history({
-        channel: channelId,
-        limit: pageLimit,
-        cursor,
-        oldest: input.oldest,
-        latest: input.latest,
-        inclusive: input.inclusive
-      }),
-      3,
-      { action: "conversations.history" }
-    );
-    const batch = response.messages ?? [];
-    messages.push(...batch);
-    cursor = response.response_metadata?.next_cursor || void 0;
-    if (!cursor) {
-      break;
-    }
+// src/chat/scheduled-tasks/tools/create.ts
+import { z as z28 } from "zod";
+
+// src/chat/scheduled-tasks/schedule-intent.ts
+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 = z26.enum([
+  "sunday",
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday"
+]);
+var oneOffScheduleIntentSchema = z26.object({
+  kind: z26.literal("one_off").describe("A schedule that runs once."),
+  timezone: timezoneSchema,
+  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(),
+    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."
+      ),
+      time: localTimeSchema.describe(
+        "Requested local wall-clock time in HH:MM format."
+      )
+    }).strict()
+  ]).describe("Relative delay or explicit local time for the one-off run.")
+}).strict();
+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: 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(),
+  timezone: timezoneSchema
+}).strict().superRefine((schedule, context) => {
+  if (schedule.frequency === "weekly" && schedule.weekdays == null) {
+    context.addIssue({
+      code: "custom",
+      message: "Weekly schedules require weekdays.",
+      path: ["weekdays"]
+    });
   }
-  return {
-    messages: messages.slice(0, targetLimit),
-    nextCursor: cursor
-  };
+  if ((schedule.frequency === "monthly" || schedule.frequency === "yearly") && schedule.day_of_month == null) {
+    context.addIssue({
+      code: "custom",
+      message: `${schedule.frequency} schedules require day_of_month.`,
+      path: ["day_of_month"]
+    });
+  }
+  if (schedule.frequency === "yearly" && schedule.month == null) {
+    context.addIssue({
+      code: "custom",
+      message: "Yearly schedules require month.",
+      path: ["month"]
+    });
+  }
+  if (schedule.frequency !== "weekly" && schedule.weekdays != null) {
+    context.addIssue({
+      code: "custom",
+      message: "weekdays applies only to weekly schedules.",
+      path: ["weekdays"]
+    });
+  }
+  if (schedule.frequency !== "monthly" && schedule.frequency !== "yearly" && schedule.day_of_month != null) {
+    context.addIssue({
+      code: "custom",
+      message: "day_of_month applies only to monthly or yearly schedules.",
+      path: ["day_of_month"]
+    });
+  }
+  if (schedule.frequency !== "yearly" && schedule.month != null) {
+    context.addIssue({
+      code: "custom",
+      message: "month applies only to yearly schedules.",
+      path: ["month"]
+    });
+  }
+});
+var scheduleIntentSchema = z26.union([
+  oneOffScheduleIntentSchema,
+  recurringScheduleIntentSchema
+]);
+var WEEKDAY_INDEX = {
+  sunday: 0,
+  monday: 1,
+  tuesday: 2,
+  wednesday: 3,
+  thursday: 4,
+  friday: 5,
+  saturday: 6
+};
+var DURATION_MS = {
+  second: 1e3,
+  minute: 60 * 1e3,
+  hour: 60 * 60 * 1e3,
+  day: 24 * 60 * 60 * 1e3,
+  week: 7 * 24 * 60 * 60 * 1e3
+};
+function parseLocalTime(value) {
+  const [hour, minute] = value.split(":").map(Number);
+  return { hour, minute };
 }
-async function listThreadReplies(input) {
-  const client = getSlackClient();
-  const channelId = input.channelId;
+function localDateAt(timestampMs, timezone) {
+  const parts = getZonedDateTimeParts(timestampMs, timezone);
+  return [parts.year, parts.month, parts.day].map(
+    (value, index) => index === 0 ? String(value).padStart(4, "0") : String(value).padStart(2, "0")
+  ).join("-");
+}
+function isValidTimeZone(timezone) {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: timezone }).format();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function plural(value, unit) {
+  return value === 1 ? unit : `${unit}s`;
+}
+function formatWeekdays(weekdays) {
+  const labels = weekdays.map(
+    (weekday) => `${weekday[0].toUpperCase()}${weekday.slice(1)}`
+  );
+  if (labels.length < 2) {
+    return labels[0] ?? "";
+  }
+  return `${labels.slice(0, -1).join(", ")} and ${labels.at(-1)}`;
+}
+function recurringDescription(schedule, timezone) {
+  const interval = schedule.interval ?? 1;
+  const cadenceUnit = {
+    daily: "day",
+    weekly: "week",
+    monthly: "month",
+    yearly: "year"
+  }[schedule.frequency];
+  const cadence = interval === 1 ? cadenceUnit : `${interval} ${cadenceUnit}s`;
+  let detail = "";
+  if (schedule.frequency === "weekly") {
+    detail = ` on ${formatWeekdays(schedule.weekdays)}`;
+  } else if (schedule.frequency === "monthly") {
+    detail = ` on day ${schedule.day_of_month}`;
+  } else if (schedule.frequency === "yearly") {
+    detail = ` on ${String(schedule.month).padStart(2, "0")}-${String(
+      schedule.day_of_month
+    ).padStart(2, "0")}`;
+  }
+  return `Every ${cadence}${detail} at ${schedule.time} (${timezone})`;
+}
+var ScheduleIntentError = class extends Error {
+};
+function compileScheduleIntent(args) {
+  const timezone = args.intent.timezone ?? args.defaultTimezone;
+  if (!isValidTimeZone(timezone)) {
+    throw new ScheduleIntentError("timezone must be a valid IANA time zone.");
+  }
+  if (args.intent.kind === "one_off") {
+    if (args.intent.timing.type === "after") {
+      const nextRunAtMs3 = args.nowMs + args.intent.timing.value * DURATION_MS[args.intent.timing.unit];
+      return {
+        nextRunAtMs: nextRunAtMs3,
+        schedule: {
+          description: `In ${args.intent.timing.value} ${plural(
+            args.intent.timing.value,
+            args.intent.timing.unit
+          )}`,
+          kind: "one_off",
+          timezone
+        }
+      };
+    }
+    const nextRunAtMs2 = resolveLocalScheduleAtMs({
+      date: args.intent.timing.date,
+      time: parseLocalTime(args.intent.timing.time),
+      timezone
+    });
+    if (nextRunAtMs2 === void 0) {
+      throw new ScheduleIntentError(
+        "The requested local date or time does not exist in that timezone."
+      );
+    }
+    if (nextRunAtMs2 <= args.nowMs) {
+      throw new ScheduleIntentError(
+        "The requested one-off schedule must be in the future."
+      );
+    }
+    return {
+      nextRunAtMs: nextRunAtMs2,
+      schedule: {
+        description: `Once on ${args.intent.timing.date} at ${args.intent.timing.time} (${timezone})`,
+        kind: "one_off",
+        timezone
+      }
+    };
+  }
+  const recurrence = {
+    frequency: args.intent.frequency,
+    interval: args.intent.interval ?? 1,
+    startDate: args.intent.start_date ?? localDateAt(args.nowMs, timezone),
+    time: parseLocalTime(args.intent.time),
+    ...args.intent.frequency === "weekly" ? {
+      weekdays: [
+        ...new Set(
+          args.intent.weekdays.map((weekday) => WEEKDAY_INDEX[weekday])
+        )
+      ].sort((left, right) => left - right)
+    } : {},
+    ...args.intent.frequency === "monthly" || args.intent.frequency === "yearly" ? { dayOfMonth: args.intent.day_of_month ?? void 0 } : {},
+    ...args.intent.frequency === "yearly" ? { month: args.intent.month ?? void 0 } : {}
+  };
+  const searchRecurrence = args.intent.start_date ? recurrence : { ...recurrence, interval: 1 };
+  const nextRunAtMs = getFirstRunAtMs({
+    afterMs: args.nowMs,
+    recurrence: searchRecurrence,
+    timezone
+  });
+  if (nextRunAtMs === void 0) {
+    throw new ScheduleIntentError(
+      "The recurring schedule has no valid future occurrence."
+    );
+  }
+  const materializedRecurrence = args.intent.start_date ? recurrence : { ...recurrence, startDate: localDateAt(nextRunAtMs, timezone) };
+  return {
+    nextRunAtMs,
+    schedule: {
+      description: recurringDescription(args.intent, timezone),
+      kind: "recurring",
+      recurrence: materializedRecurrence,
+      timezone
+    }
+  };
+}
+
+// src/chat/scheduled-tasks/tool-support.ts
+import { createHash as createHash3 } from "crypto";
+import {
+  sourceSchema
+} from "@sentry/junior-plugin-api";
+import { z as z27 } from "zod";
+
+// src/chat/scheduled-tasks/identity.ts
+var SLACK_USER_ID_PATTERN = /^[UW][A-Z0-9]{5,}$/;
+function clean(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+function cleanSlackUserId(value) {
+  const normalized = clean(value);
+  return normalized && normalized.toLowerCase() !== "unknown" ? normalized : void 0;
+}
+function cleanDisplay(value, slackUserId) {
+  const normalized = clean(value);
+  if (!normalized || normalized.toLowerCase() === "unknown" || normalized === slackUserId) {
+    return void 0;
+  }
+  return SLACK_USER_ID_PATTERN.test(normalized) ? void 0 : normalized;
+}
+function sanitizeScheduledTaskPrincipal(principal) {
+  const slackUserId = cleanSlackUserId(principal.slackUserId);
+  if (!slackUserId) {
+    throw new Error("Scheduled task principal requires a Slack user id");
+  }
+  const fullName = cleanDisplay(principal.fullName, slackUserId);
+  const userName = cleanDisplay(principal.userName, slackUserId);
+  return {
+    slackUserId,
+    ...fullName ? { fullName } : {},
+    ...userName ? { userName } : {}
+  };
+}
+
+// src/chat/scheduled-tasks/tool-support.ts
+var TASK_ID_PREFIX = "sched";
+var MAX_LISTED_TASKS = 50;
+var DEFAULT_SCHEDULE_TIMEZONE = "America/Los_Angeles";
+var compactTaskResultSchema = z27.object({
+  id: z27.string(),
+  status: z27.enum(["active", "paused", "blocked", "deleted"]),
+  task: z27.string(),
+  schedule: z27.string(),
+  timezone: z27.string(),
+  recurrence: z27.unknown().nullable(),
+  next_run_at: z27.string().nullable(),
+  conversation_access: z27.object({
+    audience: z27.enum(["direct", "group", "channel"]),
+    visibility: z27.enum(["private", "public"])
+  }).strict(),
+  credential_mode: z27.enum(["system", "creator"]),
+  last_run_at: z27.string().nullable(),
+  run_now_at: z27.string().nullable()
+}).strict();
+var scheduleTaskToolResultSchema = juniorToolOutputSchema.extend({
+  target: z27.string(),
+  task: compactTaskResultSchema
+}).strict();
+var scheduleListToolResultSchema = juniorToolOutputSchema.extend({
+  target: z27.string(),
+  tasks: z27.array(compactTaskResultSchema),
+  truncated: z27.boolean()
+}).strict();
+function throwToolInputError(error) {
+  throw new ToolInputError(error);
+}
+function requireActiveConversation(context) {
+  const parsed = sourceSchema.safeParse(context.source);
+  if (!parsed.success) {
+    const source = context.source;
+    const issues = parsed.error.issues;
+    if (!source || source.platform !== "slack") {
+      throwToolInputError("No active Slack conversation is available.");
+    }
+    if (issues.some((issue) => issue.code === "unrecognized_keys")) {
+      throwToolInputError(
+        "Active Slack conversation must not include unknown fields."
+      );
+    }
+    if (issues.some((issue) => issue.path[0] === "channelId")) {
+      throwToolInputError("Active Slack conversation channel is invalid.");
+    }
+    if (issues.some((issue) => issue.path[0] === "teamId")) {
+      throwToolInputError("Active Slack conversation workspace is invalid.");
+    }
+    throwToolInputError("No active Slack conversation is available.");
+  }
+  if (parsed.data.platform !== "slack") {
+    throwToolInputError("No active Slack conversation is available.");
+  }
+  return {
+    platform: "slack",
+    teamId: parsed.data.teamId,
+    channelId: parsed.data.channelId
+  };
+}
+function requireActor(context, destination) {
+  if (context.actor?.platform !== "slack" || context.actor.teamId !== destination.teamId) {
+    throwToolInputError("No active Slack actor context is available.");
+  }
+  const userId = context.actor?.userId?.trim();
+  if (!userId || userId.toLowerCase() === "unknown") {
+    throwToolInputError("No active Slack actor context is available.");
+  }
+  return sanitizeScheduledTaskPrincipal({
+    slackUserId: userId,
+    ...context.actor?.userName ? { userName: context.actor.userName } : {},
+    ...context.actor?.fullName ? { fullName: context.actor.fullName } : {}
+  });
+}
+function isDmChannel(channelId) {
+  return channelId.startsWith("D");
+}
+function getConversationAccess(destination, source) {
+  if (isDmChannel(destination.channelId)) {
+    return { audience: "direct", visibility: "private" };
+  }
+  if (destination.channelId.startsWith("G")) {
+    return { audience: "group", visibility: "private" };
+  }
+  return {
+    audience: "channel",
+    visibility: source?.visibility === "public" ? "public" : "private"
+  };
+}
+function sameDestination(task, destination) {
+  const taskDestination = task.destination;
+  return taskDestination.platform === "slack" && taskDestination.teamId === destination.teamId && taskDestination.channelId === destination.channelId;
+}
+async function getWritableTask(args) {
+  const destination = requireActiveConversation(args.context);
+  const task = await schedulerStore(args.context).getTask(args.taskId);
+  if (!task || task.status === "deleted") {
+    throwToolInputError(
+      "Scheduled task was not found in the active Slack conversation."
+    );
+  }
+  if (!sameDestination(task, destination)) {
+    throwToolInputError(
+      "Scheduled task can only be managed from the Slack destination where it was created."
+    );
+  }
+  return task;
+}
+function compactTask(task) {
+  return compactTaskResultSchema.parse({
+    id: task.id,
+    status: task.status,
+    task: task.task.text,
+    schedule: task.schedule.description,
+    timezone: task.schedule.timezone,
+    recurrence: task.schedule.recurrence ? {
+      frequency: task.schedule.recurrence.frequency,
+      interval: task.schedule.recurrence.interval,
+      start_date: task.schedule.recurrence.startDate,
+      time: task.schedule.recurrence.time,
+      weekdays: task.schedule.recurrence.weekdays,
+      month: task.schedule.recurrence.month,
+      day_of_month: task.schedule.recurrence.dayOfMonth
+    } : null,
+    next_run_at: task.nextRunAtMs ? new Date(task.nextRunAtMs).toISOString() : null,
+    conversation_access: task.conversationAccess,
+    credential_mode: task.credentialMode,
+    last_run_at: task.lastRunAtMs ? new Date(task.lastRunAtMs).toISOString() : null,
+    run_now_at: task.runNowAtMs ? new Date(task.runNowAtMs).toISOString() : null
+  });
+}
+function scheduleTaskToolResult(target, task) {
+  return {
+    target,
+    task
+  };
+}
+function scheduleListToolResult(args) {
+  return {
+    target: args.target,
+    tasks: args.tasks,
+    truncated: args.truncated
+  };
+}
+function buildTaskId(args) {
+  const toolCallId = args.toolCallId?.trim();
+  if (!toolCallId) {
+    throw new Error("Scheduler task creation requires a tool-call identity.");
+  }
+  const digest2 = createHash3("sha256").update(
+    JSON.stringify({
+      actor: args.actor.slackUserId,
+      channel: args.destination.channelId,
+      operation: toolCallId,
+      platform: args.destination.platform,
+      team: args.destination.teamId
+    })
+  ).digest("hex").slice(0, 32);
+  return `${TASK_ID_PREFIX}_${digest2}`;
+}
+function schedulerStore(context) {
+  return context.store;
+}
+function normalizeStatus(value) {
+  if (value === "active" || value === "paused" || value === "blocked") {
+    return value;
+  }
+  return void 0;
+}
+function getDefaultScheduleTimezone() {
+  return process.env.JUNIOR_TIMEZONE?.trim() || DEFAULT_SCHEDULE_TIMEZONE;
+}
+
+// src/chat/scheduled-tasks/tools/create.ts
+function createSlackScheduleCreateTaskTool(context) {
+  return zodTool({
+    approvalMode: "review",
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true,
+      readOnlyHint: false
+    },
+    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: z28.object({
+      task: z28.string().min(1).max(4e3),
+      schedule: scheduleIntentSchema.describe(
+        "When the task runs. The scheduler computes the exact next run from this intent and the server clock."
+      ),
+      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(),
+    prepareArguments(args) {
+      const input = args;
+      if (input?.credential_mode !== "creator" && input?.credential_mode !== null) {
+        return input;
+      }
+      const prepared = { ...input };
+      delete prepared.credential_mode;
+      return prepared;
+    },
+    outputSchema: scheduleTaskToolResultSchema,
+    execute: async (input, options) => {
+      const destination = requireActiveConversation(context);
+      const actor = requireActor(context, destination);
+      const store = schedulerStore(context);
+      const id = buildTaskId({
+        actor,
+        destination,
+        toolCallId: options.toolCallId
+      });
+      const existing = await store.getTask(id);
+      if (existing) {
+        if (!sameDestination(existing, destination) || existing.createdBy.slackUserId !== actor.slackUserId) {
+          throwToolInputError("Scheduled task operation identity is invalid.");
+        }
+        return scheduleTaskToolResult(
+          "slackScheduleCreateTask",
+          compactTask(existing)
+        );
+      }
+      const creator = await context.users.resolveActor();
+      const identity = creator?.identity;
+      if (!identity || identity.provider !== "slack" || identity.providerTenantId !== destination.teamId || identity.providerSubjectId !== actor.slackUserId) {
+        throwToolInputError("Scheduled task creator identity is unavailable.");
+      }
+      const nowMs = context.now?.() ?? Date.now();
+      let compiled;
+      try {
+        compiled = compileScheduleIntent({
+          defaultTimezone: getDefaultScheduleTimezone(),
+          intent: input.schedule,
+          nowMs
+        });
+      } catch (error) {
+        if (error instanceof ScheduleIntentError) {
+          throwToolInputError(error.message);
+        }
+        throw error;
+      }
+      const conversationAccess = getConversationAccess(
+        destination,
+        context.source
+      );
+      const task = {
+        id,
+        createdAtMs: nowMs,
+        updatedAtMs: nowMs,
+        createdBy: actor,
+        creatorIdentityId: identity.id,
+        conversationAccess,
+        credentialMode: input.credential_mode ?? "creator",
+        destination,
+        executionActor: SCHEDULED_TASK_SYSTEM_ACTOR,
+        nextRunAtMs: compiled.nextRunAtMs,
+        originalRequest: context.userText,
+        schedule: compiled.schedule,
+        status: "active",
+        task: {
+          text: input.task
+        }
+      };
+      const committed = await store.createTask(task);
+      if (!sameDestination(committed, destination) || committed.createdBy.slackUserId !== actor.slackUserId) {
+        throwToolInputError("Scheduled task operation identity is invalid.");
+      }
+      return scheduleTaskToolResult(
+        "slackScheduleCreateTask",
+        compactTask(committed)
+      );
+    }
+  });
+}
+
+// src/chat/scheduled-tasks/tools/delete.ts
+import { z as z29 } from "zod";
+function createSlackScheduleDeleteTaskTool(context) {
+  return zodTool({
+    annotations: {
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    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: z29.object({
+      task_id: z29.string().min(1).describe(
+        "ID of the task to delete. Must be from this active Slack conversation."
+      )
+    }),
+    outputSchema: scheduleTaskToolResultSchema,
+    execute: async ({ task_id }) => {
+      const lookup = await getWritableTask({ context, taskId: task_id });
+      const next = {
+        ...lookup,
+        updatedAtMs: Date.now(),
+        status: "deleted",
+        nextRunAtMs: void 0,
+        runNowAtMs: void 0
+      };
+      await schedulerStore(context).saveTask(next);
+      return scheduleTaskToolResult(
+        "slackScheduleDeleteTask",
+        compactTask(next)
+      );
+    }
+  });
+}
+
+// src/chat/scheduled-tasks/tools/list.ts
+import { z as z30 } from "zod";
+function createSlackScheduleListTasksTool(context) {
+  return zodTool({
+    description: "List scheduled Junior tasks for the active Slack conversation. Use when the user asks what is scheduled here, or when task IDs are needed before editing, deleting, or running schedules. Only manages tasks for the active Slack DM or channel.",
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+      readOnlyHint: true
+    },
+    inputSchema: z30.object({}),
+    outputSchema: scheduleListToolResultSchema,
+    execute: async () => {
+      const destination = requireActiveConversation(context);
+      const tasks = await schedulerStore(context).listTasksForTeam(
+        destination.teamId
+      );
+      const matching = tasks.filter(
+        (task) => sameDestination(task, destination)
+      );
+      const visible = matching.slice(0, MAX_LISTED_TASKS).map(compactTask);
+      return scheduleListToolResult({
+        target: "slackScheduleListTasks",
+        tasks: visible,
+        truncated: matching.length > visible.length
+      });
+    }
+  });
+}
+
+// src/chat/scheduled-tasks/tools/run-now.ts
+import { z as z31 } from "zod";
+function createSlackScheduleRunTaskNowTool(context) {
+  return zodTool({
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true,
+      readOnlyHint: false
+    },
+    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: z31.object({
+      task_id: z31.string().min(1).describe(
+        "ID of the active task to run now. Must be from this active Slack conversation."
+      )
+    }),
+    outputSchema: scheduleTaskToolResultSchema,
+    execute: async ({ task_id }) => {
+      const lookup = await getWritableTask({ context, taskId: task_id });
+      if (lookup.status !== "active") {
+        throwToolInputError(
+          "Scheduled task must be active before it can be run now. Resume the task first if you want it to run."
+        );
+      }
+      const nowMs = Date.now();
+      const next = {
+        ...lookup,
+        updatedAtMs: nowMs,
+        runNowAtMs: nowMs
+      };
+      await schedulerStore(context).saveTask(next);
+      return scheduleTaskToolResult(
+        "slackScheduleRunTaskNow",
+        compactTask(next)
+      );
+    }
+  });
+}
+
+// src/chat/scheduled-tasks/tools/update.ts
+import { z as z32 } from "zod";
+function createSlackScheduleUpdateTaskTool(context) {
+  return zodTool({
+    approvalMode: "review",
+    annotations: {
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: true,
+      readOnlyHint: false
+    },
+    description: "Edit, pause, resume, reschedule, or change credential use for an existing Junior scheduled task in the active Slack conversation.",
+    executionMode: "sequential",
+    inputSchema: z32.object({
+      task_id: z32.string().min(1).describe(
+        "ID of the task to update. Must be from this active Slack conversation."
+      ),
+      task: z32.string().min(1).max(4e3).optional(),
+      schedule: scheduleIntentSchema.describe(
+        "Complete replacement schedule when rescheduling. Omit for task, status, or credential-only changes; the scheduler computes the next run."
+      ).nullable().optional(),
+      status: z32.enum(["active", "paused", "blocked"]).describe(
+        "Set to active, paused, or blocked to resume, pause, or block the task."
+      ).optional(),
+      credential_mode: z32.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 created_by actor, never the current requester. Only that original creator may enable creator mode. Omit or use null to leave unchanged."
+      ).optional()
+    }).strict(),
+    outputSchema: scheduleTaskToolResultSchema,
+    execute: async (input) => {
+      const lookup = await getWritableTask({
+        context,
+        taskId: input.task_id
+      });
+      const actor = requireActor(context, lookup.destination);
+      const isCreator = actor.slackUserId === lookup.createdBy.slackUserId;
+      if (input.credential_mode === "creator" && !isCreator) {
+        throwToolInputError(
+          "Only the scheduled task creator can enable creator credential use."
+        );
+      }
+      const nowMs = context.now?.() ?? Date.now();
+      let compiled;
+      if (input.schedule) {
+        try {
+          compiled = compileScheduleIntent({
+            defaultTimezone: lookup.schedule.timezone || getDefaultScheduleTimezone(),
+            intent: input.schedule,
+            nowMs
+          });
+        } catch (error) {
+          if (error instanceof ScheduleIntentError) {
+            throwToolInputError(error.message);
+          }
+          throw error;
+        }
+      }
+      const nextRunAtMs = compiled?.nextRunAtMs ?? lookup.nextRunAtMs;
+      const status = normalizeStatus(input.status);
+      if (input.status && !status) {
+        throwToolInputError("status must be active, paused, or blocked.");
+      }
+      if (status === "active" && !nextRunAtMs) {
+        throwToolInputError(
+          "Active scheduled tasks require a schedule with a future occurrence."
+        );
+      }
+      const nextStatus = status ?? lookup.status;
+      const credentialMode = input.task !== void 0 && input.task !== lookup.task.text && !isCreator ? "system" : input.credential_mode ?? lookup.credentialMode;
+      const next = {
+        ...lookup,
+        credentialMode,
+        updatedAtMs: nowMs,
+        nextRunAtMs,
+        runNowAtMs: nextStatus === "active" && !compiled ? lookup.runNowAtMs : void 0,
+        status: nextStatus,
+        statusReason: nextStatus === "blocked" ? lookup.statusReason : void 0,
+        schedule: compiled?.schedule ?? lookup.schedule,
+        task: input.task ? { text: input.task } : lookup.task
+      };
+      await schedulerStore(context).saveTask(next);
+      return scheduleTaskToolResult(
+        "slackScheduleUpdateTask",
+        compactTask(next)
+      );
+    }
+  });
+}
+
+// src/chat/tools/scheduled-tasks.ts
+function scheduledTaskToolContext(context) {
+  if (context.source.platform !== "slack" || context.destination.platform !== "slack" || context.actor?.platform !== "slack" || !context.resolveActorIdentity) {
+    return void 0;
+  }
+  return {
+    actor: context.actor,
+    source: context.source,
+    store: createSchedulerSqlStore(getDb()),
+    users: { resolveActor: context.resolveActorIdentity },
+    ...context.userText ? { userText: context.userText } : {}
+  };
+}
+function createScheduledTaskTools(context) {
+  const taskContext = scheduledTaskToolContext(context);
+  if (!taskContext) return {};
+  return {
+    slackScheduleCreateTask: createSlackScheduleCreateTaskTool(taskContext),
+    slackScheduleListTasks: createSlackScheduleListTasksTool(taskContext),
+    slackScheduleUpdateTask: createSlackScheduleUpdateTaskTool(taskContext),
+    slackScheduleDeleteTask: createSlackScheduleDeleteTaskTool(taskContext),
+    slackScheduleRunTaskNow: createSlackScheduleRunTaskNowTool(taskContext)
+  };
+}
+
+// src/chat/slack/channel.ts
+async function listChannelMessages(input) {
+  const client = getSlackClient();
+  const channelId = input.channelId;
+  const targetLimit = Math.max(1, Math.min(input.limit, 1e3));
+  const maxPages = Math.max(1, Math.min(input.maxPages ?? 5, 10));
+  const messages = [];
+  let cursor = input.cursor;
+  let pages = 0;
+  while (messages.length < targetLimit && pages < maxPages) {
+    pages += 1;
+    const pageLimit = Math.max(1, Math.min(200, targetLimit - messages.length));
+    const response = await withSlackRetries(
+      () => client.conversations.history({
+        channel: channelId,
+        limit: pageLimit,
+        cursor,
+        oldest: input.oldest,
+        latest: input.latest,
+        inclusive: input.inclusive
+      }),
+      3,
+      { action: "conversations.history" }
+    );
+    const batch = response.messages ?? [];
+    messages.push(...batch);
+    cursor = response.response_metadata?.next_cursor || void 0;
+    if (!cursor) {
+      break;
+    }
+  }
+  return {
+    messages: messages.slice(0, targetLimit),
+    nextCursor: cursor
+  };
+}
+async function listThreadReplies(input) {
+  const client = getSlackClient();
+  const channelId = input.channelId;
   const targetLimit = Math.max(1, Math.min(input.limit ?? 1e3, 1e3));
   const maxPages = Math.max(1, Math.min(input.maxPages ?? 10, 10));
   const pendingTargets = new Set(
@@ -8788,11 +9299,11 @@ async function listThreadReplies(input) {
 }
 
 // src/chat/slack/timestamp-param.ts
-import { z as z30 } from "zod";
+import { z as z33 } from "zod";
 function slackTimestampParam(description) {
-  return z30.preprocess(
+  return z33.preprocess(
     (value) => typeof value === "number" && Number.isFinite(value) ? String(value) : value,
-    z30.string().min(1)
+    z33.string().min(1)
   ).describe(description);
 }
 function optionalSlackTimestampParam(description) {
@@ -8823,10 +9334,10 @@ function parseRequiredSlackTimestampParam(field, value) {
 }
 
 // src/chat/slack/tools/channel-list-messages.ts
-import { z as z31 } from "zod";
-var booleanInput2 = (description) => z31.preprocess(
+import { z as z34 } from "zod";
+var booleanInput2 = (description) => z34.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z31.boolean()
+  z34.boolean()
 ).describe(description);
 function normalizeRangeTimestamp(field, value, targetChannelId) {
   if (value === void 0) {
@@ -8858,9 +9369,9 @@ function createSlackChannelListMessagesTool(context) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z31.object({
-      limit: z31.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
-      cursor: z31.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
+    inputSchema: z34.object({
+      limit: z34.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
+      cursor: z34.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
       oldest: optionalSlackTimestampParam(
         "Optional oldest message timestamp (Slack ts) for range filtering."
       ),
@@ -8870,7 +9381,7 @@ function createSlackChannelListMessagesTool(context) {
       inclusive: booleanInput2(
         "Whether oldest/latest bounds should be inclusive."
       ).optional(),
-      max_pages: z31.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
+      max_pages: z34.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({
@@ -8933,20 +9444,20 @@ function createSlackChannelListMessagesTool(context) {
 }
 
 // src/chat/slack/tools/conversation-search.ts
-import { z as z32 } from "zod";
+import { z as z35 } from "zod";
 var DEFAULT_LIMIT = 5;
 var conversationSearchOutputSchema = juniorToolOutputSchema.extend({
-  query: z32.string(),
-  count: z32.number().int().nonnegative(),
-  threads: z32.array(
-    z32.object({
-      conversation_id: z32.string().min(1),
-      thread_ts: z32.string().min(1),
-      message_id: z32.string().min(1),
-      message_role: z32.enum(["assistant", "user"]),
-      message_timestamp: z32.string().datetime(),
-      excerpt: z32.string(),
-      permalink: z32.string().url().optional()
+  query: z35.string(),
+  count: z35.number().int().nonnegative(),
+  threads: z35.array(
+    z35.object({
+      conversation_id: z35.string().min(1),
+      thread_ts: z35.string().min(1),
+      message_id: z35.string().min(1),
+      message_role: z35.enum(["assistant", "user"]),
+      message_timestamp: z35.string().datetime(),
+      excerpt: z35.string(),
+      permalink: z35.string().url().optional()
     }).strict()
   )
 });
@@ -8964,9 +9475,9 @@ function createSlackConversationSearchTool(scope, currentConversationId, deps =
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z32.object({
-      query: z32.string().trim().min(1).max(200).describe("Words or a short phrase to find in prior conversations."),
-      limit: z32.number().int().min(1).max(10).describe("Maximum number of prior conversation threads to return.").nullable().optional()
+    inputSchema: z35.object({
+      query: z35.string().trim().min(1).max(200).describe("Words or a short phrase to find in prior conversations."),
+      limit: z35.number().int().min(1).max(10).describe("Maximum number of prior conversation threads to return.").nullable().optional()
     }),
     outputSchema: conversationSearchOutputSchema,
     execute: async ({ query, limit }) => {
@@ -9011,27 +9522,27 @@ function createSlackConversationSearchTool(scope, currentConversationId, deps =
 }
 
 // src/chat/slack/tools/public-search.ts
-import { z as z33 } from "zod";
+import { z as z36 } from "zod";
 var DEFAULT_LIMIT2 = 10;
-var optionalTimestampSchema = z33.preprocess(
+var optionalTimestampSchema = z36.preprocess(
   (value) => typeof value === "string" && value.trim() === "" ? void 0 : value,
-  z33.coerce.number().int().nonnegative().describe("Optional Unix timestamp bound.").optional()
+  z36.coerce.number().int().nonnegative().describe("Optional Unix timestamp bound.").optional()
 );
-var searchMessageSchema = z33.object({
-  author_name: z33.string().optional(),
-  author_user_id: z33.string().optional(),
-  channel_id: z33.string().min(1),
-  channel_name: z33.string().optional(),
-  message_ts: z33.string().min(1),
-  content: z33.string(),
-  is_author_bot: z33.boolean().optional(),
-  permalink: z33.string().url()
+var searchMessageSchema = z36.object({
+  author_name: z36.string().optional(),
+  author_user_id: z36.string().optional(),
+  channel_id: z36.string().min(1),
+  channel_name: z36.string().optional(),
+  message_ts: z36.string().min(1),
+  content: z36.string(),
+  is_author_bot: z36.boolean().optional(),
+  permalink: z36.string().url()
 });
 var publicSearchOutputSchema = juniorToolOutputSchema.extend({
-  query: z33.string(),
-  count: z33.number().int().nonnegative(),
-  messages: z33.array(searchMessageSchema),
-  next_cursor: z33.string().optional()
+  query: z36.string(),
+  count: z36.number().int().nonnegative(),
+  messages: z36.array(searchMessageSchema),
+  next_cursor: z36.string().optional()
 });
 function normalizeMessage(value) {
   const parsed = searchMessageSchema.safeParse(value);
@@ -9058,8 +9569,8 @@ function createSlackPublicSearchTool(actionToken) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z33.object({
-      query: z33.string().trim().min(1).max(500).describe(
+    inputSchema: z36.object({
+      query: z36.string().trim().min(1).max(500).describe(
         "A focused Slack search query, including Slack search filters when useful."
       ),
       after: optionalTimestampSchema.describe(
@@ -9068,10 +9579,10 @@ function createSlackPublicSearchTool(actionToken) {
       before: optionalTimestampSchema.describe(
         "Optional Unix timestamp upper bound."
       ),
-      cursor: z33.string().min(1).describe("Cursor for the next result page.").optional(),
-      limit: z33.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
-      sort: z33.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
-      sort_dir: z33.enum(["asc", "desc"]).describe("Sort direction.").optional()
+      cursor: z36.string().min(1).describe("Cursor for the next result page.").optional(),
+      limit: z36.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
+      sort: z36.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
+      sort_dir: z36.enum(["asc", "desc"]).describe("Sort direction.").optional()
     }),
     outputSchema: publicSearchOutputSchema,
     execute: async ({
@@ -9128,7 +9639,7 @@ function createSlackPublicSearchTool(actionToken) {
 }
 
 // src/chat/slack/tools/message-add-reaction.ts
-import { z as z34 } from "zod";
+import { z as z37 } from "zod";
 
 // src/chat/tools/idempotency.ts
 function stableSerialize(value) {
@@ -9158,8 +9669,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: z34.object({
-      emoji: z34.string().min(1).max(64).describe(
+    inputSchema: z37.object({
+      emoji: z37.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."
       )
     }),
@@ -9207,15 +9718,15 @@ function createSlackMessageAddReactionTool(context, state) {
 }
 
 // src/chat/slack/tools/send-files.ts
-import { createHash as createHash3 } from "crypto";
-import { z as z35 } from "zod";
+import { createHash as createHash4 } from "crypto";
+import { z as z38 } from "zod";
 var sendFilesResultSchema = juniorToolOutputSchema.extend({
-  target: z35.string().min(1),
-  channel_id: z35.string().min(1),
-  deduplicated: z35.boolean().optional(),
-  file_count: z35.number().int().nonnegative(),
-  file_ids: z35.array(z35.string().min(1)).optional(),
-  thread_ts: z35.string().min(1)
+  target: z38.string().min(1),
+  channel_id: z38.string().min(1),
+  deduplicated: z38.boolean().optional(),
+  file_count: z38.number().int().nonnegative(),
+  file_ids: z38.array(z38.string().min(1)).optional(),
+  thread_ts: z38.string().min(1)
 });
 function normalizeFiles(files) {
   return files.map((file) => ({
@@ -9225,7 +9736,7 @@ function normalizeFiles(files) {
   }));
 }
 function fileContentDigest(data) {
-  return createHash3("sha256").update(data).digest("hex");
+  return createHash4("sha256").update(data).digest("hex");
 }
 function fileOperationInput(files) {
   return files.map((file) => ({
@@ -9245,8 +9756,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: z35.object({
-      files: z35.array(sandboxFileReferenceSchema).min(1).describe(
+    inputSchema: z38.object({
+      files: z38.array(sandboxFileReferenceSchema).min(1).describe(
         "One or more existing sandbox files. Objects returned by imageGenerate or webFetch can be passed unchanged."
       )
     }),
@@ -9678,7 +10189,7 @@ function storedCanvasUrl(state, canvasId) {
 }
 
 // src/chat/slack/tools/canvas/create.ts
-import { z as z36 } from "zod";
+import { z as z39 } from "zod";
 function createSlackCanvasCreateTool(context, state) {
   return zodTool({
     annotations: {
@@ -9688,9 +10199,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: z36.object({
-      title: z36.string().min(1).max(160).describe("Canvas title."),
-      markdown: z36.string().min(1).describe("Canvas markdown body content.")
+    inputSchema: z39.object({
+      title: z39.string().min(1).max(160).describe("Canvas title."),
+      markdown: z39.string().min(1).describe("Canvas markdown body content.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ title, markdown }) => {
@@ -9746,26 +10257,26 @@ function createSlackCanvasCreateTool(context, state) {
 }
 
 // src/chat/slack/tools/canvas/edit.ts
-import { z as z37 } from "zod";
+import { z as z40 } from "zod";
 function prepareCanvasEditArguments(input) {
   return prepareTextReplacementArguments(input);
 }
-var editReplacementSchema2 = z37.object({
-  oldText: z37.string().min(1).describe(
+var editReplacementSchema2 = z40.object({
+  oldText: z40.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: z37.string().describe("Replacement Canvas markdown for this edit.")
+  newText: z40.string().describe("Replacement Canvas markdown for this edit.")
 });
 var slackCanvasEditOutputSchema = juniorToolOutputSchema.extend({
-  canvas_id: z37.string().optional(),
-  title: z37.string().optional(),
-  permalink: z37.string().optional(),
-  diff: z37.string().optional(),
-  first_changed_line: z37.number().int().positive().optional(),
-  replacements: z37.number().int().nonnegative().optional(),
-  normalized_heading_count: z37.number().int().nonnegative().optional(),
-  summary: z37.string().optional(),
-  deduplicated: z37.boolean().optional()
+  canvas_id: z40.string().optional(),
+  title: z40.string().optional(),
+  permalink: z40.string().optional(),
+  diff: z40.string().optional(),
+  first_changed_line: z40.number().int().positive().optional(),
+  replacements: z40.number().int().nonnegative().optional(),
+  normalized_heading_count: z40.number().int().nonnegative().optional(),
+  summary: z40.string().optional(),
+  deduplicated: z40.boolean().optional()
 }).strict();
 function createSlackCanvasEditTool(state) {
   return zodTool({
@@ -9778,9 +10289,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: z37.object({
-      canvas: z37.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
-      edits: z37.array(editReplacementSchema2).min(1).describe(
+    inputSchema: z40.object({
+      canvas: z40.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
+      edits: z40.array(editReplacementSchema2).min(1).describe(
         "Exact replacements matched against the current Canvas body, not incrementally."
       )
     }),
@@ -9837,18 +10348,18 @@ function createSlackCanvasEditTool(state) {
 }
 
 // src/chat/slack/tools/canvas/read.ts
-import { z as z38 } from "zod";
+import { z as z41 } from "zod";
 var slackCanvasReadOutputSchema = juniorToolOutputSchema.extend({
-  canvas_id: z38.string().optional(),
-  title: z38.string().optional(),
-  permalink: z38.string().optional(),
-  mimetype: z38.string().optional(),
-  filetype: z38.string().optional(),
-  original_byte_length: z38.number().int().nonnegative().optional(),
-  content: z38.string().optional(),
-  start_line: z38.number().int().positive().optional(),
-  end_line: z38.number().int().nonnegative().optional(),
-  total_lines: z38.number().int().nonnegative().optional()
+  canvas_id: z41.string().optional(),
+  title: z41.string().optional(),
+  permalink: z41.string().optional(),
+  mimetype: z41.string().optional(),
+  filetype: z41.string().optional(),
+  original_byte_length: z41.number().int().nonnegative().optional(),
+  content: z41.string().optional(),
+  start_line: z41.number().int().positive().optional(),
+  end_line: z41.number().int().nonnegative().optional(),
+  total_lines: z41.number().int().nonnegative().optional()
 }).strict();
 function createSlackCanvasReadTool() {
   return zodTool({
@@ -9859,12 +10370,12 @@ function createSlackCanvasReadTool() {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z38.object({
-      canvas: z38.string().min(1).describe(
+    inputSchema: z41.object({
+      canvas: z41.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: z38.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
-      limit: z38.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
+      offset: z41.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
+      limit: z41.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
     }),
     outputSchema: slackCanvasReadOutputSchema,
     execute: async ({ canvas, offset, limit }) => {
@@ -9900,7 +10411,7 @@ function createSlackCanvasReadTool() {
 }
 
 // src/chat/slack/tools/canvas/write.ts
-import { z as z39 } from "zod";
+import { z as z42 } from "zod";
 function createSlackCanvasWriteTool(state) {
   return zodTool({
     annotations: {
@@ -9911,9 +10422,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: z39.object({
-      canvas: z39.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
-      content: z39.string().describe("UTF-8 markdown content to write.")
+    inputSchema: z42.object({
+      canvas: z42.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
+      content: z42.string().describe("UTF-8 markdown content to write.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ canvas, content }) => {
@@ -10128,12 +10639,12 @@ async function updateListItem(input) {
 }
 
 // src/chat/slack/id-param.ts
-import { z as z40 } from "zod";
+import { z as z43 } from "zod";
 function slackChannelIdParam(description) {
-  return z40.string().min(1).describe(description);
+  return z43.string().min(1).describe(description);
 }
 function slackUserIdParam(description) {
-  return z40.string().min(1).describe(description);
+  return z43.string().min(1).describe(description);
 }
 function parseRequiredSlackChannelIdParam(field, value) {
   const channelId = parseSlackChannelId(value);
@@ -10157,7 +10668,7 @@ function parseRequiredSlackUserIdParam(field, value) {
 }
 
 // src/chat/slack/tools/list/add-items.ts
-import { z as z41 } from "zod";
+import { z as z44 } from "zod";
 function createSlackListAddItemsTool(state) {
   return zodTool({
     annotations: {
@@ -10167,12 +10678,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: z41.object({
-      items: z41.array(z41.string().min(1)).min(1).max(25).describe("List item titles to create."),
+    inputSchema: z44.object({
+      items: z44.array(z44.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: z41.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
+      due_date: z44.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ items, assignee_user_id, due_date }) => {
@@ -10220,7 +10731,7 @@ function createSlackListAddItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/create.ts
-import { z as z42 } from "zod";
+import { z as z45 } from "zod";
 function createSlackListCreateTool(state) {
   return zodTool({
     annotations: {
@@ -10230,8 +10741,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: z42.object({
-      name: z42.string().min(1).max(160).describe("Name for the new Slack list.")
+    inputSchema: z45.object({
+      name: z45.string().min(1).max(160).describe("Name for the new Slack list.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ name }) => {
@@ -10261,7 +10772,7 @@ function createSlackListCreateTool(state) {
 }
 
 // src/chat/slack/tools/list/get-items.ts
-import { z as z43 } from "zod";
+import { z as z46 } 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.",
@@ -10271,8 +10782,8 @@ function createSlackListGetItemsTool(state) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z43.object({
-      limit: z43.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
+    inputSchema: z46.object({
+      limit: z46.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ limit }) => {
@@ -10291,21 +10802,21 @@ function createSlackListGetItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/update-item.ts
-import { z as z44 } from "zod";
-var booleanInput3 = (description) => z44.preprocess(
+import { z as z47 } from "zod";
+var booleanInput3 = (description) => z47.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z44.boolean()
+  z47.boolean()
 ).describe(description);
-var updateListItemInputSchema = z44.union([
-  z44.object({
-    item_id: z44.string().min(1).describe("ID of the Slack list item to update."),
+var updateListItemInputSchema = z47.union([
+  z47.object({
+    item_id: z47.string().min(1).describe("ID of the Slack list item to update."),
     completed: booleanInput3("Optional completion status update."),
-    title: z44.string().min(1).describe("Optional new item title.").optional()
+    title: z47.string().min(1).describe("Optional new item title.").optional()
   }),
-  z44.object({
-    item_id: z44.string().min(1).describe("ID of the Slack list item to update."),
+  z47.object({
+    item_id: z47.string().min(1).describe("ID of the Slack list item to update."),
     completed: booleanInput3("Optional completion status update.").optional(),
-    title: z44.string().min(1).describe("Optional new item title.")
+    title: z47.string().min(1).describe("Optional new item title.")
   })
 ]);
 function createSlackListUpdateItemTool(state) {
@@ -10381,7 +10892,7 @@ async function checkSlackChannelReadAccess(args) {
 }
 
 // src/chat/slack/tools/thread-read.ts
-import { z as z45 } from "zod";
+import { z as z48 } from "zod";
 
 // src/chat/slack/tools/slack-message-url.ts
 var SLACK_HOST_PATTERN = /^[a-z0-9-]+\.slack(?:-gov)?\.com$/;
@@ -10559,8 +11070,8 @@ function createSlackThreadReadTool(context, deps = {}) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z45.object({
-      url: z45.string().min(1).describe(
+    inputSchema: z48.object({
+      url: z48.string().min(1).describe(
         "Slack message archive URL, e.g. https://workspace.slack.com/archives/C123/p1700000000123456"
       ).optional(),
       channel_id: slackChannelIdParam(
@@ -10569,8 +11080,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: z45.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
-      max_pages: z45.coerce.number().int().min(1).max(10).describe("Maximum number of Slack API pages to traverse.").optional()
+      limit: z48.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
+      max_pages: z48.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 }) => {
@@ -10798,10 +11309,10 @@ async function searchSlackUsers(options) {
 }
 
 // src/chat/slack/tools/user-lookup.ts
-import { z as z46 } from "zod";
-var booleanInput4 = (description) => z46.preprocess(
+import { z as z49 } from "zod";
+var booleanInput4 = (description) => z49.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z46.boolean()
+  z49.boolean()
 ).describe(description);
 function explicitUserLookupError(error) {
   if (error.apiError === "user_not_found") {
@@ -10830,20 +11341,20 @@ function createSlackUserLookupTool() {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z46.object({
+    inputSchema: z49.object({
       user_id: slackUserIdParam(
         "Slack user ID to look up (e.g. U039RR91S). Mutually exclusive with email and query."
       ).optional(),
-      email: z46.string().min(3).describe(
+      email: z49.string().min(3).describe(
         "Email address to look up. Mutually exclusive with user_id and query."
       ).optional(),
-      query: z46.string().min(2).describe(
+      query: z49.string().min(2).describe(
         "Name to search for (matches against username, display name, real name). Mutually exclusive with user_id and email."
       ).optional(),
-      limit: z46.coerce.number().int().min(1).max(20).describe(
+      limit: z49.coerce.number().int().min(1).max(20).describe(
         "Maximum number of results to return for name search. Defaults to 10."
       ).optional(),
-      max_pages: z46.coerce.number().int().min(1).max(5).describe(
+      max_pages: z49.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(
@@ -10925,12 +11436,12 @@ function createSlackUserLookupTool() {
 }
 
 // src/chat/tools/system-time.ts
-import { z as z47 } from "zod";
+import { z as z50 } from "zod";
 var systemTimeOutputSchema = juniorToolOutputSchema.extend({
-  unix_ms: z47.number(),
-  iso_utc: z47.string(),
-  iso_local: z47.string(),
-  timezone_offset_minutes: z47.number()
+  unix_ms: z50.number(),
+  iso_utc: z50.string(),
+  iso_local: z50.string(),
+  timezone_offset_minutes: z50.number()
 });
 function createSystemTimeTool() {
   return zodTool({
@@ -10941,7 +11452,7 @@ function createSystemTimeTool() {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z47.object({}),
+    inputSchema: z50.object({}),
     outputSchema: systemTimeOutputSchema,
     privateTraceResult: (result) => ({
       unix_ms: result.unix_ms,
@@ -10965,7 +11476,7 @@ function createSystemTimeTool() {
 }
 
 // src/chat/tools/query-conversation-events.ts
-import { z as z48 } from "zod";
+import { z as z51 } from "zod";
 var DEFAULT_LIMIT3 = 25;
 var MAX_LIMIT = 100;
 var MAX_EVENT_DATA_BYTES = 4e3;
@@ -10976,28 +11487,28 @@ var CONVERSATION_EVENTS_TOOL_SOURCE = {
   id: "conversation-events",
   description: "Inspect Junior's durable conversation event log for debugging runtime behavior."
 };
-var knownEventTypeSchema = z48.enum(KNOWN_CONVERSATION_EVENT_TYPES);
-var projectedEventSchema = z48.object({
-  seq: z48.number().int().nonnegative().describe("Stable event position; use it for pagination bounds."),
-  history_version: z48.number().int().nonnegative().describe(
+var knownEventTypeSchema = z51.enum(KNOWN_CONVERSATION_EVENT_TYPES);
+var projectedEventSchema = z51.object({
+  seq: z51.number().int().nonnegative().describe("Stable event position; use it for pagination bounds."),
+  history_version: z51.number().int().nonnegative().describe(
     "Model-history generation. It increments when handoff or compaction replaces active model context."
   ),
-  created_at: z48.iso.datetime().describe("When the event was recorded."),
-  idempotency_key: z48.string().min(1).optional().describe("Retry-stable event identity, when one was assigned."),
-  data: z48.record(z48.string(), z48.unknown()).describe(
+  created_at: z51.iso.datetime().describe("When the event was recorded."),
+  idempotency_key: z51.string().min(1).optional().describe("Retry-stable event identity, when one was assigned."),
+  data: z51.record(z51.string(), z51.unknown()).describe(
     "Event data. Oversized payloads are replaced by identifying fields, payload_omitted, and payload_json_bytes."
   )
 }).strict();
 var queryConversationEventsOutputSchema = juniorToolOutputSchema.extend({
-  conversation_id: z48.string().min(1),
-  events: z48.array(projectedEventSchema),
-  has_older: z48.boolean().describe(
+  conversation_id: z51.string().min(1),
+  events: z51.array(projectedEventSchema),
+  has_older: z51.boolean().describe(
     "Whether matching events exist before this page; request them with before_seq set to the first returned seq."
   ),
-  has_newer: z48.boolean().describe(
+  has_newer: z51.boolean().describe(
     "Whether matching events exist after this page; request them with after_seq set to the last returned seq."
   ),
-  omitted_event_count: z48.number().int().nonnegative().optional().describe(
+  omitted_event_count: z51.number().int().nonnegative().optional().describe(
     "Fetched events omitted to keep this response bounded. Continue with the pagination cursor for the omitted direction."
   )
 });
@@ -11012,20 +11523,20 @@ function createQueryConversationEventsTool(context) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z48.object({
-      conversation_id: z48.string().trim().min(1).describe(
+    inputSchema: z51.object({
+      conversation_id: z51.string().trim().min(1).describe(
         "Conversation ID to inspect, such as slack:{channelId}:{threadTs} or a child conversation id."
       ),
-      after_seq: z48.number().int().nonnegative().nullable().describe(
+      after_seq: z51.number().int().nonnegative().nullable().describe(
         "Exclusive lower bound on event seq. When set, returns the next newer page in ascending order."
       ).optional(),
-      before_seq: z48.number().int().nonnegative().nullable().describe(
+      before_seq: z51.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: z48.number().int().min(1).max(MAX_LIMIT).nullable().describe(
+      limit: z51.number().int().min(1).max(MAX_LIMIT).nullable().describe(
         `Maximum events to return. Defaults to ${DEFAULT_LIMIT3}; max ${MAX_LIMIT}.`
       ).optional(),
-      types: z48.array(knownEventTypeSchema).min(1).nullable().describe(
+      types: z51.array(knownEventTypeSchema).min(1).nullable().describe(
         "Optional event-type filter. Omit to return every durable event type."
       ).optional()
     }).strict(),
@@ -11273,10 +11784,10 @@ function stripReplacementHistoryField(value) {
 }
 
 // src/chat/tools/handoff/tool.ts
-import { z as z49 } from "zod";
+import { z as z52 } from "zod";
 var HANDOFF_TOOL_NAME = "handoff";
 function createHandoffTool(handoff) {
-  const profileSchema = z49.enum(handoff.profiles);
+  const profileSchema = z52.enum(handoff.profiles);
   const handoffResultSchema = juniorToolOutputSchema.extend({
     model_profile: modelProfileSchema
   });
@@ -11290,7 +11801,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: z49.object({
+    inputSchema: z52.object({
       profile: profileSchema.describe("Target execution profile")
     }).strict(),
     outputSchema: handoffResultSchema,
@@ -11311,7 +11822,7 @@ function createHandoffTool(handoff) {
 }
 
 // src/chat/tools/web/fetch-tool.ts
-import { z as z50 } from "zod";
+import { z as z53 } from "zod";
 
 // src/chat/tools/web/constants.ts
 var USER_AGENT = "junior-bot/0.1";
@@ -11754,9 +12265,9 @@ function createWebFetchTool(hooks, options = {}) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z50.object({
-      url: z50.string().min(1).describe("HTTP(S) URL to fetch."),
-      max_chars: z50.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
+    inputSchema: z53.object({
+      url: z53.string().min(1).describe("HTTP(S) URL to fetch."),
+      max_chars: z53.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 }) => {
@@ -11801,7 +12312,7 @@ function createWebFetchTool(hooks, options = {}) {
 }
 
 // src/chat/tools/web/search.ts
-import { z as z51 } from "zod";
+import { z as z54 } from "zod";
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
 var SEARCH_TIMEOUT_MS = 6e4;
@@ -11843,9 +12354,9 @@ function createWebSearchTool(modelId, override) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z51.object({
-      query: z51.string().min(1).max(500).describe("Search query."),
-      max_results: z51.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
+    inputSchema: z54.object({
+      query: z54.string().min(1).max(500).describe("Search query."),
+      max_results: z54.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ query, max_results }) => {
@@ -11884,7 +12395,7 @@ function createWebSearchTool(modelId, override) {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { z as z52 } from "zod";
+import { z as z55 } from "zod";
 function createWriteFileTool() {
   return zodTool({
     annotations: {
@@ -11895,9 +12406,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: z52.object({
-      path: z52.string().min(1).describe("Path to write in the sandbox workspace."),
-      content: z52.string().describe("UTF-8 file content to write.")
+    inputSchema: z55.object({
+      path: z55.string().min(1).describe("Path to write in the sandbox workspace."),
+      content: z55.string().describe("UTF-8 file content to write.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async () => {
@@ -11944,15 +12455,7 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
   const canSendFilesToActiveConversation = Boolean(
     slackContext && slackSourceCapabilities?.canSendFiles
   );
-  const resourceEventCatalog = Object.fromEntries(
-    canRouteResourceEvents() ? getPlugins().flatMap((plugin) => {
-      const registration = plugin.resourceEvents;
-      if (!registration || registration.isEnabled?.() === false) {
-        return [];
-      }
-      return [[plugin.manifest.name, registration]];
-    }) : []
-  );
+  const resourceEventCatalog = getResourceEventCatalog();
   const tools = {
     ...options.includeLoadSkill === false ? {} : {
       loadSkill: createLoadSkillTool(availableSkills, {
@@ -11976,7 +12479,8 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
       canSendFilesToActiveConversation
     }),
     ...createResourceEventTools(context, resourceEventCatalog),
-    ...createEventTaskTools(context, resourceEventCatalog)
+    ...createEventTaskTools(context, resourceEventCatalog),
+    ...createScheduledTaskTools(context)
   };
   if (context.conversationId) {
     tools.queryConversationEvents = createQueryConversationEventsTool(context);
@@ -12278,11 +12782,11 @@ function replaceGeneratedTextContent(content, text) {
     ...withoutFirstGeneratedTextContent(content)
   ];
 }
-function isRecord4(value) {
+function isRecord3(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function hasContinuation(value) {
-  return isRecord4(value) && isRecord4(value.continuation);
+  return isRecord3(value) && isRecord3(value.continuation);
 }
 function stringField(record, key) {
   const value = record[key];
@@ -12297,7 +12801,7 @@ function stringListField(record, key) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
 function accountText(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord3(value)) {
     return void 0;
   }
   const label = stringField(value, "label") || stringField(value, "id");
@@ -12308,7 +12812,7 @@ function accountText(value) {
   return id && id !== label ? `${label} (${id})` : label;
 }
 function upstreamPermissionDeniedText(value) {
-  if (!isRecord4(value) || !isRecord4(value.permission_denied)) {
+  if (!isRecord3(value) || !isRecord3(value.permission_denied)) {
     return void 0;
   }
   const signal = value.permission_denied;
@@ -12323,7 +12827,7 @@ function upstreamPermissionDeniedText(value) {
   if (!provider || !message || !upstreamHost || !upstreamPath || !status) {
     return void 0;
   }
-  const grant = isRecord4(signal.grant) ? signal.grant : {};
+  const grant = isRecord3(signal.grant) ? signal.grant : {};
   const grantName = stringField(grant, "name");
   const grantAccess = stringField(grant, "access");
   const grantReason = stringField(grant, "reason");
@@ -12947,7 +13451,7 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, conv
 }
 
 // src/chat/tools/execute-tool.ts
-import { z as z53 } from "zod";
+import { z as z56 } from "zod";
 var EXECUTE_TOOL_NAME = "executeTool";
 function createExecuteToolTool() {
   return zodTool({
@@ -12959,11 +13463,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: z53.object({
-      tool_name: z53.string().min(1).describe(
+    inputSchema: z56.object({
+      tool_name: z56.string().min(1).describe(
         "Exact catalog tool_name returned by searchTools or a tool-result execution hint."
       ),
-      arguments: z53.record(z53.string(), z53.unknown()).describe(
+      arguments: z56.record(z56.string(), z56.unknown()).describe(
         'Arguments matching the selected catalog tool schema, for example { "query": "..." }.'
       ).optional()
     }).strict(),
@@ -13003,34 +13507,34 @@ function planToolExposure(tools) {
 }
 
 // src/chat/tools/search-tools.ts
-import { z as z54 } from "zod";
+import { z as z57 } from "zod";
 var SEARCH_TOOLS_NAME = "searchTools";
 var DEFAULT_MAX_RESULTS2 = 5;
 var MAX_RESULTS3 = 20;
 var MODEL_VISIBLE_DESCRIPTION_CAP = 180;
-var searchToolsSourceSchema = z54.object({
-  id: z54.string(),
-  description: z54.string()
+var searchToolsSourceSchema = z57.object({
+  id: z57.string(),
+  description: z57.string()
 }).strict();
-var searchToolsToolSchema = z54.object({
-  tool_name: z54.string(),
-  description: z54.string(),
-  exposure: z54.enum(["direct", "deferred", "modelOnly", "hidden"]),
-  source: z54.string().optional(),
-  input_schema: z54.unknown(),
-  call_notes: z54.array(z54.string()),
-  annotations: z54.record(z54.string(), z54.unknown())
+var searchToolsToolSchema = z57.object({
+  tool_name: z57.string(),
+  description: z57.string(),
+  exposure: z57.enum(["direct", "deferred", "modelOnly", "hidden"]),
+  source: z57.string().optional(),
+  input_schema: z57.unknown(),
+  call_notes: z57.array(z57.string()),
+  annotations: z57.record(z57.string(), z57.unknown())
 }).strict();
 var searchToolsOutputSchema = juniorToolOutputSchema.extend({
-  query: z54.string().nullable(),
-  source: z54.string().nullable(),
-  sources: z54.array(searchToolsSourceSchema),
-  total_catalog_tools: z54.number().int().nonnegative(),
-  total_eligible_tools: z54.number().int().nonnegative(),
-  total_matches: z54.number().int().nonnegative(),
-  returned_tools: z54.number().int().nonnegative(),
-  execution_tool: z54.literal("executeTool"),
-  tools: z54.array(searchToolsToolSchema)
+  query: z57.string().nullable(),
+  source: z57.string().nullable(),
+  sources: z57.array(searchToolsSourceSchema),
+  total_catalog_tools: z57.number().int().nonnegative(),
+  total_eligible_tools: z57.number().int().nonnegative(),
+  total_matches: z57.number().int().nonnegative(),
+  returned_tools: z57.number().int().nonnegative(),
+  execution_tool: z57.literal("executeTool"),
+  tools: z57.array(searchToolsToolSchema)
 }).strict();
 function normalize2(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]+/g, " ").trim();
@@ -13145,14 +13649,14 @@ function createSearchToolsTool(catalogTools) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z54.object({
-      query: z54.string().nullable().describe(
+    inputSchema: z57.object({
+      query: z57.string().nullable().describe(
         "Optional search terms describing the tool, owner, action, or arguments needed. Empty string lists catalog tools."
       ).optional(),
-      source: z54.string().nullable().describe(
+      source: z57.string().nullable().describe(
         "Optional source id to search within, such as a plugin source returned in sources."
       ).optional(),
-      max_results: z54.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
+      max_results: z57.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
     }).strict(),
     outputSchema: searchToolsOutputSchema,
     privateTraceResult: (result) => ({
@@ -14397,7 +14901,7 @@ function createPluginEgress(deps) {
 }
 
 // src/chat/services/guardian-action-review.ts
-import { z as z55 } from "zod";
+import { z as z58 } from "zod";
 
 // src/chat/services/guardian-action-policy.ts
 var GUARDIAN_ACTION_POLICY = `You are judging one planned Junior agent action.
@@ -14463,17 +14967,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 = z55.object({
-  decision: z55.enum(["allow", "ask", "deny"]),
-  reason: z55.string().trim().min(1).max(500),
-  riskLevel: z55.enum(["low", "medium", "high", "critical"]),
-  userAuthorization: z55.enum(["high", "medium", "low", "unknown"])
+var guardianDecisionSchema = z58.object({
+  decision: z58.enum(["allow", "ask", "deny"]),
+  reason: z58.string().trim().min(1).max(500),
+  riskLevel: z58.enum(["low", "medium", "high", "critical"]),
+  userAuthorization: z58.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(z55.json().parse(proposal), null, 2);
+  const proposalJson = JSON.stringify(z58.json().parse(proposal), null, 2);
   if (proposalJson.length > MAX_PROPOSAL_CHARS) {
     throw new Error(
       `Guardian action proposal exceeds ${MAX_PROPOSAL_CHARS} characters.`
@@ -16852,7 +17356,7 @@ export {
   cancelSubscriptions,
   findMatchingResourceEventSubscriptions,
   deliverResourceEventSubscription,
-  findMatchingEventTasks,
+  sanitizeScheduledTaskPrincipal,
   listThreadReplies,
   renderSlackLegacyAttachmentText,
   appendSlackLegacyAttachmentText,