@vellumai/assistant 0.8.4 → 0.8.5

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

@@ -26,7 +26,6 @@ import type {
   TurnChannelContext,
   TurnInterfaceContext,
 } from "../channels/types.js";
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import {
   contextWindowConfigFromEffective,
   type EffectiveContextWindow,
@@ -60,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,
@@ -68,6 +66,7 @@ import {
   getLastUserTimestampBefore,
   getMessageById,
   provenanceFromTrustContext,
+  setConversationHistoryStrippedAt,
   setLastNotifiedInferenceProfile,
   updateConversationContextWindow,
   updateConversationSlackContextWatermark,
@@ -163,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,
@@ -222,10 +221,6 @@ 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";
@@ -539,6 +534,19 @@ export interface AgentLoopConversationContext {
    * 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. */
@@ -681,6 +689,13 @@ export async function runAgentLoopImpl(
   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;
@@ -709,52 +724,23 @@ export async function runAgentLoopImpl(
     options?.overrideProfile ??
     getConversationOverrideProfileFromRow(turnStartConversation);
 
+  ctx.hasExplicitProfileOverride = !!userExplicitOverride;
+
   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;
-      }
-    }
-  }
+  // 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;
 
-  // 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,
-    });
-  }
+  const turnOverrideProfile = userExplicitOverride;
 
-  // 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;
+    ctx.toolRoutedProfile;
 
   const effectiveContextWindow = resolveEffectiveContextWindow({
     llm: config.llm,
@@ -776,6 +762,7 @@ export async function runAgentLoopImpl(
   contextWindowManager.updateConfig?.(currentContextWindowConfig);
 
   let appliedOverrideProfile = turnOverrideProfile;
+  let emittedToolRoutedProfile: string | undefined;
   const refreshCurrentProfileState = (): string | undefined => {
     const currentOverrideProfile = readCurrentOverrideProfile();
     if (currentOverrideProfile !== appliedOverrideProfile) {
@@ -797,6 +784,24 @@ export async function runAgentLoopImpl(
         "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,
+      });
+    }
+
     ctx.currentTurnOverrideProfile = currentOverrideProfile;
     return currentOverrideProfile;
   };
@@ -1645,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
@@ -2307,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",
@@ -2598,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;
@@ -2850,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;
@@ -3006,6 +2990,32 @@ export async function runAgentLoopImpl(
         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,
+          ),
+        );
       }
     }
 
@@ -3081,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;
@@ -3263,7 +3319,6 @@ 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) {
@@ -3309,9 +3364,6 @@ export async function runAgentLoopImpl(
           ...(state.lastAssistantMessageId
             ? { messageId: state.lastAssistantMessageId }
             : {}),
-          ...(clientDisplayMessageId
-            ? { displayMessageId: clientDisplayMessageId }
-            : {}),
         });
         publishLoopMessagesChanged();
       } else {
@@ -3336,9 +3388,6 @@ export async function runAgentLoopImpl(
           ...(state.lastAssistantMessageId
             ? { messageId: state.lastAssistantMessageId }
             : {}),
-          ...(clientDisplayMessageId
-            ? { displayMessageId: clientDisplayMessageId }
-            : {}),
         });
         publishLoopMessagesChanged();
 
@@ -3645,6 +3694,7 @@ export async function applyCompactionResult(
     result.summaryText,
     ctx.contextCompactedMessageCount,
   );
+  setConversationHistoryStrippedAt(ctx.conversationId, compactedAt);
   if (options.slackContextCompactionWatermarkTs) {
     updateConversationSlackContextWatermark(
       ctx.conversationId,

package/src/daemon/conversation-error.ts

@@ -437,9 +437,15 @@ function classifyCore(
           errorCategory: "image_dimensions_too_large",
         };
       }
+      // Extract the provider detail after "API error (NNN): " prefix
+      const detailMatch = message.match(/API error \(\d+\):\s*(.+)/i);
+      const detail = detailMatch?.[1];
+      const suffix = detail
+        ? `: ${detail.length > 200 ? detail.slice(0, 200) + "…" : detail}`
+        : "";
       return {
         code: "PROVIDER_API",
-        userMessage: "The AI provider rejected the request.",
+        userMessage: `The AI provider rejected the request (HTTP ${error.statusCode})${suffix}`,
         retryable: true,
         errorCategory: "provider_api_error",
       };
@@ -760,6 +766,30 @@ function classifyByMessage(
   };
 }
 
