@ai-sdlc/orchestrator 0.1.0

package/dist/autonomy-tracker.d.ts

@@ -0,0 +1,76 @@
+/**
+ * AutonomyTracker — computes real agent metrics from pipeline run history,
+ * evaluates promotion/demotion eligibility, and persists state changes.
+ *
+ * Replaces the hardcoded `totalTasksCompleted: 1` in execute.ts.
+ * RFC reference: Lines 264-280 (autonomy metrics).
+ */
+import type { StateStore } from './state/store.js';
+export interface AgentPerformanceMetrics {
+    totalTasks: number;
+    successCount: number;
+    failureCount: number;
+    successRate: number;
+    prApprovalRate: number;
+    rollbackCount: number;
+    securityIncidents: number;
+    avgDurationMs: number;
+    avgCostUsd: number;
+    recentFailures: number;
+    timeAtLevelMs: number;
+}
+export interface PromotionEvaluation {
+    eligible: boolean;
+    fromLevel: number;
+    toLevel: number;
+    unmetConditions: string[];
+    metrics: AgentPerformanceMetrics;
+}
+export interface DemotionEvaluation {
+    shouldDemote: boolean;
+    fromLevel: number;
+    toLevel: number;
+    reasons: string[];
+    metrics: AgentPerformanceMetrics;
+}
+export interface PromotionProximity {
+    currentLevel: number;
+    nextLevel: number;
+    conditionProgress: Array<{
+        condition: string;
+        current: number;
+        required: number;
+        met: boolean;
+    }>;
+}
+export declare class AutonomyTracker {
+    private store;
+    constructor(store: StateStore);
+    /**
+     * Record a task outcome and update the autonomy ledger.
+     */
+    recordTaskOutcome(agentName: string, success: boolean, opts?: {
+        durationMs?: number;
+        costUsd?: number;
+        prApproved?: boolean;
+        rollback?: boolean;
+        securityIncident?: boolean;
+    }): void;
+    /**
+     * Get computed performance metrics for an agent.
+     */
+    getAgentMetrics(agentName: string): AgentPerformanceMetrics;
+    /**
+     * Evaluate promotion eligibility and persist if promoted.
+     */
+    evaluateAndPersistPromotion(agentName: string): PromotionEvaluation;
+    /**
+     * Evaluate demotion triggers and persist if demoted.
+     */
+    evaluateAndPersistDemotion(agentName: string): DemotionEvaluation;
+    /**
+     * Get proximity to next promotion (for dashboard/reporting).
+     */
+    getPromotionProximity(agentName: string): PromotionProximity;
+}
+//# sourceMappingURL=autonomy-tracker.d.ts.map

package/dist/autonomy-tracker.js

