@vellumai/assistant 0.7.1 → 0.7.3

package/src/daemon/lifecycle.ts

@@ -2,8 +2,6 @@ import { join } from "node:path";
 
 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";
@@ -25,10 +23,6 @@ import type { AssistantConfig } from "../config/schema.js";
 import { seedInferenceProfiles } from "../config/seed-inference-profiles.js";
 import type { CesClient } from "../credential-execution/client.js";
 import { createCesClient } from "../credential-execution/client.js";
-import {
-  isCesCredentialBackendEnabled,
-  isCesToolsEnabled,
-} from "../credential-execution/feature-gates.js";
 import {
   type CesProcessManager,
   CesUnavailableError,
@@ -54,16 +48,12 @@ import {
 import { expireAllPendingCanonicalRequests } from "../memory/canonical-guardian-store.js";
 import { deleteMessageById, getMessages } from "../memory/conversation-crud.js";
 import { initializeDb } from "../memory/db-init.js";
-import {
-  selectEmbeddingBackend,
-  SPARSE_EMBEDDING_VERSION,
-} from "../memory/embedding-backend.js";
+import { selectEmbeddingBackend } from "../memory/embedding-backend.js";
 import { enqueueMemoryJob } from "../memory/jobs-store.js";
 import { startMemoryJobsWorker } from "../memory/jobs-worker.js";
 import { initQdrantClient, resolveQdrantUrl } from "../memory/qdrant-client.js";
 import { QdrantManager } from "../memory/qdrant-manager.js";
 import { rotateToolInvocations } from "../memory/tool-usage-store.js";
-import { deleteOldTraceEvents } from "../memory/trace-event-store.js";
 import {
   emitNotificationSignal,
   registerBroadcastFn,
@@ -71,6 +61,7 @@ import {
 import { backfillManualTokenConnections } from "../oauth/manual-token-connection.js";
 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 { resolveManagedProxyContext } from "../providers/managed-proxy/context.js";
 import { broadcastMessage } from "../runtime/assistant-event-hub.js";
@@ -81,6 +72,7 @@ import {
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 import { recoverInterruptedImport } from "../runtime/migrations/vbundle-streaming-importer.js";
 import { registerSecretsDeps } from "../runtime/routes/secrets-deps.js";
+import { recoverStaleSchedules } from "../schedule/schedule-recovery.js";
 import { startScheduler } from "../schedule/scheduler.js";
 import {
   onCesClientChanged,
@@ -113,6 +105,11 @@ import {
   cleanupPidFileIfOwner,
   writePid,
 } from "./daemon-control.js";
+import {
+  evaluateDiskPressureNow,
+  startDiskPressureGuard,
+  stopDiskPressureGuard,
+} from "./disk-pressure-guard.js";
 import { bootstrapPlugins } from "./external-plugins-bootstrap.js";
 import {
   createGuardianActionCopyGenerator,
@@ -133,11 +130,57 @@ import { DaemonServer } from "./server.js";
 import { installShutdownHandlers } from "./shutdown-handlers.js";
 
 const log = getLogger("lifecycle");
+let diskPressureStartupSampleTimer: ReturnType<typeof setTimeout> | null = null;
 
 function loadDotEnv(): void {
   dotenvConfig({ path: getDotEnvPath(), quiet: true });
 }
 
+function runDeferredDiskPressureStartupSample(): void {
+  diskPressureStartupSampleTimer = null;
+  try {
+    const status = evaluateDiskPressureNow();
+    if (status.error) {
+      log.warn(
+        { error: status.error },
+        "Disk pressure guard sample failed during startup — continuing unlocked",
+      );
+    }
+  } catch (err) {
+    log.warn(
+      { err },
+      "Disk pressure guard failed during startup — continuing unlocked",
+    );
+  }
+}
+
+export function startDiskPressureGuardForLifecycle(): void {
+  try {
+    const startedStatus = startDiskPressureGuard();
+    if (!startedStatus.enabled) return;
+    if (!diskPressureStartupSampleTimer) {
+      diskPressureStartupSampleTimer = setTimeout(
+        runDeferredDiskPressureStartupSample,
+        0,
+      );
+      (diskPressureStartupSampleTimer as { unref?: () => void }).unref?.();
+    }
+  } catch (err) {
+    log.warn(
+      { err },
+      "Disk pressure guard failed during startup — continuing unlocked",
+    );
+  }
+}
+
+export function stopDiskPressureGuardForLifecycle(): void {
+  if (diskPressureStartupSampleTimer) {
+    clearTimeout(diskPressureStartupSampleTimer);
+    diskPressureStartupSampleTimer = null;
+  }
+  stopDiskPressureGuard();
+}
+
 export interface CesStartupResult {
   client: CesClient | undefined;
   processManager: CesProcessManager | undefined;
@@ -157,17 +200,6 @@ export interface CesStartupResult {
 async function startCesProcess(
   config: AssistantConfig,
 ): Promise<CesStartupResult> {
-  const shouldStartCes =
-    isCesToolsEnabled(config) || isCesCredentialBackendEnabled(config);
-  if (!shouldStartCes) {
-    return {
-      client: undefined,
-      processManager: undefined,
-      clientPromise: undefined,
-      abortController: undefined,
-    };
-  }
-
   const pm = createCesProcessManager({ assistantConfig: config });
   const abortController = new AbortController();
   let clientRef: CesClient | undefined;
@@ -291,9 +323,16 @@ export async function runDaemon(): Promise<void> {
     // 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"),
-    );
+    //
+    // 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"));
 
     seedInterfaceFiles();
 
@@ -460,12 +499,22 @@ export async function runDaemon(): Promise<void> {
       }
     } // end if (dbReady)
 
-    // Seed managed inference profiles into the workspace config. Runs
-    // after workspace migrations (which may have created the initial
-    // profile slots) and before mergeDefaultWorkspaceConfig / loadConfig
-    // so the profiles are on disk for the first config load.
+    // Merge CLI-provided default config (from VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH)
+    // into the workspace config file before profile seeding and the first
+    // loadConfig() call so onboarding/platform preferences are visible to the
+    // 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.
     try {
-      seedInferenceProfiles();
+      seedInferenceProfiles({
+        preserveProfileNames: defaultConfigMerge.providedLlmProfileNames,
+        preserveActiveProfile: defaultConfigMerge.providedLlmActiveProfile,
+      });
       log.info("Inference profile seeding complete");
     } catch (err) {
       log.warn(
@@ -474,11 +523,6 @@ export async function runDaemon(): Promise<void> {
       );
     }
 
-    // Merge CLI-provided default config (from VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH)
-    // into the workspace config file before the first loadConfig() call so
-    // onboarding preferences are persisted alongside schema defaults.
-    mergeDefaultWorkspaceConfig();
-
     log.info("Daemon startup: loading config");
     const config = loadConfig();
 
@@ -524,89 +568,81 @@ export async function runDaemon(): Promise<void> {
     // bootstrap connection, so startup must happen at the process level.
     const cesStartupPromise = startCesProcess(config);
 
-    // When the credential backend flag is enabled, CES startup must complete
-    // BEFORE provider initialization so credential reads can go through CES.
-    // Block with a 20-second timeout — fall back to direct credential store
-    // on timeout.
-    if (isCesCredentialBackendEnabled(config)) {
-      const cesResult = await cesStartupPromise;
-      // startCesProcess() returns immediately — the actual handshake runs
-      // inside clientPromise. Await it (with a 20s timeout) so the CES client
-      // is available before provider initialization.
-      if (cesResult.clientPromise) {
-        const client = await awaitCesClientWithTimeout(
-          cesResult.clientPromise,
-          {
-            timeoutMs: DEFAULT_CES_STARTUP_TIMEOUT_MS,
-            onTimeout: () => {
-              log.warn(
-                "CES handshake timed out after 20s — falling back to direct credential store",
-              );
-            },
-          },
-        );
-        if (client) {
-          setCesClient(client);
-        }
+    // CES startup must complete BEFORE provider initialization so credential
+    // reads can go through CES. Block with a 20-second timeout — fall back to
+    // direct credential store on timeout.
+    const cesResult = await cesStartupPromise;
+    // startCesProcess() returns immediately — the actual handshake runs
+    // inside clientPromise. Await it (with a 20s timeout) so the CES client
+    // is available before provider initialization.
+    if (cesResult.clientPromise) {
+      const client = await awaitCesClientWithTimeout(cesResult.clientPromise, {
+        timeoutMs: DEFAULT_CES_STARTUP_TIMEOUT_MS,
+        onTimeout: () => {
+          log.warn(
+            "CES handshake timed out after 20s — falling back to direct credential store",
+          );
+        },
+      });
+      if (client) {
+        setCesClient(client);
       }
+    }
 
-      // Register CES reconnection callback so the credential layer can
-      // re-establish the connection when the transport dies, instead of
-      // 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 { accepted, reason } = await newClient.handshake({
-              ...(startupProxyCtx.assistantApiKey
-                ? { assistantApiKey: startupProxyCtx.assistantApiKey }
-                : {}),
-              ...(startupAssistantId
-                ? { assistantId: startupAssistantId }
-                : {}),
-            });
-            if (accepted) {
-              log.info("CES reconnection handshake accepted");
-              return newClient;
-            }
-            log.warn({ reason }, "CES reconnection handshake rejected");
-            newClient.close();
-            await pm.stop().catch(() => {});
-            return undefined;
-          } catch (err) {
-            log.warn(
-              { error: err instanceof Error ? err.message : String(err) },
-              "CES reconnection attempt failed",
-            );
-            await pm.stop().catch(() => {});
-            return undefined;
+    // Register CES reconnection callback so the credential layer can
+    // re-establish the connection when the transport dies, instead of
+    // 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 { accepted, reason } = await newClient.handshake({
+            ...(startupProxyCtx.assistantApiKey
+              ? { assistantApiKey: startupProxyCtx.assistantApiKey }
+              : {}),
+            ...(startupAssistantId ? { assistantId: startupAssistantId } : {}),
+          });
+          if (accepted) {
+            log.info("CES reconnection handshake accepted");
+            return newClient;
           }
-        });
-      }
+          log.warn({ reason }, "CES reconnection handshake rejected");
+          newClient.close();
+          await pm.stop().catch(() => {});
+          return undefined;
+        } catch (err) {
+          log.warn(
+            { error: err instanceof Error ? err.message : String(err) },
+            "CES reconnection attempt failed",
+          );
+          await pm.stop().catch(() => {});
+          return undefined;
+        }
+      });
     }
 
-    // Populate the registry with user plugins from `~/.vellum/plugins/*`
+    // Populate the registry with user plugins from `<workspaceDir>/plugins/*`
     // AFTER first-party plugins have already registered via their static
     // side-effect imports. User plugins may fail to load individually; a
     // failing user plugin is logged and skipped so one bad install can't
@@ -645,6 +681,7 @@ export async function runDaemon(): Promise<void> {
 
     await server.start();
     log.info("Daemon startup: DaemonServer started");
+    startDiskPressureGuardForLifecycle();
 
     // Kick off the update bulletin background job AFTER `server.start()`
     // resolves. The conversation store must be initialized before wake
@@ -660,13 +697,12 @@ export async function runDaemon(): Promise<void> {
         );
     }
 
-    // Mutable refs for Qdrant, memory worker, and backup worker so background
+    // 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;
-      backupWorker: BackupWorkerHandle | null;
-    } = { qdrantManager: null, memoryWorker: null, backupWorker: 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.
@@ -707,8 +743,11 @@ 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}:sparse-v${SPARSE_EMBEDDING_VERSION}`
+            ? `${embeddingSelection.backend.provider}:${embeddingSelection.backend.model}`
             : undefined;
           const qdrantClient = initQdrantClient({
             url: qdrantUrl,
@@ -760,21 +799,32 @@ export async function runDaemon(): Promise<void> {
             );
           }
         })();
+
+        // Build the BM25 corpus stats (per-token document frequencies and
+        // average document length) used by the v2 sparse channel. Without
+        // this, document-side sparse embeddings fall back to legacy TF-only
+        // weighting via the chicken-and-egg guard in
+        // `embed-concept-page.ts`. Fire-and-forget for the same reason as
+        // PKB reconcile — the stats are an optional optimization, never a
+        // boot-blocking dependency.
+        void (async () => {
+          try {
+            const { rebuildConceptPageCorpusStats } =
+              await import("../memory/v2/sparse-bm25.js");
+            await rebuildConceptPageCorpusStats(getWorkspaceDir());
+            log.info("Memory v2 BM25 corpus stats built");
+          } catch (err) {
+            log.warn(
+              { err },
+              "BM25 corpus-stats rebuild failed — sparse channel will fall back to TF-only until next rebuild",
+            );
+          }
+        })();
       }
 
       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 {
@@ -818,6 +868,12 @@ export async function runDaemon(): Promise<void> {
     // macOS adapter so it can deliver notification_intent messages to clients.
     registerBroadcastFn((msg) => broadcastMessage(msg));
 
+    try {
+      recoverStaleSchedules();
+    } catch (err) {
+      log.error({ err }, "Schedule recovery failed — continuing startup");
+    }
+
     const scheduler = startScheduler(
       async (conversationId, message, options) => {
         await processMessage(
@@ -1199,22 +1255,6 @@ export async function runDaemon(): Promise<void> {
       }
     }
 
-    // Prune trace events older than 7 days to keep the database lean.
-    // Deferred so synchronous cleanup doesn't block the startup path.
-    setTimeout(() => {
-      try {
-        const deletedTraceEvents = deleteOldTraceEvents(7);
-        if (deletedTraceEvents > 0) {
-          log.debug(
-            { deletedTraceEvents },
-            `Pruned ${deletedTraceEvents} trace event(s) older than 7 days`,
-          );
-        }
-      } catch (err) {
-        log.warn({ err }, "Trace event cleanup failed");
-      }
-    }, 0);
-
     const workspaceHeartbeat = new WorkspaceHeartbeatService();
     workspaceHeartbeat.start();
 
@@ -1237,6 +1277,12 @@ export async function runDaemon(): Promise<void> {
       "Heartbeat service configured",
     );
 
+    try {
+      backfillGuardIfNeeded();
+    } catch (err) {
+      log.warn({ err }, "Proactive artifact backfill failed");
+    }
+
     // Filing yields to the memory v2 consolidation job when the flag is on —
     // both serve the same role (periodic background memory processing) and
     // running both is redundant. The consolidation job runs through the
@@ -1279,14 +1325,17 @@ export async function runDaemon(): Promise<void> {
       scheduler,
       feedScheduler,
       getMemoryWorker: () => bgRefs.memoryWorker,
-      getBackupWorker: () => bgRefs.backupWorker,
       getQdrantManager: () => bgRefs.qdrantManager,
       mcpManager,
       telemetryReporter,
-      cleanupPidFile,
+      cleanupPidFile: () => {
+        stopDiskPressureGuardForLifecycle();
+        cleanupPidFile();
+      },
     });
   } catch (err) {
     log.error({ err }, "Daemon startup failed — cleaning up");
+    stopDiskPressureGuardForLifecycle();
     cleanupPidFileIfOwner(process.pid);
     throw err;
   }

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

@@ -72,7 +72,7 @@ import { getLogger } from "../util/logger.js";
  * keeps the supervisor free of path assumptions and simplifies
  * tests.
  */
-export interface MeetHostManifest {
+interface MeetHostManifest {
   /** SHA-256 of the shipped skill source tree. */
   sourceHash: string;
 }
@@ -84,7 +84,7 @@ export interface MeetHostManifest {
  * protocol version) can be threaded through later without a
  * signature break.
  */
-export interface MeetHostHandshakePayload {
+interface MeetHostHandshakePayload {
   sourceHash: string;
 }
 
@@ -97,7 +97,7 @@ export interface MeetHostHandshakePayload {
  * supervisor unaware of the rest of the IPC server's surface and avoids a
  * circular import in tests that already stub `skill-server.js`.
  */
-export interface SkillRequestSender {
+interface SkillRequestSender {
   sendRequest(
     connection: SkillIpcConnection,
     method: string,
@@ -111,7 +111,7 @@ export interface SkillRequestSender {
  * child. All are optional on construction — production callers
  * rely on the defaults and tests override one or two at a time.
  */
-export interface MeetHostSupervisorDeps {
+interface MeetHostSupervisorDeps {
   /** Absolute path to the shipped `meet-join` skill dir, containing `register.ts`. */
   skillRuntimePath: string;
   /** Absolute path to a standalone bun binary, or `"bun"` for PATH lookup. */

package/src/daemon/meet-manifest-loader.ts

@@ -109,7 +109,6 @@ const SERIALIZABLE_TOOL_CONTEXT_KEYS = [
   "callSessionId",
   "principal",
   "toolUseId",
-  "memoryScopeId",
   "requesterExternalUserId",
   "requesterChatId",
   "requesterIdentifier",

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

@@ -13,10 +13,12 @@ import { getLogger } from "../util/logger.js";
 const log = getLogger("memory-v2-startup");
 
 /**
- * Fire-and-forget seed of the v2 parallel skill embedding 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.
+ * 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`
@@ -32,4 +34,12 @@ export function maybeSeedMemoryV2Skills(config: AssistantConfig): void {
   void import("../memory/v2/skill-store.js")
     .then(({ seedV2SkillEntries }) => seedV2SkillEntries())
     .catch((err) => log.warn({ err }, "Failed to seed v2 skill entries"));
+  void import("../memory/v2/qdrant.js")
+    .then(({ dropLegacySkillsCollection }) => dropLegacySkillsCollection())
+    .catch((err) =>
+      log.warn(
+        { err },
+        "Failed to drop legacy memory_v2_skills collection — non-fatal",
+      ),
+    );
 }

package/src/daemon/message-protocol.ts

@@ -20,9 +20,11 @@ export * from "./message-types/computer-use.js";
 export * from "./message-types/contacts.js";
 export * from "./message-types/conversations.js";
 export * from "./message-types/diagnostics.js";
+export * from "./message-types/disk-pressure.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-app-control.js";
 export * from "./message-types/host-bash.js";
 export * from "./message-types/host-browser.js";
 export * from "./message-types/host-cu.js";
@@ -34,7 +36,6 @@ export * from "./message-types/meet.js";
 export * from "./message-types/memory.js";
 export * from "./message-types/messages.js";
 export * from "./message-types/notifications.js";
-export * from "./message-types/pairing.js";
 export * from "./message-types/schedules.js";
 export * from "./message-types/settings.js";
 export * from "./message-types/shared.js";
@@ -71,6 +72,7 @@ import type {
   _DiagnosticsClientMessages,
   _DiagnosticsServerMessages,
 } from "./message-types/diagnostics.js";
+import type { _DiskPressureServerMessages } from "./message-types/disk-pressure.js";
 import type {
   _DocumentsClientMessages,
   _DocumentsServerMessages,
@@ -80,6 +82,7 @@ import type {
   _GuardianActionsServerMessages,
 } from "./message-types/guardian-actions.js";
 import type { _HomeServerMessages } from "./message-types/home.js";
+import type { _HostAppControlServerMessages } from "./message-types/host-app-control.js";
 import type { _HostBashServerMessages } from "./message-types/host-bash.js";
 import type {
   _HostBrowserClientMessages,
@@ -106,10 +109,6 @@ import type {
   _NotificationsClientMessages,
   _NotificationsServerMessages,
 } from "./message-types/notifications.js";
-import type {
-  _PairingClientMessages,
-  _PairingServerMessages,
-} from "./message-types/pairing.js";
 import type {
   _SchedulesClientMessages,
   _SchedulesServerMessages,
@@ -170,7 +169,6 @@ export type ClientMessage =
   | _SchedulesClientMessages
   | _DiagnosticsClientMessages
   | _InboxClientMessages
-  | _PairingClientMessages
   | _NotificationsClientMessages
   | _SettingsClientMessages;
 
@@ -191,6 +189,7 @@ export type ServerMessage =
   | _DocumentsServerMessages
   | _GuardianActionsServerMessages
   | _HomeServerMessages
+  | _HostAppControlServerMessages
   | _HostBashServerMessages
   | _HostBrowserServerMessages
   | _HostCuServerMessages
@@ -203,10 +202,10 @@ export type ServerMessage =
   | _SettingsServerMessages
   | _DiagnosticsServerMessages
   | _InboxServerMessages
-  | _PairingServerMessages
   | _NotificationsServerMessages
   | _UpgradesServerMessages
   | _AcpServerMessages
+  | _DiskPressureServerMessages
   | SubagentEvent;
 
 // === Contract schema ===
@@ -215,4 +214,3 @@ export interface ContractSchema {
   client: ClientMessage;
   server: ServerMessage;
 }
-