@ronaldjdevfs/forge 1.2.0 → 1.3.1

package/src/agents.mjs

@@ -35,6 +35,34 @@ function detect(cwd) {
     detected: existsSync(join(cwd, ".opencode")),
   });
 
+  agents.push({
+    id: "cursor-project",
+    label: "Cursor",
+    scope: "Proyecto",
+    detected: existsSync(join(cwd, ".cursor")) || existsSync(join(cwd, ".cursorrules")),
+  });
+
+  agents.push({
+    id: "codex-project",
+    label: "Codex CLI",
+    scope: "Proyecto",
+    detected: existsSync(join(cwd, ".codex")),
+  });
+
+  agents.push({
+    id: "gemini-project",
+    label: "Gemini Code Assist",
+    scope: "Proyecto",
+    detected: existsSync(join(cwd, ".gemini")),
+  });
+
+  agents.push({
+    id: "agents-project",
+    label: "Agentes Genéricos",
+    scope: "Proyecto",
+    detected: existsSync(join(cwd, ".agents")),
+  });
+
   agents.push({
     id: "copilot-project",
     label: "GitHub Copilot",
@@ -43,7 +71,7 @@ function detect(cwd) {
   });
 
   agents.push({
-    id: "codex",
+    id: "codex-global",
     label: "Codex CLI",
     scope: "Global",
     detected: existsSync(join(HOME, ".codex")),
@@ -52,4 +80,9 @@ function detect(cwd) {
   return agents;
 }
 
-export { detect as detectForWizard };
+function detectAll(cwd) {
+  const all = detect(cwd);
+  return all.filter(a => a.detected).map(a => a.id);
+}
+
+export { detect as detectForWizard, detectAll };

package/src/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { copyFileSync, mkdirSync, existsSync, writeFileSync, readFileSync, cpSync } from "fs";
+import { copyFileSync, mkdirSync, existsSync, writeFileSync, readFileSync, cpSync, readdirSync } from "fs";
 import { join, dirname, relative } from "path";
 import { fileURLToPath } from "url";
 import { execSync } from "child_process";
@@ -11,6 +11,14 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const SKILL_SRC = join(__dirname, "..", "skills", "forge");
 const AGENTS_TEMPLATES = join(SKILL_SRC, "templates", "agents");
 
+const AGENT_CONFIGS = {
+  claude:  { dir: ".claude",  template: "claude",  skillPath: ".claude/skills/forge",  need: ["CLAUDE.md", "settings.local.json"], postInstall: "forgeSentinel" },
+  cursor:  { dir: ".cursor",  template: "cursor",  skillPath: ".cursor/skills/forge",  need: [".cursorrules", "hooks.json"],         postInstall: "forgeSmith" },
+  codex:   { dir: ".agents",  template: "codex",   skillPath: ".agents/skills/forge",  need: ["hooks.json"],                          postInstall: "forgeSentinel" },
+  gemini:  { dir: ".gemini",  template: "gemini",  skillPath: ".gemini/skills/forge",  need: ["SKILL.md"],                            postInstall: null },
+  agents:  { dir: ".agents",  template: "agents",  skillPath: ".agents/skills/forge",  need: ["hooks.json"],                          postInstall: "forgeSentinel" },
+};
+
 function getTargetDir(global) {
   if (global) {
     const home = process.env.HOME || process.env.USERPROFILE;
@@ -78,16 +86,20 @@ function ensureDependencies(configDir) {
 }
 
 const COMMANDS = [
-  { name: "forge-forge", desc: "Forge — inicializar proyecto arquitectónicamente" },
-  { name: "forge-cast", desc: "Cast — crear un nuevo feature hexagonal desde cero" },
-  { name: "forge-inspect", desc: "Inspect — inspeccionar la conformidad arquitectónica" },
-  { name: "forge-relocate", desc: "Relocate — migrar feature legacy a la nueva estructura" },
-  { name: "forge-reforge", desc: "Reforge — refactorizar la arquitectura de un feature" },
-  { name: "forge-quench", desc: "Quench — verificar reglas arquitectónicas del proyecto" },
-  { name: "forge-temper", desc: "Temper — endurecer la arquitectura (DI, seguridad)" },
-  { name: "forge-chain", desc: "Chain — analizar cadena de dependencias entre features" },
-  { name: "forge-inscribe", desc: "Inscribe — generar y mantener ARCHITECTURE.md" },
-  { name: "forge-smelt", desc: "Smelt — extraer código reutilizable a shared/" },
+  { name: "forge-forge", desc: "Forge — inicializar proyecto arquitectónicamente", flags: "" },
+  { name: "forge-cast", desc: "Cast — crear un nuevo feature hexagonal desde cero", flags: "" },
+  { name: "forge-inspect", desc: "Inspect — inspeccionar la conformidad arquitectónica", flags: "--json | --diff | --full | --summary | --severity=<nivel> | --force" },
+  { name: "forge-assay", desc: "Assay — ensayo arquitectónico multi-persona", flags: "--persona=<id> | --json | --save | history" },
+  { name: "forge-graph", desc: "Graph — construir el grafo arquitectónico del proyecto", flags: "--json" },
+  { name: "forge-armorer", desc: "Armorer — reporte de ownership, huérfanos y duplicados", flags: "" },
+  { name: "forge-bootstrap", desc: "Bootstrap — inicializar platform, shared e infra layers", flags: "" },
+  { name: "forge-relocate", desc: "Relocate — migrar feature legacy a la nueva estructura", flags: "" },
+  { name: "forge-reforge", desc: "Reforge — refactorizar la arquitectura de un feature", flags: "--cycles" },
+  { name: "forge-quench", desc: "Quench — verificar reglas arquitectónicas del proyecto", flags: "--fix | --show-ignores | --severity=<nivel> | --json" },
+  { name: "forge-temper", desc: "Temper — endurecer la arquitectura (DI, seguridad)", flags: "" },
+  { name: "forge-chain", desc: "Chain — analizar cadena de dependencias entre features", flags: "--json" },
+  { name: "forge-inscribe", desc: "Inscribe — generar y mantener ARCHITECTURE.md", flags: "--output=<path>" },
+  { name: "forge-smelt", desc: "Smelt — extraer código reutilizable a shared/", flags: "" },
 ];
 
 function generateCommands(configDir) {
@@ -95,7 +107,8 @@ function generateCommands(configDir) {
   mkdirSync(cmdsDir, { recursive: true });
   for (const cmd of COMMANDS) {
     const sub = cmd.name.replace("forge-", "");
-    const content = [
+    const hasFlags = cmd.flags && cmd.flags.length > 0;
+    const lines = [
       "---",
       `description: ${cmd.desc}`,
       "agent: build",
@@ -103,8 +116,16 @@ function generateCommands(configDir) {
       "",
       `Ejecuta el subcomando ${sub} de Forge con los argumentos: $ARGUMENTS`,
       "",
-    ].join("\n");
-    writeFileSync(join(cmdsDir, `${cmd.name}.md`), content);
+    ];
+    if (hasFlags) {
+      lines.push(
+        `Flags disponibles: ${cmd.flags}`,
+        "",
+        `Si $ARGUMENTS está vacío, pregunta al usuario qué flags quiere usar con la tool question (checkboxes múltiples). Si no selecciona ninguna, ejecuta sin flags.`,
+        "",
+      );
+    }
+    writeFileSync(join(cmdsDir, `${cmd.name}.md`), lines.join("\n"));
   }
 }
 
@@ -137,40 +158,70 @@ async function installOpenCode(isGlobal = false) {
   log.success("OpenCode configurado correctamente");
 }
 
-async function installCursor() {
-  const src = join(AGENTS_TEMPLATES, "cursor", ".cursorrules");
-  const dest = join(process.cwd(), ".cursorrules");
+async function installAgentTemplates(agentDir, agentName) {
+  const config = AGENT_CONFIGS[agentName];
+  if (!config) return;
 
-  if (!existsSync(src)) {
-    log.error("Template .cursorrules no encontrado");
-    process.exit(1);
+  const templateDir = join(AGENTS_TEMPLATES, config.template);
+  if (!existsSync(templateDir)) {
+    log.error(`Template para ${agentName} no encontrado en ${templateDir}`);
+    return;
   }
 
   const s = spinner();
-  s.start("Creando .cursorrules");
-  copyFileSync(src, dest);
-  s.stop(".cursorrules creado");
+  s.start(`Copiando templates para ${agentName} en ${agentDir}/`);
+
+  mkdirSync(agentDir, { recursive: true });
+
+  // Copy skill into <agentDir>/skills/forge/
+  const skillDest = join(agentDir, "skills", "forge");
+  cpSync(SKILL_SRC, skillDest, { recursive: true, force: true });
+
+  // Copy template files (hooks, CLAUDE.md, .cursorrules, etc.)
+  for (const entry of readdirSync(templateDir)) {
+    const srcFile = join(templateDir, entry);
+    const destFile = join(agentDir, entry);
+    cpSync(srcFile, destFile, { recursive: true, force: true });
+  }
+
+  // Render SKILL.md with agent-specific path
+  const templatePath = join(AGENTS_TEMPLATES, "SKILL.md.template");
+  if (existsSync(templatePath)) {
+    const template = readFileSync(templatePath, "utf-8");
+    const rendered = template.replace(/\{\{AGENT_PATH\}\}/g, config.skillPath);
+    writeFileSync(join(skillDest, "SKILL.md"), rendered, "utf-8");
+  }
+
+  s.stop(`${agentName} configurado en ${agentDir}/`);
+  log.success(`${agentName} listo (skill + ${config.postInstall || "templates"})`);
+}
 
-  log.success("Cursor configurado correctamente");
+async function installCursor() {
+  await installAgentTemplates(join(process.cwd(), ".cursor"), "cursor");
 }
 
 async function installClaude() {
-  const claudeDir = join(process.cwd(), ".claude");
-  const src = join(AGENTS_TEMPLATES, "claude", "CLAUDE.md");
-  const dest = join(claudeDir, "CLAUDE.md");
+  await installAgentTemplates(join(process.cwd(), ".claude"), "claude");
+}
 
-  if (!existsSync(src)) {
-    log.error("Template CLAUDE.md no encontrado");
-    process.exit(1);
+async function installCodex() {
+  // Codex hooks point to .agents/skills/forge/ via git root
+  await installAgentTemplates(join(process.cwd(), ".agents"), "codex");
+  // Also copy hooks.json into .codex/ so Codex CLI picks it up
+  const codexDir = join(process.cwd(), ".codex");
+  mkdirSync(codexDir, { recursive: true });
+  const hooksSrc = join(AGENTS_TEMPLATES, "codex", "hooks.json");
+  if (existsSync(hooksSrc)) {
+    cpSync(hooksSrc, join(codexDir, "hooks.json"), { force: true });
   }
+}
 
-  const s = spinner();
-  s.start("Creando .claude/CLAUDE.md");
-  mkdirSync(claudeDir, { recursive: true });
-  copyFileSync(src, dest);
-  s.stop(".claude/CLAUDE.md creado");
+async function installGemini() {
+  await installAgentTemplates(join(process.cwd(), ".gemini"), "gemini");
+}
 
-  log.success("Claude Code configurado correctamente");
+async function installAgentsGeneric() {
+  await installAgentTemplates(join(process.cwd(), ".agents"), "agents");
 }
 
 async function installAgents(selected, isGlobal = false) {
@@ -185,6 +236,15 @@ async function installAgents(selected, isGlobal = false) {
       case "claude":
         await installClaude();
         break;
+      case "codex":
+        await installCodex();
+        break;
+      case "gemini":
+        await installGemini();
+        break;
+      case "agents":
+        await installAgentsGeneric();
+        break;
     }
   }
 }
@@ -200,10 +260,19 @@ USO
   forge install --opencode         Instalar solo para OpenCode
   forge install --cursor           Instalar solo para Cursor
   forge install --claude           Instalar solo para Claude Code
-  forge install --all              Instalar para todos los agentes
+  forge install --codex            Instalar solo para Codex CLI
+  forge install --gemini           Instalar solo para Gemini Code Assist
+  forge install --all              Instalar para todos los agentes detectados
   forge install --global           Instalar OpenCode globalmente (~/.config/opencode/)
   forge install --help             Mostrar esta ayuda
 
+AGENTES SOPORTADOS
+  OpenCode, Claude Code, Cursor, Codex CLI, Gemini Code Assist, Agentes Genéricos
+
+HOOKS
+  forgeSentinel (PostToolUse) — guardia arquitectónico post-escritura
+  forgeSmith    (preToolUse)  — guardia arquitectónico pre-escritura (Cursor)
+
 OPCIONES
   -g, --global                     Instalar OpenCode en ~/.config/opencode/skills/forge/
   -h, --help                       Mostrar esta ayuda
@@ -223,6 +292,8 @@ async function main() {
   const hasOpenCode = args.includes("--opencode");
   const hasCursor   = args.includes("--cursor");
   const hasClaude   = args.includes("--claude");
+  const hasCodex    = args.includes("--codex");
+  const hasGemini   = args.includes("--gemini");
   const hasAll      = args.includes("--all");
 
   const subcommandIndex = args.indexOf("skills");
@@ -230,12 +301,14 @@ async function main() {
 
   if (command === "install") {
     if (hasAll) {
-      await installAgents(["opencode", "cursor", "claude"], isGlobal);
-    } else if (hasOpenCode || hasCursor || hasClaude) {
+      await installAgents(["opencode", "cursor", "claude", "codex", "gemini", "agents"], isGlobal);
+    } else if (hasOpenCode || hasCursor || hasClaude || hasCodex || hasGemini) {
       const selected = [];
       if (hasOpenCode) selected.push("opencode");
       if (hasCursor) selected.push("cursor");
       if (hasClaude) selected.push("claude");
+      if (hasCodex) selected.push("codex");
+      if (hasGemini) selected.push("gemini");
       await installAgents(selected, isGlobal);
     } else {
       await runWizard();

package/src/wizard.mjs

@@ -93,6 +93,56 @@ function copyAgentTemplate(name, dest) {
   }
 }
 
+const AGENT_SKILL_PATHS = {
+  claude: ".claude/skills/forge",
+  cursor: ".cursor/skills/forge",
+  codex:  ".agents/skills/forge",
+  gemini: ".gemini/skills/forge",
+  agents: ".agents/skills/forge",
+};
+
+function installAgentTemplates(agentDir, agentName) {
+  const templateDir = join(AGENTS_TEMPLATES, agentName);
+  if (!existsSync(templateDir)) {
+    return { ok: false, error: `Template ${agentName} no encontrado` };
+  }
+  mkdirSync(agentDir, { recursive: true });
+  // Copy skill into <agentDir>/skills/forge/
+  const skillDest = join(agentDir, "skills", "forge");
+  cpSync(SKILL_SRC, skillDest, { recursive: true, force: true });
+  // Copy template files (hooks, CLAUDE.md, .cursorrules, etc.)
+  copyAgentTemplate(agentName, agentDir);
+
+  // Render SKILL.md with agent-specific path
+  const templatePath = join(AGENTS_TEMPLATES, "SKILL.md.template");
+  if (existsSync(templatePath)) {
+    const template = readFileSync(templatePath, "utf-8");
+    const skillPath = AGENT_SKILL_PATHS[agentName] || agentName;
+    const rendered = template.replace(/\{\{AGENT_PATH\}\}/g, skillPath);
+    writeFileSync(join(skillDest, "SKILL.md"), rendered, "utf-8");
+  }
+
+  // Codex special case: also copy hooks.json to .codex/
+  if (agentName === "codex") {
+    const codexDir = join(process.cwd(), ".codex");
+    mkdirSync(codexDir, { recursive: true });
+    const hooksSrc = join(templateDir, "hooks.json");
+    if (existsSync(hooksSrc)) {
+      cpSync(hooksSrc, join(codexDir, "hooks.json"), { force: true });
+    }
+  }
+
+  return { ok: true, dest: agentDir };
+}
+
+const HOOK_LABELS = {
+  claude: "forgeSentinel (PostToolUse)",
+  cursor: "forgeSmith (preToolUse)",
+  codex:  "forgeSentinel (PostToolUse)",
+  gemini: "—",
+  agents: "forgeSentinel (PostToolUse)",
+};
+
 // --- Welcome ---
 
 async function welcomePhase() {
@@ -235,6 +285,10 @@ async function summaryPhase(agentSelection) {
     console.log(`  ${pc.bold("Componentes")}`);
     console.log();
 
+    const hasHooks = agentSelection.selectedIds.some(id =>
+      ["claude-project", "claude-global", "cursor-project", "codex-project", "codex-global", "agents-project"].includes(id)
+    );
+
     const components = [
       "Forge Skill",
       "Reglas",
@@ -242,7 +296,8 @@ async function summaryPhase(agentSelection) {
       "Comandos",
       "Plantillas",
       "Agentes",
-    ];
+      hasHooks ? "forgeSentinel (PostToolUse) / forgeSmith (preToolUse)" : null,
+    ].filter(Boolean);
     for (const comp of components) {
       console.log(`  ${pc.green("\u2714")} ${comp}`);
     }
@@ -275,102 +330,97 @@ async function summaryPhase(agentSelection) {
 
 // --- Installation ---
 
+const AGENT_MAP = {
+  "claude-global":    { name: "claude", dir: () => join(HOME, ".claude"), verify: "CLAUDE.md" },
+  "claude-project":   { name: "claude", dir: () => join(process.cwd(), ".claude"), verify: "CLAUDE.md" },
+  "cursor-project":   { name: "cursor", dir: () => join(process.cwd(), ".cursor"), verify: ".cursorrules" },
+  "codex-project":    { name: "codex",  dir: () => join(process.cwd(), ".agents"),  verify: "hooks.json" },
+  "codex-global":     { name: "codex",  dir: () => join(HOME, ".codex"),            verify: "hooks.json" },
+  "gemini-project":   { name: "gemini", dir: () => join(process.cwd(), ".gemini"), verify: "SKILL.md" },
+  "agents-project":   { name: "agents", dir: () => join(process.cwd(), ".agents"), verify: "hooks.json" },
+  "opencode-global":  null,
+  "opencode-project": null,
+  "copilot-project":  null,
+};
+
 function buildAgentSteps(agent, cwd) {
   const label = `${agent.label} (${agent.scope})`;
   const s = (title, fn) => ({ title: `${pc.dim("\u2502")} ${title}`, task: fn });
 
-  switch (agent.id) {
-    case "claude-global":
-    case "claude-project": {
-      const dest = agent.id === "claude-global" ? join(HOME, ".claude") : join(cwd, ".claude");
-      const steps = [];
-      steps.push(s("Copiando Forge en .claude/", async () => {
-        mkdirSync(dest, { recursive: true });
-        copyAgentTemplate("claude", dest);
-        cpSync(SKILL_SRC, join(dest, "forge"), { recursive: true, force: true });
-        return "Forge instalado en .claude/";
-      }));
-      steps.push(s("Verificando instalaci\u00f3n", async () => {
-        const ok = existsSync(join(dest, "CLAUDE.md"));
-        return ok ? "\u2714 Instalaci\u00f3n verificada" : "ERROR: CLAUDE.md no encontrado";
-      }));
-      return { label, dest, steps };
-    }
-
-    case "opencode-global": {
-      const dest = join(HOME, ".config", "opencode", "skills", "forge");
-      const configDir = join(HOME, ".config", "opencode");
-      const steps = [];
-      steps.push(s("Copiando Skill en opencode/", async () => {
-        mkdirSync(dest, { recursive: true });
-        cpSync(SKILL_SRC, dest, { recursive: true, force: true });
-        return "Skill copiada";
-      }));
-      steps.push(s("Registrando comandos + dependencias", async () => {
-        generateCommands(configDir);
-        ensureDependencies(configDir);
-        return "Comandos y dependencias listos";
-      }));
-      steps.push(s("Verificando instalaci\u00f3n", async () => {
-        const ok = existsSync(join(dest, "scripts", "context.mjs"));
-        return ok ? "\u2714 Instalaci\u00f3n verificada" : "ERROR: Skill no encontrada";
-      }));
-      return { label, dest, steps };
-    }
+  // Handle special cases (opencode, copilot) separately
+  if (agent.id === "opencode-global") {
+    const dest = join(HOME, ".config", "opencode", "skills", "forge");
+    const configDir = join(HOME, ".config", "opencode");
+    const steps = [];
+    steps.push(s("Copiando Skill en opencode/", async () => {
+      mkdirSync(dest, { recursive: true });
+      cpSync(SKILL_SRC, dest, { recursive: true, force: true });
+      return "Skill copiada";
+    }));
+    steps.push(s("Registrando comandos + dependencias", async () => {
+      generateCommands(configDir);
+      ensureDependencies(configDir);
+      return "Comandos y dependencias listos";
+    }));
+    steps.push(s("Verificando instalaci\u00f3n", async () => {
+      const ok = existsSync(join(dest, "scripts", "context.mjs"));
+      return ok ? "\u2714 Instalaci\u00f3n verificada" : "ERROR: Skill no encontrada";
+    }));
+    return { label, dest, steps };
+  }
 
-    case "opencode-project": {
-      const dest = join(cwd, ".opencode", "skills", "forge");
-      const configDir = join(cwd, ".opencode");
-      const steps = [];
-      steps.push(s("Copiando Skill en .opencode/", async () => {
-        mkdirSync(dest, { recursive: true });
-        cpSync(SKILL_SRC, dest, { recursive: true, force: true });
-        return "Skill copiada";
-      }));
-      steps.push(s("Registrando comandos + dependencias", async () => {
-        generateCommands(configDir);
-        ensureDependencies(configDir);
-        return "Comandos y dependencias listos";
-      }));
-      steps.push(s("Verificando instalaci\u00f3n", async () => {
-        const ok = existsSync(join(dest, "scripts", "context.mjs"));
-        return ok ? "\u2714 Instalaci\u00f3n verificada" : "ERROR: Skill no encontrada";
-      }));
-      return { label, dest, steps };
-    }
+  if (agent.id === "opencode-project") {
+    const dest = join(cwd, ".opencode", "skills", "forge");
+    const configDir = join(cwd, ".opencode");
+    const steps = [];
+    steps.push(s("Copiando Skill en .opencode/", async () => {
+      mkdirSync(dest, { recursive: true });
+      cpSync(SKILL_SRC, dest, { recursive: true, force: true });
+      return "Skill copiada";
+    }));
+    steps.push(s("Registrando comandos + dependencias", async () => {
+      generateCommands(configDir);
+      ensureDependencies(configDir);
+      return "Comandos y dependencias listos";
+    }));
+    steps.push(s("Verificando instalaci\u00f3n", async () => {
+      const ok = existsSync(join(dest, "scripts", "context.mjs"));
+      return ok ? "\u2714 Instalaci\u00f3n verificada" : "ERROR: Skill no encontrada";
+    }));
+    return { label, dest, steps };
+  }
 
-    case "copilot-project": {
-      const ghDir = join(cwd, ".github");
-      const dest = join(ghDir, "copilot-instructions.md");
-      const steps = [];
-      steps.push(s("Instalando reglas en .github/", async () => {
-        mkdirSync(ghDir, { recursive: true });
-        const src = join(AGENTS_TEMPLATES, "cursor", ".cursorrules");
-        if (existsSync(src)) copyFileSync(src, dest);
-        const ok = existsSync(dest);
-        return ok ? "Reglas instaladas" : "ERROR";
-      }));
-      return { label, dest, steps };
-    }
+  if (agent.id === "copilot-project") {
+    const ghDir = join(cwd, ".github");
+    const dest = join(ghDir, "copilot-instructions.md");
+    const steps = [];
+    steps.push(s("Instalando reglas en .github/", async () => {
+      mkdirSync(ghDir, { recursive: true });
+      const src = join(AGENTS_TEMPLATES, "cursor", ".cursorrules");
+      if (existsSync(src)) copyFileSync(src, dest);
+      const ok = existsSync(dest);
+      return ok ? "Reglas instaladas" : "ERROR";
+    }));
+    return { label, dest, steps };
+  }
 
-    case "codex": {
-      const dest = join(HOME, ".codex");
-      const steps = [];
-      steps.push(s("Instalando Forge en .codex/", async () => {
-        mkdirSync(dest, { recursive: true });
-        copyAgentTemplate("cursor", dest);
-        cpSync(SKILL_SRC, join(dest, "forge"), { recursive: true, force: true });
-        return "Forge instalado";
-      }));
-      steps.push(s("Verificando instalaci\u00f3n", async () => {
-        return existsSync(dest) ? "\u2714 Instalaci\u00f3n verificada" : "ERROR";
-      }));
-      return { label, dest, steps };
-    }
+  // Generic agent types via AGENT_MAP
+  const map = AGENT_MAP[agent.id];
+  if (!map) return null;
 
-    default:
-      return null;
-  }
+  const dest = map.dir();
+  const agentName = map.name;
+  const steps = [];
+  steps.push(s(`Instalando Forge + hooks en ${dest}/`, async () => {
+    const r = installAgentTemplates(dest, agentName);
+    return r.ok ? `Forge + ${HOOK_LABELS[agentName] || "templates"} instalados` : `ERROR: ${r.error}`;
+  }));
+  steps.push(s("Verificando instalaci\u00f3n", async () => {
+    const ok = existsSync(join(dest, "skills", "forge", "scripts", "context.mjs")) &&
+               existsSync(join(dest, map.verify));
+    return ok ? "\u2714 Instalaci\u00f3n verificada" : "ERROR: archivos no encontrados";
+  }));
+  return { label, dest, steps };
 }
 
 async function installPhase(result, cwd) {
@@ -465,7 +515,9 @@ export async function runWizard() {
   console.log();
   console.log(`  \u2022 Reinicia tu agente si est\u00e1 abierto.`);
   console.log(`  \u2022 Ejecut\u00e1 el comando "forge" dentro del agente.`);
-  console.log(`  \u2022 Consult\u00e1 la documentaci\u00f3n para comenzar.`);
+  console.log(`  \u2022 forgeSentinel se activa autom\u00e1ticamente tras cada escritura.`);
+  console.log(`  \u2022 forgeSmith (Cursor) previene escrituras con violaciones CRITICAL.`);
+  console.log(`  \u2022 Gesti\u00f3n de hooks: node .<agent>/skills/forge/scripts/forgeSmith-admin.mjs`);
   console.log();
   console.log("  " + SEP);
   console.log();