@vellumai/assistant 0.12.5 → 0.12.6-dev.202609292116.41f7caa

package/src/__tests__/emit-signal-routing-intent.test.ts

@@ -1,5 +1,26 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { saveRawConfig } from "../config/loader.js";
+import type { NotificationSignal } from "../notifications/signal.js";
+import type { NotificationChannel } from "../notifications/types.js";
+
+let assistantInitiatedCandidate = false;
+const resolveAssistantInitiatedThreadMock = mock(
+  (signal: NotificationSignal) => ({
+    isCandidate: assistantInitiatedCandidate,
+    vellumSignal: assistantInitiatedCandidate
+      ? {
+          ...signal,
+          requiresConversation: true,
+          conversationMetadata: { source: "assistant_initiated" },
+        }
+      : signal,
+  }),
+);
+mock.module("../notifications/assistant-initiated-thread.js", () => ({
+  resolveAssistantInitiatedThread: resolveAssistantInitiatedThreadMock,
+}));
+
 const evaluateSignalMock = mock();
 const enforceRoutingIntentMock = mock();
 const updateDecisionMock = mock();
@@ -8,6 +29,14 @@ const createEventMock = mock();
 const setEventDedupeKeyMock = mock();
 const dispatchDecisionMock = mock();
 const isPlatformClientConfiguredMock = mock();
