@vellumai/assistant 0.6.2 → 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";
@@ -75,6 +82,11 @@ import {
   mintPairingBearerToken,
   resolveSigningKey,
 } from "../runtime/auth/token-service.js";
+import {
+  initCapabilityTokenSecret,
+  loadOrCreateCapabilityTokenSecret,
+  writeDaemonTokenFallback,
+} from "../runtime/capability-tokens.js";
 import { ensureVellumGuardianBinding } from "../runtime/guardian-vellum-migration.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 import { startScheduler } from "../schedule/scheduler.js";
@@ -84,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 {
@@ -270,11 +283,25 @@ export async function runDaemon(): Promise<void> {
     const signingKey = resolveSigningKey();
     initAuthSigningKey(signingKey);
 
+    // Load (or generate + persist) the capability-token HMAC secret used
+    // to mint scoped tokens for the chrome extension pair endpoint.
+    // Wrapped in try/catch so a disk failure here never blocks startup —
+    // tokens can still be minted using a lazy on-demand load inside the
+    // capability-tokens module.
+    try {
+      initCapabilityTokenSecret(loadOrCreateCapabilityTokenSecret());
+    } catch (err) {
+      log.warn(
+        { err },
+        "Failed to pre-load capability token secret — continuing startup (lazy load will handle subsequent calls)",
+      );
+    }
+
     // 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"),
     );
@@ -360,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 {
@@ -432,8 +482,11 @@ export async function runDaemon(): Promise<void> {
 
       // Ensure a vellum guardian binding exists so the identity system works
       // without requiring a manual bootstrap step.
+      let localGuardianPrincipalId = "local";
       try {
-        ensureVellumGuardianBinding(DAEMON_INTERNAL_ASSISTANT_ID);
+        localGuardianPrincipalId = ensureVellumGuardianBinding(
+          DAEMON_INTERNAL_ASSISTANT_ID,
+        );
       } catch (err) {
         log.warn(
           { err },
@@ -441,10 +494,17 @@ export async function runDaemon(): Promise<void> {
         );
       }
 
+      // 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 {
-        syncUpdateBulletinOnStartup();
+        writeDaemonTokenFallback(localGuardianPrincipalId);
       } catch (err) {
-        log.warn({ err }, "Bulletin sync failed — continuing startup");
+        log.warn(
+          { err },
+          "Failed to write dev daemon-token fallback — continuing startup",
+        );
       }
 
       // Recover orphaned work items that were left in 'running' state when the
@@ -483,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,
@@ -556,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");
@@ -589,8 +677,6 @@ export async function runDaemon(): Promise<void> {
       }
     }
 
-    await initializeProvidersAndTools(config);
-
     // Start the DaemonServer (conversation manager) before Qdrant so HTTP
     // routes can begin accepting requests while Qdrant initializes.
     log.info("Daemon startup: starting DaemonServer");
@@ -604,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.
@@ -692,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 {
@@ -727,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();
 
@@ -745,12 +837,17 @@ export async function runDaemon(): Promise<void> {
           conversationId,
           message,
           undefined,
-          options?.trustClass
+          options
             ? {
-                trustContext: {
-                  sourceChannel: "vellum",
-                  trustClass: options.trustClass,
-                },
+                ...(options.trustClass
+                  ? {
+                      trustContext: {
+                        sourceChannel: "vellum",
+                        trustClass: options.trustClass,
+                      },
+                    }
+                  : {}),
+                ...(options.taskRunId ? { taskRunId: options.taskRunId } : {}),
               }
             : undefined,
         );
@@ -851,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;
@@ -989,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({
@@ -1170,6 +1291,32 @@ 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
+    // server (DaemonServer.start() already calls initializeProviders internally
+    // and tools are resolved lazily at conversation creation time).
+    try {
+      log.info("Daemon startup: initializing providers and tools");
+      await initializeProvidersAndTools(config);
+    } catch (err) {
+      log.warn(
+        { err },
+        "Provider/tool initialization failed — continuing with degraded functionality",
+      );
+    }
+
     writePid(process.pid);
     log.info({ pid: process.pid }, "Daemon started");
 
@@ -1198,10 +1345,11 @@ export async function runDaemon(): Promise<void> {
         if (!runtimeManager.isReady()) {
           log.info("Downloading embedding runtime in background...");
           await runtimeManager.ensureInstalled();
-          // Reset the localBackendBroken flag so auto mode retries local embeddings
-          const { clearEmbeddingBackendCache } =
+          // Reset the sticky local-backend failure flag so auto mode retries
+          // local embeddings without evicting a worker that may already be live.
+          const { resetLocalEmbeddingFailureState } =
             await import("../memory/embedding-backend.js");
-          clearEmbeddingBackendCache();
+          resetLocalEmbeddingFailureState();
           log.info("Embedding runtime download complete");
         }
       } catch (err) {
@@ -1279,6 +1427,7 @@ export async function runDaemon(): Promise<void> {
         }),
     });
     filing.start();
+    server.setFilingService(filing);
     log.info(
       {
         enabled: filingConfig.enabled,
@@ -1302,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,11 +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";
@@ -76,7 +79,12 @@ 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,
+  _HostBrowserServerMessages,
+} from "./message-types/host-browser.js";
 import type { _HostCuServerMessages } from "./message-types/host-cu.js";
 import type { _HostFileServerMessages } from "./message-types/host-file.js";
 import type {
@@ -87,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,
@@ -157,6 +166,7 @@ export type ClientMessage =
   | _ContactsClientMessages
   | _WorkItemsClientMessages
   | _BrowserClientMessages
+  | _HostBrowserClientMessages
   | _SubagentsClientMessages
   | _DocumentsClientMessages
   | _GuardianActionsClientMessages
@@ -185,9 +195,12 @@ export type ServerMessage =
   | _SubagentsServerMessages
   | _DocumentsServerMessages
   | _GuardianActionsServerMessages
+  | _HomeServerMessages
   | _HostBashServerMessages
+  | _HostBrowserServerMessages
   | _HostCuServerMessages
   | _HostFileServerMessages
+  | _MeetServerMessages
   | _MemoryServerMessages
   | _WorkspaceServerMessages
   | _SchedulesServerMessages

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

@@ -1,6 +1,11 @@
 // Conversation lifecycle, auth, model config, and history types.
 
-import type { ChannelId, InterfaceId } from "../../channels/types.js";
+import type {
+  ChannelId,
+  HostProxyInterfaceId,
+  InterfaceId,
+} from "../../channels/types.js";
+import { supportsHostProxy } from "../../channels/types.js";
 import type { ConversationType } from "./shared.js";
 import type { UserMessageAttachment } from "./shared.js";
 
@@ -26,26 +31,61 @@ interface BaseTransportMetadata {
   chatType?: string;
 }
 
-/** Transport metadata for macOS desktop clients, including host environment fields. */
-export interface MacosTransportMetadata extends BaseTransportMetadata {
-  /** Interface identifier for macOS transport. */
-  interfaceId: "macos";
-  /** Home directory of the host macOS user. */
+/**
+ * Transport metadata for interfaces that support the full desktop host-proxy
+ * set (see `HostProxyInterfaceId` / `supportsHostProxy`). Carries the host
+ * environment fields the client reports so the `<workspace>` block renders
+ * the user's actual machine rather than a containerized daemon's own OS.
+ *
+ * Today this variant is populated only by the macOS client, but the shape
+ * is capability-keyed (not interface-name-keyed) so future host-capable
+ * clients (e.g. a native Linux or Windows desktop) get the same treatment
+ * automatically when added to `HostProxyInterfaceId`.
+ */
+export interface HostProxyTransportMetadata extends BaseTransportMetadata {
+  /** Interface identifier — restricted to interfaces that support host proxies. */
+  interfaceId: HostProxyInterfaceId;
+  /** Home directory of the user on the host machine (e.g. `NSHomeDirectory()`). */
   hostHomeDir?: string;
-  /** Username of the host macOS user. */
+  /** Username of the user on the host machine (e.g. `NSUserName()`). */
   hostUsername?: string;
 }
 
-/** Transport metadata for non-macOS transports. */
-export interface NonMacosTransportMetadata extends BaseTransportMetadata {
+/**
+ * Transport metadata for interfaces that do NOT support host-proxy tools
+ * (iOS, CLI, channel ingress, chrome-extension, etc.). No host environment
+ * because the assistant has no local filesystem to address on the client.
+ */
+export interface NonHostProxyTransportMetadata extends BaseTransportMetadata {
   /** Interface identifier for this transport (e.g. "ios", "cli"). */
-  interfaceId?: Exclude<InterfaceId, "macos">;
+  interfaceId?: Exclude<InterfaceId, HostProxyInterfaceId>;
 }
 
-/** Lightweight conversation transport metadata for channel identity and natural-language guidance. */
+/**
+ * Discriminated union of transport metadata variants, keyed on whether the
+ * interface supports host-proxy tools (`supportsHostProxy`). The daemon uses
+ * that same predicate at runtime to decide whether to populate / read host
+ * environment fields on the conversation, so the type system and the runtime
+ * gate stay in lock-step as new host-capable interfaces are added.
+ */
 export type ConversationTransportMetadata =
-  | MacosTransportMetadata
-  | NonMacosTransportMetadata;
+  | HostProxyTransportMetadata
+  | NonHostProxyTransportMetadata;
+
+/**
+ * Type guard: does this transport belong to an interface that supports the
+ * full host-proxy set? Wraps `supportsHostProxy` so the capability logic
+ * stays in one place (channels/types.ts) and narrows the discriminated
+ * union to `HostProxyTransportMetadata` for safe field access.
+ */
+export function isHostProxyTransport(
+  transport: ConversationTransportMetadata,
+): transport is HostProxyTransportMetadata {
+  return (
+    transport.interfaceId !== undefined &&
+    supportsHostProxy(transport.interfaceId)
+  );
+}
 
 export interface ConversationCreateRequest {
   type: "conversation_create";
@@ -171,6 +211,7 @@ export interface ConversationInfo {
   title: string;
   correlationId?: string;
   conversationType?: ConversationType;
+  hostAccess: boolean;
 }
 
 export interface ConversationTitleUpdated {
@@ -212,6 +253,7 @@ export interface ConversationListResponse {
     updatedAt: number;
     conversationType?: ConversationType;
     source?: string;
+    hostAccess: boolean;
     scheduleJobId?: string;
     channelBinding?: ChannelBinding;
     conversationOriginChannel?: ChannelId;
@@ -419,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";
@@ -427,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 =
@@ -465,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;