@cpretzinger/boss-claude 1.0.0 → 1.0.2

package/bin/boss-claude.js

@@ -6,6 +6,54 @@ import { loadIdentity, updateIdentity } from '../lib/identity.js';
 import { loadSession, saveSession } from '../lib/session.js';
 import { searchMemory, saveMemory } from '../lib/memory.js';
 import { getStatus } from '../lib/init.js';
+import { importCredentials, validateCredentials, listSources } from '../lib/setup/import-credentials.js';
+import {
+  getRedisStats,
+  resetRedis,
+  verifyRedis,
+  initializeRedis,
+  printInitResults
+} from '../lib/setup/init-redis.js';
+import { runIntegrationTests } from '../lib/setup/integration-test.js';
+import { validateConfig, printReport } from '../lib/validators/config.js';
+import { LOG_FILE } from '../lib/agent-logger.js';
+import { formatLogDetails } from '../lib/output-formatter.js';
+import hierarchyValidator from '../lib/hierarchy-validator.js';
+import { AGENT_HIERARCHY } from '../lib/agents/registry.js';
+import onyxReminder from '../lib/onyx-reminder.js';
+import {
+  trackDelegation,
+  trackDirectAction,
+  getDelegationStats,
+  getRecentEvents,
+  setAlertThreshold,
+  getAlertThreshold,
+  resetTracking,
+  generateReport,
+  getFormattedStatus,
+  ALERT_LOG
+} from '../lib/onyx-monitor.js';
+import {
+  getCheckpointStatus,
+  recordCheckpoint,
+  getCheckpointHistory,
+  getDelegationEfficiency,
+  resetCheckpoint,
+  exportCheckpointData,
+  formatCheckpointPrompt
+} from '../lib/checkpoint.js';
+import { modeCommand } from './commands/mode.js';
+import { spawn } from 'child_process';
+import dotenv from 'dotenv';
+import { join } from 'path';
+import os from 'os';
+import { existsSync } from 'fs';
+
+// Load environment variables
+const envPath = join(os.homedir(), '.boss-claude', '.env');
+if (existsSync(envPath)) {
+  dotenv.config({ path: envPath });
+}
 
 const program = new Command();
 
@@ -14,6 +62,39 @@ program
   .description('Boss Claude - Gamified AI assistant with persistent memory')
   .version('1.0.0');
 
+program
+  .command('setup')
+  .description('Auto-detect and import credentials')
+  .option('-l, --list', 'List all credential sources without importing')
+  .option('-v, --validate', 'Validate existing credentials')
+  .action(async (options) => {
+    try {
+      if (options.list) {
+        // List all sources
+        await listSources();
+      } else if (options.validate) {
+        // Validate existing credentials
+        console.log(chalk.blue('\n🔐 Validating credentials...\n'));
+        const result = await validateCredentials();
+
+        if (result.valid) {
+          console.log(chalk.green('✅ All credentials are valid!\n'));
+        } else {
+          console.log(chalk.red('❌ Credential validation failed:\n'));
+          result.errors.forEach(error => console.log(chalk.red(`  • ${error}`)));
+          console.log();
+          process.exit(1);
+        }
+      } else {
+        // Import credentials
+        await importCredentials();
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ Setup failed:'), error.message);
+      process.exit(1);
+    }
+  });
+
 program
   .command('init')
   .description('Initialize Boss Claude in current repository')
@@ -110,6 +191,18 @@ program
       console.log(`  XP Earned: ${chalk.cyan('+' + session.xp_earned)}`);
       console.log(`  Tokens Banked: ${chalk.magenta('+' + session.tokens_earned.toLocaleString())}\n`);
 
+      // Show efficiency breakdown if available
+      if (session.efficiency) {
+        const eff = session.efficiency;
+        console.log(chalk.bold('⚡ Efficiency Breakdown:'));
+        console.log(`  🎺 ONYX Tokens: ${chalk.dim(eff.onyx_tokens.toLocaleString())}`);
+        console.log(`  🎻 Agent Tokens: ${chalk.green(eff.agent_tokens.toLocaleString())}`);
+        console.log(`  📈 Efficiency Ratio: ${chalk.yellow(eff.ratio)}`);
+        console.log(`  🎯 Delegations: ${chalk.blue(eff.delegations)}`);
+        console.log(chalk.bold('  💎 Bonus XP: ') + chalk.cyan(`+${eff.efficiency_bonus}`) + chalk.dim(' (efficiency) ') +
+                    chalk.cyan(`+${eff.delegation_bonus}`) + chalk.dim(' (delegation)\n'));
+      }
+
     } catch (error) {
       console.error(chalk.red('❌ Error saving session:'), error.message);
       process.exit(1);
@@ -147,4 +240,1049 @@ program
     }
   });
 
