@vellumai/assistant 0.6.3 → 0.6.4

package/src/daemon/lifecycle.ts

@@ -1,5 +1,7 @@
 import { config as dotenvConfig } from "dotenv";
 
+import type { BackupWorkerHandle } from "../backup/backup-worker.js";
+import { startBackupWorker } from "../backup/backup-worker.js";
 import { setPointerMessageProcessor } from "../calls/call-pointer-messages.js";
 import { reconcileCallsOnStartup } from "../calls/call-recovery.js";
 import { setRelayBroadcast } from "../calls/relay-server.js";
@@ -34,6 +36,11 @@ import {
 } from "../credential-execution/startup-timeout.js";
 import { FilingService } from "../filing/filing-service.js";
 import { HeartbeatService } from "../heartbeat/heartbeat-service.js";
+import {
+  type FeedSchedulerHandle,
+  startFeedScheduler,
+} from "../home/feed-scheduler.js";
+import { backfillRelationshipStateIfMissing } from "../home/relationship-state-writer.js";
 import { getHookManager } from "../hooks/manager.js";
 import { installTemplates } from "../hooks/templates.js";
 import { closeSentry, initSentry, setSentryDeviceId } from "../instrument.js";
@@ -89,6 +96,7 @@ import {
   setCesReconnect,
 } from "../security/secure-keys.js";
 import { UsageTelemetryReporter } from "../telemetry/usage-telemetry-reporter.js";
