@vellumai/assistant 0.8.3 → 0.8.5

package/src/daemon/conversation-agent-loop.ts

@@ -15,6 +15,7 @@ import { optimizeImageForTransport } from "../agent/image-optimize.js";
 import type {
   AgentEvent,
   AgentLoop,
+  AgentLoopExitReason,
   CheckpointDecision,
   CheckpointInfo,
 } from "../agent/loop.js";
@@ -27,9 +28,13 @@ import type {
 } from "../channels/types.js";
 import {
   contextWindowConfigFromEffective,
+  type EffectiveContextWindow,
   resolveEffectiveContextWindow,
 } from "../config/llm-context-resolution.js";
-import { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import {
+  resolveCallSiteConfig,
+  resolveDefaultProfileKey,
+} from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import type { ContextWindowConfig } from "../config/types.js";
@@ -54,7 +59,6 @@ import { commitAppTurnChanges } from "../memory/app-git-service.js";
 import { getApp, listAppFiles, resolveAppDir } from "../memory/app-store.js";
 import { enqueueAutoAnalysisOnCompaction } from "../memory/auto-analysis-enqueue.js";
 import {
-  clearStrippedInjectionMetadataForConversation,
   getConversation,
   getConversationOriginChannel,
   getConversationOriginInterface,
@@ -62,6 +66,8 @@ import {
   getLastUserTimestampBefore,
   getMessageById,
   provenanceFromTrustContext,
+  setConversationHistoryStrippedAt,
+  setLastNotifiedInferenceProfile,
   updateConversationContextWindow,
   updateConversationSlackContextWatermark,
 } from "../memory/conversation-crud.js";
@@ -156,13 +162,13 @@ import {
   createEventHandlerState,
   dispatchAgentEvent,
   type EventHandlerDeps,
-  getClientDisplayMessageId,
 } from "./conversation-agent-loop-handlers.js";
 import {
   approveHostAttachmentRead,
   resolveAssistantAttachments,
 } from "./conversation-attachments.js";
 import {
+  budgetYieldUnrecoveredClassification,
   buildConversationErrorMessage,
   classifyConversationError,
   isUserCancellation,
@@ -521,14 +527,26 @@ export interface AgentLoopConversationContext {
   /** Per-turn snapshot of channelCapabilities, frozen at message-processing start. */
   currentTurnChannelCapabilities?: ChannelCapabilities;
   /**
-   * Per-turn snapshot of the resolved inference-profile override. Read by
+   * Current inference-profile override for this turn. Read by
    * `createToolExecutor` so `ToolContext.overrideProfile` carries the same
-   * profile the agent loop is sending to the provider. Without this, a tool
-   * that spawns nested subagents (e.g. `subagent_spawn`) cannot recover the
-   * override from a row read because the in-flight subagent's own row never
-   * had `inferenceProfile` set.
+   * profile the agent loop is sending to the provider. Refreshed between
+   * model calls so an explicitly confirmed profile session opened mid-turn
+   * is inherited by later tool executions and nested subagents.
    */
   currentTurnOverrideProfile?: string;
+  /**
+   * Set by the `switch_inference_profile` tool when the model self-selects a
+   * different profile mid-turn. Read by `readCurrentOverrideProfile` in the
+   * agent loop so the next LLM call uses the switched profile. Reset at
+   * turn start.
+   */
+  toolRoutedProfile?: string;
+  /**
+   * True when the user has explicitly selected an inference profile for this
+   * conversation (via the composer profile picker). When set, tool-based
+   * auto-routing is suppressed — the user's explicit choice takes precedence.
+   */
+  hasExplicitProfileOverride?: boolean;
   commandIntent?: { type: string; payload?: string; languageCode?: string };
   trustContext?: TrustContext;
   /** Task-run scope for the current turn. Cleared at turn end so queued/drained turns don't inherit it. */
@@ -536,7 +554,6 @@ export interface AgentLoopConversationContext {
   assistantId?: string;
   voiceCallControlPrompt?: string;
   transportHints?: string[];
-  slackRuntimeContextNotice?: string;
   clientTimezone?: string;
 
   readonly coreToolNames: Set<string>;
@@ -670,6 +687,18 @@ export async function runAgentLoopImpl(
     requestId: reqId,
   });
   let yieldedForHandoff = false;
+  let yieldedForBudget = false;
+  let pendingCheckpointYield: "budget" | "handoff" | null = null;
+  // Captured when the auto_compress_latest_turn rerun yields at the mid-loop
+  // budget checkpoint. SSE emission happens immediately at the detection site;
+  // assistant-row persistence is deferred until after the pendingToolResults
+  // flush so we don't orphan tool_use/tool_result pairs in the durable history.
+  let budgetYieldClassification: ReturnType<
+    typeof budgetYieldUnrecoveredClassification
+  > | null = null;
+  let emitTerminalExit:
+    | ((reason: AgentLoopExitReason) => Promise<void>)
+    | null = null;
 
   // Default user-initiated turns to the `mainAgent` call site. Other
   // invocation contexts (heartbeat, filing, analyze, etc.) pass their own
@@ -691,31 +720,124 @@ export async function runAgentLoopImpl(
   // spawned subagent's background conversation) wins over the row read
   // so the agent loop's own background-skip rule doesn't zero out an
   // explicitly inherited override.
-  const turnOverrideProfile =
+  const userExplicitOverride =
     options?.overrideProfile ??
     getConversationOverrideProfileFromRow(turnStartConversation);
 
+  ctx.hasExplicitProfileOverride = !!userExplicitOverride;
+
   const config = getConfig();
+
+  // Tool-based auto-routing: the switch_inference_profile tool lets the model
+  // self-select a different profile mid-turn. Reset the per-turn slot so a
+  // stale selection from a previous turn doesn't leak forward.
+  ctx.toolRoutedProfile = undefined;
+
+  const turnOverrideProfile = userExplicitOverride;
+
+  const readCurrentOverrideProfile = (): string | undefined =>
+    options?.overrideProfile ??
+    getConversationOverrideProfileFromRow(
+      getConversation(ctx.conversationId),
+    ) ??
+    ctx.toolRoutedProfile;
+
   const effectiveContextWindow = resolveEffectiveContextWindow({
     llm: config.llm,
     callSite: turnCallSite,
     overrideProfile: turnOverrideProfile ?? undefined,
   });
-  const turnContextWindowConfig = contextWindowConfigFromEffective(
+  let currentEffectiveContextWindow: EffectiveContextWindow =
+    effectiveContextWindow;
+  let currentContextWindowConfig = contextWindowConfigFromEffective(
     resolveCallSiteConfig(turnCallSite, config.llm, {
       overrideProfile: turnOverrideProfile ?? undefined,
     }).contextWindow,
-    effectiveContextWindow,
+    currentEffectiveContextWindow,
   );
-  (
+  const contextWindowManager =
     ctx.contextWindowManager as ContextWindowManager & {
       updateConfig?: (config: ContextWindowConfig) => void;
+    };
+  contextWindowManager.updateConfig?.(currentContextWindowConfig);
+
+  let appliedOverrideProfile = turnOverrideProfile;
+  let emittedToolRoutedProfile: string | undefined;
+  const refreshCurrentProfileState = (): string | undefined => {
+    const currentOverrideProfile = readCurrentOverrideProfile();
+    if (currentOverrideProfile !== appliedOverrideProfile) {
+      currentEffectiveContextWindow = resolveEffectiveContextWindow({
+        llm: config.llm,
+        callSite: turnCallSite,
+        overrideProfile: currentOverrideProfile,
+      });
+      currentContextWindowConfig = contextWindowConfigFromEffective(
+        resolveCallSiteConfig(turnCallSite, config.llm, {
+          overrideProfile: currentOverrideProfile,
+        }).contextWindow,
+        currentEffectiveContextWindow,
+      );
+      contextWindowManager.updateConfig?.(currentContextWindowConfig);
+      appliedOverrideProfile = currentOverrideProfile;
+      rlog.info(
+        { overrideProfile: currentOverrideProfile ?? null },
+        "Turn inference profile changed mid-loop",
+      );
+    }
+
+    // Emit turn_profile_auto_routed when the tool-based router selects a
+    // new profile. Deduplicated so the event fires at most once per profile.
+    if (
+      ctx.toolRoutedProfile &&
+      ctx.toolRoutedProfile !== emittedToolRoutedProfile
+    ) {
+      emittedToolRoutedProfile = ctx.toolRoutedProfile;
+      const profileEntry = config.llm.profiles?.[ctx.toolRoutedProfile];
+      const label = profileEntry?.label ?? ctx.toolRoutedProfile;
+      broadcastMessage({
+        type: "turn_profile_auto_routed",
+        conversationId: ctx.conversationId,
+        profile: ctx.toolRoutedProfile,
+        profileLabel: label,
+      });
     }
-  ).updateConfig?.(turnContextWindowConfig);
 
-  // Snapshot for `createToolExecutor` to read into `ToolContext.overrideProfile`
-  // — see field doc on `AgentLoopConversationContext` for why the tool needs
-  // it (nested subagent spawns can't recover the override from a row read).
+    ctx.currentTurnOverrideProfile = currentOverrideProfile;
+    return currentOverrideProfile;
+  };
+  const resolveCurrentOverrideProfile = (): string | undefined =>
+    refreshCurrentProfileState();
+  const resolveCurrentMaxInputTokens = (): number => {
+    refreshCurrentProfileState();
+    return currentEffectiveContextWindow.maxInputTokens;
+  };
+  const resolveCurrentContextWindowConfig = (): ContextWindowConfig => {
+    refreshCurrentProfileState();
+    return currentContextWindowConfig;
+  };
+  const resolveCurrentContextBudget = (): {
+    overflowRecovery: EffectiveContextWindow["overflowRecovery"];
+    providerMaxTokens: number;
+    preflightBudget: number;
+  } => {
+    refreshCurrentProfileState();
+    const overflowRecovery = currentEffectiveContextWindow.overflowRecovery;
+    const providerMaxTokens = currentEffectiveContextWindow.maxInputTokens;
+    const baseSafetyMargin = overflowRecovery.safetyMarginRatio;
+    const messageCount = ctx.messages.length;
+    const safetyMargin =
+      messageCount > 50 ? Math.max(baseSafetyMargin, 0.15) : baseSafetyMargin;
+    return {
+      overflowRecovery,
+      providerMaxTokens,
+      preflightBudget: Math.floor(providerMaxTokens * (1 - safetyMargin)),
+    };
+  };
+
+  // Initial value for `createToolExecutor` to read into
+  // `ToolContext.overrideProfile`. `resolveCurrentOverrideProfile` refreshes
+  // this between model calls so a confirmed profile session opened by a tool
+  // applies to later tool executions and nested subagents in the same turn.
   ctx.currentTurnOverrideProfile = turnOverrideProfile;
 
   // Capture the turn channel context *before* any awaits so a second
@@ -1029,6 +1151,7 @@ export async function runAgentLoopImpl(
           {
             message: result.messages[0]!,
             sourceChannelTs: null,
+            tagLineProvenance: "none",
           },
           ...retainedRenderedMessages,
         ],
@@ -1088,7 +1211,7 @@ export async function runAgentLoopImpl(
       precomputedEstimate: compactCheck.estimatedTokens,
       conversationOriginChannel:
         getConversationOriginChannel(ctx.conversationId) ?? undefined,
-      overrideProfile: turnOverrideProfile ?? null,
+      overrideProfile: resolveCurrentOverrideProfile() ?? null,
     };
     let compacted: Awaited<
       ReturnType<typeof ctx.contextWindowManager.maybeCompact>
@@ -1453,6 +1576,26 @@ export async function runAgentLoopImpl(
       }
     }
 
+    // Resolve the effective profile key for this turn and detect changes.
+    // Only inject model_profile into the turn context when the profile
+    // changed since the last turn (or on the first turn of a conversation)
+    // to avoid per-turn token cost.
+    const effectiveProfileKey =
+      turnOverrideProfile ??
+      config.llm.activeProfile ??
+      resolveDefaultProfileKey("mainAgent", config.llm);
+    const lastNotified = turnStartConversation?.lastNotifiedInferenceProfile;
+    let modelProfileStr: string | null = null;
+    if (effectiveProfileKey != null && effectiveProfileKey !== lastNotified) {
+      const profileEntry = config.llm.profiles?.[effectiveProfileKey];
+      const resolved = resolveCallSiteConfig(turnCallSite, config.llm, {
+        overrideProfile: turnOverrideProfile ?? undefined,
+      });
+      const label = profileEntry?.label ?? effectiveProfileKey;
+      modelProfileStr = resolved.model ? `${label} (${resolved.model})` : label;
+      setLastNotifiedInferenceProfile(ctx.conversationId, effectiveProfileKey);
+    }
+
     const baseTurnContext = {
       timestamp,
       interfaceName,
@@ -1461,6 +1604,7 @@ export async function runAgentLoopImpl(
       clientTimezone: timezoneContext.clientTimezone,
       detectedTimezone: timezoneContext.detectedTimezone,
       timeSinceLastMessage,
+      modelProfile: modelProfileStr,
     };
     const unifiedTurnContextStr = buildUnifiedTurnContextBlock(
       isGuardian
@@ -1506,7 +1650,7 @@ export async function runAgentLoopImpl(
     // V2 static memory block (essentials/threads/recent/buffer).
     // `currentMemoryV2Static` is the trust-gated content reused by every
     // re-injection path — it stays non-null on non-full-mode turns so
-    // that mid-turn reducer compaction (which strips the prior `<memory>`
+    // that mid-turn reducer compaction (which strips the prior `<info>`
     // block) can restore the freshest content. `memoryV2Static` is the
     // first-turn / post-compaction cadence-gated value for initial
     // injection only. `readMemoryV2StaticContent` self-gates on the v2
@@ -1617,7 +1761,6 @@ export async function runAgentLoopImpl(
       nowScratchpad,
       voiceCallControlPrompt: ctx.voiceCallControlPrompt ?? null,
       transportHints: ctx.transportHints ?? null,
-      slackRuntimeContextNotice: ctx.slackRuntimeContextNotice ?? null,
       isNonInteractive: !isInteractiveResolved,
       isBackgroundConversation: isBackgroundConversationType(
         turnStartConversation?.conversationType,
@@ -1704,15 +1847,9 @@ export async function runAgentLoopImpl(
     // After runtime injections are applied, estimate the prompt token count
     // and proactively invoke the reducer if already above budget. This avoids
     // a wasted provider round-trip that would just fail with context_too_large.
-    const overflowRecovery = effectiveContextWindow.overflowRecovery;
-    const providerMaxTokens = effectiveContextWindow.maxInputTokens;
-    // Widen safety margin for large conversations where estimation error
-    // compounds across many messages with tool results.
-    const baseSafetyMargin = overflowRecovery.safetyMarginRatio;
-    const messageCount = ctx.messages.length;
-    const safetyMargin =
-      messageCount > 50 ? Math.max(baseSafetyMargin, 0.15) : baseSafetyMargin;
-    const preflightBudget = Math.floor(providerMaxTokens * (1 - safetyMargin));
+    const initialContextBudget = resolveCurrentContextBudget();
+    const overflowRecovery = initialContextBudget.overflowRecovery;
+    const preflightBudget = initialContextBudget.preflightBudget;
     let reducerState: ReducerState | undefined;
 
     const toolTokenBudget = ctx.agentLoop.getToolTokenBudget(runMessages);
@@ -1789,10 +1926,10 @@ export async function runAgentLoopImpl(
         runMessages,
         systemPrompt: ctx.systemPrompt,
         providerName: estimationProviderName,
-        contextWindow: turnContextWindowConfig,
+        contextWindow: resolveCurrentContextWindowConfig(),
         preflightBudget,
         toolTokenBudget,
-        maxAttempts: overflowRecovery.maxAttempts,
+        maxAttempts: resolveCurrentContextBudget().overflowRecovery.maxAttempts,
         abortSignal: abortController.signal,
         compactFn: async (msgs, signal, opts) => {
           // Route the reducer's forced-compaction tier through the
@@ -1822,7 +1959,7 @@ export async function runAgentLoopImpl(
                 signal,
                 options: {
                   ...(opts ?? {}),
-                  overrideProfile: turnOverrideProfile ?? null,
+                  overrideProfile: resolveCurrentOverrideProfile() ?? null,
                 },
               },
               buildPluginTurnContext(ctx, reqId),
@@ -2076,8 +2213,9 @@ export async function runAgentLoopImpl(
     };
     const eventHandler = (event: AgentEvent) =>
       dispatchAgentEvent(state, deps, event);
-
-    let yieldedForBudget = false;
+    emitTerminalExit = async (reason: AgentLoopExitReason): Promise<void> => {
+      await eventHandler({ type: "agent_loop_exit", reason });
+    };
 
     const onCheckpoint = async (
       checkpoint: CheckpointInfo,
@@ -2086,6 +2224,7 @@ export async function runAgentLoopImpl(
 
       if (ctx.canHandoffAtCheckpoint()) {
         yieldedForHandoff = true;
+        pendingCheckpointYield = "handoff";
         return "yield";
       }
 
@@ -2093,7 +2232,8 @@ export async function runAgentLoopImpl(
       // yield if we're approaching the preflight budget. This lets the
       // conversation-agent-loop run compaction before the provider rejects.
       if (overflowRecovery.enabled) {
-        const midLoopThreshold = preflightBudget * 0.85;
+        const midLoopThreshold =
+          resolveCurrentContextBudget().preflightBudget * 0.85;
         const estimated = await runTokenEstimatePipeline(checkpoint.history);
         if (estimated > midLoopThreshold) {
           rlog.warn(
@@ -2101,6 +2241,7 @@ export async function runAgentLoopImpl(
             "Token estimate approaching budget — yielding for compaction",
           );
           yieldedForBudget = true;
+          pendingCheckpointYield = "budget";
           return "yield";
         }
       }
@@ -2129,7 +2270,9 @@ export async function runAgentLoopImpl(
       turnCallSite,
       loopTurnCtx,
       turnOverrideProfile,
-      effectiveContextWindow.maxInputTokens,
+      resolveCurrentMaxInputTokens(),
+      resolveCurrentOverrideProfile,
+      resolveCurrentMaxInputTokens,
     );
 
     rlog.info(
@@ -2137,6 +2280,11 @@ export async function runAgentLoopImpl(
       "Agent loop run completed",
     );
 
+    if (yieldedForHandoff) {
+      await emitTerminalExit?.("checkpoint_handoff");
+      pendingCheckpointYield = null;
+    }
+
     // ── Proactive mid-loop compaction ───────────────────────────────
     // When the agent loop yielded because the token budget check in
     // onCheckpoint detected approaching limits, run compaction on the
@@ -2146,12 +2294,14 @@ export async function runAgentLoopImpl(
     let midLoopCompactAttempts = 0;
     while (
       yieldedForBudget &&
-      midLoopCompactAttempts < overflowRecovery.maxAttempts &&
+      midLoopCompactAttempts <
+        resolveCurrentContextBudget().overflowRecovery.maxAttempts &&
       !state.contextTooLargeDetected &&
       !abortController.signal.aborted
     ) {
       midLoopCompactAttempts++;
       yieldedForBudget = false;
+      pendingCheckpointYield = null;
 
       rlog.info(
         { phase: "mid-loop-compact" },
@@ -2162,14 +2312,7 @@ export async function runAgentLoopImpl(
       // so we compact the "raw" persistent messages.
       const rawHistory = stripInjectionsForCompaction(updatedHistory);
       ctx.messages = rawHistory;
-      try {
-        clearStrippedInjectionMetadataForConversation(ctx.conversationId);
-      } catch (err) {
-        rlog.warn(
-          { err },
-          "Failed to clear stripped-injection metadata after compaction strip (non-fatal)",
-        );
-      }
+      setConversationHistoryStrippedAt(ctx.conversationId, Date.now());
 
       ctx.emitActivityState(
         "thinking",
@@ -2193,10 +2336,11 @@ export async function runAgentLoopImpl(
             options: {
               lastCompactedAt: ctx.contextCompactedAt ?? undefined,
               force: true,
-              targetInputTokensOverride: preflightBudget,
+              targetInputTokensOverride:
+                resolveCurrentContextBudget().preflightBudget,
               conversationOriginChannel:
                 getConversationOriginChannel(ctx.conversationId) ?? undefined,
-              overrideProfile: turnOverrideProfile ?? null,
+              overrideProfile: resolveCurrentOverrideProfile() ?? null,
             },
           },
           buildPluginTurnContext(ctx, reqId),
@@ -2282,7 +2426,9 @@ export async function runAgentLoopImpl(
         turnCallSite,
         loopTurnCtx,
         turnOverrideProfile,
-        effectiveContextWindow.maxInputTokens,
+        resolveCurrentMaxInputTokens(),
+        resolveCurrentOverrideProfile,
+        resolveCurrentMaxInputTokens,
       );
     }
 
@@ -2296,7 +2442,8 @@ export async function runAgentLoopImpl(
         {
           phase: "mid-loop-compact",
           midLoopCompactAttempts,
-          maxAttempts: overflowRecovery.maxAttempts,
+          maxAttempts:
+            resolveCurrentContextBudget().overflowRecovery.maxAttempts,
         },
         "Mid-loop compaction exhausted all attempts — escalating to convergence loop",
       );
@@ -2339,7 +2486,9 @@ export async function runAgentLoopImpl(
         turnCallSite,
         loopTurnCtx,
         turnOverrideProfile,
-        effectiveContextWindow.maxInputTokens,
+        resolveCurrentMaxInputTokens(),
+        resolveCurrentOverrideProfile,
+        resolveCurrentMaxInputTokens,
       );
 
       if (state.orderingErrorDetected) {
@@ -2408,7 +2557,9 @@ export async function runAgentLoopImpl(
         turnCallSite,
         loopTurnCtx,
         turnOverrideProfile,
-        effectiveContextWindow.maxInputTokens,
+        resolveCurrentMaxInputTokens(),
+        resolveCurrentOverrideProfile,
+        resolveCurrentMaxInputTokens,
       );
       if (state.imageTooLargeDetected) {
         rlog.error(
@@ -2445,14 +2596,7 @@ export async function runAgentLoopImpl(
 
       if (updatedHistory.length > preRunHistoryLength) {
         ctx.messages = stripInjectionsForCompaction(updatedHistory);
-        try {
-          clearStrippedInjectionMetadataForConversation(ctx.conversationId);
-        } catch (err) {
-          rlog.warn(
-            { err },
-            "Failed to clear stripped-injection metadata after compaction strip (non-fatal)",
-          );
-        }
+        setConversationHistoryStrippedAt(ctx.conversationId, Date.now());
         convergenceStripped = true;
         preRepairMessages = updatedHistory;
         preRunHistoryLength = updatedHistory.length;
@@ -2479,18 +2623,21 @@ export async function runAgentLoopImpl(
           toolTokenBudget,
         },
       );
-      let correctedTarget = preflightBudget;
+      const convergenceBudget = resolveCurrentContextBudget();
+      let correctedTarget = convergenceBudget.preflightBudget;
       if (actualTokens && estimatedTokensAtOverflow > 0) {
         const estimationErrorRatio = actualTokens / estimatedTokensAtOverflow;
         if (estimationErrorRatio > 1.0) {
-          correctedTarget = Math.floor(preflightBudget / estimationErrorRatio);
+          correctedTarget = Math.floor(
+            convergenceBudget.preflightBudget / estimationErrorRatio,
+          );
           rlog.warn(
             {
               phase: "convergence",
               actualTokens,
               estimatedTokens: estimatedTokensAtOverflow,
               estimationErrorRatio: estimationErrorRatio.toFixed(2),
-              preflightBudget,
+              preflightBudget: convergenceBudget.preflightBudget,
               correctedTarget,
             },
             "Adjusting compaction target based on observed estimation error",
@@ -2515,11 +2662,11 @@ export async function runAgentLoopImpl(
             systemPrompt: ctx.systemPrompt,
             tools: undefined,
             compaction: emergencyConfig,
-            maxInputTokens: effectiveContextWindow.maxInputTokens,
+            maxInputTokens: resolveCurrentMaxInputTokens(),
             previousEstimatedInputTokens: estimatedTokensAtOverflow,
             force: true,
             signal: abortController.signal,
-            overrideProfile: turnOverrideProfile ?? null,
+            overrideProfile: resolveCurrentOverrideProfile() ?? null,
             nonPersistedPrefixCount:
               ctx.contextWindowManager.nonPersistedPrefixCount,
           });
@@ -2557,7 +2704,7 @@ export async function runAgentLoopImpl(
       }
 
       let convergenceAttempts = 0;
-      const maxAttempts = overflowRecovery.maxAttempts;
+      const maxAttempts = convergenceBudget.overflowRecovery.maxAttempts;
 
       while (
         state.contextTooLargeDetected &&
@@ -2586,7 +2733,7 @@ export async function runAgentLoopImpl(
           {
             providerName: estimationProviderName,
             systemPrompt: ctx.systemPrompt,
-            contextWindow: turnContextWindowConfig,
+            contextWindow: resolveCurrentContextWindowConfig(),
             targetTokens: correctedTarget,
             toolTokenBudget,
           },
@@ -2594,7 +2741,7 @@ export async function runAgentLoopImpl(
           (msgs, signal, opts) =>
             ctx.contextWindowManager.maybeCompact(msgs, signal!, {
               ...(opts ?? {}),
-              overrideProfile: turnOverrideProfile ?? null,
+              overrideProfile: resolveCurrentOverrideProfile() ?? null,
             }),
           abortController.signal,
         );
@@ -2670,7 +2817,9 @@ export async function runAgentLoopImpl(
           turnCallSite,
           loopTurnCtx,
           turnOverrideProfile,
-          effectiveContextWindow.maxInputTokens,
+          resolveCurrentMaxInputTokens(),
+          resolveCurrentOverrideProfile,
+          resolveCurrentMaxInputTokens,
         );
 
         // If the rerun still yields at checkpoint, the turn is still
@@ -2692,14 +2841,7 @@ export async function runAgentLoopImpl(
           // pre-rerun messages.
           if (updatedHistory.length > preRunHistoryLength) {
             ctx.messages = stripInjectionsForCompaction(updatedHistory);
-            try {
-              clearStrippedInjectionMetadataForConversation(ctx.conversationId);
-            } catch (err) {
-              rlog.warn(
-                { err },
-                "Failed to clear stripped-injection metadata after compaction strip (non-fatal)",
-              );
-            }
+            setConversationHistoryStrippedAt(ctx.conversationId, Date.now());
             convergenceStripped = true;
             preRepairMessages = updatedHistory;
             preRunHistoryLength = updatedHistory.length;
@@ -2748,7 +2890,7 @@ export async function runAgentLoopImpl(
                   force: true,
                   minKeepRecentUserTurns: 0,
                   targetInputTokensOverride: correctedTarget,
-                  overrideProfile: turnOverrideProfile ?? null,
+                  overrideProfile: resolveCurrentOverrideProfile() ?? null,
                 },
               },
               buildPluginTurnContext(ctx, reqId),
@@ -2831,7 +2973,9 @@ export async function runAgentLoopImpl(
             turnCallSite,
             loopTurnCtx,
             turnOverrideProfile,
-            effectiveContextWindow.maxInputTokens,
+            resolveCurrentMaxInputTokens(),
+            resolveCurrentOverrideProfile,
+            resolveCurrentMaxInputTokens,
           );
         }
         // action === "fail_gracefully" falls through to the final error below
@@ -2843,7 +2987,35 @@ export async function runAgentLoopImpl(
           new Error("context_length_exceeded"),
           { phase: "agent_loop" },
         );
+        await emitTerminalExit?.("context_too_large");
+        pendingCheckpointYield = null;
         onEvent(buildConversationErrorMessage(ctx.conversationId, classified));
+      } else if (yieldedForBudget && !abortController.signal.aborted) {
+        // The auto_compress_latest_turn rerun (action === "auto_compress_latest_turn"
+        // above) reset `contextTooLargeDetected` to false before its final
+        // `agentLoop.run`, so the context-too-large branch above won't fire
+        // even when that rerun yields at the mid-loop budget checkpoint with
+        // no further recovery layer to re-enter. Without surfacing this here,
+        // the turn terminates silently — the inspector sees `agent_loop_exit_reason
+        // = NULL` and the user sees no message at all (just a "ghost" turn).
+        //
+        // Unlike provider-error persistence at L3091 — which only fires when
+        // the loop produced NO assistant output — budget_yield_unrecovered
+        // typically yields AFTER one or more successful tool-use iterations,
+        // so `hasAssistantResponse` is true and that path would skip us. We
+        // capture the classification here so the live SSE event fires
+        // immediately, and persist a dedicated notice row below — after the
+        // pendingToolResults flush — so the transcript reads as: tool-use →
+        // tool results → "I couldn't fit the next step…" notice. Persisting
+        // earlier would orphan an assistant(tool_use) from its user(tool_result),
+        // breaking provider adjacency on replay.
+        budgetYieldClassification = budgetYieldUnrecoveredClassification();
+        onEvent(
+          buildConversationErrorMessage(
+            ctx.conversationId,
+            budgetYieldClassification,
+          ),
+        );
       }
     }
 
@@ -2919,6 +3091,52 @@ export async function runAgentLoopImpl(
       state.pendingToolResults.clear();
     }
 
+    // Persist the budget_yield_unrecovered notice now that any pending
+    // tool_results have flushed. The SSE event already fired upstream; this
+    // makes the row durable in the right position: tool-use → tool-results →
+    // notice. Doing it earlier (e.g. at the detection site) would land the
+    // assistant row between a tool_use and its tool_result and break provider
+    // adjacency on replay.
+    if (budgetYieldClassification && !abortController.signal.aborted) {
+      const yieldNoticeMessage = createAssistantMessage(
+        budgetYieldClassification.userMessage,
+      );
+      const yieldNoticeMetadata = {
+        ...provenanceFromTrustContext(ctx.trustContext),
+        userMessageChannel: capturedTurnChannelContext.userMessageChannel,
+        assistantMessageChannel:
+          capturedTurnChannelContext.assistantMessageChannel,
+        userMessageInterface: capturedTurnInterfaceContext.userMessageInterface,
+        assistantMessageInterface:
+          capturedTurnInterfaceContext.assistantMessageInterface,
+      };
+      try {
+        await runPipeline<PersistArgs, PersistResult>(
+          "persistence",
+          getMiddlewaresFor("persistence"),
+          defaultPersistenceTerminal,
+          {
+            op: "add",
+            conversationId: ctx.conversationId,
+            role: "assistant",
+            content: JSON.stringify(yieldNoticeMessage.content),
+            metadata: yieldNoticeMetadata,
+          },
+          buildPluginTurnContext(ctx, reqId),
+          DEFAULT_TIMEOUTS.persistence,
+        );
+      } catch (err) {
+        // Non-fatal — a DB hiccup must not escalate a budget-yield exit into
+        // a turn-level throw. The live SSE event was already emitted, so the
+        // user still sees the notice this turn even if the durable row missed.
+        rlog.warn(
+          { err },
+          "Failed to persist budget_yield_unrecovered notice (non-fatal)",
+        );
+      }
+      await emitTerminalExit?.("budget_yield_unrecovered");
+    }
+
     // Reconstruct history
     const newMessages = updatedHistory.slice(preRunHistoryLength).map((msg) => {
       if (msg.role !== "assistant") return msg;
@@ -3041,11 +3259,11 @@ export async function runAgentLoopImpl(
       state.exchangeLlmCallCount,
       {
         tokens: state.lastCallInputTokens,
-        maxTokens: effectiveContextWindow.maxInputTokens,
+        maxTokens: resolveCurrentMaxInputTokens(),
       },
       {
         callSite: turnCallSite,
-        overrideProfile: turnOverrideProfile ?? null,
+        overrideProfile: resolveCurrentOverrideProfile() ?? null,
       },
     );
 
@@ -3101,10 +3319,13 @@ export async function runAgentLoopImpl(
       ctx.lastAssistantAttachments = assistantAttachments;
       ctx.lastAttachmentWarnings = attachmentResult.directiveWarnings;
       syncLastAssistantMessageToDisk();
-      const clientDisplayMessageId = getClientDisplayMessageId(state);
 
       // Re-check: the user may have cancelled during attachment resolution
       if (abortController.signal.aborted) {
+        if (pendingCheckpointYield === "budget") {
+          await emitTerminalExit?.("aborted_after_checkpoint");
+          pendingCheckpointYield = null;
+        }
         ctx.emitActivityState("idle", "generation_cancelled", "global", reqId);
         ctx.traceEmitter.emit(
           "generation_cancelled",
@@ -3143,9 +3364,6 @@ export async function runAgentLoopImpl(
           ...(state.lastAssistantMessageId
             ? { messageId: state.lastAssistantMessageId }
             : {}),
-          ...(clientDisplayMessageId
-            ? { displayMessageId: clientDisplayMessageId }
-            : {}),
         });
         publishLoopMessagesChanged();
       } else {
@@ -3170,9 +3388,6 @@ export async function runAgentLoopImpl(
           ...(state.lastAssistantMessageId
             ? { messageId: state.lastAssistantMessageId }
             : {}),
-          ...(clientDisplayMessageId
-            ? { displayMessageId: clientDisplayMessageId }
-            : {}),
         });
         publishLoopMessagesChanged();
 
@@ -3246,6 +3461,10 @@ export async function runAgentLoopImpl(
       aborted: abortController.signal.aborted,
     };
     if (isUserCancellation(err, errorCtx)) {
+      if (pendingCheckpointYield === "budget") {
+        await emitTerminalExit?.("aborted_after_checkpoint");
+        pendingCheckpointYield = null;
+      }
       ctx.emitActivityState("idle", "generation_cancelled", "global", reqId);
       rlog.info("Generation cancelled by user");
       ctx.traceEmitter.emit(
@@ -3338,7 +3557,6 @@ export async function runAgentLoopImpl(
     ctx.diskPressureCleanupModeActive = false;
     ctx.preactivatedSkillIds = undefined;
     ctx.currentTurnOverrideProfile = undefined;
-    ctx.slackRuntimeContextNotice = undefined;
     // Channel command intents (e.g. Telegram /start) are single-turn metadata.
     // Clear at turn end so they never leak into subsequent unrelated messages.
     ctx.commandIntent = undefined;
@@ -3476,6 +3694,7 @@ export async function applyCompactionResult(
     result.summaryText,
     ctx.contextCompactedMessageCount,
   );
+  setConversationHistoryStrippedAt(ctx.conversationId, compactedAt);
   if (options.slackContextCompactionWatermarkTs) {
     updateConversationSlackContextWatermark(
       ctx.conversationId,