+program
+  .command('test')
+  .description('Run integration tests to verify system health')
+  .action(async () => {
+    try {
+      await runIntegrationTests();
+    } catch (error) {
+      console.error(chalk.red('❌ Integration tests failed:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('validate')
+  .description('Validate ~/.boss-claude/.env configuration')
+  .option('--skip-optional', 'Skip validation of optional variables')
+  .action(async (options) => {
+    try {
+      const report = await validateConfig({
+        includeOptional: !options.skipOptional
+      });
+
+      printReport(report);
+
+      if (!report.valid) {
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ Validation failed:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Redis management commands
+program
+  .command('redis:stats')
+  .description('Show Redis statistics and key counts')
+  .action(async () => {
+    try {
+      if (!process.env.REDIS_URL) {
+        console.error(chalk.red('❌ REDIS_URL not configured. Run: boss-claude setup\n'));
+        process.exit(1);
+      }
+
+      console.log(chalk.blue('\n📊 Redis Statistics\n'));
+
+      const stats = await getRedisStats(process.env.REDIS_URL);
+
+      if (stats.identity) {
+        console.log(chalk.bold('Boss Identity:'));
+        console.log(`  Level: ${chalk.yellow(stats.identity.level)}`);
+        console.log(`  XP: ${chalk.cyan(stats.identity.xp)}`);
+        console.log(`  Token Bank: ${chalk.magenta(stats.identity.token_bank.toLocaleString())}`);
+        console.log(`  Total Sessions: ${chalk.blue(stats.identity.total_sessions)}`);
+        console.log(`  Repos Managed: ${chalk.green(stats.identity.repos_managed)}\n`);
+      }
+
+      console.log(chalk.bold('Data Structures:'));
+      console.log(`  Session History: ${chalk.cyan(stats.totalSessions)} sessions`);
+      console.log(`  Tracked Repos: ${chalk.green(stats.totalRepos)} repositories`);
+      console.log(`  Active Sessions: ${chalk.yellow(stats.activeSessions)}`);
+      console.log(`  Leaderboard Size: ${chalk.blue(stats.leaderboardSize)} users`);
+      console.log(`  Cache Keys: ${chalk.magenta(stats.cacheKeys)}\n`);
+
+      if (Object.keys(stats.achievements).length > 0) {
+        console.log(chalk.bold('Achievements:'));
+        Object.entries(stats.achievements).forEach(([user, achievements]) => {
+          console.log(`  ${chalk.cyan(user)}: ${achievements.length > 0 ? achievements.join(', ') : chalk.dim('none')}`);
+        });
+        console.log();
+      }
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error fetching Redis stats:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('redis:verify')
+  .description('Verify Redis connection and data structures')
+  .action(async () => {
+    try {
+      if (!process.env.REDIS_URL) {
+        console.error(chalk.red('❌ REDIS_URL not configured. Run: boss-claude setup\n'));
+        process.exit(1);
+      }
+
+      console.log(chalk.blue('\n🔍 Verifying Redis...\n'));
+
+      const result = await verifyRedis(process.env.REDIS_URL);
+
+      if (!result.connected) {
+        console.log(chalk.red('✗ Connection Failed'));
+        console.log(chalk.dim(`  Error: ${result.error}\n`));
+        process.exit(1);
+      }
+
+      console.log(chalk.green('✓ Connection Successful'));
+      console.log(chalk.dim(`  Redis Version: ${result.version}\n`));
+
+      console.log(chalk.bold('Data Structures:'));
+      console.log(result.structures.identity ?
+        chalk.green('✓ boss:identity exists') :
+        chalk.red('✗ boss:identity missing')
+      );
+      console.log(`  ${result.structures.sessionHistory > 0 ? chalk.green('✓') : chalk.yellow('○')} boss:sessions:history (${result.structures.sessionHistory} sessions)`);
+      console.log(`  ${result.structures.leaderboard > 0 ? chalk.green('✓') : chalk.yellow('○')} boss:leaderboard:xp (${result.structures.leaderboard} users)\n`);
+
+      if (result.healthCheck.passed) {
+        console.log(chalk.green('✓ All health checks passed\n'));
+      } else {
+        console.log(chalk.red('✗ Health check failed\n'));
+        Object.entries(result.healthCheck.details).forEach(([key, value]) => {
+          const status = value === 'OK' ? chalk.green('✓') : chalk.red('✗');
+          console.log(`  ${status} ${key}: ${chalk.dim(value)}`);
+        });
+        console.log();
+      }
+
+    } catch (error) {
+      console.error(chalk.red('❌ Verification failed:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('redis:init')
+  .description('Initialize or repair Redis data structures')
+  .option('-f, --force', 'Force re-initialization even if data exists')
+  .action(async (options) => {
+    try {
+      if (!process.env.REDIS_URL) {
+        console.error(chalk.red('❌ REDIS_URL not configured. Run: boss-claude setup\n'));
+        process.exit(1);
+      }
+
+      if (!process.env.GITHUB_USER) {
+        console.error(chalk.red('❌ GITHUB_USER not configured. Run: boss-claude setup\n'));
+        process.exit(1);
+      }
+
+      console.log(chalk.blue('\n🔧 Initializing Redis...\n'));
+
+      if (options.force) {
+        console.log(chalk.yellow('⚠️  Force mode: Will overwrite existing data\n'));
+      }
+
+      const results = await initializeRedis(
+        process.env.REDIS_URL,
+        process.env.GITHUB_USER,
+        options.force
+      );
+
+      printInitResults(results, process.env.GITHUB_USER);
+
+      if (results.healthCheck.passed) {
+        console.log(chalk.green('✓ Redis initialization successful!\n'));
+      } else {
+        console.log(chalk.yellow('⚠️  Initialization completed with warnings\n'));
+      }
+
+    } catch (error) {
+      console.error(chalk.red('❌ Initialization failed:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('redis:reset')
+  .description('Reset Redis to initial state (WARNING: Destructive!)')
+  .option('--confirm', 'Skip confirmation prompt')
+  .action(async (options) => {
+    try {
+      if (!process.env.REDIS_URL) {
+        console.error(chalk.red('❌ REDIS_URL not configured. Run: boss-claude setup\n'));
+        process.exit(1);
+      }
+
+      if (!process.env.GITHUB_USER) {
+        console.error(chalk.red('❌ GITHUB_USER not configured. Run: boss-claude setup\n'));
+        process.exit(1);
+      }
+
+      console.log(chalk.red('\n⚠️  WARNING: This will delete ALL Boss Claude data in Redis!\n'));
+
+      if (!options.confirm) {
+        const { confirm } = await import('./prompts.js');
+        const shouldContinue = await confirm('Are you absolutely sure?', false);
+
+        if (!shouldContinue) {
+          console.log(chalk.yellow('\nReset cancelled\n'));
+          process.exit(0);
+        }
+      }
+
+      console.log(chalk.blue('\n🔄 Resetting Redis...\n'));
+
+      const results = await resetRedis(process.env.REDIS_URL, process.env.GITHUB_USER);
+
+      printInitResults(results, process.env.GITHUB_USER);
+
+      console.log(chalk.green('✓ Redis reset complete!\n'));
+      console.log(chalk.dim('All data has been deleted and structures re-initialized\n'));
+
+    } catch (error) {
+      console.error(chalk.red('❌ Reset failed:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('watch')
+  .description('Watch agent activity in real-time (companion window)')
+  .action(() => {
+    console.log(chalk.blue('\n👁️  Boss Claude Agent Monitor\n'));
+    console.log(chalk.dim(`Watching: ${LOG_FILE}`));
+    console.log(chalk.dim('Press Ctrl+C to stop\n'));
+    console.log(chalk.gray('─'.repeat(80)));
+
+    // Use tail -f to follow the log file
+    const tail = spawn('tail', ['-f', '-n', '20', LOG_FILE], {
+      stdio: ['ignore', 'pipe', 'inherit']
+    });
+
+    // Format and colorize output
+    tail.stdout.on('data', (data) => {
+      const lines = data.toString().split('\n');
+      lines.forEach(line => {
+        if (!line.trim()) return;
+
+        // Parse log format: [timestamp] EVENT: Agent - Details
+        const match = line.match(/\[(.*?)\] (.*?): (.*?)(?:\s-\s(.*))?$/);
+        if (match) {
+          const [, timestamp, event, agent, details] = match;
+          const time = new Date(timestamp).toLocaleTimeString();
+
+          let eventColor = chalk.gray;
+          if (event === 'START') eventColor = chalk.cyan;
+          else if (event === 'COMPLETE') eventColor = chalk.green;
+          else if (event === 'ERROR') eventColor = chalk.red;
+
+          // Format details with intelligent line wrapping
+          let formattedDetails = '';
+          if (details) {
+            const wrappedDetails = formatLogDetails(details, {
+              multiline: true,
+              continuationPrefix: '                        ' // Align with agent name
+            });
+            formattedDetails = chalk.dim(' - ' + wrappedDetails);
+          }
+
+          const formatted = `${chalk.dim(time)} ${eventColor(event.padEnd(10))} ${chalk.bold(agent)}${formattedDetails}`;
+          console.log(formatted);
+        } else {
+          // Fallback for non-matching lines
+          console.log(chalk.gray(line));
+        }
+      });
+    });
+
+    tail.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        console.error(chalk.red('\n❌ Log file not found. Agent activity will be logged here once tasks start.\n'));
+        console.log(chalk.dim(`Expected location: ${LOG_FILE}\n`));
+      } else {
+        console.error(chalk.red('❌ Error watching log:'), err.message);
+      }
+      process.exit(1);
+    });
+
+    // Handle graceful shutdown
+    process.on('SIGINT', () => {
+      console.log(chalk.yellow('\n\n👋 Stopped watching agent activity\n'));
+      tail.kill();
+      process.exit(0);
+    });
+  });
+
+program
+  .command('commentate')
+  .description('Live commentary on agent activity')
+  .action(async () => {
+    const { startCommentator } = await import('../lib/commentator.js');
+    startCommentator();
+  });
+
+// Hierarchy enforcement commands
+program
+  .command('compliance-report')
+  .description('Generate hierarchy compliance report')
+  .option('-q, --quarterly', 'Show quarterly metrics')
+  .action(async (options) => {
+    try {
+      console.log(chalk.blue('\n📊 HIERARCHY COMPLIANCE REPORT\n'));
+      console.log(chalk.dim('━'.repeat(80)));
+
+      const report = hierarchyValidator.getViolationReport();
+
+      console.log(chalk.bold('\n📈 Overall Metrics:'));
+      console.log(`  Total Validations: ${chalk.green(report.totalValidations)}`);
+      console.log(`  Total Violations: ${chalk.red(report.totalViolations)}`);
+
+      if (report.totalValidations + report.totalViolations > 0) {
+        const complianceRate = report.complianceRate.toFixed(1);
+        const rateColor = report.complianceRate >= 80 ? chalk.green : report.complianceRate >= 60 ? chalk.yellow : chalk.red;
+        console.log(`  Compliance Rate: ${rateColor(complianceRate + '%')}`);
+      } else {
+        console.log(`  Compliance Rate: ${chalk.dim('N/A (no data)')}`);
+      }
+
+      if (report.mostViolatedAgents.length > 0) {
+        console.log(chalk.bold('\n🚨 Most Violated Agents:'));
+        report.mostViolatedAgents.slice(0, 5).forEach((agent, idx) => {
+          console.log(`  ${idx + 1}. ${chalk.yellow(agent.agent)}: ${chalk.red(agent.violations)} violations`);
+        });
+      }
+
+      if (report.violations.length > 0) {
+        console.log(chalk.bold('\n📋 Recent Violations:'));
+        report.violations.slice(-5).forEach(v => {
+          const date = new Date(v.timestamp).toLocaleString();
+          console.log(`  ${chalk.dim(date)} - ${chalk.yellow(v.agent)}`);
+          console.log(`    ${chalk.gray(v.reason)}`);
+        });
+      }
+
+      console.log(chalk.dim('\n━'.repeat(80)));
+      console.log(chalk.dim('💡 Use violations to improve delegation patterns\n'));
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error generating compliance report:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('validate-agent')
+  .description('Validate that an agent follows hierarchy rules')
+  .argument('<agent-name>', 'Agent name to validate')
+  .option('-t, --task <task>', 'Task description (optional)')
+  .action(async (agentName, options) => {
+    try {
+      console.log(chalk.blue(`\n🔍 Validating agent: ${chalk.bold(agentName)}\n`));
+
+      // Check if agent exists in registry
+      const workerInfo = AGENT_HIERARCHY.workers[agentName];
+      const bossInfo = AGENT_HIERARCHY.bosses[agentName];
+
+      if (!workerInfo && !bossInfo) {
+        console.log(chalk.red('❌ Agent not found in hierarchy registry'));
+        console.log(chalk.dim('\nRegistered workers:'));
+        Object.keys(AGENT_HIERARCHY.workers).forEach(w => {
+          console.log(`  - ${chalk.cyan(w)}`);
+        });
+        console.log(chalk.dim('\nRegistered bosses:'));
+        Object.keys(AGENT_HIERARCHY.bosses).forEach(b => {
+          console.log(`  - ${chalk.green(b)}`);
+        });
+        process.exit(1);
+      }
+
+      if (workerInfo) {
+        console.log(chalk.bold('Agent Type:'), chalk.cyan('Worker'));
+        console.log(chalk.bold('Domain:'), chalk.green(workerInfo.domain));
+        console.log(chalk.bold('Assigned Boss:'), chalk.yellow(workerInfo.boss));
+        console.log(chalk.bold('Description:'), chalk.gray(workerInfo.description));
+
+        const bossInfo = AGENT_HIERARCHY.bosses[workerInfo.boss];
+        console.log(chalk.bold('Reports To:'), chalk.magenta(bossInfo.metaBoss));
+        console.log(chalk.green('\n✅ Valid worker agent in hierarchy'));
+      } else if (bossInfo) {
+        console.log(chalk.bold('Agent Type:'), chalk.yellow('Boss'));
+        console.log(chalk.bold('Domain:'), chalk.green(bossInfo.domain));
+        console.log(chalk.bold('Reports To:'), chalk.magenta(bossInfo.metaBoss));
+        console.log(chalk.bold('Description:'), chalk.gray(bossInfo.description));
+        console.log(chalk.bold('Manages Workers:'));
+        bossInfo.workers.forEach(w => {
+          console.log(`  - ${chalk.cyan(w)}`);
+        });
+        console.log(chalk.green('\n✅ Valid boss agent in hierarchy'));
+      }
+
+      console.log();
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error validating agent:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('hierarchy-tree')
+  .description('Display the complete agent hierarchy tree')
+  .action(() => {
+    try {
+      console.log(chalk.bold.blue('\n🌳 AGENT HIERARCHY TREE\n'));
+      console.log(chalk.dim('━'.repeat(80)));
+
+      console.log(chalk.bold('\nTier 3: Meta-Boss'));
+      console.log(`  ${chalk.magenta('┗━ ' + AGENT_HIERARCHY.metaBoss)} ${chalk.dim('(final security gate)')}`);
+
+      console.log(chalk.bold('\nTier 2: Domain Bosses'));
+      Object.entries(AGENT_HIERARCHY.bosses).forEach(([name, info]) => {
+        console.log(`    ${chalk.yellow('┣━ ' + name)} ${chalk.dim('(' + info.domain + ')')}`);
+      });
+
+      console.log(chalk.bold('\nTier 1: Worker Agents'));
+      Object.entries(AGENT_HIERARCHY.workers).forEach(([name, info], idx, arr) => {
+        const isLast = idx === arr.length - 1;
+        const prefix = isLast ? '┗━' : '┣━';
+        console.log(`      ${chalk.cyan(prefix + ' ' + name)} ${chalk.dim('→ ' + info.boss)}`);
+      });
+
+      console.log(chalk.dim('\n━'.repeat(80)));
+      console.log(chalk.dim('💡 Use "boss-claude validate-agent <name>" for details\n'));
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error displaying hierarchy:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// ONYX Reminder commands
+program
+  .command('onyx:show')
+  .description('Display ONYX orchestrator reminder')
+  .action(async () => {
+    try {
+      await onyxReminder.showOnyxReminder();
+    } catch (error) {
+      console.error(chalk.red('❌ Error showing ONYX reminder:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('onyx:status')
+  .description('Show ONYX reminder status and message count')
+  .action(async () => {
+    try {
+      const count = await onyxReminder.getOnyxMessageCount();
+      const interval = await onyxReminder.getOnyxInterval();
+
+      console.log(chalk.blue('\n⚡ ONYX REMINDER STATUS\n'));
+      console.log(chalk.bold('Configuration:'));
+      console.log(`  Message Count: ${chalk.cyan(count)}`);
+      console.log(`  Reminder Interval: ${chalk.yellow('Every ' + interval + ' messages')}`);
+      console.log(`  Next Reminder: ${chalk.green('In ' + (interval - (count % interval)) + ' messages')}\n`);
+
+      if (count % interval === 0 && count > 0) {
+        console.log(chalk.yellow('⚡ Reminder is due NOW!\n'));
+        await onyxReminder.showOnyxReminder();
+      }
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error getting ONYX status:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('onyx:set-interval')
+  .description('Set ONYX reminder interval')
+  .argument('<interval>', 'Number of messages between reminders')
+  .action(async (interval) => {
+    try {
+      const num = parseInt(interval, 10);
+      if (isNaN(num) || num < 1) {
+        console.error(chalk.red('❌ Interval must be a positive number\n'));
+        process.exit(1);
+      }
+
+      await onyxReminder.setOnyxInterval(num);
+      console.log(chalk.green(`\n✅ ONYX reminder interval set to ${num} messages\n`));
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error setting interval:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('onyx:reset')
+  .description('Reset ONYX message counter to zero')
+  .action(async () => {
+    try {
+      await onyxReminder.resetOnyxCounter();
+      console.log(chalk.green('\n✅ ONYX message counter reset to zero\n'));
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error resetting counter:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Checkpoint commands - ONYX delegation accountability
+program
+  .command('checkpoint:status')
+  .description('Show current checkpoint status and delegation efficiency')
+  .action(async () => {
+    try {
+      const status = await getCheckpointStatus();
+      const efficiency = await getDelegationEfficiency();
+
+      if (!status) {
+        console.log(chalk.yellow('\n⚠️  No active checkpoint session\n'));
+        console.log(chalk.dim('Checkpoint tracking starts automatically when ONYX begins work\n'));
+        return;
+      }
+
+      console.log(chalk.blue('\n⚡ CHECKPOINT STATUS\n'));
+      console.log(chalk.dim('━'.repeat(80)));
+
+      console.log(chalk.bold('\n📊 Session Progress:'));
+      console.log(`  Repository: ${chalk.cyan(status.repo)}`);
+      console.log(`  Messages: ${chalk.yellow(status.message_count)}`);
+      console.log(`  Checkpoints Passed: ${chalk.green(status.checkpoints_passed)}`);
+      console.log(`  Next Checkpoint: ${chalk.magenta('In ' + (5 - (status.message_count % 5)) + ' messages')}`);
+
+      console.log(chalk.bold('\n🎯 Delegation Efficiency:'));
+      console.log(`  Delegation Rate: ${chalk.green(efficiency.delegation_rate + '%')}`);
+      console.log(`  Delegations: ${chalk.cyan(efficiency.delegations)}`);
+      console.log(`  Token Burns: ${chalk.red(efficiency.token_burns)}`);
+
+      console.log(chalk.bold('\n💰 Token Economics:'));
+      console.log(`  Tokens Saved: ${chalk.green('+' + efficiency.tokens_saved.toLocaleString())}`);
+      console.log(`  Tokens Burned: ${chalk.red('-' + efficiency.tokens_burned.toLocaleString())}`);
+      console.log(`  Net Savings: ${chalk.bold(efficiency.net_savings.toLocaleString())}`);
+      console.log(`  Efficiency Score: ${chalk.yellow(efficiency.efficiency_score + '%')}`);
+
+      if (status.awaiting_response) {
+        console.log(chalk.bold.yellow('\n⏳ CHECKPOINT PENDING - Awaiting delegation decision'));
+      }
+
+      console.log(chalk.dim('\n━'.repeat(80)));
+      console.log(chalk.dim('💡 Use "boss-claude checkpoint:history" to see past decisions\n'));
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error getting checkpoint status:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('checkpoint:record')
+  .description('Record checkpoint decision (delegated or burned)')
+  .option('-d, --delegated', 'Task was delegated to specialist')
+  .option('-b, --burned', 'Task was done directly (tokens burned)')
+  .option('-t, --tokens <number>', 'Tokens saved (if delegated) or burned (if not)', '0')
+  .option('-s, --specialist <name>', 'Specialist name (if delegated)')
+  .option('-j, --justification <text>', 'Justification for decision', '')
+  .action(async (options) => {
+    try {
+      if (!options.delegated && !options.burned) {
+        console.error(chalk.red('❌ Must specify either --delegated or --burned\n'));
+        process.exit(1);
+      }
+
+      if (options.delegated && options.burned) {
+        console.error(chalk.red('❌ Cannot specify both --delegated and --burned\n'));
+        process.exit(1);
+      }
+
+      const delegated = options.delegated;
+      const tokens = parseInt(options.tokens, 10);
+      const specialist = options.specialist || '';
+      const justification = options.justification;
+
+      if (delegated && !specialist) {
+        console.error(chalk.red('❌ Specialist name required when delegated\n'));
+        process.exit(1);
+      }
+
+      const result = await recordCheckpoint(
+        delegated,
+        delegated ? tokens : 0,
+        delegated ? 0 : tokens,
+        justification,
+        specialist
+      );
+
+      console.log(chalk.green('\n✅ Checkpoint recorded!\n'));
+      console.log(chalk.bold('Decision:'));
+      console.log(`  Type: ${delegated ? chalk.green('DELEGATED') : chalk.red('BURNED')}`);
+      console.log(`  Tokens: ${chalk.cyan(tokens.toLocaleString())}`);
+      if (specialist) {
+        console.log(`  Specialist: ${chalk.yellow(specialist)}`);
+      }
+      if (justification) {
+        console.log(`  Justification: ${chalk.gray(justification)}`);
+      }
+
+      console.log(chalk.bold('\nUpdated Stats:'));
+      console.log(`  Total Checkpoints: ${chalk.green(result.checkpoint.checkpoints_passed)}`);
+      console.log(`  Delegation Rate: ${chalk.cyan(((result.checkpoint.delegation_count / result.checkpoint.checkpoints_passed) * 100).toFixed(1) + '%')}`);
+
+      console.log();
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error recording checkpoint:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('checkpoint:history')
+  .description('Show checkpoint history')
+  .option('-l, --limit <number>', 'Number of records to show', '20')
+  .action(async (options) => {
+    try {
+      const limit = parseInt(options.limit, 10);
+      const history = await getCheckpointHistory(limit);
+
+      if (history.length === 0) {
+        console.log(chalk.yellow('\n⚠️  No checkpoint history found\n'));
+        return;
+      }
+
+      console.log(chalk.blue(`\n📋 CHECKPOINT HISTORY (Last ${history.length} records)\n`));
+      console.log(chalk.dim('━'.repeat(80)));
+
+      history.forEach((record, idx) => {
+        const date = new Date(record.timestamp).toLocaleString();
+        const decision = record.delegated ? chalk.green('DELEGATED') : chalk.red('BURNED');
+        const tokens = record.delegated ? record.tokens_saved : record.tokens_burned;
+
+        console.log(chalk.bold(`\n${idx + 1}. ${date}`));
+        console.log(`   Decision: ${decision}`);
+        console.log(`   Tokens: ${chalk.cyan(tokens.toLocaleString())}`);
+        if (record.specialist) {
+          console.log(`   Specialist: ${chalk.yellow(record.specialist)}`);
+        }
+        if (record.justification) {
+          console.log(`   Justification: ${chalk.gray(record.justification)}`);
+        }
+      });
+
+      console.log(chalk.dim('\n━'.repeat(80)));
+      console.log(chalk.dim('💡 Use "boss-claude checkpoint:status" for current stats\n'));
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error getting checkpoint history:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('checkpoint:export')
+  .description('Export checkpoint data for analysis')
+  .action(async () => {
+    try {
+      const data = await exportCheckpointData();
+
+      console.log(chalk.blue('\n📦 CHECKPOINT DATA EXPORT\n'));
+      console.log(JSON.stringify(data, null, 2));
+      console.log();
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error exporting checkpoint data:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('checkpoint:reset')
+  .description('Reset checkpoint tracking for new session')
+  .action(async () => {
+    try {
+      const newCheckpoint = await resetCheckpoint();
+
+      console.log(chalk.green('\n✅ Checkpoint reset complete!\n'));
+      console.log(chalk.bold('New Session:'));
+      console.log(`  Repository: ${chalk.cyan(newCheckpoint.repo)}`);
+      console.log(`  Started: ${chalk.gray(newCheckpoint.started_at)}`);
+      console.log(`  Checkpoints will trigger every ${chalk.yellow('5 messages')}\n`);
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error resetting checkpoint:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// ONYX Delegation Monitoring Commands
+program
+  .command('onyx-status')
+  .description('Show ONYX delegation ratio and monitoring status')
+  .action(async () => {
+    try {
+      const status = await getFormattedStatus();
+      console.log(status);
+    } catch (error) {
+      console.error(chalk.red('❌ Error getting ONYX status:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('onyx-report')
+  .description('Generate comprehensive ONYX delegation report')
+  .option('-e, --events <limit>', 'Number of recent events to include', '50')
+  .action(async (options) => {
+    try {
+      console.log(chalk.blue('\n📊 ONYX DELEGATION REPORT\n'));
+      console.log(chalk.dim('━'.repeat(80)));
+
+      const report = await generateReport({ eventLimit: parseInt(options.events) });
+
+      console.log(chalk.bold('\n📈 Overall Statistics:'));
+      console.log(`  Total Actions: ${chalk.cyan(report.overall.total_actions)}`);
+      console.log(`  Delegations: ${chalk.green(report.overall.total_delegations)}`);
+      console.log(`  Direct Actions: ${chalk.yellow(report.overall.total_direct_actions)}`);
+      console.log(`  Delegation Ratio: ${chalk.bold(report.overall.delegation_percentage + '%')}`);
+      console.log(`  Alert Threshold: ${chalk.gray(report.overall.threshold_percentage + '%')}`);
+
+      const statusIcon = report.overall.meets_threshold ? chalk.green('✅ PASSING') : chalk.red('⚠️  BELOW THRESHOLD');
+      console.log(`  Status: ${statusIcon}`);
+
+      console.log(chalk.bold('\n⏱️  Time-Based Metrics:'));
+      console.log(chalk.dim('  Last 24 Hours:'));
+      console.log(`    Delegations: ${chalk.green(report.time_periods.last_24h.delegations)}`);
+      console.log(`    Direct Actions: ${chalk.yellow(report.time_periods.last_24h.direct_actions)}`);
+      console.log(`    Ratio: ${chalk.cyan(report.time_periods.last_24h.percentage + '%')}`);
+
+      console.log(chalk.dim('  Last 7 Days:'));
+      console.log(`    Delegations: ${chalk.green(report.time_periods.last_7d.delegations)}`);
+      console.log(`    Direct Actions: ${chalk.yellow(report.time_periods.last_7d.direct_actions)}`);
+      console.log(`    Ratio: ${chalk.cyan(report.time_periods.last_7d.percentage + '%')}`);
+
+      if (Object.keys(report.overall.agent_breakdown).length > 0) {
+        console.log(chalk.bold('\n🤖 Agent Delegation Breakdown:'));
+        Object.entries(report.overall.agent_breakdown)
+          .sort((a, b) => b[1] - a[1])
+          .forEach(([agent, count]) => {
+            console.log(`  ${chalk.cyan(agent)}: ${chalk.green(count)} tasks`);
+          });
+      }
+
+      if (Object.keys(report.overall.direct_action_breakdown).length > 0) {
+        console.log(chalk.bold('\n⚡ Direct Action Breakdown:'));
+        Object.entries(report.overall.direct_action_breakdown)
+          .sort((a, b) => b[1] - a[1])
+          .forEach(([type, count]) => {
+            console.log(`  ${chalk.yellow(type)}: ${chalk.red(count)} actions`);
+          });
+      }
+
+      if (report.recent_events.length > 0) {
+        console.log(chalk.bold('\n📋 Recent Events:'));
+        report.recent_events.slice(0, 10).forEach(event => {
+          const time = new Date(event.timestamp).toLocaleTimeString();
+          if (event.type === 'delegation') {
+            console.log(`  ${chalk.dim(time)} ${chalk.green('→')} Delegated to ${chalk.cyan(event.agent)}: ${chalk.gray(event.task)}`);
+          } else {
+            console.log(`  ${chalk.dim(time)} ${chalk.red('•')} Direct action ${chalk.yellow(event.action_type)}: ${chalk.gray(event.description)}`);
+          }
+        });
+      }
+
+      console.log(chalk.dim('\n━'.repeat(80)));
+      console.log(chalk.dim(`Generated: ${new Date(report.generated_at).toLocaleString()}`));
+      console.log(chalk.dim(`Alert Log: ${ALERT_LOG}\n`));
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error generating report:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('onyx-track-delegation')
+  .description('Track a task delegated to ONYX agent')
+  .argument('<agent>', 'ONYX agent name')
+  .argument('<task>', 'Task description')
+  .action(async (agent, task) => {
+    try {
+      const stats = await trackDelegation(agent, task);
+
+      console.log(chalk.green(`\n✅ Delegation tracked: ${chalk.bold(agent)}`));
+      console.log(`  Task: ${chalk.gray(task)}`);
+      console.log(`  Current Ratio: ${chalk.cyan(stats.delegation_percentage + '%')} (${stats.total_delegations}/${stats.total_actions})`);
+
+      if (!stats.meets_threshold) {
+        console.log(chalk.yellow(`  ⚠️  Below threshold of ${stats.threshold_percentage}%`));
+      }
+
+      console.log();
+    } catch (error) {
+      console.error(chalk.red('❌ Error tracking delegation:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('onyx-track-direct')
+  .description('Track a direct action (not delegated to ONYX)')
+  .argument('<type>', 'Action type (e.g., file_edit, command_execution)')
+  .argument('<description>', 'Action description')
+  .action(async (type, description) => {
+    try {
+      const stats = await trackDirectAction(type, description);
+
+      console.log(chalk.yellow(`\n⚡ Direct action tracked: ${chalk.bold(type)}`));
+      console.log(`  Description: ${chalk.gray(description)}`);
+      console.log(`  Current Ratio: ${chalk.cyan(stats.delegation_percentage + '%')} (${stats.total_delegations}/${stats.total_actions})`);
+
+      if (!stats.meets_threshold) {
+        console.log(chalk.red(`  ⚠️  ALERT: Below threshold of ${stats.threshold_percentage}%`));
+      }
+
+      console.log();
+    } catch (error) {
+      console.error(chalk.red('❌ Error tracking direct action:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('onyx-set-threshold')
+  .description('Set ONYX delegation ratio alert threshold')
+  .argument('<threshold>', 'Threshold percentage (e.g., 95 for 95%)')
+  .action(async (threshold) => {
+    try {
+      const num = parseFloat(threshold);
+      if (isNaN(num) || num < 0 || num > 100) {
+        console.error(chalk.red('❌ Threshold must be between 0 and 100\n'));
+        process.exit(1);
+      }
+
+      const newThreshold = await setAlertThreshold(num / 100);
+      console.log(chalk.green(`\n✅ Alert threshold set to ${chalk.bold((newThreshold * 100).toFixed(0) + '%')}\n`));
+      console.log(chalk.dim('  Alerts will trigger when delegation ratio drops below this threshold\n'));
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error setting threshold:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('onyx-events')
+  .description('Show recent ONYX delegation and direct action events')
+  .option('-l, --limit <number>', 'Number of events to show', '20')
+  .action(async (options) => {
+    try {
+      const events = await getRecentEvents(parseInt(options.limit));
+
+      console.log(chalk.blue(`\n📜 Recent ONYX Events (${events.length})\n`));
+      console.log(chalk.dim('━'.repeat(80)));
+
+      events.forEach((event, idx) => {
+        const time = new Date(event.timestamp).toLocaleString();
+
+        if (event.type === 'delegation') {
+          console.log(`\n${chalk.dim(`${idx + 1}.`)} ${chalk.green('DELEGATION')} ${chalk.dim(time)}`);
+          console.log(`   Agent: ${chalk.cyan(event.agent)}`);
+          console.log(`   Task: ${chalk.gray(event.task)}`);
+          if (event.metadata && Object.keys(event.metadata).length > 0) {
+            console.log(`   Metadata: ${chalk.dim(JSON.stringify(event.metadata))}`);
+          }
+        } else {
+          console.log(`\n${chalk.dim(`${idx + 1}.`)} ${chalk.yellow('DIRECT ACTION')} ${chalk.dim(time)}`);
+          console.log(`   Type: ${chalk.yellow(event.action_type)}`);
+          console.log(`   Description: ${chalk.gray(event.description)}`);
+          if (event.metadata && Object.keys(event.metadata).length > 0) {
+            console.log(`   Metadata: ${chalk.dim(JSON.stringify(event.metadata))}`);
+          }
+        }
+      });
+
+      console.log(chalk.dim('\n━'.repeat(80)));
+      console.log(chalk.dim('💡 Use "boss-claude onyx-report" for comprehensive analysis\n'));
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error fetching events:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('onyx-reset-tracking')
+  .description('Reset all ONYX delegation tracking data')
+  .option('--confirm', 'Skip confirmation prompt')
+  .action(async (options) => {
+    try {
+      console.log(chalk.yellow('\n⚠️  WARNING: This will reset all ONYX delegation tracking data!\n'));
+
+      if (!options.confirm) {
+        const { default: inquirer } = await import('inquirer');
+        const { confirm } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Are you sure you want to reset all tracking data?',
+            default: false
+          }
+        ]);
+
+        if (!confirm) {
+          console.log(chalk.yellow('Reset cancelled\n'));
+          process.exit(0);
+        }
+      }
+
+      await resetTracking();
+      console.log(chalk.green('✅ ONYX delegation tracking has been reset\n'));
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error resetting tracking:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('onyx-banner')
+  .description('Display ONYX MODE banner (for testing and integration)')
+  .option('-c, --compact', 'Display compact version')
+  .option('-s, --stats', 'Display with statistics')
+  .option('--no-color', 'Disable colorization')
+  .action(async (options) => {
+    try {
+      const { displayOnyxBanner, displayOnyxBannerCompact, getBannerWithStats } = await import('../lib/onyx-banner.js');
+
+      if (options.stats) {
+        console.log(getBannerWithStats(true));
+      } else if (options.compact) {
+        console.log(displayOnyxBannerCompact(options.color));
+      } else {
+        console.log(displayOnyxBanner(options.color));
+      }
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error displaying banner:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Mode enforcement commands
+program
+  .command('mode')
+  .description('Manage orchestrator mode enforcement')
+  .argument('[subcommand]', 'Mode command (orchestrator|specialist|worker|review|learning|history|stats|blocked|reset|status)')
+  .allowUnknownOption()
+  .action(async (subcommand, options, command) => {
+    try {
+      // Pass all remaining arguments to mode command handler
+      const args = command.args.slice(1);
+      if (subcommand) {
+        args.unshift(subcommand);
+      }
+      await modeCommand(args);
+    } catch (error) {
+      console.error(chalk.red('❌ Mode command failed:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Agent management commands (kill stuck workers)
+program
+  .command('agent:list')
+  .description('List currently running agents')
+  .action(async () => {
+    try {
+      console.log(chalk.blue('\n🔍 Scanning for running agents...\n'));
+
+      // Check for Claude task processes
+      const { execSync } = await import('child_process');
+      try {
+        const psOutput = execSync('ps aux | grep -E "claude|task" | grep -v grep', { encoding: 'utf8' });
+        const lines = psOutput.trim().split('\n').filter(l => l.trim());
+
+        if (lines.length === 0) {
+          console.log(chalk.gray('No agents currently running.'));
+        } else {
+          console.log(chalk.bold('Running Processes:'));
+          lines.forEach(line => {
+            const parts = line.split(/\s+/);
+            const pid = parts[1];
+            const cmd = parts.slice(10).join(' ').substring(0, 60);
+            console.log(`  ${chalk.cyan(pid)} - ${chalk.dim(cmd)}`);
+          });
+        }
+      } catch (e) {
+        console.log(chalk.gray('No agents currently running.'));
+      }
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error listing agents:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('agent:kill')
+  .description('Kill a stuck agent by PID')
+  .argument('<pid>', 'Process ID to kill')
+  .option('-f, --force', 'Force kill (SIGKILL instead of SIGTERM)')
+  .action(async (pid, options) => {
+    try {
+      const signal = options.force ? 'SIGKILL' : 'SIGTERM';
+      console.log(chalk.yellow(`\n🛑 Sending ${signal} to PID ${pid}...\n`));
+
+      const { execSync } = await import('child_process');
+      execSync(`kill -${signal === 'SIGKILL' ? '9' : '15'} ${pid}`);
+
+      console.log(chalk.green(`✅ Signal sent to process ${pid}`));
+      console.log(chalk.gray('   Agent should terminate shortly.'));
+
+    } catch (error) {
+      if (error.message.includes('No such process')) {
+        console.log(chalk.yellow(`⚠️  Process ${pid} not found (may have already exited)`));
+      } else {
+        console.error(chalk.red('❌ Error killing agent:'), error.message);
+        process.exit(1);
+      }
+    }
+  });
+
+program
+  .command('agent:kill-all')
+  .description('Kill all stuck agents (nuclear option)')
+  .option('-f, --force', 'Force kill all')
+  .action(async (options) => {
+    try {
+      console.log(chalk.red.bold('\n⚠️  NUCLEAR OPTION: Killing all agent processes...\n'));
+
+      const { execSync } = await import('child_process');
+      const signal = options.force ? '9' : '15';
+
+      try {
+        // Kill claude task-related processes (but not the main Claude process)
+        execSync(`pkill -${signal} -f "claude.*task" 2>/dev/null || true`, { encoding: 'utf8' });
+        console.log(chalk.green('✅ Kill signal sent to all task agents'));
+      } catch (e) {
+        console.log(chalk.yellow('⚠️  No agents found to kill'));
+      }
+
+      console.log(chalk.gray('\nNote: Main Claude process is preserved.'));
+
+    } catch (error) {
+      console.error(chalk.red('❌ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
 program.parse();