orbital-command 0.2.0 → 1.0.0

package/dist/server/server/schema.js

@@ -81,10 +81,13 @@ CREATE TABLE IF NOT EXISTS sprint_scopes (
 CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
 CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
 CREATE INDEX IF NOT EXISTS idx_events_scope_id ON events(scope_id);
+CREATE INDEX IF NOT EXISTS idx_events_type_timestamp ON events(type, timestamp);
 CREATE INDEX IF NOT EXISTS idx_gates_scope_id ON quality_gates(scope_id);
 CREATE INDEX IF NOT EXISTS idx_gates_run_at ON quality_gates(run_at);
 CREATE INDEX IF NOT EXISTS idx_deployments_env ON deployments(environment);
 CREATE INDEX IF NOT EXISTS idx_sessions_scope ON sessions(scope_id);
+CREATE INDEX IF NOT EXISTS idx_sessions_claude_id ON sessions(claude_session_id);
 CREATE INDEX IF NOT EXISTS idx_sprints_status ON sprints(status);
 CREATE INDEX IF NOT EXISTS idx_sprint_scopes_sprint ON sprint_scopes(sprint_id);
+CREATE INDEX IF NOT EXISTS idx_events_dispatch_unresolved ON events(type, scope_id) WHERE type = 'DISPATCH' AND JSON_EXTRACT(data, '$.resolved') IS NULL;
 `;

package/dist/server/server/services/batch-orchestrator.js

@@ -1,6 +1,6 @@
-import { launchInCategorizedTerminal, escapeForAnsiC, snapshotSessionPids, discoverNewSession, isSessionPidAlive } from '../utils/terminal-launcher.js';
+import { launchInCategorizedTerminal, escapeForAnsiC, shellQuote, snapshotSessionPids, discoverNewSession, isSessionPidAlive } from '../utils/terminal-launcher.js';
 import { linkPidToDispatch, resolveDispatchEvent } from '../utils/dispatch-utils.js';
-import { getConfig } from '../config.js';
+import { buildClaudeFlags, buildEnvVarPrefix } from '../utils/flag-builder.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('batch');
 const VALID_MERGE_MODES = ['push', 'pr'];
@@ -11,12 +11,16 @@ export class BatchOrchestrator {
     sprintService;
     scopeService;
     engine;
-    constructor(db, io, sprintService, scopeService, engine) {
+    projectRoot;
+    config;
+    constructor(db, io, sprintService, scopeService, engine, projectRoot, config) {
         this.db = db;
         this.io = io;
         this.sprintService = sprintService;
         this.scopeService = scopeService;
         this.engine = engine;
+        this.projectRoot = projectRoot;
+        this.config = config;
     }
     /** Dispatch a batch — validates constraints and routes to column-specific handler */
     async dispatch(batchId, mergeMode) {
@@ -62,8 +66,10 @@ export class BatchOrchestrator {
         });
         // Launch single CLI session with BATCH_SCOPE_IDS prepended to command
         const escaped = escapeForAnsiC(command);
-        const fullCmd = `cd '${getConfig().projectRoot}' && BATCH_SCOPE_IDS='${scopeIdsStr}' MERGE_MODE='${mergeModeStr}' claude --dangerously-skip-permissions $'${escaped}'`;
-        const beforePids = snapshotSessionPids(getConfig().projectRoot);
+        const flagsStr = buildClaudeFlags(this.config.claude.dispatchFlags);
+        const envPrefix = buildEnvVarPrefix(this.config.dispatch.envVars);
+        const fullCmd = `cd '${shellQuote(this.projectRoot)}' && ${envPrefix}ORBITAL_DISPATCH_ID='${shellQuote(eventId)}' BATCH_SCOPE_IDS='${scopeIdsStr}' MERGE_MODE='${mergeModeStr}' claude ${flagsStr} $'${escaped}'`;
+        const beforePids = snapshotSessionPids(this.projectRoot);
         try {
             await launchInCategorizedTerminal(command, fullCmd);
             // Store dispatch result timestamp
@@ -71,7 +77,7 @@ export class BatchOrchestrator {
                 dispatched_at: new Date().toISOString(),
             });
             // Fire-and-forget: discover session PID and link to dispatch
-            discoverNewSession(getConfig().projectRoot, beforePids)
+            discoverNewSession(this.projectRoot, beforePids)
                 .then((session) => {
                 if (!session)
                     return;
@@ -96,7 +102,7 @@ export class BatchOrchestrator {
         catch (err) {
             this.sprintService.updateStatus(batchId, 'failed');
             resolveDispatchEvent(this.db, this.io, eventId, 'failed', String(err));
-            return { ok: false, error: `Failed to launch terminal: ${err}` };
+            return { ok: false, error: `Failed to launch terminal: ${err instanceof Error ? err.message : String(err)}` };
         }
     }
     /** Called when a scope reaches a new status — check if it satisfies a batch,
@@ -136,6 +142,15 @@ export class BatchOrchestrator {
         if (batch.status !== 'dispatched' && batch.status !== 'in_progress')
             return;
         const scopes = this.sprintService.getSprintScopes(batchId);
+        // If batch never reached 'in_progress', the session never started —
+        // don't credit any scope regardless of their current workflow status
+        if (batch.status === 'dispatched') {
+            this.sprintService.updateStatus(batchId, 'failed');
+            for (const ss of scopes) {
+                this.sprintService.updateScopeStatus(batchId, ss.scope_id, 'failed', 'Session never started');
+            }
+            return;
+        }
         const allTransitioned = scopes.every((ss) => ss.dispatch_status === 'completed');
         if (allTransitioned) {
             this.sprintService.updateStatus(batchId, 'completed');
@@ -185,18 +200,27 @@ export class BatchOrchestrator {
          ORDER BY timestamp DESC LIMIT 1`).get(id);
             let pidDead = false;
             if (dispatchEvent) {
-                const data = JSON.parse(dispatchEvent.data);
-                // If the dispatch event is already resolved, the session is definitely done
-                if (data.resolved != null) {
-                    pidDead = true;
+                let data;
+                try {
+                    data = JSON.parse(dispatchEvent.data);
                 }
-                else if (typeof data.pid === 'number') {
-                    pidDead = !isSessionPidAlive(data.pid);
+                catch {
+                    pidDead = true;
+                    // Fall through to resolution below
                 }
-                else {
-                    // No PID recorded — check if batch is old enough to consider stale
-                    const dispatchedAt = batch.dispatched_at ? new Date(batch.dispatched_at).getTime() : 0;
-                    pidDead = Date.now() - dispatchedAt > STALE_THRESHOLD_MS;
+                if (!pidDead) {
+                    // If the dispatch event is already resolved, the session is definitely done
+                    if (data.resolved != null) {
+                        pidDead = true;
+                    }
+                    else if (typeof data.pid === 'number') {
+                        pidDead = !isSessionPidAlive(data.pid);
+                    }
+                    else {
+                        // No PID recorded — check if batch is old enough to consider stale
+                        const dispatchedAt = batch.dispatched_at ? new Date(batch.dispatched_at).getTime() : 0;
+                        pidDead = Date.now() - dispatchedAt > STALE_THRESHOLD_MS;
+                    }
                 }
             }
             else {

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

@@ -1,11 +1,13 @@
 import fs from 'fs';
 import path from 'path';
 import readline from 'readline';
-import { getConfig, getClaudeSessionsDir } from '../config.js';
-function getSessionsDir() {
-    return getClaudeSessionsDir(getConfig().projectRoot);
+import { getClaudeSessionsDir } from '../config.js';
+function getSessionsDir(projectRoot) {
+    if (!projectRoot)
+        throw new Error('projectRoot is required for getSessionsDir');
+    return getClaudeSessionsDir(projectRoot);
 }
-let cache = null;
+const cacheByDir = new Map();
 const CACHE_TTL_MS = 60_000;
 /**
  * Extract metadata from a JSONL session file by reading the first few
@@ -81,11 +83,12 @@ async function parseSessionFile(filePath) {
         fileSize: stat.size,
     };
 }
-export async function getClaudeSessions(since) {
-    if (cache && Date.now() < cache.expiry) {
-        return filterSince(cache.sessions, since);
+export async function getClaudeSessions(since, projectRoot) {
+    const sessionsDir = getSessionsDir(projectRoot);
+    const cached = cacheByDir.get(sessionsDir);
+    if (cached && Date.now() < cached.expiry) {
+        return filterSince(cached.sessions, since);
     }
-    const sessionsDir = getSessionsDir();
     if (!fs.existsSync(sessionsDir))
         return [];
     const files = fs
@@ -100,7 +103,7 @@ export async function getClaudeSessions(since) {
     }
     // 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 };
+    cacheByDir.set(sessionsDir, { sessions, expiry: Date.now() + CACHE_TTL_MS });
     return filterSince(sessions, since);
 }
 function filterSince(sessions, since) {
@@ -173,8 +176,8 @@ function extractFirstUserMessage(lines, max) {
  * 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`);
+export function getSessionStats(claudeSessionId, projectRoot) {
+    const filePath = path.join(getSessionsDir(projectRoot), `${claudeSessionId}.jsonl`);
     if (!fs.existsSync(filePath))
         return null;
     const stats = {
@@ -289,8 +292,8 @@ export function getSessionStats(claudeSessionId) {
  * 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
+export async function syncClaudeSessionsToDB(db, scopeService, projectRoot) {
+    cacheByDir.clear(); // 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 }));
@@ -314,7 +317,7 @@ export async function syncClaudeSessionsToDB(db, scopeService) {
                     if (typeof uuid !== 'string' || !uuid)
                         continue;
                     // Check if JSONL file exists for metadata enrichment
-                    const jsonlPath = path.join(getSessionsDir(), `${uuid}.jsonl`);
+                    const jsonlPath = path.join(getSessionsDir(projectRoot), `${uuid}.jsonl`);
                     let startedAt = null;
                     let endedAt = null;
                     let summary = null;

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

@@ -100,7 +100,16 @@ export class ConfigService {
                 continue;
             const fullPath = path.join(currentPath, entry.name);
             const relPath = path.relative(basePath, fullPath);
-            if (entry.isDirectory()) {
+            // Resolve symlinks: Dirent.isDirectory() returns false for symlinks-to-dirs.
+            // Self-hosted projects symlink .claude/agents/*, .claude/hooks/*, etc. into templates/.
+            let stat;
+            try {
+                stat = fs.statSync(fullPath);
+            }
+            catch {
+                continue; // broken symlink — skip silently
+            }
+            if (stat.isDirectory()) {
                 const children = this.walkDir(fullPath, basePath, parseFrontmatter);
                 nodes.push({ name: entry.name, path: relPath, type: 'folder', children });
             }

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

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { DeployService } from './deploy-service.js';
+import { createTestDb } from '../__tests__/helpers/db.js';
+import { createMockEmitter } from '../__tests__/helpers/mock-emitter.js';
+describe('DeployService', () => {
+    let db;
+    let cleanup;
+    let emitter;
+    let service;
+    beforeEach(() => {
+        ({ db, cleanup } = createTestDb());
+        emitter = createMockEmitter();
+        service = new DeployService(db, emitter);
+    });
+    afterEach(() => {
+        cleanup?.();
+    });
+    // ─── record() ─────────────────────────────────────────────
+    describe('record()', () => {
+        it('inserts deployment and returns ID', () => {
+            const id = service.record({
+                environment: 'staging',
+                status: 'deploying',
+                commit_sha: 'abc1234',
+                branch: 'main',
+                pr_number: null,
+                health_check_url: null,
+                details: null,
+            });
+            expect(id).toBe(1);
+            const row = db.prepare('SELECT * FROM deployments WHERE id = ?').get(id);
+            expect(row.environment).toBe('staging');
+            expect(row.status).toBe('deploying');
+        });
+        it('emits deploy:updated with inserted row', () => {
+            service.record({
+                environment: 'production',
+                status: 'deploying',
+                commit_sha: 'def5678',
+                branch: 'main',
+                pr_number: 42,
+                health_check_url: 'https://example.com/health',
+                details: { version: '1.0.0' },
+            });
+            expect(emitter.emit).toHaveBeenCalledWith('deploy:updated', expect.objectContaining({
+                environment: 'production',
+                branch: 'main',
+                pr_number: 42,
+            }));
+        });
+    });
+    // ─── updateStatus() ──────────────────────────────────────
+    describe('updateStatus()', () => {
+        let deployId;
+        beforeEach(() => {
+            deployId = service.record({
+                environment: 'staging',
+                status: 'deploying',
+                commit_sha: 'abc',
+                branch: 'main',
+                pr_number: null,
+                health_check_url: null,
+                details: null,
+            });
+        });
+        it('updates status and emits deploy:updated', () => {
+            service.updateStatus(deployId, 'healthy');
+            const row = db.prepare('SELECT * FROM deployments WHERE id = ?').get(deployId);
+            expect(row.status).toBe('healthy');
+            // 1 from record + 1 from updateStatus
+            expect(emitter.emit).toHaveBeenCalledTimes(2);
+        });
+        it('sets completed_at for terminal status: healthy', () => {
+            service.updateStatus(deployId, 'healthy');
+            const row = db.prepare('SELECT completed_at FROM deployments WHERE id = ?').get(deployId);
+            expect(row.completed_at).not.toBeNull();
+            expect(row.completed_at).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+        });
+        it('sets completed_at for terminal status: failed', () => {
+            service.updateStatus(deployId, 'failed');
+            const row = db.prepare('SELECT completed_at FROM deployments WHERE id = ?').get(deployId);
+            expect(row.completed_at).not.toBeNull();
+        });
+        it('sets completed_at for terminal status: rolled-back', () => {
+            service.updateStatus(deployId, 'rolled-back');
+            const row = db.prepare('SELECT completed_at FROM deployments WHERE id = ?').get(deployId);
+            expect(row.completed_at).not.toBeNull();
+        });
+        it('does not set completed_at for non-terminal status', () => {
+            service.updateStatus(deployId, 'deploying');
+            const row = db.prepare('SELECT completed_at FROM deployments WHERE id = ?').get(deployId);
+            expect(row.completed_at).toBeNull();
+        });
+    });
+    // ─── getRecent() ──────────────────────────────────────────
+    describe('getRecent()', () => {
+        it('returns deployments ordered by started_at DESC with limit', () => {
+            service.record({ environment: 'staging', status: 'healthy', commit_sha: 'a', branch: 'main', pr_number: null, health_check_url: null, details: null });
+            service.record({ environment: 'production', status: 'deploying', commit_sha: 'b', branch: 'main', pr_number: null, health_check_url: null, details: null });
+            const recent = service.getRecent(1);
+            expect(recent).toHaveLength(1);
+        });
+    });
+    // ─── getLatestPerEnv() ────────────────────────────────────
+    describe('getLatestPerEnv()', () => {
+        it('returns one deployment per environment', () => {
+            service.record({ environment: 'staging', status: 'healthy', commit_sha: 'a', branch: 'main', pr_number: null, health_check_url: null, details: null });
+            service.record({ environment: 'staging', status: 'deploying', commit_sha: 'b', branch: 'main', pr_number: null, health_check_url: null, details: null });
+            service.record({ environment: 'production', status: 'healthy', commit_sha: 'c', branch: 'main', pr_number: null, health_check_url: null, details: null });
+            const latest = service.getLatestPerEnv();
+            expect(latest).toHaveLength(2);
+            const envs = latest.map(d => d.environment).sort();
+            expect(envs).toEqual(['production', 'staging']);
+        });
+        it('returns empty when no deployments exist', () => {
+            expect(service.getLatestPerEnv()).toEqual([]);
+        });
+    });
+});

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

@@ -21,7 +21,7 @@ export class EventService {
             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 });
+        log.debug('Event ingested', { type: event.type, id: event.id, scope_id: event.scope_id });
         const data = event.data ?? {};
         this.io.emit('event:new', {
             id: event.id,
@@ -60,4 +60,67 @@ export class EventService {
             .prepare('SELECT * FROM events WHERE scope_id = ? ORDER BY timestamp DESC LIMIT ?')
             .all(scopeId, limit);
     }
+    /** Get filtered events with optional type and scope_id filters */
+    getFiltered(options) {
+        const { limit = 50, type, scopeId } = options;
+        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(scopeId);
+        }
+        query += ' ORDER BY timestamp DESC LIMIT ?';
+        params.push(limit);
+        return this.db.prepare(query).all(...params);
+    }
+    /** Get violation summary: by rule, by file, overrides, and totals */
+    getViolationSummary() {
+        const byRule = this.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 = this.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 = this.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 = this.db.prepare(`SELECT COUNT(*) as count FROM events WHERE type = 'VIOLATION'`).get().count;
+        const totalOverrides = this.db.prepare(`SELECT COUNT(*) as count FROM events WHERE type = 'OVERRIDE'`).get().count;
+        return { byRule, byFile, overrides, totalViolations, totalOverrides };
+    }
+    /** Get per-rule violation and override counts (for enforcement rules view) */
+    getViolationStatsByRule() {
+        const violationStats = this.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 = this.db.prepare(`SELECT JSON_EXTRACT(data, '$.rule') as rule, COUNT(*) as count
+       FROM events WHERE type = 'OVERRIDE' GROUP BY rule`).all();
+        return {
+            violations: new Map(violationStats.map(v => [v.rule, v])),
+            overrides: new Map(overrideStats.map(o => [o.rule, o])),
+        };
+    }
+    /** Get violation trend data grouped by day and rule */
+    getViolationTrend(days = 30) {
+        return this.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}`);
+    }
+    /** Get deployment frequency by week and environment */
+    getDeployFrequency() {
+        const rows = this.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;
+        }
+        return [...weekMap.values()];
+    }
 }

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

@@ -0,0 +1,191 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { EventService } from './event-service.js';
+import { createTestDb } from '../__tests__/helpers/db.js';
+import { createMockEmitter } from '../__tests__/helpers/mock-emitter.js';
+describe('EventService', () => {
+    let db;
+    let cleanup;
+    let emitter;
+    let service;
+    beforeEach(() => {
+        ({ db, cleanup } = createTestDb());
+        emitter = createMockEmitter();
+        service = new EventService(db, emitter);
+    });
+    afterEach(() => {
+        cleanup?.();
+    });
+    const makeEvent = (overrides = {}) => ({
+        id: `evt-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+        type: 'TEST_EVENT',
+        scope_id: 1,
+        session_id: 'sess-1',
+        agent: 'test-agent',
+        data: {},
+        timestamp: new Date().toISOString(),
+        ...overrides,
+    });
+    // ─── ingest() ───────────────────────────────────────────────
+    describe('ingest()', () => {
+        it('inserts event into DB and emits event:new', () => {
+            const event = makeEvent();
+            service.ingest(event);
+            const row = db.prepare('SELECT * FROM events WHERE id = ?').get(event.id);
+            expect(row).toBeDefined();
+            expect(row.type).toBe('TEST_EVENT');
+            expect(emitter.emit).toHaveBeenCalledWith('event:new', expect.objectContaining({
+                id: event.id,
+                type: 'TEST_EVENT',
+            }));
+        });
+        it('skips duplicate events (no emit)', () => {
+            const event = makeEvent();
+            service.ingest(event);
+            emitter.emit.mockClear();
+            service.ingest(event); // same id
+            expect(emitter.emit).not.toHaveBeenCalled();
+        });
+        it('calls registered onIngest callbacks', () => {
+            const callback = vi.fn();
+            service.onIngest(callback);
+            const event = makeEvent({ type: 'SCOPE_STATUS_CHANGED', data: { to: 'review' } });
+            service.ingest(event);
+            expect(callback).toHaveBeenCalledWith('SCOPE_STATUS_CHANGED', 1, { to: 'review' });
+        });
+        it('handles null optional fields', () => {
+            const event = makeEvent({ scope_id: undefined, session_id: undefined, agent: undefined });
+            service.ingest(event);
+            const row = db.prepare('SELECT * FROM events WHERE id = ?').get(event.id);
+            expect(row.scope_id).toBeNull();
+            expect(row.session_id).toBeNull();
+            expect(row.agent).toBeNull();
+        });
+    });
+    // ─── getRecent() ────────────────────────────────────────────
+    describe('getRecent()', () => {
+        it('returns events ordered by timestamp DESC with limit', () => {
+            for (let i = 0; i < 5; i++) {
+                service.ingest(makeEvent({ id: `evt-${i}`, timestamp: `2026-01-0${i + 1}T00:00:00Z` }));
+            }
+            const recent = service.getRecent(3);
+            expect(recent).toHaveLength(3);
+            expect(recent[0].timestamp).toBe('2026-01-05T00:00:00Z');
+        });
+        it('filters by type when provided', () => {
+            service.ingest(makeEvent({ id: 'a', type: 'TYPE_A' }));
+            service.ingest(makeEvent({ id: 'b', type: 'TYPE_B' }));
+            service.ingest(makeEvent({ id: 'c', type: 'TYPE_A' }));
+            const result = service.getRecent(50, 'TYPE_A');
+            expect(result).toHaveLength(2);
+            expect(result.every(r => r.type === 'TYPE_A')).toBe(true);
+        });
+    });
+    // ─── getFiltered() ──────────────────────────────────────────
+    describe('getFiltered()', () => {
+        beforeEach(() => {
+            service.ingest(makeEvent({ id: 'f1', type: 'A', scope_id: 1 }));
+            service.ingest(makeEvent({ id: 'f2', type: 'B', scope_id: 1 }));
+            service.ingest(makeEvent({ id: 'f3', type: 'A', scope_id: 2 }));
+        });
+        it('filters by type', () => {
+            const result = service.getFiltered({ type: 'A' });
+            expect(result).toHaveLength(2);
+        });
+        it('filters by scopeId', () => {
+            const result = service.getFiltered({ scopeId: 2 });
+            expect(result).toHaveLength(1);
+            expect(result[0].id).toBe('f3');
+        });
+        it('combines type + scopeId', () => {
+            const result = service.getFiltered({ type: 'A', scopeId: 1 });
+            expect(result).toHaveLength(1);
+            expect(result[0].id).toBe('f1');
+        });
+    });
+    // ─── getByAgent() / getByScope() ───────────────────────────
+    describe('getByAgent()', () => {
+        it('filters by agent name', () => {
+            service.ingest(makeEvent({ id: 'a1', agent: 'attacker' }));
+            service.ingest(makeEvent({ id: 'a2', agent: 'architect' }));
+            service.ingest(makeEvent({ id: 'a3', agent: 'attacker' }));
+            const result = service.getByAgent('attacker');
+            expect(result).toHaveLength(2);
+        });
+    });
+    describe('getByScope()', () => {
+        it('filters by scope_id', () => {
+            service.ingest(makeEvent({ id: 's1', scope_id: 42 }));
+            service.ingest(makeEvent({ id: 's2', scope_id: 99 }));
+            const result = service.getByScope(42);
+            expect(result).toHaveLength(1);
+        });
+    });
+    // ─── getViolationSummary() ──────────────────────────────────
+    describe('getViolationSummary()', () => {
+        it('returns zeros when no violation events exist', () => {
+            const summary = service.getViolationSummary();
+            expect(summary.totalViolations).toBe(0);
+            expect(summary.totalOverrides).toBe(0);
+            expect(summary.byRule).toEqual([]);
+            expect(summary.byFile).toEqual([]);
+        });
+        it('aggregates violation data', () => {
+            service.ingest(makeEvent({ id: 'v1', type: 'VIOLATION', data: { rule: 'no-todo', file: 'src/app.ts' } }));
+            service.ingest(makeEvent({ id: 'v2', type: 'VIOLATION', data: { rule: 'no-todo', file: 'src/app.ts' } }));
+            service.ingest(makeEvent({ id: 'v3', type: 'VIOLATION', data: { rule: 'no-mock', file: 'src/lib.ts' } }));
+            service.ingest(makeEvent({ id: 'o1', type: 'OVERRIDE', data: { rule: 'no-todo', reason: 'legitimate use' } }));
+            const summary = service.getViolationSummary();
+            expect(summary.totalViolations).toBe(3);
+            expect(summary.totalOverrides).toBe(1);
+            expect(summary.byRule).toHaveLength(2);
+            expect(summary.byRule[0].rule).toBe('no-todo');
+            expect(summary.byRule[0].count).toBe(2);
+            expect(summary.byFile).toHaveLength(2);
+            expect(summary.overrides).toHaveLength(1);
+        });
+    });
+    // ─── getViolationStatsByRule() ──────────────────────────────
+    describe('getViolationStatsByRule()', () => {
+        it('returns maps keyed by rule name', () => {
+            service.ingest(makeEvent({ id: 'v1', type: 'VIOLATION', data: { rule: 'no-todo' } }));
+            service.ingest(makeEvent({ id: 'o1', type: 'OVERRIDE', data: { rule: 'no-todo' } }));
+            const stats = service.getViolationStatsByRule();
+            expect(stats.violations.get('no-todo')?.count).toBe(1);
+            expect(stats.overrides.get('no-todo')?.count).toBe(1);
+        });
+    });
+    // ─── getViolationTrend() ────────────────────────────────────
+    describe('getViolationTrend()', () => {
+        it('returns violations grouped by day and rule', () => {
+            service.ingest(makeEvent({ id: 'vt1', type: 'VIOLATION', data: { rule: 'no-todo' }, timestamp: '2026-04-01T10:00:00Z' }));
+            service.ingest(makeEvent({ id: 'vt2', type: 'VIOLATION', data: { rule: 'no-todo' }, timestamp: '2026-04-01T14:00:00Z' }));
+            service.ingest(makeEvent({ id: 'vt3', type: 'VIOLATION', data: { rule: 'no-mock' }, timestamp: '2026-04-02T10:00:00Z' }));
+            const trend = service.getViolationTrend(365);
+            expect(trend.length).toBeGreaterThanOrEqual(2);
+            const day1 = trend.find(t => t.day === '2026-04-01' && t.rule === 'no-todo');
+            expect(day1?.count).toBe(2);
+        });
+        it('returns empty array when no violations exist', () => {
+            expect(service.getViolationTrend()).toEqual([]);
+        });
+    });
+    // ─── getDeployFrequency() ───────────────────────────────────
+    describe('getDeployFrequency()', () => {
+        it('returns deployment counts grouped by week and environment', () => {
+            const now = new Date();
+            const ts = now.toISOString();
+            // Insert deployments directly into the DB (EventService queries the deployments table)
+            db.prepare(`INSERT INTO deployments (environment, status, commit_sha, branch, started_at, details) VALUES (?, ?, ?, ?, ?, ?)`).run('staging', 'healthy', 'abc', 'main', ts, '{}');
+            db.prepare(`INSERT INTO deployments (environment, status, commit_sha, branch, started_at, details) VALUES (?, ?, ?, ?, ?, ?)`).run('production', 'healthy', 'def', 'main', ts, '{}');
+            const freq = service.getDeployFrequency();
+            expect(freq.length).toBeGreaterThanOrEqual(1);
+            const week = freq[0];
+            expect(week).toHaveProperty('week');
+            expect(week).toHaveProperty('staging');
+            expect(week).toHaveProperty('production');
+        });
+        it('returns empty array when no deployments exist', () => {
+            expect(service.getDeployFrequency()).toEqual([]);
+        });
+    });
+});