@thebattlearena/battle-arena-hooks 0.5.2 → 0.5.3-beta.37

package/.claude-plugin/marketplace.json

@@ -0,0 +1,13 @@
+{
+  "name": "battlearena-local",
+  "owner": {
+    "name": "Battle Arena"
+  },
+  "plugins": [
+    {
+      "name": "battlearena",
+      "source": "./plugin",
+      "description": "Battle Arena en Claude Code"
+    }
+  ]
+}

package/README.md

@@ -1,25 +1,117 @@
-# Hooks de Claude Code (Battle Arena)
+# Battle Arena en Claude Code (plugin `battlearena`)
 
-Scripts **zero-dependency** que corren en la máquina de cada dev y emiten los eventos de las
-sesiones de Claude Code al colector (`apps/public-api`). NO les agregues imports de
-node_modules: la promesa es instalación-cero.
+Este paquete instala **Battle Arena en Claude Code** como un solo plugin, `battlearena`: los hooks que
+mandan tus sesiones al colector (`apps/public-api`), las skills del equipo y el **Scorecard** de tu día
+junto al chat. Las skills quedan con el espacio de nombres del plugin (`/battlearena:conquer`), así no
+chocan con las de otros plugins y en el autocompletado salen todas juntas al escribir `/battlearena`.
 