+const writeHomeFeedItemForSignalMock = mock(
+  async (..._args: unknown[]) => null,
+);
+
+mock.module("../notifications/home-feed-side-effect.js", () => ({
+  writeHomeFeedItemForSignal: (...args: unknown[]) =>
+    writeHomeFeedItemForSignalMock(...args),
+}));
 
 mock.module("../channels/config.js", () => ({
   getDeliverableChannels: () => ["vellum", "telegram"],
@@ -101,6 +130,10 @@ import {
 } from "../notifications/emit-signal.js";
 
 beforeEach(() => {
+  saveRawConfig({});
+  assistantInitiatedCandidate = false;
+  resolveAssistantInitiatedThreadMock.mockClear();
+  writeHomeFeedItemForSignalMock.mockClear();
   evaluateSignalMock.mockReset();
   enforceRoutingIntentMock.mockReset();
   updateDecisionMock.mockReset();
@@ -121,6 +154,104 @@ beforeEach(() => {
   enforceRoutingIntentMock.mockImplementation((decision: unknown) => decision);
 });
 
+describe("emitNotificationSignal chat reply preference", () => {
+  test.each([
+    [false, false],
+    [true, true],
+    [false, true],
+    [true, false],
+  ])(
+    "preserves routing candidates when the setting changes %s -> %s",
+    async (initial, enabled) => {
+      saveRawConfig({ notifications: { newMessageEnabled: initial } });
+      const selectedChannels: NotificationChannel[] = [
+        "vellum",
+        "platform",
+        "telegram",
+      ];
+      const decision = {
+        shouldNotify: true,
+        selectedChannels,
+        reasoningSummary: "Selected reply delivery",
+        renderedCopy: {
+          vellum: { title: "Answer", body: "The result is ready." },
+        },
+        dedupeKey: "reply-1",
+        confidence: 1,
+        fallbackUsed: false,
+        persistedDecisionId: "decision-1",
+      };
+      evaluateSignalMock.mockResolvedValue(decision);
+      enforceRoutingIntentMock.mockReturnValue(decision);
+      runDeterministicChecksMock.mockImplementation(async () => {
+        await Promise.resolve();
+        saveRawConfig({ notifications: { newMessageEnabled: enabled } });
+        return { passed: true };
+      });
+      const result = await emitNotificationSignal({
+        sourceEventName: "chat.assistant_reply",
+        sourceChannel: "vellum",
+        sourceContextId: "conv-1",
+        attentionHints: {
+          urgency: "high",
+          requiresAction: false,
+          isAsyncBackground: false,
+          visibleInSourceNow: false,
+        },
+        routingIntent: "all_channels",
+      });
+      expect(runDeterministicChecksMock.mock.calls[0]?.[1]).toMatchObject({
+        selectedChannels: decision.selectedChannels,
+      });
+      expect(result.selectedChannels).toEqual(selectedChannels);
+      expect(result.dispatched).toBe(true);
+      expect(dispatchDecisionMock.mock.calls[0]?.[1]).toMatchObject({
+        shouldNotify: true,
+        selectedChannels,
+      });
+      expect(writeHomeFeedItemForSignalMock).toHaveBeenCalledTimes(1);
+      expect(writeHomeFeedItemForSignalMock.mock.calls[0]?.[1]).toMatchObject({
+        shouldNotify: true,
+        selectedChannels,
+      });
+      expect(updateDecisionMock).not.toHaveBeenCalled();
+    },
+  );
+
+  test.each([
+    "schedule.result",
+    "guardian.question",
+    "ingress.access_request",
+    "activity.failed",
+    "chat.assistant_reply.extra",
+  ])("preserves platform selection for %s", async (sourceEventName) => {
+    saveRawConfig({ notifications: { newMessageEnabled: false } });
+    evaluateSignalMock.mockResolvedValue({
+      shouldNotify: true,
+      selectedChannels: ["vellum", "platform"],
+      reasoningSummary: "Urgent delivery",
+      renderedCopy: { vellum: { title: "Alert", body: "Action required." } },
+      dedupeKey: "alert-1",
+      confidence: 1,
+      fallbackUsed: false,
+      persistedDecisionId: "decision-1",
+    });
+    const result = await emitNotificationSignal({
+      sourceEventName,
+      sourceChannel: "vellum",
+      sourceContextId: "conv-1",
+      attentionHints: {
+        urgency: "critical",
+        requiresAction: true,
+        isAsyncBackground: false,
+        visibleInSourceNow: false,
+      },
+    });
+    expect(result.selectedChannels).toEqual(["vellum", "platform"]);
+    expect(updateDecisionMock).not.toHaveBeenCalled();
+  });
+});
+
 describe("emitNotificationSignal routing intent re-persistence", () => {
   test("re-persists selectedChannels/reasoningSummary when enforcement changes the decision", async () => {
     const preDecision = {
@@ -909,3 +1040,142 @@ describe("classifyNotificationReceipt", () => {
     ).toBe("unknown");
   });
 });
+
+describe("emitNotificationSignal From me push defaults", () => {
+  const params = {
+    sourceEventName: "assistant.share",
+    sourceChannel: "assistant_tool" as const,
+    sourceContextId: "conv-background",
+    attentionHints: {
+      urgency: "low" as const,
+      requiresAction: false,
+      isAsyncBackground: true,
+      visibleInSourceNow: false,
+    },
+  };
+  const decision = (selectedChannels: NotificationChannel[] = ["vellum"]) => ({
+    shouldNotify: true,
+    selectedChannels,
+    reasoningSummary: "Assistant-authored share",
+    renderedCopy: { vellum: { title: "An update", body: "A useful result." } },
+    dedupeKey: "share-1",
+    confidence: 1,
+    fallbackUsed: false,
+    persistedDecisionId: "decision-share",
+  });
+
+  beforeEach(() => {
+    assistantInitiatedCandidate = true;
+    evaluateSignalMock.mockResolvedValue(decision());
+  });
+
+  test("adds configured platform after routing and persists the final decision", async () => {
+    const result = await emitNotificationSignal(params);
+    expect(result.selectedChannels).toEqual(["vellum", "platform"]);
+    expect(resolveAssistantInitiatedThreadMock).toHaveBeenCalledTimes(1);
+    expect(updateDecisionMock).toHaveBeenCalledWith(
+      "decision-share",
+      expect.objectContaining({
+        selectedChannels: ["vellum", "platform"],
+      }),
+    );
+    expect(dispatchDecisionMock.mock.calls[0]?.[0]).toMatchObject({
+      attentionHints: { urgency: "low" },
+    });
+    expect(dispatchDecisionMock.mock.calls[0]?.[3]).toMatchObject({
+      assistantInitiatedThread: {
+        platformAdded: true,
+        resolution: {
+          isCandidate: true,
+          vellumSignal: {
+            requiresConversation: true,
+            conversationMetadata: { source: "assistant_initiated" },
+          },
+        },
+      },
+    });
+  });
+
+  test.each([
+    "quiet",
+    "unconfigured",
+    "noncandidate",
+    "suppressed",
+    "single_channel",
+    "external_only",
+    "vellum_allowlist",
+  ])("respects %s policy without adding platform", async (scenario) => {
+    assistantInitiatedCandidate = scenario !== "noncandidate";
+    isPlatformClientConfiguredMock.mockResolvedValue(
+      scenario !== "unconfigured",
+    );
+    evaluateSignalMock.mockResolvedValue({
+      ...decision(scenario === "external_only" ? ["telegram"] : ["vellum"]),
+      shouldNotify: scenario !== "suppressed",
+    });
+    const result = await emitNotificationSignal({
+      ...params,
+      routingIntent:
+        scenario === "single_channel" ? "single_channel" : undefined,
+      contextPayload: {
+        quiet: scenario === "quiet",
+        ...(scenario === "vellum_allowlist"
+          ? { channelAllowlist: ["vellum"] }
+          : {}),
+      },
+    });
+    expect(result.selectedChannels).not.toContain("platform");
+    expect(dispatchDecisionMock.mock.calls[0]?.[3]).toMatchObject({
+      assistantInitiatedThread: { platformAdded: false },
+    });
+  });
+
+  test("keeps existing platform and external selections independent of this feature", async () => {
+    evaluateSignalMock.mockResolvedValue(
+      decision(["vellum", "platform", "telegram"]),
+    );
+    const result = await emitNotificationSignal({
+      ...params,
+      contextPayload: { quiet: true },
+    });
+    expect(result.selectedChannels).toEqual(["vellum", "platform", "telegram"]);
+    expect(isPlatformClientConfiguredMock).not.toHaveBeenCalled();
+    expect(dispatchDecisionMock.mock.calls[0]?.[3]).toMatchObject({
+      assistantInitiatedThread: { platformAdded: false },
+    });
+  });
+
+  test("probes an unbound platform once across urgency and From me policy", async () => {
+    isPlatformClientConfiguredMock.mockResolvedValue(false);
+    const result = await emitNotificationSignal({
+      ...params,
+      attentionHints: { ...params.attentionHints, urgency: "high" },
+    });
+    expect(result.selectedChannels).toEqual(["vellum"]);
+    expect(isPlatformClientConfiguredMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("preserves preferred external selections while adding the platform default", async () => {
+    evaluateSignalMock.mockResolvedValue(decision(["vellum", "telegram"]));
+    const result = await emitNotificationSignal(params);
+    expect(result.selectedChannels).toEqual(["vellum", "telegram", "platform"]);
+  });
+
+  test.each(["deduplicated", "source_active"])(
+    "does not resolve candidates for %s signals",
+    async (scenario) => {
+      if (scenario === "deduplicated") {
+        createEventMock.mockReturnValue(null);
+      }
+      await emitNotificationSignal({
+        ...params,
+        attentionHints: {
+          ...params.attentionHints,
+          visibleInSourceNow: scenario === "source_active",
+        },
+      });
+      expect(resolveAssistantInitiatedThreadMock).not.toHaveBeenCalled();
+      expect(dispatchDecisionMock).not.toHaveBeenCalled();
+    },
+  );
+});

package/src/__tests__/gateway-flag-listener.test.ts

@@ -26,11 +26,12 @@ mock.module("../ipc/socket-path.js", () => ({
 // ---------------------------------------------------------------------------
 let refreshCallCount = 0;
 let refreshReturnsLoaded = true;
+let pendingRefresh: Promise<boolean> | undefined;
 
 mock.module("../config/assistant-feature-flags.js", () => ({
   refreshOverridesFromGateway: async () => {
     refreshCallCount++;
-    return refreshReturnsLoaded;
+    return pendingRefresh ?? refreshReturnsLoaded;
   },
   initFeatureFlagOverrides: async () => true,
   clearFeatureFlagOverridesCache: () => {},
@@ -136,6 +137,7 @@ describe("gateway-flag-listener", () => {
     mkdirSync(testRoot, { recursive: true });
     refreshCallCount = 0;
     refreshReturnsLoaded = true;
+    pendingRefresh = undefined;
     publishedTagSets = [];
     reconcileCallCount = 0;
     reconcileReturns = false;
@@ -177,7 +179,7 @@ describe("gateway-flag-listener", () => {
     expect(refreshCallCount).toBe(2);
   });
 
-  test("broadcasts feature-flags sync_changed when flags change", async () => {
+  test("broadcasts feature-flags sync_changed after connect and flag changes", async () => {
     await new Promise<void>((resolve) => {
       testServer.server.listen(socketPath, resolve);
     });
@@ -186,19 +188,59 @@ describe("gateway-flag-listener", () => {
     await testServer.waitForClient();
     await new Promise((r) => setTimeout(r, 100));
 
-    // Connect refresh should not broadcast — only an actual change does.
-    expect(publishedTagSets.length).toBe(0);
+    expect(publishedTagSets.length).toBe(1);
 
     testServer.emit("feature_flags_changed");
     await new Promise((r) => setTimeout(r, 100));
 
-    expect(publishedTagSets.length).toBe(1);
-    expect(publishedTagSets[0]).toEqual([
+    expect(publishedTagSets.length).toBe(2);
+    expect(publishedTagSets[1]).toEqual([
       "feature-flags:client",
       "feature-flags:assistant",
     ]);
   });
 
+  test("defers invalidation until the flag-change refresh settles", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+    startGatewayFlagListener();
+    await testServer.waitForClient();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    publishedTagSets = [];
+    const refresh = Promise.withResolvers<boolean>();
+    pendingRefresh = refresh.promise;
+    testServer.emit("feature_flags_changed");
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(refreshCallCount).toBe(2);
+    expect(publishedTagSets).toEqual([]);
+    expect(reconcileCallCount).toBe(1);
+    refresh.resolve(true);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(publishedTagSets).toEqual([
+      ["feature-flags:client", "feature-flags:assistant"],
+    ]);
+    expect(reconcileCallCount).toBe(2);
+  });
+
+  test("defers connection invalidation until the refreshed cache is available", async () => {
+    const refresh = Promise.withResolvers<boolean>();
+    pendingRefresh = refresh.promise;
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+    startGatewayFlagListener();
+    await testServer.waitForClient();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(refreshCallCount).toBe(1);
+    expect(publishedTagSets).toEqual([]);
+    refresh.resolve(true);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(publishedTagSets).toEqual([
+      ["feature-flags:client", "feature-flags:assistant"],
+    ]);
+  });
+
   test("reconciles flag-gated profiles and broadcasts config_changed when the profile set changes", async () => {
     reconcileReturns = true;
     await new Promise<void>((resolve) => {
@@ -251,12 +293,22 @@ describe("gateway-flag-listener", () => {
     // The profile reconcile/broadcast are gated on flags actually loading.
     expect(reconcileCallCount).toBe(0);
     expect(configChangedCount).toBe(0);
+    expect(publishedTagSets).toEqual([]);
 
     testServer.emit("feature_flags_changed");
     await new Promise((r) => setTimeout(r, 100));
 
     expect(reconcileCallCount).toBe(0);
     expect(configChangedCount).toBe(0);
+    expect(publishedTagSets).toEqual([]);
+    refreshReturnsLoaded = true;
+    testServer.emit("feature_flags_changed");
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(reconcileCallCount).toBe(1);
+    expect(configChangedCount).toBe(1);
+    expect(publishedTagSets).toEqual([
+      ["feature-flags:client", "feature-flags:assistant"],
+    ]);
   });
 
   test("reconciles profiles when the refresh reports flags loaded", async () => {
@@ -318,6 +370,7 @@ describe("gateway-flag-listener", () => {
     await new Promise((r) => setTimeout(r, 100));
     const countAfterReconnect = refreshCallCount;
     expect(countAfterReconnect).toBeGreaterThan(0);
+    expect(publishedTagSets).toHaveLength(countAfterReconnect);
 
     const payload = JSON.stringify({ event: "feature_flags_changed" }) + "\n";
     secondClient!.write(payload);

package/src/__tests__/headless-browser-navigate.test.ts

@@ -233,6 +233,7 @@ describe("executeBrowserNavigate", () => {
     resetMockPage();
     resetCdp();
     __resetPinnedTabsForTests();
+    mockExtensionAvailable = false;
   });
 
   // ── Input validation ───────────────────────────────────────────
@@ -606,6 +607,13 @@ describe("executeBrowserNavigate", () => {
     const routeCallsBefore = mockPage.route.mock.calls.length;
     const unrouteCallsBefore = mockPage.unroute.mock.calls.length;
 
+    cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") {
+        return { tabId: "42" };
+      }
+      return defaultCdpHandler(method, params);
+    };
+
     const result = await executeBrowserNavigate(
       { url: "https://example.com/page" },
       extensionCtx,
@@ -643,6 +651,9 @@ describe("executeBrowserNavigate", () => {
     // navigateAndWait returns a private final URL (simulating a
     // server-side redirect).
     cdpSendHandler = (method, params) => {
+      if (method === "Vellum.createTab") {
+        return { tabId: "42" };
+      }
       if (method === "Page.navigate") {
         return { frameId: "f1" };
       }
@@ -745,13 +756,7 @@ describe("executeBrowserNavigate", () => {
     expect(cdpDisposed).toBe(true);
   });
 
-  test("new_tab: true on extension path with no tabId in response clears live session and still continues", async () => {
-    // Defensive: dispatcher returns success but no tabId. The
-    // executor logs a warn, resets the live cdp session to undefined
-    // (so the follow-on Page.navigate routes to the active tab
-    // instead of any stale pin the cdp instance was constructed
-    // with), and proceeds. The navigate still runs (degraded
-    // behaviour but not a hard failure).
+  test("new_tab: true on extension path with no tabId in response fails closed", async () => {
     parseUrlResult = new URL("https://example.com/page");
     mockExtensionAvailable = true;
 
@@ -767,25 +772,13 @@ describe("executeBrowserNavigate", () => {
       { ...ctx },
     );
 
-    expect(result.isError).toBe(false);
-    // No new pin was set, BUT the live session was reset to undefined
-    // so the follow-on Page.navigate falls back to active-tab routing
-    // instead of any stale pin the cdp instance held at construction.
-    expect(cdpSetSessionIdCalls).toEqual([undefined]);
-    // Page.navigate still ran.
-    expect(cdpSendCalls.some((c) => c.method === "Page.navigate")).toBe(true);
+    expect(result.isError).toBe(true);
+    expect(String(result.content)).toContain("returned no tabId");
+    expect(cdpSetSessionIdCalls).toEqual([]);
+    expect(cdpSendCalls.some((c) => c.method === "Page.navigate")).toBe(false);
   });
 
-  test("new_tab: true with no tabId in response clears a pre-existing stale pin AND live session (regression)", async () => {
-    // Regression for the Codex round-2 findings (P2 + round-3 P1):
-    // when Vellum.createTab returns a malformed response with no
-    // tabId, the executor falls back to active-tab routing — but
-    // (a) the pin store still held the stale pin (round-2 P2 fix
-    // added clearPinnedTab), and (b) the LIVE cdp instance was
-    // already constructed with that stale cdpSessionId, so the
-    // follow-on Page.navigate would still route to the dead tab
-    // unless we reset the session on the cdp instance too (round-3
-    // P1 fix added cdp.setCdpSessionId(undefined)).
+  test("new_tab: true with no tabId in response clears a pre-existing stale pin and fails closed", async () => {
     const { setPinnedTab, getPinnedTab } =
       await import("../tools/browser/pinned-tabs.js");
     setPinnedTab(ctx.conversationId, "stale-pinned-tab-id");
@@ -806,12 +799,9 @@ describe("executeBrowserNavigate", () => {
       { ...ctx },
     );
 
-    expect(result.isError).toBe(false);
-    // (a) Pin store cleared.
+    expect(result.isError).toBe(true);
     expect(getPinnedTab(ctx.conversationId)).toBeUndefined();
-    // (b) Live cdp session reset (the fake records every
-    // setCdpSessionId arg; expect exactly one call with undefined).
-    expect(cdpSetSessionIdCalls).toEqual([undefined]);
+    expect(cdpSetSessionIdCalls).toEqual([]);
   });
 
   test("new_tab: true on LOCAL path is a no-op (Playwright manages its own isolated browser)", async () => {
@@ -935,7 +925,7 @@ describe("executeBrowserNavigate", () => {
       false,
     );
     expect(getPinnedTab(ctx.conversationId)).toBeUndefined();
-    expect(cdpSetSessionIdCalls).toEqual([undefined]);
+    expect(cdpSetSessionIdCalls).toEqual(["active"]);
     expect(cdpSendCalls.some((c) => c.method === "Page.navigate")).toBe(true);
   });
 

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

@@ -1186,6 +1186,85 @@ describe("HostCuProxy", () => {
 
       expect(result.content).toContain("2560x1440 px");
       expect(result.content).toContain("1280x720 pt");
+      expect(result.content).toContain("x = round(image_x * 0.500000)");
+      expect(result.content).toContain("y = round(image_y * 0.500000)");
+    });
+
+    test("derives separate screen-point scales for a downscaled screenshot", () => {
+      setup();
+
+      const result = proxy.formatObservation({
+        screenshot: "base64data",
+        screenshotWidthPx: 835,
+        screenshotHeightPx: 540,
+        screenWidthPt: 1728,
+        screenHeightPt: 1117,
+      });
+
+      const xScale = Number(result.content.match(/image_x \* ([\d.]+)/)?.[1]);
+      const yScale = Number(result.content.match(/image_y \* ([\d.]+)/)?.[1]);
+      expect(Math.round(675 * xScale)).toBe(1397);
+      expect(Math.round(330 * yScale)).toBe(683);
+      expect(result.content).toContain("screen points, not screenshot pixels");
+    });
+
+    test.each([
+      { capture_window_id: 12 },
+      { captureWindowId: 12 },
+      { captureDisplayId: 2 },
+    ])(
+      "does not scale a scoped screenshot by desktop dimensions: %j",
+      (input) => {
+        setup();
+
+        const result = proxy.formatObservation(
+          {
+            screenshot: "base64data",
+            screenshotWidthPx: 800,
+            screenshotHeightPx: 600,
+            screenWidthPt: 1600,
+            screenHeightPt: 1200,
+          },
+          undefined,
+          false,
+          { toolName: "computer_use_observe", input },
+        );
+
+        expect(result.content).toContain("screenshot is capture-relative");
+        expect(result.content).not.toContain("round(image_");
+      },
+    );
+
+    test.each([undefined, 0, -1, Number.NaN, Number.POSITIVE_INFINITY])(
+      "does not invent a mapping for an unavailable or invalid dimension: %s",
+      (screenWidthPt) => {
+        setup();
+
+        const result = proxy.formatObservation({
+          screenshot: "base64data",
+          screenshotWidthPx: 800,
+          screenshotHeightPx: 600,
+          screenWidthPt,
+          screenHeightPt: 1200,
+        });
+
+        expect(result.content).toContain("coordinate mapping is unavailable");
+        expect(result.content).not.toContain("round(image_");
+      },
+    );
+
+    test("omits coordinate guidance when no screenshot accompanies dimensions", () => {
+      setup();
+
+      const result = proxy.formatObservation({
+        axTree: "Button [1]",
+        screenshotWidthPx: 800,
+        screenshotHeightPx: 600,
+        screenWidthPt: 1600,
+        screenHeightPt: 1200,
+      });
+
+      expect(result.content).not.toContain("coordinate");
     });
 
     test("escapes </ax-tree> in AX tree content", () => {

package/src/__tests__/host-cu-routes-targeted.test.ts

@@ -17,6 +17,8 @@
  */
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import sharp from "sharp";
+
 // ── Module mocks ─────────────────────────────────────────────────────────────
 // Must be registered before the host-cu-routes module is loaded.
 
@@ -487,7 +489,14 @@ describe("handleHostCuResult: request body validation", () => {
     expect(pendingStore.has(requestId)).toBe(true);
   });
 
-  test("forwards a full observation payload unchanged", async () => {
+  test("forwards observation metadata with dimensions from the screenshot bytes", async () => {
+    const screenshot = (
+      await sharp({
+        create: { width: 835, height: 540, channels: 3, background: "white" },
+      })
+        .jpeg()
+        .toBuffer()
+    ).toString("base64");
     const requestId = "req-cu-full-observation";
     registerPending(requestId);
 
@@ -496,7 +505,7 @@ describe("handleHostCuResult: request body validation", () => {
         requestId,
         axTree: "Button [1]",
         axDiff: "+Button [1]",
-        screenshot: "base64png",
+        screenshot,
         screenshotWidthPx: 1600,
         screenshotHeightPx: 1000,
         screenWidthPt: 800,
@@ -512,9 +521,9 @@ describe("handleHostCuResult: request body validation", () => {
     expect(cuResolveSpy[0].payload).toMatchObject({
       axTree: "Button [1]",
       axDiff: "+Button [1]",
-      screenshot: "base64png",
-      screenshotWidthPx: 1600,
-      screenshotHeightPx: 1000,
+      screenshot,
+      screenshotWidthPx: 835,
+      screenshotHeightPx: 540,
       screenWidthPt: 800,
       screenHeightPt: 500,
       executionResult: "Clicked",

package/src/__tests__/host-shell-tool.test.ts

@@ -45,6 +45,8 @@ mock.module("../daemon/host-bash-proxy.js", () => ({
   },
 }));
 
+import { buildShellInvocation } from "@vellumai/environments/shell";
+
 import { hostShellTool } from "../tools/host-terminal/host-shell.js";
 import type { ToolContext, ToolExecutionResult } from "../tools/types.js";
 
@@ -139,7 +141,7 @@ describe("host_bash tool", () => {
     // Verify spawn was called with 'bash' directly — not 'bwrap' or 'sandbox-exec'
     expect(spawnCalls.length).toBe(1);
     expect(spawnCalls[0].command).toBe("bash");
-    expect(spawnCalls[0].args).toEqual(["-c", "--", "echo hello"]);
+    expect(spawnCalls[0].args).toEqual(buildShellInvocation("echo hello").args);
   });
 });
 
@@ -205,7 +207,9 @@ describe("host_bash — baseline: no sandbox isolation", () => {
     expect(spawnCalls[0].command).toBe("bash");
     expect(spawnCalls[0].args[0]).toBe("-c");
     expect(spawnCalls[0].args[1]).toBe("--");
-    expect(spawnCalls[0].args[2]).toBe("ls -la /tmp");
+    expect(spawnCalls[0].args[2]).toBe(
+      buildShellInvocation("ls -la /tmp").args[2],
+    );
   });
 
   test("host_bash always spawns plain bash without wrapCommand", async () => {