@vellumai/assistant 0.6.5 → 0.7.0

package/src/daemon/lifecycle.ts

@@ -12,8 +12,6 @@ import { setVoiceBridgeDeps } from "../calls/voice-session-bridge.js";
 import { initFeatureFlagOverrides } from "../config/assistant-feature-flags.js";
 import {
   getPlatformAssistantId,
-  getQdrantHttpPortEnv,
-  getQdrantUrlEnv,
   getRuntimeHttpHost,
   getRuntimeHttpPort,
   setIngressPublicBaseUrl,
@@ -43,27 +41,22 @@ import {
   startFeedScheduler,
 } from "../home/feed-scheduler.js";
 import { backfillRelationshipStateIfMissing } from "../home/relationship-state-writer.js";
-import { getHookManager } from "../hooks/manager.js";
-import { installTemplates } from "../hooks/templates.js";
 import { closeSentry, initSentry, setSentryDeviceId } from "../instrument.js";
 import { getMcpServerManager } from "../mcp/manager.js";
-import * as attachmentsStore from "../memory/attachments-store.js";
-import { expireAllPendingCanonicalRequests } from "../memory/canonical-guardian-store.js";
 import {
-  deleteMessageById,
-  getConversationType,
-  getMessages,
-  purgePrivateConversations,
-} from "../memory/conversation-crud.js";
-import { resolveConversationId } from "../memory/conversation-key-store.js";
-import { initializeDb } from "../memory/db.js";
+  getAttachmentsByIds,
+  getSourcePathsForAttachments,
+} from "../memory/attachments-store.js";
+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 { enqueueMemoryJob } from "../memory/jobs-store.js";
 import { startMemoryJobsWorker } from "../memory/jobs-worker.js";
-import { initQdrantClient } from "../memory/qdrant-client.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";
@@ -73,24 +66,16 @@ import {
 } from "../notifications/emit-signal.js";
 import { backfillManualTokenConnections } from "../oauth/manual-token-connection.js";
 import { seedOAuthProviders } from "../oauth/seed-providers.js";
+import { loadUserPlugins } from "../plugins/user-loader.js";
 import { ensurePromptFiles } from "../prompts/system-prompt.js";
 import { resolveManagedProxyContext } from "../providers/managed-proxy/context.js";
-import { buildAssistantEvent } from "../runtime/assistant-event.js";
-import { assistantEventHub } from "../runtime/assistant-event-hub.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import {
   initAuthSigningKey,
-  mintPairingBearerToken,
   resolveSigningKey,
 } from "../runtime/auth/token-service.js";
