@vellumai/assistant 0.6.3 → 0.6.4

package/src/__tests__/conversation-routes-disk-view.test.ts

@@ -21,6 +21,12 @@ import {
 import { getDb, initializeDb } from "../memory/db.js";
 import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
 import type { AuthContext } from "../runtime/auth/types.js";
+import {
+  __resetChromeExtensionRegistryForTests,
+  type ChromeExtensionConnection,
+  getChromeExtensionRegistry,
+} from "../runtime/chrome-extension-registry.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
 
 const testDir = process.env.VELLUM_WORKSPACE_DIR!;
@@ -329,6 +335,270 @@ beforeEach(() => {
   resetTables();
   resetConversationsDir();
   conversationInstances.clear();
+  pendingInteractions.clear();
+  __resetChromeExtensionRegistryForTests();
+});
+
+// ── macOS browser backend fallback regression ─────────────────────────
+//
+// These tests verify the route-level wiring that enables the CDP factory's
+// fallback chain on macOS-originated turns:
+//
+//   1. Extension connected  → extension backend (tested in host-browser-e2e-cloud.test.ts)
+//   2. Extension absent, cdp-inspect unavailable → local Playwright fallback
+//
+// Specifically, we verify that when a macOS message enters through
+// handleSendMessage with `interface: "macos"` and NO extension is connected,
+// the conversation's turnInterfaceContext is set correctly so the CDP factory
+// builds the right candidate list (cdp-inspect → local). If cdp-inspect
+// is also unreachable (the common case when Chrome is not launched with
+// --remote-debugging-port), the factory falls through to local.
+//
+// This is the regression guard for backend preference order step 2:
+//   macOS + no extension + cdp-inspect unavailable → local backend
+//
+// If the interface propagation or factory candidate list construction
+// regresses, these tests will fail.
+
+describe("macOS browser backend fallback (no extension, no cdp-inspect)", () => {
+  test("macOS turn without extension sets turnInterfaceContext to macos, enabling local fallback", async () => {
+    const conversationKey = `macos-fallback-${crypto.randomUUID()}`;
+    const content = "Test macOS fallback path.";
+    let capturedConversation: Conversation | undefined;
+
+    const response = await handleSendMessage(
+      new Request("http://localhost/v1/messages", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          conversationKey,
+          content,
+          sourceChannel: "vellum",
+          interface: "macos",
+        }),
+      }),
+      {
+        sendMessageDeps: {
+          getOrCreateConversation: async (conversationId: string) => {
+            const conv = getOrCreateFakeConversation(conversationId);
+            capturedConversation = conv;
+            return conv;
+          },
+          assistantEventHub: new AssistantEventHub(),
+          resolveAttachments: () => [],
+        },
+      },
+      authContext,
+    );
+
+    expect(response.status).toBe(202);
+
+    // The conversation instance should have its turnInterfaceContext set
+    // to "macos" by handleSendMessage. This is the value the CDP factory
+    // reads (via ToolContext.transportInterface) to decide whether to
+    // include cdp-inspect as a desktop-auto candidate and ultimately fall
+    // back to local Playwright when cdp-inspect is unavailable.
+    expect(capturedConversation).toBeDefined();
+    const interfaceCtx = capturedConversation!.getTurnInterfaceContext();
+    expect(interfaceCtx).not.toBeNull();
+    expect(interfaceCtx!.userMessageInterface).toBe("macos");
+    expect(interfaceCtx!.assistantMessageInterface).toBe("macos");
+
+    // With no extension in the ChromeExtensionRegistry, the conversation's
+    // hostBrowserProxy should NOT be provisioned through the registry.
+    // The absence of a hostBrowserProxy means the CDP factory will skip
+    // the extension candidate entirely and fall through:
+    // cdp-inspect (desktop-auto) → local.
+    expect(
+      (capturedConversation as unknown as Record<string, unknown>)
+        .hostBrowserProxy,
+    ).toBeUndefined();
+    expect(
+      (capturedConversation as unknown as Record<string, unknown>)
+        .hostBrowserSenderOverride,
+    ).toBeUndefined();
+  });
+
+  test("macOS turn correctly persists interface metadata through the agent loop", async () => {
+    const conversationKey = `macos-metadata-${crypto.randomUUID()}`;
+    const content = "Verify interface metadata persistence.";
+
+    const response = await handleSendMessage(
+      new Request("http://localhost/v1/messages", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          conversationKey,
+          content,
+          sourceChannel: "vellum",
+          interface: "macos",
+        }),
+      }),
+      {
+        sendMessageDeps: {
+          getOrCreateConversation: async (conversationId: string) =>
+            getOrCreateFakeConversation(conversationId),
+          assistantEventHub: new AssistantEventHub(),
+          resolveAttachments: () => [],
+        },
+      },
+      authContext,
+    );
+
+    expect(response.status).toBe(202);
+    const body = (await response.json()) as {
+      accepted: boolean;
+      conversationId: string;
+    };
+
+    // Wait for the agent loop to persist the assistant reply (the fake
+    // runAgentLoop persists interface metadata into message records).
+    const conversationRow = getConversation(body.conversationId);
+    expect(conversationRow).not.toBeNull();
+    const conversationDir = getConversationDirPath(
+      body.conversationId,
+      conversationRow!.createdAt,
+    );
+    const messagesPath = join(conversationDir, "messages.jsonl");
+
+    const lines = await waitFor(() => {
+      if (!existsSync(messagesPath)) return undefined;
+      const raw = readFileSync(messagesPath, "utf-8").trim();
+      if (!raw) return undefined;
+      const parsed = raw.split("\n").map(
+        (line) =>
+          JSON.parse(line) as {
+            role: string;
+            metadata?: Record<string, unknown>;
+          },
+      );
+      return parsed.length >= 2 ? parsed : undefined;
+    });
+
+    // The assistant reply (second line) should carry the interface metadata
+    // set by setTurnInterfaceContext during the macOS turn setup.
+    const assistantLine = lines[1];
+    expect(assistantLine?.role).toBe("assistant");
+    expect(assistantLine?.metadata?.userMessageInterface).toBe("macos");
+    expect(assistantLine?.metadata?.assistantMessageInterface).toBe("macos");
+  });
+});
+
+describe("chrome-extension host_browser pending registration", () => {
+  test("registers pending interaction before registry-routed host_browser send", async () => {
+    const guardianId = `guardian-${crypto.randomUUID()}`;
+    let pendingRegisteredAtSend: boolean | undefined;
+    let observedRequestId: string | undefined;
+
+    const connection: ChromeExtensionConnection = {
+      id: `conn-${crypto.randomUUID()}`,
+      guardianId,
+      ws: {
+        send(payload: string) {
+          const frame = JSON.parse(payload) as {
+            type?: string;
+            requestId?: string;
+          };
+          if (
+            frame.type === "host_browser_request" &&
+            typeof frame.requestId === "string"
+          ) {
+            observedRequestId = frame.requestId;
+            pendingRegisteredAtSend =
+              pendingInteractions.get(frame.requestId)?.kind === "host_browser";
+          }
+        },
+        close() {},
+      } as unknown as ChromeExtensionConnection["ws"],
+      connectedAt: Date.now(),
+      lastActiveAt: Date.now(),
+    };
+    getChromeExtensionRegistry().register(connection);
+
+    const actorAuthContext: AuthContext = {
+      ...authContext,
+      subject: `actor:self:${guardianId}`,
+      principalType: "actor",
+      scopeProfile: "actor_client_v1",
+      actorPrincipalId: guardianId,
+    };
+
+    const conversationKey = `chrome-ext-pending-${crypto.randomUUID()}`;
+    const response = await handleSendMessage(
+      new Request("http://localhost/v1/messages", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          conversationKey,
+          content: "Trigger host browser request via registry sender.",
+          sourceChannel: "vellum",
+          interface: "chrome-extension",
+        }),
+      }),
+      {
+        sendMessageDeps: {
+          getOrCreateConversation: async (conversationId: string) => {
+            const conversation = createFakeConversation(
+              conversationId,
+            ) as unknown as {
+              hostBrowserProxy?: {
+                request: (
+                  input: { cdpMethod: string; timeout_seconds?: number },
+                  conversationId: string,
+                ) => Promise<{ content: string; isError: boolean }>;
+              };
+              processing: boolean;
+              abortController: AbortController | null;
+              currentRequestId?: string;
+              runAgentLoop: (
+                content: string,
+                userMessageId: string,
+                onEvent: (msg: Record<string, unknown>) => void,
+              ) => Promise<void>;
+              conversationId: string;
+            };
+
+            conversation.runAgentLoop = async function (
+              _content: string,
+              _userMessageId: string,
+              _onEvent: (msg: Record<string, unknown>) => void,
+            ): Promise<void> {
+              if (!this.hostBrowserProxy) {
+                throw new Error(
+                  "Expected hostBrowserProxy to be provisioned for chrome-extension turn",
+                );
+              }
+              await this.hostBrowserProxy.request(
+                {
+                  cdpMethod: "Browser.getVersion",
+                  // Keep the test fast while still allowing assertion at send time.
+                  timeout_seconds: 0.05,
+                },
+                this.conversationId,
+              );
+              this.processing = false;
+              this.abortController = null;
+              this.currentRequestId = undefined;
+            };
+
+            conversationInstances.set(
+              conversationId,
+              conversation as unknown as Conversation,
+            );
+            return conversation as unknown as Conversation;
+          },
+          assistantEventHub: new AssistantEventHub(),
+          resolveAttachments: () => [],
+        },
+      },
+      actorAuthContext,
+    );
+
+    expect(response.status).toBe(202);
+    const registered = await waitFor(() => pendingRegisteredAtSend, 1000);
+    expect(observedRequestId).toBeDefined();
+    expect(registered).toBe(true);
+  });
 });
 
 describe("conversationKey send path disk-view regression", () => {

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -1391,6 +1391,61 @@ describe("buildUnifiedTurnContextBlock", () => {
     expect(text).toContain("contact_notes: Prefers short replies");
     expect(text).toContain("contact_interaction_count: 42");
   });
+
+  test("time_since_last_message: emitted right after current_time when provided", () => {
+    const options: UnifiedTurnContextOptions = {
+      timestamp: "2026-04-02T12:00:00Z",
+      interfaceName: "macos",
+      timeSinceLastMessage: "2d ago",
+    };
+
+    const text = buildUnifiedTurnContextBlock(options);
+    const lines = text.split("\n");
+    expect(lines[0]).toBe("<turn_context>");
+    expect(lines[1]).toBe("current_time: 2026-04-02T12:00:00Z");
+    expect(lines[2]).toBe("time_since_last_message: 2d ago");
+    expect(lines[3]).toBe("interface: macos");
+    expect(lines[4]).toBe("</turn_context>");
+  });
+
+  test("time_since_last_message: omitted when null", () => {
+    const options: UnifiedTurnContextOptions = {
+      timestamp: "2026-04-02T12:00:00Z",
+      interfaceName: "macos",
+      timeSinceLastMessage: null,
+    };
+
+    const text = buildUnifiedTurnContextBlock(options);
+    expect(text).not.toContain("time_since_last_message");
+  });
+
+  test("time_since_last_message: omitted when field absent (backward-compat)", () => {
+    const options: UnifiedTurnContextOptions = {
+      timestamp: "2026-04-02T12:00:00Z",
+      interfaceName: "macos",
+    };
+
+    const text = buildUnifiedTurnContextBlock(options);
+    expect(text).not.toContain("time_since_last_message");
+  });
+
+  test("time_since_last_message: works on non-guardian path", () => {
+    const options: UnifiedTurnContextOptions = {
+      timestamp: "2026-04-02T12:00:00Z",
+      interfaceName: "telegram",
+      channelName: "telegram",
+      timeSinceLastMessage: "yesterday",
+      actorContext: {
+        sourceChannel: "telegram",
+        canonicalActorIdentity: "user-1",
+        trustClass: "trusted_contact",
+      },
+    };
+
+    const text = buildUnifiedTurnContextBlock(options);
+    expect(text).toContain("time_since_last_message: yesterday");
+    expect(text).toContain("canonical_actor_identity: user-1");
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/conversation-skill-tools.test.ts

@@ -1829,7 +1829,7 @@ describe("bundled skill: browser", () => {
     sessionState = new Map<string, string>();
   });
 
-  test("browser skill activation via loaded_skill marker registers all 14 tools in allowedToolNames", () => {
+  test("browser skill activation via loaded_skill marker registers all browser tools in allowedToolNames", () => {
     mockCatalog = [makeSkill("browser", "/path/to/bundled-skills/browser")];
     mockManifests = { browser: makeManifest([...BROWSER_TOOL_NAMES]) };
 
@@ -1876,7 +1876,7 @@ describe("bundled skill: browser", () => {
 
     const tools = mockRegisteredTools.get("browser");
     expect(tools).toBeDefined();
-    expect(tools!.length).toBe(14);
+    expect(tools!.length).toBe(BROWSER_TOOL_NAMES.length);
 
     for (const tool of tools!) {
       expect(tool.origin).toBe("skill");
@@ -2610,10 +2610,13 @@ describe("browser skill migration harness", () => {
     expect(id1).not.toBe(id2);
   });
 
-  test("BROWSER_TOOL_NAMES contains all 14 browser tools", () => {
-    expect(BROWSER_TOOL_NAMES).toHaveLength(14);
+  test("BROWSER_TOOL_NAMES contains all browser tools", () => {
+    expect(BROWSER_TOOL_NAMES).toHaveLength(17);
     expect(BROWSER_TOOL_NAMES).toContain("browser_navigate");
+    expect(BROWSER_TOOL_NAMES).toContain("browser_attach");
+    expect(BROWSER_TOOL_NAMES).toContain("browser_detach");
     expect(BROWSER_TOOL_NAMES).toContain("browser_fill_credential");
+    expect(BROWSER_TOOL_NAMES).toContain("browser_status");
   });
 
   test("assertBrowserToolsPresent passes when all tools present", () => {

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

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
 import {
+  classifySlash,
   resolveSlash,
   type SlashContext,
 } from "../daemon/conversation-slash.js";
@@ -148,3 +149,35 @@ describe("resolveSlash command contract", () => {
     expect(result.message).toContain("Pairing is not available");
   });
 });
+
+describe("classifySlash is a pure classifier matching resolveSlash kinds", () => {
+  // Lookahead in `buildPassthroughBatch` must not run `resolveSlash`'s side
+  // effects (/pair registers a pairing request and writes a QR PNG). The
+  // pure classifier is synchronous, takes no side-effecting dependencies,
+  // and must agree with resolveSlash's `kind`.
+  const cases: Array<{ input: string; kind: "passthrough" | "compact" | "unknown" }> = [
+    { input: "/pair", kind: "unknown" },
+    { input: "/models", kind: "unknown" },
+    { input: "/status", kind: "unknown" },
+    { input: "/commands", kind: "unknown" },
+    { input: "/compact", kind: "compact" },
+    { input: "/model", kind: "unknown" },
+    { input: "/model foo", kind: "unknown" },
+    { input: "/opus", kind: "unknown" },
+    { input: "hello", kind: "passthrough" },
+    { input: "  /compact  ", kind: "compact" },
+    { input: "/pair foo", kind: "passthrough" },
+    { input: "/models foo", kind: "passthrough" },
+  ];
+
+  for (const { input, kind } of cases) {
+    test(`classifies ${JSON.stringify(input)} as ${kind}`, async () => {
+      expect(classifySlash(input)).toBe(kind);
+      const resolved = await resolveSlash(
+        input,
+        makeSlashContext({ userMessageInterface: "macos" }),
+      );
+      expect(resolved.kind).toBe(kind);
+    });
+  }
+});

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

@@ -90,6 +90,7 @@ mock.module("../security/secret-allowlist.js", () => ({
 mock.module("../memory/conversation-crud.js", () => ({
   getConversationType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
+  setConversationOriginInterfaceIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},
   provenanceFromTrustContext: () => ({
@@ -113,6 +114,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   },
   updateConversationUsage: () => {},
   updateConversationTitle: () => {},
+  getMessageById: () => null,
+  getLastUserTimestampBefore: () => 0,
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -206,6 +209,24 @@ mock.module("../agent/loop.js", () => ({
     }
   },
 }));
+// Avoid real workspace-git initialization on /tmp — on CI runners,
+// `git add -A` under /tmp hits permission errors on systemd-private dirs,
+// which blocks `runAgentLoopImpl` for long enough to trip the test's
+// `waitForPendingRun` 2s timeout before `AgentLoop.run` is invoked.
+mock.module("../workspace/git-service.js", () => ({
+  getWorkspaceGitService: () => ({
+    ensureInitialized: async () => {},
+  }),
+}));
+
+mock.module("../workspace/turn-commit.js", () => ({
+  commitTurnChanges: async () => {},
+}));
+
+mock.module("../memory/app-git-service.js", () => ({
+  commitAppTurnChanges: async () => {},
+}));
+
 mock.module("../memory/canonical-guardian-store.js", () => ({
   listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
   listCanonicalGuardianRequests: () => [],
@@ -232,6 +253,12 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 
 import { Conversation } from "../daemon/conversation.js";
 
+type ConversationWithWorkspaceDeps = Conversation & {
+  getWorkspaceGitService?: (_workspaceDir: string) => {
+    ensureInitialized: () => Promise<void>;
+  };
+};
+
 function makeConversation(): Conversation {
   const provider = {
     name: "mock",
@@ -244,7 +271,7 @@ function makeConversation(): Conversation {
       };
     },
   };
-  return new Conversation(
+  const conversation = new Conversation(
     "conv-1",
     provider,
     "system prompt",
@@ -252,6 +279,13 @@ function makeConversation(): Conversation {
     () => {},
     "/tmp",
   );
+  // Bypass real workspace git init: with "/tmp" as the workspace dir, a real
+  // ensureInitialized() walks all of /tmp and can exceed the 2s waitForPendingRun
+  // budget on CI where parallel tests churn /tmp subdirectories.
+  (conversation as ConversationWithWorkspaceDeps).getWorkspaceGitService = () => ({
+    ensureInitialized: async () => {},
+  });
+  return conversation;
 }
 
 async function waitForPendingRun(
@@ -296,7 +330,7 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     pendingRuns = [];
   });
 
-  test("queued slash-like input does not stall queue — passes through", async () => {
+  test("queued slash-like input does not stall queue — batches with siblings", async () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
@@ -313,7 +347,8 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     );
     await waitForPendingRun(1);
 
-    // Enqueue a slash-like message and a normal message after it
+    // Enqueue a slash-like passthrough and a normal passthrough after it.
+    // Both resolve to passthrough, so the batch builder groups them into one run.
     conversation.enqueueMessage(
       "/not-a-skill",
       [],
@@ -323,30 +358,19 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     conversation.enqueueMessage("msg-3", [], (e) => events3.push(e), "req-3");
     expect(conversation.getQueueDepth()).toBe(2);
 
-    // Complete first run — triggers drain
+    // Complete first run — drain pulls both queued messages into one batched run.
     resolveRun(0);
     await p1;
-
-    // The slash-like message should go through agent loop (passthrough)
     await waitForPendingRun(2);
 
-    // Slash-like message events: dequeued (agent loop started)
+    // Both batched clients see their own message_dequeued.
     expect(eventsSlash.some((e) => e.type === "message_dequeued")).toBe(true);
+    expect(events3.some((e) => e.type === "message_dequeued")).toBe(true);
 
-    // It goes through the agent loop — so 2 agent runs total (msg-1 and /not-a-skill)
+    // Exactly 2 runs total: msg-1 + batched [/not-a-skill, msg-3].
     expect(pendingRuns.length).toBe(2);
 
-    // Complete the slash run so msg-3 can drain
     resolveRun(1);
-    await waitForPendingRun(3);
-
-    // msg-3 events: dequeued (agent loop started)
-    expect(events3.some((e) => e.type === "message_dequeued")).toBe(true);
-
-    // 3 total agent loop runs: msg-1, /not-a-skill, msg-3
-    expect(pendingRuns.length).toBe(3);
-
-    resolveRun(2);
     await new Promise((r) => setTimeout(r, 50));
   });
 
@@ -393,4 +417,51 @@ describe("Conversation queue — slash-like messages pass through to agent loop"
     resolveRun(1);
     await new Promise((r) => setTimeout(r, 50));
   });
+
+  test("passthrough batch is terminated by a /compact in the middle of the queue", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const eventsHi: ServerMessage[] = [];
+    const eventsCompact: ServerMessage[] = [];
+    const eventsBye: ServerMessage[] = [];
+
+    // Start in-flight message
+    const p1 = conversation.processMessage("msg-1", [], () => {}, "req-1");
+    await waitForPendingRun(1);
+
+    // Enqueue ["hi", "/compact", "bye"]. /compact is non-passthrough, so the
+    // batch builder stops at "hi" (length-1 batch → drainSingleMessage). Then
+    // /compact takes its short-circuit path (no new runAgentLoop), and "bye"
+    // drains as its own run.
+    conversation.enqueueMessage("hi", [], (e) => eventsHi.push(e), "req-hi");
+    conversation.enqueueMessage(
+      "/compact",
+      [],
+      (e) => eventsCompact.push(e),
+      "req-compact",
+    );
+    conversation.enqueueMessage("bye", [], (e) => eventsBye.push(e), "req-bye");
+    expect(conversation.getQueueDepth()).toBe(3);
+
+    // Resolve msg-1 → drain pulls only "hi" (batch builder stops at /compact).
+    resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+
+    expect(pendingRuns.length).toBe(2);
+    expect(eventsHi.some((e) => e.type === "message_dequeued")).toBe(true);
+
+    // Resolve "hi" → /compact short-circuits without a new runAgentLoop, then
+    // drains "bye" as its own run.
+    resolveRun(1);
+    await waitForPendingRun(3);
+
+    expect(eventsCompact.some((e) => e.type === "message_complete")).toBe(true);
+    expect(eventsBye.some((e) => e.type === "message_dequeued")).toBe(true);
+    expect(pendingRuns.length).toBe(3);
+
+    resolveRun(2);
+    await new Promise((r) => setTimeout(r, 50));
+  });
 });

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

@@ -120,6 +120,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   },
   updateConversationUsage: () => {},
   updateConversationTitle: () => {},
+  getMessageById: () => null,
+  getLastUserTimestampBefore: () => 0,
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({