orbital-command 0.1.0

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

@@ -0,0 +1,312 @@
+import { launchInCategorizedTerminal, escapeForAnsiC, buildSessionName, snapshotSessionPids, discoverNewSession, renameSession } from '../utils/terminal-launcher.js';
+import { resolveDispatchEvent, linkPidToDispatch } from '../utils/dispatch-utils.js';
+import { getConfig } from '../config.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('sprint');
+const LAUNCH_STAGGER_MS = 2000;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// ─── Orchestrator ───────────────────────────────────────────
+export class SprintOrchestrator {
+    db;
+    io;
+    sprintService;
+    scopeService;
+    engine;
+    constructor(db, io, sprintService, scopeService, engine) {
+        this.db = db;
+        this.io = io;
+        this.sprintService = sprintService;
+        this.scopeService = scopeService;
+        this.engine = engine;
+    }
+    /** Build execution layers using Kahn's topological sort */
+    buildExecutionLayers(sprintScopeIds) {
+        const sprintSet = new Set(sprintScopeIds);
+        // Load dependency info for each scope in the sprint
+        const scopeDeps = new Map();
+        for (const id of sprintScopeIds) {
+            const scope = this.scopeService.getById(id);
+            if (!scope)
+                continue;
+            // Only keep deps that are WITHIN the sprint
+            scopeDeps.set(id, scope.blocked_by.filter((d) => sprintSet.has(d)));
+        }
+        // Build in-degree map — in-degree = count of internal deps for each scope
+        const inDegree = new Map();
+        for (const [id, deps] of scopeDeps) {
+            inDegree.set(id, deps.length);
+        }
+        const layers = [];
+        const remaining = new Set(sprintScopeIds);
+        while (remaining.size > 0) {
+            // Find all nodes with in-degree 0
+            const layer = [];
+            for (const id of remaining) {
+                if ((inDegree.get(id) ?? 0) === 0) {
+                    layer.push(id);
+                }
+            }
+            if (layer.length === 0) {
+                // Cycle detected — return remaining as cycle
+                return { layers, cycle: [...remaining] };
+            }
+            // Remove this layer and decrement dependents
+            for (const id of layer) {
+                remaining.delete(id);
+            }
+            // Decrement in-degree for scopes that depended on this layer's scopes
+            for (const id of remaining) {
+                const deps = scopeDeps.get(id) ?? [];
+                let newDeg = 0;
+                for (const dep of deps) {
+                    if (remaining.has(dep))
+                        newDeg++;
+                }
+                inDegree.set(id, newDeg);
+            }
+            layers.push(layer.sort((a, b) => a - b));
+        }
+        return { layers, cycle: [] };
+    }
+    /** Start sprint dispatch: build layers, persist, launch Layer 0 */
+    async startSprint(sprintId) {
+        const sprint = this.sprintService.getById(sprintId);
+        if (!sprint)
+            return { ok: false, error: 'Sprint not found' };
+        if (sprint.status !== 'assembling')
+            return { ok: false, error: `Sprint status is '${sprint.status}', expected 'assembling'` };
+        if (sprint.scope_ids.length === 0)
+            return { ok: false, error: 'Sprint has no scopes' };
+        // Build dependency graph
+        const { layers, cycle } = this.buildExecutionLayers(sprint.scope_ids);
+        if (cycle.length > 0) {
+            return { ok: false, error: `Dependency cycle detected among scopes: ${cycle.join(', ')}` };
+        }
+        // Persist layer assignments
+        this.sprintService.setLayers(sprintId, layers);
+        this.sprintService.updateStatus(sprintId, 'dispatched');
+        log.info('Sprint started', { id: sprintId, layers: layers.length, scopes: sprint.scope_ids.length });
+        // Dispatch Layer 0
+        await this.dispatchLayer(sprintId, layers[0], sprint.concurrency_cap);
+        return { ok: true, layers };
+    }
+    /** Called when a scope reaches 'dev' status — advance the sprint */
+    async onScopeReachedDev(scopeId) {
+        const match = this.sprintService.findActiveSprintForScope(scopeId);
+        if (!match)
+            return;
+        log.debug('Scope reached dev', { scopeId, sprintId: match.sprint_id });
+        const sprintId = match.sprint_id;
+        this.sprintService.updateScopeStatus(sprintId, scopeId, 'completed');
+        // Ensure sprint is in 'in_progress' state
+        const sprint = this.sprintService.getById(sprintId);
+        if (!sprint)
+            return;
+        if (sprint.status === 'dispatched') {
+            this.sprintService.updateStatus(sprintId, 'in_progress');
+        }
+        // Check for newly unblocked scopes and dispatch them
+        await this.dispatchUnblockedScopes(sprintId);
+        this.checkSprintCompletion(sprintId);
+    }
+    /** Called when a scope fails during sprint execution */
+    async onScopeFailed(scopeId, error) {
+        const match = this.sprintService.findActiveSprintForScope(scopeId);
+        if (!match)
+            return;
+        const sprintId = match.sprint_id;
+        this.sprintService.updateScopeStatus(sprintId, scopeId, 'failed', error);
+        // Skip downstream dependents transitively
+        this.skipDownstream(sprintId, scopeId);
+        // Try dispatching other unblocked parallel paths
+        await this.dispatchUnblockedScopes(sprintId);
+        this.checkSprintCompletion(sprintId);
+    }
+    /** Cancel an active sprint */
+    cancelSprint(sprintId) {
+        const sprint = this.sprintService.getById(sprintId);
+        if (!sprint)
+            return false;
+        if (!['assembling', 'dispatched', 'in_progress'].includes(sprint.status))
+            return false;
+        // Mark pending/queued scopes as skipped
+        const scopes = this.sprintService.getSprintScopes(sprintId);
+        for (const ss of scopes) {
+            if (ss.dispatch_status === 'pending' || ss.dispatch_status === 'queued') {
+                this.sprintService.updateScopeStatus(sprintId, ss.scope_id, 'skipped');
+            }
+        }
+        this.sprintService.updateStatus(sprintId, 'cancelled');
+        return true;
+    }
+    /** Recover active sprints after server restart */
+    async recoverActiveSprints() {
+        const active = this.db.prepare(`SELECT id FROM sprints WHERE group_type = 'sprint' AND status IN ('dispatched', 'in_progress')`).all();
+        if (active.length > 0) {
+            log.info('Recovering active sprints', { count: active.length });
+        }
+        for (const { id } of active) {
+            // Check if any scopes completed while server was down
+            const scopes = this.sprintService.getSprintScopes(id);
+            for (const ss of scopes) {
+                if (ss.dispatch_status === 'dispatched' || ss.dispatch_status === 'in_progress') {
+                    // Check actual scope status
+                    const scope = this.scopeService.getById(ss.scope_id);
+                    if (scope && this.engine.getStatusOrder(scope.status) >= this.engine.getStatusOrder('dev')) {
+                        this.sprintService.updateScopeStatus(id, ss.scope_id, 'completed');
+                    }
+                }
+            }
+            await this.dispatchUnblockedScopes(id);
+            this.checkSprintCompletion(id);
+        }
+    }
+    /** Get execution graph data for visualization */
+    getExecutionGraph(sprintId) {
+        const sprint = this.sprintService.getById(sprintId);
+        if (!sprint)
+            return null;
+        const layers = sprint.layers ?? [];
+        const sprintSet = new Set(sprint.scope_ids);
+        const edges = [];
+        for (const scopeId of sprint.scope_ids) {
+            const scope = this.scopeService.getById(scopeId);
+            if (!scope)
+                continue;
+            for (const dep of scope.blocked_by) {
+                if (sprintSet.has(dep)) {
+                    edges.push({ from: dep, to: scopeId });
+                }
+            }
+        }
+        return { layers, edges };
+    }
+    // ─── Private Helpers ────────────────────────────────────────
+    async dispatchLayer(sprintId, scopeIds, concurrencyCap) {
+        const toDispatch = scopeIds.slice(0, concurrencyCap);
+        for (let i = 0; i < toDispatch.length; i++) {
+            const scopeId = toDispatch[i];
+            // Capture current status before optimistic update (for rollback)
+            const currentScope = this.scopeService.getById(scopeId);
+            const previousStatus = currentScope?.status ?? 'implementing';
+            // Record DISPATCH event
+            const eventId = crypto.randomUUID();
+            const command = `/scope implement ${scopeId}`;
+            this.db.prepare(`INSERT INTO events (id, type, scope_id, session_id, agent, data, timestamp)
+         VALUES (?, 'DISPATCH', ?, NULL, 'sprint-orchestrator', ?, ?)`).run(eventId, scopeId, JSON.stringify({ command, sprint_id: sprintId, resolved: null }), new Date().toISOString());
+            this.io.emit('event:new', {
+                id: eventId, type: 'DISPATCH', scope_id: scopeId,
+                session_id: null, agent: 'sprint-orchestrator',
+                data: { command, sprint_id: sprintId, resolved: null },
+                timestamp: new Date().toISOString(),
+            });
+            // Update scope + sprint_scope status
+            this.scopeService.updateStatus(scopeId, 'implementing', 'dispatch');
+            this.sprintService.updateScopeStatus(sprintId, scopeId, 'dispatched');
+            // Build scope-aware session name and snapshot PIDs
+            const scopeRow = this.scopeService.getById(scopeId);
+            const sessionName = buildSessionName({ scopeId, title: scopeRow?.title, command });
+            const beforePids = snapshotSessionPids(getConfig().projectRoot);
+            // Launch in iTerm — interactive TUI mode (no -p) for full visibility
+            const escaped = escapeForAnsiC(command);
+            const fullCmd = `cd '${getConfig().projectRoot}' && claude --dangerously-skip-permissions $'${escaped}'`;
+            try {
+                await launchInCategorizedTerminal(command, fullCmd, sessionName);
+                // Fire-and-forget: discover session PID, link to dispatch, and rename
+                discoverNewSession(getConfig().projectRoot, beforePids)
+                    .then((session) => {
+                    if (!session)
+                        return;
+                    linkPidToDispatch(this.db, eventId, session.pid);
+                    if (sessionName)
+                        renameSession(getConfig().projectRoot, session.sessionId, sessionName);
+                })
+                    .catch(err => log.error('PID discovery failed', { error: err.message }));
+            }
+            catch (err) {
+                // Rollback scope status to previous value
+                this.scopeService.updateStatus(scopeId, previousStatus, 'rollback');
+                this.sprintService.updateScopeStatus(sprintId, scopeId, 'failed', `Launch failed: ${err}`);
+                resolveDispatchEvent(this.db, this.io, eventId, 'failed', `Launch failed: ${err}`);
+            }
+            // Stagger launches to prevent AppleScript race conditions
+            if (i < toDispatch.length - 1) {
+                await sleep(LAUNCH_STAGGER_MS);
+            }
+        }
+    }
+    async dispatchUnblockedScopes(sprintId) {
+        const sprint = this.sprintService.getById(sprintId);
+        if (!sprint)
+            return;
+        const scopes = this.sprintService.getSprintScopes(sprintId);
+        const completedSet = new Set(scopes.filter((ss) => ss.dispatch_status === 'completed').map((ss) => ss.scope_id));
+        const activeCount = scopes.filter((ss) => ss.dispatch_status === 'dispatched' || ss.dispatch_status === 'in_progress').length;
+        const available = sprint.concurrency_cap - activeCount;
+        if (available <= 0)
+            return;
+        // Find pending scopes whose internal deps are all completed
+        const ready = [];
+        for (const ss of scopes) {
+            if (ss.dispatch_status !== 'pending')
+                continue;
+            const scope = this.scopeService.getById(ss.scope_id);
+            if (!scope)
+                continue;
+            const internalDeps = scope.blocked_by.filter((d) => sprint.scope_ids.includes(d));
+            const allMet = internalDeps.every((d) => completedSet.has(d));
+            if (allMet)
+                ready.push(ss.scope_id);
+            if (ready.length >= available)
+                break;
+        }
+        if (ready.length > 0) {
+            await this.dispatchLayer(sprintId, ready, available);
+        }
+    }
+    skipDownstream(sprintId, failedScopeId) {
+        const scopes = this.sprintService.getSprintScopes(sprintId);
+        const sprintScopeIds = scopes.map((ss) => ss.scope_id);
+        // Build reverse dependency map: scope → scopes that depend on it
+        const dependents = new Map();
+        for (const scopeId of sprintScopeIds) {
+            const scope = this.scopeService.getById(scopeId);
+            if (!scope)
+                continue;
+            for (const dep of scope.blocked_by) {
+                if (!dependents.has(dep))
+                    dependents.set(dep, []);
+                dependents.get(dep).push(scopeId);
+            }
+        }
+        // BFS to find all transitive dependents
+        const toSkip = new Set();
+        const queue = [failedScopeId];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const downstream = dependents.get(current) ?? [];
+            for (const id of downstream) {
+                if (!toSkip.has(id)) {
+                    toSkip.add(id);
+                    queue.push(id);
+                }
+            }
+        }
+        for (const scopeId of toSkip) {
+            const ss = scopes.find((s) => s.scope_id === scopeId);
+            if (ss && ss.dispatch_status === 'pending') {
+                this.sprintService.updateScopeStatus(sprintId, scopeId, 'skipped', `Skipped: dependency ${failedScopeId} failed`);
+            }
+        }
+    }
+    checkSprintCompletion(sprintId) {
+        const scopes = this.sprintService.getSprintScopes(sprintId);
+        const allDone = scopes.every((ss) => ss.dispatch_status === 'completed' || ss.dispatch_status === 'failed' || ss.dispatch_status === 'skipped');
+        if (!allDone)
+            return;
+        const anyFailed = scopes.some((ss) => ss.dispatch_status === 'failed');
+        this.sprintService.updateStatus(sprintId, anyFailed ? 'failed' : 'completed');
+    }
+}

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

