agentic-kdd 2.0.7 → 2.1.1

package/src/init.js

@@ -10,80 +10,224 @@ const inquirer = require('inquirer');
 const GITHUB_REPO = 'Adrianlpz211/Agentic-KDD';
 const TEMP_DIR = path.join(require('os').tmpdir(), 'agentic-kdd-download');
 
-// ── Detectar stack ─────────────────────────────────────────────
+// ── Plantillas por stack ────────────────────────────────────────
+const TEMPLATES = {
+  nextjs: {
+    nombre: 'Next.js App',
+    tipo: 'NUEVO',
+    modulos_impl: [
+      '| 1 | Auth y middleware | /login, /registro, middleware.ts |',
+      '| 2 | Layout y navegación | app/layout.tsx, componentes nav |',
+    ],
+    modulos_pend: [
+      '- [ ] Dashboard principal',
+      '- [ ] Módulo de usuarios',
+      '- [ ] API routes principales',
+    ],
+    reglas: [
+      '- App Router (no Pages Router)',
+      '- Server Components por defecto, Client Components solo cuando necesario',
+      '- Queries de base de datos solo en lib/queries/',
+      '- Tailwind CSS para estilos',
+      '- TypeScript estricto',
+    ],
+    descripcion: 'Aplicación web con Next.js 14 App Router, TypeScript y Tailwind CSS.',
+  },
+  laravel: {
+    nombre: 'Laravel App',
+    tipo: 'NUEVO',
+    modulos_impl: [
+      '| 1 | Auth y roles | routes/auth.php, AuthController |',
+      '| 2 | Modelos base | app/Models/, migraciones |',
+    ],
+    modulos_pend: [
+      '- [ ] Panel de administración',
+      '- [ ] API REST principal',
+      '- [ ] Jobs y queues',
+    ],
+    reglas: [
+      '- Lógica de negocio en Services, no en Controllers',
+      '- Queries complejas en Repositories',
+      '- Form Requests para validación',
+      '- Resources para transformar respuestas API',
+      '- Jobs para procesos en background',
+    ],
+    descripcion: 'Aplicación web con Laravel, MySQL y arquitectura MVC.',
+  },
+  node: {
+    nombre: 'Node.js API',
+    tipo: 'NUEVO',
+    modulos_impl: [
+      '| 1 | Servidor y configuración | index.js, config/, middleware |',
+      '| 2 | Auth JWT | routes/auth.js, middleware/auth.js |',
+    ],
+    modulos_pend: [
+      '- [ ] Endpoints principales',
+      '- [ ] Base de datos y modelos',
+      '- [ ] Tests de integración',
+    ],
+    reglas: [
+      '- Express con middleware centralizado',
+      '- Lógica en services/, no en routes',
+      '- Variables de entorno en .env, nunca hardcoded',
+      '- Manejo de errores centralizado',
+    ],
+    descripcion: 'API REST con Node.js, Express y base de datos.',
+  },
+  react: {
+    nombre: 'React App',
+    tipo: 'NUEVO',
+    modulos_impl: [
+      '| 1 | Estructura base | App.tsx, router, layout |',
+      '| 2 | Estado global | context o zustand |',
+    ],
+    modulos_pend: [
+      '- [ ] Componentes principales',
+      '- [ ] Integración con API',
+      '- [ ] Tests de componentes',
+    ],
+    reglas: [
+      '- Componentes funcionales con hooks',
+      '- Estado local con useState, global con Context/Zustand',
+      '- Llamadas API centralizadas en services/',
+      '- CSS Modules o Tailwind, no inline styles',
+    ],
+    descripcion: 'Aplicación React con TypeScript y gestión de estado.',
+  },
+  php: {
+    nombre: 'PHP App',
+    tipo: 'NUEVO',
+    modulos_impl: [
+      '| 1 | Configuración base | config.php, conexión DB |',
+      '| 2 | Auth | login.php, session |',
+    ],
+    modulos_pend: [
+      '- [ ] Módulo principal',
+      '- [ ] Panel de administración',
+    ],
+    reglas: [
+      '- Queries preparadas siempre (PDO)',
+      '- Validación en el servidor',
+      '- Sin lógica en las vistas',
+    ],
+    descripcion: 'Aplicación PHP con MySQL.',
+  },
+  python: {
+    nombre: 'Python App',
+    tipo: 'NUEVO',
+    modulos_impl: [
+      '| 1 | Estructura base | main.py, config.py |',
+      '| 2 | Auth | auth/, middleware |',
+    ],
+    modulos_pend: [
+      '- [ ] Endpoints principales',
+      '- [ ] Base de datos',
+      '- [ ] Tests',
+    ],
+    reglas: [
+      '- FastAPI o Django según el proyecto',
+      '- Pydantic para validación',
+      '- SQLAlchemy para queries',
+      '- pytest para tests',
+    ],
+    descripcion: 'Aplicación Python con FastAPI/Django.',
+  },
+};
+
+// ── Detectar stack ──────────────────────────────────────────────
 function detectStack(projectPath) {
   const stack = {
-    framework: '—',
-    language: '—',
-    packageManager: 'npm',
-    commands: {
-      install: 'npm install',
-      dev: 'npm run dev',
-      build: 'npm run build',
-      test: 'npm test',
-      lint: 'npm run lint'
-    }
+    framework: '—', language: '—', runtime: '—',
+    base_datos: '—', packageManager: 'npm',
+    templateKey: null,
+    commands: { install: 'npm install', dev: 'npm run dev', build: 'npm run build', test: 'npm test', lint: 'npm run lint' }
   };
 
   if (fs.existsSync(path.join(projectPath, 'package.json'))) {
     const pkg = fs.readJsonSync(path.join(projectPath, 'package.json'), { throws: false }) || {};
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-    stack.language = 'TypeScript/JavaScript';
+    stack.language = deps['typescript'] ? 'TypeScript' : 'JavaScript';
+    stack.runtime = 'Node.js';
 
     if (fs.existsSync(path.join(projectPath, 'pnpm-lock.yaml'))) {
       stack.packageManager = 'pnpm';
       stack.commands = { install: 'pnpm install', dev: 'pnpm dev', build: 'pnpm build', test: 'pnpm test', lint: 'pnpm lint' };
     } else if (fs.existsSync(path.join(projectPath, 'yarn.lock'))) {
       stack.packageManager = 'yarn';
-      stack.commands = { install: 'yarn install', dev: 'yarn dev', build: 'yarn build', test: 'yarn test', lint: 'yarn lint' };
+      stack.commands = { install: 'yarn', dev: 'yarn dev', build: 'yarn build', test: 'yarn test', lint: 'yarn lint' };
     }
 
-    if (deps['next']) stack.framework = `Next.js ${deps['next'].replace('^','')}`;
-    else if (deps['vue']) stack.framework = `Vue ${deps['vue'].replace('^','')}`;
-    else if (deps['react']) stack.framework = `React`;
-    else if (deps['express']) stack.framework = `Express`;
-    else if (deps['@nestjs/core']) stack.framework = `NestJS`;
+    if (deps['next']) {
+      stack.framework = `Next.js ${(deps['next']||'').replace(/[\^~]/,'')}`;
+      stack.templateKey = 'nextjs';
+      if (deps['@supabase/supabase-js']) stack.base_datos = 'Supabase PostgreSQL';
+      else if (deps['prisma'] || deps['@prisma/client']) stack.base_datos = 'Prisma';
+      else if (deps['mongoose']) stack.base_datos = 'MongoDB';
+    } else if (deps['vue']) {
+      stack.framework = `Vue ${(deps['vue']||'').replace(/[\^~]/,'')}`;
+    } else if (deps['react'] && !deps['next']) {
+      stack.framework = 'React';
+      stack.templateKey = 'react';
+    } else if (deps['express']) {
+      stack.framework = 'Express';
+      stack.templateKey = 'node';
+      stack.commands.dev = pkg.scripts?.dev || 'node index.js';
+    } else if (deps['fastify']) {
+      stack.framework = 'Fastify';
+      stack.templateKey = 'node';
+    } else if (deps['@nestjs/core']) {
+      stack.framework = 'NestJS';
+      stack.templateKey = 'node';
+      stack.commands.dev = 'npm run start:dev';
+    }
   }
 
   if (fs.existsSync(path.join(projectPath, 'composer.json'))) {
-    stack.language = 'PHP';
+    const composer = fs.readJsonSync(path.join(projectPath, 'composer.json'), { throws: false }) || {};
+    stack.language = 'PHP'; stack.runtime = 'PHP';
     stack.packageManager = 'composer';
     stack.commands = { install: 'composer install', dev: 'php artisan serve', build: 'composer build', test: './vendor/bin/phpunit', lint: 'composer lint' };
-    const composer = fs.readJsonSync(path.join(projectPath, 'composer.json'), { throws: false }) || {};
-    if ((composer.require || {})['laravel/framework']) stack.framework = 'Laravel';
-    else stack.framework = 'PHP';
+    if ((composer.require || {})['laravel/framework']) {
+      stack.framework = `Laravel ${((composer.require||{})['laravel/framework']||'').replace(/[\^~]/,'')}`;
+      stack.templateKey = 'laravel';
+    } else {
+      stack.framework = 'PHP';
+      stack.templateKey = 'php';
+    }
   }
 
   if (fs.existsSync(path.join(projectPath, 'pyproject.toml')) ||
       fs.existsSync(path.join(projectPath, 'requirements.txt'))) {
-    stack.language = 'Python';
+    stack.language = 'Python'; stack.runtime = 'Python';
     stack.packageManager = 'pip';
+    stack.templateKey = 'python';
     stack.commands = { install: 'pip install -r requirements.txt', dev: 'uvicorn main:app --reload', build: 'pip install -e .', test: 'pytest', lint: 'flake8' };
-    stack.framework = 'Python';
+    if (fs.existsSync(path.join(projectPath, 'pyproject.toml'))) {
+      const toml = fs.readFileSync(path.join(projectPath, 'pyproject.toml'), 'utf8');
+      if (toml.includes('fastapi')) { stack.framework = 'FastAPI'; }
+      else if (toml.includes('django')) { stack.framework = 'Django'; }
+      else { stack.framework = 'Python'; }
+    }
   }
 
   return stack;
 }
 
