@sentry/junior 0.195.0 → 0.197.0

package/dist/{chunk-FEZIEEOP.js → chunk-O2H7JUEQ.js}

@@ -7,7 +7,7 @@ import {
   PluginCredentialFailureError,
   agentNameSchema,
   createPluginAuthOrchestration
-} from "./chunk-JBSCMOLR.js";
+} from "./chunk-DBTI74IT.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
@@ -38,7 +38,7 @@ import {
   searchSlackUsers,
   selectPluginGrant,
   toMcpProviderError
-} from "./chunk-OQHO62VA.js";
+} from "./chunk-V2IX5Q5L.js";
 import {
   RetryableDeliveryError,
   actorFromRun,
@@ -53,20 +53,19 @@ import {
   surfaceFromRun,
   toolInvocationDestination,
   uploadFilesToConversation
-} from "./chunk-R5OHONYU.js";
+} from "./chunk-LIK4T6CF.js";
 import {
   CooperativeTurnYieldError,
   NO_REPLY_MARKER,
   TurnInputCommitLostError,
   abandonReplacedPendingAuth,
   canReusePendingAuthLink,
-  containsNoReplyMarker,
   decideReply,
   getAssistantReplyText,
   isNoReplyMarker,
   isTurnInputCommitLostError,
   sanitizeAssistantText
-} from "./chunk-VYDIA2UL.js";
+} from "./chunk-YC5CFKME.js";
 import {
   AGENTS_REMOVAL_NOTICE,
   AGENTS_REPLACEMENT_NOTICE,
@@ -122,7 +121,7 @@ import {
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   truncateText
-} from "./chunk-RZ3PBNDV.js";
+} from "./chunk-LMTHFU5D.js";
 import {
   SCHEDULED_TASK_SYSTEM_ACTOR,
   WORKSPACE_SNAPSHOT_FAILED_EVENT,
@@ -163,13 +162,13 @@ import {
   workspaceSnapshotFinishedEvent,
   workspaceSnapshotWatch,
   writableEventTask
-} from "./chunk-DTYOEHUP.js";
+} from "./chunk-VAUPAX3O.js";
 import {
   parseSlackThreadId
-} from "./chunk-6TRQLG3D.js";
+} from "./chunk-FCONFDZ4.js";
 import {
   appendAndEnqueueInboundMessage
-} from "./chunk-QKHZF2LH.js";
+} from "./chunk-IGSAXSM7.js";
 import {
   SHORT_TITLE_MAX_LENGTH,
   ToolInputError,
@@ -177,7 +176,7 @@ import {
   generateShortTitle,
   hasAgentTurnUsage,
   resolveTaskTitle
-} from "./chunk-R5BGW4WR.js";
+} from "./chunk-YZQLXALE.js";
 import {
   bindSandboxFileSystem,
   createSandboxSession,
@@ -188,7 +187,7 @@ import {
   resolve,
   setSnapshotSpanAttributes,
   stopSession
-} from "./chunk-L62JVQPL.js";
+} from "./chunk-C2SOA3KN.js";
 import {
   privateTraceResultAttributes
 } from "./chunk-UIE3R5XU.js";
@@ -198,7 +197,7 @@ import {
 } from "./chunk-X6GDDWQH.js";
 import {
   getTurnRequestDeadline
-} from "./chunk-I4RH3KLJ.js";
+} from "./chunk-BGSAFVJO.js";
 import {
   getVercelConversationWorkQueue
 } from "./chunk-DKIJ2RP5.js";
