@vellumai/assistant 0.12.0 → 0.12.1-dev.202609142113.d1590bc

package/src/__tests__/cu-unified-flow.test.ts

@@ -224,7 +224,10 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       );
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("no desktop client connected");
+      expect(result.content).toContain(
+        "The Vellum desktop app is needed to view or control your screen",
+      );
+      expect(result.content).toContain("https://www.vellum.ai/downloads");
     });
 
     test("returns error when proxy exists but client not connected", async () => {
@@ -237,7 +240,10 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       });
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("no desktop client connected");
+      expect(result.content).toContain(
+        "The Vellum desktop app is needed to view or control your screen",
+      );
+      expect(result.content).toContain("https://www.vellum.ai/downloads");
       proxyObj.dispose();
     });
 

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

@@ -143,6 +143,31 @@ describe("document write routes publish documents:list", () => {
     expectDocumentsChanged(events);
   });
 
+  test("an existing document with a missing conversation can save before relinking", async () => {
+    await saveViaRoute();
+    const db = getDb();
+    db.run("PRAGMA foreign_keys = OFF");
+    try {
+      db.run("DELETE FROM conversations");
+    } finally {
+      db.run("PRAGMA foreign_keys = ON");
+    }
+
+    await expect(
+      saveViaRoute({ title: "Renamed notes", content: "Edited body" }),
+    ).resolves.toMatchObject({ success: true, surfaceId: "doc-sync" });
+    createConversation({ id: OTHER_CONVERSATION_ID });
+    await expect(
+      linkViaRoute("doc-sync", OTHER_CONVERSATION_ID),
+    ).resolves.toMatchObject({ success: true });
+    await expect(
+      invoke("getDocument", { pathParams: { id: "doc-sync" } }),
+    ).resolves.toMatchObject({
+      title: "Renamed notes",
+      content: "Edited body",
+    });
+  });
+
   test("a content-only save publishes", async () => {
     // The save moves `updated_at` and the word count, which order and fill the
     // Library and the assets list on every other client. The saving client

package/src/__tests__/drain-kick-guard.test.ts

@@ -79,8 +79,6 @@ function makeFakeConversation(
     getTurnInterfaceContext: () => null,
     setTurnInterfaceContext: () => {},
     setTransportHints: () => {},
-    setTrustContext: () => {},
-    ensureActorScopedHistory: async () => {},
     emitActivityState: () => {
       if (activityFailures > 0) {
         activityFailures -= 1;

package/src/__tests__/drain-requeue-on-contention.test.ts

@@ -78,12 +78,6 @@ function makeFakeConversation(options: {
     setTransportHints: () => {
       mutationCalls.push("setTransportHints");
     },
-    setTrustContext: () => {
-      mutationCalls.push("setTrustContext");
-    },
-    ensureActorScopedHistory: async () => {
-      mutationCalls.push("ensureActorScopedHistory");
-    },
     emitActivityState: () => {
       mutationCalls.push("emitActivityState");
     },

package/src/__tests__/evict-conversations-for-reload.test.ts

@@ -1,6 +1,6 @@
 /**
  * `evictConversationsForReload` drops in-memory conversations after a
- * config/prompt/skills reload so the next turn rebuilds them against the new
+ * config/prompt reload so the next turn rebuilds them against the new
  * config. Queued messages live only on the instance being disposed, so the
  * same "not idle while a queue is pending" rule the periodic evictor applies
  * has to hold here: `isProcessing()` reads false in the window between a turn

package/src/__tests__/git-porcelain.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  collectDirtyPathsFromPorcelain,
+  parsePorcelainZ,
+} from "../workspace/git-porcelain.js";
+
+describe("parsePorcelainZ", () => {
+  test("parses ordinary modified and untracked records", () => {
+    expect(parsePorcelainZ("M  tracked.txt\0?? new.txt\0")).toEqual([
+      { status: "M ", path: "tracked.txt" },
+      { status: "??", path: "new.txt" },
+    ]);
+  });
+
+  test("captures rename origin on the same record", () => {
+    expect(parsePorcelainZ("R  dest.txt\0src.txt\0")).toEqual([
+      { status: "R ", path: "dest.txt", origin: "src.txt" },
+    ]);
+  });
+
+  test("captures copy origin on the same record", () => {
+    expect(parsePorcelainZ("C  dest.txt\0src.txt\0")).toEqual([
+      { status: "C ", path: "dest.txt", origin: "src.txt" },
+    ]);
+  });
+
+  test("skips short leftover NUL entries", () => {
+    expect(parsePorcelainZ("M  a.txt\0\0")).toEqual([
+      { status: "M ", path: "a.txt" },
+    ]);
+  });
+});
+
+describe("collectDirtyPathsFromPorcelain", () => {
+  test("flattens rename origin so both paths are staged", () => {
+    expect(
+      collectDirtyPathsFromPorcelain("R  dest.txt\0src.txt\0?? extra.txt\0"),
+    ).toEqual(["dest.txt", "src.txt", "extra.txt"]);
+  });
+
+  test("dedupes a path that appears as both origin and destination", () => {
+    expect(collectDirtyPathsFromPorcelain("R  same.txt\0same.txt\0")).toEqual([
+      "same.txt",
+    ]);
+  });
+});

package/src/__tests__/heartbeat-service.test.ts

@@ -557,52 +557,52 @@ describe("HeartbeatService", () => {
     expect(processMessageCalls).toHaveLength(1);
   });
 
-    test("active hours handles overnight window", async () => {
-      setHeartbeatConfig({ activeHoursStart: 22, activeHoursEnd: 6 });
+  test("active hours handles overnight window", async () => {
+    setHeartbeatConfig({ activeHoursStart: 22, activeHoursEnd: 6 });
 
-      // 23:00 should be within the window
-      const service = createService({ getCurrentHour: () => 23 });
-      await service.runOnce();
-      expect(processMessageCalls).toHaveLength(1);
+    // 23:00 should be within the window
+    const service = createService({ getCurrentHour: () => 23 });
+    await service.runOnce();
+    expect(processMessageCalls).toHaveLength(1);
 
-      // 10:00 should be outside the window
-      processMessageCalls.length = 0;
-      createdConversations.length = 0;
-      const service2 = createService({ getCurrentHour: () => 10 });
-      await service2.runOnce();
-      expect(processMessageCalls).toHaveLength(0);
-    });
+    // 10:00 should be outside the window
+    processMessageCalls.length = 0;
+    createdConversations.length = 0;
+    const service2 = createService({ getCurrentHour: () => 10 });
+    await service2.runOnce();
+    expect(processMessageCalls).toHaveLength(0);
+  });
 
-    test("active hours guard uses user timezone in interval mode", async () => {
-      setConfig("ui", { detectedTimezone: "America/Los_Angeles" });
-      setHeartbeatConfig({
-        cronExpression: null,
-        timezone: null,
-        activeHoursStart: 8,
-        activeHoursEnd: 22,
-      });
+  test("active hours guard uses user timezone in interval mode", async () => {
+    setConfig("ui", { detectedTimezone: "America/Los_Angeles" });
+    setHeartbeatConfig({
+      cronExpression: null,
+      timezone: null,
+      activeHoursStart: 8,
+      activeHoursEnd: 22,
+    });
 
-      // 23:00 UTC is 16:00 Pacific (inside 8-22) and 23:00 host-local
-      // (outside 8-22). If the guard still used the host clock this would skip.
-      const inside = createService({
-        now: () => new Date("2026-09-08T23:00:00Z"),
-        getCurrentHour: () => 23,
-      });
-      expect(await inside.runOnce()).toBe(true);
-      expect(processMessageCalls).toHaveLength(1);
+    // 23:00 UTC is 16:00 Pacific (inside 8-22) and 23:00 host-local
+    // (outside 8-22). If the guard still used the host clock this would skip.
+    const inside = createService({
+      now: () => new Date("2026-09-08T23:00:00Z"),
+      getCurrentHour: () => 23,
+    });
+    expect(await inside.runOnce()).toBe(true);
+    expect(processMessageCalls).toHaveLength(1);
 
-      processMessageCalls.length = 0;
-      createdConversations.length = 0;
+    processMessageCalls.length = 0;
+    createdConversations.length = 0;
 
-      // 06:00 UTC is 23:00 Pacific, outside 8-22, even though 6 is inside
-      // a naive UTC 8-22 window.
-      const outside = createService({
-        now: () => new Date("2026-09-09T06:00:00Z"),
-        getCurrentHour: () => 6,
-      });
-      expect(await outside.runOnce()).toBe(false);
-      expect(processMessageCalls).toHaveLength(0);
+    // 06:00 UTC is 23:00 Pacific, outside 8-22, even though 6 is inside
+    // a naive UTC 8-22 window.
+    const outside = createService({
+      now: () => new Date("2026-09-09T06:00:00Z"),
+      getCurrentHour: () => 6,
     });
+    expect(await outside.runOnce()).toBe(false);
+    expect(processMessageCalls).toHaveLength(0);
+  });
 
   test("overlap prevention works", async () => {
     let resolveFirst: () => void;
@@ -1004,7 +1004,23 @@ describe("HeartbeatService", () => {
         "slack",
       ]);
 
-      expect(prompt).toContain("google, slack");
+      expect(prompt).toContain(
+        "google (integration, acts as the connected person), slack (integration, acts as the connected person)",
+      );
+    });
+
+    test("prompt tells an integration apart from the channel bot of the same name", () => {
+      const service = createService();
+      const { prompt } = service.buildPrompt("- Check things", ["slack"]);
+
+      expect(prompt).toContain(
+        "slack (integration, acts as the connected person)",
+      );
+      expect(prompt).not.toContain("slack_channel");
+      expect(prompt).toContain("A channel bot is the assistant's own identity");
+
+      const bot = service.buildPrompt("- Check things", ["slack_channel"]);
+      expect(bot.prompt).toContain("slack_channel (the slack channel bot)");
     });
   });
 

package/src/__tests__/helpers/set-workspace-mcp.ts

@@ -0,0 +1,11 @@
+/**
+ * Seed `$VELLUM_WORKSPACE_DIR/mcp.json` for tests that go through the
+ * real workspace MCP loader.
+ */
+
+import type { McpConfig } from "../../config/schemas/mcp.js";
+import { saveWorkspaceMcpConfig } from "../../mcp/workspace-mcp-config.js";
+
+export function setWorkspaceMcp(servers: McpConfig["servers"]): void {
+  saveWorkspaceMcpConfig({ servers });
+}

package/src/__tests__/host-bash-proxy.test.ts

@@ -669,23 +669,31 @@ describe("HostBashProxy", () => {
       expect(sentMessages).toHaveLength(0);
     });
 
-    test("rejects ambiguously when multiple same-user capable clients are connected and no targetClientId", async () => {
-      // Regression: previously fell through to untargeted broadcast, fanning
-      // a single targeted-style request out across every same-user machine.
+    test("selects the most recently active same-user client when several are connected", async () => {
       setup();
       setupMultipleClients(["client-1", "client-2", "client-3"]);
 
-      const result = await proxy.request(
+      const resultPromise = proxy.request(
         { command: "echo hello" },
         "session-1",
         undefined,
         "user-A",
       );
 
-      expect(result.isError).toBe(true);
-      expect(result.content).toContain("target_client_id");
-      // No broadcast happened
-      expect(sentMessages).toHaveLength(0);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.targetClientId).toBe("client-1");
+      const options = sentMessageOptions[0] as
+        | Record<string, unknown>
+        | undefined;
+      expect(options?.targetClientId).toBe("client-1");
+
+      proxy.resolveResult(sent.requestId as string, {
+        stdout: "hello\n",
+        stderr: "",
+        exitCode: 0,
+        timedOut: false,
+      });
+      expect((await resultPromise).isError).toBe(false);
     });
 
     test("falls through to broadcast when zero capable clients (existing timeout path)", async () => {
@@ -832,30 +840,19 @@ describe("HostBashProxy", () => {
       expect(sentMessages).toHaveLength(0);
     });
 
-    test("untargeted local flow unchanged when no auto-resolve match", async () => {
+    test("rejects when the actor has no capable client", async () => {
       setup();
-      // No capable clients connected — untargeted path runs.
 
-      const resultPromise = proxy.request(
+      const result = await proxy.request(
         { command: "echo hello" },
         "session-1",
         undefined,
         "user-A",
       );
 
-      expect(sentMessages).toHaveLength(1);
-      const sent = sentMessages[0] as Record<string, unknown>;
-      expect(sent.type).toBe("host_bash_request");
-      expect(sent.targetClientId).toBeUndefined();
-
-      const requestId = sent.requestId as string;
-      proxy.resolveResult(requestId, {
-        stdout: "hello\n",
-        stderr: "",
-        exitCode: 0,
-        timedOut: false,
-      });
-      await resultPromise;
+      expect(result).toMatchObject({ isError: true });
+      expect(result.content).toContain("belongs to this user");
+      expect(sentMessages).toHaveLength(0);
     });
 
     test("auto-resolve to same-user client succeeds", async () => {
@@ -883,36 +880,20 @@ describe("HostBashProxy", () => {
       await resultPromise;
     });
 
-    test("auto-resolve to different-user client falls through to untargeted", async () => {
+    test("rejects when only a different user has a capable client", async () => {
       setup();
-      // Single capable client owned by user-B; caller is user-A.
       setupSingleClient("client-abc", "user-B");
 
-      const resultPromise = proxy.request(
+      const result = await proxy.request(
         { command: "echo hello" },
         "session-1",
         undefined,
         "user-A",
       );
 
-      // Auto-resolve must NOT pick the cross-user client; the untargeted
-      // broadcast path runs instead.
-      expect(sentMessages).toHaveLength(1);
-      const sent = sentMessages[0] as Record<string, unknown>;
-      expect(sent.type).toBe("host_bash_request");
-      expect(sent.targetClientId).toBeUndefined();
-
-      const opts = sentMessageOptions[0] as Record<string, unknown> | undefined;
-      expect(opts?.targetClientId).toBeUndefined();
-
-      const requestId = sent.requestId as string;
-      proxy.resolveResult(requestId, {
-        stdout: "hello\n",
-        stderr: "",
-        exitCode: 0,
-        timedOut: false,
-      });
-      await resultPromise;
+      expect(result).toMatchObject({ isError: true });
+      expect(result.content).toContain("belongs to this user");
+      expect(sentMessages).toHaveLength(0);
     });
   });
 });

package/src/__tests__/host-browser-proxy.test.ts

@@ -608,22 +608,17 @@ describe("HostBrowserProxy", () => {
         },
       ];
 
-      const resultPromise = proxy.request(
+      const result = await proxy.request(
         { cdpMethod: "Page.navigate", cdpParams: { url: "https://a.test" } },
         "session-1",
         undefined,
         "user-1",
       );
 
-      // Auto-resolution filters out the cross-user candidate, so the
-      // proxy falls into the existing "no active extension connection"
-      // rejection — we never broadcast to a different actor's client.
-      await expect(resultPromise).rejects.toThrow(
-        "no active extension connection",
-      );
+      expect(result).toMatchObject({ isError: true });
+      expect(result.content).toContain("belongs to this user");
       expect(getPublishedMessages()).toHaveLength(0);
     });
-
     test("prefers the chrome-extension client over a more-recently-active macOS bridge", async () => {
       // Mock `listClientsByCapability` returns mockClients in array
       // order, which mirrors production's `lastActiveAt`-desc ordering.
@@ -720,11 +715,6 @@ describe("HostBrowserProxy", () => {
     });
 
     test("rejects when caller has actor but no host_browser-capable client is connected for that actor", async () => {
-      // Same-user filter returns empty even though listClientsByCapability
-      // would return a non-empty list (because that list is for a
-      // different actor). The unfiltered fallback path runs only when
-      // the caller has no actor — we don't silently broadcast to anyone
-      // when the caller IS authenticated to a specific actor.
       mockClients = [
         {
           clientId: "other-user-ext",
@@ -734,16 +724,15 @@ describe("HostBrowserProxy", () => {
         },
       ];
 
-      const resultPromise = proxy.request(
+      const result = await proxy.request(
         { cdpMethod: "Page.navigate", cdpParams: { url: "https://a.test" } },
         "session-1",
         undefined,
         "user-1",
       );
 
-      await expect(resultPromise).rejects.toThrow(
-        "no active extension connection",
-      );
+      expect(result).toMatchObject({ isError: true });
+      expect(result.content).toContain("belongs to this user");
       expect(getPublishedMessages()).toHaveLength(0);
     });
   });