@wundr.io/cli 1.0.12 → 1.0.13

package/dist/commands/governance.js

@@ -0,0 +1,703 @@
+"use strict";
+/**
+ * Governance CLI Commands - IPRE Compliance
+ *
+ * Implements governance commands from Appendix B:
+ * - wundr governance check - Run IPRE compliance check
+ * - wundr governance report - Generate alignment debt report
+ * - wundr governance status - Show current governance status
+ * - wundr governance validate <file> - Validate IPRE config file
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAlignmentCommand = void 0;
+exports.createGovernanceCommand = createGovernanceCommand;
+exports.governanceCommand = createGovernanceCommand;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(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 yaml_1 = tslib_1.__importDefault(require("yaml"));
+const governance_1 = require("@wundr.io/governance");
+const error_handler_1 = require("../utils/error-handler");
+const logger_1 = require("../utils/logger");
+// ============================================================================
+// Governance Command Factory
+// ============================================================================
+/**
+ * Creates the governance command with all subcommands
+ */
+function createGovernanceCommand() {
+    const governance = new commander_1.Command('governance')
+        .alias('gov')
+        .description('IPRE governance and compliance tools');
+    // Check subcommand
+    governance
+        .command('check')
+        .description('Run IPRE compliance check')
+        .option('-s, --session <id>', 'Session ID to check')
+        .option('-v, --verbose', 'Enable verbose output')
+        .action(async (options) => {
+        await runComplianceCheck(options);
+    });
+    // Report subcommand
+    governance
+        .command('report')
+        .description('Generate alignment debt report')
+        .option('-s, --session <id>', 'Session ID for the report')
+        .option('-o, --output <file>', 'Output file path')
+        .option('-f, --format <format>', 'Output format (md|json)', 'md')
+        .action(async (options) => {
+        await generateAlignmentReport(options);
+    });
+    // Status subcommand
+    governance
+        .command('status')
+        .description('Show current governance status')
+        .action(async () => {
+        await showGovernanceStatus();
+    });
+    // Validate subcommand
+    governance
+        .command('validate <file>')
+        .description('Validate IPRE config file')
+        .action(async (file) => {
+        await validateIPREConfig(file);
+    });
+    return governance;
+}
+// Re-export the full-featured alignment command from the dedicated module
+// This provides: report, score, history, and dimensions subcommands
+var alignment_1 = require("./alignment");
+Object.defineProperty(exports, "createAlignmentCommand", { enumerable: true, get: function () { return alignment_1.createAlignmentCommand; } });
+// ============================================================================
+// Command Implementations
+// ============================================================================
+/**
+ * Run IPRE compliance check
+ */
+async function runComplianceCheck(options) {
+    try {
+        logger_1.logger.info('Running IPRE compliance check...');
+        const sessionId = options.session || `session-${Date.now()}`;
+        const verbose = options.verbose || false;
+        // Create evaluation context
+        const context = {
+            evaluationId: `eval-${Date.now()}`,
+            timestamp: new Date(),
+            source: 'manual',
+            repository: process.cwd(),
+            metadata: {
+                sessionId,
+            },
+        };
+        // Create evaluator suite
+        const suite = (0, governance_1.createEvaluatorSuite)();
+        // Run policy compliance check
+        console.log(chalk_1.default.blue('\n--- Policy Compliance ---'));
+        const complianceResult = await suite.policyCompliance.checkPolicyCompliance(context);
+        displayComplianceResult(complianceResult, verbose);
+        // Run reward alignment check
+        console.log(chalk_1.default.blue('\n--- Reward Alignment ---'));
+        const alignmentEvaluator = (0, governance_1.createEvaluator)('reward_alignment');
+        const alignmentResult = await alignmentEvaluator.evaluate(context);
+        displayAlignmentResult(alignmentResult, verbose);
+        // Run drift detection
+        console.log(chalk_1.default.blue('\n--- Drift Detection ---'));
+        const driftEvaluator = (0, governance_1.createEvaluator)('drift_detection');
+        const driftResult = await driftEvaluator.evaluate(context);
+        displayDriftResult(driftResult, verbose);
+        // Run full suite and show summary
+        console.log(chalk_1.default.blue('\n--- Overall Summary ---'));
+        const evaluators = [
+            suite.policyCompliance,
+            suite.rewardAlignment,
+            suite.driftDetection,
+        ];
+        const suiteResult = await (0, governance_1.runEvaluatorSuite)(evaluators, context);
+        displaySummary(suiteResult);
+        // Save state for future checks
+        await saveGovernanceState(sessionId, {
+            complianceResult,
+            alignmentResult,
+            driftResult,
+            suiteResult,
+        });
+        if (suiteResult.passed) {
+            logger_1.logger.success('IPRE compliance check passed');
+        }
+        else {
+            logger_1.logger.warn('IPRE compliance check found issues');
+            process.exitCode = 1;
+        }
+    }
+    catch (error) {
+        throw error_handler_1.errorHandler.createError('WUNDR_GOV_CHECK_FAILED', 'Failed to run IPRE compliance check', { options }, true);
+    }
+}
+/**
+ * Generate alignment debt report
+ */
+async function generateAlignmentReport(options) {
+    try {
+        logger_1.logger.info('Generating alignment debt report...');
+        const sessionId = options.session || null;
+        const format = options.format || 'md';
+        const outputPath = options.output || `alignment-report-${Date.now()}.${format}`;
+        // Create evaluation context
+        const context = {
+            evaluationId: `eval-${Date.now()}`,
+            timestamp: new Date(),
+            source: 'manual',
+            repository: process.cwd(),
+        };
+        // Run all evaluations
+        const suite = (0, governance_1.createEvaluatorSuite)();
+        const complianceResult = await suite.policyCompliance.checkPolicyCompliance(context);
+        // Get alignment gaps
+        const alignmentEvaluator = (0, governance_1.createEvaluator)('reward_alignment');
+        const alignmentEvalResult = await alignmentEvaluator.evaluate(context);
+        // Get drift indicators
+        const driftEvaluator = (0, governance_1.createEvaluator)('drift_detection');
+        const driftEvalResult = await driftEvaluator.evaluate(context);
+        // Build report
+        const report = {
+            generatedAt: new Date().toISOString(),
+            sessionId,
+            summary: {
+                totalDebt: calculateAlignmentDebt(complianceResult, alignmentEvalResult, driftEvalResult),
+                criticalIssues: countCriticalIssues(complianceResult),
+                highPriorityItems: countHighPriorityItems(alignmentEvalResult),
+                alignmentScore: alignmentEvalResult.score,
+                complianceScore: complianceResult.score,
+                driftScore: 1 - driftEvalResult.score, // Invert since lower drift is better
+            },
+            policyViolations: complianceResult.violations.map(v => ({
+                policyId: v.policyId,
+                policyName: v.policyName,
+                severity: v.severity,
+                description: v.description,
+                location: v.location,
+                suggestedFix: v.suggestedFix,
+            })),
+            alignmentGaps: extractAlignmentGaps(alignmentEvalResult),
+            driftAlerts: extractDriftAlerts(driftEvalResult),
+            recommendations: generateRecommendations(complianceResult, alignmentEvalResult, driftEvalResult),
+        };
+        // Output report
+        if (format === 'json') {
+            await fs_extra_1.default.writeJson(outputPath, report, { spaces: 2 });
+        }
+        else {
+            const markdown = formatReportAsMarkdown(report);
+            await fs_extra_1.default.writeFile(outputPath, markdown, 'utf-8');
+        }
+        logger_1.logger.success(`Alignment debt report generated: ${outputPath}`);
+        // Display summary
+        console.log(chalk_1.default.blue('\n--- Report Summary ---'));
+        console.log(`Total Alignment Debt: ${chalk_1.default.yellow(report.summary.totalDebt.toFixed(2))}`);
+        console.log(`Critical Issues: ${chalk_1.default.red(report.summary.criticalIssues)}`);
+        console.log(`High Priority Items: ${chalk_1.default.yellow(report.summary.highPriorityItems)}`);
+        console.log(`Alignment Score: ${colorScore(report.summary.alignmentScore)}`);
+        console.log(`Compliance Score: ${colorScore(report.summary.complianceScore)}`);
+        console.log(`Drift Score: ${colorScore(1 - report.summary.driftScore)}`);
+    }
+    catch (error) {
+        throw error_handler_1.errorHandler.createError('WUNDR_GOV_REPORT_FAILED', 'Failed to generate alignment debt report', { options }, true);
+    }
+}
+/**
+ * Show current governance status
+ */
+async function showGovernanceStatus() {
+    try {
+        logger_1.logger.info('Fetching governance status...');
+        // Load saved state if available
+        const state = await loadGovernanceState();
+        // Create policy engine and get stats
+        const policyEngine = new governance_1.PolicyEngine();
+        const violationStats = policyEngine.getViolationStats();
+        const status = {
+            alignmentScore: state?.suiteResult?.overallScore ?? 0,
+            policyViolations: violationStats.total,
+            recentInterventions: await loadRecentInterventions(),
+            lastCheck: state?.timestamp ? new Date(state.timestamp) : null,
+            driftIndicators: extractDriftIndicatorsFromState(state),
+        };
+        // Display status
+        console.log(chalk_1.default.cyan('\n===================================='));
+        console.log(chalk_1.default.cyan('       GOVERNANCE STATUS'));
+        console.log(chalk_1.default.cyan('====================================\n'));
+        // Alignment Score
+        console.log(chalk_1.default.bold('Alignment Score:'));
+        displayProgressBar(status.alignmentScore);
+        console.log(`  ${colorScore(status.alignmentScore)} (${(status.alignmentScore * 100).toFixed(1)}%)\n`);
+        // Policy Violations
+        console.log(chalk_1.default.bold('Policy Violations:'));
+        if (status.policyViolations === 0) {
+            console.log(chalk_1.default.green('  No active violations'));
+        }
+        else {
+            console.log(chalk_1.default.red(`  ${status.policyViolations} active violations`));
+            console.log(`    - Security: ${violationStats.byCategory.security}`);
+            console.log(`    - Compliance: ${violationStats.byCategory.compliance}`);
+            console.log(`    - Operational: ${violationStats.byCategory.operational}`);
+        }
+        console.log();
+        // Recent Interventions
+        console.log(chalk_1.default.bold('Recent Interventions:'));
+        if (status.recentInterventions.length === 0) {
+            console.log(chalk_1.default.green('  No recent interventions'));
+        }
+        else {
+            for (const intervention of status.recentInterventions.slice(0, 5)) {
+                const statusIcon = intervention.resolved
+                    ? chalk_1.default.green('[RESOLVED]')
+                    : chalk_1.default.yellow('[OPEN]');
+                console.log(`  ${statusIcon} ${intervention.type}: ${intervention.description}`);
+            }
+        }
+        console.log();
+        // Drift Indicators
+        console.log(chalk_1.default.bold('Drift Indicators:'));
+        if (status.driftIndicators.length === 0) {
+            console.log(chalk_1.default.green('  No significant drift detected'));
+        }
+        else {
+            for (const indicator of status.driftIndicators) {
+                const severityColor = getSeverityColor(indicator.severity);
+                const direction = indicator.change > 0 ? '+' : '';
+                console.log(`  ${severityColor(`[${indicator.severity.toUpperCase()}]`)} ` +
+                    `${indicator.pattern}: ${direction}${(indicator.change * 100).toFixed(1)}%`);
+            }
+        }
+        console.log();
+        // Last Check
+        if (status.lastCheck) {
+            console.log(chalk_1.default.gray(`Last check: ${status.lastCheck.toLocaleString()}`));
+        }
+        else {
+            console.log(chalk_1.default.gray('No previous checks found. Run "wundr governance check" to start.'));
+        }
+    }
+    catch (error) {
+        throw error_handler_1.errorHandler.createError('WUNDR_GOV_STATUS_FAILED', 'Failed to fetch governance status', {}, true);
+    }
+}
+/**
+ * Validate IPRE config file
+ */
+async function validateIPREConfig(file) {
+    try {
+        const filePath = path_1.default.isAbsolute(file)
+            ? file
+            : path_1.default.join(process.cwd(), file);
+        logger_1.logger.info(`Validating IPRE config: ${filePath}`);
+        // Check file exists
+        if (!(await fs_extra_1.default.pathExists(filePath))) {
+            logger_1.logger.error(`File not found: ${filePath}`);
+            process.exitCode = 1;
+            return;
+        }
+        // Read and parse file
+        const content = await fs_extra_1.default.readFile(filePath, 'utf-8');
+        let config;
+        const ext = path_1.default.extname(file).toLowerCase();
+        if (ext === '.yaml' || ext === '.yml') {
+            config = yaml_1.default.parse(content);
+        }
+        else if (ext === '.json') {
+            config = JSON.parse(content);
+        }
+        else {
+            logger_1.logger.error('Unsupported file format. Use .yaml, .yml, or .json');
+            process.exitCode = 1;
+            return;
+        }
+        // Validate schema
+        const validationErrors = validateIPRESchema(config);
+        if (validationErrors.length === 0) {
+            console.log(chalk_1.default.green('\nIPRE configuration is valid'));
+            displayConfigSummary(config);
+        }
+        else {
+            console.log(chalk_1.default.red('\nIPRE configuration validation failed:\n'));
+            for (const error of validationErrors) {
+                console.log(chalk_1.default.red(`  - ${error}`));
+            }
+            process.exitCode = 1;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw error_handler_1.errorHandler.createError('WUNDR_GOV_VALIDATE_FAILED', `Failed to validate IPRE config: ${message}`, { file }, true);
+    }
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+function displayComplianceResult(result, verbose) {
+    const statusIcon = result.compliant
+        ? chalk_1.default.green('[PASS]')
+        : chalk_1.default.red('[FAIL]');
+    console.log(`${statusIcon} Compliance Score: ${colorScore(result.score)}`);
+    console.log(`  Passed Policies: ${result.passedPolicies.length}`);
+    console.log(`  Skipped Policies: ${result.skippedPolicies.length}`);
+    console.log(`  Violations: ${result.violations.length}`);
+    if (verbose && result.violations.length > 0) {
+        console.log(chalk_1.default.yellow('\n  Violations:'));
+        for (const violation of result.violations) {
+            console.log(`    - [${violation.severity.toUpperCase()}] ${violation.policyName}`);
+            console.log(`      ${violation.description}`);
+            if (violation.suggestedFix) {
+                console.log(chalk_1.default.gray(`      Fix: ${violation.suggestedFix}`));
+            }
+        }
+    }
+}
+function displayAlignmentResult(result, verbose) {
+    const statusIcon = result.passed
+        ? chalk_1.default.green('[PASS]')
+        : chalk_1.default.red('[FAIL]');
+    console.log(`${statusIcon} Alignment Score: ${colorScore(result.score)}`);
+    console.log(`  Issues: ${result.issues.length}`);
+    console.log(`  Recommendations: ${result.recommendations.length}`);
+    if (verbose && result.issues.length > 0) {
+        console.log(chalk_1.default.yellow('\n  Issues:'));
+        for (const issue of result.issues) {
+            console.log(`    - ${issue}`);
+        }
+    }
+    if (verbose && result.recommendations.length > 0) {
+        console.log(chalk_1.default.blue('\n  Recommendations:'));
+        for (const rec of result.recommendations) {
+            console.log(`    - ${rec}`);
+        }
+    }
+}
+function displayDriftResult(result, verbose) {
+    // Note: For drift, higher score means less drift (inverted in evaluation)
+    const driftScore = 1 - result.score;
+    const statusIcon = result.passed
+        ? chalk_1.default.green('[PASS]')
+        : chalk_1.default.red('[FAIL]');
+    console.log(`${statusIcon} Drift Score: ${colorScore(result.score)} (${(driftScore * 100).toFixed(1)}% drift)`);
+    console.log(`  Drift Alerts: ${result.issues.length}`);
+    if (verbose && result.issues.length > 0) {
+        console.log(chalk_1.default.yellow('\n  Drift Alerts:'));
+        for (const issue of result.issues) {
+            console.log(`    - ${issue}`);
+        }
+    }
+}
+function displaySummary(result) {
+    const statusIcon = result.passed
+        ? chalk_1.default.green('[PASSED]')
+        : chalk_1.default.red('[FAILED]');
+    console.log(`\n${statusIcon} Overall Score: ${colorScore(result.overallScore)}`);
+    if (result.criticalIssues.length > 0) {
+        console.log(chalk_1.default.red(`\nCritical Issues (${result.criticalIssues.length}):`));
+        for (const issue of result.criticalIssues.slice(0, 5)) {
+            console.log(chalk_1.default.red(`  - ${issue}`));
+        }
+        if (result.criticalIssues.length > 5) {
+            console.log(chalk_1.default.gray(`  ... and ${result.criticalIssues.length - 5} more`));
+        }
+    }
+}
+function colorScore(score) {
+    const percentage = (score * 100).toFixed(1);
+    if (score >= 0.9) {
+        return chalk_1.default.green(`${percentage}%`);
+    }
+    if (score >= 0.7) {
+        return chalk_1.default.yellow(`${percentage}%`);
+    }
+    return chalk_1.default.red(`${percentage}%`);
+}
+function getSeverityColor(severity) {
+    switch (severity) {
+        case 'critical':
+            return chalk_1.default.red;
+        case 'high':
+            return chalk_1.default.yellow;
+        case 'medium':
+            return chalk_1.default.blue;
+        default:
+            return chalk_1.default.gray;
+    }
+}
+function displayProgressBar(score) {
+    const width = 30;
+    const filled = Math.round(score * width);
+    const empty = width - filled;
+    const bar = chalk_1.default.green('[' + '='.repeat(filled)) + chalk_1.default.gray('-'.repeat(empty) + ']');
+    console.log(`  ${bar}`);
+}
+function calculateAlignmentDebt(compliance, alignment, drift) {
+    // Calculate debt as weighted sum of issues
+    const complianceDebt = (1 - compliance.score) * 0.4;
+    const alignmentDebt = (1 - alignment.score) * 0.35;
+    const driftDebt = (1 - drift.score) * 0.25;
+    return complianceDebt + alignmentDebt + driftDebt;
+}
+function countCriticalIssues(compliance) {
+    return compliance.violations.filter(v => v.severity === 'critical').length;
+}
+function countHighPriorityItems(alignment) {
+    // Count issues that contain high-priority indicators
+    return alignment.issues.filter(issue => issue.toLowerCase().includes('critical') ||
+        issue.toLowerCase().includes('high')).length;
+}
+function extractAlignmentGaps(result) {
+    // Parse alignment gaps from issues
+    const gaps = [];
+    for (const issue of result.issues) {
+        const match = issue.match(/gap in (\w+): expected ([\d.]+), got ([\d.]+)/i);
+        if (match) {
+            const expected = parseFloat(match[2] ?? '0');
+            const actual = parseFloat(match[3] ?? '0');
+            gaps.push({
+                dimension: match[1] ?? 'unknown',
+                expected,
+                actual,
+                gap: expected - actual,
+                priority: expected - actual > 0.2
+                    ? 'high'
+                    : expected - actual > 0.1
+                        ? 'medium'
+                        : 'low',
+            });
+        }
+    }
+    return gaps;
+}
+function extractDriftAlerts(result) {
+    // Parse drift alerts from issues
+    const alerts = [];
+    for (const issue of result.issues) {
+        const match = issue.match(/Drift.*in (\w+): ([\d.]+)% (\w+)/i);
+        if (match) {
+            const changePercent = parseFloat(match[2] ?? '0');
+            alerts.push({
+                pattern: match[1] ?? 'unknown',
+                baselineValue: 0.9, // Default baseline
+                currentValue: 0.9 * (1 + changePercent / 100),
+                changePercent,
+                direction: match[3] ?? 'stable',
+                severity: changePercent >= 30
+                    ? 'critical'
+                    : changePercent >= 20
+                        ? 'high'
+                        : 'medium',
+            });
+        }
+    }
+    return alerts;
+}
+function generateRecommendations(compliance, alignment, drift) {
+    const recommendations = [];
+    // Add compliance recommendations
+    if (compliance.violations.length > 0) {
+        recommendations.push('Address policy violations immediately, especially critical ones');
+        const criticalCount = compliance.violations.filter(v => v.severity === 'critical').length;
+        if (criticalCount > 0) {
+            recommendations.push(`Fix ${criticalCount} critical policy violation(s) before deployment`);
+        }
+    }
+    // Add alignment recommendations from evaluator
+    recommendations.push(...alignment.recommendations);
+    // Add drift recommendations
+    if (drift.issues.length > 0) {
+        recommendations.push('Investigate drift causes and consider recalibration');
+    }
+    // General recommendations
+    if (compliance.score < 0.8) {
+        recommendations.push('Review and update security policies');
+    }
+    if (alignment.score < 0.85) {
+        recommendations.push('Schedule alignment review session');
+    }
+    return [...new Set(recommendations)]; // Remove duplicates
+}
+function formatReportAsMarkdown(report) {
+    let md = '# Alignment Debt Report\n\n';
+    md += `Generated: ${report.generatedAt}\n`;
+    if (report.sessionId) {
+        md += `Session: ${report.sessionId}\n`;
+    }
+    md += '\n---\n\n';
+    // Summary
+    md += '## Summary\n\n';
+    md += '| Metric | Value |\n';
+    md += '|--------|-------|\n';
+    md += `| Total Alignment Debt | ${report.summary.totalDebt.toFixed(2)} |\n`;
+    md += `| Critical Issues | ${report.summary.criticalIssues} |\n`;
+    md += `| High Priority Items | ${report.summary.highPriorityItems} |\n`;
+    md += `| Alignment Score | ${(report.summary.alignmentScore * 100).toFixed(1)}% |\n`;
+    md += `| Compliance Score | ${(report.summary.complianceScore * 100).toFixed(1)}% |\n`;
+    md += `| Drift Score | ${(report.summary.driftScore * 100).toFixed(1)}% |\n`;
+    md += '\n';
+    // Policy Violations
+    if (report.policyViolations.length > 0) {
+        md += '## Policy Violations\n\n';
+        for (const v of report.policyViolations) {
+            md += `### ${v.policyName} (${v.severity.toUpperCase()})\n\n`;
+            md += `- **Policy ID:** ${v.policyId}\n`;
+            md += `- **Description:** ${v.description}\n`;
+            if (v.location) {
+                md += `- **Location:** ${v.location}\n`;
+            }
+            if (v.suggestedFix) {
+                md += `- **Suggested Fix:** ${v.suggestedFix}\n`;
+            }
+            md += '\n';
+        }
+    }
+    // Alignment Gaps
+    if (report.alignmentGaps.length > 0) {
+        md += '## Alignment Gaps\n\n';
+        md += '| Dimension | Expected | Actual | Gap | Priority |\n';
+        md += '|-----------|----------|--------|-----|----------|\n';
+        for (const g of report.alignmentGaps) {
+            md += `| ${g.dimension} | ${(g.expected * 100).toFixed(1)}% | ${(g.actual * 100).toFixed(1)}% | ${(g.gap * 100).toFixed(1)}% | ${g.priority} |\n`;
+        }
+        md += '\n';
+    }
+    // Drift Alerts
+    if (report.driftAlerts.length > 0) {
+        md += '## Drift Alerts\n\n';
+        md += '| Pattern | Change | Direction | Severity |\n';
+        md += '|---------|--------|-----------|----------|\n';
+        for (const d of report.driftAlerts) {
+            md += `| ${d.pattern} | ${d.changePercent.toFixed(1)}% | ${d.direction} | ${d.severity} |\n`;
+        }
+        md += '\n';
+    }
+    // Recommendations
+    if (report.recommendations.length > 0) {
+        md += '## Recommendations\n\n';
+        for (const rec of report.recommendations) {
+            md += `- ${rec}\n`;
+        }
+        md += '\n';
+    }
+    return md;
+}
+function validateIPRESchema(config) {
+    const errors = [];
+    // Required fields
+    if (!config.version) {
+        errors.push('Missing required field: version');
+    }
+    if (!config.intent) {
+        errors.push('Missing required field: intent');
+    }
+    else {
+        if (!config.intent.mission) {
+            errors.push('Missing required field: intent.mission');
+        }
+        if (!config.intent.values || !Array.isArray(config.intent.values)) {
+            errors.push('Missing or invalid field: intent.values (must be array)');
+        }
+    }
+    if (!config.policies) {
+        errors.push('Missing required field: policies');
+    }
+    else {
+        if (!Array.isArray(config.policies.security)) {
+            errors.push('policies.security must be an array');
+        }
+        if (!Array.isArray(config.policies.compliance)) {
+            errors.push('policies.compliance must be an array');
+        }
+        if (!Array.isArray(config.policies.operational)) {
+            errors.push('policies.operational must be an array');
+        }
+    }
+    if (!config.rewards) {
+        errors.push('Missing required field: rewards');
+    }
+    else {
+        if (!config.rewards.weights) {
+            errors.push('Missing required field: rewards.weights');
+        }
+        if (typeof config.rewards.threshold !== 'number') {
+            errors.push('rewards.threshold must be a number');
+        }
+    }
+    if (!config.evaluators) {
+        errors.push('Missing required field: evaluators');
+    }
+    else if (!Array.isArray(config.evaluators)) {
+        errors.push('evaluators must be an array');
+    }
+    return errors;
+}
+function displayConfigSummary(config) {
+    console.log(chalk_1.default.blue('\n--- Configuration Summary ---'));
+    console.log(`Version: ${config.version}`);
+    console.log(`Mission: ${config.intent?.mission || 'Not defined'}`);
+    console.log(`Values: ${config.intent?.values?.length || 0} defined`);
+    console.log(`Security Policies: ${config.policies?.security?.length || 0}`);
+    console.log(`Compliance Policies: ${config.policies?.compliance?.length || 0}`);
+    console.log(`Operational Policies: ${config.policies?.operational?.length || 0}`);
+    console.log(`Evaluators: ${config.evaluators?.length || 0}`);
+    if (config.rewards?.threshold) {
+        console.log(`Reward Threshold: ${config.rewards.threshold}`);
+    }
+}
+// ============================================================================
+// State Management
+// ============================================================================
+const GOVERNANCE_STATE_PATH = '.wundr/governance-state.json';
+async function saveGovernanceState(sessionId, data) {
+    const statePath = path_1.default.join(process.cwd(), GOVERNANCE_STATE_PATH);
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(statePath));
+    const state = {
+        timestamp: new Date().toISOString(),
+        sessionId,
+        suiteResult: {
+            passed: data.suiteResult.passed,
+            overallScore: data.suiteResult.overallScore,
+            criticalIssues: [...data.suiteResult.criticalIssues],
+        },
+        complianceResult: data.complianceResult,
+        alignmentResult: data.alignmentResult,
+        driftResult: data.driftResult,
+    };
+    await fs_extra_1.default.writeJson(statePath, state, { spaces: 2 });
+}
+async function loadGovernanceState() {
+    const statePath = path_1.default.join(process.cwd(), GOVERNANCE_STATE_PATH);
+    if (await fs_extra_1.default.pathExists(statePath)) {
+        return await fs_extra_1.default.readJson(statePath);
+    }
+    return null;
+}
+async function loadRecentInterventions() {
+    // Load from state file or return empty array
+    // In a real implementation, this would load from a persistent store
+    return [];
+}
+function extractDriftIndicatorsFromState(state) {
+    if (!state?.driftResult) {
+        return [];
+    }
+    const driftResult = state.driftResult;
+    const indicators = [];
+    for (const issue of driftResult.issues || []) {
+        const match = issue.match(/Drift.*in (\w+): ([\d.]+)%/i);
+        if (match) {
+            indicators.push({
+                pattern: match[1] ?? 'unknown',
+                baseline: 0.9,
+                current: 0.9 * (1 + parseFloat(match[2] ?? '0') / 100),
+                change: parseFloat(match[2] ?? '0') / 100,
+                severity: 'medium',
+            });
+        }
+    }
+    return indicators;
+}
+//# sourceMappingURL=governance.js.map