orbital-command 0.1.4 → 0.3.0

package/dist/server/server/project-manager.js

@@ -0,0 +1,297 @@
+import fs from 'fs';
+import { Router } from 'express';
+import { ProjectEmitter } from './project-emitter.js';
+import { createProjectContext } from './project-context.js';
+import { loadGlobalConfig, registerProject, unregisterProject, updateProject, findProject, } from './global-config.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 { createManifestRoutes } from './routes/manifest-routes.js';
+import { createTelemetryRoutes } from './services/telemetry-service.js';
+import { TEMPLATES_DIR } from './init.js';
+import { getPackageVersion } from './utils/package-info.js';
+import { resolveActiveDispatchesForScope } from './utils/dispatch-utils.js';
+import { createLogger } from './utils/logger.js';
+const log = createLogger('project-manager');
+// ─── Manager ────────────────────────────────────────────────
+export class ProjectManager {
+    io;
+    contexts = new Map();
+    routers = new Map();
+    healthCheckInterval = null;
+    constructor(io) {
+        this.io = io;
+    }
+    // ─── Initialization ─────────────────────────────────────
+    /** Initialize all enabled projects from the registry. */
+    async initializeAll() {
+        const config = loadGlobalConfig();
+        const enabledProjects = config.projects.filter(p => p.enabled);
+        log.info('Initializing projects', { count: enabledProjects.length });
+        for (const reg of enabledProjects) {
+            try {
+                await this.initializeProject(reg);
+            }
+            catch (err) {
+                log.error('Failed to initialize project', {
+                    id: reg.id,
+                    path: reg.path,
+                    error: String(err),
+                });
+            }
+        }
+        // Start periodic health checks
+        this.healthCheckInterval = setInterval(() => this.checkHealth(), 60_000);
+    }
+    /** Initialize a single project from its registration. */
+    async initializeProject(reg) {
+        // Verify directory exists
+        if (!fs.existsSync(reg.path)) {
+            log.warn('Project directory not found, marking offline', { id: reg.id, path: reg.path });
+            // Store a placeholder context to track status
+            return null;
+        }
+        const emitter = new ProjectEmitter(this.io, reg.id);
+        try {
+            const ctx = await createProjectContext(reg.id, reg.path, emitter);
+            this.contexts.set(reg.id, ctx);
+            // Build and cache the project's router
+            const router = this.buildProjectRouter(ctx);
+            this.routers.set(reg.id, router);
+            log.info('Project initialized', {
+                id: reg.id,
+                name: reg.name,
+                scopeCount: ctx.scopeService.getAll().length,
+            });
+            return ctx;
+        }
+        catch (err) {
+            log.error('Project initialization failed', { id: reg.id, error: String(err) });
+            return null;
+        }
+    }
+    // ─── Context Access ─────────────────────────────────────
+    /** Get a project context by ID. */
+    getContext(id) {
+        return this.contexts.get(id);
+    }
+    /** Get all active contexts. */
+    getAllContexts() {
+        return this.contexts;
+    }
+    /** Get the router for a project. */
+    getRouter(id) {
+        return this.routers.get(id);
+    }
+    /** Get all project routers. */
+    getAllRouters() {
+        return this.routers;
+    }
+    // ─── Project List ───────────────────────────────────────
+    /** Get summary of all registered projects with live status. */
+    getProjectList(options) {
+        const config = loadGlobalConfig();
+        return config.projects.map(reg => {
+            const ctx = this.contexts.get(reg.id);
+            const summary = {
+                id: reg.id,
+                name: reg.name,
+                path: reg.path,
+                color: reg.color,
+                status: ctx?.status ?? 'offline',
+                enabled: reg.enabled,
+                scopeCount: ctx ? ctx.scopeService.getAll().length : 0,
+                error: ctx?.error,
+            };
+            if (options?.includeWorkflow && ctx) {
+                summary.workflow = ctx.workflowService.getActive();
+            }
+            return summary;
+        });
+    }
+    // ─── Registration ───────────────────────────────────────
+    /** Register and initialize a new project. */
+    async addProject(projectRoot, options) {
+        const reg = registerProject(projectRoot, options);
+        const ctx = await this.initializeProject(reg);
+        // Notify all clients
+        this.io.emit('project:registered', {
+            id: reg.id,
+            name: reg.name,
+            path: reg.path,
+            color: reg.color,
+        });
+        return {
+            id: reg.id,
+            name: reg.name,
+            path: reg.path,
+            color: reg.color,
+            status: ctx?.status ?? 'offline',
+            enabled: reg.enabled,
+            scopeCount: ctx ? ctx.scopeService.getAll().length : 0,
+        };
+    }
+    /** Unregister a project and shut down its context. */
+    async removeProject(idOrPath) {
+        // Find the registration before removing
+        const config = loadGlobalConfig();
+        const reg = config.projects.find(p => p.id === idOrPath || p.path === idOrPath);
+        if (!reg)
+            return false;
+        // Shut down context
+        await this.shutdownProject(reg.id);
+        // Remove from registry
+        unregisterProject(idOrPath);
+        // Notify clients
+        this.io.emit('project:unregistered', { id: reg.id });
+        return true;
+    }
+    /** Update project metadata (name, color, enabled). */
+    async updateProject(id, updates) {
+        const result = updateProject(id, updates);
+        if (!result)
+            return null;
+        // If disabling, shut down the context
+        if (updates.enabled === false) {
+            await this.shutdownProject(id);
+        }
+        // If enabling, initialize the context
+        if (updates.enabled === true && !this.contexts.has(id)) {
+            const reg = findProject(id);
+            if (reg)
+                await this.initializeProject(reg);
+        }
+        // Notify clients of metadata change
+        this.io.emit('project:updated', { id, ...updates });
+        return result;
+    }
+    // ─── Lifecycle ──────────────────────────────────────────
+    /** Shut down a single project's context. */
+    async shutdownProject(id) {
+        const ctx = this.contexts.get(id);
+        if (ctx) {
+            await ctx.shutdown();
+            this.contexts.delete(id);
+            this.routers.delete(id);
+            log.info('Project shut down', { id });
+        }
+    }
+    /** Shut down all projects and stop health checks. */
+    async shutdownAll() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = null;
+        }
+        const shutdowns = [...this.contexts.entries()].map(([id, ctx]) => ctx.shutdown().catch(err => log.error('Error shutting down project', { id, error: String(err) })));
+        await Promise.all(shutdowns);
+        this.contexts.clear();
+        this.routers.clear();
+        log.info('All projects shut down');
+    }
+    // ─── Health Checks ──────────────────────────────────────
+    /** Periodic health check — detect projects that have gone offline or come back. */
+    async checkHealth() {
+        const config = loadGlobalConfig();
+        for (const reg of config.projects) {
+            if (!reg.enabled)
+                continue;
+            const ctx = this.contexts.get(reg.id);
+            const dirExists = fs.existsSync(reg.path);
+            if (ctx && !dirExists) {
+                // Project went offline
+                log.warn('Project directory disappeared', { id: reg.id, path: reg.path });
+                await this.shutdownProject(reg.id);
+                this.io.emit('project:status:changed', { id: reg.id, status: 'offline' });
+            }
+            else if (!ctx && dirExists) {
+                // Project came back online (or failed to initialize previously — retry)
+                log.info('Attempting to initialize project', { id: reg.id, path: reg.path });
+                try {
+                    await this.initializeProject(reg);
+                    this.io.emit('project:status:changed', { id: reg.id, status: 'active' });
+                }
+                catch (err) {
+                    log.warn('Project initialization retry failed', { id: reg.id, error: String(err) });
+                }
+            }
+        }
+    }
+    // ─── Route Building ─────────────────────────────────────
+    /** Build an Express Router with all per-project routes for a context. */
+    /** Build an Express Router with all per-project routes.
+     *  Note: createVersionRoutes is intentionally omitted — version/update endpoints
+     *  are global (they update the Orbital Command package), not per-project. */
+    buildProjectRouter(ctx) {
+        const router = Router();
+        const { db, emitter, config, scopeService, eventService, gateService, deployService, sprintService, sprintOrchestrator, batchOrchestrator, readinessService, workflowService, workflowEngine, gitService, githubService, telemetryService } = ctx;
+        // Scope status inference function (same logic as index.ts)
+        function inferScopeStatus(eventType, scopeId, data) {
+            if (scopeId == null)
+                return;
+            const id = Number(scopeId);
+            if (isNaN(id) || id <= 0)
+                return;
+            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;
+            if (typeof result === 'object' && 'dispatchResolution' in result) {
+                resolveActiveDispatchesForScope(db, emitter, id, result.resolution);
+                return;
+            }
+            scopeService.updateStatus(id, result, 'event');
+        }
+        // Project config endpoint
+        router.get('/config', (_req, res) => {
+            res.json({
+                projectName: config.projectName,
+                categories: config.categories,
+                agents: config.agents,
+                serverPort: config.serverPort,
+                clientPort: config.clientPort,
+            });
+        });
+        // Mount all route groups
+        router.use(createScopeRoutes({
+            db, io: emitter, scopeService, readinessService,
+            projectRoot: config.projectRoot, projectName: config.projectName,
+            engine: workflowEngine,
+        }));
+        router.use(createDataRoutes({
+            db, io: emitter, eventService, gateService, deployService, gitService,
+            engine: workflowEngine, projectRoot: config.projectRoot,
+            inferScopeStatus,
+        }));
+        router.use(createDispatchRoutes({
+            db, io: emitter, scopeService,
+            projectRoot: config.projectRoot, engine: workflowEngine,
+        }));
+        router.use(createSprintRoutes({
+            sprintService, sprintOrchestrator, batchOrchestrator,
+        }));
+        router.use(createWorkflowRoutes({
+            workflowService, projectRoot: config.projectRoot,
+        }));
+        router.use(createConfigRoutes({
+            projectRoot: config.projectRoot, workflowService, io: emitter,
+        }));
+        router.use(createGitRoutes({
+            gitService, githubService, engine: workflowEngine,
+        }));
+        router.use(createManifestRoutes({
+            projectRoot: config.projectRoot,
+            templatesDir: TEMPLATES_DIR,
+            packageVersion: getPackageVersion(),
+            io: emitter,
+        }));
+        router.use(createTelemetryRoutes({ telemetryService }));
+        return router;
+    }
+}

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

