@vellumai/assistant 0.8.1 → 0.8.2

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

@@ -6,6 +6,10 @@ import type {
   CheckpointInfo,
 } from "../agent/loop.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
+import {
+  conversationMessagesSyncTag,
+  type SyncChangedMessage,
+} from "../daemon/message-types/sync.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
@@ -60,7 +64,10 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
-    memory: { v2: { enabled: false } },
+    memory: {
+      v2: { enabled: false },
+      retrieval: { scratchpadInjection: { enabled: true } },
+    },
     conversations: { skipAutoRetitling: false },
     daemon: {
       startupSocketWaitMs: 5000,
@@ -272,6 +279,8 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 // ---------------------------------------------------------------------------
 
 import { Conversation } from "../daemon/conversation.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { waitFor } from "./helpers/wait-for.js";
 
 type ConversationWithWorkspaceDeps = Conversation & {
   getWorkspaceGitService?: (_workspaceDir: string) => {
@@ -342,6 +351,25 @@ function resolveRun(index: number) {
   run.resolve([...run.messages, assistantMsg]);
 }
 
+function syncChangedMessages(): {
+  messages: SyncChangedMessage[];
+  dispose: () => void;
+} {
+  const messages: SyncChangedMessage[] = [];
+  const subscription = assistantEventHub.subscribe({
+    type: "process",
+    callback: (event) => {
+      if (event.message.type === "sync_changed") {
+        messages.push(event.message);
+      }
+    },
+  });
+  return {
+    messages,
+    dispose: () => subscription.dispose(),
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -485,4 +513,34 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     resolveRun(2);
     await new Promise((r) => setTimeout(r, 50));
   });
+
+  test("/compact failure still emits message-history sync after persisting the user message", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    conversation.forceCompact = async () => {
+      throw new Error("compaction failed");
+    };
+
+    const sync = syncChangedMessages();
+    try {
+      await expect(
+        conversation.processMessage("/compact", [], () => {}, "req-compact"),
+      ).rejects.toThrow("compaction failed");
+
+      await waitFor(
+        () =>
+          sync.messages.some(
+            (message) =>
+              message.tags.length === 1 &&
+              message.tags[0] === conversationMessagesSyncTag("conv-1"),
+          ),
+        {
+          message:
+            "Timed out waiting for /compact failure message-history sync tag",
+        },
+      );
+    } finally {
+      sync.dispose();
+    }
+  });
 });

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

@@ -60,7 +60,10 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
-    memory: { v2: { enabled: false } },
+    memory: {
+      v2: { enabled: false },
+      retrieval: { scratchpadInjection: { enabled: true } },
+    },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,

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