@@ -245,23 +244,22 @@ import {
   updateWorkspace,
   withSlackRetries,
   workspaceRepoCheckoutPath
-} from "./chunk-PFQRZ4IB.js";
+} from "./chunk-4UUKQB6I.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS
 } from "./chunk-3Y47VMHV.js";
 import {
-  destinationKey,
   getConversationEventStore,
   getConversationMessageSearchStore,
   getConversationStore,
   getDb,
   getSqlExecutor
-} from "./chunk-KQ3GZGBK.js";
+} from "./chunk-5GWV7SXF.js";
 import {
   juniorArtifacts,
   juniorIdentities,
   juniorSchedulerRuns
-} from "./chunk-FPQPYJEG.js";
+} from "./chunk-6ZQ3CE6X.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_REPOS_ROOT,
@@ -292,19 +290,19 @@ import {
   throwSandboxOperationError,
   workspaceSnapshotNotReadyUserMessage,
   wrapSandboxSetupError
-} from "./chunk-LM7UE523.js";
+} from "./chunk-YLBJBBYX.js";
 import {
   fenceLock,
   getStateAdapter,
   withLock
-} from "./chunk-7MYXH5LA.js";
+} from "./chunk-PF3PEX4Q.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,
@@ -330,14 +328,16 @@ import {
   resolveGatewayCredential,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-LMYRF6HX.js";
+} from "./chunk-BR5GNDPS.js";
 import {
   ModelProfileNotConfiguredError,
   TURN_REASONING_LEVELS,
+  formatModelProfile,
+  formatModelProfiles,
   modelIdForProfile,
   modelProfileSchema,
   profileConfig
-} from "./chunk-D4YV5TDV.js";
+} from "./chunk-NHJU2ZAL.js";
 import {
   canExposeConversationPayload,
   resolveConversationPrivacy,
@@ -347,16 +347,16 @@ import {
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes
-} from "./chunk-KBPWC7NU.js";
+} from "./chunk-EZKISZ3Q.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-RQO67SAO.js";
+} from "./chunk-DLXA2ZXJ.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-RKA22BQP.js";
+} from "./chunk-2K26W3FP.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -364,7 +364,7 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-X3PBQ4BK.js";
+} from "./chunk-DHWYAHAM.js";
 import {
   credentialContextForActor,
   credentialUserSubjectId
@@ -400,7 +400,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-HUQOXMDG.js";
+} from "./chunk-7ENMKNEK.js";
 import {
   startInactiveSpan,
   withActiveSpan
@@ -924,11 +924,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", {
@@ -1146,11 +1141,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.",
@@ -1159,9 +1154,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.",
     "",
@@ -1299,6 +1296,7 @@ async function classifyTurn(args) {
       prompt: args.prompt,
       thinkingLevel: "low",
       system: buildClassifierSystemPrompt(
+        args.profiles,
         Object.keys(args.profiles),
         args.defaultProfile
       ),
@@ -1733,7 +1731,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."
 ];
@@ -3119,11 +3117,8 @@ function sleep2(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 conversationKey(conversationId) {
+  return `${AUTOMATED_TURN_LIMIT_PREFIX}:conversation:${conversationId}`;
 }
 function lockKey(key) {
   return `${key}:lock`;
@@ -3132,7 +3127,7 @@ 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) {
+async function acquireConversationLock(state, key, waitDeadlineMs = Date.now() + AUTOMATED_TURN_LIMIT_LOCK_WAIT_MS) {
   while (true) {
     const lock = await state.acquireLock(
       lockKey(key),
@@ -3147,8 +3142,8 @@ async function acquireScopeLock(state, key, waitDeadlineMs = Date.now() + AUTOMA
     await sleep2(AUTOMATED_TURN_LIMIT_LOCK_RETRY_MS);
   }
 }
-async function withScopeLock(state, key, callback) {
-  const lock = await acquireScopeLock(state, key);
+async function withConversationLock(state, key, callback) {
+  const lock = await acquireConversationLock(state, key);
   try {
     return await callback();
   } finally {
@@ -3162,36 +3157,14 @@ function emptyState(nowMs) {
     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.`;
+  return `I stopped automatic updates after ${args.maxTurns} replies without a new message from you. Send a message or @mention me in this thread to continue.`;
 }
 async function admitAutomatedTurn(args) {
   if (args.maxTurns < 1) {
@@ -3200,8 +3173,8 @@ async function admitAutomatedTurn(args) {
   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 key = conversationKey(args.conversationId);
+  return await withConversationLock(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;
@@ -3236,9 +3209,8 @@ async function countAutomatedTurn(args) {
   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 key = conversationKey(args.conversationId);
+  return await withConversationLock(state, key, async () => {
     const current = parseState(await state.get(key)) ?? emptyState(nowMs);
     const consecutiveAutomatedTurns = current.consecutiveAutomatedTurns + 1;
     const paused = consecutiveAutomatedTurns >= args.maxTurns;
@@ -3247,16 +3219,15 @@ async function countAutomatedTurn(args) {
       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.
+      // Claim the notice slot before posting. 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
+      shouldPostNotice
     };
   });
 }
@@ -3264,8 +3235,8 @@ 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 key = conversationKey(args.conversationId);
+  await withConversationLock(state, key, async () => {
     const current = parseState(await state.get(key));
     if (!current || current.noticePostedAtMs === void 0) {
       return;
@@ -3284,41 +3255,26 @@ async function clearAutomatedTurnLimitNoticeClaim(args) {
 async function resetAutomatedTurnLimit(args) {
   const state = args.state ?? getStateAdapter();
   await state.connect();
-  const key = scopeKey(args.scope);
-  await withScopeLock(state, key, async () => {
+  const key = conversationKey(args.conversationId);
+  await withConversationLock(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) {
+  if (isAutomatedTurnSource(args.source)) {
     return await countAutomatedTurn({
+      conversationId: args.conversationId,
       maxTurns: args.maxTurns,
       nowMs,
-      scope: automatedScope,
       state: args.state
     });
   }
   await resetAutomatedTurnLimit({
+    conversationId: args.conversationId,
     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;
 }
 
@@ -3331,10 +3287,6 @@ async function releaseFailedNoticeClaim(args) {
   }
 }
 async function postAutomatedTurnLimitNoticeForConversation(args) {
-  const scope = args.scope ?? {
-    kind: "conversation",
-    conversationId: args.conversationId
-  };
   try {
     const conversation = await getConversationStore().get({
       conversationId: args.conversationId
@@ -3346,18 +3298,17 @@ async function postAutomatedTurnLimitNoticeForConversation(args) {
         "app.automated_turn_limit.reason": location ? "unsupported_location" : "missing_location"
       });
       await releaseFailedNoticeClaim({
-        nowMs: args.nowMs,
-        scope
+        conversationId: args.conversationId,
+        nowMs: args.nowMs
       });
       return false;
     }
     await postSlackMessage({
       channelId: location.channelId,
       text: buildAutomatedTurnLimitResponse({
-        maxTurns: args.maxTurns,
-        resumeIn: args.resumeIn ?? "thread"
+        maxTurns: args.maxTurns
       }),
-      ...location.threadTs ? { threadTs: location.threadTs } : void 0
+      ...args.threadTs ? { threadTs: args.threadTs } : location.threadTs ? { threadTs: location.threadTs } : void 0
     });
     return true;
   } catch (error) {
@@ -3365,45 +3316,8 @@ async function postAutomatedTurnLimitNoticeForConversation(args) {
       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
+      conversationId: args.conversationId,
+      nowMs: args.nowMs
     });
     return false;
   }
@@ -3412,39 +3326,11 @@ 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
-    }
+    threadTs: args.threadTs
   });
 }
 
@@ -3452,7 +3338,7 @@ async function maybePostAutomatedTurnLimitNotice(args) {
 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."
   ];
 }
@@ -3589,12 +3475,9 @@ function createResourceEventInboundMessage(input) {
 async function enqueueResourceEventNotification(args) {
   const maxTurns = botConfig.maxConsecutiveAutomatedTurns;
   const decision = await admitAutomatedTurn({
+    conversationId: args.subscription.conversationId,
     maxTurns,
     nowMs: args.event.occurredAtMs,
-    scope: {
-      kind: "conversation",
-      conversationId: args.subscription.conversationId
-    },
     state: args.state
   });
   if (decision.status === "paused") {
@@ -3609,12 +3492,7 @@ async function enqueueResourceEventNotification(args) {
       await postAutomatedTurnLimitNoticeForConversation({
         conversationId: args.subscription.conversationId,
         maxTurns,
-        nowMs: args.event.occurredAtMs,
-        resumeIn: "thread",
-        scope: {
-          kind: "conversation",
-          conversationId: args.subscription.conversationId
-        }
+        nowMs: args.event.occurredAtMs
       });
     }
     return { status: "duplicate" };
@@ -14258,12 +14136,19 @@ function stripReplacementHistoryField(value) {
 // src/chat/tools/handoff/tool.ts
 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 = z59.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,
@@ -14271,10 +14156,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: z59.object({
-      profile: profileSchema.describe("Target model profile")
+      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) => {
@@ -18987,6 +18883,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) {
@@ -19382,93 +19417,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
@@ -19529,32 +19527,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,
@@ -19590,6 +19583,7 @@ async function executeAgentRunInPrivacyContext(run, conversationPrivacy, runLogC
       toolRuntimeContext: wiring.toolRuntimeContext,
       userContentParts
     });
+    baseInstructions = assembledBaseInstructions;
     const repositoryInstructionsContext = createRepositoryInstructionsContext({
       capture: wiring.captureRepositoryInstructions,
       hasSandbox: () => Boolean(wiring.getSandboxRef()),
@@ -19604,36 +19598,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(
         {
@@ -19764,13 +19728,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,
@@ -19847,10 +19805,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);
@@ -20000,9 +19957,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(
@@ -20296,9 +20253,7 @@ export {
   normalizeSandboxEgressTracePropagationDomains,
   shouldPropagateSandboxEgressTrace,
   resolveSandboxEgressProviderForHost,
-  admitAutomatedTurn,
   recordFinishedTurnForAutomatedLimit,
-  postAutomatedTurnLimitNoticeForDestination,
   maybePostAutomatedTurnLimitNotice,
   renderTaskInput,
   RESOURCE_EVENT_MESSAGE_AUTHOR,