@sentry/junior 0.112.0 → 0.114.0

package/dist/{chunk-GR4IB6OQ.js → chunk-WV4UJBAS.js}

@@ -1,18 +1,30 @@
 import {
   CooperativeTurnYieldError,
   JUNIOR_THREAD_STATE_TTL_MS,
+  TURN_CONTEXT_TAG,
   TurnInputCommitLostError,
   TurnSliceLimitExceededError,
   abandonReplacedPendingAuth,
   canReusePendingAuthLink,
   estimateTextTokens,
+  extractAssistantText,
   getAgentContextCompactionTriggerTokens,
+  getAgentContextInputLimitTokens,
   getInterruptionMarker,
+  getPiMessageRole,
+  getTerminalAssistantMessages,
+  hasRuntimeTurnContext,
+  isAssistantMessage,
+  isContinuablePiBoundary,
+  isToolResultError,
+  isToolResultMessage,
   isTurnInputCommitLostError,
   loadConnectedMcpProviders,
   loadConversationProjection,
+  loadTurnRoute,
   loadTurnSessionRecord,
   mergeArtifactsState,
+  normalizeToolNameFromResult,
   openConversationProjection,
   persistAuthPauseSessionRecord,
   persistContinuationSessionRecord,
@@ -21,8 +33,12 @@ import {
   recordAuthorizationRequested,
   recordMcpProviderConnected,
   recordToolExecutionStarted,
+  recordTurnRoute,
+  retainRuntimeTurnContext,
+  stripRuntimeTurnContext,
+  trimTrailingAssistantMessages,
   updateConversationStats
-} from "./chunk-SKEMI4IF.js";
+} from "./chunk-6QWPVTMO.js";
 import {
   buildNonInteractiveShellScript,
   createSandboxSession,
@@ -39,7 +55,7 @@ import {
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-66IP6WED.js";
+} from "./chunk-XLFBQJUO.js";
 import {
   addAgentTurnUsage,
   hasAgentTurnUsage
@@ -56,7 +72,7 @@ import {
   getPlugins,
   getSlackToolContext,
   resolveChannelCapabilities
-} from "./chunk-VBSVNOLA.js";
+} from "./chunk-VNNBSKCO.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -65,7 +81,7 @@ import {
   getStateAdapter,
   sandboxSkillDir,
   sandboxSkillFile
-} from "./chunk-X3SP5RDW.js";
+} from "./chunk-YU6PO42Q.js";
 import {
   SlackActionError,
   downloadPrivateSlackFile,
@@ -75,7 +91,7 @@ import {
   isDmChannel,
   normalizeSlackConversationId,
   withSlackRetries
-} from "./chunk-NDQL4ESR.js";
+} from "./chunk-RD7EJI7H.js";
 import {
   contextProvenance,
   getConversationEventStore,
@@ -85,7 +101,7 @@ import {
   instructionActors,
   instructionProvenanceFor,
   parseDestination
-} from "./chunk-QIALGHRN.js";
+} from "./chunk-FIGAF6KL.js";
 import {
   sleep
 } from "./chunk-4ZNGQH7C.js";
@@ -99,36 +115,26 @@ import {
   MODEL_HANDOFF_SUMMARY_PREFIX,
   ModelProfileNotConfiguredError,
   STANDARD_MODEL_PROFILE,
-  TURN_CONTEXT_TAG,
   TURN_REASONING_LEVELS,
   botConfig,
   completeObject,
   completeText,
+  createProviderError,
   escapeXml,
-  extractAssistantText,
   getGatewayApiKey,
   getPiGatewayApiKey,
-  getTerminalAssistantMessages,
   hasCompactedConversationContext,
-  hasRuntimeTurnContext,
-  isAssistantMessage,
   isCompactionSummaryText,
   isProviderRetryError,
-  isToolResultError,
-  isToolResultMessage,
   modelIdForProfile,
   modelProfileSchema,
-  nextProviderRetry,
   normalizeSlackEmojiName,
-  normalizeToolNameFromResult,
+  parseTurnReasoningLevel,
   profileConfig,
   renderCurrentInstruction,
   resolveGatewayModel,
-  retainRuntimeTurnContext,
-  stripRuntimeTurnContext,
-  trimTrailingAssistantMessages,
   unwrapCurrentInstruction
-} from "./chunk-PK4ETCUQ.js";
+} from "./chunk-ZGXH3REA.js";
 import {
   parseSlackThreadId,
   resolveConversationPrivacy,
@@ -144,17 +150,17 @@ import {
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-GJG67YFS.js";
+} from "./chunk-TLGM5X2M.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-ZHP4KNF7.js";
+} from "./chunk-OSKEC4XU.js";
 import {
   CredentialUnavailableError,
   credentialContextSchema,
   credentialUserSubjectId,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-TZU3R5OC.js";
+} from "./chunk-K2W4CK7K.js";
 import {
   isUserActor
 } from "./chunk-C4MZ3GP5.js";
