@vellumai/assistant 0.8.0 → 0.8.1

package/src/daemon/host-browser-proxy.ts

@@ -1,10 +1,10 @@
 import { v4 as uuid } from "uuid";
 
-import type { InterfaceId } from "../channels/types.js";
 import {
   assistantEventHub,
   broadcastMessage,
 } from "../runtime/assistant-event-hub.js";
+import { enforceSameActorOrErrorResult } from "../runtime/auth/same-actor.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
@@ -24,11 +24,49 @@ export type HostBrowserInput = DistributiveOmit<
 
 const log = getLogger("host-browser-proxy");
 
-/** Interface priority order for host_browser: Chrome Extension first, macOS SSE bridge second. */
-const HOST_BROWSER_INTERFACE_PREFERENCE: InterfaceId[] = [
-  "chrome-extension",
-  "macos",
-];
+/**
+ * Pick the host_browser-capable client to dispatch to.
+ *
+ * When `targetClientId` is supplied, the client with that id is looked
+ * up directly in the `host_browser`-capable roster. The same-actor check
+ * in `request()` still runs on the returned client when
+ * `sourceActorPrincipalId` is present.
+ *
+ * When `sourceActorPrincipalId` is supplied (and no explicit target),
+ * candidate clients are filtered down to those owned by the same actor.
+ * Returns `undefined` when no same-actor client is connected; the
+ * caller surfaces this as the existing "no active extension connection"
+ * rejection.
+ *
+ * When neither is supplied (legacy callers without a resolved actor
+ * identity), falls through to the most-recently-active host_browser
+ * client so the registry singleton continues to work for single-client
+ * setups.
+ *
+ * Within each branch, ties are broken by `lastActiveAt` descending —
+ * the natural order returned by `listClientsByCapability`. Callers that
+ * need a specific transport (e.g. Chrome Extension's `chrome.debugger`
+ * over the macOS CDP bridge) must pass `targetClientId` explicitly via
+ * the LLM-facing param added in #30066.
+ */
+function resolveTargetClient(
+  sourceActorPrincipalId: string | undefined,
+  targetClientId?: string,
+) {
+  if (targetClientId != null) {
+    const clients = assistantEventHub.listClientsByCapability("host_browser");
+    return clients.find((c) => c.clientId === targetClientId);
+  }
+
+  const candidates =
+    assistantEventHub.listClientsByCapability("host_browser");
+  if (sourceActorPrincipalId == null) {
+    return candidates[0];
+  }
+  return candidates.find(
+    (c) => c.actorPrincipalId === sourceActorPrincipalId,
+  );
+}
 
 export class HostBrowserProxy {
   private static _instance: HostBrowserProxy | null = null;
@@ -67,10 +105,7 @@ export class HostBrowserProxy {
    */
   isAvailable(): boolean {
     return (
-      assistantEventHub.getPreferredClientByCapability(
-        "host_browser",
-        HOST_BROWSER_INTERFACE_PREFERENCE,
-      ) != null
+      assistantEventHub.getMostRecentClientByCapability("host_browser") != null
     );
   }
 
@@ -84,15 +119,64 @@ export class HostBrowserProxy {
     return assistantEventHub.listClientsByInterface("chrome-extension").length > 0;
   }
 
+  /**
+   * Send a host_browser request to the connected extension/macOS bridge.
+   *
+   * When `targetClientId` is supplied, the proxy dispatches to that specific
+   * client (subject to the `host_browser` capability check and the same-actor
+   * gate below). This mirrors the `target_client_id` pattern on `host_bash`,
+   * `host_file_*`, and `host_cu`.
+   *
+   * When `sourceActorPrincipalId` is supplied, the proxy refuses to dispatch
+   * to a client owned by a different actor — same-user enforcement is the
+   * authoritative gate against routing one actor's CDP request onto another
+   * actor's connected extension. The resolved target's `clientId` and
+   * `actorPrincipalId` are then persisted alongside the pending interaction
+   * so that the result-route's same-actor check can verify the submitting
+   * client at result time.
+   *
+   * When `sourceActorPrincipalId` is undefined (legacy/internal flows
+   * with no resolved actor identity), falls back to the most-recently-
+   * active host_browser client without an actor filter so the registry
+   * singleton continues to work for single-client setups.
+   */
   request(
     input: HostBrowserInput,
     conversationId: string,
     signal?: AbortSignal,
+    sourceActorPrincipalId?: string,
+    targetClientId?: string,
   ): Promise<ToolExecutionResult> {
     if (signal?.aborted) {
       return Promise.resolve({ content: "Aborted", isError: true });
     }
 
+    // Resolve the target client up front so we can persist the actor binding
+    // alongside the pending interaction registration. Same shape as
+    // host-cu-proxy: the result-route same-actor check compares the
+    // submitting client's actor against this captured value.
+    const preferredClient = resolveTargetClient(sourceActorPrincipalId, targetClientId);
+
+    // Same-user enforcement: when the caller's actor is known, refuse to
+    // dispatch to a client owned by a different actor. This covers the
+    // cross-client exposure case where a web/iOS turn for actor A would
+    // otherwise auto-resolve to actor B's connected extension.
+    if (
+      sourceActorPrincipalId != null &&
+      preferredClient != null &&
+      preferredClient.actorPrincipalId !== sourceActorPrincipalId
+    ) {
+      const rejection = enforceSameActorOrErrorResult({
+        hub: assistantEventHub,
+        sourceActorPrincipalId,
+        targetClientId: preferredClient.clientId,
+        op: "host_browser",
+      });
+      if (rejection) return Promise.resolve(rejection);
+    }
+
+    const resolvedClientId = preferredClient?.clientId;
+    const targetActorPrincipalId = preferredClient?.actorPrincipalId;
     const requestId = uuid();
 
     return new Promise<ToolExecutionResult>((resolve, reject) => {
@@ -135,6 +219,8 @@ export class HostBrowserProxy {
       pendingInteractions.register(requestId, {
         conversationId,
         kind: "host_browser",
+        targetClientId: resolvedClientId,
+        targetActorPrincipalId,
         rpcResolve: resolve as (v: unknown) => void,
         rpcReject: reject,
         timer,
@@ -142,10 +228,6 @@ export class HostBrowserProxy {
       });
 
       try {
-        const preferredClient = assistantEventHub.getPreferredClientByCapability(
-          "host_browser",
-          HOST_BROWSER_INTERFACE_PREFERENCE,
-        );
         if (!preferredClient) {
           pendingInteractions.resolve(requestId);
           reject(
@@ -172,27 +254,6 @@ export class HostBrowserProxy {
     });
   }
 
-  /**
-   * Process a client result and resolve the RPC. Called by route handlers.
-   */
-  resolveResult(
-    requestId: string,
-    response: { content: string; isError: boolean },
-  ): void {
-    const interaction = pendingInteractions.resolve(requestId);
-    if (!interaction?.rpcResolve) {
-      log.debug(
-        { requestId },
-        "Ignoring host_browser_result for unknown or already-resolved request",
-      );
-      return;
-    }
-    interaction.rpcResolve({
-      content: response.content,
-      isError: response.isError,
-    });
-  }
-
   dispose(): void {
     for (const entry of pendingInteractions.getByKind("host_browser")) {
       pendingInteractions.resolve(entry.requestId);

package/src/daemon/host-proxy-base.ts

@@ -141,8 +141,10 @@ export abstract class HostProxyBase<TRequest, TResultPayload> {
     signal?: AbortSignal,
     extraFields?: Record<string, unknown>,
     targetClientId?: string,
+    timeoutMsOverride?: number,
   ): Promise<TResultPayload> {
     const requestId = uuid();
+    const effectiveTimeoutMs = timeoutMsOverride ?? this.timeoutMs;
 
     return new Promise<TResultPayload>((resolve, reject) => {
       // Declared up-front so onAbort can close over a stable reference once
@@ -158,7 +160,7 @@ export abstract class HostProxyBase<TRequest, TResultPayload> {
           "Host proxy request timed out",
         );
         reject(new HostProxyRequestError("timeout", "timeout"));
-      }, this.timeoutMs);
+      }, effectiveTimeoutMs);
 
       if (signal) {
         const onAbort = () => {
@@ -204,10 +206,20 @@ export abstract class HostProxyBase<TRequest, TResultPayload> {
       // (HostCuProxy bypasses dispatchRequest entirely with its own inline
       //  request method that registers directly, which is why CU works
       //  without this base-level fix.)
+      // Snapshot the target's actorPrincipalId at registration time so the
+      // result-route same-actor check has a stable value to compare against —
+      // the target client's SSE subscription may briefly disconnect between
+      // dispatch and result submission, which would make a live hub lookup
+      // falsely 403 a legitimate result.
+      const targetActorPrincipalId =
+        targetClientId != null
+          ? assistantEventHub.getActorPrincipalIdForClient(targetClientId)
+          : undefined;
       pendingInteractions.register(requestId, {
         conversationId,
         kind: this.resultPendingKind,
         ...(targetClientId != null ? { targetClientId } : {}),
+        ...(targetActorPrincipalId != null ? { targetActorPrincipalId } : {}),
       });
 
       try {

package/src/daemon/host-proxy-preactivation.ts

@@ -28,6 +28,7 @@
 
 import type { HostProxyCapability, InterfaceId } from "../channels/types.js";
 import { supportsHostProxy } from "../channels/types.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 
 /**
  * Subset of Conversation/ProcessConversationContext that
@@ -60,6 +61,29 @@ export const HOST_PROXY_SKILL_PREACTIVATIONS: ReadonlyArray<{
   { capability: "host_app_control", skillId: "app-control" },
 ];
 
+/**
+ * Returns true when a host-proxy for the given capability should be attached
+ * (instantiated and preactivated) for the current turn. Two cases qualify:
+ *
+ *  1. The source interface natively supports the capability (e.g. macOS → host_cu).
+ *  2. The source interface doesn't support the capability natively but at least
+ *     one connected client does — cross-client routing. `chrome-extension` is
+ *     excluded as a security boundary: it is its own executor context and cannot
+ *     broker cross-client routing to a macOS client.
+ *
+ * This is the single source of truth for both preactivation and proxy
+ * instantiation, so the two decisions stay in sync.
+ */
+export function shouldAttachHostProxyForCapability(
+  capability: HostProxyCapability,
+  sourceInterface: InterfaceId | undefined,
+): boolean {
+  if (!sourceInterface) return false;
+  if (supportsHostProxy(sourceInterface, capability)) return true;
+  if (sourceInterface === "chrome-extension") return false;
+  return assistantEventHub.listClientsByCapability(capability).length > 0;
+}
+
 /**
  * Preactivate every host-proxy-backed skill that the given source interface
  * supports. No-op when `sourceInterface` is undefined.
@@ -75,7 +99,7 @@ export function preactivateHostProxySkills(
 ): void {
   if (!sourceInterface) return;
   for (const { capability, skillId } of HOST_PROXY_SKILL_PREACTIVATIONS) {
-    if (supportsHostProxy(sourceInterface, capability)) {
+    if (shouldAttachHostProxyForCapability(capability, sourceInterface)) {
       conversation.addPreactivatedSkillId(skillId);
     }
   }

package/src/daemon/identity-helpers.ts

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 
 import { getWorkspacePromptPath } from "../util/platform.js";
 
@@ -14,3 +15,21 @@ export function getAssistantName(): string | null {
     return null;
   }
 }
+
+/**
+ * Read the guardian's display name from `users/default.md`. We look for the
+ * markdown-bold "Name" label (matching the IDENTITY.md convention) and fall
+ * back to `null` on any miss; callers substitute a generic label.
+ */
+export function resolveUserName(workspaceDir: string): string | null {
+  try {
+    const content = readFileSync(
+      join(workspaceDir, "users", "default.md"),
+      "utf-8",
+    );
+    const match = content.match(/\*\*Name:\*\*\s*(.+)/);
+    return match?.[1]?.trim() || null;
+  } catch {
+    return null;
+  }
+}

package/src/daemon/lifecycle.ts

@@ -31,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";
@@ -44,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";
@@ -60,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 {
@@ -327,8 +325,6 @@ export async function runDaemon(): Promise<void> {
       log.warn({ err }, "Background feature flag init failed"),
     );
 
-    maybeSeedMemoryV2Skills(loadConfig());
-
     seedInterfaceFiles();
 
     log.info("Daemon startup: initializing DB");
@@ -370,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.
@@ -500,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) {
@@ -838,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");
@@ -958,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",
@@ -986,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;
@@ -1338,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

@@ -55,8 +55,11 @@ export async function maybeRebuildMemoryV2Concepts(
   if (!config.memory.v2.enabled) return;
 
   try {
-    const { ensureConceptPageCollection, countConceptPagePoints } =
-      await import("../memory/v2/qdrant.js");
+    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");
 
@@ -76,6 +79,10 @@ export async function maybeRebuildMemoryV2Concepts(
         { 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(

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