@thebattlearena/corner 0.8.0 → 0.9.1-beta.70

package/README.md

@@ -351,10 +351,25 @@ Se instala **junto con `battlearena`**, con el mismo comando y del mismo marketp
 | `/ring:referee close`                       | Gates finales, `validateCommand` opcional sobre la punta exacta, cuerpo del PR                                                       |
 | `/ring:no-surrender`                        | Modo noche: fija el `/goal` y deja lo que es del humano anotado, sin bloquearse                                                      |
 | `/ring:title-defense <pr> [--max-rounds N]` | Defiende el PR ante la review de Copilot: cataloga cada hallazgo, lo corrige por el mismo ciclo y re-pide review hasta quedar limpio |
+| `/ring:sparring <idea>`                     | Borrador rápido y feo de una funcionalidad sólo para probar si vale: PR en draft que el CI del proyecto puede desplegar              |
 | `/ring:play-by-play <pr>`                   | Narra el combate como crónica deportiva con la hora real de cada golpe y la publica como página privada, siempre en el mismo link    |
 
-Agentes: `ring:wrestler` (ejecutor, `effort: medium`) y `ring:cornerman` (revisor de sólo lectura,
-`effort: high`, en modo rango, concepto o lote).
+Agentes: `ring:wrestler` (ejecutor, `effort: medium`), `ring:cornerman` (revisor de sólo lectura,
+`effort: high`, en modo rango, concepto o lote) y `ring:rudo` (el del sparring, `effort: medium`).
+
+**Sparring** (`/ring:sparring`): un rudo por repo escribe en su worktree, dentro de un timebox de
+3 h como máximo, lo mínimo para que el juez pruebe una hipótesis de negocio. Un solo sparring
+puede abarcar back y front: una hipótesis, una ficha (`~/.claude/ring/sparrings/<slug>/`) y un
+veredicto, con un worktree, una rama y un PR por repo, y lo que uno le entrega al otro (un SDK con
+`npm pack`) en su carpeta `tools/`; se suspenden las reglas de
+estilo y de tests, nunca las de operación en vivo (F), secretos ni base de datos (sólo aditiva,
+nunca contra producción). El PR en draft desde `sparring/<slug>` con las etiquetas `sparring` y
+`do-not-merge` es el evento: el CI del proyecto lo atrapa y despliega su preview si quiere, y el
+ring la lee de la API de Deployments de GitHub (`sparring.previewEnvironment`). Las credenciales
+viajan sólo por nombre en un bloque `<!-- sparring:credentials … -->` y el proyecto las resuelve
+de su almacén de secretos; se asumen rotadas al terminar. El juez da el veredicto (KO, revancha o
+descartado); con KO, `/ring:referee start <pr> --from-sparring <slug>` refactoriza esa misma
+rama. El contrato para el proyecto está en `ring/skills/sparring/references/host-signal.md`.
 
 **Config del repo** (`.claude/ring.json`, opcional): `gates` (typecheck, tests por ruta con
 `{paths}`, lint), `validateCommand`, `rulebook` (por defecto el genérico del plugin),
@@ -376,6 +391,13 @@ rebotes, los commits, las revisiones de Copilot, los eventos del PR y las corrid
 inventa una hora: lo que no tiene registro se dice como hueco. Es privada; tú la compartes desde su
 menú. Más adelante `ring` podrá mandar el link de la crónica al dashboard de Battle Arena; hoy no se
 conecta al colector.
+Cuando la pelea empieza en un sparring, la crónica arranca ahí (`/ring:play-by-play --sparring
+<slug>`) y la cuenta a dos de tres caídas: el rudo contra el juez, la defensa de los técnicos y el
+árbitro (cada combate abierto `--from-sparring`). Es una sola página con un solo link, guardado en
+`sparring.json`; `sparring.mjs mark` fecha el vestidor, la defensa, la campana, la máscara y «sin
+equipo» (`no-team`: no hay segunda caída). Tras el KO, `sparring.mjs vestidor <slug>` corre en cada
+repo sus gates propios (typecheck, lint y `build`, que `config.mjs` detecta de `scripts.build`) y
+sólo con todos en verde fecha el vestidor.
 
 **El contrato es del juez**: si un concepto agrega o cambia un endpoint del spec de la API
 (`apiSpec`) o un modelo de base de datos (`dbModels`: entidades, schema, migraciones), el trabajo se
