@vellumai/assistant 0.7.3 → 0.8.1

package/src/daemon/lifecycle.ts

@@ -7,10 +7,7 @@ import { reconcileCallsOnStartup } from "../calls/call-recovery.js";
 import { setRelayBroadcast } from "../calls/relay-server.js";
 import { TwilioConversationRelayProvider } from "../calls/twilio-provider.js";
 import { setVoiceBridgeDeps } from "../calls/voice-session-bridge.js";
-import {
-  initFeatureFlagOverrides,
-  isAssistantFeatureFlagEnabled,
-} from "../config/assistant-feature-flags.js";
+import { initFeatureFlagOverrides } from "../config/assistant-feature-flags.js";
 import {
   getPlatformAssistantId,
   getRuntimeHttpHost,
@@ -34,10 +31,6 @@ 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 { closeSentry, initSentry, setSentryDeviceId } from "../instrument.js";
 import { getMcpServerManager } from "../mcp/manager.js";
@@ -47,6 +40,7 @@ import {
 } from "../memory/attachments-store.js";
 import { expireAllPendingCanonicalRequests } from "../memory/canonical-guardian-store.js";
 import { deleteMessageById, getMessages } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { selectEmbeddingBackend } from "../memory/embedding-backend.js";
 import { enqueueMemoryJob } from "../memory/jobs-store.js";
@@ -63,6 +57,7 @@ import { seedOAuthProviders } from "../oauth/seed-providers.js";
 import { loadUserPlugins } from "../plugins/user-loader.js";
 import { backfillGuardIfNeeded } from "../proactive-artifact/index.js";
 import { ensurePromptFiles } from "../prompts/system-prompt.js";
+import { runProviderConnectionsBackfill } from "../providers/inference/backfill.js";
 import { resolveManagedProxyContext } from "../providers/managed-proxy/context.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import {
@@ -117,7 +112,10 @@ import {
 } from "./guardian-action-generators.js";
 import { backfillSlackInjectionTemplates } from "./handlers/config-slack-channel.js";
 import { installAssistantSymlink } from "./install-symlink.js";
-import { maybeSeedMemoryV2Skills } from "./memory-v2-startup.js";
+import {
+  maybeRebuildMemoryV2Concepts,
+  maybeSeedMemoryV2Skills,
+} from "./memory-v2-startup.js";
 import { processMessage } from "./process-message.js";
 import { runProfilerSweep } from "./profiler-run-store.js";
 import {
@@ -318,21 +316,14 @@ export async function runDaemon(): Promise<void> {
     const signingKey = resolveSigningKey();
     initAuthSigningKey(signingKey);
 
-    // Pre-populate
-    // subsequent sync isAssistantFeatureFlagEnabled() calls have data.
-    // Fired non-blocking so a slow or unreachable gateway doesn't delay
-    // daemon startup (the IPC call has a 3s connect + 5s call timeout
-    // that would otherwise stall the critical path).
-    //
-    // On resolve, retry the v2 skill seed: the synchronous gate at the
-    // skill-seed call site below evaluates the memory-v2-enabled flag
-    // before the gateway has populated overrides, so a cold-boot race
-    // can leave the v2 skill collection unseeded for the lifetime of
-    // the daemon. seedV2SkillEntries is idempotent, so re-running after
-    // overrides land is safe.
-    void initFeatureFlagOverrides()
-      .then(() => maybeSeedMemoryV2Skills(loadConfig()))
-      .catch((err) => log.warn({ err }, "Background feature flag init failed"));
+    // Pre-populate feature flag overrides so subsequent sync
+    // isAssistantFeatureFlagEnabled() calls have data. Fired non-blocking
+    // so a slow or unreachable gateway doesn't delay 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"),
+    );
 
     seedInterfaceFiles();
 
@@ -375,6 +366,20 @@ export async function runDaemon(): Promise<void> {
       await runWorkspaceMigrations(getWorkspaceDir(), WORKSPACE_MIGRATIONS);
       log.info("Daemon startup: workspace migrations complete");
 
+      // Seed canonical inference provider_connections and backfill any legacy
+      // profiles that pre-date the connection field. Runs after workspace
+      // migrations so migration 076 has already stripped services.inference.mode
+      // before backfill reads config. Idempotent — runs every boot so new
+      // canonicals propagate and manual config.json edits self-heal.
+      try {
+        runProviderConnectionsBackfill(getDb());
+      } catch (err) {
+        log.warn(
+          { err },
+          "provider_connections backfill failed — continuing startup",
+        );
+      }
+
       // Profiler retention sweep — prune completed profiler runs to stay
       // within configured byte-count, run-count, and free-space budgets.
       // Runs on every startup and is safe to call from explicit cleanup routes.
@@ -505,15 +510,16 @@ export async function runDaemon(): Promise<void> {
     // seeder and persisted alongside schema defaults.
     const defaultConfigMerge = mergeDefaultWorkspaceConfig();
 
-    // Seed managed inference profiles into the workspace config. Runs after
-    // workspace migrations and default-config merge, but before loadConfig() so
-    // fresh hatches have profiles on disk before the first config load. Any
-    // profile fields explicitly supplied by the default overlay stay
-    // authoritative for this startup.
+    // Seed inference profiles into the workspace config. Managed Anthropic
+    // profiles are overwritten on every boot so Vellum can push updates.
+    // Off-platform hatches additionally create user profiles + a personal
+    // provider connection for the hatch provider.
     try {
       seedInferenceProfiles({
         preserveProfileNames: defaultConfigMerge.providedLlmProfileNames,
         preserveActiveProfile: defaultConfigMerge.providedLlmActiveProfile,
+        isHatch: defaultConfigMerge.hadOverlay,
+        db: dbReady ? getDb() : undefined,
       });
       log.info("Inference profile seeding complete");
     } catch (err) {
@@ -741,64 +747,87 @@ export async function runDaemon(): Promise<void> {
       }
 
       if (qdrantStarted) {
-        try {
-          const embeddingSelection = await selectEmbeddingBackend(config);
-          // Sentinel only encodes the dense provider+model identity; sparse
-          // encoder changes never require collection recreation, so they
-          // intentionally do not contribute to the v1 collection identity.
-          const embeddingModel = embeddingSelection.backend
-            ? `${embeddingSelection.backend.provider}:${embeddingSelection.backend.model}`
-            : undefined;
-          const qdrantClient = initQdrantClient({
-            url: qdrantUrl,
-            collection: config.memory.qdrant.collection,
-            vectorSize: config.memory.qdrant.vectorSize,
-            onDisk: config.memory.qdrant.onDisk,
-            quantization: config.memory.qdrant.quantization,
-            embeddingModel,
-          });
+        // Skip the v1 Qdrant collection lifecycle when memory v2 is active —
+        // the v1 collection has no writers (handleRemember returns early) or
+        // readers (graph search is bypassed) under v2, so ensuring/migrating
+        // it just maintains a dead-on-arrival collection. Existing on-disk
+        // collections are left intact so flipping v2 off restores v1 cleanly.
+        if (!config.memory.v2.enabled) {
+          try {
+            const embeddingSelection = await selectEmbeddingBackend(config);
+            // Sentinel only encodes the dense provider+model identity; sparse
+            // encoder changes never require collection recreation, so they
+            // intentionally do not contribute to the v1 collection identity.
+            const embeddingModel = embeddingSelection.backend
+              ? `${embeddingSelection.backend.provider}:${embeddingSelection.backend.model}`
+              : undefined;
+            const qdrantClient = initQdrantClient({
+              url: qdrantUrl,
+              collection: config.memory.qdrant.collection,
+              vectorSize: config.memory.qdrant.vectorSize,
+              onDisk: config.memory.qdrant.onDisk,
+              quantization: config.memory.qdrant.quantization,
+              embeddingModel,
+            });
 
-          // Eagerly ensure the collection exists so we detect migrations
-          // (unnamed→named vectors, dimension/model changes) at startup.
-          // If a destructive migration occurred, enqueue a rebuild_index job
-          // to re-embed all memory items from the SQLite cache.
-          const { migrated } = await qdrantClient.ensureCollection();
-          if (migrated) {
-            enqueueMemoryJob("rebuild_index", {});
-            log.info(
-              "Qdrant collection was migrated — enqueued rebuild_index job",
+            // Eagerly ensure the collection exists so we detect migrations
+            // (unnamed→named vectors, dimension/model changes) at startup.
+            // If a destructive migration occurred, enqueue a rebuild_index job
+            // to re-embed all memory items from the SQLite cache.
+            const { migrated } = await qdrantClient.ensureCollection();
+            if (migrated) {
+              enqueueMemoryJob("rebuild_index", {});
+              log.info(
+                "Qdrant collection was migrated — enqueued rebuild_index job",
+              );
+            }
+
+            log.info("Qdrant vector store initialized");
+          } catch (err) {
+            log.warn(
+              { err },
+              "Qdrant client initialization failed — memory features will be degraded",
             );
           }
+        }
 
-          log.info("Qdrant vector store initialized");
+        // Detect schema drift on the v2 concept-page collection (e.g.
+        // pre-#29823 collections lacking summary_dense / summary_sparse) and
+        // recreate + enqueue a reembed when needed. Awaited inline so the
+        // reembed enqueue happens before the memory worker drains its first
+        // batch; the call's own try/catch keeps any v2-side failure from
+        // blocking the v1 PKB reconcile or BM25 build below.
+        try {
+          await maybeRebuildMemoryV2Concepts(config);
         } catch (err) {
           log.warn(
             { err },
-            "Qdrant client initialization failed — memory features will be degraded",
+            "Memory v2 collection schema check threw — continuing startup",
           );
         }
 
-        // Reconcile the PKB Qdrant index against the on-disk tree. Kept
-        // inside the `qdrantStarted` guard so we don't call
-        // `getQdrantClient()` (which throws "not initialized") on every
-        // startup when Qdrant is unavailable. Fire-and-forget so enqueued
-        // re-index jobs drain in the background and first-turn latency
-        // stays unaffected.
-        void (async () => {
-          try {
-            const { reconcilePkbIndex } =
-              await import("../memory/pkb/pkb-reconcile.js");
-            const { PKB_WORKSPACE_SCOPE } =
-              await import("../memory/pkb/types.js");
-            const pkbRoot = join(getWorkspaceDir(), "pkb");
-            await reconcilePkbIndex(pkbRoot, PKB_WORKSPACE_SCOPE);
-          } catch (err) {
-            log.warn(
-              { err },
-              "PKB index reconciliation failed — continuing startup",
-            );
-          }
-        })();
+        // Reconcile the PKB Qdrant index against the on-disk tree. Gated on
+        // !v2 because PKB is the v1 storage layer; under v2 the v1 collection
+        // is not initialized, so calling `getQdrantClient()` here would throw.
+        // Fire-and-forget so enqueued re-index jobs drain in the background
+        // and first-turn latency stays unaffected.
+        if (!config.memory.v2.enabled) {
+          void (async () => {
+            try {
+              const { reconcilePkbIndex } =
+                await import("../memory/pkb/pkb-reconcile.js");
+              const { PKB_WORKSPACE_SCOPE } =
+                await import("../memory/pkb/types.js");
+              const pkbRoot = join(getWorkspaceDir(), "pkb");
+              await reconcilePkbIndex(pkbRoot, PKB_WORKSPACE_SCOPE);
+            } catch (err) {
+              log.warn(
+                { err },
+                "PKB index reconciliation failed — continuing startup",
+              );
+            }
+          })();
+        }
 
         // Build the BM25 corpus stats (per-token document frequencies and
         // average document length) used by the v2 sparse channel. Without
@@ -820,6 +849,26 @@ export async function runDaemon(): Promise<void> {
             );
           }
         })();
+
+        // Validate every concept page's frontmatter against the strict
+        // schema and emit a `warn` per offender. Surfaces schema drift
+        // (unknown keys, type mismatches) at boot time instead of waiting
+        // for the failure to manifest as a silent V2 retrieval no-op when
+        // a bad page first lands in a conversation's top-K. Fire-and-forget
+        // and the sweep itself never throws — defense in depth via the
+        // outer try/catch.
+        void (async () => {
+          try {
+            const { sweepConceptPageFrontmatter } =
+              await import("../memory/v2/frontmatter-sweep.js");
+            await sweepConceptPageFrontmatter(getWorkspaceDir());
+          } catch (err) {
+            log.warn(
+              { err },
+              "Concept page frontmatter sweep threw — continuing startup",
+            );
+          }
+        })();
       }
 
       log.info("Daemon startup: starting memory worker");
@@ -940,24 +989,6 @@ export async function runDaemon(): Promise<void> {
           dedupeKey: `watcher:notification:${crypto.randomUUID()}`,
         });
       },
-      (params) => {
-        void emitNotificationSignal({
-          sourceEventName: "watcher.escalation",
-          sourceChannel: "watcher",
-          sourceContextId: `watcher-escalation-${Date.now()}`,
-          attentionHints: {
-            requiresAction: true,
-            urgency: "high",
-            isAsyncBackground: false,
-            visibleInSourceNow: false,
-          },
-          contextPayload: {
-            title: params.title,
-            body: params.body,
-          },
-          dedupeKey: `watcher:escalation:${crypto.randomUUID()}`,
-        });
-      },
       (info) => {
         broadcastMessage({
           type: "schedule_conversation_created",
@@ -968,19 +999,6 @@ 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 for optional REST API access.
     // Defaults to port 7821.
     let runtimeHttp: RuntimeHttpServer | null = null;
@@ -1283,14 +1301,11 @@ export async function runDaemon(): Promise<void> {
       log.warn({ err }, "Proactive artifact backfill failed");
     }
 
-    // Filing yields to the memory v2 consolidation job when the flag is on —
+    // Filing yields to the memory v2 consolidation job when v2 is enabled —
     // both serve the same role (periodic background memory processing) and
     // running both is redundant. The consolidation job runs through the
     // memory jobs worker (see `maybeEnqueueGraphMaintenanceJobs`).
-    const memoryV2Enabled = isAssistantFeatureFlagEnabled(
-      "memory-v2-enabled",
-      config,
-    );
+    const memoryV2Enabled = config.memory.v2.enabled;
     let filing: FilingService | null = null;
     if (!memoryV2Enabled) {
       const filingConfig = config.filing;
@@ -1323,7 +1338,6 @@ export async function runDaemon(): Promise<void> {
       filing,
       runtimeHttp,
       scheduler,
-      feedScheduler,
       getMemoryWorker: () => bgRefs.memoryWorker,
       getQdrantManager: () => bgRefs.qdrantManager,
       mcpManager,

package/src/daemon/meet-host-supervisor.ts

@@ -14,10 +14,11 @@
  *   - `ensureRunning()` — idempotent. First caller triggers
  *     `child_process.spawn`, subsequent concurrent callers await the
  *     same in-flight promise. Resolves once the child dials
- *     `assistant-skill.sock` and sends a handshake frame (via
- *     `notifyHandshake`) whose reported source-tree hash matches the
- *     shipped manifest's hash. A mismatch kills the spawn and throws
- *     a clear error pointing the user at regenerating the manifest.
+ *     `assistant-skill.sock` and the first `host.registries.register_*`
+ *     frame lands (which calls {@link setActiveConnection}). Source-hash
+ *     drift is not validated on this path — `notifyHandshake` exists for
+ *     a future explicit handshake frame that ships the skill's
+ *     runtime-computed hash, but no production caller invokes it today.
  *
  *   - `reportSessionStarted(id)` / `reportSessionEnded(id)` — mutate
  *     the active-session counter, called by the
@@ -278,15 +279,14 @@ export class MeetHostSupervisor {
   }
 
   /**
-   * Called by the IPC route handler when the child sends its
-   * `host.registries.register_tools` / `ready` frame. The supervisor
-   * validates the reported source hash against the shipped manifest
-   * and either resolves or rejects the in-flight `ensureRunning()`
-   * promise accordingly.
-   *
-   * Intentionally public so PR 24's `host.registries.*` route (which
-   * owns the IPC socket) can forward the payload without the
-   * supervisor owning any socket state itself.
+   * Validate a handshake payload's reported source hash against the
+   * shipped manifest and resolve or reject the in-flight
+   * `ensureRunning()` promise accordingly. Currently dormant on the
+   * production path — readiness is signalled by the first
+   * `host.registries.register_*` frame (see {@link setActiveConnection})
+   * which carries no hash. This method is preserved as the integration
+   * point for a future explicit handshake frame whose payload ships the
+   * skill's runtime-computed hash; only tests exercise it today.
    */
   notifyHandshake(payload: MeetHostHandshakePayload): void {
     if (!this.handshakeResolve || !this.handshakeReject) {
@@ -374,8 +374,8 @@ export class MeetHostSupervisor {
     // The first `host.registries.register_*` frame doubles as the
     // readiness signal: it means `register(client)` ran to completion and
     // the IPC socket is healthy. Resolve any in-flight handshake so
-    // `ensureRunning()` unblocks. `notifyHandshake` remains the path for
-    // callers that send a dedicated hash-bearing handshake frame.
+    // `ensureRunning()` unblocks. No source-hash check happens here —
+    // see {@link notifyHandshake} for the dormant validation path.
     this.handshakeResolve?.();
   }
 

package/src/daemon/memory-v2-startup.ts

@@ -6,9 +6,9 @@
 // startup work invoked from `lifecycle.ts`. Lives in its own file so the unit
 // test for the gate does not have to mount the entire lifecycle import graph.
 
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../config/schema.js";
 import { getLogger } from "../util/logger.js";
+import { getWorkspaceDir } from "../util/platform.js";
 
 const log = getLogger("memory-v2-startup");
 
@@ -16,21 +16,12 @@ const log = getLogger("memory-v2-startup");
  * Fire-and-forget seed of the v2 skill entries (now indexed alongside concept
  * pages in `memory_v2_concept_pages` under the `skills/<id>` slug prefix), and
  * a one-shot best-effort cleanup of the legacy `memory_v2_skills` Qdrant
- * collection. Gated on both the `memory-v2-enabled` feature flag and the
- * workspace-level `config.memory.v2.enabled` switch so v2 modules stay out of
- * the v1 startup path when v2 is off.
- *
- * Uses a dynamic import so v2 code does not load unless the gate passes.
- * Never awaits — startup must not block on this (see `assistant/CLAUDE.md`
- * daemon startup philosophy).
+ * collection. Uses a dynamic import so v2 code does not load unless the gate
+ * passes. Never awaits — startup must not block on this (see
+ * `assistant/CLAUDE.md` daemon startup philosophy).
  */
 export function maybeSeedMemoryV2Skills(config: AssistantConfig): void {
-  if (
-    !isAssistantFeatureFlagEnabled("memory-v2-enabled", config) ||
-    !config.memory.v2.enabled
-  ) {
-    return;
-  }
+  if (!config.memory.v2.enabled) return;
   void import("../memory/v2/skill-store.js")
     .then(({ seedV2SkillEntries }) => seedV2SkillEntries())
     .catch((err) => log.warn({ err }, "Failed to seed v2 skill entries"));
@@ -43,3 +34,60 @@ export function maybeSeedMemoryV2Skills(config: AssistantConfig): void {
       ),
     );
 }
+
+/**
+ * Reconcile the v2 concept-page Qdrant collection with the expected schema
+ * and enqueue `memory_v2_reembed` when the collection is missing data.
+ * Triggers reembed in two cases:
+ *  - Drift: `ensureConceptPageCollection` returned `{ migrated: true }`
+ *    after destructively recreating the collection (e.g. pre-#29823
+ *    schemas lacking `summary_*` named vectors).
+ *  - Empty-after-create: the collection has zero points but pages exist on
+ *    disk — covers crash-mid-rebuild and external Qdrant wipes.
+ *
+ * Awaited inline by `lifecycle.ts` so the enqueue happens before the memory
+ * worker drains its first batch; the body is wrapped in try/catch so a v2
+ * failure never blocks startup.
+ */
+export async function maybeRebuildMemoryV2Concepts(
+  config: AssistantConfig,
+): Promise<void> {
+  if (!config.memory.v2.enabled) return;
+
+  try {
+    const {
+      ensureConceptPageCollection,
+      countConceptPagePoints,
+      clearReembedSentinel,
+    } = await import("../memory/v2/qdrant.js");
+    const { hasConceptPages } = await import("../memory/v2/page-store.js");
+    const { enqueueMemoryJob } = await import("../memory/jobs-store.js");
+
+    const { migrated } = await ensureConceptPageCollection();
+
+    let shouldReembed = migrated;
+    if (!shouldReembed) {
+      const points = await countConceptPagePoints();
+      if (points === 0 && (await hasConceptPages(getWorkspaceDir()))) {
+        shouldReembed = true;
+      }
+    }
+
+    if (shouldReembed) {
+      const jobId = enqueueMemoryJob("memory_v2_reembed", {});
+      log.info(
+        { jobId, collectionMigrated: migrated },
+        "Memory v2 collection rebuild required — enqueued reembed job",
+      );
+      // Clear the on-disk sentinel that the qdrant ensure-path writes before
+      // delete: now that reembed is queued, the cross-call signal can retire.
+      // If the sentinel never existed this is a no-op.
+      await clearReembedSentinel();
+    }
+  } catch (err) {
+    log.warn(
+      { err },
+      "Memory v2 collection schema check failed — continuing startup; v2 retrieval may be degraded",
+    );
+  }
+}

package/src/daemon/message-protocol.ts

@@ -15,6 +15,7 @@
 // Re-export domain modules (all individual types remain importable)
 export * from "./message-types/acp.js";
 export * from "./message-types/apps.js";
+export * from "./message-types/bookmarks.js";
 export * from "./message-types/browser.js";
 export * from "./message-types/computer-use.js";
 export * from "./message-types/contacts.js";
@@ -42,6 +43,7 @@ export * from "./message-types/shared.js";
 export * from "./message-types/skills.js";
 export * from "./message-types/subagents.js";
 export * from "./message-types/surfaces.js";
+export * from "./message-types/sync.js";
 export * from "./message-types/upgrades.js";
 export * from "./message-types/work-items.js";
 export * from "./message-types/workspace.js";
@@ -52,6 +54,7 @@ import type {
   _AppsClientMessages,
   _AppsServerMessages,
 } from "./message-types/apps.js";
+import type { _BookmarksServerMessages } from "./message-types/bookmarks.js";
 import type {
   _BrowserClientMessages,
   _BrowserServerMessages,
@@ -129,6 +132,7 @@ import type {
   _SurfacesClientMessages,
   _SurfacesServerMessages,
 } from "./message-types/surfaces.js";
+import type { _SyncInvalidationServerMessages } from "./message-types/sync.js";
 import type { _UpgradesServerMessages } from "./message-types/upgrades.js";
 import type {
   _WorkItemsClientMessages,
@@ -188,6 +192,7 @@ export type ServerMessage =
   | _SubagentsServerMessages
   | _DocumentsServerMessages
   | _GuardianActionsServerMessages
+  | _SyncInvalidationServerMessages
   | _HomeServerMessages
   | _HostAppControlServerMessages
   | _HostBashServerMessages
@@ -205,6 +210,7 @@ export type ServerMessage =
   | _NotificationsServerMessages
   | _UpgradesServerMessages
   | _AcpServerMessages
+  | _BookmarksServerMessages
   | _DiskPressureServerMessages
   | SubagentEvent;
 

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

@@ -0,0 +1,18 @@
+// Bookmark events. Surfaced over SSE so a `BookmarkStore` instance in any
+// connected client can stay in sync when another window mutates the list.
+
+import type { BookmarkSummary } from "../../memory/bookmark-crud.js";
+
+export interface BookmarkCreated {
+  type: "bookmark.created";
+  bookmark: BookmarkSummary;
+}
+
+export interface BookmarkDeleted {
+  type: "bookmark.deleted";
+  messageId: string;
+}
+
+// --- Domain-level union aliases (consumed by the barrel file) ---
+
+export type _BookmarksServerMessages = BookmarkCreated | BookmarkDeleted;

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

@@ -138,12 +138,6 @@ export interface ModelGetRequest {
   type: "model_get";
 }
 
-export interface ModelSetRequest {
-  type: "model_set";
-  model: string;
-  provider?: string;
-}
-
 export interface ImageGenModelSetRequest {
   type: "image_gen_model_set";
   model: string;
@@ -310,8 +304,14 @@ export interface GenerationHandoff {
   queuedCount: number;
   attachments?: UserMessageAttachment[];
   attachmentWarnings?: string[];
-  /** Database ID of the persisted assistant message, if any. */
+  /** Database ID of the final persisted assistant row, if any. */
   messageId?: string;
+  /**
+   * Database ID used by clients for the rendered assistant bubble. Tool turns
+   * may persist multiple assistant rows; this matches the history row that
+   * survives query-time merging.
+   */
+  displayMessageId?: string;
 }
 
 export interface ModelInfo {
@@ -387,7 +387,10 @@ export interface HistoryResponse {
   type: "history_response";
   conversationId: string;
   messages: Array<{
-    id?: string; // Database message ID (for matching surfaces)
+    /** Database ID used by clients for the rendered message bubble. */
+    id?: string;
+    /** Concrete persisted row ID for row-scoped actions such as TTS/fork. */
+    daemonMessageId?: string;
     role: string;
     text: string;
     timestamp: number;
@@ -527,6 +530,7 @@ export type ConversationErrorCode =
   | "MANAGED_USAGE_LIMIT"
   | "PROVIDER_OVERLOADED"
   | "PROVIDER_API"
+  | "IMAGE_TOO_LARGE"
   | "PROVIDER_BILLING"
   | "PROVIDER_ORDERING"
   | "PROVIDER_WEB_SEARCH"
@@ -597,7 +601,6 @@ export type _ConversationsClientMessages =
   | CancelRequest
   | DeleteQueuedMessage
   | ModelGetRequest
-  | ModelSetRequest
   | ImageGenModelSetRequest
   | UndoRequest
   | UsageRequest