@@ -175,7 +181,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-CSS7JHEM.js";
+} from "./chunk-4FUEG3QY.js";
 import {
   isRecord,
   parseSlackChannelId,
@@ -274,7 +280,6 @@ function shouldPropagateSandboxEgressTrace(host, config = {}) {
 
 // src/chat/agent/index.ts
 import { Agent } from "@earendil-works/pi-agent-core";
-import { isRetryableAssistantError } from "@earendil-works/pi-ai";
 
 // src/chat/sandbox/skill-sandbox.ts
 import fs from "fs/promises";
@@ -613,6 +618,9 @@ function shouldEmitDevAgentTrace() {
   return process.env.NODE_ENV === "development";
 }
 
+// src/chat/services/turn-result.ts
+import { isRetryableAssistantError } from "@earendil-works/pi-ai";
+
 // src/chat/no-reply.ts
 var NO_REPLY_MARKER = "[[NO_REPLY]]";
 function isNoReplyMarker(text) {
@@ -827,7 +835,10 @@ function buildTurnResult(input) {
     usage,
     stopReason,
     errorMessage,
-    providerError: void 0
+    providerError: resolvedOutcome === "provider_error" && errorMessage ? createProviderError(errorMessage, {
+      modelId,
+      retryable: lastAssistant !== void 0 && isAssistantMessage(lastAssistant) && isRetryableAssistantError(lastAssistant)
+    }) : void 0
   };
   return {
     text: primaryText,
@@ -838,6 +849,40 @@ function buildTurnResult(input) {
   };
 }
 
+// src/chat/services/provider-retry.ts
+import {
+  isRetryableAssistantError as isRetryableAssistantError2
+} from "@earendil-works/pi-ai";
+var PROVIDER_RETRY_DELAYS_MS = [2e3, 4e3, 8e3];
+var MAX_PROVIDER_RETRY_DELAY_MS = 6e4;
+function nextProviderRetry(args) {
+  const backoffMs = PROVIDER_RETRY_DELAYS_MS[args.attempt];
+  const errorMessage = args.failure?.errorMessage;
+  if (backoffMs === void 0 || !args.failure || !errorMessage) {
+    return void 0;
+  }
+  const providerError = createProviderError(errorMessage, {
+    retryable: true
+  });
+  const hasRetrySignal = isRetryableAssistantError2(args.failure) || providerError.status === 408;
+  if (!hasRetrySignal || !providerError.retryable) {
+    return void 0;
+  }
+  const delayMs = Math.min(
+    MAX_PROVIDER_RETRY_DELAY_MS,
+    Math.max(backoffMs, providerError.retryAfterMs ?? 0)
+  );
+  const messages = trimTrailingAssistantMessages(args.messages);
+  if (messages.length === args.messages.length) {
+    return void 0;
+  }
+  const tailRole = getPiMessageRole(messages.at(-1));
+  if (tailRole !== "user" && tailRole !== "toolResult") {
+    return void 0;
+  }
+  return { delayMs, messages };
+}
+
 // src/chat/tool-support/structured-result.ts
 import { z } from "zod";
 var juniorToolContinuationSchema = z.object({
@@ -1057,7 +1102,8 @@ function configuredTurnRoute(profile, reasoningLevel, source) {
   return {
     profile,
     reasoningLevel,
-    reason: `configured:${source}`
+    reason: `configured:${source}`,
+    source: source === "profile" ? "inherited" : "configured"
   };
 }
 async function selectTurnRoute(args) {
@@ -1117,7 +1163,7 @@ async function selectTurnRoute(args) {
           "gen_ai.request.reasoning.level_confidence": normalizedSelection.confidence
         } : {}
       });
-      return normalizedSelection;
+      return { ...normalizedSelection, source: "router" };
     }
   );
 }
@@ -1163,20 +1209,37 @@ async function classifyTurn(args) {
         confidence: parsed.confidence,
         profile: STANDARD_MODEL_PROFILE,
         reasoningLevel: CLASSIFIER_FALLBACK_REASONING_LEVEL,
-        reason: `low_confidence_medium_default:${reason}`
+        reason: `low_confidence_medium_default:${reason}`,
+        source: "router"
       };
     }
     return {
       confidence: parsed.confidence,
       profile: parsed.profile,
       reasoningLevel: parsed.reasoning_level,
-      reason
+      reason,
+      source: "router"
     };