@@ -0,0 +1,277 @@
+/**
+ * AutonomyTracker — computes real agent metrics from pipeline run history,
+ * evaluates promotion/demotion eligibility, and persists state changes.
+ *
+ * Replaces the hardcoded `totalTasksCompleted: 1` in execute.ts.
+ * RFC reference: Lines 264-280 (autonomy metrics).
+ */
+/** Minimum tasks required per level for promotion. */
+const PROMOTION_TASK_THRESHOLDS = {
+    0: 3,
+    1: 10,
+    2: 25,
+    3: 50,
+};
+/** Minimum success rate required per level for promotion. */
+const PROMOTION_SUCCESS_RATE = {
+    0: 0.8,
+    1: 0.85,
+    2: 0.9,
+    3: 0.95,
+};
+/** Minimum time at level (ms) before promotion. */
+const MIN_TIME_AT_LEVEL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+export class AutonomyTracker {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    /**
+     * Record a task outcome and update the autonomy ledger.
+     */
+    recordTaskOutcome(agentName, success, opts) {
+        const existing = this.store.getAutonomyLedger(agentName);
+        const now = new Date().toISOString();
+        const entry = {
+            agentName,
+            currentLevel: existing?.currentLevel ?? 0,
+            totalTasks: (existing?.totalTasks ?? 0) + 1,
+            successCount: (existing?.successCount ?? 0) + (success ? 1 : 0),
+            failureCount: (existing?.failureCount ?? 0) + (success ? 0 : 1),
+            lastTaskAt: now,
+            metrics: existing?.metrics,
+            prApprovalRate: existing?.prApprovalRate ?? 0,
+            rollbackCount: (existing?.rollbackCount ?? 0) + (opts?.rollback ? 1 : 0),
+            securityIncidents: (existing?.securityIncidents ?? 0) + (opts?.securityIncident ? 1 : 0),
+            promotedAt: existing?.promotedAt,
+            demotedAt: existing?.demotedAt,
+            timeAtLevelMs: existing?.timeAtLevelMs ?? 0,
+        };
+        // Update PR approval rate (running average)
+        if (opts?.prApproved !== undefined) {
+            const totalPRs = entry.totalTasks;
+            const prevApproved = Math.round((existing?.prApprovalRate ?? 0) * (existing?.totalTasks ?? 0));
+            const newApproved = prevApproved + (opts.prApproved ? 1 : 0);
+            entry.prApprovalRate = totalPRs > 0 ? newApproved / totalPRs : 0;
+        }
+        // Update time at level
+        if (existing?.lastTaskAt) {
+            const elapsed = new Date(now).getTime() - new Date(existing.lastTaskAt).getTime();
+            entry.timeAtLevelMs = (existing.timeAtLevelMs ?? 0) + elapsed;
+        }
+        this.store.upsertAutonomyLedger(entry);
+    }
+    /**
+     * Get computed performance metrics for an agent.
+     */
+    getAgentMetrics(agentName) {
+        const ledger = this.store.getAutonomyLedger(agentName);
+        if (!ledger) {
+            return {
+                totalTasks: 0,
+                successCount: 0,
+                failureCount: 0,
+                successRate: 0,
+                prApprovalRate: 0,
+                rollbackCount: 0,
+                securityIncidents: 0,
+                avgDurationMs: 0,
+                avgCostUsd: 0,
+                recentFailures: 0,
+                timeAtLevelMs: 0,
+            };
+        }
+        // Get recent pipeline runs for duration/cost stats
+        const runs = this.store
+            .getPipelineRuns(undefined, 100)
+            .filter((r) => r.agentName === agentName);
+        const durations = runs
+            .filter((r) => r.startedAt && r.completedAt)
+            .map((r) => new Date(r.completedAt).getTime() - new Date(r.startedAt).getTime());
+        const costs = runs.filter((r) => r.costUsd != null && r.costUsd > 0).map((r) => r.costUsd);
+        // Count recent failures (last 7 days)
+        const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+        const recentFailures = runs.filter((r) => r.status === 'failed' && r.startedAt && r.startedAt >= sevenDaysAgo).length;
+        return {
+            totalTasks: ledger.totalTasks,
+            successCount: ledger.successCount,
+            failureCount: ledger.failureCount,
+            successRate: ledger.totalTasks > 0 ? ledger.successCount / ledger.totalTasks : 0,
+            prApprovalRate: ledger.prApprovalRate ?? 0,
+            rollbackCount: ledger.rollbackCount ?? 0,
+            securityIncidents: ledger.securityIncidents ?? 0,
+            avgDurationMs: durations.length > 0 ? durations.reduce((a, b) => a + b, 0) / durations.length : 0,
+            avgCostUsd: costs.length > 0 ? costs.reduce((a, b) => a + b, 0) / costs.length : 0,
+            recentFailures,
+            timeAtLevelMs: ledger.timeAtLevelMs ?? 0,
+        };
+    }
+    /**
+     * Evaluate promotion eligibility and persist if promoted.
+     */
+    evaluateAndPersistPromotion(agentName) {
+        const metrics = this.getAgentMetrics(agentName);
+        const ledger = this.store.getAutonomyLedger(agentName);
+        const currentLevel = ledger?.currentLevel ?? 0;
+        const nextLevel = currentLevel + 1;
+        if (nextLevel > 4) {
+            return {
+                eligible: false,
+                fromLevel: currentLevel,
+                toLevel: currentLevel,
+                unmetConditions: ['Already at maximum level'],
+                metrics,
+            };
+        }
+        const unmetConditions = [];
+        // Check task threshold
+        const taskThreshold = PROMOTION_TASK_THRESHOLDS[currentLevel] ?? 50;
+        if (metrics.totalTasks < taskThreshold) {
+            unmetConditions.push(`Need ${taskThreshold} tasks, have ${metrics.totalTasks}`);
+        }
+        // Check success rate
+        const rateThreshold = PROMOTION_SUCCESS_RATE[currentLevel] ?? 0.9;
+        if (metrics.successRate < rateThreshold) {
+            unmetConditions.push(`Need ${Math.round(rateThreshold * 100)}% success rate, have ${Math.round(metrics.successRate * 100)}%`);
+        }
+        // Check no recent security incidents
+        if (metrics.securityIncidents > 0) {
+            unmetConditions.push(`${metrics.securityIncidents} security incidents must be resolved`);
+        }
+        // Check time at level
+        if (metrics.timeAtLevelMs < MIN_TIME_AT_LEVEL_MS) {
+            const daysNeeded = Math.ceil(MIN_TIME_AT_LEVEL_MS / (24 * 60 * 60 * 1000));
+            const daysAt = Math.floor(metrics.timeAtLevelMs / (24 * 60 * 60 * 1000));
+            unmetConditions.push(`Need ${daysNeeded}d at level, have ${daysAt}d`);
+        }
+        const eligible = unmetConditions.length === 0;
+        if (eligible && ledger) {
+            // Persist promotion
+            const now = new Date().toISOString();
+            this.store.upsertAutonomyLedger({
+                ...ledger,
+                currentLevel: nextLevel,
+                promotedAt: now,
+                timeAtLevelMs: 0, // Reset time at level
+            });
+            // Record autonomy event
+            this.store.saveAutonomyEvent({
+                agentName,
+                eventType: 'promotion',
+                fromLevel: currentLevel,
+                toLevel: nextLevel,
+                trigger: 'auto-promotion',
+                metricsSnapshot: JSON.stringify(metrics),
+            });
+        }
+        return {
+            eligible,
+            fromLevel: currentLevel,
+            toLevel: eligible ? nextLevel : currentLevel,
+            unmetConditions,
+            metrics,
+        };
+    }
+    /**
+     * Evaluate demotion triggers and persist if demoted.
+     */
+    evaluateAndPersistDemotion(agentName) {
+        const metrics = this.getAgentMetrics(agentName);
+        const ledger = this.store.getAutonomyLedger(agentName);
+        const currentLevel = ledger?.currentLevel ?? 0;
+        if (currentLevel === 0) {
+            return {
+                shouldDemote: false,
+                fromLevel: 0,
+                toLevel: 0,
+                reasons: [],
+                metrics,
+            };
+        }
+        const reasons = [];
+        // Demotion trigger: high recent failure rate
+        if (metrics.recentFailures >= 3) {
+            reasons.push(`${metrics.recentFailures} recent failures in 7 days`);
+        }
+        // Demotion trigger: security incident
+        if (metrics.securityIncidents > 0) {
+            reasons.push(`${metrics.securityIncidents} security incident(s)`);
+        }
+        // Demotion trigger: rollbacks
+        if (metrics.rollbackCount >= 2) {
+            reasons.push(`${metrics.rollbackCount} rollbacks`);
+        }
+        // Demotion trigger: success rate dropped below threshold
+        if (metrics.totalTasks >= 5 && metrics.successRate < 0.6) {
+            reasons.push(`Success rate dropped to ${Math.round(metrics.successRate * 100)}%`);
+        }
+        const shouldDemote = reasons.length > 0;
+        const toLevel = shouldDemote ? Math.max(0, currentLevel - 1) : currentLevel;
+        if (shouldDemote && ledger) {
+            const now = new Date().toISOString();
+            this.store.upsertAutonomyLedger({
+                ...ledger,
+                currentLevel: toLevel,
+                demotedAt: now,
+                timeAtLevelMs: 0,
+            });
+            this.store.saveAutonomyEvent({
+                agentName,
+                eventType: 'demotion',
+                fromLevel: currentLevel,
+                toLevel,
+                trigger: reasons.join('; '),
+                metricsSnapshot: JSON.stringify(metrics),
+            });
+        }
+        return {
+            shouldDemote,
+            fromLevel: currentLevel,
+            toLevel,
+            reasons,
+            metrics,
+        };
+    }
+    /**
+     * Get proximity to next promotion (for dashboard/reporting).
+     */
+    getPromotionProximity(agentName) {
+        const metrics = this.getAgentMetrics(agentName);
+        const ledger = this.store.getAutonomyLedger(agentName);
+        const currentLevel = ledger?.currentLevel ?? 0;
+        const nextLevel = Math.min(currentLevel + 1, 4);
+        const taskThreshold = PROMOTION_TASK_THRESHOLDS[currentLevel] ?? 50;
+        const rateThreshold = PROMOTION_SUCCESS_RATE[currentLevel] ?? 0.9;
+        return {
+            currentLevel,
+            nextLevel,
+            conditionProgress: [
+                {
+                    condition: 'Tasks completed',
+                    current: metrics.totalTasks,
+                    required: taskThreshold,
+                    met: metrics.totalTasks >= taskThreshold,
+                },
+                {
+                    condition: 'Success rate',
+                    current: Math.round(metrics.successRate * 100),
+                    required: Math.round(rateThreshold * 100),
+                    met: metrics.successRate >= rateThreshold,
+                },
+                {
+                    condition: 'No security incidents',
+                    current: metrics.securityIncidents,
+                    required: 0,
+                    met: metrics.securityIncidents === 0,
+                },
+                {
+                    condition: 'Time at level (days)',
+                    current: Math.floor(metrics.timeAtLevelMs / (24 * 60 * 60 * 1000)),
+                    required: Math.ceil(MIN_TIME_AT_LEVEL_MS / (24 * 60 * 60 * 1000)),
+                    met: metrics.timeAtLevelMs >= MIN_TIME_AT_LEVEL_MS,
+                },
+            ],
+        };
+    }
+}
+//# sourceMappingURL=autonomy-tracker.js.map

