orbital-command 0.1.0

package/dist/server/server/config.js

@@ -0,0 +1,156 @@
+import path from 'path';
+import fs from 'fs';
+import { execFileSync } from 'child_process';
+import os from 'os';
+import { createLogger } from './utils/logger.js';
+// ─── Defaults ───────────────────────────────────────────────
+const DEFAULT_CONFIG = {
+    projectName: 'Project',
+    scopesDir: 'scopes',
+    eventsDir: '.claude/orbital-events',
+    dbDir: '.claude/orbital',
+    configDir: '.claude/config',
+    serverPort: 4444,
+    clientPort: 4445,
+    terminal: {
+        adapter: 'auto',
+        profilePrefix: 'Orbital',
+    },
+    claude: {
+        executable: 'claude',
+        flags: ['--dangerously-skip-permissions'],
+    },
+    commands: {
+        typeCheck: null,
+        lint: null,
+        build: null,
+        test: null,
+        validateTemplates: null,
+        validateDocs: null,
+        checkRules: null,
+    },
+    logLevel: 'info',
+    categories: ['feature', 'bugfix', 'refactor', 'infrastructure', 'docs'],
+    agents: [
+        { id: 'attacker', label: 'Attacker', emoji: '\u{1F5E1}\u{FE0F}', color: '#ff1744' },
+        { id: 'chaos', label: 'Chaos', emoji: '\u{1F4A5}', color: '#F97316' },
+        { id: 'solana-expert', label: 'Solana Expert', emoji: '\u{26D3}\u{FE0F}', color: '#8B5CF6' },
+        { id: 'frontend-designer', label: 'Frontend Designer', emoji: '\u{1F3A8}', color: '#EC4899' },
+        { id: 'architect', label: 'Architect', emoji: '\u{1F3D7}\u{FE0F}', color: '#536dfe' },
+        { id: 'rules-enforcer', label: 'Rules Enforcer', emoji: '\u{1F4CB}', color: '#6B7280' },
+    ],
+};
+// ─── Project Root Resolution ────────────────────────────────
+/**
+ * Resolve the project root directory.
+ * Priority: ORBITAL_PROJECT_ROOT env > git rev-parse > cwd walk > cwd
+ */
+export function resolveProjectRoot() {
+    // 1. Explicit env var
+    if (process.env.ORBITAL_PROJECT_ROOT) {
+        return path.resolve(process.env.ORBITAL_PROJECT_ROOT);
+    }
+    // 2. git rev-parse --show-toplevel
+    try {
+        const gitRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        if (gitRoot)
+            return gitRoot;
+    }
+    catch {
+        // Not in a git repo — continue
+    }
+    // 3. Walk up from cwd looking for .git directory
+    let dir = process.cwd();
+    while (dir !== path.dirname(dir)) {
+        if (fs.existsSync(path.join(dir, '.git')))
+            return dir;
+        dir = path.dirname(dir);
+    }
+    // 4. Fall back to cwd
+    return process.cwd();
+}
+// ─── Claude Sessions Path ───────────────────────────────────
+/**
+ * Derive the Claude Code sessions directory for a project.
+ * Claude Code encodes the project path by replacing `/` with `-`.
+ * The leading `/` becomes the leading `-` in the directory name.
+ */
+export function getClaudeSessionsDir(projectRoot) {
+    const encoded = projectRoot.replace(/\//g, '-');
+    return path.join(os.homedir(), '.claude', 'projects', encoded);
+}
+// ─── Config Loading ─────────────────────────────────────────
+/**
+ * Load and merge orbital.config.json with defaults.
+ * Resolves all relative paths to absolute using projectRoot.
+ */
+export function loadConfig(projectRoot) {
+    const root = projectRoot ?? resolveProjectRoot();
+    // Try loading user config
+    const configPath = path.join(root, '.claude', 'orbital.config.json');
+    let userConfig = {};
+    const log = createLogger('config');
+    if (fs.existsSync(configPath)) {
+        try {
+            userConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        }
+        catch (err) {
+            log.warn('Failed to parse orbital.config.json — using defaults', { error: err.message });
+        }
+    }
+    // Merge with defaults
+    const projectName = userConfig.projectName ?? DEFAULT_CONFIG.projectName;
+    const scopesDir = path.resolve(root, userConfig.scopesDir ?? DEFAULT_CONFIG.scopesDir);
+    const eventsDir = path.resolve(root, userConfig.eventsDir ?? DEFAULT_CONFIG.eventsDir);
+    const dbDir = path.resolve(root, userConfig.dbDir ?? DEFAULT_CONFIG.dbDir);
+    const configDir = path.resolve(root, userConfig.configDir ?? DEFAULT_CONFIG.configDir);
+    const serverPort = userConfig.serverPort ?? DEFAULT_CONFIG.serverPort;
+    const clientPort = userConfig.clientPort ?? DEFAULT_CONFIG.clientPort;
+    const terminal = {
+        ...DEFAULT_CONFIG.terminal,
+        ...(userConfig.terminal ?? {}),
+    };
+    const claude = {
+        ...DEFAULT_CONFIG.claude,
+        ...(userConfig.claude ?? {}),
+    };
+    const commands = {
+        ...DEFAULT_CONFIG.commands,
+        ...(userConfig.commands ?? {}),
+    };
+    const logLevel = userConfig.logLevel ?? DEFAULT_CONFIG.logLevel;
+    const categories = userConfig.categories ?? DEFAULT_CONFIG.categories;
+    const agents = userConfig.agents ?? DEFAULT_CONFIG.agents;
+    return {
+        projectName,
+        projectRoot: root,
+        scopesDir,
+        eventsDir,
+        dbDir,
+        configDir,
+        serverPort,
+        clientPort,
+        terminal,
+        claude,
+        commands,
+        logLevel,
+        categories,
+        agents,
+    };
+}
+// ─── Singleton ──────────────────────────────────────────────
+let _config = null;
+/** Get the global config singleton. Lazy-loaded on first access. */
+export function getConfig() {
+    if (!_config) {
+        _config = loadConfig();
+    }
+    return _config;
+}
+/** Reset the config singleton (for testing or hot-reload). */
+export function resetConfig() {
+    _config = null;
+}

package/dist/server/server/database.js

@@ -0,0 +1,90 @@
+import Database from 'better-sqlite3';
+import path from 'path';
+import fs from 'fs';
+import { SCHEMA_DDL } from './schema.js';
+import { getConfig } from './config.js';
+import { createLogger } from './utils/logger.js';
+const log = createLogger('database');
+function getDbPaths() {
+    const config = getConfig();
+    return { dir: config.dbDir, file: path.join(config.dbDir, 'orbital.db') };
+}
+let db = null;
+export function getDatabase() {
+    if (db)
+        return db;
+    const { dir, file } = getDbPaths();
+    fs.mkdirSync(dir, { recursive: true });
+    db = new Database(file);
+    log.info('Database initialized', { path: file });
+    // Performance pragmas for a local dev tool
+    db.pragma('journal_mode = WAL');
+    db.pragma('synchronous = NORMAL');
+    db.pragma('foreign_keys = ON');
+    // Run schema migrations (SQLite db.exec, not child_process)
+    db.exec(SCHEMA_DDL);
+    // Incremental migrations for existing databases
+    runMigrations(db);
+    return db;
+}
+/** Check if a table exists in the database */
+function tableExists(database, tableName) {
+    const row = database.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(tableName);
+    return row !== undefined;
+}
+/** Run incremental migrations for schema changes on existing databases */
+function runMigrations(database) {
+    log.debug('Running database migrations');
+    // Migration 2: Add claude_session_id column to sessions
+    const sessionCols = database.pragma('table_info(sessions)');
+    if (!sessionCols.some((c) => c.name === 'claude_session_id')) {
+        database.exec('ALTER TABLE sessions ADD COLUMN claude_session_id TEXT');
+    }
+    // Migration 6: Add action column to sessions for frontmatter lifecycle phase
+    if (!sessionCols.some((c) => c.name === 'action')) {
+        database.exec('ALTER TABLE sessions ADD COLUMN action TEXT');
+    }
+    // Migration 8: Add batch group columns to sprints
+    const sprintCols = database.pragma('table_info(sprints)');
+    if (!sprintCols.some((c) => c.name === 'target_column')) {
+        database.exec("ALTER TABLE sprints ADD COLUMN target_column TEXT DEFAULT 'backlog'");
+        database.exec("ALTER TABLE sprints ADD COLUMN group_type TEXT DEFAULT 'sprint'");
+        database.exec("ALTER TABLE sprints ADD COLUMN dispatch_result TEXT DEFAULT '{}'");
+        database.exec('CREATE INDEX IF NOT EXISTS idx_sprints_target_column ON sprints(target_column)');
+    }
+    // Migration 7: Drop scopes table — scopes are now served from in-memory cache.
+    // Recreate sprint_scopes without the FK to scopes.
+    if (tableExists(database, 'scopes')) {
+        database.exec(`
+      -- Backup sprint_scopes data
+      CREATE TABLE IF NOT EXISTS sprint_scopes_backup AS SELECT * FROM sprint_scopes;
+      -- Drop tables with FK dependencies first
+      DROP TABLE IF EXISTS sprint_scopes;
+      -- Drop the scopes table
+      DROP TABLE IF EXISTS scopes;
+      -- Recreate sprint_scopes without FK to scopes
+      CREATE TABLE IF NOT EXISTS sprint_scopes (
+        sprint_id INTEGER NOT NULL,
+        scope_id INTEGER NOT NULL,
+        layer INTEGER,
+        dispatch_status TEXT NOT NULL DEFAULT 'pending',
+        dispatched_at TEXT,
+        completed_at TEXT,
+        error TEXT,
+        PRIMARY KEY (sprint_id, scope_id),
+        FOREIGN KEY (sprint_id) REFERENCES sprints(id) ON DELETE CASCADE
+      );
+      -- Restore data
+      INSERT OR IGNORE INTO sprint_scopes SELECT * FROM sprint_scopes_backup;
+      -- Cleanup
+      DROP TABLE IF EXISTS sprint_scopes_backup;
+    `);
+    }
+}
+export function closeDatabase() {
+    if (db) {
+        db.close();
+        db = null;
+        log.debug('Database closed');
+    }
+}

package/dist/server/server/index.js

@@ -0,0 +1,372 @@
+import express from 'express';
+import { createServer } from 'http';
+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 { 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();
+    const envLevel = process.env.ORBITAL_LOG_LEVEL;
+    if (envLevel && ['debug', 'info', 'warn', 'error'].includes(envLevel)) {
+        setLogLevel(envLevel);
+    }
+    else {
+        setLogLevel(config.logLevel);
+    }
+    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);
+                }
+                else {
+                    callback(new Error('CORS not allowed'));
+                }
+            },
+            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 });
+                }
+            }
+            // Immediately resolve any batches/sprints whose session just ended,
+            // rather than waiting for the next stale-check interval
+            if (count > 0) {
+                batchOrchestrator.resolveStaleBatches();
+            }
+            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);
+    });
+    scopeService.onStatusChange((scopeId, newStatus) => {
+        if (workflowEngine.isTerminalStatus(newStatus)) {
+            resolveActiveDispatchesForScope(db, io, scopeId, 'completed');
+        }
+    });
+    // ─── Routes ────────────────────────────────────────────────
+    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 }));
+    app.use('/api/orbital', createVersionRoutes({ io }));
+    // ─── Static File Serving (production) ───────────────────────
+    // 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'))) {
+        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}`));
+    }
+    // ─── Socket.io ──────────────────────────────────────────────
+    io.on('connection', (socket) => {
+        log.debug('Client connected', { socketId: socket.id });
+        socket.on('disconnect', () => {
+            log.debug('Client disconnected', { socketId: socket.id });
+        });
+    });
+    // ─── 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);
+            }
+            else {
+                reject(new Error(`Failed to start server: ${err.message}`));
+            }
+        });
+        httpServer.on('listening', () => {
+            const addr = httpServer.address();
+            const listenPort = typeof addr === 'object' && addr ? addr.port : port;
+            resolve(listenPort);
+        });
+        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 });
+        }
+        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);
+    // eslint-disable-next-line no-console
+    console.log(`
+╔══════════════════════════════════════════════════════╗
+║         Orbital Command                              ║
+║         ${config.projectName.padEnd(42)} ║
+║                                                      ║
+║  >>> Open: http://localhost:${actualPort} <<<                 ║
+║                                                      ║
+╠══════════════════════════════════════════════════════╣
+║  Scopes:    ${String(scopeCount).padEnd(3)} loaded from filesystem          ║
+║  API:       http://localhost:${actualPort}/api/orbital/*       ║
+║  Socket.io: ws://localhost:${actualPort}                      ║
+╚══════════════════════════════════════════════════════╝
+`);
+    // ─── Graceful Shutdown ─────────────────────────────────────
+    let shuttingDown = false;
+    function shutdown() {
+        if (shuttingDown)
+            return Promise.resolve();
+        shuttingDown = true;
+        log.info('Shutting down');
+        scopeWatcher.close();
+        eventWatcher.close();
+        clearInterval(batchRecoveryInterval);
+        clearInterval(staleCleanupInterval);
+        clearInterval(sessionSyncInterval);
+        clearInterval(gitPollInterval);
+        return new Promise((resolve) => {
+            const forceTimeout = setTimeout(() => {
+                closeDatabase();
+                resolve();
+            }, 2000);
+            io.close(() => {
+                clearTimeout(forceTimeout);
+                closeDatabase();
+                resolve();
+            });
+        });
+    }
+    return { app, io, db, workflowEngine, 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 }) => {
+        process.on('SIGINT', async () => {
+            await shutdown();
+            process.exit(0);
+        });
+        process.on('SIGTERM', async () => {
+            await shutdown();
+            process.exit(0);
+        });
+    }).catch((err) => {
+        createLogger('server').error('Failed to start server', { error: err.message });
+        process.exit(1);
+    });
+}