@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/__tests__/channel-setup-panel-ack.test.ts

@@ -12,20 +12,21 @@ import { describe, expect, test } from "bun:test";
 
 import type { OpenPanelEvent } from "../api/events/open-panel.js";
 import type { AssistantEvent } from "../api/index.js";
+import type { Conversation } from "../daemon/conversation.js";
 import {
   createSurfaceMutex,
   handleSurfaceAction,
   openChannelSetupPanel,
-  type SurfaceConversationContext,
   surfaceProxyResolver,
 } from "../daemon/conversation-surfaces.js";
 import type { SurfaceType } from "../daemon/message-protocol.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 function makeContext(
   sent: AssistantEvent[] = [],
-  overrides: Partial<SurfaceConversationContext> = {},
-): SurfaceConversationContext {
-  return {
+  overrides: Partial<Conversation> = {},
+): Conversation {
+  return asConversation({
     conversationId: "session-1",
     sendToClient: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
@@ -46,7 +47,7 @@ function makeContext(
     processMessage: async () => "ok",
     withSurface: createSurfaceMutex(),
     ...overrides,
-  };
+  });
 }
 
 function findOpenPanel(sent: AssistantEvent[]): OpenPanelEvent | undefined {

package/src/__tests__/client-os-metadata-persistence.test.ts

@@ -2,14 +2,14 @@
  * Verifies that `persistQueuedMessageBody` stamps the client-reported OS
  * surface into `metadata.client.os` on persisted user messages.
  *
- * The web, iOS, and macOS apps all run the same web renderer and report
+ * Browser, mobile, and desktop apps all run the same web renderer and report
  * `userMessageInterface: "web"` (the transport surface, which host-proxy
  * capability gating keys off), so `client.os` is the only per-platform
  * attribution available to turn telemetry (`turn-events-store` forwards
  * `$.client` onto `TurnTelemetryEvent.client`). Without the stamp, desktop
  * and mobile usage are indistinguishable from browser usage downstream.
  *
- * Mirrors the mock harness of `dm-persistence.test.ts` — exercises
+ * Mirrors the mock harness of `dm-persistence.test.ts` and exercises
  * `persistQueuedMessageBody` directly with a captured `addMessage`.
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -65,6 +65,7 @@ import type {
 import type { MessagingConversationContext } from "../daemon/conversation-messaging.js";
 import { persistQueuedMessageBody } from "../daemon/conversation-messaging.js";
 import type { MessageQueue } from "../daemon/conversation-queue-manager.js";
+import { isMacOriginatedUserMessage } from "../persistence/conversation-types.js";
 
 function createWebTurnContext(
   clientOs: string | undefined,
@@ -110,7 +111,7 @@ describe("client OS surface metadata persistence", () => {
     addMessageCalls.length = 0;
   });
 
-  test.each(["macos", "ios", "android", "web"])(
+  test.each(["macos", "windows", "ios", "android", "web"])(
     "stamps client.os = %s from the conversation's clientOs",
     async (os) => {
       const ctx = createWebTurnContext(os);
@@ -136,7 +137,7 @@ describe("client OS surface metadata persistence", () => {
   });
 
   test("omits the client bag for values outside the ClientOs vocabulary", async () => {
-    const ctx = createWebTurnContext("windows");
+    const ctx = createWebTurnContext("linux");
     await persistQueuedMessageBody(ctx, {
       content: "hello",
       requestId: "req-invalid",
@@ -173,3 +174,101 @@ describe("client OS surface metadata persistence", () => {
     });
   });
 });
+
+/**
+ * `Conversation.clientOs` is a live field that only a transport-carrying
+ * message refreshes, so a transport-less turn stamps whatever an earlier send
+ * left there. `clientOsFromRequest` separates the two, and
+ * {@link isMacOriginatedUserMessage} (the row-origin read behind the
+ * `chat.assistant_reply` presence gate) requires it before letting an attended
+ * Mac suppress a push.
+ */
+describe("client OS per-row evidence marker", () => {
+  beforeEach(() => {
+    addMessageCalls.length = 0;
+  });
+
+  test("marks an OS this row's own transport reported", async () => {
+    const ctx = createWebTurnContext("macos");
+    await persistQueuedMessageBody(ctx, {
+      content: "hello",
+      requestId: "req-transport-os",
+      requestClientOs: "macos",
+    });
+
+    expect(lastUserMetadata().client).toEqual({ os: "macos" });
+    expect(lastUserMetadata().clientOsFromRequest).toBe(true);
+    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(true);
+  });
+
+  test("marks an OS this row's own request headers reported", async () => {
+    const ctx = createWebTurnContext(undefined);
+    await persistQueuedMessageBody(ctx, {
+      content: "hello",
+      requestId: "req-header-os",
+      metadata: { client: { os: "macos", interface_version: "0.8.2" } },
+    });
+
+    expect(lastUserMetadata().clientOsFromRequest).toBe(true);
+    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(true);
+  });
+
+  // The bug shape: a button tapped on the phone reaches a conversation whose
+  // last desktop send left `clientOs: "macos"` behind. The row still carries
+  // the inherited OS for telemetry, but nothing says this turn came from the
+  // Mac, so the reply push must survive.
+  test("leaves an inherited OS unmarked and not Mac-originated", async () => {
+    const ctx = createWebTurnContext("macos");
+    await persistQueuedMessageBody(ctx, {
+      content: "[User action on card surface: submit]",
+      requestId: "req-inherited-os",
+    });
+
+    expect(lastUserMetadata().client).toEqual({ os: "macos" });
+    expect(lastUserMetadata().clientOsFromRequest).toBeUndefined();
+    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(false);
+  });
+
+  // The marker vouches for the `client.os` that actually landed, not for
+  // whatever the row reported: a reported OS the stamp disagrees with is no
+  // evidence at all.
+  test("leaves the marker off when the reported OS is not the stamped one", async () => {
+    const ctx = createWebTurnContext("macos");
+    await persistQueuedMessageBody(ctx, {
+      content: "hello",
+      requestId: "req-mismatched-os",
+      requestClientOs: "ios",
+    });
+
+    expect(lastUserMetadata().client).toEqual({ os: "macos" });
+    expect(lastUserMetadata().clientOsFromRequest).toBeUndefined();
+    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(false);
+  });
+
+  // The marker is derived from what this persist can see, so a bag value
+  // riding in from a caller must not survive the metadata spread and assert an
+  // origin the row never reported.
+  test("drops a caller-supplied marker from the metadata bag", async () => {
+    const ctx = createWebTurnContext("macos");
+    await persistQueuedMessageBody(ctx, {
+      content: "[User action on card surface: submit]",
+      requestId: "req-spoofed-marker",
+      metadata: { clientOsFromRequest: true },
+    });
+
+    expect(lastUserMetadata().clientOsFromRequest).toBeUndefined();
+    expect(isMacOriginatedUserMessage(lastUserMetadata())).toBe(false);
+  });
+
+  test("leaves the marker off for a reported OS outside the vocabulary", async () => {
+    const ctx = createWebTurnContext(undefined);
+    await persistQueuedMessageBody(ctx, {
+      content: "hello",
+      requestId: "req-unknown-os",
+      requestClientOs: "windows",
+    });
+
+    expect(lastUserMetadata().client).toBeUndefined();
+    expect(lastUserMetadata().clientOsFromRequest).toBeUndefined();
+  });
+});

package/src/__tests__/compactor-image-manifest-trust.test.ts

@@ -51,7 +51,7 @@ async function addImageMessage(
       skipIndexing: true,
     },
   );
-  attachInlineAttachmentToMessage(
+  await attachInlineAttachmentToMessage(
     inserted.id,
     0,
     filename,

package/src/__tests__/consult-deadline.test.ts

@@ -5,6 +5,8 @@
  */
 import { describe, expect, test } from "bun:test";
 
+import type { AssistantEvent } from "../api/index.js";
+import { isSubagentProgressEvent } from "../subagent/progress-events.js";
 import { createConsultDeadline } from "../tools/subagent/consult-deadline.js";
 
 const delay = (ms: number): Promise<void> =>
@@ -58,3 +60,66 @@ describe("createConsultDeadline", () => {
     expect(d.signal.aborted).toBe(false);
   });
 });
+
+describe("createConsultDeadline driven by subagent events", () => {
+  /** Feed an event through the classifier exactly as the manager's tap does. */
+  const feed = (
+    d: ReturnType<typeof createConsultDeadline>,
+    msg: AssistantEvent,
+  ): void => {
+    if (isSubagentProgressEvent(msg)) {
+      d.recordProgress();
+    }
+  };
+
+  test("tool activity re-arms the idle window with no token in sight", async () => {
+    // An advisor that opens a file streams no delta for the whole read. Tool
+    // events are the only sign of life, so they must hold the window open.
+    const d = createConsultDeadline({ idleMs: 150, maxMs: 10_000 });
+    const toolEvents = [
+      { type: "tool_use_start", toolName: "file_read", input: {} },
+      { type: "tool_input_delta", toolName: "file_read", content: "{" },
+      { type: "tool_output_chunk", chunk: "line" },
+      { type: "tool_result", result: "contents" },
+    ] as unknown as AssistantEvent[];
+    try {
+      for (let i = 0; i < 8; i++) {
+        await delay(25);
+        expect(d.signal.aborted).toBe(false);
+        feed(d, toolEvents[i % toolEvents.length]!);
+      }
+    } finally {
+      d.dispose();
+    }
+  });
+
+  test("a lifecycle event is not progress and does not hold the window open", async () => {
+    // The classifier is an allowlist: status chatter must not keep a genuinely
+    // stalled consult alive.
+    const d = createConsultDeadline({ idleMs: 50, maxMs: 10_000 });
+    try {
+      for (let i = 0; i < 5; i++) {
+        await delay(50);
+        feed(d, { type: "subagent_status_changed" } as AssistantEvent);
+      }
+      expect(d.signal.aborted).toBe(true);
+    } finally {
+      d.dispose();
+    }
+  });
+
+  test("tool activity cannot push the consult past the absolute backstop", async () => {
+    // The idle window can't fire; the max must, so a wedged tool that keeps
+    // emitting output chunks still ends the consult.
+    const d = createConsultDeadline({ idleMs: 10_000, maxMs: 70 });
+    try {
+      for (let i = 0; i < 8; i++) {
+        await delay(25);
+        feed(d, { type: "tool_output_chunk", chunk: "x" } as AssistantEvent);
+      }
+      expect(d.signal.aborted).toBe(true);
+    } finally {
+      d.dispose();
+    }
+  });
+});