@vellumai/assistant 0.5.1 → 0.5.3

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

@@ -0,0 +1,149 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  resolveSlash,
+  type SlashContext,
+} from "../daemon/conversation-slash.js";
+
+function makeSlashContext(
+  overrides: Partial<SlashContext> = {},
+): SlashContext {
+  return {
+    messageCount: 4,
+    inputTokens: 1024,
+    outputTokens: 256,
+    maxInputTokens: 200000,
+    model: "claude-opus-4-6",
+    provider: "anthropic",
+    estimatedCost: 0.03,
+    ...overrides,
+  };
+}
+
+async function resolveCommandsLines(context?: SlashContext): Promise<string[]> {
+  const result = await resolveSlash("/commands", context);
+  expect(result.kind).toBe("unknown");
+  if (result.kind !== "unknown") {
+    throw new Error("Expected /commands to resolve to kind=unknown");
+  }
+  return result.message.split("\n");
+}
+
+describe("resolveSlash /commands interface-aware help", () => {
+  test("renders desktop command help for macOS", async () => {
+    const lines = await resolveCommandsLines(
+      makeSlashContext({ userMessageInterface: "macos" }),
+    );
+    expect(lines).toEqual([
+      "/commands — List all available commands",
+      "/models — List all available models",
+      "/status — Show conversation status and context usage",
+      "/btw — Ask a side question while the assistant is working",
+      "/fork — Fork the current conversation into a new branch",
+      "/pair — Generate pairing info for connecting a mobile device",
+    ]);
+    expect(lines).not.toContain(
+      "/model — Switch the active model",
+    );
+  });
+
+  test("renders iOS command help with /fork but without /pair", async () => {
+    const lines = await resolveCommandsLines(
+      makeSlashContext({ userMessageInterface: "ios" }),
+    );
+    expect(lines).toEqual([
+      "/commands — List all available commands",
+      "/models — List all available models",
+      "/status — Show conversation status and context usage",
+      "/btw — Ask a side question while the assistant is working",
+      "/fork — Fork the current conversation into a new branch",
+    ]);
+  });
+
+  test("renders explicit cli command help without /pair", async () => {
+    const lines = await resolveCommandsLines(
+      makeSlashContext({ userMessageInterface: "cli" }),
+    );
+    expect(lines).toEqual([
+      "/commands — List all available commands",
+      "/models — List all available models",
+      "/status — Show conversation status and context usage",
+      "/btw — Ask a side question while the assistant is working",
+    ]);
+  });
+
+  test("keeps legacy fallback help when no interface is provided", async () => {
+    const lines = await resolveCommandsLines(makeSlashContext());
+    expect(lines).toEqual([
+      "/commands — List all available commands",
+      "/models — List all available models",
+      "/pair — Generate pairing info for connecting a mobile device",
+      "/status — Show conversation status and context usage",
+    ]);
+  });
+
+  test("keeps context-free fallback without /status", async () => {
+    const lines = await resolveCommandsLines();
+    expect(lines).toEqual([
+      "/commands — List all available commands",
+      "/models — List all available models",
+      "/pair — Generate pairing info for connecting a mobile device",
+    ]);
+  });
+});
+
+describe("resolveSlash command contract", () => {
+  test("keeps unsupported slash forms as passthrough", async () => {
+    const slashForms = [
+      "/commands foo",
+      "/models foo",
+      "/status foo",
+      "/pair foo",
+      "/btw",
+    ];
+
+    for (const input of slashForms) {
+      const result = await resolveSlash(
+        input,
+        makeSlashContext({ userMessageInterface: "macos" }),
+      );
+      expect(result).toEqual({ kind: "passthrough", content: input });
+    }
+  });
+
+  test("rejects /pair on iOS interfaces", async () => {
+    const result = await resolveSlash(
+      "/pair",
+      makeSlashContext({ userMessageInterface: "ios" }),
+    );
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") {
+      throw new Error("Expected /pair on iOS to resolve to kind=unknown");
+    }
+    expect(result.message).toContain("only available in the macOS desktop app");
+  });
+
+  test("keeps /pair rejected for explicit non-macOS interfaces", async () => {
+    const result = await resolveSlash(
+      "/pair",
+      makeSlashContext({ userMessageInterface: "cli" }),
+    );
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") {
+      throw new Error("Expected /pair on cli to resolve to kind=unknown");
+    }
+    expect(result.message).toContain("only available in the macOS desktop app");
+  });
+
+  test("keeps /pair handling enabled on macOS interfaces", async () => {
+    const result = await resolveSlash(
+      "/pair",
+      makeSlashContext({ userMessageInterface: "macos" }),
+    );
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") {
+      throw new Error("Expected /pair on macOS to resolve to kind=unknown");
+    }
+    expect(result.message).toContain("Pairing is not available");
+  });
+});

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

