@cpretzinger/boss-claude 1.0.0 → 1.0.2

package/lib/task-agent-worker.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+/**
+ * TASK AGENT WORKER
+ *
+ * Executes delegated operations via Task tool.
+ * Handles the actual execution of auto-delegated tool calls.
+ */
+
+import chalk from 'chalk';
+
+/**
+ * Task Agent Worker Class
+ *
+ * Processes delegated tool operations by calling Task tool
+ */
+export class TaskAgentWorker {
+  constructor(config = {}) {
+    this.taskExecutor = config.taskExecutor || null;
+    this.executionLog = [];
+    this.successCount = 0;
+    this.failureCount = 0;
+  }
+
+  /**
+   * Execute delegated tool call via Task
+   *
+   * @param {Object} delegation - Delegation object from tool-wrapper
+   * @returns {Promise<Object>} Execution result
+   */
+  async executeDelegation(delegation) {
+    const startTime = Date.now();
+
+    console.log(chalk.cyan('\n📤 Task Agent Processing Delegation'));
+    console.log(chalk.dim('─'.repeat(60)));
+    console.log(chalk.white(`Tool: ${chalk.bold(delegation.originalTool)}`));
+    console.log(chalk.white(`Description: ${delegation.description}`));
+    console.log(chalk.dim(`Strategy: ${delegation.strategy}`));
+    console.log(chalk.dim('─'.repeat(60)));
+
+    try {
+      // Execute via Task tool
+      const result = await this._executeViaTask(delegation);
+
+      this.successCount++;
+      const executionTime = Date.now() - startTime;
+
+      const logEntry = {
+        timestamp: new Date().toISOString(),
+        delegation,
+        result,
+        success: true,
+        executionTime
+      };
+
+      this.executionLog.push(logEntry);
+
+      console.log(chalk.green(`✅ Delegation completed (${executionTime}ms)`));
+
+      return {
+        success: true,
+        delegated: true,
+        result,
+        executionTime,
+        originalTool: delegation.originalTool,
+        strategy: delegation.strategy
+      };
+
+    } catch (error) {
+      this.failureCount++;
+      const executionTime = Date.now() - startTime;
+
+      const logEntry = {
+        timestamp: new Date().toISOString(),
+        delegation,
+        error: error.message,
+        success: false,
+        executionTime
+      };
+
+      this.executionLog.push(logEntry);
+
+      console.log(chalk.red(`❌ Delegation failed: ${error.message}`));
+
+      return {
+        success: false,
+        delegated: true,
+        error: error.message,
+        executionTime,
+        originalTool: delegation.originalTool,
+        strategy: delegation.strategy
+      };
+    }
+  }
+
+  /**
+   * Execute via Task tool
+   */
+  async _executeViaTask(delegation) {
+    if (!this.taskExecutor) {
+      // No task executor provided - return mock result
+      console.log(chalk.yellow('⚠️  No task executor configured - returning mock result'));
+
+      return {
+        mock: true,
+        message: 'Task would be executed here',
+        delegation
+      };
+    }
+
+    // Call provided task executor
+    if (typeof this.taskExecutor === 'function') {
+      const taskParams = {
+        description: delegation.description,
+        context: {
+          originalTool: delegation.originalTool,
+          originalParams: delegation.originalParams,
+          delegatedBy: 'ToolWrapper',
+          strategy: delegation.strategy,
+          details: delegation.details
+        }
+      };
+
+      return await this.taskExecutor(taskParams);
+    }
+
+    throw new Error('Invalid task executor - must be a function');
+  }
+
+  /**
+   * Set task executor function
+   */
+  setTaskExecutor(executor) {
+    if (typeof executor !== 'function') {
+      throw new Error('Task executor must be a function');
+    }
+    this.taskExecutor = executor;
+    console.log(chalk.green('✅ Task executor configured'));
+  }
+
+  /**
+   * Get execution statistics
+   */
+  getStats() {
+    const total = this.successCount + this.failureCount;
+    const successRate = total > 0
+      ? (this.successCount / total * 100).toFixed(2)
+      : 0;
+
+    const avgExecutionTime = this.executionLog.length > 0
+      ? this.executionLog.reduce((sum, entry) => sum + entry.executionTime, 0) / this.executionLog.length
+      : 0;
+
+    return {
+      total,
+      successCount: this.successCount,
+      failureCount: this.failureCount,
+      successRate: parseFloat(successRate),
+      avgExecutionTime: Math.round(avgExecutionTime),
+      recentExecutions: this.executionLog.slice(-10)
+    };
+  }
+
+  /**
+   * Print execution report
+   */
+  printReport() {
+    const stats = this.getStats();
+
+    console.log(chalk.blue('\n📊 TASK AGENT WORKER REPORT'));
+    console.log(chalk.dim('═'.repeat(60)));
+    console.log(chalk.white(`Total Delegations: ${chalk.magenta(stats.total)}`));
+    console.log(chalk.white(`Successful: ${chalk.green(stats.successCount)}`));
+    console.log(chalk.white(`Failed: ${chalk.red(stats.failureCount)}`));
+    console.log(chalk.white(`Success Rate: ${chalk.cyan(stats.successRate + '%')}`));
+    console.log(chalk.white(`Avg Execution Time: ${chalk.yellow(stats.avgExecutionTime + 'ms')}`));
+    console.log(chalk.dim('═'.repeat(60)));
+
+    if (stats.recentExecutions.length > 0) {
+      console.log(chalk.white('\nRecent Delegations:'));
+      stats.recentExecutions.forEach((exec, i) => {
+        const status = exec.success ? chalk.green('✓') : chalk.red('✗');
+        const time = chalk.dim(`${exec.executionTime}ms`);
+        const tool = exec.delegation.originalTool;
+        console.log(`  ${status} ${tool} - ${time}`);
+      });
+    }
+  }
+
+  /**
+   * Get execution log
+   */
+  getLog(limit = 20) {
+    return this.executionLog.slice(-limit);
+  }
+
+  /**
+   * Reset worker state
+   */
+  reset() {
+    this.executionLog = [];
+    this.successCount = 0;
+    this.failureCount = 0;
+    console.log(chalk.green('✅ Task Agent Worker reset'));
+  }
+}
+
+// Singleton instance
+const taskWorker = new TaskAgentWorker();
+
+export default taskWorker;
+
+/**
+ * INTEGRATION EXAMPLE:
+ *
+ * import taskWorker from '@cpretzinger/boss-claude/lib/task-agent-worker.js';
+ *
+ * // Configure task executor
+ * taskWorker.setTaskExecutor(async (taskParams) => {
+ *   // Your Task tool implementation
+ *   return await executeTaskTool(taskParams);
+ * });
+ *
+ * // Execute delegation
+ * const delegation = {
+ *   description: 'Read config file',
+ *   originalTool: 'Read',
+ *   originalParams: { file_path: '/path/to/config.json' },
+ *   strategy: 'ONYX_AUTO_DELEGATE'
+ * };
+ *
+ * const result = await taskWorker.executeDelegation(delegation);
+ *
+ * // Print report
+ * taskWorker.printReport();
+ */

