@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240206.7c2bca6

package/src/daemon/message-types/surfaces.ts

@@ -1,5 +1,17 @@
 // Surface types, UI surface lifecycle messages.
 
+import {
+  type CardSurfaceData,
+  CardSurfaceDataSchema,
+} from "../../api/surfaces.js";
+
+// Surface `data` shapes are wire payloads owned by `@vellumai/assistant-api`.
+// Card is migrated (canonical Zod schema); the remaining types below are still
+// hand-written interfaces pending migration. Re-exported so the daemon's
+// surface protocol barrel (`message-protocol.ts`) keeps surfacing them to
+// daemon consumers under their canonical names.
+export { type CardSurfaceData, CardSurfaceDataSchema };
+
 // === Surface type definitions ===
 
 export type SurfaceType =
@@ -35,17 +47,6 @@ export interface SurfaceAction {
   data?: Record<string, unknown>;
 }
 
-export interface CardSurfaceData {
-  title: string;
-  subtitle?: string;
-  body: string;
-  metadata?: Array<{ label: string; value: string }>;
-  /** Optional template name for specialized rendering (e.g. "weather_forecast"). */
-  template?: string;
-  /** Arbitrary data consumed by the template renderer. Shape depends on template. */
-  templateData?: Record<string, unknown>;
-}
-
 export interface ChoiceOption {
   id: string;
   title: string;

package/src/daemon/server.ts

@@ -47,7 +47,6 @@ import { refreshSurfacesForApp } from "./conversation-surfaces.js";
 import { parseIdentityFields } from "./handlers/identity.js";
 import type { ConversationCreateOptions } from "./handlers/shared.js";
 import { setGlobalSkillIpcSender } from "./meet-host-supervisor.js";
-import { PluginSourceWatcher } from "./plugin-source-watcher.js";
 import { refreshSkillCapabilityMemories } from "./skill-memory-refresh.js";
 import { WorkspaceToolsWatcher } from "./workspace-tools-watcher.js";
 
@@ -84,7 +83,6 @@ export class DaemonServer {
   // Composed subsystems
   private configWatcher = getConfigWatcher();
   private appSourceWatcher = new AppSourceWatcher();
-  private pluginSourceWatcher = PluginSourceWatcher.getInstance();
   private cliIpc = new AssistantIpcServer();
   private skillIpc = new SkillIpcServer();
 
@@ -310,7 +308,6 @@ export class DaemonServer {
 
     this.appSourceWatcher.start((appId) => this.handleAppSourceChange(appId));
 
-    this.pluginSourceWatcher.start();
     WorkspaceToolsWatcher.getInstance().start();
 
     // Broadcast contacts_changed to all clients when any contact mutation occurs.
@@ -327,7 +324,6 @@ export class DaemonServer {
     this.evictor.stop();
     this.configWatcher.stop();
     this.appSourceWatcher.stop();
-    this.pluginSourceWatcher.stop();
     WorkspaceToolsWatcher.getInstance().stop();
     this.cliIpc.stop();
     this.skillIpc.stop();

package/src/daemon/shutdown-handlers.ts

@@ -5,6 +5,7 @@ import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
 import type { McpServerManager } from "../mcp/manager.js";
 import { getSqlite, resetDb } from "../memory/db-connection.js";
 import type { QdrantManager } from "../memory/qdrant-manager.js";
+import { stopMemoryWorkerProcess } from "../memory/worker-control.js";
 import type { RuntimeHttpServer } from "../runtime/http-server.js";
 import { browserManager } from "../tools/browser/browser-manager.js";
 import { cleanupShellOutputTempFiles } from "../tools/shared/shell-output.js";
@@ -117,8 +118,27 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     await browserManager.closeAllPages();
     cleanupShellOutputTempFiles();
     deps.scheduler.stop();
+
+    // Stop the in-process memory worker if one was started on the daemon's
+    // event loop (memory.worker.enabled = false).
     deps.getMemoryWorker()?.stop();
 
+    // Stop the out-of-process memory worker if it's actually running. This is
+    // keyed off live state rather than config: the worker may have been
+    // spawned at startup (memory.worker.enabled = true) or out of band via
+    // `assistant memory worker start`, so we stop whatever is actually there.
+    try {
+      const workerStatus = stopMemoryWorkerProcess();
+      if (workerStatus.status === "running") {
+        log.info(
+          { pid: workerStatus.pid },
+          "Sent SIGTERM to memory worker process",
+        );
+      }
+    } catch (err) {
+      log.warn({ err }, "Failed to stop memory worker process (non-fatal)");
+    }
+
     if (deps.mcpManager) {
       try {
         await deps.mcpManager.stop();

package/src/daemon/tool-setup-types.ts

@@ -125,10 +125,12 @@ export interface ToolSetupContext extends SurfaceConversationContext {
    */
   currentTurnOverrideProfile?: string;
   /**
-   * Set by the `switch_inference_profile` tool when the model self-selects a
-   * different profile mid-turn. Read by `readCurrentOverrideProfile` in the
-   * agent loop so the next LLM call uses the switched profile. Reset at
-   * turn start.
+   * Whether the current turn has no human present to answer clarification
+   * prompts. Resolved once per turn by the agent loop — honoring an explicit
+   * per-run `isInteractive` option (e.g. scheduled/background turns) over the
+   * live client state — so tool execution sees turn-level interactivity rather
+   * than re-deriving it from `hasNoClient`/`headlessLock`, which would read a
+   * scheduled turn running on a client-attached conversation as interactive.
    */
-  toolRoutedProfile?: string;
+  currentTurnIsNonInteractive?: boolean;
 }

package/src/daemon/trust-context.ts

@@ -38,6 +38,12 @@ export interface TrustContext {
   requesterExternalUserId?: string;
   /** Chat/conversation ID the requester is interacting through. */
   requesterChatId?: string;
+  /** Contact ID of the requester's member record, for local info joins. */
+  requesterContactId?: string;
+  /** API-facing member status of the requester's channel (ACL). */
+  memberStatus?: string;
+  /** Channel policy of the requester's channel (ACL). */
+  memberPolicy?: string;
 }
 
 /**

package/src/daemon/wake-conversation-ops.ts

@@ -22,6 +22,7 @@ import { syncMessageToDisk } from "../memory/conversation-disk-view.js";
 import { backfillMessageIdOnLogs } from "../memory/llm-request-log-store.js";
 import type { Message } from "../providers/types.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
+import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../util/logger.js";
 import type { Conversation } from "./conversation.js";
 import type { ServerMessage } from "./message-protocol.js";
@@ -147,6 +148,7 @@ function translateAgentEventToServerMessage(
     case "compaction_completed":
     case "history_stripped":
     case "agent_loop_exit":
+    case "system_prompt_changed":
       return null;
     case "llm_call_started":
       // The wake path persists its assistant tail via
@@ -255,6 +257,74 @@ export async function persistWakeTailMessage(
   }
 }
 
+/**
+ * Persist a wake's trigger as a single visible user message — the
+ * append-only counterpart to the legacy ephemeral hint injection. Keeping the
+ * trigger in durable history (instead of splicing a non-persisted message per
+ * wake) lets the provider prompt-cache treat repeated wakes like normal user
+ * turns rather than re-creating the whole prefix each time.
+ *
+ * Mirrors {@link persistWakeTailMessage}'s channel/interface/provenance
+ * metadata, but stamps `kind: "background-event"` (+ the originating `source`)
+ * for identification, skips indexing (the body may carry untrusted command
+ * output), and is NOT flagged hidden so the trigger shows in the transcript.
+ */
+export async function persistWakeTriggerMessage(
+  conversation: Conversation,
+  message: Message,
+  source: string,
+): Promise<void> {
+  const turnChannelCtx = conversation.getTurnChannelContext();
+  const turnInterfaceCtx = conversation.getTurnInterfaceContext();
+  const metadata: Record<string, unknown> = {
+    ...provenanceFromTrustContext(conversation.trustContext),
+    userMessageChannel: turnChannelCtx?.userMessageChannel ?? "vellum",
+    assistantMessageChannel:
+      turnChannelCtx?.assistantMessageChannel ?? "vellum",
+    userMessageInterface: turnInterfaceCtx?.userMessageInterface ?? "web",
+    assistantMessageInterface:
+      turnInterfaceCtx?.assistantMessageInterface ?? "web",
+    kind: "background-event",
+    backgroundEventSource: source,
+    automated: true,
+  };
+  const persisted = await addMessage(
+    conversation.conversationId,
+    message.role,
+    JSON.stringify(message.content),
+    { metadata, skipIndexing: true },
+  );
+  try {
+    const convRow = getConversation(conversation.conversationId);
+    if (convRow) {
+      syncMessageToDisk(
+        conversation.conversationId,
+        persisted.id,
+        convRow.createdAt,
+      );
+    }
+  } catch (err) {
+    log.warn(
+      { err, conversationId: conversation.conversationId },
+      "wake trigger persist: syncMessageToDisk failed (non-fatal)",
+    );
+  }
+  // Tell connected clients the message list changed so they refetch and the
+  // visible trigger renders live. The normal user-send path publishes the same
+  // invalidation after persisting a user message; without it a wake that
+  // produces no assistant stream (silent no-op), or a conversation open in
+  // another client, would not show the <background_event> row until a manual
+  // reload.
+  try {
+    publishConversationMessagesChanged(conversation.conversationId);
+  } catch (err) {
+    log.warn(
+      { err, conversationId: conversation.conversationId },
+      "wake trigger persist: publishConversationMessagesChanged failed (non-fatal)",
+    );
+  }
+}
+
 /**
  * Temporarily restrict the tools visible/executable during a wake by
  * reusing the conversation's subagent allowlist slot. Returns a restore

package/src/daemon/workspace-tools-watcher.ts

@@ -23,9 +23,9 @@
  * the world: "given what's on disk right now for `<stem>.*`, what
  * registry state should the assistant be in?"
  *
- * This is the same eventual-consistency pattern as
- * `plugin-source-watcher.ts` — the watcher exists to KICK the
- * reconciler, not to be the source of truth about what changed.
+ * This is the same eventual-consistency pattern the plugin mtime cache
+ * uses — the watcher exists to KICK the reconciler, not to be the
+ * source of truth about what changed.
  *
  * ## Lifecycle position
  *
@@ -57,6 +57,7 @@ import {
   loadSingleWorkspaceTool,
 } from "../tools/workspace-tools/loader.js";
 import { DebouncerMap } from "../util/debounce.js";
+import { attachFsWatcherErrorHandler } from "../util/fs-watcher-error.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceToolsDir } from "../util/platform.js";
 
@@ -154,6 +155,9 @@ export class WorkspaceToolsWatcher {
           });
         },
       );
+      // Async FSWatcher errors (e.g. ENOSPC, ENXIO) arrive as an 'error' event;
+      // without a listener they crash the daemon. Degrade to a dead watcher.
+      attachFsWatcherErrorHandler(this.watcher, log, toolsDir);
       log.info({ toolsDir }, "Workspace tools watcher started");
     } catch (err) {
       log.warn(

package/src/documents/document-comments-store.test.ts

@@ -18,7 +18,7 @@ import {
   resolveComment,
 } from "./document-comments-store.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/heartbeat/__tests__/heartbeat-run-store.test.ts

@@ -25,7 +25,7 @@ import {
   supersedePendingRun,
 } from "../heartbeat-run-store.js";
 
-initializeDb();
+await initializeDb();
 
 describe("heartbeat-run-store", () => {
   beforeEach(() => {

package/src/heartbeat/__tests__/heartbeat-service.test.ts

@@ -88,6 +88,9 @@ const stubConfig: {
     maxDailyRuns: number | null;
     disposition: string;
   };
+  timeouts: {
+    backgroundTurnTimeoutSec: number;
+  };
 } = {
   heartbeat: {
     enabled: true,
@@ -98,6 +101,9 @@ const stubConfig: {
     maxDailyRuns: null,
     disposition: "Default disposition text.",
   },
+  timeouts: {
+    backgroundTurnTimeoutSec: 1800,
+  },
 };
 mock.module("../../config/loader.js", () => ({
   getConfig: () => stubConfig,

package/src/heartbeat/heartbeat-service.ts

@@ -46,7 +46,6 @@ const DEFAULT_CHECKLIST = `- Check in with yourself. Read NOW.md. Is it still ac
 
 const EARLY_HEARTBEAT_THRESHOLD = 3;
 const REENGAGEMENT_COOLDOWN_MS = 18 * 60 * 60 * 1000; // 18 hours
-const HEARTBEAT_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
 
 // Stripped-comment form of the guardian persona scaffold. Computed
 // once at module load because stripping comment lines is deterministic
@@ -774,8 +773,8 @@ export class HeartbeatService {
     //
     // The runner fires `onConversationCreated` synchronously after
     // bootstrap so the macOS sidebar gets the new conversation
-    // immediately rather than waiting up to HEARTBEAT_TIMEOUT_MS for
-    // the LLM turn to finish. If the model judges the run worth
+    // immediately rather than waiting up to the full background-turn timeout
+    // for the LLM turn to finish. If the model judges the run worth
     // surfacing to the guardian, it calls the `notifications` skill
     // directly — no in-band marker.
     let conversationId: string | undefined;
@@ -789,7 +788,7 @@ export class HeartbeatService {
         trustClass: "guardian",
       },
       callSite: "heartbeatAgent",
-      timeoutMs: HEARTBEAT_TIMEOUT_MS,
+      timeoutMs: getConfig().timeouts.backgroundTurnTimeoutSec * 1000,
       origin: "heartbeat",
       deferNotifications: true,
       onConversationCreated: (newConversationId) => {

package/src/ipc/__tests__/attachment-ipc.test.ts

@@ -20,7 +20,7 @@ import { cliIpcCall } from "../cli-client.js";
 // DB setup (attachment store needs SQLite)
 // ---------------------------------------------------------------------------
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/ipc/__tests__/browser-ipc.test.ts

@@ -24,12 +24,14 @@ let mockOperationCalls: Array<{
   conversationId: string;
   trustClass?: string;
   transportInterface?: string;
+  sourceActorPrincipalId?: string;
 }> = [];
 
 /** When set, findConversation returns a fake conversation object. */
 let mockConversation: {
   trustContext?: { trustClass: string };
   transportInterface?: string;
+  getTurnActorPrincipalId?: () => string | undefined;
 } | null = null;
 
 let mockFindConversationCalls: string[] = [];
@@ -42,6 +44,7 @@ mock.module("../../browser/operations.js", () => ({
       conversationId: string;
       trustClass?: string;
       transportInterface?: string;
+      sourceActorPrincipalId?: string;
     },
   ) => {
     mockOperationCalls.push({
@@ -50,6 +53,7 @@ mock.module("../../browser/operations.js", () => ({
       conversationId: context.conversationId,
       trustClass: context.trustClass,
       transportInterface: context.transportInterface,
+      sourceActorPrincipalId: context.sourceActorPrincipalId,
     });
     return mockOperationResult;
   },
@@ -71,8 +75,16 @@ const browserExecuteHandler = ROUTES.find(
 )!.handler;
 
 /** Call the handler with the RouteHandlerArgs shape. */
-function callHandler(body: Record<string, unknown>) {
-  return browserExecuteHandler({ body, pathParams: {}, queryParams: {} });
+function callHandler(
+  body: Record<string, unknown>,
+  headers?: Record<string, string>,
+) {
+  return browserExecuteHandler({
+    body,
+    headers,
+    pathParams: {},
+    queryParams: {},
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -187,6 +199,7 @@ describe("browser_execute route", () => {
     mockConversation = {
       trustContext: { trustClass: "trusted" },
       transportInterface: "chrome-extension",
+      getTurnActorPrincipalId: () => undefined,
     };
 
     await callHandler({
@@ -204,6 +217,64 @@ describe("browser_execute route", () => {
     });
   });
 
+  test("threads actor principal header into browser tool context", async () => {
+    await callHandler(
+      {
+        operation: "status",
+        input: {},
+        sessionId: "actor-session",
+      },
+      { "x-vellum-actor-principal-id": "actor-123" },
+    );
+
+    expect(mockOperationCalls).toHaveLength(1);
+    expect(mockOperationCalls[0].sourceActorPrincipalId).toBe("actor-123");
+  });
+
+  test("falls back to live conversation actor when no actor header exists", async () => {
+    mockConversation = {
+      trustContext: { trustClass: "trusted" },
+      transportInterface: "macos",
+      getTurnActorPrincipalId: () => "conversation-actor",
+    };
+
+    await callHandler({
+      operation: "status",
+      input: {},
+      sessionId: "unused",
+      conversationId: "conv-live-actor",
+    });
+
+    expect(mockOperationCalls).toHaveLength(1);
+    expect(mockOperationCalls[0]).toMatchObject({
+      conversationId: "conv-live-actor",
+      sourceActorPrincipalId: "conversation-actor",
+    });
+  });
+
+  test("prefers live conversation actor over the request header", async () => {
+    mockConversation = {
+      trustContext: { trustClass: "trusted" },
+      transportInterface: "macos",
+      getTurnActorPrincipalId: () => "conversation-actor",
+    };
+
+    await callHandler(
+      {
+        operation: "status",
+        input: {},
+        sessionId: "unused",
+        conversationId: "conv-live-actor",
+      },
+      { "x-vellum-actor-principal-id": "header-actor" },
+    );
+
+    expect(mockOperationCalls).toHaveLength(1);
+    expect(mockOperationCalls[0].sourceActorPrincipalId).toBe(
+      "conversation-actor",
+    );
+  });
+
   test("does not call findConversation when no conversationId provided", async () => {
     await callHandler({
       operation: "snapshot",

package/src/ipc/__tests__/clients-list-ipc.test.ts

@@ -36,7 +36,7 @@ mock.module("../../config/env.js", () => ({
 }));
 
 mock.module("../../runtime/local-actor-identity.js", () => ({
-  findLocalGuardianPrincipalId: () => fakeLocalPrincipalId,
+  findLocalGuardianPrincipalIdFromStore: () => fakeLocalPrincipalId,
 }));
 
 // ── Real imports (after mocks) ────────────────────────────────────────────

package/src/ipc/__tests__/watcher-ipc.test.ts

@@ -19,7 +19,7 @@ import { cliIpcCall } from "../cli-client.js";
 // DB + provider setup
 // ---------------------------------------------------------------------------
 
-initializeDb();
+await initializeDb();
 
 const mockProvider: WatcherProvider = {
   id: "test-provider",
@@ -67,12 +67,14 @@ afterEach(async () => {
 async function createTestWatcher(
   overrides?: Record<string, unknown>,
 ): Promise<Watcher> {
-  const result = await cliIpcCall<Watcher>("watcher_create", { body: {
-    name: "Test Watcher",
-    provider: "test-provider",
-    action_prompt: "Handle events",
-    ...overrides,
-  } });
+  const result = await cliIpcCall<Watcher>("watcher_create", {
+    body: {
+      name: "Test Watcher",
+      provider: "test-provider",
+      action_prompt: "Handle events",
+      ...overrides,
+    },
+  });
   expect(result.ok).toBe(true);
   expect(result.result).toBeDefined();
   createdWatcherIds.push(result.result!.id);
@@ -96,7 +98,9 @@ describe("watcher IPC routes", () => {
     expect(watcher.status).toBe("idle");
 
     // List all
-    const listResult = await cliIpcCall<Watcher[]>("watcher_list", { body: {} });
+    const listResult = await cliIpcCall<Watcher[]>("watcher_list", {
+      body: {},
+    });
     expect(listResult.ok).toBe(true);
     expect(Array.isArray(listResult.result)).toBe(true);
     const found = listResult.result!.find((w) => w.id === watcher.id);
@@ -112,10 +116,12 @@ describe("watcher IPC routes", () => {
     expect(Array.isArray(detailResult.result!.events)).toBe(true);
 
     // Update
-    const updateResult = await cliIpcCall<Watcher>("watcher_update", { body: {
-      watcher_id: watcher.id,
-      name: "Updated Watcher",
-    } });
+    const updateResult = await cliIpcCall<Watcher>("watcher_update", {
+      body: {
+        watcher_id: watcher.id,
+        name: "Updated Watcher",
+      },
+    });
     expect(updateResult.ok).toBe(true);
     expect(updateResult.result!.name).toBe("Updated Watcher");
 
@@ -133,7 +139,9 @@ describe("watcher IPC routes", () => {
     if (idx >= 0) createdWatcherIds.splice(idx, 1);
 
     // Confirm gone
-    const afterDelete = await cliIpcCall<Watcher[]>("watcher_list", { body: {} });
+    const afterDelete = await cliIpcCall<Watcher[]>("watcher_list", {
+      body: {},
+    });
     expect(afterDelete.ok).toBe(true);
     const gone = afterDelete.result!.find((w) => w.id === watcher.id);
     expect(gone).toBeUndefined();
@@ -142,11 +150,13 @@ describe("watcher IPC routes", () => {
   // -- Create: unknown provider -----------------------------------------------
 
   test("watcher/create rejects unknown provider", async () => {
-    const result = await cliIpcCall("watcher_create", { body: {
-      name: "Bad Watcher",
-      provider: "nonexistent",
-      action_prompt: "Do stuff",
-    } });
+    const result = await cliIpcCall("watcher_create", {
+      body: {
+        name: "Bad Watcher",
+        provider: "nonexistent",
+        action_prompt: "Do stuff",
+      },
+    });
     expect(result.ok).toBe(false);
     expect(result.error).toContain('Unknown provider "nonexistent"');
     expect(result.error).toContain("test-provider");
@@ -155,12 +165,14 @@ describe("watcher IPC routes", () => {
   // -- Create: poll interval too low ------------------------------------------
 
   test("watcher/create rejects poll_interval_ms < 15000", async () => {
-    const result = await cliIpcCall("watcher_create", { body: {
-      name: "Fast Watcher",
-      provider: "test-provider",
-      action_prompt: "Handle events",
-      poll_interval_ms: 5000,
-    } });
+    const result = await cliIpcCall("watcher_create", {
+      body: {
+        name: "Fast Watcher",
+        provider: "test-provider",
+        action_prompt: "Handle events",
+        poll_interval_ms: 5000,
+      },
+    });
     expect(result.ok).toBe(false);
     expect(result.error).toBeDefined();
   });
@@ -179,9 +191,11 @@ describe("watcher IPC routes", () => {
 
   test("watcher/update rejects when no update fields provided", async () => {
     const watcher = await createTestWatcher();
-    const result = await cliIpcCall("watcher_update", { body: {
-      watcher_id: watcher.id,
-    } });
+    const result = await cliIpcCall("watcher_update", {
+      body: {
+        watcher_id: watcher.id,
+      },
+    });
     expect(result.ok).toBe(false);
     expect(result.error).toContain("No updates provided");
   });
@@ -189,9 +203,11 @@ describe("watcher IPC routes", () => {
   // -- Delete: non-existent watcher -------------------------------------------
 
   test("watcher/delete returns error for non-existent watcher", async () => {
-    const result = await cliIpcCall("watcher_delete", { body: {
-      watcher_id: "does-not-exist",
-    } });
+    const result = await cliIpcCall("watcher_delete", {
+      body: {
+        watcher_id: "does-not-exist",
+      },
+    });
     expect(result.ok).toBe(false);
     expect(result.error).toContain("Watcher not found");
   });
@@ -211,11 +227,13 @@ describe("watcher IPC routes", () => {
   // -- Underscore aliases -----------------------------------------------------
 
   test("watcher_create alias works identically to watcher/create", async () => {
-    const result = await cliIpcCall<Watcher>("watcher_create", { body: {
-      name: "Alias Watcher",
-      provider: "test-provider",
-      action_prompt: "Handle events",
-    } });
+    const result = await cliIpcCall<Watcher>("watcher_create", {
+      body: {
+        name: "Alias Watcher",
+        provider: "test-provider",
+        action_prompt: "Handle events",
+      },
+    });
     expect(result.ok).toBe(true);
     expect(result.result!.name).toBe("Alias Watcher");
     createdWatcherIds.push(result.result!.id);
@@ -232,10 +250,12 @@ describe("watcher IPC routes", () => {
 
   test("watcher_update alias works identically to watcher/update", async () => {
     const watcher = await createTestWatcher();
-    const result = await cliIpcCall<Watcher>("watcher_update", { body: {
-      watcher_id: watcher.id,
-      name: "Alias Updated",
-    } });
+    const result = await cliIpcCall<Watcher>("watcher_update", {
+      body: {
+        watcher_id: watcher.id,
+        name: "Alias Updated",
+      },
+    });
     expect(result.ok).toBe(true);
     expect(result.result!.name).toBe("Alias Updated");
   });