-  } catch {
+  } catch (error) {
+    logWarn(
+      "turn_router_classifier_failed",
+      {
+        messageConversationId: args.metadata.threadId,
+        destinationName: args.metadata.channelId,
+        userId: args.metadata.actorId,
+        runId: args.metadata.runId,
+        modelId: args.fastModelId
+      },
+      {
+        "exception.message": error instanceof Error ? error.message : String(error)
+      },
+      "Turn router classifier failed; using the default route"
+    );
     return {
       profile: STANDARD_MODEL_PROFILE,
       reasoningLevel: CLASSIFIER_FALLBACK_REASONING_LEVEL,
-      reason: "classifier_error_default"
+      reason: "classifier_error_default",
+      source: "router"
     };
   }
 }
@@ -5066,6 +5129,16 @@ async function collectFiles(params) {
 }
 
 // src/chat/tools/sandbox/text-edits.ts
+var MAX_DIFF_LINE_CHARS = 4e3;
+function truncateDiffLine(value) {
+  if (value.length <= MAX_DIFF_LINE_CHARS) {
+    return { line: value, truncated: false };
+  }
+  return {
+    line: `${value.slice(0, MAX_DIFF_LINE_CHARS)}... [line truncated]`,
+    truncated: true
+  };
+}
 function detectLineEnding(value) {
   return value.includes("\r\n") ? "\r\n" : "\n";
 }
