@vellumai/assistant 0.8.5 → 0.8.6

package/src/__tests__/conversation-slash-queue.test.ts

@@ -135,6 +135,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationTitle: () => {},
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  updateMessageContent: mock(() => {}),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -204,7 +206,7 @@ mock.module("../config/skill-state.js", () => ({
 interface PendingRun {
   resolve: (history: Message[]) => void;
   messages: Message[];
-  onEvent: (event: AgentEvent) => void;
+  onEvent: (event: AgentEvent) => void | Promise<void>;
 }
 
 let pendingRuns: PendingRun[] = [];
@@ -223,7 +225,7 @@ mock.module("../agent/loop.js", () => ({
     }
     async run(
       messages: Message[],
-      onEvent: (event: AgentEvent) => void,
+      onEvent: (event: AgentEvent) => void | Promise<void>,
       _signal?: AbortSignal,
       _requestId?: string,
       _onCheckpoint?: (
@@ -333,21 +335,24 @@ async function waitForPendingRun(
   }
 }
 
-function resolveRun(index: number) {
+async function resolveRun(index: number) {
   const run = pendingRuns[index];
   if (!run) throw new Error(`No pending run at index ${index}`);
   const assistantMsg: Message = {
     role: "assistant",
     content: [{ type: "text", text: `reply-${index}` }],
   };
-  run.onEvent({
+  // Prime the assistant row anchor — production code emits this from
+  // `AgentLoop.run` just before `provider.sendMessage`.
+  await run.onEvent({ type: "llm_call_started" });
+  await run.onEvent({
     type: "usage",
     inputTokens: 10,
     outputTokens: 5,
     model: "mock",
     providerDurationMs: 100,
   });
-  run.onEvent({ type: "message_complete", message: assistantMsg });
+  await run.onEvent({ type: "message_complete", message: assistantMsg });
   run.resolve([...run.messages, assistantMsg]);
 }
 
@@ -398,17 +403,20 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
 
     // Enqueue a slash-like passthrough and a normal passthrough after it.
     // Both resolve to passthrough, so the batch builder groups them into one run.
-    conversation.enqueueMessage(
-      "/not-a-skill",
-      [],
-      (e) => eventsSlash.push(e),
-      "req-slash",
-    );
-    conversation.enqueueMessage("msg-3", [], (e) => events3.push(e), "req-3");
+    conversation.enqueueMessage({
+      content: "/not-a-skill",
+      onEvent: (e) => eventsSlash.push(e),
+      requestId: "req-slash",
+    });
+    conversation.enqueueMessage({
+      content: "msg-3",
+      onEvent: (e) => events3.push(e),
+      requestId: "req-3",
+    });
     expect(conversation.getQueueDepth()).toBe(2);
 
     // Complete first run — drain pulls both queued messages into one batched run.
-    resolveRun(0);
+    await resolveRun(0);
     await p1;
     await waitForPendingRun(2);
 
@@ -419,8 +427,46 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     // Exactly 2 runs total: msg-1 + batched [/not-a-skill, msg-3].
     expect(pendingRuns.length).toBe(2);
 
+    await resolveRun(1);
+    await new Promise((r) => setTimeout(r, 50));
+  });
+
+  test("batched queued messages with the same event sink do not duplicate assistant stream events", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const sharedEvents: ServerMessage[] = [];
+    const sharedOnEvent = (event: ServerMessage) => sharedEvents.push(event);
+
+    const p1 = conversation.processMessage("msg-1", [], () => {}, "req-1");
+    await waitForPendingRun(1);
+
+    conversation.enqueueMessage({
+      content: "msg-2",
+      onEvent: sharedOnEvent,
+      requestId: "req-2",
+    });
+    conversation.enqueueMessage({
+      content: "msg-3",
+      onEvent: sharedOnEvent,
+      requestId: "req-3",
+    });
+
+    resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+
+    expect(
+      sharedEvents.filter((event) => event.type === "message_dequeued"),
+    ).toHaveLength(2);
+
+    sharedEvents.length = 0;
     resolveRun(1);
     await new Promise((r) => setTimeout(r, 50));
+
+    expect(
+      sharedEvents.filter((event) => event.type === "message_complete"),
+    ).toHaveLength(1);
   });
 
   test("queued skill-name slash passes through as-is", async () => {
@@ -440,15 +486,14 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     await waitForPendingRun(1);
 
     // Enqueue a slash command that matches a skill name — still passes through
-    conversation.enqueueMessage(
-      "/start-the-day",
-      [],
-      (e) => eventsSlash.push(e),
-      "req-slash",
-    );
+    conversation.enqueueMessage({
+      content: "/start-the-day",
+      onEvent: (e) => eventsSlash.push(e),
+      requestId: "req-slash",
+    });
 
     // Complete first run — triggers drain
-    resolveRun(0);
+    await resolveRun(0);
     await p1;
     await waitForPendingRun(2);
 
@@ -463,7 +508,7 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     // Content passes through as-is — no rewriting
     expect(text).toContain("/start-the-day");
 
-    resolveRun(1);
+    await resolveRun(1);
     await new Promise((r) => setTimeout(r, 50));
   });
 
@@ -483,18 +528,25 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     // batch builder stops at "hi" (length-1 batch → drainSingleMessage). Then
     // /compact takes its short-circuit path (no new runAgentLoop), and "bye"
     // drains as its own run.
-    conversation.enqueueMessage("hi", [], (e) => eventsHi.push(e), "req-hi");
-    conversation.enqueueMessage(
-      "/compact",
-      [],
-      (e) => eventsCompact.push(e),
-      "req-compact",
-    );
-    conversation.enqueueMessage("bye", [], (e) => eventsBye.push(e), "req-bye");
+    conversation.enqueueMessage({
+      content: "hi",
+      onEvent: (e) => eventsHi.push(e),
+      requestId: "req-hi",
+    });
+    conversation.enqueueMessage({
+      content: "/compact",
+      onEvent: (e) => eventsCompact.push(e),
+      requestId: "req-compact",
+    });
+    conversation.enqueueMessage({
+      content: "bye",
+      onEvent: (e) => eventsBye.push(e),
+      requestId: "req-bye",
+    });
     expect(conversation.getQueueDepth()).toBe(3);
 
     // Resolve msg-1 → drain pulls only "hi" (batch builder stops at /compact).
-    resolveRun(0);
+    await resolveRun(0);
     await p1;
     await waitForPendingRun(2);
 
@@ -503,14 +555,14 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
 
     // Resolve "hi" → /compact short-circuits without a new runAgentLoop, then
     // drains "bye" as its own run.
-    resolveRun(1);
+    await resolveRun(1);
     await waitForPendingRun(3);
 
     expect(eventsCompact.some((e) => e.type === "message_complete")).toBe(true);
     expect(eventsBye.some((e) => e.type === "message_dequeued")).toBe(true);
     expect(pendingRuns.length).toBe(3);
 
-    resolveRun(2);
+    await resolveRun(2);
     await new Promise((r) => setTimeout(r, 50));
   });
 

package/src/__tests__/conversation-slash-unknown.test.ts

@@ -136,6 +136,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationTitle: () => {},
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  updateMessageContent: mock(() => {}),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -254,6 +256,9 @@ mock.module("../agent/loop.js", () => ({
         checkpoint: CheckpointInfo,
       ) => CheckpointDecision | Promise<CheckpointDecision>,
     ): Promise<Message[]> {
+      // Prime the assistant row anchor — production code emits this from
+      // `AgentLoop.run` just before `provider.sendMessage`.
+      await onEvent({ type: "llm_call_started" });
       agentLoopRunCalled = true;
       const assistantMsg: Message = {
         role: "assistant",

package/src/__tests__/conversation-speed-override.test.ts

@@ -150,6 +150,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   addMessage: () => ({ id: `msg-${Date.now()}` }),
   updateConversationUsage: () => {},
   updateConversationTitle: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

package/src/__tests__/conversation-surfaces-action-delivery.test.ts

@@ -182,6 +182,52 @@ describe("surface action delivery to assistant", () => {
     );
   });
 
+  test("history-restored relay action uses stored prompt data and can complete the surface", async () => {
+    const ctx = makeContext();
+    const surfaceId = "max-token-surface";
+    ctx.surfaceState.set(surfaceId, {
+      surfaceType: "card",
+      data: {
+        title: "Response limit reached",
+        body: "Continue from where the assistant stopped.",
+      },
+      actions: [
+        {
+          id: "relay_prompt",
+          label: "Continue",
+          style: "primary",
+          data: {
+            prompt: "Continue from where you stopped.",
+            _completeSurface: true,
+            _completionSummary: "Continue",
+          },
+        },
+      ],
+    });
+
+    await handleSurfaceAction(ctx, surfaceId, "relay_prompt");
+
+    expect(ctx.processMessageCalls).toHaveLength(1);
+    expect(ctx.processMessageCalls[0]!.content).toBe(
+      "Continue from where you stopped.",
+    );
+    expect(
+      broadcastedMessages.some(
+        (msg) =>
+          msg.type === "ui_surface_complete" &&
+          msg.surfaceId === surfaceId &&
+          msg.summary === "Continue",
+      ),
+    ).toBe(true);
+    expect(
+      broadcastedMessages.some(
+        (msg) =>
+          msg.type === "user_message_echo" &&
+          msg.text === "Continue from where you stopped.",
+      ),
+    ).toBe(true);
+  });
+
   test("action on history-restored surface (no pending) still processes", async () => {
     const sent: ServerMessage[] = [];
     const ctx = makeContext(sent);

package/src/__tests__/conversation-surfaces-data-persist.test.ts

@@ -29,6 +29,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessages: (conversationId: string) => getMessagesImpl(conversationId),
   updateMessageContent: (id: string, content: string) =>
     updateMessageContentSpy(id, content),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 // Imports must come AFTER mock.module so the surface module picks up

package/src/__tests__/conversation-surfaces-standalone-payloads.test.ts

@@ -72,9 +72,12 @@ function createMockContext(
     hostCuProxy: undefined,
     hasNoClient: overrides?.hasNoClient ?? false,
     isProcessing: () => false,
-    enqueueMessage: (content, _attachments, _onEvent, requestId) => {
-      const resolvedId = requestId ?? "mock-request-id";
-      enqueuedMessages.push({ content, requestId: resolvedId });
+    enqueueMessage: (options) => {
+      const resolvedId = options.requestId ?? "mock-request-id";
+      enqueuedMessages.push({
+        content: options.content,
+        requestId: resolvedId,
+      });
       return { queued: false, requestId: resolvedId };
     },
     getQueueDepth: () => 0,

package/src/__tests__/conversation-surfaces-standalone.test.ts

@@ -63,9 +63,12 @@ function createMockContext(
     hostCuProxy: undefined,
     hasNoClient: overrides?.hasNoClient ?? false,
     isProcessing: () => false,
-    enqueueMessage: (content, _attachments, _onEvent, requestId) => {
-      const resolvedId = requestId ?? "mock-request-id";
-      enqueuedMessages.push({ content, requestId: resolvedId });
+    enqueueMessage: (options) => {
+      const resolvedId = options.requestId ?? "mock-request-id";
+      enqueuedMessages.push({
+        content: options.content,
+        requestId: resolvedId,
+      });
       return { queued: false, requestId: resolvedId };
     },
     getQueueDepth: () => 0,

package/src/__tests__/conversation-surfaces-state-update.test.ts

@@ -45,9 +45,9 @@ function makeContext(opts?: {
     surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
     isProcessing: () => false,
-    enqueueMessage: (content, _attachments, _onEvent, requestId) => {
-      const resolvedId = requestId ?? "mock-request-id";
-      enqueueCalls.push({ content, requestId: resolvedId });
+    enqueueMessage: (options) => {
+      const resolvedId = options.requestId ?? "mock-request-id";
+      enqueueCalls.push({ content: options.content, requestId: resolvedId });
       return { queued: false, requestId: resolvedId };
     },
     getQueueDepth: () => 0,

package/src/__tests__/conversation-surfaces-table-action.test.ts

@@ -64,25 +64,15 @@ function makeContext(): SurfaceConversationContext & {
     surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
     isProcessing: () => false,
-    enqueueMessage: (
-      content,
-      attachments,
-      _onEvent,
-      requestId,
-      surfaceId,
-      _currentPage,
-      _metadata,
-      _options,
-      displayContent,
-    ) => {
+    enqueueMessage: (options) => {
       enqueueCalls.push({
-        content,
-        requestId: requestId ?? "enq-req",
-        attachments,
-        surfaceId,
-        displayContent,
+        content: options.content,
+        requestId: options.requestId ?? "enq-req",
+        attachments: options.attachments ?? [],
+        surfaceId: options.activeSurfaceId,
+        displayContent: options.displayContent,
       });
-      return { queued: false, requestId: requestId ?? "enq-req" };
+      return { queued: false, requestId: options.requestId ?? "enq-req" };
     },
     getQueueDepth: () => 0,
     processMessage: async (

package/src/__tests__/conversation-sync-tags.test.ts

@@ -1,3 +1,5 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, test } from "bun:test";
 
 import {
@@ -8,14 +10,15 @@ import {
   projectAssistantMessage,
   recordConversationSeenSignal,
 } from "../memory/conversation-attention-store.js";
-import { createConversation } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { addMessage, createConversation } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import type { AssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES as CONVERSATION_LIST_ROUTES } from "../runtime/routes/conversation-list-routes.js";
 import { ROUTES as CONVERSATION_MANAGEMENT_ROUTES } from "../runtime/routes/conversation-management-routes.js";
 import type { RouteDefinition } from "../runtime/routes/types.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 import { waitFor } from "./helpers/wait-for.js";
 
 initializeDb();
@@ -70,7 +73,7 @@ describe("conversation sync tags", () => {
   });
 
   afterAll(() => {
-    resetDb();
+    resetDbForTesting();
   });
 
   test("rename emits the typed title event and a metadata-only sync tag (no list umbrella)", async () => {
@@ -107,9 +110,9 @@ describe("conversation sync tags", () => {
     // Defense-in-depth: the umbrella `conversationsList` tag would force
     // web to redrain the full paginated list — we deliberately omit it
     // for content-only reasons.
-    expect(
-      (received[1]!.message as { tags: string[] }).tags,
-    ).not.toContain(SYNC_TAGS.conversationsList);
+    expect((received[1]!.message as { tags: string[] }).tags).not.toContain(
+      SYNC_TAGS.conversationsList,
+    );
     // The legacy invalidation broadcast is macOS-scoped and must not
     // reach this process-type subscriber.
     expect(
@@ -119,6 +122,22 @@ describe("conversation sync tags", () => {
     ).toBe(false);
   });
 
+  test("agent-loop title updates emit metadata-only sync tags (no list umbrella)", () => {
+    const source = readFileSync(
+      join(import.meta.dir, "..", "daemon", "conversation-agent-loop.ts"),
+      "utf-8",
+    );
+    const titleUpdateBlocks =
+      source.match(
+        /type: "conversation_title_updated"[\s\S]{0,500}?type: "sync_changed"[\s\S]{0,250}?tags: \[[\s\S]*?\]/g,
+      ) ?? [];
+
+    expect(titleUpdateBlocks.length).toBeGreaterThanOrEqual(2);
+    for (const block of titleUpdateBlocks) {
+      expect(block).not.toContain("SYNC_TAGS.conversationsList");
+    }
+  });
+
   test("create emits a sync_changed with the conversationsList umbrella tag", async () => {
     // Create is shape-changing — a row is added to the paginated list,
     // so web must redrain the list (cannot patch a row it has never
@@ -246,9 +265,9 @@ describe("conversation sync tags", () => {
     // Defense-in-depth: the umbrella `conversationsList` tag would
     // force the very paginated-list drain this redesign exists to
     // avoid. It must not appear here.
-    expect(
-      (received[0]!.message as { tags: string[] }).tags,
-    ).not.toContain(SYNC_TAGS.conversationsList);
+    expect((received[0]!.message as { tags: string[] }).tags).not.toContain(
+      SYNC_TAGS.conversationsList,
+    );
     expect(
       received.some(
         (event) => event.message.type === "conversation_list_invalidated",
@@ -290,13 +309,110 @@ describe("conversation sync tags", () => {
       type: "sync_changed",
       tags: [conversationMetadataSyncTag(conversation.id)],
     });
-    expect(
-      (received[0]!.message as { tags: string[] }).tags,
-    ).not.toContain(SYNC_TAGS.conversationsList);
+    expect((received[0]!.message as { tags: string[] }).tags).not.toContain(
+      SYNC_TAGS.conversationsList,
+    );
     expect(
       received.some(
         (event) => event.message.type === "conversation_list_invalidated",
       ),
     ).toBe(false);
   });
+
+  test("addMessage('assistant') emits a metadata sync tag when attention state transitions", async () => {
+    // When an assistant message transitions a conversation from seen to
+    // unseen, `addMessage` emits `conversation:<id>:metadata` so the web
+    // sidebar picks up the attention state change without a full list
+    // refetch. This is the fix for LUM-1907: background processes that
+    // add assistant messages (notification delivery, proactive artifacts)
+    // now automatically notify clients.
+    const conversation = createConversation("Attention sync");
+
+    const received = await captureEvents(async () => {
+      await addMessage(
+        conversation.id,
+        "assistant",
+        JSON.stringify([{ type: "text", text: "hello" }]),
+      );
+    }, 1);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "sync_changed",
+    ]);
+    expect(received[0]!.message).toEqual({
+      type: "sync_changed",
+      tags: [conversationMetadataSyncTag(conversation.id)],
+    });
+  });
+
+  test("addMessage('assistant') does not emit a metadata sync tag when already unseen", async () => {
+    // When the conversation is already unseen (attention cursor was
+    // already past the seen cursor), a subsequent assistant message
+    // should NOT emit a metadata tag — no state transition occurred.
+    const conversation = createConversation("Already unseen");
+    await addMessage(
+      conversation.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "first" }]),
+    );
+
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+    try {
+      await addMessage(
+        conversation.id,
+        "assistant",
+        JSON.stringify([{ type: "text", text: "second" }]),
+      );
+      // Brief wait to ensure no event is emitted
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      const metadataEvents = received.filter(
+        (event) =>
+          event.message.type === "sync_changed" &&
+          (event.message as { tags: string[] }).tags.some((tag: string) =>
+            tag.includes(":metadata"),
+          ),
+      );
+      expect(metadataEvents).toHaveLength(0);
+    } finally {
+      subscription.dispose();
+    }
+  });
+
+  test("addMessage('user') does not emit a metadata sync tag", async () => {
+    // User messages never affect attention state — only assistant
+    // messages advance the attention cursor via projectAssistantMessage.
+    const conversation = createConversation("User message");
+
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+    try {
+      await addMessage(
+        conversation.id,
+        "user",
+        JSON.stringify([{ type: "text", text: "hello" }]),
+      );
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      const metadataEvents = received.filter(
+        (event) =>
+          event.message.type === "sync_changed" &&
+          (event.message as { tags: string[] }).tags.some((tag: string) =>
+            tag.includes(":metadata"),
+          ),
+      );
+      expect(metadataEvents).toHaveLength(0);
+    } finally {
+      subscription.dispose();
+    }
+  });
 });

package/src/__tests__/conversation-title-service.test.ts

@@ -37,6 +37,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversation: mockGetConversation,
   getMessages: mockGetMessages,
   updateConversationTitle: mockUpdateConversationTitle,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../providers/provider-send-message.js", () => ({

package/src/__tests__/conversation-tool-setup-app-refresh.test.ts

@@ -295,6 +295,36 @@ describe("session-tool-setup app refresh side effects", () => {
       });
     });
 
+    test("canonicalizes legacy computer_use_press_key skill_execute alias before dispatch", async () => {
+      const ctx = makeCtx({ allowedToolNames: new Set(["computer_use_key"]) });
+      const executor = makeFakeExecutor({ content: "ok", isError: false });
+
+      const toolFn = createToolExecutor(
+        executor as unknown as ToolExecutor,
+        noopPrompter,
+        noopSecretPrompter,
+        ctx,
+        noopLifecycleHandler,
+      );
+
+      await toolFn("skill_execute", {
+        tool: "computer_use_press_key",
+        input: {
+          key: "Space",
+          modifiers: ["Command"],
+          reasoning: "Open Spotlight",
+        },
+        activity: "Opening Spotlight",
+      });
+
+      const calls = executor.execute.mock.calls as unknown[][];
+      expect(calls[0][0]).toBe("computer_use_key");
+      expect(calls[0][1]).toEqual({
+        key: "cmd+space",
+        reasoning: "Open Spotlight",
+      });
+    });
+
     test("preserves exact active create_app skill tool when app_create is also active", async () => {
       const ctx = makeCtx({
         allowedToolNames: new Set(["create_app", "app_create"]),

package/src/__tests__/conversation-usage.test.ts

@@ -36,6 +36,7 @@ mock.module("../memory/conversation-crud.js", () => ({
       estimatedCost,
     });
   },
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 import { recordUsage } from "../daemon/conversation-usage.js";

package/src/__tests__/conversation-workspace-cache-state.test.ts

@@ -111,6 +111,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationContextWindow: () => {},
   deleteMessageById: () => ({ segmentIds: [], deletedSummaryIds: [] }),
   deleteLastExchange: () => 0,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -145,6 +145,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   setLastNotifiedInferenceProfile: () => {},
   getConversationOverrideProfileFromRow: () => undefined,
   updateMessageMetadata: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  updateMessageContent: mock(() => {}),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -244,6 +246,9 @@ mock.module("../agent/loop.js", () => ({
       messages: Message[],
       onEvent: (event: AgentEvent) => void,
     ): Promise<Message[]> {
+      // Prime the assistant row anchor — production code emits this from
+      // `AgentLoop.run` just before `provider.sendMessage`.
+      await onEvent({ type: "llm_call_started" });
       runCalls.push(messages);
       agentLoopScript(onEvent);
       onEvent({