orbital-command 0.1.0

package/dist/server/server/services/claude-session-service.js

@@ -0,0 +1,352 @@
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+import { getConfig, getClaudeSessionsDir } from '../config.js';
+function getSessionsDir() {
+    return getClaudeSessionsDir(getConfig().projectRoot);
+}
+let cache = null;
+const CACHE_TTL_MS = 60_000;
+/**
+ * Extract metadata from a JSONL session file by reading the first few
+ * lines and the last line (avoids parsing the entire file).
+ */
+async function parseSessionFile(filePath) {
+    const stat = fs.statSync(filePath);
+    const filename = path.basename(filePath, '.jsonl');
+    let sessionId = filename;
+    let slug = '';
+    let branch = '';
+    let startedAt = '';
+    let summary = null;
+    // Read first 20 lines for metadata
+    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    let lineNum = 0;
+    for await (const line of rl) {
+        if (lineNum > 20)
+            break;
+        lineNum++;
+        try {
+            const data = JSON.parse(line);
+            if (data.sessionId && !sessionId)
+                sessionId = data.sessionId;
+            if (data.slug && !slug)
+                slug = data.slug;
+            if (data.gitBranch && !branch)
+                branch = data.gitBranch;
+            // Capture the earliest timestamp
+            if (!startedAt) {
+                const ts = data.timestamp ??
+                    data.snapshot?.timestamp;
+                if (ts)
+                    startedAt = ts;
+            }
+            // If we have all fields, stop early
+            if (sessionId && slug && branch && startedAt)
+                break;
+        }
+        catch {
+            // skip unparseable lines
+        }
+    }
+    rl.close();
+    stream.destroy();
+    if (!sessionId)
+        return null;
+    // Read file content for summary extraction
+    try {
+        const fullContent = fs.readFileSync(filePath, 'utf-8');
+        const lines = fullContent.trimEnd().split('\n');
+        // Prefer explicit summary line from Claude
+        const lastLine = JSON.parse(lines[lines.length - 1]);
+        if (lastLine.type === 'summary' && lastLine.summary) {
+            summary = lastLine.summary;
+        }
+        // Fall back to first user message
+        if (!summary) {
+            summary = extractFirstUserMessage(lines, 120);
+        }
+    }
+    catch {
+        // ignore
+    }
+    return {
+        id: sessionId,
+        slug: slug || filename,
+        branch: branch || 'unknown',
+        startedAt: startedAt || stat.birthtime.toISOString(),
+        lastActiveAt: stat.mtime.toISOString(),
+        summary,
+        fileSize: stat.size,
+    };
+}
+export async function getClaudeSessions(since) {
+    if (cache && Date.now() < cache.expiry) {
+        return filterSince(cache.sessions, since);
+    }
+    const sessionsDir = getSessionsDir();
+    if (!fs.existsSync(sessionsDir))
+        return [];
+    const files = fs
+        .readdirSync(sessionsDir)
+        .filter((f) => f.endsWith('.jsonl'))
+        .map((f) => path.join(sessionsDir, f));
+    const sessions = [];
+    for (const file of files) {
+        const session = await parseSessionFile(file);
+        if (session)
+            sessions.push(session);
+    }
+    // Sort by most recent first
+    sessions.sort((a, b) => new Date(b.lastActiveAt).getTime() - new Date(a.lastActiveAt).getTime());
+    cache = { sessions, expiry: Date.now() + CACHE_TTL_MS };
+    return filterSince(sessions, since);
+}
+function filterSince(sessions, since) {
+    if (!since)
+        return sessions;
+    const cutoff = new Date(since).getTime();
+    return sessions.filter((s) => new Date(s.lastActiveAt).getTime() >= cutoff);
+}
+/** Truncate text to max length with ellipsis */
+function truncate(text, max) {
+    if (!text)
+        return '';
+    return text.length > max ? text.slice(0, max) + '...' : text;
+}
+/**
+ * Extract a meaningful session name from JSONL lines.
+ *
+ * Priority:
+ * 1. First non-meta user message (what the user actually typed)
+ * 2. Slash command name from the first command-message (e.g. "/scope review 1")
+ * 3. null if nothing useful found
+ *
+ * Skips isMeta messages (skill prompts injected by the system),
+ * tool_result lines, and raw command XML.
+ */
+function extractFirstUserMessage(lines, max) {
+    let slashCommand = null;
+    for (const line of lines) {
+        try {
+            const data = JSON.parse(line);
+            if (data.type !== 'user')
+                continue;
+            const content = data.message?.content;
+            let text = '';
+            if (typeof content === 'string') {
+                text = content;
+            }
+            else if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block?.type === 'text' && typeof block.text === 'string') {
+                        text = block.text;
+                        break;
+                    }
+                }
+            }
+            if (!text)
+                continue;
+            // Capture slash command as fallback (e.g. "/scope review 1")
+            if (!slashCommand && text.includes('<command-name>')) {
+                const cmdMatch = text.match(/<command-name>\/?(.+?)<\/command-name>/);
+                const argsMatch = text.match(/<command-args>(.+?)<\/command-args>/);
+                if (cmdMatch) {
+                    slashCommand = '/' + cmdMatch[1] + (argsMatch ? ' ' + argsMatch[1] : '');
+                }
+            }
+            // Skip system-injected lines: commands, meta/skill prompts, tool results
+            if (text.startsWith('<command') || text.startsWith('<tool_result'))
+                continue;
+            if (data.isMeta)
+                continue;
+            return truncate(text.trim(), max);
+        }
+        catch {
+            // skip unparseable lines
+        }
+    }
+    return slashCommand ?? null;
+}
+/**
+ * Parse a full JSONL file and return detailed stats grouped by line type.
+ * This is heavier than parseSessionFile — only called for the detail view.
+ */
+export function getSessionStats(claudeSessionId) {
+    const filePath = path.join(getSessionsDir(), `${claudeSessionId}.jsonl`);
+    if (!fs.existsSync(filePath))
+        return null;
+    const stats = {
+        typeCounts: {},
+        user: { totalMessages: 0, metaMessages: 0, toolResults: 0, commands: [], permissionModes: [], cwd: null, version: null },
+        assistant: { totalMessages: 0, models: [], totalInputTokens: 0, totalOutputTokens: 0, totalCacheReadTokens: 0, totalCacheCreationTokens: 0, toolsUsed: {} },
+        system: { totalMessages: 0, subtypes: [], stopReasons: [], totalDurationMs: 0, hookCount: 0, hookErrors: 0 },
+        progress: { totalLines: 0 },
+        timing: { firstTimestamp: null, lastTimestamp: null, durationMs: 0 },
+    };
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    const lines = content.trimEnd().split('\n');
+    for (const line of lines) {
+        let data;
+        try {
+            data = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const type = data.type ?? 'unknown';
+        stats.typeCounts[type] = (stats.typeCounts[type] ?? 0) + 1;
+        // Track timestamps
+        const ts = data.timestamp ?? null;
+        if (ts) {
+            if (!stats.timing.firstTimestamp)
+                stats.timing.firstTimestamp = ts;
+            stats.timing.lastTimestamp = ts;
+        }
+        if (type === 'user') {
+            stats.user.totalMessages++;
+            if (data.isMeta)
+                stats.user.metaMessages++;
+            if (data.toolUseResult)
+                stats.user.toolResults++;
+            if (!stats.user.cwd && data.cwd)
+                stats.user.cwd = data.cwd;
+            if (!stats.user.version && data.version)
+                stats.user.version = data.version;
+            const pm = data.permissionMode;
+            if (pm && !stats.user.permissionModes.includes(pm))
+                stats.user.permissionModes.push(pm);
+            // Extract slash commands
+            const content = data.message?.content;
+            const text = typeof content === 'string' ? content : '';
+            const cmdMatch = text.match(/<command-name>\/?(.+?)<\/command-name>/);
+            if (cmdMatch) {
+                const cmd = '/' + cmdMatch[1];
+                if (!stats.user.commands.includes(cmd))
+                    stats.user.commands.push(cmd);
+            }
+        }
+        if (type === 'assistant') {
+            stats.assistant.totalMessages++;
+            const msg = data.message;
+            if (msg) {
+                const model = msg.model;
+                if (model && !stats.assistant.models.includes(model))
+                    stats.assistant.models.push(model);
+                const usage = msg.usage;
+                if (usage) {
+                    stats.assistant.totalInputTokens += Number(usage.input_tokens) || 0;
+                    stats.assistant.totalOutputTokens += Number(usage.output_tokens) || 0;
+                    stats.assistant.totalCacheReadTokens += Number(usage.cache_read_input_tokens) || 0;
+                    stats.assistant.totalCacheCreationTokens += Number(usage.cache_creation_input_tokens) || 0;
+                }
+                // Track tool usage
+                const msgContent = msg.content;
+                if (Array.isArray(msgContent)) {
+                    for (const block of msgContent) {
+                        if (block?.type === 'tool_use' && block.name) {
+                            const name = block.name;
+                            stats.assistant.toolsUsed[name] = (stats.assistant.toolsUsed[name] ?? 0) + 1;
+                        }
+                    }
+                }
+            }
+        }
+        if (type === 'system') {
+            stats.system.totalMessages++;
+            const subtype = data.subtype;
+            if (subtype && !stats.system.subtypes.includes(subtype))
+                stats.system.subtypes.push(subtype);
+            const stopReason = data.stopReason;
+            if (stopReason && !stats.system.stopReasons.includes(stopReason))
+                stats.system.stopReasons.push(stopReason);
+            stats.system.totalDurationMs += Number(data.durationMs) || 0;
+            stats.system.hookCount += Number(data.hookCount) || 0;
+            stats.system.hookErrors += Number(data.hookErrors) || 0;
+        }
+        if (type === 'progress') {
+            stats.progress.totalLines++;
+        }
+    }
+    // Compute session duration
+    if (stats.timing.firstTimestamp && stats.timing.lastTimestamp) {
+        stats.timing.durationMs = new Date(stats.timing.lastTimestamp).getTime() - new Date(stats.timing.firstTimestamp).getTime();
+    }
+    return stats;
+}
+/**
+ * Sync sessions into the DB from scope frontmatter.
+ *
+ * Algorithm:
+ * 1. Read scopes with non-empty sessions JSON from DB
+ * 2. For each scope, parse the sessions JSON: Record<phase, uuid[]>
+ * 3. For each (phase, uuid), UPSERT into sessions table with JSONL metadata if available
+ */
+export async function syncClaudeSessionsToDB(db, scopeService) {
+    cache = null; // Force fresh read from filesystem
+    const scopeRows = scopeService.getAll()
+        .filter(s => Object.keys(s.sessions).length > 0)
+        .map(s => ({ id: s.id, sessions: s.sessions }));
+    const upsert = db.prepare(`
+    INSERT INTO sessions (id, scope_id, claude_session_id, action, started_at, ended_at, summary, handoff_file, discoveries, next_steps)
+    VALUES (?, ?, ?, ?, ?, ?, ?, NULL, '[]', '[]')
+    ON CONFLICT(id) DO UPDATE SET
+      started_at = excluded.started_at,
+      ended_at = excluded.ended_at,
+      summary = excluded.summary,
+      claude_session_id = excluded.claude_session_id,
+      action = excluded.action
+  `);
+    let count = 0;
+    const insertAll = db.transaction(() => {
+        for (const row of scopeRows) {
+            for (const [phase, uuids] of Object.entries(row.sessions)) {
+                if (!Array.isArray(uuids))
+                    continue;
+                for (const uuid of uuids) {
+                    if (typeof uuid !== 'string' || !uuid)
+                        continue;
+                    // Check if JSONL file exists for metadata enrichment
+                    const jsonlPath = path.join(getSessionsDir(), `${uuid}.jsonl`);
+                    let startedAt = null;
+                    let endedAt = null;
+                    let summary = null;
+                    if (fs.existsSync(jsonlPath)) {
+                        try {
+                            const stat = fs.statSync(jsonlPath);
+                            startedAt = stat.birthtime.toISOString();
+                            endedAt = stat.mtime.toISOString();
+                            const content = fs.readFileSync(jsonlPath, 'utf-8');
+                            const lines = content.trimEnd().split('\n');
+                            // Prefer explicit summary line from Claude
+                            const lastLine = JSON.parse(lines[lines.length - 1]);
+                            if (lastLine.type === 'summary' && lastLine.summary) {
+                                summary = truncate(lastLine.summary, 200);
+                            }
+                            // Fall back to first user message
+                            if (!summary) {
+                                summary = extractFirstUserMessage(lines, 200);
+                            }
+                        }
+                        catch {
+                            // Metadata unavailable — row still created with nulls
+                        }
+                    }
+                    // Composite key includes phase so same UUID under different phases creates distinct rows
+                    const compositeId = `${uuid}-scope-${row.id}-${phase}`;
+                    upsert.run(compositeId, row.id, uuid, phase, startedAt, endedAt, summary);
+                    count++;
+                }
+            }
+        }
+    });
+    insertAll();
+    return count;
+}

package/dist/server/server/services/config-service.js

@@ -0,0 +1,132 @@
+import fs from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+const VALID_TYPES = new Set(['agents', 'skills', 'hooks']);
+export function isValidPrimitiveType(type) {
+    return VALID_TYPES.has(type);
+}
+export class ConfigService {
+    projectRoot;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+    }
+    /** Resolve the base directory for a primitive type */
+    getBasePath(type) {
+        switch (type) {
+            case 'agents': return path.join(this.projectRoot, '.claude', 'agents');
+            case 'skills': return path.join(this.projectRoot, '.claude', 'skills');
+            case 'hooks': return path.join(this.projectRoot, '.claude', 'hooks');
+        }
+    }
+    /** Scan a directory tree and parse SKILL.md / agent frontmatter */
+    scanDirectory(basePath, parseFrontmatter = true) {
+        if (!fs.existsSync(basePath))
+            return [];
+        return this.walkDir(basePath, basePath, parseFrontmatter);
+    }
+    readFile(basePath, relativePath) {
+        const resolved = this.validatePath(basePath, relativePath);
+        return fs.readFileSync(resolved, 'utf-8');
+    }
+    writeFile(basePath, relativePath, content) {
+        const resolved = this.validatePath(basePath, relativePath);
+        if (!fs.existsSync(resolved)) {
+            throw new Error('File not found');
+        }
+        // Atomic write: write to .tmp, then rename
+        const tmpPath = resolved + '.tmp';
+        fs.writeFileSync(tmpPath, content, 'utf-8');
+        fs.renameSync(tmpPath, resolved);
+    }
+    createFile(basePath, relativePath, content) {
+        const resolved = this.validatePath(basePath, relativePath);
+        if (fs.existsSync(resolved)) {
+            throw new Error('File already exists');
+        }
+        const dir = path.dirname(resolved);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(resolved, content, 'utf-8');
+    }
+    deleteFile(basePath, relativePath) {
+        const resolved = this.validatePath(basePath, relativePath);
+        if (!fs.existsSync(resolved)) {
+            throw new Error('File not found');
+        }
+        const stat = fs.statSync(resolved);
+        if (stat.isDirectory()) {
+            throw new Error('Cannot delete a directory');
+        }
+        fs.unlinkSync(resolved);
+    }
+    renameFile(basePath, oldPath, newPath) {
+        const resolvedOld = this.validatePath(basePath, oldPath);
+        const resolvedNew = this.validatePath(basePath, newPath);
+        if (!fs.existsSync(resolvedOld)) {
+            throw new Error('Source file not found');
+        }
+        if (fs.existsSync(resolvedNew)) {
+            throw new Error('Destination already exists');
+        }
+        const destDir = path.dirname(resolvedNew);
+        if (!fs.existsSync(destDir))
+            fs.mkdirSync(destDir, { recursive: true });
+        fs.renameSync(resolvedOld, resolvedNew);
+    }
+    createFolder(basePath, relativePath) {
+        const resolved = this.validatePath(basePath, relativePath);
+        if (fs.existsSync(resolved)) {
+            throw new Error('Folder already exists');
+        }
+        fs.mkdirSync(resolved, { recursive: true });
+    }
+    // ─── Private Helpers ────────────────────────────────────
+    /** Path traversal validation — ensure resolved path is within basePath */
+    validatePath(basePath, relativePath) {
+        const resolvedBase = path.resolve(basePath);
+        const resolved = path.resolve(basePath, relativePath);
+        if (resolved !== resolvedBase && !resolved.startsWith(resolvedBase + path.sep)) {
+            throw new Error('Path traversal detected');
+        }
+        return resolved;
+    }
+    /** Recursively walk a directory and build a file tree */
+    walkDir(currentPath, basePath, parseFrontmatter) {
+        const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+        const nodes = [];
+        for (const entry of entries) {
+            // Skip hidden files/dirs (e.g. .DS_Store)
+            if (entry.name.startsWith('.'))
+                continue;
+            const fullPath = path.join(currentPath, entry.name);
+            const relPath = path.relative(basePath, fullPath);
+            if (entry.isDirectory()) {
+                const children = this.walkDir(fullPath, basePath, parseFrontmatter);
+                nodes.push({ name: entry.name, path: relPath, type: 'folder', children });
+            }
+            else {
+                const node = { name: entry.name, path: relPath, type: 'file' };
+                if (parseFrontmatter && entry.name.endsWith('.md')) {
+                    try {
+                        const content = fs.readFileSync(fullPath, 'utf-8');
+                        const parsed = matter(content);
+                        if (Object.keys(parsed.data).length > 0) {
+                            node.frontmatter = parsed.data;
+                        }
+                    }
+                    catch {
+                        // Skip frontmatter parsing errors
+                    }
+                }
+                nodes.push(node);
+            }
+        }
+        // Sort: folders first, then files, alphabetical within each group
+        nodes.sort((a, b) => {
+            if (a.type !== b.type)
+                return a.type === 'folder' ? -1 : 1;
+            return a.name.localeCompare(b.name);
+        });
+        return nodes;
+    }
+}

