@vellumai/assistant 0.8.2 → 0.8.4

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";
@@ -25,11 +26,16 @@ import type {
   TurnChannelContext,
   TurnInterfaceContext,
 } from "../channels/types.js";
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.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";
@@ -62,6 +68,7 @@ import {
   getLastUserTimestampBefore,
   getMessageById,
   provenanceFromTrustContext,
+  setLastNotifiedInferenceProfile,
   updateConversationContextWindow,
   updateConversationSlackContextWatermark,
 } from "../memory/conversation-crud.js";
@@ -71,7 +78,9 @@ import {
   isReplaceableTitle,
   queueRegenerateConversationTitle,
 } from "../memory/conversation-title-service.js";
+import { isBackgroundConversationType } from "../memory/conversation-types.js";
 import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
+import { backfillMessageIdOnLogs } from "../memory/llm-request-log-store.js";
 import { recordMemoryRecallLog } from "../memory/memory-recall-log-store.js";
 import { enqueueMemoryRetrospectiveOnCompaction } from "../memory/memory-retrospective-enqueue.js";
 import { PKB_WORKSPACE_SCOPE } from "../memory/pkb/types.js";
@@ -109,6 +118,7 @@ import type {
   MemoryResult,
   OverflowReduceArgs,
   OverflowReduceResult,
+  PersistAddResult,
   PersistArgs,
   PersistResult,
   TurnContext as PluginTurnContext,
@@ -212,6 +222,10 @@ import {
   SYNC_TAGS,
 } from "./message-types/sync.js";
 import { parseActualTokensFromError } from "./parse-actual-tokens-from-error.js";
+import {
+  classifyQueryComplexity,
+  complexityTierToProfileKey,
+} from "./query-complexity-router.js";
 import type { TraceEmitter } from "./trace-emitter.js";
 import type { TrustContext } from "./trust-context.js";
 import { stripHistoricalWebSearchResults } from "./web-search-history.js";
@@ -518,12 +532,11 @@ 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;
   commandIntent?: { type: string; payload?: string; languageCode?: string };
@@ -533,7 +546,6 @@ export interface AgentLoopConversationContext {
   assistantId?: string;
   voiceCallControlPrompt?: string;
   transportHints?: string[];
-  slackRuntimeContextNotice?: string;
   clientTimezone?: string;
 
   readonly coreToolNames: Set<string>;
@@ -667,6 +679,11 @@ export async function runAgentLoopImpl(
     requestId: reqId,
   });
   let yieldedForHandoff = false;
+  let yieldedForBudget = false;
+  let pendingCheckpointYield: "budget" | "handoff" | 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
@@ -688,31 +705,134 @@ 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);
 
   const config = getConfig();
+
+  // Query complexity routing: when no explicit user override is set and the
+  // feature flag is enabled, classify the query and route to the appropriate
+  // profile for this turn. The override is ephemeral (not persisted).
+  let turnOverrideProfile = userExplicitOverride;
+  if (
+    !userExplicitOverride &&
+    turnCallSite === "mainAgent" &&
+    isAssistantFeatureFlagEnabled("query-complexity-routing", config)
+  ) {
+    const tier = await classifyQueryComplexity(content);
+    if (tier && tier !== "balanced") {
+      const routedProfile = complexityTierToProfileKey(tier);
+      if (config.llm.profiles?.[routedProfile]) {
+        turnOverrideProfile = routedProfile;
+      }
+    }
+  }
+
+  // Notify clients when the auto-router selected a non-default profile.
+  if (turnOverrideProfile && turnOverrideProfile !== userExplicitOverride) {
+    const profileEntry = config.llm.profiles?.[turnOverrideProfile];
+    const label = profileEntry?.label ?? turnOverrideProfile;
+    broadcastMessage({
+      type: "turn_profile_auto_routed",
+      conversationId: ctx.conversationId,
+      profile: turnOverrideProfile,
+      profileLabel: label,
+    });
+  }
+
+  // Only use the complexity-routed profile as a fallback — not the initial
+  // explicit override. If a mid-turn session expiry clears the conversation
+  // override, the old behavior (return undefined → revert to workspace
+  // defaults) must be preserved for non-routed turns.
+  const complexityRoutedProfile =
+    turnOverrideProfile !== userExplicitOverride
+      ? turnOverrideProfile
+      : undefined;
+  const readCurrentOverrideProfile = (): string | undefined =>
+    options?.overrideProfile ??
+    getConversationOverrideProfileFromRow(
+      getConversation(ctx.conversationId),
+    ) ??
+    complexityRoutedProfile;
+
   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;
+  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",
+      );
     }
-  ).updateConfig?.(turnContextWindowConfig);
+    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)),
+    };
+  };
 
