@vellumai/assistant 0.5.0 → 0.5.2

package/src/daemon/handlers/config-model.ts

@@ -4,12 +4,19 @@ import {
   saveRawConfig,
 } from "../../config/loader.js";
 import { setServiceField } from "../../config/raw-config-utils.js";
+import { VALID_INFERENCE_PROVIDERS } from "../../config/schemas/services.js";
+import type { ProviderCatalogEntry } from "../../providers/model-catalog.js";
+import {
+  isModelInCatalog,
+  PROVIDER_CATALOG,
+} from "../../providers/model-catalog.js";
+import { getProviderDefaultModel } from "../../providers/model-intents.js";
 import {
   getConfiguredProviders,
   isProviderAvailable,
 } from "../../providers/provider-availability.js";
 import { initializeProviders } from "../../providers/registry.js";
-import { MODEL_TO_PROVIDER } from "../conversation-slash.js";
+import { getMaskedProviderKey } from "../../security/secure-keys.js";
 import type {
   ImageGenModelSetRequest,
   ModelSetRequest,
@@ -20,6 +27,13 @@ import {
   log,
 } from "./shared.js";
 
+/** Reverse lookup: model ID → provider, derived from PROVIDER_CATALOG. */
+export const MODEL_TO_PROVIDER: Record<string, string> = Object.fromEntries(
+  PROVIDER_CATALOG.flatMap((provider) =>
+    provider.models.map(({ id }) => [id, provider.id]),
+  ),
+);
+
 // ---------------------------------------------------------------------------
 // Shared business logic (transport-agnostic)
 // ---------------------------------------------------------------------------
@@ -28,15 +42,29 @@ export interface ModelInfo {
   model: string;
   provider: string;
   configuredProviders?: string[];
+  availableModels?: Array<{ id: string; displayName: string }>;
+  allProviders?: ProviderCatalogEntry[];
+  maskedKeys?: Record<string, string>;
 }
 
 /** Return current model configuration. */
 export async function getModelInfo(): Promise<ModelInfo> {
   const config = getConfig();
+  const provider = config.services.inference.provider;
+
+  const maskedKeys: Record<string, string> = {};
+  for (const p of VALID_INFERENCE_PROVIDERS) {
+    const masked = await getMaskedProviderKey(p);
+    if (masked) maskedKeys[p] = masked;
+  }
+
   return {
     model: config.services.inference.model,
-    provider: config.services.inference.provider,
+    provider,
     configuredProviders: await getConfiguredProviders(),
+    availableModels: PROVIDER_CATALOG.find((p) => p.id === provider)?.models,
+    allProviders: PROVIDER_CATALOG,
+    maskedKeys,
   };
 }
 
@@ -58,28 +86,52 @@ export interface ModelSetContext {
 /**
  * Set the active model. Returns the resulting ModelInfo, or throws on failure.
  * The caller is responsible for sending the response to the client.
+ *
+ * When `explicitProvider` is supplied, it takes precedence over automatic
+ * provider inference from the model ID. If the provider changes and the
+ * current model doesn't belong to the new provider's catalog, the model
+ * is auto-reset to the provider's default.
  */
 export async function setModel(
   modelId: string,
   ctx: ModelSetContext,
+  explicitProvider?: string,
 ): Promise<ModelInfo> {
-  // If the requested model is already the current model AND the provider
-  // is already aligned with what MODEL_TO_PROVIDER expects, skip expensive
-  // reinitialization but still return model_info so the client confirms.
-  {
-    const current = getConfig();
-    const expectedProvider = MODEL_TO_PROVIDER[modelId];
-    const providerAligned =
-      !expectedProvider ||
-      current.services.inference.provider === expectedProvider;
-    if (modelId === current.services.inference.model && providerAligned) {
-      return await getModelInfo();
-    }
+  const validProviders = new Set<string>(VALID_INFERENCE_PROVIDERS);
+
+  // Validate explicit provider against allowlist
+  if (explicitProvider && !validProviders.has(explicitProvider)) {
+    throw new Error(
+      `Invalid provider "${explicitProvider}". Valid providers: ${[...validProviders].join(", ")}`,
+    );
+  }
+
+  // Resolve provider: explicit > MODEL_TO_PROVIDER lookup > current
+  const current = getConfig();
+  const resolvedProvider =
+    explicitProvider ??
+    MODEL_TO_PROVIDER[modelId] ??
+    current.services.inference.provider;
+
+  // Auto-reset model when provider changes and current modelId doesn't
+  // belong to the new provider's catalog.
+  if (
+    resolvedProvider !== current.services.inference.provider &&
+    !isModelInCatalog(resolvedProvider, modelId)
+  ) {
+    modelId = getProviderDefaultModel(resolvedProvider);
+  }
+
+  // No-op guard: skip expensive reinitialization when nothing changed
+  if (
+    modelId === current.services.inference.model &&
+    resolvedProvider === current.services.inference.provider
+  ) {
+    return await getModelInfo();
   }
 
   // Validate provider availability (secure key, env var, or managed proxy) before switching
-  const provider = MODEL_TO_PROVIDER[modelId];
-  if (provider && !(await isProviderAvailable(provider))) {
+  if (!(await isProviderAvailable(resolvedProvider))) {
     // Return current model_info so the client resyncs its optimistic state
     return await getModelInfo();
   }
@@ -87,10 +139,7 @@ export async function setModel(
   // Use raw config to avoid persisting env-var API keys to disk
   const raw = loadRawConfig();
   setServiceField(raw, "inference", "model", modelId);
-  // Infer provider from model ID to keep provider and model in sync
-  if (provider) {
-    setServiceField(raw, "inference", "provider", provider);
-  }
+  setServiceField(raw, "inference", "provider", resolvedProvider);
 
   // Suppress the file watcher callback — setModel already does
   // the full reload sequence; a redundant watcher-triggered reload
@@ -128,11 +177,7 @@ export async function setModel(
 
   ctx.updateConfigFingerprint();
 
-  return {
-    model: config.services.inference.model,
-    provider: config.services.inference.provider,
-    configuredProviders: await getConfiguredProviders(),
-  };
+  return await getModelInfo();
 }
 
 /**
@@ -179,7 +224,7 @@ export async function handleModelSet(
   ctx: HandlerContext,
 ): Promise<void> {
   try {
-    const info = await setModel(msg.model, ctx);
+    const info = await setModel(msg.model, ctx, msg.provider);
     ctx.send({ type: "model_info", ...info });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);

package/src/daemon/handlers/conversations.ts

@@ -9,7 +9,6 @@ import { getConfig } from "../../config/loader.js";
 import {
   createCanonicalGuardianRequest,
   generateCanonicalRequestCode,
-  resolveCanonicalGuardianRequest,
 } from "../../memory/canonical-guardian-store.js";
 import {
   batchSetDisplayOrders,
@@ -50,27 +49,6 @@ import {
   pendingStandaloneSecrets,
 } from "./shared.js";
 
-export function syncCanonicalStatusFromConfirmationDecision(
-  requestId: string,
-  decision: ConfirmationResponse["decision"],
-): void {
-  const targetStatus =
-    decision === "deny" || decision === "always_deny"
-      ? ("denied" as const)
-      : ("approved" as const);
-
-  try {
-    resolveCanonicalGuardianRequest(requestId, "pending", {
-      status: targetStatus,
-    });
-  } catch (err) {
-    log.debug(
-      { err, requestId, targetStatus },
-      "Failed to resolve canonical request from local confirmation response",
-    );
-  }
-}
-
 export function makeEventSender(params: {
   ctx: HandlerContext;
   conversation: Conversation;
@@ -165,7 +143,6 @@ export function handleConfirmationResponse(
         undefined,
         { source: "button" },
       );
-      syncCanonicalStatusFromConfirmationDecision(msg.requestId, msg.decision);
       pendingInteractions.resolve(msg.requestId);
       return;
     }

package/src/daemon/handlers/recording.ts

@@ -4,10 +4,10 @@ import * as path from "node:path";
 import { v4 as uuid } from "uuid";
 
 import {
-  linkAttachmentToMessage,
-  uploadFileBackedAttachment,
+  attachFileBackedAttachmentToMessage,
 } from "../../memory/attachments-store.js";
-import { addMessage } from "../../memory/conversation-crud.js";
+import { addMessage, getConversation } from "../../memory/conversation-crud.js";
+import { syncMessageToDisk } from "../../memory/conversation-disk-view.js";
 import type { RecordingOptions, RecordingStatus } from "../message-protocol.js";
 import { type HandlerContext, log } from "./shared.js";
 
@@ -616,23 +616,6 @@ export async function finalizeAndPublishRecording(params: {
     const ext = filename.split(".").pop()?.toLowerCase();
     const mimeType = (ext && RECORDING_MIME_TYPES.get(ext)) || "video/mp4";
 
-    // Store as file-backed attachment (avoids reading large files into memory)
-    const attachment = uploadFileBackedAttachment(
-      filename,
-      mimeType,
-      resolvedPath,
-      sizeBytes,
-    );
-    log.info(
-      {
-        recordingId,
-        attachmentId: attachment.id,
-        sizeBytes,
-        filePath: resolvedPath,
-      },
-      "Created attachment for standalone recording",
-    );
-
     // Always create a new assistant message for the recording attachment.
     // Reusing the last assistant message would attach the recording to an
     // unrelated older message after reload.
@@ -648,12 +631,34 @@ export async function finalizeAndPublishRecording(params: {
       "Created assistant message for recording attachment",
     );
 
-    linkAttachmentToMessage(messageId, attachment.id, 0);
+    const attachment = attachFileBackedAttachmentToMessage(
+      messageId,
+      0,
+      filename,
+      mimeType,
+      resolvedPath,
+      sizeBytes,
+    );
+    log.info(
+      {
+        recordingId,
+        attachmentId: attachment.id,
+        sizeBytes,
+        filePath: resolvedPath,
+      },
+      "Created attachment for standalone recording",
+    );
     log.info(
       { recordingId, messageId, attachmentId: attachment.id },
       "Linked recording attachment to assistant message",
     );
 
+    // Sync the recording message (with attachment) to the disk view
+    const convForDisk = getConversation(conversationId);
+    if (convForDisk) {
+      syncMessageToDisk(conversationId, messageId, convForDisk.createdAt);
+    }
+
     // Skip server-side thumbnail generation for recordings — the client
     // generates thumbnails natively from the local file path using
     // AVAssetImageGenerator, which is faster and doesn't depend on ffmpeg.

package/src/daemon/history-repair.ts

@@ -69,7 +69,10 @@ export function repairHistory(messages: Message[]): RepairResult {
       }
 
       // Ensure every server_tool_use has a paired web_search_tool_result
-      // in the same assistant message (handles interrupted streams)
+      // in the same assistant message (handles interrupted streams).
+      // Synthetic results are inserted IMMEDIATELY AFTER their corresponding
+      // server_tool_use block — not appended to the end — so that
+      // ensureToolPairing's split at tool_use boundaries cannot separate them.
       const serverToolIds = new Set(
         cleanedContent
           .filter(
@@ -82,18 +85,35 @@ export function repairHistory(messages: Message[]): RepairResult {
           .filter((b) => b.type === "web_search_tool_result")
           .map((b) => (b as { tool_use_id: string }).tool_use_id),
       );
+      const orphanedServerIds = new Set<string>();
       for (const id of serverToolIds) {
         if (!matchedServerIds.has(id)) {
-          cleanedContent.push({
-            type: "web_search_tool_result",
-            tool_use_id: id,
-            content: SYNTHETIC_WEB_SEARCH_ERROR,
-          });
-          stats.missingToolResultsInserted++;
+          orphanedServerIds.add(id);
         }
       }
 
-      result.push({ role: "assistant", content: cleanedContent });
+      let repairedContent: ContentBlock[];
+      if (orphanedServerIds.size > 0) {
+        repairedContent = [];
+        for (const block of cleanedContent) {
+          repairedContent.push(block);
+          if (
+            block.type === "server_tool_use" &&
+            orphanedServerIds.has(block.id)
+          ) {
+            repairedContent.push({
+              type: "web_search_tool_result",
+              tool_use_id: block.id,
+              content: SYNTHETIC_WEB_SEARCH_ERROR,
+            });
+            stats.missingToolResultsInserted++;
+          }
+        }
+      } else {
+        repairedContent = cleanedContent;
+      }
+
+      result.push({ role: "assistant", content: repairedContent });
 
       // Only track client-side tool_use IDs as pending (not server_tool_use)
       pendingToolUseIds = new Set(

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

@@ -10,6 +10,7 @@
 import { v4 as uuid } from "uuid";
 
 import { escapeAxTreeContent } from "../agent/loop.js";
+import { loadConfig } from "../config/loader.js";
 import type { ContentBlock } from "../providers/types.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
@@ -23,7 +24,6 @@ const log = getLogger("host-cu-proxy");
 // ---------------------------------------------------------------------------
 
 const REQUEST_TIMEOUT_SEC = 60;
-const MAX_STEPS = 50;
 const MAX_HISTORY_ENTRIES = 10;
 const LOOP_DETECTION_WINDOW = 3;
 const CONSECUTIVE_UNCHANGED_WARNING_THRESHOLD = 2;
@@ -79,7 +79,7 @@ export class HostCuProxy {
   constructor(
     sendToClient: (msg: ServerMessage) => void,
     onInternalResolve?: (requestId: string) => void,
-    maxSteps = MAX_STEPS,
+    maxSteps = loadConfig().maxStepsPerSession,
   ) {
     this.sendToClient = sendToClient;
     this.onInternalResolve = onInternalResolve;

package/src/daemon/lifecycle.ts

@@ -142,7 +142,6 @@ export async function runDaemon(): Promise<void> {
     await initLogfire();
 
     ensureDataDir();
-    await runWorkspaceMigrations(getWorkspaceDir(), WORKSPACE_MIGRATIONS);
 
     // Load (or generate + persist) the auth signing key so tokens survive
     // daemon restarts. Must happen after ensureDataDir() creates the
@@ -150,14 +149,16 @@ export async function runDaemon(): Promise<void> {
     const signingKey = loadOrCreateSigningKey();
     initAuthSigningKey(signingKey);
 
-    log.info("Daemon startup: migrations complete");
-
     seedInterfaceFiles();
 
     log.info("Daemon startup: installing templates and initializing DB");
     installTemplates();
     ensurePromptFiles();
 
+    // DB must be initialized before workspace migrations because some
+    // workspace migrations (e.g. 009-backfill-conversation-disk-view)
+    // depend on DB migrations having run (e.g. the inline-attachment-to-disk
+    // backfill that populates attachment filePaths).
     initializeDb();
     // Seed well-known OAuth provider configurations (insert-if-not-exists)
     seedOAuthProviders();
@@ -174,6 +175,9 @@ export async function runDaemon(): Promise<void> {
     }
     log.info("Daemon startup: DB initialized");
 
+    await runWorkspaceMigrations(getWorkspaceDir(), WORKSPACE_MIGRATIONS);
+    log.info("Daemon startup: workspace migrations complete");
+
     // Purge private (temporary) conversations from the previous daemon run.
     // These are ephemeral by design and should not survive daemon restarts.
     const { count: purgedCount, deletedMemory } = purgePrivateConversations();
@@ -210,17 +214,21 @@ export async function runDaemon(): Promise<void> {
       }
     }
 
-    // Expire pending interaction-bound canonical guardian requests left over
-    // from before this process started.  Their in-memory pending-interaction
-    // session references are gone, so they can never be completed.  Only
-    // interaction-bound kinds (tool_approval, pending_question) are expired;
-    // persistent kinds (access_request, tool_grant_request) remain valid
-    // across restarts.
+    // Expire stale pending canonical guardian requests left over from before
+    // this process started.  Two categories are cleaned up:
+    //
+    // 1. Interaction-bound kinds (tool_approval, pending_question) — their
+    //    in-memory pending-interaction session references are gone, so they
+    //    can never be completed.
+    // 2. Any pending request whose expiresAt has already passed — persistent
+    //    kinds (access_request, tool_grant_request) that expired while the
+    //    daemon was stopped are transitioned so dedup logic doesn't return
+    //    stale rows.
     const expiredCount = expireAllPendingCanonicalRequests();
     if (expiredCount > 0) {
       log.info(
         { event: "startup_expired_stale_requests", expiredCount },
-        `Expired ${expiredCount} stale interaction-bound canonical request(s) from previous process`,
+        `Expired ${expiredCount} stale canonical request(s) from previous process`,
       );
     }
 
@@ -329,56 +337,74 @@ export async function runDaemon(): Promise<void> {
     await server.start();
     log.info("Daemon startup: DaemonServer started");
 
-    // Initialize Qdrant vector store — non-fatal so the daemon stays up without it
-    // Prefer QDRANT_HTTP_PORT (locally-spawned Qdrant on a specific port) over
-    // QDRANT_URL (external Qdrant instance) so the CLI can set the port without
-    // triggering QdrantManager's external mode which skips local process spawn.
-    const qdrantHttpPort = getQdrantHttpPortEnv();
-    const qdrantUrl = qdrantHttpPort
-      ? `http://127.0.0.1:${qdrantHttpPort}`
-      : getQdrantUrlEnv() || config.memory.qdrant.url;
-    log.info({ qdrantUrl }, "Daemon startup: initializing Qdrant");
-    const qdrantManager = new QdrantManager({ url: qdrantUrl });
-    try {
-      await qdrantManager.start();
-      const embeddingSelection = await selectEmbeddingBackend(config);
-      const embeddingModel = embeddingSelection.backend
-        ? `${embeddingSelection.backend.provider}:${embeddingSelection.backend.model}:sparse-v${SPARSE_EMBEDDING_VERSION}`
-        : 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,
-      });
+    // Mutable refs for Qdrant and memory 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 };
+
+    // Initialize Qdrant vector store and memory worker in the background so the
+    // RuntimeHttpServer can start accepting requests without waiting for Qdrant.
+    async function initializeQdrantAndMemory(): Promise<void> {
+      // Prefer QDRANT_HTTP_PORT (locally-spawned Qdrant on a specific port) over
+      // QDRANT_URL (external Qdrant instance) so the CLI can set the port without
+      // triggering QdrantManager's external mode which skips local process spawn.
+      const qdrantHttpPort = getQdrantHttpPortEnv();
+      const qdrantUrl = qdrantHttpPort
+        ? `http://127.0.0.1:${qdrantHttpPort}`
+        : getQdrantUrlEnv() || config.memory.qdrant.url;
+      log.info({ qdrantUrl }, "Daemon startup: initializing Qdrant");
+      const manager = new QdrantManager({ url: qdrantUrl });
+      bgRefs.qdrantManager = manager;
+      try {
+        await manager.start();
+        const embeddingSelection = await selectEmbeddingBackend(config);
+        const embeddingModel = embeddingSelection.backend
+          ? `${embeddingSelection.backend.provider}:${embeddingSelection.backend.model}:sparse-v${SPARSE_EMBEDDING_VERSION}`
+          : 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 failed to start — memory features will be unavailable",
+        );
       }
 
-      log.info("Qdrant vector store initialized");
-    } catch (err) {
-      log.warn(
-        { err },
-        "Qdrant failed to start — memory features will be unavailable",
+      log.info("Daemon startup: starting memory worker");
+      bgRefs.memoryWorker = startMemoryJobsWorker();
+
+      // Seed capability memories for first-party catalog skills so the memory
+      // pipeline can surface relevant skills via semantic search.
+      void seedCatalogSkillMemories().catch((err) =>
+        log.warn({ err }, "Catalog skill memory seeding failed — continuing"),
       );
     }
 
-    log.info("Daemon startup: starting memory worker");
-    const memoryWorker = startMemoryJobsWorker();
-
-    // Seed capability memories for first-party catalog skills so the memory
-    // pipeline can surface relevant skills via semantic search.
-    void seedCatalogSkillMemories().catch((err) =>
-      log.warn({ err }, "Catalog skill memory seeding failed — continuing"),
+    // Fire-and-forget: Qdrant init runs concurrently with the rest of startup
+    void initializeQdrantAndMemory().catch((err) =>
+      log.warn({ err }, "Background Qdrant init failed"),
     );
 
     registerWatcherProviders();
@@ -459,7 +485,7 @@ export async function runDaemon(): Promise<void> {
             title: notification.title,
             body: notification.body,
           },
-          dedupeKey: `watcher:notification:${Date.now()}`,
+          dedupeKey: `watcher:notification:${crypto.randomUUID()}`,
         });
       },
       (params) => {
@@ -477,7 +503,7 @@ export async function runDaemon(): Promise<void> {
             title: params.title,
             body: params.body,
           },
-          dedupeKey: `watcher:escalation:${Date.now()}`,
+          dedupeKey: `watcher:escalation:${crypto.randomUUID()}`,
         });
       },
       (info) => {
@@ -532,13 +558,22 @@ export async function runDaemon(): Promise<void> {
         getOrCreateConversation: (conversationId) =>
           server.getConversationForMessages(conversationId),
         assistantEventHub,
-        resolveAttachments: (attachmentIds) =>
-          attachmentsStore.getAttachmentsByIds(attachmentIds).map((a) => ({
+        resolveAttachments: (attachmentIds) => {
+          const resolved = attachmentsStore.getAttachmentsByIds(attachmentIds, {
+            hydrateFileData: true,
+          });
+          const sourcePaths =
+            attachmentsStore.getSourcePathsForAttachments(attachmentIds);
+          return resolved.map((a) => ({
             id: a.id,
             filename: a.originalFilename,
             mimeType: a.mimeType,
             data: a.dataBase64,
-          })),
+            ...(sourcePaths.has(a.id)
+              ? { filePath: sourcePaths.get(a.id) }
+              : {}),
+          }));
+        },
       },
       findConversation: (conversationId) =>
         server.findConversation(conversationId),
@@ -623,13 +658,20 @@ export async function runDaemon(): Promise<void> {
     setVoiceBridgeDeps({
       getOrCreateConversation: (conversationId, _transport) =>
         server.getConversationForMessages(conversationId),
-      resolveAttachments: (attachmentIds) =>
-        attachmentsStore.getAttachmentsByIds(attachmentIds).map((a) => ({
+      resolveAttachments: (attachmentIds) => {
+        const resolved = attachmentsStore.getAttachmentsByIds(attachmentIds, {
+          hydrateFileData: true,
+        });
+        const sourcePaths =
+          attachmentsStore.getSourcePathsForAttachments(attachmentIds);
+        return resolved.map((a) => ({
           id: a.id,
           filename: a.originalFilename,
           mimeType: a.mimeType,
           data: a.dataBase64,
-        })),
+          ...(sourcePaths.has(a.id) ? { filePath: sourcePaths.get(a.id) } : {}),
+        }));
+      },
       deriveDefaultStrictSideEffects: (conversationId) => {
         const conversationType = getConversationType(conversationId);
         return conversationType === "private";
@@ -881,8 +923,8 @@ export async function runDaemon(): Promise<void> {
       hookManager,
       runtimeHttp,
       scheduler,
-      memoryWorker,
-      qdrantManager,
+      getMemoryWorker: () => bgRefs.memoryWorker,
+      getQdrantManager: () => bgRefs.qdrantManager,
       mcpManager,
       telemetryReporter,
       cleanupPidFile,

package/src/daemon/message-protocol.ts

@@ -38,6 +38,7 @@ export * from "./message-types/skills.js";
 export * from "./message-types/subagents.js";
 export * from "./message-types/surfaces.js";
 export * from "./message-types/trust.js";
+export * from "./message-types/upgrades.js";
 export * from "./message-types/work-items.js";
 export * from "./message-types/workspace.js";
 
@@ -123,6 +124,7 @@ import type {
   _TrustClientMessages,
   _TrustServerMessages,
 } from "./message-types/trust.js";
+import type { _UpgradesServerMessages } from "./message-types/upgrades.js";
 import type {
   _WorkItemsClientMessages,
   _WorkItemsServerMessages,
@@ -194,6 +196,7 @@ export type ServerMessage =
   | _InboxServerMessages
   | _PairingServerMessages
   | _NotificationsServerMessages
+  | _UpgradesServerMessages
   | _AcpServerMessages
   | SubagentEvent;