@sentry/junior 0.194.0 → 0.196.0

package/dist/{chunk-G4RARFNT.js → chunk-OVWAO5KY.js}

@@ -7,7 +7,7 @@ import {
   PluginCredentialFailureError,
   agentNameSchema,
   createPluginAuthOrchestration
-} from "./chunk-QMEF4Z7R.js";
+} from "./chunk-CNI74T7U.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
@@ -38,7 +38,7 @@ import {
   searchSlackUsers,
   selectPluginGrant,
   toMcpProviderError
-} from "./chunk-AWZS5SVX.js";
+} from "./chunk-N2MSPOGG.js";
 import {
   RetryableDeliveryError,
   actorFromRun,
@@ -48,24 +48,24 @@ import {
   formatProviderLabel,
   getSlackMessagePermalink,
   isAgentRunFeatureDisabled,
+  postSlackMessage,
   resolveBaseUrl,
   surfaceFromRun,
   toolInvocationDestination,
   uploadFilesToConversation
-} from "./chunk-ENWIHU54.js";
+} from "./chunk-RFNMWONZ.js";
 import {
   CooperativeTurnYieldError,
   NO_REPLY_MARKER,
   TurnInputCommitLostError,
   abandonReplacedPendingAuth,
   canReusePendingAuthLink,
-  containsNoReplyMarker,
   decideReply,
   getAssistantReplyText,
   isNoReplyMarker,
   isTurnInputCommitLostError,
   sanitizeAssistantText
-} from "./chunk-G35QGPO2.js";
+} from "./chunk-DFWJJOW3.js";
 import {
   AGENTS_REMOVAL_NOTICE,
   AGENTS_REPLACEMENT_NOTICE,
@@ -121,7 +121,7 @@ import {
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   truncateText
-} from "./chunk-OEQOAONV.js";
+} from "./chunk-6LQNW2CJ.js";
 import {
   SCHEDULED_TASK_SYSTEM_ACTOR,
   WORKSPACE_SNAPSHOT_FAILED_EVENT,
@@ -162,13 +162,13 @@ import {
   workspaceSnapshotFinishedEvent,
   workspaceSnapshotWatch,
   writableEventTask
-} from "./chunk-WMJS5DDV.js";
+} from "./chunk-GZ336GZ5.js";
 import {
   parseSlackThreadId
-} from "./chunk-IOGDKPVU.js";
+} from "./chunk-VXAQTJSR.js";
 import {
   appendAndEnqueueInboundMessage
-} from "./chunk-E53C73ML.js";
+} from "./chunk-S74KAE77.js";
 import {
   SHORT_TITLE_MAX_LENGTH,
   ToolInputError,
@@ -176,7 +176,7 @@ import {
   generateShortTitle,
   hasAgentTurnUsage,
   resolveTaskTitle
-} from "./chunk-RFE7DCZK.js";
+} from "./chunk-B5WJBVHY.js";
 import {
   bindSandboxFileSystem,
   createSandboxSession,
@@ -187,7 +187,7 @@ import {
   resolve,
   setSnapshotSpanAttributes,
   stopSession
-} from "./chunk-ELCYG6UU.js";
+} from "./chunk-KZX7LORG.js";
 import {
   privateTraceResultAttributes
 } from "./chunk-UIE3R5XU.js";
@@ -197,7 +197,7 @@ import {
 } from "./chunk-X6GDDWQH.js";
 import {
   getTurnRequestDeadline
-} from "./chunk-NWWDFHXP.js";
+} from "./chunk-VRHZXY5X.js";
 import {
   getVercelConversationWorkQueue
 } from "./chunk-DKIJ2RP5.js";
@@ -244,19 +244,23 @@ import {
   updateWorkspace,
   withSlackRetries,
   workspaceRepoCheckoutPath
-} from "./chunk-CCTYK5RH.js";
+} from "./chunk-NE2UQMC7.js";
 import {
+  JUNIOR_THREAD_STATE_TTL_MS
+} from "./chunk-3Y47VMHV.js";
+import {
+  destinationKey,
   getConversationEventStore,
   getConversationMessageSearchStore,
   getConversationStore,
   getDb,
   getSqlExecutor
-} from "./chunk-ADEACKAH.js";
+} from "./chunk-XNXKRWWI.js";
 import {
   juniorArtifacts,
   juniorIdentities,
   juniorSchedulerRuns
-} from "./chunk-XLWZRHX5.js";
+} from "./chunk-PIZJBSGZ.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_REPOS_ROOT,
@@ -287,19 +291,19 @@ import {
   throwSandboxOperationError,
   workspaceSnapshotNotReadyUserMessage,
   wrapSandboxSetupError
-} from "./chunk-7ANA7PBB.js";
+} from "./chunk-SR5FS2JP.js";
 import {
   fenceLock,
   getStateAdapter,
   withLock
-} from "./chunk-V4HXV5MY.js";
+} from "./chunk-EQBHN4JK.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
   instructionActors,
   instructionProvenanceFor,
   sameActorIdentity