@@ -0,0 +1,360 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  createSurfaceMutex,
+  handleSurfaceAction,
+  type SurfaceConversationContext,
+} from "../daemon/conversation-surfaces.js";
+import type {
+  ServerMessage,
+  SurfaceData,
+  SurfaceType,
+} from "../daemon/message-protocol.js";
+
+/**
+ * Build a minimal SurfaceConversationContext for testing table surface actions.
+ * Tracks calls to enqueueMessage and processMessage so tests can assert
+ * whether an LLM turn was triggered with the correct content.
+ */
+function makeContext(): SurfaceConversationContext & {
+  enqueueCalls: Array<{
+    content: string;
+    requestId: string;
+    attachments: unknown[];
+    surfaceId?: string;
+    displayContent?: string;
+  }>;
+  processCalls: Array<{
+    content: string;
+    requestId?: string;
+    attachments: unknown[];
+    surfaceId?: string;
+    displayContent?: string;
+  }>;
+  sentMessages: ServerMessage[];
+} {
+  const enqueueCalls: Array<{
+    content: string;
+    requestId: string;
+    attachments: unknown[];
+    surfaceId?: string;
+    displayContent?: string;
+  }> = [];
+  const processCalls: Array<{
+    content: string;
+    requestId?: string;
+    attachments: unknown[];
+    surfaceId?: string;
+    displayContent?: string;
+  }> = [];
+  const sentMessages: ServerMessage[] = [];
+
+  return {
+    conversationId: "test-convo",
+    traceEmitter: { emit: () => {} },
+    sendToClient: (msg) => sentMessages.push(msg),
+    pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
+    lastSurfaceAction: new Map<
+      string,
+      { actionId: string; data?: Record<string, unknown> }
+    >(),
+    surfaceState: new Map(),
+    surfaceUndoStacks: new Map(),
+    accumulatedSurfaceState: new Map(),
+    surfaceActionRequestIds: new Set<string>(),
+    currentTurnSurfaces: [],
+    isProcessing: () => false,
+    enqueueMessage: (
+      content,
+      attachments,
+      _onEvent,
+      requestId,
+      surfaceId,
+      _currentPage,
+      _metadata,
+      _options,
+      displayContent,
+    ) => {
+      enqueueCalls.push({
+        content,
+        requestId: requestId ?? "enq-req",
+        attachments,
+        surfaceId,
+        displayContent,
+      });
+      return { queued: false, requestId: requestId ?? "enq-req" };
+    },
+    getQueueDepth: () => 0,
+    processMessage: async (
+      content,
+      attachments,
+      _onEvent,
+      requestId,
+      surfaceId,
+      _currentPage,
+      _options,
+      displayContent,
+    ) => {
+      processCalls.push({
+        content,
+        requestId,
+        attachments,
+        surfaceId,
+        displayContent,
+      });
+      return "ok";
+    },
+    withSurface: createSurfaceMutex(),
+    enqueueCalls,
+    processCalls,
+    sentMessages,
+  };
+}
+
+/**
+ * Register a table surface with selectionMode and action buttons,
+ * mimicking what surfaceProxyResolver does for ui_show with await_action.
+ */
+function registerTableSurface(
+  ctx: SurfaceConversationContext,
+  surfaceId: string,
+  opts?: {
+    selectionMode?: "single" | "multiple" | "none";
+    rows?: Array<{
+      id: string;
+      cells: Record<string, string>;
+      selectable?: boolean;
+    }>;
+    actions?: Array<{
+      id: string;
+      label: string;
+      style?: string;
+      data?: Record<string, unknown>;
+    }>;
+  },
+): void {
+  const rows = opts?.rows ?? [
+    {
+      id: "r1",
+      cells: { from: "alice@example.com", subject: "Meeting" },
+      selectable: true,
+    },
+    {
+      id: "r2",
+      cells: { from: "bob@example.com", subject: "Update" },
+      selectable: true,
+    },
+    {
+      id: "r3",
+      cells: { from: "carol@example.com", subject: "Invoice" },
+      selectable: true,
+    },
+  ];
+  const actions = opts?.actions ?? [
+    { id: "archive", label: "Archive Selected", style: "primary" },
+    { id: "delete", label: "Delete Selected", style: "destructive" },
+  ];
+
+  const data = {
+    columns: [
+      { id: "from", label: "From" },
+      { id: "subject", label: "Subject" },
+    ],
+    rows,
+    selectionMode: opts?.selectionMode ?? "multiple",
+  };
+
+  ctx.surfaceState.set(surfaceId, {
+    surfaceType: "table",
+    data: data as unknown as SurfaceData,
+    title: "Test Table",
+    actions,
+  });
+
+  ctx.pendingSurfaceActions.set(surfaceId, { surfaceType: "table" });
+}
+
+describe("table surface action with selectedIds", () => {
+  test("action button click with selectedIds triggers LLM message", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-1");
+
+    await handleSurfaceAction(ctx, "table-1", "archive", {
+      selectedIds: ["r1", "r3"],
+    });
+
+    // Should trigger processMessage (not enqueued since not processing)
+    expect(ctx.processCalls).toHaveLength(1);
+    const msg = ctx.processCalls[0];
+
+    // Content should include action summary
+    expect(msg.content).toContain("[User action on table surface:");
+
+    // Content should include selectedIds in action data
+    expect(msg.content).toContain("selectedIds");
+    expect(msg.content).toContain("r1");
+    expect(msg.content).toContain("r3");
+
+    // Content should include deselection description (r2 was not selected)
+    expect(msg.content).toContain("Deselected items");
+    expect(msg.content).toContain("bob@example.com");
+
+    // Should NOT contain alice or carol in deselection (they were selected)
+    expect(msg.content).not.toContain("alice@example.com");
+    expect(msg.content).not.toContain("carol@example.com");
+  });
+
+  test("action button click without selectedIds still triggers LLM message", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-2");
+
+    await handleSurfaceAction(ctx, "table-2", "archive", undefined);
+
+    expect(ctx.processCalls).toHaveLength(1);
+    expect(ctx.processCalls[0].content).toContain(
+      "[User action on table surface:",
+    );
+  });
+
+  test("selectedIds are included via action data merge", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-3");
+
+    await handleSurfaceAction(ctx, "table-3", "archive", {
+      selectedIds: ["r2"],
+    });
+
+    expect(ctx.processCalls).toHaveLength(1);
+    const content = ctx.processCalls[0].content;
+
+    // Action data should contain selectedIds
+    expect(content).toContain('"selectedIds":["r2"]');
+
+    // Deselection should show r1 and r3 (not selected)
+    expect(content).toContain("Deselected items");
+    expect(content).toContain("alice@example.com");
+    expect(content).toContain("carol@example.com");
+  });
+
+  test("pending surface action is cleared after processing", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-4");
+
+    expect(ctx.pendingSurfaceActions.has("table-4")).toBe(true);
+
+    await handleSurfaceAction(ctx, "table-4", "archive", {
+      selectedIds: ["r1"],
+    });
+
+    // Non-dynamic_page pending entries are cleared after action
+    expect(ctx.pendingSurfaceActions.has("table-4")).toBe(false);
+  });
+
+  test("action with stored action data merges with client data", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-5", {
+      actions: [
+        {
+          id: "archive",
+          label: "Archive",
+          style: "primary",
+          data: { destination: "archive-folder" },
+        },
+      ],
+    });
+
+    await handleSurfaceAction(ctx, "table-5", "archive", {
+      selectedIds: ["r1", "r2"],
+    });
+
+    expect(ctx.processCalls).toHaveLength(1);
+    const content = ctx.processCalls[0].content;
+
+    // Both stored action data and client data should be present
+    expect(content).toContain("destination");
+    expect(content).toContain("archive-folder");
+    expect(content).toContain("selectedIds");
+  });
+
+  test("relay_prompt action on table includes selectedIds context", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-6", {
+      actions: [
+        {
+          id: "relay_prompt",
+          label: "Archive",
+          style: "primary",
+          data: { prompt: "Archive these selected items" },
+        },
+      ],
+    });
+
+    await handleSurfaceAction(ctx, "table-6", "relay_prompt", {
+      selectedIds: ["r1"],
+    });
+
+    expect(ctx.processCalls).toHaveLength(1);
+    const content = ctx.processCalls[0].content;
+
+    // relay_prompt should use the prompt as content
+    expect(content).toContain("Archive these selected items");
+
+    // Should also include deselection context
+    expect(content).toContain("Deselected items");
+  });
+
+  test("selection_changed action is non-terminal and does not trigger LLM", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-7");
+
+    await handleSurfaceAction(ctx, "table-7", "selection_changed", {
+      selectedIds: ["r1", "r2"],
+    });
+
+    expect(ctx.enqueueCalls).toHaveLength(0);
+    expect(ctx.processCalls).toHaveLength(0);
+
+    // Pending surface should still be present (not consumed)
+    expect(ctx.pendingSurfaceActions.has("table-7")).toBe(true);
+  });
+
+  test("all rows selected produces no deselection description", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-8");
+
+    await handleSurfaceAction(ctx, "table-8", "archive", {
+      selectedIds: ["r1", "r2", "r3"],
+    });
+
+    expect(ctx.processCalls).toHaveLength(1);
+    const content = ctx.processCalls[0].content;
+
+    // No deselection when all are selected
+    expect(content).not.toContain("Deselected items");
+  });
+
+  test("displayContent is set for non-relay actions", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-9");
+
+    await handleSurfaceAction(ctx, "table-9", "archive", {
+      selectedIds: ["r1"],
+    });
+
+    expect(ctx.processCalls).toHaveLength(1);
+    // displayContent should be set for non-relay actions
+    expect(ctx.processCalls[0].displayContent).toBeDefined();
+  });
+
+  test("surfaceId is forwarded to processMessage", async () => {
+    const ctx = makeContext();
+    registerTableSurface(ctx, "table-10");
+
+    await handleSurfaceAction(ctx, "table-10", "archive", {
+      selectedIds: ["r1"],
+    });
+
+    expect(ctx.processCalls).toHaveLength(1);
+    expect(ctx.processCalls[0].surfaceId).toBe("table-10");
+  });
+});

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

