@sentry/junior 0.137.0 → 0.139.0

package/dist/{chunk-KJ4HGRHN.js → chunk-ZYQSPQYR.js}

@@ -1,42 +1,55 @@
+import {
+  AgentInvocationBusyError,
+  AgentInvocationLimitError,
+  AuthPausePersistenceError,
+  AuthorizationFlowDisabledError,
+  AuthorizationPauseError,
+  PluginCredentialFailureError,
+  agentNameSchema,
+  createPluginAuthOrchestration
+} from "./chunk-WZH4JV7R.js";
 import {
   authorizationId
 } from "./chunk-DIB4GX3G.js";
 import {
   McpProviderError,
   McpToolError,
-  RetryableDeliveryError,
-  actorFromRouting,
-  addReactionToMessage,
-  assertRunRoutingConsistency,
   createMcpOAuthClientProvider,
   createUserTokenStore,
   deleteMcpAuthSession,
-  deliverOAuthAuthorization,
-  formatProviderLabel,
   getMcpAuthSession,
   getMcpAwareErrorType,
   getMcpAwareTelemetryMessage,
   getMcpProviderErrorAttributes,
-  getSlackMessagePermalink,
   hasEgressCredentialHooks,
   issuePluginCredential,
   issueProviderCredentialLease,
   onPluginEgressResponse,
   patchMcpAuthSession,
-  resolveBaseUrl,
   selectPluginGrant,
-  startOAuthFlow,
+  toMcpProviderError
+} from "./chunk-ZQCGQMF2.js";
+import {
+  RetryableDeliveryError,
+  actorFromRouting,
+  assertRunRoutingConsistency,
+  isAgentRunFeatureDisabled,
   surfaceFromRouting,
-  toMcpProviderError,
-  toolInvocationDestination,
+  toolInvocationDestination
+} from "./chunk-R776HKPK.js";
+import {
+  addReactionToMessage,
+  deliverOAuthAuthorization,
+  formatProviderLabel,
+  getSlackMessagePermalink,
+  resolveBaseUrl,
   uploadFilesToConversation
-} from "./chunk-EWDSB24B.js";
+} from "./chunk-U27DSXKB.js";
 import {
   AGENTS_REMOVAL_NOTICE,
   AGENTS_REPLACEMENT_NOTICE,
   CooperativeTurnYieldError,
   DEFAULT_SEARCH_COMMAND_TIMEOUT_MS,
-  JUNIOR_THREAD_STATE_TTL_MS,
   MAX_TEXT_CHARS,
   NO_REPLY_MARKER,
   RIPGREP_EXCLUDED_GLOBS,
@@ -98,13 +111,19 @@ import {
   trimTrailingAssistantMessages,
   truncateText,
   updateConversationStats
-} from "./chunk-POBSY47Q.js";
+} from "./chunk-PJW6U46K.js";
+import {
+  JUNIOR_THREAD_STATE_TTL_MS
+} from "./chunk-3Y47VMHV.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
   sandboxEgressCredentialContextSchema,
   sandboxEgressCredentialLeaseSchema
-} from "./chunk-EPBBYMNE.js";
+} from "./chunk-HUO3UTAQ.js";
+import {
+  isExperimentalFeatureEnabled
+} from "./chunk-5IDFPCON.js";
 import {
   bindSandboxFileSystem,
   buildCommandScript,
@@ -124,7 +143,7 @@ import {
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-UOXATPSI.js";
+} from "./chunk-G52UXKGO.js";
 import {
   SCHEDULED_TASK_SYSTEM_ACTOR,
   compactEventTask,
@@ -155,10 +174,10 @@ import {
   resolveLocalScheduleAtMs,
   saveEventTask,
   writableEventTask
-} from "./chunk-K2NCQJKH.js";
+} from "./chunk-DW4PMHNW.js";
 import {
   parseSlackThreadId
-} from "./chunk-YRPC6MJY.js";
+} from "./chunk-MXVD2BDS.js";
 import {
   ToolInputError,
   addAgentTurnUsage,
@@ -168,21 +187,23 @@ import {
   privateTraceResultAttributes
 } from "./chunk-UIE3R5XU.js";
 import {
-  SlackActionError,
   createPluginHookRunner,
-  downloadPrivateSlackFile,
-  getFilePermalink,
   getPluginSystemPromptContributions,
   getPluginTools,
   getPluginUserPromptContributions,
-  getSlackClient,
   getSlackToolContext,
+  readActorIdentity,
+  resolveChannelCapabilities
+} from "./chunk-IIESAYDL.js";
+import {
+  SlackActionError,
+  downloadPrivateSlackFile,
+  getFilePermalink,
+  getSlackClient,
   isConversationScopedChannel,
   normalizeSlackConversationId,
-  readActorIdentity,
-  resolveChannelCapabilities,
   withSlackRetries
-} from "./chunk-WPPXIAFB.js";
+} from "./chunk-6SU2DT27.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
@@ -193,17 +214,19 @@ import {
   instructionActors,
   instructionProvenanceFor,
   sameActorIdentity
-} from "./chunk-ZFS67WIR.js";
+} from "./chunk-QTBKPZDA.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
   SANDBOX_WORKSPACE_ROOT,
-  getStateAdapter,
   sandboxSkillDir,
   sandboxSkillFile,
   sandboxSkillPathResolution,
   sleep
-} from "./chunk-5G34IEK2.js";
+} from "./chunk-EM225ITJ.js";
+import {
+  getStateAdapter
+} from "./chunk-MXTVUV3I.js";
 import {
   ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
@@ -237,7 +260,7 @@ import {
   resolveGatewayCredential,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-UG6ZYPBI.js";
+} from "./chunk-75I3UBIL.js";
 import {
   canExposeConversationPayload,
   resolveConversationPrivacy,
@@ -247,16 +270,16 @@ import {
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes
-} from "./chunk-YNFERGKP.js";
+} from "./chunk-YGZ2OLXL.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-3Q342EJJ.js";
+} from "./chunk-GWQSZT4C.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-36EG34YI.js";
+} from "./chunk-6OHTDR4F.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -264,10 +287,10 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-BZAMASJP.js";
+} from "./chunk-CXH25EL4.js";
 import {
   credentialUserSubjectId
-} from "./chunk-77VDLF3Z.js";
+} from "./chunk-RUIXF3YQ.js";
 import {
   isUserActor
 } from "./chunk-HZF5P5UN.js";
@@ -293,7 +316,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-T6Z5S6PQ.js";
+} from "./chunk-2ECYPYKP.js";
 import {
   startInactiveSpan,
   withActiveSpan
@@ -1238,47 +1261,6 @@ function toPiReasoningLevel(level) {
   }
 }
 
-// src/chat/services/auth-pause.ts
-var AuthorizationPauseError = class extends Error {
-  disposition;
-  kind;
-  provider;
-  providerDisplayName;
-  requestText;
-  constructor(kind, provider, providerDisplayName, disposition, requestText) {
-    super(
-      kind === "mcp" ? `MCP authorization started for ${provider}` : `Plugin authorization started for ${provider}`
-    );
-    this.name = kind === "mcp" ? "McpAuthorizationPauseError" : "PluginAuthorizationPauseError";
-    this.disposition = disposition;
-    this.kind = kind;
-    this.provider = provider;
-    this.providerDisplayName = providerDisplayName;
-    this.requestText = requestText;
-  }
-};
-var AuthPausePersistenceError = class extends Error {
-  constructor(conversationId, turnId, cause) {
-    super(
-      `Failed to persist auth pause for conversation=${conversationId} turn=${turnId}`,
-      cause === void 0 ? void 0 : { cause }
-    );
-    this.name = "AuthPausePersistenceError";
-  }
-};
-var AuthorizationFlowDisabledError = class extends Error {
-  kind;
-  provider;
-  constructor(kind, provider) {
-    super(
-      `Authorization is required for ${provider}, but this turn cannot start an authorization flow.`
-    );
-    this.name = "AuthorizationFlowDisabledError";
-    this.kind = kind;
-    this.provider = provider;
-  }
-};
-
 // src/chat/conversations/destination-visibility.ts
 async function resolveDestinationVisibility(args) {
   if (args.visibility) {
@@ -7560,6 +7542,67 @@ function createReportProgressTool() {
   });
 }
 