package/lib/token-monitor.js

@@ -0,0 +1,466 @@
+import chalk from 'chalk';
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import os from 'os';
+
+const BOSS_DIR = join(os.homedir(), '.boss-claude');
+const MONITOR_LOG = join(BOSS_DIR, 'delegation-violations.log');
+const SESSION_FILE = join(BOSS_DIR, 'current-session.json');
+
+/**
+ * REAL-TIME TOKEN MONITOR
+ *
+ * Screams "DELEGATION VIOLATION" if ONYX (Boss Claude) burns >100 tokens
+ * without using Task tool delegation.
+ *
+ * RULES:
+ * - Boss Claude (ONYX) must delegate tasks >100 tokens to Task tool
+ * - Task tool is the primary worker agent for comprehensive searches
+ * - Violations are logged and displayed in real-time
+ * - Session tracking persists across conversation turns
+ */
+
+export class TokenMonitor {
+  constructor() {
+    this.threshold = 100;
+    this.sessionTokens = 0;
+    this.lastDelegation = null;
+    this.violations = [];
+    this.operations = [];
+    this.sessionStartTime = new Date();
+
+    // Load existing session if available
+    this._loadSession();
+  }
+
+  /**
+   * Start tracking an operation
+   * @param {string} operation - Operation description
+   * @param {number} estimatedTokens - Estimated token cost
+   * @returns {string} Operation ID
+   */
+  startOperation(operation, estimatedTokens = 0) {
+    const opId = `op_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+
+    const op = {
+      id: opId,
+      operation,
+      estimatedTokens,
+      startTime: new Date().toISOString(),
+      actualTokens: 0,
+      delegated: false,
+      delegationTool: null,
+      completed: false
+    };
+
+    this.operations.push(op);
+
+    console.log(chalk.cyan(`\n📊 TOKEN MONITOR: Starting operation "${operation}"`));
+    console.log(chalk.dim(`Estimated tokens: ${estimatedTokens}`));
+
+    if (estimatedTokens > this.threshold) {
+      console.log(chalk.yellow(`⚠️  WARNING: Operation exceeds ${this.threshold} token threshold`));
+      console.log(chalk.yellow(`💡 RECOMMENDATION: Delegate to Task tool for comprehensive work`));
+    }
+
+    return opId;
+  }
+
+  /**
+   * Record delegation to Task tool or other agents
+   * @param {string} opId - Operation ID
+   * @param {string} tool - Tool name (e.g., 'Task', 'Agent', etc.)
+   */
+  recordDelegation(opId, tool = 'Task') {
+    const op = this.operations.find(o => o.id === opId);
+
+    if (!op) {
+      console.error(chalk.red(`❌ Operation ${opId} not found`));
+      return;
+    }
+
+    op.delegated = true;
+    op.delegationTool = tool;
+    op.delegationTime = new Date().toISOString();
+    this.lastDelegation = new Date();
+
+    console.log(chalk.green(`✅ Delegation recorded: ${tool}`));
+    this._saveSession();
+  }
+
+  /**
+   * Update actual token usage for an operation
+   * @param {string} opId - Operation ID
+   * @param {number} tokensUsed - Actual tokens consumed
+   */
+  addTokens(opId, tokensUsed) {
+    const op = this.operations.find(o => o.id === opId);
+
+    if (!op) {
+      console.error(chalk.red(`❌ Operation ${opId} not found`));
+      return;
+    }
+
+    op.actualTokens += tokensUsed;
+    this.sessionTokens += tokensUsed;
+
+    // Check for violation
+    if (!op.delegated && op.actualTokens > this.threshold) {
+      this._screamViolation(op);
+    }
+
+    this._saveSession();
+    this._displayStatus(op);
+  }
+
+  /**
+   * Complete an operation
+   * @param {string} opId - Operation ID
+   */
+  completeOperation(opId) {
+    const op = this.operations.find(o => o.id === opId);
+
+    if (!op) {
+      console.error(chalk.red(`❌ Operation ${opId} not found`));
+      return;
+    }
+
+    op.completed = true;
+    op.endTime = new Date().toISOString();
+
+    // Final violation check
+    if (!op.delegated && op.actualTokens > this.threshold) {
+      this._screamViolation(op);
+    } else if (op.delegated) {
+      console.log(chalk.green(`\n✅ Operation completed with proper delegation`));
+      console.log(chalk.dim(`Tokens used: ${op.actualTokens} | Tool: ${op.delegationTool}`));
+    }
+
+    this._saveSession();
+  }
+
+  /**
+   * SCREAM DELEGATION VIOLATION
+   * @param {Object} op - Operation object
+   */
+  _screamViolation(op) {
+    const violation = {
+      timestamp: new Date().toISOString(),
+      operation: op.operation,
+      tokensUsed: op.actualTokens,
+      threshold: this.threshold,
+      excess: op.actualTokens - this.threshold,
+      estimatedTokens: op.estimatedTokens,
+      severity: this._calculateSeverity(op.actualTokens)
+    };
+
+    this.violations.push(violation);
+
+    // SCREAM TO CONSOLE
+    console.log('\n' + chalk.bgRed.white.bold('═'.repeat(80)));
+    console.log(chalk.bgRed.white.bold('║' + ' '.repeat(78) + '║'));
+    console.log(chalk.bgRed.white.bold('║' + ' '.repeat(25) + '🚨 DELEGATION VIOLATION 🚨' + ' '.repeat(26) + '║'));
+    console.log(chalk.bgRed.white.bold('║' + ' '.repeat(78) + '║'));
+    console.log(chalk.bgRed.white.bold('═'.repeat(80)));
+
+    console.log(chalk.red.bold('\n⚠️  ONYX BURNED TOKENS WITHOUT DELEGATION'));
+    console.log(chalk.dim('─'.repeat(80)));
+    console.log(chalk.white(`Operation: ${chalk.yellow(op.operation)}`));
+    console.log(chalk.white(`Tokens Used: ${chalk.red.bold(op.actualTokens)} (Threshold: ${this.threshold})`));
+    console.log(chalk.white(`Excess: ${chalk.red.bold('+' + violation.excess + ' tokens')}`));
+    console.log(chalk.white(`Severity: ${this._getSeverityColor(violation.severity)}`));
+
+    if (op.estimatedTokens > 0) {
+      console.log(chalk.white(`Estimated: ${op.estimatedTokens} | Actual: ${op.actualTokens}`));
+      const accuracy = Math.abs(100 - (op.actualTokens / op.estimatedTokens * 100));
+      if (accuracy > 20) {
+        console.log(chalk.yellow(`⚠️  Estimation was off by ${accuracy.toFixed(1)}%`));
+      }
+    }
+
+    console.log(chalk.dim('\n' + '─'.repeat(80)));
+    console.log(chalk.red.bold('CANONICAL PROTOCOL VIOLATED:'));
+    console.log(chalk.white('  Rule: ONYX must delegate operations >100 tokens to Task tool'));
+    console.log(chalk.white('  Why: Task tool provides comprehensive search & analysis'));
+    console.log(chalk.white('  Fix: Use Task tool for multi-step operations'));
+
+    console.log(chalk.dim('\n' + '─'.repeat(80)));
+    console.log(chalk.yellow('RECOMMENDED ACTION:'));
+    console.log(chalk.white('  1. Stop current operation'));
+    console.log(chalk.white('  2. Invoke Task tool with clear instructions'));
+    console.log(chalk.white('  3. Let Task tool handle comprehensive work'));
+    console.log(chalk.dim('─'.repeat(80)) + '\n');
+
+    // Log to file
+    this._logViolation(violation);
+    this._saveSession();
+  }
+
+  /**
+   * Display current status for an operation
+   */
+  _displayStatus(op) {
+    const pct = (op.actualTokens / this.threshold * 100).toFixed(0);
+    const color = pct < 50 ? chalk.green : pct < 80 ? chalk.yellow : chalk.red;
+
+    console.log(color(`Token usage: ${op.actualTokens}/${this.threshold} (${pct}%)`));
+
+    if (!op.delegated && op.actualTokens > this.threshold * 0.8) {
+      console.log(chalk.yellow(`⚠️  Approaching threshold! Consider delegation.`));
+    }
+  }
+
+  /**
+   * Calculate severity of violation
+   */
+  _calculateSeverity(tokensUsed) {
+    const excess = tokensUsed - this.threshold;
+
+    if (excess < 100) return 'LOW';
+    if (excess < 500) return 'MEDIUM';
+    if (excess < 1000) return 'HIGH';
+    return 'CRITICAL';
+  }
+
+  /**
+   * Get colored severity indicator
+   */
+  _getSeverityColor(severity) {
+    const colors = {
+      'LOW': chalk.yellow('⚠️  LOW'),
+      'MEDIUM': chalk.orange('⚠️  MEDIUM'),
+      'HIGH': chalk.red('🚨 HIGH'),
+      'CRITICAL': chalk.bgRed.white.bold('💀 CRITICAL')
+    };
+
+    return colors[severity] || severity;
+  }
+
+  /**
+   * Log violation to file
+   */
+  _logViolation(violation) {
+    const logEntry = [
+      `[${violation.timestamp}] VIOLATION`,
+      `Operation: ${violation.operation}`,
+      `Tokens: ${violation.tokensUsed} (excess: +${violation.excess})`,
+      `Severity: ${violation.severity}`,
+      `---`
+    ].join('\n') + '\n';
+
+    try {
+      appendFileSync(MONITOR_LOG, logEntry, 'utf8');
+    } catch (err) {
+      console.error(chalk.dim(`Failed to write violation log: ${err.message}`));
+    }
+  }
+
+  /**
+   * Save session state to disk
+   */
+  _saveSession() {
+    const session = {
+      startTime: this.sessionStartTime.toISOString(),
+      sessionTokens: this.sessionTokens,
+      operations: this.operations,
+      violations: this.violations,
+      lastUpdated: new Date().toISOString()
+    };
+
+    try {
+      writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2), 'utf8');
+    } catch (err) {
+      console.error(chalk.dim(`Failed to save session: ${err.message}`));
+    }
+  }
+
+  /**
+   * Load existing session from disk
+   */
+  _loadSession() {
+    if (!existsSync(SESSION_FILE)) {
+      return;
+    }
+
+    try {
+      const data = readFileSync(SESSION_FILE, 'utf8');
+      const session = JSON.parse(data);
+
+      this.sessionStartTime = new Date(session.startTime);
+      this.sessionTokens = session.sessionTokens || 0;
+      this.operations = session.operations || [];
+      this.violations = session.violations || [];
+
+      console.log(chalk.dim(`\n📊 Resumed session from ${this.sessionStartTime.toLocaleString()}`));
+      console.log(chalk.dim(`Session tokens: ${this.sessionTokens}`));
+
+      if (this.violations.length > 0) {
+        console.log(chalk.yellow(`⚠️  ${this.violations.length} violation(s) in this session`));
+      }
+    } catch (err) {
+      console.error(chalk.dim(`Failed to load session: ${err.message}`));
+    }
+  }
+
+  /**
+   * Get session summary
+   */
+  getSessionSummary() {
+    const completedOps = this.operations.filter(o => o.completed);
+    const delegatedOps = this.operations.filter(o => o.delegated);
+    const totalTokens = this.sessionTokens;
+    const violationCount = this.violations.length;
+
+    return {
+      duration: Date.now() - this.sessionStartTime.getTime(),
+      operations: {
+        total: this.operations.length,
+        completed: completedOps.length,
+        delegated: delegatedOps.length,
+        delegationRate: (delegatedOps.length / this.operations.length * 100).toFixed(1) + '%'
+      },
+      tokens: {
+        total: totalTokens,
+        average: totalTokens / this.operations.length || 0
+      },
+      violations: {
+        count: violationCount,
+        severity: this._getViolationBreakdown()
+      },
+      compliance: violationCount === 0 ? '✅ COMPLIANT' : `❌ ${violationCount} VIOLATION(S)`
+    };
+  }
+
+  /**
+   * Display formatted session summary
+   */
+  displaySummary() {
+    const summary = this.getSessionSummary();
+
+    console.log(chalk.blue('\n═'.repeat(80)));
+    console.log(chalk.blue.bold('                      TOKEN MONITOR SESSION SUMMARY'));
+    console.log(chalk.blue('═'.repeat(80)));
+
+    console.log(chalk.white('\n📊 OPERATIONS:'));
+    console.log(chalk.dim(`  Total: ${summary.operations.total}`));
+    console.log(chalk.dim(`  Completed: ${summary.operations.completed}`));
+    console.log(chalk.dim(`  Delegated: ${summary.operations.delegated} (${summary.operations.delegationRate})`));
+
+    console.log(chalk.white('\n💰 TOKENS:'));
+    console.log(chalk.dim(`  Total: ${summary.tokens.total.toLocaleString()}`));
+    console.log(chalk.dim(`  Average: ${summary.tokens.average.toFixed(0)} per operation`));
+
+    console.log(chalk.white('\n🚨 VIOLATIONS:'));
+    if (summary.violations.count === 0) {
+      console.log(chalk.green('  ✅ No violations - COMPLIANT'));
+    } else {
+      console.log(chalk.red(`  ❌ Total: ${summary.violations.count}`));
+      Object.entries(summary.violations.severity).forEach(([severity, count]) => {
+        console.log(chalk.dim(`  ${severity}: ${count}`));
+      });
+    }
+
+    console.log(chalk.white('\n🎯 COMPLIANCE:'));
+    console.log(summary.violations.count === 0 ?
+      chalk.green.bold('  ✅ FULLY COMPLIANT') :
+      chalk.red.bold(`  ❌ ${summary.violations.count} VIOLATION(S) LOGGED`)
+    );
+
+    console.log(chalk.blue('\n═'.repeat(80)) + '\n');
+  }
+
+  /**
+   * Get breakdown of violations by severity
+   */
+  _getViolationBreakdown() {
+    const breakdown = { LOW: 0, MEDIUM: 0, HIGH: 0, CRITICAL: 0 };
+
+    this.violations.forEach(v => {
+      breakdown[v.severity]++;
+    });
+
+    return breakdown;
+  }
+
+  /**
+   * Reset session (start fresh)
+   */
+  resetSession() {
+    this.sessionTokens = 0;
+    this.operations = [];
+    this.violations = [];
+    this.sessionStartTime = new Date();
+    this.lastDelegation = null;
+
+    try {
+      if (existsSync(SESSION_FILE)) {
+        writeFileSync(SESSION_FILE, JSON.stringify({
+          startTime: this.sessionStartTime.toISOString(),
+          sessionTokens: 0,
+          operations: [],
+          violations: [],
+          lastUpdated: new Date().toISOString()
+        }, null, 2), 'utf8');
+      }
+    } catch (err) {
+      console.error(chalk.dim(`Failed to reset session: ${err.message}`));
+    }
+
+    console.log(chalk.green('\n✅ Session reset - starting fresh'));
+  }
+
+  /**
+   * Quick check: Should this operation be delegated?
+   * @param {number} estimatedTokens - Estimated token cost
+   * @returns {boolean}
+   */
+  shouldDelegate(estimatedTokens) {
+    return estimatedTokens > this.threshold;
+  }
+}
+
+// Singleton instance
+const monitor = new TokenMonitor();
+
+export default monitor;
+
+/**
+ * USAGE EXAMPLES:
+ *
+ * 1. Start an operation:
+ *    const opId = tokenMonitor.startOperation('Search codebase for patterns', 150);
+ *
+ * 2. Record delegation (if using Task tool):
+ *    tokenMonitor.recordDelegation(opId, 'Task');
+ *
+ * 3. Update tokens as work progresses:
+ *    tokenMonitor.addTokens(opId, 50);
+ *    tokenMonitor.addTokens(opId, 75);
+ *
+ * 4. Complete operation:
+ *    tokenMonitor.completeOperation(opId);
+ *
+ * 5. Display session summary:
+ *    tokenMonitor.displaySummary();
+ *
+ * 6. Check if delegation needed:
+ *    if (tokenMonitor.shouldDelegate(200)) {
+ *      // Use Task tool
+ *    }
+ *
+ * INTEGRATION WITH HIERARCHY VALIDATOR:
+ *
+ * import tokenMonitor from './token-monitor.js';
+ * import hierarchyValidator from './hierarchy-validator.js';
+ *
+ * // Before starting work
+ * const opId = tokenMonitor.startOperation('Complex analysis', 500);
+ *
+ * if (tokenMonitor.shouldDelegate(500)) {
+ *   const delegation = await hierarchyValidator.checkDelegation('Complex analysis', 500);
+ *   if (delegation.shouldDelegate) {
+ *     tokenMonitor.recordDelegation(opId, delegation.agent);
+ *     // Delegate to specialist
+ *   }
+ * }
+ */