@sentry/junior 0.105.0 → 0.107.0

package/dist/{chunk-NJJFU6CP.js → chunk-EDLNHZH3.js}

@@ -1,20 +1,30 @@
 import {
   CooperativeTurnYieldError,
   TurnInputCommitLostError,
+  TurnSliceLimitExceededError,
   abandonReplacedPendingAuth,
   canReusePendingAuthLink,
+  estimateTextTokens,
+  getAgentContextCompactionTriggerTokens,
   getInterruptionMarker,
   isTurnInputCommitLostError,
   loadTurnSessionRecord,
   mergeArtifactsState,
   persistAuthPauseSessionRecord,
+  persistContinuationSessionRecord,
   persistRunningSessionRecord,
-  persistTimeoutSessionRecord,
-  persistYieldSessionRecord
-} from "./chunk-RMZ65YAA.js";
+  persistYieldSessionRecord,
+  updateConversationStats
+} from "./chunk-YFQ7CQDE.js";
 import {
-  JUNIOR_THREAD_STATE_TTL_MS
-} from "./chunk-XIMUQ4IU.js";
+  JUNIOR_THREAD_STATE_TTL_MS,
+  loadConnectedMcpProviders,
+  loadConversationProjection,
+  openConversationProjection,
+  recordAuthorizationRequested,
+  recordMcpProviderConnected,
+  recordToolExecutionStarted
+} from "./chunk-4YF7Z6IA.js";
 import {
   buildNonInteractiveShellScript,
   createSandboxInstance,
@@ -24,22 +34,11 @@ import {
   isSnapshotMissingError,
   resolveRuntimeDependencySnapshot,
   runNonInteractiveCommand
-} from "./chunk-7G4J3CR7.js";
+} from "./chunk-SPUAJVVH.js";
 import {
   addAgentTurnUsage,
-  hasAgentTurnUsage,
-  loadConnectedMcpProviders,
-  loadConversationProjection,
-  openConversationProjection,
-  recordAuthorizationRequested,
-  recordMcpProviderConnected,
-  recordToolExecutionStarted
-} from "./chunk-QDKRE3LS.js";
-import {
-  estimateTextTokens,
-  getAgentContextCompactionTriggerTokens,
-  updateConversationStats
-} from "./chunk-RYDF4GOX.js";
+  hasAgentTurnUsage
+} from "./chunk-MU6HHZEN.js";
 import {
   privateTraceResultAttributes
 } from "./chunk-UIE3R5XU.js";
@@ -51,10 +50,10 @@ import {
   getPlugins,
   getSlackToolContext,
   resolveChannelCapabilities
-} from "./chunk-VDHMFCDY.js";
+} from "./chunk-RMVOAJRL.js";
 import {
   createPluginLogger
-} from "./chunk-4PDVOHXP.js";
+} from "./chunk-AUUOHQAT.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -62,6 +61,10 @@ import {
   sandboxSkillDir,
   sandboxSkillFile
 } from "./chunk-G3E7SCME.js";
+import {
+  acquireActiveLock,
+  getStateAdapter
+} from "./chunk-B2Z2H66D.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -71,16 +74,16 @@ import {
   isDmChannel,
   normalizeSlackConversationId,
   withSlackRetries
-} from "./chunk-CCTCIISK.js";
+} from "./chunk-VH6KWKG2.js";
 import {
   contextProvenance,
-  getAgentStepStore,
+  getConversationEventStore,
   getConversationSearchStore,
   getConversationStore,
   getDb,
   instructionActors,
   instructionProvenanceFor
-} from "./chunk-BCULHGZK.js";
+} from "./chunk-NVOTGWYX.js";
 import {
   sleep
 } from "./chunk-4ZNGQH7C.js";
