@vellumai/assistant 0.8.4 → 0.8.6

package/src/background-wake/wake-intent-hooks.test.ts

@@ -0,0 +1,282 @@
+import { mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { BackgroundWakeIntent } from "./next-wake.js";
+import type { BackgroundWakeIntentClientResult } from "./platform-client.js";
+
+const mockPublishBackgroundWakeIntent = mock(
+  async (): Promise<BackgroundWakeIntentClientResult> => ({
+    status: "published",
+  }),
+);
+const mockClearBackgroundWakeIntent = mock(
+  async (): Promise<BackgroundWakeIntentClientResult> => ({
+    status: "cleared",
+  }),
+);
+let computedIntent: BackgroundWakeIntent | null = intentFixture();
+const testWorkspaceDir =
+  process.env.VELLUM_WORKSPACE_DIR ?? "/tmp/vellum-wake-intent-hooks";
+const workspacePath = (...parts: string[]) => join(testWorkspaceDir, ...parts);
+
+mock.module("./next-wake.js", () => ({
+  computeNextBackgroundWakeIntent: () => computedIntent,
+}));
+
+mock.module("./platform-client.js", () => ({
+  publishBackgroundWakeIntent: mockPublishBackgroundWakeIntent,
+  clearBackgroundWakeIntent: mockClearBackgroundWakeIntent,
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+  truncateForLog: (value: string) => value,
+}));
+
+mock.module("../runtime/sync/resource-sync-events.js", () => ({
+  publishSchedulesChanged: () => {},
+}));
+
+mock.module("../util/platform.js", () => ({
+  getWorkspaceDir: () => testWorkspaceDir,
+  getWorkspaceDirDisplay: () => testWorkspaceDir,
+  getWorkspacePromptPath: (name: string) => workspacePath(name),
+  getWorkspaceConfigPath: () => workspacePath("config.json"),
+  getWorkspaceSkillsDir: () => workspacePath("skills"),
+  getWorkspaceHooksDir: () => workspacePath("hooks"),
+  getWorkspacePluginsDir: () => workspacePath("plugins"),
+  getWorkspaceRoutesDir: () => workspacePath("routes"),
+  vellumRoot: () => testWorkspaceDir,
+  getDataDir: () => workspacePath("data"),
+  getDbPath: () => workspacePath("data", "db", "assistant.db"),
+  ensureDataDir: () => {
+    mkdirSync(workspacePath("data", "db"), { recursive: true });
+  },
+  getLogsDir: () => workspacePath("data", "logs"),
+  getHistoryPath: () => workspacePath("data", "history"),
+  getProtectedDir: () => workspacePath("protected"),
+  getSignalsDir: () => workspacePath("signals"),
+  getPidPath: () => workspacePath("vellum.pid"),
+  getDaemonStderrLogPath: () => workspacePath("logs", "daemon-stderr.log"),
+  getDaemonStartupLockPath: () => workspacePath("daemon-startup.lock"),
+  getExternalDir: () => workspacePath("external"),
+  getBinDir: () => workspacePath("bin"),
+  getDotEnvPath: () => workspacePath(".env"),
+  getEmbedWorkerPidPath: () => workspacePath("embed-worker.pid"),
+  getDeprecatedDir: () => workspacePath("deprecated"),
+  getConversationsDir: () => workspacePath("conversations"),
+  isMacOS: () => false,
+  isLinux: () => true,
+  isWindows: () => false,
+  getPlatformName: () => "linux",
+  normalizeAssistantId: (id: string) => id,
+  getEmbeddingModelsDir: () => workspacePath("embedding-models"),
+  getSandboxRootDir: () => workspacePath("data", "sandbox"),
+  getSandboxWorkingDir: () => testWorkspaceDir,
+  getSoundsDir: () => workspacePath("data", "sounds"),
+  getAvatarDir: () => workspacePath("data", "avatar"),
+  AVATAR_IMAGE_FILENAME: "avatar-image.png",
+  getAvatarImagePath: () => workspacePath("data", "avatar", "avatar-image.png"),
+  getXdgVellumConfigDirName: () => ".vellum",
+  getProfilerRootDir: () => workspacePath("data", "profiler"),
+  getProfilerRunsDir: () => workspacePath("data", "profiler", "runs"),
+  getProfilerRunDir: (runId: string) =>
+    workspacePath("data", "profiler", "runs", runId),
+  getSkillRuntimePath: () => undefined,
+  getBundledBunPath: () => undefined,
+}));
+
+const {
+  flushBackgroundWakeIntentRefreshForTest,
+  refreshBackgroundWakeIntent,
+  resetBackgroundWakeIntentPublisherForTest,
+} = await import("./publisher.js");
+const { initializeDb } = await import("../memory/db-init.js");
+const { getDb } = await import("../memory/db-connection.js");
+const { createSchedule, deleteSchedule, updateSchedule } =
+  await import("../schedule/schedule-store.js");
+
+initializeDb();
+
+describe("background wake intent publisher hooks", () => {
+  beforeEach(() => {
+    computedIntent = intentFixture();
+    mockPublishBackgroundWakeIntent.mockClear();
+    mockClearBackgroundWakeIntent.mockClear();
+    mockPublishBackgroundWakeIntent.mockImplementation(async () => ({
+      status: "published" as const,
+    }));
+    mockClearBackgroundWakeIntent.mockImplementation(async () => ({
+      status: "cleared" as const,
+    }));
+    resetBackgroundWakeIntentPublisherForTest();
+    const db = getDb();
+    db.run("DELETE FROM cron_runs");
+    db.run("DELETE FROM cron_jobs");
+  });
+
+  test("debounces repeated refreshes into one publish", async () => {
+    refreshBackgroundWakeIntent("first");
+    refreshBackgroundWakeIntent("second");
+    refreshBackgroundWakeIntent("third");
+
+    await flushBackgroundWakeIntentRefreshForTest();
+
+    expect(mockPublishBackgroundWakeIntent).toHaveBeenCalledTimes(1);
+    expect(mockClearBackgroundWakeIntent).not.toHaveBeenCalled();
+  });
+
+  test("clears without throwing when no local intent exists", async () => {
+    computedIntent = null;
+
+    refreshBackgroundWakeIntent("no-intent");
+    await flushBackgroundWakeIntentRefreshForTest();
+
+    expect(mockClearBackgroundWakeIntent).toHaveBeenCalledTimes(1);
+    expect(mockClearBackgroundWakeIntent).toHaveBeenCalledWith(null);
+  });
+
+  test("keeps last intent snapshot when clear is skipped so it can retry", async () => {
+    const publishedIntent = intentFixture({
+      computedAt: 1_800_000_000_000,
+      sourceGeneration: "bw1:stable-source",
+    });
+    computedIntent = publishedIntent;
+
+    refreshBackgroundWakeIntent("publish");
+    await flushBackgroundWakeIntentRefreshForTest();
+
+    computedIntent = null;
+    mockClearBackgroundWakeIntent.mockImplementationOnce(async () => ({
+      status: "skipped" as const,
+      reason: "missing_platform_client" as const,
+    }));
+
+    refreshBackgroundWakeIntent("clear-skipped");
+    await flushBackgroundWakeIntentRefreshForTest();
+    refreshBackgroundWakeIntent("clear-retry");
+    await flushBackgroundWakeIntentRefreshForTest();
+
+    expect(mockClearBackgroundWakeIntent).toHaveBeenCalledTimes(2);
+    expect(mockClearBackgroundWakeIntent).toHaveBeenNthCalledWith(
+      1,
+      publishedIntent,
+    );
+    expect(mockClearBackgroundWakeIntent).toHaveBeenNthCalledWith(
+      2,
+      publishedIntent,
+    );
+  });
+
+  test("does not throw into callers when platform publish fails", async () => {
+    mockPublishBackgroundWakeIntent.mockImplementation(async () => {
+      throw new Error("network down");
+    });
+
+    refreshBackgroundWakeIntent("publish-failure");
+    await expect(
+      flushBackgroundWakeIntentRefreshForTest(),
+    ).resolves.toBeUndefined();
+
+    expect(mockPublishBackgroundWakeIntent).toHaveBeenCalledTimes(1);
+  });
+
+  test("schedule create, update, and delete mutations refresh the wake intent", async () => {
+    const job = createSchedule({
+      name: "Wake hook",
+      cronExpression: "* * * * *",
+      message: "wake",
+      syntax: "cron",
+    });
+    await flushQueuedWakeRefresh();
+    expect(mockPublishBackgroundWakeIntent).toHaveBeenCalledTimes(1);
+
+    updateSchedule(job.id, { name: "Wake hook updated" });
+    await flushQueuedWakeRefresh();
+    expect(mockPublishBackgroundWakeIntent).toHaveBeenCalledTimes(2);
+
+    expect(deleteSchedule(job.id)).toBe(true);
+    await flushQueuedWakeRefresh();
+    expect(mockPublishBackgroundWakeIntent).toHaveBeenCalledTimes(3);
+  });
+
+  test("heartbeat scheduling and run-completion paths queue wake intent refreshes", () => {
+    const heartbeatSource = readFileSync(
+      new URL("../heartbeat/heartbeat-service.ts", import.meta.url),
+      "utf-8",
+    );
+
+    expect(heartbeatSource).toContain(
+      'refreshBackgroundWakeIntentSoon("heartbeat-disabled")',
+    );
+    expect(heartbeatSource).toContain(
+      'refreshBackgroundWakeIntentSoon("heartbeat-cron-scheduled")',
+    );
+    expect(heartbeatSource).toContain(
+      'refreshBackgroundWakeIntentSoon("heartbeat-interval-scheduled")',
+    );
+    expect(heartbeatSource).toContain(
+      'refreshBackgroundWakeIntentSoon("heartbeat-reconfigured")',
+    );
+    expect(heartbeatSource).toContain(
+      'refreshBackgroundWakeIntentSoon("heartbeat-run-complete")',
+    );
+  });
+
+  test("daemon lifecycle publishes once after heartbeat and scheduler startup", () => {
+    const lifecycleSource = readFileSync(
+      new URL("../daemon/lifecycle.ts", import.meta.url),
+      "utf-8",
+    );
+
+    expect(lifecycleSource).toContain(
+      [
+        "heartbeat.start();",
+        "registerBackgroundWakeRuntime({ scheduler, heartbeat });",
+        'refreshBackgroundWakeIntent("daemon-startup");',
+      ].join("\n    "),
+    );
+  });
+
+  test("shutdown paths do not clear background wake intents", () => {
+    const lifecycleSource = readFileSync(
+      new URL("../daemon/lifecycle.ts", import.meta.url),
+      "utf-8",
+    );
+    const shutdownSource = readFileSync(
+      new URL("../daemon/shutdown-handlers.ts", import.meta.url),
+      "utf-8",
+    );
+
+    expect(lifecycleSource).not.toContain("clearBackgroundWakeIntent");
+    expect(shutdownSource).not.toContain("clearBackgroundWakeIntent");
+    expect(shutdownSource).not.toContain("background-wake/platform-client");
+  });
+});
+
+async function flushQueuedWakeRefresh(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  await flushBackgroundWakeIntentRefreshForTest();
+}
+
+function intentFixture(
+  overrides: Partial<BackgroundWakeIntent> = {},
+): BackgroundWakeIntent {
+  const nextWakeAt = 1_800_000_060_000;
+  return {
+    nextWakeAt,
+    actualNextDueAt: nextWakeAt,
+    reason: "schedule",
+    sourceGeneration: "bw1:source",
+    computedAt: nextWakeAt - 60_000,
+    sourcePayload: {
+      heartbeat: null,
+      schedules: [],
+    },
+    ...overrides,
+  };
+}

package/src/calls/guardian-dispatch.ts

@@ -186,6 +186,7 @@ async function dispatchGuardianQuestionInner(
       sourceEventName: "guardian.question",
       sourceChannel: "phone",
       sourceContextId: callSessionId,
+      requiresConversation: true,
       attentionHints: {
         requiresAction: true,
         urgency: "high",

package/src/calls/voice-session-bridge.ts

@@ -434,11 +434,11 @@ export async function startVoiceTurn(
     );
     conversation.setVoiceCallControlPrompt(voiceCallControlPrompt);
 
-    messageId = await conversation.persistUserMessage(
-      persistedContent,
-      [],
+    const persistResult = await conversation.persistUserMessage({
+      content: persistedContent,
       requestId,
-    );
+    });
+    messageId = persistResult.id;
   } catch (err) {
     cleanup();
     throw err;

package/src/cli/commands/__tests__/browser.test.ts

@@ -131,26 +131,44 @@ beforeEach(() => {
 // ---------------------------------------------------------------------------
 
 describe("subcommand registration", () => {
-  test("registers exactly 17 subcommands", () => {
+  test("registers one direct subcommand per BROWSER_OPERATIONS entry plus 'tabs' group", () => {
     const program = new Command();
     registerBrowserCommand(program);
     const browser = program.commands.find((c) => c.name() === "browser");
     expect(browser).toBeDefined();
-    const subcommands = browser!.commands;
-    expect(subcommands).toHaveLength(17);
+    // 17 operation commands + 1 'tabs' grouping subcommand
+    expect(browser!.commands).toHaveLength(BROWSER_OPERATIONS.length + 1);
   });
 
-  test("subcommand names match kebab-cased BROWSER_OPERATIONS", () => {
+  test("operation subcommand names match kebab-cased BROWSER_OPERATIONS", () => {
     const program = new Command();
     registerBrowserCommand(program);
     const browser = program.commands.find((c) => c.name() === "browser");
-    const subcommandNames = browser!.commands.map((c) => c.name()).sort();
+    // Filter out the 'tabs' grouping subcommand — it's not a BROWSER_OPERATIONS entry.
+    const subcommandNames = browser!.commands
+      .filter((c) => c.name() !== "tabs")
+      .map((c) => c.name())
+      .sort();
     const expectedNames = BROWSER_OPERATIONS.map((op) =>
       op.replace(/_/g, "-"),
     ).sort();
     expect(subcommandNames).toEqual(expectedNames);
   });
 
+  test("registers 'tabs' subcommand group with list/select/new/close", () => {
+    const program = new Command();
+    registerBrowserCommand(program);
+    const browser = program.commands.find((c) => c.name() === "browser");
+    const tabs = browser!.commands.find((c) => c.name() === "tabs");
+    expect(tabs).toBeDefined();
+    expect(tabs!.commands.map((c) => c.name()).sort()).toEqual([
+      "close",
+      "list",
+      "new",
+      "select",
+    ]);
+  });
+
   test("all 17 operations from BROWSER_OPERATIONS are covered", () => {
     expect(BROWSER_OPERATIONS).toHaveLength(17);
     expect(BROWSER_OPERATION_META).toHaveLength(17);

package/src/cli/commands/__tests__/conversations-slack.test.ts

@@ -77,6 +77,18 @@ mock.module("../../../ipc/gateway-client.js", () => ({
     gatewayCalls.push({ method, params, timeoutMs });
     return gatewayResponse;
   },
+  ipcCallPersistent: async (
+    method: string,
+    params?: Record<string, unknown>,
+    timeoutMs?: number,
+  ) => {
+    gatewayCalls.push({ method, params, timeoutMs });
+    return gatewayResponse;
+  },
+  resetPersistentClient: () => {},
+  ipcGetFeatureFlags: async () => ({}),
+  ipcGetVelayStatus: async () => null,
+  ipcClassifyRisk: async () => ({ risk: "low" }),
 }));
 
 mock.module("../../../messaging/providers/slack/send.js", () => ({
@@ -126,6 +138,10 @@ mock.module("../../../util/logger.js", () => ({
     error: () => {},
     debug: () => {},
   }),
+  initLogger: () => {},
+  truncateForLog: (value: string) => value,
+  pruneOldLogFiles: () => 0,
+  LOG_FILE_PATTERN: /^assistant-(\d{4}-\d{2}-\d{2})\.log$/,
 }));
 
 const { registerConversationsCommand } = await import("../conversations.js");

package/src/cli/commands/__tests__/domain-register.test.ts

@@ -204,4 +204,114 @@ describe("assistant domain register", () => {
     await runDomainCommand("domain", "register", "velly");
     expect(process.exitCode).not.toBe(0);
   });
+
+  test("--email-username is included in IPC body", async () => {
+    mockIpcCallFn = mock(() =>
+      Promise.resolve({
+        ok: true,
+        result: {
+          id: "550e8400-e29b-41d4-a716-446655440000",
+          domain: "velly.vellum.me",
+          status: "active",
+          verified: true,
+        },
+      }),
+    );
+
+    await runDomainCommand(
+      "domain",
+      "register",
+      "velly",
+      "--email-username",
+      "hello",
+    );
+
+    expect(mockIpcCallFn).toHaveBeenCalledWith("domain_register", {
+      body: { subdomain: "velly", email_username: "hello" },
+    });
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("email error in response is surfaced as warning", async () => {
+    mockIpcCallFn = mock(() =>
+      Promise.resolve({
+        ok: true,
+        result: {
+          id: "550e8400-e29b-41d4-a716-446655440000",
+          domain: "velly.vellum.me",
+          status: "active",
+          verified: true,
+          email_error: {
+            detail: "MX records not ready",
+            code: "email_setup_failed",
+          },
+        },
+      }),
+    );
+
+    await runDomainCommand(
+      "domain",
+      "register",
+      "velly",
+      "--email-username",
+      "hello",
+    );
+
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("--json includes email_error in output", async () => {
+    mockIpcCallFn = mock(() =>
+      Promise.resolve({
+        ok: true,
+        result: {
+          id: "550e8400-e29b-41d4-a716-446655440000",
+          domain: "velly.vellum.me",
+          status: "active",
+          verified: true,
+          email_error: {
+            detail: "MX records not ready",
+            code: "email_setup_failed",
+          },
+        },
+      }),
+    );
+
+    const output = await runDomainCommand(
+      "domain",
+      "--json",
+      "register",
+      "velly",
+      "--email-username",
+      "hello",
+    );
+
+    const parsed = JSON.parse(output.trim());
+    expect(parsed.email_error).toEqual({
+      detail: "MX records not ready",
+      code: "email_setup_failed",
+    });
+    expect(process.exitCode).toBe(0);
+  });
+
+  test("without --email-username behavior is unchanged", async () => {
+    mockIpcCallFn = mock(() =>
+      Promise.resolve({
+        ok: true,
+        result: {
+          id: "550e8400-e29b-41d4-a716-446655440000",
+          domain: "velly.vellum.me",
+          status: "active",
+          verified: true,
+        },
+      }),
+    );
+
+    await runDomainCommand("domain", "register", "velly");
+
+    expect(mockIpcCallFn).toHaveBeenCalledWith("domain_register", {
+      body: { subdomain: "velly" },
+    });
+    expect(process.exitCode).toBe(0);
+  });
 });

package/src/cli/commands/__tests__/domain-status.test.ts

@@ -2,9 +2,9 @@
  * Tests for the domain status CLI subcommand (thin IPC wrapper).
  *
  * Validates:
- *   - status calls domain_status
+ *   - status calls domain_status then domain_verification_status
  *   - --json outputs structured response
- *   - no domain shows helpful message
+ *   - unknown subdomain shows helpful message
  *   - error responses are surfaced correctly
  */
 
@@ -99,15 +99,16 @@ async function runDomainCommand(...args: string[]) {
 // status
 // ---------------------------------------------------------------------------
 
-describe("assistant domain status", () => {
-  test("calls domain_status", async () => {
-    mockIpcCallFn = mock(() =>
-      Promise.resolve({
+function mockDomainStatusWithVerification() {
+  mockIpcCallFn = mock((method: string) => {
+    if (method === "domain_status") {
+      return Promise.resolve({
         ok: true,
         result: {
           results: [
             {
               id: "550e8400-e29b-41d4-a716-446655440000",
+              subdomain: "becky",
               domain: "becky.vellum.me",
               status: "active",
               verified: true,
@@ -115,38 +116,37 @@ describe("assistant domain status", () => {
             },
           ],
         },
-      }),
-    );
+      });
+    }
+    return Promise.resolve({
+      ok: true,
+      result: {
+        domain: "becky.vellum.me",
+        status: "verified",
+        message: "DNS records have been verified.",
+      },
+    });
+  }) as unknown as typeof mockIpcCallFn;
+}
 
-    await runDomainCommand("domain", "status");
+describe("assistant domain status", () => {
+  test("calls domain_status and domain_verification_status", async () => {
+    mockDomainStatusWithVerification();
 
-    expect(mockIpcCallFn).toHaveBeenCalledWith("domain_status");
+    await runDomainCommand("domain", "status", "becky");
+
+    expect(mockIpcCallFn).toHaveBeenCalledTimes(2);
     expect(process.exitCode).toBe(0);
   });
 
   test("--json outputs structured response", async () => {
-    mockIpcCallFn = mock(() =>
-      Promise.resolve({
-        ok: true,
-        result: {
-          results: [
-            {
-              id: "550e8400-e29b-41d4-a716-446655440000",
-              domain: "becky.vellum.me",
-              status: "active",
-              verified: true,
-              created_at: "2026-04-15T19:00:00Z",
-            },
-          ],
-        },
-      }),
-    );
+    mockDomainStatusWithVerification();
 
-    const output = await runDomainCommand("domain", "--json", "status");
+    const output = await runDomainCommand("domain", "--json", "status", "becky");
 
     const parsed = JSON.parse(output.trim());
-    expect(parsed.results).toHaveLength(1);
-    expect(parsed.results[0].domain).toBe("becky.vellum.me");
+    expect(parsed.domain.domain).toBe("becky.vellum.me");
+    expect(parsed.verification.status).toBe("verified");
     expect(process.exitCode).toBe(0);
   });
 
@@ -158,8 +158,8 @@ describe("assistant domain status", () => {
       }),
     );
 
-    await runDomainCommand("domain", "status");
-    expect(process.exitCode).toBe(0);
+    await runDomainCommand("domain", "status", "becky");
+    expect(process.exitCode).toBe(1);
   });
 
   test("IPC error with --json outputs error envelope", async () => {
@@ -171,7 +171,7 @@ describe("assistant domain status", () => {
       }),
     ) as unknown as typeof mockIpcCallFn;
 
-    const output = await runDomainCommand("domain", "--json", "status");
+    const output = await runDomainCommand("domain", "--json", "status", "becky");
 
     expect(process.exitCode).not.toBe(0);
     const parsed = JSON.parse(output.trim());
@@ -187,7 +187,7 @@ describe("assistant domain status", () => {
       }),
     ) as unknown as typeof mockIpcCallFn;
 
-    await runDomainCommand("domain", "status");
+    await runDomainCommand("domain", "status", "becky");
     expect(process.exitCode).not.toBe(0);
   });
 });