@@ -0,0 +1,235 @@
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  conversationMetadataSyncTag,
+  SYNC_TAGS,
+} from "../daemon/message-types/sync.js";
+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 { 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 { waitFor } from "./helpers/wait-for.js";
+
+initializeDb();
+
+function clearTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM conversation_assistant_attention_state");
+  db.run("DELETE FROM external_conversation_bindings");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+function findRoute(
+  routes: RouteDefinition[],
+  operationId: string,
+): RouteDefinition {
+  const route = routes.find(
+    (candidate) => candidate.operationId === operationId,
+  );
+  if (!route) {
+    throw new Error(`Route ${operationId} not found`);
+  }
+  return route;
+}
+
+async function captureEvents(
+  action: () => void | Promise<unknown>,
+  expectedCount: number,
+): Promise<AssistantEvent[]> {
+  const received: AssistantEvent[] = [];
+  const subscription = assistantEventHub.subscribe({
+    type: "process",
+    callback: (event) => {
+      received.push(event);
+    },
+  });
+  try {
+    await action();
+    await waitFor(() => received.length >= expectedCount, {
+      message: "Timed out waiting for conversation sync tag event",
+    });
+    return received;
+  } finally {
+    subscription.dispose();
+  }
+}
+
+describe("conversation sync tags", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  afterAll(() => {
+    resetDb();
+  });
+
+  test("rename emits legacy title/list events and conversation metadata sync tags", async () => {
+    const conversation = createConversation("Old title");
+    const route = findRoute(
+      CONVERSATION_MANAGEMENT_ROUTES,
+      "renameConversation",
+    );
+
+    const received = await captureEvents(() => {
+      route.handler({
+        pathParams: { id: conversation.id },
+        body: { name: "New title" },
+      });
+    }, 3);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_title_updated",
+      "conversation_list_invalidated",
+      "sync_changed",
+    ]);
+    expect(received[2]!.message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMetadataSyncTag(conversation.id),
+      ],
+    });
+  });
+
+  test("create emits legacy list invalidation and list/metadata sync tags", async () => {
+    const route = findRoute(
+      CONVERSATION_MANAGEMENT_ROUTES,
+      "createConversation",
+    );
+    let conversationId: string | undefined;
+
+    const received = await captureEvents(async () => {
+      const result = (await route.handler({
+        body: { conversationKey: "sync-create-test" },
+      })) as { id: string };
+      conversationId = result.id;
+    }, 2);
+
+    expect(conversationId).toBeDefined();
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_list_invalidated",
+      "sync_changed",
+    ]);
+    expect(received[1]!.message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMetadataSyncTag(conversationId!),
+      ],
+    });
+  });
+
+  test("reorder emits list invalidation and metadata sync tags for touched conversations", async () => {
+    const first = createConversation("First");
+    const second = createConversation("Second");
+    const route = findRoute(
+      CONVERSATION_MANAGEMENT_ROUTES,
+      "reorderConversations",
+    );
+
+    const received = await captureEvents(() => {
+      route.handler({
+        body: {
+          updates: [
+            { conversationId: first.id, displayOrder: 1, isPinned: true },
+            { conversationId: second.id, displayOrder: 2, isPinned: false },
+          ],
+        },
+      });
+    }, 2);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_list_invalidated",
+      "sync_changed",
+    ]);
+    expect(received[1]!.message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMetadataSyncTag(first.id),
+        conversationMetadataSyncTag(second.id),
+      ],
+    });
+  });
+
+  test("record seen emits list invalidation and metadata sync tags for the touched conversation", async () => {
+    const conversation = createConversation("Attention");
+    projectAssistantMessage({
+      conversationId: conversation.id,
+      messageId: "assistant-message-1",
+      messageAt: 1_700_000_000_000,
+    });
+    const route = findRoute(CONVERSATION_LIST_ROUTES, "recordConversationSeen");
+
+    const received = await captureEvents(() => {
+      route.handler({
+        body: {
+          conversationId: conversation.id,
+          sourceChannel: "vellum",
+          signalType: "macos_conversation_opened",
+          confidence: "explicit",
+          source: "test",
+        },
+      });
+    }, 2);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_list_invalidated",
+      "sync_changed",
+    ]);
+    expect(received[1]!.message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMetadataSyncTag(conversation.id),
+      ],
+    });
+  });
+
+  test("mark unread emits list invalidation and metadata sync tags for the touched conversation", async () => {
+    const conversation = createConversation("Attention");
+    projectAssistantMessage({
+      conversationId: conversation.id,
+      messageId: "assistant-message-1",
+      messageAt: 1_700_000_000_000,
+    });
+    recordConversationSeenSignal({
+      conversationId: conversation.id,
+      sourceChannel: "vellum",
+      signalType: "macos_conversation_opened",
+      confidence: "explicit",
+      source: "test",
+    });
+    const route = findRoute(CONVERSATION_LIST_ROUTES, "markConversationUnread");
+
+    const received = await captureEvents(() => {
+      route.handler({
+        body: {
+          conversationId: conversation.id,
+        },
+      });
+    }, 2);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_list_invalidated",
+      "sync_changed",
+    ]);
+    expect(received[1]!.message).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMetadataSyncTag(conversation.id),
+      ],
+    });
+  });
+});

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

@@ -63,7 +63,11 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
-    memory: { enabled: false, v2: { enabled: false } },
+    memory: {
+      enabled: false,
+      v2: { enabled: false },
+      retrieval: { scratchpadInjection: { enabled: true } },
+    },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,