@qubiit/lmagent 3.1.2 → 3.1.3

package/install.js

@@ -10,6 +10,7 @@ const figlet = require('figlet');
 const gradient = require('gradient-string');
 
 const program = new Command();
+const PKG_VERSION = require('./package.json').version;
 
 // Configuración: Directorios fuente del paquete
 const PACKAGE_SKILLS_DIR = path.join(__dirname, '.agents', 'skills');
@@ -21,9 +22,11 @@ const PACKAGE_DOCS_DIR = path.join(__dirname, '.agents', 'docs');
 const PACKAGE_MEMORY_DIR = path.join(__dirname, '.agents', 'memory');
 
 // Archivos de proyecto que init copia a la raíz
+// Usan {{VERSION}} como placeholder; se reemplaza dinámicamente al instalar
 const INIT_FILES = [
-    { src: 'CLAUDE.md', desc: 'Instrucciones para Claude Code' },
-    { src: 'AGENTS.md', desc: 'Catálogo de capacidades LMAgent' },
+    { src: 'CLAUDE.md', desc: 'Instrucciones para Claude Code / Antigravity', versionTemplate: true },
+    { src: 'GEMINI.md', desc: 'Instrucciones para Gemini CLI / Antigravity', versionTemplate: true },
+    { src: 'AGENTS.md', desc: 'Catálogo de capacidades LMAgent', versionTemplate: false },
 ];
 
 const INIT_DIRS = [
@@ -33,322 +36,78 @@ const INIT_DIRS = [
     { src: 'workflows', desc: 'SOPs y Procedimientos' },
 ];
 
-// Configuración: IDEs y Agentes soportados
-// Configuración: IDEs y Agentes soportados
+// IDE_CONFIGS: Lista ÚNICA y DEDUPLICADA de todos los agentes soportados
 const IDE_CONFIGS = [
-    // --- IDEs & Tiers Principales (Auto-Detected) ---
+    // --- IDEs Principales (Auto-Detectados) ---
+    // Cursor: usa .cursor/rules/*.mdc (formato MDC con frontmatter)
     { name: 'Cursor', value: 'cursor', rulesDir: '.cursor/rules', skillsDir: '.cursor/skills', workflowsDir: '.cursor/workflows', configFile: '.cursorrules', bridgeFile: 'lmagent.mdc', markerFile: '.cursorrules', forceCopy: true },
-    { name: 'Windsurf', value: 'windsurf', rulesDir: '.windsurf/rules', skillsDir: '.windsurf/skills', workflowsDir: '.windsurf/workflows', configFile: '.windsurfrules', bridgeFile: 'lmagent.md', markerFile: '.windsurfrules', forceCopy: true },
+    // Windsurf Wave 8+: usa .windsurf/rules/*.md (directorio, NO .windsurfrules)
+    { name: 'Windsurf', value: 'windsurf', rulesDir: '.windsurf/rules', skillsDir: '.windsurf/skills', workflowsDir: '.windsurf/workflows', configFile: null, bridgeFile: 'lmagent.md', markerFile: '.windsurf', forceCopy: true },
+    // Cline: usa .clinerules/ (directorio con .md files)
     { name: 'Cline', value: 'cline', rulesDir: '.clinerules', skillsDir: '.cline/skills', workflowsDir: '.cline/workflows', configFile: null, bridgeFile: '00-lmagent.md', markerFile: '.clinerules', forceCopy: true },
-    { name: 'Roo Code', value: 'roo', rulesDir: '.clinerules', skillsDir: '.roo/skills', workflowsDir: '.roo/workflows', configFile: null, bridgeFile: '00-lmagent.md', markerFile: '.roo', forceCopy: true },
-    { name: 'VSCode Copilot', value: 'vscode', rulesDir: '.github/instructions', skillsDir: '.github/skills', workflowsDir: '.github/workflows', configFile: '.github/copilot-instructions.md', markerFile: '.vscode' },
+    // Roo Code: usa .roo/rules/ (NO .clinerules, que es de Cline)
+    { name: 'Roo Code', value: 'roo', rulesDir: '.roo/rules', skillsDir: '.roo/skills', workflowsDir: '.roo/workflows', configFile: null, bridgeFile: '00-lmagent.md', markerFile: '.roo', forceCopy: true },
+    // GitHub Copilot: usa .github/copilot-instructions.md + .github/instructions/*.md
+    { name: 'VSCode Copilot', value: 'vscode', rulesDir: '.github/instructions', skillsDir: '.github/skills', workflowsDir: '.github/workflows', configFile: '.github/copilot-instructions.md', bridgeFile: null, markerFile: '.vscode' },
     { name: 'Trae', value: 'trae', rulesDir: '.trae/rules', skillsDir: '.trae/skills', workflowsDir: '.trae/workflows', configFile: null, bridgeFile: 'lmagent.md', markerFile: '.trae', forceCopy: true },
-    { name: 'Claude Code', value: 'claude', rulesDir: '.claude/rules', skillsDir: '.claude/skills', workflowsDir: '.claude/workflows', configFile: 'CLAUDE.md', markerFile: '.claude', forceCopy: true },
-
-    // --- Expanded Agent Support (Manual/Config Injection) ---
-    { name: 'Amp / Kimi / Replit', value: 'amp', rulesDir: '.agents/rules', skillsDir: '.agents/skills', workflowsDir: '.agents/workflows', configFile: null, markerFile: '.agents' },
-    { name: 'Antigravity', value: 'antigravity', rulesDir: '.agent/rules', skillsDir: '.agent/skills', workflowsDir: '.agent/workflows', configFile: null, markerFile: '.agent' },
-    { name: 'Augment', value: 'augment', rulesDir: '.augment/rules', skillsDir: '.augment/skills', workflowsDir: '.augment/workflows', configFile: null, markerFile: '.augment' },
-    { name: 'OpenClaw', value: 'openclaw', rulesDir: 'rules', skillsDir: 'skills', workflowsDir: 'workflows', configFile: null, markerFile: 'openclaw.yaml' },
-    { name: 'CodeBuddy', value: 'codebuddy', rulesDir: '.codebuddy/rules', skillsDir: '.codebuddy/skills', workflowsDir: '.codebuddy/workflows', configFile: null, markerFile: '.codebuddy' },
-    { name: 'Codex', value: 'codex', rulesDir: '.codex/rules', skillsDir: '.codex/skills', workflowsDir: '.codex/workflows', configFile: null, markerFile: '.codex' },
-    { name: 'Command Code', value: 'command-code', rulesDir: '.commandcode/rules', skillsDir: '.commandcode/skills', workflowsDir: '.commandcode/workflows', configFile: null, markerFile: '.commandcode' },
-    { name: 'Continue', value: 'continue', rulesDir: '.continue/rules', skillsDir: '.continue/skills', workflowsDir: '.continue/workflows', configFile: null, bridgeFile: '00-lmagent.md', markerFile: '.continue' },
-    { name: 'Crush', value: 'crush', rulesDir: '.crush/rules', skillsDir: '.crush/skills', workflowsDir: '.crush/workflows', configFile: null, markerFile: '.crush' },
-    { name: 'Droid', value: 'droid', rulesDir: '.factory/rules', skillsDir: '.factory/skills', workflowsDir: '.factory/workflows', configFile: null, markerFile: '.factory' },
-    { name: 'Gemini CLI', value: 'gemini', rulesDir: '.agents/rules', skillsDir: '.agents/skills', workflowsDir: '.agents/workflows', configFile: null, markerFile: '.gemini' },
-    { name: 'Goose', value: 'goose', rulesDir: '.goose/rules', skillsDir: '.goose/skills', workflowsDir: '.goose/workflows', configFile: null, bridgeFile: 'lmagent.md', markerFile: '.goose' },
-    { name: 'Junie', value: 'junie', rulesDir: '.junie/rules', skillsDir: '.junie/skills', workflowsDir: '.junie/workflows', configFile: null, markerFile: '.junie' },
-    { name: 'iFlow CLI', value: 'iflow', rulesDir: '.iflow/rules', skillsDir: '.iflow/skills', workflowsDir: '.iflow/workflows', configFile: null, markerFile: '.iflow' },
-    { name: 'Kilo Code', value: 'kilo', rulesDir: '.kilocode/rules', skillsDir: '.kilocode/skills', workflowsDir: '.kilocode/workflows', configFile: null, markerFile: '.kilocode' },
-    { name: 'Kiro CLI', value: 'kiro', rulesDir: '.kiro/rules', skillsDir: '.kiro/skills', workflowsDir: '.kiro/workflows', configFile: null, markerFile: '.kiro' },
-    { name: 'Kode', value: 'kode', rulesDir: '.kode/rules', skillsDir: '.kode/skills', workflowsDir: '.kode/workflows', configFile: null, markerFile: '.kode' },
-    { name: 'MCPJam', value: 'mcpjam', rulesDir: '.mcpjam/rules', skillsDir: '.mcpjam/skills', workflowsDir: '.mcpjam/workflows', configFile: null, markerFile: '.mcpjam' },
-    { name: 'Mistral Vibe', value: 'mistral', rulesDir: '.vibe/rules', skillsDir: '.vibe/skills', workflowsDir: '.vibe/workflows', configFile: null, markerFile: '.vibe' },
-    { name: 'Mux', value: 'mux', rulesDir: '.mux/rules', skillsDir: '.mux/skills', workflowsDir: '.mux/workflows', configFile: null, markerFile: '.mux' },
-    { name: 'OpenCode', value: 'opencode', rulesDir: '.opencode/rules', skillsDir: '.opencode/skills', workflowsDir: '.opencode/workflows', configFile: null, markerFile: '.opencode' },
-    { name: 'OpenHands', value: 'openhands', rulesDir: '.openhands/microagents', skillsDir: '.openhands/skills', workflowsDir: '.openhands/workflows', configFile: null, bridgeFile: 'repo.md', markerFile: '.openhands' },
-    { name: 'Pi', value: 'pi', rulesDir: '.pi/rules', skillsDir: '.pi/skills', workflowsDir: '.pi/workflows', configFile: null, markerFile: '.pi' },
-    { name: 'Qoder', value: 'qoder', rulesDir: '.qoder/rules', skillsDir: '.qoder/skills', workflowsDir: '.qoder/workflows', configFile: null, markerFile: '.qoder' },
-    { name: 'Qwen Code', value: 'qwen', rulesDir: '.qwen/rules', skillsDir: '.qwen/skills', workflowsDir: '.qwen/workflows', configFile: null, markerFile: '.qwen' },
+    // Claude Code: usa CLAUDE.md (raíz) + .claude/rules/ + .claude/skills/
+    { name: 'Claude Code', value: 'claude', rulesDir: '.claude/rules', skillsDir: '.claude/skills', workflowsDir: '.claude/workflows', configFile: 'CLAUDE.md', bridgeFile: null, markerFile: '.claude', forceCopy: true },
+    { name: 'Zed', value: 'zed', rulesDir: '.rules', skillsDir: '.rules/skills', workflowsDir: '.rules/workflows', configFile: null, bridgeFile: 'lmagent.md', markerFile: '.zed' },
+
+    // --- Agentes CLI & Autónomos ---
+    { name: 'Amp / Kimi / Replit', value: 'amp', rulesDir: '.agents/rules', skillsDir: '.agents/skills', workflowsDir: '.agents/workflows', configFile: null, bridgeFile: null, markerFile: '.agents' },
+    // Antigravity (Google Deepmind): usa GEMINI.md (raíz) + .agent/skills/ + .agent/rules/
+    { name: 'Antigravity', value: 'antigravity', rulesDir: '.agent/rules', skillsDir: '.agent/skills', workflowsDir: '.agent/workflows', configFile: 'GEMINI.md', bridgeFile: null, markerFile: '.agent' },
+    { name: 'Augment', value: 'augment', rulesDir: '.augment/rules', skillsDir: '.augment/skills', workflowsDir: '.augment/workflows', configFile: null, bridgeFile: null, markerFile: '.augment' },
+    // Gemini CLI: usa GEMINI.md (raíz) + .gemini/skills/ (oficial) o .agents/skills/ (fallback)
+    { name: 'Gemini CLI', value: 'gemini', rulesDir: '.gemini/rules', skillsDir: '.gemini/skills', workflowsDir: '.gemini/workflows', configFile: 'GEMINI.md', bridgeFile: null, markerFile: '.gemini' },
+    { name: 'OpenClaw / Envoid', value: 'openclaw', rulesDir: 'rules', skillsDir: 'skills', workflowsDir: 'workflows', configFile: 'openclaw.json', configTemplate: 'openclaw.json', bridgeFile: null, markerFile: 'openclaw.json' },
+    { name: 'CodeBuddy', value: 'codebuddy', rulesDir: '.codebuddy/rules', skillsDir: '.codebuddy/skills', workflowsDir: '.codebuddy/workflows', configFile: null, bridgeFile: null, markerFile: '.codebuddy', forceCopy: true },
+    // Codex CLI (OpenAI): usa AGENTS.md en raíz + .codex/ como directorio de config
+    { name: 'Codex', value: 'codex', rulesDir: '.codex', skillsDir: '.codex/skills', workflowsDir: '.codex/workflows', configFile: 'AGENTS.md', bridgeFile: null, markerFile: '.codex' },
+    { name: 'Command Code', value: 'command-code', rulesDir: '.commandcode/rules', skillsDir: '.commandcode/skills', workflowsDir: '.commandcode/workflows', configFile: null, bridgeFile: null, markerFile: '.commandcode' },
+    // Continue: soporta .continuerules (raíz) + .continue/rules/ (directorio)
+    { name: 'Continue', value: 'continue', rulesDir: '.continue/rules', skillsDir: '.continue/skills', workflowsDir: '.continue/workflows', configFile: '.continuerules', configTemplate: 'continuerules.md', bridgeFile: '00-lmagent.md', markerFile: '.continue' },
+    { name: 'Crush', value: 'crush', rulesDir: '.crush/rules', skillsDir: '.crush/skills', workflowsDir: '.crush/workflows', configFile: null, bridgeFile: null, markerFile: '.crush' },
+    { name: 'Droid', value: 'droid', rulesDir: '.factory/rules', skillsDir: '.factory/skills', workflowsDir: '.factory/workflows', configFile: null, bridgeFile: null, markerFile: '.factory' },
+    // Goose (Block): usa .goosehints en raíz para instrucciones al agente
+    { name: 'Goose', value: 'goose', rulesDir: '.goose', skillsDir: '.goose/skills', workflowsDir: '.goose/workflows', configFile: '.goosehints', configTemplate: 'goosehints.md', bridgeFile: null, markerFile: '.goose' },
+    // Junie (JetBrains): usa .junie/guidelines.md como archivo de instrucciones
+    { name: 'Junie', value: 'junie', rulesDir: '.junie', skillsDir: '.junie/skills', workflowsDir: '.junie/workflows', configFile: '.junie/guidelines.md', configTemplate: 'junie-guidelines.md', bridgeFile: null, markerFile: '.junie' },
+    { name: 'iFlow CLI', value: 'iflow', rulesDir: '.iflow/rules', skillsDir: '.iflow/skills', workflowsDir: '.iflow/workflows', configFile: null, bridgeFile: null, markerFile: '.iflow' },
+    { name: 'Kilo Code', value: 'kilo', rulesDir: '.kilocode/rules', skillsDir: '.kilocode/skills', workflowsDir: '.kilocode/workflows', configFile: null, bridgeFile: null, markerFile: '.kilocode' },
+    { name: 'Kiro CLI', value: 'kiro', rulesDir: '.kiro/rules', skillsDir: '.kiro/skills', workflowsDir: '.kiro/workflows', configFile: null, bridgeFile: null, markerFile: '.kiro' },
+    { name: 'Kode', value: 'kode', rulesDir: '.kode/rules', skillsDir: '.kode/skills', workflowsDir: '.kode/workflows', configFile: null, bridgeFile: null, markerFile: '.kode' },
+    { name: 'MCPJam', value: 'mcpjam', rulesDir: '.mcpjam/rules', skillsDir: '.mcpjam/skills', workflowsDir: '.mcpjam/workflows', configFile: null, bridgeFile: null, markerFile: '.mcpjam' },
+    { name: 'Mistral Vibe', value: 'mistral', rulesDir: '.vibe/rules', skillsDir: '.vibe/skills', workflowsDir: '.vibe/workflows', configFile: null, bridgeFile: null, markerFile: '.vibe' },
+    { name: 'Mux', value: 'mux', rulesDir: '.mux/rules', skillsDir: '.mux/skills', workflowsDir: '.mux/workflows', configFile: null, bridgeFile: null, markerFile: '.mux' },
+    { name: 'OpenCode', value: 'opencode', rulesDir: '.opencode/rules', skillsDir: '.opencode/skills', workflowsDir: '.opencode/workflows', configFile: null, bridgeFile: null, markerFile: '.opencode' },
+    // OpenHands: usa .openhands/microagents/repo.md para instrucciones del repo
+    { name: 'OpenHands', value: 'openhands', rulesDir: '.openhands/microagents', skillsDir: '.openhands/skills', workflowsDir: '.openhands/workflows', configFile: '.openhands/microagents/repo.md', configTemplate: 'openhands-repo.md', bridgeFile: null, markerFile: '.openhands' },
+    { name: 'Pi', value: 'pi', rulesDir: '.pi/rules', skillsDir: '.pi/skills', workflowsDir: '.pi/workflows', configFile: null, bridgeFile: null, markerFile: '.pi' },
+    { name: 'Qoder', value: 'qoder', rulesDir: '.qoder/rules', skillsDir: '.qoder/skills', workflowsDir: '.qoder/workflows', configFile: null, bridgeFile: null, markerFile: '.qoder' },
+    { name: 'Qwen Code', value: 'qwen', rulesDir: '.qwen/rules', skillsDir: '.qwen/skills', workflowsDir: '.qwen/workflows', configFile: null, bridgeFile: null, markerFile: '.qwen' },
     { name: 'Trae CN', value: 'trae-cn', rulesDir: '.trae-cn/rules', skillsDir: '.trae-cn/skills', workflowsDir: '.trae-cn/workflows', configFile: null, bridgeFile: 'lmagent.md', markerFile: '.trae-cn' },
-    { name: 'Zencoder', value: 'zencoder', rulesDir: '.zencoder/rules', skillsDir: '.zencoder/skills', workflowsDir: '.zencoder/workflows', configFile: null, markerFile: '.zencoder' },
-    { name: 'Neovate', value: 'neovate', rulesDir: '.neovate/rules', skillsDir: '.neovate/skills', workflowsDir: '.neovate/workflows', configFile: null, markerFile: '.neovate' },
-    { name: 'Pochi', value: 'pochi', rulesDir: '.pochi/rules', skillsDir: '.pochi/skills', workflowsDir: '.pochi/workflows', configFile: null, markerFile: '.pochi' },
-    { name: 'AdaL', value: 'adal', rulesDir: '.adal/rules', skillsDir: '.adal/skills', workflowsDir: '.adal/workflows', configFile: null, markerFile: '.adal' },
-
-    {
-        name: 'Gemini CLI',
-        value: 'gemini',
-        rulesDir: '.agents/rules',
-        skillsDir: '.gemini/skills',
-        workflowsDir: '.agents/workflows',
-        configFile: '.gemini/config',
-        markerFile: '.gemini'
-    },
-    {
-        name: 'Continue',
-        value: 'continue',
-        rulesDir: '.continue/rules',
-        skillsDir: '.continue/skills',
-        workflowsDir: '.continue/workflows',
-        configFile: '.continue/config.json',
-        markerFile: '.continue'
-    },
-    {
-        name: 'OpenCode',
-        value: 'opencode',
-        rulesDir: '.agents/rules',
-        skillsDir: '.config/opencode/skills',
-        workflowsDir: '.agents/workflows',
-        configFile: '.opencode/config',
-        markerFile: '.opencode'
-    },
-    {
-        name: 'OpenHands',
-        value: 'openhands',
-        rulesDir: '.openhands/rules',
-        skillsDir: '.openhands/skills',
-        workflowsDir: '.openhands/workflows',
-        configFile: '.openhands/config',
-        markerFile: '.openhands'
-    },
-    {
-        name: 'Goose',
-        value: 'goose',
-        rulesDir: '.goose/rules',
-        skillsDir: '.goose/skills',
-        workflowsDir: '.goose/workflows',
-        configFile: '.goose/config',
-        markerFile: '.goose'
-    },
-    {
-        name: 'Mistral Vibe',
-        value: 'vibe',
-        rulesDir: '.vibe/rules',
-        skillsDir: '.vibe/skills',
-        workflowsDir: '.vibe/workflows',
-        configFile: '.vibe/config',
-        markerFile: '.vibe'
-    },
-    {
-        name: 'Zed',
-        value: 'zed',
-        rulesDir: '.rules',
-        skillsDir: '.rules/skills',
-        workflowsDir: '.rules/workflows',
-        configFile: '.rules/config',
-        markerFile: '.zed'
-    },
-    {
-        name: 'Envoid (OpenClaw / Moltbot)',
-        value: 'openclaw',
-        rulesDir: 'rules',
-        skillsDir: 'skills',
-        workflowsDir: 'workflows',
-        configFile: 'openclaw.json',
-        markerFile: 'openclaw.json'
-    },
-    {
-        name: 'CodeBuddy',
-        value: 'codebuddy',
-        rulesDir: '.codebuddy/rules',
-        skillsDir: '.codebuddy/skills',
-        workflowsDir: '.codebuddy/workflows',
-        configFile: '.codebuddy/config',
-        markerFile: '.codebuddy',
-        forceCopy: true
-    },
-    {
-        name: 'Command Code',
-        value: 'command-code',
-        rulesDir: '.commandcode/rules',
-        skillsDir: '.commandcode/skills',
-        workflowsDir: '.commandcode/workflows',
-        configFile: '.commandcode/config',
-        markerFile: '.commandcode'
-    },
-    {
-        name: 'Crush',
-        value: 'crush',
-        rulesDir: '.crush/rules',
-        skillsDir: '.crush/skills',
-        workflowsDir: '.crush/workflows',
-        configFile: '.crush/config',
-        markerFile: '.crush'
-    },
-    {
-        name: 'Droid',
-        value: 'droid',
-        rulesDir: '.factory/rules',
-        skillsDir: '.factory/skills',
-        workflowsDir: '.factory/workflows',
-        configFile: '.factory/config',
-        markerFile: '.factory'
-    },
-    {
-        name: 'Junie',
-        value: 'junie',
-        rulesDir: '.junie/rules',
-        skillsDir: '.junie/skills',
-        workflowsDir: '.junie/workflows',
-        configFile: '.junie/config',
-        markerFile: '.junie'
-    },
-    {
-        name: 'iFlow',
-        value: 'iflow',
-        rulesDir: '.iflow/rules',
-        skillsDir: '.iflow/skills',
-        workflowsDir: '.iflow/workflows',
-        configFile: '.iflow/config',
-        markerFile: '.iflow'
-    },
-    {
-        name: 'Kilo Code',
-        value: 'kilo',
-        rulesDir: '.kilocode/rules',
-        skillsDir: '.kilocode/skills',
-        workflowsDir: '.kilocode/workflows',
-        configFile: '.kilocode/config',
-        markerFile: '.kilocode'
-    },
-    {
-        name: 'Kiro',
-        value: 'kiro',
-        rulesDir: '.kiro/rules',
-        skillsDir: '.kiro/skills',
-        workflowsDir: '.kiro/workflows',
-        configFile: '.kiro/config',
-        markerFile: '.kiro'
-    },
-    {
-        name: 'Kode',
-        value: 'kode',
-        rulesDir: '.kode/rules',
-        skillsDir: '.kode/skills',
-        workflowsDir: '.kode/workflows',
-        configFile: '.kode/config',
-        markerFile: '.kode'
-    },
-    {
-        name: 'MCPJam',
-        value: 'mcpjam',
-        rulesDir: '.mcpjam/rules',
-        skillsDir: '.mcpjam/skills',
-        workflowsDir: '.mcpjam/workflows',
-        configFile: '.mcpjam/config',
-        markerFile: '.mcpjam'
-    },
-    {
-        name: 'Mux',
-        value: 'mux',
-        rulesDir: '.mux/rules',
-        skillsDir: '.mux/skills',
-        workflowsDir: '.mux/workflows',
-        configFile: '.mux/config',
-        markerFile: '.mux'
-    },
-    {
-        name: 'Pi',
-        value: 'pi',
-        rulesDir: '.pi/rules',
-        skillsDir: '.pi/skills',
-        workflowsDir: '.pi/workflows',
-        configFile: '.pi/config',
-        markerFile: '.pi'
-    },
-    {
-        name: 'Qoder',
-        value: 'qoder',
-        rulesDir: '.qoder/rules',
-        skillsDir: '.qoder/skills',
-        workflowsDir: '.qoder/workflows',
-        configFile: '.qoder/config',
-        markerFile: '.qoder'
-    },
-    {
-        name: 'Qwen Code',
-        value: 'qwen',
-        rulesDir: '.qwen/rules',
-        skillsDir: '.qwen/skills',
-        workflowsDir: '.qwen/workflows',
-        configFile: '.qwen/config',
-        markerFile: '.qwen'
-    },
-    {
-        name: 'Trae CN',
-        value: 'trae-cn',
-        rulesDir: '.trae-cn/rules',
-        skillsDir: '.trae-cn/skills',
-        workflowsDir: '.trae-cn/workflows',
-        configFile: '.trae-cn/config',
-        markerFile: '.trae-cn'
-    },
-    {
-        name: 'Zencoder',
-        value: 'zencoder',
-        rulesDir: '.zencoder/rules',
-        skillsDir: '.zencoder/skills',
-        workflowsDir: '.zencoder/workflows',
-        configFile: '.zencoder/config',
-        markerFile: '.zencoder'
-    },
-    {
-        name: 'Neovate',
-        value: 'neovate',
-        rulesDir: '.neovate/rules',
-        skillsDir: '.neovate/skills',
-        workflowsDir: '.neovate/workflows',
-        configFile: '.neovate/config',
-        markerFile: '.neovate'
-    },
-    {
-        name: 'Pochi',
-        value: 'pochi',
-        rulesDir: '.pochi/rules',
-        skillsDir: '.pochi/skills',
-        workflowsDir: '.pochi/workflows',
-        configFile: '.pochi/config',
-        markerFile: '.pochi'
-    },
-    {
-        name: 'AdaL',
-        value: 'adal',
-        rulesDir: '.adal/rules',
-        skillsDir: '.adal/skills',
-        workflowsDir: '.adal/workflows',
-        configFile: '.adal/config',
-        markerFile: '.adal'
-    },
-    {
-        name: 'Generic/Other',
-        value: 'generic',
-        rulesDir: '.agents/rules',
-        skillsDir: '.agents/skills',
-        workflowsDir: '.agents/workflows',
-        configFile: 'AGENTS.md',
-        markerFile: '.agents'
-    },
-    {
-        name: 'Custom Path (Manual)',
-        value: 'custom',
-        rulesDir: '',
-        skillsDir: '',
-        workflowsDir: '',
-        markerFile: ''
-    }
+    { name: 'Zencoder', value: 'zencoder', rulesDir: '.zencoder/rules', skillsDir: '.zencoder/skills', workflowsDir: '.zencoder/workflows', configFile: null, bridgeFile: null, markerFile: '.zencoder' },
+    { name: 'Neovate', value: 'neovate', rulesDir: '.neovate/rules', skillsDir: '.neovate/skills', workflowsDir: '.neovate/workflows', configFile: null, bridgeFile: null, markerFile: '.neovate' },
+    { name: 'Pochi', value: 'pochi', rulesDir: '.pochi/rules', skillsDir: '.pochi/skills', workflowsDir: '.pochi/workflows', configFile: null, bridgeFile: null, markerFile: '.pochi' },
+    { name: 'AdaL', value: 'adal', rulesDir: '.adal/rules', skillsDir: '.adal/skills', workflowsDir: '.adal/workflows', configFile: null, bridgeFile: null, markerFile: '.adal' },
+
+    // --- Opciones Especiales ---
+    { name: 'Generic/Other', value: 'generic', rulesDir: '.agents/rules', skillsDir: '.agents/skills', workflowsDir: '.agents/workflows', configFile: 'AGENTS.md', bridgeFile: null, markerFile: '.agents' },
+    { name: 'Custom Path (Manual)', value: 'custom', rulesDir: '', skillsDir: '', workflowsDir: '', configFile: null, bridgeFile: null, markerFile: '' },
 ];
 
 program
     .name('lmagent')
     .description('CLI para instalar skills y reglas de LMAgent')
-    .version('3.1.2');
+    .version(PKG_VERSION);
 
 program.command('install')
     .description('Instalar skills, rules y workflows en el IDE del proyecto')
     .option('-f, --force', 'Forzar instalación')
     .option('-y, --yes', 'Instalar todo sin preguntar')
+    .option('-g, --global', 'También sincronizar al repositorio global (~/.agents/)')
     .action((options) => {
         runInstall(options);
     });
@@ -357,6 +116,7 @@ program.command('update')
     .description('Actualizar skills y reglas en el proyecto (alias de install)')
     .option('-f, --force', 'Forzar actualización')
     .option('-y, --yes', 'Instalar todo sin preguntar')
+    .option('-g, --global', 'También sincronizar al repositorio global (~/.agents/)')
     .action((options) => {
         console.log(chalk.blue('ℹ Iniciando actualización...'));
         runInstall(options);
@@ -402,19 +162,226 @@ program.command('create-skill')
         }
     });
 
