claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/cli/simple-commands/verification.js

@@ -1,531 +1,551 @@
 /**
  * Verification and Truth Enforcement System
  * Implements mandatory verification for multi-agent operations
- */ import { exec } from "child_process";
-import { promisify } from "util";
-import fs from "node:fs/promises";
-import path from "path";
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+
 const execAsync = promisify(exec);
+
 // Verification modes
 const VERIFICATION_MODES = {
-    strict: {
-        threshold: 0.95,
-        autoRollback: true,
-        requireConsensus: true
-    },
-    moderate: {
-        threshold: 0.85,
-        autoRollback: false,
-        requireConsensus: true
-    },
-    development: {
-        threshold: 0.75,
-        autoRollback: false,
-        requireConsensus: false
-    }
+  strict: { threshold: 0.95, autoRollback: true, requireConsensus: true },
+  moderate: { threshold: 0.85, autoRollback: false, requireConsensus: true },
+  development: { threshold: 0.75, autoRollback: false, requireConsensus: false },
 };
+
 // Agent-specific verification requirements
 const AGENT_VERIFICATION = {
-    coder: [
-        'compile',
-        'test',
-        'lint',
-        'typecheck'
-    ],
-    reviewer: [
-        'code-analysis',
-        'security-scan',
-        'performance-check'
-    ],
-    tester: [
-        'unit-tests',
-        'integration-tests',
-        'coverage-check'
-    ],
-    planner: [
-        'task-decomposition',
-        'dependency-check',
-        'feasibility'
-    ],
-    architect: [
-        'design-validation',
-        'scalability-check',
-        'pattern-compliance'
-    ]
+  coder: ['compile', 'test', 'lint', 'typecheck'],
+  reviewer: ['code-analysis', 'security-scan', 'performance-check'],
+  tester: ['unit-tests', 'integration-tests', 'coverage-check'],
+  planner: ['task-decomposition', 'dependency-check', 'feasibility'],
+  architect: ['design-validation', 'scalability-check', 'pattern-compliance'],
 };