package/dist/check-runs.d.ts

@@ -0,0 +1,37 @@
+/**
+ * GitHub Check Run integration via `gh` CLI.
+ * Creates one check run per gate result. Falls back gracefully when `gh` is unavailable.
+ */
+export interface CheckRunInput {
+    name: string;
+    headSha: string;
+    status: 'queued' | 'in_progress' | 'completed';
+    conclusion?: 'success' | 'failure' | 'neutral' | 'skipped';
+    title?: string;
+    summary?: string;
+}
+/**
+ * Create a GitHub Check Run for a gate result.
+ */
+export declare function createCheckRun(input: CheckRunInput): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * Update an existing GitHub Check Run.
+ */
+export declare function updateCheckRun(checkRunId: number, input: Partial<CheckRunInput>): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+export interface GateResult {
+    gate: string;
+    verdict: 'pass' | 'fail' | 'skip';
+    message?: string;
+}
+/**
+ * Report gate results as GitHub Check Runs.
+ * Creates one check run per gate result. Falls back silently on failure.
+ */
+export declare function reportGateCheckRuns(headSha: string, gateResults: GateResult[]): Promise<void>;
+//# sourceMappingURL=check-runs.d.ts.map

package/dist/check-runs.js

@@ -0,0 +1,72 @@
+/**
+ * GitHub Check Run integration via `gh` CLI.
+ * Creates one check run per gate result. Falls back gracefully when `gh` is unavailable.
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { DEFAULT_GH_CLI_TIMEOUT_MS } from './defaults.js';
+const execFileAsync = promisify(execFile);
+async function ghApiCall(method, endpoint, body) {
+    try {
+        const args = ['api', endpoint, '--method', method];
+        for (const [key, value] of Object.entries(body)) {
+            args.push('-f', `${key}=${String(value)}`);
+        }
+        await execFileAsync('gh', args, { timeout: DEFAULT_GH_CLI_TIMEOUT_MS });
+        return { success: true };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { success: false, error: message };
+    }
+}
+/**
+ * Create a GitHub Check Run for a gate result.
+ */
+export async function createCheckRun(input) {
+    const body = {
+        name: input.name,
+        head_sha: input.headSha,
+        status: input.status,
+    };
+    if (input.conclusion)
+        body.conclusion = input.conclusion;
+    if (input.title || input.summary) {
+        body['output[title]'] = input.title ?? input.name;
+        body['output[summary]'] = input.summary ?? '';
+    }
+    return ghApiCall('POST', 'repos/{owner}/{repo}/check-runs', body);
+}
+/**
+ * Update an existing GitHub Check Run.
+ */
+export async function updateCheckRun(checkRunId, input) {
+    const body = {};
+    if (input.status)
+        body.status = input.status;
+    if (input.conclusion)
+        body.conclusion = input.conclusion;
+    if (input.title || input.summary) {
+        body['output[title]'] = input.title ?? '';
+        body['output[summary]'] = input.summary ?? '';
+    }
+    return ghApiCall('PATCH', `repos/{owner}/{repo}/check-runs/${checkRunId}`, body);
+}
+/**
+ * Report gate results as GitHub Check Runs.
+ * Creates one check run per gate result. Falls back silently on failure.
+ */
+export async function reportGateCheckRuns(headSha, gateResults) {
+    for (const result of gateResults) {
+        const conclusion = result.verdict === 'pass' ? 'success' : result.verdict === 'fail' ? 'failure' : 'neutral';
+        await createCheckRun({
+            name: `AI-SDLC: ${result.gate}`,
+            headSha,
+            status: 'completed',
+            conclusion,
+            title: `Gate: ${result.gate}`,
+            summary: result.message ?? `Gate ${result.gate}: ${result.verdict}`,
+        });
+    }
+}
+//# sourceMappingURL=check-runs.js.map