+program.command('tokens')
+    .description('Analizar consumo de tokens del framework instalado en el proyecto')
+    .option('--json', 'Salida en formato JSON')
+    .option('--report', 'Generar reporte en .agents/token-report.md')
+    .action((options) => {
+        const { execSync } = require('child_process');
+        const scriptPath = path.join(__dirname, 'scripts', 'token-analyzer.js');
+        const args = [options.json ? '--json' : '', options.report ? '--report' : ''].filter(Boolean).join(' ');
+        try {
+            execSync(`node "${scriptPath}" ${args}`, { stdio: 'inherit' });
+        } catch (e) {
+            process.exit(e.status || 1);
+        }
+    });
+
+program.command('skills')
+    .description('Gestionar skills externos desde GitHub (compatible con el estándar skills.sh)')
+    .argument('<action>', 'Acción: add')
+    .argument('<source>', 'Repositorio GitHub: owner/repo o URL completa')
+    .option('--skill <name>', 'Nombre específico del skill a instalar (opcional)')
+    .action(async (action, source, opts) => {
+        if (action !== 'add') {
+            console.error(chalk.red(`❌ Acción desconocida: ${action}. Usa: lmagent skills add <owner/repo>`));
+            process.exit(1);
+        }
+        const { execSync } = require('child_process');
+        const repoSlug = source.replace('https://github.com/', '').replace(/\.git$/, '');
+        const [owner, repo] = repoSlug.split('/');
+        if (!owner || !repo) {
+            console.error(chalk.red('❌ Formato inválido. Usa: lmagent skills add owner/repo'));
+            process.exit(1);
+        }
+        const tmpDir = path.join(os.tmpdir(), `lmagent-skill-${Date.now()}`);
+        const targetSkillsDir = path.join(process.cwd(), '.agents', 'skills');
+        console.log(chalk.cyan(`📦 Descargando skill desde github.com/${owner}/${repo}...`));
+        try {
+            execSync(`git clone --depth 1 https://github.com/${owner}/${repo} "${tmpDir}"`, { stdio: 'pipe' });
+            const skillsPath = fs.existsSync(path.join(tmpDir, 'skills')) ? path.join(tmpDir, 'skills') : tmpDir;
+            const items = fs.readdirSync(skillsPath).filter(i => {
+                const p = path.join(skillsPath, i);
+                return fs.statSync(p).isDirectory() && fs.existsSync(path.join(p, 'SKILL.md'));
+            });
+            if (items.length === 0) {
+                console.log(chalk.yellow('⚠️  No se encontraron skills con SKILL.md en el repositorio.'));
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+                return;
+            }
+            const toInstall = opts.skill ? items.filter(i => i.includes(opts.skill)) : items;
+            if (!fs.existsSync(targetSkillsDir)) fs.mkdirSync(targetSkillsDir, { recursive: true });
+            for (const skill of toInstall) {
+                const src = path.join(skillsPath, skill);
+                const dest = path.join(targetSkillsDir, skill);
+                copyRecursiveSync(src, dest, true);
+                console.log(`  ${chalk.green('✔')} ${skill}/`);
+            }
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+            console.log(chalk.green(`✨ ${toInstall.length} skill(s) instalado(s) en .agents/skills/`));
+            console.log(chalk.dim('   Ejecuta `lmagent install` para sincronizarlos a tu agente.'));
+        } catch (e) {
+            console.error(chalk.red(`❌ Error al instalar skill: ${e.message}`));
+            try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_) { }
+            process.exit(1);
+        }
+    });
+
+program.command('uninstall')
+    .description('Eliminar todos los archivos instalados por LMAgent del proyecto')
+    .option('-f, --force', 'No pedir confirmación, eliminar directamente')
+    .option('--all', 'También eliminar entry points raíz (CLAUDE.md, GEMINI.md, AGENTS.md)')
+    .action(async (options) => {
+        console.clear();
+        const branding = figlet.textSync('LMAGENT', { font: 'ANSI Shadow' });
+        console.log(gradient.pastel.multiline(branding));
+        console.log(gradient.cristal('                              Uninstall - Limpieza\n'));
+
+        const projectRoot = process.cwd();
+
+        // Detectar qué agentes están instalados en el proyecto
+        const installedIdes = IDE_CONFIGS.filter(ide => {
+            if (ide.value === 'custom' || ide.value === 'generic') return false;
+            const markerInProject = ide.markerFile && fs.existsSync(path.join(projectRoot, ide.markerFile));
+            const rulesDirInProject = ide.rulesDir && fs.existsSync(path.join(projectRoot, ide.rulesDir));
+            const skillsDirInProject = ide.skillsDir && fs.existsSync(path.join(projectRoot, ide.skillsDir));
+            return markerInProject || rulesDirInProject || skillsDirInProject;
+        });
+
+        if (installedIdes.length === 0) {
+            console.log(chalk.yellow('⚠️  No se detectó ningún agente instalado en este proyecto.'));
+            return;
+        }
+
+        console.log(chalk.bold('🔍 Agentes detectados en este proyecto:\n'));
+        for (const ide of installedIdes) {
+            const parts = [];
+            if (ide.rulesDir && fs.existsSync(path.join(projectRoot, ide.rulesDir))) parts.push(chalk.gray(ide.rulesDir));
+            if (ide.skillsDir && fs.existsSync(path.join(projectRoot, ide.skillsDir))) parts.push(chalk.gray(ide.skillsDir));
+            if (ide.configFile && fs.existsSync(path.join(projectRoot, ide.configFile))) parts.push(chalk.gray(ide.configFile));
+            console.log(`  ${chalk.cyan('•')} ${chalk.bold(ide.name)}: ${parts.join(', ')}`);
+        }
+
+        // Entry points raíz
+        const rootFiles = ['CLAUDE.md', 'GEMINI.md', 'AGENTS.md', '.cursorrules', '.windsurfrules', '.continuerules', '.goosehints'];
+        const existingRootFiles = rootFiles.filter(f => fs.existsSync(path.join(projectRoot, f)));
+
+        if (options.all && existingRootFiles.length > 0) {
+            console.log(chalk.bold('\n📄 Entry points raíz que también se eliminarán:'));
+            for (const f of existingRootFiles) {
+                console.log(`  ${chalk.red('•')} ${f}`);
+            }
+        }
+
+        console.log('');
+
+        if (!options.force) {
+            const { confirm } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'confirm',
+                message: chalk.red(`⚠️  ¿Eliminar todos los archivos de LMAgent de este proyecto? Esta acción no se puede deshacer.`),
+                default: false
+            }]);
+            if (!confirm) {
+                console.log(chalk.gray('Cancelado.'));
+                return;
+            }
+        }
+
+        console.log('');
+        let removed = 0;
+        let errors = 0;
+
+        // Eliminar directorios y archivos de cada agente
+        for (const ide of installedIdes) {
+            const toRemove = [];
+
+            // Directorios del agente (skills, rules, workflows) — solo si son específicos del agente
+            // No eliminar directorios genéricos como .github, rules/, skills/ que pueden tener otros usos
+            const agentSpecificDirs = [ide.skillsDir, ide.workflowsDir];
+            if (ide.rulesDir && !['rules', '.github/instructions'].includes(ide.rulesDir)) {
+                agentSpecificDirs.push(ide.rulesDir);
+            }
+
+            // Determinar el directorio raíz del agente (ej: .cursor, .windsurf, .claude)
+            const agentRootDir = ide.markerFile && !ide.markerFile.includes('.') ? null
+                : ide.rulesDir ? ide.rulesDir.split('/')[0] : null;
+            if (agentRootDir && agentRootDir.startsWith('.') && fs.existsSync(path.join(projectRoot, agentRootDir))) {
+                // Eliminar el directorio raíz completo del agente
+                toRemove.push({ path: path.join(projectRoot, agentRootDir), type: 'dir', label: agentRootDir + '/' });
+            } else {
+                // Eliminar subdirectorios individualmente
+                for (const dir of agentSpecificDirs) {
+                    if (dir && fs.existsSync(path.join(projectRoot, dir))) {
+                        toRemove.push({ path: path.join(projectRoot, dir), type: 'dir', label: dir + '/' });
+                    }
+                }
+            }
+
+            // Archivos de configuración específicos del agente (markerFile si es un archivo)
+            if (ide.markerFile && ide.markerFile.includes('.') && fs.existsSync(path.join(projectRoot, ide.markerFile))) {
+                const markerStat = fs.statSync(path.join(projectRoot, ide.markerFile));
+                if (markerStat.isFile()) {
+                    toRemove.push({ path: path.join(projectRoot, ide.markerFile), type: 'file', label: ide.markerFile });
+                }
+            }
+
+            for (const item of toRemove) {
+                try {
+                    if (item.type === 'dir') {
+                        fs.rmSync(item.path, { recursive: true, force: true });
+                    } else {
+                        fs.unlinkSync(item.path);
+                    }
+                    console.log(`  ${chalk.red('✘')} ${ide.name}: ${chalk.gray(item.label)} eliminado`);
+                    removed++;
+                } catch (e) {
+                    console.error(`  ${chalk.red('❌')} Error eliminando ${item.label}: ${e.message}`);
+                    errors++;
+                }
+            }
+        }
+
+        // Eliminar entry points raíz si --all
+        if (options.all) {
+            for (const f of existingRootFiles) {
+                try {
+                    fs.unlinkSync(path.join(projectRoot, f));
+                    console.log(`  ${chalk.red('✘')} ${chalk.gray(f)} eliminado`);
+                    removed++;
+                } catch (e) {
+                    console.error(`  ${chalk.red('❌')} Error eliminando ${f}: ${e.message}`);
+                    errors++;
+                }
+            }
+        }
+
+        console.log('');
+        if (errors === 0) {
+            console.log(gradient.pastel(`\n✨ Limpieza completada. ${removed} elemento(s) eliminado(s).\n`));
+            if (!options.all) {
+                console.log(chalk.dim('   💡 Usa `lmagent uninstall --all` para también eliminar CLAUDE.md, GEMINI.md y AGENTS.md.'));
+            }
+        } else {
+            console.log(chalk.yellow(`\n⚠️  ${removed} eliminado(s), ${errors} error(es).\n`));
+        }
+    });
+
 if (process.argv.length === 2) {
     runInstall({});
 } else {
     program.parse();
 }
 