@@ -5153,27 +5226,35 @@ function buildCompactDiff(oldContent, newContent) {
   const oldContextEnd = Math.min(oldLines.length - 1, oldSuffix + 3);
   const width = String(Math.max(oldLines.length, newLines.length)).length;
   const output = [];
+  let lineTruncated = false;
+  const pushLine = (value) => {
+    const bounded2 = truncateDiffLine(value);
+    output.push(bounded2.line);
+    lineTruncated ||= bounded2.truncated;
+  };
   if (contextStart > 0) {
-    output.push(` ${"".padStart(width)} ...`);
+    pushLine(` ${"".padStart(width)} ...`);
   }
   for (let index = contextStart; index < prefix; index += 1) {
-    output.push(` ${String(index + 1).padStart(width)} ${oldLines[index]}`);
+    pushLine(` ${String(index + 1).padStart(width)} ${oldLines[index]}`);
   }
   for (let index = prefix; index <= oldSuffix; index += 1) {
-    output.push(`-${String(index + 1).padStart(width)} ${oldLines[index]}`);
+    pushLine(`-${String(index + 1).padStart(width)} ${oldLines[index]}`);
   }
   for (let index = prefix; index <= newSuffix; index += 1) {
-    output.push(`+${String(index + 1).padStart(width)} ${newLines[index]}`);
+    pushLine(`+${String(index + 1).padStart(width)} ${newLines[index]}`);
   }
   for (let index = newSuffix + 1; index <= newContextEnd; index += 1) {
-    output.push(` ${String(index + 1).padStart(width)} ${newLines[index]}`);
+    pushLine(` ${String(index + 1).padStart(width)} ${newLines[index]}`);
   }
   if (newContextEnd < newLines.length - 1 || oldContextEnd < oldLines.length - 1) {
-    output.push(` ${"".padStart(width)} ...`);
+    pushLine(` ${"".padStart(width)} ...`);
   }
+  const bounded = truncateText(output.join("\n"), MAX_TEXT_CHARS);
   return {
-    diff: output.join("\n"),
-    firstChangedLine: firstChangedLine(oldContent, newContent)
+    diff: bounded.content,
+    firstChangedLine: firstChangedLine(oldContent, newContent),
+    truncated: lineTruncated || bounded.truncated
   };
 }
 function validateAndApplyTextEdits(content, edits, targetName) {
@@ -5402,7 +5483,6 @@ async function editFile(params) {
     status: "success",
     target: params.path,
     data: {
-      diff: diff.diff,
       first_changed_line: diff.firstChangedLine,
       path: params.path,
       replacements: params.edits.length
@@ -5410,7 +5490,8 @@ async function editFile(params) {
     diff: diff.diff,
     first_changed_line: diff.firstChangedLine,
     path: params.path,
-    replacements: params.edits.length
+    replacements: params.edits.length,
+    truncated: diff.truncated
   });
 }
 var editReplacementSchema = z5.object({
@@ -14716,7 +14797,11 @@ function createResumeState(args) {
       if (!args.durability.shouldYield?.()) {
         return void 0;
       }
-      resumeMessages = this.getResumeSnapshot(currentMessages);
+      const nextResumeMessages = this.getResumeSnapshot(currentMessages);
+      if (!isContinuablePiBoundary(nextResumeMessages)) {
+        return void 0;
+      }
+      resumeMessages = nextResumeMessages;
       return new CooperativeTurnYieldError(
         `Agent turn yielded at a safe boundary after ${currentDurationMs()}ms`
       );
@@ -14815,16 +14900,24 @@ function createResumeState(args) {
 }
 
 // src/chat/services/context-compaction.ts
-import {
-  estimateContextTokens,
-  estimateTokens
-} from "@earendil-works/pi-agent-core";
 var RETAINED_USER_MESSAGE_TOKENS = 2e4;
 var MAX_SUMMARY_INPUT_CHARS = 8e4;
 var MAX_VISIBLE_CONTEXT_CHARS = 2e4;
 var MAX_SUMMARY_CHARS = 6e3;
 var MAX_RENDERED_MESSAGE_CHARS = 4e3;
 var OMITTED_OLDER_CONTEXT_NOTICE = "[older context omitted]";
+var ContextInputLimitExceededError = class extends Error {
+  constructor(estimatedTokens, inputLimitTokens) {
+    super(
+      `Agent context is ${estimatedTokens} estimated input tokens, above the ${inputLimitTokens} token limit`
+    );
+    this.estimatedTokens = estimatedTokens;
+    this.inputLimitTokens = inputLimitTokens;
+    this.name = "ContextInputLimitExceededError";
+  }
+  estimatedTokens;
+  inputLimitTokens;
+};
 function textPart(value) {
   if (value && typeof value === "object" && value.type === "text" && typeof value.text === "string") {
     return value.text;
@@ -14985,13 +15078,10 @@ async function summarizeContext(args, deps) {
   return summary.slice(0, MAX_SUMMARY_CHARS);
 }
 function estimateHistoryTokens(messages) {
-  const stripped = stripRuntimeTurnContext(messages);
-  const usageEstimate = estimateContextTokens(stripped).tokens;
-  const structuralEstimate = stripped.reduce(
-    (total, message) => total + estimateTokens(message),
+  return messages.reduce(
+    (total, message) => total + estimateTextTokens(JSON.stringify(message) ?? ""),
     0
   );
-  return Math.max(usageEstimate, structuralEstimate);
 }
 function buildReplacementProvenance(args) {
   return [
@@ -15015,11 +15105,11 @@ async function maybeCompactWithDeps(args, deps) {
   if ("reason" in source) {
     return { compacted: false, reason: source.reason };
   }
-  const triggerTokens = deps.autoCompactionTriggerTokens ?? getAgentContextCompactionTriggerTokens();
+  const triggerTokens = deps.autoCompactionTriggerTokens ?? getAgentContextCompactionTriggerTokens(args.modelId);
   if (source.estimatedTokens <= triggerTokens) {
     return { compacted: false, reason: "below_threshold" };
   }
-  args.onCompactionStart?.();
+  await args.onCompactionStart?.();
   let summary;
   try {
     summary = await summarizeContext(
@@ -15050,7 +15140,8 @@ async function maybeCompactWithDeps(args, deps) {
   }
   return await writeCompactedThreadContext(args, source.messages, summary, {
     estimatedTokens: source.estimatedTokens,
-    triggerTokens
+    triggerTokens,
+    inputLimitTokens: getAgentContextInputLimitTokens(args.modelId)
   });
 }
 async function writeCompactedThreadContext(args, sourceMessages, summary, context) {
@@ -15066,6 +15157,7 @@ async function writeCompactedThreadContext(args, sourceMessages, summary, contex
     userMessage(`${COMPACTION_SUMMARY_PREFIX}
 ${summary}`)
   ];
+  const replacementInputTokens = estimateHistoryTokens(replacement);
   const replacementProvenance = buildReplacementProvenance({
     retained,
     sourceProvenance: sourceProjection.provenance
@@ -15076,6 +15168,16 @@ ${summary}`)
       type: "compaction",
       modelProfile: sourceProjection.modelProfile,
       modelId: modelIdForProfile(botConfig, sourceProjection.modelProfile),
+      details: {
+        reason: "capacity",
+        estimatedInputTokens: context.estimatedTokens,
+        replacementInputTokens,
+        triggerTokens: context.triggerTokens ?? getAgentContextCompactionTriggerTokens(args.modelId),
+        inputLimitTokens: context.inputLimitTokens,
+        inputMessageCount: sourceMessages.length,
+        retainedMessageCount: replacement.length - 1,
+        summaryChars: summary.length
+      },
       replacementHistory: replacement.map((message, index) => {
         const sourceEventSeq = index < retained.length ? sourceProjection.seqs[retained[index].sourceIndex] : void 0;
         return {
@@ -15137,6 +15239,114 @@ ${await summarizeContext(args, deps)}`;
   });
   return messages;
 }
+async function compactActiveContextIfNeeded(args, deps) {
+  const pendingMessages = args.pendingMessages ?? [];
+  const source = loadCompactionSource([
+    ...args.piMessages,
+    ...pendingMessages.map((entry) => entry.message)
+  ]);
+  if ("reason" in source) {
+    return { compacted: false, reason: source.reason };
+  }
+  const triggerTokens = getAgentContextCompactionTriggerTokens(args.modelId);
+  if (source.estimatedTokens <= triggerTokens) {
+    return { compacted: false, reason: "below_threshold" };
+  }
+  await args.onCompactionStart?.();
+  const inputLimitTokens = getAgentContextInputLimitTokens(args.modelId);
+  let summary;
+  try {
+    summary = await summarizeContext(
+      {
+        ...args,
+        piMessages: args.piMessages
+      },
+      deps
+    );
+  } catch (error) {
+    if (source.estimatedTokens >= inputLimitTokens) {
+      throw new ContextInputLimitExceededError(
+        source.estimatedTokens,
+        inputLimitTokens
+      );
+    }
+    logWarn(
+      "active_context_compaction_summary_failed",
+      {
+        messageConversationId: args.metadata?.threadId,
+        userId: args.metadata?.actorId,
+        destinationName: args.metadata?.channelId,
+        runId: args.metadata?.runId,
+        assistantUserName: botConfig.userName,
+        modelId: args.modelId
+      },
+      {
+        "app.context_input_limit_tokens": inputLimitTokens,
+        "app.context_tokens_estimated": source.estimatedTokens,
+        "exception.message": error instanceof Error ? error.message : String(error)
+      },
+      "Active context compaction failed below the hard input limit"
+    );
+    return { compacted: false, reason: "summary_failed" };
+  }
+  const summaryText = `${COMPACTION_SUMMARY_PREFIX}
+${summary}`;
+  const runtimeMessage = retainRuntimeTurnContext(args.piMessages).at(-1);
+  const summaryMessages = runtimeMessage ? [
+    {
+      ...runtimeMessage,
+      content: [
+        ...runtimeMessage.content,
+        { type: "text", text: renderCurrentInstruction(summaryText) }
+      ]
+    }
+  ] : [userMessage(renderCurrentInstruction(summaryText))];
+  const messages = [
+    ...summaryMessages,
+    ...pendingMessages.map((entry) => entry.message)
+  ];
+  const replacementInputTokens = estimateHistoryTokens(messages);
+  if (replacementInputTokens >= inputLimitTokens) {
+    throw new ContextInputLimitExceededError(
+      replacementInputTokens,
+      inputLimitTokens
+    );
+  }
+  const replacementMessages = stripRuntimeTurnContext(messages);
+  args.signal?.throwIfAborted();
+  await getConversationEventStore().replaceHistory(args.conversationId, {
+    createdAtMs: Date.now(),
+    data: {
+      type: "compaction",
+      modelProfile: args.modelProfile,
+      modelId: args.modelId,
+      details: {
+        reason: "capacity",
+        estimatedInputTokens: source.estimatedTokens,
+        replacementInputTokens,
+        triggerTokens,
+        inputLimitTokens,
+        inputMessageCount: source.messages.length,
+        retainedMessageCount: pendingMessages.length,
+        summaryChars: summary.length
+      },
+      replacementHistory: replacementMessages.map((message, index) => ({
+        message,
+        provenance: index === 0 ? contextProvenance : pendingMessages[index - 1]?.provenance ?? contextProvenance
+      }))
+    }
+  });
+  setSpanAttributes({
+    "app.compaction.input_messages": source.messages.length,
+    "app.compaction.replacement_tokens": replacementInputTokens,
+    "app.compaction.retained_messages": pendingMessages.length,
+    "app.compaction.summary_chars": summary.length,
+    "app.compaction.trigger_tokens": triggerTokens,
+    "app.context_input_limit_tokens": inputLimitTokens,
+    "app.context_tokens_estimated": source.estimatedTokens
+  });
+  return { compacted: true, piMessages: messages };
+}
 
 // src/chat/agent/index.ts
 var AGENT_ABORT_SETTLE_GRACE_MS = 5e3;
@@ -15235,7 +15445,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
   let mcpToolManager;
   let connectedMcpProviders = /* @__PURE__ */ new Set();
   let turnUsage;
-  let handoffPhaseUsage;
+  let priorPhaseUsage;
   const configuredReasoningLevel = policy.reasoningLevel ?? botConfig.reasoningLevel;
   let turnRoute = configuredReasoningLevel ? configuredTurnRoute(
     STANDARD_MODEL_PROFILE,
@@ -15286,6 +15496,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     const projection = await openConversationProjection({ conversationId });
     activeModelProfile = projection.modelProfile;
     activeModelId = modelIdForProfile(botConfig, activeModelProfile);
+    let durableModelProfile = projection.modelProfile;
     const shouldTrace = shouldEmitDevAgentTrace();
     const spanContext = { modelId: activeModelId };
     const availableSkills = await discoverRunSkills({
@@ -15390,7 +15601,30 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     });
     const { routerBlocks, userContentParts } = buildPromptInput(input);
     const preAgentPromptMessages = () => existingSessionRecord?.piMessages ?? [...input.piMessages ?? []];
-    if (activeModelProfile === STANDARD_MODEL_PROFILE) {
+    const storedTurnRoute = await loadTurnRoute({ conversationId, turnId });
+    if (storedTurnRoute) {
+      const resumedAfterHandoff = activeModelProfile !== STANDARD_MODEL_PROFILE && activeModelProfile !== storedTurnRoute.modelProfile;
+      if (resumedAfterHandoff) {
+        const activeProfileConfig = profileConfig(
+          botConfig,
+          activeModelProfile
+        );
+        const resumedReasoningLevel = existingSessionRecord?.reasoningLevel ? parseTurnReasoningLevel(existingSessionRecord.reasoningLevel) : void 0;
+        turnRoute = {
+          profile: activeModelProfile,
+          reasoningLevel: activeProfileConfig.reasoningLevel ?? resumedReasoningLevel ?? storedTurnRoute.reasoningLevel,
+          reason: `resumed_handoff:${storedTurnRoute.modelProfile}:${activeModelProfile}`
+        };
+      } else {
+        turnRoute = {
+          profile: storedTurnRoute.modelProfile,
+          reasoningLevel: storedTurnRoute.reasoningLevel,
+          ...storedTurnRoute.confidence !== void 0 ? { confidence: storedTurnRoute.confidence } : {},
+          reason: `persisted:${storedTurnRoute.source}`,
+          source: storedTurnRoute.source
+        };
+      }
+    } else if (activeModelProfile === STANDARD_MODEL_PROFILE) {
       turnRoute = await selectTurnRoute({
         completeObject,
         conversationContext: input.conversationContext,
@@ -15405,7 +15639,11 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
         messageText: userInput,
         profiles: botConfig.profiles
       });
-      if (configuredReasoningLevel) {
+      const routedProfileReasoningLevel = profileConfig(
+        botConfig,
+        turnRoute.profile
+      ).reasoningLevel;
+      if (configuredReasoningLevel && !routedProfileReasoningLevel) {
         turnRoute = {
           ...turnRoute,
           reasoningLevel: configuredReasoningLevel,
@@ -15414,12 +15652,29 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
       }
     } 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 reasoningSource = activeProfileConfig.reasoningLevel ? "profile" : policy.reasoningLevel ? "agent_config" : "default";
+      turnRoute = {
+        profile: activeModelProfile,
+        reasoningLevel: activeProfileConfig.reasoningLevel ?? policy.reasoningLevel ?? botConfig.reasoningLevel ?? "medium",
+        reason: `inherited:${reasoningSource}`,
+        source: "inherited"
+      };
     }
+    const routedModelProfile = turnRoute.profile;
+    const routedModelId = modelIdForProfile(botConfig, routedModelProfile);
+    if (!storedTurnRoute) {
+      await recordTurnRoute({
+        conversationId,
+        turnId,
+        modelProfile: routedModelProfile,
+        modelId: routedModelId,
+        reasoningLevel: turnRoute.reasoningLevel,
+        ...turnRoute.confidence !== void 0 ? { confidence: turnRoute.confidence } : {},
+        source: turnRoute.source ?? "configured"
+      });
+    }
+    activeModelProfile = routedModelProfile;
+    activeModelId = routedModelId;
     const generatedFiles = [];
     const artifactStatePatch = {};
     const toolCalls = [];
@@ -15432,17 +15687,20 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
         (profile) => profile !== STANDARD_MODEL_PROFILE && profile !== DEFAULT_HANDOFF_MODEL_PROFILE
       ).sort()
     ];
+    const usageSinceCurrentBoundary = (messages) => {
+      const usage = extractGenAiUsageSummary(
+        ...messages.slice(runResume.beforeMessageCount).filter(isAssistantMessage)
+      );
+      return hasAgentTurnUsage(usage) ? usage : void 0;
+    };
     const scheduleHandoff = async (args) => {
-      if (args.profile === activeModelProfile) {
+      if (args.profile === durableModelProfile) {
         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 phaseUsage = usageSinceCurrentBoundary(args.sourceMessages);
       const selectedProfile = profileConfig(botConfig, args.profile);
       const handoffReasoningLevel = selectedProfile.reasoningLevel ?? turnRoute.reasoningLevel;
       const target = {
@@ -15480,8 +15738,11 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
             runId
           }
         },
-        { completeText }
+        {
+          completeText: (args2) => completeText(args2)
+        }
       );
+      durableModelProfile = args.profile;
       if (handoffReasoningLevel !== turnRoute.reasoningLevel) {
         turnRoute = {
           ...turnRoute,
@@ -15489,7 +15750,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
           reason: `profile_reasoning_override:${args.profile}:${turnRoute.reason}`
         };
       }
-      handoffPhaseUsage = phaseUsage;
+      priorPhaseUsage = addAgentTurnUsage(priorPhaseUsage, phaseUsage);
       pendingHandoff = {
         messages: handoffMessages,
         model: handoffModel,
@@ -15602,6 +15863,52 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
         thinkingLevel
       };
     };
+    const applyActiveContextCompaction = async (messages, hookSignal, pendingMessages, clearSteeringQueueOnCommit = false) => {
+      const compaction = await compactActiveContextIfNeeded(
+        {
+          conversationContext: input.conversationContext,
+          conversationId,
+          metadata: {
+            threadId: conversationId,
+            channelId: slackDestination?.channelId,
+            actorId: slackActor?.userId,
+            runId
+          },
+          modelId: activeModelId,
+          modelProfile: activeModelProfile,
+          onCompactionStart: () => observers.onStatus?.({ text: "Compacting context" }),
+          pendingMessages,
+          piMessages: messages,
+          signal: hookSignal
+        },
+        {
+          completeText: (args) => completeText(args)
+        }
+      );
+      if (!compaction.compacted || !compaction.piMessages) {
+        return void 0;
+      }
+      priorPhaseUsage = addAgentTurnUsage(
+        priorPhaseUsage,
+        usageSinceCurrentBoundary(messages)
+      );
+      const replacement = [...compaction.piMessages];
+      await runResume.requireDurableInputCheckpoint(replacement);
+      agent.state.messages = replacement;
+      runResume.setBeforeMessageCount(replacement.length);
+      runResume.setTurnStartMessageIndex(0);
+      runResume.adoptCommittedBoundary(replacement);
+      if (clearSteeringQueueOnCommit && pendingMessages?.length) {
+        agent.clearSteeringQueue();
+      }
+      return {
+        context: {
+          systemPrompt: baseInstructions,
+          messages: replacement,
+          tools: agent.state.tools
+        }
+      };
+    };
     let assistantMessageDeliveryError;
     const deliverAssistantMessage = async (message) => {
       const text = getAssistantMessageText(message);
@@ -15619,8 +15926,9 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
     };
     const drainSteeringMessages = async () => {
       if (!durability.drainSteeringMessages) {
-        return;
+        return [];
       }
+      const acceptedMessages = [];
       try {
         let steeredMessageCount = 0;
         await durability.drainSteeringMessages(async (messages) => {
@@ -15638,6 +15946,12 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
           for (const message of piMessages) {
             agent.steer(message);
           }
+          acceptedMessages.push(
+            ...piMessages.map((message, index) => ({
+              message,
+              provenance: messages[index].provenance
+            }))
+          );
           steeredMessageCount += piMessages.length;
         });
         if (steeredMessageCount > 0) {
@@ -15663,6 +15977,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
           "Agent turn steering message drain failed"
         );
       }
+      return acceptedMessages;
     };
     const apiKeyOverride = getPiGatewayApiKey();
     let pendingPiHookError;
@@ -15686,15 +16001,27 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
         return void 0;
       },
       afterToolCall: async ({ result: result2 }, signal2) => runResume.timedOut && signal2?.aborted ? annotateTurnDeadlineToolResult(result2) : void 0,
-      prepareNextTurn: async () => {
-        const update = applyPendingHandoff();
-        await drainSteeringMessages();
-        const yieldError = runResume.prepareYieldIfDue(currentAgentMessages());
-        if (yieldError) {
-          pendingPiHookError = yieldError;
-          throw yieldError;
+      prepareNextTurnWithContext: async (nextTurn, hookSignal) => {
+        try {
+          const handoffUpdate = applyPendingHandoff();
+          const pendingMessages = await drainSteeringMessages();
+          const capacityUpdate = await applyActiveContextCompaction(
+            handoffUpdate ? currentAgentMessages() : nextTurn.context.messages,
+            hookSignal,
+            pendingMessages,
+            true
+          );
+          const yieldError = runResume.prepareYieldIfDue(
+            currentAgentMessages()
+          );
+          if (yieldError) {
+            throw yieldError;
+          }
+          return capacityUpdate && handoffUpdate ? { ...handoffUpdate, ...capacityUpdate } : capacityUpdate ?? handoffUpdate;
+        } catch (error) {
+          pendingPiHookError = error instanceof Error ? error : new Error(String(error));
+          throw error;
         }
-        return update;
       },
       initialState: {
         systemPrompt: baseInstructions,
@@ -15859,6 +16186,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
           };
           const requestedProfile = activeModelProfile === STANDARD_MODEL_PROFILE ? turnRoute.profile : void 0;
           let run;
+          let handoffApplied = false;
           if (requestedProfile && requestedProfile !== STANDARD_MODEL_PROFILE) {
             const handoffAbortController = new AbortController();
             await runAgentStep(
@@ -15870,19 +16198,29 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
               }),
               () => 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();
+            handoffApplied = Boolean(applyPendingHandoff());
           }
+          const compactionAbortController = new AbortController();
+          const capacityUpdate = await runAgentStep(
+            applyActiveContextCompaction(
+              [...agent.state.messages],
+              compactionAbortController.signal,
+              shouldPromptAgent ? [
+                {
+                  message: freshPromptMessage,
+                  provenance: instructionProvenanceFor(actor)
+                }
+              ] : void 0
+            ),
+            () => compactionAbortController.abort()
+          );
+          if (shouldPromptAgent && handoffApplied && !capacityUpdate) {
+            await runResume.requireDurableInputCheckpoint([
+              ...agent.state.messages,
+              freshPromptMessage
+            ]);
+          }
+          run = shouldPromptAgent && !capacityUpdate ? agent.prompt(freshPromptMessage) : agent.continue();
           let retryUsage;
           try {
             for (let attempt = 0; ; attempt += 1) {
@@ -15905,10 +16243,7 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
                 retryUsage,
                 currentUsage
               );
-              turnUsage = addAgentTurnUsage(
-                handoffPhaseUsage,
-                currentPhaseUsage
-              );
+              turnUsage = addAgentTurnUsage(priorPhaseUsage, currentPhaseUsage);
               setSpanAttributes({
                 ...outputMessagesAttribute ? { "gen_ai.output.messages": outputMessagesAttribute } : {},
                 ...toGenAiMessagesTraceAttributes(
@@ -15931,8 +16266,8 @@ async function executeAgentRunInPrivacyContext(request, conversationPrivacy, run
               }
               const providerRetry = nextProviderRetry({
                 attempt,
-                messages: agent.state.messages,
-                retryableFailure: lastAssistant !== void 0 && isRetryableAssistantError(lastAssistant)
+                failure: lastAssistant,
+                messages: agent.state.messages
               });
               if (!providerRetry) {
                 break;