@thebattlearena/corner 0.10.0 → 0.10.1-beta.79

package/README.md

@@ -123,28 +123,28 @@ El detalle (esquema, íconos y colores válidos) está en «Monitores del repo»
 Con la fuente Battle Arena Icons instalada (la pone `install`), estos símbolos se dibujan con sus
 glifos; sin ella, con el carácter de la tabla.
 
-| Ícono | Dónde | Significa |
-| --- | --- | --- |
-| ✓ | punto, banda | entregado |
-| ↻ | punto, banda | en curso: tiene tiempo hoy |
-| ↷ | punto, banda | desplazado por un emergente |
-| ○ | punto, banda | por hacer: sin tiempo todavía |
-| ● | punto, en el cierre | avanzó pero no se entregó |
-| ⚠ | banda, riesgos | riesgo abierto; en una ficha, «va con avisos» |
-| ✗ | ficha | un paso falló |
-| ✎ | emergente, banda | falta responder el motivo |
-| ✋ | riesgo | levantar la mano: avisa a tu líder |
-| 👍 👎 | riesgo | si el aviso de riesgo acertó o no (ajusta la detección) |
-| 📅 | punto | reunión ligada |
-| 💡 | punto, complemento | tiempo en cabina |
-| 🧪 | punto, complemento | sesión de Tape |
-| ▸ ▾ ▴ | filas | desplegar, contraer, cerrar el detalle |
-| ↗ | ligas | abrir en la web |
-| ♪ ▶ ⏸ ▲ | radio | la canción, escuchar, dejar de escuchar, votar |
-| spinner | ring | alguien del combate está trabajando |
-| ■ (ámbar) | ring | te toca decidir |
-| 👊N (rojo) | ring | Copilot dejó N hilos |
-| ◣ | ficha de Copilot | en la esquina: Copilot está revisando |
+| Ícono      | Dónde               | Significa                                               |
+| ---------- | ------------------- | ------------------------------------------------------- |
+| ✓          | punto, banda        | entregado                                               |
+| ↻          | punto, banda        | en curso: tiene tiempo hoy                              |
+| ↷          | punto, banda        | desplazado por un emergente                             |
+| ○          | punto, banda        | por hacer: sin tiempo todavía                           |
+| ●          | punto, en el cierre | avanzó pero no se entregó                               |
+| ⚠          | banda, riesgos      | riesgo abierto; en una ficha, «va con avisos»           |
+| ✗          | ficha               | un paso falló                                           |
+| ✎          | emergente, banda    | falta responder el motivo                               |
+| ✋         | riesgo              | levantar la mano: avisa a tu líder                      |
+| 👍 👎      | riesgo              | si el aviso de riesgo acertó o no (ajusta la detección) |
+| 📅         | punto               | reunión ligada                                          |
+| 💡         | punto, complemento  | tiempo en cabina                                        |
+| 🧪         | punto, complemento  | sesión de Tape                                          |
+| ▸ ▾ ▴      | filas               | desplegar, contraer, cerrar el detalle                  |
+| ↗          | ligas               | abrir en la web                                         |
+| ♪ ▶ ⏸ ▲    | radio               | la canción, escuchar, dejar de escuchar, votar          |
+| spinner    | ring                | alguien del combate está trabajando                     |
+| ■ (ámbar)  | ring                | te toca decidir                                         |
+| 👊N (rojo) | ring                | Copilot dejó N hilos                                    |
+| ◣          | ficha de Copilot    | en la esquina: Copilot está revisando                   |
 
 Las fichas del ring son el **árbitro**, el **luchador**, el **esquinero**, la **campana** (round-bell),
 **Copilot** y el **juez** (tú). Su borde dice el estado: gris quieta, azul trabajando, morada en la
