ultra-dex 2.2.0 → 3.1.0

package/lib/commands/agents.js

@@ -3,8 +3,11 @@ import fs from 'fs/promises';
 import path from 'path';
 import { ASSETS_ROOT, ROOT_FALLBACK } from '../config/paths.js';
 import { githubBlobUrl } from '../config/urls.js';
+import { readWithFallback } from '../utils/fallback.js';
+import { pathExists } from '../utils/files.js';
 
 export const AGENTS = [
+  { name: 'orchestrator', description: 'Multi-agent coordination', file: '0-orchestration/orchestrator.md', tier: 'Orchestration' },
   { name: 'cto', description: 'Architecture & tech decisions', file: '1-leadership/cto.md', tier: 'Leadership' },
   { name: 'planner', description: 'Task breakdown & planning', file: '1-leadership/planner.md', tier: 'Leadership' },
   { name: 'research', description: 'Technology evaluation & comparison', file: '1-leadership/research.md', tier: 'Leadership' },
@@ -22,67 +25,118 @@ export const AGENTS = [
   { name: 'refactoring', description: 'Code quality & design patterns', file: '6-specialist/refactoring.md', tier: 'Specialist' },
 ];
 
-async function readAgentPrompt(agent) {
-  const agentPath = path.join(ASSETS_ROOT, 'agents', agent.file);
+const CUSTOM_AGENTS_DIR = path.join(process.cwd(), '.ultra-dex', 'custom-agents');
+
+export function findBuiltInAgent(name) {
+  return AGENTS.find(a => a.name.toLowerCase() === name.toLowerCase());
+}
+
+export async function listCustomAgents() {
   try {
-    return await fs.readFile(agentPath, 'utf-8');
-  } catch (err) {
-    const fallbackPath = path.join(ROOT_FALLBACK, 'agents', agent.file);
-    return await fs.readFile(fallbackPath, 'utf-8');
+    const entries = await fs.readdir(CUSTOM_AGENTS_DIR, { withFileTypes: true });
+    return entries
+      .filter(entry => entry.isFile() && entry.name.endsWith('.md'))
+      .map(entry => entry.name.replace(/\.md$/, ''));
+  } catch {
+    return [];
+  }
+}
+
+export async function getCustomAgentPath(name) {
+  const filePath = path.join(CUSTOM_AGENTS_DIR, `${name}.md`);
+  if (await pathExists(filePath)) {
+    return filePath;
+  }
+  return null;
+}
+
+export async function readCustomAgent(name) {
+  const filePath = await getCustomAgentPath(name);
+  if (!filePath) {
+    throw new Error(`Custom agent "${name}" not found.`);
   }
+  return fs.readFile(filePath, 'utf-8');
+}
+
+export async function readAgentPrompt(agent) {
+  const agentPath = path.join(ASSETS_ROOT, 'agents', agent.file);
+  const fallbackPath = path.join(ROOT_FALLBACK, 'agents', agent.file);
+  return readWithFallback(agentPath, fallbackPath, 'utf-8');
 }
 
 export function registerAgentsCommand(program) {
-  program
+  const agents = program
     .command('agents')
     .description('List available AI agent prompts')
-    .action(() => {
-      console.log(chalk.bold('\n🤖 Ultra-Dex AI Agents (15 Total)\n'));
-      console.log(chalk.gray('Organized by tier for production pipeline\n'));
-
-      let currentTier = '';
-      AGENTS.forEach((agent) => {
-        if (agent.tier !== currentTier) {
-          currentTier = agent.tier;
-          console.log(chalk.bold(`\n  ${currentTier} Tier:`));
-        }
-        console.log(chalk.cyan(`    ${agent.name}`) + chalk.gray(` - ${agent.description}`));
-      });
-
-      console.log('\n' + chalk.bold('Usage:'));
-      console.log(chalk.gray('  ultra-dex agent <name>   Show agent prompt'));
-      console.log(chalk.gray('  ultra-dex agent backend  Example: show backend agent'));
-
-      console.log(`\n${chalk.gray(`Agent Index: ${githubBlobUrl('agents/00-AGENT_INDEX.md')}\n`)}`);
+    .action(async () => {
+      await listAgents();
     });
 
   program
-    .command('agent <name>')
-    .description('Show a specific agent prompt')
+    .command('agent [name]')
+    .description('Show a specific agent prompt or list all agents')
     .action(async (name) => {
-      const agent = AGENTS.find(a => a.name.toLowerCase() === name.toLowerCase());
-
-      if (!agent) {
-        console.log(chalk.red(`\n❌ Agent "${name}" not found.\n`));
-        console.log(chalk.gray('Available agents:'));
-        AGENTS.forEach(a => console.log(chalk.cyan(`  - ${a.name}`)));
-        console.log('\n' + chalk.gray('Run "ultra-dex agents" to see all agents.\n'));
-        process.exit(1);
+      if (!name) {
+        await listAgents();
+      } else {
+        await showAgent(name);
       }
+    });
+}
 
-      try {
-        const content = await readAgentPrompt(agent);
-        console.log(chalk.bold(`\n🤖 ${agent.name.toUpperCase()} Agent\n`));
-        console.log(chalk.gray('─'.repeat(60)));
-        console.log(content);
-        console.log(chalk.gray('─'.repeat(60)));
-        console.log(chalk.bold('\n📋 Copy the above prompt and paste into your AI tool.\n'));
-      } catch (err) {
-        console.log(chalk.bold(`\n🤖 ${agent.name.toUpperCase()} Agent\n`));
-        console.log(chalk.gray('View full prompt on GitHub:'));
-        console.log(chalk.blue(`  ${githubBlobUrl(`agents/${agent.file}`)}\n`));
-      }
+async function listAgents() {
+  const customAgents = await listCustomAgents();
+  const totalAgents = AGENTS.length + customAgents.length;
+  console.log(chalk.bold(`\n🤖 Ultra-Dex AI Agents (${totalAgents} Total)\n`));
+  console.log(chalk.gray('Organized by tier for production pipeline\n'));
+
+  let currentTier = '';
+  AGENTS.forEach((agent) => {
+    if (agent.tier !== currentTier) {
+      currentTier = agent.tier;
+      console.log(chalk.bold(`\n  ${currentTier} Tier:`));
+    }
+    console.log(chalk.cyan(`    ${agent.name}`) + chalk.gray(` - ${agent.description}`));
+  });
+
+  if (customAgents.length > 0) {
+    console.log(chalk.bold('\n  Custom Agents:'));
+    customAgents.forEach((name) => {
+      console.log(chalk.cyan(`    ${name}`));
     });
+  }
+
+  console.log('\n' + chalk.bold('Usage:'));
+  console.log(chalk.gray('  ultra-dex agent show <name>     Show agent prompt'));
+  console.log(chalk.gray('  ultra-dex pack <name>           Package agent + context'));
+
+  console.log(`\n${chalk.gray(`Agent Index: ${githubBlobUrl('agents/00-AGENT_INDEX.md')}\n`)}`);
+}
+
+async function showAgent(name) {
+  const agent = AGENTS.find(a => a.name.toLowerCase() === name.toLowerCase());
+  if (!agent) {
+    const custom = await getCustomAgentPath(name);
+    if (custom) {
+      const content = await fs.readFile(custom, 'utf-8');
+      console.log(chalk.bold(`\n🤖 Custom Agent: ${name}\n`));
+      console.log(content);
+      return;
+    }
+    console.log(chalk.red(`\n❌ Agent "${name}" not found.`));
+    return;
+  }
+
+  try {
+    const prompt = await readAgentPrompt(agent);
+    console.log(chalk.bold(`\n🤖 Agent: ${agent.name} (${agent.tier})\n`));
+    console.log(chalk.gray(agent.description) + '\n');
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(prompt);
+    console.log(chalk.gray('─'.repeat(60)));
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Could not read prompt for ${agent.name}`));
+  }
 }
 
 export function registerPackCommand(program) {

package/lib/commands/auto-implement.js

@@ -0,0 +1,68 @@
+/**
+ * ultra-dex auto-implement command
+ * Fully autonomous feature implementation (GOD MODE)
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import { updateState } from './state.js';
+import { buildGraph } from '../utils/graph.js';
+import { createProvider, getDefaultProvider } from '../providers/index.js';
+import { runAgentLoop } from './run.js';
+
+export function registerAutoImplementCommand(program) {
+  program
+    .command('auto-implement <feature>')
+    .description('Autonomous implementation: Plan -> Code -> Verify (God Mode)')
+    .option('-p, --provider <provider>', 'AI provider (defaults to router if configured)')
+    .option('--dry-run', 'Show plan without making changes')
+    .action(async (feature, options) => {
+      console.log(chalk.cyan('\n🚀 Ultra-Dex Autonomous Implementation Engine\n'));
+      console.log(chalk.bold(`Target Feature: ${feature}\n`));
+
+      const providerId = options.provider || getDefaultProvider() || 'router';
+      const provider = createProvider(providerId);
+      
+      const spinner = ora('Initializing God Mode Swarm...').start();
+
+      try {
+        // 1. Structural Awareness (CPG)
+        const graph = await buildGraph();
+        spinner.text = 'Analyzing architectural impact...';
+        
+        // 2. Planning Phase (@Planner)
+        spinner.text = '@Planner is breaking down the feature...';
+        const projectContext = {
+            context: `Feature Request: ${feature}\nCodebase Nodes: ${graph.nodes.length}\nEdges: ${graph.edges.length}`,
+            graph
+        };
+
+        const plan = await runAgentLoop('planner', `Break down this feature: ${feature}`, provider, projectContext);
+        
+        if (options.dryRun) {
+            spinner.succeed('Planning complete (Dry Run)');
+            console.log(chalk.white('\nProposed Plan:'));
+            console.log(chalk.gray(plan));
+            return;
+        }
+
+        // 3. Execution Phase (@Backend/@Frontend)
+        spinner.text = 'Agents are implementing code...';
+        await runAgentLoop('orchestrator', `Coordinate the implementation of this plan:\n${plan}`, provider, projectContext);
+
+        // 4. Verification Phase (@Testing)
+        spinner.text = '@Testing is verifying changes...';
+        const verification = await runAgentLoop('testing', `Verify the implementation of: ${feature}`, provider, projectContext);
+
+        // 5. Finalize
+        await updateState();
+        spinner.succeed(chalk.green('Feature implemented autonomously!'));
+        
+        console.log(chalk.bold('\nFinal Report:'));
+        console.log(chalk.gray(verification));
+
+      } catch (e) {
+        spinner.fail(chalk.red(`Auto-Implementation failed: ${e.message}`));
+      }
+    });
+}

package/lib/commands/build.js

@@ -1,214 +1,100 @@
 /**
- * ultra-dex build command
- * Auto-loads context and starts AI-assisted development
+ * ultra-dex build command (GOD MODE)
+ * Auto-Pilot: Finds the next pending task and executes it using Agents.
  */
 
 import chalk from 'chalk';
 import ora from 'ora';
-import inquirer from 'inquirer';
 import fs from 'fs/promises';
 import path from 'path';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-
-const execAsync = promisify(exec);
-
-// Agent configurations
-const AGENTS = {
-  planner: { name: '@Planner', tier: 'Leadership', task: 'Break down features into atomic tasks' },
-  cto: { name: '@CTO', tier: 'Leadership', task: 'Architecture decisions' },
-  backend: { name: '@Backend', tier: 'Development', task: 'API endpoints and business logic' },
-  frontend: { name: '@Frontend', tier: 'Development', task: 'UI components and pages' },
-  database: { name: '@Database', tier: 'Development', task: 'Schema design and migrations' },
-  auth: { name: '@Auth', tier: 'Security', task: 'Authentication and authorization' },
-  security: { name: '@Security', tier: 'Security', task: 'Security audit' },
-  testing: { name: '@Testing', tier: 'Quality', task: 'Write and run tests' },
-  reviewer: { name: '@Reviewer', tier: 'Quality', task: 'Code review' },
-  devops: { name: '@DevOps', tier: 'DevOps', task: 'Deployment and CI/CD' },
-};
-
-async function readFileSafe(filePath) {
-  try {
-    return await fs.readFile(filePath, 'utf-8');
-  } catch {
-    return null;
-  }
-}
-
-async function fileExists(filePath) {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
+import { loadState } from './plan.js';
+import { runAgentLoop } from './run.js';
+import { createProvider, getDefaultProvider, checkConfiguredProviders } from '../providers/index.js';
+
+async function readProjectContext() {
+  const context = {};
+  try { context.plan = await fs.readFile('IMPLEMENTATION-PLAN.md', 'utf8'); } catch { context.plan = null; }
+  try { context.context = await fs.readFile('CONTEXT.md', 'utf8'); } catch { context.context = null; }
+  context.state = await loadState();
+  return context;
 }
 
 export function registerBuildCommand(program) {
   program
     .command('build')
-    .description('Start AI-assisted development with auto-loaded context')
-    .option('-a, --agent <agent>', 'Agent to use (planner, backend, frontend, etc.)')
-    .option('-t, --task <task>', 'Specific task to work on')
-    .option('--copy', 'Copy prompt to clipboard instead of displaying')
-    .option('--cursor', 'Open in Cursor IDE')
+    .description('Auto-Pilot: Execute the next pending task from the plan')
+    .option('-p, --provider <provider>', 'AI provider')
+    .option('-k, --key <apiKey>', 'API key')
+    .option('--dry-run', 'Preview the task without executing')
     .action(async (options) => {
-      console.log(chalk.cyan('\n🔧 Ultra-Dex Build Mode\n'));
-
-      // Check for required files
-      const hasContext = await fileExists('CONTEXT.md');
-      const hasPlan = await fileExists('IMPLEMENTATION-PLAN.md');
-      const hasQuickStart = await fileExists('QUICK-START.md');
-
-      if (!hasContext && !hasPlan) {
-        console.log(chalk.yellow('⚠️  No Ultra-Dex project found in current directory.\n'));
-        console.log(chalk.white('Run one of these first:'));
-        console.log(chalk.gray('  npx ultra-dex init      # Create from template'));
-        console.log(chalk.gray('  npx ultra-dex generate  # Generate from idea\n'));
+      console.log(chalk.cyan('\n\u{1F30B}  Ultra-Dex Auto-Pilot (Build Mode)\n'));
+
+      // Check for API key
+      const configured = checkConfiguredProviders();
+      const hasProvider = configured.some(p => p.configured) || options.key;
+
+      if (!hasProvider && !options.dryRun) {
+        console.log(chalk.yellow('⚠️  No AI provider configured.'));
+        console.log(chalk.white('Set an API key to enable Auto-Pilot.'));
         return;
       }
 
-      // Load context files
-      const spinner = ora('Loading project context...').start();
-
-      const context = await readFileSafe('CONTEXT.md');
-      const plan = await readFileSafe('IMPLEMENTATION-PLAN.md');
-      const quickStart = await readFileSafe('QUICK-START.md');
-
-      spinner.succeed('Context loaded');
-
-      // Select agent if not provided
-      let agent = options.agent;
-      if (!agent) {
-        const { selectedAgent } = await inquirer.prompt([
-          {
-            type: 'list',
-            name: 'selectedAgent',
-            message: 'Select an agent:',
-            choices: [
-              new inquirer.Separator('── Leadership ──'),
-              { name: '📋 @Planner - Break down tasks', value: 'planner' },
-              { name: '🏗️  @CTO - Architecture decisions', value: 'cto' },
-              new inquirer.Separator('── Development ──'),
-              { name: '⚙️  @Backend - API endpoints', value: 'backend' },
-              { name: '🎨 @Frontend - UI components', value: 'frontend' },
-              { name: '🗄️  @Database - Schema design', value: 'database' },
-              new inquirer.Separator('── Security ──'),
-              { name: '🔐 @Auth - Authentication', value: 'auth' },
-              { name: '🛡️  @Security - Security audit', value: 'security' },
-              new inquirer.Separator('── Quality ──'),
-              { name: '🧪 @Testing - Write tests', value: 'testing' },
-              { name: '👁️  @Reviewer - Code review', value: 'reviewer' },
-              new inquirer.Separator('── DevOps ──'),
-              { name: '🚀 @DevOps - Deployment', value: 'devops' },
-            ],
-          },
-        ]);
-        agent = selectedAgent;
+      const state = await loadState();
+      if (!state) {
+        console.log(chalk.red('❌ No state found. Run "ultra-dex init" first.'));
+        return;
       }
 
-      const agentConfig = AGENTS[agent];
-      if (!agentConfig) {
-        console.log(chalk.red(`Unknown agent: ${agent}`));
-        console.log(chalk.gray(`Available: ${Object.keys(AGENTS).join(', ')}`));
-        return;
+      // Find next pending task
+      let nextTask = null;
+      let currentPhase = null;
+
+      for (const phase of state.phases) {
+        const pending = phase.steps.find(s => s.status !== 'completed');
+        if (pending) {
+          nextTask = pending;
+          currentPhase = phase;
+          break;
+        }
       }
 
-      // Get task if not provided
-      let task = options.task;
-      if (!task) {
-        const { taskInput } = await inquirer.prompt([
-          {
-            type: 'input',
-            name: 'taskInput',
-            message: `What should ${agentConfig.name} do?`,
-            default: agentConfig.task,
-          },
-        ]);
-        task = taskInput;
+      if (!nextTask) {
+        console.log(chalk.green('✅ All phases completed! You are ready to launch.'));
+        return;
       }
 
-      // Build the prompt
-      const contextSection = context ? `## Project Context\n${context}\n` : '';
-      const planSection = plan ? `## Implementation Plan (Summary)\n${plan.slice(0, 8000)}...\n[Full plan in IMPLEMENTATION-PLAN.md]\n` : '';
-
-      const prompt = `# ${agentConfig.name} Agent Session
-
-You are acting as ${agentConfig.name} for this project.
-
-${contextSection}
-${planSection}
-
-## Your Task
-${task}
-
-## Instructions
-1. Read the context and plan carefully
-2. Focus ONLY on your assigned task
-3. Follow Ultra-Dex 21-step verification for any code changes
-4. Document your work in a way the next agent can continue
-
-## Output Format
-- For code: Include full file paths and production-ready code
-- For plans: Use atomic tasks (4-9 hours each)
-- For reviews: Use severity levels (critical, warning, info)
-
-Begin working on: ${task}
-`;
-
-      // Output the prompt
-      console.log(chalk.green(`\n✅ ${agentConfig.name} prompt ready\n`));
-
-      if (options.copy) {
-        // Copy to clipboard
-        try {
-          const platform = process.platform;
-          if (platform === 'darwin') {
-            await execAsync(`echo ${JSON.stringify(prompt)} | pbcopy`);
-          } else if (platform === 'linux') {
-            await execAsync(`echo ${JSON.stringify(prompt)} | xclip -selection clipboard`);
-          } else if (platform === 'win32') {
-            await execAsync(`echo ${JSON.stringify(prompt)} | clip`);
-          }
-          console.log(chalk.cyan('📋 Prompt copied to clipboard!'));
-          console.log(chalk.gray('Paste into your AI tool (Cursor, Claude, ChatGPT)\n'));
-        } catch {
-          console.log(chalk.yellow('Could not copy to clipboard. Displaying prompt instead:\n'));
-          console.log(chalk.gray('─'.repeat(60)));
-          console.log(prompt);
-          console.log(chalk.gray('─'.repeat(60)));
-        }
-      } else if (options.cursor) {
-        // Save prompt and open Cursor
-        const promptPath = path.join('.ultra-dex', 'current-prompt.md');
-        await fs.mkdir('.ultra-dex', { recursive: true });
-        await fs.writeFile(promptPath, prompt);
-
-        console.log(chalk.gray(`Prompt saved to: ${promptPath}`));
-        console.log(chalk.cyan('Opening Cursor...\n'));
-
-        try {
-          await execAsync('cursor .');
-        } catch {
-          console.log(chalk.yellow('Could not open Cursor. Is it installed?'));
-          console.log(chalk.gray('Install: https://cursor.sh'));
-        }
-      } else {
-        // Display the prompt
-        console.log(chalk.gray('─'.repeat(60)));
-        console.log(prompt);
-        console.log(chalk.gray('─'.repeat(60)));
-
-        console.log(chalk.cyan('\n📋 Copy this prompt into your AI tool'));
-        console.log(chalk.gray('Or use --copy to copy to clipboard\n'));
+      console.log(chalk.bold(`Phase: ${currentPhase.name}`));
+      console.log(chalk.bold(`Task:  ${nextTask.task}`));
+
+      // Heuristic to pick agent (naive)
+      let agentName = 'backend'; // default
+      const taskLower = nextTask.task.toLowerCase();
+      if (taskLower.includes('ui') || taskLower.includes('component') || taskLower.includes('page')) agentName = 'frontend';
+      if (taskLower.includes('db') || taskLower.includes('schema') || taskLower.includes('database')) agentName = 'database';
+      if (taskLower.includes('plan') || taskLower.includes('break down')) agentName = 'planner';
+      if (taskLower.includes('test')) agentName = 'testing';
+      
+      console.log(chalk.gray(`Selected Agent: @${agentName}`));
+
+      if (options.dryRun) {
+        console.log(chalk.yellow('\nDry run mode. Exiting.'));
+        return;
       }
 
-      // Show next steps
-      console.log(chalk.white('Tips:'));
-      console.log(chalk.gray('  • Paste the prompt into Cursor, Claude, or ChatGPT'));
-      console.log(chalk.gray('  • Use "npx ultra-dex serve" for MCP-compatible context'));
-      console.log(chalk.gray('  • Run "npx ultra-dex review" after making changes\n'));
+      const providerId = options.provider || getDefaultProvider();
+      const provider = createProvider(providerId, { apiKey: options.key, maxTokens: 8000 });
+      const context = await readProjectContext();
+
+      console.log(chalk.gray('─'.repeat(50)));
+      
+      const result = await runAgentLoop(agentName, nextTask.task, provider, context);
+
+      // Save output
+      const filename = `task-${nextTask.id}-${agentName}.md`;
+      await fs.writeFile(filename, result);
+      console.log(chalk.green(`\n✅ Task output saved to ${filename}`));
+      console.log(chalk.gray('Review the code and mark the task as completed in .ultra/state.json'));
     });
 }
 
-export default { registerBuildCommand };
+export default { registerBuildCommand };

package/lib/commands/ci-monitor.js

@@ -0,0 +1,84 @@
+/**
+ * ultra-dex ci-monitor command
+ * Self-healing CI/CD pipeline monitor (The Autonomic Nervous System)
+ */
+
+import chalk from 'chalk';
+import http from 'http';
+import { createProvider, getDefaultProvider } from '../providers/index.js';
+import { runAgentLoop } from './run.js';
+import { buildGraph } from '../utils/graph.js';
+
+export function registerCiMonitorCommand(program) {
+  program
+    .command('ci-monitor')
+    .description('Start the Self-Healing CI/CD Webhook Listener')
+    .option('-p, --port <port>', 'Webhook port', '3003')
+    .option('--provider <provider>', 'AI provider for fixes')
+    .action(async (options) => {
+      const port = parseInt(options.port);
+      console.log(chalk.cyan('\n🛡️  Ultra-Dex Self-Healing CI Monitor\n'));
+      console.log(chalk.gray(`Listening for GitHub Webhooks on port ${port}...`));
+
+      const server = http.createServer(async (req, res) => {
+        if (req.method === 'POST') {
+          let body = '';
+          req.on('data', chunk => { body += chunk.toString(); });
+          req.on('end', async () => {
+            try {
+              const payload = JSON.parse(body);
+              
+              // Filter for Workflow Failures
+              // (Simplification: Assuming GitHub Actions payload structure)
+              if (payload.action === 'completed' && payload.workflow_job?.conclusion === 'failure') {
+                await handleBuildFailure(payload, options);
+              }
+
+              res.writeHead(200);
+              res.end('Received');
+            } catch (e) {
+              console.error(chalk.red('Webhook Error:'), e.message);
+              res.writeHead(400);
+              res.end('Bad Request');
+            }
+          });
+        } else {
+          res.writeHead(404);
+          res.end();
+        }
+      });
+
+      server.listen(port, () => {
+        console.log(chalk.green(`✅ Monitor Active: http://localhost:${port}`));
+      });
+    });
+}
+
+async function handleBuildFailure(payload, options) {
+    const jobName = payload.workflow_job.name;
+    const repo = payload.repository.full_name;
+    const logs = "Mock Log: Error: Cannot find module './utils/graph.js'"; // Real imp would fetch logs via API
+
+    console.log(chalk.red(`\n🚨 Build Failed: ${jobName} in ${repo}`));
+    console.log(chalk.yellow('   Initiating Self-Healing Protocol...'));
+
+    const providerId = options.provider || getDefaultProvider() || 'router';
+    const provider = createProvider(providerId);
+
+    // 1. Analyze Context (CPG)
+    const graph = await buildGraph();
+    const context = {
+        context: `Build Failure Log:\n${logs}\n\nRepository: ${repo}`,
+        graph
+    };
+
+    // 2. Diagnose & Fix (@Debugger)
+    const fixPlan = await runAgentLoop('debugger', `Analyze this build failure and propose a fix:\n${logs}`, provider, context);
+    
+    // 3. Apply Fix (Mock - would be git push)
+    console.log(chalk.bold('\nProposed Fix:'));
+    console.log(chalk.gray(fixPlan));
+    
+    // In a real system, we would:
+    // await runAgentLoop('devops', `Apply this fix and push to branch 'fix/${jobName}':\n${fixPlan}`, provider, context);
+}