@@ -1,5 +1,6 @@
 import { Router } from 'express';
 import { ConfigService, isValidPrimitiveType } from '../services/config-service.js';
+import { errMsg } from '../utils/route-helpers.js';
 export function createConfigRoutes({ projectRoot, workflowService: _workflowService, io }) {
     const router = Router();
     const configService = new ConfigService(projectRoot);
@@ -158,6 +159,3 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
     });
     return router;
 }
-function errMsg(err) {
-    return err instanceof Error ? err.message : String(err);
-}

package/dist/server/server/routes/data-routes.js

@@ -5,6 +5,8 @@ import { promisify } from 'util';
 import { getHookEnforcement } from '../../shared/workflow-config.js';
 import { getClaudeSessions, getSessionStats } from '../services/claude-session-service.js';
 import { launchInTerminal } from '../utils/terminal-launcher.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('server');
 const execFileAsync = promisify(execFile);
 const JSON_FIELDS = ['tags', 'blocked_by', 'blocks', 'data', 'discoveries', 'next_steps', 'details'];
 function parseJsonFields(row) {
@@ -19,77 +21,14 @@ function parseJsonFields(row) {
     }
     return parsed;
 }
-function parseDriftCommits(raw) {
-    if (!raw)
-        return [];
-    return raw.split('\n').map((line) => {
-        const [sha, date, message, author] = line.split('|');
-        return { sha, date, message: message ?? '', author: author ?? '' };
-    });
-}
-function parseHead(raw) {
-    const [sha, date, message] = raw.split('|');
-    return { sha: sha ?? '', date: date ?? '', message: message ?? '' };
-}
-export function createDataRoutes({ db, io, gateService, deployService, engine, projectRoot, inferScopeStatus, }) {
+export function createDataRoutes({ db, io, eventService, gateService, deployService, gitService, engine, projectRoot, inferScopeStatus, }) {
     const router = Router();
-    // ─── Pipeline Drift (cached) ─────────────────────────────
-    let driftCache = null;
-    const DRIFT_CACHE_MS = 60_000;
-    async function gitLog(args) {
-        const { stdout } = await execFileAsync('git', args, { cwd: projectRoot });
-        return stdout.trim();
-    }
-    async function computeDrift() {
-        if (driftCache && Date.now() - driftCache.ts < DRIFT_CACHE_MS)
-            return driftCache.data;
-        const [devToStagingRaw, stagingToMainRaw, devHead, stagingHead, mainHead] = await Promise.all([
-            gitLog(['log', 'origin/dev', '--not', 'origin/staging', '--reverse', '--format=%H|%aI|%s|%an']),
-            gitLog(['log', 'origin/staging', '--not', 'origin/main', '--reverse', '--format=%H|%aI|%s|%an']),
-            gitLog(['log', 'origin/dev', '-1', '--format=%H|%aI|%s']),
-            gitLog(['log', 'origin/staging', '-1', '--format=%H|%aI|%s']),
-            gitLog(['log', 'origin/main', '-1', '--format=%H|%aI|%s']),
-        ]);
-        const devToStaging = parseDriftCommits(devToStagingRaw);
-        const stagingToMain = parseDriftCommits(stagingToMainRaw);
-        const data = {
-            devToStaging: {
-                count: devToStaging.length,
-                commits: devToStaging,
-                oldestDate: devToStaging[0]?.date ?? null,
-            },
-            stagingToMain: {
-                count: stagingToMain.length,
-                commits: stagingToMain,
-                oldestDate: stagingToMain[0]?.date ?? null,
-            },
-            heads: {
-                dev: parseHead(devHead),
-                staging: parseHead(stagingHead),
-                main: parseHead(mainHead),
-            },
-        };
-        driftCache = { data, ts: Date.now() };
-        return data;
-    }
     // ─── Event Routes ──────────────────────────────────────────
     router.get('/events', (req, res) => {
         const limit = Number(req.query.limit) || 50;
         const type = req.query.type;
-        const scopeId = req.query.scope_id;
-        let query = 'SELECT * FROM events WHERE 1=1';
-        const params = [];
-        if (type) {
-            query += ' AND type = ?';
-            params.push(type);
-        }
-        if (scopeId) {
-            query += ' AND scope_id = ?';
-            params.push(Number(scopeId));
-        }
-        query += ' ORDER BY timestamp DESC LIMIT ?';
-        params.push(limit);
-        const events = db.prepare(query).all(...params);
+        const scopeId = req.query.scope_id ? Number(req.query.scope_id) : undefined;
+        const events = eventService.getFiltered({ limit, type, scopeId });
         res.json(events.map(parseJsonFields));
     });
     router.post('/events', (req, res) => {
@@ -115,18 +54,10 @@ export function createDataRoutes({ db, io, gateService, deployService, engine, p
     // ─── Violations Summary ──────────────────────────────────
     router.get('/events/violations/summary', (_req, res) => {
         try {
-            const byRule = db.prepare(`SELECT JSON_EXTRACT(data, '$.rule') as rule, COUNT(*) as count, MAX(timestamp) as last_seen
-         FROM events WHERE type = 'VIOLATION' GROUP BY rule ORDER BY count DESC`).all();
-            const byFile = db.prepare(`SELECT JSON_EXTRACT(data, '$.file') as file, COUNT(*) as count FROM events
-         WHERE type = 'VIOLATION' AND JSON_EXTRACT(data, '$.file') IS NOT NULL AND JSON_EXTRACT(data, '$.file') != ''
-         GROUP BY file ORDER BY count DESC LIMIT 20`).all();
-            const overrides = db.prepare(`SELECT JSON_EXTRACT(data, '$.rule') as rule, JSON_EXTRACT(data, '$.reason') as reason, timestamp as date
-         FROM events WHERE type = 'OVERRIDE' ORDER BY timestamp DESC LIMIT 50`).all();
-            const totalViolations = db.prepare(`SELECT COUNT(*) as count FROM events WHERE type = 'VIOLATION'`).get();
-            const totalOverrides = db.prepare(`SELECT COUNT(*) as count FROM events WHERE type = 'OVERRIDE'`).get();
-            res.json({ byRule, byFile, overrides, totalViolations: totalViolations.count, totalOverrides: totalOverrides.count });
-        }
-        catch {
+            res.json(eventService.getViolationSummary());
+        }
+        catch (err) {
+            log.error('Violations summary failed', { error: String(err) });
             res.status(500).json({ error: 'Failed to query violations summary' });
         }
     });
@@ -144,13 +75,7 @@ export function createDataRoutes({ db, io, gateService, deployService, engine, p
                     hookEdgeMap.get(hookId).push({ from: edge.from, to: edge.to, label: edge.label });
                 }
             }
-            // Query violation and override stats per rule
-            const violationStats = db.prepare(`SELECT JSON_EXTRACT(data, '$.rule') as rule, COUNT(*) as count, MAX(timestamp) as last_seen
-         FROM events WHERE type = 'VIOLATION' GROUP BY rule`).all();
-            const overrideStats = db.prepare(`SELECT JSON_EXTRACT(data, '$.rule') as rule, COUNT(*) as count
-         FROM events WHERE type = 'OVERRIDE' GROUP BY rule`).all();
-            const violationMap = new Map(violationStats.map((v) => [v.rule, v]));
-            const overrideMap = new Map(overrideStats.map((o) => [o.rule, o]));
+            const { violations: violationMap, overrides: overrideMap } = eventService.getViolationStatsByRule();
             // Build summary counts
             const summary = { guards: 0, gates: 0, lifecycle: 0, observers: 0 };
             for (const hook of allHooks) {
@@ -175,20 +100,19 @@ export function createDataRoutes({ db, io, gateService, deployService, engine, p
             }));
             res.json({ summary, rules, totalEdges: allEdges.length });
         }
-        catch {
+        catch (err) {
+            log.error('Enforcement rules failed', { error: String(err) });
             res.status(500).json({ error: 'Failed to query enforcement rules' });
         }
     });
     // ─── Violation Trends ──────────────────────────────────────
     router.get('/events/violations/trend', (req, res) => {
         try {
-            const days = Number(req.query.days) || 30;
-            const trend = db.prepare(`SELECT date(timestamp) as day, JSON_EXTRACT(data, '$.rule') as rule, COUNT(*) as count
-         FROM events WHERE type = 'VIOLATION' AND timestamp >= datetime('now', ? || ' days')
-         GROUP BY day, rule ORDER BY day ASC`).all(`-${days}`);
-            res.json(trend);
+            const days = Math.max(1, Math.min(365, Number(req.query.days) || 30));
+            res.json(eventService.getViolationTrend(days));
         }
-        catch {
+        catch (err) {
+            log.error('Violation trends failed', { error: String(err) });
             res.status(500).json({ error: 'Failed to query violation trends' });
         }
     });
@@ -251,8 +175,7 @@ export function createDataRoutes({ db, io, gateService, deployService, engine, p
     });
     router.get('/pipeline/drift', async (_req, res) => {
         try {
-            const drift = await computeDrift();
-            res.json(drift);
+            res.json(await gitService.getPipelineDrift());
         }
         catch (err) {
             res.status(500).json({ error: 'Failed to compute drift', details: String(err) });
@@ -260,21 +183,10 @@ export function createDataRoutes({ db, io, gateService, deployService, engine, p
     });
     router.get('/deployments/frequency', (_req, res) => {
         try {
-            const rows = db.prepare(`SELECT environment, strftime('%Y-W%W', started_at) as week, COUNT(*) as count
-         FROM deployments WHERE started_at > datetime('now', '-56 days') GROUP BY environment, week ORDER BY week ASC`).all();
-            const weekMap = new Map();
-            for (const row of rows) {
-                if (!weekMap.has(row.week))
-                    weekMap.set(row.week, { week: row.week, staging: 0, production: 0 });
-                const entry = weekMap.get(row.week);
-                if (row.environment === 'staging')
-                    entry.staging = row.count;
-                if (row.environment === 'production')
-                    entry.production = row.count;
-            }
-            res.json([...weekMap.values()]);
+            res.json(eventService.getDeployFrequency());
         }
-        catch {
+        catch (err) {
+            log.error('Deploy frequency query failed', { error: String(err) });
             res.status(500).json({ error: 'Failed to query deployment frequency' });
         }
     });
@@ -330,7 +242,7 @@ export function createDataRoutes({ db, io, gateService, deployService, engine, p
         let meta = null;
         let stats = null;
         if (parsed.claude_session_id && typeof parsed.claude_session_id === 'string') {
-            const claudeSessions = await getClaudeSessions();
+            const claudeSessions = await getClaudeSessions(undefined, projectRoot);
             const match = claudeSessions.find(s => s.id === parsed.claude_session_id);
             if (match) {
                 meta = {
@@ -342,7 +254,7 @@ export function createDataRoutes({ db, io, gateService, deployService, engine, p
                     lastActiveAt: match.lastActiveAt,
                 };
             }
-            stats = getSessionStats(parsed.claude_session_id);
+            stats = getSessionStats(parsed.claude_session_id, projectRoot);
         }
         if (!content) {
             const parts = [];

package/dist/server/server/routes/dispatch-routes.js

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { launchInCategorizedTerminal, escapeForAnsiC, buildSessionName, snapshotSessionPids, discoverNewSession, renameSession } from '../utils/terminal-launcher.js';
+import { launchInCategorizedTerminal, escapeForAnsiC, shellQuote, buildSessionName, snapshotSessionPids, discoverNewSession, renameSession } from '../utils/terminal-launcher.js';
 import { resolveDispatchEvent, resolveAbandonedDispatchesForScope, getActiveScopeIds, getAbandonedScopeIds, linkPidToDispatch } from '../utils/dispatch-utils.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('dispatch');
@@ -69,20 +69,23 @@ export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine
         // Launch in iTerm — interactive TUI mode (no -p) for full visibility
         const promptText = prompt ?? command;
         const escaped = escapeForAnsiC(promptText);
-        const fullCmd = `cd '${projectRoot}' && ORBITAL_DISPATCH_ID='${eventId}' claude --dangerously-skip-permissions $'${escaped}'`;
+        const fullCmd = `cd '${shellQuote(projectRoot)}' && ORBITAL_DISPATCH_ID='${shellQuote(eventId)}' claude --dangerously-skip-permissions $'${escaped}'`;
         try {
             await launchInCategorizedTerminal(command, fullCmd, sessionName);
             res.json({ ok: true, dispatch_id: eventId, scope_id: scope_id ?? null });
-            // Fire-and-forget: discover session PID, link to dispatch, and rename
+            // Fire-and-forget: discover session PID, link to dispatch, and rename.
+            // If discovery fails, SESSION_START event handler will link via ORBITAL_DISPATCH_ID.
             discoverNewSession(projectRoot, beforePids)
                 .then((session) => {
-                if (!session)
+                if (!session) {
+                    log.warn('PID discovery returned null — dispatch will rely on ORBITAL_DISPATCH_ID for linkage', { dispatch_id: eventId, scope_id });
                     return;
+                }
                 linkPidToDispatch(db, eventId, session.pid);
                 if (sessionName)
                     renameSession(projectRoot, session.sessionId, sessionName);
             })
-                .catch(err => log.error('PID discovery failed', { error: err.message }));
+                .catch(err => log.warn('PID discovery failed — dispatch will rely on ORBITAL_DISPATCH_ID for linkage', { dispatch_id: eventId, error: err.message }));
         }
         catch (err) {
             if (scope_id != null && transition?.from) {
@@ -188,18 +191,21 @@ export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine
         // Launch single CLI session
         const batchEscaped = escapeForAnsiC(command);
         const beforePids = snapshotSessionPids(projectRoot);
-        const fullCmd = `cd '${projectRoot}' && ORBITAL_DISPATCH_ID='${eventId}' claude --dangerously-skip-permissions -p $'${batchEscaped}'`;
+        const fullCmd = `cd '${shellQuote(projectRoot)}' && ORBITAL_DISPATCH_ID='${shellQuote(eventId)}' claude --dangerously-skip-permissions -p $'${batchEscaped}'`;
         try {
             await launchInCategorizedTerminal(command, fullCmd);
             res.json({ ok: true, dispatch_id: eventId, scope_ids });
-            // Fire-and-forget: discover session PID and link to dispatch
+            // Fire-and-forget: discover session PID and link to dispatch.
+            // If discovery fails, SESSION_START event handler will link via ORBITAL_DISPATCH_ID.
             discoverNewSession(projectRoot, beforePids)
                 .then((session) => {
-                if (!session)
+                if (!session) {
+                    log.warn('Batch PID discovery returned null — dispatch will rely on ORBITAL_DISPATCH_ID for linkage', { dispatch_id: eventId });
                     return;
+                }
                 linkPidToDispatch(db, eventId, session.pid);
             })
-                .catch(err => log.error('Batch PID discovery failed', { error: err.message }));
+                .catch(err => log.warn('Batch PID discovery failed — dispatch will rely on ORBITAL_DISPATCH_ID for linkage', { dispatch_id: eventId, error: err.message }));
         }
         catch (err) {
             if (transition?.from) {

package/dist/server/server/routes/git-routes.js

@@ -88,5 +88,79 @@ export function createGitRoutes({ gitService, githubService, engine }) {
             res.status(500).json({ error: 'Failed to get PRs', details: String(err) });
         }
     });
+    // ─── GitHub Auth Flow ──────────────────────────────────────
+    router.post('/github/connect', async (req, res) => {
+        try {
+            const { method, token } = req.body;
+            if (method === 'pat' && token) {
+                const result = await githubService.connectWithToken(token);
+                res.json(result);
+            }
+            else {
+                const result = await githubService.connectOAuth();
+                res.json(result);
+            }
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to connect', details: String(err) });
+        }
+    });
+    router.get('/github/auth-status', async (_req, res) => {
+        try {
+            const status = await githubService.getAuthStatus();
+            res.json(status);
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to check auth', details: String(err) });
+        }
+    });
+    router.post('/github/disconnect', async (_req, res) => {
+        try {
+            const result = await githubService.disconnect();
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to disconnect', details: String(err) });
+        }
+    });
+    // ─── GitHub CI Checks ──────────────────────────────────────
+    router.get('/github/checks/:ref', async (req, res) => {
+        try {
+            const checks = await githubService.getCheckRuns(req.params.ref);
+            res.json(checks);
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to get checks', details: String(err) });
+        }
+    });
+    // ─── Git Health Metrics ────────────────────────────────────
+    router.get('/git/health', async (_req, res) => {
+        try {
+            // Get PR ages for health calculation
+            let prAges = [];
+            try {
+                const prs = await githubService.getOpenPRs();
+                const now = Date.now();
+                prAges = prs.map(pr => Math.round((now - new Date(pr.createdAt).getTime()) / (1000 * 60 * 60 * 24)));
+            }
+            catch { /* ok — GitHub may not be connected */ }
+            const health = await gitService.getHealthMetrics(prAges);
+            res.json(health);
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to get health metrics', details: String(err) });
+        }
+    });
+    // ─── Git Activity Series ───────────────────────────────────
+    router.get('/git/activity', async (req, res) => {
+        try {
+            const days = Number(req.query.days) || 30;
+            const activity = await gitService.getActivitySeries(days);
+            res.json(activity);
+        }
+        catch (err) {
+            res.status(500).json({ error: 'Failed to get activity', details: String(err) });
+        }
+    });
     return router;
 }