package/dist/server/server/services/deploy-service.js

@@ -0,0 +1,51 @@
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('deploy');
+export class DeployService {
+    db;
+    io;
+    constructor(db, io) {
+        this.db = db;
+        this.io = io;
+    }
+    /** Record a deployment event */
+    record(deploy) {
+        const now = new Date().toISOString();
+        const result = this.db.prepare(`INSERT INTO deployments (environment, status, commit_sha, branch, pr_number, health_check_url, started_at, details)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(deploy.environment, deploy.status, deploy.commit_sha, deploy.branch, deploy.pr_number, deploy.health_check_url, now, JSON.stringify(deploy.details ?? {}));
+        const id = result.lastInsertRowid;
+        log.info('Deploy recorded', { id, env: deploy.environment, status: deploy.status, commit_sha: deploy.commit_sha, branch: deploy.branch });
+        const inserted = this.db.prepare('SELECT * FROM deployments WHERE id = ?').get(id);
+        if (inserted) {
+            this.io.emit('deploy:updated', inserted);
+        }
+        return id;
+    }
+    /** Update deployment status */
+    updateStatus(id, status, details) {
+        const completedAt = (status === 'healthy' || status === 'failed' || status === 'rolled-back')
+            ? new Date().toISOString()
+            : null;
+        this.db.prepare(`UPDATE deployments SET status = ?, completed_at = COALESCE(?, completed_at), details = COALESCE(?, details) WHERE id = ?`).run(status, completedAt, details, id);
+        log.info('Deploy status updated', { id, status });
+        const updated = this.db.prepare('SELECT * FROM deployments WHERE id = ?').get(id);
+        if (updated) {
+            this.io.emit('deploy:updated', updated);
+        }
+    }
+    /** Get recent deployments */
+    getRecent(limit = 20) {
+        return this.db
+            .prepare('SELECT * FROM deployments ORDER BY started_at DESC LIMIT ?')
+            .all(limit);
+    }
+    /** Get latest deployment per environment */
+    getLatestPerEnv() {
+        return this.db.prepare(`
+      SELECT * FROM deployments
+      WHERE id IN (
+        SELECT MAX(id) FROM deployments GROUP BY environment
+      )
+      ORDER BY environment
+    `).all();
+    }
+}

package/dist/server/server/services/event-service.js

@@ -0,0 +1,63 @@
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('event');
+export class EventService {
+    db;
+    io;
+    onIngestCallbacks = [];
+    constructor(db, io) {
+        this.db = db;
+        this.io = io;
+    }
+    /** Register a callback to be called after each successful event ingest */
+    onIngest(callback) {
+        this.onIngestCallbacks.push(callback);
+    }
+    /** Ingest a parsed event into the database and broadcast it */
+    ingest(event) {
+        const result = this.db.prepare(`INSERT OR IGNORE INTO events (id, type, scope_id, session_id, agent, data, timestamp, processed)
+       VALUES (?, ?, ?, ?, ?, ?, ?, 1)`).run(event.id, event.type, event.scope_id ?? null, event.session_id ?? null, event.agent ?? null, JSON.stringify(event.data ?? {}), event.timestamp);
+        // Only broadcast if this was a new insert (not a duplicate)
+        if (result.changes === 0) {
+            log.debug('Event duplicate skipped', { id: event.id });
+            return;
+        }
+        log.info('Event ingested', { type: event.type, id: event.id, scope_id: event.scope_id, agent: event.agent });
+        const data = event.data ?? {};
+        this.io.emit('event:new', {
+            id: event.id,
+            type: event.type,
+            scope_id: event.scope_id ?? null,
+            session_id: event.session_id ?? null,
+            agent: event.agent ?? null,
+            data,
+            timestamp: event.timestamp,
+        });
+        // Trigger event-driven inference
+        for (const cb of this.onIngestCallbacks) {
+            cb(event.type, event.scope_id ?? data.scope_id, data);
+        }
+    }
+    /** Get recent events, optionally filtered by type */
+    getRecent(limit = 50, type) {
+        if (type) {
+            return this.db
+                .prepare('SELECT * FROM events WHERE type = ? ORDER BY timestamp DESC LIMIT ?')
+                .all(type, limit);
+        }
+        return this.db
+            .prepare('SELECT * FROM events ORDER BY timestamp DESC LIMIT ?')
+            .all(limit);
+    }
+    /** Get events for a specific agent */
+    getByAgent(agent, limit = 50) {
+        return this.db
+            .prepare('SELECT * FROM events WHERE agent = ? ORDER BY timestamp DESC LIMIT ?')
+            .all(agent, limit);
+    }
+    /** Get events for a specific scope */
+    getByScope(scopeId, limit = 50) {
+        return this.db
+            .prepare('SELECT * FROM events WHERE scope_id = ? ORDER BY timestamp DESC LIMIT ?')
+            .all(scopeId, limit);
+    }
+}

package/dist/server/server/services/gate-service.js

@@ -0,0 +1,83 @@
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('gate');
+// The 13 quality gates from /test-checks
+export const GATE_NAMES = [
+    'type-check',
+    'lint',
+    'build',
+    'template-validation',
+    'doc-links',
+    'doc-freshness',
+    'rule-enforcement',
+    'no-placeholders',
+    'no-mock-data',
+    'no-shortcuts',
+    'no-default-secrets',
+    'no-stale-scopes',
+    'tests',
+];
+export class GateService {
+    db;
+    io;
+    constructor(db, io) {
+        this.db = db;
+        this.io = io;
+    }
+    /** Record a gate result */
+    record(gate) {
+        const result = this.db.prepare(`INSERT INTO quality_gates (scope_id, gate_name, status, details, duration_ms, run_at, commit_sha)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`).run(gate.scope_id, gate.gate_name, gate.status, gate.details, gate.duration_ms, new Date().toISOString(), gate.commit_sha);
+        log.info('Gate recorded', { scope_id: gate.scope_id, gate: gate.gate_name, status: gate.status, duration_ms: gate.duration_ms });
+        const inserted = this.db.prepare('SELECT * FROM quality_gates WHERE id = ?').get(result.lastInsertRowid);
+        if (inserted) {
+            this.io.emit('gate:updated', inserted);
+        }
+    }
+    /** Get latest gate results for a scope */
+    getLatestForScope(scopeId) {
+        return this.db.prepare(`
+      SELECT * FROM quality_gates
+      WHERE scope_id = ? AND id IN (
+        SELECT MAX(id) FROM quality_gates
+        WHERE scope_id = ?
+        GROUP BY gate_name
+      )
+      ORDER BY gate_name
+    `).all(scopeId, scopeId);
+    }
+    /** Get latest gate run (all gates from most recent execution) */
+    getLatestRun() {
+        // Get the most recent run_at timestamp
+        const latest = this.db.prepare('SELECT run_at FROM quality_gates ORDER BY run_at DESC LIMIT 1').get();
+        if (!latest)
+            return [];
+        // Get all gates from that run (within 60 seconds of each other)
+        return this.db.prepare(`
+      SELECT * FROM quality_gates
+      WHERE run_at >= datetime(?, '-60 seconds')
+      ORDER BY gate_name
+    `).all(latest.run_at);
+    }
+    /** Get gate history for trend chart */
+    getTrend(limit = 30) {
+        return this.db.prepare(`
+      SELECT gate_name, status, run_at, duration_ms
+      FROM quality_gates
+      ORDER BY run_at DESC
+      LIMIT ?
+    `).all(limit * GATE_NAMES.length); // Get enough to cover N runs
+    }
+    /** Get aggregate pass/fail stats */
+    getStats() {
+        return this.db.prepare(`
+      SELECT
+        gate_name,
+        COUNT(*) as total,
+        SUM(CASE WHEN status = 'pass' THEN 1 ELSE 0 END) as passed,
+        SUM(CASE WHEN status = 'fail' THEN 1 ELSE 0 END) as failed
+      FROM quality_gates
+      GROUP BY gate_name
+      ORDER BY gate_name
+    `).all();
+    }
+}