@@ -167,8 +167,8 @@ Se invocan escribiendo el comando o pidiéndolo con tus palabras («arma mi plan
 
 ### Comandos
 
-| Comando      | Para qué sirve                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Comando     | Para qué sirve                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `/ringside` | Abre **Ringside**: 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`, su nombre anterior, lo sigue abriendo con un aviso. |
 
 Arriba del prompt sale además una **banda** compacta de Ringside (`LER-640   ✓ 1   ↻ 1   ↷ 1   ⚠ 1   Abrir`, cada contador con su color).
@@ -374,8 +374,84 @@ rama. El contrato para el proyecto está en `ring/skills/sparring/references/hos
 **Config del repo** (`.claude/ring.json`, opcional): `gates` (typecheck, tests por ruta con
 `{paths}`, lint), `validateCommand`, `rulebook` (por defecto el genérico del plugin),
 `protectedBranches`, `forbidAiTrailers` (por defecto `true`), `heavyCommands`, `delegation`,
-`precedents` y `monitors` (ver «Monitores del repo»). Sin el archivo, `ring` usa los gates que detecta en `package.json`, `pyproject.toml`,
-`go.mod` y el `Makefile`.
+`precedents`, `monitors` (ver «Monitores del repo»), `briefGuard` (`warn`, `block` u `off`), `layers`, `layersIgnore`, `layersRequired` y `findingsNeedJudge` (ver «Gate de arquitectura»), `relayEvery`, `engramUrl` y `engramProject` (ver «Memoria entre peleas»), y `agents` (modelo y esfuerzo por rol; por
+defecto el luchador y el rudo en `sonnet` con esfuerzo `high` y el esquinero en `opus` con `high`,
+p. ej. `"agents": { "wrestler": { "model": "opus" } }`). Sin el archivo, `ring` usa los gates que
+detecta en `package.json`, `pyproject.toml`, `go.mod` y el `Makefile`.
+
+**Briefs generados, no escritos**: el árbitro no le escribe a mano las instrucciones al luchador
+ni al esquinero. `ring/scripts/brief.mjs` las arma desde los templates con el reglamento y los
+precedentes embebidos completos (abriendo con un checklist de arquitectura: lo que más se escapa en
+una revisión línea por línea), las decisiones que importan (todas las faltas, las de esos archivos
+y las últimas 20) y los commits del rango; las sella y las registra en
+`<combate>/briefs/index.jsonl`. El árbitro sólo pone sus valores (el encargo, las invariantes…).
+Todo hallazgo de un esquinero o de una revisión tuya cita una regla del reglamento
+(`<archivo:línea> — R11 — …`): `findings.mjs add` rechaza el que no la trae, y uno que ninguna regla
+cubre lleva `X0` y queda como propuesta para el reglamento.
+El árbitro lanza al luchador y al esquinero con `prompt: "ring-brief: <archivo>"`: el hook
+`brief-guard` revisa el sello (generado por `brief.mjs`, sin editar, con las reglas de hoy, de este
+combate y de ese rol), pone el texto del archivo como instrucción y el modelo y esfuerzo del rol.
+Con `briefGuard: "warn"` (el default en `.claude/ring.json`) un brief que no cumple pasa y el árbitro
+recibe el aviso; con `"block"` se rechaza con el comando que lo genera; `"off"` lo apaga. Cada
+decisión queda en `<combate>/brief-guard.jsonl`. Y cuando la sesión del árbitro se compacta, el hook
+`compact-hook` le devuelve (en menos de 10 000 caracteres) el combate, el checklist, sus faltas y el
+«cómo reanudar» de la tarjeta.
+
+**Gate de arquitectura**: `ring/scripts/arch-gate.mjs check <worktree> --range A..B` revisa los
+imports que el rango **agrega** contra las capas del repo y, si el repo tiene dependency-cruiser
+(`.dependency-cruiser.cjs` y el paquete instalado), también lo corre, con su lista de violaciones
+conocidas cuando la tiene. Cada violación es un hallazgo que cita P14. El esquinero lo corre en cada
+modo y `mask-guard` en cada push a la rama del PR; la deuda que ya estaba no bloquea. Las capas van
+en `.claude/ring.json`:
+
+```json
+"layers": [
+  { "name": "domain", "paths": ["packages/contexts/*/domain/**"], "mayImport": [],
+    "forbid": ["^@nestjs/", "^typeorm$"] },
+  { "name": "application", "paths": ["apps/public-api/src/**/application/**"],
+    "mayImport": ["domain"] },
+  { "name": "infrastructure",
+    "paths": ["apps/public-api/src/**/typeorm/**", "apps/public-api/src/**/controllers/**"],
+    "mayImport": ["application", "domain"] }
+]
+```
+
+Cuenta la **primera** capa cuya ruta coincide: van primero las más específicas (una
+`infrastructure/` anidada dentro de una `application/` es infraestructura). Con `layersRequired`
+(globs, p. ej. `["apps/public-api/src/**"]`) todo archivo **nuevo** bajo esas rutas tiene que caer en
+alguna capa: el que no, es hallazgo, porque ninguna regla de dependencias lo alcanza. Si el worktree
+de la pelea no tiene `.claude/ring.json` (un repo que lo guarda sin versionar), el gate usa el del
+checkout principal del mismo repo. Los globs usan `**` y `*` (sin llaves `{a,b}`: una ruta por entrada). Las pruebas (`*.spec.*`, `*.test.*`, `__tests__/`, `test/`) quedan fuera por default: pueden armar un adaptador a propósito (`layersIgnore` cambia la lista). Los alias de `tsconfig.json` (`@arena/*`) se resuelven solos. Un repo sin capas ni dependency-cruiser
+recibe un aviso al abrir la pelea (`judges-card open`). Y un hallazgo que cita una regla de
+`findingsNeedJudge` (por defecto `["P14"]`; una pelea de limpieza agrega R6, R11, R12, R19 y R22) no
+se manda a ticket ni se descarta sin `--judge "<lo que dijo el humano>"`.
+
+**Un luchador nuevo por concepto, y el relevo del árbitro**: cuando el esquinero aprueba un
+concepto, `judges-card.mjs concept <pr> "<concepto>" --range A..B` lo registra y retira a los
+luchadores que lo cargaron; el siguiente concepto va a uno nuevo (`brief.mjs wrestler <pr> --mode
+resume`), y `brief-guard` avisa (o bloquea) un `SendMessage` a uno retirado. Cada `relayEvery`
+conceptos (4 por default, `null` lo apaga) el árbitro reescribe el «cómo reanudar» de la tarjeta, que
+tiene que nombrar el último concepto, y corre `judges-card.mjs relay <pr>`; hasta entonces
+`brief.mjs` no le arma instrucciones al siguiente luchador. Eso es lo que la sesión recupera al
+compactarse. Y `judges-card.mjs close` no cierra mientras una propuesta de «For the rulebook /
+precedents» (los `X0` incluidos) no tenga decisión: `judges-card.mjs proposal <pr> <n>
+accept|reject --why "<lo que dijo el humano>"`.
+
+**Memoria entre peleas (Engram, opcional)**: si en `engramUrl` (por default
+`http://127.0.0.1:7437`) contesta un [Engram](https://github.com/Gentleman-Programming/engram)
+(`engram serve`), los scripts le mandan lo que cada pelea aprendió: las faltas, las respuestas y
+decisiones del juez, los precedentes aceptados, los hallazgos `X0` (con su estado) y el estado de la
+pelea (cómo reanudar, plan y conceptos, que se actualiza en el mismo registro). Lo mandan
+`judges-card.mjs` y `findings.mjs` después de cada comando, sin repetir nada (cada envío lleva un id
+de operación sacado de su contenido, y los enviados quedan en `<combate>/engram-sent.json`). De
+vuelta, `brief.mjs` agrega al brief, después de las decisiones y antes de las reglas, lo aprendido en
+otras peleas del repo sobre los archivos del rango, y `judges-card.mjs summary` las faltas y veredictos
+recientes del repo. Las reglas nunca van a Engram: siguen en archivos y el brief las trae completas;
+lo que viene de Engram es contexto, no regla. Sin Engram (o con `engramUrl: null`) todo sigue igual.
+`engram.mjs status` dice si contesta, `engram.mjs sync --all` sube las peleas que ya existían del repo
+y `engram.mjs recall <pr> [--files a,b]` muestra lo que leería un brief. El proyecto es el nombre del
+repo (`engramProject` lo cambia) y `RING_ENGRAM_URL` gana sobre el archivo (`off` lo apaga; así
+corren las pruebas del plugin).
 
 **Delegación y precedentes**: con `delegation: "referee"` (el default) el árbitro decide él mismo
 las dudas de diseño con el reglamento y los precedentes, anota por qué en `decisions.md` y sigue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thebattlearena/corner",
-  "version": "0.10.0",
+  "version": "0.10.1-beta.79",
   "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": {
@@ -33,7 +33,7 @@
   "scripts": {
     "bundle:skill": "node -e \"const{cpSync,rmSync,mkdirSync}=require('fs');const out='plugin/skills';rmSync(out,{recursive:true,force:true});mkdirSync(out,{recursive:true});for(const s of ['arena-objective','arena-self-review','execution-coach','scope-technical-task','pr-review-loop','conquer'])cpSync('../../.claude/skills/'+s,out+'/'+s,{recursive:true,dereference:true})\"",
     "prepack": "npm run bundle:skill",
-    "test": "node --test test/*.test.mjs",
+    "test": "RING_ENGRAM_URL=off node --test test/*.test.mjs",
     "preview:ring": "node scripts/ring-preview.mjs"
   },
   "engines": {

package/ring/agents/cornerman.md

@@ -2,6 +2,7 @@
 name: cornerman
 description: The ring's read-only reviewer. Reviews a fixed commit range against the rulebook in one of three modes the referee names in its brief, range (≤15 lines of findings), concept (numbered behavior invariants, tests on a `git archive` copy) or batch (≤20 files through the lenses of the bout's venue). Never edits, commits or touches anyone's index. Launched by `/ring:referee` at high effort.
 tools: Read, Grep, Glob, Bash
+model: opus
 effort: high
 ---
 
@@ -10,9 +11,14 @@ command that writes the index or the tree of someone else's worktree. You read w
 `git -C <worktree> log|show|diff <refs>` and with file reads. Your cwd resets between commands,
 so every git command carries `-C`.
 
-Your brief names the **mode**, the worktree, the base, the exact range, the rulebook path and the
-decisions file. The base is a remote ref (`origin/main`); if the brief names a bare branch, use
-its `origin/` ref, never the local branch, which may be behind. Read the rulebook and the decisions in full first. Review **only the lines the
+Your brief names the **mode**, the worktree, the base and the exact range, and carries the
+decisions and then the rules in full at its end (`brief.mjs` embeds them: the architecture
+checklist first, then the rulebook and the precedents). If your prompt is only `ring-brief:
+<path>`, read that file whole: it is your brief. The base is a remote ref (`origin/main`); if the
+brief names a bare branch, use its `origin/` ref, never the local branch, which may be behind.
+Read the rules and the decisions first, the checklist before anything: what slips past a
+line-by-line review is there. **Every finding cites the rule it breaks in its second field**, or
+`X0` when no rule covers it; the referee's ledger refuses a finding without one. Review **only the lines the
 range adds or changes**: no taste, no debt that was already there.
 
 The referee filters your report against the base before acting on it, so be exact: every finding
@@ -47,6 +53,13 @@ clean:** sort-imports or prettier is not installed (`missing`), so the files in
 checked. Report it as its own line, `format — NO VERIFICADO — falta <missing> — <files>`, never as
 "no findings".
 
+**Architecture, in every mode:** `node "<ring>/scripts/arch-gate.mjs" check <wt> --range <A>..<B>`
+(read-only). It checks the imports the range adds against the repo's layers (`layers` in
+`.claude/ring.json`) and runs the repo's dependency-cruiser when it has one. Each line it prints is
+already a finding citing P14 (`<file:line> — P14 — <layer> imports <layer> … — …`): report it as
+it is, as a BLOCKER (P14). Exit 2 means the repo has no gate: no finding, but say in one line that
+layers were reviewed only by eye. A layer the gate does not know is still yours to read (lens 1).
+
 ## Mode: concept
 
 A deep review when a concept closes. The brief lists the commits with what each claims to do and a
@@ -88,8 +101,11 @@ bout's venue). For a `backend` bout they are these 8:
    with its business sentence (R15), the backend shaped by the business and not by a screen
    (R16), every optional with its reason (R17), aggregates born valid (R18), no primitives
    crossing commands, events or ports (R19), no new endpoint an existing one covers (R20), names
-   that do not collide with another context (R21). A deviation from a pattern the host's rules
-   fix is a BLOCKER (P14).
+   that do not collide with another context (R21), no ternary or optional filling a gap that
+   should not exist (R23), types derived from their source (R24), provider responses through an
+   anti-corruption layer (R25), business metrics apart from monitoring (R26), a cross-cutting
+   precondition checked once (R27). A deviation from a pattern the host's rules fix is a BLOCKER
+   (P14).
 6. Errors: does it fail open or closed, who catches what.
 7. Expressiveness: names, more than 3 parameters, control booleans.
 8. Production risk: concurrency, idempotency, volume, reversibility, and a new infrastructure

package/ring/agents/rudo.md

@@ -2,7 +2,8 @@
 name: rudo
 description: The ring's sparring executor. Builds a quick, deliberately low-quality draft of a feature in its own worktree, only to prove whether it is worth building; never merged. Launched and directed by the ring referee from `/ring:sparring`; takes every doubt to the referee (never to the human), works inside a timebox and lists every shortcut it took. Suspends the style and test rules, never the live-operation ones.
 tools: Read, Grep, Glob, Edit, Write, Bash
-effort: medium
+model: sonnet
+effort: high
 ---
 
 You are the rudo: in lucha libre the rudo wins however he can, the técnico wins clean. You are

package/ring/agents/wrestler.md

@@ -2,7 +2,8 @@
 name: wrestler
 description: The ring's executor. Applies a refactor or a correction package in its own worktree, one concept at a time, without changing behavior, with the host repo's gates and small thematic commits. Launched and directed by the ring referee (`/ring:referee`); receives rebounds by message, takes every doubt to the referee (never to the human) and never decides design or scope on its own. Does not review its own work with reviewers and does not open ready PRs.
 tools: Read, Grep, Glob, Edit, Write, Bash
-effort: medium
+model: sonnet
+effort: high
 ---
 
 You write code; someone else reviews it. Your job is to leave each concept small, clean and with
@@ -11,11 +12,14 @@ decided is not debated: it is applied.
 
 ## Sources
 
-- Your brief: the assignment, the worktree, the branch, the base, the order of concepts, the
+- Your brief (if your prompt is only `ring-brief: <path>`, read that file whole: it is your
+  brief): the assignment, the worktree, the branch, the base, the order of concepts, the
   frozen zones, the decisions already taken, what waits on the human, and the absolute path of the
   ring scripts (`<ring>/scripts`).
-- The rulebook and the precedents the brief names, read in full. Rules are cited by number (R, T,
-  F, P), precedents by id (PRn bundled, HPn the host's).
+- The rules, embedded in full at the end of your brief by `brief.mjs`: the architecture checklist
+  first, then the rulebook and the precedents. They are the ones in force; apply them while you
+  write and check the checklist before every commit. Rules are cited by number (R, T, F, P),
+  precedents by id (PRn bundled, HPn the host's).
 - Every doubt goes to the referee in your report, never to the human: the referee decides it or
   escalates it.
 - The host repo's own instructions (`AGENTS.md`, `CLAUDE.md`, `CONTRIBUTING.md` if present).

package/ring/hooks/hooks.json

@@ -10,6 +10,16 @@
           }
         ]
       },
+      {
+        "matcher": "Agent|Task|SendMessage",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/brief-guard.mjs\"",
+            "timeout": 10
+          }
+        ]
+      },
       {
         "matcher": "Agent|Task|AskUserQuestion|Bash",
         "hooks": [
@@ -97,6 +107,18 @@
           }
         ]
       }
+    ],
+    "SessionStart": [
+      {
+        "matcher": "compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/compact-hook.mjs\"",
+            "timeout": 10
+          }
+        ]
+      }
     ]
   }
 }