orbital-command 0.2.0 → 1.0.0

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 { catchRoute, inferErrorStatus } from '../utils/route-helpers.js';
 export function createConfigRoutes({ projectRoot, workflowService: _workflowService, io }) {
     const router = Router();
     const configService = new ConfigService(projectRoot);
@@ -12,21 +13,16 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
         return typeParam;
     }
     // GET /config/:type/tree — directory tree with frontmatter
-    router.get('/config/:type/tree', (req, res) => {
+    router.get('/config/:type/tree', catchRoute((req, res) => {
         const type = parseType(req.params.type, res);
         if (!type)
             return;
-        try {
-            const basePath = configService.getBasePath(type);
-            const tree = configService.scanDirectory(basePath);
-            res.json({ success: true, data: tree });
-        }
-        catch (err) {
-            res.status(500).json({ success: false, error: errMsg(err) });
-        }
-    });
+        const basePath = configService.getBasePath(type);
+        const tree = configService.scanDirectory(basePath);
+        res.json({ success: true, data: tree });
+    }));
     // GET /config/:type/file?path=<relative> — file content
-    router.get('/config/:type/file', (req, res) => {
+    router.get('/config/:type/file', catchRoute((req, res) => {
         const type = parseType(req.params.type, res);
         if (!type)
             return;
@@ -35,19 +31,12 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
             res.status(400).json({ success: false, error: 'path query parameter is required' });
             return;
         }
-        try {
-            const basePath = configService.getBasePath(type);
-            const content = configService.readFile(basePath, filePath);
-            res.json({ success: true, data: { path: filePath, content } });
-        }
-        catch (err) {
-            const msg = errMsg(err);
-            const status = msg.includes('traversal') ? 403 : msg.includes('ENOENT') || msg.includes('not found') ? 404 : 500;
-            res.status(status).json({ success: false, error: msg });
-        }
-    });
+        const basePath = configService.getBasePath(type);
+        const content = configService.readFile(basePath, filePath);
+        res.json({ success: true, data: { path: filePath, content } });
+    }, inferErrorStatus));
     // PUT /config/:type/file — save file { path, content }
-    router.put('/config/:type/file', (req, res) => {
+    router.put('/config/:type/file', catchRoute((req, res) => {
         const type = parseType(req.params.type, res);
         if (!type)
             return;
@@ -56,20 +45,13 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
             res.status(400).json({ success: false, error: 'path and content are required' });
             return;
         }
-        try {
-            const basePath = configService.getBasePath(type);
-            configService.writeFile(basePath, filePath, content);
-            io.emit(`config:${type}:changed`, { action: 'updated', path: filePath });
-            res.json({ success: true });
-        }
-        catch (err) {
-            const msg = errMsg(err);
-            const status = msg.includes('traversal') ? 403 : msg.includes('not found') ? 404 : 500;
-            res.status(status).json({ success: false, error: msg });
-        }
-    });
+        const basePath = configService.getBasePath(type);
+        configService.writeFile(basePath, filePath, content);
+        io.emit(`config:${type}:changed`, { action: 'updated', path: filePath });
+        res.json({ success: true });
+    }, inferErrorStatus));
     // POST /config/:type/file — create file { path, content }
-    router.post('/config/:type/file', (req, res) => {
+    router.post('/config/:type/file', catchRoute((req, res) => {
         const type = parseType(req.params.type, res);
         if (!type)
             return;
@@ -78,20 +60,13 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
             res.status(400).json({ success: false, error: 'path and content are required' });
             return;
         }
-        try {
-            const basePath = configService.getBasePath(type);
-            configService.createFile(basePath, filePath, content);
-            io.emit(`config:${type}:changed`, { action: 'created', path: filePath });
-            res.status(201).json({ success: true });
-        }
-        catch (err) {
-            const msg = errMsg(err);
-            const status = msg.includes('traversal') ? 403 : msg.includes('already exists') ? 409 : 500;
-            res.status(status).json({ success: false, error: msg });
-        }
-    });
+        const basePath = configService.getBasePath(type);
+        configService.createFile(basePath, filePath, content);
+        io.emit(`config:${type}:changed`, { action: 'created', path: filePath });
+        res.status(201).json({ success: true });
+    }, inferErrorStatus));
     // DELETE /config/:type/file?path=<relative> — delete file
