orbital-command 0.2.0 → 1.0.0

package/server/index.ts

@@ -4,91 +4,61 @@ import { Server } from 'socket.io';
 import path from 'path';
 import fs from 'fs';
 import { fileURLToPath } from 'url';
-import { getDatabase, closeDatabase } from './database.js';
-import { getConfig, resetConfig } from './config.js';
-import { ScopeCache } from './services/scope-cache.js';
-import { ScopeService } from './services/scope-service.js';
-import { EventService } from './services/event-service.js';
-import { GateService } from './services/gate-service.js';
-import { DeployService } from './services/deploy-service.js';
-import { SprintService } from './services/sprint-service.js';
-import { SprintOrchestrator } from './services/sprint-orchestrator.js';
-import { BatchOrchestrator } from './services/batch-orchestrator.js';
-import { ReadinessService } from './services/readiness-service.js';
-import { startScopeWatcher } from './watchers/scope-watcher.js';
-import { startEventWatcher } from './watchers/event-watcher.js';
-import { ensureDynamicProfiles } from './utils/terminal-launcher.js';
-import { syncClaudeSessionsToDB } from './services/claude-session-service.js';
-import { resolveStaleDispatches, resolveActiveDispatchesForScope, resolveDispatchesByPid, resolveDispatchesByDispatchId, linkPidToDispatch } from './utils/dispatch-utils.js';
-import { createScopeRoutes } from './routes/scope-routes.js';
-import { createDataRoutes } from './routes/data-routes.js';
-import { createDispatchRoutes } from './routes/dispatch-routes.js';
-import { createSprintRoutes } from './routes/sprint-routes.js';
-import { createWorkflowRoutes } from './routes/workflow-routes.js';
-import { createConfigRoutes } from './routes/config-routes.js';
-import { createGitRoutes } from './routes/git-routes.js';
 import { createVersionRoutes } from './routes/version-routes.js';
-import { WorkflowService } from './services/workflow-service.js';
-import { GitService } from './services/git-service.js';
-import { GitHubService } from './services/github-service.js';
-import { WorkflowEngine } from '../shared/workflow-engine.js';
-import defaultWorkflow from '../shared/default-workflow.json' with { type: 'json' };
-import type { WorkflowConfig } from '../shared/workflow-config.js';
+import { createAggregateRoutes } from './routes/aggregate-routes.js';
 import { createLogger, setLogLevel } from './utils/logger.js';
 import type { LogLevel } from './utils/logger.js';
 
 import type http from 'http';
-import type Database from 'better-sqlite3';
 