+/**
+ * Classify a `budget_yield_unrecovered` terminal exit.
+ *
+ * Emitted when the agent loop's `auto_compress_latest_turn` rerun
+ * (the last layer of the overflow-recovery ladder) still yields at
+ * the mid-loop preflight budget checkpoint. The turn cannot proceed,
+ * but it is not a provider rejection — every compaction the loop ran
+ * has already been applied to the conversation, so the user's next
+ * message starts from the compacted history and typically succeeds.
+ *
+ * The returned `userMessage` is persisted as a `role="assistant"` row
+ * by the same path that already persists `PROVIDER_BILLING` etc., so
+ * the notice is durable across reload (not just a transient banner).
+ */
+export function budgetYieldUnrecoveredClassification(): ClassifiedConversationError {
+  return {
+    code: "BUDGET_YIELD_UNRECOVERED",
+    userMessage:
+      "I tried to compact this conversation but couldn't fit the next step into the model's context window. Send another message to continue — the compaction I did run has been saved, so your next turn starts from a smaller history.",
+    retryable: true,
+    errorCategory: "budget_yield_unrecovered",
+  };
+}
+
 /**
  * Build a `conversation_error` server message from a classified error.
  */

package/src/daemon/conversation-lifecycle.ts

@@ -16,7 +16,7 @@ import {
   getMessages,
   type MessageRow,
 } from "../memory/conversation-crud.js";
-import { enqueueMemoryJob } from "../memory/jobs-store.js";
+import { enqueueMemoryJob, isMemoryEnabled } from "../memory/jobs-store.js";
 import { enqueueMemoryRetrospectiveIfEnabled } from "../memory/memory-retrospective-enqueue.js";
 import { shouldExposePersonalMemory } from "../memory/v2/static-context.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
@@ -189,17 +189,18 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
     ctx.contextCompactedAt = conv?.contextCompactedAt ?? null;
   }
 
-  // `/clean` persists a timestamp; messages older than this should skip
-  // metadata rehydration and have any injection prefixes still embedded in
-  // their content stripped, so the cleaned state survives reload and forks.
-  const cleanedAt = conv?.cleanedAt ?? null;
+  // Every injection-strip event (`/clean` or compaction) updates
+  // `historyStrippedAt`. Messages older than this should skip metadata
+  // rehydration and have any injection prefixes still embedded in their
+  // content stripped, so the post-strip view survives reload and forks.
+  const historyStrippedAt = conv?.historyStrippedAt ?? null;
   const slicedDbMessages = dbMessages.slice(ctx.contextCompactedMessageCount);
