orbital-command 0.2.0 → 1.0.0

package/dist/server/server/global-config.js

@@ -0,0 +1,143 @@
+import crypto from 'crypto';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { createLogger } from './utils/logger.js';
+const log = createLogger('global-config');
+// ─── Constants ──────────────────────────────────────────────
+/** Global Orbital Command directory */
+export const ORBITAL_HOME = path.join(os.homedir(), '.orbital');
+/** Path to the global registry file */
+export const REGISTRY_PATH = path.join(ORBITAL_HOME, 'config.json');
+/** Path to global primitives directory */
+export const GLOBAL_PRIMITIVES_DIR = path.join(ORBITAL_HOME, 'primitives');
+/** Path to global workflow config */
+export const GLOBAL_WORKFLOW_PATH = path.join(ORBITAL_HOME, 'workflow.json');
+/** Import from shared — re-exported for convenience */
+import { PROJECT_COLORS } from '../shared/project-colors.js';
+export { PROJECT_COLORS };
+// ─── Slug Generation ────────────────────────────────────────
+/**
+ * Generate a project slug from a filesystem path.
+ * Uses the directory basename, lowercased, with non-alphanumeric chars
+ * replaced by hyphens. Deduplicates against existing IDs with a 4-char hash.
+ */
+export function generateProjectId(projectRoot, existingIds) {
+    const base = path.basename(projectRoot)
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+    const slug = base || 'project';
+    if (!existingIds.includes(slug))
+        return slug;
+    // Collision — append 4-char hash of the full path
+    const hash = crypto.createHash('sha256').update(projectRoot).digest('hex').slice(0, 4);
+    return `${slug}-${hash}`;
+}
+// ─── Registry I/O ───────────────────────────────────────────
+/** Ensure ~/.orbital/ directory structure exists, including primitives subdirectories. */
+export function ensureOrbitalHome() {
+    if (!fs.existsSync(ORBITAL_HOME)) {
+        fs.mkdirSync(ORBITAL_HOME, { recursive: true });
+        log.info('Created ~/.orbital/', { path: ORBITAL_HOME });
+    }
+    // Ensure primitives subdirectories exist so the global watcher can start
+    for (const sub of ['agents', 'skills', 'hooks', 'config']) {
+        const dir = path.join(GLOBAL_PRIMITIVES_DIR, sub);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+    }
+}
+/** Load the global registry. Creates default if missing. */
+export function loadGlobalConfig() {
+    ensureOrbitalHome();
+    if (!fs.existsSync(REGISTRY_PATH)) {
+        const config = { version: 1, projects: [] };
+        saveGlobalConfig(config);
+        return config;
+    }
+    try {
+        const raw = fs.readFileSync(REGISTRY_PATH, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        log.error('Failed to read global config, creating fresh', { error: String(err) });
+        const config = { version: 1, projects: [] };
+        saveGlobalConfig(config);
+        return config;
+    }
+}
+/** Save the global registry atomically. */
+export function saveGlobalConfig(config) {
+    ensureOrbitalHome();
+    const tmpPath = REGISTRY_PATH + '.tmp';
+    fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2), 'utf-8');
+    fs.renameSync(tmpPath, REGISTRY_PATH);
+}
+// ─── Project Registration ───────────────────────────────────
+/** Pick the next unused color from the palette. */
+function nextColor(usedColors) {
+    const available = PROJECT_COLORS.filter(c => !usedColors.includes(c));
+    return available[0] ?? PROJECT_COLORS[0];
+}
+/** Register a project in the global config. Returns the registration. */
+export function registerProject(projectRoot, options) {
+    const absPath = path.resolve(projectRoot);
+    const config = loadGlobalConfig();
+    // Check if already registered
+    const existing = config.projects.find(p => p.path === absPath);
+    if (existing) {
+        log.info('Project already registered', { id: existing.id, path: absPath });
+        return existing;
+    }
+    const existingIds = config.projects.map(p => p.id);
+    const usedColors = config.projects.map(p => p.color);
+    const registration = {
+        id: generateProjectId(absPath, existingIds),
+        path: absPath,
+        name: options?.name ?? path.basename(absPath),
+        color: options?.color ?? nextColor(usedColors),
+        registeredAt: new Date().toISOString(),
+        enabled: true,
+    };
+    config.projects.push(registration);
+    saveGlobalConfig(config);
+    log.info('Project registered', { id: registration.id, path: absPath });
+    return registration;
+}
+/** Unregister a project by ID or path. Returns true if found. */
+export function unregisterProject(idOrPath) {
+    const config = loadGlobalConfig();
+    const absPath = path.isAbsolute(idOrPath) ? idOrPath : path.resolve(idOrPath);
+    const idx = config.projects.findIndex(p => p.id === idOrPath || p.path === absPath);
+    if (idx === -1)
+        return false;
+    const removed = config.projects.splice(idx, 1)[0];
+    saveGlobalConfig(config);
+    log.info('Project unregistered', { id: removed.id, path: removed.path });
+    return true;
+}
+/** Update a project's registration (color, name, enabled). */
+export function updateProject(id, updates) {
+    const config = loadGlobalConfig();
+    const project = config.projects.find(p => p.id === id);
+    if (!project)
+        return null;
+    if (updates.name !== undefined)
+        project.name = updates.name;
+    if (updates.color !== undefined)
+        project.color = updates.color;
+    if (updates.enabled !== undefined)
+        project.enabled = updates.enabled;
+    saveGlobalConfig(config);
+    return project;
+}
+/** Get all registered projects. */
+export function getRegisteredProjects() {
+    return loadGlobalConfig().projects;
+}
+/** Find a registered project by ID. */
+export function findProject(id) {
+    return loadGlobalConfig().projects.find(p => p.id === id);
+}