-let VerificationSystem = class VerificationSystem {
-    async initialize(mode = 'moderate') {
-        this.mode = mode;
-        await this.loadMemory();
-        console.log(`✅ Verification system initialized in ${mode} mode`);
-        console.log(`   Threshold: ${VERIFICATION_MODES[mode].threshold}`);
-        console.log(`   Auto-rollback: ${VERIFICATION_MODES[mode].autoRollback}`);
-        console.log(`   Consensus required: ${VERIFICATION_MODES[mode].requireConsensus}`);
+
+class VerificationSystem {
+  constructor() {
+    this.mode = 'moderate';
+    this.scores = new Map();
+    this.verificationHistory = [];
+    this.memoryPath = '.swarm/verification-memory.json';
+  }
+
+  async initialize(mode = 'moderate') {
+    this.mode = mode;
+    await this.loadMemory();
+    console.log(`✅ Verification system initialized in ${mode} mode`);
+    console.log(`   Threshold: ${VERIFICATION_MODES[mode].threshold}`);
+    console.log(`   Auto-rollback: ${VERIFICATION_MODES[mode].autoRollback}`);
+    console.log(`   Consensus required: ${VERIFICATION_MODES[mode].requireConsensus}`);
+  }
+
+  async loadMemory() {
+    try {
+      const data = await fs.readFile(this.memoryPath, 'utf8');
+      const memory = JSON.parse(data);
+      this.scores = new Map(memory.scores);
+      this.verificationHistory = memory.history || [];
+    } catch (error) {
+      // Initialize empty memory if file doesn't exist
+      this.scores = new Map();
+      this.verificationHistory = [];
     }
-    async loadMemory() {
-        try {
-            const data = await fs.readFile(this.memoryPath, 'utf8');
-            const memory = JSON.parse(data);
-            this.scores = new Map(memory.scores);
-            this.verificationHistory = memory.history || [];
-        } catch (error) {
-            // Initialize empty memory if file doesn't exist
-            this.scores = new Map();
-            this.verificationHistory = [];
-        }
+  }
+
+  async saveMemory() {
+    const memory = {
+      scores: Array.from(this.scores.entries()),
+      history: this.verificationHistory,
+      timestamp: new Date().toISOString(),
+    };
+
+    await fs.mkdir(path.dirname(this.memoryPath), { recursive: true });
+    await fs.writeFile(this.memoryPath, JSON.stringify(memory, null, 2));
+  }
+
+  async verifyTask(taskId, agentType, claims) {
+    console.log(`\n🔍 Verifying task ${taskId} (Agent: ${agentType})`);
+
+    const requirements = AGENT_VERIFICATION[agentType] || ['basic-check'];
+    const results = [];
+    let totalScore = 0;
+
+    for (const check of requirements) {
+      const result = await this.runVerification(check, claims);
+      results.push(result);
+      totalScore += result.score;
+
+      console.log(`   ${result.passed ? '✅' : '❌'} ${check}: ${result.score.toFixed(2)}`);
     }
-    async saveMemory() {
-        const memory = {
-            scores: Array.from(this.scores.entries()),
-            history: this.verificationHistory,
-            timestamp: new Date().toISOString()
-        };
-        await fs.mkdir(path.dirname(this.memoryPath), {
-            recursive: true
-        });
-        await fs.writeFile(this.memoryPath, JSON.stringify(memory, null, 2));
+
+    const averageScore = totalScore / requirements.length;
+    const threshold = VERIFICATION_MODES[this.mode].threshold;
+    const passed = averageScore >= threshold;
+
+    const verification = {
+      taskId,
+      agentType,
+      score: averageScore,
+      passed,
+      threshold,
+      timestamp: new Date().toISOString(),
+      results,
+    };
+
+    this.verificationHistory.push(verification);
+    await this.saveMemory();
+
+    console.log(`\n📊 Verification Score: ${averageScore.toFixed(2)}/${threshold}`);
+    console.log(`   Status: ${passed ? '✅ PASSED' : '❌ FAILED'}`);
+
+    if (!passed && VERIFICATION_MODES[this.mode].autoRollback) {
+      console.log('\n🔄 Auto-rollback triggered due to verification failure');
+      await this.triggerRollback(taskId);
     }
-    async verifyTask(taskId, agentType, claims) {
-        console.log(`\n🔍 Verifying task ${taskId} (Agent: ${agentType})`);
-        const requirements = AGENT_VERIFICATION[agentType] || [
-            'basic-check'
-        ];
-        const results = [];
-        let totalScore = 0;
-        for (const check of requirements){
-            const result = await this.runVerification(check, claims);
-            results.push(result);
-            totalScore += result.score;
-            console.log(`   ${result.passed ? '✅' : '❌'} ${check}: ${result.score.toFixed(2)}`);
+
+    return verification;
+  }
+
+  async runVerification(checkType, claims) {
+    // Simulate different verification checks
+    const verificationChecks = {
+      compile: async () => {
+        try {
+          const { stdout } = await execAsync('npm run typecheck 2>&1 || true');
+          return { score: stdout.includes('error') ? 0.5 : 1.0, passed: !stdout.includes('error') };
+        } catch {
+          return { score: 0.5, passed: false };
         }
-        const averageScore = totalScore / requirements.length;
-        const threshold = VERIFICATION_MODES[this.mode].threshold;
-        const passed = averageScore >= threshold;
-        const verification = {
-            taskId,
-            agentType,
-            score: averageScore,
-            passed,
-            threshold,
-            timestamp: new Date().toISOString(),
-            results
-        };
-        this.verificationHistory.push(verification);
-        await this.saveMemory();
-        console.log(`\n📊 Verification Score: ${averageScore.toFixed(2)}/${threshold}`);
-        console.log(`   Status: ${passed ? '✅ PASSED' : '❌ FAILED'}`);
-        if (!passed && VERIFICATION_MODES[this.mode].autoRollback) {
-            console.log('\n🔄 Auto-rollback triggered due to verification failure');
-            await this.triggerRollback(taskId);
+      },
+      test: async () => {
+        try {
+          const { stdout } = await execAsync('npm test 2>&1 || true');
+          return { score: stdout.includes('PASS') ? 1.0 : 0.6, passed: stdout.includes('PASS') };
+        } catch {
+          return { score: 0.6, passed: false };
         }
-        return verification;
-    }
-    async runVerification(checkType, claims) {
-        // Simulate different verification checks
-        const verificationChecks = {
-            compile: async ()=>{
-                try {
-                    const { stdout } = await execAsync('npm run typecheck 2>&1 || true');
-                    return {
-                        score: stdout.includes('error') ? 0.5 : 1.0,
-                        passed: !stdout.includes('error')
-                    };
-                } catch  {
-                    return {
-                        score: 0.5,
-                        passed: false
-                    };
-                }
-            },
-            test: async ()=>{
-                try {
-                    const { stdout } = await execAsync('npm test 2>&1 || true');
-                    return {
-                        score: stdout.includes('PASS') ? 1.0 : 0.6,
-                        passed: stdout.includes('PASS')
-                    };
-                } catch  {
-                    return {
-                        score: 0.6,
-                        passed: false
-                    };
-                }
-            },
-            lint: async ()=>{
-                try {
-                    const { stdout } = await execAsync('npm run lint 2>&1 || true');
-                    return {
-                        score: stdout.includes('warning') ? 0.8 : 1.0,
-                        passed: true
-                    };
-                } catch  {
-                    return {
-                        score: 0.7,
-                        passed: false
-                    };
-                }
-            },
-            typecheck: async ()=>{
-                try {
-                    const { stdout } = await execAsync('npm run typecheck 2>&1 || true');
-                    return {
-                        score: stdout.includes('error') ? 0.6 : 1.0,
-                        passed: !stdout.includes('error')
-                    };
-                } catch  {
-                    return {
-                        score: 0.6,
-                        passed: false
-                    };
-                }
-            },
-            default: async ()=>{
-                // Simulate verification based on claims
-                const claimScore = claims && claims.success ? 0.85 : 0.65;
-                return {
-                    score: claimScore,
-                    passed: claimScore >= 0.75
-                };
-            }
-        };
-        const check = verificationChecks[checkType] || verificationChecks.default;
-        return await check();
-    }
-    async triggerRollback(taskId) {
-        console.log(`🔄 Rolling back task ${taskId}...`);
-        // Simulate rollback process
-        await new Promise((resolve)=>setTimeout(resolve, 1000));
-        console.log(`✅ Rollback completed for task ${taskId}`);
-    }
-    async getAgentReliability(agentId) {
-        const agentHistory = this.verificationHistory.filter((v)=>v.agentType === agentId);
-        if (agentHistory.length === 0) return 1.0;
-        const totalScore = agentHistory.reduce((sum, v)=>sum + v.score, 0);
-        return totalScore / agentHistory.length;
-    }
-    async generateTruthReport() {
-        const report = {
-            mode: this.mode,
-            threshold: VERIFICATION_MODES[this.mode].threshold,
-            totalVerifications: this.verificationHistory.length,
-            passedVerifications: this.verificationHistory.filter((v)=>v.passed).length,
-            averageScore: 0,
-            agentReliability: {},
-            timestamp: new Date().toISOString()
-        };
-        if (this.verificationHistory.length > 0) {
-            const totalScore = this.verificationHistory.reduce((sum, v)=>sum + v.score, 0);
-            report.averageScore = totalScore / this.verificationHistory.length;
+      },
+      lint: async () => {
+        try {
+          const { stdout } = await execAsync('npm run lint 2>&1 || true');
+          return { score: stdout.includes('warning') ? 0.8 : 1.0, passed: true };
+        } catch {
+          return { score: 0.7, passed: false };
         }
-        // Calculate per-agent reliability
-        const agentTypes = [
-            ...new Set(this.verificationHistory.map((v)=>v.agentType))
-        ];
-        for (const agent of agentTypes){
-            report.agentReliability[agent] = await this.getAgentReliability(agent);
+      },
+      typecheck: async () => {
+        try {
+          const { stdout } = await execAsync('npm run typecheck 2>&1 || true');
+          return { score: stdout.includes('error') ? 0.6 : 1.0, passed: !stdout.includes('error') };
+        } catch {
+          return { score: 0.6, passed: false };
         }
-        return report;
-    }
-    constructor(){
-        this.mode = 'moderate';
-        this.scores = new Map();
-        this.verificationHistory = [];
-        this.memoryPath = '.swarm/verification-memory.json';
-    }
-};
-// Helper function to generate filtered report for specific agent
-async function generateFilteredReport(system, filteredHistory, agentType) {
+      },
+      default: async () => {
+        // Simulate verification based on claims
+        const claimScore = claims && claims.success ? 0.85 : 0.65;
+        return { score: claimScore, passed: claimScore >= 0.75 };
+      },
+    };
+
+    const check = verificationChecks[checkType] || verificationChecks.default;
+    return await check();
+  }
+
+  async triggerRollback(taskId) {
+    console.log(`🔄 Rolling back task ${taskId}...`);
+    // Simulate rollback process
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    console.log(`✅ Rollback completed for task ${taskId}`);
+  }
+
+  async getAgentReliability(agentId) {
+    const agentHistory = this.verificationHistory.filter((v) => v.agentType === agentId);
+    if (agentHistory.length === 0) return 1.0;
+
+    const totalScore = agentHistory.reduce((sum, v) => sum + v.score, 0);
+    return totalScore / agentHistory.length;
+  }
+
+  async generateTruthReport() {
     const report = {
-        mode: system.mode,
-        threshold: VERIFICATION_MODES[system.mode].threshold,
-        totalVerifications: filteredHistory.length,
-        passedVerifications: filteredHistory.filter((v)=>v.passed).length,
-        averageScore: 0,
-        agentReliability: {},
-        timestamp: new Date().toISOString()
+      mode: this.mode,
+      threshold: VERIFICATION_MODES[this.mode].threshold,
+      totalVerifications: this.verificationHistory.length,
+      passedVerifications: this.verificationHistory.filter((v) => v.passed).length,
+      averageScore: 0,
+      agentReliability: {},
+      timestamp: new Date().toISOString(),
     };
-    if (filteredHistory.length > 0) {
-        const totalScore = filteredHistory.reduce((sum, v)=>sum + v.score, 0);
-        report.averageScore = totalScore / filteredHistory.length;
-        report.agentReliability[agentType] = report.averageScore;
+
+    if (this.verificationHistory.length > 0) {
+      const totalScore = this.verificationHistory.reduce((sum, v) => sum + v.score, 0);
+      report.averageScore = totalScore / this.verificationHistory.length;
+    }
+
+    // Calculate per-agent reliability
+    const agentTypes = [...new Set(this.verificationHistory.map((v) => v.agentType))];
+    for (const agent of agentTypes) {
+      report.agentReliability[agent] = await this.getAgentReliability(agent);
     }
+
     return report;
+  }
 }
+
+// Helper function to generate filtered report for specific agent
+async function generateFilteredReport(system, filteredHistory, agentType) {
+  const report = {
+    mode: system.mode,
+    threshold: VERIFICATION_MODES[system.mode].threshold,
+    totalVerifications: filteredHistory.length,
+    passedVerifications: filteredHistory.filter((v) => v.passed).length,
+    averageScore: 0,
+    agentReliability: {},
+    timestamp: new Date().toISOString(),
+  };
+
+  if (filteredHistory.length > 0) {
+    const totalScore = filteredHistory.reduce((sum, v) => sum + v.score, 0);
+    report.averageScore = totalScore / filteredHistory.length;
+    report.agentReliability[agentType] = report.averageScore;
+  }
+
+  return report;
+}
+
 // CLI command handlers
 export async function verificationCommand(args, flags) {
-    const system = new VerificationSystem();
-    const subcommand = args[0] || 'status';
-    // Handle help flag
-    if (flags.help || subcommand === '--help' || subcommand === 'help') {
-        const { COMMAND_HELP } = await import("../help-text.js");
-        console.log(COMMAND_HELP.verify);
+  const system = new VerificationSystem();
+  const subcommand = args[0] || 'status';
+
+  // Handle help flag
+  if (flags.help || subcommand === '--help' || subcommand === 'help') {
+    const { COMMAND_HELP } = await import('../help-text.js');
+    console.log(COMMAND_HELP.verify);
+    return;
+  }
+
+  switch (subcommand) {
+    case 'init':
+      const mode = args[1] || flags.mode || 'moderate';
+      await system.initialize(mode);
+      break;
+
+    case 'verify':
+      const taskId = args[1] || flags.taskId || `task-${Date.now()}`;
+      const agentType = flags.agent || 'coder';
+      const claims = { success: flags.success !== false };
+      await system.verifyTask(taskId, agentType, claims);
+      break;
+
+    case 'truth':
+    case 'score':
+      await system.loadMemory();
+
+      // Filter by agent if specified
+      let filteredHistory = system.verificationHistory;
+      if (flags.agent) {
+        filteredHistory = system.verificationHistory.filter((v) => v.agentType === flags.agent);
+        if (filteredHistory.length === 0) {
+          console.log(`\n⚠️ No verification history found for agent: ${flags.agent}`);
+          return;
+        }
+      }
+
+      // Filter by taskId if specified
+      if (flags.taskId) {
+        filteredHistory = filteredHistory.filter((v) => v.taskId === flags.taskId);
+        if (filteredHistory.length === 0) {
+          console.log(`\n⚠️ No verification history found for task: ${flags.taskId}`);
+          return;
+        }
+      }
+
+      // Filter by threshold if specified
+      if (flags.threshold) {
+        const threshold = parseFloat(flags.threshold);
+        filteredHistory = filteredHistory.filter((v) => v.score < threshold);
+        if (filteredHistory.length === 0) {
+          console.log(`\n✅ All verifications meet or exceed threshold: ${threshold}`);
+          return;
+        }
+      }
+
+      // Generate report (with filtered data if agent specified)
+      const report = flags.agent
+        ? await generateFilteredReport(system, filteredHistory, flags.agent)
+        : await system.generateTruthReport();
+
+      // JSON output only mode
+      if (flags.json) {
+        console.log(JSON.stringify(report, null, 2));
         return;
-    }
-    switch(subcommand){
-        case 'init':
-            const mode = args[1] || flags.mode || 'moderate';
-            await system.initialize(mode);
-            break;
-        case 'verify':
-            const taskId = args[1] || flags.taskId || `task-${Date.now()}`;
-            const agentType = flags.agent || 'coder';
-            const claims = {
-                success: flags.success !== false
-            };
-            await system.verifyTask(taskId, agentType, claims);
-            break;
-        case 'truth':
-        case 'score':
-            await system.loadMemory();
-            // Filter by agent if specified
-            let filteredHistory = system.verificationHistory;
-            if (flags.agent) {
-                filteredHistory = system.verificationHistory.filter((v)=>v.agentType === flags.agent);
-                if (filteredHistory.length === 0) {
-                    console.log(`\n⚠️ No verification history found for agent: ${flags.agent}`);
-                    return;
-                }
-            }
-            // Filter by taskId if specified
-            if (flags.taskId) {
-                filteredHistory = filteredHistory.filter((v)=>v.taskId === flags.taskId);
-                if (filteredHistory.length === 0) {
-                    console.log(`\n⚠️ No verification history found for task: ${flags.taskId}`);
-                    return;
-                }
-            }
-            // Filter by threshold if specified
-            if (flags.threshold) {
-                const threshold = parseFloat(flags.threshold);
-                filteredHistory = filteredHistory.filter((v)=>v.score < threshold);
-                if (filteredHistory.length === 0) {
-                    console.log(`\n✅ All verifications meet or exceed threshold: ${threshold}`);
-                    return;
-                }
+      }
+
+      // Basic report (shown when not in JSON mode)
+      console.log('\n📊 Truth Scoring Report' + (flags.agent ? ` - Agent: ${flags.agent}` : ''));
+      console.log('━'.repeat(50));
+      console.log(`Mode: ${report.mode || system.mode}`);
+      console.log(`Threshold: ${report.threshold || VERIFICATION_MODES[system.mode].threshold}`);
+      console.log(`Total Verifications: ${report.totalVerifications}`);
+      console.log(`Passed: ${report.passedVerifications}`);
+      console.log(`Average Score: ${report.averageScore.toFixed(3)}`);
+
+      if (flags.agent) {
+        // Show detailed info for specific agent
+        console.log(`\n🤖 ${flags.agent} Agent Details:`);
+        console.log(`   Reliability: ${(report.agentReliability[flags.agent] * 100).toFixed(1)}%`);
+        console.log(`   Total Tasks: ${filteredHistory.length}`);
+        console.log(`   Passed: ${filteredHistory.filter((v) => v.passed).length}`);
+        console.log(`   Failed: ${filteredHistory.filter((v) => !v.passed).length}`);
+
+        if (flags.detailed || flags.detail) {
+          console.log('\n📋 Verification History:');
+          const recentAgent = filteredHistory.slice(-10);
+          for (const v of recentAgent) {
+            const time = new Date(v.timestamp).toLocaleTimeString();
+            console.log(
+              `   ${v.passed ? '✅' : '❌'} [${time}] ${v.taskId}: ${v.score.toFixed(3)}`,
+            );
+            if (v.results && flags.verbose) {
+              for (const [check, result] of Object.entries(v.results)) {
+                console.log(
+                  `      • ${check}: ${result.passed ? '✓' : '✗'} (${result.score.toFixed(2)})`,
+                );
+              }
             }
-            // Generate report (with filtered data if agent specified)
-            const report = flags.agent ? await generateFilteredReport(system, filteredHistory, flags.agent) : await system.generateTruthReport();
-            // JSON output only mode
-            if (flags.json) {
-                console.log(JSON.stringify(report, null, 2));
-                return;
-            }
-            // Basic report (shown when not in JSON mode)
-            console.log('\n📊 Truth Scoring Report' + (flags.agent ? ` - Agent: ${flags.agent}` : ''));
-            console.log('━'.repeat(50));
-            console.log(`Mode: ${report.mode || system.mode}`);
-            console.log(`Threshold: ${report.threshold || VERIFICATION_MODES[system.mode].threshold}`);
-            console.log(`Total Verifications: ${report.totalVerifications}`);
-            console.log(`Passed: ${report.passedVerifications}`);
-            console.log(`Average Score: ${report.averageScore.toFixed(3)}`);
-            if (flags.agent) {
-                // Show detailed info for specific agent
-                console.log(`\n🤖 ${flags.agent} Agent Details:`);
-                console.log(`   Reliability: ${(report.agentReliability[flags.agent] * 100).toFixed(1)}%`);
-                console.log(`   Total Tasks: ${filteredHistory.length}`);
-                console.log(`   Passed: ${filteredHistory.filter((v)=>v.passed).length}`);
-                console.log(`   Failed: ${filteredHistory.filter((v)=>!v.passed).length}`);
-                if (flags.detailed || flags.detail) {
-                    console.log('\n📋 Verification History:');
-                    const recentAgent = filteredHistory.slice(-10);
-                    for (const v of recentAgent){
-                        const time = new Date(v.timestamp).toLocaleTimeString();
-                        console.log(`   ${v.passed ? '✅' : '❌'} [${time}] ${v.taskId}: ${v.score.toFixed(3)}`);
-                        if (v.results && flags.verbose) {
-                            for (const [check, result] of Object.entries(v.results)){
-                                console.log(`      • ${check}: ${result.passed ? '✓' : '✗'} (${result.score.toFixed(2)})`);
-                            }
-                        }
-                    }
-                    // Score distribution
-                    const scores = filteredHistory.map((v)=>v.score);
-                    const minScore = Math.min(...scores);
-                    const maxScore = Math.max(...scores);
-                    console.log('\n📊 Score Distribution:');
-                    console.log(`   Min Score: ${minScore.toFixed(3)}`);
-                    console.log(`   Max Score: ${maxScore.toFixed(3)}`);
-                    console.log(`   Average: ${report.averageScore.toFixed(3)}`);
-                    // Performance trend
-                    if (filteredHistory.length > 5) {
-                        const recent5 = filteredHistory.slice(-5);
-                        const older5 = filteredHistory.slice(-10, -5);
-                        const recentAvg = recent5.reduce((sum, v)=>sum + v.score, 0) / recent5.length;
-                        const olderAvg = older5.length > 0 ? older5.reduce((sum, v)=>sum + v.score, 0) / older5.length : 0;
-                        console.log('\n📈 Performance Trend:');
-                        if (olderAvg > 0) {
-                            const trend = recentAvg - olderAvg;
-                            const trendSymbol = trend > 0 ? '↑' : trend < 0 ? '↓' : '→';
-                            console.log(`   Recent Average: ${recentAvg.toFixed(3)} ${trendSymbol}`);
-                            console.log(`   Previous Average: ${olderAvg.toFixed(3)}`);
-                            console.log(`   Change: ${trend >= 0 ? '+' : ''}${(trend * 100).toFixed(1)}%`);
-                        } else {
-                            console.log(`   Recent Average: ${recentAvg.toFixed(3)}`);
-                        }
-                    }
-                }
+          }
+
+          // Score distribution
+          const scores = filteredHistory.map((v) => v.score);
+          const minScore = Math.min(...scores);
+          const maxScore = Math.max(...scores);
+          console.log('\n📊 Score Distribution:');
+          console.log(`   Min Score: ${minScore.toFixed(3)}`);
+          console.log(`   Max Score: ${maxScore.toFixed(3)}`);
+          console.log(`   Average: ${report.averageScore.toFixed(3)}`);
+
+          // Performance trend
+          if (filteredHistory.length > 5) {
+            const recent5 = filteredHistory.slice(-5);
+            const older5 = filteredHistory.slice(-10, -5);
+            const recentAvg = recent5.reduce((sum, v) => sum + v.score, 0) / recent5.length;
+            const olderAvg =
+              older5.length > 0 ? older5.reduce((sum, v) => sum + v.score, 0) / older5.length : 0;
+
+            console.log('\n📈 Performance Trend:');
+            if (olderAvg > 0) {
+              const trend = recentAvg - olderAvg;
+              const trendSymbol = trend > 0 ? '↑' : trend < 0 ? '↓' : '→';
+              console.log(`   Recent Average: ${recentAvg.toFixed(3)} ${trendSymbol}`);
+              console.log(`   Previous Average: ${olderAvg.toFixed(3)}`);
+              console.log(`   Change: ${trend >= 0 ? '+' : ''}${(trend * 100).toFixed(1)}%`);
             } else {
-                console.log('\n🤖 Agent Reliability:');
-                for (const [agent, reliability] of Object.entries(report.agentReliability)){
-                    console.log(`   ${agent}: ${(reliability * 100).toFixed(1)}%`);
-                }
-            }
-            // Detailed report with --report flag
-            if (flags.report) {
-                console.log('\n📈 Detailed Verification Breakdown:');
-                console.log(`   Pass Rate: ${(report.passedVerifications / report.totalVerifications * 100).toFixed(1)}%`);
-                console.log(`   Failure Rate: ${((report.totalVerifications - report.passedVerifications) / report.totalVerifications * 100).toFixed(1)}%`);
-                // Show recent history
-                if (system.verificationHistory.length > 0) {
-                    console.log('\n📜 Last 10 Verifications:');
-                    const recent = system.verificationHistory.slice(-10);
-                    for (const v of recent){
-                        const time = new Date(v.timestamp).toLocaleTimeString();
-                        console.log(`   ${v.passed ? '✅' : '❌'} [${time}] ${v.taskId} (${v.agentType}): ${v.score.toFixed(3)}`);
-                    }
-                }
-                // Performance metrics
-                console.log('\n🎯 Target Metrics Comparison:');
-                console.log(`   Truth Accuracy: ${report.averageScore >= 0.95 ? '✅' : '❌'} ${(report.averageScore * 100).toFixed(1)}% (target: 95%)`);
-                console.log(`   Pass Rate: ${report.passedVerifications / report.totalVerifications >= 0.9 ? '✅' : '❌'} ${(report.passedVerifications / report.totalVerifications * 100).toFixed(1)}% (target: 90%)`);
-            }
-            // Failure analysis with --analyze flag
-            if (flags.analyze) {
-                console.log('\n🔍 Failure Pattern Analysis:');
-                // Analyze failures by agent
-                const failures = system.verificationHistory.filter((v)=>!v.passed);
-                if (failures.length > 0) {
-                    const failuresByAgent = {};
-                    for (const f of failures){
-                        failuresByAgent[f.agentType] = (failuresByAgent[f.agentType] || 0) + 1;
-                    }
-                    console.log('   Failures by Agent:');
-                    for (const [agent, count] of Object.entries(failuresByAgent)){
-                        const percentage = (count / failures.length * 100).toFixed(1);
-                        console.log(`   • ${agent}: ${count} failures (${percentage}%)`);
-                    }
-                    // Common failure scores
-                    const failureScores = failures.map((f)=>f.score);
-                    const avgFailureScore = failureScores.reduce((a, b)=>a + b, 0) / failureScores.length;
-                    console.log(`\n   Average Failure Score: ${avgFailureScore.toFixed(3)}`);
-                    console.log(`   Score Gap to Threshold: ${(report.threshold - avgFailureScore).toFixed(3)}`);
-                    // Recommendations
-                    console.log('\n💡 Recommendations:');
-                    if (avgFailureScore < 0.5) {
-                        console.log('   • Critical: Major quality issues detected');
-                        console.log('   • Consider switching to development mode for debugging');
-                        console.log('   • Review agent configurations and requirements');
-                    } else if (avgFailureScore < report.threshold) {
-                        console.log('   • Moderate: Close to threshold but needs improvement');
-                        console.log('   • Focus on failing agents: ' + Object.keys(failuresByAgent).join(', '));
-                        console.log('   • Consider adjusting verification requirements');
-                    }
-                } else {
-                    console.log('   ✅ No failures detected!');
-                }
-            }
-            // Export to file with --export flag
-            if (flags.export) {
-                const exportPath = typeof flags.export === 'string' ? flags.export : `truth-report-${Date.now()}.json`;
-                const exportData = {
-                    report,
-                    filteredHistory,
-                    metadata: {
-                        exported: new Date().toISOString(),
-                        filters: {
-                            agent: flags.agent || null,
-                            taskId: flags.taskId || null,
-                            threshold: flags.threshold || null
-                        },
-                        command: 'truth',
-                        version: '2.0.0-alpha.89'
-                    }
-                };
-                try {
-                    await fs.writeFile(exportPath, JSON.stringify(exportData, null, 2));
-                    console.log(`\n📁 Report exported to: ${exportPath}`);
-                } catch (error) {
-                    console.error(`\n❌ Failed to export report: ${error.message}`);
-                }
+              console.log(`   Recent Average: ${recentAvg.toFixed(3)}`);
             }
-            break;
-        case 'status':
-        default:
-            await system.loadMemory();
-            console.log('\n🔍 Verification System Status');
-            console.log('━'.repeat(50));
-            console.log(`Mode: ${system.mode}`);
-            console.log(`Verifications: ${system.verificationHistory.length}`);
-            console.log(`Recent: ${system.verificationHistory.slice(-5).length} verifications`);
-            if (system.verificationHistory.length > 0) {
-                const recent = system.verificationHistory.slice(-5);
-                console.log('\n📜 Recent Verifications:');
-                for (const v of recent){
-                    console.log(`   ${v.passed ? '✅' : '❌'} ${v.taskId} (${v.agentType}): ${v.score.toFixed(2)}`);
-                }
-            }
-            console.log('\n💡 Commands:');
-            console.log('   verify init [mode]     - Initialize system');
-            console.log('   verify verify [taskId] - Verify a task');
-            console.log('   verify truth          - Show truth scores');
-            console.log('   verify status         - Show system status');
-            break;
-    }
+          }
+        }
+      } else {
+        console.log('\n🤖 Agent Reliability:');
+        for (const [agent, reliability] of Object.entries(report.agentReliability)) {
+          console.log(`   ${agent}: ${(reliability * 100).toFixed(1)}%`);
+        }
+      }
+
+      // Detailed report with --report flag
+      if (flags.report) {
+        console.log('\n📈 Detailed Verification Breakdown:');
+        console.log(
+          `   Pass Rate: ${((report.passedVerifications / report.totalVerifications) * 100).toFixed(1)}%`,
+        );
+        console.log(
+          `   Failure Rate: ${(((report.totalVerifications - report.passedVerifications) / report.totalVerifications) * 100).toFixed(1)}%`,
+        );
+
+        // Show recent history
+        if (system.verificationHistory.length > 0) {
+          console.log('\n📜 Last 10 Verifications:');
+          const recent = system.verificationHistory.slice(-10);
+          for (const v of recent) {
+            const time = new Date(v.timestamp).toLocaleTimeString();
+            console.log(
+              `   ${v.passed ? '✅' : '❌'} [${time}] ${v.taskId} (${v.agentType}): ${v.score.toFixed(3)}`,
+            );
+          }
+        }
+
+        // Performance metrics
+        console.log('\n🎯 Target Metrics Comparison:');
+        console.log(
+          `   Truth Accuracy: ${report.averageScore >= 0.95 ? '✅' : '❌'} ${(report.averageScore * 100).toFixed(1)}% (target: 95%)`,
+        );
+        console.log(
+          `   Pass Rate: ${report.passedVerifications / report.totalVerifications >= 0.9 ? '✅' : '❌'} ${((report.passedVerifications / report.totalVerifications) * 100).toFixed(1)}% (target: 90%)`,
+        );
+      }
+
+      // Failure analysis with --analyze flag
+      if (flags.analyze) {
+        console.log('\n🔍 Failure Pattern Analysis:');
+
+        // Analyze failures by agent
+        const failures = system.verificationHistory.filter((v) => !v.passed);
+        if (failures.length > 0) {
+          const failuresByAgent = {};
+          for (const f of failures) {
+            failuresByAgent[f.agentType] = (failuresByAgent[f.agentType] || 0) + 1;
+          }
+
+          console.log('   Failures by Agent:');
+          for (const [agent, count] of Object.entries(failuresByAgent)) {
+            const percentage = ((count / failures.length) * 100).toFixed(1);
+            console.log(`   • ${agent}: ${count} failures (${percentage}%)`);
+          }
+
+          // Common failure scores
+          const failureScores = failures.map((f) => f.score);
+          const avgFailureScore = failureScores.reduce((a, b) => a + b, 0) / failureScores.length;
+          console.log(`\n   Average Failure Score: ${avgFailureScore.toFixed(3)}`);
+          console.log(
+            `   Score Gap to Threshold: ${(report.threshold - avgFailureScore).toFixed(3)}`,
+          );
+
+          // Recommendations
+          console.log('\n💡 Recommendations:');
+          if (avgFailureScore < 0.5) {
+            console.log('   • Critical: Major quality issues detected');
+            console.log('   • Consider switching to development mode for debugging');
+            console.log('   • Review agent configurations and requirements');
+          } else if (avgFailureScore < report.threshold) {
+            console.log('   • Moderate: Close to threshold but needs improvement');
+            console.log('   • Focus on failing agents: ' + Object.keys(failuresByAgent).join(', '));
+            console.log('   • Consider adjusting verification requirements');
+          }
+        } else {
+          console.log('   ✅ No failures detected!');
+        }
+      }
+
+      // Export to file with --export flag
+      if (flags.export) {
+        const exportPath =
+          typeof flags.export === 'string' ? flags.export : `truth-report-${Date.now()}.json`;
+        const exportData = {
+          report,
+          filteredHistory,
+          metadata: {
+            exported: new Date().toISOString(),
+            filters: {
+              agent: flags.agent || null,
+              taskId: flags.taskId || null,
+              threshold: flags.threshold || null,
+            },
+            command: 'truth',
+            version: '2.0.0-alpha.89',
+          },
+        };
+
+        try {
+          await fs.writeFile(exportPath, JSON.stringify(exportData, null, 2));
+          console.log(`\n📁 Report exported to: ${exportPath}`);
+        } catch (error) {
+          console.error(`\n❌ Failed to export report: ${error.message}`);
+        }
+      }
+      break;
+
+    case 'status':
+    default:
+      await system.loadMemory();
+      console.log('\n🔍 Verification System Status');
+      console.log('━'.repeat(50));
+      console.log(`Mode: ${system.mode}`);
+      console.log(`Verifications: ${system.verificationHistory.length}`);
+      console.log(`Recent: ${system.verificationHistory.slice(-5).length} verifications`);
+
+      if (system.verificationHistory.length > 0) {
+        const recent = system.verificationHistory.slice(-5);
+        console.log('\n📜 Recent Verifications:');
+        for (const v of recent) {
+          console.log(
+            `   ${v.passed ? '✅' : '❌'} ${v.taskId} (${v.agentType}): ${v.score.toFixed(2)}`,
+          );
+        }
+      }
+
+      console.log('\n💡 Commands:');
+      console.log('   verify init [mode]     - Initialize system');
+      console.log('   verify verify [taskId] - Verify a task');
+      console.log('   verify truth          - Show truth scores');
+      console.log('   verify status         - Show system status');
+      break;
+  }
 }
+
 // Truth command shortcut
 export async function truthCommand(args, flags) {
-    // Handle help flag
-    if (flags.help || args[0] === '--help' || args[0] === 'help') {
-        const { COMMAND_HELP } = await import("../help-text.js");
-        console.log(COMMAND_HELP.truth);
-        return;
-    }
-    return verificationCommand([
-        'truth',
-        ...args
-    ], flags);
+  // Handle help flag
+  if (flags.help || args[0] === '--help' || args[0] === 'help') {
+    const { COMMAND_HELP } = await import('../help-text.js');
+    console.log(COMMAND_HELP.truth);
+    return;
+  }
+  return verificationCommand(['truth', ...args], flags);
 }
+
 // Pair programming command
 export async function pairCommand(args, flags) {
-    // Handle help flag
-    if (flags.help || args[0] === '--help' || args[0] === 'help') {
-        const { COMMAND_HELP } = await import("../help-text.js");
-        console.log(COMMAND_HELP.pair);
-        return;
-    }
-    console.log('\n👥 Pair Programming with Verification');
-    console.log('━'.repeat(50));
-    const system = new VerificationSystem();
-    await system.initialize('strict');
-    console.log('\n🎯 Verification-First Development Mode Activated');
-    console.log('   • All changes require verification');
-    console.log('   • Truth threshold: 0.95');
-    console.log('   • Real-time validation enabled');
-    console.log('   • Auto-rollback on failures');
-    if (flags.start) {
-        console.log('\n🚀 Starting pair programming session...');
-        console.log('   Monitoring file changes...');
-        console.log('   Running continuous verification...');
-        // Simulate monitoring
-        let iteration = 0;
-        const interval = setInterval(async ()=>{
-            iteration++;
-            console.log(`\n[${new Date().toISOString()}] Verification cycle ${iteration}`);
-            const taskId = `pair-${Date.now()}`;
-            const result = await system.verifyTask(taskId, 'coder', {
-                success: Math.random() > 0.3
-            });
-            if (iteration >= 3 || !result.passed) {
-                clearInterval(interval);
-                console.log('\n✨ Pair programming session complete');
-            }
-        }, 3000);
-    } else {
-        console.log('\n💡 Use --start to begin a pair programming session');
-    }
+  // Handle help flag
+  if (flags.help || args[0] === '--help' || args[0] === 'help') {
+    const { COMMAND_HELP } = await import('../help-text.js');
+    console.log(COMMAND_HELP.pair);
+    return;
+  }
+  console.log('\n👥 Pair Programming with Verification');
+  console.log('━'.repeat(50));
+
+  const system = new VerificationSystem();
+  await system.initialize('strict');
+
+  console.log('\n🎯 Verification-First Development Mode Activated');
+  console.log('   • All changes require verification');
+  console.log('   • Truth threshold: 0.95');
+  console.log('   • Real-time validation enabled');
+  console.log('   • Auto-rollback on failures');
+
+  if (flags.start) {
+    console.log('\n🚀 Starting pair programming session...');
+    console.log('   Monitoring file changes...');
+    console.log('   Running continuous verification...');
+
+    // Simulate monitoring
+    let iteration = 0;
+    const interval = setInterval(async () => {
+      iteration++;
+      console.log(`\n[${new Date().toISOString()}] Verification cycle ${iteration}`);
+
+      const taskId = `pair-${Date.now()}`;
+      const result = await system.verifyTask(taskId, 'coder', { success: Math.random() > 0.3 });
+
+      if (iteration >= 3 || !result.passed) {
+        clearInterval(interval);
+        console.log('\n✨ Pair programming session complete');
+      }
+    }, 3000);
+  } else {
+    console.log('\n💡 Use --start to begin a pair programming session');
+  }
 }
+
 // Export for use in command registry
 export default {
-    verificationCommand,
-    truthCommand,
-    pairCommand
+  verificationCommand,
+  truthCommand,
+  pairCommand,
 };