-  // 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).
+  // 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
@@ -1026,6 +1146,7 @@ export async function runAgentLoopImpl(
           {
             message: result.messages[0]!,
             sourceChannelTs: null,
+            tagLineProvenance: "none",
           },
           ...retainedRenderedMessages,
         ],
@@ -1085,7 +1206,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>
@@ -1450,6 +1571,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,
@@ -1458,6 +1599,7 @@ export async function runAgentLoopImpl(
       clientTimezone: timezoneContext.clientTimezone,
       detectedTimezone: timezoneContext.detectedTimezone,
       timeSinceLastMessage,
+      modelProfile: modelProfileStr,
     };
     const unifiedTurnContextStr = buildUnifiedTurnContextBlock(
       isGuardian
@@ -1614,8 +1756,10 @@ export async function runAgentLoopImpl(
       nowScratchpad,
       voiceCallControlPrompt: ctx.voiceCallControlPrompt ?? null,
       transportHints: ctx.transportHints ?? null,
-      slackRuntimeContextNotice: ctx.slackRuntimeContextNotice ?? null,
       isNonInteractive: !isInteractiveResolved,
+      isBackgroundConversation: isBackgroundConversationType(
+        turnStartConversation?.conversationType,
+      ),
       subagentStatusBlock,
       slackChronologicalMessages,
       slackActiveThreadFocusBlock,
@@ -1698,15 +1842,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);
@@ -1783,10 +1921,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
@@ -1816,7 +1954,7 @@ export async function runAgentLoopImpl(
                 signal,
                 options: {
                   ...(opts ?? {}),
-                  overrideProfile: turnOverrideProfile ?? null,
+                  overrideProfile: resolveCurrentOverrideProfile() ?? null,
                 },
               },
               buildPluginTurnContext(ctx, reqId),
@@ -2070,8 +2208,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,
@@ -2080,6 +2219,7 @@ export async function runAgentLoopImpl(
 
       if (ctx.canHandoffAtCheckpoint()) {
         yieldedForHandoff = true;
+        pendingCheckpointYield = "handoff";
         return "yield";
       }
 
@@ -2087,7 +2227,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(
@@ -2095,6 +2236,7 @@ export async function runAgentLoopImpl(
             "Token estimate approaching budget — yielding for compaction",
           );
           yieldedForBudget = true;
+          pendingCheckpointYield = "budget";
           return "yield";
         }
       }
@@ -2123,7 +2265,9 @@ export async function runAgentLoopImpl(
       turnCallSite,
       loopTurnCtx,
       turnOverrideProfile,
-      effectiveContextWindow.maxInputTokens,
+      resolveCurrentMaxInputTokens(),
+      resolveCurrentOverrideProfile,
+      resolveCurrentMaxInputTokens,
     );
 
     rlog.info(
@@ -2131,6 +2275,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
@@ -2140,12 +2289,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" },
@@ -2187,10 +2338,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),
@@ -2276,7 +2428,9 @@ export async function runAgentLoopImpl(
         turnCallSite,
         loopTurnCtx,
         turnOverrideProfile,
-        effectiveContextWindow.maxInputTokens,
+        resolveCurrentMaxInputTokens(),
+        resolveCurrentOverrideProfile,
+        resolveCurrentMaxInputTokens,
       );
     }
 
@@ -2290,7 +2444,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",
       );