package/dist/server/server/index.js

@@ -4,72 +4,36 @@ 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 { createAggregateRoutes } from './routes/aggregate-routes.js';
 import { createLogger, setLogLevel } from './utils/logger.js';
-// ─── Server Factory ─────────────────────────────────────────
-export async function startServer(overrides) {
-    // Apply project root override before config loads
-    if (overrides?.projectRoot) {
-        process.env.ORBITAL_PROJECT_ROOT = overrides.projectRoot;
-        resetConfig();
-    }
-    const config = getConfig();
+// ─── 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 async function startCentralServer(overrides) {
+    ensureOrbitalHome();
     const envLevel = process.env.ORBITAL_LOG_LEVEL;
     if (envLevel && ['debug', 'info', 'warn', 'error'].includes(envLevel)) {
         setLogLevel(envLevel);
     }
-    else {
-        setLogLevel(config.logLevel);
+    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 log = createLogger('server');
-    const port = overrides?.port ?? config.serverPort;
-    const workflowEngine = new WorkflowEngine(defaultWorkflow);
-    // 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 app = express();
     const httpServer = createServer(app);
     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);
                 }
@@ -80,122 +44,70 @@ export async function startServer(overrides) {
             methods: ['GET', 'POST'],
         },
     });
-    // 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, scopeId, data) {
-        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);
-            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;
-        }
-        // 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 });
-                }
+    // ─── Bind port early ──────────────────────────────────────
+    // Listen before async init so Vite's proxy doesn't get ECONNREFUSED
+    const actualPort = await new Promise((resolve, reject) => {
+        let attempt = 0;
+        const maxAttempts = 10;
+        httpServer.on('error', (err) => {
+            if (err.code === 'EADDRINUSE' && attempt < maxAttempts) {
+                attempt++;
+                httpServer.listen(port + attempt);
             }
-            // Immediately resolve any batches/sprints whose session just ended,
-            // rather than waiting for the next stale-check interval
-            if (count > 0) {
-                batchOrchestrator.resolveStaleBatches();
+            else {
+                reject(new Error(`Failed to start server: ${err.message}`));
             }
-            return;
-        }
-        inferScopeStatus(eventType, scopeId, data);
-    });
-    scopeService.onStatusChange((scopeId, newStatus) => {
-        if (newStatus === 'dev') {
-            sprintOrchestrator.onScopeReachedDev(scopeId);
-        }
-        // Batch orchestrator tracks all status transitions (dev, staging, production)
-        batchOrchestrator.onScopeStatusChanged(scopeId, newStatus);
+        });
+        httpServer.on('listening', () => {
+            const addr = httpServer.address();
+            resolve(typeof addr === 'object' && addr ? addr.port : port);
+        });
+        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;
     });
-    // ─── Routes ────────────────────────────────────────────────
+    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 ──────────────────────────────────────────────
+    // 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,
-        });
-    });
-    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 }));
+    // Project management + sync routes (top-level)
+    app.use('/api/orbital', createSyncRoutes({ syncService, projectManager }));
     app.use('/api/orbital', createVersionRoutes({ io }));
-    // ─── Static File Serving (production) ───────────────────────
-    // Resolve the Vite-built frontend dist directory (server/ → ../dist).
+    // 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);
+    });
+    // Aggregate endpoints (cross-project)
+    app.use('/api/orbital', createAggregateRoutes({ projectManager, io, syncService }));
+    // ─── Static File Serving ─────────────────────────────────
     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'))
@@ -204,159 +116,89 @@ export async function startServer(overrides) {
         });
     }
     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) => {
+            if (payload.scope === 'all') {
+                socket.join('all-projects');
+            }
+            else if (payload.projectId) {
+                socket.join(`project:${payload.projectId}`);
+            }
         });
-    });
-    // ─── Startup ───────────────────────────────────────────────
-    // References for graceful shutdown
-    let scopeWatcher;
-    let eventWatcher;
-    let batchRecoveryInterval;
-    let staleCleanupInterval;
-    let sessionSyncInterval;
-    let gitPollInterval;
-    const actualPort = await new Promise((resolve, reject) => {
-        let attempt = 0;
-        const maxAttempts = 10;
-        httpServer.on('error', (err) => {
-            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);
+        socket.on('unsubscribe', (payload) => {
+            if (payload.scope === 'all') {
+                socket.leave('all-projects');
             }
-            else {
-                reject(new Error(`Failed to start server: ${err.message}`));
+            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();
-    // 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 }));
-    // 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 });
-    }
-    // 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);
-    // 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 });
+    // ─── Error Handling Middleware ─────────────────────────────
+    // Catches unhandled errors thrown from route handlers.
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    app.use((err, _req, res, _next) => {
+        log.error('Unhandled route error', { error: err.message, stack: err.stack });
+        if (!res.headersSent) {
+            res.status(500).json({ ok: false, error: 'Internal server error' });
         }
-        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);
+    });
+    // ─── Startup Banner ──────────────────────────────────────
+    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');
+    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() {
+    async function shutdown() {
         if (shuttingDown)
-            return Promise.resolve();
+            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');
+        if (globalWatcher)
+            await globalWatcher.close();
+        await projectManager.shutdownAll();
         return new Promise((resolve) => {
-            const forceTimeout = setTimeout(() => {
-                closeDatabase();
-                resolve();
-            }, 2000);
+            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) ───
 const isDirectRun = process.argv[1] && (process.argv[1].endsWith('server/index.ts') ||
     process.argv[1].endsWith('server/index.js') ||
     process.argv[1].endsWith('server'));
 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);