package/dist/cli/commands/agents.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ai-sdlc agents [name] — show agent roster, autonomy levels, performance.
+ */
+import { Command } from 'commander';
+export declare const agentsCommand: Command;
+//# sourceMappingURL=agents.d.ts.map

package/dist/cli/commands/agents.js

@@ -0,0 +1,33 @@
+/**
+ * ai-sdlc agents [name] — show agent roster, autonomy levels, performance.
+ */
+import { Command } from 'commander';
+import { Orchestrator } from '../../orchestrator.js';
+import { formatOutput } from '../formatters/index.js';
+export const agentsCommand = new Command('agents')
+    .description('Show agent roster with autonomy levels and performance')
+    .argument('[name]', 'Filter by agent name')
+    .option('--state <path>', 'SQLite state database path')
+    .action(async (name, opts, cmd) => {
+    const globalOpts = cmd.parent?.opts() ?? {};
+    const format = globalOpts.format ?? 'table';
+    const orchestrator = new Orchestrator({
+        configDir: globalOpts.config,
+        statePath: opts.state,
+    });
+    try {
+        let agents = await orchestrator.agents();
+        if (name) {
+            agents = agents.filter((a) => a.agentName === name);
+        }
+        console.log(formatOutput(format, { type: 'agents', agents }));
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+    }
+    finally {
+        orchestrator.close();
+    }
+});
+//# sourceMappingURL=agents.js.map

