@wundr.io/cli 1.0.12 → 1.0.14

package/dist/commands/alignment.js

@@ -0,0 +1,817 @@
+"use strict";
+/**
+ * Alignment Monitoring CLI Commands
+ *
+ * Provides commands for monitoring AI agent alignment drift across five dimensions:
+ * - Policy Violation Rate
+ * - Intent-Outcome Gap
+ * - Evaluator Disagreement
+ * - Escalation Suppression
+ * - Reward Hacking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAlignmentCommand = createAlignmentCommand;
+const tslib_1 = require("tslib");
+const os = tslib_1.__importStar(require("os"));
+const path = tslib_1.__importStar(require("path"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const commander_1 = require("commander");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const ora_1 = tslib_1.__importDefault(require("ora"));
+// ============================================================================
+// AlignmentDriftDetector - Embedded Implementation
+// ============================================================================
+class AlignmentDriftDetector {
+    dataDir;
+    historyFile;
+    // Thresholds from Three-Tier Architecture spec
+    thresholds = {
+        policyViolation: 0.005, // >0.5% daily violations triggers alert
+        intentOutcomeGap: 0.15, // >15% divergence is concerning
+        evaluatorDisagreement: 0.2, // >20% monthly overrides
+        escalationSuppression: 0.4, // >40% drop from baseline
+        rewardHacking: 5, // >5 instances/month
+    };
+    constructor(dataDir) {
+        this.dataDir = dataDir || path.join(os.homedir(), '.wundr', 'alignment');
+        this.historyFile = path.join(this.dataDir, 'history.json');
+    }
+    async initialize() {
+        await fs_extra_1.default.ensureDir(this.dataDir);
+        if (!(await fs_extra_1.default.pathExists(this.historyFile))) {
+            await fs_extra_1.default.writeJson(this.historyFile, { entries: [] }, { spaces: 2 });
+        }
+    }
+    async calculateAlignmentDebt(sessionId) {
+        const metrics = await this.collectMetrics(sessionId);
+        return this.calculateScore(metrics);
+    }
+    async getAlignmentReport(sessionId) {
+        await this.initialize();
+        const metrics = await this.collectMetrics(sessionId);
+        const score = this.calculateScore(metrics);
+        const status = this.determineStatus(score);
+        const dimensions = this.analyzeDimensions(metrics);
+        const recommendations = this.generateRecommendations(dimensions, status);
+        const report = {
+            timestamp: new Date().toISOString(),
+            sessionId,
+            overallScore: score,
+            status,
+            metrics,
+            dimensions,
+            recommendations,
+        };
+        // Store in history
+        await this.storeHistoryEntry({
+            timestamp: report.timestamp,
+            sessionId,
+            score,
+            status,
+            metrics,
+        });
+        return report;
+    }
+    async getAlignmentScore(sessionId) {
+        const score = await this.calculateAlignmentDebt(sessionId);
+        const status = this.determineStatus(score);
+        return {
+            score,
+            status,
+            color: status === 'healthy'
+                ? 'green'
+                : status === 'warning'
+                    ? 'yellow'
+                    : 'red',
+        };
+    }
+    async getHistory(days = 30) {
+        await this.initialize();
+        const history = await this.loadHistory();
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - days);
+        return history.entries
+            .filter((entry) => new Date(entry.timestamp) >= cutoffDate)
+            .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+    }
+    async getDimensionBreakdown() {
+        const metrics = await this.collectMetrics();
+        return this.analyzeDimensions(metrics);
+    }
+    async generateDebtReport(days = 7, sessionId, outputFile) {
+        await this.initialize();
+        const history = await this.getHistory(days);
+        const filteredHistory = sessionId
+            ? history.filter(h => h.sessionId === sessionId)
+            : history;
+        const endDate = new Date();
+        const startDate = new Date();
+        startDate.setDate(startDate.getDate() - days);
+        // Calculate summary statistics
+        const scores = filteredHistory.map(h => h.score);
+        const averageScore = scores.length > 0
+            ? scores.reduce((a, b) => a + b, 0) / scores.length
+            : 100;
+        const lowestScore = scores.length > 0 ? Math.min(...scores) : 100;
+        const highestScore = scores.length > 0 ? Math.max(...scores) : 100;
+        // Calculate trend
+        let trend = 'stable';
+        if (scores.length >= 2) {
+            const firstHalf = scores.slice(0, Math.floor(scores.length / 2));
+            const secondHalf = scores.slice(Math.floor(scores.length / 2));
+            const firstAvg = firstHalf.reduce((a, b) => a + b, 0) / firstHalf.length;
+            const secondAvg = secondHalf.reduce((a, b) => a + b, 0) / secondHalf.length;
+            if (secondAvg > firstAvg + 5) {
+                trend = 'improving';
+            }
+            else if (secondAvg < firstAvg - 5) {
+                trend = 'degrading';
+            }
+        }
+        // Analyze dimensions across history
+        const dimensionAnalysis = {};
+        const dimensionKeys = [
+            'policyViolationRate',
+            'intentOutcomeGap',
+            'evaluatorDisagreement',
+            'escalationSuppression',
+            'rewardHacking',
+        ];
+        for (const key of dimensionKeys) {
+            const values = filteredHistory.map(h => h.metrics[key]);
+            const threshold = this.getThresholdForKey(key);
+            dimensionAnalysis[key] = {
+                average: values.length > 0
+                    ? values.reduce((a, b) => a + b, 0) / values.length
+                    : 0,
+                max: values.length > 0 ? Math.max(...values) : 0,
+                exceedances: values.filter(v => v > threshold).length,
+            };
+        }
+        // Find critical events
+        const criticalEvents = [];
+        for (const entry of filteredHistory) {
+            for (const key of dimensionKeys) {
+                const threshold = this.getThresholdForKey(key);
+                if (entry.metrics[key] > threshold * 2) {
+                    criticalEvents.push({
+                        timestamp: entry.timestamp,
+                        dimension: key,
+                        value: entry.metrics[key],
+                        threshold,
+                    });
+                }
+            }
+        }
+        // Calculate total violations
+        const totalViolations = Object.values(dimensionAnalysis).reduce((sum, dim) => sum + dim.exceedances, 0);
+        // Generate recommendations
+        const recommendations = this.generateDebtRecommendations(dimensionAnalysis, trend);
+        const report = {
+            generatedAt: new Date().toISOString(),
+            period: {
+                start: startDate.toISOString(),
+                end: endDate.toISOString(),
+                days,
+            },
+            summary: {
+                averageScore,
+                lowestScore,
+                highestScore,
+                trend,
+                totalViolations,
+            },
+            dimensionAnalysis,
+            criticalEvents: criticalEvents.slice(0, 20),
+            recommendations,
+        };
+        if (outputFile) {
+            await fs_extra_1.default.writeJson(outputFile, report, { spaces: 2 });
+        }
+        return report;
+    }
+    getThresholds() {
+        return { ...this.thresholds };
+    }
+    async collectMetrics(sessionId) {
+        const sessionMetricsFile = sessionId
+            ? path.join(this.dataDir, 'sessions', `${sessionId}.json`)
+            : path.join(this.dataDir, 'current-metrics.json');
+        if (await fs_extra_1.default.pathExists(sessionMetricsFile)) {
+            try {
+                const data = await fs_extra_1.default.readJson(sessionMetricsFile);
+                return {
+                    policyViolationRate: data.policyViolationRate ?? 0,
+                    intentOutcomeGap: data.intentOutcomeGap ?? 0,
+                    evaluatorDisagreement: data.evaluatorDisagreement ?? 0,
+                    escalationSuppression: data.escalationSuppression ?? 0,
+                    rewardHacking: data.rewardHacking ?? 0,
+                };
+            }
+            catch {
+                // Fall through to defaults
+            }
+        }
+        return {
+            policyViolationRate: 0,
+            intentOutcomeGap: 0,
+            evaluatorDisagreement: 0,
+            escalationSuppression: 0,
+            rewardHacking: 0,
+        };
+    }
+    calculateScore(metrics) {
+        const normalizedPolicyViolation = Math.min(metrics.policyViolationRate / this.thresholds.policyViolation, 2);
+        const normalizedIntentGap = Math.min(metrics.intentOutcomeGap / this.thresholds.intentOutcomeGap, 2);
+        const normalizedEvaluatorDisagreement = Math.min(metrics.evaluatorDisagreement / this.thresholds.evaluatorDisagreement, 2);
+        const normalizedEscalationSuppression = Math.min(metrics.escalationSuppression / this.thresholds.escalationSuppression, 2);
+        const normalizedRewardHacking = Math.min(metrics.rewardHacking / this.thresholds.rewardHacking, 2);
+        const weights = {
+            policyViolation: 0.25,
+            intentOutcomeGap: 0.25,
+            evaluatorDisagreement: 0.2,
+            escalationSuppression: 0.15,
+            rewardHacking: 0.15,
+        };
+        const penalty = normalizedPolicyViolation * weights.policyViolation +
+            normalizedIntentGap * weights.intentOutcomeGap +
+            normalizedEvaluatorDisagreement * weights.evaluatorDisagreement +
+            normalizedEscalationSuppression * weights.escalationSuppression +
+            normalizedRewardHacking * weights.rewardHacking;
+        const score = Math.max(0, Math.min(100, 100 - penalty * 50));
+        return Math.round(score * 10) / 10;
+    }
+    determineStatus(score) {
+        if (score >= 80) {
+            return 'healthy';
+        }
+        if (score >= 50) {
+            return 'warning';
+        }
+        return 'critical';
+    }
+    analyzeDimensions(metrics) {
+        return [
+            {
+                name: 'Policy Violation Rate',
+                key: 'policyViolationRate',
+                threshold: this.thresholds.policyViolation,
+                description: 'Percentage of actions violating defined constraints',
+                currentValue: metrics.policyViolationRate,
+                status: this.getDimensionStatus(metrics.policyViolationRate, this.thresholds.policyViolation),
+            },
+            {
+                name: 'Intent-Outcome Gap',
+                key: 'intentOutcomeGap',
+                threshold: this.thresholds.intentOutcomeGap,
+                description: 'Divergence between stated goals and actual outcomes',
+                currentValue: metrics.intentOutcomeGap,
+                status: this.getDimensionStatus(metrics.intentOutcomeGap, this.thresholds.intentOutcomeGap),
+            },
+            {
+                name: 'Evaluator Disagreement',
+                key: 'evaluatorDisagreement',
+                threshold: this.thresholds.evaluatorDisagreement,
+                description: 'Rate of human overrides on agent decisions',
+                currentValue: metrics.evaluatorDisagreement,
+                status: this.getDimensionStatus(metrics.evaluatorDisagreement, this.thresholds.evaluatorDisagreement),
+            },
+            {
+                name: 'Escalation Suppression',
+                key: 'escalationSuppression',
+                threshold: this.thresholds.escalationSuppression,
+                description: 'Drop in escalation triggers compared to baseline',
+                currentValue: metrics.escalationSuppression,
+                status: this.getDimensionStatus(metrics.escalationSuppression, this.thresholds.escalationSuppression),
+            },
+            {
+                name: 'Reward Hacking',
+                key: 'rewardHacking',
+                threshold: this.thresholds.rewardHacking,
+                description: 'Instances of gaming metrics without achieving intent',
+                currentValue: metrics.rewardHacking,
+                status: this.getDimensionStatus(metrics.rewardHacking, this.thresholds.rewardHacking),
+            },
+        ];
+    }
+    getDimensionStatus(value, threshold) {
+        if (value <= threshold) {
+            return 'healthy';
+        }
+        if (value <= threshold * 2) {
+            return 'warning';
+        }
+        return 'critical';
+    }
+    getThresholdForKey(key) {
+        const thresholdMap = {
+            policyViolationRate: this.thresholds.policyViolation,
+            intentOutcomeGap: this.thresholds.intentOutcomeGap,
+            evaluatorDisagreement: this.thresholds.evaluatorDisagreement,
+            escalationSuppression: this.thresholds.escalationSuppression,
+            rewardHacking: this.thresholds.rewardHacking,
+        };
+        return thresholdMap[key];
+    }
+    generateRecommendations(dimensions, status) {
+        const recommendations = [];
+        for (const dim of dimensions) {
+            if (dim.status === 'critical') {
+                recommendations.push(`CRITICAL: ${dim.name} at ${this.formatValue(dim.currentValue, dim.key)} exceeds threshold (${this.formatValue(dim.threshold, dim.key)}). Immediate action required.`);
+            }
+            else if (dim.status === 'warning') {
+                recommendations.push(`WARNING: ${dim.name} at ${this.formatValue(dim.currentValue, dim.key)} approaching threshold (${this.formatValue(dim.threshold, dim.key)}). Monitor closely.`);
+            }
+        }
+        if (status === 'critical') {
+            recommendations.push('Consider pausing autonomous operations until alignment issues are resolved.');
+            recommendations.push('Schedule immediate review with Guardian role.');
+        }
+        else if (status === 'warning') {
+            recommendations.push('Review recent agent decisions for potential alignment drift.');
+            recommendations.push('Consider tightening constraints or adding checkpoints.');
+        }
+        if (recommendations.length === 0) {
+            recommendations.push('All alignment metrics within acceptable thresholds.');
+        }
+        return recommendations;
+    }
+    generateDebtRecommendations(dimensionAnalysis, trend) {
+        const recommendations = [];
+        if (trend === 'degrading') {
+            recommendations.push('Alignment score is degrading over time. Review recent changes to agent configurations.');
+        }
+        else if (trend === 'improving') {
+            recommendations.push('Alignment score is improving. Continue current governance practices.');
+        }
+        for (const [key, analysis] of Object.entries(dimensionAnalysis)) {
+            if (analysis.exceedances > 0) {
+                const friendlyName = this.getFriendlyDimensionName(key);
+                const entry = analysis;
+                recommendations.push(`${friendlyName}: ${entry.exceedances} threshold exceedance(s) detected. Average: ${entry.average.toFixed(3)}`);
+            }
+        }
+        return recommendations;
+    }
+    getFriendlyDimensionName(key) {
+        const names = {
+            policyViolationRate: 'Policy Violation Rate',
+            intentOutcomeGap: 'Intent-Outcome Gap',
+            evaluatorDisagreement: 'Evaluator Disagreement',
+            escalationSuppression: 'Escalation Suppression',
+            rewardHacking: 'Reward Hacking',
+        };
+        return names[key] || key;
+    }
+    formatValue(value, key) {
+        if (key === 'rewardHacking') {
+            return `${value} instances`;
+        }
+        return `${(value * 100).toFixed(1)}%`;
+    }
+    async storeHistoryEntry(entry) {
+        const history = await this.loadHistory();
+        history.entries.push(entry);
+        if (history.entries.length > 1000) {
+            history.entries = history.entries.slice(-1000);
+        }
+        await fs_extra_1.default.writeJson(this.historyFile, history, { spaces: 2 });
+    }
+    async loadHistory() {
+        try {
+            if (await fs_extra_1.default.pathExists(this.historyFile)) {
+                return await fs_extra_1.default.readJson(this.historyFile);
+            }
+        }
+        catch {
+            // Fall through to default
+        }
+        return { entries: [] };
+    }
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+function padRight(str, length) {
+    return str.length >= length
+        ? str.substring(0, length)
+        : str + ' '.repeat(length - str.length);
+}
+function getStatusColor(status) {
+    switch (status) {
+        case 'healthy':
+            return chalk_1.default.green;
+        case 'warning':
+            return chalk_1.default.yellow;
+        case 'critical':
+            return chalk_1.default.red;
+        default:
+            return chalk_1.default.white;
+    }
+}
+function getStatusIcon(status) {
+    switch (status) {
+        case 'healthy':
+            return '[HEALTHY]';
+        case 'warning':
+            return '[WARNING]';
+        case 'critical':
+            return '[CRITICAL]';
+        default:
+            return '[UNKNOWN]';
+    }
+}
+function formatScore(score) {
+    if (score >= 80) {
+        return chalk_1.default.green(`${score.toFixed(1)}/100`);
+    }
+    if (score >= 50) {
+        return chalk_1.default.yellow(`${score.toFixed(1)}/100`);
+    }
+    return chalk_1.default.red(`${score.toFixed(1)}/100`);
+}
+function formatTrend(trend) {
+    switch (trend) {
+        case 'improving':
+            return chalk_1.default.green('Improving [^]');
+        case 'degrading':
+            return chalk_1.default.red('Degrading [v]');
+        case 'stable':
+            return chalk_1.default.gray('Stable [-]');
+        default:
+            return chalk_1.default.gray('Unknown');
+    }
+}
+function formatPercentage(value) {
+    return `${(value * 100).toFixed(2)}%`;
+}
+function formatDimensionValue(value, key) {
+    if (key === 'rewardHacking') {
+        return `${value} instances`;
+    }
+    return formatPercentage(value);
+}
+// ============================================================================
+// Command Factory
+// ============================================================================
+/**
+ * Create the alignment command with subcommands
+ */
+function createAlignmentCommand() {
+    const command = new commander_1.Command('alignment')
+        .description('Alignment drift monitoring and reporting')
+        .addHelpText('after', chalk_1.default.gray(`
+Examples:
+  ${chalk_1.default.green('wundr alignment report')}              Generate alignment debt report
+  ${chalk_1.default.green('wundr alignment score')}               Get current alignment score
+  ${chalk_1.default.green('wundr alignment history --days 7')}    Show alignment history for past week
+  ${chalk_1.default.green('wundr alignment dimensions')}          Show breakdown by dimension
+      `));
+    // Report subcommand
+    command
+        .command('report')
+        .description('Generate alignment debt report')
+        .option('-s, --session <id>', 'Filter by session ID')
+        .option('-d, --days <n>', 'Number of days to analyze', '7')
+        .option('-o, --output <file>', 'Output file path for JSON report')
+        .action(async (options) => {
+        await generateAlignmentReport(options);
+    });
+    // Score subcommand
+    command
+        .command('score')
+        .description('Get current alignment score')
+        .option('-s, --session <id>', 'Get score for specific session')
+        .action(async (options) => {
+        await showAlignmentScore(options);
+    });
+    // History subcommand
+    command
+        .command('history')
+        .description('Show alignment history')
+        .option('-d, --days <n>', 'Number of days to show', '30')
+        .option('-f, --format <type>', 'Output format (table, json, chart)', 'table')
+        .action(async (options) => {
+        await showAlignmentHistory(options);
+    });
+    // Dimensions subcommand
+    command
+        .command('dimensions')
+        .description('Show breakdown by dimension')
+        .option('-s, --session <id>', 'Get dimensions for specific session')
+        .action(async (options) => {
+        await showDimensionBreakdown(options);
+    });
+    return command;
+}
+// ============================================================================
+// Command Implementations
+// ============================================================================
+async function generateAlignmentReport(options) {
+    const spinner = (0, ora_1.default)('Generating alignment debt report...').start();
+    try {
+        const detector = new AlignmentDriftDetector();
+        await detector.initialize();
+        const days = parseInt(options.days || '7', 10);
+        const report = await detector.generateDebtReport(days, options.session, options.output);
+        spinner.stop();
+        // Display report header
+        console.log(chalk_1.default.cyan('\nAlignment Debt Report'));
+        console.log(chalk_1.default.gray('='.repeat(70)));
+        console.log(chalk_1.default.white('Generated: ') +
+            chalk_1.default.gray(new Date(report.generatedAt).toLocaleString()));
+        console.log(chalk_1.default.white('Period:    ') +
+            chalk_1.default.gray(`${days} days (${new Date(report.period.start).toLocaleDateString()} - ${new Date(report.period.end).toLocaleDateString()})`));
+        if (options.session) {
+            console.log(chalk_1.default.white('Session:   ') + chalk_1.default.gray(options.session));
+        }
+        // Summary section
+        console.log(chalk_1.default.gray('\n' + '-'.repeat(70)));
+        console.log(chalk_1.default.cyan('Summary'));
+        console.log(chalk_1.default.white('Average Score:    ') +
+            formatScore(report.summary.averageScore));
+        console.log(chalk_1.default.white('Lowest Score:     ') +
+            formatScore(report.summary.lowestScore));
+        console.log(chalk_1.default.white('Highest Score:    ') +
+            formatScore(report.summary.highestScore));
+        console.log(chalk_1.default.white('Trend:            ') + formatTrend(report.summary.trend));
+        console.log(chalk_1.default.white('Total Violations: ') +
+            (report.summary.totalViolations > 0
+                ? chalk_1.default.red(String(report.summary.totalViolations))
+                : chalk_1.default.green('0')));
+        // Dimension analysis section
+        console.log(chalk_1.default.gray('\n' + '-'.repeat(70)));
+        console.log(chalk_1.default.cyan('Dimension Analysis'));
+        console.log(chalk_1.default.cyan(padRight('Dimension', 25) +
+            padRight('Average', 12) +
+            padRight('Max', 12) +
+            padRight('Exceedances', 12)));
+        console.log(chalk_1.default.gray('-'.repeat(61)));
+        const dimensionNames = {
+            policyViolationRate: 'Policy Violation Rate',
+            intentOutcomeGap: 'Intent-Outcome Gap',
+            evaluatorDisagreement: 'Evaluator Disagreement',
+            escalationSuppression: 'Escalation Suppression',
+            rewardHacking: 'Reward Hacking',
+        };
+        for (const [key, analysis] of Object.entries(report.dimensionAnalysis)) {
+            const name = dimensionNames[key] || key;
+            const entry = analysis;
+            const exceedanceColor = entry.exceedances > 0 ? chalk_1.default.red : chalk_1.default.green;
+            console.log(padRight(name, 25) +
+                padRight(formatDimensionValue(entry.average, key), 12) +
+                padRight(formatDimensionValue(entry.max, key), 12) +
+                exceedanceColor(padRight(String(entry.exceedances), 12)));
+        }
+        // Critical events section
+        if (report.criticalEvents.length > 0) {
+            console.log(chalk_1.default.gray('\n' + '-'.repeat(70)));
+            console.log(chalk_1.default.red('Critical Events'));
+            for (const event of report.criticalEvents.slice(0, 5)) {
+                const dimName = dimensionNames[event.dimension] || event.dimension;
+                console.log(chalk_1.default.red('  [!] ') +
+                    chalk_1.default.gray(new Date(event.timestamp).toLocaleString()) +
+                    chalk_1.default.white(` ${dimName}: `) +
+                    chalk_1.default.red(formatDimensionValue(event.value, event.dimension)) +
+                    chalk_1.default.gray(` (threshold: ${formatDimensionValue(event.threshold, event.dimension)})`));
+            }
+            if (report.criticalEvents.length > 5) {
+                console.log(chalk_1.default.gray(`  ... and ${report.criticalEvents.length - 5} more`));
+            }
+        }
+        // Recommendations section
+        console.log(chalk_1.default.gray('\n' + '-'.repeat(70)));
+        console.log(chalk_1.default.cyan('Recommendations'));
+        for (const rec of report.recommendations) {
+            const color = rec.startsWith('CRITICAL')
+                ? chalk_1.default.red
+                : rec.startsWith('WARNING')
+                    ? chalk_1.default.yellow
+                    : chalk_1.default.white;
+            console.log(color(`  - ${rec}`));
+        }
+        console.log(chalk_1.default.gray('='.repeat(70)));
+        // Show output file if saved
+        if (options.output) {
+            console.log(chalk_1.default.green(`\nReport saved to: ${options.output}`));
+        }
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Failed to generate alignment report');
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+    }
+}
+async function showAlignmentScore(options) {
+    const spinner = (0, ora_1.default)('Calculating alignment score...').start();
+    try {
+        const detector = new AlignmentDriftDetector();
+        await detector.initialize();
+        const result = await detector.getAlignmentScore(options.session);
+        spinner.stop();
+        console.log(chalk_1.default.cyan('\nAlignment Score'));
+        console.log(chalk_1.default.gray('='.repeat(40)));
+        // Large score display with color
+        const scoreColor = result.color === 'green'
+            ? chalk_1.default.green
+            : result.color === 'yellow'
+                ? chalk_1.default.yellow
+                : chalk_1.default.red;
+        const scoreDisplay = `
+    ${scoreColor('  +-----------------+')}
+    ${scoreColor('  |                 |')}
+    ${scoreColor('  |')}     ${chalk_1.default.bold(scoreColor(result.score.toFixed(1)))}       ${scoreColor('|')}
+    ${scoreColor('  |')}    ${chalk_1.default.gray('/100')}        ${scoreColor('|')}
+    ${scoreColor('  |                 |')}
+    ${scoreColor('  +-----------------+')}
+`;
+        console.log(scoreDisplay);
+        const statusColor = getStatusColor(result.status);
+        console.log(chalk_1.default.white('Status: ') + statusColor(getStatusIcon(result.status)));
+        if (options.session) {
+            console.log(chalk_1.default.white('Session: ') + chalk_1.default.gray(options.session));
+        }
+        // Show quick dimension summary
+        const report = await detector.getAlignmentReport(options.session);
+        console.log(chalk_1.default.gray('\n' + '-'.repeat(40)));
+        console.log(chalk_1.default.cyan('Quick Dimension Status'));
+        for (const dim of report.dimensions) {
+            const dimStatusColor = getStatusColor(dim.status);
+            const icon = dim.status === 'healthy'
+                ? '[OK]'
+                : dim.status === 'warning'
+                    ? '[!]'
+                    : '[X]';
+            console.log(dimStatusColor(`  ${icon} `) +
+                chalk_1.default.white(padRight(dim.name, 25)) +
+                dimStatusColor(formatDimensionValue(dim.currentValue, dim.key)));
+        }
+        console.log(chalk_1.default.gray('='.repeat(40)));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Failed to get alignment score');
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+    }
+}
+async function showAlignmentHistory(options) {
+    const spinner = (0, ora_1.default)('Loading alignment history...').start();
+    try {
+        const detector = new AlignmentDriftDetector();
+        await detector.initialize();
+        const days = parseInt(options.days || '30', 10);
+        const history = await detector.getHistory(days);
+        spinner.stop();
+        if (options.format === 'json') {
+            console.log(JSON.stringify({
+                timestamp: new Date().toISOString(),
+                days,
+                count: history.length,
+                entries: history,
+            }, null, 2));
+            return;
+        }
+        console.log(chalk_1.default.cyan('\nAlignment History'));
+        console.log(chalk_1.default.gray('='.repeat(80)));
+        console.log(chalk_1.default.gray(`Showing last ${days} days (${history.length} entries)`));
+        if (history.length === 0) {
+            console.log(chalk_1.default.yellow('\nNo alignment history found.'));
+            console.log(chalk_1.default.gray('Run "wundr alignment score" to start tracking.'));
+            console.log('');
+            return;
+        }
+        if (options.format === 'chart') {
+            displayHistoryChart(history);
+        }
+        else {
+            // Table format (default)
+            console.log(chalk_1.default.gray('\n' + '-'.repeat(80)));
+            console.log(chalk_1.default.cyan(padRight('Timestamp', 22) +
+                padRight('Score', 10) +
+                padRight('Status', 12) +
+                padRight('Session', 20) +
+                padRight('Policy', 10)));
+            console.log(chalk_1.default.gray('-'.repeat(80)));
+            for (const entry of history.slice(0, 20)) {
+                const statusColor = getStatusColor(entry.status);
+                const timestamp = new Date(entry.timestamp).toLocaleString();
+                console.log(padRight(timestamp, 22) +
+                    formatScore(entry.score).padEnd(19) + // Account for ANSI codes
+                    statusColor(padRight(getStatusIcon(entry.status), 12)) +
+                    chalk_1.default.gray(padRight(entry.sessionId || '-', 20)) +
+                    padRight(formatPercentage(entry.metrics.policyViolationRate), 10));
+            }
+            if (history.length > 20) {
+                console.log(chalk_1.default.gray(`... and ${history.length - 20} more entries`));
+            }
+        }
+        console.log(chalk_1.default.gray('='.repeat(80)));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Failed to load alignment history');
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+    }
+}
+function displayHistoryChart(history) {
+    const chartHeight = 10;
+    const chartWidth = Math.min(60, history.length);
+    const step = Math.ceil(history.length / chartWidth);
+    const sampledHistory = history
+        .filter((_, i) => i % step === 0)
+        .slice(0, chartWidth);
+    console.log(chalk_1.default.gray('\n  Score Trend:'));
+    console.log(chalk_1.default.gray('  100 |'));
+    for (let row = chartHeight; row >= 0; row--) {
+        const threshold = (row / chartHeight) * 100;
+        let line = `  ${String(Math.round(threshold)).padStart(3)} |`;
+        for (const entry of sampledHistory) {
+            if (entry.score >= threshold &&
+                entry.score < threshold + 100 / chartHeight) {
+                const color = entry.score >= 80
+                    ? chalk_1.default.green
+                    : entry.score >= 50
+                        ? chalk_1.default.yellow
+                        : chalk_1.default.red;
+                line += color('*');
+            }
+            else if (entry.score >= threshold) {
+                line += chalk_1.default.gray('|');
+            }
+            else {
+                line += ' ';
+            }
+        }
+        console.log(line);
+    }
+    console.log(chalk_1.default.gray('    0 +' + '-'.repeat(chartWidth)));
+    console.log(chalk_1.default.gray('       ' +
+        'oldest'.padEnd(chartWidth / 2) +
+        'newest'.padStart(chartWidth / 2)));
+}
+async function showDimensionBreakdown(options) {
+    const spinner = (0, ora_1.default)('Loading dimension breakdown...').start();
+    try {
+        const detector = new AlignmentDriftDetector();
+        await detector.initialize();
+        const dimensions = await detector.getDimensionBreakdown();
+        const thresholds = detector.getThresholds();
+        spinner.stop();
+        console.log(chalk_1.default.cyan('\nAlignment Dimensions'));
+        console.log(chalk_1.default.gray('='.repeat(90)));
+        if (options.session) {
+            console.log(chalk_1.default.white('Session: ') + chalk_1.default.gray(options.session));
+            console.log('');
+        }
+        // Display each dimension in detail
+        for (const dim of dimensions) {
+            const statusColor = getStatusColor(dim.status);
+            const icon = dim.status === 'healthy'
+                ? '[OK]'
+                : dim.status === 'warning'
+                    ? '[!!]'
+                    : '[XX]';
+            console.log(chalk_1.default.gray('-'.repeat(90)));
+            console.log(chalk_1.default.bold(statusColor(`${icon} ${dim.name}`)));
+            console.log(chalk_1.default.gray(`   ${dim.description}`));
+            console.log('');
+            // Value bar visualization
+            const barWidth = 40;
+            const valueRatio = Math.min(dim.currentValue / (dim.threshold * 3), 1);
+            const thresholdPos = Math.floor((dim.threshold / (dim.threshold * 3)) * barWidth);
+            const valuePos = Math.floor(valueRatio * barWidth);
+            let bar = '';
+            for (let i = 0; i < barWidth; i++) {
+                if (i === thresholdPos) {
+                    bar += chalk_1.default.yellow('|');
+                }
+                else if (i < valuePos) {
+                    bar += statusColor('#');
+                }
+                else {
+                    bar += chalk_1.default.gray('-');
+                }
+            }
+            console.log(`   [${bar}]`);
+            console.log(`   ${chalk_1.default.white('Current:')} ${statusColor(formatDimensionValue(dim.currentValue, dim.key))}  ${chalk_1.default.white('Threshold:')} ${chalk_1.default.yellow(formatDimensionValue(dim.threshold, dim.key))}`);
+            console.log(`   ${chalk_1.default.white('Status:')} ${statusColor(dim.status.toUpperCase())}`);
+        }
+        // Threshold reference
+        console.log(chalk_1.default.gray('\n' + '='.repeat(90)));
+        console.log(chalk_1.default.cyan('Threshold Reference'));
+        console.log(chalk_1.default.gray(`  Policy Violation:      >${formatPercentage(thresholds.policyViolation)} daily violations`));
+        console.log(chalk_1.default.gray(`  Intent-Outcome Gap:    >${formatPercentage(thresholds.intentOutcomeGap)} divergence`));
+        console.log(chalk_1.default.gray(`  Evaluator Disagreement:>${formatPercentage(thresholds.evaluatorDisagreement)} monthly overrides`));
+        console.log(chalk_1.default.gray(`  Escalation Suppression:>${formatPercentage(thresholds.escalationSuppression)} drop from baseline`));
+        console.log(chalk_1.default.gray(`  Reward Hacking:        >${thresholds.rewardHacking} instances/month`));
+        console.log(chalk_1.default.gray('='.repeat(90)));
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Failed to load dimension breakdown');
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+    }
+}
+// Export the command
+exports.default = createAlignmentCommand;
+//# sourceMappingURL=alignment.js.map