-import {
-  initCapabilityTokenSecret,
-  loadOrCreateCapabilityTokenSecret,
-  writeDaemonTokenFallback,
-} from "../runtime/capability-tokens.js";
-import { ensureVellumGuardianBinding } from "../runtime/guardian-vellum-migration.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 import { recoverInterruptedImport } from "../runtime/migrations/vbundle-streaming-importer.js";
+import { registerSecretsDeps } from "../runtime/routes/secrets-deps.js";
 import { startScheduler } from "../schedule/scheduler.js";
 import {
   onCesClientChanged,
@@ -104,9 +89,9 @@ import { getLogger, initLogger } from "../util/logger.js";
 import {
   ensureDataDir,
   getDotEnvPath,
-  getInterfacesDir,
   getWorkspaceDir,
 } from "../util/platform.js";
+import { APP_VERSION } from "../version.js";
 import {
   listWorkItems,
   updateWorkItem,
@@ -118,27 +103,20 @@ import {
   createApprovalConversationGenerator,
   createApprovalCopyGenerator,
 } from "./approval-generators.js";
-import { initSlashPairingContext } from "./conversation-slash.js";
 import {
   cleanupPidFile,
   cleanupPidFileIfOwner,
   writePid,
 } from "./daemon-control.js";
+import { bootstrapPlugins } from "./external-plugins-bootstrap.js";
 import {
   createGuardianActionCopyGenerator,
   createGuardianFollowUpConversationGenerator,
 } from "./guardian-action-generators.js";
 import { backfillSlackInjectionTemplates } from "./handlers/config-slack-channel.js";
-import {
-  cancelGeneration,
-  clearAllConversations,
-  regenerateResponse,
-  renameConversation,
-  switchConversation,
-  undoLastMessage,
-} from "./handlers/conversations.js";
 import { installAssistantSymlink } from "./install-symlink.js";
-import type { ServerMessage } from "./message-protocol.js";
+import { maybeSeedMemoryV2Skills } from "./memory-v2-startup.js";
+import { processMessage } from "./process-message.js";
 import { runProfilerSweep } from "./profiler-run-store.js";
 import {
   initializeProvidersAndTools,
@@ -148,18 +126,6 @@ import {
 import { seedInterfaceFiles } from "./seed-files.js";
 import { DaemonServer } from "./server.js";
 import { installShutdownHandlers } from "./shutdown-handlers.js";
-import { handleWatchObservation } from "./watch-handler.js";
-
-// Re-export public API so existing consumers don't need to change imports
-export type { StopResult } from "./daemon-control.js";
-export {
-  cleanupPidFile,
-  ensureDaemonRunning,
-  getDaemonStatus,
-  isDaemonRunning,
-  startDaemon,
-  stopDaemon,
-} from "./daemon-control.js";
 
 const log = getLogger("lifecycle");
 
@@ -183,7 +149,7 @@ export interface CesStartupResult {
  * The managed sidecar accepts exactly one bootstrap connection, so this must
  * be called at the process level (not per-conversation).
  */
-export async function startCesProcess(
+async function startCesProcess(
   config: AssistantConfig,
 ): Promise<CesStartupResult> {
   const shouldStartCes =
@@ -315,21 +281,7 @@ export async function runDaemon(): Promise<void> {
     const signingKey = resolveSigningKey();
     initAuthSigningKey(signingKey);
 
-    // Load (or generate + persist) the capability-token HMAC secret used
-    // to mint scoped tokens for the chrome extension pair endpoint.
-    // Wrapped in try/catch so a disk failure here never blocks startup —
-    // tokens can still be minted using a lazy on-demand load inside the
-    // capability-tokens module.
-    try {
-      initCapabilityTokenSecret(loadOrCreateCapabilityTokenSecret());
-    } catch (err) {
-      log.warn(
-        { err },
-        "Failed to pre-load capability token secret — continuing startup (lazy load will handle subsequent calls)",
-      );
-    }
-
-    // Pre-populate the feature flag cache from the gateway so all
+    // 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
@@ -340,8 +292,7 @@ export async function runDaemon(): Promise<void> {
 
     seedInterfaceFiles();
 
-    log.info("Daemon startup: installing templates and initializing DB");
-    installTemplates();
+    log.info("Daemon startup: initializing DB");
     ensurePromptFiles();
 
     // DB must be initialized before workspace migrations because some
@@ -458,42 +409,6 @@ export async function runDaemon(): Promise<void> {
       // to read the device ID and set the Sentry tag.
       setSentryDeviceId(getDeviceId());
 
-      // 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();
-      if (purgedCount > 0) {
-        log.info(
-          { purgedCount },
-          `Purged ${purgedCount} private conversation(s) from previous daemon run`,
-        );
-        // Qdrant may not be ready at startup, so enqueue vector cleanup jobs
-        // rather than attempting direct deletion.
-        for (const segId of deletedMemory.segmentIds) {
-          enqueueMemoryJob("delete_qdrant_vectors", {
-            targetType: "segment",
-            targetId: segId,
-          });
-        }
-        for (const summaryId of deletedMemory.deletedSummaryIds) {
-          enqueueMemoryJob("delete_qdrant_vectors", {
-            targetType: "summary",
-            targetId: summaryId,
-          });
-        }
-        if (
-          deletedMemory.segmentIds.length > 0 ||
-          deletedMemory.deletedSummaryIds.length > 0
-        ) {
-          log.info(
-            {
-              segments: deletedMemory.segmentIds.length,
-              deletedSummaries: deletedMemory.deletedSummaryIds.length,
-            },
-            "Enqueued Qdrant vector cleanup jobs for purged private conversations",
-          );
-        }
-      }
-
       // Expire stale pending canonical guardian requests left over from before
       // this process started.  Two categories are cleaned up:
       //
@@ -512,33 +427,6 @@ export async function runDaemon(): Promise<void> {
         );
       }
 
-      // Ensure a vellum guardian binding exists so the identity system works
-      // without requiring a manual bootstrap step.
-      let localGuardianPrincipalId = "local";
-      try {
-        localGuardianPrincipalId = ensureVellumGuardianBinding(
-          DAEMON_INTERNAL_ASSISTANT_ID,
-        );
-      } catch (err) {
-        log.warn(
-          { err },
-          "Vellum guardian binding backfill failed — continuing startup",
-        );
-      }
-
-      // Write a dev-only fallback capability token to the per-instance
-      // protected directory so developers can manually pair the chrome
-      // extension without the native messaging helper. Production pairing
-      // goes through `POST /v1/browser-extension-pair` via the native helper.
-      try {
-        writeDaemonTokenFallback(localGuardianPrincipalId);
-      } catch (err) {
-        log.warn(
-          { err },
-          "Failed to write dev daemon-token fallback — continuing startup",
-        );
-      }
-
       // Recover orphaned work items that were left in 'running' state when the
       // daemon previously crashed or was killed mid-task.
       const orphanedRunning = listWorkItems({ status: "running" });
@@ -699,6 +587,33 @@ export async function runDaemon(): Promise<void> {
       }
     }
 
+    // Populate the registry with user plugins from `~/.vellum/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
+    // prevent the daemon from starting. Ordering is load-bearing:
+    //   first-party registrations → user registrations → bootstrap (init).
+    // Both groups are fully registered before any `init()` runs so plugins
+    // that depend on each other's registration observably see a stable
+    // registry at init time.
+    await loadUserPlugins();
+
+    // Bootstrap registered plugins. Runs after the plugin registry is
+    // populated (first-party static side-effect imports + user plugins
+    // loaded above) and before the DaemonServer starts handling
+    // conversations. Credential resolution + per-plugin storage directory
+    // creation happen here. Wrapped in try/catch so a failing plugin can't
+    // block daemon startup — bootstrapPlugins internally tears down any
+    // partially-initialized plugins before throwing.
+    try {
+      await bootstrapPlugins({ config, assistantVersion: APP_VERSION });
+    } catch (err) {
+      log.warn(
+        { err },
+        "Plugin bootstrap failed — continuing startup with degraded plugin functionality",
+      );
+    }
+
     // Start the DaemonServer (conversation manager) before Qdrant so HTTP
     // routes can begin accepting requests while Qdrant initializes.
     log.info("Daemon startup: starting DaemonServer");
@@ -713,12 +628,8 @@ export async function runDaemon(): Promise<void> {
     log.info("Daemon startup: DaemonServer started");
 
     // Kick off the update bulletin background job AFTER `server.start()`
-    // resolves. `server.start()` installs the default wake resolver (via
-    // `registerDefaultWakeResolver()`), which the job depends on to actually
-    // invoke the agent. Dispatching before that point races the resolver
-    // registration and causes `wakeAgentForOpportunity()` to silently return
-    // `{invoked: false}`, leaving an orphan background conversation and a
-    // wasted LLM title-generation call every startup.
+    // resolves. The conversation store must be initialized before wake
+    // calls can resolve targets.
     //
     // Kept fire-and-forget (`void import(...).then(...).catch(...)`) so the
     // daemon never blocks startup on it.
@@ -741,13 +652,7 @@ export async function runDaemon(): Promise<void> {
     // 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;
+      const qdrantUrl = resolveQdrantUrl(config);
       log.info({ qdrantUrl }, "Daemon startup: initializing Qdrant");
       const manager = new QdrantManager({ url: qdrantUrl });
       bgRefs.qdrantManager = manager;
@@ -859,6 +764,7 @@ export async function runDaemon(): Promise<void> {
           seedUninstalledCatalogSkillMemories,
         } = await import("../memory/graph/capability-seed.js");
         seedSkillGraphNodes();
+        maybeSeedMemoryV2Skills(config);
         await seedCliGraphNodes();
         void seedUninstalledCatalogSkillMemories().catch((err) =>
           log.warn(
@@ -895,7 +801,7 @@ export async function runDaemon(): Promise<void> {
 
     const scheduler = startScheduler(
       async (conversationId, message, options) => {
-        await server.processMessage(
+        await processMessage(
           conversationId,
           message,
           undefined,
@@ -941,29 +847,6 @@ export async function runDaemon(): Promise<void> {
           throwOnError: true,
         });
       },
-      (schedule) => {
-        void emitNotificationSignal({
-          sourceEventName: "schedule.complete",
-          sourceChannel: "scheduler",
-          sourceContextId: schedule.id,
-          attentionHints: {
-            requiresAction: false,
-            urgency: "medium",
-            isAsyncBackground: true,
-            visibleInSourceNow: false,
-          },
-          contextPayload: {
-            scheduleId: schedule.id,
-            name: schedule.name,
-          },
-          conversationMetadata: {
-            groupId: "system:scheduled",
-            scheduleJobId: schedule.id,
-            source: "schedule",
-          },
-          dedupeKey: `schedule:complete:${schedule.id}:${Date.now()}`,
-        });
-      },
       (notification) => {
         void emitNotificationSignal({
           sourceEventName: "watcher.notification",
@@ -1023,145 +906,28 @@ export async function runDaemon(): Promise<void> {
       );
     }
 
-    // Start the runtime HTTP server. Required for iOS pairing (gateway proxies
-    // to it) and optional REST API access. Defaults to port 7821.
+    // Start the runtime HTTP server for optional REST API access.
+    // Defaults to port 7821.
     let runtimeHttp: RuntimeHttpServer | null = null;
     const httpPort = getRuntimeHttpPort();
     log.info({ httpPort }, "Daemon startup: starting runtime HTTP server");
 
     const hostname = getRuntimeHttpHost();
 
-    // Mint a JWT bearer token for the pairing flow. The pairing handler
-    // and HTTP auto-approve logic both guard on a non-empty bearer token.
-    const pairingBearerToken = mintPairingBearerToken();
-
     runtimeHttp = new RuntimeHttpServer({
       port: httpPort,
       hostname,
-      bearerToken: pairingBearerToken,
-      processMessage: (
-        conversationId,
-        content,
-        attachmentIds,
-        options,
-        sourceChannel,
-        sourceInterface,
-      ) =>
-        server.processMessage(
-          conversationId,
-          content,
-          attachmentIds,
-          options,
-          sourceChannel,
-          sourceInterface,
-        ),
-      interfacesDir: getInterfacesDir(),
       approvalCopyGenerator: createApprovalCopyGenerator(),
       approvalConversationGenerator: createApprovalConversationGenerator(),
       guardianActionCopyGenerator: createGuardianActionCopyGenerator(),
       guardianFollowUpConversationGenerator:
         createGuardianFollowUpConversationGenerator(),
-      sendMessageDeps: {
-        getOrCreateConversation: (conversationId, options) =>
-          server.getConversationForMessages(conversationId, options),
-        assistantEventHub,
-        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),
-      findConversationBySurfaceId: (surfaceId) =>
-        server.findConversationBySurfaceId(surfaceId),
-      getSkillContext: () => server.getSkillContext(),
-      getModelSetContext: () => server.getHandlerContext(),
-      conversationManagementDeps: {
-        switchConversation: (conversationId) =>
-          switchConversation(conversationId, server.getHandlerContext()),
-        renameConversation: (conversationId, name) =>
-          renameConversation(conversationId, name),
-        clearAllConversations: () =>
-          clearAllConversations(server.getHandlerContext()),
-        cancelGeneration: (conversationId) =>
-          cancelGeneration(conversationId, server.getHandlerContext()),
-        destroyConversation: (conversationId) =>
-          server.destroyConversation(conversationId),
-        undoLastMessage: (conversationId) =>
-          undoLastMessage(conversationId, server.getHandlerContext()),
-        regenerateResponse: (conversationId) => {
-          // Resolve conversation key up front so SSE events are tagged with
-          // the internal conversation ID, not the raw client key.
-          const resolvedId =
-            resolveConversationId(conversationId) ?? conversationId;
-          let hubChain: Promise<void> = Promise.resolve();
-          const sendEvent = (event: ServerMessage) => {
-            const ae = buildAssistantEvent(
-              DAEMON_INTERNAL_ASSISTANT_ID,
-              event,
-              resolvedId,
-            );
-            hubChain = (async () => {
-              await hubChain;
-              try {
-                await assistantEventHub.publish(ae);
-              } catch (err) {
-                log.warn(
-                  { err },
-                  "assistant-events hub subscriber threw during regenerate",
-                );
-              }
-            })();
-          };
-          return regenerateResponse(
-            conversationId,
-            server.getHandlerContext(),
-            sendEvent,
-          );
-        },
-      },
-      getWatchDeps: () => {
-        const ctx = server.getHandlerContext();
-        return {
-          handleWatchObservation: async (params) => {
-            await handleWatchObservation(
-              {
-                type: "watch_observation",
-                watchId: params.watchId,
-                conversationId: params.conversationId,
-                ocrText: params.ocrText,
-                appName: params.appName,
-                windowTitle: params.windowTitle,
-                bundleIdentifier: params.bundleIdentifier,
-                timestamp: params.timestamp,
-                captureIndex: params.captureIndex,
-                totalExpected: params.totalExpected,
-              },
-              ctx,
-            );
-          },
-        };
-      },
-      getRecordingDeps: () => ({
-        getHandlerContext: () => server.getHandlerContext(),
-      }),
+    });
+
+    registerSecretsDeps({
       getCesClient: () => server.getCesClient(),
       onProviderCredentialsChanged: () =>
         server.refreshConversationsForProviderChange(),
-      getHeartbeatService: () => server.getHeartbeatService(),
-      getFilingService: () => server.getFilingService(),
     });
 
     // Fire-and-forget: Qdrant init and memory worker startup run concurrently
@@ -1180,11 +946,10 @@ export async function runDaemon(): Promise<void> {
       getOrCreateConversation: (conversationId, _transport) =>
         server.getConversationForMessages(conversationId),
       resolveAttachments: (attachmentIds) => {
-        const resolved = attachmentsStore.getAttachmentsByIds(attachmentIds, {
+        const resolved = getAttachmentsByIds(attachmentIds, {
           hydrateFileData: true,
         });
-        const sourcePaths =
-          attachmentsStore.getSourcePathsForAttachments(attachmentIds);
+        const sourcePaths = getSourcePathsForAttachments(attachmentIds);
         return resolved.map((a) => ({
           id: a.id,
           filename: a.originalFilename,
@@ -1193,10 +958,6 @@ export async function runDaemon(): Promise<void> {
           ...(sourcePaths.has(a.id) ? { filePath: sourcePaths.get(a.id) } : {}),
         }));
       },
-      deriveDefaultStrictSideEffects: (conversationId) => {
-        const conversationType = getConversationType(conversationId);
-        return conversationType === "private";
-      },
     });
     try {
       await runtimeHttp.start();
@@ -1336,10 +1097,6 @@ export async function runDaemon(): Promise<void> {
           }
         },
       );
-      runtimeHttp.setPairingBroadcast((msg) =>
-        server.broadcast(msg as ServerMessage),
-      );
-      initSlashPairingContext(runtimeHttp.getPairingStore());
       server.broadcastStatus();
       log.info(
         { port: httpPort, hostname },
@@ -1390,13 +1147,6 @@ export async function runDaemon(): Promise<void> {
       log.warn({ err }, "Assistant symlink installation failed — continuing");
     }
 
-    const hookManager = getHookManager();
-    hookManager.watch();
-
-    void hookManager.trigger("daemon-start", {
-      pid: process.pid,
-    });
-
     // Download embedding runtime in background (non-blocking).
     // If download fails, local embeddings gracefully fall back to cloud backends.
     void (async () => {
@@ -1451,14 +1201,6 @@ export async function runDaemon(): Promise<void> {
 
     const heartbeatConfig = config.heartbeat;
     const heartbeat = new HeartbeatService({
-      processMessage: (conversationId, content, options) =>
-        server.processMessage(conversationId, content, undefined, {
-          trustContext: {
-            sourceChannel: "vellum",
-            trustClass: "guardian",
-          },
-          ...options,
-        }),
       alerter: (alert) => server.broadcast(alert),
       onConversationCreated: (info) =>
         server.broadcast({
@@ -1468,7 +1210,6 @@ export async function runDaemon(): Promise<void> {
         }),
     });
     heartbeat.start();
-    server.setHeartbeatService(heartbeat);
     log.info(
       {
         enabled: heartbeatConfig.enabled,
@@ -1478,18 +1219,8 @@ export async function runDaemon(): Promise<void> {
     );
 
     const filingConfig = config.filing;
-    const filing = new FilingService({
-      processMessage: (conversationId, content, options) =>
-        server.processMessage(conversationId, content, undefined, {
-          trustContext: {
-            sourceChannel: "vellum",
-            trustClass: "guardian",
-          },
-          ...options,
-        }),
-    });
+    const filing = new FilingService();
     filing.start();
-    server.setFilingService(filing);
     log.info(
       {
         enabled: filingConfig.enabled,
@@ -1510,7 +1241,6 @@ export async function runDaemon(): Promise<void> {
       workspaceHeartbeat,
       heartbeat,
       filing,
-      hookManager,
       runtimeHttp,
       scheduler,
       feedScheduler,

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

@@ -0,0 +1,51 @@
+/**
+ * Meet-host startup.
+ *
+ * Loads the meet-join skill via its lazy-external path: read the shipped
+ * manifest from disk, install proxy tools/routes/shutdown-hooks into the
+ * daemon's registries, and stand up a `MeetHostSupervisor` that spawns
+ * the meet-host child process on first invocation.
+ *
+ * The daemon does not import any code from `skills/` here. The skill runs
+ * as a separate `bun run` subprocess and communicates with the daemon
+ * over the skill IPC socket. The proxy tools/routes the daemon installs
+ * dispatch to that subprocess via bidirectional RPC.
+ */
+
+import { setMeetHostSupervisorForSessionReports } from "../ipc/skill-routes/registries.js";
+import { getRepoSkillsDir } from "../skills/catalog-install.js";
+import { getLogger } from "../util/logger.js";
+import { getBundledBunPath, getSkillRuntimePath } from "../util/platform.js";
+import { MeetHostSupervisor } from "./meet-host-supervisor.js";
+import {
+  loadMeetManifestFromDisk,
+  loadMeetManifestProxies,
+  resolveMeetManifestPath,
+} from "./meet-manifest-loader.js";
+
+const log = getLogger("meet-host-startup");
+
+export async function startMeetHost(): Promise<void> {
+  const skillsRoot = getRepoSkillsDir();
+  const skillRuntime = getSkillRuntimePath("meet-join", skillsRoot);
+  const manifestPath = resolveMeetManifestPath();
+  if (!skillRuntime || !manifestPath) {
+    throw new Error(
+      "meet-host startup requires a shipped meet-join skill runtime. " +
+        "Rebuild/repackage so first-party skills ship with the daemon.",
+    );
+  }
+  const manifest = loadMeetManifestFromDisk(manifestPath);
+  const bunBinary = getBundledBunPath() ?? "bun";
+  const supervisor = new MeetHostSupervisor({
+    skillRuntimePath: skillRuntime,
+    bunBinaryPath: bunBinary,
+    manifest: { sourceHash: manifest.sourceHash },
+  });
+  setMeetHostSupervisorForSessionReports(supervisor);
+  await loadMeetManifestProxies(supervisor, { manifestPath });
+  log.info(
+    { skillRuntime, manifestPath },
+    "meet-join registered via meet-host startup",
+  );
+}