@@ -0,0 +1,293 @@
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('sprint');
+// ─── Service ────────────────────────────────────────────────
+export class SprintService {
+    db;
+    io;
+    scopeService;
+    constructor(db, io, scopeService) {
+        this.db = db;
+        this.io = io;
+        this.scopeService = scopeService;
+    }
+    /** Create a new sprint or batch in assembling state */
+    create(name, options) {
+        const now = new Date().toISOString();
+        const targetColumn = options?.target_column ?? 'backlog';
+        const groupType = options?.group_type ?? 'sprint';
+        const result = this.db.prepare(`INSERT INTO sprints (name, status, concurrency_cap, created_at, updated_at, target_column, group_type)
+       VALUES (?, 'assembling', 5, ?, ?, ?, ?)`).run(name, now, now, targetColumn, groupType);
+        const sprint = this.getById(Number(result.lastInsertRowid));
+        log.info('Sprint created', { id: sprint.id, name, group_type: groupType, target_column: targetColumn });
+        this.io.emit('sprint:created', sprint);
+        return sprint;
+    }
+    /** Rename a sprint/batch (only while assembling) */
+    rename(id, name) {
+        const result = this.db.prepare(`UPDATE sprints SET name = ?, updated_at = ? WHERE id = ? AND status = 'assembling'`).run(name, new Date().toISOString(), id);
+        if (result.changes > 0) {
+            this.emitUpdate(id);
+            return true;
+        }
+        return false;
+    }
+    /** List sprints, optionally filtered by status and/or target column */
+    getAll(status, targetColumn) {
+        let rows;
+        if (status && targetColumn) {
+            rows = this.db.prepare('SELECT * FROM sprints WHERE status = ? AND target_column = ? ORDER BY created_at DESC')
+                .all(status, targetColumn);
+        }
+        else if (status) {
+            rows = this.db.prepare('SELECT * FROM sprints WHERE status = ? ORDER BY created_at DESC').all(status);
+        }
+        else if (targetColumn) {
+            rows = this.db.prepare('SELECT * FROM sprints WHERE target_column = ? ORDER BY created_at DESC').all(targetColumn);
+        }
+        else {
+            rows = this.db.prepare('SELECT * FROM sprints ORDER BY created_at DESC').all();
+        }
+        return rows.map((row) => this.buildDetail(row));
+    }
+    /** Get full sprint detail by ID */
+    getById(id) {
+        const row = this.db.prepare('SELECT * FROM sprints WHERE id = ?').get(id);
+        if (!row)
+            return null;
+        return this.buildDetail(row);
+    }
+    /** Delete a sprint (only if assembling) */
+    delete(id) {
+        const row = this.db.prepare('SELECT status FROM sprints WHERE id = ?').get(id);
+        if (!row || row.status !== 'assembling')
+            return false;
+        this.db.prepare('DELETE FROM sprint_scopes WHERE sprint_id = ?').run(id);
+        this.db.prepare('DELETE FROM sprints WHERE id = ?').run(id);
+        this.io.emit('sprint:deleted', { id });
+        return true;
+    }
+    /** Add scopes to a sprint; returns which were added and any unmet dependencies */
+    addScopes(sprintId, scopeIds) {
+        const sprint = this.db.prepare('SELECT * FROM sprints WHERE id = ?').get(sprintId);
+        if (!sprint || sprint.status !== 'assembling')
+            return null;
+        // Existing scope IDs already in this sprint
+        const existingIds = new Set(this.db.prepare('SELECT scope_id FROM sprint_scopes WHERE sprint_id = ?').all(sprintId)
+            .map((r) => r.scope_id));
+        const added = [];
+        const unmet = [];
+        const insert = this.db.prepare(`INSERT OR IGNORE INTO sprint_scopes (sprint_id, scope_id, dispatch_status)
+       VALUES (?, ?, 'pending')`);
+        for (const scopeId of scopeIds) {
+            if (existingIds.has(scopeId))
+                continue;
+            // Check dependencies via cache
+            const scope = this.scopeService.getById(scopeId);
+            if (!scope)
+                continue;
+            // W-8: For batch groups, validate scope status matches target column
+            if (sprint.group_type === 'batch' && scope.status !== sprint.target_column) {
+                continue; // silently skip — frontend shows toast for rejected drops
+            }
+            const missing = [];
+            for (const depId of scope.blocked_by) {
+                if (existingIds.has(depId) || scopeIds.includes(depId))
+                    continue;
+                // Check if dependency is already complete (dev or beyond)
+                const dep = this.scopeService.getById(depId);
+                if (!dep)
+                    continue;
+                const completedStatuses = ['dev', 'staging', 'production'];
+                if (!completedStatuses.includes(dep.status)) {
+                    missing.push({ scope_id: dep.id, title: dep.title, status: dep.status });
+                }
+            }
+            if (missing.length > 0) {
+                unmet.push({ scope_id: scopeId, missing });
+            }
+            insert.run(sprintId, scopeId);
+            existingIds.add(scopeId);
+            added.push(scopeId);
+        }
+        this.touchUpdatedAt(sprintId);
+        this.emitUpdate(sprintId);
+        return { added, unmet_dependencies: unmet };
+    }
+    /** Remove scopes from a sprint (assembling only) */
+    removeScopes(sprintId, scopeIds) {
+        const sprint = this.db.prepare('SELECT status FROM sprints WHERE id = ?').get(sprintId);
+        if (!sprint || sprint.status !== 'assembling')
+            return false;
+        const remove = this.db.prepare('DELETE FROM sprint_scopes WHERE sprint_id = ? AND scope_id = ?');
+        for (const scopeId of scopeIds) {
+            remove.run(sprintId, scopeId);
+        }
+        this.touchUpdatedAt(sprintId);
+        this.emitUpdate(sprintId);
+        return true;
+    }
+    /** Update sprint status */
+    updateStatus(id, status) {
+        const now = new Date().toISOString();
+        const extras = {};
+        if (status === 'dispatched')
+            extras.dispatched_at = now;
+        if (status === 'completed' || status === 'failed' || status === 'cancelled')
+            extras.completed_at = now;
+        const setClauses = ['status = ?', 'updated_at = ?'];
+        const params = [status, now];
+        for (const [col, val] of Object.entries(extras)) {
+            setClauses.push(`${col} = ?`);
+            params.push(val);
+        }
+        params.push(id);
+        const result = this.db.prepare(`UPDATE sprints SET ${setClauses.join(', ')} WHERE id = ?`).run(...params);
+        if (result.changes > 0) {
+            log.info('Sprint status updated', { id, status });
+            this.emitUpdate(id);
+            if (status === 'completed') {
+                const detail = this.getById(id);
+                if (detail)
+                    this.io.emit('sprint:completed', detail);
+            }
+        }
+        return result.changes > 0;
+    }
+    /** Update a sprint scope's dispatch status */
+    updateScopeStatus(sprintId, scopeId, status, error) {
+        const now = new Date().toISOString();
+        const extras = [];
+        const params = [status];
+        if (status === 'dispatched') {
+            extras.push('dispatched_at = ?');
+            params.push(now);
+        }
+        if (status === 'completed' || status === 'failed' || status === 'skipped') {
+            extras.push('completed_at = ?');
+            params.push(now);
+        }
+        if (error != null) {
+            extras.push('error = ?');
+            params.push(error);
+        }
+        const setClauses = ['dispatch_status = ?', ...extras];
+        params.push(sprintId, scopeId);
+        this.db.prepare(`UPDATE sprint_scopes SET ${setClauses.join(', ')} WHERE sprint_id = ? AND scope_id = ?`).run(...params);
+        this.emitUpdate(sprintId);
+    }
+    /** Persist layer assignments for all scopes in a sprint */
+    setLayers(sprintId, layers) {
+        const update = this.db.prepare('UPDATE sprint_scopes SET layer = ? WHERE sprint_id = ? AND scope_id = ?');
+        for (let i = 0; i < layers.length; i++) {
+            for (const scopeId of layers[i]) {
+                update.run(i, sprintId, scopeId);
+            }
+        }
+        this.db.prepare('UPDATE sprints SET dispatch_meta = ?, updated_at = ? WHERE id = ?')
+            .run(JSON.stringify({ layers }), new Date().toISOString(), sprintId);
+    }
+    /** Find the active sprint containing a given scope (for orchestrator callbacks) */
+    findActiveSprintForScope(scopeId) {
+        return this.db.prepare(`SELECT ss.sprint_id FROM sprint_scopes ss
+       JOIN sprints s ON s.id = ss.sprint_id
+       WHERE ss.scope_id = ? AND s.status IN ('dispatched', 'in_progress')
+       LIMIT 1`).get(scopeId);
+    }
+    /** Find any active group (assembling/dispatched/in_progress) containing a scope.
+     *  Used to guard against moving scopes that are part of an active batch/sprint. */
+    getActiveGroupForScope(scopeId) {
+        return this.db.prepare(`SELECT ss.sprint_id, s.group_type FROM sprint_scopes ss
+       JOIN sprints s ON s.id = ss.sprint_id
+       WHERE ss.scope_id = ? AND s.status IN ('assembling', 'dispatched', 'in_progress')
+       LIMIT 1`).get(scopeId);
+    }
+    /** Force-remove a scope from a sprint regardless of sprint status.
+     *  Used for cleanup when a scope's status diverges from the batch target. */
+    forceRemoveScope(sprintId, scopeId) {
+        this.db.prepare('DELETE FROM sprint_scopes WHERE sprint_id = ? AND scope_id = ?')
+            .run(sprintId, scopeId);
+        this.touchUpdatedAt(sprintId);
+        this.emitUpdate(sprintId);
+    }
+    /** Get all sprint scopes for a sprint */
+    getSprintScopes(sprintId) {
+        return this.db.prepare('SELECT * FROM sprint_scopes WHERE sprint_id = ?').all(sprintId);
+    }
+    /** Store typed dispatch result (commit SHA, PR URL, etc.) for a batch */
+    updateDispatchResult(id, result) {
+        this.db.prepare('UPDATE sprints SET dispatch_result = ?, updated_at = ? WHERE id = ?')
+            .run(JSON.stringify(result), new Date().toISOString(), id);
+        this.emitUpdate(id);
+    }
+    /** Check if there's an active (assembling/dispatched/in_progress) batch in the given column */
+    findActiveBatchForColumn(targetColumn) {
+        const row = this.db.prepare(`SELECT * FROM sprints WHERE group_type = 'batch' AND target_column = ? AND status IN ('assembling', 'dispatched', 'in_progress')
+       ORDER BY created_at DESC LIMIT 1`).get(targetColumn);
+        if (!row)
+            return null;
+        return this.buildDetail(row);
+    }
+    // ─── Private Helpers ────────────────────────────────────────
+    buildDetail(row) {
+        const ssRows = this.db.prepare(`SELECT scope_id, layer, dispatch_status FROM sprint_scopes
+       WHERE sprint_id = ? ORDER BY layer ASC, scope_id ASC`).all(row.id);
+        const progress = { pending: 0, in_progress: 0, completed: 0, failed: 0, skipped: 0 };
+        const scopes = [];
+        for (const ss of ssRows) {
+            const scope = this.scopeService.getById(ss.scope_id);
+            scopes.push({
+                scope_id: ss.scope_id,
+                title: scope?.title ?? `Scope ${ss.scope_id}`,
+                scope_status: scope?.status ?? 'unknown',
+                effort_estimate: scope?.effort_estimate ?? null,
+                layer: ss.layer,
+                dispatch_status: ss.dispatch_status,
+            });
+            const key = ss.dispatch_status === 'dispatched' || ss.dispatch_status === 'queued'
+                ? 'in_progress' : ss.dispatch_status;
+            if (key in progress)
+                progress[key]++;
+            else
+                progress.pending++;
+        }
+        let layers = null;
+        try {
+            const meta = JSON.parse(row.dispatch_meta || '{}');
+            if (meta.layers)
+                layers = meta.layers;
+        }
+        catch { /* ignore */ }
+        let dispatchResult = null;
+        try {
+            const parsed = JSON.parse(row.dispatch_result || '{}');
+            if (Object.keys(parsed).length > 0)
+                dispatchResult = parsed;
+        }
+        catch { /* ignore */ }
+        return {
+            id: row.id,
+            name: row.name,
+            status: row.status,
+            concurrency_cap: row.concurrency_cap,
+            group_type: row.group_type ?? 'sprint',
+            target_column: row.target_column ?? 'backlog',
+            dispatch_result: dispatchResult,
+            scope_ids: ssRows.map((ss) => ss.scope_id),
+            scopes,
+            layers,
+            progress,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+            dispatched_at: row.dispatched_at,
+            completed_at: row.completed_at,
+        };
+    }
+    touchUpdatedAt(id) {
+        this.db.prepare('UPDATE sprints SET updated_at = ? WHERE id = ?').run(new Date().toISOString(), id);
+    }
+    emitUpdate(id) {
+        const detail = this.getById(id);
+        if (detail)
+            this.io.emit('sprint:updated', detail);
+    }
+}