-| Script                      | Hook             | Qué hace                                                                                                                                                                        |
-| --------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `emit.mjs`                  | todos            | Enriquece con identidad git, sanitiza y postea a `/ingest`; buffer local si el colector no responde                                                                             |
-| `session-start.mjs`         | SessionStart     | Handshake + inyecta ranking (`/v1/leaderboard/rank`) y alerta de rama protegida                                                                                                 |
-| `check-connection.mjs`      | UserPromptSubmit | Avisa si hay desconexión o eventos en cola                                                                                                                                      |
-| `objective-nudge.mjs`       | UserPromptSubmit | Recuerda invocar la skill `arena-objective`                                                                                                                                     |
-| `execution-coach-nudge.mjs` | UserPromptSubmit | Detecta señales de ejecución subóptima en el transcript y, con throttle por sesión, sugiere invocar la skill `execution-coach`                                                  |
-| `pr-review-worktree.mjs`    | PostToolUse      | Al detectar `gh pr create`, inyecta contexto para OFRECER (opt-in) la skill `pr-review-loop`; no crea worktrees ni lanza nada (de eso se encarga la skill si el usuario acepta) |
+```bash
+npx @thebattlearena/battle-arena-hooks@latest install \
+  --url https://api.battlearena.dev --api-key <tu-llave>
+```
+
+La llave se genera en [battlearena.dev/api-keys](https://battlearena.dev/api-keys). Para quitarlo:
+`npx @thebattlearena/battle-arena-hooks uninstall`.
+
+## Qué trae el plugin
+
+### Skills
+
+Se invocan escribiendo el comando o pidiéndolo con tus palabras («arma mi plan de mañana»).
+
+| Skill                               | Para qué sirve                                                                                                                                                                                                                                                                                                                                                                                        |
+| ----------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `/battlearena:conquer`              | Arma o actualiza tu **plan de batalla** del siguiente día hábil (o el de **hoy**, si aún no tienes: antes de las 16:00 te pregunta cuál): revisa lo que hiciste hoy (git, tus sesiones de Claude, tus pendientes), te entrevista tema por tema (valor de negocio, DoD, ≤ 3 h, riesgos) y crea tu ticket del día (el de mañana, desde las 16:00 de la víspera) en Linear y tu orden de batalla en PDF. |
+| `/battlearena:arena-objective`      | Etiqueta el **objetivo del turno** (nuevo o continuación) y lo manda al colector, para que tu actividad se agrupe por objetivo. Claude la usa solo al inicio de cada turno; no hace falta llamarla.                                                                                                                                                                                                   |
+| `/battlearena:arena-self-review`    | Tu **revisión semanal de desempeño**, self-service: lee tu actividad de la semana desde el MCP de Battle Arena y te da una autocrítica con evidencia.                                                                                                                                                                                                                                                 |
+| `/battlearena:execution-coach`      | **Interceptor mayéutico** durante la ejecución: te frena con preguntas cuando el pedido es vago o la sesión da vueltas sin converger. Se activa sola cuando el hook detecta esas señales.                                                                                                                                                                                                             |
+| `/battlearena:scope-technical-task` | **Coach de alcance antes de codear**: problema de negocio, sub-problemas, soluciones sin código, estimación en horas.                                                                                                                                                                                                                                                                                 |
+| `/battlearena:pr-review-loop`       | Atiende la **review de Copilot** de un PR en segundo plano (corrige → gates → commit → resolver hilos → re-review). Siempre opt-in: pregunta antes y cuántas iteraciones tolera.                                                                                                                                                                                                                      |
+
+### Comandos
 
-Skills distribuidas con el paquete (se copian a `~/.claude/skills/`): `arena-objective`,
-`arena-self-review`, `execution-coach` (interceptor mayéutico durante la ejecución),
-`scope-technical-task` (coach de alcance pre-ejecución; el interceptor le hace handoff) y
-`pr-review-loop` (atiende la review de Copilot de un PR: corrige → gates → commit → responder/resolver
-hilos → re-review, hasta converger).
+| Comando            | Para qué sirve                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `/scorecard`       | Abre el **Scorecard**: la pelea de tu día junto al chat. Tu plan con el avance y el tiempo de cada punto contra lo comprometido (semáforo verde · amarillo · rojo), los emergentes (clic para ver su motivo), los riesgos siempre visibles con ✋ Levantar la mano y 👍/👎, y el pie con Plan · Reuniones · Fuera · Total. Pestaña **Semana** con tus hábitos. Sin datos, te dice el **siguiente paso** (instalar, armar el plan, entrar a la daily). |
+| `/scorecard-demo`  | El Scorecard con datos de muestra; otra vez, vuelve a tus datos.                                                                                                                                                                                                                                                                                                                                                                                      |
+| `/scorecard-empty` | Cómo ve el Scorecard alguien sin hooks; otra vez, vuelve a tus datos.                                                                                                                                                                                                                                                                                                                                                                                 |
 
-### PR review loop (`pr-review-worktree` + skill `pr-review-loop`)
+Arriba del prompt sale además una **banda** compacta del Scorecard (`LER-640 ✓1 ◐1 ↷1 ⚠1 [Abrir]`).
+Los comandos del Scorecard no llevan el prefijo del plugin (así registra Claude Code los comandos de
+un módulo), por eso su nombre ya es único.
+
+### Hooks
+
+Scripts **zero-dependency** que corren en la máquina de cada dev. NO les agregues imports de
+node_modules: la promesa es instalación-cero. Viven junto al plugin y su `hooks/hooks.json` los
+llama con `node "${CLAUDE_PLUGIN_ROOT}/../<script>"`.
+
+| Script                      | Hook             | Qué hace                                                                                                 |
+| --------------------------- | ---------------- | -------------------------------------------------------------------------------------------------------- |
+| `emit.mjs`                  | todos            | Enriquece con identidad git, sanitiza y postea a `/ingest`; buffer local si el colector no responde      |
+| `session-start.mjs`         | SessionStart     | Handshake + inyecta ranking (`/v1/leaderboard/rank`) y alerta de rama protegida                          |
+| `check-connection.mjs`      | UserPromptSubmit | Avisa si hay desconexión o eventos en cola                                                               |
+| `objective-nudge.mjs`       | UserPromptSubmit | Recuerda invocar `battlearena:arena-objective`                                                           |
+| `execution-coach-nudge.mjs` | UserPromptSubmit | Detecta señales de ejecución subóptima y, con throttle por sesión, sugiere `battlearena:execution-coach` |
+| `pr-review-worktree.mjs`    | PostToolUse      | Al detectar `gh pr create`, ofrece (opt-in) `battlearena:pr-review-loop`; no lanza nada por sí solo      |
+
+Helpers que usan las skills: `objective.mjs` (el objetivo del turno) y `plan.mjs` (actividad local de
+git y el PDF de la orden de batalla de `/battlearena:conquer`).
+
+### Estructura
+
+```
+apps/claude-hooks/
+  cli.mjs  install.sh  *.mjs  lib/       el paquete npm y los scripts de los hooks
+  .claude-plugin/marketplace.json        marketplace local: battlearena → ./plugin
+  plugin/
+    .claude-plugin/plugin.json           { name: "battlearena" }
+    hooks/hooks.json                     los hooks de comando + el módulo del Scorecard
+    hooks/register.tsx …                 el Scorecard (panel, banda, comandos)
+    skills/                              las skills (las genera `npm run bundle:skill`)
+    tests/                               pruebas del Scorecard (`claude plugin test plugin`)
+```
+
+### Plan de batalla (skill `/battlearena:conquer` + `plan.mjs`, ADR-0042)
+
+`/conquer` (o «arma mi plan de mañana») arma tu plan del siguiente día hábil como estratega: revisa
+lo que hiciste hoy, te propone los pendientes con su explicación y su ticket, y por cada tema pide
+contexto en Linear, valor, DoD no ambiguo, duración (≤ 3 h o «divide y vencerás» en subtareas) y
+riesgos. **El de mañana se completa desde las 16:00 (CDMX) de la víspera** (fin de semana libre);
+antes solo guarda el borrador.
+
+**¿Hoy o mañana?** De lunes a viernes antes de las 16:00, si aún no tienes plan de hoy, te pregunta
+cuál armar (hoy, recomendado); desde las 16:00 o con el de hoy ya hecho, arma el de mañana. También
+puedes pedirlo directo («arma mi plan de hoy»). El plan de hoy se completa al momento y entra a tu
+reloj del día y a los recordatorios.
+
+Cómo habla:
+
+- **Conector MCP de Battle Arena** (claude.ai → Settings → Connectors, o `/mcp`): `plan_pending`,
+  `plan_my_day`, `plan_get`, `plan_save_draft`, `plan_can_complete`, `plan_complete`,
+  `plan_reopen`, `board_add`, `plan_summary`. Identidad = tu cuenta OAuth (sin api-key).
+- **Conector de Linear**, como tú: busca tus tickets y, al completar, crea «tu ticket del día»
+  (`conquest:daily`) con el borrador que da `plan_can_complete`. Lo que no tiene ticket NO se crea:
+  va al tablero de la PM (`board_add`).
+- **`plan.mjs`, solo local** (sin api-key ni red):
+
+```bash
+node plan.mjs local-activity [--repo <ruta>]…   # git de hoy SOLO en esas rutas (sin --repo, el cwd):
+                                               # rama, commits con tu email (máx. 10), archivos sin
+                                               # commit (solo nombres, máx. 20) y con `gh` el PR de
+                                               # la rama actual + los tuyos de los últimos 5 hábiles
+node plan.mjs pdf --file summary.json [--reviewer <PM>] [--out <carpeta>] [--no-open]
+```
+
+`pdf` arma la «orden de batalla» (diseño A4 · Primero lo importante) con lo de `plan_summary`: HTML
+con el logo embebido y, si la máquina tiene Chrome/Chromium/Edge (`BATTLE_ORDER_CHROME` para otra
+ruta), el PDF con `--headless --print-to-pdf` en `~/Documents/Battle Arena/`. Sin navegador deja el
+HTML listo para «Imprimir → Guardar como PDF». Es solo para ti: no se sube.
+
+Su **fuente única** vive en este paquete: `skill/conquer/SKILL.md` (en el repo,
+`.claude/skills/conquer` es un symlink hacia ella y `bundle:skill` no la toca).
+
+### PR review loop (`pr-review-worktree` + skill `battlearena:pr-review-loop`)
 
 Al crear un PR con `gh pr create`, el hook `pr-review-worktree` **sugiere** (no lanza) activar la skill
 `pr-review-loop`. Es **opt-in**: la skill primero **pregunta** al usuario si quiere activarlo,
@@ -74,39 +166,38 @@ que corren las dos suites: `yarn workspace @thebattlearena/battle-arena-hooks te
   Tras un envío exitoso con la key nueva, el flag se limpia solo. Lógica compartida en
   `lib/reauth.mjs`.
 
-## Instalación rápida
-
-La forma recomendada (cualquier SO, sin clonar) es el paquete npm — ver README raíz:
+## Instalación
 
 ```bash
 npx @thebattlearena/battle-arena-hooks@latest install \
-  --url https://api.battlearena.dev --api-key sk_xxx
+  --url https://api.battlearena.dev --api-key <tu-llave>
 ```
 
-Desde el clone, el equivalente para contribuidores:
+Requiere Claude Code CLI (`claude` en el PATH) y node ≥ 18. El instalador:
 
-```bash
-HOOK_STREAM_URL=https://api.battlearena.dev \
-HOOK_STREAM_API_KEY=sk_xxx \
-bash apps/claude-hooks/install.sh
-```
+1. Copia los scripts y el plugin a `~/.claude/battle-arena/hooks/` (la misma ruta de antes).
+2. Guarda la url y la llave en `~/.claude/battle-arena/config.json`.
+3. **Limpia la versión anterior:** quita sus hooks de `~/.claude/settings.json` (si no, cada evento se
+   mandaría dos veces) y mueve sus skills sueltas de `~/.claude/skills` a
+   `~/.claude/battle-arena/legacy-skills/<fecha>/` (respaldo, no las borra).
+4. Registra la carpeta como marketplace local e instala `battlearena@battlearena-local` para tu usuario
+   (`claude plugin marketplace add` + `claude plugin install --scope user`). Se lee directo de esa
+   carpeta: para actualizar basta volver a correr el instalador y `/reload-plugins`.
+
+Desde el clone (contribuidores): `HOOK_STREAM_URL=… HOOK_STREAM_API_KEY=… bash apps/claude-hooks/install.sh`.
+Para probar el plugin sin instalarlo: `npm run bundle:skill` y `claude --plugin-dir apps/claude-hooks/plugin`.
 
 ## Configuración
 
-El instalador (`cli.mjs`) guarda el endpoint + api-key en
-`~/.claude/battle-arena/config.json` y registra los hooks en `~/.claude/settings.json` con
-comandos `node "<ruta>"` (sin `VAR=valor` inline, que no existe en Windows). Los hooks leen, en
-orden de prioridad:
+Los hooks y el Scorecard leen, en orden de prioridad:
 
 1. **Variables de entorno** `HOOK_STREAM_URL` / `HOOK_STREAM_API_KEY` (si están seteadas).
-2. **`config.json`** (`{ "url": "...", "apiKey": "..." }`).
+2. **`~/.claude/battle-arena/config.json`** (`{ "url": "...", "apiKey": "..." }`), que escribe el instalador.
 3. Default `http://127.0.0.1:4500`.
 
 `HOOK_STREAM_API_KEY` con `ARENA_REQUIRE_AUTH=true` necesita scopes `arena:read`
-(handshake/ranking) y `arena:write` (objetivos); `/ingest` acepta cualquier api-key válida.
-
-El nudge de objetivos requiere además instalar la skill `arena-objective` en cada repo (o
-global en `~/.claude/skills/`): ver `docs/how-to/install-arena-objective-skill.md`.
+(handshake, ranking, Scorecard), `arena:write` (objetivos) y `arena:hands` (✋ desde el Scorecard);
+`/ingest` acepta cualquier api-key válida.
 
 ## Cutover desde el colector legacy (speech-analytics/tooling/hook-stream)
 

package/cli.mjs

@@ -1,16 +1,17 @@
 #!/usr/bin/env node
 // CLI del paquete @thebattlearena/battle-arena-hooks.
-// Instala los hooks + skill del Battle Arena en ~/.claude SIN clonar el repo.
+// Instala Battle Arena en Claude Code como el plugin `battlearena` SIN clonar el repo: los hooks,
+// las skills (/battlearena:conquer, …) y el Scorecard de tu día, todo en un solo plugin.
 //
 //   npx @thebattlearena/battle-arena-hooks install \
 //     --url https://api.battlearena.dev --api-key sk_xxx
+//   npx @thebattlearena/battle-arena-hooks uninstall
 //
 // (también lee HOOK_STREAM_URL / HOOK_STREAM_API_KEY del entorno)
 import {
   cpSync,
   existsSync,
   mkdirSync,
-  readdirSync,
   readFileSync,
   writeFileSync,
 } from 'node:fs';
@@ -18,6 +19,15 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execFileSync } from 'node:child_process';
 import os from 'node:os';
