@vellumai/assistant 0.3.5 → 0.3.7

package/src/daemon/ipc-protocol.ts

@@ -42,7 +42,7 @@ export function createMessageParser(options?: { maxLineSize?: number }) {
         try {
           const msg = JSON.parse(trimmed);
           const entry: ParsedMessage = { msg };
-          if (typeof msg === 'object' && msg !== null && msg.type === 'cu_observation') {
+          if (typeof msg === 'object' && msg != null && msg.type === 'cu_observation') {
             entry.rawByteLength = Buffer.byteLength(trimmed, 'utf8');
           }
           results.push(entry);

package/src/daemon/ipc-validate.ts

@@ -1,3 +1,4 @@
+import { isChannelId } from '../channels/types.js';
 import type { ClientMessage } from './ipc-contract.js';
 import inventory from './ipc-contract-inventory.json' with { type: 'json' };
 
@@ -82,6 +83,9 @@ const HIGH_RISK_VALIDATORS: Record<string, PropertyValidator> = {
     if (obj.activeSurfaceId !== undefined && typeof obj.activeSurfaceId !== 'string') {
       return 'user_message "activeSurfaceId" must be a string when present';
     }
+    if (obj.channel !== undefined && !isChannelId(obj.channel)) {
+      return 'user_message "channel" must be a valid channel ID when present';
+    }
     return null;
   },
 
@@ -100,6 +104,9 @@ const HIGH_RISK_VALIDATORS: Record<string, PropertyValidator> = {
       if (typeof transport.channelId !== 'string' || transport.channelId.trim().length === 0) {
         return 'session_create "transport.channelId" must be a non-empty string';
       }
+      if (!isChannelId(transport.channelId)) {
+        return 'session_create "transport.channelId" must be a valid channel ID';
+      }
       if (transport.uxBrief !== undefined && typeof transport.uxBrief !== 'string') {
         return 'session_create "transport.uxBrief" must be a string when present';
       }

package/src/daemon/lifecycle.ts

@@ -1,261 +1,64 @@
-import { spawn } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
-import { mkdirSync, readFileSync, writeFileSync, unlinkSync, existsSync, openSync, closeSync, chmodSync } from 'node:fs';
+import { mkdirSync, readFileSync, writeFileSync, existsSync, chmodSync } from 'node:fs';
 import { createRequire } from 'node:module';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, join } from 'node:path';
 import { config as dotenvConfig } from 'dotenv';
-import * as Sentry from '@sentry/node';
 import {
   getInterfacesDir,
   getSocketPath,
-  getPidPath,
   getHttpTokenPath,
   getRootDir,
   ensureDataDir,
-  migrateToDataLayout,
-  migrateToWorkspaceLayout,
-  removeSocketFile,
 } from '../util/platform.js';
+import { migrateToDataLayout } from '../migrations/data-layout.js';
+import { migrateToWorkspaceLayout } from '../migrations/workspace-layout.js';
 import { initializeDb } from '../memory/db.js';
 import { rotateToolInvocations } from '../memory/tool-usage-store.js';
-import { initializeProviders } from '../providers/registry.js';
-import { initializeTools } from '../tools/registry.js';
 import { loadConfig } from '../config/loader.js';
+import {
+  getQdrantUrlEnv,
+  getRuntimeHttpPort,
+  getRuntimeProxyBearerToken,
+  getRuntimeHttpHost,
+  validateEnv,
+} from '../config/env.js';
 import { ensurePromptFiles } from '../config/system-prompt.js';
 import { loadPrebuiltHtml } from '../home-base/prebuilt/seed.js';
 import { DaemonServer } from './server.js';
+import { setRelayBroadcast } from '../calls/relay-server.js';
 import { listWorkItems, updateWorkItem } from '../work-items/work-item-store.js';
 import { getLogger, initLogger } from '../util/logger.js';
-import { DaemonError } from '../util/errors.js';
 import { initSentry } from '../instrument.js';
 import { initLogfire } from '../logfire.js';
 import { startMemoryJobsWorker } from '../memory/jobs-worker.js';
 import { QdrantManager } from '../memory/qdrant-manager.js';
 import { initQdrantClient } from '../memory/qdrant-client.js';
 import { startScheduler } from '../schedule/scheduler.js';
-import { initWatcherEngine } from '../watcher/engine.js';
-import { registerWatcherProvider } from '../watcher/provider-registry.js';
-import { gmailProvider } from '../watcher/providers/gmail.js';
-import { googleCalendarProvider } from '../watcher/providers/google-calendar.js';
-import { slackProvider as slackWatcherProvider } from '../watcher/providers/slack.js';
-import { registerMessagingProvider } from '../messaging/registry.js';
-import { slackProvider as slackMessagingProvider } from '../messaging/providers/slack/adapter.js';
-import { gmailMessagingProvider } from '../messaging/providers/gmail/adapter.js';
-import { telegramBotMessagingProvider } from '../messaging/providers/telegram-bot/adapter.js';
-import { smsMessagingProvider } from '../messaging/providers/sms/adapter.js';
-import { browserManager } from '../tools/browser/browser-manager.js';
 import { RuntimeHttpServer } from '../runtime/http-server.js';
 import { getHookManager } from '../hooks/manager.js';
 import { installTemplates } from '../hooks/templates.js';
+import { installCliLaunchers } from './install-cli-launchers.js';
 import { HeartbeatService } from '../workspace/heartbeat-service.js';
 import { AgentHeartbeatService } from '../agent-heartbeat/agent-heartbeat-service.js';
-import { getEnrichmentService } from '../workspace/commit-message-enrichment-service.js';
 import { reconcileCallsOnStartup } from '../calls/call-recovery.js';
 import { TwilioConversationRelayProvider } from '../calls/twilio-provider.js';
+import { createApprovalCopyGenerator, createApprovalConversationGenerator } from './approval-generators.js';
+import { initializeProvidersAndTools, registerWatcherProviders, registerMessagingProviders } from './providers-setup.js';
+import { installShutdownHandlers } from './shutdown-handlers.js';
+import { writePid, cleanupPidFile } from './daemon-control.js';
+
+// Re-export public API so existing consumers don't need to change imports
+export {
+  isDaemonRunning,
+  getDaemonStatus,
+  startDaemon,
+  stopDaemon,
+  ensureDaemonRunning,
+} from './daemon-control.js';
+export type { StopResult } from './daemon-control.js';
 
 const log = getLogger('lifecycle');
 
-function isProcessRunning(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function readPid(): number | null {
-  const pidPath = getPidPath();
-  if (!existsSync(pidPath)) return null;
-  try {
-    const pid = parseInt(readFileSync(pidPath, 'utf-8').trim(), 10);
-    return isNaN(pid) ? null : pid;
-  } catch {
-    return null;
-  }
-}
-
-function writePid(pid: number): void {
-  writeFileSync(getPidPath(), String(pid));
-}
-
-function cleanupPidFile(): void {
-  const pidPath = getPidPath();
-  if (existsSync(pidPath)) {
-    unlinkSync(pidPath);
-  }
-}
-
-export function isDaemonRunning(): boolean {
-  const pid = readPid();
-  if (pid === null) return false;
-  if (!isProcessRunning(pid)) {
-    // Stale PID file
-    cleanupPidFile();
-    return false;
-  }
-  return true;
-}
-
-export function getDaemonStatus(): { running: boolean; pid?: number } {
-  const pid = readPid();
-  if (pid === null) return { running: false };
-  if (!isProcessRunning(pid)) {
-    cleanupPidFile();
-    return { running: false };
-  }
-  return { running: true, pid };
-}
-
-export async function startDaemon(): Promise<{
-  pid: number;
-  alreadyRunning: boolean;
-}> {
-  const status = getDaemonStatus();
-  if (status.running && status.pid) {
-    return { pid: status.pid, alreadyRunning: true };
-  }
-
-  // Only create the root dir for socket/PID — the daemon process itself
-  // handles migration + full ensureDataDir() in runDaemon(). Calling
-  // ensureDataDir() here would pre-create workspace destination dirs
-  // and cause migration moves to no-op.
-  const rootDir = getRootDir();
-  if (!existsSync(rootDir)) {
-    mkdirSync(rootDir, { recursive: true });
-  }
-
-  // Clean up stale socket (only if it's actually a Unix socket)
-  const socketPath = getSocketPath();
-  removeSocketFile(socketPath);
-
-  // Spawn the daemon as a detached child process
-  const mainPath = resolve(
-    import.meta.dirname ?? __dirname,
-    'main.ts',
-  );
-
-  // Redirect the child's stderr to a file instead of piping it back to the
-  // parent. A pipe's read end is destroyed when the parent exits, leaving
-  // fd 2 broken in the child. Bun (unlike Node.js) does not ignore SIGPIPE,
-  // so any later stderr write would silently kill the daemon.
-  const stderrPath = join(rootDir, 'daemon-stderr.log');
-  const stderrFd = openSync(stderrPath, 'w');
-
-  const child = spawn('bun', ['run', mainPath], {
-    detached: true,
-    stdio: ['ignore', 'ignore', stderrFd],
-    env: { ...process.env },
-  });
-
-  // The child inherited the fd; close the parent's copy.
-  closeSync(stderrFd);
-
-  let childExited = false;
-  let childExitCode: number | null = null;
-  child.on('exit', (code) => {
-    childExited = true;
-    childExitCode = code;
-  });
-
-  child.unref();
-
-  const pid = child.pid;
-  if (!pid) {
-    throw new DaemonError('Failed to start daemon: no PID returned');
-  }
-
-  writePid(pid);
-
-  // Wait for socket to appear
-  const maxWait = 5000;
-  const interval = 100;
-  let waited = 0;
-  while (waited < maxWait) {
-    if (existsSync(socketPath)) {
-      return { pid, alreadyRunning: false };
-    }
-    if (childExited) {
-      cleanupPidFile();
-      const stderr = readFileSync(stderrPath, 'utf-8').trim();
-      const detail = stderr
-        ? `\n${stderr}`
-        : `\nCheck logs at ~/.vellum/workspace/data/logs/ for details.`;
-      throw new DaemonError(
-        `Daemon exited immediately (code ${childExitCode ?? 'unknown'}).${detail}`,
-      );
-    }
-    await new Promise((r) => setTimeout(r, interval));
-    waited += interval;
-  }
-
-  throw new DaemonError(
-    'Daemon started but socket not available after 5 seconds',
-  );
-}
-
-export type StopResult =
-  | { stopped: true }
-  | { stopped: false; reason: 'not_running' | 'stop_failed' };
-
-export async function stopDaemon(): Promise<StopResult> {
-  const pid = readPid();
-  if (pid === null || !isProcessRunning(pid)) {
-    cleanupPidFile();
-    return { stopped: false, reason: 'not_running' };
-  }
-
-  process.kill(pid, 'SIGTERM');
-
-  // Wait for process to exit
-  const maxWait = 5000;
-  const interval = 100;
-  let waited = 0;
-  while (waited < maxWait) {
-    if (!isProcessRunning(pid)) {
-      cleanupPidFile();
-      return { stopped: true };
-    }
-    await new Promise((r) => setTimeout(r, interval));
-    waited += interval;
-  }
-
-  // Force kill
-  try {
-    process.kill(pid, 'SIGKILL');
-  } catch (err) {
-    log.debug({ err, pid }, 'SIGKILL failed, process already exited');
-  }
-
-  // Wait for the process to actually die after SIGKILL. Without this,
-  // startDaemon() can race with the dying process's shutdown handler,
-  // which removes the socket file and bricks the new daemon.
-  const killMaxWait = 2000;
-  let killWaited = 0;
-  while (killWaited < killMaxWait && isProcessRunning(pid)) {
-    await new Promise((r) => setTimeout(r, 100));
-    killWaited += 100;
-  }
-
-  // Only clean up if the process has actually exited.
-  // If it's still alive after SIGKILL + timeout, preserve both socket
-  // and PID file so isDaemonRunning() still reports true and prevents
-  // a duplicate daemon from being spawned.
-  if (!isProcessRunning(pid)) {
-    removeSocketFile(getSocketPath());
-    cleanupPidFile();
-    return { stopped: true };
-  }
-
-  log.warn({ pid }, 'Daemon process still running after SIGKILL + timeout, leaving socket and PID file intact');
-  return { stopped: false, reason: 'stop_failed' };
-}
-
-export async function ensureDaemonRunning(): Promise<void> {
-  if (isDaemonRunning()) return;
-  await startDaemon();
-}
-
 function loadDotEnv(): void {
   dotenvConfig({ path: join(getRootDir(), '.env'), quiet: true });
 }
@@ -263,6 +66,7 @@ function loadDotEnv(): void {
 // Entry point for the daemon process itself
 export async function runDaemon(): Promise<void> {
   loadDotEnv();
+  validateEnv();
   initSentry();
   await initLogfire();
 
@@ -312,6 +116,12 @@ export async function runDaemon(): Promise<void> {
   log.info('Daemon startup: installing templates and initializing DB');
   installTemplates();
   ensurePromptFiles();
+
+  try {
+    installCliLaunchers();
+  } catch (err) {
+    log.warn({ err }, 'CLI launcher installation failed — continuing startup');
+  }
   initializeDb();
   log.info('Daemon startup: DB initialized');
 
@@ -326,8 +136,6 @@ export async function runDaemon(): Promise<void> {
     log.info({ count: orphanedRunning.length }, 'Recovered orphaned running work items');
   }
 
-  // Reconcile in-flight calls that were left in non-terminal states
-  // after a daemon crash or restart.
   try {
     const twilioProvider = new TwilioConversationRelayProvider();
     await reconcileCallsOnStartup(twilioProvider, log);
@@ -342,10 +150,7 @@ export async function runDaemon(): Promise<void> {
     initLogger({ dir: config.logFile.dir, retentionDays: config.logFile.retentionDays });
   }
 
-  log.info('Daemon startup: initializing providers and tools');
-  initializeProviders(config);
-  await initializeTools();
-  log.info('Daemon startup: providers and tools initialized');
+  await initializeProvidersAndTools(config);
 
   // Start the IPC socket BEFORE Qdrant so that clients can connect
   // immediately. Qdrant startup can take 30+ seconds (binary download,
@@ -356,11 +161,9 @@ export async function runDaemon(): Promise<void> {
   log.info('Daemon startup: DaemonServer started');
 
   // Initialize Qdrant vector store — non-fatal so the daemon stays up without it
-  const qdrantUrl = process.env.QDRANT_URL?.trim() || config.memory.qdrant.url;
+  const qdrantUrl = getQdrantUrlEnv() || config.memory.qdrant.url;
   log.info({ qdrantUrl }, 'Daemon startup: initializing Qdrant');
-  const qdrantManager = new QdrantManager({
-    url: qdrantUrl,
-  });
+  const qdrantManager = new QdrantManager({ url: qdrantUrl });
   try {
     await qdrantManager.start();
     initQdrantClient({
@@ -377,17 +180,9 @@ export async function runDaemon(): Promise<void> {
 
   log.info('Daemon startup: starting memory worker');
   const memoryWorker = startMemoryJobsWorker();
-  // Initialize watcher engine and register providers
-  registerWatcherProvider(gmailProvider);
-  registerWatcherProvider(googleCalendarProvider);
-  registerWatcherProvider(slackWatcherProvider);
-  initWatcherEngine();
 
-  // Register messaging providers
-  registerMessagingProvider(slackMessagingProvider);
-  registerMessagingProvider(gmailMessagingProvider);
-  registerMessagingProvider(telegramBotMessagingProvider);
-  registerMessagingProvider(smsMessagingProvider);
+  registerWatcherProviders();
+  registerMessagingProviders();
 
   const scheduler = startScheduler(
     async (conversationId, message) => {
@@ -424,57 +219,57 @@ export async function runDaemon(): Promise<void> {
     },
   );
 
-  // Start optional runtime HTTP server when RUNTIME_HTTP_PORT is set
+  // Start the runtime HTTP server. Required for iOS pairing (gateway proxies
+  // to it) and optional REST API access. Defaults to port 7821.
   let runtimeHttp: RuntimeHttpServer | null = null;
-  const httpPortEnv = process.env.RUNTIME_HTTP_PORT;
-  log.info({ httpPortEnv }, 'Daemon startup: checking RUNTIME_HTTP_PORT');
-  if (httpPortEnv) {
-    const port = parseInt(httpPortEnv, 10);
-    if (!isNaN(port) && port > 0) {
-      // Resolve the bearer token in priority order:
-      //   1. Explicit env var (e.g. cloud deploys)
-      //   2. Existing token file on disk (preserves QR-paired iOS devices across restarts)
-      //   3. Fresh random token (first-time startup)
-      const httpTokenPath = getHttpTokenPath();
-      let bearerToken = process.env.RUNTIME_PROXY_BEARER_TOKEN;
-      if (!bearerToken) {
-        try {
-          const existing = readFileSync(httpTokenPath, 'utf-8').trim();
-          if (existing) bearerToken = existing;
-        } catch {
-          // File doesn't exist or can't be read — will generate below
-        }
-      }
-      if (!bearerToken) {
-        bearerToken = randomBytes(32).toString('hex');
-      }
-      writeFileSync(httpTokenPath, bearerToken, { mode: 0o600 });
-      chmodSync(httpTokenPath, 0o600);
-
-      const hostname = process.env.RUNTIME_HTTP_HOST?.trim() || '127.0.0.1';
-
-      runtimeHttp = new RuntimeHttpServer({
-        port,
-        hostname,
-        bearerToken,
-        processMessage: (conversationId, content, attachmentIds, options, sourceChannel) =>
-          server.processMessage(conversationId, content, attachmentIds, options, sourceChannel),
-        persistAndProcessMessage: (conversationId, content, attachmentIds, options, sourceChannel) =>
-          server.persistAndProcessMessage(conversationId, content, attachmentIds, options, sourceChannel),
-        runOrchestrator: server.createRunOrchestrator(),
-        interfacesDir: getInterfacesDir(),
-      });
-      try {
-        log.info({ port, hostname }, 'Daemon startup: starting runtime HTTP server');
-        await runtimeHttp.start();
-        server.setHttpPort(port);
-        log.info({ port, hostname }, 'Daemon startup: runtime HTTP server listening');
-      } catch (err) {
-        log.warn({ err, port }, 'Failed to start runtime HTTP server, continuing without it');
-        runtimeHttp = null;
-      }
+  const httpPort = getRuntimeHttpPort();
+  log.info({ httpPort }, 'Daemon startup: starting runtime HTTP server');
+
+  // Resolve the bearer token in priority order:
+  //   1. Explicit env var (e.g. cloud deploys)
+  //   2. Existing token file on disk (preserves QR-paired iOS devices across restarts)
+  //   3. Fresh random token (first-time startup)
+  const httpTokenPath = getHttpTokenPath();
+  let bearerToken = getRuntimeProxyBearerToken();
+  if (!bearerToken) {
+    try {
+      const existing = readFileSync(httpTokenPath, 'utf-8').trim();
+      if (existing) bearerToken = existing;
+    } catch {
+      // File doesn't exist or can't be read — will generate below
     }
   }
+  if (!bearerToken) {
+    bearerToken = randomBytes(32).toString('hex');
+  }
+  writeFileSync(httpTokenPath, bearerToken, { mode: 0o600 });
+  chmodSync(httpTokenPath, 0o600);
+
+  const hostname = getRuntimeHttpHost();
+
+  runtimeHttp = new RuntimeHttpServer({
+    port: httpPort,
+    hostname,
+    bearerToken,
+    processMessage: (conversationId, content, attachmentIds, options, sourceChannel) =>
+      server.processMessage(conversationId, content, attachmentIds, options, sourceChannel),
+    persistAndProcessMessage: (conversationId, content, attachmentIds, options, sourceChannel) =>
+      server.persistAndProcessMessage(conversationId, content, attachmentIds, options, sourceChannel),
+    runOrchestrator: server.createRunOrchestrator(),
+    interfacesDir: getInterfacesDir(),
+    approvalCopyGenerator: createApprovalCopyGenerator(),
+    approvalConversationGenerator: createApprovalConversationGenerator(),
+  });
+  try {
+    await runtimeHttp.start();
+    setRelayBroadcast((msg) => server.broadcast(msg));
+    runtimeHttp.setPairingBroadcast((msg) => server.broadcast(msg));
+    server.setHttpPort(httpPort);
+    log.info({ port: httpPort, hostname }, 'Daemon startup: runtime HTTP server listening');
+  } catch (err) {
+    log.warn({ err, port: httpPort }, 'Failed to start runtime HTTP server, continuing without it');
+    runtimeHttp = null;
+  }
 
   writePid(process.pid);
   log.info({ pid: process.pid }, 'Daemon started');
@@ -487,9 +282,6 @@ export async function runDaemon(): Promise<void> {
     socketPath: getSocketPath(),
   });
 
-  // Rotate old audit log entries after startup handshake is complete.
-  // This runs after the socket is listening so it won't block the 5s
-  // readiness window in startDaemon().
   if (config.auditLog.retentionDays > 0) {
     try {
       rotateToolInvocations(config.auditLog.retentionDays);
@@ -498,15 +290,9 @@ export async function runDaemon(): Promise<void> {
     }
   }
 
-  // Start workspace heartbeat service. This periodically checks all
-  // tracked workspaces for uncommitted changes and auto-commits when
-  // thresholds are exceeded (age > 5 min OR > 20 files changed).
-  // Acts as a safety net for long-running operations or background
-  // processes that modify workspace files between turn-boundary commits.
   const heartbeat = new HeartbeatService();
   heartbeat.start();
 
-  // Start model-driven heartbeat service (opt-in via config).
   const agentHeartbeat = new AgentHeartbeatService({
     processMessage: (conversationId, content) =>
       server.processMessage(conversationId, content),
@@ -514,83 +300,15 @@ export async function runDaemon(): Promise<void> {
   });
   agentHeartbeat.start();
 
-  // Graceful shutdown
-  let shuttingDown = false;
-  const shutdown = async () => {
-    if (shuttingDown) return; // Prevent re-entrant shutdown
-    shuttingDown = true;
-    log.info('Shutting down daemon...');
-
-    hookManager.stopWatching();
-
-    // Force exit if graceful shutdown takes too long.
-    // Set this BEFORE awaiting heartbeat stop and triggering daemon-stop hooks
-    // so it covers all potentially-blocking async shutdown work.
-    const forceTimer = setTimeout(() => {
-      log.warn('Graceful shutdown timed out, forcing exit');
-      cleanupPidFile();
-      process.exit(1);
-    }, 10_000);
-    forceTimer.unref();
-
-    await heartbeat.stop();
-    await agentHeartbeat.stop();
-
-    try {
-      await hookManager.trigger('daemon-stop', { pid: process.pid });
-    } catch {
-      // Don't let hook failures block shutdown
-    }
-
-    // Commit any uncommitted workspace changes before stopping the server.
-    // This ensures no workspace state is lost during graceful shutdown.
-    try {
-      log.info({ phase: 'pre_stop' }, 'Committing pending workspace changes');
-      await heartbeat.commitAllPending();
-    } catch (err) {
-      log.warn({ err, phase: 'pre_stop' }, 'Shutdown workspace commit failed');
-    }
-
-    await server.stop();
-
-    // Final commit sweep: catch any writes that occurred during server.stop()
-    // (e.g. in-flight tool executions completing during drain).
-    try {
-      log.info({ phase: 'post_stop' }, 'Final workspace commit sweep');
-      await heartbeat.commitAllPending();
-    } catch (err) {
-      log.warn({ err, phase: 'post_stop' }, 'Post-stop workspace commit failed');
-    }
-
-    // Flush in-flight enrichment jobs so shutdown commit notes are not dropped.
-    // The enrichment service's shutdown() drains active jobs and discards pending ones.
-    try {
-      await getEnrichmentService().shutdown();
-    } catch (err) {
-      log.warn({ err }, 'Enrichment service shutdown failed (non-fatal)');
-    }
-
-    if (runtimeHttp) await runtimeHttp.stop();
-    await browserManager.closeAllPages();
-    scheduler.stop();
-    memoryWorker.stop();
-    await qdrantManager.stop();
-    await Sentry.flush(2000);
-    clearTimeout(forceTimer);
-    cleanupPidFile();
-    process.exit(0);
-  };
-
-  process.on('SIGTERM', shutdown);
-  process.on('SIGINT', shutdown);
-
-  process.on('unhandledRejection', (reason) => {
-    log.error({ err: reason }, 'Unhandled promise rejection');
-    Sentry.captureException(reason);
-  });
-
-  process.on('uncaughtException', (err) => {
-    log.error({ err }, 'Uncaught exception');
-    Sentry.captureException(err);
+  installShutdownHandlers({
+    server,
+    heartbeat,
+    agentHeartbeat,
+    hookManager,
+    runtimeHttp,
+    scheduler,
+    memoryWorker,
+    qdrantManager,
+    cleanupPidFile,
   });
 }