@@ -549,7 +549,11 @@ describe("attachment reuse across conversation lifecycles", () => {
   test("attachment uploaded in conversation A is retrievable by ID without any conversation reference", async () => {
     const convA = createConversation("Conversation A");
     const msgA = await addMessage(convA.id, "assistant", "Here is a file");
-    const stored = uploadAttachment("report.pdf", "application/pdf", "JVBER");
+    const stored = uploadAttachment(
+      "report.pdf",
+      "application/pdf",
+      "JVBERA==",
+    );
     linkAttachmentToMessage(msgA.id, stored.id, 0);
 
     // Create a completely separate conversation
@@ -557,14 +561,14 @@ describe("attachment reuse across conversation lifecycles", () => {
     await addMessage(convB.id, "user", "hello");
 
     // The attachment is retrievable by ID regardless of which conversation is active.
-    const fetched = getAttachmentById(stored.id);
+    const fetched = getAttachmentById(stored.id, { hydrateFileData: true });
     expect(fetched).not.toBeNull();
     expect(fetched!.id).toBe(stored.id);
     expect(fetched!.originalFilename).toBe("report.pdf");
-    expect(fetched!.dataBase64).toBe("JVBER");
+    expect(fetched!.dataBase64).toBe("JVBERA==");
   });
 
-  test("attachment can be linked to messages in different conversations", async () => {
+  test("re-linking an attachment across conversations creates a conversation-local row", async () => {
     const convA = createConversation("Conversation A");
     const convB = createConversation("Conversation B");
 
@@ -576,17 +580,17 @@ describe("attachment reuse across conversation lifecycles", () => {
     linkAttachmentToMessage(msgA.id, stored.id, 0);
     linkAttachmentToMessage(msgB.id, stored.id, 0);
 
-    // Both messages see the attachment
+    // Both messages see the attachment, but each conversation keeps its own row.
     const linkedA = getAttachmentsForMessage(msgA.id);
     expect(linkedA).toHaveLength(1);
     expect(linkedA[0].id).toBe(stored.id);
 
     const linkedB = getAttachmentsForMessage(msgB.id);
     expect(linkedB).toHaveLength(1);
-    expect(linkedB[0].id).toBe(stored.id);
+    expect(linkedB[0].id).not.toBe(stored.id);
   });
 
-  test("deleting conversation A does not orphan attachment reused in conversation B", async () => {
+  test("deleting conversation A does not remove the copied attachment in conversation B", async () => {
     const convA = createConversation("Conversation A");
     const convB = createConversation("Conversation B");
 
@@ -600,33 +604,33 @@ describe("attachment reuse across conversation lifecycles", () => {
     const stored = uploadAttachment("chart.png", "image/png", "AAAA");
     linkAttachmentToMessage(msgA.id, stored.id, 0);
     linkAttachmentToMessage(msgB.id, stored.id, 0);
+    const linkedB = getAttachmentsForMessage(msgB.id);
+    expect(linkedB).toHaveLength(1);
 
     // Delete conversation A's exchange
     deleteLastExchange(convA.id);
 
-    // Attachment survives because convB still references it
-    const fetched = getAttachmentById(stored.id);
+    // Conversation B keeps its own attachment row and file.
+    const fetched = getAttachmentById(linkedB[0].id);
     expect(fetched).not.toBeNull();
 
     // convB's message still has the attachment linked
-    const linkedB = getAttachmentsForMessage(msgB.id);
-    expect(linkedB).toHaveLength(1);
-    expect(linkedB[0].id).toBe(stored.id);
+    const linkedBAfterDelete = getAttachmentsForMessage(msgB.id);
+    expect(linkedBAfterDelete).toHaveLength(1);
+    expect(linkedBAfterDelete[0].id).toBe(linkedB[0].id);
   });
 
-  test("content-hash dedup works across conversations", async () => {
+  test("identical uploads remain distinct across conversations", async () => {
     const convA = createConversation("Conversation A");
     const convB = createConversation("Conversation B");
 
     await addMessage(convA.id, "user", "upload in A");
     await addMessage(convB.id, "user", "upload in B");
 
-    // Same content uploaded in two different conversation contexts
     const first = uploadAttachment("photo.png", "image/png", "DEDUPCROSS");
     const second = uploadAttachment("photo.png", "image/png", "DEDUPCROSS");
 
-    // Dedup returns the same attachment row
-    expect(second.id).toBe(first.id);
+    expect(second.id).not.toBe(first.id);
   });
 });
 
@@ -664,7 +668,7 @@ describe("no private-conversation attachment visibility boundary", () => {
     expect(fetched!.originalFilename).toBe("secret.pdf");
   });
 
-  test("attachment from private conversation can be linked to a standard conversation message", async () => {
+  test("attachment from a private conversation is copied when linked into a standard conversation", async () => {
     const privateConv = createConversation({
       title: "Private",
       conversationType: "private",
@@ -695,7 +699,7 @@ describe("no private-conversation attachment visibility boundary", () => {
 
     const linkedStandard = getAttachmentsForMessage(standardMsg.id);
     expect(linkedStandard).toHaveLength(1);
-    expect(linkedStandard[0].id).toBe(stored.id);
+    expect(linkedStandard[0].id).not.toBe(stored.id);
   });
 
   test("getAttachmentsForMessage returns private conversation attachments", async () => {
@@ -712,7 +716,7 @@ describe("no private-conversation attachment visibility boundary", () => {
     expect(linked[0].id).toBe(stored.id);
   });
 
-  test("content-hash dedup works across private and standard conversations", () => {
+  test("identical uploads remain distinct across private and standard conversations", () => {
     createConversation({ title: "Private", conversationType: "private" });
     createConversation({ title: "Standard", conversationType: "standard" });
 
@@ -728,8 +732,7 @@ describe("no private-conversation attachment visibility boundary", () => {
       "CROSSCONVERSATION",
     );
 
-    // Dedup returns the same row — no conversation-type isolation
-    expect(fromStandard.id).toBe(fromPrivate.id);
+    expect(fromStandard.id).not.toBe(fromPrivate.id);
   });
 
   test("clearAll removes attachments from both private and standard conversations", async () => {

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

@@ -0,0 +1,246 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  createSurfaceMutex,
+  handleSurfaceAction,
+  type SurfaceConversationContext,
+  surfaceProxyResolver,
+} from "../daemon/conversation-surfaces.js";
+import type {
+  ServerMessage,
+  SurfaceData,
+  SurfaceType,
+} from "../daemon/message-protocol.js";
+
+/**
+ * Build a minimal SurfaceConversationContext for testing.
+ * Tracks calls to enqueueMessage and processMessage so tests can assert
+ * whether an LLM turn was triggered.
+ */
+function makeContext(opts?: {
+  sent?: ServerMessage[];
+}): SurfaceConversationContext & {
+  enqueueCalls: Array<{ content: string; requestId: string }>;
+  processCalls: Array<{ content: string; requestId?: string }>;
+} {
+  const sent = opts?.sent ?? [];
+  const enqueueCalls: Array<{ content: string; requestId: string }> = [];
+  const processCalls: Array<{ content: string; requestId?: string }> = [];
+
+  return {
+    conversationId: "test-session",
+    traceEmitter: { emit: () => {} },
+    sendToClient: (msg) => sent.push(msg),
+    pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
+    lastSurfaceAction: new Map<
+      string,
+      { actionId: string; data?: Record<string, unknown> }
+    >(),
+    surfaceState: new Map<
+      string,
+      { surfaceType: SurfaceType; data: SurfaceData; title?: string }
+    >(),
+    surfaceUndoStacks: new Map<string, string[]>(),
+    accumulatedSurfaceState: new Map<string, Record<string, unknown>>(),
+    surfaceActionRequestIds: new Set<string>(),
+    currentTurnSurfaces: [],
+    isProcessing: () => false,
+    enqueueMessage: (content, _attachments, _onEvent, requestId) => {
+      enqueueCalls.push({ content, requestId });
+      return { queued: false, requestId };
+    },
+    getQueueDepth: () => 0,
+    processMessage: async (content, _attachments, _onEvent, requestId) => {
+      processCalls.push({ content, requestId });
+      return "ok";
+    },
+    withSurface: createSurfaceMutex(),
+    enqueueCalls,
+    processCalls,
+  };
+}
+
+/** Register a dynamic_page surface in the context so state_update is accepted. */
+function registerDynamicPage(
+  ctx: SurfaceConversationContext,
+  surfaceId: string,
+): void {
+  ctx.pendingSurfaceActions.set(surfaceId, { surfaceType: "dynamic_page" });
+  ctx.surfaceState.set(surfaceId, {
+    surfaceType: "dynamic_page",
+    data: { html: "<div>test</div>" } as SurfaceData,
+  });
+}
+
+describe("state_update silent accumulation", () => {
+  test("accumulates state from multiple calls via shallow merge", () => {
+    const ctx = makeContext();
+    registerDynamicPage(ctx, "surface-1");
+
+    handleSurfaceAction(ctx, "surface-1", "state_update", { page: 2 });
+    handleSurfaceAction(ctx, "surface-1", "state_update", {
+      selectedTab: "overview",
+    });
+    handleSurfaceAction(ctx, "surface-1", "state_update", { page: 5 });
+
+    const accumulated = ctx.accumulatedSurfaceState.get("surface-1");
+    expect(accumulated).toEqual({ page: 5, selectedTab: "overview" });
+  });
+
+  test("ignores calls with undefined data", () => {
+    const ctx = makeContext();
+    registerDynamicPage(ctx, "surface-1");
+
+    handleSurfaceAction(ctx, "surface-1", "state_update", { count: 1 });
+    handleSurfaceAction(ctx, "surface-1", "state_update", undefined);
+
+    const accumulated = ctx.accumulatedSurfaceState.get("surface-1");
+    expect(accumulated).toEqual({ count: 1 });
+  });
+
+  test("does not accumulate for non-dynamic_page surfaces", () => {
+    const ctx = makeContext();
+    // Register as a table surface instead of dynamic_page
+    ctx.pendingSurfaceActions.set("surface-table", { surfaceType: "table" });
+    ctx.surfaceState.set("surface-table", {
+      surfaceType: "table",
+      data: {
+        columns: [],
+        rows: [],
+      } as unknown as SurfaceData,
+    });
+
+    handleSurfaceAction(ctx, "surface-table", "state_update", { page: 1 });
+
+    const accumulated = ctx.accumulatedSurfaceState.get("surface-table");
+    expect(accumulated).toBeUndefined();
+  });
+});
+
+describe("state_update does not trigger LLM", () => {
+  test("does not call enqueueMessage or processMessage", () => {
+    const ctx = makeContext();
+    registerDynamicPage(ctx, "surface-1");
+
+    handleSurfaceAction(ctx, "surface-1", "state_update", {
+      currentSlide: 3,
+    });
+
+    expect(ctx.enqueueCalls).toHaveLength(0);
+    expect(ctx.processCalls).toHaveLength(0);
+  });
+
+  test("does not add to surfaceActionRequestIds", () => {
+    const ctx = makeContext();
+    registerDynamicPage(ctx, "surface-1");
+
+    handleSurfaceAction(ctx, "surface-1", "state_update", { zoom: 1.5 });
+
+    expect(ctx.surfaceActionRequestIds.size).toBe(0);
+  });
+});
+
+describe("accumulated state injection into reactive actions", () => {
+  test("subsequent reactive action includes accumulated state in message content", () => {
+    const ctx = makeContext();
+    registerDynamicPage(ctx, "surface-1");
+
+    // Accumulate some state
+    handleSurfaceAction(ctx, "surface-1", "state_update", { page: 3 });
+    handleSurfaceAction(ctx, "surface-1", "state_update", {
+      selectedItem: "item-42",
+    });
+
+    // Fire a reactive action (e.g. "save")
+    handleSurfaceAction(ctx, "surface-1", "save");
+
+    // The enqueueMessage call should include the accumulated state
+    expect(ctx.enqueueCalls).toHaveLength(1);
+    const content = ctx.enqueueCalls[0].content;
+    expect(content).toContain("Accumulated surface state:");
+    expect(content).toContain('"page":3');
+    expect(content).toContain('"selectedItem":"item-42"');
+  });
+
+  test("empty accumulated state is not appended", () => {
+    const ctx = makeContext();
+    registerDynamicPage(ctx, "surface-1");
+
+    // Fire a reactive action without any prior state_update
+    handleSurfaceAction(ctx, "surface-1", "refresh");
+
+    expect(ctx.enqueueCalls).toHaveLength(1);
+    const content = ctx.enqueueCalls[0].content;
+    expect(content).not.toContain("Accumulated surface state:");
+  });
+});
+
+describe("per-surface state isolation", () => {
+  test("accumulated state from surface A does not appear in surface B reactive action", () => {
+    const ctx = makeContext();
+    registerDynamicPage(ctx, "surface-a");
+    registerDynamicPage(ctx, "surface-b");
+
+    // Accumulate state only on surface A
+    handleSurfaceAction(ctx, "surface-a", "state_update", {
+      filterA: "active",
+    });
+
+    // Fire a reactive action on surface B
+    handleSurfaceAction(ctx, "surface-b", "submit");
+
+    expect(ctx.enqueueCalls).toHaveLength(1);
+    const content = ctx.enqueueCalls[0].content;
+    expect(content).not.toContain("filterA");
+    expect(content).not.toContain("Accumulated surface state:");
+  });
+
+  test("each surface maintains its own accumulated state", () => {
+    const ctx = makeContext();
+    registerDynamicPage(ctx, "surface-a");
+    registerDynamicPage(ctx, "surface-b");
+
+    handleSurfaceAction(ctx, "surface-a", "state_update", { page: 1 });
+    handleSurfaceAction(ctx, "surface-b", "state_update", { page: 99 });
+
+    expect(ctx.accumulatedSurfaceState.get("surface-a")).toEqual({ page: 1 });
+    expect(ctx.accumulatedSurfaceState.get("surface-b")).toEqual({ page: 99 });
+  });
+});
+
+describe("cleanup on dismiss", () => {
+  test("ui_dismiss clears accumulated state for the surface", async () => {
+    const ctx = makeContext();
+    registerDynamicPage(ctx, "surface-1");
+
+    // Accumulate state
+    handleSurfaceAction(ctx, "surface-1", "state_update", { dirty: true });
+    expect(ctx.accumulatedSurfaceState.get("surface-1")).toEqual({
+      dirty: true,
+    });
+
+    // Dismiss via surfaceProxyResolver (ui_dismiss)
+    await surfaceProxyResolver(ctx, "ui_dismiss", {
+      surface_id: "surface-1",
+    });
+
+    // Accumulated state should be cleared
+    expect(ctx.accumulatedSurfaceState.has("surface-1")).toBe(false);
+  });
+
+  test("ui_dismiss does not affect other surfaces accumulated state", async () => {
+    const ctx = makeContext();
+    registerDynamicPage(ctx, "surface-1");
+    registerDynamicPage(ctx, "surface-2");
+
+    handleSurfaceAction(ctx, "surface-1", "state_update", { x: 1 });
+    handleSurfaceAction(ctx, "surface-2", "state_update", { y: 2 });
+
+    await surfaceProxyResolver(ctx, "ui_dismiss", {
+      surface_id: "surface-1",
+    });
+
+    expect(ctx.accumulatedSurfaceState.has("surface-1")).toBe(false);
+    expect(ctx.accumulatedSurfaceState.get("surface-2")).toEqual({ y: 2 });
+  });
+});

package/src/__tests__/conversation-surfaces-task-progress.test.ts

@@ -34,6 +34,7 @@ function makeContext(
       { surfaceType: SurfaceType; data: SurfaceData; title?: string }
     >(),
     surfaceUndoStacks: new Map<string, string[]>(),
+    accumulatedSurfaceState: new Map<string, Record<string, unknown>>(),
     surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
     isProcessing: () => false,

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

@@ -0,0 +1,137 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const mockRunBtwSidechain = mock(async () => ({
+  text: "Project kickoff",
+  hadTextDeltas: true,
+  response: {
+    content: [{ type: "text", text: "Project kickoff" }],
+    model: "test-model",
+    usage: { inputTokens: 10, outputTokens: 5 },
+    stopReason: "end_turn",
+  },
+}));
+
+const mockGetConversation = mock(
+  (_conversationId: string) =>
+    ({
+      title: "Generating title...",
+      isAutoTitle: 1,
+    }) as {
+      title: string;
+      isAutoTitle: number;
+    },
+);
+const mockGetMessages = mock(() => [
+  { role: "user", content: "first message" },
+  { role: "assistant", content: "first reply" },
+  { role: "user", content: "follow-up" },
+]);
+const mockUpdateConversationTitle = mock(() => {});
+const mockGetConfiguredProvider = mock(async () => null);
+const mockGetConfig = mock(() => ({
+  daemon: {
+    titleGenerationMaxTokens: 37,
+  },
+}));
+
+mock.module("../runtime/btw-sidechain.js", () => ({
+  runBtwSidechain: mockRunBtwSidechain,
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getConversation: mockGetConversation,
+  getMessages: mockGetMessages,
+  updateConversationTitle: mockUpdateConversationTitle,
+}));
+
+mock.module("../providers/provider-send-message.js", () => ({
+  getConfiguredProvider: mockGetConfiguredProvider,
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: mockGetConfig,
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import {
+  generateAndPersistConversationTitle,
+  regenerateConversationTitle,
+} from "../memory/conversation-title-service.js";
+
+describe("conversation-title-service", () => {
+  beforeEach(() => {
+    mockRunBtwSidechain.mockClear();
+    mockGetConversation.mockClear();
+    mockGetMessages.mockClear();
+    mockUpdateConversationTitle.mockClear();
+    mockGetConfiguredProvider.mockClear();
+    mockGetConfig.mockClear();
+  });
+
+  test("uses the BTW side-chain helper for initial title generation", async () => {
+    const provider = {
+      name: "test-provider",
+      sendMessage: mock(async () => {
+        throw new Error("provider.sendMessage should not be called directly");
+      }),
+    };
+
+    const result = await generateAndPersistConversationTitle({
+      conversationId: "conv-1",
+      provider,
+      userMessage: "Help me plan the kickoff",
+    });
+
+    expect(result).toEqual({ title: "Project kickoff", updated: true });
+    expect(mockRunBtwSidechain).toHaveBeenCalledTimes(1);
+    expect(mockRunBtwSidechain).toHaveBeenCalledWith(
+      expect.objectContaining({
+        provider,
+        maxTokens: 37,
+        modelIntent: "latency-optimized",
+        timeoutMs: 10_000,
+      }),
+    );
+    expect(mockUpdateConversationTitle).toHaveBeenCalledWith(
+      "conv-1",
+      "Project kickoff",
+      1,
+    );
+  });
+
+  test("uses the BTW side-chain helper for title regeneration", async () => {
+    const provider = {
+      name: "test-provider",
+      sendMessage: mock(async () => {
+        throw new Error("provider.sendMessage should not be called directly");
+      }),
+    };
+
+    const result = await regenerateConversationTitle({
+      conversationId: "conv-1",
+      provider,
+    });
+
+    expect(result).toEqual({ title: "Project kickoff", updated: true });
+    expect(mockRunBtwSidechain).toHaveBeenCalledTimes(1);
+    expect(mockRunBtwSidechain).toHaveBeenCalledWith(
+      expect.objectContaining({
+        provider,
+        maxTokens: 37,
+        modelIntent: "latency-optimized",
+        timeoutMs: 10_000,
+      }),
+    );
+    expect(mockUpdateConversationTitle).toHaveBeenCalledWith(
+      "conv-1",
+      "Project kickoff",
+      1,
+    );
+  });
+});