-// ─── Types ──────────────────────────────────────────────────
-
-export interface ServerOverrides {
+// ─── Central Server ─────────────────────────────────────────
+
+import { ProjectManager } from './project-manager.js';
+import { SyncService } from './services/sync-service.js';
+import { startGlobalWatcher } from './watchers/global-watcher.js';
+import { createSyncRoutes } from './routes/sync-routes.js';
+import { seedGlobalPrimitives } from './init.js';
+import {
+  ensureOrbitalHome,
+  loadGlobalConfig,
+  registerProject as registerProjectGlobal,
+  GLOBAL_PRIMITIVES_DIR,
+  ORBITAL_HOME,
+} from './global-config.js';
+
+export interface CentralServerOverrides {
   port?: number;
-  projectRoot?: string;
+  clientPort?: number;
+  /** If set, auto-register this project on first launch */
+  autoRegisterPath?: string;
 }
 
-export interface ServerInstance {
+export interface CentralServerInstance {
   app: express.Application;
   io: Server;
-  db: Database.Database;
-  workflowEngine: WorkflowEngine;
+  projectManager: ProjectManager;
+  syncService: SyncService;
   httpServer: http.Server;
   shutdown: () => Promise<void>;
 }
 
-// ─── Server Factory ─────────────────────────────────────────
-
-export async function startServer(overrides?: ServerOverrides): Promise<ServerInstance> {
-  // Apply project root override before config loads
-  if (overrides?.projectRoot) {
-    process.env.ORBITAL_PROJECT_ROOT = overrides.projectRoot;
-    resetConfig();
-  }
+export async function startCentralServer(overrides?: CentralServerOverrides): Promise<CentralServerInstance> {
+  ensureOrbitalHome();
 
-  const config = getConfig();
   const envLevel = process.env.ORBITAL_LOG_LEVEL;
   if (envLevel && ['debug', 'info', 'warn', 'error'].includes(envLevel)) {
     setLogLevel(envLevel as LogLevel);
-  } else {
-    setLogLevel(config.logLevel);
   }
-  const log = createLogger('server');
-  const port = overrides?.port ?? config.serverPort;
-
-  const workflowEngine = new WorkflowEngine(defaultWorkflow as WorkflowConfig);
-
-  // Generate shell manifest for bash hooks (config-driven lifecycle)
-  const MANIFEST_PATH = path.join(config.configDir, 'workflow-manifest.sh');
-  if (!fs.existsSync(config.configDir)) fs.mkdirSync(config.configDir, { recursive: true });
-  fs.writeFileSync(MANIFEST_PATH, workflowEngine.generateShellManifest(), 'utf-8');
-
-  const ICEBOX_DIR = path.join(config.scopesDir, 'icebox');
-  // Resolve path to the bundled default workflow config.
-  const __selfDir2 = path.dirname(fileURLToPath(import.meta.url));
-  const DEFAULT_CONFIG_PATH = path.resolve(__selfDir2, '../shared/default-workflow.json');
-
-  // Ensure icebox directory exists for idea files
-  if (!fs.existsSync(ICEBOX_DIR)) fs.mkdirSync(ICEBOX_DIR, { recursive: true });
+  const log = createLogger('central');
+  const port = overrides?.port ?? (Number(process.env.ORBITAL_SERVER_PORT) || 4444);
+  const clientPort = overrides?.clientPort ?? (Number(process.env.ORBITAL_CLIENT_PORT) || 4445);
+
+  // Auto-register current project if registry is empty
+  const globalConfig = loadGlobalConfig();
+  if (globalConfig.projects.length === 0 && overrides?.autoRegisterPath) {
+    registerProjectGlobal(overrides.autoRegisterPath);
+    log.info('Auto-registered current project', { path: overrides.autoRegisterPath });
+  }
 
   const app = express();
   const httpServer = createServer(app);
@@ -96,7 +66,6 @@ export async function startServer(overrides?: ServerOverrides): Promise<ServerIn
   const io = new Server(httpServer, {
     cors: {
       origin: (origin, callback) => {
-        // Allow all localhost origins (dev tool, not production)
         if (!origin || origin.startsWith('http://localhost:')) {
           callback(null, true);
         } else {
@@ -107,324 +76,174 @@ export async function startServer(overrides?: ServerOverrides): Promise<ServerIn
     },
   });
 
-  // Middleware
   app.use(express.json());
 
-  // Initialize database
-  const db = getDatabase();
-
-  // Initialize services
-  const scopeCache = new ScopeCache();
-  const scopeService = new ScopeService(scopeCache, io, config.scopesDir, workflowEngine);
-  const eventService = new EventService(db, io);
-  const gateService = new GateService(db, io);
-  const deployService = new DeployService(db, io);
-  const sprintService = new SprintService(db, io, scopeService);
-  const sprintOrchestrator = new SprintOrchestrator(db, io, sprintService, scopeService, workflowEngine);
-  const batchOrchestrator = new BatchOrchestrator(db, io, sprintService, scopeService, workflowEngine);
-  const readinessService = new ReadinessService(scopeService, gateService, workflowEngine, config.projectRoot);
-  const workflowService = new WorkflowService(config.configDir, workflowEngine, config.scopesDir, DEFAULT_CONFIG_PATH);
-  workflowService.setSocketServer(io);
-
-  // Ensure in-memory engine reflects the actual active config (may differ from bundled default
-  // if the user applied a custom preset)
-  workflowEngine.reload(workflowService.getActive());
-  const gitService = new GitService(config.projectRoot, scopeCache);
-  const githubService = new GitHubService(config.projectRoot);
-
-  // Wire active-group guard into scope service (blocks manual moves for scopes in active batches/sprints)
-  scopeService.setActiveGroupCheck((scopeId) => sprintService.getActiveGroupForScope(scopeId));
-
-  // ─── Event Wiring ──────────────────────────────────────────
-
-  function inferScopeStatus(
-    eventType: string,
-    scopeId: unknown,
-    data: Record<string, unknown>
-  ): void {
-    if (scopeId == null) return;
-    const id = Number(scopeId);
-    if (isNaN(id) || id <= 0) return;
-
-    // Don't infer status for icebox idea cards
-    const current = scopeService.getById(id);
-    if (current?.status === 'icebox') return;
-
-    const currentStatus = current?.status ?? '';
-    const result = workflowEngine.inferStatus(eventType, currentStatus, data);
-    if (result === null) return;
-
-    // Handle dispatch resolution (AGENT_COMPLETED with outcome)
-    if (typeof result === 'object' && 'dispatchResolution' in result) {
-      resolveActiveDispatchesForScope(
-        db, io, id,
-        result.resolution as 'completed' | 'failed',
-      );
-      return;
-    }
-
-    scopeService.updateStatus(id, result, 'event');
-  }
-
-  eventService.onIngest((eventType, scopeId, data) => {
-    // Handle SESSION_START: link PID to dispatch via dispatch_id env var
-    if (eventType === 'SESSION_START' && typeof data.dispatch_id === 'string' && typeof data.pid === 'number') {
-      linkPidToDispatch(db, data.dispatch_id, data.pid);
-      log.info('SESSION_START: linked PID to dispatch', { pid: data.pid, dispatch_id: data.dispatch_id });
-      return;
-    }
+  // ─── Bind port early ──────────────────────────────────────
+  // Listen before async init so Vite's proxy doesn't get ECONNREFUSED
+  const actualPort = await new Promise<number>((resolve, reject) => {
+    let attempt = 0;
+    const maxAttempts = 10;
 
-    // Handle SESSION_END: resolve dispatches by dispatch_id (preferred) or PID (fallback)
-    if (eventType === 'SESSION_END') {
-      let count = 0;
-      if (typeof data.dispatch_id === 'string') {
-        count = resolveDispatchesByDispatchId(db, io, data.dispatch_id);
-        if (count > 0) {
-          log.info('SESSION_END: resolved dispatches', { count, dispatch_id: data.dispatch_id });
-        }
-      }
-      // PID fallback for old hooks without dispatch_id
-      if (count === 0 && typeof data.pid === 'number') {
-        count = resolveDispatchesByPid(db, io, data.pid);
-        if (count > 0) {
-          log.info('SESSION_END: resolved dispatches by PID fallback', { count, pid: data.pid });
-        }
-      }
-      // Immediately resolve any batches/sprints whose session just ended,
-      // rather than waiting for the next stale-check interval
-      if (count > 0) {
-        batchOrchestrator.resolveStaleBatches();
+    httpServer.on('error', (err: NodeJS.ErrnoException) => {
+      if (err.code === 'EADDRINUSE' && attempt < maxAttempts) {
+        attempt++;
+        httpServer.listen(port + attempt);
+      } else {
+        reject(new Error(`Failed to start server: ${err.message}`));
       }
-      return;
-    }
+    });
 
-    inferScopeStatus(eventType, scopeId, data);
-  });
+    httpServer.on('listening', () => {
+      const addr = httpServer.address();
+      resolve(typeof addr === 'object' && addr ? addr.port : port);
+    });
 
-  scopeService.onStatusChange((scopeId, newStatus) => {
-    if (newStatus === 'dev') {
-      sprintOrchestrator.onScopeReachedDev(scopeId);
-    }
-    // Batch orchestrator tracks all status transitions (dev, staging, production)
-    batchOrchestrator.onScopeStatusChanged(scopeId, newStatus);
+    httpServer.listen(port);
   });
 
-  scopeService.onStatusChange((scopeId, newStatus) => {
-    if (workflowEngine.isTerminalStatus(newStatus)) {
-      resolveActiveDispatchesForScope(db, io, scopeId, 'completed');
-    }
+  // Initialize ProjectManager and boot all registered projects
+  const projectManager = new ProjectManager(io);
+  await projectManager.initializeAll();
+
+  // Seed global primitives if empty (lazy fallback for first launch)
+  const globalPrimitivesEmpty = ['agents', 'skills', 'hooks'].every(t => {
+    const dir = path.join(GLOBAL_PRIMITIVES_DIR, t);
+    return !fs.existsSync(dir) || fs.readdirSync(dir).filter(f => !f.startsWith('.')).length === 0;
   });
+  if (globalPrimitivesEmpty) {
+    seedGlobalPrimitives();
+    log.info('Seeded global primitives from package templates');
+  }
+
+  // Initialize SyncService and global watcher
+  const syncService = new SyncService();
+  const globalWatcher = startGlobalWatcher(syncService, io);
 
-  // ─── Routes ────────────────────────────────────────────────
+  // ─── Routes ──────────────────────────────────────────────
 
+  // Health check
   app.get('/api/orbital/health', (_req, res) => {
     res.json({ status: 'ok', uptime: process.uptime(), timestamp: new Date().toISOString() });
   });
 
-  // Serve dynamic config to the frontend
-  app.get('/api/orbital/config', (_req, res) => {
-    res.json({
-      projectName: config.projectName,
-      categories: config.categories,
-      agents: config.agents,
-      serverPort: config.serverPort,
-      clientPort: config.clientPort,
-    });
+  // Project management + sync routes (top-level)
+  app.use('/api/orbital', createSyncRoutes({ syncService, projectManager }));
+  app.use('/api/orbital', createVersionRoutes({ io }));
+
+  // Per-project routes — dynamic middleware that resolves :projectId
+  app.use('/api/orbital/projects/:projectId', (req, res, next) => {
+    const projectId = req.params.projectId;
+    const router = projectManager.getRouter(projectId);
+    if (!router) {
+      const ctx = projectManager.getContext(projectId);
+      if (!ctx) return res.status(404).json({ error: `Project '${projectId}' not found` });
+      return res.status(503).json({ error: `Project '${projectId}' is offline` });
+    }
+    router(req, res, next);
   });
 
-  app.use('/api/orbital', createScopeRoutes({ db, io, scopeService, readinessService, projectRoot: config.projectRoot, engine: workflowEngine }));
-  app.use('/api/orbital', createDataRoutes({ db, io, gateService, deployService, engine: workflowEngine, projectRoot: config.projectRoot, inferScopeStatus }));
-  app.use('/api/orbital', createDispatchRoutes({ db, io, scopeService, projectRoot: config.projectRoot, engine: workflowEngine }));
-  app.use('/api/orbital', createSprintRoutes({ sprintService, sprintOrchestrator, batchOrchestrator }));
-  app.use('/api/orbital', createWorkflowRoutes({ workflowService, projectRoot: config.projectRoot }));
-  app.use('/api/orbital', createConfigRoutes({ projectRoot: config.projectRoot, workflowService, io }));
-  app.use('/api/orbital', createGitRoutes({ gitService, githubService, engine: workflowEngine }));
-  app.use('/api/orbital', createVersionRoutes({ io }));
+  // Aggregate endpoints (cross-project)
+  app.use('/api/orbital', createAggregateRoutes({ projectManager, io, syncService }));
 
-  // ─── Static File Serving (production) ───────────────────────
+  // ─── Static File Serving ─────────────────────────────────
 
-  // Resolve the Vite-built frontend dist directory (server/ → ../dist).
   const __selfDir = path.dirname(fileURLToPath(import.meta.url));
   const distDir = path.resolve(__selfDir, '../dist');
-  if (fs.existsSync(path.join(distDir, 'index.html'))) {
+  const devMode = clientPort !== port;
+  const hasBuiltFrontend = !devMode && fs.existsSync(path.join(distDir, 'index.html'));
+  if (hasBuiltFrontend) {
     app.use(express.static(distDir));
     app.get('*', (req, res, next) => {
       if (req.path.startsWith('/api/') || req.path.startsWith('/socket.io')) return next();
       res.sendFile(path.join(distDir, 'index.html'));
     });
   } else {
-    // Dev mode: redirect root to Vite dev server
-    app.get('/', (_req, res) => res.redirect(`http://localhost:${config.clientPort}`));
+    app.get('/', (_req, res) => res.redirect(`http://localhost:${clientPort}`));
   }
 
-  // ─── Socket.io ──────────────────────────────────────────────
+  // ─── Socket.io ───────────────────────────────────────────
 
   io.on('connection', (socket) => {
     log.debug('Client connected', { socketId: socket.id });
 
-    socket.on('disconnect', () => {
-      log.debug('Client disconnected', { socketId: socket.id });
+    socket.on('subscribe', (payload: { projectId?: string; scope?: string }) => {
+      if (payload.scope === 'all') {
+        socket.join('all-projects');
+      } else if (payload.projectId) {
+        socket.join(`project:${payload.projectId}`);
+      }
     });
-  });
-
-  // ─── Startup ───────────────────────────────────────────────
-
-  // References for graceful shutdown
-  let scopeWatcher: ReturnType<typeof startScopeWatcher>;
-  let eventWatcher: ReturnType<typeof startEventWatcher>;
-  let batchRecoveryInterval: ReturnType<typeof setInterval>;
-  let staleCleanupInterval: ReturnType<typeof setInterval>;
-  let sessionSyncInterval: ReturnType<typeof setInterval>;
-  let gitPollInterval: ReturnType<typeof setInterval>;
-
-  const actualPort = await new Promise<number>((resolve, reject) => {
-    let attempt = 0;
-    const maxAttempts = 10;
 
-    httpServer.on('error', (err: NodeJS.ErrnoException) => {
-      if (err.code === 'EADDRINUSE' && attempt < maxAttempts) {
-        attempt++;
-        const nextPort = port + attempt;
-        log.warn('Port in use, trying next', { tried: port + attempt - 1, next: nextPort });
-        httpServer.listen(nextPort);
-      } else {
-        reject(new Error(`Failed to start server: ${err.message}`));
+    socket.on('unsubscribe', (payload: { projectId?: string; scope?: string }) => {
+      if (payload.scope === 'all') {
+        socket.leave('all-projects');
+      } else if (payload.projectId) {
+        socket.leave(`project:${payload.projectId}`);
       }
     });
 
-    httpServer.on('listening', () => {
-      const addr = httpServer.address();
-      const listenPort = typeof addr === 'object' && addr ? addr.port : port;
-      resolve(listenPort);
+    socket.on('disconnect', () => {
+      log.debug('Client disconnected', { socketId: socket.id });
     });
-
-    httpServer.listen(port);
   });
 
-  // ─── Post-listen initialization ────────────────────────────
-
-  // Sync scopes from filesystem on startup (populates in-memory cache)
-  const scopeCount = scopeService.syncFromFilesystem();
+  // ─── Error Handling Middleware ─────────────────────────────
+  // Catches unhandled errors thrown from route handlers.
 
-  // Resolve stale dispatch events (terminal scopes + age-based)
-  const staleResolved = resolveStaleDispatches(db, io, scopeService, workflowEngine);
-  if (staleResolved > 0) {
-    log.info('Resolved stale dispatch events', { count: staleResolved });
-  }
-
-  // Write iTerm2 dispatch profiles (idempotent, fire-and-forget)
-  ensureDynamicProfiles(workflowEngine);
-
-  // Start file watchers
-  scopeWatcher = startScopeWatcher(config.scopesDir, scopeService);
-  eventWatcher = startEventWatcher(config.eventsDir, eventService);
-
-  // Recover any active sprints/batches from before server restart
-  sprintOrchestrator.recoverActiveSprints().catch(err => log.error('Sprint recovery failed', { error: err.message }));
-  batchOrchestrator.recoverActiveBatches().catch(err => log.error('Batch recovery failed', { error: err.message }));
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  app.use((err: Error, _req: express.Request, res: express.Response, _next: express.NextFunction) => {
+    log.error('Unhandled route error', { error: err.message, stack: err.stack });
+    if (!res.headersSent) {
+      res.status(500).json({ ok: false, error: 'Internal server error' });
+    }
+  });
 
-  // Resolve stale batches on startup (catches stuck dispatches from previous runs)
-  const staleBatchesResolved = batchOrchestrator.resolveStaleBatches();
-  if (staleBatchesResolved > 0) {
-    log.info('Resolved stale batches', { count: staleBatchesResolved });
-  }
+  // ─── Startup Banner ──────────────────────────────────────
 
-  // Poll active batch PIDs every 30s for two-phase completion (B-1)
-  batchRecoveryInterval = setInterval(() => {
-    batchOrchestrator.recoverActiveBatches().catch(err => log.error('Batch recovery failed', { error: err.message }));
-  }, 30_000);
+  const projectList = projectManager.getProjectList();
+  const projectLines = projectList.map(p =>
+    `║  ${p.status === 'active' ? '●' : '○'} ${p.name.padEnd(20)} ${String(p.scopeCount).padStart(3)} scopes    ${p.status.padEnd(8)} ║`
+  ).join('\n');
 
-  // Periodic stale dispatch + batch cleanup (crash recovery — catches SIGKILL'd sessions)
-  staleCleanupInterval = setInterval(() => {
-    const count = resolveStaleDispatches(db, io, scopeService, workflowEngine);
-    if (count > 0) {
-      log.info('Periodic cleanup: resolved stale dispatches', { count });
-    }
-    const batchCount = batchOrchestrator.resolveStaleBatches();
-    if (batchCount > 0) {
-      log.info('Periodic cleanup: resolved stale batches', { count: batchCount });
-    }
-  }, 30_000);
-
-  // Sync frontmatter-derived sessions into DB (non-blocking)
-  syncClaudeSessionsToDB(db, scopeService).then((count) => {
-    log.info('Synced frontmatter sessions', { count });
-
-    // Purge legacy pattern-matched rows (no action = old regex system)
-    const purged = db.prepare(
-      "DELETE FROM sessions WHERE action IS NULL AND id LIKE 'claude-%'"
-    ).run();
-    if (purged.changes > 0) {
-      log.info('Purged legacy pattern-matched session rows', { count: purged.changes });
-    }
-  }).catch(err => log.error('Session sync failed', { error: err.message }));
-
-  // Re-sync every 5 minutes so new sessions appear without restart
-  sessionSyncInterval = setInterval(() => {
-    syncClaudeSessionsToDB(db, scopeService)
-      .then((count) => {
-        if (count > 0) io.emit('session:updated', { type: 'resync', count });
-      })
-      .catch(err => log.error('Session resync failed', { error: err.message }));
-  }, 5 * 60 * 1000);
-
-  // Poll git status every 10s — emit socket event on change
-  let lastGitHash = '';
-  gitPollInterval = setInterval(async () => {
-    try {
-      const hash = await gitService.getStatusHash();
-      if (lastGitHash && hash !== lastGitHash) {
-        gitService.clearCache();
-        io.emit('git:status:changed');
-      }
-      lastGitHash = hash;
-    } catch { /* ok */ }
-  }, 10_000);
+  const dashboardPort = devMode ? clientPort : actualPort;
 
   // eslint-disable-next-line no-console
   console.log(`
 ╔══════════════════════════════════════════════════════╗
-║         Orbital Command                              ║
-║         ${config.projectName.padEnd(42)} ║
+║         Orbital Command — Central Server             ║
 ║                                                      ║
-║  >>> Open: http://localhost:${actualPort} <<<                 ║
+║  >>> Open: http://localhost:${String(dashboardPort).padEnd(25)} <<<║
 ║                                                      ║
 ╠══════════════════════════════════════════════════════╣
-║  Scopes:    ${String(scopeCount).padEnd(3)} loaded from filesystem          ║
+${projectLines}
+╠══════════════════════════════════════════════════════╣
 ║  API:       http://localhost:${actualPort}/api/orbital/*       ║
 ║  Socket.io: ws://localhost:${actualPort}                      ║
+║  Home:      ${ORBITAL_HOME.padEnd(39)} ║
 ╚══════════════════════════════════════════════════════╝
 `);
 
-  // ─── Graceful Shutdown ─────────────────────────────────────
+  // ─── Graceful Shutdown ───────────────────────────────────
 
   let shuttingDown = false;
-  function shutdown(): Promise<void> {
-    if (shuttingDown) return Promise.resolve();
+  async function shutdown(): Promise<void> {
+    if (shuttingDown) return;
     shuttingDown = true;
-    log.info('Shutting down');
-    scopeWatcher.close();
-    eventWatcher.close();
-    clearInterval(batchRecoveryInterval);
-    clearInterval(staleCleanupInterval);
-    clearInterval(sessionSyncInterval);
-    clearInterval(gitPollInterval);
+    log.info('Shutting down central server');
 
-    return new Promise<void>((resolve) => {
-      const forceTimeout = setTimeout(() => {
-        closeDatabase();
-        resolve();
-      }, 2000);
+    if (globalWatcher) await globalWatcher.close();
+    await projectManager.shutdownAll();
 
+    return new Promise<void>((resolve) => {
+      const forceTimeout = setTimeout(resolve, 2000);
       io.close(() => {
         clearTimeout(forceTimeout);
-        closeDatabase();
         resolve();
       });
     });
   }
 
-  return { app, io, db, workflowEngine, httpServer, shutdown };
+  return { app, io, projectManager, syncService, httpServer, shutdown };
 }
 
 // ─── Direct Execution (backward compat: tsx watch server/index.ts) ───
@@ -436,7 +255,11 @@ const isDirectRun = process.argv[1] && (
 );
 
 if (isDirectRun) {
-  startServer().then(({ shutdown }) => {
+  const projectRoot = process.env.ORBITAL_PROJECT_ROOT || process.cwd();
+  startCentralServer({
+    port: Number(process.env.ORBITAL_SERVER_PORT) || 4444,
+    autoRegisterPath: projectRoot,
+  }).then(({ shutdown }) => {
     process.on('SIGINT', async () => {
       await shutdown();
       process.exit(0);