@vellumai/assistant 0.8.5 → 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__/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__/notifications.test.ts

@@ -437,74 +437,218 @@ describe("notifications send — minimal-surface ergonomics", () => {
 // ---------------------------------------------------------------------------
 
 describe("notifications list", () => {
-  test("list returns empty array when no events", async () => {
-    ipcResponse = { ok: true, result: [] };
+  const emptyPayload = {
+    items: [],
+    total: 0,
+    returned: 0,
+    hasMore: false,
+    updatedAt: "2026-05-28T00:00:00.000Z",
+  };
+
+  function feedItem(
+    overrides: Record<string, unknown>,
+  ): Record<string, unknown> {
+    return {
+      id: "feed-1",
+      type: "notification",
+      priority: 50,
+      summary: "Background sync done",
+      timestamp: "2026-05-28T10:00:00.000Z",
+      status: "new",
+      createdAt: "2026-05-28T10:00:00.000Z",
+      ...overrides,
+    };
+  }
+
+  test("list calls list_home_feed and returns empty payload", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
 
     const { parsed, exitCode } = await runCommand(["list"]);
 
     expect(exitCode).toBe(0);
     expect(parsed.ok).toBe(true);
-    expect(parsed.events).toEqual([]);
+    expect(parsed.items).toEqual([]);
+    expect(parsed.total).toBe(0);
 
     expect(ipcCalls).toHaveLength(1);
-    expect(ipcCalls[0].method).toBe("list_notification_events");
+    expect(ipcCalls[0].method).toBe("list_home_feed");
   });
 
-  test("list returns events from IPC", async () => {
+  test("list returns items from IPC", async () => {
     ipcResponse = {
       ok: true,
-      result: [
-        {
-          id: "evt-1",
-          sourceEventName: "user.send_notification",
-          sourceChannel: "assistant_tool",
-          sourceContextId: "session-1",
-          urgency: "medium",
-          dedupeKey: null,
-          createdAt: "2026-01-01T00:00:00.000Z",
-        },
-      ],
+      result: {
+        ...emptyPayload,
+        items: [feedItem({ title: "Hello", urgency: "medium" })],
+        total: 1,
+        returned: 1,
+      },
     };
 
     const { parsed, exitCode } = await runCommand(["list"]);
 
     expect(exitCode).toBe(0);
     expect(parsed.ok).toBe(true);
-    const events = parsed.events as Array<Record<string, unknown>>;
-    expect(events).toHaveLength(1);
-    expect(events[0].sourceEventName).toBe("user.send_notification");
+    const items = parsed.items as Array<Record<string, unknown>>;
+    expect(items).toHaveLength(1);
+    expect(items[0].title).toBe("Hello");
   });
 
-  test("list passes --limit to IPC", async () => {
-    ipcResponse = { ok: true, result: [] };
+  test("list defaults to excluding dismissed (no includeDismissed flag in body)", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
 
-    const { parsed, exitCode } = await runCommand(["list", "--limit", "5"]);
+    await runCommand(["list"]);
 
-    expect(exitCode).toBe(0);
-    expect(parsed.ok).toBe(true);
+    const body = ipcCalls[0].params?.body as Record<string, unknown>;
+    expect(body.includeDismissed).toBeUndefined();
+    expect(body.statuses).toBeUndefined();
+  });
 
-    expect(ipcCalls).toHaveLength(1);
-    expect((ipcCalls[0].params?.body as Record<string, unknown>)?.limit).toBe(
-      5,
-    );
+  test("--all sets includeDismissed=true", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
+
+    await runCommand(["list", "--all"]);
+
+    const body = ipcCalls[0].params?.body as Record<string, unknown>;
+    expect(body.includeDismissed).toBe(true);
   });
 
-  test("list passes --source-event-name to IPC", async () => {
-    ipcResponse = { ok: true, result: [] };
+  test("--status is repeatable and passed as statuses array", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
 
+    await runCommand(["list", "--status", "new", "--status", "acted_on"]);
+
+    const body = ipcCalls[0].params?.body as Record<string, unknown>;
+    expect(body.statuses).toEqual(["new", "acted_on"]);
+  });
+
+  test("--status rejects invalid value before IPC call", async () => {
     const { parsed, exitCode } = await runCommand([
       "list",
-      "--source-event-name",
-      "schedule.notify",
+      "--status",
+      "bogus",
     ]);
 
-    expect(exitCode).toBe(0);
-    expect(parsed.ok).toBe(true);
+    expect(exitCode).toBe(1);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("status");
+    expect(ipcCalls).toHaveLength(0);
+  });
 
-    expect(ipcCalls).toHaveLength(1);
-    expect(
-      (ipcCalls[0].params?.body as Record<string, unknown>)?.sourceEventName,
-    ).toBe("schedule.notify");
+  test("--before and --after are forwarded as ISO strings", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
+
+    await runCommand([
+      "list",
+      "--after",
+      "2026-05-28T00:00:00Z",
+      "--before",
+      "2026-05-29T00:00:00Z",
+    ]);
+
+    const body = ipcCalls[0].params?.body as Record<string, unknown>;
+    expect(body.after).toBe("2026-05-28T00:00:00Z");
+    expect(body.before).toBe("2026-05-29T00:00:00Z");
+  });
+
+  test("--urgency is repeatable and passed as urgencies array", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
+
+    await runCommand(["list", "--urgency", "high", "--urgency", "critical"]);
+
+    const body = ipcCalls[0].params?.body as Record<string, unknown>;
+    expect(body.urgencies).toEqual(["high", "critical"]);
+  });
+
+  test("--urgency rejects invalid value", async () => {
+    const { exitCode, parsed } = await runCommand([
+      "list",
+      "--urgency",
+      "extreme",
+    ]);
+
+    expect(exitCode).toBe(1);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("urgency");
+    expect(ipcCalls).toHaveLength(0);
+  });
+
+  test("--category is repeatable and passed as categories array", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
+
+    await runCommand([
+      "list",
+      "--category",
+      "email",
+      "--category",
+      "scheduling",
+    ]);
+
+    const body = ipcCalls[0].params?.body as Record<string, unknown>;
+    expect(body.categories).toEqual(["email", "scheduling"]);
+  });
+
+  test("--conversation-id, --from-assistant, --noteworthy forwarded", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
+
+    await runCommand([
+      "list",
+      "--conversation-id",
+      "conv-abc",
+      "--from-assistant",
+      "--noteworthy",
+    ]);
+
+    const body = ipcCalls[0].params?.body as Record<string, unknown>;
+    expect(body.conversationId).toBe("conv-abc");
+    expect(body.fromAssistant).toBe(true);
+    expect(body.noteworthy).toBe(true);
+  });
+
+  test("--limit and --offset are forwarded as integers", async () => {
+    ipcResponse = { ok: true, result: emptyPayload };
+
+    await runCommand(["list", "--limit", "5", "--offset", "10"]);
+
+    const body = ipcCalls[0].params?.body as Record<string, unknown>;
+    expect(body.limit).toBe(5);
+    expect(body.offset).toBe(10);
+  });
+
+  test("--limit rejects non-positive integers", async () => {
+    const { exitCode, parsed } = await runCommand(["list", "--limit", "0"]);
+    expect(exitCode).toBe(1);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("limit");
+    expect(ipcCalls).toHaveLength(0);
+  });
+
+  test("--limit rejects values above 200", async () => {
+    const { exitCode, parsed } = await runCommand(["list", "--limit", "500"]);
+    expect(exitCode).toBe(1);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("200");
+    expect(ipcCalls).toHaveLength(0);
+  });
+
+  test("--offset rejects negative values", async () => {
+    const { exitCode, parsed } = await runCommand(["list", "--offset", "-1"]);
+    expect(exitCode).toBe(1);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("offset");
+    expect(ipcCalls).toHaveLength(0);
+  });
+
+  test("empty --conversation-id is rejected", async () => {
+    const { exitCode, parsed } = await runCommand([
+      "list",
+      "--conversation-id",
+      "   ",
+    ]);
+    expect(exitCode).toBe(1);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.error).toContain("Conversation ID");
+    expect(ipcCalls).toHaveLength(0);
   });
 
   test("list surfaces IPC error response", async () => {
@@ -524,7 +668,7 @@ describe("notifications list", () => {
   test("list maps daemon 4xx to exit 2", async () => {
     ipcResponse = {
       ok: false,
-      error: "Invalid limit",
+      error: "Invalid filter",
       statusCode: 400,
     };
 
@@ -532,7 +676,7 @@ describe("notifications list", () => {
 
     expect(exitCode).toBe(2);
     expect(parsed.ok).toBe(false);
-    expect(parsed.error).toBe("Invalid limit");
+    expect(parsed.error).toBe("Invalid filter");
   });
 
   test("list maps daemon 5xx to exit 3", async () => {