@@ -423,7 +445,16 @@ feed en vivo o, en combates de antes, de `gh pr list --head ring/<pr>/round-<n>`
 round). Un escritor puede mandar la tabla de la ficha con `fields` (`live.mjs emit --field
 rama=feat/x`).
 
-**La fuente de íconos.** `fonts/battle-arena-icons/BattleArenaIcons.ttf`: 58 glifos en el área de
+**Los sparrings en Ringside.** Cada sparring activo (sin veredicto `ko` ni `discard` y tocado en las
+últimas 12 h) lleva su propia sección «▸ Sparring <slug>» tras la del combate, con su tira de
+árbitro, rudo (la máscara, en rosa) y juez: el rudo se enciende mientras escribe, el juez cuando hay
+una pregunta abierta. Desplegada, su cabecera dice la ronda (veredictos de `history` + 1), el último
+veredicto y cada repo con su PR. Salen los que registró la sesión (`sparring.mjs` registra a la que
+lo corre, salvo `list`) o, si no registró ninguno, los que trabajan en su carpeta; el feed vive en
+`~/.claude/ring/sparrings/<slug>/live.jsonl` y lo escriben `sparring.mjs` y `live-hook.mjs` (Agent
+`ring:rudo` o «Rudo: …», AskUserQuestion) cuando la sesión no tiene combate propio.
+
+**La fuente de íconos.** `fonts/battle-arena-icons/BattleArenaIcons.ttf`: 59 glifos en el área de
 uso privado suplementaria A (U+FBA00–U+FBA85, lejos de los de Nerd Fonts), con nombre de glifo igual
 al id de `src/codepoints.json`. UPM 1000; un ícono de una celda avanza 600 y uno de dos, 1200 (la
 celda de una mono típica es 0.6 em), centrados en vertical en y = 340. 31 vienen de Lucide (ISC,
@@ -476,7 +507,7 @@ ejemplo, el de agents-studio-be (su batería de campañas, que además abre la v
 
 - `id` (minúsculas, dígitos, `_`, `-`; nunca el de un actor del ring) y `label`. Una entrada
   inválida se ignora con un aviso en `config.mjs show`; nunca tumba `mask-guard`.
-- `icon` (opcional): cualquiera de los 58 nombres de la fuente Battle Arena Icons; uno que no exista,
+- `icon` (opcional): cualquiera de los 59 nombres de la fuente Battle Arena Icons; uno que no exista,
   o ninguno, deja las dos primeras letras del `label` (los de puntos, acciones y medios son de la
   interfaz de Ringside y no tienen imagen, sólo glifo):
   - marca: `arena`
@@ -540,7 +571,9 @@ ejemplo, el de agents-studio-be (su batería de campañas, que además abre la v
 
 **`mask-guard`** (hook `PreToolUse` sobre Bash) bloquea **siempre** `git add -A/./--all`,
 `git stash pop`, `git reset --hard` con el árbol sucio y, si `forbidAiTrailers` está activo, los
-commits con trailers de atribución de IA (los coautores humanos pasan). **Sólo mientras hay un
+commits con trailers de atribución de IA (los coautores humanos pasan); y en un sparring, commitear
+`.env.sparring`, mezclar una rama `sparring/*` o empujarla a otra rama, abrir su PR sin draft o sin
+`do-not-merge`, y sacarlo de draft o mezclarlo. **Sólo mientras hay un
 combate activo en ese repo** bloquea además lo que decide el humano: merges (y `git pull` que no sea
 `--ff-only`/`--rebase`), cambios de base, cerrar o sacar de draft PRs, `gh pr review`, pedir review
 a Copilot, force push, push a una rama protegida, comandos pesados fuera de `one-at-a-time` y

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thebattlearena/corner",
-  "version": "0.8.0",
+  "version": "0.9.1-beta.70",
   "description": "Corner: tu esquina de Battle Arena en Claude Code (el plugin `battlearena`). Hooks de tracking, objetivo del turno, plan de batalla /battlearena:conquer, Ringside (el panel de tu día), el ring y la radio. Zero-dependency.",
   "type": "module",
   "bin": {

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "battlearena",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Corner, tu esquina de Battle Arena en Claude Code: tus sesiones al colector, el objetivo del turno, el plan de batalla /battlearena:conquer y Ringside, el panel de tu día junto al chat.",
   "author": {
     "name": "Battle Arena"

package/plugin/hooks/icons.generated.ts

@@ -11,6 +11,7 @@ export const FONT_ICONS = {
   'campana': { codepoint: 0xfba13, cells: 1, group: 'actores', tints: ['amber','red'], png: true },
   'copilot': { codepoint: 0xfba14, cells: 1, group: 'actores', tints: ['purple','red','amber'], png: true },
   'juez': { codepoint: 0xfba15, cells: 1, group: 'actores', tints: ['orange','red','amber'], png: true },
+  'rudo': { codepoint: 0xfba16, cells: 1, group: 'actores', tints: ['pink','red','amber'], png: true },
   'activo': { codepoint: 0xfba20, cells: 1, group: 'estados', tints: [], png: true },
   'en-la-esquina': { codepoint: 0xfba21, cells: 1, group: 'estados', tints: [], png: true },
   'golpe': { codepoint: 0xfba22, cells: 1, group: 'estados', tints: [], png: true },
@@ -98,6 +99,7 @@ export const ACTOR_COLOR = {
   campana: 'amber',
   copilot: 'purple',
   juez: 'orange',
+  rudo: 'pink',
 } as const;
 
 /** Las cajas de ícono con PNG (columnas × filas). */

package/plugin/hooks/pane.tsx

@@ -50,8 +50,8 @@ import {
   unlinkedMeetingMinutes,
 } from './meetings';
 import { outsideMinutes, planMinutes, workedMinutes } from './close';
-import type { RingPaneModel } from './ring-pane';
-import { pointBadge, ringHost, RingRow } from './ring-pane';
+import type { RingPaneModel, SparringPaneModel } from './ring-pane';
+import { pointBadge, ringHost, RingRow, SparringRow } from './ring-pane';
 import { ic } from './icons';
 import type { TerminalCaps } from './terminal-caps';
 import { labelLinks } from './label-links';
@@ -83,6 +83,8 @@ export type PaneModel = {
   ) => void;
   /** El combate activo del ring en este repo; sin él, la sección no se pinta. */
   ring?: RingPaneModel | null;
+  /** Los sparrings activos de la sesión: una sección cada uno, tras la del combate. */
+  sparrings?: SparringPaneModel[];
   /** El tema de la persona es claro: el panel se queda sin el fondo navy. */
   lightTheme: boolean;
   /** Lo que sabe dibujar la terminal; sin dato, todo (Ghostty). */
@@ -1017,6 +1019,14 @@ const NextLine = (el: Elements, next: MyDay, ms: number) => {
   );
 };
 
+/** Una sección por sparring activo, tras la del combate; nada sin sparrings. */
+const Sparrings = (el: Elements, m: PaneModel, width: number) =>
+  m.sparrings?.length ? (
+    <el.Box key="sparrings" flexDirection="column" gap={1}>
+      {m.sparrings.map((s) => SparringRow(el, s, width))}
+    </el.Box>
+  ) : null;
+
 /**
  * La vista «Hoy». Desde las 16:00, sin plan de hoy y con el de mañana listo, muestra el de mañana
  * (sus puntos y la fecha arriba); con plan de hoy, agrega una línea con el de mañana.
@@ -1046,6 +1056,7 @@ const Today = (el: Elements, day: MyDay, m: PaneModel, columns: number) => {
         </Box>
       )}
       {m.ring && !host && RingRow(el, m.ring, columns - GUTTER)}
+      {Sparrings(el, m, columns - GUTTER)}
       {shown === next && <Text dimColor>Hoy</Text>}
       {Emergents(el, day, m, columns)}
       {Complements(el, day, m, columns)}
@@ -1147,6 +1158,9 @@ export function renderPane($: EngineInterface, e: RenderEvent, m: PaneModel) {
         m.ring &&
         m.tab === 'hoy' &&
         RingRow(el, m.ring, columns - GUTTER)}
+      {(!day || closing) &&
+        m.tab === 'hoy' &&
+        Sparrings(el, m, columns - GUTTER)}
       {riskDay && Risks(el, riskDay.risks, m, columns)}
       {day &&
         m.tab === 'hoy' &&

package/plugin/hooks/register.tsx

@@ -27,7 +27,8 @@ import {
 } from './api';
 import { renderPane } from './pane';
 import { deriveRing } from './ring';
-import { readIconFont, readRing } from './ring-io';
+import { readIconFont, readRing, readSparrings } from './ring-io';
+import { deriveSparring } from './sparring';
 import { iconSource, loadIconBytes } from './icon-files';
 import { ic, setIconFont } from './icons';
 import { terminalCaps } from './terminal-caps';
@@ -55,6 +56,8 @@ const RING_TICK_MS = 1_000;
 const RING_READ_EVERY = 2;
 /** Clave de la fila «Revisión #N» en `opened`. */
 const RING_ROW = 'ring';
+/** El prefijo de un sparring: su fila en `opened` y sus llaves (`sparring-<slug>-chip-rudo`). */
+const sparringScope = (slug: string) => `sparring-${slug}`;
 
 const EMPTY: Snapshot = {
   day: null,
@@ -100,7 +103,7 @@ const isBandHidden = atom(
 
 export const ring = atom(
   { plugin: 'battlearena', key: 'ring' } as const,
-  { bout: null, readAt: 0 } as RingSnapshot,
+  { bout: null, sparrings: [], readAt: 0 } as RingSnapshot,
 );
 export const ringChip = atom(
   { plugin: 'battlearena', key: 'ringChip' } as const,
@@ -154,12 +157,13 @@ async function refreshRing($: EngineInterface): Promise<void> {
   const refs = [...(day?.items ?? []), ...(next?.items ?? [])].flatMap(
     (item) => item.brief?.refs ?? [],
   );
-  const [bout, iconFont] = await Promise.all([
+  const [bout, sparrings, iconFont] = await Promise.all([
     readRing($, refs),
+    readSparrings($),
     readIconFont($),
   ]);
   const readAt = await $.clock.now();
-  await update($, ring, () => ({ bout, readAt, iconFont }));
+  await update($, ring, () => ({ bout, sparrings, readAt, iconFont }));
 }
 
 /**
@@ -169,10 +173,13 @@ async function refreshRing($: EngineInterface): Promise<void> {
 async function ringBeat($: EngineInterface, beat: number): Promise<void> {
   if (!(await isPaneShown($))) return;
   if (beat % RING_READ_EVERY === 0) await refreshRing($);
-  const { bout } = await read($, ring);
-  if (!bout) return;
-  const view = deriveRing(bout, await $.clock.now());
-  if (view.running) await update($, ringTick, (n) => n + 1);
+  const { bout, sparrings = [] } = await read($, ring);
+  if (!bout && !sparrings.length) return;
+  const now = await $.clock.now();
+  const running =
+    (bout && deriveRing(bout, now).running) ||
+    sparrings.some((s) => deriveSparring(s, now).running);
+  if (running) await update($, ringTick, (n) => n + 1);
   await probeChipImage($);
 }
 
@@ -416,40 +423,62 @@ export const register: Register = (on) => {
   });
 
   on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
-    const { bout, iconFont = false } = await read($, ring);
+    const { bout, sparrings = [], iconFont = false } = await read($, ring);
     const caps = terminalCaps(await $.env.get('TERM_PROGRAM'));
     // Los símbolos de todo Ringside van con la fuente de íconos si está instalada.
     setIconFont(iconFont, caps.glyphsFit);
     const now = await $.clock.now();
+    // Lo que comparten las secciones del ring (el combate y cada sparring); cada una con su fila en
+    // `opened` y su ficha abierta en `ringChip` (la de un sparring, con su prefijo: una a la vez).
+    const section = async (row: string, scope?: string) => {
+      const key = (id: string) => (scope ? `${scope}/${id}` : id);
+      const prefix = scope ? `${scope}/` : null;
+      const chip = await read($, ringChip);
+      return {
+        scope,
+        iconFont,
+        iconDir: iconDirOf($),
+        imagesDraw: (await read($, ringImages)).draws,
+        onProbe: (shape: typeof chipShape) => {
+          chipShape = shape;
+        },
+        light: await isLightTheme($),
+        isTerminal: e.surface === 'terminal',
+        tick: await read($, ringTick),
+        now,
+        isOpen: (await read($, opened)).includes(row),
+        onRow: () =>
+          void update($, opened, (list) =>
+            list.includes(row) ? list.filter((x) => x !== row) : [...list, row],
+          ).then(() => probeChipImage($)),
+        selected: prefix
+          ? chip?.startsWith(prefix)
+            ? chip.slice(prefix.length)
+            : null
+          : chip,
+        onChip: (id: string) =>
+          void update($, ringChip, (current) =>
+            current === key(id) ? null : key(id),
+          ),
+        onOpen: (command: string) =>
+          void $.command
+            .run({ command })
+            .catch(() => $.ui.toast(`Escribe /${command}`)),
+      };
+    };
     const ringModel = bout && {
-      iconFont,
-      iconDir: iconDirOf($),
-      imagesDraw: (await read($, ringImages)).draws,
-      onProbe: (shape: typeof chipShape) => {
-        chipShape = shape;
-      },
-      light: await isLightTheme($),
-      isTerminal: e.surface === 'terminal',
+      ...(await section(RING_ROW)),
       view: deriveRing(bout, now),
-      tick: await read($, ringTick),
-      now,
-      isOpen: (await read($, opened)).includes(RING_ROW),
-      onRow: () =>
-        void update($, opened, (list) =>
-          list.includes(RING_ROW)
-            ? list.filter((x) => x !== RING_ROW)
-            : [...list, RING_ROW],
-        ).then(() => probeChipImage($)),
-      selected: await read($, ringChip),
-      onChip: (id: string) =>
-        void update($, ringChip, (current) => (current === id ? null : id)),
-      onOpen: (command: string) =>
-        void $.command
-          .run({ command })
-          .catch(() => $.ui.toast(`Escribe /${command}`)),
     };
+    const sparringModels = await Promise.all(
+      sparrings.map(async (s) => ({
+        ...(await section(sparringScope(s.slug), sparringScope(s.slug))),
+        view: deriveSparring(s, now),
+      })),
+    );
     return renderPane($, e, {
       ring: ringModel,
+      sparrings: sparringModels,
       lightTheme: await isLightTheme($),
       caps,
       onOpenUrl: (url) =>

package/plugin/hooks/ring-io.ts

@@ -1,6 +1,6 @@
 import type { EngineInterface } from 'claude-code';
 
-import type { RingBout } from '../types';
+import type { RingBout, RingSparring } from '../types';
 import {
   bellsOf,
   defenseOf,
@@ -9,6 +9,8 @@ import {
   refersTo,
   slugFromRemote,
 } from './ring';
+import type { SparringFile } from './sparring';
+import { sparringOf, sparringsFor } from './sparring';
 
 /**
  * Lee el combate activo del repo de la sesión desde los archivos del plugin `ring`
@@ -233,6 +235,62 @@ export async function readRing(
   }
 }
 
+/** Los archivos de un sparring que cuentan como «tocarlo». */
+const SPARRING_FILES = ['sparring.json', 'card.md', 'live.jsonl'];
+
+/**
+ * Los sparrings activos que muestra esta sesión (`~/.claude/ring/sparrings/<slug>/`): los que ella
+ * registró o, sin ninguno, los que trabajan en su carpeta (ver `sparringsFor`), cada uno con su feed.
+ * Vacío sin ring o sin sparrings; nunca falla.
+ */
+export async function readSparrings(
+  $: EngineInterface,
+): Promise<RingSparring[]> {
+  try {
+    const [root, home, sessionId, now] = await Promise.all([
+      $.session.root(),
+      ringHome($),
+      $.session.id().catch(() => null),
+      $.clock.now(),
+    ]);
+    if (!home) return [];
+    const base = `${home}/sparrings`;
+    const entries = await $.fs.list(base).catch(() => []);
+    const found = await Promise.all(
+      entries
+        .filter((entry) => entry.kind === 'dir')
+        .map(async (entry) => {
+          const dir = `${base}/${entry.name}`;
+          const [state, files] = await Promise.all([
+            readJson<SparringFile>($, `${dir}/sparring.json`),
+            $.fs.list(dir).catch(() => []),
+          ]);
+          const touched = Math.max(
+            0,
+            ...files
+              .filter((f) => SPARRING_FILES.includes(f.name))
+              .map((f) => f.mtimeMs),
+          );
+          return state ? { dir, state, touched } : null;
+        }),
+    );
+    const shown = sparringsFor(
+      found.filter((s) => s !== null),
+      { sessionId, root, now },
+    );
+    return await Promise.all(
+      shown.map(async ({ dir, state }) =>
+        sparringOf(
+          state,
+          parseEvents(await $.fs.read(`${dir}/live.jsonl`).catch(() => ''), []),
+        ),
+      ),
+    );
+  } catch {
+    return [];
+  }
+}
+
 /**
  * ¿Está instalada la fuente de íconos? Lo dice `iconFont: true` en `~/.claude/battle-arena/config.json`,
  * que escribe el instalador al copiarla: un mod no puede preguntarle a la terminal por sus fuentes.