package/dist/cli/commands/complexity.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ai-sdlc complexity [--analyze] — show codebase complexity profile.
+ */
+import { Command } from 'commander';
+export declare const complexityCommand: Command;
+//# sourceMappingURL=complexity.d.ts.map

package/dist/cli/commands/complexity.js

@@ -0,0 +1,35 @@
+/**
+ * ai-sdlc complexity [--analyze] — show codebase complexity profile.
+ */
+import { Command } from 'commander';
+import { Orchestrator } from '../../orchestrator.js';
+import { formatOutput } from '../formatters/index.js';
+export const complexityCommand = new Command('complexity')
+    .description('Show codebase complexity profile')
+    .option('--analyze', 'Force a fresh analysis (skip cache)')
+    .option('--state <path>', 'SQLite state database path')
+    .action(async (opts, cmd) => {
+    const globalOpts = cmd.parent?.opts() ?? {};
+    const format = globalOpts.format ?? 'table';
+    const orchestrator = new Orchestrator({
+        configDir: globalOpts.config,
+        statePath: opts.state,
+        workDir: process.cwd(),
+    });
+    try {
+        const { profile, context } = await orchestrator.complexity({ analyze: opts.analyze });
+        console.log(formatOutput(format, {
+            type: 'complexity',
+            profile,
+            context,
+        }));
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+    }
+    finally {
+        orchestrator.close();
+    }
+});
+//# sourceMappingURL=complexity.js.map

package/dist/cli/commands/cost.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ai-sdlc cost [--last <dur>] [--agent <name>] [--budget <usd>]
+ */
+import { Command } from 'commander';
+export declare const costCommand: Command;
+//# sourceMappingURL=cost.d.ts.map

package/dist/cli/commands/cost.js

