@vellumai/assistant 0.8.4 → 0.8.6

package/src/daemon/conversation-skill-tools.ts

@@ -23,6 +23,7 @@ import { parseToolManifestFile } from "../skills/tool-manifest.js";
 import { computeSkillVersionHash } from "../skills/version-hash.js";
 import {
   getTool,
+  getToolOwner,
   registerSkillTools,
   unregisterSkillTools,
 } from "../tools/registry.js";
@@ -313,7 +314,6 @@ export function projectSkillTools(
     // Create runtime Tool objects
     const tools = createSkillToolsFromManifest(
       manifest.tools,
-      skillId,
       skill.directoryPath,
       currentHash,
       skill.bundled,
@@ -324,7 +324,7 @@ export function projectSkillTools(
       const prevHash = prevActive.get(skillId);
       if (prevHash === undefined) {
         // Newly active skill — register for the first time
-        accepted = registerSkillTools(tools);
+        accepted = registerSkillTools(skillId, tools);
       } else if (prevHash !== currentHash) {
         // Hash changed — unregister stale tools, then re-register with new definitions
         log.info(
@@ -334,7 +334,7 @@ export function projectSkillTools(
         unregisterSkillTools(skillId);
         alreadyUnregistered.add(skillId);
         try {
-          accepted = registerSkillTools(tools);
+          accepted = registerSkillTools(skillId, tools);
         } catch (err) {
           log.error(
             { err, skillId },
@@ -344,33 +344,17 @@ export function projectSkillTools(
           continue;
         }
       } else {
-        // Hash unchanged — check if the bundled status drifted (e.g. a
-        // managed skill override was added/removed with identical content).
-        // Re-register so the ownerSkillBundled flag stays accurate.
-        const existing = getTool(tools[0].name);
-        if (
-          existing &&
-          existing.ownerSkillBundled !== (skill.bundled ?? undefined)
-        ) {
-          log.info(
-            { skillId, bundled: skill.bundled },
-            "Skill bundled status changed, re-registering tools",
-          );
-          unregisterSkillTools(skillId);
-          accepted = registerSkillTools(tools);
-        } else {
-          // Filter to only tools that are actually registered for this skill.
-          // Some tools may have been skipped during initial registration due
-          // to core-name collisions — don't let them leak back in.
-          accepted = tools.filter((t) => {
-            const reg = getTool(t.name);
-            return (
-              reg !== undefined &&
-              reg.origin === "skill" &&
-              reg.ownerSkillId === skillId
-            );
-          });
-        }
+        // Hash unchanged — filter to only tools that are actually registered
+        // for this skill. Some tools may have been skipped during initial
+        // registration due to core-name collisions — don't let them leak
+        // back in. Bundled-status drift no longer requires re-registration
+        // because the permission checker derives bundled state from the
+        // live catalog instead of a stamped tool field.
+        accepted = tools.filter((t) => {
+          if (getTool(t.name) === undefined) return false;
+          const owner = getToolOwner(t.name);
+          return owner?.kind === "skill" && owner.id === skillId;
+        });
       }
 
       successfulEntries.set(skillId, currentHash);

package/src/daemon/conversation-surfaces.ts

@@ -28,6 +28,7 @@ import { getLogger } from "../util/logger.js";
 import { isPlainObject } from "../util/object.js";
 import { buildConversationErrorMessage } from "./conversation-error.js";
 import { launchConversation } from "./conversation-launch.js";
+import type { EnqueueMessageOptions } from "./conversation-messaging.js";
 import type { HostAppControlProxy } from "./host-app-control-proxy.js";
 import type { HostCuProxy } from "./host-cu-proxy.js";
 import type {
@@ -45,7 +46,6 @@ import type {
   UiSurfaceShow,
 } from "./message-protocol.js";
 import { INTERACTIVE_SURFACE_TYPES } from "./message-protocol.js";
-import type { ConversationTransportMetadata } from "./message-types/conversations.js";
 import type { HostAppControlInput } from "./message-types/host-app-control.js";
 import type { UserMessageAttachment } from "./message-types/shared.js";
 import type { TrustContext } from "./trust-context.js";
@@ -518,18 +518,11 @@ export interface SurfaceConversationContext {
   /** True when no interactive client is connected (headless / channel-only). */
   readonly hasNoClient?: boolean;
   isProcessing(): boolean;
-  enqueueMessage(
-    content: string,
-    attachments: UserMessageAttachment[],
-    onEvent?: (msg: ServerMessage) => void,
-    requestId?: string,
-    activeSurfaceId?: string,
-    currentPage?: string,
-    metadata?: Record<string, unknown>,
-    options?: { isInteractive?: boolean },
-    displayContent?: string,
-    transport?: ConversationTransportMetadata,
-  ): { queued: boolean; requestId: string; rejected?: boolean };
+  enqueueMessage(options: EnqueueMessageOptions): {
+    queued: boolean;
+    requestId: string;
+    rejected?: boolean;
+  };
   getQueueDepth(): number;
   processMessage(
     content: string,
@@ -1142,6 +1135,34 @@ export type SurfaceActionResult =
   | { accepted: false; error: string }
   | void;
 
+const SURFACE_COMPLETE_FLAG = "_completeSurface";
+const SURFACE_COMPLETION_SUMMARY_FIELD = "_completionSummary";
+
+function getRequestedSurfaceCompletionSummary(
+  data?: Record<string, unknown>,
+): string | null {
+  if (data?.[SURFACE_COMPLETE_FLAG] !== true) return null;
+  const summary =
+    typeof data[SURFACE_COMPLETION_SUMMARY_FIELD] === "string"
+      ? data[SURFACE_COMPLETION_SUMMARY_FIELD].trim()
+      : "";
+  return summary || "Completed";
+}
+
+function completeSurfaceFromAction(
+  ctx: SurfaceConversationContext,
+  surfaceId: string,
+  summary: string,
+): void {
+  broadcastMessage({
+    type: "ui_surface_complete",
+    conversationId: ctx.conversationId,
+    surfaceId,
+    summary,
+  });
+  markSurfaceCompleted(ctx, surfaceId, summary);
+}
+
 export async function handleSurfaceAction(
   ctx: SurfaceConversationContext,
   surfaceId: string,
@@ -1318,9 +1339,16 @@ export async function handleSurfaceAction(
     }
 
     // Determine message content from the action.
+    const stored = ctx.surfaceState.get(surfaceId);
+    const actionDef = stored?.actions?.find((a) => a.id === actionId);
+    const mergedData: Record<string, unknown> | undefined =
+      actionDef?.data || data ? { ...actionDef?.data, ...data } : undefined;
+
     const isRelay = actionId === "relay_prompt" || actionId === "agent_prompt";
     const prompt =
-      isRelay && typeof data?.prompt === "string" ? data.prompt.trim() : "";
+      isRelay && typeof mergedData?.prompt === "string"
+        ? mergedData.prompt.trim()
+        : "";
 
     // Read accumulated state once — used by both relay and custom action paths.
     const accState = ctx.accumulatedSurfaceState.get(surfaceId);
@@ -1329,9 +1357,9 @@ export async function handleSurfaceAction(
     // Extract file attachments from action data so they are sent as proper
     // image/file content blocks instead of dumping base64 into the text.
     let attachments: UserMessageAttachment[] = [];
-    let actionDataForText = data;
-    if (data && Array.isArray(data.files)) {
-      const files = data.files as Array<Record<string, unknown>>;
+    let actionDataForText = mergedData;
+    if (mergedData && Array.isArray(mergedData.files)) {
+      const files = mergedData.files as Array<Record<string, unknown>>;
       attachments = files
         .filter(
           (f) =>
@@ -1351,7 +1379,7 @@ export async function handleSurfaceAction(
       // attachments — otherwise preserve the original data so the model still
       // sees the files field (e.g. IDs/paths from dynamic app actions).
       if (attachments.length > 0) {
-        const { files: _files, ...rest } = data;
+        const { files: _files, ...rest } = mergedData;
         actionDataForText = Object.keys(rest).length > 0 ? rest : undefined;
       }
     }
@@ -1414,23 +1442,26 @@ export async function handleSurfaceAction(
       attributes: { source: "surface_action", surfaceId, actionId },
     });
 
-    const result = ctx.enqueueMessage(
+    const result = ctx.enqueueMessage({
       content,
       attachments,
       onEvent,
       requestId,
-      surfaceId,
-      undefined,
-      undefined,
-      undefined,
+      activeSurfaceId: surfaceId,
       displayContent,
-    );
+    });
 
     if (result.rejected) {
       ctx.surfaceActionRequestIds.delete(requestId);
       return;
     }
 
+    const requestedCompletionSummary =
+      getRequestedSurfaceCompletionSummary(mergedData);
+    if (requestedCompletionSummary) {
+      completeSurfaceFromAction(ctx, surfaceId, requestedCompletionSummary);
+    }
+
     // One-shot: clear accumulated state now that the message has been accepted.
     // Deferred until after rejection check so state is preserved for retry on rejection.
     if (hasAccState) {
@@ -1653,22 +1684,22 @@ export async function handleSurfaceAction(
     "Surface action follow-up: preparing to send message to model",
   );
 
-  const result = ctx.enqueueMessage(
+  const result = ctx.enqueueMessage({
     content,
-    pendingAttachments,
+    attachments: pendingAttachments,
     onEvent,
     requestId,
-    surfaceId,
-    undefined,
-    undefined,
-    undefined,
+    activeSurfaceId: surfaceId,
     displayContent,
-  );
+  });
   if (result.rejected) {
     ctx.surfaceActionRequestIds.delete(requestId);
     return;
   }
 
+  const requestedCompletionSummary =
+    getRequestedSurfaceCompletionSummary(mergedData);
+
   // One-shot interactive surfaces — auto-complete now that the message has
   // been accepted. Deferred until after rejection check so the surface stays
   // active and retryable if the queue was full.
@@ -1678,15 +1709,19 @@ export async function handleSurfaceAction(
     "file_upload",
     "task_preferences",
   ];
-  if (ONE_SHOT_SURFACE_TYPES.includes(pending.surfaceType)) {
+  if (
+    requestedCompletionSummary ||
+    ONE_SHOT_SURFACE_TYPES.includes(pending.surfaceType)
+  ) {
+    const completionSummary = requestedCompletionSummary ?? summary;
     broadcastMessage({
       type: "ui_surface_complete",
       conversationId: ctx.conversationId,
       surfaceId,
-      summary,
+      summary: completionSummary,
       submittedData: mergedDataForText,
     });
-    markSurfaceCompleted(ctx, surfaceId, summary);
+    markSurfaceCompleted(ctx, surfaceId, completionSummary);
   }
 
   // One-shot: clear accumulated state now that the message has been accepted.

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

@@ -20,18 +20,14 @@ import type { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { Message, ToolDefinition } from "../providers/types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
-import { coreAppProxyTools } from "../tools/apps/definitions.js";
 import { registerConversationSender } from "../tools/browser/browser-screencast.js";
 import type { ToolExecutor } from "../tools/executor.js";
-import {
-  getAllToolDefinitions,
-  getMcpToolDefinitions,
-} from "../tools/registry.js";
+import { getMcpToolDefinitions } from "../tools/registry.js";
 import {
   ACTIVITY_SKIP_SET,
   injectActivityField,
 } from "../tools/schema-transforms.js";
-import { resolveToolNameAlias } from "../tools/tool-name-aliases.js";
+import { resolveToolInvocationAlias } from "../tools/tool-name-aliases.js";
 import {
   isDiskPressureCleanupToolName,
   type ProxyApprovalCallback,
@@ -40,7 +36,6 @@ import {
   type ToolExecutionResult,
   type ToolLifecycleEventHandler,
 } from "../tools/types.js";
-import { allUiSurfaceTools } from "../tools/ui-surface/definitions.js";
 import { getLogger } from "../util/logger.js";
 import {
   projectSkillTools,
@@ -74,23 +69,15 @@ export function resolveTrustClass(
   return trustContext?.trustClass ?? "unknown";
 }
 
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import { AUTO_PROFILE_KEY } from "../config/seed-inference-profiles.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";
 
-// ── buildToolDefinitions ─────────────────────────────────────────────
-
-/**
- * Collect all tool definitions for the agent loop: built-in tools,
- * UI surface proxy tools, and app proxy tools.
- */
-export function buildToolDefinitions(): ToolDefinition[] {
-  return [
-    ...getAllToolDefinitions(),
-    ...allUiSurfaceTools.map((t) => t.getDefinition()),
-    ...coreAppProxyTools.map((t) => t.getDefinition()),
-  ];
-}
-
 // ── createToolExecutor ───────────────────────────────────────────────
 
 /**
@@ -124,10 +111,11 @@ export function createToolExecutor(
     toolUseId?: string,
     turnContext?: import("../plugins/types.js").TurnContext,
   ) => {
-    const executionName = resolveToolNameAlias(name, ctx.allowedToolNames);
+    const { name: executionName, input: executionInput } =
+      resolveToolInvocationAlias(name, input, ctx.allowedToolNames);
 
-    if (isDoordashCommand(executionName, input)) {
-      markDoordashStepInProgress(ctx, input);
+    if (isDoordashCommand(executionName, executionInput)) {
+      markDoordashStepInProgress(ctx, executionInput);
     }
 
     // Build the context object shared by both the skill_execute interception
@@ -209,20 +197,54 @@ 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 executionInput.profile === "string"
+          ? executionInput.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
     // with the real tool name.
     if (executionName === "skill_execute") {
-      const rawToolName = typeof input.tool === "string" ? input.tool : "";
-      const toolName = resolveToolNameAlias(rawToolName, ctx.allowedToolNames);
+      const rawToolName =
+        typeof executionInput.tool === "string" ? executionInput.tool : "";
       const rawToolInput =
-        input.input != null && typeof input.input === "object"
-          ? (input.input as Record<string, unknown>)
+        executionInput.input != null && typeof executionInput.input === "object"
+          ? (executionInput.input as Record<string, unknown>)
           : {};
 
       // Clone to avoid mutating shared input objects
-      const toolInput = { ...rawToolInput };
+      const { name: toolName, input: toolInput } = resolveToolInvocationAlias(
+        rawToolName,
+        { ...rawToolInput },
+        ctx.allowedToolNames,
+      );
 
       if (!toolName) {
         return {
@@ -249,7 +271,7 @@ export function createToolExecutor(
 
     const result = await executor.execute(
       executionName,
-      input,
+      executionInput,
       toolContext,
       turnContext,
     );
@@ -257,7 +279,7 @@ export function createToolExecutor(
       ctx.approvedViaPromptThisTurn = true;
     }
 
-    runPostExecutionSideEffects(executionName, input, result, { ctx });
+    runPostExecutionSideEffects(executionName, executionInput, result, { ctx });
 
     return result;
   };
@@ -326,6 +348,8 @@ 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;
 }
 
 // ── Conditional tool sets ────────────────────────────────────────────
@@ -613,6 +637,27 @@ 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
+    ) {
+      const effectiveProfile =
+        ctx.currentTurnOverrideProfile ?? config.llm.activeProfile;
+      if (effectiveProfile === AUTO_PROFILE_KEY) {
+        const toolDef = buildSwitchInferenceProfileToolDef(
+          config.llm.profiles ?? {},
+          effectiveProfile,
+        );
+        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,

package/src/daemon/conversation.ts

@@ -53,14 +53,13 @@ import {
   getConversation,
   getConversationOriginChannel,
   getConversationOverrideProfileFromRow,
-  setConversationCleanedAt,
+  setConversationHistoryStrippedAt,
 } from "../memory/conversation-crud.js";
 import { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import { shouldExposePersonalMemory } from "../memory/v2/static-context.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { UserDecision } from "../permissions/types.js";
-import { resolvePersonaContext } from "../prompts/persona-resolver.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import type { Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
@@ -69,6 +68,7 @@ import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import type { AuthContext } from "../runtime/auth/types.js";
 import type { InteractiveUiResult } from "../runtime/interactive-ui.js";
 import { ToolExecutor } from "../tools/executor.js";
+import { getAllToolDefinitions } from "../tools/registry.js";
 import type { ToolLifecycleEvent } from "../tools/types.js";
 import type { OnboardingContext } from "../types/onboarding-context.js";
 import type { AbortReason } from "../util/abort-reasons.js";
@@ -86,7 +86,11 @@ import {
   disposeConversation,
   loadFromDb as loadFromDbImpl,
 } from "./conversation-lifecycle.js";
-import type { RedirectToSecurePromptOptions } from "./conversation-messaging.js";
+import type {
+  EnqueueMessageOptions,
+  PersistMessageOptions,
+  RedirectToSecurePromptOptions,
+} from "./conversation-messaging.js";
 import {
   enqueueMessage as enqueueMessageImpl,
   persistUserMessage as persistUserMessageImpl,
@@ -117,7 +121,6 @@ import {
 } from "./conversation-surfaces.js";
 import type { ToolSetupContext } from "./conversation-tool-setup.js";
 import {
-  buildToolDefinitions,
   createResolveToolsCallback,
   createToolExecutor,
   resolveTrustClass,
@@ -327,7 +330,12 @@ export class Conversation {
     surfaceType: SurfaceType;
     title?: string;
     data: SurfaceData;
-    actions?: Array<{ id: string; label: string; style?: string }>;
+    actions?: Array<{
+      id: string;
+      label: string;
+      style?: string;
+      data?: Record<string, unknown>;
+    }>;
     display?: string;
     persistent?: boolean;
   }> = [];
@@ -452,7 +460,7 @@ export class Conversation {
       return publishToolDomainEvent(event);
     };
 
-    const toolDefs = buildToolDefinitions();
+    const toolDefs = getAllToolDefinitions();
     this.coreToolNames = new Set(toolDefs.map((d) => d.name));
     const toolExecutor = createToolExecutor(
       this.executor,
@@ -492,19 +500,12 @@ export class Conversation {
       const resolved: ResolvedSystemPrompt = {
         systemPrompt: this.hasSystemPromptOverride
           ? systemPrompt
-          : (() => {
-              const persona = resolvePersonaContext(
-                this.currentTurnTrustContext,
-                this.currentTurnChannelCapabilities,
-              );
-              return buildSystemPrompt({
-                hasNoClient: this.hasNoClient,
-                userPersona: persona.userPersona,
-                channelPersona: persona.channelPersona,
-                userSlug: persona.userSlug,
-                onboardingContext: this.getOnboardingContext(),
-              });
-            })(),
+          : buildSystemPrompt({
+              hasNoClient: this.hasNoClient,
+              trustContext: this.currentTurnTrustContext,
+              channelCapabilities: this.currentTurnChannelCapabilities,
+              onboardingContext: this.getOnboardingContext(),
+            }),
       };
       if (configuredMaxTokens !== undefined) {
         resolved.maxTokens = configuredMaxTokens;
@@ -583,20 +584,13 @@ export class Conversation {
 
     const systemPrompt = this.hasSystemPromptOverride
       ? this.systemPrompt
-      : (() => {
-          const persona = resolvePersonaContext(
-            this.currentTurnTrustContext,
-            this.currentTurnChannelCapabilities,
-          );
-          return buildSystemPrompt({
-            hasNoClient: this.hasNoClient,
-            userPersona: persona.userPersona,
-            channelPersona: persona.channelPersona,
-            userSlug: persona.userSlug,
-            onboardingContext: this.getOnboardingContext(),
-          });
-        })();
-    const tools = buildToolDefinitions();
+      : buildSystemPrompt({
+          hasNoClient: this.hasNoClient,
+          trustContext: this.currentTurnTrustContext,
+          channelCapabilities: this.currentTurnChannelCapabilities,
+          onboardingContext: this.getOnboardingContext(),
+        });
+    const tools = getAllToolDefinitions();
     const provider = this.provider;
 
     const warmMessage: Message = {
@@ -838,33 +832,15 @@ export class Conversation {
     );
   }
 
-  enqueueMessage(
-    content: string,
-    attachments: UserMessageAttachment[],
-    onEvent?: (msg: ServerMessage) => void,
-    requestId?: string,
-    activeSurfaceId?: string,
-    currentPage?: string,
-    metadata?: Record<string, unknown>,
-    options?: { isInteractive?: boolean },
-    displayContent?: string,
-    transport?: ConversationTransportMetadata,
-    clientMessageId?: string,
-  ): { queued: boolean; requestId: string; rejected?: boolean } {
-    return enqueueMessageImpl(
-      this,
-      content,
-      attachments,
-      onEvent ?? this.sendToClient,
-      requestId ?? crypto.randomUUID(),
-      activeSurfaceId,
-      currentPage,
-      metadata,
-      options,
-      displayContent,
-      transport,
-      clientMessageId,
-    );
+  enqueueMessage(options: EnqueueMessageOptions): {
+    queued: boolean;
+    requestId: string;
+    rejected?: boolean;
+  } {
+    return enqueueMessageImpl(this, {
+      ...options,
+      onEvent: options.onEvent ?? this.sendToClient,
+    });
   }
 
   getQueueDepth(): number {
@@ -1155,7 +1131,7 @@ export class Conversation {
     this.messages = stripped;
     await this.graphMemory.onCompacted(0);
     this.pendingPostCompactReinject = true;
-    setConversationCleanedAt(this.conversationId, Date.now());
+    setConversationHistoryStrippedAt(this.conversationId, Date.now());
     const estimatedInputTokens = this.contextWindowManager.estimateInputTokens(
       this.messages,
     );
@@ -1293,23 +1269,12 @@ export class Conversation {
   }
 
   async persistUserMessage(
-    content: string,
-    attachments: UserMessageAttachment[],
-    requestId?: string,
-    metadata?: Record<string, unknown>,
-    displayContent?: string,
-  ): Promise<string> {
+    options: PersistMessageOptions,
+  ): Promise<{ id: string; deduplicated: boolean }> {
     if (!this.processing) {
       await this.ensureActorScopedHistory();
     }
-    return persistUserMessageImpl(
-      this,
-      content,
-      attachments,
-      requestId,
-      metadata,
-      displayContent,
-    );
+    return persistUserMessageImpl(this, options);
   }
 
   // ── Agent Loop ───────────────────────────────────────────────────