@vellumai/assistant 0.8.0 → 0.8.2

package/src/proactive-artifact/job.test.ts

@@ -1,5 +1,10 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import {
+  conversationMessagesSyncTag,
+  SYNC_TAGS,
+} from "../daemon/message-types/sync.js";
+
 // ── Mock state ──────────────────────────────────────────────────────────
 
 // Provider mock
@@ -51,9 +56,15 @@ mock.module("../providers/provider-send-message.js", () => ({
 
 // rawAll mock
 let rawAllRows: Array<{ role: string; content: string }> = [];
+let rawAllLastSql = "";
+let rawAllLastArgs: unknown[] = [];
 
 mock.module("../memory/raw-query.js", () => ({
-  rawAll: () => rawAllRows,
+  rawAll: (sql: string, ...args: unknown[]) => {
+    rawAllLastSql = sql;
+    rawAllLastArgs = args;
+    return rawAllRows;
+  },
   rawRun: () => 0,
 }));
 
@@ -279,6 +290,8 @@ function resetState() {
   copyResponse = "";
   providerSendCalls = [];
   rawAllRows = [];
+  rawAllLastSql = "";
+  rawAllLastArgs = [];
   bootstrapCalls = [];
   processMessageCalls = [];
   processMessageShouldThrow = false;
@@ -645,7 +658,7 @@ describe("runProactiveArtifactJob", () => {
   });
 
   describe("Transcript collection", () => {
-    test("dual-condition transcript query uses userMessageCutoff and assistantMessageId", async () => {
+    test("transcript query is scoped to the triggering conversation", async () => {
       rawAllRows = defaultTranscript;
       decisionResponse = decisionNo;
 
@@ -656,8 +669,8 @@ describe("runProactiveArtifactJob", () => {
         broadcastMessage: mockBroadcast,
       });
 
-      // The rawAll mock captures all calls; verify the decision was called
-      // (proving transcript was collected and passed to decision)
+      expect(rawAllLastSql).toContain("AND m.conversation_id = ?");
+      expect(rawAllLastArgs).toEqual(["conv-1", 5000, "asst-msg-99"]);
       expect(
         providerSendCalls.some(
           (c) => c.callSite === "proactiveArtifactDecision",
@@ -683,7 +696,7 @@ describe("runProactiveArtifactJob", () => {
 });
 
 describe("injectAuxAssistantMessage", () => {
-  test("idle conversation: persists with skipIndexing, pushes to getMessages(), broadcasts delta + complete(aux) + list_invalidated", async () => {
+  test("idle conversation: persists with skipIndexing, pushes to getMessages(), broadcasts delta + complete(aux) + list sync", async () => {
     const messages: unknown[] = [];
     mockConversations.set("conv-inject-1", {
       processing: false,
@@ -706,7 +719,7 @@ describe("injectAuxAssistantMessage", () => {
     // Pushed to in-memory messages
     expect(messages).toHaveLength(1);
 
-    // Broadcasts: delta, complete(aux), list_invalidated
+    // Broadcasts: delta, complete(aux), list invalidation + sync tag
     const deltaMsg = broadcastCalls.find(
       (c) => c.type === "assistant_text_delta",
     );
@@ -726,6 +739,15 @@ describe("injectAuxAssistantMessage", () => {
     );
     expect(listMsg).toBeDefined();
     expect(listMsg!.reason).toBe("reordered");
+
+    const syncMsg = broadcastCalls.find((c) => c.type === "sync_changed");
+    expect(syncMsg).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMessagesSyncTag("conv-inject-1"),
+      ],
+    });
   });
 
   test("processing → idle: waits for processing to become false before persisting", async () => {
@@ -816,13 +838,22 @@ describe("injectAuxAssistantMessage", () => {
       broadcastCalls.filter((c) => c.type === "message_complete"),
     ).toHaveLength(0);
 
-    // But list_invalidated IS sent (always sent regardless of processing state)
+    // But list invalidation + sync tag ARE sent regardless of processing state.
     expect(
       broadcastCalls.filter((c) => c.type === "conversation_list_invalidated"),
     ).toHaveLength(1);
+    expect(broadcastCalls.filter((c) => c.type === "sync_changed")).toEqual([
+      {
+        type: "sync_changed",
+        tags: [
+          SYNC_TAGS.conversationsList,
+          conversationMessagesSyncTag("conv-inject-3"),
+        ],
+      },
+    ]);
   });
 
-  test("inactive/unloaded conversation: persists + list_invalidated only", async () => {
+  test("inactive/unloaded conversation: persists + list sync only", async () => {
     // No conversation in the store
     await injectAuxAssistantMessage({
       conversationId: "conv-inject-4",
@@ -842,10 +873,19 @@ describe("injectAuxAssistantMessage", () => {
       broadcastCalls.filter((c) => c.type === "message_complete"),
     ).toHaveLength(0);
 
-    // But list_invalidated IS sent
+    // But list invalidation + sync tag ARE sent
     expect(
       broadcastCalls.filter((c) => c.type === "conversation_list_invalidated"),
     ).toHaveLength(1);
+    expect(broadcastCalls.filter((c) => c.type === "sync_changed")).toEqual([
+      {
+        type: "sync_changed",
+        tags: [
+          SYNC_TAGS.conversationsList,
+          conversationMessagesSyncTag("conv-inject-4"),
+        ],
+      },
+    ]);
   });
 });
 

package/src/proactive-artifact/job.ts

@@ -57,12 +57,16 @@ export async function runProactiveArtifactJob(params: {
   let buildSucceeded = false;
   try {
     // ── Collect transcript (bounded) ────────────────────────────────
+    // The trigger window is workspace-wide, but raw transcript context sent to
+    // the LLM must stay scoped to the conversation that fired the job.
     const rows = rawAll<{ role: string; content: string }>(
       `SELECT m.role, m.content FROM messages m
        JOIN conversations c ON m.conversation_id = c.id
        WHERE c.conversation_type = 'standard'
+         AND m.conversation_id = ?
          AND (m.created_at <= ? OR m.id = ?)
        ORDER BY m.created_at ASC`,
+      params.conversationId,
       params.userMessageCutoff,
       params.assistantMessageId ?? "",
     );

package/src/proactive-artifact/trigger-state.test.ts

@@ -123,6 +123,15 @@ describe("trigger-state", () => {
       expect(getUserMessageCountUpTo(350)).toBe(3);
     });
 
+    test("counts user messages across standard conversations", () => {
+      seedUserMessage(100);
+      seedUserMessage(200);
+      seedUserMessage(300);
+      seedUserMessage(400);
+
+      expect(getUserMessageCountUpTo(400)).toBe(4);
+    });
+
     test("caps at 11 due to LIMIT", () => {
       for (let i = 1; i <= 15; i++) {
         seedUserMessage(i * 100);

package/src/proactive-artifact/trigger-state.ts

@@ -16,6 +16,10 @@ function guardPath(): string {
 
 /**
  * Count user messages in standard conversations with created_at <= beforeOrAt.
+ * This is intentionally cross-conversation: a user who starts a new thread
+ * early should still enter the proactive artifact trigger window. The job
+ * separately scopes raw transcript context to the triggering conversation.
+ *
  * LIMIT caps scan cost since we only care about thresholds up to TRIGGER_MAX.
  */
 export function getUserMessageCountUpTo(beforeOrAt: number): number {

package/src/prompts/__tests__/system-prompt.test.ts

@@ -0,0 +1,117 @@
+/**
+ * Tests for the Background Conversation gating in buildSystemPrompt.
+ *
+ * The Background Conversation guidance is gated on
+ * `options.isBackgroundConversation === true`.  Interactive (default)
+ * conversations must pay zero token cost — the section must be entirely
+ * absent unless the flag is explicitly true.
+ */
+
+import { mkdirSync } from "node:fs";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
+
+const noopLogger: Record<string, unknown> = new Proxy(
+  {} as Record<string, unknown>,
+  {
+    get: (_target, prop) => (prop === "child" ? () => noopLogger : () => {}),
+  },
+);
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realLogger = require("../../util/logger.js");
+mock.module("../../util/logger.js", () => ({
+  ...realLogger,
+  getLogger: () => noopLogger,
+  getCliLogger: () => noopLogger,
+  truncateForLog: (v: string) => v,
+  initLogger: () => {},
+  pruneOldLogFiles: () => 0,
+}));
+
+const mockLoadedConfig: Record<string, unknown> = {};
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    services: {
+      inference: {
+        mode: "your-own",
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+      },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
+    },
+  }),
+  loadConfig: () => mockLoadedConfig,
+  loadRawConfig: () => ({}),
+  saveConfig: () => {},
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+}));
+
+const { buildSystemPrompt, SYSTEM_PROMPT_CACHE_BOUNDARY } =
+  await import("../system-prompt.js");
+
+describe("buildSystemPrompt — Background Conversation gating", () => {
+  beforeEach(() => {
+    mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  test("isBackgroundConversation: true — appends the Background Conversation section", () => {
+    const result = buildSystemPrompt({ isBackgroundConversation: true });
+    expect(result).toContain("## Background Conversation");
+    expect(result).toContain("`notifications` skill");
+    expect(result).toContain("assistant notifications send");
+  });
+
+  test("isBackgroundConversation: false — section is omitted", () => {
+    const result = buildSystemPrompt({ isBackgroundConversation: false });
+    expect(result).not.toContain("## Background Conversation");
+  });
+
+  test("options undefined — section is omitted (interactive default)", () => {
+    const result = buildSystemPrompt(undefined);
+    expect(result).not.toContain("## Background Conversation");
+  });
+
+  test("options provided without the flag — section is omitted", () => {
+    const result = buildSystemPrompt({});
+    expect(result).not.toContain("## Background Conversation");
+  });
+
+  test("section lives in the static (cached) block, not the dynamic suffix", () => {
+    // The section is deterministic for a given conversationType, so it
+    // belongs in staticParts to share the cache block with other
+    // call-time-stable instructions.
+    const result = buildSystemPrompt({ isBackgroundConversation: true });
+    const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
+    expect(boundaryIdx).toBeGreaterThan(-1);
+    const staticBlock = result.slice(0, boundaryIdx);
+    const dynamicBlock = result.slice(
+      boundaryIdx + SYSTEM_PROMPT_CACHE_BOUNDARY.length,
+    );
+    expect(staticBlock).toContain("## Background Conversation");
+    expect(dynamicBlock).not.toContain("## Background Conversation");
+  });
+});
+
+describe("buildSystemPrompt — tool routing guidance", () => {
+  beforeEach(() => {
+    mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  test("does not include ask_question routing guidance", () => {
+    const result = buildSystemPrompt({});
+    expect(result).not.toContain("## Clarifying questions");
+    expect(result).not.toContain("ask_question");
+  });
+});

package/src/prompts/__tests__/task-progress-hint-section.test.ts

@@ -0,0 +1,99 @@
+/**
+ * Tests for the task_progress hint in the 01-parallel-tool-calls workspace
+ * system prompt section.
+ *
+ * Verifies that the task_progress guidance renders unconditionally in the
+ * system prompt — no `enabled` frontmatter gating, no options dependency.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const noopLogger: Record<string, unknown> = new Proxy(
+  {} as Record<string, unknown>,
+  {
+    get: (_target, prop) => (prop === "child" ? () => noopLogger : () => {}),
+  },
+);
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realLogger = require("../../util/logger.js");
+mock.module("../../util/logger.js", () => ({
+  ...realLogger,
+  getLogger: () => noopLogger,
+  getCliLogger: () => noopLogger,
+  truncateForLog: (v: string) => v,
+  initLogger: () => {},
+  pruneOldLogFiles: () => 0,
+}));
+
+const mockLoadedConfig: Record<string, unknown> = {};
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    services: {
+      inference: {
+        mode: "your-own",
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+      },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
+    },
+  }),
+  loadConfig: () => mockLoadedConfig,
+  loadRawConfig: () => ({}),
+  saveConfig: () => {},
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+}));
+
+const { buildSystemPrompt, ensurePromptFiles, SYSTEM_PROMPT_CACHE_BOUNDARY } =
+  await import("../system-prompt.js");
+
+describe("task_progress hint in parallel-tool-calls section", () => {
+  beforeEach(() => {
+    ensurePromptFiles();
+  });
+
+  test("buildSystemPrompt() includes task_progress guidance", () => {
+    const result = buildSystemPrompt();
+    expect(result).toContain("task_progress");
+    expect(result).toContain("No exceptions");
+  });
+
+  test("renders unconditionally — no options required", () => {
+    const result = buildSystemPrompt(undefined);
+    expect(result).toContain("task_progress");
+  });
+
+  test("renders regardless of options passed", () => {
+    const withBackground = buildSystemPrompt({
+      isBackgroundConversation: true,
+    });
+    const withoutBackground = buildSystemPrompt({
+      isBackgroundConversation: false,
+    });
+    const withExcludePrefix = buildSystemPrompt({
+      excludeCustomPrefix: true,
+    });
+
+    expect(withBackground).toContain("task_progress");
+    expect(withoutBackground).toContain("task_progress");
+    expect(withExcludePrefix).toContain("task_progress");
+  });
+
+  test("hint lives in the static (cached) block before SYSTEM_PROMPT_CACHE_BOUNDARY", () => {
+    const result = buildSystemPrompt();
+    const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
+    expect(boundaryIdx).toBeGreaterThan(-1);
+    const staticBlock = result.slice(0, boundaryIdx);
+    expect(staticBlock).toContain("task_progress");
+  });
+});

package/src/prompts/normalize-onboarding.ts

@@ -62,6 +62,29 @@ export interface NormalizedOnboarding {
   dailyTools: string[];
   tone?: string;
   assistantName?: string;
+  googleConnected?: boolean;
+  googleServices?: string[];
+}
+
+const SCOPE_SERVICE_MAP: Record<string, string> = {
+  "gmail.readonly": "Gmail",
+  "gmail.modify": "Gmail",
+  "gmail.send": "Gmail",
+  "gmail.settings.basic": "Gmail",
+  "calendar.readonly": "Calendar",
+  "calendar.events": "Calendar",
+  drive: "Drive",
+};
+
+export function deriveGoogleServices(scopes?: string[]): string[] {
+  if (!scopes?.length) return ["Gmail", "Calendar", "Drive"];
+  const services = new Set<string>();
+  for (const scope of scopes) {
+    const suffix = scope.replace("https://www.googleapis.com/auth/", "");
+    const service = SCOPE_SERVICE_MAP[suffix];
+    if (service) services.add(service);
+  }
+  return services.size > 0 ? [...services] : ["Gmail", "Calendar", "Drive"];
 }
 
 /**
@@ -76,5 +99,9 @@ export function normalizeOnboardingContext(
     dailyTools: normalizeTools(ctx.tools),
     tone: ctx.tone,
     assistantName: ctx.assistantName,
+    googleConnected: ctx.googleConnected,
+    googleServices: ctx.googleConnected
+      ? deriveGoogleServices(ctx.googleScopes)
+      : undefined,
   };
 }