@@ -0,0 +1,53 @@
+/**
+ * ai-sdlc cost [--last <dur>] [--agent <name>] [--budget <usd>]
+ */
+import { Command } from 'commander';
+import { Orchestrator } from '../../orchestrator.js';
+import { formatOutput } from '../formatters/index.js';
+export const costCommand = new Command('cost')
+    .description('Show cost summary and budget status')
+    .option('--last <duration>', 'Time range (e.g., 7d, 30d, 1h)')
+    .option('--agent <name>', 'Filter by agent name')
+    .option('--budget <usd>', 'Budget in USD', parseFloat)
+    .option('--state <path>', 'SQLite state database path')
+    .action(async (opts, cmd) => {
+    const globalOpts = cmd.parent?.parent?.opts() ?? {};
+    const format = globalOpts.format ?? 'table';
+    const orchestrator = new Orchestrator({
+        configDir: globalOpts.config,
+        statePath: opts.state,
+    });
+    try {
+        const since = opts.last ? computeSince(opts.last) : undefined;
+        const { summary, budget } = await orchestrator.cost({ since, budget: opts.budget });
+        const data = {
+            type: 'cost',
+            summary,
+            budget,
+            agent: opts.agent,
+            period: opts.last ?? 'all-time',
+        };
+        // Filter by agent if requested
+        if (opts.agent && summary.costByAgent) {
+            data.filteredCost = summary.costByAgent[opts.agent] ?? 0;
+        }
+        console.log(formatOutput(format, data));
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+    }
+    finally {
+        orchestrator.close();
+    }
+});
+function computeSince(duration) {
+    const match = duration.match(/^(\d+)([dhm])$/);
+    if (!match)
+        return new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    const ms = unit === 'd' ? value * 86400000 : unit === 'h' ? value * 3600000 : value * 60000;
+    return new Date(Date.now() - ms).toISOString();
+}
+//# sourceMappingURL=cost.js.map

package/dist/cli/commands/dashboard.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ai-sdlc dashboard — live TUI monitoring dashboard.
+ *
+ * Uses setInterval + ANSI repainting. Ctrl-C to exit.
+ * D1: Zero dependencies — pure ANSI escape codes.
+ */
+import { Command } from 'commander';
+export declare const dashboardCommand: Command;
+//# sourceMappingURL=dashboard.d.ts.map

package/dist/cli/commands/dashboard.js

@@ -0,0 +1,50 @@
+/**
+ * ai-sdlc dashboard — live TUI monitoring dashboard.
+ *
+ * Uses setInterval + ANSI repainting. Ctrl-C to exit.
+ * D1: Zero dependencies — pure ANSI escape codes.
+ */
+import { Command } from 'commander';
+import { Orchestrator } from '../../orchestrator.js';
+import { renderDashboardFrame } from '../dashboard-renderer.js';
+import { DEFAULT_DASHBOARD_REFRESH_MS } from '../../defaults.js';
+export const dashboardCommand = new Command('dashboard')
+    .description('Live monitoring dashboard (Ctrl-C to exit)')
+    .option('--refresh <ms>', 'Refresh interval in ms', String(DEFAULT_DASHBOARD_REFRESH_MS))
+    .option('--state <path>', 'SQLite state database path')
+    .action(async (opts, cmd) => {
+    const globalOpts = cmd.parent?.parent?.opts() ?? {};
+    const refreshMs = parseInt(opts.refresh, 10) || DEFAULT_DASHBOARD_REFRESH_MS;
+    const orchestrator = new Orchestrator({
+        configDir: globalOpts.config,
+        statePath: opts.state,
+    });
+    // Clear screen and hide cursor
+    process.stdout.write('\x1B[?25l\x1B[2J\x1B[H');
+    const render = async () => {
+        try {
+            const data = await orchestrator.dashboard();
+            const width = process.stdout.columns || 80;
+            const frame = renderDashboardFrame(data, width);
+            // Move cursor to top-left and write frame
+            process.stdout.write('\x1B[H' + frame);
+        }
+        catch {
+            // Dashboard rendering is best-effort
+        }
+    };
+    // Initial render
+    await render();
+    // Polling loop
+    const interval = setInterval(render, refreshMs);
+    // Graceful shutdown
+    const cleanup = () => {
+        clearInterval(interval);
+        process.stdout.write('\x1B[?25h\n'); // Show cursor
+        orchestrator.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+});
+//# sourceMappingURL=dashboard.js.map

package/dist/cli/commands/health.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ai-sdlc health — validate config, state store, and adapter connectivity.
+ */
+import { Command } from 'commander';
+export declare const healthCommand: Command;
+//# sourceMappingURL=health.d.ts.map