+import { registerBuiltinTtsProviders } from "../tts/providers/register-builtins.js";
 import { getDeviceId } from "../util/device-id.js";
 import { getLogger, initLogger } from "../util/logger.js";
 import {
@@ -292,8 +300,8 @@ export async function runDaemon(): Promise<void> {
     // Pre-populate the feature flag cache from the gateway so all
     // subsequent sync isAssistantFeatureFlagEnabled() calls have data.
     // Fired non-blocking so a slow or unreachable gateway doesn't delay
-    // daemon startup (the fetch has a 10s timeout that would otherwise
-    // stall the critical path).
+    // daemon startup (the IPC call has a 3s connect + 5s call timeout
+    // that would otherwise stall the critical path).
     void initFeatureFlagOverrides().catch((err) =>
       log.warn({ err }, "Background feature flag init failed"),
     );
@@ -379,6 +387,29 @@ export async function runDaemon(): Promise<void> {
         );
       }
 
+      // One-time backfill of `relationship-state.json` for existing or
+      // upgraded users so they don't land on an empty Home page after the
+      // Phase 3 ship. Runs after DB init + workspace migrations so the
+      // writer can actually resolve the guardian persona file and list
+      // connected OAuth providers — firing this from `ensurePromptFiles()`
+      // would be too early (DB isn't ready yet) and produce a degraded
+      // snapshot with zero facts and zero unlocked capabilities.
+      //
+      // Deferred via `setImmediate` so any sync filesystem/DB work the
+      // writer does (`readdirSync`, `readFileSync`, contact + provider
+      // lookups) happens on a later tick, off the startup critical path.
+      // Failures are logged — not silenced — to match the pattern used by
+      // other `void … .catch()` fire-and-forgets in this file and the
+      // assistant/CLAUDE.md rule that all errors must be observable.
+      setImmediate(() => {
+        void backfillRelationshipStateIfMissing().catch((err) =>
+          log.warn(
+            { err },
+            "Relationship state backfill failed — continuing startup",
+          ),
+        );
+      });
+
       // Backfill injection templates on Slack bot token credentials so the
       // credential proxy can inject Authorization headers. Safe on every startup.
       try {
@@ -463,10 +494,10 @@ export async function runDaemon(): Promise<void> {
         );
       }
 
-      // Write a dev-only fallback capability token to `~/.vellum/daemon-token`
-      // so developers can manually pair the chrome extension without the
-      // native messaging helper. Production pairing goes through
-      // `POST /v1/browser-extension-pair` via the native helper.
+      // Write a dev-only fallback capability token to the per-instance
+      // protected directory so developers can manually pair the chrome
+      // extension without the native messaging helper. Production pairing
+      // goes through `POST /v1/browser-extension-pair` via the native helper.
       try {
         writeDaemonTokenFallback(localGuardianPrincipalId);
       } catch (err) {
@@ -476,12 +507,6 @@ export async function runDaemon(): Promise<void> {
         );
       }
 
-      try {
-        syncUpdateBulletinOnStartup();
-      } catch (err) {
-        log.warn({ err }, "Bulletin sync failed — continuing startup");
-      }
-
       // Recover orphaned work items that were left in 'running' state when the
       // daemon previously crashed or was killed mid-task.
       const orphanedRunning = listWorkItems({ status: "running" });
@@ -518,6 +543,18 @@ export async function runDaemon(): Promise<void> {
     log.info("Daemon startup: loading config");
     const config = loadConfig();
 
+    // Run bulletin sync AFTER the config merge + load so that getConfig()
+    // inside syncUpdateBulletinOnStartup() observes the fully merged config.
+    // Running it earlier would populate the config cache with pre-merge
+    // values, poisoning every downstream getConfig() consumer.
+    if (dbReady) {
+      try {
+        syncUpdateBulletinOnStartup();
+      } catch (err) {
+        log.warn({ err }, "Bulletin sync failed — continuing startup");
+      }
+    }
+
     // Seed module-level ingress state from the workspace config so that
     // getIngressPublicBaseUrl() returns the correct value immediately after
     // startup (before any handleIngressConfig("set") call). Without this,
@@ -591,18 +628,34 @@ export async function runDaemon(): Promise<void> {
       // falling back to the encrypted file store.
       if (cesResult.processManager) {
         const pm = cesResult.processManager;
+
+        // Snapshot the managed-proxy context and assistant ID at CES startup
+        // so the reconnect closure below never calls back into
+        // `resolveManagedProxyContext()`. That function reads the assistant
+        // API key via `getSecureKeyAsync()`, which — once `setCesClient()`
+        // has resolved the backend to CES RPC — routes the read through CES
+        // itself. During a reconnect the old transport is dead and a new
+        // one is being set up by this very closure, so the nested credential
+        // read recursively awaits its own in-flight reconnection and
+        // deadlocks until `CREDENTIAL_OP_TIMEOUT_MS` (45s) fires. That
+        // 45-second stall delays every CES restart and causes dependent
+        // credential reads (e.g. Meet's STT provider resolution) to return
+        // `undefined` during the window. API key rotation uses the
+        // `updateAssistantApiKey` RPC on the live client, not a reconnect,
+        // so caching at startup is safe.
+        const startupProxyCtx = await resolveManagedProxyContext();
+        const startupAssistantId = getPlatformAssistantId();
+
         setCesReconnect(async () => {
           try {
             await pm.stop();
             const transport = await pm.start();
             const newClient = createCesClient(transport);
-            const proxyCtx = await resolveManagedProxyContext();
-            const assistantId = getPlatformAssistantId();
             const { accepted, reason } = await newClient.handshake({
-              ...(proxyCtx.assistantApiKey
-                ? { assistantApiKey: proxyCtx.assistantApiKey }
+              ...(startupProxyCtx.assistantApiKey
+                ? { assistantApiKey: startupProxyCtx.assistantApiKey }
                 : {}),
-              ...(assistantId ? { assistantId } : {}),
+              ...(startupAssistantId ? { assistantId: startupAssistantId } : {}),
             });
             if (accepted) {
               log.info("CES reconnection handshake accepted");
@@ -637,12 +690,13 @@ export async function runDaemon(): Promise<void> {
     await server.start();
     log.info("Daemon startup: DaemonServer started");
 
-    // Mutable refs for Qdrant and memory worker so background init can assign
-    // them and the shutdown handler always sees the latest value.
+    // Mutable refs for Qdrant, memory worker, and backup worker so background
+    // init can assign them and the shutdown handler always sees the latest value.
     const bgRefs: {
       qdrantManager: QdrantManager | null;
       memoryWorker: { stop(): void } | null;
-    } = { qdrantManager: null, memoryWorker: null };
+      backupWorker: BackupWorkerHandle | null;
+    } = { qdrantManager: null, memoryWorker: null, backupWorker: null };
 
     // Initialize Qdrant vector store and memory worker in the background so the
     // RuntimeHttpServer can start accepting requests without waiting for Qdrant.
@@ -725,6 +779,16 @@ export async function runDaemon(): Promise<void> {
       log.info("Daemon startup: starting memory worker");
       bgRefs.memoryWorker = startMemoryJobsWorker();
 
+      log.info("Daemon startup: starting backup worker");
+      try {
+        bgRefs.backupWorker = startBackupWorker();
+      } catch (err) {
+        log.warn(
+          { err },
+          "Backup worker failed to start — continuing without backups",
+        );
+      }
+
       // Seed capability graph nodes (new memory graph system)
       try {
         const {
@@ -760,11 +824,6 @@ export async function runDaemon(): Promise<void> {
       }
     }
 
-    // Fire-and-forget: Qdrant init runs concurrently with the rest of startup
-    void initializeQdrantAndMemory().catch((err) =>
-      log.warn({ err }, "Background Qdrant init failed"),
-    );
-
     registerWatcherProviders();
     registerMessagingProviders();
 
@@ -889,6 +948,19 @@ export async function runDaemon(): Promise<void> {
       },
     );
 
+    // Home activity feed scheduler — drives the assistant reflection
+    // loop + the platform Gmail digest. Fire-and-forget; a startup
+    // failure must never block the rest of daemon boot (CLAUDE.md).
+    let feedScheduler: FeedSchedulerHandle | null = null;
+    try {
+      feedScheduler = startFeedScheduler();
+    } catch (err) {
+      log.warn(
+        { err },
+        "Failed to start home feed scheduler — continuing startup",
+      );
+    }
+
     // Start the runtime HTTP server. Required for iOS pairing (gateway proxies
     // to it) and optional REST API access. Defaults to port 7821.
     let runtimeHttp: RuntimeHttpServer | null = null;
@@ -1027,8 +1099,19 @@ export async function runDaemon(): Promise<void> {
       onProviderCredentialsChanged: () =>
         server.refreshConversationsForProviderChange(),
       getHeartbeatService: () => server.getHeartbeatService(),
+      getFilingService: () => server.getFilingService(),
     });
 
+    // Fire-and-forget: Qdrant init and memory worker startup run concurrently
+    // with the rest of daemon boot. Must run AFTER `new RuntimeHttpServer(...)`
+    // so the analyze-deps singleton (populated inside `buildRouteTable()`) is
+    // available before the memory worker can claim leftover
+    // `conversation_analyze` jobs from a prior run. See the daemon-startup
+    // ordering test in `assistant/src/daemon/__tests__/`.
+    void initializeQdrantAndMemory().catch((err) =>
+      log.warn({ err }, "Background Qdrant init failed"),
+    );
+
     // Inject voice bridge deps BEFORE attempting to start the HTTP server.
     // The bridge must be available even when the HTTP server fails to bind.
     setVoiceBridgeDeps({
@@ -1208,6 +1291,17 @@ export async function runDaemon(): Promise<void> {
       runtimeHttp = null;
     }
 
+    // Register built-in TTS providers so the provider abstraction can resolve
+    // them by ID. Must happen before call controllers or routes are created.
+    try {
+      registerBuiltinTtsProviders();
+    } catch (err) {
+      log.warn(
+        { err },
+        "TTS provider registration failed — continuing with degraded TTS",
+      );
+    }
+
     // Initialize providers and tools after the HTTP server is listening so
     // health-check and pairing requests can be served immediately.  Wrapped in
     // its own try/catch so a failure here doesn't tear down the running HTTP
@@ -1333,6 +1427,7 @@ export async function runDaemon(): Promise<void> {
         }),
     });
     filing.start();
+    server.setFilingService(filing);
     log.info(
       {
         enabled: filingConfig.enabled,
@@ -1356,7 +1451,9 @@ export async function runDaemon(): Promise<void> {
       hookManager,
       runtimeHttp,
       scheduler,
+      feedScheduler,
       getMemoryWorker: () => bgRefs.memoryWorker,
+      getBackupWorker: () => bgRefs.backupWorker,
       getQdrantManager: () => bgRefs.qdrantManager,
       mcpManager,
       telemetryReporter,

package/src/daemon/message-protocol.ts

@@ -22,12 +22,14 @@ export * from "./message-types/conversations.js";
 export * from "./message-types/diagnostics.js";
 export * from "./message-types/documents.js";
 export * from "./message-types/guardian-actions.js";
+export * from "./message-types/home.js";
 export * from "./message-types/host-bash.js";
 export * from "./message-types/host-browser.js";
 export * from "./message-types/host-cu.js";
 export * from "./message-types/host-file.js";
 export * from "./message-types/inbox.js";
 export * from "./message-types/integrations.js";
+export * from "./message-types/meet.js";
 export * from "./message-types/memory.js";
 export * from "./message-types/messages.js";
 export * from "./message-types/notifications.js";
@@ -77,6 +79,7 @@ import type {
   _GuardianActionsClientMessages,
   _GuardianActionsServerMessages,
 } from "./message-types/guardian-actions.js";
+import type { _HomeServerMessages } from "./message-types/home.js";
 import type { _HostBashServerMessages } from "./message-types/host-bash.js";
 import type {
   _HostBrowserClientMessages,
@@ -92,6 +95,7 @@ import type {
   _IntegrationsClientMessages,
   _IntegrationsServerMessages,
 } from "./message-types/integrations.js";
+import type { _MeetServerMessages } from "./message-types/meet.js";
 import type { _MemoryServerMessages } from "./message-types/memory.js";
 import type {
   _MessagesClientMessages,
@@ -191,10 +195,12 @@ export type ServerMessage =
   | _SubagentsServerMessages
   | _DocumentsServerMessages
   | _GuardianActionsServerMessages
+  | _HomeServerMessages
   | _HostBashServerMessages
   | _HostBrowserServerMessages
   | _HostCuServerMessages
   | _HostFileServerMessages
+  | _MeetServerMessages
   | _MemoryServerMessages
   | _WorkspaceServerMessages
   | _SchedulesServerMessages

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

@@ -461,6 +461,20 @@ export interface ConversationErrorMessage {
   errorCategory?: string;
 }
 
+/** Reason the conversation list was invalidated. */
+export type ConversationListInvalidatedReason =
+  | "created"
+  | "renamed"
+  | "deleted"
+  | "reordered"
+  | "seen_changed";
+
+/** Server push — tells clients their sidebar conversation list is stale. */
+export interface ConversationListInvalidated {
+  type: "conversation_list_invalidated";
+  reason: ConversationListInvalidatedReason;
+}
+
 /** Server push — broadcast when a schedule creates a conversation. */
 export interface ScheduleConversationCreated {
   type: "schedule_conversation_created";
@@ -469,6 +483,23 @@ export interface ScheduleConversationCreated {
   title: string;
 }
 
+/**
+ * Server push — instructs the client to open and focus a conversation. If
+ * the conversation isn't already present in the client's sidebar list (e.g.
+ * it was just created via `POST /v1/conversations`), the client should stub
+ * a sidebar entry using the provided `title` before navigating.
+ */
+export interface OpenConversation {
+  type: "open_conversation";
+  conversationId: string;
+  /** Optional conversation title; supplied when the client may not yet have the conversation in its list. */
+  title?: string;
+  /** Optional message ID to scroll to after focus. */
+  anchorMessageId?: string;
+  /** When `false`, the client should register the conversation in its sidebar (so it's visible and navigable) but must NOT switch focus to it. Omitting the field defaults to `true` for backward compatibility with existing single-target 'jump to conversation' callers. */
+  focus?: boolean;
+}
+
 // --- Domain-level union aliases (consumed by the barrel file) ---
 
 export type _ConversationsClientMessages =
@@ -507,4 +538,6 @@ export type _ConversationsServerMessages =
   | ConversationsClearResponse
   | ConversationSearchResponse
   | MessageContentResponse
-  | ScheduleConversationCreated;
+  | ConversationListInvalidated
+  | ScheduleConversationCreated
+  | OpenConversation;

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

@@ -0,0 +1,40 @@
+/**
+ * Home — server → client push messages for the macOS Home page.
+ *
+ * These messages are fire-and-forget notifications; the client reacts
+ * by refetching the authoritative state from the HTTP route
+ * (`GET /v1/home/state`). Payloads stay deliberately tiny — they carry
+ * just enough metadata to invalidate a cache and trigger a refetch.
+ */
+
+/**
+ * Broadcast after the daemon successfully writes a fresh
+ * `relationship-state.json` snapshot to disk. Subscribers should
+ * refetch `GET /v1/home/state` to read the new state.
+ *
+ * Only emitted on the success branch of the writer — if the
+ * underlying `writeFileSync` throws, this event is NOT published.
+ */
+export interface RelationshipStateUpdated {
+  type: "relationship_state_updated";
+  /** ISO-8601 timestamp of the newly-written state's `updatedAt` field. */
+  updatedAt: string;
+}
+
+/**
+ * Broadcast after the daemon successfully writes a fresh home activity
+ * feed snapshot. Subscribers (e.g. `HomeFeedStore` on the client) should
+ * refetch the authoritative feed from its HTTP route.
+ *
+ * Only emitted on the success branch of the feed writer — if the
+ * underlying write fails, this event is NOT published.
+ */
+export interface HomeFeedUpdated {
+  type: "home_feed_updated";
+  /** ISO-8601 timestamp of when the feed was written. */
+  updatedAt: string;
+  /** Count of items with `status === "new"` after this write. */
+  newItemCount: number;
+}
+
+export type _HomeServerMessages = RelationshipStateUpdated | HomeFeedUpdated;

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

@@ -0,0 +1,143 @@
+/**
+ * Meet — server → client push messages for live meeting state.
+ *
+ * Emitted by the assistant daemon as the Meet-bot progresses through its
+ * lifecycle (joining → joined → left) and as in-meeting state changes
+ * (participants, active speaker, transcript chunks).
+ *
+ * Keep payloads small and client-actionable: these events power the
+ * macOS "In meeting" status panel and the conversation bridge's live
+ * transcript feed. A client that missed an event can always refetch
+ * authoritative state from the daemon's HTTP routes.
+ */
+
+/** A single participant in a meeting. Shape mirrors the wire-level type. */
+export interface MeetParticipant {
+  /** Stable participant identifier (provider-specific). */
+  id: string;
+  /** Display name of the participant. */
+  name: string;
+  /** Whether the participant is the meeting host. */
+  isHost?: boolean;
+  /** Whether the participant is the bot itself. */
+  isSelf?: boolean;
+}
+
+/** The bot has started attempting to join a meeting. */
+export interface MeetJoining {
+  type: "meet.joining";
+  meetingId: string;
+  /** The Meet URL the bot was asked to join. */
+  url: string;
+}
+
+/** The bot has successfully joined and is live in the meeting. */
+export interface MeetJoined {
+  type: "meet.joined";
+  meetingId: string;
+}
+
+/** Participants joined and/or left the meeting since the last snapshot. */
+export interface MeetParticipantChanged {
+  type: "meet.participant_changed";
+  meetingId: string;
+  /** Participants who joined since the last snapshot. */
+  joined: MeetParticipant[];
+  /** Participants who left since the last snapshot. */
+  left: MeetParticipant[];
+}
+
+/** The active speaker in the meeting changed. */
+export interface MeetSpeakerChanged {
+  type: "meet.speaker_changed";
+  meetingId: string;
+  /** Stable speaker identifier for the new active speaker. */
+  speakerId: string;
+  /** Display name of the new active speaker. */
+  speakerName: string;
+}
+
+/**
+ * A finalized chunk of transcribed speech. Interim chunks are filtered
+ * out before publication so clients only render stable text.
+ */
+export interface MeetTranscriptChunk {
+  type: "meet.transcript_chunk";
+  meetingId: string;
+  /** The transcribed text. */
+  text: string;
+  /** Human-readable speaker label, if the ASR provided one. */
+  speakerLabel?: string;
+  /** Stable speaker identifier across the meeting, if available. */
+  speakerId?: string;
+  /** ASR confidence in [0, 1], if available. */
+  confidence?: number;
+}
+
+/** The bot has left the meeting. */
+export interface MeetLeft {
+  type: "meet.left";
+  meetingId: string;
+  /** Free-form reason passed to `leave()` (e.g. "user-requested", "timeout"). */
+  reason: string;
+}
+
+/**
+ * The assistant successfully posted a chat message into the meeting via
+ * the bot's `/send_chat` endpoint. Emitted once per successful send so
+ * SSE-subscribed clients can render the outbound chat without waiting for
+ * the bot to echo it back through the transcript/chat stream.
+ */
+export interface MeetChatSent {
+  type: "meet.chat_sent";
+  meetingId: string;
+  /** The text that was posted into the meeting's chat. */
+  text: string;
+}
+
+/** The bot hit a non-recoverable error (container crash, join failure, etc.). */
+export interface MeetError {
+  type: "meet.error";
+  meetingId: string;
+  /** Human-readable error detail. */
+  detail: string;
+}
+
+/**
+ * The assistant has begun speaking into the meeting via the TTS bridge. Fired
+ * once per {@link MeetSessionManager.speak} invocation immediately before the
+ * synthesis stream starts flowing to the bot's `/play_audio` endpoint. Useful
+ * for clients that want to render a "speaking …" indicator.
+ */
+export interface MeetSpeakingStarted {
+  type: "meet.speaking_started";
+  meetingId: string;
+  /** Opaque stream identifier — matches `meet.speaking_ended.streamId`. */
+  streamId: string;
+}
+
+/**
+ * The assistant has finished (or cancelled) a TTS playback stream. Fired
+ * after the bot-side playback request settles — whether normally, via an
+ * explicit cancel, or due to an upstream error.
+ */
+export interface MeetSpeakingEnded {
+  type: "meet.speaking_ended";
+  meetingId: string;
+  /** Opaque stream identifier — matches `meet.speaking_started.streamId`. */
+  streamId: string;
+  /** Why the stream ended: natural completion, caller-initiated cancel, or an upstream error. */
+  reason: "completed" | "cancelled" | "error";
+}
+
+export type _MeetServerMessages =
+  | MeetJoining
+  | MeetJoined
+  | MeetParticipantChanged
+  | MeetSpeakerChanged
+  | MeetTranscriptChunk
+  | MeetLeft
+  | MeetChatSent
+  | MeetError
+  | MeetSpeakingStarted
+  | MeetSpeakingEnded;

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

@@ -60,6 +60,13 @@ export interface UserMessageEcho {
   type: "user_message_echo";
   text: string;
   conversationId?: string;
+  /** Database ID of the persisted user message, used by the originating
+   *  client to dedupe its optimistic row. Absent for synthetic echoes
+   *  (e.g. surface-action prompts) where no distinct user row is persisted. */
+  messageId?: string;
+  /** Server-generated request ID for the send. Allows correlation with
+   *  `message_queued` / `message_dequeued` events for the same turn. */
+  requestId?: string;
 }
 
 export interface AssistantTextDelta {
@@ -194,6 +201,13 @@ export interface MessageComplete {
   attachmentWarnings?: string[];
   /** Database ID of the persisted assistant message, if any. */
   messageId?: string;
+  /**
+   * Distinguishes a real main-turn completion from auxiliary events such as
+   * call transcripts, call summaries, and watch notifier outputs. Clients
+   * gate turn-completion side effects (e.g. the task_complete sound) on
+   * `source !== "aux"`. Absent is treated as main for backwards compatibility.
+   */
+  source?: "main" | "aux";
 }
 
 export interface ErrorMessage {

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

@@ -54,6 +54,15 @@ export interface HeartbeatChecklistWrite {
   content: string;
 }
 
+export interface FilingConfig {
+  type: "filing_config";
+  action: "get";
+}
+
+export interface FilingRunNow {
+  type: "filing_run_now";
+}
+
 // === Server → Client ===
 
 export interface SchedulesListResponse {
@@ -133,6 +142,25 @@ export interface HeartbeatChecklistWriteResponse {
   error?: string;
 }
 
+export interface FilingConfigResponse {
+  type: "filing_config_response";
+  enabled: boolean;
+  intervalMs: number;
+  activeHoursStart: number | null;
+  activeHoursEnd: number | null;
+  nextRunAt: number | null;
+  lastRunAt: number | null;
+  success: boolean;
+  error?: string;
+}
+
+export interface FilingRunNowResponse {
+  type: "filing_run_now_response";
+  success: boolean;
+  ran: boolean;
+  error?: string;
+}
+
 // --- Domain-level union aliases (consumed by the barrel file) ---
 
 export type _SchedulesClientMessages =
@@ -145,7 +173,9 @@ export type _SchedulesClientMessages =
   | HeartbeatRunsList
   | HeartbeatRunNow
   | HeartbeatChecklistRead
-  | HeartbeatChecklistWrite;
+  | HeartbeatChecklistWrite
+  | FilingConfig
+  | FilingRunNow;
 
 export type _SchedulesServerMessages =
   | SchedulesListResponse
@@ -155,4 +185,6 @@ export type _SchedulesServerMessages =
   | HeartbeatRunsListResponse
   | HeartbeatRunNowResponse
   | HeartbeatChecklistResponse
-  | HeartbeatChecklistWriteResponse;
+  | HeartbeatChecklistWriteResponse
+  | FilingConfigResponse
+  | FilingRunNowResponse;