+// src/chat/tools/runtime/spawn-agent.ts
+import { z as z17 } from "zod";
+var spawnAgentOutputSchema = juniorToolOutputSchema.extend({
+  invocation_id: z17.string().min(1)
+});
+function createSpawnAgentTool(spawnAgent) {
+  return zodTool({
+    description: "Start an asynchronous child agent on a delegated task. Give it a name to reuse the same child agent and its history on later calls; omit the name for a one-off agent. This call confirms durable scheduling, not task completion.",
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    inputSchema: z17.object({
+      task: z17.string().trim().min(1).describe("Task for the child agent"),
+      name: agentNameSchema.nullable().optional().describe("Stable child-agent name, or omit for a one-off agent"),
+      reasoning_level: z17.enum(TURN_REASONING_LEVELS).nullable().optional().describe(
+        "Optional reasoning level for this delegated task only"
+      )
+    }).strict(),
+    outputSchema: spawnAgentOutputSchema,
+    execute: async (input, options) => {
+      if (!options.toolCallId) {
+        throw new ToolInputError("spawnAgent requires an active tool call ID");
+      }
+      let result;
+      try {
+        result = await spawnAgent(
+          {
+            task: input.task,
+            ...input.name ? { name: input.name } : {},
+            ...input.reasoning_level ? { reasoningLevel: input.reasoning_level } : {}
+          },
+          {
+            ...options.signal ? { signal: options.signal } : {},
+            toolCallId: options.toolCallId
+          }
+        );
+      } catch (error) {
+        if (error instanceof AgentInvocationBusyError) {
+          throw new ToolInputError(
+            `${error.message}. Wait for it to finish or use a different name.`,
+            { cause: error }
+          );
+        }
+        if (error instanceof AgentInvocationLimitError) {
+          throw new ToolInputError(
+            `${error.message}. Wait for active children to finish before spawning more.`,
+            { cause: error }
+          );
+        }
+        throw error;
+      }
+      return {
+        invocation_id: result.invocationId
+      };
+    }
+  });
+}
+
 // src/chat/resource-events/tool-support.ts
 var STOP_WATCHING_TOOL_NAME = "stopWatchingResources";
 var RESOURCE_WATCH_TOOL_SOURCE = {
@@ -7595,7 +7638,7 @@ function isSlackThreadConversationId(conversationId) {
 }
 
 // src/chat/tools/list-resource-event-subscriptions.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/chat/resource-events/store.ts
 import { createHash } from "crypto";
@@ -7603,29 +7646,29 @@ import {
   destinationSchema,
   resourceEventTypeSchema
 } from "@sentry/junior-plugin-api";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var RESOURCE_EVENT_PREFIX = "junior:resource_event_subscription:v3";
 var INDEX_LOCK_TTL_MS = 1e4;
 var SUBSCRIPTION_LOCK_TTL_MS = 1e4;
 var SUBSCRIPTION_LOCK_WAIT_MS = 1e4;
 var SUBSCRIPTION_LOCK_RETRY_MS = 25;
 var SUBSCRIPTION_LOCK_HEARTBEAT_MS = 3e3;
-var subscriptionStatusSchema = 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(),
+var subscriptionStatusSchema = z18.enum(["active", "cancelled", "completed"]);
+var subscriptionIdIndexSchema = z18.array(z18.string().min(1));
+var subscriptionSchema = z18.object({
+  conversationId: z18.string().min(1),
+  createdAtMs: z18.number().finite(),
   destination: destinationSchema,
-  events: 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),
+  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),
   status: subscriptionStatusSchema,
-  updatedAtMs: z17.number().finite()
+  updatedAtMs: z18.number().finite()
 }).strict();
 function digest(value) {
   return createHash("sha256").update(value).digest("hex").slice(0, 32);
@@ -7995,17 +8038,17 @@ async function deliverResourceEventSubscription(input) {
 }
 
 // src/chat/tools/list-resource-event-subscriptions.ts
-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()
+var listedResourceWatchSchema = z19.object({
+  id: z19.string().min(1),
+  label: z19.string().min(1),
+  identifier: z19.string().min(1),
+  namespace: z19.string().min(1),
+  resourceType: z19.string().min(1),
+  events: z19.array(z19.string().min(1)).min(1),
+  intent: z19.string().min(1),
+  expiresAtMs: z19.number().finite()
 }).strict();
-var resultDataSchema = z18.object({ subscriptions: z18.array(listedResourceWatchSchema) }).strict();
+var resultDataSchema = z19.object({ subscriptions: z19.array(listedResourceWatchSchema) }).strict();
 var outputSchema = juniorToolOutputSchema.extend({
   ...resultDataSchema.shape
 }).strict();
@@ -8020,7 +8063,7 @@ function createListResourceEventSubscriptionsTool(context) {
     description: "List active resource event subscriptions for the current conversation.",
     exposure: "deferred",
     source: RESOURCE_WATCH_TOOL_SOURCE,
-    inputSchema: z18.object({}).strict(),
+    inputSchema: z19.object({}).strict(),
     outputSchema,
     async execute() {
       const conversationId = requireResourceWatchConversation(context);
@@ -8047,20 +8090,20 @@ function createListResourceEventSubscriptionsTool(context) {
 }
 
 // src/chat/tools/search-resource-event-types.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var DEFAULT_SEARCH_RESULTS = 10;
 var MAX_SEARCH_RESULTS = 20;
-var searchedResourceTypeSchema = z19.object({
-  namespace: z19.string(),
-  type: z19.string(),
-  supportedEvents: z19.array(z19.string()),
-  suggestedEvents: z19.array(z19.string()).optional()
+var searchedResourceTypeSchema = z20.object({
+  namespace: z20.string(),
+  type: z20.string(),
+  supportedEvents: z20.array(z20.string()),
+  suggestedEvents: z20.array(z20.string()).optional()
 }).strict();
 var outputSchema2 = juniorToolOutputSchema.extend({
-  query: z19.string().nullable(),
-  namespace: z19.string().nullable(),
-  totalMatches: z19.number().int().nonnegative(),
-  resourceTypes: z19.array(searchedResourceTypeSchema)
+  query: z20.string().nullable(),
+  namespace: z20.string().nullable(),
+  totalMatches: z20.number().int().nonnegative(),
+  resourceTypes: z20.array(searchedResourceTypeSchema)
 }).strict();
 function normalizeSearchText(value) {
   return value.toLowerCase().replace(/[^a-z0-9_.-]+/g, " ").trim();
@@ -8086,12 +8129,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: z19.object({
-      query: z19.string().nullable().describe(
+    inputSchema: z20.object({
+      query: z20.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: z19.number().int().min(1).max(MAX_SEARCH_RESULTS).nullable().describe("Maximum matching resource types to return.").optional()
+      maxResults: z20.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 }) {
@@ -8129,10 +8172,10 @@ function createSearchResourceEventTypesTool(catalog) {
 }
 
 // src/chat/tools/stop-watching-resources.ts
-import { z as z20 } from "zod";
-var resultDataSchema2 = z20.object({
-  watching_status: z20.literal("stopped"),
-  stoppedIds: z20.array(z20.string().min(1))
+import { z as z21 } from "zod";
+var resultDataSchema2 = z21.object({
+  watching_status: z21.literal("stopped"),
+  stoppedIds: z21.array(z21.string().min(1))
 }).strict();
 var outputSchema3 = juniorToolOutputSchema.extend({
   ...resultDataSchema2.shape
@@ -8148,7 +8191,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: z20.object({ id: z20.string().min(1).nullable().optional() }).strict(),
+    inputSchema: z21.object({ id: z21.string().min(1).nullable().optional() }).strict(),
     outputSchema: outputSchema3,
     async execute({ id }) {
       const conversationId = requireResourceWatchConversation(context);
@@ -8183,26 +8226,26 @@ function createStopWatchingResourcesTool(context) {
 }
 
 // src/chat/tools/watch-resource-events.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var DEFAULT_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
 var MAX_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 function inputSchema(catalog) {
-  return z21.object({
-    identifier: z21.string().trim().min(1).describe("Plugin-defined resource identifier."),
+  return z22.object({
+    identifier: z22.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: z21.string().trim().min(1).max(500).describe("Human-readable resource label."),
-    events: z21.array(registeredEventTypeSchema(catalog)).min(1).describe(
+    label: z22.string().trim().min(1).max(500).describe("Human-readable resource label."),
+    events: z22.array(registeredEventTypeSchema(catalog)).min(1).describe(
       "High-signal event names to deliver to this conversation when they occur."
     ),
-    intent: z21.string().trim().min(1).max(4e3).describe(
+    intent: z22.string().trim().min(1).max(4e3).describe(
       "Concise reason this conversation wants these events, used when an event arrives."
     ),
-    ttlMs: z21.coerce.number().describe(
+    ttlMs: z22.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) => {
@@ -8222,19 +8265,19 @@ function inputSchema(catalog) {
     });
   });
 }
-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()
+var stopWatchingActionSchema = z22.object({
+  execution_tool: z22.literal("executeTool"),
+  execution_example: z22.object({
+    tool_name: z22.literal(STOP_WATCHING_TOOL_NAME),
+    arguments: z22.object({ id: z22.string().min(1) }).strict()
   }).strict()
 }).strict();
-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(),
+var resultDataSchema3 = z22.object({
+  id: z22.string().min(1),
+  subscription_status: z22.enum(["active", "cancelled", "completed"]),
+  identifier: z22.string().min(1),
+  events: z22.array(z22.string().min(1)).min(1),
+  expiresAtMs: z22.number().finite(),
   stop_watching: stopWatchingActionSchema
 }).strict();
 var outputSchema4 = juniorToolOutputSchema.extend({
@@ -8339,7 +8382,7 @@ function createResourceEventTools(context, catalog) {
 
 // src/chat/tools/create-event-task.ts
 import { createHash as createHash2 } from "crypto";
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 function buildEventTaskId(args) {
   const toolCallId = args.toolCallId?.trim();
   if (!toolCallId) {
@@ -8367,10 +8410,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: z22.object({
-      task: z22.string().trim().min(1).max(4e3),
+    inputSchema: z23.object({
+      task: z23.string().trim().min(1).max(4e3),
       trigger,
-      credentialMode: z22.enum(["creator", "system"]).nullable().describe(
+      credentialMode: z23.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(),
@@ -8431,7 +8474,7 @@ function createEventTaskTool(context, catalog) {
 }
 
 // src/chat/tools/delete-event-task.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 function createDeleteEventTaskTool(context, catalog) {
   return zodTool({
     approvalMode: "review",
@@ -8443,7 +8486,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: z23.object({ taskId: z23.string().min(1) }).strict(),
+    inputSchema: z24.object({ taskId: z24.string().min(1) }).strict(),
     outputSchema: eventTaskToolResultSchema,
     async execute({ taskId }) {
       const current = await writableEventTask(context, taskId);
@@ -8459,7 +8502,7 @@ function createDeleteEventTaskTool(context, catalog) {
 }
 
 // src/chat/tools/list-event-tasks.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var MAX_LISTED_EVENT_TASKS = 50;
 function createListEventTasksTool(context, catalog) {
   return zodTool({
@@ -8470,7 +8513,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: z24.object({}).strict(),
+    inputSchema: z25.object({}).strict(),
     outputSchema: eventTaskListToolResultSchema,
     async execute() {
       const { destination } = requireEventTaskSlackContext(context);
@@ -8485,7 +8528,7 @@ function createListEventTasksTool(context, catalog) {
 }
 
 // src/chat/tools/update-event-task.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 function changesEventTaskTrigger(current, next) {
   const currentEvents = [...current.events].sort();
   const nextEvents = [...next.events].sort();
@@ -8502,11 +8545,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: z25.object({
-      taskId: z25.string().min(1),
-      task: z25.string().trim().min(1).max(4e3).nullable().optional(),
+    inputSchema: z26.object({
+      taskId: z26.string().min(1),
+      task: z26.string().trim().min(1).max(4e3).nullable().optional(),
       trigger: registeredEventTaskTriggerSchema(catalog).nullable().optional(),
-      credentialMode: z25.enum(["system", "creator"]).nullable().describe(
+      credentialMode: z26.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(),
@@ -8580,16 +8623,16 @@ function createEventTaskTools(context, catalog) {
 }
 
 // src/chat/scheduled-tasks/tools/create.ts
-import { z as z28 } from "zod";
+import { z as z29 } 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(
+import { z as z27 } from "zod";
+var localDateSchema = z27.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Use a local date in YYYY-MM-DD format.");
+var localTimeSchema = z27.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "Use local time in HH:MM format.");
+var timezoneSchema = z27.string().min(1).max(80).describe(
   "IANA timezone, for example America/Los_Angeles. Omit or use null for the scheduler default."
 ).nullable().optional();
-var weekdaySchema = z26.enum([
+var weekdaySchema = z27.enum([
   "sunday",
   "monday",
   "tuesday",
@@ -8598,17 +8641,17 @@ var weekdaySchema = z26.enum([
   "friday",
   "saturday"
 ]);
-var oneOffScheduleIntentSchema = z26.object({
-  kind: z26.literal("one_off").describe("A schedule that runs once."),
+var oneOffScheduleIntentSchema = z27.object({
+  kind: z27.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"])
+  timing: z27.discriminatedUnion("type", [
+    z27.object({
+      type: z27.literal("after").describe("Run after a relative delay from the server clock."),
+      value: z27.number().int().positive().max(1e5),
+      unit: z27.enum(["second", "minute", "hour", "day", "week"])
     }).strict(),
-    z26.object({
-      type: z26.literal("at").describe("Run at an explicit local calendar date and time."),
+    z27.object({
+      type: z27.literal("at").describe("Run at an explicit local calendar date and time."),
       date: localDateSchema.describe(
         "Requested local calendar date in YYYY-MM-DD format."
       ),
@@ -8618,16 +8661,16 @@ var oneOffScheduleIntentSchema = z26.object({
     }).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(),
+var recurringScheduleIntentSchema = z27.object({
+  kind: z27.literal("recurring").describe("A repeating calendar schedule."),
+  frequency: z27.enum(["daily", "weekly", "monthly", "yearly"]).describe("Recurring tasks can run at most once per day."),
+  interval: z27.number().int().positive().max(365).describe("Repeat every N frequency units. Defaults to 1.").nullable().optional(),
   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(),
+  weekdays: z27.array(weekdaySchema).min(1).max(7).describe("Required for weekly schedules.").nullable().optional(),
+  day_of_month: z27.number().int().min(1).max(31).describe("Required for monthly and yearly schedules.").nullable().optional(),
+  month: z27.number().int().min(1).max(12).describe("Required for yearly schedules, where January is 1.").nullable().optional(),
   start_date: localDateSchema.describe(
     "Optional local calendar date that anchors the recurrence. Omit to start with the next matching occurrence."
   ).nullable().optional(),
@@ -8676,7 +8719,7 @@ var recurringScheduleIntentSchema = z26.object({
     });
   }
 });
-var scheduleIntentSchema = z26.union([
+var scheduleIntentSchema = z27.union([
   oneOffScheduleIntentSchema,
   recurringScheduleIntentSchema
 ]);
@@ -8836,7 +8879,7 @@ import { createHash as createHash3 } from "crypto";
 import {
   sourceSchema
 } from "@sentry/junior-plugin-api";
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 
 // src/chat/scheduled-tasks/identity.ts
 var SLACK_USER_ID_PATTERN = /^[UW][A-Z0-9]{5,}$/;
@@ -8873,30 +8916,30 @@ function sanitizeScheduledTaskPrincipal(principal) {
 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", "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"])
+var compactTaskResultSchema = z28.object({
+  id: z28.string(),
+  status: z28.enum(["active", "blocked", "deleted"]),
+  task: z28.string(),
+  schedule: z28.string(),
+  timezone: z28.string(),
+  recurrence: z28.unknown().nullable(),
+  next_run_at: z28.string().nullable(),
+  conversation_access: z28.object({
+    audience: z28.enum(["direct", "group", "channel"]),
+    visibility: z28.enum(["private", "public"])
   }).strict(),
-  credential_mode: z27.enum(["system", "creator"]),
-  last_run_at: z27.string().nullable(),
-  run_now_at: z27.string().nullable()
+  credential_mode: z28.enum(["system", "creator"]),
+  last_run_at: z28.string().nullable(),
+  run_now_at: z28.string().nullable()
 }).strict();
 var scheduleTaskToolResultSchema = juniorToolOutputSchema.extend({
-  target: z27.string(),
+  target: z28.string(),
   task: compactTaskResultSchema
 }).strict();
 var scheduleListToolResultSchema = juniorToolOutputSchema.extend({
-  target: z27.string(),
-  tasks: z27.array(compactTaskResultSchema),
-  truncated: z27.boolean()
+  target: z28.string(),
+  tasks: z28.array(compactTaskResultSchema),
+  truncated: z28.boolean()
 }).strict();
 function throwToolInputError(error) {
   throw new ToolInputError(error);
@@ -9056,12 +9099,12 @@ function createSlackScheduleCreateTaskTool(context) {
     },
     description: "Create a one-time or recurring Junior task in the active Slack conversation when the user asks Junior to do work later or repeatedly.",
     executionMode: "sequential",
-    inputSchema: z28.object({
-      task: z28.string().min(1).max(4e3),
+    inputSchema: z29.object({
+      task: z29.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(
+      credential_mode: z29.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(),
@@ -9148,7 +9191,7 @@ function createSlackScheduleCreateTaskTool(context) {
 }
 
 // src/chat/scheduled-tasks/tools/delete.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 function createSlackScheduleDeleteTaskTool(context) {
   return zodTool({
     annotations: {
@@ -9159,8 +9202,8 @@ function createSlackScheduleDeleteTaskTool(context) {
     },
     description: "Delete one scheduled Junior task from the active Slack conversation. Use only task IDs returned for this conversation. Do not delete schedules from threads, other channels, or another user's DM.",
     executionMode: "sequential",
-    inputSchema: z29.object({
-      task_id: z29.string().min(1).describe(
+    inputSchema: z30.object({
+      task_id: z30.string().min(1).describe(
         "ID of the task to delete. Must be from this active Slack conversation."
       )
     }),
@@ -9184,7 +9227,7 @@ function createSlackScheduleDeleteTaskTool(context) {
 }
 
 // src/chat/scheduled-tasks/tools/list.ts
-import { z as z30 } from "zod";
+import { z as z31 } 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.",
@@ -9194,7 +9237,7 @@ function createSlackScheduleListTasksTool(context) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z30.object({}),
+    inputSchema: z31.object({}),
     outputSchema: scheduleListToolResultSchema,
     execute: async () => {
       const destination = requireActiveConversation(context);
@@ -9215,7 +9258,7 @@ function createSlackScheduleListTasksTool(context) {
 }
 
 // src/chat/scheduled-tasks/tools/run-now.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 function createSlackScheduleRunTaskNowTool(context) {
   return zodTool({
     annotations: {
@@ -9226,8 +9269,8 @@ function createSlackScheduleRunTaskNowTool(context) {
     },
     description: "Queue an existing active scheduled Junior task to run as soon as possible, without changing its cadence. Use when the user asks to run an existing scheduled task now. Use only task IDs returned for this conversation.",
     executionMode: "sequential",
-    inputSchema: z31.object({
-      task_id: z31.string().min(1).describe(
+    inputSchema: z32.object({
+      task_id: z32.string().min(1).describe(
         "ID of the active task to run now. Must be from this active Slack conversation."
       )
     }),
@@ -9255,7 +9298,7 @@ function createSlackScheduleRunTaskNowTool(context) {
 }
 
 // src/chat/scheduled-tasks/tools/update.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 function createSlackScheduleUpdateTaskTool(context) {
   return zodTool({
     approvalMode: "review",
@@ -9267,18 +9310,18 @@ function createSlackScheduleUpdateTaskTool(context) {
     },
     description: "Edit, reschedule, unblock, 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(
+    inputSchema: z33.object({
+      task_id: z33.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(),
+      task: z33.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", "blocked"]).describe(
+      status: z33.enum(["active", "blocked"]).describe(
         "Set to active to clear a blocked task, or blocked when dispatch cannot continue."
       ).optional(),
-      credential_mode: z32.enum(["system", "creator"]).nullable().describe(
+      credential_mode: z33.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(),
@@ -9447,11 +9490,11 @@ async function listThreadReplies(input) {
 }
 
 // src/chat/slack/timestamp-param.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 function slackTimestampParam(description) {
-  return z33.preprocess(
+  return z34.preprocess(
     (value) => typeof value === "number" && Number.isFinite(value) ? String(value) : value,
-    z33.string().min(1)
+    z34.string().min(1)
   ).describe(description);
 }
 function optionalSlackTimestampParam(description) {
@@ -9482,10 +9525,10 @@ function parseRequiredSlackTimestampParam(field, value) {
 }
 
 // src/chat/slack/tools/channel-list-messages.ts
-import { z as z34 } from "zod";
-var booleanInput2 = (description) => z34.preprocess(
+import { z as z35 } from "zod";
+var booleanInput2 = (description) => z35.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z34.boolean()
+  z35.boolean()
 ).describe(description);
 function normalizeRangeTimestamp(field, value, targetChannelId) {
   if (value === void 0) {
@@ -9517,9 +9560,9 @@ function createSlackChannelListMessagesTool(context) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    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(),
+    inputSchema: z35.object({
+      limit: z35.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
+      cursor: z35.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
       oldest: optionalSlackTimestampParam(
         "Optional oldest message timestamp (Slack ts) for range filtering."
       ),
@@ -9529,7 +9572,7 @@ function createSlackChannelListMessagesTool(context) {
       inclusive: booleanInput2(
         "Whether oldest/latest bounds should be inclusive."
       ).optional(),
-      max_pages: z34.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
+      max_pages: z35.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({
@@ -9592,20 +9635,20 @@ function createSlackChannelListMessagesTool(context) {
 }
 
 // src/chat/slack/tools/conversation-search.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 var DEFAULT_LIMIT = 5;
 var conversationSearchOutputSchema = juniorToolOutputSchema.extend({
-  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()
+  query: z36.string(),
+  count: z36.number().int().nonnegative(),
+  threads: z36.array(
+    z36.object({
+      conversation_id: z36.string().min(1),
+      thread_ts: z36.string().min(1),
+      message_id: z36.string().min(1),
+      message_role: z36.enum(["assistant", "user"]),
+      message_timestamp: z36.string().datetime(),
+      excerpt: z36.string(),
+      permalink: z36.string().url().optional()
     }).strict()
   )
 });
@@ -9623,9 +9666,9 @@ function createSlackConversationSearchTool(scope, currentConversationId, deps =
       openWorldHint: false,
       readOnlyHint: true
     },
-    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()
+    inputSchema: z36.object({
+      query: z36.string().trim().min(1).max(200).describe("Words or a short phrase to find in prior conversations."),
+      limit: z36.number().int().min(1).max(10).describe("Maximum number of prior conversation threads to return.").nullable().optional()
     }),
     outputSchema: conversationSearchOutputSchema,
     execute: async ({ query, limit }) => {
@@ -9670,27 +9713,27 @@ function createSlackConversationSearchTool(scope, currentConversationId, deps =
 }
 
 // src/chat/slack/tools/public-search.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 var DEFAULT_LIMIT2 = 10;
-var optionalTimestampSchema = z36.preprocess(
+var optionalTimestampSchema = z37.preprocess(
   (value) => typeof value === "string" && value.trim() === "" ? void 0 : value,
-  z36.coerce.number().int().nonnegative().describe("Optional Unix timestamp bound.").optional()
+  z37.coerce.number().int().nonnegative().describe("Optional Unix timestamp bound.").optional()
 );
-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 searchMessageSchema = z37.object({
+  author_name: z37.string().optional(),
+  author_user_id: z37.string().optional(),
+  channel_id: z37.string().min(1),
+  channel_name: z37.string().optional(),
+  message_ts: z37.string().min(1),
+  content: z37.string(),
+  is_author_bot: z37.boolean().optional(),
+  permalink: z37.string().url()
 });
 var publicSearchOutputSchema = juniorToolOutputSchema.extend({
-  query: z36.string(),
-  count: z36.number().int().nonnegative(),
-  messages: z36.array(searchMessageSchema),
-  next_cursor: z36.string().optional()
+  query: z37.string(),
+  count: z37.number().int().nonnegative(),
+  messages: z37.array(searchMessageSchema),
+  next_cursor: z37.string().optional()
 });
 function normalizeMessage(value) {
   const parsed = searchMessageSchema.safeParse(value);
@@ -9717,8 +9760,8 @@ function createSlackPublicSearchTool(actionToken) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z36.object({
-      query: z36.string().trim().min(1).max(500).describe(
+    inputSchema: z37.object({
+      query: z37.string().trim().min(1).max(500).describe(
         "A focused Slack search query, including Slack search filters when useful."
       ),
       after: optionalTimestampSchema.describe(
@@ -9727,10 +9770,10 @@ function createSlackPublicSearchTool(actionToken) {
       before: optionalTimestampSchema.describe(
         "Optional Unix timestamp upper bound."
       ),
-      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()
+      cursor: z37.string().min(1).describe("Cursor for the next result page.").optional(),
+      limit: z37.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
+      sort: z37.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
+      sort_dir: z37.enum(["asc", "desc"]).describe("Sort direction.").optional()
     }),
     outputSchema: publicSearchOutputSchema,
     execute: async ({
@@ -9787,7 +9830,7 @@ function createSlackPublicSearchTool(actionToken) {
 }
 
 // src/chat/slack/tools/message-add-reaction.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 
 // src/chat/tools/idempotency.ts
 function stableSerialize(value) {
@@ -9817,8 +9860,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: z37.object({
-      emoji: z37.string().min(1).max(64).describe(
+    inputSchema: z38.object({
+      emoji: z38.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."
       )
     }),
@@ -9867,14 +9910,14 @@ function createSlackMessageAddReactionTool(context, state) {
 
 // src/chat/slack/tools/send-files.ts
 import { createHash as createHash4 } from "crypto";
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 var sendFilesResultSchema = juniorToolOutputSchema.extend({
-  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)
+  target: z39.string().min(1),
+  channel_id: z39.string().min(1),
+  deduplicated: z39.boolean().optional(),
+  file_count: z39.number().int().nonnegative(),
+  file_ids: z39.array(z39.string().min(1)).optional(),
+  thread_ts: z39.string().min(1)
 });
 function normalizeFiles(files) {
   return files.map((file) => ({
@@ -9904,8 +9947,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: z38.object({
-      files: z38.array(sandboxFileReferenceSchema).min(1).describe(
+    inputSchema: z39.object({
+      files: z39.array(sandboxFileReferenceSchema).min(1).describe(
         "One or more existing sandbox files. Objects returned by imageGenerate or webFetch can be passed unchanged."
       )
     }),
@@ -10337,7 +10380,7 @@ function storedCanvasUrl(state, canvasId) {
 }
 
 // src/chat/slack/tools/canvas/create.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 function createSlackCanvasCreateTool(context, state) {
   return zodTool({
     annotations: {
@@ -10347,9 +10390,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: z39.object({
-      title: z39.string().min(1).max(160).describe("Canvas title."),
-      markdown: z39.string().min(1).describe("Canvas markdown body content.")
+    inputSchema: z40.object({
+      title: z40.string().min(1).max(160).describe("Canvas title."),
+      markdown: z40.string().min(1).describe("Canvas markdown body content.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ title, markdown }) => {
@@ -10405,26 +10448,26 @@ function createSlackCanvasCreateTool(context, state) {
 }
 
 // src/chat/slack/tools/canvas/edit.ts
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 function prepareCanvasEditArguments(input) {
   return prepareTextReplacementArguments(input);
 }
-var editReplacementSchema2 = z40.object({
-  oldText: z40.string().min(1).describe(
+var editReplacementSchema2 = z41.object({
+  oldText: z41.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: z40.string().describe("Replacement Canvas markdown for this edit.")
+  newText: z41.string().describe("Replacement Canvas markdown for this edit.")
 });
 var slackCanvasEditOutputSchema = juniorToolOutputSchema.extend({
-  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()
+  canvas_id: z41.string().optional(),
+  title: z41.string().optional(),
+  permalink: z41.string().optional(),
+  diff: z41.string().optional(),
+  first_changed_line: z41.number().int().positive().optional(),
+  replacements: z41.number().int().nonnegative().optional(),
+  normalized_heading_count: z41.number().int().nonnegative().optional(),
+  summary: z41.string().optional(),
+  deduplicated: z41.boolean().optional()
 }).strict();
 function createSlackCanvasEditTool(state) {
   return zodTool({
@@ -10437,9 +10480,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: 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(
+    inputSchema: z41.object({
+      canvas: z41.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
+      edits: z41.array(editReplacementSchema2).min(1).describe(
         "Exact replacements matched against the current Canvas body, not incrementally."
       )
     }),
@@ -10496,18 +10539,18 @@ function createSlackCanvasEditTool(state) {
 }
 
 // src/chat/slack/tools/canvas/read.ts
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 var slackCanvasReadOutputSchema = juniorToolOutputSchema.extend({
-  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()
+  canvas_id: z42.string().optional(),
+  title: z42.string().optional(),
+  permalink: z42.string().optional(),
+  mimetype: z42.string().optional(),
+  filetype: z42.string().optional(),
+  original_byte_length: z42.number().int().nonnegative().optional(),
+  content: z42.string().optional(),
+  start_line: z42.number().int().positive().optional(),
+  end_line: z42.number().int().nonnegative().optional(),
+  total_lines: z42.number().int().nonnegative().optional()
 }).strict();
 function createSlackCanvasReadTool() {
   return zodTool({
@@ -10518,12 +10561,12 @@ function createSlackCanvasReadTool() {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z41.object({
-      canvas: z41.string().min(1).describe(
+    inputSchema: z42.object({
+      canvas: z42.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: 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()
+      offset: z42.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
+      limit: z42.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
     }),
     outputSchema: slackCanvasReadOutputSchema,
     execute: async ({ canvas, offset, limit }) => {
@@ -10559,7 +10602,7 @@ function createSlackCanvasReadTool() {
 }
 
 // src/chat/slack/tools/canvas/write.ts
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 function createSlackCanvasWriteTool(state) {
   return zodTool({
     annotations: {
@@ -10570,9 +10613,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: 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.")
+    inputSchema: z43.object({
+      canvas: z43.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
+      content: z43.string().describe("UTF-8 markdown content to write.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ canvas, content }) => {
@@ -10787,12 +10830,12 @@ async function updateListItem(input) {
 }
 
 // src/chat/slack/id-param.ts
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 function slackChannelIdParam(description) {
-  return z43.string().min(1).describe(description);
+  return z44.string().min(1).describe(description);
 }
 function slackUserIdParam(description) {
-  return z43.string().min(1).describe(description);
+  return z44.string().min(1).describe(description);
 }
 function parseRequiredSlackChannelIdParam(field, value) {
   const channelId = parseSlackChannelId(value);
@@ -10816,7 +10859,7 @@ function parseRequiredSlackUserIdParam(field, value) {
 }
 
 // src/chat/slack/tools/list/add-items.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 function createSlackListAddItemsTool(state) {
   return zodTool({
     annotations: {
@@ -10826,12 +10869,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: z44.object({
-      items: z44.array(z44.string().min(1)).min(1).max(25).describe("List item titles to create."),
+    inputSchema: z45.object({
+      items: z45.array(z45.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: z44.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
+      due_date: z45.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 }) => {
@@ -10879,7 +10922,7 @@ function createSlackListAddItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/create.ts
-import { z as z45 } from "zod";
+import { z as z46 } from "zod";
 function createSlackListCreateTool(state) {
   return zodTool({
     annotations: {
@@ -10889,8 +10932,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: z45.object({
-      name: z45.string().min(1).max(160).describe("Name for the new Slack list.")
+    inputSchema: z46.object({
+      name: z46.string().min(1).max(160).describe("Name for the new Slack list.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ name }) => {
@@ -10920,7 +10963,7 @@ function createSlackListCreateTool(state) {
 }
 
 // src/chat/slack/tools/list/get-items.ts
-import { z as z46 } from "zod";
+import { z as z47 } 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.",
@@ -10930,8 +10973,8 @@ function createSlackListGetItemsTool(state) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z46.object({
-      limit: z46.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
+    inputSchema: z47.object({
+      limit: z47.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ limit }) => {
@@ -10950,21 +10993,21 @@ function createSlackListGetItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/update-item.ts
-import { z as z47 } from "zod";
-var booleanInput3 = (description) => z47.preprocess(
+import { z as z48 } from "zod";
+var booleanInput3 = (description) => z48.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z47.boolean()
+  z48.boolean()
 ).describe(description);
-var updateListItemInputSchema = z47.union([
-  z47.object({
-    item_id: z47.string().min(1).describe("ID of the Slack list item to update."),
+var updateListItemInputSchema = z48.union([
+  z48.object({
+    item_id: z48.string().min(1).describe("ID of the Slack list item to update."),
     completed: booleanInput3("Optional completion status update."),
-    title: z47.string().min(1).describe("Optional new item title.").optional()
+    title: z48.string().min(1).describe("Optional new item title.").optional()
   }),
-  z47.object({
-    item_id: z47.string().min(1).describe("ID of the Slack list item to update."),
+  z48.object({
+    item_id: z48.string().min(1).describe("ID of the Slack list item to update."),
     completed: booleanInput3("Optional completion status update.").optional(),
-    title: z47.string().min(1).describe("Optional new item title.")
+    title: z48.string().min(1).describe("Optional new item title.")
   })
 ]);
 function createSlackListUpdateItemTool(state) {
@@ -11040,7 +11083,7 @@ async function checkSlackChannelReadAccess(args) {
 }
 
 // src/chat/slack/tools/thread-read.ts
-import { z as z48 } from "zod";
+import { z as z49 } from "zod";
 
 // src/chat/slack/tools/slack-message-url.ts
 var SLACK_HOST_PATTERN = /^[a-z0-9-]+\.slack(?:-gov)?\.com$/;
@@ -11119,6 +11162,9 @@ function renderField(raw) {
   if (title && value) return `${title}: ${value}`;
   return title || value;
 }
+function normalizeAttachmentText(value) {
+  return value.replace(/\r\n?/g, "\n").replace(/ {2,}(?=[-*+]\s|\d+\.\s)/g, "\n").replace(/(?<=\S) (?=[-*+] \*\*[^*\n]+\*\*)/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
 function renderAttachment(raw) {
   if (!raw || typeof raw !== "object") return "";
   const obj = raw;
@@ -11134,7 +11180,7 @@ function renderAttachment(raw) {
   const fields = Array.isArray(obj.fields) ? obj.fields : [];
   const add = (value) => {
     if (!value) return;
-    const normalized = value.trim();
+    const normalized = normalizeAttachmentText(value);
     if (!normalized || seen.has(normalized)) return;
     seen.add(normalized);
     parts.push(normalized);
@@ -11147,7 +11193,7 @@ function renderAttachment(raw) {
   add(authorName);
   if (title && titleLink) {
     add(`${title} (${titleLink})`);
-    seen.add(title.trim());
+    seen.add(normalizeAttachmentText(title));
   } else {
     add(title);
   }
@@ -11156,7 +11202,7 @@ function renderAttachment(raw) {
     add(renderField(field));
   }
   add(footer);
-  return parts.join(" | ");
+  return parts.join("\n");
 }
 function renderSlackLegacyAttachmentText(input) {
   const rendered = getAttachmentPayload(input).slice(0, MAX_ATTACHMENTS).map(renderAttachment).filter((line) => line.length > 0).map((line) => `[attachment] ${line}`).join("\n");
@@ -11218,8 +11264,8 @@ function createSlackThreadReadTool(context, deps = {}) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z48.object({
-      url: z48.string().min(1).describe(
+    inputSchema: z49.object({
+      url: z49.string().min(1).describe(
         "Slack message archive URL, e.g. https://workspace.slack.com/archives/C123/p1700000000123456"
       ).optional(),
       channel_id: slackChannelIdParam(
@@ -11228,8 +11274,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: 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()
+      limit: z49.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
+      max_pages: z49.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 }) => {
@@ -11457,7 +11503,7 @@ async function searchSlackUsers(options) {
 }
 
 // src/chat/slack/tools/user-lookup.ts
-import { z as z49 } from "zod";
+import { z as z50 } from "zod";
 function explicitUserLookupError(error) {
   if (error.apiError === "user_not_found") {
     return "No Slack user found for the supplied user ID.";
@@ -11485,11 +11531,11 @@ function createSlackUserLookupTool() {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z49.object({
-      mode: z49.enum(["user_id", "email", "query"]).describe(
+    inputSchema: z50.object({
+      mode: z50.enum(["user_id", "email", "query"]).describe(
         "Lookup method: user_id for Slack IDs, email for email addresses, or query for name searches."
       ),
-      value: z49.string().trim().min(2).describe(
+      value: z50.string().trim().min(2).describe(
         "The Slack user ID, email address, or name to look up, interpreted according to mode."
       )
     }).strict(),
@@ -11547,18 +11593,18 @@ function createSlackUserLookupTool() {
 }
 
 // src/chat/tools/system-time.ts
-import { z as z50 } from "zod";
-var systemTimeInputSchema = z50.object({
-  timezone: z50.string().trim().min(1).optional().describe(
+import { z as z51 } from "zod";
+var systemTimeInputSchema = z51.object({
+  timezone: z51.string().trim().min(1).optional().describe(
     "Optional IANA timezone, for example America/Los_Angeles. When set, iso_local and timezone_offset_minutes are for that zone."
   )
 });
 var systemTimeOutputSchema = juniorToolOutputSchema.extend({
-  unix_ms: z50.number(),
-  iso_utc: z50.string(),
-  iso_local: z50.string(),
-  timezone: z50.string().nullable(),
-  timezone_offset_minutes: z50.number()
+  unix_ms: z51.number(),
+  iso_utc: z51.string(),
+  iso_local: z51.string(),
+  timezone: z51.string().nullable(),
+  timezone_offset_minutes: z51.number()
 });
 function createSystemTimeTool() {
   return zodTool({
@@ -11638,7 +11684,7 @@ function getTimeZoneOffsetMinutes(timestampMs, timezone) {
 }
 
 // src/chat/tools/query-conversation-events.ts
-import { z as z51 } from "zod";
+import { z as z52 } from "zod";
 var DEFAULT_LIMIT3 = 25;
 var MAX_LIMIT = 100;
 var MAX_EVENT_DATA_BYTES = 4e3;
@@ -11649,28 +11695,28 @@ var CONVERSATION_EVENTS_TOOL_SOURCE = {
   id: "conversation-events",
   description: "Inspect Junior's durable conversation event log for debugging runtime behavior."
 };
-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(
+var knownEventTypeSchema = z52.enum(KNOWN_CONVERSATION_EVENT_TYPES);
+var projectedEventSchema = z52.object({
+  seq: z52.number().int().nonnegative().describe("Stable event position; use it for pagination bounds."),
+  history_version: z52.number().int().nonnegative().describe(
     "Model-history generation. It increments when handoff or compaction replaces active model context."
   ),
-  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(
+  created_at: z52.iso.datetime().describe("When the event was recorded."),
+  idempotency_key: z52.string().min(1).optional().describe("Retry-stable event identity, when one was assigned."),
+  data: z52.record(z52.string(), z52.unknown()).describe(
     "Event data. Oversized payloads are replaced by identifying fields, payload_omitted, and payload_json_bytes."
   )
 }).strict();
 var queryConversationEventsOutputSchema = juniorToolOutputSchema.extend({
-  conversation_id: z51.string().min(1),
-  events: z51.array(projectedEventSchema),
-  has_older: z51.boolean().describe(
+  conversation_id: z52.string().min(1),
+  events: z52.array(projectedEventSchema),
+  has_older: z52.boolean().describe(
     "Whether matching events exist before this page; request them with before_seq set to the first returned seq."
   ),
-  has_newer: z51.boolean().describe(
+  has_newer: z52.boolean().describe(
     "Whether matching events exist after this page; request them with after_seq set to the last returned seq."
   ),
-  omitted_event_count: z51.number().int().nonnegative().optional().describe(
+  omitted_event_count: z52.number().int().nonnegative().optional().describe(
     "Fetched events omitted to keep this response bounded. Continue with the pagination cursor for the omitted direction."
   )
 });
@@ -11685,20 +11731,20 @@ function createQueryConversationEventsTool(context) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z51.object({
-      conversation_id: z51.string().trim().min(1).describe(
+    inputSchema: z52.object({
+      conversation_id: z52.string().trim().min(1).describe(
         "Conversation ID to inspect, such as slack:{channelId}:{threadTs} or a child conversation id."
       ),
-      after_seq: z51.number().int().nonnegative().nullable().describe(
+      after_seq: z52.number().int().nonnegative().nullable().describe(
         "Exclusive lower bound on event seq. When set, returns the next newer page in ascending order."
       ).optional(),
-      before_seq: z51.number().int().nonnegative().nullable().describe(
+      before_seq: z52.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: z51.number().int().min(1).max(MAX_LIMIT).nullable().describe(
+      limit: z52.number().int().min(1).max(MAX_LIMIT).nullable().describe(
         `Maximum events to return. Defaults to ${DEFAULT_LIMIT3}; max ${MAX_LIMIT}.`
       ).optional(),
-      types: z51.array(knownEventTypeSchema).min(1).nullable().describe(
+      types: z52.array(knownEventTypeSchema).min(1).nullable().describe(
         "Optional event-type filter. Omit to return every durable event type."
       ).optional()
     }).strict(),
@@ -11946,10 +11992,10 @@ function stripReplacementHistoryField(value) {
 }
 
 // src/chat/tools/handoff/tool.ts
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 var HANDOFF_TOOL_NAME = "handoff";
 function createHandoffTool(handoff) {
-  const profileSchema = z52.enum(handoff.profiles);
+  const profileSchema = z53.enum(handoff.profiles);
   const handoffResultSchema = juniorToolOutputSchema.extend({
     model_profile: modelProfileSchema
   });
@@ -11963,7 +12009,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: z52.object({
+    inputSchema: z53.object({
       profile: profileSchema.describe("Target execution profile")
     }).strict(),
     outputSchema: handoffResultSchema,
@@ -11984,7 +12030,7 @@ function createHandoffTool(handoff) {
 }
 
 // src/chat/tools/web/fetch-tool.ts
-import { z as z53 } from "zod";
+import { z as z54 } from "zod";
 
 // src/chat/tools/web/constants.ts
 var USER_AGENT = "junior-bot/0.1";
@@ -12427,9 +12473,9 @@ function createWebFetchTool(hooks, options = {}) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    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()
+    inputSchema: z54.object({
+      url: z54.string().min(1).describe("HTTP(S) URL to fetch."),
+      max_chars: z54.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 }) => {
@@ -12474,7 +12520,7 @@ function createWebFetchTool(hooks, options = {}) {
 }
 
 // src/chat/tools/web/search.ts
-import { z as z54 } from "zod";
+import { z as z55 } from "zod";
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
 var SEARCH_TIMEOUT_MS = 6e4;
@@ -12516,9 +12562,9 @@ function createWebSearchTool(modelId, override) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    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()
+    inputSchema: z55.object({
+      query: z55.string().min(1).max(500).describe("Search query."),
+      max_results: z55.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ query, max_results }) => {
@@ -12560,7 +12606,7 @@ function createWebSearchTool(modelId, override) {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { z as z55 } from "zod";
+import { z as z56 } from "zod";
 function createWriteFileTool() {
   return zodTool({
     annotations: {
@@ -12571,9 +12617,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: 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.")
+    inputSchema: z56.object({
+      path: z56.string().min(1).describe("Path to write in the sandbox workspace."),
+      content: z56.string().describe("UTF-8 file content to write.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async () => {
@@ -12672,6 +12718,9 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
   if (context.handoff) {
     tools.handoff = createHandoffTool(context.handoff);
   }
+  if (context.spawnAgent) {
+    tools.spawnAgent = createSpawnAgentTool(context.spawnAgent);
+  }
   if (context.mcpToolManager) {
     tools.searchMcpTools = createSearchMcpToolsTool(context.mcpToolManager);
     tools.callMcpTool = createCallMcpToolTool(context.mcpToolManager);
@@ -12905,167 +12954,6 @@ function buildSandboxInput(toolName, params) {
 // src/chat/tools/execution/tool-error-handler.ts
 import { PluginToolInputError } from "@sentry/junior-plugin-api";
 
-// src/chat/services/plugin-auth-orchestration.ts
-var PluginAuthorizationPauseError = class extends AuthorizationPauseError {
-  constructor(provider, providerDisplayName, disposition, requestText) {
-    super("plugin", provider, providerDisplayName, disposition, requestText);
-  }
-};
-var PluginCredentialFailureError = class extends Error {
-  provider;
-  constructor(provider, message) {
-    super(message);
-    this.name = "PluginCredentialFailureError";
-    this.provider = provider;
-  }
-};
-function pluginAuthRequiredSignal(details) {
-  if (!details || typeof details !== "object") {
-    return void 0;
-  }
-  const signal = details.auth_required;
-  const parsedSignal = parseSandboxEgressAuthRequiredSignal(signal);
-  if (!parsedSignal) {
-    return void 0;
-  }
-  return {
-    provider: parsedSignal.provider,
-    grant: parsedSignal.grant,
-    kind: parsedSignal.kind,
-    ...parsedSignal.message ? { message: parsedSignal.message } : {},
-    ...parsedSignal.authorization ? { authorization: parsedSignal.authorization } : {}
-  };
-}
-function createPluginAuthOrchestration(input) {
-  let pendingPause;
-  const startAuthorizationPause = async (provider, options) => {
-    if (pendingPause) {
-      throw pendingPause;
-    }
-    if (!input.actorId || !pluginCatalogRuntime.getOAuthConfig(provider)) {
-      throw new Error(`Cannot start plugin authorization for ${provider}`);
-    }
-    if (input.authorizationFlowMode === "disabled") {
-      throw new AuthorizationFlowDisabledError("plugin", provider);
-    }
-    const recordPendingAuth = input.sessionId ? input.recordPendingAuth : void 0;
-    if (input.sessionId && !recordPendingAuth) {
-      throw new Error(
-        `Missing pending auth recorder for plugin authorization pause "${provider}"`
-      );
-    }
-    const providerLabel = formatProviderLabel(provider);
-    const reusingPendingLink = input.sessionId ? canReusePendingAuthLink({
-      pendingAuth: input.pendingAuth,
-      kind: "plugin",
-      provider,
-      actorId: input.actorId,
-      sessionId: input.sessionId,
-      ...options?.scope ? { scope: options.scope } : {}
-    }) : false;
-    if (!reusingPendingLink) {
-      const oauthResult = await startOAuthFlow(provider, {
-        actorId: input.actorId,
-        channelId: input.channelId,
-        destination: input.destination,
-        source: input.source,
-        threadTs: input.threadTs,
-        ...options?.scope ? { scope: options.scope } : {},
-        resumeConversationId: input.conversationId,
-        resumeSessionId: input.sessionId,
-        authorization: input.authorization
-      });
-      if (!oauthResult.ok) {
-        throw new Error(oauthResult.error);
-      }
-      if (!oauthResult.delivery) {
-        throw new Error(
-          `I need to connect your ${providerLabel} account first, but I wasn't able to send you a private authorization link. Please send me a direct message and try again.`
-        );
-      }
-    }
-    if (input.sessionId && recordPendingAuth) {
-      const nextPendingAuth = {
-        kind: "plugin",
-        provider,
-        actorId: input.actorId,
-        ...options?.scope ? { scope: options.scope } : {},
-        sessionId: input.sessionId,
-        linkSentAtMs: reusingPendingLink ? input.pendingAuth.linkSentAtMs : Date.now()
-      };
-      await recordPendingAuth(nextPendingAuth);
-      await abandonReplacedPendingAuth({
-        conversationId: input.conversationId,
-        previousPendingAuth: input.pendingAuth,
-        nextPendingAuth
-      });
-    }
-    if (input.conversationId && input.sessionId) {
-      await recordAuthorizationRequested({
-        conversationId: input.conversationId,
-        kind: "plugin",
-        provider,
-        actorId: input.actorId,
-        authorizationId: authorizationId({
-          kind: "plugin",
-          provider,
-          sessionId: input.sessionId
-        }),
-        delivery: reusingPendingLink ? "private_link_reused" : "private_link_sent"
-      });
-    }
-    pendingPause = new PluginAuthorizationPauseError(
-      provider,
-      providerLabel,
-      reusingPendingLink ? "link_already_sent" : "link_sent",
-      input.userMessage
-    );
-    input.abortAgent();
-    throw pendingPause;
-  };
-  return {
-    maybeHandleAuthSignal: async (details) => {
-      const signal = pluginAuthRequiredSignal(details);
-      if (!signal) {
-        return;
-      }
-      const { provider, authorization } = signal;
-      if (signal.kind === "unavailable") {
-        throw new PluginCredentialFailureError(
-          provider,
-          signal.message ?? `${formatProviderLabel(provider)} credentials are unavailable.`
-        );
-      }
-      if (!authorization) {
-        throw new PluginCredentialFailureError(
-          provider,
-          signal.message ?? `${formatProviderLabel(provider)} credentials are required but no OAuth flow is available for this provider.`
-        );
-      }
-      if (!input.actorId || !input.userTokenStore) {
-        if (input.authorizationFlowMode === "disabled") {
-          throw new AuthorizationFlowDisabledError("plugin", provider);
-        }
-        throw new PluginCredentialFailureError(
-          provider,
-          signal.message ?? `${formatProviderLabel(provider)} credentials are required. Please connect your ${formatProviderLabel(provider)} account and try again.`
-        );
-      }
-      if (!pluginCatalogRuntime.getOAuthConfig(authorization.provider)) {
-        throw new PluginCredentialFailureError(
-          provider,
-          signal.message ?? `${formatProviderLabel(provider)} credentials are required but the provider is not configured for OAuth.`
-        );
-      }
-      await startAuthorizationPause(
-        authorization.provider,
-        authorization.scope ? { scope: authorization.scope } : void 0
-      );
-    },
-    getPendingPause: () => pendingPause
-  };
-}
-
 // src/chat/tool-support/action-review.ts
 var ACTION_CONFIRMATION_INSTRUCTIONS = [
   "The action was not executed because explicit user confirmation is required.",
@@ -13441,7 +13329,7 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, conv
 }
 
 // src/chat/tools/execute-tool.ts
-import { z as z56 } from "zod";
+import { z as z57 } from "zod";
 var EXECUTE_TOOL_NAME = "executeTool";
 function createExecuteToolTool() {
   return zodTool({
@@ -13453,11 +13341,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: z56.object({
-      tool_name: z56.string().min(1).describe(
+    inputSchema: z57.object({
+      tool_name: z57.string().min(1).describe(
         "Exact catalog tool_name returned by searchTools or a tool-result execution hint."
       ),
-      arguments: z56.record(z56.string(), z56.unknown()).describe(
+      arguments: z57.record(z57.string(), z57.unknown()).describe(
         'Arguments matching the selected catalog tool schema, for example { "query": "..." }.'
       ).optional()
     }).strict(),
@@ -13497,34 +13385,34 @@ function planToolExposure(tools) {
 }
 
 // src/chat/tools/search-tools.ts
-import { z as z57 } from "zod";
+import { z as z58 } from "zod";
 var SEARCH_TOOLS_NAME = "searchTools";
 var DEFAULT_MAX_RESULTS2 = 5;
 var MAX_RESULTS3 = 20;
 var MODEL_VISIBLE_DESCRIPTION_CAP = 180;
-var searchToolsSourceSchema = z57.object({
-  id: z57.string(),
-  description: z57.string()
+var searchToolsSourceSchema = z58.object({
+  id: z58.string(),
+  description: z58.string()
 }).strict();
-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())
+var searchToolsToolSchema = z58.object({
+  tool_name: z58.string(),
+  description: z58.string(),
+  exposure: z58.enum(["direct", "deferred", "modelOnly", "hidden"]),
+  source: z58.string().optional(),
+  input_schema: z58.unknown(),
+  call_notes: z58.array(z58.string()),
+  annotations: z58.record(z58.string(), z58.unknown())
 }).strict();
 var searchToolsOutputSchema = juniorToolOutputSchema.extend({
-  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)
+  query: z58.string().nullable(),
+  source: z58.string().nullable(),
+  sources: z58.array(searchToolsSourceSchema),
+  total_catalog_tools: z58.number().int().nonnegative(),
+  total_eligible_tools: z58.number().int().nonnegative(),
+  total_matches: z58.number().int().nonnegative(),
+  returned_tools: z58.number().int().nonnegative(),
+  execution_tool: z58.literal("executeTool"),
+  tools: z58.array(searchToolsToolSchema)
 }).strict();
 function normalize2(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]+/g, " ").trim();
@@ -13639,14 +13527,14 @@ function createSearchToolsTool(catalogTools) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z57.object({
-      query: z57.string().nullable().describe(
+    inputSchema: z58.object({
+      query: z58.string().nullable().describe(
         "Optional search terms describing the tool, owner, action, or arguments needed. Empty string lists catalog tools."
       ).optional(),
-      source: z57.string().nullable().describe(
+      source: z58.string().nullable().describe(
         "Optional source id to search within, such as a plugin source returned in sources."
       ).optional(),
-      max_results: z57.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
+      max_results: z58.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
     }).strict(),
     outputSchema: searchToolsOutputSchema,
     privateTraceResult: (result) => ({
@@ -13961,7 +13849,7 @@ function createMcpAuthOrchestration(input) {
     if (!input.conversationId || !input.sessionId || !input.actorId) {
       return void 0;
     }
-    if (!input.recordPendingAuth && input.authorizationFlowMode !== "disabled") {
+    if (!input.recordPendingAuth && input.interactiveAuthEnabled !== false) {
       throw new Error(
         `Missing pending auth recorder for MCP authorization pause "${plugin.manifest.name}"`
       );
@@ -13997,7 +13885,7 @@ function createMcpAuthOrchestration(input) {
         `Missing MCP auth session context for plugin "${provider}"`
       );
     }
-    if (input.authorizationFlowMode === "disabled") {
+    if (input.interactiveAuthEnabled === false) {
       await deleteMcpAuthSession(authSessionId);
       throw new AuthorizationFlowDisabledError("mcp", provider);
     }
@@ -14891,7 +14779,7 @@ function createPluginEgress(deps) {
 }
 
 // src/chat/services/guardian-action-review.ts
-import { z as z58 } from "zod";
+import { z as z59 } from "zod";
 
 // src/chat/services/guardian-action-policy.ts
 var GUARDIAN_ACTION_POLICY = `You are judging one planned Junior agent action.
@@ -14957,17 +14845,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 = 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"])
+var guardianDecisionSchema = z59.object({
+  decision: z59.enum(["allow", "ask", "deny"]),
+  reason: z59.string().trim().min(1).max(500),
+  riskLevel: z59.enum(["low", "medium", "high", "critical"]),
+  userAuthorization: z59.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(z58.json().parse(proposal), null, 2);
+  const proposalJson = JSON.stringify(z59.json().parse(proposal), null, 2);
   if (proposalJson.length > MAX_PROPOSAL_CHARS) {
     throw new Error(
       `Guardian action proposal exceeds ${MAX_PROPOSAL_CHARS} characters.`
@@ -15255,7 +15143,10 @@ async function wireAgentTools(args) {
       args.artifactStatePatch
     ),
     recordPendingAuth: args.durability.recordPendingAuth,
-    authorizationFlowMode: args.policy.authorizationFlowMode,
+    interactiveAuthEnabled: !isAgentRunFeatureDisabled(
+      args.policy,
+      "interactive-auth"
+    ),
     authorization: args.authorization
   });
   const pluginAuth = createPluginAuthOrchestration({
@@ -15270,7 +15161,10 @@ async function wireAgentTools(args) {
     userMessage: args.userInput,
     pendingAuth: args.state.pendingAuth,
     recordPendingAuth: args.durability.recordPendingAuth,
-    authorizationFlowMode: args.policy.authorizationFlowMode,
+    interactiveAuthEnabled: !isAgentRunFeatureDisabled(
+      args.policy,
+      "interactive-auth"
+    ),
     userTokenStore,
     authorization: args.authorization
   });
@@ -15323,6 +15217,7 @@ async function wireAgentTools(args) {
     ...args.currentActor ? {
       resolveActorIdentity: async () => await readActorIdentity(args.currentActor)
     } : {},
+    ...args.durability.spawnAgent ? { spawnAgent: args.durability.spawnAgent } : {},
     ...args.requestHandoff ? { handoff: args.requestHandoff } : {}
   };
   const toolDestination = toolInvocationDestination(args.routing);
@@ -16504,9 +16399,10 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     const explicitSkill = invokedSkill ? activeSkills.find((skill) => skill.name === invokedSkill.name) ?? null : null;
     const { contextContentParts, routerBlocks, userContentParts } = buildPromptInput(input);
     const preAgentPromptMessages = () => existingSessionRecord?.piMessages ?? [...input.piMessages ?? []];
+    const handoffEnabled = !isAgentRunFeatureDisabled(policy, "handoff");
     const storedTurnRoute = await loadTurnRoute({ conversationId, turnId });
     if (storedTurnRoute) {
-      const resumedAfterHandoff = activeModelProfile !== STANDARD_MODEL_PROFILE && activeModelProfile !== storedTurnRoute.modelProfile;
+      const resumedAfterHandoff = handoffEnabled && activeModelProfile !== STANDARD_MODEL_PROFILE && activeModelProfile !== storedTurnRoute.modelProfile;
       if (resumedAfterHandoff) {
         const activeProfileConfig = profileConfig(
           botConfig,
@@ -16527,7 +16423,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
           source: storedTurnRoute.source
         };
       }
-    } else if (activeModelProfile === STANDARD_MODEL_PROFILE) {
+    } else if (activeModelProfile === STANDARD_MODEL_PROFILE && handoffEnabled) {
       turnRoute = await selectTurnRoute({
         completeObject,
         conversationContext: input.conversationContext,
@@ -16553,6 +16449,15 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
           reason: `configured:${policy.reasoningLevel ? "agent_config" : "default"}:${turnRoute.reason}`
         };
       }
+    } else if (!handoffEnabled) {
+      const activeProfileConfig = profileConfig(botConfig, activeModelProfile);
+      const reasoningSource = policy.reasoningLevel ? "agent_config" : activeProfileConfig.reasoningLevel ? "profile" : "default";
+      turnRoute = {
+        profile: activeModelProfile,
+        reasoningLevel: policy.reasoningLevel ?? activeProfileConfig.reasoningLevel ?? botConfig.reasoningLevel ?? "medium",
+        reason: `fixed:${reasoningSource}`,
+        source: "configured"
+      };
     } else {
       const activeProfileConfig = profileConfig(botConfig, activeModelProfile);
       const reasoningSource = activeProfileConfig.reasoningLevel ? "profile" : policy.reasoningLevel ? "agent_config" : "default";
@@ -16672,7 +16577,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
         })
       } : void 0;
     };
-    const requestHandoff = handoffControlFor(activeModelProfile);
+    const requestHandoff = handoffEnabled ? handoffControlFor(activeModelProfile) : void 0;
     setTags({
       ...runLogContext,
       modelId: activeModelId
@@ -16731,7 +16636,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       (tool) => tool.name === HANDOFF_TOOL_NAME
     );
     const toolsForActiveProfile = () => {
-      const handoff = handoffControlFor(activeModelProfile);
+      const handoff = handoffEnabled ? handoffControlFor(activeModelProfile) : void 0;
       if (!handoff) {
         return toolsWithoutHandoff;
       }
@@ -17436,17 +17341,28 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
 // src/chat/runtime/agent-runner.ts
 function createAgentRunner(run, options) {
   const tracePropagation = options?.tracePropagation;
-  if (!tracePropagation) {
+  const bindSpawnAgent = options?.bindSpawnAgent;
+  const canBindSpawn = Boolean(bindSpawnAgent) && isExperimentalFeatureEnabled("subagents");
+  if (!tracePropagation && !canBindSpawn) {
     return { run };
   }
   return {
-    run: async (request) => await run({
-      ...request,
-      policy: {
-        ...request.policy,
-        sandboxTracePropagation: request.policy?.sandboxTracePropagation ?? tracePropagation
-      }
-    })
+    run: async (request) => {
+      const spawnAgent = bindSpawnAgent && canBindSpawn && !isAgentRunFeatureDisabled(request.policy, "subagents") ? bindSpawnAgent(request) : void 0;
+      return await run({
+        ...request,
+        policy: {
+          ...request.policy,
+          sandboxTracePropagation: request.policy?.sandboxTracePropagation ?? tracePropagation
+        },
+        ...spawnAgent ? {
+          durability: {
+            ...request.durability,
+            spawnAgent
+          }
+        } : {}
+      });
+    }
   };
 }
 
@@ -17454,7 +17370,6 @@ export {
   setConfigDefaults,
   getConfigDefaults,
   shouldEmitDevAgentTrace,
-  AuthorizationFlowDisabledError,
   resolveDestinationVisibility,
   buildSteeringPiMessage,
   SANDBOX_EGRESS_PROXY_PATH,
@@ -17473,7 +17388,6 @@ export {
   renderSlackLegacyAttachmentText,
   appendSlackLegacyAttachmentText,
   latestReportedProgress,
-  PluginCredentialFailureError,
   executeCredentialedEgressRequest,
   createContextCompactor,
   executeAgentRun,