+
 // Helper for Windows-proof path comparison
 function arePathsEqual(p1, p2) {
     if (!p1 || !p2) return false;
     return path.resolve(p1).toLowerCase() === path.resolve(p2).toLowerCase();
 }
 
-// Helper to deploy AGENTS.md and CLAUDE.md to project root
+// Helper to deploy AGENTS.md, CLAUDE.md y GEMINI.md to project root
+// Los archivos con versionTemplate:true tienen {{VERSION}} que se reemplaza dinámicamente
 async function deployCorePillars(options, projectRoot) {
     console.log(chalk.bold('\n🚀 Desplegando Pilares de Inteligencia (Contexto Root):'));
     for (const file of INIT_FILES) {
@@ -427,18 +394,22 @@ async function deployCorePillars(options, projectRoot) {
                 shouldCopy = true;
                 console.log(`  ${chalk.green('✔')} ${file.src} (Creado en la raíz)`);
             } else {
-                if (options.force) {
+                // Si ya existe pero tiene versión vieja, actualizar automáticamente
+                const existingContent = fs.readFileSync(destPath, 'utf8');
+                const hasOldVersion = existingContent.includes('{{VERSION}}') ||
+                    (file.versionTemplate && !existingContent.includes(`v${PKG_VERSION}`));
+
+                if (options.force || hasOldVersion) {
                     shouldCopy = true;
-                    console.log(`  ${chalk.yellow('✎')} ${file.src} (Sobrescribiendo por --force)`);
+                    const reason = hasOldVersion ? 'Actualizando versión' : 'Sobrescribiendo por --force';
+                    console.log(`  ${chalk.yellow('✎')} ${file.src} (${reason})`);
                 } else if (options.yes) {
-                    // En modo --yes, si ya existe, NO sobrescribimos para no borrar personalización del usuario
-                    // PERO informamos.
-                    console.log(`  ${chalk.blue('ℹ')} ${file.src} ya existe (Manteniendo versión local)`);
+                    console.log(`  ${chalk.blue('ℹ')} ${file.src} ya existe v${PKG_VERSION} (OK)`);
                 } else {
                     const answer = await inquirer.prompt([{
                         type: 'confirm',
                         name: 'overwrite',
-                        message: `⚠️  ${file.src} ya existe en la raíz. ¿Deseas actualizarlo/sobrescribirlo?`,
+                        message: `⚠️  ${file.src} ya existe. ¿Deseas actualizarlo?`,
                         default: false
                     }]);
                     shouldCopy = answer.overwrite;
@@ -447,7 +418,12 @@ async function deployCorePillars(options, projectRoot) {
             }
 
             if (shouldCopy) {
-                fs.copyFileSync(srcPath, destPath);
+                let content = fs.readFileSync(srcPath, 'utf8');
+                // Inyectar versión dinámica si el archivo usa template
+                if (file.versionTemplate) {
+                    content = content.replace(/\{\{VERSION\}\}/g, PKG_VERSION);
+                }
+                fs.writeFileSync(destPath, content, 'utf8');
             }
         }
     }
@@ -464,20 +440,21 @@ async function runInstall(options) {
     const globalAgentDir = path.join(userHome, '.agents');
     const globalSkillsDir = path.join(globalAgentDir, 'skills');
     const globalRulesDir = path.join(globalAgentDir, 'rules');
-    const globalWorkflowsDir = path.join(globalAgentDir, 'workflows'); // New
-
-    // 1. Sincronizar (Copiar) Package -> Global Repo (~/.agents)
-    // UX OPTIMIZATION: Silent sync unless error
-    try {
-        if (!fs.existsSync(globalAgentDir)) fs.mkdirSync(globalAgentDir, { recursive: true });
-
-        if (fs.existsSync(PACKAGE_SKILLS_DIR)) copyRecursiveSync(PACKAGE_SKILLS_DIR, globalSkillsDir, true);
-        if (fs.existsSync(PACKAGE_RULES_DIR)) copyRecursiveSync(PACKAGE_RULES_DIR, globalRulesDir, true);
-        if (fs.existsSync(PACKAGE_WORKFLOWS_DIR)) copyRecursiveSync(PACKAGE_WORKFLOWS_DIR, globalWorkflowsDir, true);
-        if (fs.existsSync(PACKAGE_MEMORY_DIR)) copyRecursiveSync(PACKAGE_MEMORY_DIR, path.join(globalAgentDir, 'memory'), true);
-        // console.log(chalk.green('✔ Repositorio global sincronizado.'));
-    } catch (e) {
-        // console.error(chalk.red(`❌ Error al sincronizar repositorio global: ${e.message}`));
+    const globalWorkflowsDir = path.join(globalAgentDir, 'workflows');
+
+    // Sync global SOLO si se pasa --global explícitamente (evita doble lectura de contexto)
+    if (options.global) {
+        console.log(chalk.blue('🌐 Sincronizando al repositorio global (~/.agents/)...'));
+        try {
+            if (!fs.existsSync(globalAgentDir)) fs.mkdirSync(globalAgentDir, { recursive: true });
+            if (fs.existsSync(PACKAGE_SKILLS_DIR)) copyRecursiveSync(PACKAGE_SKILLS_DIR, globalSkillsDir, true);
+            if (fs.existsSync(PACKAGE_RULES_DIR)) copyRecursiveSync(PACKAGE_RULES_DIR, globalRulesDir, true);
+            if (fs.existsSync(PACKAGE_WORKFLOWS_DIR)) copyRecursiveSync(PACKAGE_WORKFLOWS_DIR, globalWorkflowsDir, true);
+            if (fs.existsSync(PACKAGE_MEMORY_DIR)) copyRecursiveSync(PACKAGE_MEMORY_DIR, path.join(globalAgentDir, 'memory'), true);
+            console.log(chalk.green('✔ Repositorio global sincronizado.'));
+        } catch (e) {
+            console.error(chalk.red(`❌ Error al sincronizar repositorio global: ${e.message}`));
+        }
     }
 
     await deployCorePillars(options, projectRoot);
@@ -510,10 +487,6 @@ async function runInstall(options) {
         console.log(chalk.cyan('🔹 Configuración de Instalación'));
         console.log(chalk.gray('================================================================'));
 
-        console.log(chalk.gray('================================================================'));
-        console.log(chalk.cyan('🔹 Configuración de Instalación'));
-        console.log(chalk.gray('================================================================'));
-
         // UX OPTIMIZATION: "Project First" & Windows Compat
         // 1. Detect Environment
         const isWindows = os.platform() === 'win32';
@@ -527,21 +500,65 @@ async function runInstall(options) {
         console.log('');
 
         // 3. Auto-Detect IDEs
+        // Mapa de rutas de instalación global por agente (donde el IDE instala sus archivos en ~/)
+        // HOME_PATHS: rutas de instalación global de cada agente en el sistema del usuario
+        // Cubre los 37 agentes soportados. Se verifica si alguna de las rutas existe en ~/
+        const HOME_PATHS = {
+            // IDEs principales
+            'cursor': ['.cursor'],
+            'windsurf': ['.windsurf'],
+            'cline': ['.vscode/extensions', '.cline'],
+            'roo': ['.vscode/extensions', '.roo'],
+            'vscode': ['.vscode'],
+            'trae': ['.trae'],
+            'trae-cn': ['.trae-cn', '.trae'],
+            'claude': ['.claude'],
+            'zed': ['.config/zed', '.zed'],
+            // Agentes CLI & autónomos
+            'antigravity': ['.gemini/antigravity'],
+            'gemini': ['.gemini'],
+            'augment': ['.augment'],
+            'continue': ['.continue'],
+            'codex': ['.codex'],
+            'goose': ['.config/goose', '.goose'],
+            'junie': ['.junie'],
+            'kilo': ['.kilocode'],
+            'kiro': ['.kiro'],
+            'opencode': ['.opencode'],
+            'openhands': ['.openhands'],
+            'amp': ['.agents'],
+            'zencoder': ['.zencoder'],
+            'codebuddy': ['.codebuddy'],
+            'crush': ['.crush'],
+            'droid': ['.factory'],
+            'mux': ['.mux'],
+            'qwen': ['.qwen'],
+            // Agentes menores / nicho
+            'openclaw': ['.config/openclaw', '.openclaw'],
+            'command-code': ['.commandcode'],
+            'iflow': ['.iflow'],
+            'kode': ['.kode'],
+            'mcpjam': ['.mcpjam'],
+            'mistral': ['.vibe', '.mistral'],
+            'pi': ['.pi'],
+            'qoder': ['.qoder'],
+            'neovate': ['.neovate'],
+            'pochi': ['.pochi'],
+            'adal': ['.adal'],
+        };
+
         const detectedIdes = IDE_CONFIGS.filter(ide => {
-            if (ide.value === 'custom') return false; // Custom is never auto-detected
+            if (ide.value === 'custom' || ide.value === 'generic') return false;
 
-            // Check Project Root
-            const inProject = (ide.rulesDir && fs.existsSync(path.join(projectRoot, ide.rulesDir.split('/')[0]))) ||
-                (ide.markerFile && fs.existsSync(path.join(projectRoot, ide.markerFile)));
+            // Check Project Root: usar markerFile primero (más preciso), luego rulesDir como fallback
+            const markerInProject = ide.markerFile && fs.existsSync(path.join(projectRoot, ide.markerFile));
+            const rulesDirInProject = ide.rulesDir && fs.existsSync(path.join(projectRoot, ide.rulesDir));
+            const skillsDirInProject = ide.skillsDir && fs.existsSync(path.join(projectRoot, ide.skillsDir));
+            const inProject = markerInProject || rulesDirInProject || skillsDirInProject;
 
-            // Check User Home (Heuristic for installed IDEs)
-            const inHome = (ide.markerFile && fs.existsSync(path.join(userHome, ide.markerFile))) ||
-                (ide.value === 'vscode' && fs.existsSync(path.join(userHome, '.vscode'))) ||
-                (ide.value === 'cursor' && fs.existsSync(path.join(userHome, '.cursor'))) ||
-                (ide.value === 'windsurf' && fs.existsSync(path.join(userHome, '.windsurf'))) ||
-                (ide.value === 'trae' && fs.existsSync(path.join(userHome, '.trae'))) ||
-                (ide.value === 'cline' && fs.existsSync(path.join(userHome, '.cline'))) ||
-                (ide.value === 'roo' && fs.existsSync(path.join(userHome, '.roo')));
+            // Check User Home: usar mapa explícito de rutas de instalación global
+            const homePaths = HOME_PATHS[ide.value] || [];
+            const inHome = homePaths.some(p => fs.existsSync(path.join(userHome, p)));
 
             return inProject || inHome;
         });
@@ -670,6 +687,16 @@ async function runInstall(options) {
             options.installMemory = memoryAnswer.memory;
         }
 
+        // Opción global: sincronizar también a ~/.agents/
+        console.log('');
+        const globalAnswer = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'global',
+            message: '🌐 ¿También sincronizar al repositorio global (~/.agents/)? (Útil para Gemini CLI, Codex y agentes CLI)',
+            default: false
+        }]);
+        if (globalAnswer.global) options.global = true;
+
         console.log('');
         const { confirm } = await inquirer.prompt([{
             type: 'confirm',
@@ -729,11 +756,28 @@ async function runInstall(options) {
                 const relativeCatalogPath = getRelLink(ide.configFile, 'AGENTS.md');
                 const relativeContextPath = getRelLink(ide.configFile, 'CLAUDE.md');
 
-                // console.log(chalk.bold(`\nConfiguring ${ide.name} auto-detect:`));
-                try {
-                    let content = `
-# 🤖 LMAgent Framework v3.0.0
-> Contexto Activo: Este proyecto utiliza el estándar LMAgent V3.
+                // Usar template específico del agente si existe, si no usar contenido genérico
+                const AGENT_CONFIGS_TEMPLATE_DIR = path.join(__dirname, '.agents', 'templates', 'agent-configs');
+                const templateFile = ide.configTemplate
+                    ? path.join(AGENT_CONFIGS_TEMPLATE_DIR, ide.configTemplate)
+                    : path.join(AGENT_CONFIGS_TEMPLATE_DIR, '_generic.md');
+
+                let content;
+                if (fs.existsSync(templateFile) && !ide.configFile.endsWith('.json')) {
+                    // Usar template del archivo, inyectando VERSION
+                    content = fs.readFileSync(templateFile, 'utf8')
+                        .replace(/\{\{VERSION\}\}/g, PKG_VERSION)
+                        .replace(/\{\{MAJOR\}\}/g, PKG_VERSION.split('.')[0]);
+                } else if (ide.configFile.endsWith('.json') && fs.existsSync(templateFile)) {
+                    // JSON: usar template y reemplazar VERSION
+                    content = fs.readFileSync(templateFile, 'utf8')
+                        .replace(/\{\{VERSION\}\}/g, PKG_VERSION)
+                        .replace(/\{\{MAJOR\}\}/g, PKG_VERSION.split('.')[0]);
+                } else {
+                    // Fallback: contenido genérico dinámico
+                    content = `
+# 🤖 LMAgent Framework v${PKG_VERSION}
+> Contexto Activo: Este proyecto utiliza el estándar LMAgent V${PKG_VERSION.split('.')[0]}.
 
 ## 🚨 SOURCE OF TRUTH (CEREBRO)
 **TU CONTEXTO Y REGLAS VIVEN AQUÍ 👉 [AGENTS.md](${relativeCatalogPath})**
@@ -753,7 +797,9 @@ Use estos comandos para activar su rol. Para detalles, consulte \`AGENTS.md\`.
 
 !! SYSTEM NOTE: Read AGENTS.md to understand how to execute these roles. !!
 `;
-                    // If file exists, check if we need to append
+                }
+                // If file exists, check if we need to append
+                try {
                     if (fs.existsSync(configPath)) {
                         // Check if it's a directory (Edge case: Cline legacy folders)
                         if (fs.statSync(configPath).isDirectory()) {
@@ -785,9 +831,16 @@ Use estos comandos para activar su rol. Para detalles, consulte \`AGENTS.md\`.
             console.log(`  ${bootstrapStatus === 'CREATED' ? chalk.green('✔') : chalk.blue('ℹ')} ${ide.name} Bootstrap: ${bootstrapStatus}`);
         }
 
-        // 4.1 Generate Bridge Rule if supported
-        const bridgeFile = ide.bridgeFile || 'lmagent.md';
-        if (ide.rulesDir && bridgeFile) {
+        // 4.1 Generate Bridge Rule
+        // Si el agente NO tiene configFile, necesita un archivo puente en rulesDir para auto-invocarse.
+        // Si tampoco tiene bridgeFile definido, usamos '00-lmagent.md' como default genérico.
+        const bridgeFile = ide.bridgeFile || (ide.rulesDir && !ide.configFile ? '00-lmagent.md' : null);
+        const needsBridge = bridgeFile && !ide.configFile;
+        // Garantizar que rulesDir existe siempre (para que el agente pueda detectar la instalación)
+        if (ide.rulesDir && !fs.existsSync(path.join(targetRoot, ide.rulesDir))) {
+            fs.mkdirSync(path.join(targetRoot, ide.rulesDir), { recursive: true });
+        }
+        if (ide.rulesDir && needsBridge) {
             const bridgePath = path.join(targetRoot, ide.rulesDir, bridgeFile);
             const relativeBridgeToRoot = path.join(ide.rulesDir, bridgeFile);
             const relContext = getRelLink(relativeBridgeToRoot, 'CLAUDE.md');
@@ -805,7 +858,7 @@ globs: **/*
 
 # 🤖 LMAgent Bridge Rule
 
-Este proyecto está potenciado por **LMAgent v3.0.0**.
+Este proyecto está potenciado por **LMAgent v${PKG_VERSION}**.
 
 ## 🚨 SOURCE OF TRUTH (CEREBRO)
 **TU CONTEXTO Y REGLAS VIVEN AQUÍ 👉 [AGENTS.md](${relCatalog})**
@@ -829,7 +882,7 @@ Use estos comandos para activar su rol. Para detalles, consulte \`AGENTS.md\`.
                 // Standard Markdown (Universal & Cline/Windsurf)
                 bridgeContent = `# 🤖 LMAgent Framework Entry Point
 
-Este proyecto utiliza **LMAgent v3.0.0**.
+Este proyecto utiliza **LMAgent v${PKG_VERSION}**.
 
 ## 🚨 SOURCE OF TRUTH (CEREBRO)
 **TU CONTEXTO Y REGLAS VIVEN AQUÍ 👉 [AGENTS.md](${relCatalog})**
@@ -958,15 +1011,18 @@ Use estos comandos para activar su rol. Para detalles, consulte \`AGENTS.md\`.
     console.log(chalk.gray('================================================================'));
     console.log(chalk.bold.green('🎉 ¡Todo listo! Aquí tienes cómo usar tus nuevos superpoderes:'));
     console.log('');
-    console.log(chalk.cyan('🤖  Para Cursor / Windsurf / Trae:'));
-    console.log(chalk.white('    1. Tus skills aparecen como Reglas (.cursorrules, etc.)'));
-    console.log(chalk.white('    2. En el Chat (Ctrl+L) o Composer (Ctrl+I), simplemente pídelo.'));
-    console.log(chalk.gray('       Ej: "Crea un nuevo componente de React" (El agente usará frontend-engineer automáticamente)'));
+
+    // Mensaje dinámico según agentes instalados
+    const ideNames = targetIdes.map(i => i.name).join(', ');
+    console.log(chalk.cyan(`🤖  Agentes configurados: ${chalk.bold(ideNames)}`));
+    console.log('');
+    console.log(chalk.white('    1. Abre tu agente en este proyecto — leerá el contexto automáticamente.'));
+    console.log(chalk.white('    2. Usa los triggers para activar un rol específico:'));
+    console.log(chalk.gray('       /dev → Backend  |  /front → Frontend  |  /arch → Arquitecto'));
+    console.log(chalk.gray('       /fix → Debugger  |  /pm → Product  |  /orch → Orchestrator'));
     console.log('');
-    console.log(chalk.magenta('🧠  Para Antigravity / Claude Code / Agentes Autónomos:'));
-    console.log(chalk.white('    1. El agente lee automáticamente tu carpeta .agent/ o configuración local.'));
-    console.log(chalk.white('    2. Escribe tu petición en lenguaje natural.'));
-    console.log(chalk.gray('       Ej: "Analiza la base de datos" (El agente buscará y usará backend-engineer/data-engineer)'));
+    console.log(chalk.dim('    💡 Ejecuta `lmagent doctor` para verificar la instalación.'));
+    console.log(chalk.dim('    💡 Ejecuta `lmagent tokens` para ver el consumo de tokens del framework.'));
     console.log(chalk.gray('================================================================'));
 }
 
@@ -1181,7 +1237,9 @@ async function runInit(options) {
 
             if (fs.existsSync(srcPath)) {
                 if (!fs.existsSync(destPath)) {
-                    fs.copyFileSync(srcPath, destPath);
+                    let content = fs.readFileSync(srcPath, 'utf8');
+                    if (file.versionTemplate) content = content.replace(/\{\{VERSION\}\}/g, PKG_VERSION);
+                    fs.writeFileSync(destPath, content, 'utf8');
                     console.log(`  ${chalk.green('✔')} ${file.src} (Created)`);
                 } else {
                     // Exists: Ask to overwrite (unless force/yes)
@@ -1199,7 +1257,9 @@ async function runInit(options) {
                     }
 
                     if (shouldOverwrite) {
-                        fs.copyFileSync(srcPath, destPath);
+                        let content = fs.readFileSync(srcPath, 'utf8');
+                        if (file.versionTemplate) content = content.replace(/\{\{VERSION\}\}/g, PKG_VERSION);
+                        fs.writeFileSync(destPath, content, 'utf8');
                         console.log(`  ${chalk.yellow('✎')} ${file.src} (Overwritten)`);
                     } else {
                         console.log(`  ${chalk.gray('SKIP')} ${file.src} (Kept existing)`);
@@ -1266,7 +1326,7 @@ DEBUG=true
     }
 
     // Resumen
-    console.log(gradient.pastel.multiline('\n✨ Proyecto inicializado con LMAgent v3.1.2 ✨'));
+    console.log(gradient.pastel.multiline(`\n✨ Proyecto inicializado con LMAgent v${PKG_VERSION} ✨`));
     console.log('');
     console.log(chalk.cyan('Próximos pasos:'));
     console.log(`  1. ${chalk.bold('lmagent install')} - Instalar skills/rules/workflows en tu IDE`);