-// ── Detectar si el proyecto tiene contenido ────────────────────
+// ── Detectar si el proyecto tiene contenido ─────────────────────
 function detectProjectState(projectPath) {
   const hasCode = fs.existsSync(path.join(projectPath, 'src')) ||
                   fs.existsSync(path.join(projectPath, 'app')) ||
                   fs.existsSync(path.join(projectPath, 'pages')) ||
                   fs.existsSync(path.join(projectPath, 'api'));
-
   const hasKnowledge = fs.existsSync(path.join(projectPath, '.agentic', 'conocimiento')) &&
-    fs.readdirSync(path.join(projectPath, '.agentic', 'conocimiento'))
-      .filter(f => f !== 'README.md').length > 0;
-
+    fs.readdirSync(path.join(projectPath, '.agentic', 'conocimiento')).filter(f => f !== 'README.md').length > 0;
   const hasPackageFile = fs.existsSync(path.join(projectPath, 'package.json')) ||
                          fs.existsSync(path.join(projectPath, 'composer.json')) ||
                          fs.existsSync(path.join(projectPath, 'pyproject.toml'));
-
   return { hasCode, hasKnowledge, hasPackageFile };
 }
 
-// ── Descargar desde GitHub ─────────────────────────────────────
+// ── Descargar desde GitHub ──────────────────────────────────────
 async function downloadFromGitHub(spinner) {
   const tmpFile = path.join(require('os').tmpdir(), 'agentic-kdd.tar.gz');
   try {
@@ -97,41 +241,31 @@ async function downloadFromGitHub(spinner) {
   }
 }
 
-// ── Copiar archivos al proyecto ────────────────────────────────
+// ── Copiar archivos al proyecto ─────────────────────────────────
 function copyAgenticFiles(sourcePath, projectPath) {
-  const files = ['CLAUDE.md', '_LOCKS.md', '_output', 'docs', '.cursor'];
-
+  const files = ['CLAUDE.md', '_LOCKS.md', '.cursorrules', 'dashboard.cjs', 'docs', '.cursor', '.audit'];
   for (const file of files) {
     const src = path.join(sourcePath, file);
     const dest = path.join(projectPath, file);
     if (fs.existsSync(src)) fs.copySync(src, dest, { overwrite: true });
   }
 
-  // .agentic — copiar agentes y estructura pero NO sobreescribir memoria si existe
   const agSrc = path.join(sourcePath, '.agentic');
   const agDest = path.join(projectPath, '.agentic');
 
   if (fs.existsSync(agSrc)) {
-    // Agentes siempre se actualizan
     fs.copySync(path.join(agSrc, 'agentes'), path.join(agDest, 'agentes'), { overwrite: true });
+    fs.copySync(path.join(agSrc, 'grafo'), path.join(agDest, 'grafo'), { overwrite: true });
+    fs.ensureDirSync(path.join(agDest, 'specs'));
+    fs.ensureDirSync(path.join(projectPath, '_output'));
 
-    // Memoria y config solo si no existen
     const memorySrc = path.join(agSrc, 'memoria');
     const memoryDest = path.join(agDest, 'memoria');
     if (!fs.existsSync(memoryDest)) fs.copySync(memorySrc, memoryDest);
 
-    const configDest = path.join(agDest, 'config.md');
-    if (!fs.existsSync(configDest)) {
-      fs.copySync(path.join(agSrc, 'config.md'), configDest);
-    }
-
-    // PLAN.md solo si no existe
     const planDest = path.join(agDest, 'PLAN.md');
-    if (!fs.existsSync(planDest)) {
-      fs.copySync(path.join(agSrc, 'PLAN.md'), planDest);
-    }
+    if (!fs.existsSync(planDest)) fs.copySync(path.join(agSrc, 'PLAN.md'), planDest);
 
-    // conocimiento/README siempre
     const knSrc = path.join(agSrc, 'conocimiento', 'README.md');
     const knDest = path.join(agDest, 'conocimiento', 'README.md');
     fs.ensureDirSync(path.dirname(knDest));
@@ -139,14 +273,21 @@ function copyAgenticFiles(sourcePath, projectPath) {
   }
 }
 
-// ── Escribir config.md con la info recopilada ──────────────────
+// ── Escribir config.md completo y listo ────────────────────────
 function writeConfig(projectPath, data) {
-  const { name, description, isNew, stack } = data;
+  const { name, description, isNew, stack, template } = data;
+  const tpl = template || {};
+
+  const modulosImpl = tpl.modulos_impl ? tpl.modulos_impl.join('\n') : '_El agente Setup los detecta al correr aa: configurar_';
+  const modulosPend = tpl.modulos_pend ? tpl.modulos_pend.join('\n') : '_El agente Setup los detecta al correr aa: configurar_';
+  const reglas = tpl.reglas ? tpl.reglas.join('\n') : '_Se definen durante el desarrollo._';
 
   const config = `# Agentic KDD — Configuración del proyecto
 CONFIGURADO: SI
 VERSION: 2.0
 
+---
+
 ## Proyecto
 Nombre: ${name}
 Descripción: ${description}
@@ -159,9 +300,9 @@ frontend:
   language: ${stack.language}
 
 backend:
-  runtime: ${stack.language}
+  runtime: ${stack.runtime || stack.language}
   framework: ${stack.framework}
-  base_datos: —
+  base_datos: ${stack.base_datos || '—'}
 
 devops:
   package_manager: ${stack.packageManager}
@@ -175,30 +316,44 @@ commands:
 \`\`\`
 
 ## Módulos
+
 ### Implementados
-_El agente Setup los detecta al correr aa: configurar_
+| Fase | Módulo | Rutas clave |
+|------|--------|-------------|
+${modulosImpl}
 
 ### Pendientes
-_El agente Setup los detecta al correr aa: configurar_
+${modulosPend}
 
 ## Archivos compartidos críticos
-_El Setup los detecta._
+_El Setup los detecta al correr aa: configurar._
 
 ## Reglas del proyecto
-_Se definen durante el desarrollo._
+
+### Agentic KDD
+- \`aa:\` → pipeline completo sin pausas ni confirmaciones entre agentes
+- \`audit:\` → solo auditar, no modificar código
+- Context Guard: validar instrucción contra config/conocimiento/código
+
+### Desarrollo ${stack.framework !== '—' ? stack.framework : ''}
+${reglas}
 
 ## Sinónimos del proyecto
 _Sin sinónimos registrados aún._
+
+## Mapa BD → módulo
+_El agente Setup lo detecta._
 `;
 
+  fs.ensureDirSync(path.join(projectPath, '.agentic'));
   fs.writeFileSync(path.join(projectPath, '.agentic', 'config.md'), config, 'utf8');
 }
 
-// ── Comando principal: akdd init ───────────────────────────────
+// ── Comando principal: akdd init ────────────────────────────────
 async function init() {
   const projectPath = process.cwd();
 
-  console.log('\n' + chalk.bold.blue('  Agentic KDD') + chalk.gray(' — autonomous development pipeline'));
+  console.log('\n' + chalk.bold.hex('#8b5cf6')('  🤖 Agentic KDD') + chalk.gray(' — autonomous development pipeline'));
   console.log(chalk.gray('  github.com/Adrianlpz211/Agentic-KDD\n'));
 
   // Verificar si ya está instalado
@@ -207,27 +362,44 @@ async function init() {
     const content = fs.readFileSync(path.join(projectPath, '.agentic', 'config.md'), 'utf8');
     if (content.includes('CONFIGURADO: SI')) {
       const { confirm } = await inquirer.prompt([{
-        type: 'confirm',
-        name: 'confirm',
+        type: 'confirm', name: 'confirm',
         message: chalk.yellow('Agentic KDD ya está instalado. ¿Reinstalar?'),
         default: false
       }]);
       if (!confirm) {
-        console.log(chalk.gray('\n  Usa akdd update para actualizar sin perder tu memoria.\n'));
+        console.log(chalk.gray('\n  Usa akdd update para actualizar los agentes sin perder tu memoria.\n'));
         return;
       }
     }
   }
 
-  // Detectar estado del proyecto
+  // Detectar estado y stack automáticamente
   const state = detectProjectState(projectPath);
   const stack = detectStack(projectPath);
 
-  // ── PREGUNTA 1 — Nuevo o existente ────────────────────────────
+  // Mostrar lo que detectó
+  if (stack.framework !== '—') {
+    console.log(chalk.green(`  ✓ Stack detectado: ${stack.framework} · ${stack.language} · ${stack.packageManager}`));
+  }
+  if (state.hasCode) {
+    console.log(chalk.green('  ✓ Código existente detectado'));
+  }
+  if (state.hasKnowledge) {
+    console.log(chalk.green('  ✓ Documentación encontrada en conocimiento/'));
+  }
+  console.log('');
+
+  // ── PREGUNTA 1 — Nombre ─────────────────────────────────────────
+  const { name } = await inquirer.prompt([{
+    type: 'input', name: 'name',
+    message: 'Nombre del proyecto:',
+    default: path.basename(projectPath)
+  }]);
+
+  // ── PREGUNTA 2 — Nuevo o existente ──────────────────────────────
   const { isNew } = await inquirer.prompt([{
-    type: 'list',
-    name: 'isNew',
-    message: '¿El proyecto es nuevo o ya está encaminado?',
+    type: 'list', name: 'isNew',
+    message: '¿El proyecto es nuevo o ya tiene código?',
     choices: [
       { name: 'Nuevo — empezando desde cero', value: true },
       { name: 'Existente — ya tiene código o avance', value: false }
@@ -235,62 +407,38 @@ async function init() {
     default: !state.hasCode
   }]);
 
-  // ── PREGUNTA 2 — Documentación ────────────────────────────────
-  let hasDocsAnswer = false;
+  // ── PREGUNTA 3 — Descripción (solo proyectos nuevos sin docs) ──
+  let description = '—';
+  if (isNew && !state.hasKnowledge) {
+    const { desc } = await inquirer.prompt([{
+      type: 'input', name: 'desc',
+      message: 'Describe brevemente qué hace el proyecto:',
+      validate: (v) => v.trim().length > 5 || 'Al menos 5 caracteres'
+    }]);
+    description = desc;
+  } else if (!isNew && state.hasCode) {
+    description = 'Proyecto existente — el agente Setup detectará módulos y describirá el proyecto al correr aa: configurar';
+  } else if (state.hasKnowledge) {
+    description = 'El agente Setup leerá conocimiento/ y generará la descripción';
+  }
 
+  // ── DOCUMENTACIÓN ──────────────────────────────────────────────
   if (!state.hasKnowledge) {
     const { hasDocs } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'hasDocs',
-      message: '¿Tienes documentación del proyecto? (specs, wireframes, reglas de negocio, etc.)',
+      type: 'confirm', name: 'hasDocs',
+      message: '¿Tienes specs, wireframes o documentación del proyecto?',
       default: false
     }]);
-    hasDocsAnswer = hasDocs;
-
     if (hasDocs) {
-      console.log('\n' + chalk.cyan('  Sube tus archivos a la carpeta:'));
+      console.log('\n' + chalk.cyan('  Sube tus archivos a:'));
       console.log(chalk.bold('  .agentic/conocimiento/'));
-      console.log(chalk.gray('  (PDFs, Markdown, Word, specs — cualquier formato)\n'));
-
-      await inquirer.prompt([{
-        type: 'input',
-        name: 'ready',
-        message: 'Presiona Enter cuando hayas subido los archivos...'
-      }]);
+      console.log(chalk.gray('  (PDFs, Markdown, specs, wireframes — cualquier formato)\n'));
+      await inquirer.prompt([{ type: 'input', name: 'ready', message: 'Presiona Enter cuando hayas subido los archivos...' }]);
     }
-  } else {
-    console.log(chalk.green('  ✓ Encontré archivos en conocimiento/ — el Setup los leerá al configurar'));
-    hasDocsAnswer = true;
-  }
-
-  // ── PREGUNTA 3 — Nombre ────────────────────────────────────────
-  const { name } = await inquirer.prompt([{
-    type: 'input',
-    name: 'name',
-    message: 'Nombre del proyecto:',
-    default: path.basename(projectPath)
-  }]);
-
-  // Descripción según el caso
-  let description = '—';
-
-  if (isNew && !hasDocsAnswer) {
-    // Proyecto nuevo sin docs — pedir descripción
-    const { desc } = await inquirer.prompt([{
-      type: 'input',
-      name: 'desc',
-      message: 'Describe brevemente el proyecto (qué hace, para quién):',
-      validate: (v) => v.trim().length > 10 || 'Por favor da una descripción de al menos 10 caracteres'
-    }]);
-    description = desc;
-  } else if (!isNew && state.hasCode) {
-    description = 'Proyecto existente — el agente Setup detectará los módulos y describirá el proyecto al correr aa: configurar';
-  } else if (hasDocsAnswer) {
-    description = 'El agente Setup leerá conocimiento/ y generará la descripción al correr aa: configurar';
   }
 
-  // ── Descargar e instalar ───────────────────────────────────────
-  const spinner = ora({ text: 'Descargando Agentic KDD desde GitHub...', color: 'blue' }).start();
+  // ── Instalar ────────────────────────────────────────────────────
+  const spinner = ora({ text: 'Descargando Agentic KDD...', color: 'magenta' }).start();
 
   try {
     const sourcePath = await downloadFromGitHub(spinner);
@@ -298,29 +446,36 @@ async function init() {
     spinner.text = 'Instalando archivos...';
     copyAgenticFiles(sourcePath, projectPath);
 
-    spinner.text = 'Configurando proyecto...';
-    writeConfig(projectPath, { name, description, isNew, stack });
+    spinner.text = 'Generando configuración...';
+    const template = stack.templateKey ? TEMPLATES[stack.templateKey] : null;
+    writeConfig(projectPath, { name, description, isNew, stack, template });
 
     fs.removeSync(TEMP_DIR);
-
     spinner.succeed(chalk.green('¡Agentic KDD instalado!'));
 
-    console.log('\n' + chalk.bold('  Siguiente paso — abre el proyecto en Cursor o Claude Code y escribe:\n'));
+    // Resumen de lo instalado
+    console.log('\n' + chalk.bold('  Instalado:'));
+    console.log(chalk.gray('  .agentic/        — pipeline de agentes + memoria KDD'));
+    console.log(chalk.gray('  .audit/          — departamento QA (7 subagentes)'));
+    console.log(chalk.gray('  dashboard.cjs    — dashboard visual'));
+    console.log(chalk.gray('  CLAUDE.md        — activación aa: / ag: / audit:'));
+    console.log(chalk.gray('  .cursorrules     — reglas para Cursor'));
+    if (template) {
+      console.log(chalk.green(`\n  Plantilla aplicada: ${stack.framework}`));
+    }
 
+    console.log('\n' + chalk.bold('  Siguiente paso:\n'));
     if (!isNew && state.hasCode) {
-      console.log(chalk.cyan('  aa: configurar') + chalk.gray('   ← el Setup leerá el código y configurará todo'));
-    } else if (hasDocsAnswer) {
-      console.log(chalk.cyan('  aa: configurar') + chalk.gray('   ← el Setup leerá conocimiento/ y configurará todo'));
+      console.log('  ' + chalk.hex('#a78bfa')('aa: configurar') + chalk.gray('   ← el Setup leerá el código y configurará todo'));
     } else {
-      console.log(chalk.cyan('  aa: configurar') + chalk.gray('   ← el Setup terminará la configuración'));
+      console.log('  ' + chalk.hex('#a78bfa')('aa: configurar') + chalk.gray('   ← termina la configuración'));
     }
+    console.log('  ' + chalk.hex('#10b981')('aa: [tu tarea]') + chalk.gray('  ← cuando esté listo, a construir'));
+    console.log('  ' + chalk.hex('#06b6d4')('node dashboard.cjs') + chalk.gray(' ← abrir dashboard visual\n'));
 
-    console.log(chalk.cyan('  aa: [tu tarea]') + chalk.gray('  ← cuando esté configurado, a trabajar\n'));
-
-    if (!hasDocsAnswer && isNew) {
-      console.log(chalk.yellow('  💡 Tip: si tienes specs o docs del proyecto, súbelos a'));
-      console.log(chalk.yellow('     .agentic/conocimiento/ antes de correr aa: configurar'));
-      console.log(chalk.gray('     Esto hará que el Context Guard funcione mejor.\n'));
+    if (stack.templateKey === null) {
+      console.log(chalk.yellow('  💡 Stack no detectado automáticamente. Edita .agentic/config.md'));
+      console.log(chalk.yellow('     con tu stack y luego corre aa: configurar\n'));
     }
 
   } catch (err) {