-  let preCleanCount = 0;
-  if (cleanedAt != null) {
+  let preStrippedCount = 0;
+  if (historyStrippedAt != null) {
     const boundary = slicedDbMessages.findIndex(
-      (m) => m.createdAt >= cleanedAt,
+      (m) => m.createdAt >= historyStrippedAt,
     );
-    preCleanCount = boundary === -1 ? slicedDbMessages.length : boundary;
+    preStrippedCount = boundary === -1 ? slicedDbMessages.length : boundary;
   }
 
   // Mirror the injection-time gate (`shouldExposePersonalMemory` in
@@ -213,7 +214,7 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
     isTrustedActor: resolveTrustClass(ctx.trustContext) === "guardian",
   });
   const parsedMessages: Message[] = slicedDbMessages.map((m, index, arr) => {
-    const isPreClean = index < preCleanCount;
+    const isPreStripped = index < preStrippedCount;
     const role = m.role as "user" | "assistant";
     let content: ContentBlock[];
     try {
@@ -233,7 +234,7 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
 
     // Re-inject persisted injection blocks from metadata so it survives
     // conversation reloads (eviction, restart, fork).
-    if (role === "user" && m.metadata && !isPreClean) {
+    if (role === "user" && m.metadata && !isPreStripped) {
       try {
         const meta = JSON.parse(m.metadata);
         const isTail = index === arr.length - 1;
@@ -244,9 +245,12 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
         // (pkb-context 30, pkb-reminder 35, memory-v2-static 38,
         // now-md 40 — the v2 static block lands inside the memory
         // prefix, so now-md splices *after* it):
-        //   [<workspace>, <turn_context>, <memory __injected>,
-        //    <memory>\n…</memory>, <NOW.md>, <system_reminder>,
+        //   [<workspace>, <turn_context>, <memory>dynamic</memory>,
+        //    <info>v2static</info>, <NOW.md>, <system_reminder>,
         //    <knowledge_base>, ...original]
+        // The v2 static block is replayed verbatim from stored metadata,
+        // so rows may carry either `<info>…</info>` or `<memory>…</memory>`
+        // depending on when they were persisted.
         // Required so Anthropic's prefix cache keeps matching msg[0]
         // across daemon restart and conversation eviction. The tail
         // row only rehydrates `memoryInjectedBlock` — the next turn
@@ -273,11 +277,12 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
         }
 
         // The v2 static memory block (essentials/threads/recent/buffer
-        // wrapped in `<memory>…</memory>`) carries personal user memory.
-        // Trust-gated to mirror `shouldExposePersonalMemory` at injection
-        // time — untrusted-actor views must not read persisted personal
-        // memory back through metadata. Skipped on the tail row because
-        // the next turn re-injects fresh content on full-mode turns.
+        // wrapped in either `<info>…</info>` or `<memory>…</memory>`)
+        // carries personal user memory. Trust-gated to mirror
+        // `shouldExposePersonalMemory` at injection time — untrusted-actor
+        // views must not read persisted personal memory back through
+        // metadata. Skipped on the tail row because the next turn
+        // re-injects fresh content on full-mode turns.
         if (
           !isTail &&
           personalMemoryAllowed &&
@@ -336,13 +341,13 @@ export async function loadFromDb(ctx: LoadFromDbContext): Promise<void> {
   // Strip pre-clean messages only; post-clean messages keep the fresh
   // injections they were generated with.
   const messagesBeforeRepair =
-    preCleanCount === 0
+    preStrippedCount === 0
       ? parsedMessages
       : [
           ...stripInjectionsForCompaction(
-            parsedMessages.slice(0, preCleanCount),
+            parsedMessages.slice(0, preStrippedCount),
           ),
-          ...parsedMessages.slice(preCleanCount),
+          ...parsedMessages.slice(preStrippedCount),
         ];
 
   const { messages: repairedMessages, stats } =
@@ -448,7 +453,7 @@ export function disposeConversation(ctx: DisposeContext): void {
       } catch {
         // Best-effort — fall through to legacy v1 enqueue
       }
-      if (!v2Enabled) {
+      if (!v2Enabled && isMemoryEnabled()) {
         try {
           enqueueMemoryJob("graph_extract", {
             conversationId: ctx.conversationId,

package/src/daemon/conversation-runtime-assembly.ts

@@ -1734,15 +1734,16 @@ const RUNTIME_INJECTION_PREFIXES = [
   "<background_turn>",
   "<memory_context __injected>",
   "<memory_context>", // backward-compat: strip legacy blocks from pre-__injected history
-  // The static `memory-v2-static` block (opens `<memory>\n…`) IS stripped
-  // so each compaction re-injects the freshest essentials/threads/recent/
-  // buffer view, matching the `<knowledge_base>` cadence. The dynamic
-  // activation block (opens `<memory __injected>…`) is intentionally NOT
-  // stripped — `startsWith("<memory>\n")` does not match it — so per-turn
-  // memory activations persist in history. The activation pipeline dedupes
-  // via `everInjected`, and compaction handles aggregate growth, so
-  // accumulation does not cause unbounded context growth.
+  // The static `memory-v2-static` block (`<info>\n…</info>`) and the
+  // dynamic activation block (`<memory>\n…</memory>`, plus legacy
+  // `<memory __injected>…`) are both stripped so each compaction
+  // re-injects the freshest essentials/threads/recent/buffer view and
+  // re-runs the activation pipeline, matching the `<knowledge_base>`
+  // cadence. The activation pipeline dedupes via `everInjected`, and
+  // compaction handles aggregate growth, so accumulation does not cause
+  // unbounded context growth. Both wrappers may appear in persisted rows.
   "<memory>\n",
+  "<info>\n",
   "<voice_call_control>",
   "<workspace_top_level>", // backward-compat: strip legacy workspace blocks
   // NOTE: <workspace> is intentionally NOT stripped — workspace context
@@ -2037,7 +2038,7 @@ export interface RuntimeInjectionOptions {
   /**
    * Pre-rendered v2 static memory content (essentials/threads/recent/buffer
    * concatenated, header-wrapped). When non-null on full-mode turns the
-   * `memory-v2-static` injector wraps it in `<memory>` and splices it onto
+   * `memory-v2-static` injector wraps it in `<info>` and splices it onto
    * the user message; subsequent turns leave the prior block cached on its
    * original user message.
    */

package/src/daemon/conversation-tool-setup.ts

@@ -74,6 +74,11 @@ export function resolveTrustClass(
   return trustContext?.trustClass ?? "unknown";
 }
 
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import {
+  buildSwitchInferenceProfileToolDef,
+  SWITCH_INFERENCE_PROFILE_TOOL_NAME,
+} from "./switch-inference-profile-tool.js";
 import type { ToolSetupContext } from "./tool-setup-types.js";
 export type { ToolSetupContext } from "./tool-setup-types.js";
 
@@ -86,8 +91,8 @@ export type { ToolSetupContext } from "./tool-setup-types.js";
 export function buildToolDefinitions(): ToolDefinition[] {
   return [
     ...getAllToolDefinitions(),
-    ...allUiSurfaceTools.map((t) => t.getDefinition()),
-    ...coreAppProxyTools.map((t) => t.getDefinition()),
+    ...allUiSurfaceTools,
+    ...coreAppProxyTools,
   ];
 }
 
@@ -209,6 +214,33 @@ export function createToolExecutor(
       },
     };
 
+    // Intercept switch_inference_profile: daemon-internal tool that lets the
+    // model self-select a different inference profile mid-turn. No permission
+    // checks — this is a control-flow signal, not a user-visible tool.
+    if (executionName === SWITCH_INFERENCE_PROFILE_TOOL_NAME) {
+      const profile = typeof input.profile === "string" ? input.profile : "";
+      const config = getConfig();
+      const profileEntry = config.llm.profiles?.[profile];
+      if (!profileEntry) {
+        return {
+          content: `Profile "${profile}" not found. Available profiles: ${Object.keys(config.llm.profiles ?? {}).join(", ")}`,
+          isError: true,
+        };
+      }
+      if (profileEntry.status === "disabled") {
+        return {
+          content: `Profile "${profile}" is disabled.`,
+          isError: true,
+        };
+      }
+      ctx.toolRoutedProfile = profile;
+      const label = profileEntry.label ?? profile;
+      return {
+        content: `Switched to ${label} profile. Continue with your response.`,
+        isError: false,
+      };
+    }
+
     // Intercept skill_execute: extract the real tool name and input, then
     // route through the full executor pipeline so the underlying tool's
     // risk level, permission checks, hooks, and lifecycle events all fire
@@ -326,6 +358,14 @@ export interface SkillProjectionContext {
    * host tools into the LLM tool definitions.
    */
   readonly transportInterface?: InterfaceId;
+  /** Per-turn override profile, read by the switch_inference_profile tool injection. */
+  currentTurnOverrideProfile?: 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;
 }
 
 // ── Conditional tool sets ────────────────────────────────────────────
@@ -613,6 +653,26 @@ export function createResolveToolsCallback(
     }
 
     ctx.allowedToolNames = turnAllowed;
-    return injectActivityField(allBaseDefs, ACTIVITY_SKIP_SET);
+    const baseDefs = injectActivityField(allBaseDefs, ACTIVITY_SKIP_SET);
+
+    const config = getConfig();
+    if (
+      isAssistantFeatureFlagEnabled("query-complexity-routing", config) &&
+      config.llm &&
+      !ctx.hasExplicitProfileOverride
+    ) {
+      const currentProfile =
+        ctx.currentTurnOverrideProfile ?? config.llm.activeProfile;
+      const toolDef = buildSwitchInferenceProfileToolDef(
+        config.llm.profiles ?? {},
+        currentProfile,
+      );
+      if (toolDef) {
+        turnAllowed.add(SWITCH_INFERENCE_PROFILE_TOOL_NAME);
+        return [...baseDefs, toolDef];
+      }
+    }
+
+    return baseDefs;
   };
 }

package/src/daemon/conversation-usage.ts

@@ -3,6 +3,7 @@ import { updateConversationUsage } from "../memory/conversation-crud.js";
 import { recordUsageEvent } from "../memory/llm-usage-store.js";
 import type { UsageActor } from "../usage/actors.js";
 import { resolveUsageAttribution } from "../usage/attribution.js";
+import { extractRawUsage } from "../usage/pricing.js";
 import type {
   AnthropicCacheCreationTokenDetails,
   PricingResult,
@@ -235,6 +236,7 @@ export function recordUsage(
         outputTokens,
         cacheCreationInputTokens: normalizedCacheCreationInputTokens,
         cacheReadInputTokens: normalizedCacheReadInputTokens,
+        rawUsage: extractRawUsage(rawResponse),
         conversationId: ctx.conversationId,
         runId: null,
         requestId,