-} from "./chunk-GFBR4S3Q.js";
+} from "./chunk-7NL7T6VU.js";
 import {
   ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
@@ -325,14 +329,16 @@ import {
   resolveGatewayCredential,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-U76RWMFR.js";
+} from "./chunk-5XSEOJPC.js";
 import {
   ModelProfileNotConfiguredError,
   TURN_REASONING_LEVELS,
+  formatModelProfile,
+  formatModelProfiles,
   modelIdForProfile,
   modelProfileSchema,
   profileConfig
-} from "./chunk-D4YV5TDV.js";
+} from "./chunk-NHJU2ZAL.js";
 import {
   canExposeConversationPayload,
   resolveConversationPrivacy,
@@ -342,16 +348,16 @@ import {
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes
-} from "./chunk-JOI3DHML.js";
+} from "./chunk-ES7KCEND.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-P2P6MUQ4.js";
+} from "./chunk-LSPUMNZK.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-WWXJUURQ.js";
+} from "./chunk-G6YRPYDC.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -359,7 +365,7 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-S7GX44BU.js";
+} from "./chunk-BXIVMNLR.js";
 import {
   credentialContextForActor,
   credentialUserSubjectId
@@ -395,7 +401,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-X76JVHQ4.js";
+} from "./chunk-CTS72G4B.js";
 import {
   startInactiveSpan,
   withActiveSpan
@@ -919,11 +925,6 @@ function buildTurnResult(input) {
     if (!isProviderError) {
       logInfo("ai.no_reply_marker.accepted", markerAttributes);
     }
-  } else if (containsNoReplyMarker(rawPrimaryText)) {
-    logWarn("ai.no_reply_marker.mixed_text", {
-      "app.ai.no_reply_marker": true,
-      "app.ai.no_reply_marker_mode": "mixed"
-    });
   }
   if (!primaryText && !completedWithoutTerminalText && !isProviderError) {
     logWarn("ai.model_response.empty", {
@@ -1141,11 +1142,11 @@ function trimContextForRouter(text) {
     originalCharCount: trimmed.length
   };
 }
-function buildClassifierSystemPrompt(profileNames, defaultProfile) {
+function buildClassifierSystemPrompt(profiles, profileNames, defaultProfile) {
+  const profileList = formatModelProfiles(profiles, profileNames);
   return [
     "You choose the model profile most likely to produce a complete, source-grounded answer.",
     "Choose exactly one bucket: none, low, medium, high, or xhigh.",
-    `Choose profile from the configured profiles: ${profileNames.join(", ")}.`,
     "Choose profile independently from the reasoning bucket.",
     "",
     "Use none only for greetings, acknowledgments, and turns that need no substantive assistant work.",
@@ -1154,9 +1155,11 @@ function buildClassifierSystemPrompt(profileNames, defaultProfile) {
     "Use high for research-heavy work, non-trivial drafting, or explicit requests to be thorough.",
     "Use xhigh for the most complex tasks: code changes, debugging/root-cause analysis, broad refactors, architecture decisions, multi-file implementation, or any task where deep reasoning across multiple systems or files is required.",
     "When unsure between two non-none buckets, choose the higher bucket. Do not use low as the default.",
-    `The default profile is ${defaultProfile}.`,
-    "Profile names are configured labels. Do not assume that a non-default profile is more capable than the default profile.",
-    "Choose a non-default profile only when its label clearly matches the task. Otherwise keep the default profile.",
+    "",
+    `Default profile: "${defaultProfile}". Keep it unless another profile's description is a clearly better fit.`,
+    "Configured profiles (use each description's use and avoid cases; names are labels only; non-default does not mean stronger):",
+    profileList,
+    "Choose a non-default profile only when its description clearly fits the task. If no description clearly fits, keep the default profile.",
     "",
     "Classify based on the substance of the task, not the length of the current message. When the current instruction is a short affirmation (for example: 'go', 'do it', 'yes please', 'proceed') and prior thread context contains a pending task, classify the pending task \u2014 not the affirmation.",
     "",
@@ -1294,6 +1297,7 @@ async function classifyTurn(args) {
       prompt: args.prompt,
       thinkingLevel: "low",
       system: buildClassifierSystemPrompt(
+        args.profiles,
         Object.keys(args.profiles),
         args.defaultProfile
       ),
@@ -1728,7 +1732,7 @@ var TOOL_POLICY_RULES = [
   "- Event tasks make the task creator's connected credentials available by default when the requested work needs user-bound authorization. Do not ask for separate confirmation merely to use credentials needed for the requested work. On creation, omit credentialMode for the creator default and set system only when the creator explicitly requires it. For later changes, creator always means the task's original createdBy actor, never the current requester. If the requester is not that creator, do not attempt to enable creator credential use or suggest that confirmation could authorize it.",
   "- Event tasks list for the current destination, not one thread. Public tasks can also be updated or deleted by task id from another destination in the same workspace. When listing them, use createdBy to explain creator-only credential changes and warn when triggerAvailable is false; an unavailable task remains stored but cannot receive events until its plugin event is enabled again.",
   "- Scheduled tasks make the task creator's connected credentials available by default when the requested work needs user-bound authorization. Do not ask for separate confirmation merely to use credentials needed for the requested work. On creation, omit credential_mode for the creator default and set system only when the creator explicitly requires it. For later changes, creator always means the task's original created_by actor, never the current requester. If the requester is not that creator, do not attempt to enable creator credential use or suggest that confirmation could authorize it.",
-  "- For code changes, debugging or root-cause analysis, broad refactors, and software architecture decisions, use `handoff` before substantive analysis only when it offers a profile that better matches the task. Do not switch merely because the task involves code.",
+  "- When another model profile fits the task better, call `handoff` before substantial work. Follow the profile list and selection rules in the tool description.",
   "- Run `jr-rpc config get|set|unset|list` for provider defaults and `jr-rpc plugins list` for installed plugin introspection as standalone bash commands; do not chain them with `cd`, `&&`, pipes, or provider commands.",
   "- If the first result is empty, stale, ambiguous, or incomplete, try a focused alternate query, path, command, or source before concluding the answer cannot be verified."
 ];
@@ -3096,11 +3100,358 @@ async function prepareWorkspaceSnapshot(params) {
 // src/chat/resource-events/ingest.ts
 import { resourceEventSchema } from "@sentry/junior-plugin-api";
 
+// src/chat/services/automated-turn-limit.ts
+import { z as z3 } from "zod";
+var AUTOMATED_TURN_LIMIT_PREFIX = "junior:automated_turn_limit:v1";
+var AUTOMATED_TURN_LIMIT_LOCK_TTL_MS = 5e3;
+var AUTOMATED_TURN_LIMIT_LOCK_WAIT_MS = 2e3;
+var AUTOMATED_TURN_LIMIT_LOCK_RETRY_MS = 25;
+var automatedTurnLimitStateSchema = z3.object({
+  consecutiveAutomatedTurns: z3.number().int().nonnegative(),
+  noticePostedAtMs: z3.number().finite().nonnegative().optional(),
+  paused: z3.boolean(),
+  updatedAtMs: z3.number().finite().nonnegative()
+}).strict();
+function sleep2(ms) {
+  return new Promise((resolve2) => {
+    const timer = setTimeout(resolve2, ms);
+    timer.unref?.();
+  });
+}
+function scopeKey(scope) {
+  if (scope.kind === "conversation") {
+    return `${AUTOMATED_TURN_LIMIT_PREFIX}:conversation:${scope.conversationId}`;
+  }
+  return `${AUTOMATED_TURN_LIMIT_PREFIX}:destination:${destinationKey(scope.destination)}`;
+}
+function lockKey(key) {
+  return `${key}:lock`;
+}
+function parseState(value) {
+  const parsed = automatedTurnLimitStateSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+async function acquireScopeLock(state, key, waitDeadlineMs = Date.now() + AUTOMATED_TURN_LIMIT_LOCK_WAIT_MS) {
+  while (true) {
+    const lock = await state.acquireLock(
+      lockKey(key),
+      AUTOMATED_TURN_LIMIT_LOCK_TTL_MS
+    );
+    if (lock) {
+      return lock;
+    }
+    if (Date.now() >= waitDeadlineMs) {
+      throw new Error(`Could not acquire automated turn limit lock for ${key}`);
+    }
+    await sleep2(AUTOMATED_TURN_LIMIT_LOCK_RETRY_MS);
+  }
+}
+async function withScopeLock(state, key, callback) {
+  const lock = await acquireScopeLock(state, key);
+  try {
+    return await callback();
+  } finally {
+    await state.releaseLock(lock);
+  }
+}
+function emptyState(nowMs) {
+  return {
+    consecutiveAutomatedTurns: 0,
+    paused: false,
+    updatedAtMs: nowMs
+  };
+}
+function resumeInForScope(scope) {
+  return scope.kind === "conversation" ? "thread" : "channel";
+}
+function isAutomatedTurnSource(source) {
+  if (!source) {
+    return false;
+  }
+  return source.kind === "resource_event" || source.kind === "event_task" || source.kind === "scheduled_task" || source.kind === "plugin_dispatch" || source.kind === "agent_invocation";
+}
+function automatedTurnLimitScopeForSource(args) {
+  if (!isAutomatedTurnSource(args.source)) {
+    return void 0;
+  }
+  if (args.source?.kind === "resource_event") {
+    return {
+      kind: "conversation",
+      conversationId: args.conversationId
+    };
+  }
+  if (args.destination) {
+    return { kind: "destination", destination: args.destination };
+  }
+  return {
+    kind: "conversation",
+    conversationId: args.conversationId
+  };
+}
+function buildAutomatedTurnLimitResponse(args) {
+  const place = args.resumeIn === "channel" ? "channel" : "thread";
+  return `I stopped automatic updates after ${args.maxTurns} replies without a new message from you. Send a message or @mention me in this ${place} to continue.`;
+}
+async function admitAutomatedTurn(args) {
+  if (args.maxTurns < 1) {
+    throw new Error("Automated turn limit must be at least 1");
+  }
+  const state = args.state ?? getStateAdapter();
+  await state.connect();
+  const nowMs = args.nowMs ?? Date.now();
+  const key = scopeKey(args.scope);
+  return await withScopeLock(state, key, async () => {
+    const current = parseState(await state.get(key)) ?? emptyState(nowMs);
+    if (current.paused || current.consecutiveAutomatedTurns >= args.maxTurns) {
+      const shouldPostNotice = current.noticePostedAtMs === void 0;
+      const next = {
+        consecutiveAutomatedTurns: Math.max(
+          current.consecutiveAutomatedTurns,
+          args.maxTurns
+        ),
+        paused: true,
+        updatedAtMs: nowMs,
+        // Claim the notice slot so concurrent paused wakes do not all post.
+        // Callers must mark success or clear the claim if the post fails.
+        ...shouldPostNotice ? { noticePostedAtMs: nowMs } : current.noticePostedAtMs !== void 0 ? { noticePostedAtMs: current.noticePostedAtMs } : void 0
+      };
+      await state.set(key, next, JUNIOR_THREAD_STATE_TTL_MS);
+      return {
+        status: "paused",
+        consecutiveAutomatedTurns: next.consecutiveAutomatedTurns,
+        shouldPostNotice
+      };
+    }
+    return {
+      status: "allow",
+      consecutiveAutomatedTurns: current.consecutiveAutomatedTurns
+    };
+  });
+}
+async function countAutomatedTurn(args) {
+  if (args.maxTurns < 1) {
+    throw new Error("Automated turn limit must be at least 1");
+  }
+  const state = args.state ?? getStateAdapter();
+  await state.connect();
+  const nowMs = args.nowMs ?? Date.now();
+  const key = scopeKey(args.scope);
+  const resumeIn = resumeInForScope(args.scope);
+  return await withScopeLock(state, key, async () => {
+    const current = parseState(await state.get(key)) ?? emptyState(nowMs);
+    const consecutiveAutomatedTurns = current.consecutiveAutomatedTurns + 1;
+    const paused = consecutiveAutomatedTurns >= args.maxTurns;
+    const shouldPostNotice = paused && current.noticePostedAtMs === void 0;
+    const next = {
+      consecutiveAutomatedTurns,
+      paused,
+      updatedAtMs: nowMs,
+      // Claim the notice slot before the destination post. Mark success after
+      // the post lands; clear the claim if the post fails or is skipped.
+      ...shouldPostNotice ? { noticePostedAtMs: nowMs } : current.noticePostedAtMs !== void 0 ? { noticePostedAtMs: current.noticePostedAtMs } : void 0
+    };
+    await state.set(key, next, JUNIOR_THREAD_STATE_TTL_MS);
+    return {
+      consecutiveAutomatedTurns,
+      paused,
+      shouldPostNotice,
+      resumeIn
+    };
+  });
+}
+async function clearAutomatedTurnLimitNoticeClaim(args) {
+  const state = args.state ?? getStateAdapter();
+  await state.connect();
+  const nowMs = args.nowMs ?? Date.now();
+  const key = scopeKey(args.scope);
+  await withScopeLock(state, key, async () => {
+    const current = parseState(await state.get(key));
+    if (!current || current.noticePostedAtMs === void 0) {
+      return;
+    }
+    const { noticePostedAtMs: _noticePostedAtMs, ...rest } = current;
+    await state.set(
+      key,
+      {
+        ...rest,
+        updatedAtMs: nowMs
+      },
+      JUNIOR_THREAD_STATE_TTL_MS
+    );
+  });
+}
+async function resetAutomatedTurnLimit(args) {
+  const state = args.state ?? getStateAdapter();
+  await state.connect();
+  const key = scopeKey(args.scope);
+  await withScopeLock(state, key, async () => {
+    await state.delete(key);
+  });
+}
+async function recordFinishedTurnForAutomatedLimit(args) {
+  const nowMs = args.nowMs ?? Date.now();
+  const automatedScope = automatedTurnLimitScopeForSource({
+    conversationId: args.conversationId,
+    destination: args.destination,
+    source: args.source
+  });
+  if (automatedScope) {
+    return await countAutomatedTurn({
+      maxTurns: args.maxTurns,
+      nowMs,
+      scope: automatedScope,
+      state: args.state
+    });
+  }
+  await resetAutomatedTurnLimit({
+    nowMs,
+    scope: {
+      kind: "conversation",
+      conversationId: args.conversationId
+    },
+    state: args.state
+  });
+  if (args.destination) {
+    await resetAutomatedTurnLimit({
+      nowMs,
+      scope: { kind: "destination", destination: args.destination },
+      state: args.state
+    });
+  }
+  return void 0;
+}
+
+// src/chat/slack/automated-turn-limit-notice.ts
+async function releaseFailedNoticeClaim(args) {
+  try {
+    await clearAutomatedTurnLimitNoticeClaim(args);
+  } catch (error) {
+    logException(error, "automated_turn_limit.notice_claim_clear_failed");
+  }
+}
+async function postAutomatedTurnLimitNoticeForConversation(args) {
+  const scope = args.scope ?? {
+    kind: "conversation",
+    conversationId: args.conversationId
+  };
+  try {
+    const conversation = await getConversationStore().get({
+      conversationId: args.conversationId
+    });
+    const location = conversation?.location;
+    if (!location || location.provider !== "slack") {
+      logWarn("automated_turn_limit.notice_skipped", {
+        conversationId: args.conversationId,
+        "app.automated_turn_limit.reason": location ? "unsupported_location" : "missing_location"
+      });
+      await releaseFailedNoticeClaim({
+        nowMs: args.nowMs,
+        scope
+      });
+      return false;
+    }
+    await postSlackMessage({
+      channelId: location.channelId,
+      text: buildAutomatedTurnLimitResponse({
+        maxTurns: args.maxTurns,
+        resumeIn: args.resumeIn ?? "thread"
+      }),
+      ...location.threadTs ? { threadTs: location.threadTs } : void 0
+    });
+    return true;
+  } catch (error) {
+    logException(error, "automated_turn_limit.notice_failed", {
+      conversationId: args.conversationId
+    });
+    await releaseFailedNoticeClaim({
+      nowMs: args.nowMs,
+      scope
+    });
+    return false;
+  }
+}
+async function postAutomatedTurnLimitNoticeForDestination(args) {
+  const scope = args.scope ?? {
+    kind: "destination",
+    destination: args.destination
+  };
+  if (args.destination.platform !== "slack") {
+    logWarn("automated_turn_limit.notice_skipped", {
+      "app.automated_turn_limit.reason": "unsupported_destination"
+    });
+    await releaseFailedNoticeClaim({
+      nowMs: args.nowMs,
+      scope
+    });
+    return false;
+  }
+  try {
+    await postSlackMessage({
+      channelId: args.destination.channelId,
+      text: buildAutomatedTurnLimitResponse({
+        maxTurns: args.maxTurns,
+        resumeIn: args.resumeIn ?? "channel"
+      }),
+      ...args.threadTs ? { threadTs: args.threadTs } : void 0
+    });
+    return true;
+  } catch (error) {
+    logException(error, "automated_turn_limit.notice_failed", {
+      "app.slack.channel_id": args.destination.channelId,
+      "app.slack.team_id": args.destination.teamId
+    });
+    await releaseFailedNoticeClaim({
+      nowMs: args.nowMs,
+      scope
+    });
+    return false;
+  }
+}
+async function maybePostAutomatedTurnLimitNotice(args) {
+  if (!args.update?.shouldPostNotice) {
+    return;
+  }
+  if (args.update.resumeIn === "thread") {
+    await postAutomatedTurnLimitNoticeForConversation({
+      conversationId: args.conversationId,
+      maxTurns: args.maxTurns,
+      nowMs: args.nowMs,
+      resumeIn: "thread",
+      scope: {
+        kind: "conversation",
+        conversationId: args.conversationId
+      }
+    });
+    return;
+  }
+  if (args.destination) {
+    await postAutomatedTurnLimitNoticeForDestination({
+      destination: args.destination,
+      maxTurns: args.maxTurns,
+      nowMs: args.nowMs,
+      resumeIn: "channel",
+      scope: { kind: "destination", destination: args.destination },
+      threadTs: args.threadTs
+    });
+    return;
+  }
+  await postAutomatedTurnLimitNoticeForConversation({
+    conversationId: args.conversationId,
+    maxTurns: args.maxTurns,
+    nowMs: args.nowMs,
+    resumeIn: args.update.resumeIn,
+    scope: {
+      kind: "conversation",
+      conversationId: args.conversationId
+    }
+  });
+}
+
 // src/chat/task-input.ts
 function replyContractLines() {
   return [
     "When you reply, follow any reply format in the instructions.",
-    `If no visible reply is needed, make the final message exactly ${NO_REPLY_MARKER}.`,
+    `If no visible reply is needed, your final assistant message must be exactly ${NO_REPLY_MARKER} and nothing else.`,
     "Otherwise briefly summarize what you acted on and what you did or need next."
   ];
 }
@@ -3235,6 +3586,38 @@ function createResourceEventInboundMessage(input) {
   };
 }
 async function enqueueResourceEventNotification(args) {
+  const maxTurns = botConfig.maxConsecutiveAutomatedTurns;
+  const decision = await admitAutomatedTurn({
+    maxTurns,
+    nowMs: args.event.occurredAtMs,
+    scope: {
+      kind: "conversation",
+      conversationId: args.subscription.conversationId
+    },
+    state: args.state
+  });
+  if (decision.status === "paused") {
+    logInfo("resource_events.automated_turn_limit.paused", {
+      conversationId: args.subscription.conversationId,
+      "app.automated_turn_limit.consecutive": decision.consecutiveAutomatedTurns,
+      "app.automated_turn_limit.max": maxTurns,
+      "app.resource_event.event_type": args.event.eventType,
+      "app.resource_event.namespace": args.event.namespace
+    });
+    if (decision.shouldPostNotice) {
+      await postAutomatedTurnLimitNoticeForConversation({
+        conversationId: args.subscription.conversationId,
+        maxTurns,
+        nowMs: args.event.occurredAtMs,
+        resumeIn: "thread",
+        scope: {
+          kind: "conversation",
+          conversationId: args.subscription.conversationId
+        }
+      });
+    }
+    return { status: "duplicate" };
+  }
   const text = renderResourceEventNotificationText(
     args.subscription,
     args.event
@@ -5008,10 +5391,10 @@ function validateAndApplyTextEdits(content, edits, targetName) {
 }
 
 // src/chat/tools/sandbox/edit-file.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/chat/tool-support/zod-tool.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 function isContentOnlyToolResult(value) {
   return value !== null && typeof value === "object" && Array.isArray(value.content) && !("details" in value);
 }
@@ -5048,7 +5431,7 @@ function zodTool(definition) {
   const { inputSchema: inputSchema2, outputSchema: outputSchema7, prepareArguments, execute, ...toolDef } = definition;
   let modelInputSchema;
   try {
-    modelInputSchema = z3.toJSONSchema(inputSchema2);
+    modelInputSchema = z4.toJSONSchema(inputSchema2);
   } catch (error) {
     throw new TypeError(
       "zodTool() inputSchema must be representable as JSON Schema.",
@@ -5058,7 +5441,7 @@ function zodTool(definition) {
   let modelOutputSchema;
   if (outputSchema7) {
     try {
-      modelOutputSchema = z3.toJSONSchema(outputSchema7);
+      modelOutputSchema = z4.toJSONSchema(outputSchema7);
     } catch (error) {
       throw new TypeError(
         "zodTool() outputSchema must be representable as JSON Schema.",
@@ -5143,11 +5526,11 @@ async function editFile(params) {
     truncated: diff.truncated
   });
 }
-var editReplacementSchema = z4.object({
-  oldText: z4.string().min(1).describe(
+var editReplacementSchema = z5.object({
+  oldText: z5.string().min(1).describe(
     "Exact text to replace. It must be unique in the original file and must not overlap another edit."
   ),
-  newText: z4.string().describe("Replacement text for this edit.")
+  newText: z5.string().describe("Replacement text for this edit.")
 });
 function createEditFileTool() {
   return zodTool({
@@ -5160,9 +5543,9 @@ function createEditFileTool() {
     description: "Edit one sandbox workspace file with exact text replacements. Use for precise changes to existing files; prefer this over writeFile for targeted changes. Each oldText must match exactly, be unique, and not overlap another edit. Returns a diff. Multiple changes to the same file: use one edits[] call.",
     prepareArguments: prepareEditFileArguments,
     executionMode: "sequential",
-    inputSchema: z4.object({
-      path: z4.string().min(1).describe("Path to edit in the sandbox workspace."),
-      edits: z4.array(editReplacementSchema).min(1).describe(
+    inputSchema: z5.object({
+      path: z5.string().min(1).describe("Path to edit in the sandbox workspace."),
+      edits: z5.array(editReplacementSchema).min(1).describe(
         "Exact replacements matched against the original file, not incrementally."
       )
     }),
@@ -5177,7 +5560,7 @@ function createEditFileTool() {
 
 // src/chat/tools/sandbox/find-files.ts
 import path4 from "path";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var DEFAULT_FIND_LIMIT = 100;
 async function findFiles(params) {
   if (!params.pattern.trim()) {
@@ -5350,14 +5733,14 @@ function createFindFilesTool() {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z5.object({
-      pattern: z5.string().min(1).describe(
+    inputSchema: z6.object({
+      pattern: z6.string().min(1).describe(
         "Glob pattern to match, for example '*.ts', '**/*.json', or 'src/**/*.test.ts'."
       ),
-      path: z5.string().min(1).describe(
+      path: z6.string().min(1).describe(
         "Directory or file path in the sandbox workspace. Defaults to the workspace root."
       ).optional(),
-      limit: z5.coerce.number().int().min(1).describe("Maximum number of file paths to return. Defaults to 100.").optional()
+      limit: z6.coerce.number().int().min(1).describe("Maximum number of file paths to return. Defaults to 100.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async () => {
@@ -5370,12 +5753,12 @@ function createFindFilesTool() {
 
 // src/chat/tools/sandbox/grep.ts
 import path5 from "path";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var DEFAULT_GREP_LIMIT = 100;
 var MAX_GREP_LINE_CHARS = 500;
-var booleanInput = (description) => z6.preprocess(
+var booleanInput = (description) => z7.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z6.boolean()
+  z7.boolean()
 ).describe(description);
 function truncateGrepLine(value) {
   if (value.length <= MAX_GREP_LINE_CHARS) {
@@ -5729,20 +6112,20 @@ function createGrepTool() {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z6.object({
-      pattern: z6.string().min(1).describe("Regex pattern or literal text to search for."),
-      path: z6.string().min(1).describe(
+    inputSchema: z7.object({
+      pattern: z7.string().min(1).describe("Regex pattern or literal text to search for."),
+      path: z7.string().min(1).describe(
         "Directory or file path in the sandbox workspace. Defaults to the workspace root."
       ).optional(),
-      glob: z6.string().min(1).describe("Optional glob filter such as '*.ts' or '**/*.test.ts'.").optional(),
+      glob: z7.string().min(1).describe("Optional glob filter such as '*.ts' or '**/*.test.ts'.").optional(),
       ignoreCase: booleanInput(
         "Whether matching should ignore case."
       ).optional(),
       literal: booleanInput(
         "Treat pattern as literal text instead of regex."
       ).optional(),
-      context: z6.coerce.number().int().min(0).describe("Number of surrounding context lines to include.").optional(),
-      limit: z6.coerce.number().int().min(1).describe("Maximum matches to return. Defaults to 100.").optional()
+      context: z7.coerce.number().int().min(0).describe("Number of surrounding context lines to include.").optional(),
+      limit: z7.coerce.number().int().min(1).describe("Maximum matches to return. Defaults to 100.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async () => {
@@ -5753,7 +6136,7 @@ function createGrepTool() {
 
 // src/chat/tools/sandbox/list-dir.ts
 import path6 from "path";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var DEFAULT_LIST_LIMIT = 500;
 async function listDir(params) {
   const dirPath = resolveWorkspacePath(params.path);
@@ -5834,11 +6217,11 @@ function createListDirTool() {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z7.object({
-      path: z7.string().min(1).describe(
+    inputSchema: z8.object({
+      path: z8.string().min(1).describe(
         "Directory path in the sandbox workspace. Defaults to the workspace root."
       ).optional(),
-      limit: z7.coerce.number().int().min(1).describe("Maximum entries to return. Defaults to 500.").optional()
+      limit: z8.coerce.number().int().min(1).describe("Maximum entries to return. Defaults to 500.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async () => {
@@ -5850,7 +6233,7 @@ function createListDirTool() {
 }
 
 // src/chat/tools/sandbox/read-file.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/chat/tool-support/text-range-result.ts
 var DEFAULT_READ_LIMIT = 1e3;
@@ -5944,10 +6327,10 @@ function createReadFileTool() {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z8.object({
-      path: z8.string().min(1).describe("Path to the file in the sandbox workspace."),
-      offset: z8.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
-      limit: z8.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
+    inputSchema: z9.object({
+      path: z9.string().min(1).describe("Path to the file in the sandbox workspace."),
+      offset: z9.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
+      limit: z9.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async () => {
@@ -6547,25 +6930,25 @@ function createSandbox(options) {
 
 // src/chat/tools/sandbox/file-uploads.ts
 import path7 from "path";
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var MAX_SANDBOX_FILE_UPLOAD_BYTES = 10 * 1024 * 1024;
 var SANDBOX_ARTIFACTS_DIR = "/tmp/junior/artifacts";
-var sandboxFileReferenceSchema = z9.object({
-  path: z9.string().min(1).describe(
+var sandboxFileReferenceSchema = z10.object({
+  path: z10.string().min(1).describe(
     "Exact source path of an existing sandbox file. Preserve paths returned by other tools unchanged; do not move or rewrite them before sending."
   ),
-  filename: z9.string().min(1).nullable().optional().describe(
+  filename: z10.string().min(1).nullable().optional().describe(
     "Optional filename override shown to the recipient. Null is treated as omitted."
   ),
-  mimeType: z9.string().min(1).nullable().optional().describe("Optional MIME type override. Null is treated as omitted."),
-  bytes: z9.number().int().nonnegative().nullable().optional().describe(
+  mimeType: z10.string().min(1).nullable().optional().describe("Optional MIME type override. Null is treated as omitted."),
+  bytes: z10.number().int().nonnegative().nullable().optional().describe(
     "Optional known file size returned by a producing tool. Null is treated as omitted; sending tools validate the file contents directly."
   )
 });
 var generatedArtifactFileRefSchema = sandboxFileReferenceSchema.extend({
-  filename: z9.string().min(1),
-  mimeType: z9.string().min(1).optional(),
-  bytes: z9.number().int().nonnegative()
+  filename: z10.string().min(1),
+  mimeType: z10.string().min(1).optional(),
+  bytes: z10.number().int().nonnegative()
 }).strict();
 var MIME_BY_EXTENSION = {
   ".png": "image/png",
@@ -7816,7 +8199,7 @@ function serializeMcpPayload(payload, privacy, options = {}) {
 }
 
 // src/chat/tools/sandbox/bash.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 function createBashTool() {
   return zodTool({
     annotations: {
@@ -7826,10 +8209,10 @@ function createBashTool() {
       readOnlyHint: false
     },
     description: "Run a bash command inside the isolated sandbox workspace. Use this for repository inspection/execution tasks that need shell access. Do not use for network-sensitive or destructive actions unless explicitly required.",
-    inputSchema: z10.object({
-      command: z10.string().min(1).describe("Bash command to run inside the sandbox."),
-      cwd: z10.string().min(1).describe("Optional working directory for this command only.").optional(),
-      timeoutMs: z10.coerce.number().int().min(1e3).describe(
+    inputSchema: z11.object({
+      command: z11.string().min(1).describe("Bash command to run inside the sandbox."),
+      cwd: z11.string().min(1).describe("Optional working directory for this command only.").optional(),
+      timeoutMs: z11.coerce.number().int().min(1e3).describe(
         "Optional command timeout in milliseconds. Use for commands that may hang."
       ).optional()
     }),
@@ -7843,14 +8226,14 @@ function createBashTool() {
 }
 
 // src/chat/tools/web/image-generate.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var imageGenerateOutputSchema = juniorToolOutputSchema.extend({
-  model: z11.string(),
-  prompt: z11.string(),
-  enrichedPrompt: z11.string(),
-  image_count: z11.number().int().nonnegative(),
-  images: z11.array(generatedArtifactFileRefSchema),
-  delivery: z11.string()
+  model: z12.string(),
+  prompt: z12.string(),
+  enrichedPrompt: z12.string(),
+  image_count: z12.number().int().nonnegative(),
+  images: z12.array(generatedArtifactFileRefSchema),
+  delivery: z12.string()
 }).strict();
 var ENRICHMENT_SYSTEM_PROMPT = `You are an image prompt enrichment agent. Your job is to rewrite image generation requests to reflect a specific visual identity and mood.
 
@@ -7912,8 +8295,8 @@ function createImageGenerateTool(hooks, options, deps = {}) {
       readOnlyHint: false
     },
     description: "Generate images from a prompt. Use when the user wants to visually show or represent something \u2014 feelings, concepts, art, humor, or any visual idea. Also use for explicit image creation requests.",
-    inputSchema: z11.object({
-      prompt: z11.string().min(1).max(4e3).describe("Image generation prompt.")
+    inputSchema: z12.object({
+      prompt: z12.string().min(1).max(4e3).describe("Image generation prompt.")
     }),
     outputSchema: imageGenerateOutputSchema,
     execute: async ({ prompt }) => {
@@ -8003,7 +8386,7 @@ function parseMcpProviderFromToolName(toolName) {
 }
 
 // src/chat/tools/skill/call-mcp-tool.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 function resolveMcpArguments(input) {
   const extraKeys = Object.keys(input).filter(
     (key) => key !== "tool_name" && key !== "arguments"
@@ -8046,9 +8429,9 @@ function createCallMcpToolTool(mcpToolManager) {
       readOnlyHint: false
     },
     description: "Call an active MCP tool by exact tool_name. Use searchMcpTools to discover tool names and schemas; copy required provider fields into arguments. Do not call with only tool_name unless the discovered tool has no arguments. Authorization is handled by the runtime when required.",
-    inputSchema: z12.object({
-      tool_name: z12.string().min(1).describe("Exact MCP tool_name from searchMcpTools."),
-      arguments: z12.record(z12.string(), z12.unknown()).describe(
+    inputSchema: z13.object({
+      tool_name: z13.string().min(1).describe("Exact MCP tool_name from searchMcpTools."),
+      arguments: z13.record(z13.string(), z13.unknown()).describe(
         'Arguments matching the disclosed MCP tool schema, for example { "query": "..." } when searchMcpTools shows query is required.'
       ).optional()
     }).passthrough(),
@@ -8101,7 +8484,7 @@ function createCallMcpToolTool(mcpToolManager) {
 }
 
 // src/chat/tools/skill/load-skill.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 function toLoadedSkill(result, availableSkills) {
   if (typeof result.skill_name !== "string" || typeof result.description !== "string" || typeof result.skill_dir !== "string" || typeof result.instructions !== "string") {
     return null;
@@ -8151,8 +8534,8 @@ function createLoadSkillTool(availableSkills, options) {
       readOnlyHint: false
     },
     description: "Load a skill by name for this turn. The result includes working_directory; resolve skill paths there and run skill-owned bash commands from there or with absolute paths. When the skill instructions name an MCP provider, use searchMcpTools before callMcpTool. Use when a request clearly matches a known skill.",
-    inputSchema: z13.object({
-      skill_name: z13.string().min(1).describe("Skill name to load, without the leading slash.")
+    inputSchema: z14.object({
+      skill_name: z14.string().min(1).describe("Skill name to load, without the leading slash.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ skill_name }) => {
@@ -8167,7 +8550,7 @@ function createLoadSkillTool(availableSkills, options) {
 }
 
 // src/chat/tools/skill/search-mcp-tools.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // src/chat/tool-support/skill/mcp-tool-summary.ts
 function toExposedToolSummary(toolDef) {
@@ -8199,29 +8582,29 @@ function toActiveMcpCatalogSummaries(toolDefs) {
 // src/chat/tools/skill/search-mcp-tools.ts
 var DEFAULT_MAX_RESULTS = 5;
 var MAX_RESULTS = 20;
-var providerSummarySchema = z14.object({
-  provider: z14.string(),
-  description: z14.string(),
-  active: z14.boolean()
+var providerSummarySchema = z15.object({
+  provider: z15.string(),
+  description: z15.string(),
+  active: z15.boolean()
 }).strict();
-var exposedToolSummarySchema = z14.object({
-  tool_name: z14.string(),
-  mcp_tool_name: z14.string(),
-  provider: z14.string(),
-  title: z14.string().optional(),
-  description: z14.string(),
-  input_schema: z14.record(z14.string(), z14.unknown()),
-  output_schema: z14.record(z14.string(), z14.unknown()).optional(),
-  annotations: z14.record(z14.string(), z14.unknown()).optional()
+var exposedToolSummarySchema = z15.object({
+  tool_name: z15.string(),
+  mcp_tool_name: z15.string(),
+  provider: z15.string(),
+  title: z15.string().optional(),
+  description: z15.string(),
+  input_schema: z15.record(z15.string(), z15.unknown()),
+  output_schema: z15.record(z15.string(), z15.unknown()).optional(),
+  annotations: z15.record(z15.string(), z15.unknown()).optional()
 }).strict();
 var searchMcpToolsOutputSchema = juniorToolOutputSchema.extend({
-  query: z14.string().nullable(),
-  provider: z14.string().nullable(),
-  total_active_tools: z14.number().int().nonnegative(),
-  returned_tools: z14.number().int().nonnegative(),
-  execution_tool: z14.literal("callMcpTool"),
-  available_providers: z14.array(providerSummarySchema),
-  tools: z14.array(exposedToolSummarySchema)
+  query: z15.string().nullable(),
+  provider: z15.string().nullable(),
+  total_active_tools: z15.number().int().nonnegative(),
+  returned_tools: z15.number().int().nonnegative(),
+  execution_tool: z15.literal("callMcpTool"),
+  available_providers: z15.array(providerSummarySchema),
+  tools: z15.array(exposedToolSummarySchema)
 }).strict();
 function normalize(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]+/g, " ").trim();
@@ -8347,14 +8730,14 @@ function createSearchMcpToolsTool(mcpToolManager) {
       readOnlyHint: true
     },
     description: "List or search MCP providers and active MCP tools. When provider is supplied and not yet active, Junior connects to it on demand and returns tool descriptors including schemas. Without provider, returns active tools plus matching configured providers without connecting. Use when choosing a provider tool or when callMcpTool arguments are unclear.",
-    inputSchema: z14.object({
-      query: z14.string().min(1).describe(
+    inputSchema: z15.object({
+      query: z15.string().min(1).describe(
         "Optional search terms describing the MCP tool or arguments needed."
       ).optional(),
-      provider: z14.string().min(1).describe(
+      provider: z15.string().min(1).describe(
         "Optional provider name to list or search within. If configured but not yet connected, Junior activates it on demand."
       ).optional(),
-      max_results: z14.number().int().min(1).max(MAX_RESULTS).describe("Maximum matching tool descriptors to return.").optional()
+      max_results: z15.number().int().min(1).max(MAX_RESULTS).describe("Maximum matching tool descriptors to return.").optional()
     }).strict(),
     outputSchema: searchMcpToolsOutputSchema,
     privateTraceResult: (result) => ({
@@ -8394,10 +8777,10 @@ function createSearchMcpToolsTool(mcpToolManager) {
 }
 
 // src/chat/tools/sandbox/view-image.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var MAX_VIEW_IMAGE_BYTES = 5 * 1024 * 1024;
-var viewImageInputSchema = z15.object({
-  path: z15.string().min(1).describe("Path to an image file in the sandbox workspace.")
+var viewImageInputSchema = z16.object({
+  path: z16.string().min(1).describe("Path to an image file in the sandbox workspace.")
 }).strict();
 function detectImageMimeType(data) {
   if (data.length >= 8 && data.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
@@ -8464,7 +8847,7 @@ function createViewImageTool(sandbox, supportsImageInput, deps = {}) {
 }
 
 // src/chat/tools/runtime/report-progress.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 function createReportProgressTool() {
   return zodTool({
     annotations: {
@@ -8474,8 +8857,8 @@ function createReportProgressTool() {
       readOnlyHint: false
     },
     description: "Update the user-visible assistant loading message with a short progress phase. Use this only for work with multiple substantive phases or a materially long wait. Skip short lookups, routine commands, generic filler, and minor substeps. After an initial update, call it again only when the major phase meaningfully changes. Messages must be written in sentence case with a present-participle verb (e.g. 'Searching docs', 'Reviewing results', 'Running checks').",
-    inputSchema: z16.object({
-      message: z16.string().min(1).describe("Short user-facing progress message.")
+    inputSchema: z17.object({
+      message: z17.string().min(1).describe("Short user-facing progress message.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async () => ({})
@@ -8483,9 +8866,9 @@ function createReportProgressTool() {
 }
 
 // src/chat/tools/runtime/spawn-agent.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var spawnAgentOutputSchema = juniorToolOutputSchema.extend({
-  invocation_id: z17.string().min(1)
+  invocation_id: z18.string().min(1)
 });
 function createSpawnAgentTool(spawnAgent) {
   return zodTool({
@@ -8496,10 +8879,10 @@ function createSpawnAgentTool(spawnAgent) {
       openWorldHint: false,
       readOnlyHint: false
     },
-    inputSchema: z17.object({
-      task: z17.string().trim().min(1).describe("Task for the child agent"),
+    inputSchema: z18.object({
+      task: z18.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(
+      reasoning_level: z18.enum(TURN_REASONING_LEVELS).nullable().optional().describe(
         "Optional reasoning level for this delegated task only"
       )
     }).strict(),
@@ -8544,19 +8927,19 @@ function createSpawnAgentTool(spawnAgent) {
 }
 
 // src/chat/tools/list-resource-event-subscriptions.ts
-import { z as z18 } from "zod";
-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),
-  match: z18.record(z18.string(), z18.unknown()).optional(),
-  intent: z18.string().min(1),
-  expiresAtMs: z18.number().finite()
+import { z as z19 } from "zod";
+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),
+  match: z19.record(z19.string(), z19.unknown()).optional(),
+  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.merge(resultDataSchema);
 function createListResourceEventSubscriptionsTool(context) {
   return zodTool({
@@ -8569,7 +8952,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 subscriptions = await listResourceEventSubscriptions({
@@ -8596,28 +8979,28 @@ 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(),
-  matchFields: z19.record(
-    z19.string(),
-    z19.object({
-      kind: z19.enum(["boolean", "string", "number"]),
-      description: z19.string(),
-      enum: 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(),
+  matchFields: z20.record(
+    z20.string(),
+    z20.object({
+      kind: z20.enum(["boolean", "string", "number"]),
+      description: z20.string(),
+      enum: z20.array(z20.string()).optional()
     }).strict()
   ).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();
@@ -8644,12 +9027,12 @@ function createSearchResourceEventTypesTool(catalog) {
       readOnlyHint: true
     },
     description: "Search the resource event types currently enabled without creating anything. Includes plugin resources and core Workspace snapshot events. Use watchResourceEvents for temporary updates in the current conversation; use createEventTask for durable automation. This tool does not watch a resource, create a task, or list 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 }) {
@@ -8688,10 +9071,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.merge(resultDataSchema2);
 function createStopWatchingResourcesTool(context) {
@@ -8705,7 +9088,7 @@ function createStopWatchingResourcesTool(context) {
     description: "Stop one resource watch in the current conversation by id. Omit id only when the user explicitly asks to stop every watch in this conversation. 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 }) {
       let stoppedIds;
@@ -8739,25 +9122,25 @@ function createStopWatchingResourcesTool(context) {
 }
 
 // src/chat/tools/watch-resource-events.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 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."
     ),
     match: registeredResourceEventMatchSchema(),
-    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) => {
@@ -8777,20 +9160,20 @@ 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),
-  match: z21.record(z21.string(), z21.unknown()).optional(),
-  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),
+  match: z22.record(z22.string(), z22.unknown()).optional(),
+  expiresAtMs: z22.number().finite(),
   stop_watching: stopWatchingActionSchema
 }).strict();
 var outputSchema4 = juniorToolOutputSchema.merge(resultDataSchema3);
@@ -8892,7 +9275,7 @@ function createResourceEventTools(context, catalog) {
 
 // src/chat/tools/create-event-task.ts
 import { createHash } from "crypto";
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 function buildEventTaskId(args) {
   const toolCallId = args.toolCallId?.trim();
   if (!toolCallId) {
@@ -8920,13 +9303,13 @@ function createEventTaskTool(context, catalog) {
     },
     executionMode: "sequential",
     description: "Create a durable event task that executes the supplied instruction for every matching resource event. Use for whenever-this-happens-do-X automation; ordinary watch, notify, or tell-me-when requests use watchResourceEvents instead. The task 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),
-      title: z22.string().trim().min(1).max(SHORT_TITLE_MAX_LENGTH).nullable().describe(
+    inputSchema: z23.object({
+      task: z23.string().trim().min(1).max(4e3),
+      title: z23.string().trim().min(1).max(SHORT_TITLE_MAX_LENGTH).nullable().describe(
         "Optional short display title. Omit or use null to generate one from the task instruction."
       ).optional(),
       trigger,
-      credentialMode: 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(),
@@ -8957,7 +9340,9 @@ function createEventTaskTool(context, catalog) {
         if (!eventTaskMatchesDestination(existing, destination) || existing.createdBy.slackUserId !== actor.userId) {
           throw new ToolInputError("Event task operation identity is invalid.");
         }
-        return eventTaskSuccess(existing, catalog);
+        if (existing.status !== "deleted") {
+          return eventTaskSuccess(existing, catalog);
+        }
       }
       const title = await resolveTaskTitle({
         completeText,
@@ -8996,7 +9381,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",
@@ -9008,7 +9393,7 @@ function createDeleteEventTaskTool(context, catalog) {
     },
     executionMode: "sequential",
     description: "Delete an event task.",
-    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);
@@ -9022,7 +9407,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({
@@ -9033,7 +9418,7 @@ function createListEventTasksTool(context, catalog) {
       readOnlyHint: true
     },
     description: "List event tasks for the current 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);
@@ -9049,7 +9434,7 @@ function createListEventTasksTool(context, catalog) {
 
 // src/chat/tools/update-event-task.ts
 import { stableResourceEventMatchKey } from "@sentry/junior-plugin-api";
-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();
@@ -9066,11 +9451,11 @@ function createUpdateEventTaskTool(context, catalog) {
     },
     executionMode: "sequential",
     description: "Update the instruction, registered trigger, or credential use for an event task.",
-    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(),
@@ -9152,10 +9537,10 @@ 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";
+import { z as z27 } from "zod";
 
 // src/chat/scheduled-tasks/cadence.ts
 var FORMATTERS = /* @__PURE__ */ new Map();
@@ -9446,12 +9831,12 @@ function getNextRunAtMs(task, scheduledForMs, afterMs = scheduledForMs) {
 }
 
 // src/chat/scheduled-tasks/schedule-intent.ts
-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(
+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",
@@ -9460,17 +9845,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."
       ),
@@ -9480,16 +9865,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(),
@@ -9538,7 +9923,7 @@ var recurringScheduleIntentSchema = z26.object({
     });
   }
 });
-var scheduleIntentSchema = z26.union([
+var scheduleIntentSchema = z27.union([
   oneOffScheduleIntentSchema,
   recurringScheduleIntentSchema
 ]);
@@ -9733,7 +10118,7 @@ import { createHash as createHash2 } 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,}$/;
@@ -9770,36 +10155,36 @@ 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", "completed", "deleted"]),
-  task: z27.string(),
-  schedule: z27.string(),
-  timezone: z27.string(),
-  recurrence: z27.unknown().nullable(),
-  next_run_at: z27.string().nullable(),
-  destination: z27.object({
-    platform: z27.literal("slack"),
-    team_id: z27.string().min(1),
-    channel_id: z27.string().min(1)
+var compactTaskResultSchema = z28.object({
+  id: z28.string(),
+  status: z28.enum(["active", "blocked", "completed", "deleted"]),
+  task: z28.string(),
+  schedule: z28.string(),
+  timezone: z28.string(),
+  recurrence: z28.unknown().nullable(),
+  next_run_at: z28.string().nullable(),
+  destination: z28.object({
+    platform: z28.literal("slack"),
+    team_id: z28.string().min(1),
+    channel_id: z28.string().min(1)
   }).strict(),
-  conversation_access: z27.object({
-    audience: z27.enum(["direct", "group", "channel"]),
-    visibility: z27.enum(["private", "public"])
+  conversation_access: z28.object({
+    audience: z28.enum(["direct", "group", "channel"]),
+    visibility: z28.enum(["private", "public"])
   }).strict(),
-  credential_mode: z27.enum(["system", "creator"]),
-  dashboard_url: z27.string().url().nullable(),
-  last_run_at: z27.string().nullable(),
-  run_now_at: z27.string().nullable()
+  credential_mode: z28.enum(["system", "creator"]),
+  dashboard_url: z28.string().url().nullable(),
+  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);
@@ -9962,15 +10347,15 @@ function createSlackScheduleCreateTaskTool(context) {
     },
     description: "Create a one-time or recurring Junior task in the active Slack conversation when the user asks Junior to do work later or repeatedly.",
     executionMode: "sequential",
-    inputSchema: z28.object({
-      task: z28.string().min(1).max(4e3),
-      title: z28.string().trim().min(1).max(SHORT_TITLE_MAX_LENGTH).nullable().describe(
+    inputSchema: z29.object({
+      task: z29.string().min(1).max(4e3),
+      title: z29.string().trim().min(1).max(SHORT_TITLE_MAX_LENGTH).nullable().describe(
         "Optional short display title. Omit or use null to generate one from the task instruction."
       ).optional(),
       schedule: scheduleIntentSchema.describe(
         "When the task runs. The scheduler computes the exact next run from this intent and the server clock."
       ),
-      credential_mode: 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(),
@@ -10069,7 +10454,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({
     approvalMode: "review",
@@ -10081,8 +10466,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."
       )
     }),
@@ -10106,12 +10491,12 @@ function createSlackScheduleDeleteTaskTool(context) {
 }
 
 // src/chat/slack/id-param.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 function slackChannelIdParam(description) {
-  return z30.string().min(1).describe(description);
+  return z31.string().min(1).describe(description);
 }
 function slackUserIdParam(description) {
-  return z30.string().min(1).describe(description);
+  return z31.string().min(1).describe(description);
 }
 function parseRequiredSlackChannelIdParam(field, value) {
   const channelId = parseSlackChannelId(value);
@@ -10135,7 +10520,7 @@ function parseRequiredSlackUserIdParam(field, value) {
 }
 
 // src/chat/scheduled-tasks/tools/list.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 function taskMatchesQuery(task, query) {
   const normalized = query.toLowerCase();
   return [
@@ -10155,11 +10540,11 @@ function createSlackScheduleListTasksTool(context) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z31.object({
+    inputSchema: z32.object({
       channel_id: slackChannelIdParam(
         "Current destination channel ID to filter by. Use the ID from a channel mention; do not guess."
       ).nullable().optional(),
-      query: z31.string().trim().min(1).max(200).nullable().describe("Text to match in the requester's scheduled tasks.").optional()
+      query: z32.string().trim().min(1).max(200).nullable().describe("Text to match in the requester's scheduled tasks.").optional()
     }).strict(),
     outputSchema: scheduleListToolResultSchema,
     execute: async (input) => {
@@ -10207,7 +10592,7 @@ function createSlackScheduleListTasksTool(context) {
 }
 
 // src/chat/scheduled-tasks/tools/run-now.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 function createSlackScheduleRunTaskNowTool(context) {
   return zodTool({
     approvalMode: "review",
@@ -10219,8 +10604,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: z32.object({
-      task_id: z32.string().min(1).describe(
+    inputSchema: z33.object({
+      task_id: z33.string().min(1).describe(
         "ID of the active task to run now. Must be from this active Slack conversation."
       )
     }),
@@ -10248,7 +10633,7 @@ function createSlackScheduleRunTaskNowTool(context) {
 }
 
 // src/chat/scheduled-tasks/tools/update.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 import { and, eq, inArray } from "drizzle-orm";
 function createSlackScheduleUpdateTaskTool(context) {
   return zodTool({
@@ -10261,17 +10646,17 @@ function createSlackScheduleUpdateTaskTool(context) {
     },
     description: `Update a scheduled task. To move the requester's task into this Slack conversation, set destination to "here".`,
     executionMode: "sequential",
-    inputSchema: z33.object({
-      task_id: z33.string().min(1).describe("Scheduled task ID returned by slackScheduleListTasks."),
-      task: z33.string().min(1).max(4e3).optional(),
+    inputSchema: z34.object({
+      task_id: z34.string().min(1).describe("Scheduled task ID returned by slackScheduleListTasks."),
+      task: z34.string().min(1).max(4e3).optional(),
       schedule: scheduleIntentSchema.describe("Complete replacement schedule. Omit to keep it unchanged.").nullable().optional(),
-      status: z33.enum(["active", "blocked"]).describe(
+      status: z34.enum(["active", "blocked"]).describe(
         "Set active to resume a blocked task, or blocked to stop dispatch."
       ).optional(),
-      destination: z33.literal("here").nullable().describe(
+      destination: z34.literal("here").nullable().describe(
         `Set to "here" to move the creator's task into this Slack conversation. Omit to keep its destination.`
       ).optional(),
-      credential_mode: z33.enum(["system", "creator"]).nullable().describe(
+      credential_mode: z34.enum(["system", "creator"]).nullable().describe(
         "Use creator credentials or system credentials. Only the task creator may enable creator mode. Omit to keep unchanged."
       ).optional()
     }).strict(),
@@ -10630,9 +11015,9 @@ async function joinPublicChannelForRead(args) {
 }
 
 // src/chat/slack/tool-support/channel-target.ts
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 var SLACK_CHANNEL_REF_MAX_LENGTH = 160;
-var slackChannelRefParam = z34.string().trim().min(1).max(SLACK_CHANNEL_REF_MAX_LENGTH).describe(
+var slackChannelRefParam = z35.string().trim().min(1).max(SLACK_CHANNEL_REF_MAX_LENGTH).describe(
   "Slack channel id (`C123`), mention (`<#C123>` / `<#C123|name>`), Junior slack reference (`slack:C123`), or a channel name Junior already knows in this workspace."
 );
 async function resolveSlackChannelRef(input) {
@@ -10680,7 +11065,7 @@ async function resolveOptionalSlackChannelRef(input) {
 }
 
 // src/chat/slack/tools/channel-join.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 function createSlackChannelJoinTool(context) {
   return zodTool({
     description: "Join a public Slack channel.",
@@ -10690,7 +11075,7 @@ function createSlackChannelJoinTool(context) {
       openWorldHint: true,
       readOnlyHint: false
     },
-    inputSchema: z35.object({
+    inputSchema: z36.object({
       channel_id: slackChannelRefParam
     }),
     outputSchema: juniorToolOutputSchema,
@@ -10747,11 +11132,11 @@ function createSlackChannelJoinTool(context) {
 }
 
 // src/chat/slack/timestamp-param.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 function slackTimestampParam(description) {
-  return z36.preprocess(
+  return z37.preprocess(
     (value) => typeof value === "number" && Number.isFinite(value) ? String(value) : value,
-    z36.string().min(1)
+    z37.string().min(1)
   ).describe(description);
 }
 function parseSlackTimestampParam(field, value) {
@@ -10779,10 +11164,10 @@ function parseRequiredSlackTimestampParam(field, value) {
 }
 
 // src/chat/slack/tools/channel-list-messages.ts
-import { z as z37 } from "zod";
-var booleanInput2 = (description) => z37.preprocess(
+import { z as z38 } from "zod";
+var booleanInput2 = (description) => z38.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z37.boolean()
+  z38.boolean()
 ).describe(description);
 function normalizeRangeTimestamp(field, value, targetChannelId) {
   if (value === void 0) {
@@ -10814,10 +11199,10 @@ function createSlackChannelListMessagesTool(context) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z37.object({
+    inputSchema: z38.object({
       channel_id: slackChannelRefParam.optional(),
-      limit: z37.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
-      cursor: z37.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
+      limit: z38.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
+      cursor: z38.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
       oldest: slackTimestampParam(
         "Oldest message timestamp (Slack ts) for range filtering."
       ).optional(),
@@ -10827,7 +11212,7 @@ function createSlackChannelListMessagesTool(context) {
       inclusive: booleanInput2(
         "Whether oldest/latest bounds should be inclusive."
       ).optional(),
-      max_pages: z37.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
+      max_pages: z38.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({
@@ -10950,7 +11335,7 @@ function createSlackChannelListMessagesTool(context) {
 }
 
 // src/chat/slack/tools/conversation-message-search.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 
 // src/chat/conversations/tool-source.ts
 var CONVERSATIONS_TOOL_SOURCE = {
@@ -10962,23 +11347,23 @@ var CONVERSATIONS_TOOL_SOURCE = {
 var DEFAULT_LIMIT = 20;
 var MAX_LIMIT = 50;
 var conversationMessageSearchOutputSchema = juniorToolOutputSchema.extend({
-  after: z38.string().datetime().optional(),
-  annotation: z38.string().min(1).optional(),
-  before: z38.string().datetime().optional(),
-  channel_id: z38.string().min(1).optional(),
-  count: z38.number().int().nonnegative(),
-  query: z38.string().optional(),
-  matches: z38.array(
-    z38.object({
-      channel_id: z38.string().min(1),
-      channel_name: z38.string().min(1).optional(),
-      conversation_id: z38.string().min(1),
-      excerpt: z38.string(),
-      message_id: z38.string().min(1),
-      message_role: z38.enum(["assistant", "user"]),
-      message_timestamp: z38.string().datetime(),
-      permalink: z38.string().url().optional(),
-      thread_ts: z38.string().min(1)
+  after: z39.string().datetime().optional(),
+  annotation: z39.string().min(1).optional(),
+  before: z39.string().datetime().optional(),
+  channel_id: z39.string().min(1).optional(),
+  count: z39.number().int().nonnegative(),
+  query: z39.string().optional(),
+  matches: z39.array(
+    z39.object({
+      channel_id: z39.string().min(1),
+      channel_name: z39.string().min(1).optional(),
+      conversation_id: z39.string().min(1),
+      excerpt: z39.string(),
+      message_id: z39.string().min(1),
+      message_role: z39.enum(["assistant", "user"]),
+      message_timestamp: z39.string().datetime(),
+      permalink: z39.string().url().optional(),
+      thread_ts: z39.string().min(1)
     }).strict()
   )
 });
@@ -11033,15 +11418,15 @@ function createSlackConversationMessageSearchTool(scope, currentConversationId)
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z38.object({
-      after: z38.string().datetime().nullable().describe("Include conversations active at or after this timestamp.").optional(),
-      annotation: z38.string().trim().min(1).max(256).nullable().describe(
+    inputSchema: z39.object({
+      after: z39.string().datetime().nullable().describe("Include conversations active at or after this timestamp.").optional(),
+      annotation: z39.string().trim().min(1).max(256).nullable().describe(
         "Linked resource key. Matches that key, or nested children that continue with #."
       ).optional(),
-      before: z38.string().datetime().nullable().describe("Include conversations active before this timestamp.").optional(),
+      before: z39.string().datetime().nullable().describe("Include conversations active before this timestamp.").optional(),
       channel_id: slackChannelRefParam.nullable().optional(),
-      query: z38.string().trim().min(1).max(200).nullable().describe("Words or phrase to match in message text.").optional(),
-      limit: z38.number().int().min(1).max(MAX_LIMIT).describe(
+      query: z39.string().trim().min(1).max(200).nullable().describe("Words or phrase to match in message text.").optional(),
+      limit: z39.number().int().min(1).max(MAX_LIMIT).describe(
         `Maximum conversations. Default ${DEFAULT_LIMIT}; max ${MAX_LIMIT}.`
       ).nullable().optional()
     }).strict(),
@@ -11100,13 +11485,13 @@ function createSlackConversationMessageSearchTool(scope, currentConversationId)
 }
 
 // src/chat/slack/tools/public-search.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 var DEFAULT_LIMIT2 = 10;
 var DEFAULT_CONTENT_TYPES = ["messages"];
 var CONTENT_TYPES = ["messages", "files", "channels", "users"];
-var unixTimestampParam = z39.coerce.number().int().nonnegative();
+var unixTimestampParam = z40.coerce.number().int().nonnegative();
 function optionalUnixTimestampParam(description) {
-  return z39.preprocess(
+  return z40.preprocess(
     (value) => typeof value === "string" && value.trim() === "" ? void 0 : value,
     unixTimestampParam.optional()
   ).describe(description);
@@ -11120,64 +11505,64 @@ function normalizeOptionalUnixTimestamp(value) {
   }
   return unixTimestampParam.parse(value);
 }
-var searchMessageSchema = z39.object({
-  author_name: z39.string().min(1).optional().describe("Author display name."),
-  author_user_id: z39.string().min(1).optional().describe("Author user ID."),
-  channel_id: z39.string().min(1).describe("Channel ID."),
-  channel_name: z39.string().min(1).optional().describe("Channel name."),
-  message_ts: z39.string().min(1).describe("Message timestamp."),
-  content: z39.string().describe("Message text."),
-  is_author_bot: z39.boolean().optional().describe("Whether the author is a bot."),
-  permalink: z39.string().url().describe("Message permalink.")
+var searchMessageSchema = z40.object({
+  author_name: z40.string().min(1).optional().describe("Author display name."),
+  author_user_id: z40.string().min(1).optional().describe("Author user ID."),
+  channel_id: z40.string().min(1).describe("Channel ID."),
+  channel_name: z40.string().min(1).optional().describe("Channel name."),
+  message_ts: z40.string().min(1).describe("Message timestamp."),
+  content: z40.string().describe("Message text."),
+  is_author_bot: z40.boolean().optional().describe("Whether the author is a bot."),
+  permalink: z40.string().url().describe("Message permalink.")
 });
-var searchFileSchema = z39.object({
-  file_id: z39.string().min(1).describe("File ID."),
-  title: z39.string().min(1).optional().describe("File title."),
-  name: z39.string().min(1).optional().describe("File name."),
-  filetype: z39.string().min(1).optional().describe("File type."),
-  user_id: z39.string().min(1).optional().describe("Uploader user ID."),
-  user_name: z39.string().min(1).optional().describe("Uploader user name."),
-  channel_id: z39.string().min(1).optional().describe("Channel ID."),
-  channel_name: z39.string().min(1).optional().describe("Channel name."),
-  permalink: z39.string().url().optional().describe("File permalink."),
-  content: z39.string().min(1).optional().describe("File preview or content snippet.")
+var searchFileSchema = z40.object({
+  file_id: z40.string().min(1).describe("File ID."),
+  title: z40.string().min(1).optional().describe("File title."),
+  name: z40.string().min(1).optional().describe("File name."),
+  filetype: z40.string().min(1).optional().describe("File type."),
+  user_id: z40.string().min(1).optional().describe("Uploader user ID."),
+  user_name: z40.string().min(1).optional().describe("Uploader user name."),
+  channel_id: z40.string().min(1).optional().describe("Channel ID."),
+  channel_name: z40.string().min(1).optional().describe("Channel name."),
+  permalink: z40.string().url().optional().describe("File permalink."),
+  content: z40.string().min(1).optional().describe("File preview or content snippet.")
 });
-var searchChannelSchema = z39.object({
-  channel_id: z39.string().min(1).describe("Channel ID."),
-  channel_name: z39.string().min(1).optional().describe("Channel name."),
-  is_private: z39.boolean().optional().describe("Whether the channel is private."),
-  is_member: z39.boolean().optional().describe("Whether the bot is a member."),
-  topic: z39.string().min(1).optional().describe("Channel topic."),
-  purpose: z39.string().min(1).optional().describe("Channel purpose."),
-  permalink: z39.string().url().optional().describe("Channel permalink.")
+var searchChannelSchema = z40.object({
+  channel_id: z40.string().min(1).describe("Channel ID."),
+  channel_name: z40.string().min(1).optional().describe("Channel name."),
+  is_private: z40.boolean().optional().describe("Whether the channel is private."),
+  is_member: z40.boolean().optional().describe("Whether the bot is a member."),
+  topic: z40.string().min(1).optional().describe("Channel topic."),
+  purpose: z40.string().min(1).optional().describe("Channel purpose."),
+  permalink: z40.string().url().optional().describe("Channel permalink.")
 });
-var searchUserSchema = z39.object({
-  user_id: z39.string().min(1).describe("User ID."),
-  user_name: z39.string().min(1).optional().describe("Username."),
-  real_name: z39.string().min(1).optional().describe("Real name."),
-  display_name: z39.string().min(1).optional().describe("Display name."),
-  title: z39.string().min(1).optional().describe("Profile title."),
-  permalink: z39.string().url().optional().describe("Profile permalink.")
+var searchUserSchema = z40.object({
+  user_id: z40.string().min(1).describe("User ID."),
+  user_name: z40.string().min(1).optional().describe("Username."),
+  real_name: z40.string().min(1).optional().describe("Real name."),
+  display_name: z40.string().min(1).optional().describe("Display name."),
+  title: z40.string().min(1).optional().describe("Profile title."),
+  permalink: z40.string().url().optional().describe("Profile permalink.")
 });
 var publicSearchOutputSchema = juniorToolOutputSchema.extend({
-  query: z39.string().describe("Search query."),
-  content_types: z39.array(z39.enum(CONTENT_TYPES)).describe("Content types included in the search."),
-  count: z39.number().int().nonnegative().describe("Total matched results."),
-  messages: z39.array(searchMessageSchema).describe("Matched messages."),
-  files: z39.array(searchFileSchema).describe("Matched files."),
-  channels: z39.array(searchChannelSchema).describe("Matched channels."),
-  users: z39.array(searchUserSchema).describe("Matched users."),
-  next_cursor: z39.string().min(1).optional().describe("Cursor for the next result page.")
+  query: z40.string().describe("Search query."),
+  content_types: z40.array(z40.enum(CONTENT_TYPES)).describe("Content types included in the search."),
+  count: z40.number().int().nonnegative().describe("Total matched results."),
+  messages: z40.array(searchMessageSchema).describe("Matched messages."),
+  files: z40.array(searchFileSchema).describe("Matched files."),
+  channels: z40.array(searchChannelSchema).describe("Matched channels."),
+  users: z40.array(searchUserSchema).describe("Matched users."),
+  next_cursor: z40.string().min(1).optional().describe("Cursor for the next result page.")
 });
-var nonEmptyString = z39.string().trim().min(1);
-var optionalWireString = z39.preprocess((value) => {
+var nonEmptyString = z40.string().trim().min(1);
+var optionalWireString = z40.preprocess((value) => {
   if (typeof value !== "string") {
     return void 0;
   }
   const trimmed = value.trim();
   return trimmed === "" ? void 0 : trimmed;
 }, nonEmptyString.optional());
-var optionalWireUrl = z39.preprocess((value) => {
+var optionalWireUrl = z40.preprocess((value) => {
   if (typeof value !== "string") {
     return void 0;
   }
@@ -11191,20 +11576,20 @@ var optionalWireUrl = z39.preprocess((value) => {
   } catch {
     return void 0;
   }
-}, z39.string().url().optional());
-var optionalWireBoolean = z39.preprocess(
+}, z40.string().url().optional());
+var optionalWireBoolean = z40.preprocess(
   (value) => typeof value === "boolean" ? value : void 0,
-  z39.boolean().optional()
+  z40.boolean().optional()
 );
-var slackSearchMessageWireSchema = z39.object({
+var slackSearchMessageWireSchema = z40.object({
   author_name: optionalWireString,
   author_user_id: optionalWireString,
   channel_id: nonEmptyString,
   channel_name: optionalWireString,
   message_ts: nonEmptyString,
-  content: z39.string(),
+  content: z40.string(),
   is_author_bot: optionalWireBoolean,
-  permalink: z39.string().url()
+  permalink: z40.string().url()
 }).transform(
   (value) => ({
     channel_id: value.channel_id,
@@ -11217,7 +11602,7 @@ var slackSearchMessageWireSchema = z39.object({
     ...value.is_author_bot !== void 0 ? { is_author_bot: value.is_author_bot } : void 0
   })
 );
-var slackSearchFileWireSchema = z39.object({
+var slackSearchFileWireSchema = z40.object({
   id: optionalWireString,
   file_id: optionalWireString,
   title: optionalWireString,
@@ -11251,7 +11636,7 @@ var slackSearchFileWireSchema = z39.object({
     ...value.content ?? value.preview ? { content: value.content ?? value.preview } : void 0
   };
 });
-var slackSearchChannelWireSchema = z39.object({
+var slackSearchChannelWireSchema = z40.object({
   id: optionalWireString,
   channel_id: optionalWireString,
   name: optionalWireString,
@@ -11276,7 +11661,7 @@ var slackSearchChannelWireSchema = z39.object({
     ...value.permalink ? { permalink: value.permalink } : void 0
   };
 });
-var slackSearchUserWireSchema = z39.object({
+var slackSearchUserWireSchema = z40.object({
   id: optionalWireString,
   user_id: optionalWireString,
   name: optionalWireString,
@@ -11300,12 +11685,12 @@ var slackSearchUserWireSchema = z39.object({
     ...value.permalink ? { permalink: value.permalink } : void 0
   };
 });
-var slackSearchResponseSchema = z39.object({
-  results: z39.object({
-    messages: z39.array(z39.unknown()).default([]),
-    files: z39.array(z39.unknown()).default([]),
-    channels: z39.array(z39.unknown()).default([]),
-    users: z39.array(z39.unknown()).default([]),
+var slackSearchResponseSchema = z40.object({
+  results: z40.object({
+    messages: z40.array(z40.unknown()).default([]),
+    files: z40.array(z40.unknown()).default([]),
+    channels: z40.array(z40.unknown()).default([]),
+    users: z40.array(z40.unknown()).default([]),
     // Slack often returns "" on the final page; omit rather than fail the parse.
     next_cursor: optionalWireString
   }).default({
@@ -11354,15 +11739,15 @@ function createSlackPublicSearchTool(actionToken) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z39.object({
-      query: z39.string().trim().min(1).max(500).describe("Slack search query."),
-      content_types: z39.array(z39.enum(CONTENT_TYPES)).min(1).max(4).describe("Content types to include. Defaults to messages.").optional(),
+    inputSchema: z40.object({
+      query: z40.string().trim().min(1).max(500).describe("Slack search query."),
+      content_types: z40.array(z40.enum(CONTENT_TYPES)).min(1).max(4).describe("Content types to include. Defaults to messages.").optional(),
       after: optionalUnixTimestampParam("Unix timestamp lower bound."),
       before: optionalUnixTimestampParam("Unix timestamp upper bound."),
-      cursor: z39.string().min(1).describe("Cursor for the next result page.").optional(),
-      limit: z39.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
-      sort: z39.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
-      sort_dir: z39.enum(["asc", "desc"]).describe("Sort direction.").optional()
+      cursor: z40.string().min(1).describe("Cursor for the next result page.").optional(),
+      limit: z40.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
+      sort: z40.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
+      sort_dir: z40.enum(["asc", "desc"]).describe("Sort direction.").optional()
     }),
     outputSchema: publicSearchOutputSchema,
     execute: async ({
@@ -11447,7 +11832,7 @@ function createSlackPublicSearchTool(actionToken) {
 }
 
 // src/chat/slack/tools/message-add-reaction.ts
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 
 // src/chat/tools/idempotency.ts
 function stableSerialize(value) {
@@ -11478,8 +11863,8 @@ function createSlackMessageAddReactionTool(context, state) {
       readOnlyHint: false
     },
     description: "Add an emoji reaction to the current inbound Slack message.",
-    inputSchema: z40.object({
-      emoji: z40.string().min(1).max(64).describe(
+    inputSchema: z41.object({
+      emoji: z41.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."
       )
     }),
@@ -11528,14 +11913,14 @@ function createSlackMessageAddReactionTool(context, state) {
 
 // src/chat/slack/tools/send-files.ts
 import { createHash as createHash3 } from "crypto";
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 var sendFilesResultSchema = juniorToolOutputSchema.extend({
-  deduplicated: z41.boolean().optional(),
-  attachment_refs: z41.array(
-    z41.object({
-      id: z41.string().min(1),
+  deduplicated: z42.boolean().optional(),
+  attachment_refs: z42.array(
+    z42.object({
+      id: z42.string().min(1),
       // Same noun as storage, delivery events, and the report API.
-      filename: z41.string().min(1)
+      filename: z42.string().min(1)
     })
   )
 });
@@ -11567,8 +11952,8 @@ function createSendFilesTool(context, state, materializeFile, attachments) {
       readOnlyHint: false
     },
     description: "Send one or more sandbox files into the active Slack conversation.",
-    inputSchema: z41.object({
-      files: z41.array(sandboxFileReferenceSchema).min(1).describe(
+    inputSchema: z42.object({
+      files: z42.array(sandboxFileReferenceSchema).min(1).describe(
         "One or more existing sandbox files. Objects returned by imageGenerate or webFetch can be passed unchanged."
       )
     }),
@@ -11987,7 +12372,7 @@ async function readCanvas(canvasIdOrUrl) {
 }
 
 // src/chat/slack/tools/canvas/create.ts
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 function createSlackCanvasCreateTool(context, state) {
   return zodTool({
     annotations: {
@@ -11997,9 +12382,9 @@ function createSlackCanvasCreateTool(context, state) {
       readOnlyHint: false
     },
     description: "Create a Slack canvas in the active channel.",
-    inputSchema: z42.object({
-      title: z42.string().min(1).max(160).describe("Canvas title."),
-      markdown: z42.string().min(1).describe("Canvas markdown body content.")
+    inputSchema: z43.object({
+      title: z43.string().min(1).max(160).describe("Canvas title."),
+      markdown: z43.string().min(1).describe("Canvas markdown body content.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ title, markdown }) => {
@@ -12043,8 +12428,8 @@ function createSlackCanvasCreateTool(context, state) {
 }
 
 // src/chat/slack/tool-support/canvas/context.ts
-import { z as z43 } from "zod";
-var slackCanvasRefParam = z43.string().min(1).describe("Slack canvas/file ID or canvas/docs URL.");
+import { z as z44 } from "zod";
+var slackCanvasRefParam = z44.string().min(1).describe("Slack canvas/file ID or canvas/docs URL.");
 function resolveCanvasTarget(canvas) {
   const canvasId = extractCanvasId(canvas);
   if (!canvasId) {
@@ -12057,26 +12442,26 @@ function resolveCanvasTarget(canvas) {
 }
 
 // src/chat/slack/tools/canvas/edit.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 function prepareCanvasEditArguments(input) {
   return prepareTextReplacementArguments(input);
 }
-var editReplacementSchema2 = z44.object({
-  oldText: z44.string().min(1).describe(
+var editReplacementSchema2 = z45.object({
+  oldText: z45.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: z44.string().describe("Replacement Canvas markdown for this edit.")
+  newText: z45.string().describe("Replacement Canvas markdown for this edit.")
 });
 var slackCanvasEditOutputSchema = juniorToolOutputSchema.extend({
-  canvas_id: z44.string().optional(),
-  title: z44.string().optional(),
-  permalink: z44.string().optional(),
-  diff: z44.string().optional(),
-  first_changed_line: z44.number().int().positive().optional(),
-  replacements: z44.number().int().nonnegative().optional(),
-  normalized_heading_count: z44.number().int().nonnegative().optional(),
-  summary: z44.string().optional(),
-  deduplicated: z44.boolean().optional()
+  canvas_id: z45.string().optional(),
+  title: z45.string().optional(),
+  permalink: z45.string().optional(),
+  diff: z45.string().optional(),
+  first_changed_line: z45.number().int().positive().optional(),
+  replacements: z45.number().int().nonnegative().optional(),
+  normalized_heading_count: z45.number().int().nonnegative().optional(),
+  summary: z45.string().optional(),
+  deduplicated: z45.boolean().optional()
 }).strict();
 function createSlackCanvasEditTool(state) {
   return zodTool({
@@ -12089,9 +12474,9 @@ function createSlackCanvasEditTool(state) {
     description: "Edit a Slack canvas with exact markdown replacements. Returns a diff.",
     prepareArguments: prepareCanvasEditArguments,
     executionMode: "sequential",
-    inputSchema: z44.object({
+    inputSchema: z45.object({
       canvas: slackCanvasRefParam,
-      edits: z44.array(editReplacementSchema2).min(1).describe(
+      edits: z45.array(editReplacementSchema2).min(1).describe(
         "Exact replacements matched against the current Canvas body, not incrementally."
       )
     }),
@@ -12144,18 +12529,18 @@ function createSlackCanvasEditTool(state) {
 }
 
 // src/chat/slack/tools/canvas/read.ts
-import { z as z45 } from "zod";
+import { z as z46 } from "zod";
 var slackCanvasReadOutputSchema = juniorToolOutputSchema.extend({
-  canvas_id: z45.string().optional(),
-  title: z45.string().optional(),
-  permalink: z45.string().optional(),
-  mimetype: z45.string().optional(),
-  filetype: z45.string().optional(),
-  original_byte_length: z45.number().int().nonnegative().optional(),
-  content: z45.string().optional(),
-  start_line: z45.number().int().positive().optional(),
-  end_line: z45.number().int().nonnegative().optional(),
-  total_lines: z45.number().int().nonnegative().optional()
+  canvas_id: z46.string().optional(),
+  title: z46.string().optional(),
+  permalink: z46.string().optional(),
+  mimetype: z46.string().optional(),
+  filetype: z46.string().optional(),
+  original_byte_length: z46.number().int().nonnegative().optional(),
+  content: z46.string().optional(),
+  start_line: z46.number().int().positive().optional(),
+  end_line: z46.number().int().nonnegative().optional(),
+  total_lines: z46.number().int().nonnegative().optional()
 }).strict();
 function createSlackCanvasReadTool() {
   return zodTool({
@@ -12166,10 +12551,10 @@ function createSlackCanvasReadTool() {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z45.object({
+    inputSchema: z46.object({
       canvas: slackCanvasRefParam,
-      offset: z45.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
-      limit: z45.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
+      offset: z46.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
+      limit: z46.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
     }),
     outputSchema: slackCanvasReadOutputSchema,
     execute: async ({ canvas, offset, limit }) => {
@@ -12205,7 +12590,7 @@ function createSlackCanvasReadTool() {
 }
 
 // src/chat/slack/tools/canvas/write.ts
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 function createSlackCanvasWriteTool(state) {
   return zodTool({
     annotations: {
@@ -12216,9 +12601,9 @@ function createSlackCanvasWriteTool(state) {
     },
     description: "Replace the full markdown body of a Slack canvas.",
     executionMode: "sequential",
-    inputSchema: z46.object({
+    inputSchema: z47.object({
       canvas: slackCanvasRefParam,
-      content: z46.string().describe("UTF-8 markdown content to write.")
+      content: z47.string().describe("UTF-8 markdown content to write.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ canvas, content }) => {
@@ -12440,12 +12825,12 @@ async function updateListItem(input) {
 }
 
 // src/chat/slack/tool-support/list/params.ts
-import { z as z47 } from "zod";
-var slackListIdParam = z47.string().min(1).describe("Slack list ID.");
-var slackListItemIdParam = z47.string().min(1).describe("Slack list item ID.");
+import { z as z48 } from "zod";
+var slackListIdParam = z48.string().min(1).describe("Slack list ID.");
+var slackListItemIdParam = z48.string().min(1).describe("Slack list item ID.");
 
 // src/chat/slack/tools/list/add-items.ts
-import { z as z48 } from "zod";
+import { z as z49 } from "zod";
 function createSlackListAddItemsTool(state) {
   return zodTool({
     annotations: {
@@ -12455,13 +12840,13 @@ function createSlackListAddItemsTool(state) {
       readOnlyHint: false
     },
     description: "Add tasks to a Slack list.",
-    inputSchema: z48.object({
+    inputSchema: z49.object({
       list_id: slackListIdParam,
-      items: z48.array(z48.string().min(1)).min(1).max(25).describe("List item titles to create."),
+      items: z49.array(z49.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: z48.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
+      due_date: z49.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ list_id, items, assignee_user_id, due_date }) => {
@@ -12500,7 +12885,7 @@ function createSlackListAddItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/create.ts
-import { z as z49 } from "zod";
+import { z as z50 } from "zod";
 function createSlackListCreateTool(state) {
   return zodTool({
     annotations: {
@@ -12510,8 +12895,8 @@ function createSlackListCreateTool(state) {
       readOnlyHint: false
     },
     description: "Create a Slack todo list.",
-    inputSchema: z49.object({
-      name: z49.string().min(1).max(160).describe("Name for the new Slack list.")
+    inputSchema: z50.object({
+      name: z50.string().min(1).max(160).describe("Name for the new Slack list.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ name }) => {
@@ -12536,7 +12921,7 @@ function createSlackListCreateTool(state) {
 }
 
 // src/chat/slack/tools/list/get-items.ts
-import { z as z50 } from "zod";
+import { z as z51 } from "zod";
 function createSlackListGetItemsTool() {
   return zodTool({
     description: "Read items from a Slack list.",
@@ -12546,9 +12931,9 @@ function createSlackListGetItemsTool() {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z50.object({
+    inputSchema: z51.object({
       list_id: slackListIdParam,
-      limit: z50.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
+      limit: z51.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ list_id, limit }) => {
@@ -12563,23 +12948,23 @@ function createSlackListGetItemsTool() {
 }
 
 // src/chat/slack/tools/list/update-item.ts
-import { z as z51 } from "zod";
-var booleanInput3 = (description) => z51.preprocess(
+import { z as z52 } from "zod";
+var booleanInput3 = (description) => z52.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z51.boolean()
+  z52.boolean()
 ).describe(description);
-var updateListItemInputSchema = z51.union([
-  z51.object({
+var updateListItemInputSchema = z52.union([
+  z52.object({
     list_id: slackListIdParam,
     item_id: slackListItemIdParam,
     completed: booleanInput3("Optional completion status update."),
-    title: z51.string().min(1).describe("Optional new item title.").optional()
+    title: z52.string().min(1).describe("Optional new item title.").optional()
   }),
-  z51.object({
+  z52.object({
     list_id: slackListIdParam,
     item_id: slackListItemIdParam,
     completed: booleanInput3("Optional completion status update.").optional(),
-    title: z51.string().min(1).describe("Optional new item title.")
+    title: z52.string().min(1).describe("Optional new item title.")
   })
 ]);
 function createSlackListUpdateItemTool(state) {
@@ -12627,7 +13012,7 @@ function createSlackListUpdateItemTool(state) {
 }
 
 // src/chat/slack/tools/thread-read.ts
-import { z as z52 } from "zod";
+import { z as z53 } from "zod";
 
 // src/chat/slack/tool-support/slack-message-url.ts
 var SLACK_HOST_PATTERN = /^[a-z0-9-]+\.slack(?:-gov)?\.com$/;
@@ -12893,14 +13278,14 @@ function createSlackThreadReadTool(context) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z52.object({
-      url: z52.string().min(1).describe("Slack message archive URL.").optional(),
+    inputSchema: z53.object({
+      url: z53.string().min(1).describe("Slack message archive URL.").optional(),
       channel_id: slackChannelRefParam.optional(),
       ts: slackTimestampParam(
         "Slack message timestamp. May be the thread root or any message in the thread."
       ).optional(),
-      limit: z52.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
-      max_pages: z52.coerce.number().int().min(1).max(10).describe("Maximum number of Slack API pages to traverse.").optional()
+      limit: z53.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
+      max_pages: z53.coerce.number().int().min(1).max(10).describe("Maximum number of Slack API pages to traverse.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ url, channel_id, ts, limit, max_pages }) => {
@@ -13027,7 +13412,7 @@ function createSlackThreadReadTool(context) {
 // src/chat/tools/user-lookup.ts
 import { and as and2, eq as eq2, or, sql } from "drizzle-orm";
 import { alias } from "drizzle-orm/pg-core";
-import { z as z53 } from "zod";
+import { z as z54 } from "zod";
 var linkedSlackIdentity = alias(juniorIdentities, "user_lookup_slack_identity");
 function explicitUserLookupError(error) {
   if (error.apiError === "user_not_found" || error.code === "not_found") {
@@ -13176,9 +13561,9 @@ function createUserLookupTool(teamId, providers) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z53.object({
-      provider: z53.enum(providers).describe("Enabled identity provider to query."),
-      query: z53.string().trim().min(1).describe("Provider subject ID, handle, Slack email, or Slack name.")
+    inputSchema: z54.object({
+      provider: z54.enum(providers).describe("Enabled identity provider to query."),
+      query: z54.string().trim().min(1).describe("Provider subject ID, handle, Slack email, or Slack name.")
     }).strict(),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ provider, query }) => {
@@ -13198,18 +13583,18 @@ function createUserLookupTool(teamId, providers) {
 }
 
 // src/chat/tools/system-time.ts
-import { z as z54 } from "zod";
-var systemTimeInputSchema = z54.object({
-  timezone: z54.string().trim().min(1).optional().describe(
+import { z as z55 } from "zod";
+var systemTimeInputSchema = z55.object({
+  timezone: z55.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: z54.number(),
-  iso_utc: z54.string(),
-  iso_local: z54.string(),
-  timezone: z54.string().nullable(),
-  timezone_offset_minutes: z54.number()
+  unix_ms: z55.number(),
+  iso_utc: z55.string(),
+  iso_local: z55.string(),
+  timezone: z55.string().nullable(),
+  timezone_offset_minutes: z55.number()
 });
 function createSystemTimeTool() {
   return zodTool({
@@ -13289,7 +13674,7 @@ function getTimeZoneOffsetMinutes(timestampMs, timezone) {
 }
 
 // src/chat/tools/publish-image.ts
-import { z as z55 } from "zod";
+import { z as z56 } from "zod";
 
 // src/chat/artifacts/store.ts
 import { createHash as createHash4, randomUUID as randomUUID4 } from "crypto";
@@ -13490,10 +13875,10 @@ function unpublishedArtifactHeaders() {
 
 // src/chat/tools/publish-image.ts
 var outputSchema5 = juniorToolOutputSchema.extend({
-  bytes: z55.number().int().positive(),
-  content_type: z55.string().min(1),
-  public: z55.literal(true),
-  url: z55.string().url()
+  bytes: z56.number().int().positive(),
+  content_type: z56.string().min(1),
+  public: z56.literal(true),
+  url: z56.string().url()
 });
 function createPublishImageTool(args) {
   return zodTool({
@@ -13507,8 +13892,8 @@ function createPublishImageTool(args) {
     description: "Publish one sandbox image to a durable public HTTPS URL. Anyone on the internet with the URL can view the image. Use only when an external destination needs a public image URL. Do not use for private file sharing or private conversation storage. Supports PNG, JPEG, GIF, and WebP up to 10 MB.",
     describeProposal: ({ path: path8 }) => `Publish sandbox image ${path8} to a public internet URL.`,
     executionMode: "sequential",
-    inputSchema: z55.object({
-      path: z55.string().min(1).describe("Exact sandbox path of an existing image file.")
+    inputSchema: z56.object({
+      path: z56.string().min(1).describe("Exact sandbox path of an existing image file.")
     }).strict(),
     outputSchema: outputSchema5,
     async execute({ path: path8 }) {
@@ -13541,10 +13926,10 @@ function createPublishImageTool(args) {
 }
 
 // src/chat/tools/unpublish-image.ts
-import { z as z56 } from "zod";
+import { z as z57 } from "zod";
 var outputSchema6 = juniorToolOutputSchema.extend({
-  filename: z56.string().min(1),
-  unpublished: z56.literal(true)
+  filename: z57.string().min(1),
+  unpublished: z57.literal(true)
 });
 function createUnpublishImageTool(args) {
   return zodTool({
@@ -13558,8 +13943,8 @@ function createUnpublishImageTool(args) {
     description: "Unpublish one public image previously published in this conversation so its public URL stops serving. Pass the public artifact URL or `<id>.<ext>` filename. Only images owned by this conversation can be unpublished. Republishing the same image bytes later in this conversation restores a live URL for this conversation. Does not remove copies already fetched by browsers or GitHub.",
     describeProposal: ({ ref }) => `Unpublish public image ${ref}.`,
     executionMode: "sequential",
-    inputSchema: z56.object({
-      ref: z56.string().min(1).describe(
+    inputSchema: z57.object({
+      ref: z57.string().min(1).describe(
         "Public artifact URL or artifact filename (`<id>.<ext>`)."
       )
     }).strict(),
@@ -13579,27 +13964,27 @@ function createUnpublishImageTool(args) {
 }
 
 // src/chat/tools/search-conversation-events.ts
-import { z as z57 } from "zod";
+import { z as z58 } from "zod";
 var DEFAULT_LIMIT3 = 25;
 var MAX_LIMIT2 = 100;
 var MAX_EVENT_DATA_BYTES = 4e3;
 var MAX_EVENTS_JSON_BYTES = 2e4;
 var MAX_IDENTITY_CHARS = 256;
 var textEncoder = new TextEncoder();
-var knownEventTypeSchema = z57.enum(KNOWN_CONVERSATION_EVENT_TYPES);
-var projectedEventSchema = z57.object({
-  seq: z57.number().int().nonnegative().describe("Stable event position for pagination."),
-  history_version: z57.number().int().nonnegative().describe("Agent history generation after replacement."),
-  created_at: z57.iso.datetime().describe("When the event was recorded."),
-  idempotency_key: z57.string().min(1).optional().describe("Retry-stable event identity, when assigned."),
-  data: z57.record(z57.string(), z57.unknown()).describe("Bounded event data.")
+var knownEventTypeSchema = z58.enum(KNOWN_CONVERSATION_EVENT_TYPES);
+var projectedEventSchema = z58.object({
+  seq: z58.number().int().nonnegative().describe("Stable event position for pagination."),
+  history_version: z58.number().int().nonnegative().describe("Agent history generation after replacement."),
+  created_at: z58.iso.datetime().describe("When the event was recorded."),
+  idempotency_key: z58.string().min(1).optional().describe("Retry-stable event identity, when assigned."),
+  data: z58.record(z58.string(), z58.unknown()).describe("Bounded event data.")
 }).strict();
 var searchConversationEventsOutputSchema = juniorToolOutputSchema.extend({
-  conversation_id: z57.string().min(1),
-  events: z57.array(projectedEventSchema),
-  has_older: z57.boolean().describe("Whether matching older events exist."),
-  has_newer: z57.boolean().describe("Whether matching newer events exist."),
-  omitted_event_count: z57.number().int().nonnegative().optional().describe("Events omitted by the response byte limit.")
+  conversation_id: z58.string().min(1),
+  events: z58.array(projectedEventSchema),
+  has_older: z58.boolean().describe("Whether matching older events exist."),
+  has_newer: z58.boolean().describe("Whether matching newer events exist."),
+  omitted_event_count: z58.number().int().nonnegative().optional().describe("Events omitted by the response byte limit.")
 });
 function createSearchConversationEventsTool(context) {
   return zodTool({
@@ -13612,16 +13997,16 @@ function createSearchConversationEventsTool(context) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z57.object({
-      conversation_id: z57.string().trim().min(1).nullable().describe(
+    inputSchema: z58.object({
+      conversation_id: z58.string().trim().min(1).nullable().describe(
         "Conversation ID to search. Omit or null for the current conversation."
       ).optional(),
-      after_seq: z57.number().int().nonnegative().nullable().describe("Exclusive event sequence lower bound; returns ascending.").optional(),
-      before_seq: z57.number().int().nonnegative().nullable().describe("Exclusive event sequence upper bound.").optional(),
-      limit: z57.number().int().min(1).max(MAX_LIMIT2).nullable().describe(
+      after_seq: z58.number().int().nonnegative().nullable().describe("Exclusive event sequence lower bound; returns ascending.").optional(),
+      before_seq: z58.number().int().nonnegative().nullable().describe("Exclusive event sequence upper bound.").optional(),
+      limit: z58.number().int().min(1).max(MAX_LIMIT2).nullable().describe(
         `Maximum events. Default ${DEFAULT_LIMIT3}; max ${MAX_LIMIT2}.`
       ).optional(),
-      types: z57.array(knownEventTypeSchema).min(1).nullable().describe("Event types to include; omit for all types.").optional()
+      types: z58.array(knownEventTypeSchema).min(1).nullable().describe("Event types to include; omit for all types.").optional()
     }).strict(),
     outputSchema: searchConversationEventsOutputSchema,
     execute: async (input) => {
@@ -13870,14 +14255,21 @@ function stripReplacementHistoryField(value) {
 }
 
 // src/chat/tools/handoff/tool.ts
-import { z as z58 } from "zod";
+import { z as z59 } from "zod";
 var HANDOFF_TOOL_NAME = "handoff";
+function formatHandoffProfiles(handoff) {
+  return handoff.profiles.map(
+    (profile) => `- ${formatModelProfile(profile.name, profile.description)}`
+  ).join("\n");
+}
 function createHandoffTool(handoff) {
-  const profileSchema = z58.enum(handoff.profiles);
+  const profileSchema = z59.enum(
+    handoff.profiles.map((profile) => profile.name)
+  );
   const handoffResultSchema = juniorToolOutputSchema.extend({
     model_profile: modelProfileSchema
   });
-  const profileNames = handoff.profiles.map((profile) => `\`${profile}\``).join(", ");
+  const profileList = formatHandoffProfiles(handoff);
   return zodTool({
     annotations: {
       destructiveHint: false,
@@ -13885,10 +14277,21 @@ function createHandoffTool(handoff) {
       openWorldHint: false,
       readOnlyHint: false
     },
-    description: `Switch to another model profile and continue the same task. Profiles: ${profileNames}. Call this as the only tool.`,
+    description: [
+      "Switch this conversation to another configured model profile and continue the same task.",
+      "Call this as the only tool in the assistant turn, before substantial analysis or implementation, when a listed profile's description fits the task better than the current profile.",
+      "Use each description's use and avoid cases. Do not select by the profile name or assume that a non-default profile is stronger.",
+      "Do not call this for ordinary lookups, short answers, light investigation, or only because the task mentions code.",
+      "Do not call this after you have done the difficult work on the current profile. Do not combine it with other tools in the same assistant message.",
+      "A successful handoff becomes the active profile for later turns. Another handoff can change it again.",
+      `Available profiles:
+${profileList}`
+    ].join(" "),
     executionMode: "sequential",
-    inputSchema: z58.object({
-      profile: profileSchema.describe("Target model profile")
+    inputSchema: z59.object({
+      profile: profileSchema.describe(
+        "Exact configured profile name. Choose the profile whose description best fits the remaining task. If none clearly fits better, do not call handoff."
+      )
     }).strict(),
     outputSchema: handoffResultSchema,
     execute: async (input, options) => {
@@ -13908,7 +14311,7 @@ function createHandoffTool(handoff) {
 }
 
 // src/chat/tools/web/fetch-tool.ts
-import { z as z59 } from "zod";
+import { z as z60 } from "zod";
 
 // src/chat/tools/web/constants.ts
 var USER_AGENT = "junior-bot/0.1";
@@ -14357,9 +14760,9 @@ function createWebFetchTool(hooks, options = {}) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z59.object({
-      url: z59.string().min(1).describe("HTTP(S) URL to fetch."),
-      max_chars: z59.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
+    inputSchema: z60.object({
+      url: z60.string().min(1).describe("HTTP(S) URL to fetch."),
+      max_chars: z60.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ url, max_chars }) => {
@@ -14404,7 +14807,7 @@ function createWebFetchTool(hooks, options = {}) {
 }
 
 // src/chat/tools/web/search.ts
-import { z as z60 } from "zod";
+import { z as z61 } from "zod";
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
 var SEARCH_TIMEOUT_MS = 6e4;
@@ -14446,9 +14849,9 @@ function createWebSearchTool(modelId, override) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z60.object({
-      query: z60.string().min(1).max(500).describe("Search query."),
-      max_results: z60.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
+    inputSchema: z61.object({
+      query: z61.string().min(1).max(500).describe("Search query."),
+      max_results: z61.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ query, max_results }) => {
@@ -14490,7 +14893,7 @@ function createWebSearchTool(modelId, override) {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { z as z61 } from "zod";
+import { z as z62 } from "zod";
 function createWriteFileTool() {
   return zodTool({
     annotations: {
@@ -14501,9 +14904,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: z61.object({
-      path: z61.string().min(1).describe("Path to write in the sandbox workspace."),
-      content: z61.string().describe("UTF-8 file content to write.")
+    inputSchema: z62.object({
+      path: z62.string().min(1).describe("Path to write in the sandbox workspace."),
+      content: z62.string().describe("UTF-8 file content to write.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async () => {
@@ -14515,7 +14918,7 @@ function createWriteFileTool() {
 }
 
 // src/chat/workspaces/tools.ts
-import { z as z62 } from "zod";
+import { z as z63 } from "zod";
 import {
   resourceEventSubscriptionResultSchema
 } from "@sentry/junior-plugin-api";
@@ -14547,16 +14950,16 @@ async function stopWorkspaceSnapshotWatch(input) {
     });
   }
 }
-var repoSchema = z62.object({
-  provider: z62.string(),
-  repo: z62.string(),
-  checkout_path: z62.string()
+var repoSchema = z63.object({
+  provider: z63.string(),
+  repo: z63.string(),
+  checkout_path: z63.string()
 });
-var workspaceSchema = z62.object({
-  id: z62.string(),
-  name: z62.string(),
-  setup_script: z62.string(),
-  repos: z62.array(repoSchema)
+var workspaceSchema = z63.object({
+  id: z63.string(),
+  name: z63.string(),
+  setup_script: z63.string(),
+  repos: z63.array(repoSchema)
 });
 function view(workspace) {
   return {
@@ -14589,18 +14992,18 @@ function workspaceProviderNames() {
 }
 function workspaceWriteSchemas(providers) {
   const providerNames = providers.map((provider) => `\`${provider}\``).join(", ");
-  const repoInputSchema = z62.object({
-    provider: z62.enum(providers).describe(`Repository provider. Supported: ${providerNames}.`),
-    repo: z62.string().trim().min(1).describe("Repository in owner/name format.")
+  const repoInputSchema = z63.object({
+    provider: z63.enum(providers).describe(`Repository provider. Supported: ${providerNames}.`),
+    repo: z63.string().trim().min(1).describe("Repository in owner/name format.")
   }).strict();
-  const workspaceInputSchema = z62.object({
-    name: z62.string().trim().min(1).describe(
+  const workspaceInputSchema = z63.object({
+    name: z63.string().trim().min(1).describe(
       "Workspace name. Use lowercase letters, digits, underscores, or hyphens."
     ),
-    setup_script: z62.string().nullable().describe(
+    setup_script: z63.string().nullable().describe(
       "Optional shell script to run after repository checkout whenever this Workspace starts. Omit or use null for no setup script."
     ).optional(),
-    repos: z62.array(repoInputSchema).max(32).describe("Complete repository list.")
+    repos: z63.array(repoInputSchema).max(32).describe("Complete repository list.")
   }).strict();
   return { providerNames, workspaceInputSchema };
 }
@@ -14675,7 +15078,7 @@ function createWorkspaceWriteTools(providers) {
       },
       description: `Replace an install-wide Workspace recipe. Repository providers: ${providerNames}. Use the Workspace ID returned by listWorkspaces.`,
       inputSchema: workspaceInputSchema.extend({
-        id: z62.string().uuid().describe("Workspace ID from listWorkspaces.")
+        id: z63.string().uuid().describe("Workspace ID from listWorkspaces.")
       }).strict(),
       prepareArguments(args) {
         const input = args;
@@ -14708,11 +15111,11 @@ function createWorkspaceWriteTools(providers) {
         readOnlyHint: false
       },
       description: "Delete one install-wide Workspace recipe. Use the Workspace ID returned by listWorkspaces.",
-      inputSchema: z62.object({
-        id: z62.string().uuid().describe("Workspace ID from listWorkspaces.")
+      inputSchema: z63.object({
+        id: z63.string().uuid().describe("Workspace ID from listWorkspaces.")
       }).strict(),
       outputSchema: juniorToolOutputSchema.extend({
-        deleted: z62.literal(true)
+        deleted: z63.literal(true)
       }),
       async execute({ id }) {
         const deleted = await workspaceWrite(() => deleteWorkspace(id));
@@ -14737,10 +15140,10 @@ function createWorkspaceTools(context) {
         readOnlyHint: true
       },
       description: "List named repository workspaces that can replace the current sandbox.",
-      inputSchema: z62.object({}).strict(),
+      inputSchema: z63.object({}).strict(),
       outputSchema: juniorToolOutputSchema.extend({
-        active_workspace_id: z62.string().nullable(),
-        workspaces: z62.array(workspaceSchema)
+        active_workspace_id: z63.string().nullable(),
+        workspaces: z63.array(workspaceSchema)
       }),
       async execute() {
         return {
@@ -14758,12 +15161,12 @@ function createWorkspaceTools(context) {
         readOnlyHint: false
       },
       description: "Replace the current sandbox with a named repository Workspace. Files in the old sandbox do not carry over. Returns ready after the switch, or building with a temporary subscription when the snapshot is still being prepared. When building, wait for the ready event and call switchWorkspace again with the same name.",
-      inputSchema: z62.object({
-        name: z62.string().trim().min(1).describe("Exact workspace name.")
+      inputSchema: z63.object({
+        name: z63.string().trim().min(1).describe("Exact workspace name.")
       }).strict(),
       outputSchema: juniorToolOutputSchema.extend({
         workspace: workspaceSchema,
-        status: z62.enum(["ready", "building"]),
+        status: z63.enum(["ready", "building"]),
         subscription: resourceEventSubscriptionResultSchema.optional().describe(
           "Present when the snapshot ready and failed events are already watched for this conversation."
         )
@@ -15549,7 +15952,7 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, conv
 }
 
 // src/chat/tools/execute-tool.ts
-import { z as z63 } from "zod";
+import { z as z64 } from "zod";
 var EXECUTE_TOOL_NAME = "executeTool";
 function createExecuteToolTool() {
   return zodTool({
@@ -15561,11 +15964,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: z63.object({
-      tool_name: z63.string().min(1).describe(
+    inputSchema: z64.object({
+      tool_name: z64.string().min(1).describe(
         "Exact catalog tool_name returned by searchTools or a tool-result execution hint."
       ),
-      arguments: z63.record(z63.string(), z63.unknown()).describe(
+      arguments: z64.record(z64.string(), z64.unknown()).describe(
         'Arguments matching the selected catalog tool schema, for example { "query": "..." }.'
       ).optional()
     }).strict(),
@@ -15605,7 +16008,7 @@ function planToolExposure(tools) {
 }
 
 // src/chat/tools/search-tools.ts
-import { z as z64 } from "zod";
+import { z as z65 } from "zod";
 var SEARCH_TOOLS_NAME = "searchTools";
 var DEFAULT_MAX_RESULTS2 = 5;
 var MAX_RESULTS3 = 20;
@@ -15650,29 +16053,29 @@ var SEARCH_STOP_WORDS = /* @__PURE__ */ new Set([
   "you",
   "your"
 ]);
-var searchToolsSourceSchema = z64.object({
-  id: z64.string(),
-  description: z64.string()
+var searchToolsSourceSchema = z65.object({
+  id: z65.string(),
+  description: z65.string()
 }).strict();
-var searchToolsToolSchema = z64.object({
-  tool_name: z64.string(),
-  description: z64.string(),
-  exposure: z64.enum(["direct", "deferred", "modelOnly", "hidden"]),
-  source: z64.string().optional(),
-  input_schema: z64.unknown(),
-  call_notes: z64.array(z64.string()),
-  annotations: z64.record(z64.string(), z64.unknown())
+var searchToolsToolSchema = z65.object({
+  tool_name: z65.string(),
+  description: z65.string(),
+  exposure: z65.enum(["direct", "deferred", "modelOnly", "hidden"]),
+  source: z65.string().optional(),
+  input_schema: z65.unknown(),
+  call_notes: z65.array(z65.string()),
+  annotations: z65.record(z65.string(), z65.unknown())
 }).strict();
 var searchToolsOutputSchema = juniorToolOutputSchema.extend({
-  query: z64.string().nullable(),
-  source: z64.string().nullable(),
-  sources: z64.array(searchToolsSourceSchema),
-  total_catalog_tools: z64.number().int().nonnegative(),
-  total_eligible_tools: z64.number().int().nonnegative(),
-  total_matches: z64.number().int().nonnegative(),
-  returned_tools: z64.number().int().nonnegative(),
-  execution_tool: z64.literal("executeTool"),
-  tools: z64.array(searchToolsToolSchema)
+  query: z65.string().nullable(),
+  source: z65.string().nullable(),
+  sources: z65.array(searchToolsSourceSchema),
+  total_catalog_tools: z65.number().int().nonnegative(),
+  total_eligible_tools: z65.number().int().nonnegative(),
+  total_matches: z65.number().int().nonnegative(),
+  returned_tools: z65.number().int().nonnegative(),
+  execution_tool: z65.literal("executeTool"),
+  tools: z65.array(searchToolsToolSchema)
 }).strict();
 function terms(value) {
   const chunks = value.match(/[\p{L}\p{N}]+/gu) ?? [];
@@ -15883,14 +16286,14 @@ function createSearchToolsTool(catalogTools) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z64.object({
-      query: z64.string().nullable().describe(
+    inputSchema: z65.object({
+      query: z65.string().nullable().describe(
         "Optional search terms describing the tool, owner, action, or arguments needed. Empty string lists catalog tools."
       ).optional(),
-      source: z64.string().nullable().describe(
+      source: z65.string().nullable().describe(
         "Optional source id to search within, such as a plugin source returned in sources."
       ).optional(),
-      max_results: z64.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
+      max_results: z65.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
     }).strict(),
     outputSchema: searchToolsOutputSchema,
     privateTraceResult: (result) => ({
@@ -17188,7 +17591,7 @@ function createPluginEgress(deps) {
 }
 
 // src/chat/services/guardian-action-review.ts
-import { z as z65 } from "zod";
+import { z as z66 } from "zod";
 
 // src/chat/services/guardian-action-policy.ts
 var GUARDIAN_ACTION_POLICY = `You are judging one planned Junior agent action.
@@ -17262,17 +17665,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 = z65.object({
-  decision: z65.enum(["allow", "ask", "deny"]),
-  reason: z65.string().trim().min(1).max(500),
-  riskLevel: z65.enum(["low", "medium", "high", "critical"]),
-  userAuthorization: z65.enum(["high", "medium", "low", "unknown"])
+var guardianDecisionSchema = z66.object({
+  decision: z66.enum(["allow", "ask", "deny"]),
+  reason: z66.string().trim().min(1).max(500),
+  riskLevel: z66.enum(["low", "medium", "high", "critical"]),
+  userAuthorization: z66.enum(["high", "medium", "low", "unknown"])
 }).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(z65.json().parse(proposal), null, 2);
+  const proposalJson = JSON.stringify(z66.json().parse(proposal), null, 2);
   if (proposalJson.length > MAX_PROPOSAL_CHARS) {
     throw new Error(
       `Guardian action proposal exceeds ${MAX_PROPOSAL_CHARS} characters.`
@@ -18601,6 +19004,145 @@ ${summary}`
   return { compacted: true, piMessages: messages };
 }
 
+// src/chat/agent/handoff.ts
+var EXCLUSIVE_TOOL_NAMES = [HANDOFF_TOOL_NAME, "switchWorkspace"];
+function exclusiveToolName(toolCalls) {
+  for (const name of EXCLUSIVE_TOOL_NAMES) {
+    if (toolCalls.some((call) => call.name === name)) {
+      return name;
+    }
+  }
+  return void 0;
+}
+function handoffControl(args) {
+  if (!args.enabled) {
+    return void 0;
+  }
+  const profileNames = [
+    botConfig.defaultProfile,
+    ...Object.keys(botConfig.profiles).filter((profile) => profile !== botConfig.defaultProfile).sort()
+  ].filter((profile) => profile !== args.activeProfile);
+  const [firstProfileName, ...otherProfileNames] = profileNames;
+  if (!firstProfileName) {
+    return void 0;
+  }
+  const toHandoffProfile = (name) => ({
+    name,
+    description: profileConfig(botConfig, name).description
+  });
+  return {
+    profiles: [
+      toHandoffProfile(firstProfileName),
+      ...otherProfileNames.map(toHandoffProfile)
+    ],
+    execute: args.execute
+  };
+}
+function toolsForHandoffProfile(args) {
+  const control = handoffControl({
+    activeProfile: args.activeProfile,
+    enabled: args.enabled,
+    execute: args.execute
+  });
+  if (!control) {
+    return args.agentTools.filter((tool) => tool.name !== HANDOFF_TOOL_NAME);
+  }
+  const handoffAgentTool = args.agentTools.find(
+    (tool) => tool.name === HANDOFF_TOOL_NAME
+  );
+  if (!handoffAgentTool) {
+    throw new Error("Handoff control is missing its Pi tool");
+  }
+  const definition = createHandoffTool(control);
+  return args.agentTools.map(
+    (tool) => tool.name === HANDOFF_TOOL_NAME ? {
+      ...handoffAgentTool,
+      description: definition.description,
+      parameters: definition.inputSchema,
+      prepareArguments: definition.prepareArguments
+    } : tool
+  );
+}
+async function commitHandoff(args) {
+  if (args.profile === args.activeModelProfile) {
+    return void 0;
+  }
+  const runtimeContext = retainRuntimeTurnContext(
+    args.runtimeContextSourceMessages ?? args.sourceMessages
+  );
+  const phaseUsageSummary = extractGenAiUsageSummary(
+    ...args.sourceMessages.slice(args.beforeMessageCount).filter(isAssistantMessage)
+  );
+  const phaseUsage = hasAgentTurnUsage(phaseUsageSummary) ? phaseUsageSummary : void 0;
+  const selectedProfile = profileConfig(botConfig, args.profile);
+  const handoffReasoningLevel = selectedProfile.reasoningLevel ?? args.turnRoute.reasoningLevel;
+  const target = {
+    modelId: selectedProfile.modelId,
+    modelProfile: args.profile,
+    reasoningLevel: handoffReasoningLevel
+  };
+  void (async () => {
+    await args.onStatus?.({ text: "Switching models" });
+  })().catch((error) => {
+    logWarn("assistant.status.observer.failed", {
+      "exception.message": error instanceof Error ? error.message : String(error)
+    });
+  });
+  const handoffMessages = await compactContextForHandoff(
+    {
+      conversationContext: args.conversationContext,
+      conversationId: args.conversationId,
+      piMessages: args.sourceMessages,
+      runtimeContext,
+      signal: args.signal,
+      triggeringToolCallId: args.triggeringToolCallId,
+      target,
+      metadata: args.metadata
+    },
+    {
+      completeText: (completeArgs) => completeText(completeArgs)
+    }
+  );
+  const turnRoute = handoffReasoningLevel === args.turnRoute.reasoningLevel ? args.turnRoute : {
+    ...args.turnRoute,
+    reasoningLevel: handoffReasoningLevel,
+    reason: `profile_reasoning_override:${args.profile}:${args.turnRoute.reason}`
+  };
+  return {
+    messages: handoffMessages,
+    model: resolveGatewayModel(target.modelId),
+    modelId: target.modelId,
+    modelProfile: args.profile,
+    phaseUsage,
+    thinkingLevel: toPiReasoningLevel(handoffReasoningLevel),
+    turnRoute
+  };
+}
+function applyHandoff(args) {
+  const replacement = [...args.pending.messages];
+  args.agent.state.messages = replacement;
+  args.agent.state.model = args.pending.model;
+  args.agent.state.thinkingLevel = args.pending.thinkingLevel;
+  args.agent.state.tools = args.tools;
+  args.resume.setBeforeMessageCount(replacement.length);
+  args.resume.setTurnStartMessageIndex(0);
+  args.resume.adoptCommittedBoundary(replacement);
+  setSpanAttributes({
+    "gen_ai.agent.model": args.pending.modelId,
+    "gen_ai.agent.model_profile": args.pending.modelProfile,
+    "gen_ai.agent.reasoning.level": args.pending.turnRoute.reasoningLevel
+  });
+  return {
+    context: {
+      systemPrompt: args.baseInstructions,
+      messages: replacement,
+      tools: args.tools
+    },
+    model: args.pending.model,
+    thinkingLevel: args.pending.thinkingLevel
+  };
+}
+
 // src/chat/agent/index.ts
 var AGENT_ABORT_SETTLE_GRACE_MS = 5e3;
 async function readRunConversationVisibility(conversationId) {
@@ -18996,93 +19538,56 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
     activeModelProfile = routedModelProfile;
     activeModelId = routedModelId;
     let pendingPiHookError;
-    let pendingHandoff;
     const currentAgentMessages = () => agent ? [...agent.state.messages] : [];
-    const handoffProfiles = [
-      botConfig.defaultProfile,
-      ...Object.keys(botConfig.profiles).filter((profile) => profile !== botConfig.defaultProfile).sort()
-    ];
     const usageSinceCurrentBoundary = (messages) => {
       const usage = extractGenAiUsageSummary(
         ...messages.slice(runResume.beforeMessageCount).filter(isAssistantMessage)
       );
       return hasAgentTurnUsage(usage) ? usage : void 0;
     };
+    let baseInstructions = "";
+    let pendingHandoff;
+    const handoffMetadata = {
+      threadId: conversationId,
+      channelId: slackChannelId,
+      actorId: slackActor?.userId,
+      runId
+    };
     const scheduleHandoff = async (args) => {
-      if (args.profile === activeModelProfile) {
-        return;
-      }
-      const runtimeContext = retainRuntimeTurnContext(
-        args.runtimeContextSourceMessages ?? args.sourceMessages
-      );
-      const phaseUsage = usageSinceCurrentBoundary(args.sourceMessages);
-      const selectedProfile = profileConfig(botConfig, args.profile);
-      const handoffReasoningLevel = selectedProfile.reasoningLevel ?? turnRoute.reasoningLevel;
-      const target = {
-        modelId: selectedProfile.modelId,
-        modelProfile: args.profile,
-        reasoningLevel: handoffReasoningLevel
-      };
-      const handoffModel = resolveGatewayModel(target.modelId);
-      const handoffThinkingLevel = toPiReasoningLevel(handoffReasoningLevel);
-      void (async () => {
-        await observers.onStatus?.({ text: "Switching models" });
-      })().catch((error) => {
-        logWarn("assistant.status.observer.failed", {
-          "exception.message": error instanceof Error ? error.message : String(error)
-        });
+      const pending = await commitHandoff({
+        activeModelProfile,
+        beforeMessageCount: runResume.beforeMessageCount,
+        conversationContext: input.conversationContext,
+        conversationId,
+        metadata: handoffMetadata,
+        onStatus: observers.onStatus,
+        profile: args.profile,
+        runtimeContextSourceMessages: args.runtimeContextSourceMessages,
+        signal: args.signal,
+        sourceMessages: args.sourceMessages,
+        triggeringToolCallId: args.triggeringToolCallId,
+        turnRoute
       });
-      const handoffMessages = await compactContextForHandoff(
-        {
-          conversationContext: input.conversationContext,
-          conversationId,
-          piMessages: args.sourceMessages,
-          runtimeContext,
-          signal: args.signal,
-          triggeringToolCallId: args.triggeringToolCallId,
-          target,
-          metadata: {
-            threadId: conversationId,
-            channelId: slackChannelId,
-            actorId: slackActor?.userId,
-            runId
-          }
-        },
-        {
-          completeText: (args2) => completeText(args2)
-        }
-      );
-      if (handoffReasoningLevel !== turnRoute.reasoningLevel) {
-        turnRoute = {
-          ...turnRoute,
-          reasoningLevel: handoffReasoningLevel,
-          reason: `profile_reasoning_override:${args.profile}:${turnRoute.reason}`
-        };
+      if (!pending) {
+        return;
       }
-      priorPhaseUsage = addAgentTurnUsage(priorPhaseUsage, phaseUsage);
-      pendingHandoff = {
-        messages: handoffMessages,
-        model: handoffModel,
-        thinkingLevel: handoffThinkingLevel
-      };
-      activeModelProfile = args.profile;
-      activeModelId = target.modelId;
-    };
-    const handoffControlFor = (activeProfile) => {
-      const profiles = handoffProfiles.filter(
-        (profile) => profile !== activeProfile
-      );
-      return profiles.length > 0 ? {
-        profiles,
-        execute: async (profile, options) => await scheduleHandoff({
-          profile,
-          signal: options.signal,
-          sourceMessages: [...agent.state.messages],
-          triggeringToolCallId: options.toolCallId
-        })
-      } : void 0;
+      priorPhaseUsage = addAgentTurnUsage(priorPhaseUsage, pending.phaseUsage);
+      pendingHandoff = pending;
+      activeModelProfile = pending.modelProfile;
+      activeModelId = pending.modelId;
+      turnRoute = pending.turnRoute;
     };
-    const requestHandoff = handoffEnabled ? handoffControlFor(activeModelProfile) : void 0;
+    const handoffExecute = async (profile, options) => await scheduleHandoff({
+      profile,
+      signal: options.signal,
+      sourceMessages: [...agent.state.messages],
+      triggeringToolCallId: options.toolCallId
+    });
+    const requestHandoff = handoffControl({
+      activeProfile: activeModelProfile,
+      enabled: handoffEnabled,
+      execute: handoffExecute
+    });
     setTags({
       ...runLogContext,
       modelId: activeModelId
@@ -19143,32 +19648,27 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
       await recordAgentsTransition(initialRepositoryInstructions);
     }
     const getPendingAuthPause = wiring.getPendingAuthPause;
-    const toolsWithoutHandoff = wiring.agentTools.filter(
-      (tool) => tool.name !== HANDOFF_TOOL_NAME
-    );
-    const handoffAgentTool = wiring.agentTools.find(
-      (tool) => tool.name === HANDOFF_TOOL_NAME
-    );
-    const toolsForActiveProfile = () => {
-      const handoff = handoffEnabled ? handoffControlFor(activeModelProfile) : void 0;
-      if (!handoff) {
-        return toolsWithoutHandoff;
-      }
-      if (!handoffAgentTool) {
-        throw new Error("Handoff control is missing its Pi tool");
-      }
-      const definition = createHandoffTool(handoff);
-      return wiring.agentTools.map(
-        (tool) => tool.name === HANDOFF_TOOL_NAME ? {
-          ...handoffAgentTool,
-          description: definition.description,
-          parameters: definition.inputSchema,
-          prepareArguments: definition.prepareArguments
-        } : tool
-      );
+    const applyPendingHandoff = () => {
+      if (!pendingHandoff) {
+        return void 0;
+      }
+      const pending = pendingHandoff;
+      pendingHandoff = void 0;
+      return applyHandoff({
+        agent,
+        baseInstructions,
+        pending,
+        resume: runResume,
+        tools: toolsForHandoffProfile({
+          activeProfile: pending.modelProfile,
+          agentTools: wiring.agentTools,
+          enabled: handoffEnabled,
+          execute: handoffExecute
+        })
+      });
     };
     const {
-      baseInstructions,
+      baseInstructions: assembledBaseInstructions,
       contextContentParts: promptContextContentParts,
       inputMessages,
       inputMessagesAttribute,
@@ -19204,6 +19704,7 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
       toolRuntimeContext: wiring.toolRuntimeContext,
       userContentParts
     });
+    baseInstructions = assembledBaseInstructions;
     const repositoryInstructionsContext = createRepositoryInstructionsContext({
       capture: wiring.captureRepositoryInstructions,
       hasSandbox: () => Boolean(wiring.getSandboxRef()),
@@ -19218,36 +19719,6 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
       shouldPromptAgent
     });
     runResume.setTurnContexts(turnContexts);
-    const applyPendingHandoff = () => {
-      if (!pendingHandoff) {
-        return void 0;
-      }
-      const { messages, model, thinkingLevel } = pendingHandoff;
-      const replacement = [...messages];
-      pendingHandoff = void 0;
-      agent.state.messages = replacement;
-      agent.state.model = model;
-      agent.state.thinkingLevel = thinkingLevel;
-      const tools = toolsForActiveProfile();
-      agent.state.tools = tools;
-      runResume.setBeforeMessageCount(replacement.length);
-      runResume.setTurnStartMessageIndex(0);
-      runResume.adoptCommittedBoundary(replacement);
-      setSpanAttributes({
-        "gen_ai.agent.model": activeModelId,
-        "gen_ai.agent.model_profile": activeModelProfile,
-        "gen_ai.agent.reasoning.level": turnRoute.reasoningLevel
-      });
-      return {
-        context: {
-          systemPrompt: baseInstructions,
-          messages: replacement,
-          tools
-        },
-        model,
-        thinkingLevel
-      };
-    };
     const applyActiveContextCompaction = async (messages, hookSignal, pendingMessages, clearSteeringQueueOnCommit = false, pairPendingRuntimeContext = false) => {
       const compaction = await compactActiveContextIfNeeded(
         {
@@ -19378,13 +19849,7 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
         const toolCalls2 = assistantMessage.content.filter(
           (part) => part.type === "toolCall"
         );
-        const containsHandoff = toolCalls2.some(
-          (call) => call.name === HANDOFF_TOOL_NAME
-        );
-        const containsWorkspaceSwitch = toolCalls2.some(
-          (call) => call.name === "switchWorkspace"
-        );
-        const exclusiveTool = containsHandoff ? HANDOFF_TOOL_NAME : containsWorkspaceSwitch ? "switchWorkspace" : void 0;
+        const exclusiveTool = exclusiveToolName(toolCalls2);
         if (exclusiveTool && toolCalls2.length !== 1) {
           return {
             block: true,
@@ -19461,10 +19926,9 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
         if (event.message.stopReason === "error" || event.message.stopReason === "aborted") {
           return;
         }
-        const containsHandoff = event.message.content.some(
+        if (event.message.content.some(
           (part) => part.type === "toolCall" && part.name === HANDOFF_TOOL_NAME
-        );
-        if (containsHandoff) {
+        )) {
           return;
         }
         return deliverAssistantMessage(event.message);
@@ -19614,9 +20078,9 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
             }
             return result2;
           };
-          const requestedProfile = activeModelProfile === botConfig.defaultProfile ? turnRoute.profile : void 0;
           let run2;
           let handoffApplied = false;
+          const requestedProfile = activeModelProfile === botConfig.defaultProfile ? turnRoute.profile : void 0;
           if (requestedProfile && requestedProfile !== botConfig.defaultProfile) {
             const handoffAbortController = new AbortController();
             await runAgentStep(
@@ -19910,6 +20374,10 @@ export {
   normalizeSandboxEgressTracePropagationDomains,
   shouldPropagateSandboxEgressTrace,
   resolveSandboxEgressProviderForHost,
+  admitAutomatedTurn,
+  recordFinishedTurnForAutomatedLimit,
+  postAutomatedTurnLimitNoticeForDestination,
+  maybePostAutomatedTurnLimitNotice,
   renderTaskInput,
   RESOURCE_EVENT_MESSAGE_AUTHOR,
   RESOURCE_EVENT_SYSTEM_ACTOR,