-    router.delete('/config/:type/file', (req, res) => {
+    router.delete('/config/:type/file', catchRoute((req, res) => {
         const type = parseType(req.params.type, res);
         if (!type)
             return;
@@ -100,20 +75,13 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
             res.status(400).json({ success: false, error: 'path query parameter is required' });
             return;
         }
-        try {
-            const basePath = configService.getBasePath(type);
-            configService.deleteFile(basePath, filePath);
-            io.emit(`config:${type}:changed`, { action: 'deleted', path: filePath });
-            res.json({ success: true });
-        }
-        catch (err) {
-            const msg = errMsg(err);
-            const status = msg.includes('traversal') ? 403 : msg.includes('not found') ? 404 : msg.includes('directory') ? 400 : 500;
-            res.status(status).json({ success: false, error: msg });
-        }
-    });
+        const basePath = configService.getBasePath(type);
+        configService.deleteFile(basePath, filePath);
+        io.emit(`config:${type}:changed`, { action: 'deleted', path: filePath });
+        res.json({ success: true });
+    }, inferErrorStatus));
     // POST /config/:type/rename — rename { oldPath, newPath }
-    router.post('/config/:type/rename', (req, res) => {
+    router.post('/config/:type/rename', catchRoute((req, res) => {
         const type = parseType(req.params.type, res);
         if (!type)
             return;
@@ -122,20 +90,13 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
             res.status(400).json({ success: false, error: 'oldPath and newPath are required' });
             return;
         }
-        try {
-            const basePath = configService.getBasePath(type);
-            configService.renameFile(basePath, oldPath, newPath);
-            io.emit(`config:${type}:changed`, { action: 'renamed', oldPath, newPath });
-            res.json({ success: true });
-        }
-        catch (err) {
-            const msg = errMsg(err);
-            const status = msg.includes('traversal') ? 403 : msg.includes('not found') ? 404 : msg.includes('already exists') ? 409 : 500;
-            res.status(status).json({ success: false, error: msg });
-        }
-    });
+        const basePath = configService.getBasePath(type);
+        configService.renameFile(basePath, oldPath, newPath);
+        io.emit(`config:${type}:changed`, { action: 'renamed', oldPath, newPath });
+        res.json({ success: true });
+    }, inferErrorStatus));
     // POST /config/:type/folder — create folder { path }
-    router.post('/config/:type/folder', (req, res) => {
+    router.post('/config/:type/folder', catchRoute((req, res) => {
         const type = parseType(req.params.type, res);
         if (!type)
             return;
@@ -144,20 +105,10 @@ export function createConfigRoutes({ projectRoot, workflowService: _workflowServ
             res.status(400).json({ success: false, error: 'path is required' });
             return;
         }
-        try {
-            const basePath = configService.getBasePath(type);
-            configService.createFolder(basePath, folderPath);
-            io.emit(`config:${type}:changed`, { action: 'folder-created', path: folderPath });
-            res.status(201).json({ success: true });
-        }
-        catch (err) {
-            const msg = errMsg(err);
-            const status = msg.includes('traversal') ? 403 : msg.includes('already exists') ? 409 : 500;
-            res.status(status).json({ success: false, error: msg });
-        }
-    });
+        const basePath = configService.getBasePath(type);
+        configService.createFolder(basePath, folderPath);
+        io.emit(`config:${type}:changed`, { action: 'folder-created', path: folderPath });
+        res.status(201).json({ success: true });
+    }, inferErrorStatus));
     return router;
 }
-function errMsg(err) {
-    return err instanceof Error ? err.message : String(err);
-}

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

@@ -5,91 +5,19 @@ 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 { buildClaudeFlags } from '../utils/flag-builder.js';
+import { createLogger } from '../utils/logger.js';
+import { parseJsonFields } from '../utils/json-fields.js';
+const log = createLogger('server');
 const execFileAsync = promisify(execFile);
-const JSON_FIELDS = ['tags', 'blocked_by', 'blocks', 'data', 'discoveries', 'next_steps', 'details'];
-function parseJsonFields(row) {
-    const parsed = { ...row };
-    for (const field of JSON_FIELDS) {
-        if (typeof parsed[field] === 'string') {
-            try {
-                parsed[field] = JSON.parse(parsed[field]);
-            }
-            catch { /* keep string */ }
-        }
-    }
-    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, config, }) {
     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 +43,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 });
+            res.json(eventService.getViolationSummary());
         }
-        catch {
+        catch (err) {
+            log.error('Violations summary failed', { error: String(err) });
             res.status(500).json({ error: 'Failed to query violations summary' });
         }
     });
