@vellumai/assistant 0.5.1 → 0.5.3

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

@@ -15,11 +15,16 @@ import type {
 } from "../channels/types.js";
 import {
   addMessage,
+  getConversation,
   getMessageById,
   provenanceFromTrustContext,
   updateMessageContent,
 } from "../memory/conversation-crud.js";
-import { recordRequestLog } from "../memory/llm-request-log-store.js";
+import { syncMessageToDisk } from "../memory/conversation-disk-view.js";
+import {
+  backfillMessageIdOnLogs,
+  recordRequestLog,
+} from "../memory/llm-request-log-store.js";
 import type { ContentBlock, ImageContent } from "../providers/types.js";
 import type { DirectiveRequest } from "./assistant-attachments.js";
 import {
@@ -48,6 +53,8 @@ export interface EventHandlerState {
   llmCallStartedEmitted: boolean;
   pendingDirectiveDisplayBuffer: string;
   firstAssistantText: string;
+  /** Most recent resolved provider for the current exchange's usage accounting. */
+  exchangeProviderName: string | undefined;
   exchangeInputTokens: number;
   exchangeCacheCreationInputTokens: number;
   exchangeCacheReadInputTokens: number;
@@ -114,6 +121,7 @@ export function createEventHandlerState(): EventHandlerState {
     llmCallStartedEmitted: false,
     pendingDirectiveDisplayBuffer: "",
     firstAssistantText: "",
+    exchangeProviderName: undefined,
     exchangeInputTokens: 0,
     exchangeCacheCreationInputTokens: 0,
     exchangeCacheReadInputTokens: 0,
@@ -167,6 +175,12 @@ export function emitLlmCallStartedIfNeeded(
   );
 }
 
+// ── Client Payload Size Caps ─────────────────────────────────────────
+// tool_input_delta streams accumulated JSON as tools run. For non-app
+// tools the client discards it (extractCodePreview only handles app tools),
+// so we skip forwarding entirely to avoid transport/decode overhead.
+const APP_TOOL_NAMES = new Set(["app_create"]);
+
 // ── Friendly Tool Names ──────────────────────────────────────────────
 
 const TOOL_FRIENDLY_NAMES: Record<string, string> = {
@@ -183,11 +197,9 @@ const TOOL_FRIENDLY_NAMES: Record<string, string> = {
   browser_scroll: "browser",
   browser_wait: "browser",
   app_create: "app",
-  app_update: "app",
+  app_refresh: "app refresh",
   skill_load: "skill",
   skill_execute: "skill",
-  app_file_edit: "app file",
-  app_file_write: "app file",
 };
 
 function friendlyToolName(name: string): string {
@@ -267,7 +279,12 @@ export function handleToolUse(
   state.toolCallTimestamps.set(event.id, { startedAt: Date.now() });
   state.currentToolUseId = event.id;
   state.currentTurnToolUseIds.push(event.id);
-  const statusText = `Running ${friendlyToolName(event.name)}`;
+  const statusText =
+    event.name === "skill_execute" &&
+    typeof event.input.activity === "string" &&
+    event.input.activity.length > 0
+      ? event.input.activity
+      : `Running ${friendlyToolName(event.name)}`;
   deps.ctx.emitActivityState(
     "tool_running",
     "tool_use_start",
@@ -385,6 +402,10 @@ export function handleInputJsonDelta(
   deps: EventHandlerDeps,
   event: Extract<AgentEvent, { type: "input_json_delta" }>,
 ): void {
+  // Only forward input deltas for app tools — the client only uses this
+  // stream for app_create code previews. Non-app tools would send large
+  // cumulative JSON on every delta with no benefit.
+  if (!APP_TOOL_NAMES.has(event.toolName)) return;
   deps.onEvent({
     type: "tool_input_delta",
     toolName: event.toolName,
@@ -627,12 +648,21 @@ export async function handleMessageComplete(
       assistantMessageInterface:
         deps.turnInterfaceContext.assistantMessageInterface,
     };
-    await addMessage(
+    const toolResultMsg = await addMessage(
       deps.ctx.conversationId,
       "user",
       JSON.stringify(toolResultBlocks),
       toolResultMetadata,
     );
+    // Sync tool-result user message to disk view
+    const convForToolResult = getConversation(deps.ctx.conversationId);
+    if (convForToolResult) {
+      syncMessageToDisk(
+        deps.ctx.conversationId,
+        toolResultMsg.id,
+        convForToolResult.createdAt,
+      );
+    }
     for (const id of state.pendingToolResults.keys()) {
       state.persistedToolUseIds.add(id);
     }
@@ -697,6 +727,18 @@ export async function handleMessageComplete(
   );
   state.lastAssistantMessageId = assistantMsg.id;
 
+  // Backfill message_id on all LLM request logs from this turn.
+  // The agent loop is single-threaded per conversation, so all rows with
+  // message_id IS NULL belong to the current turn.
+  try {
+    backfillMessageIdOnLogs(deps.ctx.conversationId, assistantMsg.id);
+  } catch (err) {
+    deps.rlog.warn(
+      { err },
+      "Failed to backfill message_id on LLM request logs (non-fatal)",
+    );
+  }
+
   deps.ctx.currentTurnSurfaces = [];
 
   // Emit trace event
@@ -724,6 +766,8 @@ export function handleUsage(
   deps: EventHandlerDeps,
   event: Extract<AgentEvent, { type: "usage" }>,
 ): void {
+  const providerName = event.actualProvider ?? deps.ctx.provider.name;
+  state.exchangeProviderName = providerName;
   state.exchangeInputTokens += event.inputTokens;
   state.exchangeCacheCreationInputTokens += event.cacheCreationInputTokens ?? 0;
   state.exchangeCacheReadInputTokens += event.cacheReadInputTokens ?? 0;
@@ -739,6 +783,8 @@ export function handleUsage(
         deps.ctx.conversationId,
         JSON.stringify(event.rawRequest),
         JSON.stringify(event.rawResponse),
+        undefined,
+        providerName,
       );
     } catch (err) {
       deps.rlog.warn({ err }, "Failed to persist LLM request log (non-fatal)");
@@ -749,12 +795,12 @@ export function handleUsage(
 
   deps.ctx.traceEmitter.emit(
     "llm_call_finished",
-    `LLM call to ${deps.ctx.provider.name} finished`,
+    `LLM call to ${providerName} finished`,
     {
       requestId: deps.reqId,
       status: "success",
       attributes: {
-        provider: deps.ctx.provider.name,
+        provider: providerName,
         model: event.model,
         inputTokens: event.inputTokens,
         outputTokens: event.outputTokens,

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

@@ -32,7 +32,8 @@ import {
   setSentryConversationContext,
 } from "../instrument.js";
 import { commitAppTurnChanges } from "../memory/app-git-service.js";
-import { getApp, listAppFiles } from "../memory/app-store.js";
+import { getApp, listAppFiles, resolveAppDir } from "../memory/app-store.js";
+import { insertCompactionEpisode } from "../memory/archive-store.js";
 import {
   addMessage,
   deleteMessageById,
@@ -43,6 +44,10 @@ import {
   updateConversationContextWindow,
   updateConversationTitle,
 } from "../memory/conversation-crud.js";
+import {
+  rebuildConversationDiskViewFromDbState,
+  syncMessageToDisk,
+} from "../memory/conversation-disk-view.js";
 import {
   isReplaceableTitle,
   queueGenerateConversationTitle,
@@ -77,7 +82,6 @@ import {
 } from "./conversation-agent-loop-handlers.js";
 import {
   approveHostAttachmentRead,
-  formatAttachmentWarnings,
   resolveAssistantAttachments,
 } from "./conversation-attachments.js";
 import {
@@ -173,11 +177,9 @@ const TOOL_FRIENDLY_LABEL: Record<string, string> = {
   browser_scroll: "Browser",
   browser_wait: "Browser",
   app_create: "Create App",
-  app_update: "Update App",
+  app_refresh: "Refresh App",
   skill_load: "Load Skill",
   skill_execute: "Run Skill Tool",
-  app_file_edit: "Edit App File",
-  app_file_write: "Write App File",
 };
 
 type GitServiceInitializer = {
@@ -207,7 +209,17 @@ export interface AgentLoopConversationContext {
   currentPage?: string;
   readonly surfaceState: Map<
     string,
-    { surfaceType: SurfaceType; data: SurfaceData; title?: string }
+    {
+      surfaceType: SurfaceType;
+      data: SurfaceData;
+      title?: string;
+      actions?: Array<{
+        id: string;
+        label: string;
+        style?: string;
+        data?: Record<string, unknown>;
+      }>;
+    }
   >;
   pendingSurfaceActions: Map<string, { surfaceType: SurfaceType }>;
   surfaceActionRequestIds: Set<string>;
@@ -502,6 +514,12 @@ export async function runAgentLoopImpl(
         compacted.summaryText,
         ctx.contextCompactedMessageCount,
       );
+      dualWriteCompactionEpisode(
+        ctx.conversationId,
+        ctx.memoryPolicy.scopeId,
+        compacted.summaryText,
+        compacted.summaryOutputTokens,
+      );
       onEvent({
         type: "context_compacted",
         previousEstimatedInputTokens: compacted.previousEstimatedInputTokens,
@@ -604,6 +622,7 @@ export async function runAgentLoopImpl(
           if (app) {
             activeSurface.appId = app.id;
             activeSurface.appName = app.name;
+            activeSurface.appDirName = resolveAppDir(app.id).dirName;
             activeSurface.appSchemaJson = app.schemaJson;
             activeSurface.appFiles = listAppFiles(app.id);
             if (app.pages && Object.keys(app.pages).length > 0) {
@@ -768,6 +787,12 @@ export async function runAgentLoopImpl(
             step.compactionResult.summaryText,
             ctx.contextCompactedMessageCount,
           );
+          dualWriteCompactionEpisode(
+            ctx.conversationId,
+            ctx.memoryPolicy.scopeId,
+            step.compactionResult.summaryText,
+            step.compactionResult.summaryOutputTokens,
+          );
           onEvent({
             type: "context_compacted",
             previousEstimatedInputTokens:
@@ -801,7 +826,16 @@ export async function runAgentLoopImpl(
           mode: currentInjectionMode,
         });
 
-        if (step.estimatedTokens <= preflightBudget) break;
+        // Re-estimate with injections included — step.estimatedTokens was
+        // computed on bare history (ctx.messages) and doesn't account for
+        // tokens added by runtime injections.
+        const postInjectionTokens = estimatePromptTokens(
+          runMessages,
+          ctx.systemPrompt,
+          { providerName: ctx.provider.name, toolTokenBudget },
+        );
+
+        if (postInjectionTokens <= preflightBudget) break;
       }
     }
 
@@ -943,6 +977,12 @@ export async function runAgentLoopImpl(
           midLoopCompact.summaryText,
           ctx.contextCompactedMessageCount,
         );
+        dualWriteCompactionEpisode(
+          ctx.conversationId,
+          ctx.memoryPolicy.scopeId,
+          midLoopCompact.summaryText,
+          midLoopCompact.summaryOutputTokens,
+        );
         onEvent({
           type: "context_compacted",
           previousEstimatedInputTokens:
@@ -1139,6 +1179,12 @@ export async function runAgentLoopImpl(
             step.compactionResult.summaryText,
             ctx.contextCompactedMessageCount,
           );
+          dualWriteCompactionEpisode(
+            ctx.conversationId,
+            ctx.memoryPolicy.scopeId,
+            step.compactionResult.summaryText,
+            step.compactionResult.summaryOutputTokens,
+          );
           onEvent({
             type: "context_compacted",
             previousEstimatedInputTokens:
@@ -1173,6 +1219,7 @@ export async function runAgentLoopImpl(
         preRepairMessages = runMessages;
         preRunHistoryLength = runMessages.length;
         state.contextTooLargeDetected = false;
+        yieldedForBudget = false;
 
         updatedHistory = await ctx.agentLoop.run(
           runMessages,
@@ -1195,6 +1242,15 @@ export async function runAgentLoopImpl(
             "Post-convergence rerun still yielded at checkpoint — continuing reduction",
           );
           state.contextTooLargeDetected = true;
+
+          // Fold rerun progress into ctx.messages so the next reducer
+          // tier operates on up-to-date history instead of stale
+          // pre-rerun messages.
+          if (updatedHistory.length > preRunHistoryLength) {
+            ctx.messages = stripInjectedContext(updatedHistory);
+            preRepairMessages = updatedHistory;
+            preRunHistoryLength = updatedHistory.length;
+          }
         }
       }
 
@@ -1236,6 +1292,12 @@ export async function runAgentLoopImpl(
                 emergencyCompact.summaryText,
                 ctx.contextCompactedMessageCount,
               );
+              dualWriteCompactionEpisode(
+                ctx.conversationId,
+                ctx.memoryPolicy.scopeId,
+                emergencyCompact.summaryText,
+                emergencyCompact.summaryOutputTokens,
+              );
               onEvent({
                 type: "context_compacted",
                 previousEstimatedInputTokens:
@@ -1340,6 +1402,12 @@ export async function runAgentLoopImpl(
               emergencyCompact.summaryText,
               ctx.contextCompactedMessageCount,
             );
+            dualWriteCompactionEpisode(
+              ctx.conversationId,
+              ctx.memoryPolicy.scopeId,
+              emergencyCompact.summaryText,
+              emergencyCompact.summaryOutputTokens,
+            );
             onEvent({
               type: "context_compacted",
               previousEstimatedInputTokens:
@@ -1514,16 +1582,29 @@ export async function runAgentLoopImpl(
       state.exchangeCacheCreationInputTokens,
       state.exchangeCacheReadInputTokens,
       collapseRawResponses(state.exchangeRawResponses),
+      state.exchangeProviderName,
     );
 
     void getHookManager().trigger("post-message", {
       conversationId: ctx.conversationId,
     });
 
+    const syncLastAssistantMessageToDisk = (): void => {
+      if (!state.lastAssistantMessageId) return;
+      const convForDisk = getConversation(ctx.conversationId);
+      if (!convForDisk) return;
+      syncMessageToDisk(
+        ctx.conversationId,
+        state.lastAssistantMessageId,
+        convForDisk.createdAt,
+      );
+    };
+
     // Fast-path: when the user cancelled, skip expensive post-loop work
     // (attachment resolution) and emit the cancellation event immediately
     // so the client can re-enable the UI without delay.
     if (abortController.signal.aborted) {
+      syncLastAssistantMessageToDisk();
       ctx.emitActivityState("idle", "generation_cancelled", "global", reqId);
       ctx.traceEmitter.emit(
         "generation_cancelled",
@@ -1559,17 +1640,7 @@ export async function runAgentLoopImpl(
 
       ctx.lastAssistantAttachments = assistantAttachments;
       ctx.lastAttachmentWarnings = attachmentResult.directiveWarnings;
-
-      const warningText = formatAttachmentWarnings(
-        attachmentResult.directiveWarnings,
-      );
-      if (warningText) {
-        onEvent({
-          type: "assistant_text_delta",
-          text: warningText,
-          conversationId: ctx.conversationId,
-        });
-      }
+      syncLastAssistantMessageToDisk();
 
       // Re-check: the user may have cancelled during attachment resolution
       if (abortController.signal.aborted) {
@@ -1604,6 +1675,9 @@ export async function runAgentLoopImpl(
           ...(emittedAttachments.length > 0
             ? { attachments: emittedAttachments }
             : {}),
+          ...(ctx.lastAttachmentWarnings.length > 0
+            ? { attachmentWarnings: ctx.lastAttachmentWarnings }
+            : {}),
           ...(state.lastAssistantMessageId
             ? { messageId: state.lastAssistantMessageId }
             : {}),
@@ -1624,6 +1698,9 @@ export async function runAgentLoopImpl(
           ...(emittedAttachments.length > 0
             ? { attachments: emittedAttachments }
             : {}),
+          ...(ctx.lastAttachmentWarnings.length > 0
+            ? { attachmentWarnings: ctx.lastAttachmentWarnings }
+            : {}),
           ...(state.lastAssistantMessageId
             ? { messageId: state.lastAssistantMessageId }
             : {}),
@@ -1739,7 +1816,13 @@ export async function runAgentLoopImpl(
     ctx.commandIntent = undefined;
 
     if (userMessageId) {
-      consolidateAssistantMessages(ctx.conversationId, userMessageId);
+      const didMutateHistory = consolidateAssistantMessages(
+        ctx.conversationId,
+        userMessageId,
+      );
+      if (didMutateHistory) {
+        rebuildConversationDiskViewFromDbState(ctx.conversationId);
+      }
     }
 
     ctx.drainQueue(yieldedForHandoff ? "checkpoint_handoff" : "loop_complete");
@@ -1766,11 +1849,12 @@ function emitUsage(
   cacheCreationInputTokens = 0,
   cacheReadInputTokens = 0,
   rawResponse?: unknown,
+  providerName?: string,
 ): void {
   recordUsage(
     {
       conversationId: ctx.conversationId,
-      providerName: ctx.provider.name,
+      providerName: providerName ?? ctx.provider.name,
       usageStats: ctx.usageStats,
     },
     inputTokens,
@@ -1789,3 +1873,26 @@ function collapseRawResponses(rawResponses?: unknown[]): unknown | undefined {
   if (!rawResponses || rawResponses.length === 0) return undefined;
   return rawResponses.length === 1 ? rawResponses[0] : rawResponses;
 }
+
+/**
+ * Dual-write a compaction summary as an archive episode so it becomes
+ * searchable via vector recall. Called after each successful compaction
+ * that produces a new summary.
+ */
+function dualWriteCompactionEpisode(
+  conversationId: string,
+  scopeId: string,
+  summaryText: string,
+  summaryOutputTokens: number,
+): void {
+  const now = Date.now();
+  insertCompactionEpisode({
+    conversationId,
+    scopeId,
+    title: truncate(summaryText, 120, ""),
+    summary: summaryText,
+    tokenEstimate: summaryOutputTokens,
+    startAt: now,
+    endAt: now,
+  });
+}

package/src/daemon/conversation-attachments.ts

@@ -1,11 +1,8 @@
 import {
+  attachInlineAttachmentToMessage,
   AttachmentUploadError,
-  FILE_BACKED_THRESHOLD_BYTES,
-  linkAttachmentToMessage,
+  getFilePathForAttachment,
   setAttachmentThumbnail,
-  uploadAttachment,
-  uploadFileBackedAttachment,
-  writeAttachmentToDisk,
 } from "../memory/attachments-store.js";
 import {
   check,
@@ -107,12 +104,6 @@ export async function approveHostAttachmentRead(
   return isAllowDecision(response.decision);
 }
 
-export function formatAttachmentWarnings(warnings: string[]): string | null {
-  if (warnings.length === 0) return null;
-  const lines = warnings.map((warning) => `Attachment warning: ${warning}`);
-  return `\n\n${lines.join("\n")}`;
-}
-
 export interface AttachmentResolutionResult {
   assistantAttachments: AssistantAttachmentDraft[];
   emittedAttachments: UserMessageAttachment[];
@@ -211,28 +202,16 @@ export async function resolveAssistantAttachments(
   if (assistantAttachments.length > 0 && lastAssistantMessageId) {
     for (let i = 0; i < assistantAttachments.length; i++) {
       const draft = assistantAttachments[i];
-      const isFileBacked = draft.sizeBytes > FILE_BACKED_THRESHOLD_BYTES;
       let stored;
-      let diskFilePath: string | undefined;
       try {
-        if (isFileBacked) {
-          diskFilePath = writeAttachmentToDisk(
-            draft.dataBase64,
-            draft.filename,
-          );
-          stored = uploadFileBackedAttachment(
-            draft.filename,
-            draft.mimeType,
-            diskFilePath,
-            draft.sizeBytes,
-          );
-        } else {
-          stored = uploadAttachment(
-            draft.filename,
-            draft.mimeType,
-            draft.dataBase64,
-          );
-        }
+        stored = attachInlineAttachmentToMessage(
+          lastAssistantMessageId,
+          i,
+          draft.filename,
+          draft.mimeType,
+          draft.dataBase64,
+          { skipSizeLimit: true },
+        );
       } catch (err) {
         if (err instanceof AttachmentUploadError) {
           log.warn(
@@ -246,11 +225,11 @@ export async function resolveAssistantAttachments(
         }
         throw err;
       }
-      linkAttachmentToMessage(lastAssistantMessageId, stored.id, i);
       const isVideo = draft.mimeType.startsWith("video/");
-      const omitData =
-        isFileBacked ||
-        (isVideo && draft.dataBase64.length > MAX_INLINE_B64_SIZE);
+      // Only omit data for videos — they have an end-to-end lazy-load path
+      // via /v1/attachments/:id/content. Other types (images, PDFs) still need
+      // inline data for thumbnails, preview, and file-save in the client.
+      const omitData = isVideo && draft.dataBase64.length > MAX_INLINE_B64_SIZE;
 
       // Generate and persist a thumbnail for video attachments.
       let thumbnailData: string | undefined;
@@ -259,6 +238,7 @@ export async function resolveAssistantAttachments(
         if (existing) {
           thumbnailData = existing;
         } else {
+          const diskFilePath = getFilePathForAttachment(stored.id);
           const generated = diskFilePath
             ? await generateVideoThumbnailFromPath(diskFilePath)
             : await generateVideoThumbnail(draft.dataBase64);
@@ -274,8 +254,9 @@ export async function resolveAssistantAttachments(
         filename: draft.filename,
         mimeType: draft.mimeType,
         data: omitData ? "" : draft.dataBase64,
+        sourceType: draft.sourceType,
         ...(omitData ? { sizeBytes: draft.sizeBytes } : {}),
-        ...(isFileBacked ? { fileBacked: true } : {}),
+        fileBacked: true,
         ...(thumbnailData ? { thumbnailData } : {}),
       });
     }
@@ -285,6 +266,7 @@ export async function resolveAssistantAttachments(
         filename: draft.filename,
         mimeType: draft.mimeType,
         data: draft.dataBase64,
+        sourceType: draft.sourceType,
       });
     }
   }

package/src/daemon/conversation-error.ts

@@ -390,7 +390,8 @@ function classifyByMessage(
   if (isStreamingError(message)) {
     return {
       code: "PROVIDER_API",
-      userMessage: "The AI provider's response was interrupted. Please try again.",
+      userMessage:
+        "The AI provider's response was interrupted. Please try again.",
       retryable: true,
       errorCategory: "stream_corruption",
     };

package/src/daemon/conversation-history.ts

@@ -29,6 +29,16 @@ function isToolResultBlock(
   );
 }
 
+function isSystemNoticeBlock(
+  block: ContentBlock | Record<string, unknown>,
+): boolean {
+  if (block.type !== "text") return false;
+  const text = (block as { text?: string }).text ?? "";
+  return (
+    text.startsWith("<system_notice>") && text.endsWith("</system_notice>")
+  );
+}
+
 function isUndoableUserMessage(message: Message): boolean {
   if (message.role !== "user") return false;
   if (getSummaryFromContextMessage(message) != null) return false;
@@ -37,8 +47,9 @@ function isUndoableUserMessage(message: Message): boolean {
   // responses) are not undoable. Messages that have both tool_result and text blocks
   // (e.g. after repairHistory merges a tool_result turn with a user prompt) are still
   // undoable because they contain real user content.
+  // System notice text blocks (retry nudges, progress checks) are not user content.
   const hasNonToolResultContent = message.content.some(
-    (block) => !isToolResultBlock(block),
+    (block) => !isToolResultBlock(block) && !isSystemNoticeBlock(block),
   );
   if (!hasNonToolResultContent) return false;
   return true;
@@ -131,10 +142,10 @@ export async function cleanupQdrantVectors(
 export function consolidateAssistantMessages(
   conversationId: string,
   userMessageId: string,
-): void {
+): boolean {
   const allMessages = getMessages(conversationId);
   const userMsgIndex = allMessages.findIndex((m) => m.id === userMessageId);
-  if (userMsgIndex === -1) return;
+  if (userMsgIndex === -1) return false;
 
   const messagesToConsolidate: typeof allMessages = [];
   const internalToolResultMessages: typeof allMessages = [];
@@ -171,12 +182,14 @@ export function consolidateAssistantMessages(
 
   // Only consolidate if there are multiple assistant messages
   if (messagesToConsolidate.length <= 1) {
+    let didMutate = false;
     // Still delete internal tool_result messages even if only one assistant message,
     // and collect IDs for vector cleanup
     const allSegmentIds: string[] = [];
     const allOrphanedItemIds: string[] = [];
     for (const id of messagesToDelete) {
       const deleted = deleteMessageById(id);
+      didMutate = true;
       allSegmentIds.push(...deleted.segmentIds);
       allOrphanedItemIds.push(...deleted.orphanedItemIds);
     }
@@ -194,7 +207,7 @@ export function consolidateAssistantMessages(
         );
       });
     }
-    return;
+    return didMutate;
   }
 
   log.info(
@@ -339,6 +352,7 @@ export function consolidateAssistantMessages(
     },
     "Assistant messages consolidated",
   );
+  return true;
 }
 
 // ── Undo ─────────────────────────────────────────────────────────────