+import {
+  copyPlugin,
+  hasClaudeCli,
+  moveLegacySkills,
+  PLUGIN_ID,
+  registerPlugin,
+  unregisterPlugin,
+  withoutLegacyHooks,
+} from './lib/plugin-install.mjs';
 
 const PKG_DIR = dirname(fileURLToPath(import.meta.url));
 const HOME = os.homedir();
@@ -35,6 +45,7 @@ const HOOK_FILES = [
   'execution-coach-nudge.mjs',
   'pr-review-worktree.mjs',
   'objective.mjs',
+  'plan.mjs',
 ];
 
 function arg(name) {
@@ -52,97 +63,110 @@ function gitEmail() {
   }
 }
 
+/** Quita de settings.json los hooks de la versión anterior (ahora los trae el plugin). */
+function cleanLegacyHooks() {
+  if (!existsSync(SETTINGS)) return 0;
+  const { settings, removed } = withoutLegacyHooks(
+    JSON.parse(readFileSync(SETTINGS, 'utf8')),
+  );
+  if (removed)
+    writeFileSync(SETTINGS, JSON.stringify(settings, null, 2) + '\n');
+  return removed;
+}
+
+function cleanLegacy() {
+  const removed = cleanLegacyHooks();
+  if (removed)
+    console.log(
+      `🧹 ${removed} hooks de la versión anterior quitados de ${SETTINGS}`,
+    );
+  const backup = join(BA_DIR, 'legacy-skills', String(Date.now()));
+  const moved = moveLegacySkills(SKILLS_DEST, backup);
+  if (moved.length)
+    console.log(`🧹 skills sueltas movidas a ${backup}: ${moved.join(', ')}`);
+}
+
 function install() {
   const url =
     arg('url') || process.env.HOOK_STREAM_URL || 'https://api.battlearena.dev';
   const key = arg('api-key') || process.env.HOOK_STREAM_API_KEY || '';
 
+  if (!hasClaudeCli()) {
+    console.error(
+      '❌ No encontré el comando `claude` (Claude Code CLI). Instálalo y vuelve a correr este instalador:\n' +
+        '   https://docs.claude.com/en/docs/claude-code/setup',
+    );
+    process.exit(1);
+  }
   if (!gitEmail()) {
     console.log(
       '⚠️  git config user.email vacío — configúralo: es tu identidad en el arena.',
     );
   }
 
-  // 1) Hooks → ~/.claude/battle-arena/hooks (ubicación estable)
+  // 1) Scripts de los hooks → ~/.claude/battle-arena/hooks (las skills los buscan ahí)
   mkdirSync(HOOKS_DEST, { recursive: true });
   for (const f of HOOK_FILES) cpSync(join(PKG_DIR, f), join(HOOKS_DEST, f));
   cpSync(join(PKG_DIR, 'lib'), join(HOOKS_DEST, 'lib'), { recursive: true });
-  console.log(`✅ hooks copiados a ${HOOKS_DEST}`);
-
-  // 2) Skills del paquete → ~/.claude/skills (cada subcarpeta de skill/*)
-  const skillsRoot = join(PKG_DIR, 'skill');
-  if (existsSync(skillsRoot)) {
-    mkdirSync(SKILLS_DEST, { recursive: true });
-    const skillDirs = readdirSync(skillsRoot, { withFileTypes: true }).filter(
-      (d) => d.isDirectory(),
-    );
-    for (const d of skillDirs) {
-      cpSync(join(skillsRoot, d.name), join(SKILLS_DEST, d.name), {
-        recursive: true,
-      });
-      console.log(`✅ skill ${d.name} instalada en ${SKILLS_DEST}`);
-    }
-  }
 
-  // 3) Config (url + api-key) → ~/.claude/battle-arena/config.json. Los hooks lo leen de ahí.
-  //    Evita hornear `VAR=val node ...` en el comando, sintaxis que NO existe en Windows
-  //    (cmd/PowerShell). Así el comando es solo `node "<ruta>"`, idéntico en los 3 SOs.
+  // 2) El plugin (hooks, skills y Scorecard) y su marketplace local, junto a los scripts
+  copyPlugin(PKG_DIR, HOOKS_DEST);
+
+  // 3) Config (url + api-key) → ~/.claude/battle-arena/config.json. Los hooks y el Scorecard lo leen
+  //    de ahí; así el comando es solo `node "<ruta>"`, idéntico en los 3 SOs.
   writeFileSync(
     join(BA_DIR, 'config.json'),
     JSON.stringify({ url, apiKey: key || undefined }, null, 2) + '\n',
   );
 
-  // 4) Hooks en ~/.claude/settings.json (merge idempotente, sin pisar otros)
-  const cmd = (f) => `node "${join(HOOKS_DEST, f)}"`;
-  const map = {
-    SessionStart: ['session-start.mjs'],
-    UserPromptSubmit: [
-      'emit.mjs',
-      'check-connection.mjs',
-      'objective-nudge.mjs',
-      'execution-coach-nudge.mjs',
-    ],
-    PreToolUse: ['emit.mjs'],
-    PostToolUse: ['emit.mjs', 'pr-review-worktree.mjs'],
-    Notification: ['emit.mjs'],
-    Stop: ['emit.mjs'],
-    SubagentStop: ['emit.mjs'],
-    PreCompact: ['emit.mjs'],
-    SessionEnd: ['emit.mjs'],
-  };
-
-  mkdirSync(CLAUDE, { recursive: true });
-  const settings = existsSync(SETTINGS)
-    ? JSON.parse(readFileSync(SETTINGS, 'utf8'))
-    : {};
-  settings.hooks = settings.hooks || {};
-  for (const [event, scripts] of Object.entries(map)) {
-    const groups = (settings.hooks[event] = settings.hooks[event] || []);
-    // quita entradas previas del arena (idempotente) y reescribe en su grupo
-    for (const g of groups)
-      g.hooks = (g.hooks || []).filter(
-        (h) =>
-          !/battle-arena[/\\]hooks|claude-hooks[/\\]/.test(h.command || ''),
-      );
-    settings.hooks[event] = groups.filter((g) => (g.hooks || []).length > 0);
-    settings.hooks[event].push({
-      hooks: scripts.map((f) => ({ type: 'command', command: cmd(f) })),
-    });
+  // 4) Registrar e instalar el plugin (idempotente). Va ANTES de limpiar lo anterior: si falla,
+  //    la instalación vieja sigue funcionando intacta.
+  try {
+    registerPlugin(HOOKS_DEST);
+  } catch (error) {
+    console.error(
+      `❌ No pude instalar el plugin (tu instalación anterior sigue igual): ${String(error.stderr || error.message).trim()}`,
+    );
+    process.exit(1);
   }
-  writeFileSync(SETTINGS, JSON.stringify(settings, null, 2) + '\n');
-  console.log(`✅ hooks registrados en ${SETTINGS}`);
+
+  // 5) Ya con el plugin activo, lo que dejó la versión anterior: hooks en settings.json y skills
+  //    sueltas (no duplicar cada evento)
+  cleanLegacy();
+
+  console.log(
+    `✅ plugin ${PLUGIN_ID} instalado (se lee de ${join(HOOKS_DEST, 'plugin')})`,
+  );
   console.log(`   colector: ${url}${key ? '' : '  (sin api-key)'}`);
   console.log(
-    '\nListo. Abre Claude Code en cualquier repo y verás el handshake del arena.',
+    '\nListo. Abre Claude Code: /battlearena:conquer arma tu plan y /scorecard abre tu día.' +
+      '\nSi ya tenías una sesión abierta, corre /reload-plugins.',
+  );
+}
+
+function uninstall() {
+  const result = hasClaudeCli()
+    ? unregisterPlugin()
+    : { plugin: false, marketplace: false };
+  cleanLegacyHooks();
+  console.log(
+    result.plugin
+      ? `✅ plugin ${PLUGIN_ID} desinstalado`
+      : `ℹ️  el plugin ${PLUGIN_ID} no estaba instalado`,
+  );
+  console.log(
+    `   Tu config (${join(BA_DIR, 'config.json')}) se queda; bórrala si ya no usarás Battle Arena.`,
   );
 }
 
+const COMMANDS = { install, uninstall };
 const command = process.argv[2];
-if (command === 'install') {
-  install();
-} else {
+const run = COMMANDS[command];
+if (!run) {
   console.log(
-    'Uso: npx @thebattlearena/battle-arena-hooks install [--url <colector>] [--api-key <key>]',
+    'Uso: npx @thebattlearena/battle-arena-hooks install [--url <colector>] [--api-key <key>]\n' +
+      '     npx @thebattlearena/battle-arena-hooks uninstall',
   );
   process.exit(command ? 1 : 0);
 }
+run();

package/execution-coach-nudge.mjs

@@ -36,7 +36,7 @@ const SELF_ASSESS =
   'Battle Arena — antes de responder, juzga si el pedido del usuario está claramente vago, ' +
   'subespecificado o confuso: sin objetivo claro, sin criterio de aceptación, o sin saber para ' +
   'quién/para qué es (p. ej. "quiero un código para desplegar el proyecto" sin decir qué app, ' +
-  'entorno ni cómo se ve "listo"). Si CLARAMENTE lo está, invoca el skill `execution-coach` para ' +
+  'entorno ni cómo se ve "listo"). Si CLARAMENTE lo está, invoca el skill `battlearena:execution-coach` para ' +
   'interceptar con preguntas mayéuticas antes de codear. Sé conservador: ante la duda, o si el ' +
   'pedido ya es concreto, sigue normal sin interrumpir.';
 
@@ -228,7 +228,7 @@ process.stdin.on('end', () => {
     let context = SELF_ASSESS;
     if (signals.length) {
       context +=
-        '\n\nAdemás, señales deterministas en esta sesión (revísalas con `execution-coach` si ' +
+        '\n\nAdemás, señales deterministas en esta sesión (revísalas con `battlearena:execution-coach` si ' +
         'siguen vigentes):\n' +
         signals.map((s) => `- ${s}`).join('\n');
     }