@@ -144,13 +64,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 +89,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 +164,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 +172,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 +231,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 +243,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 = [];
@@ -377,7 +278,8 @@ export function createDataRoutes({ db, io, gateService, deployService, engine, p
             res.status(400).json({ error: 'Valid claude_session_id (UUID) required' });
             return;
         }
-        const resumeCmd = `cd '${projectRoot}' && claude --dangerously-skip-permissions --resume '${claude_session_id}'`;
+        const flagsStr = buildClaudeFlags(config.claude.dispatchFlags);
+        const resumeCmd = `cd '${projectRoot}' && claude ${flagsStr} --resume '${claude_session_id}'`;
         try {
             await launchInTerminal(resumeCmd);
             res.json({ ok: true, session_id: claude_session_id });

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

@@ -1,10 +1,11 @@
 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 { buildClaudeFlags, buildEnvVarPrefix } from '../utils/flag-builder.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('dispatch');
-const MAX_BATCH_SIZE = 20;
-export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine }) {
+const DEFAULT_MAX_BATCH_SIZE = 20;
+export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine, config }) {
     const router = Router();
     router.get('/dispatch/active-scopes', (_req, res) => {
         const scope_ids = getActiveScopeIds(db, scopeService, engine);
@@ -44,6 +45,16 @@ export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine
                 return;
             }
         }
+        // Max concurrent dispatches guard
+        const maxConcurrent = config.dispatch.maxConcurrent;
+        if (maxConcurrent > 0) {
+            const activeCount = db.prepare(`SELECT COUNT(*) as count FROM events
+         WHERE type = 'DISPATCH' AND JSON_EXTRACT(data, '$.resolved') IS NULL`).get().count;
+            if (activeCount >= maxConcurrent) {
+                res.status(429).json({ error: `Max concurrent dispatches reached (${maxConcurrent})` });
+                return;
+            }
+        }
         // Update scope status if transition provided
         if (scope_id != null && transition?.to) {
             const result = scopeService.updateStatus(scope_id, transition.to, 'dispatch');
@@ -66,23 +77,28 @@ export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine
         const scope = scope_id != null ? scopeService.getById(scope_id) : undefined;
         const sessionName = buildSessionName({ scopeId: scope_id ?? undefined, title: scope?.title, command });
         const beforePids = snapshotSessionPids(projectRoot);
-        // Launch in iTerm — interactive TUI mode (no -p) for full visibility
+        // Launch in iTerm — interactive TUI mode (no -p unless printMode) 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 flagsStr = buildClaudeFlags(config.claude.dispatchFlags);
+        const envPrefix = buildEnvVarPrefix(config.dispatch.envVars);
+        const fullCmd = `cd '${shellQuote(projectRoot)}' && ${envPrefix}ORBITAL_DISPATCH_ID='${shellQuote(eventId)}' claude ${flagsStr} $'${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) {
@@ -157,8 +173,9 @@ export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine
             return;
         }
         // W-12: Validate batch size and scope ID types
-        if (scope_ids.length > MAX_BATCH_SIZE) {
-            res.status(400).json({ error: `Maximum batch size is ${MAX_BATCH_SIZE}` });
+        const maxBatch = config.dispatch.maxBatchSize || DEFAULT_MAX_BATCH_SIZE;
+        if (scope_ids.length > maxBatch) {
+            res.status(400).json({ error: `Maximum batch size is ${maxBatch}` });
             return;
         }
         if (!scope_ids.every(id => Number.isInteger(id) && id > 0)) {
@@ -185,21 +202,26 @@ export function createDispatchRoutes({ db, io, scopeService, projectRoot, engine
             session_id: null, agent: 'dashboard', data: eventData,
             timestamp: new Date().toISOString(),
         });
-        // Launch single CLI session
+        // Launch single CLI session with batch env vars
         const batchEscaped = escapeForAnsiC(command);
         const beforePids = snapshotSessionPids(projectRoot);
-        const fullCmd = `cd '${projectRoot}' && ORBITAL_DISPATCH_ID='${eventId}' claude --dangerously-skip-permissions -p $'${batchEscaped}'`;
+        const batchFlags = buildClaudeFlags(config.claude.dispatchFlags);
+        const envPrefix = buildEnvVarPrefix(config.dispatch.envVars);
+        const fullCmd = `cd '${shellQuote(projectRoot)}' && ${envPrefix}ORBITAL_DISPATCH_ID='${shellQuote(eventId)}' claude ${batchFlags} $'${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;
 }