@@ -2333,7 +2488,9 @@ export async function runAgentLoopImpl(
         turnCallSite,
         loopTurnCtx,
         turnOverrideProfile,
-        effectiveContextWindow.maxInputTokens,
+        resolveCurrentMaxInputTokens(),
+        resolveCurrentOverrideProfile,
+        resolveCurrentMaxInputTokens,
       );
 
       if (state.orderingErrorDetected) {
@@ -2402,7 +2559,9 @@ export async function runAgentLoopImpl(
         turnCallSite,
         loopTurnCtx,
         turnOverrideProfile,
-        effectiveContextWindow.maxInputTokens,
+        resolveCurrentMaxInputTokens(),
+        resolveCurrentOverrideProfile,
+        resolveCurrentMaxInputTokens,
       );
       if (state.imageTooLargeDetected) {
         rlog.error(
@@ -2473,18 +2632,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",
@@ -2509,11 +2671,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,
           });
@@ -2551,7 +2713,7 @@ export async function runAgentLoopImpl(
       }
 
       let convergenceAttempts = 0;
-      const maxAttempts = overflowRecovery.maxAttempts;
+      const maxAttempts = convergenceBudget.overflowRecovery.maxAttempts;
 
       while (
         state.contextTooLargeDetected &&
@@ -2580,7 +2742,7 @@ export async function runAgentLoopImpl(
           {
             providerName: estimationProviderName,
             systemPrompt: ctx.systemPrompt,
-            contextWindow: turnContextWindowConfig,
+            contextWindow: resolveCurrentContextWindowConfig(),
             targetTokens: correctedTarget,
             toolTokenBudget,
           },
@@ -2588,7 +2750,7 @@ export async function runAgentLoopImpl(
           (msgs, signal, opts) =>
             ctx.contextWindowManager.maybeCompact(msgs, signal!, {
               ...(opts ?? {}),
-              overrideProfile: turnOverrideProfile ?? null,
+              overrideProfile: resolveCurrentOverrideProfile() ?? null,
             }),
           abortController.signal,
         );
@@ -2664,7 +2826,9 @@ export async function runAgentLoopImpl(
           turnCallSite,
           loopTurnCtx,
           turnOverrideProfile,
-          effectiveContextWindow.maxInputTokens,
+          resolveCurrentMaxInputTokens(),
+          resolveCurrentOverrideProfile,
+          resolveCurrentMaxInputTokens,
         );
 
         // If the rerun still yields at checkpoint, the turn is still
@@ -2742,7 +2906,7 @@ export async function runAgentLoopImpl(
                   force: true,
                   minKeepRecentUserTurns: 0,
                   targetInputTokensOverride: correctedTarget,
-                  overrideProfile: turnOverrideProfile ?? null,
+                  overrideProfile: resolveCurrentOverrideProfile() ?? null,
                 },
               },
               buildPluginTurnContext(ctx, reqId),
@@ -2825,7 +2989,9 @@ export async function runAgentLoopImpl(
             turnCallSite,
             loopTurnCtx,
             turnOverrideProfile,
-            effectiveContextWindow.maxInputTokens,
+            resolveCurrentMaxInputTokens(),
+            resolveCurrentOverrideProfile,
+            resolveCurrentMaxInputTokens,
           );
         }
         // action === "fail_gracefully" falls through to the final error below
@@ -2837,6 +3003,8 @@ export async function runAgentLoopImpl(
           new Error("context_length_exceeded"),
           { phase: "agent_loop" },
         );
+        await emitTerminalExit?.("context_too_large");
+        pendingCheckpointYield = null;
         onEvent(buildConversationErrorMessage(ctx.conversationId, classified));
       }
     }
@@ -2942,7 +3110,7 @@ export async function runAgentLoopImpl(
       const errorAssistantMessage = createAssistantMessage(
         state.providerErrorUserMessage,
       );
-      await runPipeline<PersistArgs, PersistResult>(
+      const errorPersistResult = (await runPipeline<PersistArgs, PersistResult>(
         "persistence",
         getMiddlewaresFor("persistence"),
         defaultPersistenceTerminal,
@@ -2955,9 +3123,30 @@ export async function runAgentLoopImpl(
         },
         buildPluginTurnContext(ctx, reqId),
         DEFAULT_TIMEOUTS.persistence,
-      );
+      )) as PersistAddResult;
       persistedErrorAssistantMessage = true;
       newMessages.push(errorAssistantMessage);
+      // Pipe the just-assigned message id into any orphaned LLM request log
+      // row(s) for this turn. The success path links rows via
+      // `handleMessageComplete` -> `backfillMessageIdOnLogs`, but provider-
+      // failure turns never fire `message_complete` (the synthetic assistant
+      // message is persisted directly above), so without this call the rows
+      // from `handleProviderError` stay with `message_id IS NULL` and a
+      // later turn's backfill sweep would wrong-attach them to that turn's
+      // assistant message. Scope is per-conversation, so concurrent runs on
+      // other conversations cannot collide. Non-fatal — a DB hiccup must
+      // not escalate a provider rejection into a turn-level throw.
+      try {
+        backfillMessageIdOnLogs(
+          ctx.conversationId,
+          errorPersistResult.message.id,
+        );
+      } catch (err) {
+        rlog.warn(
+          { err },
+          "Failed to backfill message_id on provider-error LLM request logs (non-fatal)",
+        );
+      }
       // Do NOT send assistant_text_delta here — handleProviderError already
       // emitted a conversation_error event for this same error text, and the
       // client renders it as an InlineChatErrorAlert. Sending a text delta
@@ -3014,11 +3203,11 @@ export async function runAgentLoopImpl(
       state.exchangeLlmCallCount,
       {
         tokens: state.lastCallInputTokens,
-        maxTokens: effectiveContextWindow.maxInputTokens,
+        maxTokens: resolveCurrentMaxInputTokens(),
       },
       {
         callSite: turnCallSite,
-        overrideProfile: turnOverrideProfile ?? null,
+        overrideProfile: resolveCurrentOverrideProfile() ?? null,
       },
     );
 
@@ -3078,6 +3267,10 @@ export async function runAgentLoopImpl(
 
       // 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",
@@ -3219,6 +3412,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(
@@ -3311,7 +3508,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;