ultra-dex 2.2.1 → 3.2.0

package/lib/commands/agents.js

@@ -4,8 +4,11 @@ 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';
+import { showAgentsTable } from '../utils/tables.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' },
@@ -23,63 +26,120 @@ export const AGENTS = [
   { name: 'refactoring', description: 'Code quality & design patterns', file: '6-specialist/refactoring.md', tier: 'Specialist' },
 ];
 
-async function readAgentPrompt(agent) {
+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 {
+    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`));
+  
+  // Format agents for the table
+  const agentsForTable = AGENTS.map(agent => ({
+    tier: agent.tier,
+    name: agent.name,
+    status: 'ready'
+  }));
+
+  if (customAgents.length > 0) {
+    customAgents.forEach(name => {
+      agentsForTable.push({
+        tier: 'Custom',
+        name: name,
+        status: 'ready'
+      });
     });
+  }
+
+  showAgentsTable(agentsForTable);
+
+  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/banner.js

@@ -1,21 +1,43 @@
-export const banner = `
-╔═══════════════════════════════════════════════════════════╗
-║                                                           ║
-║   ██╗   ██╗██╗  ████████╗██████╗  █████╗                 ║
-║   ██║   ██║██║  ╚══██╔══╝██╔══██╗██╔══██╗                ║
-║   ██║   ██║██║     ██║   ██████╔╝███████║                ║
-║   ██║   ██║██║     ██║   ██╔══██╗██╔══██║                ║
-║   ╚██████╔╝███████╗██║   ██║  ██║██║  ██║                ║
-║    ╚═════╝ ╚══════╝╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝                ║
-║                                                           ║
-║   ██████╗ ███████╗██╗  ██╗                               ║
-║   ██╔══██╗██╔════╝╚██╗██╔╝                               ║
-║   ██║  ██║█████╗   ╚███╔╝                                ║
-║   ██║  ██║██╔══╝   ██╔██╗                                ║
-║   ██████╔╝███████╗██╔╝ ██╗                               ║
-║   ╚═════╝ ╚══════╝╚═╝  ╚═╝                               ║
-║                                                           ║
-║   From Idea to Production-Ready SaaS                      ║
-║                                                           ║
-╚═══════════════════════════════════════════════════════════╝
-`;
+import gradient from 'gradient-string';
+import boxen from 'boxen';
+import chalk from 'chalk';
+
+const ultraGradient = gradient(['#6366f1', '#8b5cf6', '#d946ef']);
+
+const asciiLogo = `
+██╗   ██╗██╗  ████████╗██████╗  █████╗       ██████╗ ███████╗██╗  ██╗
+██║   ██║██║  ╚══██╔══╝██╔══██╗██╔══██╗      ██╔══██╗██╔════╝╚██╗██╔╝
+██║   ██║██║     ██║   ██████╔╝███████║█████╗██║  ██║█████╗   ╚███╔╝ 
+██║   ██║██║     ██║   ██╔══██╗██╔══██║╚════╝██║  ██║██╔══╝   ██╔██╗ 
+╚██████╔╝███████╗██║   ██║  ██║██║  ██║      ██████╔╝███████╗██╔╝ ██╗
+ ╚═════╝ ╚══════╝╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝      ╚═════╝ ╚══════╝╚═╝  ╚═╝`;
+
+export const banner = asciiLogo;
+
+export function showBanner(version = '3.2.0') {
+  console.log(ultraGradient(asciiLogo));
+  console.log(boxen(
+    `${chalk.hex('#8b5cf6').bold('🪐 Ultra-Dex')} ${chalk.dim('v' + version)}
+
+` +
+    `${chalk.hex('#6366f1')('AI Orchestration Meta-Layer')}
+
+` +
+    `${chalk.dim('github.com/Srujan0798/Ultra-Dex')}`,
+    {
+      padding: 1,
+      margin: 1,
+      borderStyle: 'round',
+      borderColor: '#8b5cf6',
+      dimBorder: true
+    }
+  ));
+}
+
+export function showCompactBanner() {
+  console.log(`  ${chalk.hex('#8b5cf6').bold('🪐 Ultra-Dex')} ${chalk.dim('v3.2.0')}`);
+}
+
+export function showWelcome() {
+  showBanner();
+}

package/lib/commands/build.js

@@ -1,213 +1,108 @@
 /**
  * ultra-dex build command
- * Auto-loads context and starts AI-assisted development
+ * 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';
+import { showProgress } from '../utils/progress.js';
+import { getRandomMessage } from '../utils/messages.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⚡ Ultra-Dex Auto-Pilot\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 API keys found.'));
+        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');
+      const state = await loadState();
+      if (!state) {
+        console.log(chalk.red('❌ No project state found. Run "ultra-dex init" first.'));
+        return;
+      }
 
-      spinner.succeed('Context loaded');
+      // Find next pending task
+      let nextTask = null;
+      let currentPhase = null;
 
-      // 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;
+      for (const phase of state.phases) {
+        const pending = phase.steps.find(s => s.status !== 'completed');
+        if (pending) {
+          nextTask = pending;
+          currentPhase = phase;
+          break;
+        }
       }
 
-      const agentConfig = AGENTS[agent];
-      if (!agentConfig) {
-        console.log(chalk.red(`Unknown agent: ${agent}`));
-        console.log(chalk.gray(`Available: ${Object.keys(AGENTS).join(', ')}`));
+      if (!nextTask) {
+        console.log(chalk.green('✅ All phases completed! The project is ready.'));
         return;
       }
 
-      // 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;
+      // Show Progress
+      showProgress([`Phase: ${currentPhase.name}`, `Target: ${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(`Activating Agent: @${agentName}`));
+
+      if (options.dryRun) {
+        console.log(chalk.yellow('\nDry run mode. Exiting.'));
+        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'));
+      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 spinner = ora(getRandomMessage('loading')).start();
+      try {
+        const result = await runAgentLoop(agentName, nextTask.task, provider, context);
+        spinner.succeed(chalk.green('Task execution completed'));
+
+        // 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'));
+      } catch (error) {
+        spinner.fail(chalk.red('Task execution failed'));
+        console.error(error);
       }
-
-      // 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'));
     });
 }