@@ -96,7 +99,6 @@ import {
   STANDARD_MODEL_PROFILE,
   TURN_CONTEXT_TAG,
   TURN_REASONING_LEVELS,
-  acquireActiveLock,
   botConfig,
   completeObject,
   completeText,
@@ -104,7 +106,6 @@ import {
   extractAssistantText,
   getGatewayApiKey,
   getPiGatewayApiKey,
-  getStateAdapter,
   getTerminalAssistantMessages,
   hasCompactedConversationContext,
   hasRuntimeTurnContext,
@@ -114,16 +115,18 @@ import {
   isToolResultError,
   isToolResultMessage,
   modelIdForProfile,
+  modelProfileSchema,
   nextProviderRetry,
   normalizeSlackEmojiName,
   normalizeToolNameFromResult,
+  profileConfig,
   renderCurrentInstruction,
   resolveGatewayModel,
   retainRuntimeTurnContext,
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   unwrapCurrentInstruction
-} from "./chunk-M3UAVLEN.js";
+} from "./chunk-SS67LUOK.js";
 import {
   parseSlackThreadId,
   resolveConversationPrivacy,
@@ -142,21 +145,22 @@ import {
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-WR7H7VLJ.js";
+} from "./chunk-YT72TOEK.js";
 import {
   CredentialUnavailableError,
   credentialContextSchema,
   pluginCatalogRuntime,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-77LHNQK4.js";
+} from "./chunk-YIPD3L6L.js";
+import {
+  isUserActor
+} from "./chunk-VIXFG2VC.js";
 import {
-  createActor,
   extractGenAiUsageAttributes,
   extractGenAiUsageSummary,
   getLogContextAttributesForSpan,
   getTracePropagationHeaders,
-  isUserActor,
   logError,
   logException,
   logInfo,
@@ -168,7 +172,7 @@ import {
   setTags,
   summarizeMessageText,
   withSpan
-} from "./chunk-AEWZ7F65.js";
+} from "./chunk-O24R4DCK.js";
 import {
   isRecord
 } from "./chunk-OB42YVAE.js";
@@ -668,27 +672,10 @@ function isRawToolPayloadResponse(text) {
   if (isToolPayloadShape(parsed)) {
     return true;
   }
-  const compact = text.replace(/\s+/g, " ");
-  return /"type"\s*:\s*"tool[-_](use|call|result|error)"/i.test(compact);
+  return false;
 }
-var POST_CANVAS_REPLY_MAX_CHARS = 700;
-var POST_CANVAS_REPLY_MAX_LINES = 8;
 var THINKING_XML_BLOCK_PATTERN = /[ \t]*<thinking\b[^>]*>[\s\S]*?<\/thinking>[ \t]*(?:\r?\n)?/gi;
 var FENCED_CODE_BLOCK_PATTERN = /```[\s\S]*?```/g;
-function isVerbosePostCanvasReply(text) {
-  const lines = text.split(/\r?\n/).filter((line) => line.trim().length > 0);
-  return text.length > POST_CANVAS_REPLY_MAX_CHARS || lines.length > POST_CANVAS_REPLY_MAX_LINES;
-}
-function getCreatedCanvasUrl(artifactStatePatch) {
-  if (artifactStatePatch.lastCanvasUrl) {
-    return artifactStatePatch.lastCanvasUrl;
-  }
-  return artifactStatePatch.recentCanvases?.find((canvas) => canvas.url)?.url;
-}
-function buildBriefPostCanvasReply(artifactStatePatch) {
-  const canvasUrl = getCreatedCanvasUrl(artifactStatePatch);
-  return canvasUrl ? `I created a canvas with the full reference: ${canvasUrl}` : "I created a canvas with the full reference.";
-}
 function stripThinkingXmlBlocks(text) {
   let result = "";
   let cursor = 0;
@@ -704,6 +691,23 @@ function stripThinkingXmlBlocks(text) {
   result += text.slice(cursor).replace(THINKING_XML_BLOCK_PATTERN, "");
   return result;
 }
+function getVisibleAssistantText(rawText) {
+  const text = stripThinkingXmlBlocks(rawText).trim();
+  if (!text || isNoReplyMarker(text) || containsNoReplyMarker(text) || isRawToolPayloadResponse(text)) {
+    return void 0;
+  }
+  return text;
+}
+function getAssistantMessageText(message) {
+  if (message.content.some((part) => part.type === "toolCall")) {
+    return void 0;
+  }
+  const text = getVisibleAssistantText(extractAssistantText(message));
+  if (!text) {
+    return void 0;
+  }
+  return isExecutionEscapeResponse(text) ? void 0 : text;
+}
 function buildTurnResult(input) {
   const {
     newMessages,
@@ -715,8 +719,7 @@ function buildTurnResult(input) {
     shouldTrace,
     spanContext,
     usage,
-    reasoningSelection,
-    correlation,
+    executionProfile,
     assistantUserName,
     modelId
   } = input;
@@ -729,20 +732,16 @@ function buildTurnResult(input) {
   const exactNoReplyMarker = isNoReplyMarker(rawPrimaryText);
   const mixedNoReplyMarker = !exactNoReplyMarker && containsNoReplyMarker(rawPrimaryText);
   const noReplyRequested = exactNoReplyMarker || mixedNoReplyMarker;
-  const primaryText = noReplyRequested ? "" : rawPrimaryText;
+  const primaryText = noReplyRequested ? "" : terminalAssistantMessages.map((message) => getAssistantMessageText(message)).filter((text) => Boolean(text)).join("\n\n");
   const toolErrorCount = toolResults.filter((result) => result.isError).length;
-  const successfulToolResults = toolResults.filter(
-    (result) => !isToolResultError(result)
-  );
-  const successfulToolNames = new Set(
-    successfulToolResults.map((result) => normalizeToolNameFromResult(result)).filter((value) => Boolean(value))
+  const reactionPerformed = toolResults.some(
+    (result) => !isToolResultError(result) && normalizeToolNameFromResult(result) === "addReaction"
   );
-  const canvasCreated = successfulToolNames.has("slackCanvasCreate");
-  const reactionPerformed = successfulToolNames.has("addReaction");
-  const silentCompletionSuccess = noReplyRequested;
-  const baseDeliveryPlan = {
-    mode: "thread",
-    postThreadText: true
+  const completedWithoutTerminalText = noReplyRequested;
+  const resultLogContext = {
+    ...spanContext,
+    assistantUserName,
+    modelId
   };
   const lastAssistant = terminalAssistantMessages.at(-1);
   const stopReason = typeof lastAssistant?.stopReason === "string" ? lastAssistant.stopReason : void 0;
@@ -750,14 +749,7 @@ function buildTurnResult(input) {
   const isProviderError = stopReason === "error";
   if (exactNoReplyMarker) {
     const markerCategory = reactionPerformed ? "reaction" : "none";
-    const markerContext = {
-      slackThreadId: correlation?.threadId,
-      slackUserId: correlation?.actorId,
-      slackChannelId: correlation?.channelId,
-      runId: correlation?.runId,
-      assistantUserName,
-      modelId
-    };
+    const markerContext = resultLogContext;
     const markerAttributes = {
       "app.ai.no_reply_marker": true,
       "app.ai.no_reply_marker_category": markerCategory,
@@ -774,14 +766,7 @@ function buildTurnResult(input) {
   } else if (mixedNoReplyMarker) {
     logWarn(
       "ai_no_reply_marker_mixed_text",
-      {
-        slackThreadId: correlation?.threadId,
-        slackUserId: correlation?.actorId,
-        slackChannelId: correlation?.channelId,
-        runId: correlation?.runId,
-        assistantUserName,
-        modelId
-      },
+      resultLogContext,
       {
         "app.ai.no_reply_marker": true,
         "app.ai.no_reply_marker_mode": "mixed"
@@ -789,17 +774,10 @@ function buildTurnResult(input) {
       "No-reply marker appeared with visible assistant text"
     );
   }
-  if (!primaryText && !silentCompletionSuccess && !isProviderError) {
+  if (!primaryText && !completedWithoutTerminalText && !isProviderError) {
     logWarn(
       "ai_model_response_empty",
-      {
-        slackThreadId: correlation?.threadId,
-        slackUserId: correlation?.actorId,
-        slackChannelId: correlation?.channelId,
-        runId: correlation?.runId,
-        assistantUserName,
-        modelId
-      },
+      resultLogContext,
       {
         "app.ai.tool_results": toolResults.length,
         "app.ai.tool_error_results": toolErrorCount,
@@ -812,29 +790,23 @@ function buildTurnResult(input) {
   let outcome;
   if (isProviderError) {
     outcome = "provider_error";
-  } else if (primaryText || silentCompletionSuccess) {
+  } else if (primaryText || completedWithoutTerminalText) {
     outcome = "success";
   } else {
     outcome = "execution_failure";
   }
-  const rawResponseText = primaryText;
-  const responseText = canvasCreated && isVerbosePostCanvasReply(rawResponseText) ? buildBriefPostCanvasReply(artifactStatePatch) : rawResponseText;
-  const escapedOrRawPayload = Boolean(primaryText) && (isExecutionEscapeResponse(primaryText) || isRawToolPayloadResponse(primaryText));
-  const resolvedText = escapedOrRawPayload ? "" : responseText;
-  const resolvedOutcome = escapedOrRawPayload ? "execution_failure" : outcome;
-  const deliveryPlan = resolvedOutcome === "success" && !resolvedText ? {
-    ...baseDeliveryPlan,
-    postThreadText: false
-  } : baseDeliveryPlan;
-  const deliveryMode = deliveryPlan.mode;
+  const rejectedPrimaryText = Boolean(
+    rawPrimaryText && !noReplyRequested && !primaryText
+  );
+  const resolvedOutcome = rejectedPrimaryText ? "execution_failure" : outcome;
   if (shouldTrace) {
     logInfo(
       "agent_message_out",
       spanContext,
       {
         "app.message.kind": "assistant_outbound",
-        "app.message.length": resolvedText.length,
-        "app.message.output": summarizeMessageText(resolvedText),
+        "app.message.length": primaryText.length,
+        "app.message.output": summarizeMessageText(primaryText),
         "app.ai.outcome": resolvedOutcome,
         "app.ai.assistant_messages": assistantMessages.length,
         ...stopReason ? { "gen_ai.response.finish_reasons": [stopReason] } : {}
@@ -846,7 +818,7 @@ function buildTurnResult(input) {
     outcome: resolvedOutcome,
     modelId,
     assistantMessageCount: assistantMessages.length,
-    reasoningLevel: reasoningSelection.reasoningLevel,
+    reasoningLevel: executionProfile.reasoningLevel,
     toolCalls,
     toolResultCount: toolResults.length,
     toolErrorCount,
@@ -858,10 +830,8 @@ function buildTurnResult(input) {
     providerError: void 0
   };
   return {
-    text: resolvedText,
+    text: primaryText,
     artifactStatePatch: Object.keys(artifactStatePatch).length > 0 ? artifactStatePatch : void 0,
-    deliveryPlan,
-    deliveryMode,
     sandboxId,
     sandboxDependencyProfileHash,
     piMessages: input.piMessages,
@@ -869,7 +839,7 @@ function buildTurnResult(input) {
   };
 }
 
-// src/chat/services/turn-reasoning-level.ts
+// src/chat/services/turn-router.ts
 import { z } from "zod";
 var CLASSIFIER_CONFIDENCE_THRESHOLD = 0.75;
 var MAX_ROUTER_CONTEXT_CHARS = 8e3;
@@ -895,14 +865,20 @@ function coerceClassifierConfidence(value) {
   }
   return CONFIDENCE_LABELS[trimmed] ?? value;
 }
-var turnExecutionProfileSchema = z.object({
-  reasoning_level: z.enum(TURN_REASONING_LEVELS),
-  confidence: z.preprocess(
-    coerceClassifierConfidence,
-    z.number().min(0).max(1)
-  ),
-  reason: z.string().min(1)
-});
+function createTurnRouteSchema(profiles) {
+  return z.object({
+    reasoning_level: z.enum(TURN_REASONING_LEVELS),
+    profile: modelProfileSchema.refine(
+      (profile) => Object.hasOwn(profiles, profile),
+      "Profile is not configured"
+    ),
+    confidence: z.preprocess(
+      coerceClassifierConfidence,
+      z.number().min(0).max(1)
+    ),
+    reason: z.string().min(1)
+  });
+}
 var CLASSIFIER_FALLBACK_REASONING_LEVEL = "medium";
 var REASONING_LEVEL_RANK = {
   none: 0,
@@ -931,10 +907,12 @@ function trimContextForRouter(text) {
     originalCharCount: trimmed.length
   };
 }
-function buildClassifierSystemPrompt() {
+function buildClassifierSystemPrompt(profileNames) {
   return [
-    "You route assistant turns to the reasoning level most likely to produce a complete, source-grounded answer.",
+    "You choose the execution 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.",
     "Use low rarely: only for deterministic one-step answers or transformations with no tools, no current/external facts, no prior thread-context interpretation, and no source verification.",
@@ -942,10 +920,12 @@ function buildClassifierSystemPrompt() {
     "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.",
+    "Use profile handoff for writing, editing, reviewing, debugging, or substantially reasoning about code; multi-file changes; root-cause analysis; research-heavy synthesis or complex planning; or another task where a more capable model materially improves reliability. Otherwise use standard.",
+    "Any request for a software architecture or component-design decision must use handoff, including advice-only requests with no implementation.",
     "",
     "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.",
     "",
-    "Return JSON only with reasoning_level, confidence, and reason.",
+    "Return JSON only with reasoning_level, profile, confidence, and reason.",
     "confidence must be a number from 0 to 1, not a word label."
   ].join("\n");
 }
@@ -974,13 +954,14 @@ function buildClassifierPrompt(args) {
   }
   return sections.join("\n");
 }
-function configuredTurnReasoningLevel(reasoningLevel, source) {
+function configuredTurnRoute(profile, reasoningLevel, source) {
   return {
+    profile,
     reasoningLevel,
     reason: `configured:${source}`
   };
 }
-async function selectTurnReasoningLevel(args) {
+async function selectTurnRoute(args) {
   const trimmedContext = trimContextForRouter(args.conversationContext);
   const instructionLength = args.messageText.trim().length;
   const turnBlockCount = (args.currentTurnBlocks ?? []).filter(
@@ -999,8 +980,8 @@ async function selectTurnReasoningLevel(args) {
     modelId: args.fastModelId
   };
   return withSpan(
-    "chat.route_reasoning",
-    "chat.route_reasoning",
+    "chat.route_execution_profile",
+    "chat.route_execution_profile",
     logContext,
     async () => {
       setSpanAttributes({
@@ -1020,11 +1001,16 @@ async function selectTurnReasoningLevel(args) {
           actorId: args.context?.actorId ?? "",
           runId: args.context?.runId ?? ""
         },
+        profiles: args.profiles,
         prompt
       });
-      const normalizedSelection = applyReasoningFloor(selection, {
+      const flooredSelection = applyReasoningFloor(selection, {
         minimum: trimmedContext || turnBlockCount > 0 ? "medium" : void 0
       });
+      const normalizedSelection = applyProfileReasoningOverride(
+        flooredSelection,
+        args.profiles
+      );
       setSpanAttributes({
         "gen_ai.request.reasoning.level": normalizedSelection.reasoningLevel,
         "gen_ai.request.reasoning.level_reason": normalizedSelection.reason,
@@ -1047,34 +1033,49 @@ function applyReasoningFloor(selection, args) {
     reason: `reasoning_floor:${minimum}:${selection.reason}`
   };
 }
+function applyProfileReasoningOverride(route, profiles) {
+  const reasoningLevel = profiles[route.profile]?.reasoningLevel;
+  if (!reasoningLevel || reasoningLevel === route.reasoningLevel) {
+    return route;
+  }
+  return {
+    ...route,
+    reasoningLevel,
+    reason: `profile_reasoning_override:${route.profile}:${route.reason}`
+  };
+}
 async function classifyTurn(args) {
   try {
+    const schema = createTurnRouteSchema(args.profiles);
     const result = await args.completeObject({
       modelId: args.fastModelId,
-      schema: turnExecutionProfileSchema,
-      maxTokens: 120,
+      schema,
+      maxTokens: 140,
       metadata: args.metadata,
       prompt: args.prompt,
       thinkingLevel: "low",
-      system: buildClassifierSystemPrompt(),
+      system: buildClassifierSystemPrompt(Object.keys(args.profiles)),
       temperature: 0
     });
-    const parsed = turnExecutionProfileSchema.parse(result.object);
+    const parsed = schema.parse(result.object);
     const reason = parsed.reason.trim();
     if (parsed.confidence < CLASSIFIER_CONFIDENCE_THRESHOLD) {
       return {
         confidence: parsed.confidence,
+        profile: STANDARD_MODEL_PROFILE,
         reasoningLevel: CLASSIFIER_FALLBACK_REASONING_LEVEL,
         reason: `low_confidence_medium_default:${reason}`
       };
     }
     return {
       confidence: parsed.confidence,
+      profile: parsed.profile,
       reasoningLevel: parsed.reasoning_level,
       reason
     };
   } catch {
     return {
+      profile: STANDARD_MODEL_PROFILE,
       reasoningLevel: CLASSIFIER_FALLBACK_REASONING_LEVEL,
       reason: "classifier_error_default"
     };
@@ -1126,60 +1127,49 @@ var AuthorizationFlowDisabledError = class extends Error {
 };
 
 // src/chat/agent/request.ts
-function getSessionIdentifiers(routing) {
-  return {
-    conversationId: routing.correlation?.conversationId ?? routing.correlation?.threadId ?? routing.correlation?.runId,
-    sessionId: routing.correlation?.turnId
-  };
-}
+var RetryableDeliveryError = class extends Error {
+  constructor(cause) {
+    super("Assistant delivery was transient or ambiguous", { cause });
+    this.name = "RetryableDeliveryError";
+  }
+};
 function actorFromRouting(routing) {
   if (routing.dispatch?.actor) {
     return routing.dispatch.actor;
   }
-  const userActor = createActor(
-    isUserActor(routing.actor) ? routing.actor : void 0,
-    {
-      platform: (isUserActor(routing.actor) ? routing.actor.platform : void 0) ?? (routing.destination.platform === "slack" ? "slack" : void 0),
-      teamId: (routing.destination.platform === "slack" ? routing.destination.teamId : void 0) ?? routing.correlation?.teamId ?? (routing.actor?.platform === "slack" ? routing.actor.teamId : void 0),
-      userId: routing.correlation?.actorId
-    }
-  );
-  if (userActor) {
-    return userActor;
+  if (routing.actor) {
+    return routing.actor;
   }
   if (routing.credentialContext && !("type" in routing.credentialContext.actor)) {
     return routing.credentialContext.actor;
   }
   return void 0;
 }
-function assertActorDestinationMatch(routing) {
-  const { destination, actor } = routing;
-  if (!actor) {
-    return;
+function assertRunRoutingConsistency(request) {
+  const { destination, source } = request.routing;
+  if (source.platform !== destination.platform) {
+    throw new TypeError("Run source and destination platforms do not match");
   }
-  if (actor.platform !== destination.platform) {
+  if (source.platform === "slack" && destination.platform === "slack") {
+    if (source.teamId !== destination.teamId) {
+      throw new TypeError("Slack source and destination teams do not match");
+    }
+  } else if (source.platform === "local" && destination.platform === "local" && (source.conversationId !== request.conversationId || destination.conversationId !== request.conversationId)) {
     throw new TypeError(
-      `Actor platform "${actor.platform}" does not match destination platform "${destination.platform}"`
+      "Local source, destination, and run conversation IDs do not match"
     );
   }
-  if (actor.platform === "slack" && destination.platform === "slack" && actor.teamId !== destination.teamId) {
-    throw new TypeError("Slack actor team does not match destination team");
-  }
-}
-function assertCorrelationDestinationMatch(routing) {
-  const { correlation, destination } = routing;
-  if (destination.platform !== "slack") {
+  const actor = request.routing.dispatch?.actor ?? request.routing.actor;
+  if (!actor || actor.platform === "system") {
     return;
   }
-  if (correlation?.channelId !== void 0 && correlation.channelId !== destination.channelId) {
+  if (actor.platform !== destination.platform) {
     throw new TypeError(
-      "Slack correlation channel does not match destination channel"
+      `Actor platform "${actor.platform}" does not match destination platform "${destination.platform}"`
     );
   }
-  if (correlation?.teamId !== void 0 && correlation.teamId !== destination.teamId) {
-    throw new TypeError(
-      "Slack correlation team does not match destination team"
-    );
+  if (actor.platform === "slack" && destination.platform === "slack" && actor.teamId !== destination.teamId) {
+    throw new TypeError("Slack actor team does not match destination team");
   }
 }
 function toolInvocationDestination(routing) {
@@ -1196,30 +1186,20 @@ function surfaceFromRouting(routing) {
   if (routing.surface) {
     return routing.surface;
   }
-  const conversationId = routing.correlation?.conversationId ?? routing.correlation?.threadId ?? routing.correlation?.runId;
-  if (routing.slackConversation || (conversationId ? parseSlackThreadId(conversationId) : void 0)) {
-    return "slack";
-  }
-  if (conversationId) {
-    return "api";
-  }
-  return void 0;
+  return routing.source.platform === "slack" ? "slack" : "internal";
 }
 
 // src/chat/agent/session.ts
-async function restoreSessionRecord(routing) {
-  const { conversationId: sessionConversationId, sessionId } = getSessionIdentifiers(routing);
+async function restoreSessionRecord(args) {
   const sessionRecordState = await loadTurnSessionRecord({
-    conversationId: sessionConversationId,
-    sessionId
+    conversationId: args.conversationId,
+    sessionId: args.turnId
   });
   const { resumedFromSessionRecord, currentSliceId, existingSessionRecord } = sessionRecordState;
   return {
     currentSliceId,
     existingSessionRecord,
     resumedFromSessionRecord,
-    sessionConversationId,
-    sessionId,
     sessionRecordState
   };
 }
@@ -2077,7 +2057,6 @@ var LOCAL_HEADER = "You are a helper assistant. Follow the personality section f
 var TURN_CONTEXT_HEADER = "Runtime context for this request. Treat these blocks as trusted runtime facts; the static system prompt remains authoritative.";
 var TOOL_POLICY_RULES = [
   "- Tool schemas are the source of truth for parameters; tool names are case-sensitive, so call tools exactly by their exposed names and do not invent arguments.",
-  "- Model upgrade: when `handoff` is available, call it immediately and as the only tool before handling any request to write, edit, review, debug, or substantially reason about code; make a multi-file change; perform architecture or root-cause analysis; do research-heavy synthesis or complex planning; or complete another task where a more capable model materially improves reliability. Choose the configured profile whose name best fits the task, or omit `profile` to use the default. Do not inspect or modify files first. After handoff, continue the same task normally.",
   "- Use tools for actionable work and for facts that are mutable, external, repository-backed, provider-backed, or requested as verified/current. Stable general knowledge and already-provided context may be answered directly.",
   "- Resolve provider action targets before calls: explicit target wins; ambient `<configuration>` fills omitted targets. Treat non-target links/references as context.",
   "- Verification source order: conversation/thread context; user-provided attachments, links, and reference files; local/sandbox files when present; loaded skill references; repository/provider tools; public web. Use the nearest authoritative available source before weaker sources.",
@@ -2101,7 +2080,7 @@ var SKILL_POLICY_RULES = [
 var EXECUTION_CONTRACT_RULES = [
   "- Actionable request: act in this turn.",
   "- Continue until done or genuinely blocked. Do not finish with a plan, promise, or offer to check next when an available tool or source can move the request forward.",
-  "- Completion means the final answer covers the user's actual ask, including requested follow-up checks, and is grounded in the best evidence you could access.",
+  "- Complete the full task, but report only the result and evidence the user needs; do not narrate every step, check, or detail.",
   "- Ask the user only for missing access, approval, or a decision that blocks safe progress. Ask one focused question; otherwise infer conservatively and continue.",
   "- For conflicting evidence, compare sources and state which source is authoritative for the answer.",
   "- For non-trivial or long-running work, call `reportProgress` early when available, then only when the major phase changes. Routine tool calls should stay silent."
@@ -2113,11 +2092,8 @@ var CONVERSATION_RULES = [
 ];
 var SLACK_ACTION_RULES = [
   "- Slack tools target the current runtime context; if the requested Slack target differs, explain the limitation instead of calling the tool.",
-  "- Use sendMessage only when the user asks to send, share, or attach text, sandbox-path files, or both in the active Slack conversation.",
-  "- sendMessage has no target argument; it always sends into the active Slack conversation/thread. For top-level channel posts, other channels, or named recipients, explain that this runtime can only send into the active conversation.",
-  "- sendMessage is not final-reply delivery. After using sendMessage, provide a brief normal final answer unless the user requested no further text.",
   "- Ambient reaction requests target the current inbound message; do not ask for a message reference.",
-  `- When no visible final thread reply is useful, make the final message exactly ${NO_REPLY_MARKER}.`
+  `- When no visible thread reply is requested or useful, keep tool-calling messages text-free and make the final message exactly ${NO_REPLY_MARKER}.`
 ];
 var SAFETY_RULES = [
   "- Stay within the user's request and the runtime's available capabilities; do not pursue independent goals, persistence, replication, credential gathering, or access expansion.",
@@ -2166,8 +2142,8 @@ function buildOutputSection(platform) {
     openTag,
     "- Start with the answer or result, not internal process narration.",
     "- Use Slack-flavored Markdown: **bold** section labels, `code`, [text](url) links, bullet lists, and fenced code blocks. No hash-prefixed headings and no tables. When the answer primarily lists several URLs, show each URL bare instead of as a labeled link.",
-    "- Keep replies brief and scannable; use bullets or short code blocks when helpful, and one compact thread reply when it fits.",
-    "- When a research or document-style answer would benefit from continuation, multiple sections, or future reference value, create a Slack canvas and keep the thread reply to one or two short sentences plus the link; do not recap the canvas contents.",
+    "- Default to one compact thread reply containing the conclusion and only decisive evidence or action. Do not split an explainer across multiple Slack messages.",
+    "- Put plans, research, and other long or multi-section explainers in a Slack canvas; reply with one or two short sentences plus the link, without recapping the canvas.",
     "- End every turn with a final user-facing markdown response unless the Slack action rules allow a no-reply completion.",
     "</output>"
   ].join("\n");
@@ -4755,8 +4731,26 @@ function createGrepTool() {
 
 // src/chat/tools/sandbox/file-uploads.ts
 import path6 from "path";
+import { z as z8 } from "zod";
 var MAX_SANDBOX_FILE_UPLOAD_BYTES = 10 * 1024 * 1024;
 var SANDBOX_ARTIFACTS_DIR = "/tmp/junior/artifacts";
+var sandboxFileReferenceSchema = z8.object({
+  path: z8.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: z8.string().min(1).nullable().optional().describe(
+    "Optional filename override shown to the recipient. Null is treated as omitted."
+  ),
+  mimeType: z8.string().min(1).nullable().optional().describe("Optional MIME type override. Null is treated as omitted."),
+  bytes: z8.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: z8.string().min(1),
+  mimeType: z8.string().min(1).optional(),
+  bytes: z8.number().int().nonnegative()
+}).strict();
 var MIME_BY_EXTENSION = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -4771,7 +4765,7 @@ var MIME_BY_EXTENSION = {
   ".csv": "text/csv",
   ".log": "text/plain"
 };
-var SandboxFileNotFoundError = class extends Error {
+var SandboxFileNotFoundError = class extends ToolInputError {
   constructor(path9) {
     super(`failed to read file: ${path9}`);
     this.path = path9;
@@ -4838,10 +4832,10 @@ async function readSandboxFileUpload(sandbox, input) {
     throw new SandboxFileNotFoundError(targetPath);
   }
   if (fileBuffer.byteLength === 0) {
-    throw new Error(`file is empty: ${targetPath}`);
+    throw new ToolInputError(`file is empty: ${targetPath}`);
   }
   if (fileBuffer.byteLength > MAX_SANDBOX_FILE_UPLOAD_BYTES) {
-    throw new Error(
+    throw new ToolInputError(
       `file exceeds ${MAX_SANDBOX_FILE_UPLOAD_BYTES} bytes: ${targetPath} (${fileBuffer.byteLength} bytes)`
     );
   }
@@ -4862,7 +4856,7 @@ async function readSandboxFileUpload(sandbox, input) {
 
 // src/chat/tools/sandbox/list-dir.ts
 import path7 from "path";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var DEFAULT_LIST_LIMIT = 500;
 async function listDir(params) {
   const dirPath = resolveWorkspacePath(params.path);
@@ -4943,11 +4937,11 @@ function createListDirTool() {
   return zodTool({
     description: "List a sandbox workspace directory. Returns sorted entries with '/' suffixes for directories and bounded truncation notices.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z8.object({
-      path: z8.string().min(1).describe(
+    inputSchema: z9.object({
+      path: z9.string().min(1).describe(
         "Directory path in the sandbox workspace. Defaults to the workspace root."
       ).optional(),
-      limit: z8.coerce.number().int().min(1).describe("Maximum entries to return. Defaults to 500.").optional()
+      limit: z9.coerce.number().int().min(1).describe("Maximum entries to return. Defaults to 500.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async () => {
@@ -4959,23 +4953,15 @@ function createListDirTool() {
 }
 
 // src/chat/tools/web/image-generate.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var DEFAULT_IMAGE_MODEL = "google/gemini-3-pro-image";
 var imageGenerateOutputSchema = juniorToolResultSchema.extend({
-  model: z9.string(),
-  prompt: z9.string(),
-  enrichedPrompt: z9.string(),
-  image_count: z9.number().int().nonnegative(),
-  images: z9.array(
-    z9.object({
-      filename: z9.string(),
-      path: z9.string(),
-      attachment_path: z9.string(),
-      media_type: z9.string().optional(),
-      bytes: z9.number().int().nonnegative()
-    }).strict()
-  ),
-  delivery: z9.string()
+  model: z10.string(),
+  prompt: z10.string(),
+  enrichedPrompt: z10.string(),
+  image_count: z10.number().int().nonnegative(),
+  images: z10.array(generatedArtifactFileRefSchema),
+  delivery: z10.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.
 
@@ -5036,8 +5022,8 @@ function parseImageGenerationError(status, body, model) {
 function createImageGenerateTool(hooks, options = {}, deps = {}) {
   return zodTool({
     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: z9.object({
-      prompt: z9.string().min(1).max(4e3).describe("Image generation prompt.")
+    inputSchema: z10.object({
+      prompt: z10.string().min(1).max(4e3).describe("Image generation prompt.")
     }),
     outputSchema: imageGenerateOutputSchema,
     execute: async ({ prompt }) => {
@@ -5104,14 +5090,8 @@ function createImageGenerateTool(hooks, options = {}, deps = {}) {
           prompt,
           enrichedPrompt,
           image_count: artifactRefs.length,
-          images: artifactRefs.map((artifact) => ({
-            filename: artifact.filename,
-            path: artifact.path,
-            attachment_path: artifact.path,
-            media_type: artifact.mimeType,
-            bytes: artifact.bytes
-          })),
-          delivery: options.canSendFilesToActiveConversation ? "Generated images were written to sandbox paths. Use sendMessage to share or attach the image in the active conversation." : "Generated images were written to sandbox paths, but this runtime has no file-send tool for the active conversation."
+          images: artifactRefs,
+          delivery: options.canSendFilesToActiveConversation ? "Generated images were written to sandbox paths. To share them, pass the returned image objects unchanged as sendFiles files." : "Generated images were written to sandbox paths, but this runtime has no file-send tool for the active conversation."
         };
       }
       return {
@@ -5129,7 +5109,7 @@ function createImageGenerateTool(hooks, options = {}, deps = {}) {
 }
 
 // src/chat/tools/skill/call-mcp-tool.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 function resolveMcpArguments(input) {
   const extraKeys = Object.keys(input).filter(
     (key) => key !== "tool_name" && key !== "arguments"
@@ -5165,9 +5145,9 @@ function missingToolMessage(toolName, provider) {
 function createCallMcpToolTool(mcpToolManager) {
   return zodTool({
     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: z10.object({
-      tool_name: z10.string().min(1).describe("Exact MCP tool_name from searchMcpTools."),
-      arguments: z10.record(z10.string(), z10.unknown()).describe(
+    inputSchema: z11.object({
+      tool_name: z11.string().min(1).describe("Exact MCP tool_name from searchMcpTools."),
+      arguments: z11.record(z11.string(), z11.unknown()).describe(
         'Arguments matching the disclosed MCP tool schema, for example { "query": "..." } when searchMcpTools shows query is required.'
       ).optional()
     }).passthrough(),
@@ -5208,7 +5188,7 @@ function createCallMcpToolTool(mcpToolManager) {
 }
 
 // src/chat/tools/skill/load-skill.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 function toLoadedSkill(result, availableSkills) {
   if (result.ok !== true || typeof result.skill_name !== "string" || typeof result.description !== "string" || typeof result.skill_dir !== "string" || typeof result.instructions !== "string") {
     return null;
@@ -5257,8 +5237,8 @@ async function loadSkillFromHost(availableSkills, skillName) {
 function createLoadSkillTool(availableSkills, options) {
   return zodTool({
     description: "Load a skill by name for this turn. The result includes working_directory; resolve skill paths there and run skill-owned bash commands from there or with absolute paths. When the result includes mcp_provider, use searchMcpTools before callMcpTool. Use when a request clearly matches a known skill.",
-    inputSchema: z11.object({
-      skill_name: z11.string().min(1).describe("Skill name to load, without the leading slash.")
+    inputSchema: z12.object({
+      skill_name: z12.string().min(1).describe("Skill name to load, without the leading slash.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ skill_name }) => {
@@ -5276,7 +5256,7 @@ function createLoadSkillTool(availableSkills, options) {
 }
 
 // src/chat/tools/skill/search-mcp-tools.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // src/chat/tool-support/schema-summary.ts
 function getSchemaProperties(schema) {
@@ -5406,37 +5386,37 @@ function toActiveMcpCatalogSummaries(toolDefs) {
 // src/chat/tools/skill/search-mcp-tools.ts
 var DEFAULT_MAX_RESULTS = 5;
 var MAX_RESULTS = 20;
-var providerSummarySchema = z12.object({
-  provider: z12.string(),
-  description: z12.string(),
-  active: z12.boolean()
+var providerSummarySchema = z13.object({
+  provider: z13.string(),
+  description: z13.string(),
+  active: z13.boolean()
 }).strict();
-var mcpCallExampleSchema = z12.object({
-  tool_name: z12.string(),
-  arguments: z12.record(z12.string(), z12.string())
+var mcpCallExampleSchema = z13.object({
+  tool_name: z13.string(),
+  arguments: z13.record(z13.string(), z13.string())
 }).strict();
-var exposedToolSummarySchema = z12.object({
-  tool_name: z12.string(),
-  mcp_tool_name: z12.string(),
-  provider: z12.string(),
-  title: z12.string().optional(),
-  description: z12.string(),
-  signature: z12.string(),
+var exposedToolSummarySchema = z13.object({
+  tool_name: z13.string(),
+  mcp_tool_name: z13.string(),
+  provider: z13.string(),
+  title: z13.string().optional(),
+  description: z13.string(),
+  signature: z13.string(),
   call: mcpCallExampleSchema,
-  input_schema: z12.record(z12.string(), z12.unknown()),
-  input_schema_summary: z12.string(),
-  output_schema: z12.record(z12.string(), z12.unknown()).optional(),
-  annotations: z12.record(z12.string(), z12.unknown()).optional()
+  input_schema: z13.record(z13.string(), z13.unknown()),
+  input_schema_summary: z13.string(),
+  output_schema: z13.record(z13.string(), z13.unknown()).optional(),
+  annotations: z13.record(z13.string(), z13.unknown()).optional()
 }).strict();
 var searchMcpToolsOutputSchema = juniorToolResultSchema.extend({
-  query: z12.string().nullable(),
-  provider: z12.string().nullable(),
-  total_active_tools: z12.number().int().nonnegative(),
-  returned_tools: z12.number().int().nonnegative(),
-  execution_tool: z12.literal("callMcpTool"),
+  query: z13.string().nullable(),
+  provider: z13.string().nullable(),
+  total_active_tools: z13.number().int().nonnegative(),
+  returned_tools: z13.number().int().nonnegative(),
+  execution_tool: z13.literal("callMcpTool"),
   execution_example: mcpCallExampleSchema,
-  available_providers: z12.array(providerSummarySchema),
-  tools: z12.array(exposedToolSummarySchema)
+  available_providers: z13.array(providerSummarySchema),
+  tools: z13.array(exposedToolSummarySchema)
 }).strict();
 function normalize(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]+/g, " ").trim();
@@ -5556,14 +5536,14 @@ function searchProviderCatalog(providers, query) {
 function createSearchMcpToolsTool(mcpToolManager) {
   return zodTool({
     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: z12.object({
-      query: z12.string().min(1).describe(
+    inputSchema: z13.object({
+      query: z13.string().min(1).describe(
         "Optional search terms describing the MCP tool or arguments needed."
       ).optional(),
-      provider: z12.string().min(1).describe(
+      provider: z13.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: z12.number().int().min(1).max(MAX_RESULTS).describe("Maximum matching tool descriptors to return.").optional()
+      max_results: z13.number().int().min(1).max(MAX_RESULTS).describe("Maximum matching tool descriptors to return.").optional()
     }).strict(),
     outputSchema: searchMcpToolsOutputSchema,
     privateTraceResult: (result) => ({
@@ -5618,7 +5598,7 @@ function createSearchMcpToolsTool(mcpToolManager) {
 }
 
 // src/chat/tools/sandbox/read-file.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/chat/tool-support/text-range-result.ts
 var DEFAULT_READ_LIMIT = 1e3;
@@ -5693,10 +5673,10 @@ function createReadFileTool() {
   return zodTool({
     description: "Read a bounded line range from a file in the sandbox workspace. Use when you need exact file contents to verify facts or make edits safely. Prefer grep/findFiles/listDir for broad discovery.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z13.object({
-      path: z13.string().min(1).describe("Path to the file in the sandbox workspace."),
-      offset: z13.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
-      limit: z13.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
+    inputSchema: z14.object({
+      path: z14.string().min(1).describe("Path to the file in the sandbox workspace."),
+      offset: z14.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
+      limit: z14.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async () => {
@@ -5708,12 +5688,12 @@ function createReadFileTool() {
 }
 
 // src/chat/tools/runtime/report-progress.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 function createReportProgressTool() {
   return zodTool({
     description: "Update the user-visible assistant loading message with a short progress phase. For every non-trivial turn, call this early with the initial major work phase, then 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'). Skip trivial direct answers, generic filler, and minor substeps.",
-    inputSchema: z14.object({
-      message: z14.string().min(1).describe("Short user-facing progress message.")
+    inputSchema: z15.object({
+      message: z15.string().min(1).describe("Short user-facing progress message.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async () => ({
@@ -5724,34 +5704,34 @@ function createReportProgressTool() {
 }
 
 // src/chat/tools/resource-events.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // src/chat/resource-events/store.ts
 import { createHash } from "crypto";
 import { destinationSchema } from "@sentry/junior-plugin-api";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var RESOURCE_EVENT_PREFIX = "junior:resource_event_subscription";
 var INDEX_LOCK_TTL_MS = 1e4;
 var SUBSCRIPTION_LOCK_TTL_MS = 1e4;
 var SUBSCRIPTION_LOCK_WAIT_MS = 1e4;
 var SUBSCRIPTION_LOCK_RETRY_MS = 25;
 var SUBSCRIPTION_LOCK_HEARTBEAT_MS = 3e3;
-var subscriptionStatusSchema = z15.enum(["active", "cancelled", "completed"]);
-var subscriptionIdIndexSchema = z15.array(z15.string().min(1));
-var subscriptionSchema = z15.object({
-  conversationId: z15.string().min(1),
-  createdAtMs: z15.number().finite(),
+var subscriptionStatusSchema = z16.enum(["active", "cancelled", "completed"]);
+var subscriptionIdIndexSchema = z16.array(z16.string().min(1));
+var subscriptionSchema = z16.object({
+  conversationId: z16.string().min(1),
+  createdAtMs: z16.number().finite(),
   destination: destinationSchema,
-  events: z15.array(z15.string().min(1)).min(1),
-  expiresAtMs: z15.number().finite(),
-  id: z15.string().min(1),
-  intent: z15.string().min(1),
-  label: z15.string().min(1),
-  provider: z15.string().min(1),
-  resourceRef: z15.string().min(1),
-  resourceType: z15.string().min(1),
+  events: z16.array(z16.string().min(1)).min(1),
+  expiresAtMs: z16.number().finite(),
+  id: z16.string().min(1),
+  intent: z16.string().min(1),
+  label: z16.string().min(1),
+  provider: z16.string().min(1),
+  resourceRef: z16.string().min(1),
+  resourceType: z16.string().min(1),
   status: subscriptionStatusSchema,
-  updatedAtMs: z15.number().finite()
+  updatedAtMs: z16.number().finite()
 }).strict();
 function digest(value) {
   return createHash("sha256").update(value).digest("hex").slice(0, 32);
@@ -6091,23 +6071,23 @@ async function deliverResourceEventSubscription(input) {
 // src/chat/tools/resource-events.ts
 var DEFAULT_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
 var MAX_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
-var subscribeInputSchema = z16.object({
-  resourceRef: z16.string().describe("Opaque resource ref copied from a subscribable tool result."),
-  provider: z16.string().describe("Provider that owns the resource ref."),
-  resourceType: z16.string().describe("Provider-defined resource type from the subscribable hint."),
-  label: z16.string().describe("Human-readable resource label from the subscribable hint."),
-  events: z16.array(z16.string()).min(1).describe(
+var subscribeInputSchema = z17.object({
+  resourceRef: z17.string().describe("Opaque resource ref copied from a subscribable tool result."),
+  provider: z17.string().describe("Provider that owns the resource ref."),
+  resourceType: z17.string().describe("Provider-defined resource type from the subscribable hint."),
+  label: z17.string().describe("Human-readable resource label from the subscribable hint."),
+  events: z17.array(z17.string()).min(1).describe(
     "High-signal event names to deliver to this conversation when they occur."
   ),
-  intent: z16.string().describe(
+  intent: z17.string().describe(
     "Concise reason this conversation wants these events, used when an event arrives."
   ),
-  ttlMs: z16.coerce.number().describe(
+  ttlMs: z17.coerce.number().describe(
     "How long to keep the subscription active. Defaults to 14 days and is capped at 30 days."
   ).optional()
 });
-var cancelInputSchema = z16.object({
-  subscriptionId: z16.string().describe(
+var cancelInputSchema = z17.object({
+  subscriptionId: z17.string().describe(
     "Subscription id returned by subscribeToResourceEvents or listResourceEventSubscriptions."
   )
 });
@@ -6191,7 +6171,7 @@ function createSubscribeToResourceEventsTool(context) {
 function createListResourceEventSubscriptionsTool(context) {
   return zodTool({
     description: "List active resource event subscriptions for the current conversation.",
-    inputSchema: z16.object({}),
+    inputSchema: z17.object({}),
     outputSchema: juniorToolResultSchema,
     async execute() {
       const conversationId = requireConversationContext(context);
@@ -6326,11 +6306,11 @@ async function listThreadReplies(input) {
 }
 
 // src/chat/slack/timestamp-param.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 function slackTimestampParam(description) {
-  return z17.preprocess(
+  return z18.preprocess(
     (value) => typeof value === "number" && Number.isFinite(value) ? String(value) : value,
-    z17.string().min(1)
+    z18.string().min(1)
   ).describe(description);
 }
 function optionalSlackTimestampParam(description) {
@@ -6361,10 +6341,10 @@ function parseRequiredSlackTimestampParam(field, value) {
 }
 
 // src/chat/slack/tools/channel-list-messages.ts
-import { z as z18 } from "zod";
-var booleanInput2 = (description) => z18.preprocess(
+import { z as z19 } from "zod";
+var booleanInput2 = (description) => z19.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z18.boolean()
+  z19.boolean()
 ).describe(description);
 function normalizeRangeTimestamp(field, value, targetChannelId) {
   if (value === void 0) {
@@ -6391,9 +6371,9 @@ function createSlackChannelListMessagesTool(context) {
   return zodTool({
     description: "List channel messages from Slack history in the active channel context. Use when the user asks for recent or historical channel context outside this thread. Do not use for live monitoring or when current thread context already answers the question.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z18.object({
-      limit: z18.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
-      cursor: z18.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
+    inputSchema: z19.object({
+      limit: z19.coerce.number().int().min(1).max(1e3).describe("Maximum number of messages to return across pages.").optional(),
+      cursor: z19.string().min(1).describe("Optional cursor to continue from a prior call.").optional(),
       oldest: optionalSlackTimestampParam(
         "Optional oldest message timestamp (Slack ts) for range filtering."
       ),
@@ -6403,7 +6383,7 @@ function createSlackChannelListMessagesTool(context) {
       inclusive: booleanInput2(
         "Whether oldest/latest bounds should be inclusive."
       ).optional(),
-      max_pages: z18.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
+      max_pages: z19.coerce.number().int().min(1).max(10).describe("Maximum number of API pages to traverse in a single call.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({
@@ -6477,7 +6457,7 @@ function createSlackChannelListMessagesTool(context) {
 }
 
 // src/chat/slack/tools/conversation-search.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // src/chat/slack/outbound.ts
 var MAX_SLACK_MESSAGE_TEXT_CHARS = 4e4;
@@ -6636,12 +6616,10 @@ async function uploadFilesToConversation(input) {
       filename
     };
   });
-  const initialComment = input.initialComment?.trim();
   const response = await withSlackRetries(
     () => getSlackClient().filesUploadV2({
       channel_id: channelId,
       ...threadTs ? { thread_ts: threadTs } : {},
-      ...initialComment ? { initial_comment: initialComment } : {},
       file_uploads: fileUploads
     }),
     3,
@@ -6741,17 +6719,17 @@ async function removeReactionFromMessage(input) {
 // src/chat/slack/tools/conversation-search.ts
 var DEFAULT_LIMIT = 5;
 var conversationSearchOutputSchema = juniorToolResultSchema.extend({
-  query: z19.string(),
-  count: z19.number().int().nonnegative(),
-  threads: z19.array(
-    z19.object({
-      conversation_id: z19.string().min(1),
-      thread_ts: z19.string().min(1),
-      message_id: z19.string().min(1),
-      message_role: z19.enum(["assistant", "user"]),
-      message_timestamp: z19.string().datetime(),
-      excerpt: z19.string(),
-      permalink: z19.string().url().optional()
+  query: z20.string(),
+  count: z20.number().int().nonnegative(),
+  threads: z20.array(
+    z20.object({
+      conversation_id: z20.string().min(1),
+      thread_ts: z20.string().min(1),
+      message_id: z20.string().min(1),
+      message_role: z20.enum(["assistant", "user"]),
+      message_timestamp: z20.string().datetime(),
+      excerpt: z20.string(),
+      permalink: z20.string().url().optional()
     }).strict()
   )
 });
@@ -6764,9 +6742,9 @@ function createSlackConversationSearchTool(scope, currentConversationId, deps =
       description: "Search retained public Junior conversation threads in the current Slack workspace."
     },
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z19.object({
-      query: z19.string().trim().min(1).max(200).describe("Words or a short phrase to find in prior conversations."),
-      limit: z19.number().int().min(1).max(10).describe("Maximum number of prior conversation threads to return.").nullable().optional()
+    inputSchema: z20.object({
+      query: z20.string().trim().min(1).max(200).describe("Words or a short phrase to find in prior conversations."),
+      limit: z20.number().int().min(1).max(10).describe("Maximum number of prior conversation threads to return.").nullable().optional()
     }),
     outputSchema: conversationSearchOutputSchema,
     execute: async ({ query, limit }) => {
@@ -6813,27 +6791,27 @@ function createSlackConversationSearchTool(scope, currentConversationId, deps =
 }
 
 // src/chat/slack/tools/public-search.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var DEFAULT_LIMIT2 = 10;
-var optionalTimestampSchema = z20.preprocess(
+var optionalTimestampSchema = z21.preprocess(
   (value) => typeof value === "string" && value.trim() === "" ? void 0 : value,
-  z20.coerce.number().int().nonnegative().describe("Optional Unix timestamp bound.").optional()
+  z21.coerce.number().int().nonnegative().describe("Optional Unix timestamp bound.").optional()
 );
-var searchMessageSchema = z20.object({
-  author_name: z20.string().optional(),
-  author_user_id: z20.string().optional(),
-  channel_id: z20.string().min(1),
-  channel_name: z20.string().optional(),
-  message_ts: z20.string().min(1),
-  content: z20.string(),
-  is_author_bot: z20.boolean().optional(),
-  permalink: z20.string().url()
+var searchMessageSchema = z21.object({
+  author_name: z21.string().optional(),
+  author_user_id: z21.string().optional(),
+  channel_id: z21.string().min(1),
+  channel_name: z21.string().optional(),
+  message_ts: z21.string().min(1),
+  content: z21.string(),
+  is_author_bot: z21.boolean().optional(),
+  permalink: z21.string().url()
 });
 var publicSearchOutputSchema = juniorToolResultSchema.extend({
-  query: z20.string(),
-  count: z20.number().int().nonnegative(),
-  messages: z20.array(searchMessageSchema),
-  next_cursor: z20.string().optional()
+  query: z21.string(),
+  count: z21.number().int().nonnegative(),
+  messages: z21.array(searchMessageSchema),
+  next_cursor: z21.string().optional()
 });
 function normalizeMessage(value) {
   const parsed = searchMessageSchema.safeParse(value);
@@ -6855,8 +6833,8 @@ function createSlackPublicSearchTool(actionToken) {
   return zodTool({
     description: "Search public Slack channel messages across the current workspace. Use when the user asks about company activity, announcements, public mentions, or context outside the active channel. Search only when requested or clearly needed, prefer focused keywords and time bounds, and cite returned permalinks. This never searches private channels or DMs.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z20.object({
-      query: z20.string().trim().min(1).max(500).describe(
+    inputSchema: z21.object({
+      query: z21.string().trim().min(1).max(500).describe(
         "A focused Slack search query, including Slack search filters when useful."
       ),
       after: optionalTimestampSchema.describe(
@@ -6865,10 +6843,10 @@ function createSlackPublicSearchTool(actionToken) {
       before: optionalTimestampSchema.describe(
         "Optional Unix timestamp upper bound."
       ),
-      cursor: z20.string().min(1).describe("Cursor for the next result page.").optional(),
-      limit: z20.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
-      sort: z20.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
-      sort_dir: z20.enum(["asc", "desc"]).describe("Sort direction.").optional()
+      cursor: z21.string().min(1).describe("Cursor for the next result page.").optional(),
+      limit: z21.coerce.number().int().min(1).max(20).describe("Maximum results to return; Slack allows at most 20.").optional(),
+      sort: z21.enum(["score", "timestamp"]).describe("Rank by relevance or timestamp.").optional(),
+      sort_dir: z21.enum(["asc", "desc"]).describe("Sort direction.").optional()
     }),
     outputSchema: publicSearchOutputSchema,
     execute: async ({
@@ -6934,7 +6912,7 @@ function createSlackPublicSearchTool(actionToken) {
 }
 
 // src/chat/slack/tools/message-add-reaction.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 
 // src/chat/tools/idempotency.ts
 function stableSerialize(value) {
@@ -6958,8 +6936,8 @@ function createOperationKey(toolName, input) {
 function createSlackMessageAddReactionTool(context, state) {
   return zodTool({
     description: "Add an emoji reaction to the current inbound Slack message. Use when the user asks for a reaction on the current message without another target. Provide a Slack emoji alias name (for example `thumbsup`, `white_check_mark`, or `thumbsup::skin-tone-6`), not a unicode emoji glyph. The target message is injected by runtime context; do not use this for arbitrary historical messages.",
-    inputSchema: z21.object({
-      emoji: z21.string().min(1).max(64).describe(
+    inputSchema: z22.object({
+      emoji: z22.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."
       )
     }),
@@ -7008,23 +6986,24 @@ function createSlackMessageAddReactionTool(context, state) {
   });
 }
 
-// src/chat/slack/tools/send-message.ts
+// src/chat/slack/tools/send-files.ts
 import { createHash as createHash2 } from "crypto";
-import { z as z22 } from "zod";
-var fileInputSchema = z22.object({
-  path: z22.string().min(1).describe(
-    "Sandbox file path to include in the message. Absolute paths and workspace-relative paths are supported."
-  ),
-  filename: z22.string().min(1).nullable().optional().describe(
-    "Optional filename override shown in Slack. Null is treated as omitted."
-  ),
-  mimeType: z22.string().min(1).nullable().optional().describe("Optional MIME type override. Null is treated as omitted.")
+import { z as z23 } from "zod";
+var sendFilesDataSchema = z23.object({
+  channel_id: z23.string().min(1),
+  deduplicated: z23.boolean().optional(),
+  file_count: z23.number().int().nonnegative(),
+  file_ids: z23.array(z23.string().min(1)).optional(),
+  thread_ts: z23.string().min(1)
 });
-function hasText(text) {
-  return typeof text === "string" && text.trim().length > 0;
-}
-function normalizeMessageFiles(files) {
-  return (files ?? []).map((file) => ({
+var sendFilesResultSchema = juniorToolResultSchema.extend({
+  ok: z23.literal(true),
+  status: z23.literal("success"),
+  target: z23.string().min(1),
+  data: sendFilesDataSchema
+});
+function normalizeFiles(files) {
+  return files.map((file) => ({
     path: file.path,
     ...file.filename ? { filename: file.filename } : {},
     ...file.mimeType ? { mimeType: file.mimeType } : {}
@@ -7042,18 +7021,17 @@ function fileOperationInput(files) {
     sha256: fileContentDigest(file.data)
   }));
 }
-function createSendMessageTool(context, state, materializeFile) {
+function createSendFilesTool(context, state, materializeFile) {
   return zodTool({
-    description: "Send a Slack message with optional files into the active Slack conversation. Use when the user asks to attach, send, or share files here, in this conversation, or in this thread. The message can contain text, files, or both; file-only messages are allowed. Do not use for top-level channel posts, other named channels, inline @mentions, or pinging mentioned users.",
-    inputSchema: z22.object({
-      text: z22.string().max(4e4).nullable().optional().describe("Slack mrkdwn text to send. Null is treated as omitted."),
-      files: z22.array(fileInputSchema).min(1).nullable().optional().describe(
-        "Sandbox files to include in the message. Null is treated as omitted."
+    description: "Send one or more sandbox files into the active Slack conversation. Use when the user asks to attach, send, or share files here, in this conversation, or in this thread. Do not use for ordinary assistant text, top-level channel posts, other named channels, inline @mentions, or pinging mentioned users.",
+    inputSchema: z23.object({
+      files: z23.array(sandboxFileReferenceSchema).min(1).describe(
+        "One or more existing sandbox files. Objects returned by imageGenerate or webFetch can be passed unchanged."
       )
     }),
-    outputSchema: juniorToolResultSchema,
-    execute: async ({ text, files }) => {
-      const filesToSend = normalizeMessageFiles(files);
+    outputSchema: sendFilesResultSchema,
+    execute: async ({ files }) => {
+      const filesToSend = normalizeFiles(files);
       const activeChannelId = context.sourceChannelId;
       if (!activeChannelId) {
         throw new ToolInputError("No active Slack conversation is available.");
@@ -7064,48 +7042,34 @@ function createSendMessageTool(context, state, materializeFile) {
           "No active Slack conversation timestamp is available."
         );
       }
-      const textToSend = hasText(text) ? text : void 0;
-      if (!textToSend && filesToSend.length === 0) {
-        throw new ToolInputError(
-          "sendMessage requires text or at least one file."
-        );
-      }
       const materializedFiles = await Promise.all(
         filesToSend.map((file) => materializeFile(file))
       );
-      const operationKey = createOperationKey("sendMessage", {
+      const operationKey = createOperationKey("sendFiles", {
         channel_id: activeChannelId,
         thread_ts: threadTs,
-        ...textToSend ? { text: textToSend } : {},
-        ...materializedFiles.length > 0 ? { files: fileOperationInput(materializedFiles) } : {}
+        files: fileOperationInput(materializedFiles)
       });
       const cached = state.getOperationResult(operationKey);
       if (cached) {
-        return {
+        return sendFilesResultSchema.parse({
           ...cached,
           data: {
             ...cached.data,
             deduplicated: true
-          },
-          deduplicated: true
-        };
+          }
+        });
       }
       const uploads = materializedFiles.map((file) => ({
         data: file.data,
         filename: file.filename
       }));
-      const posted = uploads.length === 0 && textToSend ? await postSlackMessage({
-        channelId: activeChannelId,
-        text: textToSend,
-        threadTs,
-        includePermalink: true
-      }) : void 0;
-      const uploaded = uploads.length > 0 ? await uploadFilesToConversation({
+      const uploaded = await uploadFilesToConversation({
         channelId: activeChannelId,
         files: uploads,
-        threadTs,
-        ...textToSend ? { initialComment: textToSend } : {}
-      }) : void 0;
+        threadTs
+      });
+      const fileIds = uploaded?.files?.map((file) => file.id).filter((id) => Boolean(id));
       const response = {
         ok: true,
         status: "success",
@@ -7113,19 +7077,9 @@ function createSendMessageTool(context, state, materializeFile) {
         data: {
           channel_id: activeChannelId,
           thread_ts: threadTs,
-          ...posted ? { ts: posted.ts, permalink: posted.permalink } : {},
-          ...uploads.length > 0 ? { file_count: uploads.length } : {},
-          ...uploaded?.files ? {
-            file_ids: uploaded.files.map((file) => file.id).filter((id) => Boolean(id))
-          } : {}
-        },
-        channel_id: activeChannelId,
-        thread_ts: threadTs,
-        ...posted ? { ts: posted.ts, permalink: posted.permalink } : {},
-        ...uploads.length > 0 ? { file_count: uploads.length } : {},
-        ...uploaded?.files ? {
-          file_ids: uploaded.files.map((file) => file.id).filter((id) => Boolean(id))
-        } : {}
+          file_count: uploads.length,
+          ...fileIds ? { file_ids: fileIds } : {}
+        }
       };
       state.setOperationResult(operationKey, response);
       return response;
@@ -7375,13 +7329,13 @@ function storedCanvasUrl(state, canvasId) {
 }
 
 // src/chat/slack/tools/canvas/create.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 function createSlackCanvasCreateTool(context, state) {
   return zodTool({
     description: "Create a Slack canvas for long-form output in the active assistant context channel. Use when the answer is better as a reusable document than a thread reply: long-form research, timelines, bios/profiles, structured notes, plans, comparisons, or anything likely to exceed one compact Slack reply. After creating it, reply with one or two short sentences plus the canvas link; do not recap the canvas contents. Do not use for short answers that fit cleanly in one normal thread reply.",
-    inputSchema: z23.object({
-      title: z23.string().min(1).max(160).describe("Canvas title."),
-      markdown: z23.string().min(1).describe("Canvas markdown body content.")
+    inputSchema: z24.object({
+      title: z24.string().min(1).max(160).describe("Canvas title."),
+      markdown: z24.string().min(1).describe("Canvas markdown body content.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ title, markdown }) => {
@@ -7444,35 +7398,35 @@ function createSlackCanvasCreateTool(context, state) {
 }
 
 // src/chat/slack/tools/canvas/edit.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 function prepareCanvasEditArguments(input) {
   return prepareTextReplacementArguments(input);
 }
-var editReplacementSchema2 = z24.object({
-  oldText: z24.string().min(1).describe(
+var editReplacementSchema2 = z25.object({
+  oldText: z25.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: z24.string().describe("Replacement Canvas markdown for this edit.")
+  newText: z25.string().describe("Replacement Canvas markdown for this edit.")
 });
 var slackCanvasEditOutputSchema = juniorToolResultSchema.extend({
-  canvas_id: z24.string().optional(),
-  title: z24.string().optional(),
-  permalink: z24.string().optional(),
-  diff: z24.string().optional(),
-  first_changed_line: z24.number().int().positive().optional(),
-  replacements: z24.number().int().nonnegative().optional(),
-  normalized_heading_count: z24.number().int().nonnegative().optional(),
-  summary: z24.string().optional(),
-  deduplicated: z24.boolean().optional()
+  canvas_id: z25.string().optional(),
+  title: z25.string().optional(),
+  permalink: z25.string().optional(),
+  diff: z25.string().optional(),
+  first_changed_line: z25.number().int().positive().optional(),
+  replacements: z25.number().int().nonnegative().optional(),
+  normalized_heading_count: z25.number().int().nonnegative().optional(),
+  summary: z25.string().optional(),
+  deduplicated: z25.boolean().optional()
 }).strict();
 function createSlackCanvasEditTool(state) {
   return zodTool({
     description: "Edit one Slack canvas with exact markdown replacements. Use for precise changes to existing Canvas content; prefer this over slackCanvasWrite for targeted changes. Each oldText must match exactly, be unique, and not overlap another edit. Returns a diff. Multiple changes to the same canvas: use one edits[] call.",
     prepareArguments: prepareCanvasEditArguments,
     executionMode: "sequential",
-    inputSchema: z24.object({
-      canvas: z24.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
-      edits: z24.array(editReplacementSchema2).min(1).describe(
+    inputSchema: z25.object({
+      canvas: z25.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
+      edits: z25.array(editReplacementSchema2).min(1).describe(
         "Exact replacements matched against the current Canvas body, not incrementally."
       )
     }),
@@ -7550,29 +7504,29 @@ function createSlackCanvasEditTool(state) {
 }
 
 // src/chat/slack/tools/canvas/read.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var slackCanvasReadOutputSchema = juniorToolResultSchema.extend({
-  canvas_id: z25.string().optional(),
-  title: z25.string().optional(),
-  permalink: z25.string().optional(),
-  mimetype: z25.string().optional(),
-  filetype: z25.string().optional(),
-  original_byte_length: z25.number().int().nonnegative().optional(),
-  content: z25.string().optional(),
-  start_line: z25.number().int().positive().optional(),
-  end_line: z25.number().int().nonnegative().optional(),
-  total_lines: z25.number().int().nonnegative().optional()
+  canvas_id: z26.string().optional(),
+  title: z26.string().optional(),
+  permalink: z26.string().optional(),
+  mimetype: z26.string().optional(),
+  filetype: z26.string().optional(),
+  original_byte_length: z26.number().int().nonnegative().optional(),
+  content: z26.string().optional(),
+  start_line: z26.number().int().positive().optional(),
+  end_line: z26.number().int().nonnegative().optional(),
+  total_lines: z26.number().int().nonnegative().optional()
 }).strict();
 function createSlackCanvasReadTool() {
   return zodTool({
     description: "Read a bounded line range from a Slack canvas as markdown. Use when you need exact Canvas contents to verify facts or make edits safely. Do not use for generic web pages \u2014 use webFetch for those.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z25.object({
-      canvas: z25.string().min(1).describe(
+    inputSchema: z26.object({
+      canvas: z26.string().min(1).describe(
         "Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL (e.g. `https://team.slack.com/docs/T.../F...`)."
       ),
-      offset: z25.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
-      limit: z25.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
+      offset: z26.coerce.number().int().min(1).describe("1-indexed line number to start reading from.").optional(),
+      limit: z26.coerce.number().int().min(1).describe("Maximum number of lines to read. Defaults to 1000.").optional()
     }),
     outputSchema: slackCanvasReadOutputSchema,
     execute: async ({ canvas, offset, limit }) => {
@@ -7629,14 +7583,14 @@ function createSlackCanvasReadTool() {
 }
 
 // src/chat/slack/tools/canvas/write.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 function createSlackCanvasWriteTool(state) {
   return zodTool({
     description: "Write UTF-8 markdown content to a Slack canvas. Use for deliberate full-Canvas replacement after validation; use slackCanvasEdit for targeted changes to existing canvas content.",
     executionMode: "sequential",
-    inputSchema: z26.object({
-      canvas: z26.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
-      content: z26.string().describe("UTF-8 markdown content to write.")
+    inputSchema: z27.object({
+      canvas: z27.string().min(1).describe("Canvas/file ID (e.g. `F0ABCDEF`) or Slack canvas/docs URL."),
+      content: z27.string().describe("UTF-8 markdown content to write.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ canvas, content }) => {
@@ -7872,12 +7826,12 @@ async function updateListItem(input) {
 }
 
 // src/chat/slack/id-param.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 function slackChannelIdParam(description) {
-  return z27.string().min(1).describe(description);
+  return z28.string().min(1).describe(description);
 }
 function slackUserIdParam(description) {
-  return z27.string().min(1).describe(description);
+  return z28.string().min(1).describe(description);
 }
 function parseRequiredSlackChannelIdParam(field, value) {
   const channelId = parseSlackChannelId(value);
@@ -7901,16 +7855,16 @@ function parseRequiredSlackUserIdParam(field, value) {
 }
 
 // src/chat/slack/tools/list/add-items.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 function createSlackListAddItemsTool(state) {
   return zodTool({
     description: "Add tasks to the active Slack list tracked in artifact context. Use when the user wants actionable items recorded in the current thread list. Do not use when no list exists and list creation was not requested.",
-    inputSchema: z28.object({
-      items: z28.array(z28.string().min(1)).min(1).max(25).describe("List item titles to create."),
+    inputSchema: z29.object({
+      items: z29.array(z29.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: z28.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
+      due_date: z29.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Optional due date in YYYY-MM-DD format.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ items, assignee_user_id, due_date }) => {
@@ -7964,12 +7918,12 @@ function createSlackListAddItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/create.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 function createSlackListCreateTool(state) {
   return zodTool({
     description: "Create a Slack todo list for action tracking. Use when the user needs structured tasks with ownership/completion tracking. Do not use for one-off notes without task management needs.",
-    inputSchema: z29.object({
-      name: z29.string().min(1).max(160).describe("Name for the new Slack list.")
+    inputSchema: z30.object({
+      name: z30.string().min(1).max(160).describe("Name for the new Slack list.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ name }) => {
@@ -8001,13 +7955,13 @@ function createSlackListCreateTool(state) {
 }
 
 // src/chat/slack/tools/list/get-items.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 function createSlackListGetItemsTool(state) {
   return zodTool({
     description: "Read items from the active Slack list tracked in artifact context. Use when the user asks for task status, open items, or list contents. Do not use when list state is already known from the immediately prior result.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z30.object({
-      limit: z30.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
+    inputSchema: z31.object({
+      limit: z31.coerce.number().int().min(1).max(200).describe("Maximum number of list items to return.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ limit }) => {
@@ -8032,21 +7986,21 @@ function createSlackListGetItemsTool(state) {
 }
 
 // src/chat/slack/tools/list/update-item.ts
-import { z as z31 } from "zod";
-var booleanInput3 = (description) => z31.preprocess(
+import { z as z32 } from "zod";
+var booleanInput3 = (description) => z32.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z31.boolean()
+  z32.boolean()
 ).describe(description);
-var updateListItemInputSchema = z31.union([
-  z31.object({
-    item_id: z31.string().min(1).describe("ID of the Slack list item to update."),
+var updateListItemInputSchema = z32.union([
+  z32.object({
+    item_id: z32.string().min(1).describe("ID of the Slack list item to update."),
     completed: booleanInput3("Optional completion status update."),
-    title: z31.string().min(1).describe("Optional new item title.").optional()
+    title: z32.string().min(1).describe("Optional new item title.").optional()
   }),
-  z31.object({
-    item_id: z31.string().min(1).describe("ID of the Slack list item to update."),
+  z32.object({
+    item_id: z32.string().min(1).describe("ID of the Slack list item to update."),
     completed: booleanInput3("Optional completion status update.").optional(),
-    title: z31.string().min(1).describe("Optional new item title.")
+    title: z32.string().min(1).describe("Optional new item title.")
   })
 ]);
 function createSlackListUpdateItemTool(state) {
@@ -8122,7 +8076,7 @@ async function checkSlackChannelReadAccess(args) {
 }
 
 // src/chat/slack/tools/thread-read.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 
 // src/chat/slack/tools/slack-message-url.ts
 var SLACK_HOST_PATTERN = /^[a-z0-9-]+\.slack(?:-gov)?\.com$/;
@@ -8295,8 +8249,8 @@ function createSlackThreadReadTool(context, deps = {}) {
   return zodTool({
     description: "Read a Slack thread from a shared Slack message archive URL or explicit channel + timestamp. Use when the user shares a Slack message link (https://*.slack.com/archives/...) and you need the referenced message and its thread context. Only the current conversation and public channels Junior has seen in this workspace are readable.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z32.object({
-      url: z32.string().min(1).describe(
+    inputSchema: z33.object({
+      url: z33.string().min(1).describe(
         "Slack message archive URL, e.g. https://workspace.slack.com/archives/C123/p1700000000123456"
       ).optional(),
       channel_id: slackChannelIdParam(
@@ -8305,8 +8259,8 @@ function createSlackThreadReadTool(context, deps = {}) {
       ts: slackTimestampParam(
         "Slack message timestamp (e.g. 1700000000.123456). May be the thread root or any message in the thread."
       ).optional(),
-      limit: z32.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
-      max_pages: z32.coerce.number().int().min(1).max(10).describe("Maximum number of Slack API pages to traverse.").optional()
+      limit: z33.coerce.number().int().min(1).max(1e3).describe("Maximum number of thread messages to fetch.").optional(),
+      max_pages: z33.coerce.number().int().min(1).max(10).describe("Maximum number of Slack API pages to traverse.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ url, channel_id, ts, limit, max_pages }) => {
@@ -8562,29 +8516,29 @@ async function searchSlackUsers(options) {
 }
 
 // src/chat/slack/tools/user-lookup.ts
-import { z as z33 } from "zod";
-var booleanInput4 = (description) => z33.preprocess(
+import { z as z34 } from "zod";
+var booleanInput4 = (description) => z34.preprocess(
   (value) => value === "true" ? true : value === "false" ? false : value,
-  z33.boolean()
+  z34.boolean()
 ).describe(description);
 function createSlackUserLookupTool() {
   return zodTool({
     description: "Look up Slack user profiles by user ID, email, or name search. Use when you need to identify a user, resolve cross-platform identity, or look up profile details like title or status. Returns profile fields including custom fields. For user ID lookup, pass a Slack user ID (e.g. U039RR91S). For search, pass a name query.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z33.object({
+    inputSchema: z34.object({
       user_id: slackUserIdParam(
         "Slack user ID to look up (e.g. U039RR91S). Mutually exclusive with email and query."
       ).optional(),
-      email: z33.string().min(3).describe(
+      email: z34.string().min(3).describe(
         "Email address to look up. Mutually exclusive with user_id and query."
       ).optional(),
-      query: z33.string().min(2).describe(
+      query: z34.string().min(2).describe(
         "Name to search for (matches against username, display name, real name). Mutually exclusive with user_id and email."
       ).optional(),
-      limit: z33.coerce.number().int().min(1).max(20).describe(
+      limit: z34.coerce.number().int().min(1).max(20).describe(
         "Maximum number of results to return for name search. Defaults to 10."
       ).optional(),
-      max_pages: z33.coerce.number().int().min(1).max(5).describe(
+      max_pages: z34.coerce.number().int().min(1).max(5).describe(
         "Maximum number of Slack API pages to scan for name search. Defaults to 3."
       ).optional(),
       include_bots: booleanInput4(
@@ -8688,18 +8642,18 @@ function createSlackUserLookupTool() {
 }
 
 // src/chat/tools/system-time.ts
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 var systemTimeOutputSchema = juniorToolResultSchema.extend({
-  unix_ms: z34.number(),
-  iso_utc: z34.string(),
-  iso_local: z34.string(),
-  timezone_offset_minutes: z34.number()
+  unix_ms: z35.number(),
+  iso_utc: z35.string(),
+  iso_local: z35.string(),
+  timezone_offset_minutes: z35.number()
 });
 function createSystemTimeTool() {
   return zodTool({
     description: "Return current system time in UTC and local ISO formats. Use when the user asks for current time/date context. Do not use as a substitute for historical or timezone-conversion research.",
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z34.object({}),
+    inputSchema: z35.object({}),
     outputSchema: systemTimeOutputSchema,
     privateTraceResult: (result) => ({
       ok: result.ok,
@@ -8728,27 +8682,30 @@ function createSystemTimeTool() {
 }
 
 // src/chat/tools/handoff/tool.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 var HANDOFF_TOOL_NAME = "handoff";
 function createHandoffTool(handoff) {
-  const profileSchema = z35.enum(handoff.profiles);
-  const defaultProfile = handoff.profiles[0];
+  const profileSchema = z36.enum(handoff.profiles);
   const handoffResultSchema = juniorToolResultSchema.extend({
     model_profile: profileSchema
   });
   const profileNames = handoff.profiles.map((profile) => `\`${profile}\``).join(", ");
   return zodTool({
-    description: `Permanently switch this conversation to a more capable model profile, replace prior context with a continuation summary, and continue the same task with the same workspace and all other normal tools. Available profiles: ${profileNames}. Omit profile to use \`${defaultProfile}\`. Call it as the only tool in the assistant message when the system tool policy requires a model upgrade.`,
+    description: `Switch to another execution profile and continue the same task. Profiles: ${profileNames}. Call this as the only tool.`,
     executionMode: "sequential",
-    inputSchema: z35.object({
-      profile: profileSchema.nullish().describe(
-        "Named model profile to use for the rest of the conversation; omit or pass null for the default"
-      )
+    inputSchema: z36.object({
+      profile: profileSchema.describe("Target execution profile")
     }).strict(),
     outputSchema: handoffResultSchema,
     execute: async (input, options) => {
-      const profile = input.profile ?? defaultProfile;
-      await handoff.execute(profile, options.signal);
+      const profile = input.profile;
+      if (!options.toolCallId) {
+        throw new ToolInputError("Handoff requires an active tool call ID");
+      }
+      await handoff.execute(profile, {
+        ...options.signal ? { signal: options.signal } : {},
+        toolCallId: options.toolCallId
+      });
       return {
         ok: true,
         status: "success",
@@ -8759,7 +8716,7 @@ function createHandoffTool(handoff) {
 }
 
 // src/chat/tools/web/fetch-tool.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 
 // src/chat/tools/web/constants.ts
 var USER_AGENT = "junior-bot/0.1";
@@ -9206,9 +9163,9 @@ function createWebFetchTool(hooks, options = {}) {
       destructiveHint: false,
       openWorldHint: true
     },
-    inputSchema: z36.object({
-      url: z36.string().min(1).describe("HTTP(S) URL to fetch."),
-      max_chars: z36.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
+    inputSchema: z37.object({
+      url: z37.string().min(1).describe("HTTP(S) URL to fetch."),
+      max_chars: z37.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ url, max_chars }) => {
@@ -9246,14 +9203,8 @@ function createWebFetchTool(hooks, options = {}) {
             url: safeUrl.toString(),
             media_type: contentType,
             bytes: bytes.byteLength,
-            images: artifactRefs.map((artifact) => ({
-              filename: artifact.filename,
-              path: artifact.path,
-              attachment_path: artifact.path,
-              media_type: artifact.mimeType,
-              bytes: artifact.bytes
-            })),
-            delivery: artifactRefs.length > 0 ? options.canSendFilesToActiveConversation ? "Fetched image was written to a sandbox path. Use sendMessage to share or attach the image in the active conversation." : "Fetched image was written to a sandbox path, but this runtime has no file-send tool for the active conversation." : "Fetched image bytes are available only in this tool result; this runtime has no file-send tool for the active conversation."
+            images: artifactRefs,
+            delivery: artifactRefs.length > 0 ? options.canSendFilesToActiveConversation ? "Fetched images were written to sandbox paths. To share them, pass the returned image objects unchanged as sendFiles files." : "Fetched image was written to a sandbox path, but this runtime has no file-send tool for the active conversation." : "Fetched image bytes are available only in this tool result; this runtime has no file-send tool for the active conversation."
           };
         }
         return await extractWebFetchResponse(safeUrl, response, max_chars);
@@ -9275,7 +9226,7 @@ function createWebFetchTool(hooks, options = {}) {
 }
 
 // src/chat/tools/web/search.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
 import { getModel } from "@earendil-works/pi-ai/compat";
@@ -9326,9 +9277,9 @@ function createWebSearchTool(override) {
       destructiveHint: false,
       openWorldHint: true
     },
-    inputSchema: z37.object({
-      query: z37.string().min(1).max(500).describe("Search query."),
-      max_results: z37.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
+    inputSchema: z38.object({
+      query: z38.string().min(1).max(500).describe("Search query."),
+      max_results: z38.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
     }),
     outputSchema: juniorToolResultSchema,
     execute: async ({ query, max_results }) => {
@@ -9398,14 +9349,14 @@ function createWebSearchTool(override) {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 function createWriteFileTool() {
   return zodTool({
     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: z38.object({
-      path: z38.string().min(1).describe("Path to write in the sandbox workspace."),
-      content: z38.string().describe("UTF-8 file content to write.")
+    inputSchema: z39.object({
+      path: z39.string().min(1).describe("Path to write in the sandbox workspace."),
+      content: z39.string().describe("UTF-8 file content to write.")
     }),
     outputSchema: juniorToolResultSchema,
     execute: async () => {
@@ -9450,7 +9401,7 @@ function createTools(availableSkills, hooks = {}, context) {
   const slackContext = getSlackToolContext(context);
   const slackSourceCapabilities = slackContext ? resolveChannelCapabilities(slackContext.sourceChannelId) : void 0;
   const canSendFilesToActiveConversation = Boolean(
-    slackContext && slackSourceCapabilities?.canSendMessage
+    slackContext && slackSourceCapabilities?.canSendFiles
   );
   const tools = {
     loadSkill: createLoadSkillTool(availableSkills, {
@@ -9529,8 +9480,8 @@ function createTools(availableSkills, hooks = {}, context) {
         state
       );
     }
-    if (rawChannelCapabilities.canSendMessage) {
-      tools.sendMessage = createSendMessageTool(
+    if (rawChannelCapabilities.canSendFiles) {
+      tools.sendFiles = createSendFilesTool(
         slackContext,
         state,
         (input) => readSandboxFileUpload(context.sandbox, input)
@@ -9935,10 +9886,6 @@ function parseOAuthStatePayload(value) {
   if (value.source !== void 0 && (!source || !source.success)) {
     return void 0;
   }
-  const pendingMessage = optionalString(value.pendingMessage);
-  if (pendingMessage && !source?.success) {
-    return void 0;
-  }
   return {
     userId: value.userId,
     provider: value.provider,
@@ -9946,8 +9893,6 @@ function parseOAuthStatePayload(value) {
     ...destination ? { destination } : {},
     ...source?.success ? { source: source.data } : {},
     ...optionalString(value.threadTs) ? { threadTs: optionalString(value.threadTs) } : {},
-    ...pendingMessage ? { pendingMessage } : {},
-    ...isRecord(value.configuration) ? { configuration: value.configuration } : {},
     ...optionalString(value.resumeConversationId) ? { resumeConversationId: optionalString(value.resumeConversationId) } : {},
     ...optionalString(value.resumeSessionId) ? { resumeSessionId: optionalString(value.resumeSessionId) } : {},
     ...optionalString(value.scope) ? { scope: optionalString(value.scope) } : {}
@@ -10065,7 +10010,6 @@ async function startOAuthFlow(provider, input) {
       error: "Cannot determine base URL (set JUNIOR_BASE_URL or deploy to Vercel)"
     };
   }
-  const configuration = input.userMessage && input.channelConfiguration ? await input.channelConfiguration.resolveValues() : void 0;
   const state = randomBytes(32).toString("hex");
   const requestedScope = input.scope ?? providerConfig.scope;
   await getStateAdapter().set(
@@ -10077,8 +10021,6 @@ async function startOAuthFlow(provider, input) {
       ...input.destination ? { destination: input.destination } : {},
       ...input.source ? { source: input.source } : {},
       ...input.threadTs ? { threadTs: input.threadTs } : {},
-      ...input.userMessage ? { pendingMessage: input.userMessage } : {},
-      ...configuration && Object.keys(configuration).length > 0 ? { configuration } : {},
       ...input.resumeConversationId ? { resumeConversationId: input.resumeConversationId } : {},
       ...input.resumeSessionId ? { resumeSessionId: input.resumeSessionId } : {},
       ...requestedScope ? { scope: requestedScope } : {}
@@ -10125,59 +10067,59 @@ async function startOAuthFlow(provider, input) {
 }
 
 // src/chat/sandbox/egress/schemas.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 import {
   pluginAuthorizationSchema,
   pluginCredentialHeaderTransformSchema,
   pluginGrantSchema,
   pluginProviderAccountSchema
 } from "@sentry/junior-plugin-api";
-var finiteNumberSchema = z39.number().refine(Number.isFinite);
-var httpStatusSchema = z39.number().int().min(100).max(599);
-var providerNameSchema = z39.string().regex(/^[a-z][a-z0-9-]*$/);
-var credentialSignalKindSchema = z39.enum(["auth_required", "unavailable"]);
+var finiteNumberSchema = z40.number().refine(Number.isFinite);
+var httpStatusSchema = z40.number().int().min(100).max(599);
+var providerNameSchema = z40.string().regex(/^[a-z][a-z0-9-]*$/);
+var credentialSignalKindSchema = z40.enum(["auth_required", "unavailable"]);
 var sandboxEgressGrantSchema = pluginGrantSchema;
-var sandboxEgressCredentialContextSchema = z39.object({
+var sandboxEgressCredentialContextSchema = z40.object({
   credentials: credentialContextSchema,
-  egressId: z39.string().min(1),
+  egressId: z40.string().min(1),
   expiresAtMs: finiteNumberSchema,
-  contextId: z39.string().min(1)
+  contextId: z40.string().min(1)
 }).strict();
-var sandboxEgressCredentialLeaseSchema = z39.object({
+var sandboxEgressCredentialLeaseSchema = z40.object({
   account: pluginProviderAccountSchema.optional(),
   authorization: pluginAuthorizationSchema.optional(),
   grant: sandboxEgressGrantSchema,
   provider: providerNameSchema,
-  expiresAt: z39.string().min(1),
-  headerTransforms: z39.array(pluginCredentialHeaderTransformSchema).min(1)
+  expiresAt: z40.string().min(1),
+  headerTransforms: z40.array(pluginCredentialHeaderTransformSchema).min(1)
 }).strict();
-var sandboxEgressAuthRequiredSignalSchema = z39.object({
+var sandboxEgressAuthRequiredSignalSchema = z40.object({
   authorization: pluginAuthorizationSchema.optional(),
   grant: sandboxEgressGrantSchema,
   kind: credentialSignalKindSchema.default("auth_required"),
   provider: providerNameSchema,
-  message: z39.string().optional(),
+  message: z40.string().optional(),
   createdAtMs: finiteNumberSchema
 }).strict().superRefine((signal, ctx) => {
   if (signal.authorization && signal.authorization.provider !== signal.provider) {
     ctx.addIssue({
-      code: z39.ZodIssueCode.custom,
+      code: z40.ZodIssueCode.custom,
       message: "Auth signal authorization provider must match provider",
       path: ["authorization", "provider"]
     });
   }
 });
-var sandboxEgressPermissionDeniedSignalSchema = z39.object({
+var sandboxEgressPermissionDeniedSignalSchema = z40.object({
   account: pluginProviderAccountSchema.optional(),
-  acceptedPermissions: z39.string().optional(),
+  acceptedPermissions: z40.string().optional(),
   grant: sandboxEgressGrantSchema,
-  message: z39.string().min(1),
+  message: z40.string().min(1),
   provider: providerNameSchema,
-  source: z39.literal("upstream"),
-  sso: z39.string().optional(),
+  source: z40.literal("upstream"),
+  sso: z40.string().optional(),
   status: httpStatusSchema,
-  upstreamHost: z39.string().min(1),
-  upstreamPath: z39.string().min(1),
+  upstreamHost: z40.string().min(1),
+  upstreamPath: z40.string().min(1),
   createdAtMs: finiteNumberSchema
 }).strict();
 function parseSandboxEgressAuthRequiredSignal(value) {
@@ -10257,8 +10199,6 @@ function createPluginAuthOrchestration(input) {
         destination: input.destination,
         source: input.source,
         threadTs: input.threadTs,
-        userMessage: input.userMessage,
-        channelConfiguration: input.channelConfiguration,
         ...options?.scope ? { scope: options.scope } : {},
         resumeConversationId: input.conversationId,
         resumeSessionId: input.sessionId
@@ -10438,15 +10378,15 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, trac
 }
 
 // src/chat/tools/execute-tool.ts
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 var EXECUTE_TOOL_NAME = "executeTool";
 function createExecuteToolTool() {
   return zodTool({
     description: "Execute any catalog tool by exact tool_name from searchTools. Put tool-specific parameters inside arguments.",
     executionMode: "sequential",
-    inputSchema: z40.object({
-      tool_name: z40.string().min(1).describe("Exact catalog tool_name returned by searchTools."),
-      arguments: z40.record(z40.string(), z40.unknown()).describe(
+    inputSchema: z41.object({
+      tool_name: z41.string().min(1).describe("Exact catalog tool_name returned by searchTools."),
+      arguments: z41.record(z41.string(), z41.unknown()).describe(
         'Arguments matching the selected catalog tool schema, for example { "query": "..." }.'
       ).optional()
     }).strict(),
@@ -10486,42 +10426,42 @@ function planToolExposure(tools) {
 }
 
 // src/chat/tools/search-tools.ts
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 var SEARCH_TOOLS_NAME = "searchTools";
 var DEFAULT_MAX_RESULTS2 = 5;
 var MAX_RESULTS3 = 20;
 var MODEL_VISIBLE_DESCRIPTION_CAP = 180;
-var searchToolsSourceSchema = z41.object({
-  id: z41.string(),
-  description: z41.string()
+var searchToolsSourceSchema = z42.object({
+  id: z42.string(),
+  description: z42.string()
 }).strict();
-var toolCallExampleSchema = z41.object({
-  tool_name: z41.string(),
-  arguments: z41.record(z41.string(), z41.string())
+var toolCallExampleSchema = z42.object({
+  tool_name: z42.string(),
+  arguments: z42.record(z42.string(), z42.string())
 }).strict();
-var searchToolsToolSchema = z41.object({
-  tool_name: z41.string(),
-  description: z41.string(),
-  exposure: z41.enum(["direct", "deferred", "modelOnly", "hidden"]),
-  source: z41.string().optional(),
-  signature: z41.string(),
+var searchToolsToolSchema = z42.object({
+  tool_name: z42.string(),
+  description: z42.string(),
+  exposure: z42.enum(["direct", "deferred", "modelOnly", "hidden"]),
+  source: z42.string().optional(),
+  signature: z42.string(),
   call: toolCallExampleSchema,
-  input_schema: z41.unknown(),
-  input_schema_summary: z41.string(),
-  call_notes: z41.array(z41.string()),
-  annotations: z41.record(z41.string(), z41.unknown())
+  input_schema: z42.unknown(),
+  input_schema_summary: z42.string(),
+  call_notes: z42.array(z42.string()),
+  annotations: z42.record(z42.string(), z42.unknown())
 }).strict();
 var searchToolsOutputSchema = juniorToolResultSchema.extend({
-  query: z41.string().nullable(),
-  source: z41.string().nullable(),
-  sources: z41.array(searchToolsSourceSchema),
-  total_catalog_tools: z41.number().int().nonnegative(),
-  total_eligible_tools: z41.number().int().nonnegative(),
-  total_matches: z41.number().int().nonnegative(),
-  returned_tools: z41.number().int().nonnegative(),
-  execution_tool: z41.literal("executeTool"),
+  query: z42.string().nullable(),
+  source: z42.string().nullable(),
+  sources: z42.array(searchToolsSourceSchema),
+  total_catalog_tools: z42.number().int().nonnegative(),
+  total_eligible_tools: z42.number().int().nonnegative(),
+  total_matches: z42.number().int().nonnegative(),
+  returned_tools: z42.number().int().nonnegative(),
+  execution_tool: z42.literal("executeTool"),
   execution_example: toolCallExampleSchema,
-  tools: z41.array(searchToolsToolSchema)
+  tools: z42.array(searchToolsToolSchema)
 }).strict();
 function normalize2(value) {
   return value.toLowerCase().replace(/[^a-z0-9_]+/g, " ").trim();
@@ -10713,14 +10653,14 @@ function createSearchToolsTool(catalogTools) {
   return zodTool({
     description: renderSearchToolsDescription(knownSources),
     annotations: { readOnlyHint: true, destructiveHint: false },
-    inputSchema: z41.object({
-      query: z41.string().nullable().describe(
+    inputSchema: z42.object({
+      query: z42.string().nullable().describe(
         "Optional search terms describing the tool, owner, action, or arguments needed. Empty string lists catalog tools."
       ).optional(),
-      source: z41.string().nullable().describe(
+      source: z42.string().nullable().describe(
         "Optional source id to search within, such as a plugin source returned in sources."
       ).optional(),
-      max_results: z41.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
+      max_results: z42.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
     }).strict(),
     outputSchema: searchToolsOutputSchema,
     privateTraceResult: (result) => ({
@@ -10823,14 +10763,7 @@ function createPiAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecut
     return normalized.details;
   };
   const executeDefinition = async (args) => {
-    const {
-      normalizedToolCallId,
-      params,
-      signal,
-      setSpanAttributes: setSpanAttributes2,
-      toolDef,
-      toolName
-    } = args;
+    const { toolCallId, params, signal, setSpanAttributes: setSpanAttributes2, toolDef, toolName } = args;
     if (typeof toolDef.execute !== "function") {
       throw new Error(`Tool ${toolName} does not define an executor.`);
     }
@@ -10839,7 +10772,7 @@ function createPiAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecut
       input: params
     }) : { input: params, env: {} };
     const toolInput = beforeTool.input;
-    await onToolCall?.(toolName, toolInput);
+    await onToolCall?.(toolCallId, toolName, toolInput);
     const sandboxInput = buildSandboxInput(toolName, toolInput);
     const isSandbox = Boolean(sandboxExecutor?.canExecute(toolName));
     const result = isSandbox ? await sandboxExecutor.execute({
@@ -10850,7 +10783,7 @@ function createPiAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecut
       experimental_context: sandbox,
       ...signal ? { signal } : {},
       conversationPrivacy: effectiveConversationPrivacy,
-      ...normalizedToolCallId ? { toolCallId: normalizedToolCallId } : {}
+      toolCallId
     });
     const normalized = normalizeToolResult(result, isSandbox, {
       requireStructuredResult: Boolean(toolDef.outputSchema),
@@ -10903,6 +10836,7 @@ function createPiAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecut
       ok: toolResultOk(normalized.details),
       params: toolInput,
       result: resultAttributeValue,
+      toolCallId,
       toolName
     });
     return normalized;
@@ -10924,7 +10858,9 @@ function createPiAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecut
     prepareArguments: toolDef.prepareArguments,
     executionMode: toolDef.executionMode,
     execute: async (toolCallId, params, signal) => {
-      const normalizedToolCallId = typeof toolCallId === "string" && toolCallId.length > 0 ? toolCallId : void 0;
+      if (typeof toolCallId !== "string" || toolCallId.length === 0) {
+        throw new Error("Pi tool execution requires a non-empty tool call id.");
+      }
       const toolArgumentsAttribute = serializeToolPayload(params, {
         privateMetadata: true
       });
@@ -10957,7 +10893,7 @@ function createPiAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecut
               executionParams = catalogCall.arguments;
               await reportStatus(executionToolName, executionParams);
               return await executeDefinition({
-                normalizedToolCallId,
+                toolCallId,
                 params: catalogCall.arguments,
                 signal,
                 setSpanAttributes: setSpanAttributes2,
@@ -10967,7 +10903,7 @@ function createPiAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecut
             }
             await reportStatus(executionToolName, executionParams);
             return await executeDefinition({
-              normalizedToolCallId,
+              toolCallId,
               params: parsed,
               signal,
               setSpanAttributes: setSpanAttributes2,
@@ -10979,6 +10915,7 @@ function createPiAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecut
               error: error instanceof Error ? error.message : String(error),
               ok: false,
               params: executionParams,
+              toolCallId,
               toolName: executionToolName
             });
             if (error instanceof AuthorizationPauseError || error instanceof AuthorizationFlowDisabledError) {
@@ -10987,7 +10924,7 @@ function createPiAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecut
             handleToolExecutionError(
               error,
               executionToolName,
-              normalizedToolCallId,
+              toolCallId,
               shouldTrace,
               spanContext,
               effectiveConversationPrivacy,
@@ -11001,7 +10938,7 @@ function createPiAgentTools(tools, sandbox, spanContext, onStatus, sandboxExecut
           "gen_ai.tool.description": toolDef.description,
           "gen_ai.tool.type": "function",
           ...toolArgumentsMetadata,
-          ...normalizedToolCallId ? { "gen_ai.tool.call.id": normalizedToolCallId } : {},
+          "gen_ai.tool.call.id": toolCallId,
           ...toolArgumentsAttribute ? { "gen_ai.tool.call.arguments": toolArgumentsAttribute } : {}
         }
       );
@@ -11430,6 +11367,19 @@ function findInErrorChain(error, predicate) {
   }
   return false;
 }
+function isRecord5(value) {
+  return typeof value === "object" && value !== null;
+}
+function isInvalidSandboxSessionError(error) {
+  if (!isRecord5(error)) {
+    return false;
+  }
+  if (isRecord5(error.json) && error.json.invalidToken === true) {
+    return true;
+  }
+  const response = error.response;
+  return isRecord5(response) && response.status === 403 && typeof response.url === "string" && response.url.includes("/sandboxes/sessions");
+}
 function getFirstErrorMessage(error) {
   const seen = /* @__PURE__ */ new Set();
   let current = error;
@@ -11451,9 +11401,12 @@ function isAlreadyExistsError(error) {
 }
 function isSandboxUnavailableError(error) {
   return findInErrorChain(error, (candidate) => {
+    if (isInvalidSandboxSessionError(candidate)) {
+      return true;
+    }
     const details = getSandboxErrorDetails(candidate);
     const searchable = `${details.searchableText} ${details.summary}`.toLowerCase();
-    return searchable.includes("sandbox_stopped") || searchable.includes("status=410") || searchable.includes("status code 410") || searchable.includes("no longer available");
+    return searchable.includes("sandbox_stopped") || searchable.includes("status=410") || searchable.includes("status code 410") || searchable.includes("no longer available") || searchable.includes("stream was closed and is not accepting commands");
   });
 }
 function isSnapshottingError(error) {
@@ -14683,13 +14636,13 @@ async function wireAgentTools(args) {
   const slackChannelId = slackDestination?.channelId;
   const mcpAuth = createMcpAuthOrchestration({
     abortAgent: args.abortAgent,
-    conversationId: args.sessionConversationId,
-    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    sessionId: args.turnId,
     actorId: authActorId,
     channelId: slackChannelId,
     destination: args.routing.destination,
     source: runSource,
-    threadTs: args.routing.correlation?.threadTs,
+    threadTs: args.routing.source.platform === "slack" ? args.routing.source.threadTs : void 0,
     toolChannelId: args.routing.toolChannelId,
     userMessage: args.userInput,
     pendingAuth: args.state.pendingAuth,
@@ -14704,15 +14657,13 @@ async function wireAgentTools(args) {
   });
   const pluginAuth = createPluginAuthOrchestration({
     abortAgent: args.abortAgent,
-    conversationId: args.sessionConversationId,
-    sessionId: args.sessionId,
+    conversationId: args.conversationId,
+    sessionId: args.turnId,
     actorId: authActorId,
     channelId: slackChannelId,
     destination: args.routing.destination,
     source: runSource,
-    threadTs: args.routing.correlation?.threadTs,
-    userMessage: args.userInput,
-    channelConfiguration: args.policy.channelConfiguration,
+    threadTs: args.routing.source.platform === "slack" ? args.routing.source.threadTs : void 0,
     pendingAuth: args.state.pendingAuth,
     recordPendingAuth: args.durability.recordPendingAuth,
     authorizationFlowMode: args.policy.authorizationFlowMode,
@@ -14730,7 +14681,7 @@ async function wireAgentTools(args) {
     (skill) => skill.disableModelInvocation !== true || skill.name === args.invokedSkill?.name
   );
   const commonToolRuntimeContext = {
-    conversationId: args.sessionConversationId,
+    conversationId: args.conversationId,
     userText: args.userInput,
     artifactState: args.state.artifactState,
     configuration: args.configurationValues,
@@ -14873,10 +14824,14 @@ async function wireAgentTools(args) {
   const activeMcpCatalogs = toActiveMcpCatalogSummaries(
     mcpToolManager.getActiveToolCatalog()
   );
-  const onToolCall = async (toolName, params) => {
+  const onToolCall = async (toolCallId, toolName, params) => {
     args.toolCalls.push(toolName);
     try {
-      await args.observers.onToolInvocation?.({ toolName, params });
+      await args.observers.onToolInvocation?.({
+        params,
+        toolCallId,
+        toolName
+      });
     } catch (error) {
       logWarn(
         "tool_invocation_observer_failed",
@@ -14929,20 +14884,19 @@ function createResumeState(args) {
   let resumeMessages = [];
   let turnStartMessageIndex;
   const currentSliceId = args.sessionRecordState.currentSliceId;
-  const canPersistSession = args.sessionRecordState.canUseTurnSession && Boolean(args.sessionConversationId && args.sessionId);
   const currentDurationMs = () => Date.now() - args.startedAtMs;
   const sessionRecordBase = () => ({
     channelName: args.channelName,
-    conversationId: args.sessionConversationId,
+    conversationId: args.conversationId,
     destination: args.destination,
     source: args.runSource,
-    sessionId: args.sessionId,
+    sessionId: args.turnId,
     loadedSkillNames: args.getLoadedSkillNames(),
     logContext: args.logContext,
     modelId: args.getModelId(),
     ...args.getReasoningLevel() ? { reasoningLevel: args.getReasoningLevel() } : {},
     actor: args.actor,
-    ...args.surface ? { surface: args.surface } : {}
+    surface: args.surface
   });
   return {
     get inputCommitted() {
@@ -14985,9 +14939,6 @@ function createResumeState(args) {
       inputCommitted = true;
     },
     async persistSafeBoundary(messages, trailingMessageProvenance) {
-      if (!canPersistSession) {
-        return false;
-      }
       const persisted = await persistRunningSessionRecord({
         ...sessionRecordBase(),
         sliceId: currentSliceId,
@@ -15008,7 +14959,7 @@ function createResumeState(args) {
       );
       if (!persisted && args.durability.onInputCommitted) {
         throw new TurnInputCommitLostError(
-          `Durable turn input could not be checkpointed for conversation=${args.sessionConversationId ?? "unknown"} session=${args.sessionId ?? "unknown"}`
+          `Durable turn input could not be checkpointed for conversation=${args.conversationId} turn=${args.turnId}`
         );
       }
       return persisted;
@@ -15030,9 +14981,6 @@ function createResumeState(args) {
      */
     async translateExpectedEnding(args2) {
       const { error } = args2;
-      if (!args.sessionConversationId || !args.sessionId) {
-        return {};
-      }
       if (cooperativeYieldError && error instanceof CooperativeTurnYieldError) {
         const usage = args2.currentUsage ?? extractSliceUsage(resumeMessages, beforeMessageCount);
         await args.recordActiveMcpProviders();
@@ -15046,7 +14994,7 @@ function createResumeState(args) {
         });
         if (!sessionRecord) {
           throw new Error(
-            `Failed to persist cooperative yield continuation for conversation=${args.sessionConversationId} session=${args.sessionId}`
+            `Failed to persist cooperative yield continuation for conversation=${args.conversationId} turn=${args.turnId}`
           );
         }
         return {
@@ -15057,20 +15005,25 @@ function createResumeState(args) {
           }
         };
       }
-      if (timedOut) {
+      const resumeReason = error instanceof RetryableDeliveryError ? "retry" : timedOut ? "timeout" : void 0;
+      if (resumeReason) {
+        if (resumeReason === "retry") {
+          resumeMessages = [...latestSafeBoundaryMessages];
+        }
         const usage = args2.currentUsage ?? extractSliceUsage(resumeMessages, beforeMessageCount);
         await args.recordActiveMcpProviders();
-        const sessionRecord = await persistTimeoutSessionRecord({
+        const sessionRecord = await persistContinuationSessionRecord({
           ...sessionRecordBase(),
           currentSliceId,
           currentDurationMs: currentDurationMs(),
           currentUsage: usage,
           messages: resumeMessages,
-          errorMessage: error instanceof Error ? error.message : String(error)
+          errorMessage: error instanceof Error ? error.message : String(error),
+          resumeReason
         });
         if (!sessionRecord) {
           throw new Error(
-            `Failed to persist timeout continuation for conversation=${args.sessionConversationId} session=${args.sessionId}`
+            `Failed to persist continuation for conversation=${args.conversationId} turn=${args.turnId}`
           );
         }
         if (sessionRecord.state === "awaiting_resume") {
@@ -15082,9 +15035,7 @@ function createResumeState(args) {
             }
           };
         }
-        throw new Error(
-          sessionRecord.errorMessage ?? (error instanceof Error ? error.message : String(error))
-        );
+        throw new TurnSliceLimitExceededError(botConfig.maxSlicesPerTurn);
       }
       if (error instanceof AuthorizationPauseError) {
         const usage = args2.currentUsage ?? (resumeMessages.length > 0 ? extractSliceUsage(resumeMessages, beforeMessageCount) : void 0);
@@ -15169,10 +15120,6 @@ function userMessage(text) {
     timestamp: Date.now()
   };
 }
-function piMessageTimestamp(message) {
-  const timestamp = message.timestamp;
-  return typeof timestamp === "number" ? timestamp : Date.now();
-}
 function selectRetainedUserMessageEntries(messages, maxTokens = RETAINED_USER_MESSAGE_TOKENS) {
   const selected = [];
   let remaining = maxTokens;
@@ -15356,7 +15303,7 @@ async function maybeCompactWithDeps(args, deps) {
   });
 }
 async function writeCompactedThreadContext(args, sourceMessages, summary, context) {
-  const stepStore = getAgentStepStore();
+  const eventStore = getConversationEventStore();
   const sourceProjection = await loadConversationProjection({
     conversationId: args.conversationId
   });
@@ -15372,15 +15319,21 @@ ${summary}`)
     retained,
     sourceProvenance: sourceProjection.provenance
   });
-  await stepStore.startEpoch(args.conversationId, {
-    reason: "compaction",
-    modelProfile: sourceProjection.modelProfile,
-    modelId: modelIdForProfile(botConfig, sourceProjection.modelProfile),
-    messages: replacement.map((message, index) => ({
-      message,
-      createdAtMs: piMessageTimestamp(message),
-      provenance: replacementProvenance[index]
-    }))
+  await eventStore.replaceHistory(args.conversationId, {
+    createdAtMs: Date.now(),
+    data: {
+      type: "compaction",
+      modelProfile: sourceProjection.modelProfile,
+      modelId: modelIdForProfile(botConfig, sourceProjection.modelProfile),
+      replacementHistory: replacement.map((message, index) => {
+        const sourceEventSeq = index < retained.length ? sourceProjection.seqs[retained[index].sourceIndex] : void 0;
+        return {
+          message,
+          provenance: replacementProvenance[index],
+          ...sourceEventSeq === void 0 ? {} : { sourceEventSeq }
+        };
+      })
+    }
   });
   updateConversationStats(args.conversation);
   setSpanAttributes({
@@ -15415,24 +15368,33 @@ ${await summarizeContext(args, deps)}`;
     ]
   };
   const messages = [message];
+  const replacementMessages = stripRuntimeTurnContext(messages);
   args.signal?.throwIfAborted();
-  await getAgentStepStore().startEpoch(args.conversationId, {
-    reason: "handoff",
-    modelProfile: args.target.modelProfile,
-    modelId: args.target.modelId,
-    messages: [
-      {
-        message,
-        createdAtMs: piMessageTimestamp(message),
+  await getConversationEventStore().replaceHistory(args.conversationId, {
+    createdAtMs: Date.now(),
+    data: {
+      type: "handoff",
+      modelProfile: args.target.modelProfile,
+      modelId: args.target.modelId,
+      ...args.triggeringToolCallId ? { triggeringToolCallId: args.triggeringToolCallId } : {},
+      replacementHistory: replacementMessages.map((replacementMessage) => ({
+        message: replacementMessage,
         provenance: contextProvenance
-      }
-    ]
+      }))
+    }
   });
   return messages;
 }
 
 // src/chat/agent/index.ts
 var AGENT_ABORT_SETTLE_GRACE_MS = 5e3;
+var AssistantMessageDeliveryError = class extends Error {
+  constructor(originalError) {
+    super("Assistant message delivery failed");
+    this.originalError = originalError;
+  }
+  originalError;
+};
 function waitForAbortSettlement(promise, timeoutMs) {
   return new Promise((resolve) => {
     let done = false;
@@ -15462,9 +15424,13 @@ function waitForAbortSettlement(promise, timeoutMs) {
   });
 }
 async function executeAgentRun(request) {
+  if (!request.routing.destination) {
+    throw new TypeError("Assistant reply generation requires a destination");
+  }
+  const channelId = request.routing.destination.platform === "slack" ? request.routing.destination.channelId : void 0;
   const conversationPrivacy = resolveConversationPrivacy({
-    channelId: request.routing.correlation?.channelId,
-    conversationId: request.routing.correlation?.conversationId ?? request.routing.correlation?.threadId ?? request.routing.correlation?.runId,
+    channelId,
+    conversationId: request.conversationId,
     // Destination visibility is provider-neutral. Slack event context remains
     // a compatibility fallback for callers that have not projected it yet.
     visibility: request.routing.destinationVisibility ?? request.routing.slackConversation?.visibility
@@ -15475,18 +15441,15 @@ async function executeAgentRun(request) {
   );
 }
 async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
-  const { input, routing } = request;
+  const { conversationId, input, routing, runId, turnId } = request;
   const policy = request.policy ?? {};
   const signal = policy.signal;
   const state = request.state ?? {};
   const observers = request.observers ?? {};
+  const delivery = request.delivery;
   const durability = request.durability ?? {};
   signal?.throwIfAborted();
-  if (!routing.destination) {
-    throw new TypeError("Assistant reply generation requires a destination");
-  }
-  assertActorDestinationMatch(routing);
-  assertCorrelationDestinationMatch(routing);
+  assertRunRoutingConsistency(request);
   const replyStartedAtMs = Date.now();
   const configuredTurnDeadlineAtMs = replyStartedAtMs + botConfig.turnTimeoutMs;
   const policyTurnDeadlineAtMs = typeof policy.turnDeadlineAtMs === "number" && Number.isFinite(policy.turnDeadlineAtMs) ? Math.floor(policy.turnDeadlineAtMs) : void 0;
@@ -15497,11 +15460,11 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
   let lastKnownSandboxDependencyProfileHash = state.sandbox?.sandboxDependencyProfileHash;
   let mcpToolManager;
   let connectedMcpProviders = /* @__PURE__ */ new Set();
-  let canRecordMcpProviders = false;
   let turnUsage;
   let handoffPhaseUsage;
   const configuredReasoningLevel = policy.reasoningLevel ?? botConfig.reasoningLevel;
-  let reasoningSelection = configuredReasoningLevel ? configuredTurnReasoningLevel(
+  let turnRoute = configuredReasoningLevel ? configuredTurnRoute(
+    STANDARD_MODEL_PROFILE,
     configuredReasoningLevel,
     policy.reasoningLevel ? "agent_config" : "default"
   ) : void 0;
@@ -15510,6 +15473,9 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
   const actor = actorFromRouting(routing);
   const surface = surfaceFromRouting(routing);
   const runSource = routing.source;
+  const slackSource = runSource.platform === "slack" ? runSource : void 0;
+  const slackDestination = routing.destination.platform === "slack" ? routing.destination : void 0;
+  const slackActor = actor?.platform === "slack" ? actor : void 0;
   const userInput = input.messageText;
   const credentialActor = routing.credentialContext?.actor;
   const credentialActorLogContext = credentialActor ? {
@@ -15517,20 +15483,19 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
     actorId: "type" in credentialActor ? credentialActor.userId : credentialActor.name
   } : {};
   const sessionRecordLogContext = {
-    threadId: routing.correlation?.threadId,
-    actorId: routing.correlation?.actorId,
-    channelId: routing.correlation?.channelId,
-    runId: routing.correlation?.runId,
+    threadId: slackSource ? conversationId : void 0,
+    actorId: slackActor?.userId,
+    channelId: slackDestination?.channelId,
+    runId,
     ...credentialActorLogContext,
     assistantUserName: botConfig.userName
   };
-  const { conversationId: sessionConversationId, sessionId } = getSessionIdentifiers(routing);
   const recordConnectedMcpProvider = async (provider) => {
-    if (!canRecordMcpProviders || !sessionConversationId || connectedMcpProviders.has(provider)) {
+    if (connectedMcpProviders.has(provider)) {
       return;
     }
     await recordMcpProviderConnected({
-      conversationId: sessionConversationId,
+      conversationId,
       provider
     });
     connectedMcpProviders.add(provider);
@@ -15548,21 +15513,16 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
     sandboxDependencyProfileHash: lastKnownSandboxDependencyProfileHash
   });
   try {
-    if (sessionConversationId) {
-      const projection = await openConversationProjection({
-        conversationId: sessionConversationId,
-        modelId: activeModelId
-      });
-      activeModelProfile = projection.modelProfile;
-      activeModelId = modelIdForProfile(botConfig, activeModelProfile);
-    }
+    const projection = await openConversationProjection({ conversationId });
+    activeModelProfile = projection.modelProfile;
+    activeModelId = modelIdForProfile(botConfig, activeModelProfile);
     const shouldTrace = shouldEmitDevAgentTrace();
     const spanContext = {
-      conversationId: sessionConversationId,
-      slackThreadId: routing.correlation?.threadId,
-      slackUserId: routing.correlation?.actorId,
-      slackChannelId: routing.correlation?.channelId,
-      runId: routing.correlation?.runId,
+      conversationId,
+      slackThreadId: slackSource ? conversationId : void 0,
+      slackUserId: slackActor?.userId,
+      slackChannelId: slackDestination?.channelId,
+      runId,
       ...credentialActorLogContext,
       assistantUserName: botConfig.userName,
       modelId: activeModelId
@@ -15585,7 +15545,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
           // look indistinguishable from Slack ingress dropping attachments.
           "app.message.attachment_count": inboundAttachmentCount,
           "app.message.prompt_attachment_count": promptAttachmentCount,
-          "messaging.message.id": routing.correlation?.messageTs ?? ""
+          "messaging.message.id": slackSource?.messageTs ?? ""
         },
         "Agent message received"
       );
@@ -15603,44 +15563,40 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
       resumedFromSessionRecord,
       currentSliceId,
       existingSessionRecord
-    } = await restoreSessionRecord(routing);
+    } = await restoreSessionRecord({
+      conversationId,
+      turnId
+    });
     const committedInstructionProvenance = [
       ...existingSessionRecord?.piMessageProvenance ?? [],
       ...(existingSessionRecord?.actors ?? []).map(instructionProvenanceFor),
       ...resumedFromSessionRecord ? [] : [instructionProvenanceFor(actor)]
     ];
     const runActors = () => instructionActors(committedInstructionProvenance);
-    canRecordMcpProviders = Boolean(
-      sessionRecordState.canUseTurnSession && sessionConversationId && sessionId
-    );
     resume = createResumeState({
-      channelName: routing.correlation?.channelName,
+      channelName: routing.slackConversation?.name,
       destination: routing.destination,
       durability,
       getLoadedSkillNames: () => loadedSkillNamesForResume,
-      getReasoningLevel: () => reasoningSelection?.reasoningLevel,
+      getReasoningLevel: () => turnRoute?.reasoningLevel,
       logContext: sessionRecordLogContext,
       getModelId: () => activeModelId,
       recordActiveMcpProviders,
       actor,
       runSource,
-      sessionConversationId,
-      sessionId,
+      conversationId,
+      turnId,
       sessionRecordState,
       startedAtMs: replyStartedAtMs,
       surface
     });
     const runResume = resume;
     const recordParentToolExecutionStart = async (event) => {
-      if (!sessionRecordState.canUseTurnSession || !sessionConversationId || !sessionId) {
-        return;
-      }
       try {
         await recordToolExecutionStarted({
-          conversationId: sessionConversationId,
+          conversationId,
           toolCallId: event.toolCallId,
-          toolName: event.toolName,
-          args: event.args
+          toolName: event.toolName
         });
       } catch (error) {
         logException(
@@ -15662,9 +15618,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
     };
     const priorPiMessages = resumedFromSessionRecord ? existingSessionRecord?.piMessages : input.piMessages;
     connectedMcpProviders = new Set(
-      sessionRecordState.canUseTurnSession && sessionConversationId ? await loadConnectedMcpProviders({
-        conversationId: sessionConversationId
-      }) : []
+      await loadConnectedMcpProviders({ conversationId })
     );
     await restoreSkillRuntime({
       activeSkills,
@@ -15675,19 +15629,36 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
     });
     const { routerBlocks, userContentParts } = buildPromptInput(input);
     const preAgentPromptMessages = () => existingSessionRecord?.piMessages ?? [...input.piMessages ?? []];
-    reasoningSelection ??= await selectTurnReasoningLevel({
-      completeObject,
-      conversationContext: input.conversationContext,
-      context: {
-        threadId: routing.correlation?.threadId,
-        channelId: routing.correlation?.channelId,
-        actorId: routing.correlation?.actorId,
-        runId: routing.correlation?.runId
-      },
-      currentTurnBlocks: routerBlocks,
-      fastModelId: botConfig.fastModelId,
-      messageText: userInput
-    });
+    if (activeModelProfile === STANDARD_MODEL_PROFILE) {
+      turnRoute = await selectTurnRoute({
+        completeObject,
+        conversationContext: input.conversationContext,
+        context: {
+          threadId: conversationId,
+          channelId: slackDestination?.channelId,
+          actorId: slackActor?.userId,
+          runId
+        },
+        currentTurnBlocks: routerBlocks,
+        fastModelId: botConfig.fastModelId,
+        messageText: userInput,
+        profiles: botConfig.profiles
+      });
+      if (configuredReasoningLevel) {
+        turnRoute = {
+          ...turnRoute,
+          reasoningLevel: configuredReasoningLevel,
+          reason: `configured:${policy.reasoningLevel ? "agent_config" : "default"}:${turnRoute.reason}`
+        };
+      }
+    } else {
+      const activeProfileConfig = profileConfig(botConfig, activeModelProfile);
+      turnRoute = configuredTurnRoute(
+        activeModelProfile,
+        activeProfileConfig.reasoningLevel ?? policy.reasoningLevel ?? botConfig.reasoningLevel ?? "medium",
+        activeProfileConfig.reasoningLevel ? "profile" : policy.reasoningLevel ? "agent_config" : "default"
+      );
+    }
     const generatedFiles = [];
     const artifactStatePatch = {};
     const toolCalls = [];
@@ -15696,70 +15667,90 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
     const currentAgentMessages = () => agent ? [...agent.state.messages] : [];
     const handoffProfiles = [
       DEFAULT_HANDOFF_MODEL_PROFILE,
-      ...Object.keys(botConfig.modelProfiles).filter((profile) => profile !== DEFAULT_HANDOFF_MODEL_PROFILE).sort()
+      ...Object.keys(botConfig.profiles).filter(
+        (profile) => profile !== STANDARD_MODEL_PROFILE && profile !== DEFAULT_HANDOFF_MODEL_PROFILE
+      ).sort()
     ];
-    const requestHandoff = activeModelProfile === STANDARD_MODEL_PROFILE && sessionConversationId ? {
-      profiles: handoffProfiles,
-      execute: async (profile, signal2) => {
-        const sourceMessages = [...agent.state.messages];
-        const runtimeContext = retainRuntimeTurnContext(sourceMessages);
-        const standardPhaseUsage = extractGenAiUsageSummary(
-          ...sourceMessages.slice(runResume.beforeMessageCount).filter(isAssistantMessage)
-        );
-        const phaseUsage = hasAgentTurnUsage(standardPhaseUsage) ? standardPhaseUsage : void 0;
-        const target = {
-          modelId: modelIdForProfile(botConfig, profile),
-          modelProfile: profile
-        };
-        const handoffModel = resolveGatewayModel(target.modelId);
-        const handoffThinkingLevel = toPiReasoningLevel(
-          reasoningSelection.reasoningLevel
-        );
-        void (async () => {
-          await observers.onStatus?.({ text: "Switching models" });
-        })().catch((error) => {
-          logWarn(
-            "assistant_status_observer_failed",
-            {},
-            {
-              "exception.message": error instanceof Error ? error.message : String(error)
-            },
-            "Failed to report assistant status"
-          );
-        });
-        const handoffMessages = await compactContextForHandoff(
+    const scheduleHandoff = async (args) => {
+      if (args.profile === activeModelProfile) {
+        return;
+      }
+      const runtimeContext = retainRuntimeTurnContext(
+        args.runtimeContextSourceMessages ?? args.sourceMessages
+      );
+      const standardPhaseUsage = extractGenAiUsageSummary(
+        ...args.sourceMessages.slice(runResume.beforeMessageCount).filter(isAssistantMessage)
+      );
+      const phaseUsage = hasAgentTurnUsage(standardPhaseUsage) ? standardPhaseUsage : void 0;
+      const selectedProfile = profileConfig(botConfig, args.profile);
+      const target = {
+        modelId: selectedProfile.modelId,
+        modelProfile: args.profile
+      };
+      const handoffModel = resolveGatewayModel(target.modelId);
+      const handoffReasoningLevel = selectedProfile.reasoningLevel ?? turnRoute.reasoningLevel;
+      const handoffThinkingLevel = toPiReasoningLevel(handoffReasoningLevel);
+      void (async () => {
+        await observers.onStatus?.({ text: "Switching models" });
+      })().catch((error) => {
+        logWarn(
+          "assistant_status_observer_failed",
+          {},
           {
-            conversationContext: input.conversationContext,
-            conversationId: sessionConversationId,
-            piMessages: sourceMessages,
-            runtimeContext,
-            signal: signal2,
-            target,
-            metadata: {
-              threadId: routing.correlation?.threadId,
-              channelId: routing.correlation?.channelId,
-              actorId: routing.correlation?.actorId,
-              runId: routing.correlation?.runId
-            }
+            "exception.message": error instanceof Error ? error.message : String(error)
           },
-          { completeText }
+          "Failed to report assistant status"
         );
-        handoffPhaseUsage = phaseUsage;
-        pendingHandoff = {
-          messages: handoffMessages,
-          model: handoffModel,
-          thinkingLevel: handoffThinkingLevel
+      });
+      const handoffMessages = await compactContextForHandoff(
+        {
+          conversationContext: input.conversationContext,
+          conversationId,
+          piMessages: args.sourceMessages,
+          runtimeContext,
+          signal: args.signal,
+          triggeringToolCallId: args.triggeringToolCallId,
+          target,
+          metadata: {
+            threadId: conversationId,
+            channelId: slackDestination?.channelId,
+            actorId: slackActor?.userId,
+            runId
+          }
+        },
+        { completeText }
+      );
+      if (handoffReasoningLevel !== turnRoute.reasoningLevel) {
+        turnRoute = {
+          ...turnRoute,
+          reasoningLevel: handoffReasoningLevel,
+          reason: `profile_reasoning_override:${args.profile}:${turnRoute.reason}`
         };
-        activeModelProfile = profile;
-        activeModelId = target.modelId;
       }
-    } : void 0;
+      handoffPhaseUsage = phaseUsage;
+      pendingHandoff = {
+        messages: handoffMessages,
+        model: handoffModel,
+        thinkingLevel: handoffThinkingLevel
+      };
+      activeModelProfile = args.profile;
+      activeModelId = target.modelId;
+    };
+    const requestHandoff = {
+      profiles: handoffProfiles,
+      execute: async (profile, options) => await scheduleHandoff({
+        profile,
+        signal: options.signal,
+        sourceMessages: [...agent.state.messages],
+        triggeringToolCallId: options.toolCallId
+      })
+    };
     setTags({
       conversationId: spanContext.conversationId,
-      slackThreadId: routing.correlation?.threadId,
-      slackUserId: routing.correlation?.actorId,
-      slackChannelId: routing.correlation?.channelId,
-      runId: routing.correlation?.runId,
+      slackThreadId: slackSource ? conversationId : void 0,
+      slackUserId: slackActor?.userId,
+      slackChannelId: slackDestination?.channelId,
+      runId,
       ...credentialActorLogContext,
       assistantUserName: botConfig.userName,
       modelId: activeModelId
@@ -15789,8 +15780,8 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
       requestHandoff,
       resume: runResume,
       routing,
-      sessionConversationId,
-      sessionId,
+      conversationId,
+      turnId,
       skillSandbox,
       spanContext,
       state,
@@ -15802,9 +15793,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
     mcpToolManager = wiring.mcpToolManager;
     const sandboxExecutor = wiring.sandboxExecutor;
     const getPendingAuthPause = wiring.getPendingAuthPause;
-    const toolsAfterHandoff = wiring.agentTools.filter(
-      (tool) => tool.name !== HANDOFF_TOOL_NAME
-    );
+    const toolsAfterHandoff = wiring.agentTools;
     const {
       baseInstructions,
       inputMessages,
@@ -15830,42 +15819,52 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
       toolRuntimeContext: wiring.toolRuntimeContext,
       userContentParts
     });
-    let hasEmittedText = false;
-    let needsSeparator = false;
-    let bufferedStandardText = "";
-    let bufferedStandardMessageStart = false;
-    const startAssistantMessage = () => {
-      Promise.resolve(observers.onAssistantMessageStart?.()).catch((error) => {
-        logWarn(
-          "streaming_message_start_error",
-          {},
-          {
-            "exception.message": error instanceof Error ? error.message : String(error)
-          },
-          "Failed to deliver assistant message start to stream coordinator"
-        );
-      });
-      if (hasEmittedText) {
-        needsSeparator = true;
+    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;
+      agent.state.tools = toolsAfterHandoff;
+      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: toolsAfterHandoff
+        },
+        model,
+        thinkingLevel
+      };
     };
-    const deliverText = (deltaText) => {
-      const text = needsSeparator ? "\n\n" + deltaText : deltaText;
-      needsSeparator = false;
-      hasEmittedText = true;
-      Promise.resolve(observers.onTextDelta?.(text)).catch((error) => {
-        logWarn(
-          "streaming_text_delta_error",
-          {},
-          {
-            "exception.message": error instanceof Error ? error.message : String(error)
-          },
-          "Failed to deliver text delta to stream"
+    let assistantMessageDeliveryError;
+    const deliverAssistantMessage = async (message) => {
+      const text = getAssistantMessageText(message);
+      if (!text || !delivery) {
+        return;
+      }
+      try {
+        await delivery.onAssistantMessage({ text });
+      } catch (error) {
+        assistantMessageDeliveryError = new AssistantMessageDeliveryError(
+          error
         );
-      });
+        throw assistantMessageDeliveryError;
+      }
     };
     const drainSteeringMessages = async () => {
-      if (!durability.drainSteeringMessages || !sessionRecordState.canUseTurnSession || !sessionConversationId || !sessionId) {
+      if (!durability.drainSteeringMessages) {
         return;
       }
       try {
@@ -15932,33 +15931,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
         return void 0;
       },
       prepareNextTurn: async () => {
-        let update;
-        if (pendingHandoff) {
-          const { messages, model, thinkingLevel } = pendingHandoff;
-          const replacement = [...messages];
-          pendingHandoff = void 0;
-          agent.state.messages = replacement;
-          agent.state.model = model;
-          agent.state.thinkingLevel = thinkingLevel;
-          agent.state.tools = toolsAfterHandoff;
-          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": reasoningSelection.reasoningLevel
-          });
-          update = {
-            context: {
-              systemPrompt: baseInstructions,
-              messages: replacement,
-              tools: toolsAfterHandoff
-            },
-            model,
-            thinkingLevel
-          };
-        }
+        const update = applyPendingHandoff();
         await drainSteeringMessages();
         runResume.yieldAtSafeBoundaryIfDue(currentAgentMessages());
         return update;
@@ -15966,7 +15939,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
       initialState: {
         systemPrompt: baseInstructions,
         model: resolveGatewayModel(activeModelId),
-        thinkingLevel: toPiReasoningLevel(reasoningSelection.reasoningLevel),
+        thinkingLevel: toPiReasoningLevel(turnRoute.reasoningLevel),
         tools: wiring.agentTools
       }
     });
@@ -15980,40 +15953,17 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
         }
         return runResume.persistSafeBoundary([...agent.state.messages]).then(() => void 0);
       }
-      if (event.type === "message_start") {
-        if (activeModelProfile === STANDARD_MODEL_PROFILE && requestHandoff) {
-          bufferedStandardMessageStart = true;
-          bufferedStandardText = "";
-        } else {
-          startAssistantMessage();
-        }
-        return;
-      }
       if (event.type === "message_end" && isAssistantMessage(event.message)) {
-        if (!bufferedStandardMessageStart) {
+        if (event.message.stopReason === "error" || event.message.stopReason === "aborted") {
           return;
         }
         const containsHandoff = event.message.content.some(
           (part) => part.type === "toolCall" && part.name === HANDOFF_TOOL_NAME
         );
-        if (!containsHandoff) {
-          startAssistantMessage();
-          if (bufferedStandardText) {
-            deliverText(bufferedStandardText);
-          }
+        if (containsHandoff) {
+          return;
         }
-        bufferedStandardMessageStart = false;
-        bufferedStandardText = "";
-        return;
-      }
-      if (event.type !== "message_update") return;
-      if (event.assistantMessageEvent.type !== "text_delta") return;
-      const deltaText = event.assistantMessageEvent.delta;
-      if (!deltaText) return;
-      if (bufferedStandardMessageStart) {
-        bufferedStandardText += deltaText;
-      } else {
-        deliverText(deltaText);
+        return deliverAssistantMessage(event.message);
       }
     });
     let newMessages = [];
@@ -16049,13 +15999,13 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
               await runResume.commitInput();
             }
           }
-          const runAgentStep = async (run2) => {
+          const runAgentStep = async (run2, abortRun = () => agent.abort()) => {
             let timeoutId;
             let removeAbortListener;
             const timeoutPromise = new Promise((_, reject) => {
               const rejectWithTimeout = () => {
                 runResume.markTimedOut();
-                agent.abort();
+                abortRun();
                 reject(
                   new Error(
                     `Agent turn timed out after ${turnTimeoutBudgetMs}ms`
@@ -16071,7 +16021,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
             });
             const abortPromise = signal ? new Promise((_, reject) => {
               const rejectWithAbort = () => {
-                agent.abort();
+                abortRun();
                 reject(signal.reason);
               };
               if (signal.aborted) {
@@ -16096,8 +16046,8 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
                     "gen_ai.provider.name": GEN_AI_PROVIDER_NAME,
                     "gen_ai.operation.name": "invoke_agent",
                     "gen_ai.request.model": activeModelId,
-                    ...reasoningSelection ? {
-                      "gen_ai.request.reasoning.level": reasoningSelection.reasoningLevel
+                    ...turnRoute ? {
+                      "gen_ai.request.reasoning.level": turnRoute.reasoningLevel
                     } : {},
                     "app.ai.turn_timeout_ms": turnTimeoutBudgetMs,
                     "app.ai.turn_deadline_remaining_ms": Math.max(
@@ -16139,10 +16089,38 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
               removeAbortListener?.();
             }
           };
-          let run = shouldPromptAgent ? agent.prompt(freshPromptMessage) : agent.continue();
+          const requestedProfile = activeModelProfile === STANDARD_MODEL_PROFILE ? turnRoute.profile : void 0;
+          let run;
+          if (requestedProfile && requestedProfile !== STANDARD_MODEL_PROFILE) {
+            const handoffAbortController = new AbortController();
+            await runAgentStep(
+              scheduleHandoff({
+                profile: requestedProfile,
+                runtimeContextSourceMessages: shouldPromptAgent ? [freshPromptMessage] : void 0,
+                signal: handoffAbortController.signal,
+                sourceMessages: [...agent.state.messages]
+              }),
+              () => handoffAbortController.abort()
+            );
+            applyPendingHandoff();
+            if (shouldPromptAgent) {
+              await runResume.requireDurableInputCheckpoint([
+                ...agent.state.messages,
+                freshPromptMessage
+              ]);
+              run = agent.prompt(freshPromptMessage);
+            } else {
+              run = agent.continue();
+            }
+          } else {
+            run = shouldPromptAgent ? agent.prompt(freshPromptMessage) : agent.continue();
+          }
           let retryUsage;
           for (let attempt = 0; ; attempt += 1) {
             await runAgentStep(run);
+            if (assistantMessageDeliveryError) {
+              throw assistantMessageDeliveryError;
+            }
             signal?.throwIfAborted();
             if (runResume.cooperativeYieldError) {
               throw runResume.cooperativeYieldError;
@@ -16207,15 +16185,15 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
           "gen_ai.operation.name": "invoke_agent",
           "gen_ai.agent.model": activeModelId,
           "gen_ai.agent.model_profile": activeModelProfile,
-          "gen_ai.agent.reasoning.level": reasoningSelection.reasoningLevel,
-          "gen_ai.agent.reasoning.level_reason": reasoningSelection.reason,
-          ...reasoningSelection.confidence !== void 0 ? {
-            "gen_ai.agent.reasoning.level_confidence": reasoningSelection.confidence
+          "gen_ai.agent.reasoning.level": turnRoute.reasoningLevel,
+          "gen_ai.agent.reasoning.level_reason": turnRoute.reason,
+          ...turnRoute.confidence !== void 0 ? {
+            "gen_ai.agent.reasoning.level_confidence": turnRoute.confidence
           } : {},
           "gen_ai.output.type": "text",
           ...conversationPrivacy ? { "app.conversation.privacy": conversationPrivacy } : {},
-          ...sessionConversationId ? { "app.ai.session.conversation_id": sessionConversationId } : {},
-          ...sessionId ? { "app.ai.turn.session_id": sessionId } : {},
+          "app.ai.session.conversation_id": conversationId,
+          "app.ai.turn.session_id": turnId,
           ...currentSliceId ? { "app.ai.turn.slice_id": currentSliceId } : {},
           ...toGenAiMessagesTraceAttributes("gen_ai.input", inputMessages),
           ...inputMessagesAttribute ? { "gen_ai.input.messages": inputMessagesAttribute } : {}
@@ -16224,40 +16202,45 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
     } finally {
       unsubscribe();
     }
-    if (sessionRecordState.canUseTurnSession && sessionConversationId && sessionId) {
-      await recordActiveMcpProviders();
-    }
+    await recordActiveMcpProviders();
+    const result = buildTurnResult({
+      newMessages,
+      userInput,
+      artifactStatePatch,
+      toolCalls,
+      sandboxId: sandboxExecutor.getSandboxId(),
+      sandboxDependencyProfileHash: sandboxExecutor.getDependencyProfileHash(),
+      piMessages: [...agent.state.messages],
+      durationMs: Date.now() - replyStartedAtMs,
+      generatedFileCount: generatedFiles.length,
+      shouldTrace,
+      spanContext,
+      usage: turnUsage,
+      executionProfile: turnRoute,
+      assistantUserName: botConfig.userName,
+      modelId: activeModelId
+    });
     return {
       status: "completed",
-      result: buildTurnResult({
-        newMessages,
-        userInput,
-        artifactStatePatch,
-        toolCalls,
-        sandboxId: sandboxExecutor.getSandboxId(),
-        sandboxDependencyProfileHash: sandboxExecutor.getDependencyProfileHash(),
-        piMessages: [...agent.state.messages],
-        durationMs: Date.now() - replyStartedAtMs,
-        generatedFileCount: generatedFiles.length,
-        shouldTrace,
-        spanContext,
-        usage: turnUsage,
-        reasoningSelection,
-        correlation: routing.correlation,
-        assistantUserName: botConfig.userName,
-        modelId: activeModelId
-      })
+      result
     };
   } catch (error) {
+    if (error instanceof AssistantMessageDeliveryError && !(error.originalError instanceof RetryableDeliveryError)) {
+      throw error.originalError;
+    }
+    const runError = error instanceof AssistantMessageDeliveryError ? error.originalError : error;
     if (resume) {
       const { outcome } = await resume.translateExpectedEnding({
         currentUsage: turnUsage,
-        error
+        error: runError
       });
       if (outcome) {
         return outcome;
       }
     }
+    if (error instanceof AssistantMessageDeliveryError) {
+      throw error.originalError;
+    }
     if (error instanceof ModelProfileNotConfiguredError) {
       throw error;
     }
@@ -16277,10 +16260,11 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
       error,
       "assistant_reply_generation_failed",
       {
-        slackThreadId: routing.correlation?.threadId,
-        slackUserId: routing.correlation?.actorId,
-        slackChannelId: routing.correlation?.channelId,
-        runId: routing.correlation?.runId,
+        conversationId,
+        slackThreadId: slackSource ? conversationId : void 0,
+        slackUserId: slackActor?.userId,
+        slackChannelId: slackDestination?.channelId,
+        runId,
         ...credentialActorLogContext,
         assistantUserName: botConfig.userName,
         modelId: activeModelId
@@ -16298,8 +16282,8 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy) {
           outcome: "provider_error",
           modelId: activeModelId,
           assistantMessageCount: 0,
-          ...reasoningSelection ? {
-            reasoningLevel: reasoningSelection.reasoningLevel
+          ...turnRoute ? {
+            reasoningLevel: turnRoute.reasoningLevel
           } : {},
           toolCalls: [],
           toolResultCount: 0,
@@ -16349,6 +16333,7 @@ export {
   getConfigDefaults,
   shouldEmitDevAgentTrace,
   AuthorizationFlowDisabledError,
+  RetryableDeliveryError,
   truncateStatusText,
   escapeSlackMrkdwnText,
   formatSlackLink,