EJEMPLO SDD · CLAUDE CODE

Arkanoid paso a paso con Claude Code

Tecleamos en Claude Code, una a una, las catorce instrucciones que propone el libro. Aquí contamos lo que pasó, con capturas, tiempos y lo que aprendimos.

El libro Desarrollo agéntico de software basado en especificaciones incluye un recorrido para construir un Arkanoid y añadirle la multibola con Claude Code. No queríamos dejarlo en teoría: lo hemos ejecutado con la herramienta real, en una carpeta limpia, y el recorrido queda validado. Donde la herramienta no se comportó como esperábamos, lo contamos y corregimos el libro.

Claude Code 2.1.285 Opus 5.5 14 pasos · 46 minutos Validado el 20/11/2026
El Arkanoid en el navegador con tres bolas en juego después de romper el ladrillo amarillo x3
El juego que construyó Claude Code, un segundo después de romper el ladrillo x3: la bola se ha convertido en tres.

EL TEXTO DEL LIBRO

Cómo plantea el libro el recorrido

Antes de contar lo que pasó conviene leer lo que el libro pide, porque es la vara con la que medimos cada paso. En cada paso de esta página encontrarás el texto completo del libro en un recuadro con borde azul, tal como queda en la versión 87a, ya corregida con lo que aprendimos aquí. Este es el planteamiento general:

Lo que dice el libro (versión 87a)

El siguiente recorrido combina los mecanismos de Claude Code (comandos, CLAUDE.md, skills, hooks y subagentes) para construir el Arkanoid del libro.

En cada paso indicaremos dónde se trabaja, qué se escribe, qué resultado queda y qué debe revisarse para continuar.

Lo que dice el libro (versión 87a)

El recorrido dejará un repositorio Git, instrucciones en CLAUDE.md, una especificación ratificada, un plan, código y pruebas construidos por incrementos, los resultados de su ejecución y un commit candidato.

El libro reúne después, en una tabla, cada orden o pieza de Claude Code con lo que aporta y sus límites. De ahí sale el mapa de órdenes que usamos:

Lo que dice el libro (versión 87a)

Mapa mínimo de comandos. Los cinco primeros se escriben en la terminal del sistema. Los comandos con barra se escriben después de que Claude Code haya abierto la sesión.

Si una orden con barra no aparece al teclear /, la buscamos con /help dentro de la sesión; claude --help solo describe las opciones de la terminal.

cd /ruta/al/arkanoid
claude --version
claude --help
claude doctor
claude
/help
/status
/permissions
/init
/plan describir la multibola y sus casos límite
/agents
/mcp
/memory
/context
/usage
/diff
/rewind

CÓMO LO INVOCAMOS

Una carpeta limpia y un programa que teclea como una persona

Queríamos ver lo mismo que verá quien lea el libro, así que no usamos nuestra configuración habitual de Claude Code, que tiene skills y reglas propias. Creamos una configuración vacía en ~/sdd-931/config y un repositorio nuevo en ~/sdd-931/arkanoid, fuera de nuestras carpetas de trabajo, para que no se colara ningún CLAUDE.md de un proyecto vecino. Claude Code se arrancó siempre con la variable CLAUDE_CONFIG_DIR apuntando a esa configuración y con un entorno mínimo: HOME, PATH, TERM=xterm-256color y LANG=es_ES.UTF-8. La sesión usó Claude Code 2.1.285 con el modelo Opus 5.5 y esfuerzo medio, en modo interactivo, como lo usaría una persona; no usamos claude -p ni la API.

Para que el recorrido se pudiera repetir escribimos un pequeño programa en Python que hace de persona. Abre Claude Code dentro de una terminal tmux de 120 columnas por 42 filas (tmux es un programa que mantiene terminales a las que otro programa puede enviar teclas y de las que puede leer la pantalla). A partir de ahí, el programa repite siempre el mismo ciclo:

  1. Escribir la instrucción. Las órdenes con barra, como /plan …, se teclean carácter a carácter. Los mensajes normales se pegan de una vez con tmux load-buffer y paste-buffer -p, que los envía como un pegado de verdad; por eso Claude Code recibe los mensajes largos como «texto pegado». Cuando el texto aparece en la caja de entrada, el programa pulsa Enter.
  2. Esperar a que Claude termine. Cada dos segundos lee la pantalla. Mientras Claude trabaja, la pantalla cambia; el turno se da por terminado cuando lleva unos seis segundos quieta y se ha visto a Claude trabajar.
  3. Contestar los menús. Si aparece un menú de permiso («Do you want to…»), elige «Yes». Si aparece la aprobación de un plan, elige «manually approve edits», para seguir viendo cada edición. Si apareciera una petición de git push, elegiría «No». Cada respuesta se da 1,5 segundos después de ver el menú.
  4. Fotografiar la pantalla. Guarda la pantalla con sus colores en un fichero .ansi, que después convertimos en imagen. Las capturas de esta página salen de ahí sin retocar el texto, y los desplegables de cada paso muestran el texto de esas mismas pantallas.
  5. Anotar lo ocurrido. Cada orden, menú, reinicio y tiempo se escribe en un diario, del que salen las cifras de la tabla.

Las órdenes que solo abren un panel (/status, /permissions, /skills, /hooks…) se escriben, se fotografía el panel y se cierra con Escape. Para cambiar de modo, el programa pulsa Mayúsculas+Tab hasta ver el modo pedido en la barra inferior. Para reiniciar, escribe /exit y vuelve a entrar con claude --continue, que recupera la misma conversación. Los pasos de terminal (Git, npm) se ejecutan en otra ventana de tmux, fuera de Claude.

Hicieron falta tres vueltas. En la primera, el programa escribía antes de que Claude estuviera listo. En la segunda tecleaba los mensajes largos carácter a carácter; Claude Code tomó esa avalancha de teclas como un pegado y solo envió la última línea, así que, sin las decisiones que le dábamos, Claude diseñó su propia multibola. Para la tercera pegamos el texto de una vez y contestamos por escrito las preguntas de Claude, como haría una persona. La tercera vuelta es la válida y es la única que contamos aquí.

Los ficheros que el libro pide preparar (las reglas de permisos, la skill, el subagente y los hooks) los copiamos desde una carpeta de plantillas en el paso correspondiente. En la sección siguiente explicamos cada uno, línea a línea, con la orden que lo instala, cómo comprobamos que Claude Code lo había cargado y qué hizo de verdad durante la vuelta.

Los números de la vuelta válida
MedidaValor
Duración total46 minutos, casi todos de trabajo de Claude
Mensajes enviados a Claude25 turnos, entre órdenes con barra y peticiones escritas
Menús contestados103: 101 permisos y 2 aprobaciones de plan, cada uno en 1,5 segundos
Reinicios de la sesión2 (para la skill y para el subagente)
Cambios de modo4, con Mayúsculas+Tab (a manual tres veces y a planificación una)
Preguntas que Claude hizo con opciones0; las dudas las planteó en prosa
Código generado1.533 líneas añadidas y 237 quitadas
Coste estimado que muestra /usage6,45 dólares, dentro de una suscripción
Con qué se hizo el experimento
ElementoValor
Fecha20 de noviembre de 2026, de 20:18 a 21:05 (hora peninsular española)
MáquinaMac Studio con Apple M3 Ultra, 32 núcleos y 256 GB de memoria
SistemamacOS 27.2
Claude Code2.1.285, interactivo, sin actualizar durante la prueba
ModeloClaude Opus 5.5 con esfuerzo medio, dentro de una suscripción (plan Ultra)
ConfiguraciónVacía, en ~/sdd-931/config; sin skills, reglas ni CLAUDE.md de usuario
HerramientasNode.js 25.9, npm, Git 2.54, tmux 3.8 (terminal de 120×42) y Python 3.13 para el programa que teclea
Menú de permiso para ejecutar npm -v con cuatro opciones: sí, sí y no volver a preguntar, sí y pasar a modo auto, o no
Uno de los 101 menús de permiso. El programa elige siempre la primera opción, «Yes», que permite esa acción una vez.

LAS PIEZAS, UNA A UNA

Qué preparamos alrededor de Claude y para qué sirve cada cosa

Claude Code no es solo la conversación. Alrededor de ella hay ficheros que cambian lo que puede hacer: las reglas de permisos, el fichero de instrucciones, las skills, los subagentes y los hooks. El libro pide preparar cada uno en un paso concreto, y aquí los explicamos antes de entrar en los pasos, para que al leer «copiamos la skill» o «activamos el hook» se sepa qué hay dentro, dónde va y qué cambió en la sesión. Todos viven en la carpeta .claude/ del repositorio, de modo que se versionan con Git como el código y cualquiera que clone el proyecto los recibe.

Para cada pieza contamos lo mismo: qué es, qué dice el fichero que usamos, la orden con la que lo pusimos en su sitio, cómo comprobamos que Claude Code lo había cargado y qué hizo de verdad durante la vuelta, incluido lo que no llegamos a ver funcionar.

Una configuración aislada

Claude Code guarda su configuración de usuario (la cuenta, las preferencias, las skills y las instrucciones personales) en una carpeta de la persona. Si la hubiéramos usado, la sesión habría cargado nuestras propias reglas y skills, y el recorrido no habría mostrado lo que ve alguien que empieza. Por eso apuntamos la variable CLAUDE_CONFIG_DIR a una carpeta vacía y abrimos el proyecto en una carpeta nueva:

export CLAUDE_CONFIG_DIR=~/sdd-931/config
mkdir -p ~/sdd-931/arkanoid && cd ~/sdd-931/arkanoid
claude --version
claude doctor

El programa que condujo la vuelta abría Claude siempre con esa variable puesta. Hay una consecuencia que no esperábamos: aunque la carpeta esté vacía, la sesión trae las skills y los conectores sincronizados desde la cuenta de claude.ai. Se ven en /skills (marcadas «claude.ai sync») y en /mcp. Aislar la configuración local no aísla la cuenta.

Lista de skills: casos-limite marcada como project y las demás como sincronizadas desde claude.ai
En /skills, la única skill del proyecto es casos-limite; las demás llegan desde la cuenta.

Las reglas de permisos y los modos

Cada vez que Claude quiere hacer algo con efecto (editar un fichero, ejecutar una orden), Claude Code consulta unas reglas antes de dejarle. Las reglas del proyecto van en .claude/settings.json y se escriben como el nombre de la herramienta seguido de un patrón entre paréntesis: Bash(npm test) es la orden exacta, Bash(npm test:*) es esa orden con cualquier argumento y Edit(src/**) es editar cualquier fichero bajo src/. Las reglas se reparten en tres listas:

  • allow: se hace sin preguntar. Pusimos npm test y npm run lint, que solo leen y comprueban.
  • ask: se pregunta siempre, aunque el modo diga otra cosa. Pusimos editar src/, porque ahí está el juego.
  • deny: no se hace nunca. Pusimos editar las pruebas ratificadas y git push. Si una acción encaja a la vez en deny y en otra lista, gana deny.

Lo que no encaja en ninguna lista depende del modo de la sesión, que se ve en la barra inferior y se cambia con Mayúsculas+Tab. En modo manual (el que el libro llama «por defecto») Claude pregunta antes de cada acción con efecto; en modo plan solo lee y propone; en modo auto un clasificador decide por él muchas acciones. La línea "defaultMode": "default" fija el modo manual al abrir la sesión, y la añadimos después de descubrir en el paso 4 que, sin ella, esta versión arranca en auto.

mkdir -p .claude
cp plantillas/settings-permisos.json .claude/settings.json

Lo comprobamos con /permissions, que enseña las reglas por pestañas. Durante la vuelta, el modo manual produjo 101 menús de permiso: cada lectura de un fichero fuera de lo permitido, cada orden de terminal y cada edición de src/. La regla deny de git push se vio funcionar en el paso 11: la orden ni siquiera llegó a preguntarse. La de las pruebas ratificadas no llegó a dispararse, porque Claude se negó antes de intentarlo.

Fíjate en el .gitignore del proyecto: excluye .claude/settings.local.json. Ese es el sitio de las reglas personales de cada persona, que no deben imponerse al equipo; settings.json, en cambio, se versiona.

Panel de permisos con las reglas que permiten npm run lint y npm test
/permissions, pestaña de reglas permitidas: las cuatro de npm.
Menú de permiso para ejecutar npm -v
Lo que no está en ninguna lista se pregunta. «Yes» lo permite una vez; la segunda opción lo añadiría a allow.
Fichero completo: settings-permisos.json
{
  "permissions": {
    "allow": [
      "Bash(npm test)",
      "Bash(npm test:*)",
      "Bash(npm run lint)",
      "Bash(npm run lint:*)"
    ],
    "ask": [
      "Edit(src/**)"
    ],
    "deny": [
      "Edit(tests/**/*.ratificada.test.js)",
      "Bash(git push:*)"
    ],
    "defaultMode": "default"
  }
}
Fichero completo: gitignore
node_modules/
dist/
coverage/
.env
.env.*
*.log
.DS_Store
.claude/settings.local.json

El fichero de instrucciones: CLAUDE.md

CLAUDE.md es un fichero de texto en la raíz del repositorio que Claude Code lee al empezar cada sesión. Sirve para lo que una persona nueva tendría que saber antes de tocar nada: cómo se arranca, cómo se prueba, qué partes no se deben romper y qué reglas tiene el proyecto. No es una barrera (Claude puede equivocarse aunque lo lea), pero evita que cada sesión empiece de cero.

No lo escribimos nosotros: en el paso 6 tecleamos /init y Claude lo generó leyendo el proyecto. Recogió las órdenes de package.json, una trampa real de Node 25 con npm test, la arquitectura (lógica pura en src/game.js, navegador solo en src/main.js) y las reglas de settings.json. Que leyera también los permisos es útil: así Claude sabe por qué le van a decir que no antes de intentarlo.

Para comprobar qué instrucciones está usando, /memory enseña los ficheros cargados y permite abrirlos. /context los cuenta: «Memory files: 2 files · 6.3k tokens», que son el CLAUDE.md del proyecto y el de la configuración. El fichero completo que generó /init está en el paso 6.

Resumen de /init tras crear CLAUDE.md
El resumen de /init: órdenes, arquitectura, decisiones de diseño y permisos.

La skill: un procedimiento con nombre

Una skill es una carpeta dentro de .claude/skills/ con un fichero SKILL.md. El fichero tiene dos partes. Arriba, entre las dos líneas ---, una cabecera con el name (el nombre con el que se llama, aquí casos-limite) y la description, que es lo único que Claude ve de la skill hasta que la usa: por eso dice tanto qué hace como cuándo usarla. Debajo, el procedimiento, escrito como se le explicaría a una persona.

La nuestra pide una tabla de casos límite: cada cantidad en 0, 1, un valor intermedio, justo por debajo del máximo, el máximo y por encima; los eventos simultáneos; y que marque como «decisión abierta» lo que la especificación no fije, en vez de inventarlo. La última línea le prohíbe editar nada. Esa frase no impide editar (solo los permisos lo impiden), así que la invocamos en modo plan, que sí lo impide.

mkdir -p .claude/skills/casos-limite
cp plantillas/skill/SKILL.md .claude/skills/casos-limite/

Hay dos formas de usar una skill: llamarla por su nombre, como una orden (/casos-limite la multibola de docs/especificacion-multibola.md…), o dejar que Claude la elija cuando el encargo encaja con su descripción. Nosotros la llamamos por su nombre, para poder comparar el resultado con el plan anterior.

Lo que pasó al instalarla: la copiamos con la sesión abierta y /skills contestó «No changes». Claude Code lee las skills al arrancar, así que hubo que salir con /exit y volver con claude --continue. Después apareció como casos-limite · project · ~80 tok: «project» quiere decir que viene del repositorio, y los 80 tokens son lo que cuesta tener su descripción siempre a mano. La tabla que produjo tenía 42 casos, 19 de ellos nuevos.

Resultado de la skill casos-limite
El resultado de /casos-limite, en modo plan, comparado con la especificación.
Fichero completo: skill/SKILL.md
---
name: casos-limite
description: Construye la tabla de casos límite de una regla o requisito (valores cero, uno, intermedios, el máximo y lo que ocurre a la vez) antes de implementarlo. Úsala al especificar o planificar un cambio con números, límites o eventos simultáneos.
---

# Casos límite

Para la regla que te indiquen:

1. Localiza cada cantidad con límite (mínimo, máximo, constantes) y cada evento que pueda ocurrir a la vez que otro.
2. Para cada cantidad, propone casos en 0, 1, un valor intermedio, justo por debajo del máximo, el máximo y lo que pasaría al superarlo.
3. Para los eventos, propone los casos simultáneos: dos impactos en el mismo instante, dos efectos seguidos, un efecto que llega con el máximo ya alcanzado.
4. Devuelve una tabla con columnas: caso, estado inicial, acción, resultado esperado, requisito que lo justifica y si ya estaba en el plan.
5. Marca como «decisión abierta» todo resultado que la especificación no fije; no lo inventes.

No edites código ni pruebas: esta skill solo produce la tabla.

El subagente: otro agente con un encargo

Un subagente es un segundo agente al que el principal encarga una tarea. Trabaja con su propio contexto (no ve la conversación, solo el encargo), puede usar otro modelo y otras herramientas, y devuelve un informe. Sirve para repartir trabajo y para tener una segunda mirada que no arrastre lo que el principal ya cree.

Se define con un fichero Markdown en .claude/agents/. La cabecera lleva el name, la description (para que el principal sepa cuándo recurrir a él), el model y las tools. Elegimos haiku, un modelo más barato, porque revisar una lista de casos no necesita el más capaz, y solo Read, Grep, Glob: puede leer y buscar, pero no editar ni ejecutar órdenes. Esta vez la restricción sí es real, porque la impone Claude Code al darle las herramientas. El texto de debajo es lo que el subagente recibe como instrucciones de partida.

mkdir -p .claude/agents
cp plantillas/agente/revisor-casos-limite.md .claude/agents/

Para usarlo basta pedirlo en la conversación: «Pide al subagente revisor-casos-limite que busque casos límite de la multibola y contrasta su informe con docs/especificacion-multibola.md». En los mensajes del paso 9 se ve cómo funciona: el principal lanza el subagente con la herramienta Agent, el subagente trabaja en segundo plano y su informe vuelve como una notificación que entra sola en la conversación.

Comprobar que estaba cargado fue menos directo de lo que dice el libro. En esta versión, /agents ya no abre un panel; solo explica dónde se guardan los ficheros. La prueba la dio /context: «Custom agents · .claude/agents/ · 1 agent · 69 tokens».

Claude contrasta el informe del subagente
El principal contrasta el informe del revisor y descarta sus seis «contradicciones».
Fichero completo: agente/revisor-casos-limite.md
---
name: revisor-casos-limite
description: Revisor de casos límite de la multibola. Lee la especificación, el código y las pruebas y devuelve los casos límite que faltan. No edita nada.
model: haiku
tools: Read, Grep, Glob
---

Eres un revisor. Lee la especificación de la multibola, el código de src/ y las pruebas de tests/.
Devuelve una lista breve de casos límite que no estén cubiertos por una prueba, cada uno con el requisito que afecta (FR-00x) y el resultado que debería observarse.
No edites ficheros ni propongas código; solo informa.

Los hooks: programas que se ejecutan solos

Un hook es una orden que Claude Code ejecuta por su cuenta cuando ocurre un evento: antes de usar una herramienta, después de usarla, al empezar la sesión, al terminar un turno y unos treinta momentos más, que lista el panel /hooks. A diferencia de CLAUDE.md o de una skill, no depende de que Claude lo lea ni de que esté de acuerdo: lo ejecuta la herramienta. Por eso es el sitio de las comprobaciones que no se pueden dejar a la buena voluntad del modelo.

Se configuran en el mismo settings.json, en un bloque hooks. Cada entrada dice el evento, un matcher con las herramientas a las que afecta y la orden que se ejecuta. Nosotros pusimos dos, los dos sobre Edit|Write|MultiEdit, las tres herramientas con las que Claude escribe ficheros:

  • PreToolUse → proteger-ratificadas.mjs. Antes de cada escritura, Claude Code le pasa por la entrada estándar un JSON con la herramienta y sus argumentos. El script lee la ruta del fichero y, si termina en .ratificada.test.js, escribe un motivo y sale con código 2. El código 2 significa «bloquear»: la edición no se hace y el motivo le llega a Claude.
  • PostToolUse → pruebas-rapidas.sh. Después de cada escritura ejecuta npm test. Si pasa, sale con 0 y no se nota nada. Si falla, devuelve las últimas 25 líneas con código 2, y Claude recibe el fallo en ese mismo momento, sin esperar a que alguien lance las pruebas.

La variable $CLAUDE_PROJECT_DIR la pone Claude Code con la raíz del proyecto, para que las rutas funcionen aunque Claude esté en otra carpeta. El fichero de hooks incluye también los permisos, porque sustituye al settings.json del paso 4:

cp plantillas/settings-hooks.json .claude/settings.json
mkdir -p .claude/hooks
cp plantillas/hooks/* .claude/hooks/

Al contrario que la skill y el subagente, los hooks se cargaron sin reiniciar: /hooks mostró «2 hooks configured», uno en PreToolUse y otro en PostToolUse. Lo que hicieron durante la vuelta:

  • El de pruebas rápidas trabajó de verdad. Claude escribió una prueba que fallaba por un error suyo (comprobaba las bolas originales y no las del estado del juego), el hook se lo devolvió y Claude lo corrigió en el mismo turno. Lo contó así: «La primera versión falló, y el hook de pruebas rápidas lo señaló».
  • El de las ratificadas no llegó a bloquear nada, porque en el ensayo Claude se negó antes de intentar la edición. Lo que demostramos es que estaba cargado, no que bloqueara; para verlo bloquear habría que forzar la edición.
  • Tuvo un efecto que nadie había previsto: npm run lint analizó el script del hook y dio tres errores, porque ESLint no sabía que era código de Node. Claude no tocó el hook («un hook nuevo que no es mío») y añadió .claude/hooks/**/*.mjs a la configuración de ESLint.

El propio script lo avisa en su segunda línea: solo mira las herramientas de edición. Una orden sed desde la terminal no pasa por él, y eso fue justo lo que probamos en el segundo ensayo del paso 11.

Panel de hooks con un hook del proyecto
/hooks es de solo lectura: para cambiar un hook se edita settings.json.
Fichero completo: settings-hooks.json
{
  "permissions": {
    "allow": [
      "Bash(npm test)",
      "Bash(npm test:*)",
      "Bash(npm run lint)",
      "Bash(npm run lint:*)"
    ],
    "ask": [
      "Edit(src/**)"
    ],
    "deny": [
      "Edit(tests/**/*.ratificada.test.js)",
      "Bash(git push:*)"
    ],
    "defaultMode": "default"
  },
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write|MultiEdit",
        "hooks": [
          {
            "type": "command",
            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/proteger-ratificadas.mjs\""
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Edit|Write|MultiEdit",
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/pruebas-rapidas.sh\""
          }
        ]
      }
    ]
  }
}
Fichero completo: hooks/proteger-ratificadas.mjs
// PreToolUse: rechaza editar una prueba ratificada (*.ratificada.test.js).
// Solo mira las herramientas de edición; una orden de Bash no pasa por aquí.
let raw = '';
for await (const c of process.stdin) raw += c;
const { tool_input: t = {} } = JSON.parse(raw || '{}');
const ruta = t.file_path || t.notebook_path || '';
if (/\.ratificada\.test\.js$/.test(ruta)) {
  console.error(`Prueba ratificada protegida: ${ruta}. Si la regla cambia, se cambia antes la especificación y la persona ratifica la prueba nueva.`);
  process.exit(2);
}
Fichero completo: hooks/pruebas-rapidas.sh
#!/bin/sh
# PostToolUse: pruebas rápidas tras cada edición; si fallan, el fallo vuelve al agente.
out=$(npm test --silent 2>&1) && exit 0
printf '%s\n' "$out" | tail -25 >&2
exit 2

Ratificar una prueba

«Ratificada» es una palabra del libro, no de Claude Code. Una prueba ratificada es una que la persona ha revisado y acepta como contrato: si el código no la cumple, se cambia el código; si la regla cambia, primero se cambia la especificación y después la persona ratifica una prueba nueva. Para que la herramienta pueda reconocerla sin interpretar nada, la convención es el nombre: *.ratificada.test.js. Las dos protecciones (la regla deny y el hook) se fijan en ese sufijo.

En la vuelta, la persona ratificó la prueba del tope de 200 bolas después de la segunda etapa, renombrándola y haciendo commit desde la terminal:

git mv -f tests/tope-200.test.js tests/tope-200.ratificada.test.js
git add -A && git commit -q -m "Multibola: p11-inc2-tope"

El git mv falló porque el fichero aún no estaba en Git (Claude lo acababa de crear), y el programa hizo un mv normal; se ve en las órdenes de preparación del paso 11. Desde ese commit, los dos ensayos de protección se hicieron contra ese fichero.

Las órdenes con barra que usamos

Dentro de la sesión, todo lo que empieza por / es una orden de Claude Code o una skill. Algunas abren un panel y no hablan con el modelo; otras se convierten en un encargo para Claude. Estas son las que tecleamos, en el orden en que aparecen:

OrdenQué haceHabla con el modeloPaso
/helpLista las órdenes y los atajosNo1
/statusVersión, modelo, carpeta, cuenta y configuración en usoNo1
/mcpServidores MCP conectados y sus herramientasNo3
/permissionsReglas allow, ask y deny por pestañasNo4
/initLee el proyecto y escribe CLAUDE.mdSí6
/memoryFicheros de instrucciones cargadosNo6
/plan …Pasa a modo plan y le da el encargo: leer y proponer sin editarSí7
/skillsSkills disponibles, su origen y lo que ocupanNo8
/casos-limite …Nuestra skill, llamada por su nombreSí8
/agentsEn esta versión solo explica dónde van los subagentesNo9
/goal …Fija una condición de terminación y Claude sigue trabajando hasta cumplirlaSí10
/hooksEventos con hooks configurados, de solo lecturaNo11
/contextQué ocupa la memoria de trabajo de ClaudeNo11
/usageEl uso de la cuenta y cuánto se gastó con contextos largos (no publicamos la imagen porque enseña datos de la cuenta)No11
/runSkill que trae Claude Code: arranca la aplicación y la usaSí12
/verifySkill que trae Claude Code: comprueba de punta a punta que un cambio funciona; aquí dejó además una skill verify propia del proyectoSí12
/exit y claude --continueSalir y volver a la misma conversación, para que se carguen skills y subagentes nuevosNo8 y 9

El README y el .gitignore de partida

El repositorio empezó con dos ficheros escritos a mano en el paso 2: un README de una línea que dice qué es el proyecto, y un .gitignore que deja fuera las dependencias, las compilaciones, los secretos (.env) y las reglas personales de Claude Code. Claude amplió el README en los pasos 10 y 13; el .gitignore no lo tocó.

Fichero completo: README.md
# Arkanoid

Arkanoid para el navegador, construido paso a paso con Claude Code siguiendo el apartado 9.3.1 del libro.

LOS CATORCE PASOS

Qué escribimos y qué pasó en cada paso

Esta tabla resume el recorrido. Debajo, cada paso tiene a la izquierda lo que hicimos y lo que dice el libro, y a la derecha sus capturas. Bajo cada paso hay desplegables con los mensajes literales: lo que escribimos (la ida) y todo lo que contestó Claude (la vuelta), incluidas las herramientas que usó y los errores que le devolvieron. La columna del tiempo cuenta desde que enviamos la instrucción hasta que Claude devolvió el control.

Seguimos el orden de la versión 86a del libro, que es la que recorrimos. En la 87a, corregida tras este recorrido, los incrementos pasan a ser el paso 10 y /goal el 11, y el paso de las peticiones va antes que el de la entrega. En cada paso indicamos su número en la 87a.

PasoQué escribimosQué pasóTiempo
1. Preparar la herramientaclaude --version, claude doctor; dentro, /help y /statusVersión 2.1.285, anotada como primera entrada del registro23 s
2. Repositoriogit init -b main, README, .gitignore y primer commitCommit inicial limpio7 s
3. Herramientas externasclaude mcp list y /mcpNingún servidor del proyecto; solo dos conectores de la cuenta, sin usar4 s
4. Permisos.claude/settings.json y /permissionsReglas visibles. Descubrimos que, sin decir nada, la sesión arranca en modo auto43 s
5. Primera versión«Construye un Arkanoid para el navegador con JavaScript y npm, sin multibola…»Juego jugable, 13 pruebas, lint y build en verde3 min 38 s
6. Instrucciones/init y /memoryCLAUDE.md de 43 líneas con los comandos reales54 s
7. Especificar/plan describir la multibola y sus casos límiteLista de decisiones abiertas; con las nuestras, la especificación en docs/2 min 42 s
8. SkillSkill casos-limite y /casos-limite …Hubo que reiniciar para verla; tabla de 42 casos2 min 20 s
9. SubagenteRevisor con modelo barato y solo lectura/agents ya no abre panel; un informe más pobre que el de la skill1 min 43 s
10. Cuándo termina (11 en la 87a)/goal Termina cuando el juego compile, pasen lint y tests…Implementó toda la multibola en un solo turno9 min 14 s
11. Incrementos y hooks (10 en la 87a)Hook PreToolUse, cuatro etapas, intento de cambiar la prueba ratificada y git pushLas etapas ya estaban hechas; la prueba y el push, protegidos12 min 26 s
12. Comprobacionesnpm run build, lint, test, /run y /verify44 pruebas en verde y un fallo real que las pruebas no veían10 min 52 s
13. Dejarlo repetible y entregar (14 en la 87a)«Actualiza el README con la instalación, el arranque…»README completo, con cada orden comprobada; commit final1 min 4 s
14. Peticiones en su sitio (13 en la 87a)Repasar dónde queda cada reglaYa estaban en CLAUDE.md, la skill, el hook y los permisos—

Paso 1: preparar la herramienta y anotar su versión

El primer paso es de terminal y no tiene sorpresas: claude --version dijo 2.1.285, claude --help listó las opciones y claude doctor comprobó la instalación. Dentro de la sesión, /help enseñó las órdenes y /status el modelo, la carpeta y la cuenta. Anotar la versión parece un trámite, pero es lo que permite saber, meses después, si un comportamiento distinto viene del proyecto o de la herramienta. En este recorrido lo comprobamos en carne propia: varias cosas del libro habían cambiado en la versión que usamos.

Lo que dice el libro (versión 87a)

1. Preparar y comprobar la herramienta. Empezamos en una terminal del sistema, antes de abrir Claude Code, y ejecutamos claude --version, claude --help y claude doctor para comprobar la instalación y consultar su ayuda.

Anotamos el número de versión que devuelve claude --version, la fecha y el sistema operativo (por ejemplo, macOS 15 o Ubuntu 24.04) como primera entrada del registro del entorno.

Después entramos en la raíz del repositorio y ejecutamos claude, para que la sesión se abra en esa carpeta.

claude doctor pertenece a la terminal, mientras que las órdenes con barra se escriben dentro de la sesión. Ya dentro, /help muestra las órdenes disponibles y /status el modelo y la conexión que usa la sesión. Si más adelante un resultado cambia, esa primera anotación nos dirá si también cambió la herramienta.

Pantalla de bienvenida de Claude Code 2.1.285 con Opus 5.5 en la carpeta del Arkanoid, con el modo manual activado
La sesión se abre en la raíz del repositorio. Abajo, «manual mode on»: el modo en el que Claude pide permiso antes de cada acción.
Salida de claude doctor: versión 2.1.285 instalada con Homebrew, actualizaciones gestionadas por el gestor de paquetes y ningún problema de instalación
claude doctor, desde la terminal: versión, cómo se instaló y quién la actualiza. «No installation issues found».

Salida de cada orden, tal como apareció en la pantalla

Terminal: $ claude --version
arkanoid $ claude --version
2.1.285 (Claude Code)
arkanoid $
Terminal: $ claude --help
arkanoid $ claude --help
Usage: claude [options] [command] [prompt]

Claude Code - starts an interactive session by default, use -p/--print for non-interactive output

Arguments:
  prompt                                Your prompt

Options:
  --add-dir <directories...>            Additional directories to allow tool access to
  --agent <agent>                       Agent for the current session. Overrides the 'agent' setting.
  --agents <json-or-file>               JSON object defining custom agents, or with --print the path to a file that
                                        holds one (e.g. '{"reviewer": {"description": "Reviews code", "prompt": "You are
                                        a code reviewer"}}')
  --allow-dangerously-skip-permissions  Enable bypassing all permission checks as an option, without it being enabled by
                                        default. Recommended only for sandboxes with no internet access.
  --allowedTools, --allowed-tools <tools...>
      Comma or space-separated list of tool names to allow (e.g. "Bash(git *) Edit")
  --append-system-prompt <prompt>       Append a system prompt to the default system prompt
  --autocompact <auto|tokens>           Auto-compact window size (auto, or 100k–1M tokens)
  --ax-screen-reader                    Render screen-reader friendly output (flat text, no decorative borders or
                                        animations).
  --bg, --background                    Start the session in the background and return immediately. Prints the id that
                                        `claude attach`, `logs`, `stop` and `rm` take; `claude agents` lists them. With
                                        --resume <session-id>, continues that session in the background under the same
                                        ID, or starts a copy and says so when the session is already running
  --bare                                Minimal mode: skip hooks (those defined in settings and by installed plugins;
                                        features built into Claude Code are unaffected), LSP, plugin sync, attribution,
                                        auto-memory, background prefetches, keychain reads, and CLAUDE.md
                                        auto-discovery. Sets CLAUDE_CODE_SIMPLE=1. Anthropic auth is strictly
                                        ANTHROPIC_API_KEY or apiKeyHelper via --settings (OAuth and keychain are never
                                        read). 3P providers (Bedrock/Vertex/Foundry) use their own credentials. Skills
                                        still resolve via /skill-name. Explicitly provide context via:
                                        --system-prompt[-file], --append-system-prompt[-file], --add-dir (CLAUDE.md
                                        dirs), --mcp-config, --settings, --agents, --plugin-dir.
  --betas <betas...>                    Beta headers to include in API requests (API key users only)
  --brief                               Enable SendUserMessage tool for agent-to-user communication
  --chrome                              Enable Claude in Chrome integration
  --client-data-url <url>               URL for a signed configuration document. Claude Code exits if it cannot load it
                                        or it does not cover the selected model. Setting CLAUDE_CODE_CLIENT_DATA_URL
                                        instead keeps the URL out of the process list
  --cloud [description|session_id|url]  Create a cloud session with the given description, or attach to an existing one
                                        by session ID or claude.ai/code URL
  -c, --continue                        Continue the most recent conversation in the current directory
  --dangerously-skip-permissions        Bypass all permission checks. Recommended only for sandboxes with no internet
                                        access.
  -d, --debug [filter]                  Enable debug mode with optional category filtering (e.g., "api,hooks" or
                                        "!1p,!file")
  --debug-file <path>                   Write debug logs to a specific file path (implicitly enables debug mode)
  --desktop                             Open in the Claude Desktop app instead of the terminal (with --continue or
                                        --resume <id> to pick the session)
  --disable-slash-commands              Disable all skills
  --disallowedTools, --disallowed-tools <tools...>
      Comma or space-separated list of tool names to deny (e.g. "Bash(git *) Edit")
  --effort <level>                      Effort level for the current session (low, medium, high, xhigh, max)
  --environment <environment_id>        Create a new cloud session that runs on the given self-hosted environment
                                        (ccpool_...).
  --exclude-dynamic-system-prompt-sections
      Move per-machine sections (cwd, env info, memory paths, git status) from the system prompt into the first user
      message. Improves cross-user prompt-cache reuse. Only applies with the default system prompt (ignored with
      --system-prompt). (default: false)
  --fallback-model <model>              Enable automatic fallback to specified model(s) when the default model is
                                        overloaded or not available. Accepts a comma-separated list to try each in
                                        order. Re-tries the primary at the start of each user turn.
  --file <specs...>                     File resources to download at startup. Format: file_id:relative_path (e.g.,
                                        --file file_abc:doc.txt file_def:img.png)
  --fork-session                        When resuming, create a new session ID instead of reusing the original (use with
                                        --resume or --continue)
  --forward-subagent-text               Forward subagent text and thinking blocks as assistant/user messages with
                                        parent_tool_use_id set (only works with --print and --output-format=stream-json)
  --from-pr [value]                     Resume a session linked to a PR by PR number/URL, or open interactive picker
                                        with optional search term
  -h, --help                            Display help for command
  --ide                                 Automatically connect to IDE on startup if exactly one valid IDE is available
  --include-hook-events                 Include all hook lifecycle events in the output stream (only works with
                                        --output-format=stream-json)
  --include-partial-messages            Include partial message chunks as they arrive (only works with --print and
                                        --output-format=stream-json)
  --input-format <format>               Input format (only works with --print): "text" (default), or "stream-json"
                                        (realtime streaming input) (choices: "text", "stream-json")
  --json-schema <schema>                JSON Schema for structured output validation. Example:
                                        {"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}
  --max-budget-usd <amount>             Maximum dollar amount to spend on API calls (only works with --print)
  --mcp-config <configs...>             Load MCP servers from JSON files or strings (space-separated)
  --model <model>                       Model for the current session. Provide an alias for the latest model (e.g.
                                        'fable', 'opus', or 'sonnet') or a model's full name.
  -n, --name <name>                     Set a display name for this session (shown in the prompt box, /resume picker,
                                        and terminal title)
  --no-chrome                           Disable Claude in Chrome integration
  --no-session-persistence              Disable session persistence - sessions will not be saved to disk and cannot be
                                        resumed (only works with --print)
  --output-format <format>              Output format (only works with --print): "text" (default), "json" (single
                                        result), or "stream-json" (realtime streaming) (choices: "text", "json",
                                        "stream-json")
  --permission-mode <mode>              Permission mode to use for the session (choices: "acceptEdits", "auto",
                                        "bypassPermissions", "manual", "dontAsk", "plan")
  --permission-prompts <target>         Who answers permission prompts with --print: "host" (the SDK host or
                                        --permission-prompt-tool) or "none" (nobody: anything that would prompt is
                                        denied automatically; the permission mode still decides everything else)
                                        (choices: "host", "none", default: "host")
  --plugin-dir <path>                   Load a plugin from a directory or .zip for this session only; a folder of
                                        plugins loads each child (repeatable: --plugin-dir A --plugin-dir B.zip)
                                        (default: [])
  --plugin-url <url>                    Fetch a plugin .zip from a URL for this session only (repeatable: --plugin-url A
                                        --plugin-url B) (default: [])
  -p, --print                           Print response and exit (useful for pipes). Note: The workspace trust dialog is
                                        skipped when Claude is run in non-interactive mode (via -p, or when stdout is
                                        not a TTY, e.g. piped or redirected output). Only use this in directories you
                                        trust. Settings files that fail validation are silently ignored in this mode (no
                                        error dialog is shown).
  --prompt-suggestions [value]          Enable prompt suggestions. In print/SDK mode, emits a prompt_suggestion message
                                        after each turn with a predicted next user prompt (choices: "true", "false",
                                        "1", "0", "yes", "no", "on", "off", preset: "true")
  --remote-control [name]               Start an interactive session with Remote Control enabled (optionally named)
  --remote-control-session-name-prefix <prefix>
      Prefix for auto-generated Remote Control session names (default: hostname)
  --replay-user-messages                Re-emit user messages from stdin back on stdout for acknowledgment (only works
                                        with --input-format=stream-json and --output-format=stream-json)
  --restricted                          Restricted mode: removes the built-in tools that run commands or code (Bash,
                                        PowerShell, REPL and the other code-running tools) and WebFetch unless --tools
                                        names them, and ignores user, project and local settings files (managed settings
                                        and --settings still apply; add --strict-mcp-config to skip MCP servers too).
                                        Also confines the file tools to the working directories (--add-dir included),
                                        refuses bypassPermissions, and lets only a person or the configured permission
                                        handler approve writes to settings, git and tool-configuration files.
  -r, --resume [value]                  Resume a conversation by session ID, or open interactive picker with optional
                                        search term
  --safe-mode                           Start with all customizations (CLAUDE.md, skills, installed plugins, hooks, MCP
                                        servers, custom commands and agents, output styles, workflows, custom themes,
                                        keybindings, and more) disabled — useful for troubleshooting a broken
                                        configuration. Admin-managed (policy) settings still apply. Auth, model
                                        selection, built-in tools and plugins, and permissions work normally. Sets
                                        CLAUDE_CODE_SAFE_MODE=1.
  --session-id <uuid>                   Use a specific session ID for the conversation (must be a valid UUID)
  --setting-sources <sources>           Comma-separated list of setting sources to load (user, project, local).
  --settings <file-or-json>             Path to a settings JSON file or a JSON string to load additional settings from
  --strict-mcp-config                   Only use MCP servers from --mcp-config, ignoring all other MCP configurations
  --system-prompt <prompt>              System prompt to use for the session
  --system-prompt-snapshot <on|off>     Record the system prompt once per conversation and reuse it verbatim on every
                                        request and resume. on (the default): the prompt is rendered on the
                                        conversation's first request — a --system-prompt or --append-system-prompt
                                        included — sent, and recorded; every later request and resume sends the record
                                        as-is, even when a later launch passes different text, until the conversation is
                                        compacted. off: never record; the prompt is rendered fresh every request (for
                                        iterating on prompt text). No effect where system-prompt recording is not yet
                                        enabled. (choices: "on", "off")
  --teleport [session]                  Resume a teleport session, optionally specify session ID
  --tmux                                Create a tmux session for the worktree (requires --worktree). Uses iTerm2 native
                                        panes when available; use --tmux=classic for traditional tmux.
  --tools <tools...>                    Specify the list of available tools from the built-in set. Use "" to disable all
                                        tools, "default" to use all tools, or specify tool names (e.g.
                                        "Bash,Edit,Read").
  --verbose                             Override verbose mode setting from config
  -v, --version                         Output the version number
  -w, --worktree [name]                 Create a new git worktree for this session (optionally specify a name)

Commands:
  agents [options]                      Manage background agents
  attach <id>                           Open a background session in this terminal. <id> is the short id that `claude
                                        --bg` prints and `claude agents` lists
  auth                                  Manage authentication
  auto-mode                             Inspect or reset auto mode classifier configuration
  doctor                                Check the health of your Claude Code installation. Reads settings files in the
                                        current directory without a trust prompt. For a full checkup that can also fix
                                        issues, run /doctor in a session.
  gateway [options]                     Run the enterprise auth/telemetry gateway
  import [options] [source]             Import config from another AI coding agent into Claude Code
  install [options] [target]            Install Claude Code native build. Use [target] to specify version (stable,
                                        latest, or specific version)
  logs <id>                             Print a background session's recent terminal output
  mcp                                   Configure and manage MCP servers
  plugin|plugins                        Manage Claude Code plugins
  project                               Manage Claude Code project state
  respawn [options] [id]                Restart a background session, or all of them with --all, so it runs the current
                                        Claude Code version
  rm <id>                               Delete a background session, and its worktree when that is safe. Works on
                                        sessions that have already exited
  setup-token                           Set up a long-lived authentication token (requires Claude subscription)
  stop|kill <id>                        Stop a background session. Its conversation is kept: `claude attach <id>` opens
                                        it again, `claude --resume` works once it is stopped
  ultrareview [options] [target]        Run a cloud-hosted multi-agent code review of the current branch (or a PR number
                                        / base branch) and print the findings
  update|upgrade                        Check for updates and install if available
arkanoid $
Terminal: $ claude doctor
arkanoid $ claude doctor
Claude Code doctor

Running: package-manager (2.1.285)
Commit: afb212976052
Platform: darwin-arm64
Package manager: homebrew
Path: /opt/homebrew/Caskroom/claude-code/2.1.285/claude
Config install method: unknown
Search: OK (bundled)
Auto-updates: Managed by package manager
Auto-update channel: latest
Last update attempt: none recorded
Managed settings (remote): not fetched — requires an Enterprise or Team subscription
Organization policy: not applicable to Pro and Max accounts

Remote Control
Control this session from claude.ai/code or the Claude mobile app

No installation issues found.

For a full setup checkup that can also fix issues, run /doctor in a Claude Code session.
arkanoid $
Terminal: $ sw_vers; date
arkanoid $ sw_vers; date
ProductName:		macOS
ProductVersion:		27.2.1
BuildVersion:		26B131
viernes, 20 de noviembre de 2026, 20:19:11 CET
arkanoid $
Dentro de Claude Code: /help
 ▐▛███▛█   Claude Code v2.1.285
▝▜██████▀  Opus 5.5 · Claude Ultra
 ▝▝   ▝▝   ~/sdd-931/arkanoid

▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
   Help  General   Commands   Custom commands

   Claude understands your codebase, makes edits with your permission, and executes commands — right from your
   terminal.
   Shortcuts
   ! for shell mode          double tap esc to clear input        ctrl + shift + _ to undo
   / for commands            shift + tab to auto-accept edits     ctrl + z to suspend
   @ for file paths          ctrl + o for verbose output          ctrl + v to paste images
   /btw for side question    ctrl + t to toggle tasks             opt + p to switch model
                             backslash (\) + return (⏎) for       ctrl + s to stash prompt
                             newline                              ctrl + g to edit in $EDITOR
                                                                  /keybindings to customize

   For more help: https://code.claude.com/docs/en/overview

   Esc to cancel
Dentro de Claude Code: /status
 ▝▝   ▝▝   ~/sdd-931/arkanoid

▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔ ◐ medium · /effort ▔
   Settings  Status   Config   Usage   Stats

   Version:           2.1.285
   Session name:      /rename to add a name
   Session ID:        [identificador omitido]
   Session kind:      interactive
   Peer address:      uds:[carpeta temporal de la sesión]
   cwd:               ~/sdd-931/arkanoid
   Login method:      Claude Ultra account
   Organization:      persona@ejemplo.com's Organization
   Email:             persona@ejemplo.com
   Cloud sessions:    GitHub connected

   Model:             Default (Opus 5.5 · Best for everyday, complex tasks)
   MCP servers:       2 connected, 1 disabled · /mcp
   Setting sources:   User settings, Shared project settings
   Auto mode server:  Disabled

   Esc to cancel

Paso 2: un repositorio con su primer commit

Creamos el repositorio con git init -b main, copiamos un README mínimo y un .gitignore, y guardamos el primer commit, «Inicio del proyecto». Tener un punto de partida limpio sirve para todo lo que viene después: cada cambio de Claude se podrá ver con git diff y deshacer si hace falta.

Lo que dice el libro (versión 87a)

2. Crear el repositorio y guardar el punto de partida. Desde la raíz de arkanoid ejecutamos git init -b main y creamos README.md y .gitignore (el fichero que indica a Git qué archivos no debe versionar).

Revisamos git status para comprobar que no hemos incluido secretos, binarios temporales ni archivos ajenos al proyecto.

Después guardamos el inicio con git add README.md .gitignore y git commit -m "Inicio del proyecto".

Si el proyecto ya existe en un remoto, lo clonamos y comprobamos el destino con git remote -v. Al terminar tendremos un commit inicial limpio desde el que poder comparar los cambios.

Salida de cada orden, tal como apareció en la pantalla

Terminal: $ git init -b main
arkanoid $ git init -b main
Initialized empty Git repository in ~/sdd-931/arkanoid/.git/
arkanoid $
Órdenes que lanzó el programa antes, sin captura
$ cp plantillas/README.md README.md && cp plantillas/gitignore .gitignore
Terminal: $ git status
arkanoid $ git status
On branch main

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	.gitignore
	README.md

nothing added to commit but untracked files present (use "git add" to track)
arkanoid $
Terminal: $ git add README.md .gitignore && git commit -m "Inicio del proyecto"
arkanoid $ git add README.md .gitignore && git commit -m "Inicio del proyecto"
[main (root-commit) 538423c] Inicio del proyecto
 2 files changed, 11 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 README.md
arkanoid $

Paso 3: las herramientas externas

MCP (Model Context Protocol) es el protocolo que usa Claude Code para hablar con herramientas externas, como GitHub o una base de datos. claude mcp list en la terminal y /mcp dentro de la sesión mostraron que el proyecto no tenía ningún servidor propio. Lo que sí aparecieron fueron dos conectores de la cuenta de claude.ai (la documentación de Claude y Google Drive), que Claude Code trae solo porque la sesión se abre con esa cuenta, y la herramienta integrada computer-use, desactivada. Es un detalle que conviene mirar en cualquier proyecto: aunque la configuración esté vacía, la cuenta puede añadir herramientas. Para este ejercicio no hacía falta ninguna, y ninguna se usó; no conectar lo que no se necesita reduce lo que el agente puede tocar.

Lo que dice el libro (versión 87a)

3. Conectar las herramientas necesarias. Este ejercicio puede completarse sin MCP. Si necesitamos una fuente externa, preparamos la conexión desde la terminal con claude mcp, y dentro de la sesión /mcp sirve para revisarla y completar la autenticación.

Si conectamos, por ejemplo, el servidor MCP de GitHub para consultar las incidencias del Arkanoid, anotamos el servidor, la herramienta que vamos a usar y que solo la usaremos para leer, sin abrir ni cerrar incidencias.

Lo conectamos al empezar y no a mitad de una tarea, porque una herramienta nueva obliga a rehacer la caché. Un servidor que no recordamos para qué se conectó, como uno de Slack en un ejercicio que no necesita mensajería, se queda fuera.

Panel de /mcp con tres servidores: dos conectores de claude.ai conectados y computer-use desactivado
/mcp: los dos conectores vienen de la cuenta de claude.ai, no del proyecto. computer-use está integrado y apagado.

Salida de cada orden, tal como apareció en la pantalla

Terminal: $ claude mcp list
arkanoid $ claude mcp list
claude.ai Claude Docs: https://api.anthropic.com/v1/pages/mcp - ✔ Connected
claude.ai Google Drive: https://drivemcp.googleapis.com/mcp/v1 - ✔ Connected
arkanoid $
Dentro de Claude Code: /mcp
 ▐▛███▛█   Claude Code v2.1.285
▝▜██████▀  Opus 5.5 · Claude Ultra
 ▝▝   ▝▝   ~/sdd-931/arkanoid

▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔ ◐ medium · /effort ▔
   Manage MCP servers
   3 servers

     claude.ai
   ❯ ✔ claude.ai Claude Docs    8 tools
     ✔ claude.ai Google Drive   17 tools

     Built-in MCPs (always available)
     ◯ computer-use

   https://code.claude.com/docs/en/mcp for help
   ↑/↓ to navigate · Enter to confirm · Esc to cancel

Paso 4: los permisos, antes de editar nada

Escribimos las reglas de permisos en .claude/settings.json: permitir npm test y npm run lint sin preguntar, preguntar antes de editar src/, y denegar la edición de las pruebas ratificadas y git push. La orden /permissions las enseña en pestañas; el fichero completo está en la sección anterior.

Aquí apareció la primera diferencia con el libro. Si el fichero de configuración no dice qué modo usar, esta versión de Claude Code arranca en modo auto, que decide solo muchas acciones sin preguntar. El modo que pregunta antes de actuar se llama ahora «manual». Para ver cada permiso, como pide el recorrido, hay que poner "defaultMode": "default" en la configuración o cambiar de modo con Mayúsculas+Tab. Nuestro programa hizo lo segundo al abrir la sesión. El libro ya recoge este cambio en el último párrafo de su texto:

Lo que dice el libro (versión 87a)

4. Delimitar los permisos antes de editar. Dentro de Claude Code abrimos /permissions y revisamos qué puede leer y editar, qué comandos puede ejecutar, qué acceso tiene a la red y qué directorios adicionales puede utilizar.

Mientras decidimos el cambio, trabajamos en el modo de planificación.

Las reglas de permitir, preguntar o denegar (allow, ask y deny en la configuración) se reparten según el riesgo.

En el Arkanoid podemos permitir npm test y npm run lint sin preguntar, pedir confirmación antes de editar src/ y denegar la edición de las pruebas ratificadas y git push, para que el agente no pueda cambiar por su cuenta una prueba protegida ni publicar en el remoto.

Sin defaultMode en la configuración, Claude Code 2.1.285 abre la sesión en modo auto, que aprueba por su cuenta las acciones que considera seguras. Para ver cada permiso durante este recorrido añadimos a .claude/settings.json el valor "defaultMode": "default", que la pantalla llama modo «manual», o cambiamos de modo con Mayús+Tab antes de pedir nada.

/permissions solo muestra y edita esas reglas; lo que aísla el acceso a archivos y a la red es /sandbox, donde esté disponible. Configurar los permisos antes de la primera edición evita descubrirlos cuando el agente ya ha tocado algo que no debía.

Panel de permisos de Claude Code con las reglas que permiten npm run lint y npm test
/permissions solo muestra y edita reglas. Lo que aísla de verdad archivos y red es /sandbox.

Salida de cada orden, tal como apareció en la pantalla

Órdenes que lanzó el programa antes, sin captura
$ mkdir -p .claude && cp plantillas/settings-permisos.json .claude/settings.json
Terminal: $ cat .claude/settings.json
arkanoid $ cat .claude/settings.json
{
  "permissions": {
    "allow": [
      "Bash(npm test)",
      "Bash(npm test:*)",
      "Bash(npm run lint)",
      "Bash(npm run lint:*)"
    ],
    "ask": [
      "Edit(src/**)"
    ],
    "deny": [
      "Edit(tests/**/*.ratificada.test.js)",
      "Bash(git push:*)"
    ],
    "defaultMode": "default"
  }
}
arkanoid $
Terminal: $ claude
 ▐▛███▛█   Claude Code v2.1.285
▝▜██████▀  Opus 5.5 · Claude Ultra
 ▝▝   ▝▝   ~/sdd-931/arkanoid

                                                                       Update available! Run: brew upgrade claude-code
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
❯ Try "edit <filepath> to..."
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Dentro de Claude Code: /permissions
 ▐▛███▛█   Claude Code v2.1.285
▝▜██████▀  Opus 5.5 · Claude Ultra
 ▝▝   ▝▝   ~/sdd-931/arkanoid

▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔ ◐ medium · /effort ▔
   Permissions  Recently denied   Allow   Ask   Deny   Auto mode   Workspace

   Claude Code won't ask before using allowed tools.
   ╭───────────────────────────────────────────────╮
   │ ⌕ Search…                                     │
   ╰───────────────────────────────────────────────╯

     1.  Add a new rule…
     2.  Bash(npm run lint:*)
     3.  Bash(npm run lint)
     4.  Bash(npm test:*)
     5.  Bash(npm test)
     6.  mcp__computer-use__computer_batch
     7.  mcp__computer-use__cursor_position
     8.  mcp__computer-use__double_click
     9.  mcp__computer-use__hold_key
   ↓ 10. mcp__computer-use__key

   ←/→ to switch · ↓ to select · Esc to cancel
015-p04-permissions-pestana2
 ▐▛███▛█   Claude Code v2.1.285
▝▜██████▀  Opus 5.5 · Claude Ultra
 ▝▝   ▝▝   ~/sdd-931/arkanoid

                                                                                                    ◐ medium · /effort
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
❯
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents

Paso 5: una primera versión sin multibola

Para especificar la multibola hace falta antes un juego. Se lo pedimos con el texto del libro, que fija la tecnología y lo que no queremos todavía, y Claude tardó algo más de tres minutos y medio y pidió 14 permisos. Separó la lógica del juego (game.js, sin dibujo, fácil de probar) del dibujo en el canvas y el teclado (main.js), escribió 13 pruebas y dejó lint y build en verde.

Nos gustó que dijera lo que no había comprobado: no abrió el juego en el navegador. También contó que una prueba falló y que corrigió la prueba, no el juego, algo que conviene leer con atención. Como predice el libro, decidió cosas que no le habíamos pedido: llamó a la página «Rompeladrillos», eligió las teclas (flechas, A, D y espacio) y la velocidad de la bola. Lo aceptamos, porque lo que vamos a especificar es la multibola, y guardamos esta versión con el commit «Primera versión sin multibola».

Lo que dice el libro (versión 87a)

5. Crear una primera versión del juego. Hasta aquí el repositorio solo tiene el README y el .gitignore, y para especificar la multibola necesitamos antes un juego al que añadírsela.

Salimos del modo de planificación y pedimos esa primera versión con una petición breve, parecida a la del primer intento sin especificación.

Esta vez indicamos la tecnología, porque los pasos siguientes necesitan órdenes reales del proyecto para arrancarlo y comprobarlo: “Construye un Arkanoid para el navegador con JavaScript y npm, sin multibola: una pala que se mueve con el teclado, una bola, una rejilla de ladrillos, puntuación, victoria al destruirlos todos y derrota si la bola cae. Deja el código en src/ y las pruebas en tests/, y añade a package.json las órdenes para arrancar el juego, analizar el código y ejecutar las pruebas.”

Como en el primer intento, el agente decidirá por su cuenta muchos detalles que no le hemos pedido, como la velocidad de la bola o el tamaño de la pala.

Por ahora lo aceptamos, porque lo que vamos a especificar es la multibola. Los permisos piden confirmación antes de editar src/, así que Claude Code nos preguntará antes de escribir cada fichero.

Abrimos el juego con la orden de arranque para comprobar que se puede jugar, revisamos con git status qué ficheros ha creado y guardamos esta versión con un commit.

Desde esta misma base sin multibola repetiremos el cambio con Spec Kit, Kiro, OpenSpec y Tessl en los capítulos siguientes.

Resumen de Claude tras construir la primera versión: 13 pruebas, lint y build correctos, sin abrir el juego en el navegador
Claude avisa de lo que no ha hecho: no ha abierto el juego en el navegador.
Pantalla inicial del Arkanoid con la rejilla de ladrillos y la bola sobre la pala
El punto de partida: una pala, una bola y una rejilla de ladrillos.
Ida y vuelta de el turno 1: 3 min 28 s de trabajo, 16 herramientas usadas

Turno 1 · 3 min 28 s

Ida: lo que escribimos

Construye un Arkanoid para el navegador con JavaScript y npm, sin multibola: una pala que se mueve con el teclado, una bola, una rejilla de ladrillos, puntuación, victoria al destruirlos todos y derrota si la bola cae. Deja el código en src/ y las pruebas en tests/, y añade a package.json las órdenes para arrancar el juego, analizar el código y ejecutar las pruebas.

Vuelta: lo que contestó Claude

  1. Bash ls -la && git log --stat | head -30 && ls .claude; node -v; npm -v
  2. Bash cat .gitignore README.md .claude/settings.json
  3. Bash mkdir -p src tests && npm init -y >/dev/null && npm install -D vite eslint @eslint/js globals 2>&1 | tail -3

Separo la lógica del juego (pura y comprobable sin navegador) del dibujo en canvas y del teclado.

  1. Write ~/sdd-931/arkanoid/src/game.js
  2. Edit ~/sdd-931/arkanoid/src/game.js
  3. Write ~/sdd-931/arkanoid/src/main.js
  4. Write ~/sdd-931/arkanoid/index.html

Ahora las pruebas, la configuración de ESLint y las órdenes de package.json.

  1. Write ~/sdd-931/arkanoid/tests/game.test.js
  2. Write ~/sdd-931/arkanoid/eslint.config.js
  3. Bash npm pkg set type=module description="Juego de romper ladrillos para el navegador" scripts.start="vite" scripts.build="vite build" scripts.lint="eslint ." scripts.test="node --test tests/" && npm pkg delete main keywords && cat package.json
  4. Bash npm run lint 2>&1 | tail -15; npm test 2>&1 | grep -E "^(not ok|# (tests|pass|fail))|Error|expected|actual" | head -30

Lint pasa limpio. Node 25 no acepta un directorio como argumento de --test; uso un patrón glob.

  1. Bash npm pkg set scripts.test="node --test \"tests/**/*.test.js\"" && npm test 2>&1 | grep -E "^(not ok|# (tests|pass|fail))|Error|expected|actual" | head -30
  2. Bash node -e " import('./src/game.js').then(({createGame,update})=>{ const s=createGame();update(s,1/60,{launch:true}); for(let i=0;i<60*120&&s.status==='playing';i++){const c=s.paddle.x+s.paddle.w/2;update(s,1/60,{left:s.ball.x<c-4,right:s.ball.x>c+4});} console.log(s.status,s.score,s.bricks.filter(b=>b.alive).length,s.ball);});"
  3. Edit ~/sdd-931/arkanoid/tests/game.test.js
  4. Bash npm test 2>&1 | grep -E "^(not ok|# (tests|pass|fail))|expected|actual" ; npm run lint 2>&1 | tail -3; npx vite build 2>&1 | tail -4
  5. Bash npm test 2>&1 | tail -9; rm -rf dist

El juego ya funciona. Las 13 pruebas pasan, npm run lint no da avisos y la compilación de producción (vite build) se genera sin errores. Lo que no he hecho es abrirlo en el navegador y jugarlo, así que conviene una partida de prueba con npm start.

He separado el juego en dos partes. La primera, src/game.js, contiene toda la lógica y no depende del navegador: crea la partida, mueve la pala y la bola, resuelve los choques y lleva la puntuación y el estado (ready, playing, won, lost). Como es código puro, las pruebas pueden comprobarla directamente. La segunda, src/main.js, dibuja en un canvas y lee el teclado. La página de entrada es index.html, en la raíz, que es donde Vite la busca.

Cómo se juega: la pala se mueve con ← → o con A y D, y la bola se lanza con la barra espaciadora. El ángulo del rebote depende del punto de la pala donde golpea la bola: en el centro sale casi vertical y en los extremos se desvía hasta 60 grados. Cada ladrillo da entre 10 y 50 puntos según su fila. Se gana al romper los 40 ladrillos y se pierde si la bola cae. Al terminar, la barra espaciadora empieza otra partida. La bola avanza en pasos más cortos que su radio, así que no atraviesa ningún ladrillo aunque vaya muy rápida; una de las pruebas lo comprueba.

Las órdenes de package.json:

  • npm start arranca el servidor de desarrollo de Vite.
  • npm run lint analiza el código con ESLint.
  • npm test ejecuta las pruebas con el ejecutor que trae Node (node --test), sin dependencias extra.
  • npm run build, que no pediste, genera la versión publicable.

En las pruebas hubo un fallo, y lo arreglé en la prueba, no en el juego. La última prueba simula una partida completa con una pala que persigue la bola. Al principio la pala siempre golpeaba con el centro, la bola caía casi vertical sobre huecos ya vacíos y la partida se quedaba con 9 ladrillos sin romper. El juego estaba bien: el problema era que el jugador simulado no apuntaba. Ahora cambia el punto de impacto cada dos segundos, como haría una persona, y la partida simulada termina en victoria.

Sobre el nombre: la página se llama «Rompeladrillos» y usa colores y dibujo propios. Sigue la mecánica del género, pero no copia el nombre ni el aspecto del juego original. El repositorio y el paquete npm siguen llamándose arkanoid.

No he hecho ningún commit. Los cambios nuevos son src/, tests/, index.html, eslint.config.js, package.json y package-lock.json.

Salida de cada orden, tal como apareció en la pantalla

Pantalla al terminar el turno: «Construye un Arkanoid para el navegador con JavaScript y npm, sin multibola: una pala q…»
  Ran 2 shell commands

⏺ El juego ya funciona. Las 13 pruebas pasan, npm run lint no da avisos y la compilación de producción (vite build) se
  genera sin errores. Lo que no he hecho es abrirlo en el navegador y jugarlo, así que conviene una partida de prueba
  con npm start.

  He separado el juego en dos partes. La primera, src/game.js, contiene toda la lógica y no depende del navegador: crea
  la partida, mueve la pala y la bola, resuelve los choques y lleva la puntuación y el estado (ready, playing, won,
  lost). Como es código puro, las pruebas pueden comprobarla directamente. La segunda, src/main.js, dibuja en un canvas
  y lee el teclado. La página de entrada es index.html, en la raíz, que es donde Vite la busca.

  Cómo se juega: la pala se mueve con ← → o con A y D, y la bola se lanza con la barra espaciadora. El ángulo del rebote
  depende del punto de la pala donde golpea la bola: en el centro sale casi vertical y en los extremos se desvía hasta
  60 grados. Cada ladrillo da entre 10 y 50 puntos según su fila. Se gana al romper los 40 ladrillos y se pierde si la
  bola cae. Al terminar, la barra espaciadora empieza otra partida. La bola avanza en pasos más cortos que su radio, así
  que no atraviesa ningún ladrillo aunque vaya muy rápida; una de las pruebas lo comprueba.

  Las órdenes de package.json:
  - npm start arranca el servidor de desarrollo de Vite.
  - npm run lint analiza el código con ESLint.
  - npm test ejecuta las pruebas con el ejecutor que trae Node (node --test), sin dependencias extra.
  - npm run build, que no pediste, genera la versión publicable.

  En las pruebas hubo un fallo, y lo arreglé en la prueba, no en el juego. La última prueba simula una partida completa
  con una pala que persigue la bola. Al principio la pala siempre golpeaba con el centro, la bola caía casi vertical
  sobre huecos ya vacíos y la partida se quedaba con 9 ladrillos sin romper. El juego estaba bien: el problema era que
  el jugador simulado no apuntaba. Ahora cambia el punto de impacto cada dos segundos, como haría una persona, y la
  partida simulada termina en victoria.

  Sobre el nombre: la página se llama «Rompeladrillos» y usa colores y dibujo propios. Sigue la mecánica del género,
  pero no copia el nombre ni el aspecto del juego original. El repositorio y el paquete npm siguen llamándose arkanoid.

  No he hecho ningún commit. Los cambios nuevos son src/, tests/, index.html, eslint.config.js, package.json y
  package-lock.json.

✻ Crunched for 1m 39s · done 20:23
                                                                       Update available! Run: brew upgrade claude-code
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
❯ haz un commit con los cambios
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Órdenes que lanzó el programa antes, sin captura
$ git status --short > /dev/null
Terminal: $ git status --short
arkanoid $ git status --short
?? .claude/
?? eslint.config.js
?? index.html
?? package-lock.json
?? package.json
?? src/
?? tests/
arkanoid $
Terminal: $ git add -A && git commit -q -m "Primera versión sin multibola" && git log --oneline
arkanoid $ git add -A && git commit -q -m "Primera versión sin multibola" && git log --oneline
3515776 (HEAD -> main) Primera versión sin multibola
538423c Inicio del proyecto
arkanoid $
Los 12 menús de este paso, tal como aparecieron

Menú de permiso · 016

 ▐▛███▛█   Claude Code v2.1.285
▝▜██████▀  Opus 5.5 · Claude Ultra
 ▝▝   ▝▝   ~/sdd-931/arkanoid

❯ Construye un Arkanoid para el navegador con JavaScript y npm, sin multibola: una pala que se mueve con el teclado,
  una bola, una rejilla de ladrillos, puntuación, victoria al destruirlos todos y derrota si la bola cae. Deja el
  código en src/ y las pruebas en tests/, y añade a package.json las órdenes para arrancar el juego, analizar el código
  y ejecutar las pruebas.

  Inspecting repository contents and tool versions
  ⎿  $ ls -la && git log --stat | head -30 && ls .claude; node -v; npm -v

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   ls -la && git log --stat | head -30 && ls .claude; node -v; npm -v
   Inspect repository contents and tool versions

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don’t ask again for: npm -v
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 017

 ▐▛███▛█   Claude Code v2.1.285
▝▜██████▀  Opus 5.5 · Claude Ultra
 ▝▝   ▝▝   ~/sdd-931/arkanoid

❯ Construye un Arkanoid para el navegador con JavaScript y npm, sin multibola: una pala que se mueve con el teclado,
  una bola, una rejilla de ladrillos, puntuación, victoria al destruirlos todos y derrota si la bola cae. Deja el
  código en src/ y las pruebas en tests/, y añade a package.json las órdenes para arrancar el juego, analizar el código
  y ejecutar las pruebas.

⏺ Initialize npm and install vite and eslint
  ⎿  $ mkdir -p src tests && npm init -y >/dev/null && npm install -D vite eslint @eslint/js globals 2>&1 | tail -3

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ mkdir -p src tests && npm init -y >/dev/null && npm install -D vite eslint @eslint/js globals 2>&1 | tail -3
   Initialize npm and install vite and eslint

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don't ask again for mkdir -p src tests, npm init, and npm install commands in
      ~/sdd-931/arkanoid
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 018

  135 function bounceOnPaddle(state) {
  136   const { ball, paddle } = state;
  137   if (ball.vy <= 0 || !circleHitsRect(ball, paddle)) return;
  138
  139   // El punto de impacto decide el ángulo: el centro devuelve la bola casi vertical
  140   // y los extremos la desvían hasta 60 grados.
  141   const offset = (ball.x - (paddle.x + paddle.w / 2)) / (paddle.w / 2);
  142   const angle = Math.max(-1, Math.min(1, offset)) * (Math.PI / 3);
  143   const speed = Math.hypot(ball.vx, ball.vy);
  144   ball.vx = speed * Math.sin(angle);
  145   ball.vy = -speed * Math.cos(angle);
  146   ball.y = paddle.y - ball.r;
  147 }
  148
  149 function hitBrick(state) {
  150   const { ball } = state;
  151   const brick = state.bricks.find((b) => b.alive && circleHitsRect(ball, b));
  152   if (!brick) return;
  153
  154   brick.alive = false;
  155   state.score += brick.points;
  156
  157   // Rebota en el eje de menor penetración: lateral invierte vx, superior o inferior invierte vy.
  158   const overlapX = Math.min(ball.x + ball.r - brick.x, brick.x + brick.w - (ball.x - ball.r));
  159   const overlapY = Math.min(ball.y + ball.r - brick.y, brick.y + brick.h - (ball.y - ball.r));
  160   if (overlapX < overlapY) {
  161     ball.vx = ball.x < brick.x + brick.w / 2 ? -Math.abs(ball.vx) : Math.abs(ball.vx);
  162   } else {
  163     ball.vy = ball.y < brick.y + brick.h / 2 ? -Math.abs(ball.vy) : Math.abs(ball.vy);
  164   }
  165
  166   if (state.bricks.every((b) => !b.alive)) {
  167     state.status = 'won';
  168   }
  169 }
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to create game.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 019

⏺ Write(src/game.js)
  ⎿  Wrote 169 lines to src/game.js
       1 // Lógica del juego sin dependencias del navegador: estado, movimiento y colisiones.
       2
       3 export const DEFAULTS = {
       4   width: 480,
       5   height: 360,
       6   paddleWidth: 72,
       7   paddleHeight: 10,
       8   paddleSpeed: 360,
       9   ballRadius: 6,
      10   ballSpeed: 260,
     … +159 lines

⏺ Update(src/game.js)

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 src/game.js
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 66  export function launch(state) {
 67    if (state.status !== 'ready') return;
 68    const speed = state.config.ballSpeed;
 69 -  const angle = -Math.PI / 4;
 70 -  state.ball.vx = speed * Math.sin(-angle) * 0.6;
 71 -  state.ball.vy = -Math.sqrt(speed * speed - state.ball.vx * state.ball.vx);
 69 +  // Sale hacia arriba y a la derecha, 30 grados respecto a la vertical.
 70 +  const angle = Math.PI / 6;
 71 +  state.ball.vx = speed * Math.sin(angle);
 72 +  state.ball.vy = -speed * Math.cos(angle);
 73    state.status = 'playing';
 74  }
 75
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to game.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 020

  48   ctx.fillRect(0, 0, canvas.width, canvas.height);
  49
  50   for (const brick of state.bricks) {
  51     if (!brick.alive) continue;
  52     ctx.fillStyle = rowColors[brick.row % rowColors.length];
  53     ctx.fillRect(brick.x, brick.y, brick.w, brick.h);
  54   }
  55
  56   const { paddle, ball } = state;
  57   ctx.fillStyle = '#e8edf2';
  58   ctx.fillRect(paddle.x, paddle.y, paddle.w, paddle.h);
  59
  60   ctx.beginPath();
  61   ctx.arc(ball.x, ball.y, ball.r, 0, Math.PI * 2);
  62   ctx.fill();
  63
  64   ctx.textAlign = 'left';
  65   ctx.font = '16px system-ui, sans-serif';
  66   ctx.fillText(`Puntos: ${state.score}`, 12, 24);
  67
  68   if (state.status === 'ready') drawMessage('Pulsa espacio', '← → o A D para mover la pala');
  69   if (state.status === 'won') drawMessage('¡Has ganado!', 'Espacio para jugar otra vez');
  70   if (state.status === 'lost') drawMessage('Has perdido', 'Espacio para volver a empezar');
  71 }
  72
  73 let last = performance.now();
  74 function frame(now) {
  75   // Limita el paso para que una pestaña en segundo plano no provoque un salto enorme.
  76   const dt = Math.min((now - last) / 1000, 1 / 30);
  77   last = now;
  78   update(state, dt, keys);
  79   draw();
  80   requestAnimationFrame(frame);
  81 }
  82 requestAnimationFrame(frame);
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to create main.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 021

      8 let state = createGame({ width: canvas.width, height: canvas.height });
      9 const keys = { left: false, right: false, launch: false };
     … +72 lines

⏺ Write(index.html)

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Create file
 index.html
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
   1 <!doctype html>
   2 <html lang="es">
   3   <head>
   4     <meta charset="utf-8" />
   5     <meta name="viewport" content="width=device-width, initial-scale=1" />
   6     <title>Rompeladrillos</title>
   7     <style>
   8       body {
   9         margin: 0;
  10         min-height: 100vh;
  11         display: grid;
  12         place-items: center;
  13         background: #1b2630;
  14       }
  15       canvas {
  16         max-width: 100vw;
  17         border: 2px solid #3768a4;
  18       }
  19     </style>
  20   </head>
  21   <body>
  22     <canvas id="board" width="480" height="360"></canvas>
  23     <script type="module" src="/src/main.js"></script>
  24   </body>
  25 </html>
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to create index.html?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 022

  109   update(state, DT);
  110   assert.equal(state.status, 'won');
  111 });
  112
  113 test('si la bola cae por debajo del campo se pierde la partida', () => {
  114   const state = createGame();
  115   state.status = 'playing';
  116   Object.assign(state.ball, { x: 5, y: state.config.height - 2, vx: 0, vy: 300 });
  117   update(state, 0.1);
  118   assert.equal(state.status, 'lost');
  119 });
  120
  121 test('una partida terminada no cambia aunque se pulse el teclado', () => {
  122   const state = createGame();
  123   state.status = 'lost';
  124   const x = state.paddle.x;
  125   update(state, 0.1, { right: true, launch: true });
  126   assert.equal(state.paddle.x, x);
  127   assert.equal(state.status, 'lost');
  128 });
  129
  130 test('una partida simulada termina en victoria o derrota y nunca resta puntos', () => {
  131   const state = createGame();
  132   update(state, DT, { launch: true });
  133   let previous = 0;
  134   for (let i = 0; i < 60 * 120 && state.status === 'playing'; i++) {
  135     // La pala persigue la bola, así que la partida debería acabar ganándose.
  136     const center = state.paddle.x + state.paddle.w / 2;
  137     update(state, DT, { left: state.ball.x < center - 4, right: state.ball.x > center + 4 });
  138     assert.ok(state.score >= previous);
  139     previous = state.score;
  140   }
  141   assert.equal(state.status, 'won');
  142   assert.equal(state.score, state.bricks.reduce((sum, b) => sum + b.points, 0));
  143 });
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to create game.test.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 023

      3 import { createGame, createBricks, update, DEFAULTS } from '../src/game.js';
      4
      5 const DT = 1 / 60;
      6
      7 function brick(x, y, points = 10) {
      8   return { x, y, w: 40, h: 16, row: 0, points, alive: true };
      9 }
     … +133 lines

⏺ Write(eslint.config.js)

⏺ Setting package type and npm scripts
  ⎿  $ npm pkg set type=module description="Juego de romper ladrillos para el navegador" scripts.start="vite"
     scripts.build="vite build" scripts.lint="eslint ." scripts.test="node --test tests/" && npm pkg delete main
     keywords && cat package.json

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Create file
 eslint.config.js
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
   1 import js from '@eslint/js';
   2 import globals from 'globals';
   3
   4 export default [
   5   { ignores: ['dist/', 'coverage/'] },
   6   js.configs.recommended,
   7   {
   8     files: ['src/**/*.js'],
   9     languageOptions: { globals: globals.browser },
  10   },
  11   {
  12     files: ['tests/**/*.js', '*.config.js'],
  13     languageOptions: { globals: globals.node },
  14   },
  15 ];
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to create eslint.config.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 024

      7 function brick(x, y, points = 10) {
      8   return { x, y, w: 40, h: 16, row: 0, points, alive: true };
      9 }
     … +133 lines

⏺ Write(eslint.config.js)
  ⎿  Wrote 15 lines to eslint.config.js
       1 import js from '@eslint/js';
       2 import globals from 'globals';
       3
       4 export default [
       5   { ignores: ['dist/', 'coverage/'] },
       6   js.configs.recommended,
       7   {
       8     files: ['src/**/*.js'],
       9     languageOptions: { globals: globals.browser },
      10   },
     … +5 lines

⏺ Setting package type and npm scripts
  ⎿  $ npm pkg set type=module description="Juego de romper ladrillos para el navegador" scripts.start="vite"
     scripts.build="vite build" scripts.lint="eslint ." scripts.test="node --test tests/" && npm pkg delete main
     keywords && cat package.json

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ npm pkg set type=module description="Juego de romper ladrillos para el navegador" scripts.start="vite"
   │ scripts.build="vite build" scripts.lint="eslint ." scripts.test="node --test tests/" && npm pkg delete main
   │ keywords && cat package.json
   Set package type and npm scripts

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don’t ask again for: npm pkg *
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 025

      9 }
     … +133 lines

⏺ Write(eslint.config.js)
  ⎿  Wrote 15 lines to eslint.config.js
       1 import js from '@eslint/js';
       2 import globals from 'globals';
       3
       4 export default [
       5   { ignores: ['dist/', 'coverage/'] },
       6   js.configs.recommended,
       7   {
       8     files: ['src/**/*.js'],
       9     languageOptions: { globals: globals.browser },
      10   },
     … +5 lines

  Ran 2 shell commands

⏺ Lint pasa limpio. Node 25 no acepta un directorio como argumento de --test; uso un patrón glob.

⏺ Running 1 shell command…
  ⎿  $ npm pkg set scripts.test="node --test \"tests/**/*.test.js\"" && npm test 2>&1 | grep -E "^(not ok|#
     (tests|pass|fail))|Error|expected|actual" | head -30

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ npm pkg set scripts.test="node --test \"tests/**/*.test.js\"" && npm test 2>&1 | grep -E "^(not ok|#
   │ (tests|pass|fail))|Error|expected|actual" | head -30
   Fix test script glob and rerun tests

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don’t ask again for: npm pkg *
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 026

       4 export default [
       5   { ignores: ['dist/', 'coverage/'] },
       6   js.configs.recommended,
       7   {
       8     files: ['src/**/*.js'],
       9     languageOptions: { globals: globals.browser },
      10   },
     … +5 lines

  Ran 2 shell commands

⏺ Lint pasa limpio. Node 25 no acepta un directorio como argumento de --test; uso un patrón glob.

⏺ Diagnose the simulated game outcome
  ⎿  $ node -e "
     import('./src/game.js').then(({createGame,update})=>{
     const s=createGame();update(s,1/60,{launch:true});
     for(let i=0;i<60*120&&s.status==='playing';i++){const
     c=s.paddle.x+s.paddle.w/2;update(s,1/60,{left:s.ball.x<c-4,right:s.ball.x>c+4});}
     console.log(s.status,s.score,s.bricks.filter(b…

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ node -e "
   │ import('./src/game.js').then(({createGame,update})=>{
   │ const s=createGame();update(s,1/60,{launch:true});
   │ for(let i=0;i<60*120&&s.status==='playing';i++){const
   │ c=s.paddle.x+s.paddle.w/2;update(s,1/60,{left:s.ball.x<c-4,right:s.ball.x>c+4});}
   │ console.log(s.status,s.score,s.bricks.filter(b=>b.alive).length,s.ball);});"
   Diagnose the simulated game outcome

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don’t ask again for: node *
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 027

       9     languageOptions: { globals: globals.browser },
      10   },
     … +5 lines

  Ran 2 shell commands

⏺ Lint pasa limpio. Node 25 no acepta un directorio como argumento de --test; uso un patrón glob.

  Ran 2 shell commands

⏺ La lógica ya funciona (950 puntos, 9 ladrillos restantes), pero la prueba siempre golpea con el centro de la pala, así
  que voy a hacer que varíe el punto de impacto.

⏺ Update(tests/game.test.js)

  Rerunning tests, linting and production build
  ⎿  $ npm test 2>&1 | grep -E "^(not ok|# (tests|pass|fail))|expected|actual" ; npm run lint 2>&1 | tail -3; npx vite
     build 2>&1 | tail -4

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 tests/game.test.js
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 132    update(state, DT, { launch: true });
 133    let previous = 0;
 134    for (let i = 0; i < 60 * 120 && state.status === 'playing'; i++) {
 135 -    // La pala persigue la bola, así que la partida debería acabar ganándose.
 136 -    const center = state.paddle.x + state.paddle.w / 2;
 135 +    // La pala persigue la bola y cambia cada dos segundos el punto de impacto para
 136 +    // variar el ángulo; así la bola alcanza todos los ladrillos y se acaba ganando.
 137 +    const aim = ((Math.floor(i / 120) % 5) - 2) * 12;
 138 +    const center = state.paddle.x + state.paddle.w / 2 + aim;
 139      update(state, DT, { left: state.ball.x < center - 4, right: state.ball.x > center + 4 });
 140      assert.ok(state.score >= previous);
 141      previous = state.score;
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to game.test.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Paso 6: el fichero de instrucciones

/init lee el código y redacta CLAUDE.md, el fichero que Claude carga al empezar cada sesión. Lo lanzamos después de la primera versión porque necesita código que leer: en un repositorio vacío solo podría escribir generalidades. El resultado recogía la arquitectura, las decisiones de diseño, los comandos reales y dos detalles que no habríamos escrito a mano: una trampa de Node 25 con npm test y la prohibición de hacer git push, que había leído en los permisos. Con /memory comprobamos que la sesión solo cargaba ese fichero.

En un proyecto nuevo, las reglas que deben valer desde el primer mensaje (idioma, carpetas que no se tocan, cómo se prueba) se escriben a mano en CLAUDE.md antes de pedir nada, y /init las completa después con lo que encuentra en el código. En un repositorio que ya existe, /init va lo primero.

Lo que dice el libro (versión 87a)

6. Preparar las instrucciones del proyecto. Con el juego ya en el repositorio, ejecutamos /init, que lee el código para redactar el fichero de instrucciones, y abrimos el CLAUDE.md resultante para comprobar que recoge el propósito del proyecto, la estructura, la tecnología elegida y los comandos reales de instalación, arranque, build, lint y test.

Este fichero explica cómo trabajar en el repositorio; la especificación funcional de la multibola se guarda por separado.

Si una instrucción solo afecta a una ruta, la llevamos a una regla en .claude/rules/ con ese alcance.

Con /memory comprobamos además qué CLAUDE.md ha cargado la sesión, incluidos los de carpetas superiores, y dejamos fuera con claudeMdExcludes los que no sean del proyecto, para que el agente trabaje solo con instrucciones que hemos revisado.

Resumen de /init con las secciones del CLAUDE.md generado
CLAUDE.md explica cómo trabajar en el repositorio. Lo que debe hacer la multibola va en otro documento.
Ida y vuelta de el turno 2: 52 s de trabajo, 2 herramientas usadas

Turno 2 · 52 s

Ida: lo que escribimos

/init

Vuelta: lo que contestó Claude

  1. Bash ls -a; ls .cursor .cursorrules .github .codex .gemini GEMINI.md CLAUDE.md 2>&1 | head; ls -d [configuración local omitida] ~/.gemini/settings.json 2>&1

La herramienta devolvió un error a Claude:

Exit code 1
.
..
.claude
.git
.gitignore
eslint.config.js
index.html
node_modules
package-lock.json
package.json
README.md
src
tests
ls: .codex: No such file or directory
ls: .cursor: No such file or directory
ls: .cursorrules: No such file or directory
ls: .gemini: No such file or directory
ls: .github: No such file or directory
ls: CLAUDE.md: No such file or directory
ls: GEMINI.md: No such file or directory
ls: [ruta local omitida] No such file or directory
[ruta local omitida]
  1. Write ~/sdd-931/arkanoid/CLAUDE.md

He creado CLAUDE.md en la raíz, en castellano como el resto del proyecto. Recoge cuatro cosas:

  • Las órdenes y una trampa de Node 25: npm test necesita un patrón glob, porque si recibe el directorio tests/ falla con «Cannot find module». También explica cómo ejecutar una sola prueba con --test-name-pattern.
  • La arquitectura: src/game.js es lógica pura, sin navegador. src/main.js es la única parte que toca el DOM, el teclado y el canvas. Explica cómo pasa el juego de un estado a otro (ready, playing, won, lost) y que reiniciar consiste en crear la partida de nuevo con createGame.
  • Las decisiones de diseño que conviene no romper: los pasos cortos de la bola para que no atraviese ladrillos, el rebote según el punto de la pala donde golpea, y la rejilla a medida que usan las pruebas. También advierte de que, si el jugador simulado golpea siempre con el centro de la pala, la partida nunca termina, y que eso no es un fallo del juego.
  • Los permisos de .claude/settings.json: las pruebas *.ratificada.test.js no se pueden editar, así que si una falla se corrige el código y no la prueba. Además, git push está prohibido y editar src/ pide confirmación.

No había reglas de Cursor ni de Copilot. Del README solo había que recoger su contexto (el apartado 9.3.1 del libro), y ya está incluido.

He encontrado una configuración de Codex en [configuración local omitida]. Si quieres importarla, responde /import: verás qué se puede traer (servidores MCP, órdenes, skills e instrucciones) y luego lo aplicas con /import --yes=<digest>. Si /import no está disponible aquí, ejecuta claude import desde una terminal.

Fichero completo: CLAUDE-generado-por-init.md
# CLAUDE.md

This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.

## Proyecto

Juego de romper ladrillos para el navegador (una pala, rejilla de ladrillos, puntuación, victoria al romperlos todos y derrota cuando no queda ninguna bola), construido paso a paso con Claude Code siguiendo el apartado 9.3.1 del libro. Tiene multibola: los ladrillos x3 triplican todas las bolas activas hasta 200. Sus requisitos (FR-…), decisiones (ADR-…) y las decisiones provisionales pendientes de ratificar están en `docs/especificacion-multibola.md`; cualquier cambio de la multibola debe contrastarse con ese documento. El paquete se llama `arkanoid`, pero el juego visible se titula «Rompeladrillos» y usa aspecto propio: no copiar nombre, personajes, gráficos ni niveles del juego original.

## Órdenes

- `npm start`: servidor de desarrollo de Vite (sirve `index.html` de la raíz).
- `npm run build`: compilación de producción en `dist/` (ignorada por Git).
- `npm run lint`: ESLint con configuración plana (`eslint.config.js`): globales de navegador en `src/`, de Node en `tests/` y en los `*.config.js`.
- `npm test`: ejecutor nativo de Node, `node --test "tests/**/*.test.js"`. Con Node 25 hay que pasar un patrón glob; un directorio (`tests/`) falla con «Cannot find module».
- Una sola prueba: `node --test --test-name-pattern="último ladrillo" tests/game.test.js`.

El paquete es ESM (`"type": "module"`).

## Arquitectura

La lógica está separada del navegador para poder probarla sin DOM:

- `src/game.js` es puro: `createGame(options)` devuelve un objeto de estado mutable (`config`, `paddle`, `balls`, `nextBallId`, `bricks`, `score`, `status`) y `update(state, dt, input)` lo avanza, con `input = { left, right, launch }`. `status` recorre `ready` → `playing` → `won` | `lost`; en `ready` la única bola (`balls[0]`) viaja pegada a la pala hasta el saque, y en `won`/`lost` `update` no cambia nada.
- `src/multiball.js` es puro y no conoce el estado: `MAX_BALLS`, `tripledBallCount(n)` y `tripleBalls(balls, nextId)`, que devuelve la lista nueva ordenada por id. `game.js` lo llama al resolver los x3.
- `src/main.js` es la única capa con DOM: lee el teclado (flechas, A/D, espacio), llama a `update` en cada `requestAnimationFrame` con `dt` limitado a 1/30 s y dibuja en el canvas `#board`. Reiniciar una partida terminada consiste en crear un estado nuevo; no hay función de reinicio en la lógica. Con `?escenario=multibola` la partida empieza con la bola lanzada contra un x3.

Cada paso corto (`step` en `game.js`) sigue este orden, y de él dependen varias reglas de la especificación: mover todas las bolas y rebotarlas en paredes y pala, quitar las que han caído, recoger los impactos con ladrillos, ordenarlos por `(y, x, id)` (`compareImpacts`), resolverlos (todas rebotan, solo la primera de cada ladrillo lo destruye y puntúa), aplicar los x3 uno tras otro y, por último, comprobar la victoria antes que la derrota. `update` ordena `balls` por id al empezar, para que el resultado no dependa del orden de la lista (FR-004).

Decisiones de `game.js` que conviene conservar:

- Las bolas avanzan en subpasos de longitud no mayor que su radio, calculados con la bola más rápida, para no atravesar ladrillos (hay una prueba que lo cubre).
- Cada bola toca como mucho un ladrillo por subpaso y rebota por el eje de menor penetración.
- El rebote en la pala depende del punto de impacto (hasta ±60° respecto a la vertical) y conserva la velocidad de la bola.
- `createGame({ bricks, balls })` acepta una rejilla y unas bolas a medida (`balls` con `id`; más de 200 lanza `RangeError`). Con `balls`, las bolas no se colocan sobre la pala; las pruebas las sitúan y asignan `status = 'playing'`.
- `speedBonus` redondea en vez de truncar: los rebotes dejan la velocidad en 259,9999… y truncar daba un punto menos.

Para observar el juego en marcha: `npm start` y `node scripts/observar.mjs <url> <prefijo> <ms>...`. Las capturas de Chrome con `--screenshot` y tiempo virtual no avanzan `requestAnimationFrame`, así que no sirven para ver la animación.

La prueba de partida simulada mueve la pala con un punto de impacto que varía cada dos segundos. Si la pala golpea siempre con el centro, la bola sale casi vertical y la partida no termina; no es un fallo del juego.

## Permisos del repositorio

`.claude/settings.json` pide confirmación para editar `src/**`, prohíbe `git push` y prohíbe editar cualquier `tests/**/*.ratificada.test.js`: esas pruebas están ratificadas por el autor y, si una falla, se corrige el código, no la prueba.

Salida de cada orden, tal como apareció en la pantalla

Pantalla al terminar el turno: «/init»
⏺ Write(CLAUDE.md)
  ⎿  Wrote 37 lines to CLAUDE.md
      1 # CLAUDE.md
      2
      4
      5 ## Proyecto
      6
        ictoria al romperlos todos y derrota si la bola cae), construido paso a paso con Claude Code siguiendo el
         apartado 9.3.1 del libro. No hay multibola. El paquete se llama `arkanoid`, pero el juego visible se tit
        ula «Rompeladrillos» y usa aspecto propio: no copiar nombre, personajes, gráficos ni niveles del juego or
      8
      9 ## Órdenes
     … +43 lines

⏺ He creado CLAUDE.md en la raíz, en castellano como el resto del proyecto. Recoge cuatro cosas:

  - Las órdenes y una trampa de Node 25: npm test necesita un patrón glob, porque si recibe el directorio tests/ falla
    con «Cannot find module». También explica cómo ejecutar una sola prueba con --test-name-pattern.
  - La arquitectura: src/game.js es lógica pura, sin navegador. src/main.js es la única parte que toca el DOM, el
    teclado y el canvas. Explica cómo pasa el juego de un estado a otro (ready, playing, won, lost) y que reiniciar
    consiste en crear la partida de nuevo con createGame.
  - Las decisiones de diseño que conviene no romper: los pasos cortos de la bola para que no atraviese ladrillos, el
    rebote según el punto de la pala donde golpea, y la rejilla a medida que usan las pruebas. También advierte de que,
    si el jugador simulado golpea siempre con el centro de la pala, la partida nunca termina, y que eso no es un fallo
    del juego.
  - Los permisos de .claude/settings.json: las pruebas *.ratificada.test.js no se pueden editar, así que si una falla se
    corrige el código y no la prueba. Además, git push está prohibido y editar src/ pide confirmación.

  No había reglas de Cursor ni de Copilot. Del README solo había que recoger su contexto (el apartado 9.3.1 del libro),
  y ya está incluido.

  He encontrado una configuración de Codex en [configuración local omitida] Si quieres importarla, responde /import: verás qué
  se puede traer (servidores MCP, órdenes, skills e instrucciones) y luego lo aplicas con /import --yes=<digest>. Si
  /import no está disponible aquí, ejecuta claude import desde una terminal.

✻ Brewed for 23s · done 20:24
                                                                       Update available! Run: brew upgrade claude-code
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
❯ haz commit de todo
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Dentro de Claude Code: /memory
        ictoria al romperlos todos y derrota si la bola cae), construido paso a paso con Claude Code siguiendo el
         apartado 9.3.1 del libro. No hay multibola. El paquete se llama `arkanoid`, pero el juego visible se tit
        ula «Rompeladrillos» y usa aspecto propio: no copiar nombre, personajes, gráficos ni niveles del juego or
      8
      9 ## Órdenes
     … +43 lines

⏺ He creado CLAUDE.md en la raíz, en castellano como el resto del proyecto. Recoge cuatro cosas:

  - Las órdenes y una trampa de Node 25: npm test necesita un patrón glob, porque si recibe el directorio tests/ falla
    con «Cannot find module». También explica cómo ejecutar una sola prueba con --test-name-pattern.
  - La arquitectura: src/game.js es lógica pura, sin navegador. src/main.js es la única parte que toca el DOM, el
    teclado y el canvas. Explica cómo pasa el juego de un estado a otro (ready, playing, won, lost) y que reiniciar
    consiste en crear la partida de nuevo con createGame.
  - Las decisiones de diseño que conviene no romper: los pasos cortos de la bola para que no atraviese ladrillos, el
    rebote según el punto de la pala donde golpea, y la rejilla a medida que usan las pruebas. También advierte de que,
    si el jugador simulado golpea siempre con el centro de la pala, la partida nunca termina, y que eso no es un fallo
    del juego.
  - Los permisos de .claude/settings.json: las pruebas *.ratificada.test.js no se pueden editar, así que si una falla se
    corrige el código y no la prueba. Además, git push está prohibido y editar src/ pide confirmación.

  No había reglas de Cursor ni de Copilot. Del README solo había que recoger su contexto (el apartado 9.3.1 del libro),
  y ya está incluido.

  He encontrado una configuración de Codex en [configuración local omitida] Si quieres importarla, responde /import: verás qué
  se puede traer (servidores MCP, órdenes, skills e instrucciones) y luego lo aplicas con /import --yes=<digest>. Si
  /import no está disponible aquí, ejecuta claude import desde una terminal.

✻ Brewed for 23s · done 20:24
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
   Memory

   ❯ Auto-memory  true

   ❯ ~/.claude/CLAUDE.md
     Project instructions      Checked in at ./CLAUDE.md
     User instructions         Saved in ~/.claude/CLAUDE.md
     Open auto-memory folder

   Learn more: https://code.claude.com/docs/en/memory

   Enter to confirm · Esc to cancel
Los 2 menús de este paso, tal como aparecieron

Menú de permiso · 031

  Las órdenes de package.json:
  - npm start arranca el servidor de desarrollo de Vite.
  - npm run lint analiza el código con ESLint.
  - npm test ejecuta las pruebas con el ejecutor que trae Node (node --test), sin dependencias extra.
  - npm run build, que no pediste, genera la versión publicable.

  En las pruebas hubo un fallo, y lo arreglé en la prueba, no en el juego. La última prueba simula una partida completa
  con una pala que persigue la bola. Al principio la pala siempre golpeaba con el centro, la bola caía casi vertical
  sobre huecos ya vacíos y la partida se quedaba con 9 ladrillos sin romper. El juego estaba bien: el problema era que
  el jugador simulado no apuntaba. Ahora cambia el punto de impacto cada dos segundos, como haría una persona, y la
  partida simulada termina en victoria.

  Sobre el nombre: la página se llama «Rompeladrillos» y usa colores y dibujo propios. Sigue la mecánica del género,
  pero no copia el nombre ni el aspecto del juego original. El repositorio y el paquete npm siguen llamándose arkanoid.

  No he hecho ningún commit. Los cambios nuevos son src/, tests/, index.html, eslint.config.js, package.json y
  package-lock.json.

✻ Crunched for 1m 39s · done 20:23

❯ /init

⏺ Checking for existing agent rule and config files
  ⎿  $ ls -a; ls .cursor .cursorrules .github .codex .gemini GEMINI.md CLAUDE.md 2>&1 | head; ls -d [configuración local omitida]
     ~/.gemini/settings.json 2>&1

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ ls -a; ls .cursor .cursorrules .github .codex .gemini GEMINI.md CLAUDE.md 2>&1 | head; ls -d
   │ [configuración local omitida] ~/.gemini/settings.json 2>&1
   Check for existing agent rule and config files

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, allow reading from [configuración local omitida] from this project
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 032

     lob; un directorio (`tests/`) falla con «Cannot find module».
  15 - Una sola prueba: `node --test --test-name-pattern="último ladrillo" tests/game.test.js`.
  16
  17 El paquete es ESM (`"type": "module"`).
  18
  19 ## Arquitectura
  20
  21 La lógica está separada del navegador para poder probarla sin DOM:
  22
  23 - `src/game.js` es puro: `createGame(options)` devuelve un objeto de estado mutable (`config`, `paddle`, `ball`,
      `bricks`, `score`, `status`) y `update(state, dt, input)` lo avanza, con `input = { left, right, launch }`. `st
     atus` recorre `ready` → `playing` → `won` | `lost`; en `ready` la bola viaja pegada a la pala hasta el saque, y
     en `won`/`lost` `update` no cambia nada.
  24 - `src/main.js` es la única capa con DOM: lee el teclado (flechas, A/D, espacio), llama a `update` en cada `requ
     estAnimationFrame` con `dt` limitado a 1/30 s y dibuja en el canvas `#board`. Reiniciar una partida terminada co
     nsiste en crear un estado nuevo con `createGame`; no hay función de reinicio en la lógica.
  25
  26 Decisiones de `game.js` que conviene conservar:
  27
  28 - La bola avanza en subpasos de longitud no mayor que su radio para no atravesar ladrillos a gran velocidad (hay
      una prueba que lo cubre).
  29 - Cada subpaso rompe como mucho un ladrillo y rebota por el eje de menor penetración.
  30 - El rebote en la pala depende del punto de impacto (hasta ±60° respecto a la vertical) y conserva la velocidad
     de la bola.
  31 - `createGame({ bricks: [...] })` acepta una rejilla a medida; las pruebas la usan para montar escenarios con un
     o o dos ladrillos y colocar la bola a mano asignando `status = 'playing'`.
  32
  33 La prueba de partida simulada mueve la pala con un punto de impacto que varía cada dos segundos. Si la pala golp
     ea siempre con el centro, la bola sale casi vertical y la partida no termina; no es un fallo del juego.
  34
  35 ## Permisos del repositorio
  36
  37 `.claude/settings.json` pide confirmación para editar `src/**`, prohíbe `git push` y prohíbe editar cualquier `t
     ests/**/*.ratificada.test.js`: esas pruebas están ratificadas por el autor y, si una falla, se corrige el código
     , no la prueba.
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to create CLAUDE.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Paso 7: especificar antes de programar

Este es el corazón del método. Escribimos /plan describir la multibola y sus casos límite y le pedimos que primero enumerara las decisiones abiertas, sin tocar código. El modo de planificación es un modo en el que Claude puede leer pero no editar. Devolvió catorce preguntas bien razonadas: dónde nacen las bolas nuevas, cuándo se pierde, qué pasa si se gana y se pierde en el mismo instante, cómo cambia el modelo de datos…

Le contestamos con las decisiones que el libro da por ratificadas (FR-001 a FR-007, ADR-002 y ADR-003) y le dijimos que, al aprobar, solo guardara la especificación. Claude rehízo el plan y nos lo presentó para aprobar. Elegimos «manually approve edits» para seguir viendo cada edición, y Claude hizo exactamente lo pedido: creó docs/especificacion-multibola.md y nada más. Además señaló dos huecos que no quiso rellenar: en lo ratificado no hay ningún FR-005 ni ningún ADR-001.

Una salvedad que también llevamos al libro: /plan seguido de texto entra solo en modo de planificación, pero si ya estás en ese modo el texto se ignora. En la primera vuelta nos pasó y Claude no hizo nada.

Lo que dice el libro (versión 87a)

7. Especificar la multibola. Escribimos /plan describir la multibola y sus casos límite y pedimos que primero enumere las decisiones abiertas, sin editar código.

La orden entra por sí sola en el modo de planificación; si la sesión ya estaba en ese modo, el texto que sigue a /plan se ignora y la petición se escribe como un mensaje normal.

La propuesta debe recoger MAX_BALLS = 200, la puntuación del multiplicador, la puntuación única por ladrillo aunque haya impactos simultáneos y el bonus de velocidad de la bola destructora.

También debe incluir los casos n = 0, 1, valores intermedios y 200, además de un plan por ficheros. Leemos el resultado, corregimos las decisiones que el agente haya supuesto y ratificamos su significado antes de salir del modo de planificación. Lo que se decide aquí ya no tendrá que adivinarlo el agente cuando escriba el código.

Plan de Claude «especificación de la multibola» con las opciones para aprobarlo
La segunda opción, «manually approve edits», aprueba el plan sin pasar a modo auto.
Comienzo del documento de especificación con los requisitos FR-001 a FR-007, los ADR y la tabla de casos límite
La especificación: requisitos con identificador, decisiones de arquitectura y la tabla de casos de 0, 1, 2, 50, 66, 67, 199 y 200 bolas.
Ida y vuelta de turnos 3 a 4: 3 min 4 s de trabajo, 5 herramientas usadas

Turno 3 · 39 s

Ida: lo que escribimos

/plan describir la multibola y sus casos límite. Antes de proponer nada, enumera las decisiones abiertas. No edites código.

Vuelta: lo que contestó Claude

Antes de describir la multibola hay que decidir varias cosas, porque el juego actual se apoya en una sola bola. El estado guarda un único state.ball, la partida pasa a lost en cuanto esa bola cruza el borde inferior, y la victoria se comprueba dentro de hitBrick, justo antes de mirar si la bola ha caído. Además, CLAUDE.md dice expresamente «No hay multibola», así que esto amplía lo que se pidió al principio. Cada una de las decisiones siguientes cambia cómo se comporta algún caso límite.

Cómo aparece y cuánto dura

  1. Qué la activa. Puede salir de una cápsula que cae al romper un ladrillo y que hay que recoger con la pala, de un ladrillo especial que la activa al romperse, o de otra condición, como alcanzar una puntuación. Si es una cápsula, aparece un objeto nuevo que cae y choca con la pala, y con él más casos: la cápsula toca el suelo, la recoges en el mismo instante en que la bola toca la pala, o la partida termina mientras sigue cayendo.
  2. Si interviene el azar. Si la cápsula sale de un ladrillo al azar, las pruebas necesitan poder fijar ese azar desde fuera, porque hoy todo es determinista y las pruebas dependen de ello. Si sale de ladrillos fijos de la rejilla, el azar no aparece.
  3. Cuántas bolas salen y desde dónde. Puede dividirse solo la bola que tocó la cápsula, o todas las que haya en juego. Hay que fijar también cuántas nuevas aparecen (por ejemplo, dos más) y si hay un máximo. El caso que lo pone a prueba es activar la multibola con tres bolas ya en juego.
  4. Si se puede repetir. Hay que decidir si se puede activar otra vez mientras sigue activa, y qué pasa cuando vuelve a quedar una sola bola: si el juego sigue con normalidad o si queda algún rastro (el máximo de bolas, una cápsula pendiente).

Las bolas nuevas al nacer

  1. Dirección y velocidad. Las bolas nuevas pueden salir con ángulos fijos respecto a la original, simétricos o al azar, y con la misma velocidad o con otra. Si la bola original va casi horizontal, al girarla puede salir una completamente horizontal que rebote sin fin entre las paredes. Hoy eso no ocurre porque la pala limita el ángulo a ±60°, pero el reparto de bolas se salta esa limitación. Hay que decidir si se impone una componente vertical mínima.
  2. Dónde nacen. Si las nuevas nacen en el mismo punto que la original, pueden empezar metidas en un ladrillo o en la pala. El código actual rompería ese ladrillo enseguida, o haría rebotar la bola hacia arriba si está bajando sobre la pala. Hay que decidir si eso es aceptable o si las bolas nuevas nacen desplazadas, o sin chocar durante un instante.

Derrota, victoria y simultaneidad

  1. Cuándo se pierde. La opción más natural es perder solo cuando caen todas las bolas, sin castigo por cada bola perdida. Como el juego no tiene vidas, la otra posibilidad (quitar algo al perder una bola) obligaría a añadirlas, y eso es otra ampliación.
  2. El mismo instante. Si la última bola cae en el mismo fotograma en que otra rompe el último ladrillo, hay que decidir si se gana, se pierde o depende del orden. Con varias bolas, el resultado depende del orden en que se actualizan, salvo que se fije una regla explícita (por ejemplo, que la victoria tenga prioridad).
  3. Choques simultáneos. Si dos bolas tocan el mismo ladrillo en el mismo fotograma, ¿puntúa solo la primera y la segunda lo atraviesa o rebota igualmente? También hay que decidir si las bolas chocan entre sí o se atraviesan, que es lo habitual en el género y mucho más simple.
  4. Cómo se reparten los pasos cortos. Hoy el número de pasos se calcula para que la única bola no atraviese ladrillos. Con varias bolas, cada una puede tener su propio número de pasos o pueden avanzar todas a la vez, intercaladas, paso a paso. Lo segundo hace más justos los choques simultáneos de los puntos 8 y 9, pero cuesta más.
  5. Puntuación. Puede quedar igual o dar algo por la cápsula o una bonificación mientras haya varias bolas.

Contrato y compatibilidad

  1. El modelo de datos. Al pasar de state.ball a una lista state.balls, las pruebas actuales y main.js dejan de funcionar. Hay que elegir entre migrarlo todo de una vez o mantener state.ball como alias de la primera bola. También hay que decidir cómo inyectan las pruebas varias bolas, igual que hoy inyectan su propia rejilla con createGame({ bricks }).
  2. El saque y el reinicio. En ready hay una sola bola sobre la pala. Hay que confirmar que una partida nueva siempre empieza así y que no se puede activar la multibola antes del saque.
  3. Qué se ratifica. El repositorio protege las pruebas *.ratificada.test.js. Conviene decidir cuáles de estos casos límite pasan a ser pruebas ratificadas por ti antes de tocar src/, y cuáles quedan como pruebas normales.

Las que más condicionan el resto son la 1, la 7, la 8 y la 12. Si me las respondes, describo la multibola y sus casos límite sobre esa base; las demás puedo dejarlas marcadas con un valor por defecto para que las revises.

Turno 4 · 2 min 25 s

Ida: lo que escribimos

Estas son las decisiones ratificadas; corrige el plan con ellas: FR-001, la multibola x3 se aplica a todas las bolas activas: con n bolas al romper un ladrillo x3 quedan min(3 × n, MAX_BALLS). FR-002, nunca se supera MAX_BALLS = 200 (1 → 3, 2 → 6, 199 → 200, 200 → 200). FR-003, cada ladrillo puntúa una sola vez, incluso con impactos simultáneos. FR-004, misma puntuación final con las mismas entradas. FR-006, el ladrillo x3 concede 50 puntos base. FR-007, el bonus por velocidad se aplica una vez, con la velocidad de la bola destructora. ADR-002, el estado usa balls: Ball[]. ADR-003, los impactos de un fotograma se ordenan por (y, x, id). Casos: n = 0, 1, valores intermedios y 200. Incluye un plan por ficheros en este orden: recuento con n = 0, aparición hasta el tope de 200, puntuación única con impactos simultáneos y, al final, multiplicador y bonus. Cuando apruebe el plan, el único paso que harás es guardar esta especificación en docs/especificacion-multibola.md; la implementación la pediré por etapas.

Claude Code lo recibió como texto pegado (bracketed paste).

Vuelta: lo que contestó Claude

  1. Write ~/sdd-931/config/plans/pasted-content-id-f5c4-estas-son-steady-dragonfly.md
  2. ExitPlanMode
  3. Write ~/sdd-931/arkanoid/docs/especificacion-multibola.md
  4. Bash git status --short && for id in FR-001 FR-002 FR-003 FR-004 FR-006 FR-007 ADR-002 ADR-003; do printf "%s %s\n" $id $(grep -c "$id" docs/especificacion-multibola.md); done
  5. Bash git log --oneline | head -5

He guardado la especificación en docs/especificacion-multibola.md y no he tocado nada más: ni src/, ni tests/, ni package.json. git status muestra como nuevos docs/ y CLAUDE.md, que sigue pendiente desde /init porque el commit «Primera versión sin multibola» no lo incluyó. Tampoco he hecho ningún commit.

He comprobado que el documento recoge las ocho decisiones ratificadas (FR-001, FR-002, FR-003, FR-004, FR-006, FR-007, ADR-002 y ADR-003). Los casos de n = 0, 1, 2, varios intermedios (50, 66 y 67), 199 y 200 están en una tabla. El plan va por etapas en el orden que pediste: recuento con n = 0, aparición hasta el tope de 200, puntuación única con impactos simultáneos y, al final, multiplicador y bonus.

Al final del documento hay una sección de decisiones abiertas, porque varias cosas no quedan cubiertas por lo ratificado y no quería inventarlas. Antes de cada etapa conviene resolver estas:

  • Etapa 2: la dirección y el punto de nacimiento de las bolas nuevas, y qué bolas se descartan al recortar hasta 200.
  • Etapa 3: si las demás bolas que golpean un ladrillo ya destruido rebotan o lo atraviesan. También falta confirmar el sentido de y en ADR-003 (si va de arriba abajo) y si cuenta la posición de la bola o la del ladrillo.
  • Etapa 4: la fórmula del bonus por velocidad, y si «multiplicador» se refiere a la multiplicación de bolas o a un multiplicador de puntos aparte.
  • Sin etapa fija: la regla de derrota con n = 0, qué prevalece si se gana y se pierde en el mismo fotograma, y si las bolas chocan entre sí.

En lo ratificado faltan FR-005 y un ADR-001. Lo he anotado en el documento sin rellenarlos.

Fichero completo: especificacion-multibola.md
# Especificación de la multibola

## Propósito

La multibola amplía el juego, que empezó con una sola bola. Cuando una bola rompe un ladrillo x3, cada bola activa se convierte en tres, hasta un máximo fijo. Este documento recoge los requisitos y las decisiones de arquitectura que ha ratificado el autor, los casos límite que las pruebas deben cubrir, el plan de implementación por etapas y las decisiones que siguen abiertas.

Punto de partida, antes de implementar la multibola: `src/game.js` guardaba una sola bola en `state.ball`. La partida se perdía cuando esa bola caía, la victoria se comprobaba dentro de `hitBrick` y cada choque se resolvía en el momento en que ocurría, dentro de cada paso corto de la bola.

## Requisitos ratificados

- **FR-001. Multiplicación sobre todas las bolas.** Romper un ladrillo x3 actúa sobre todas las bolas activas, no solo sobre la que lo ha roto. Si había `n` bolas, después quedan `min(3 × n, MAX_BALLS)`.
- **FR-002. Tope.** Nunca hay más de `MAX_BALLS = 200` bolas. Ejemplos de referencia: 1 → 3, 2 → 6, 199 → 200, 200 → 200.
- **FR-003. Puntuación única por ladrillo.** Cada ladrillo puntúa una sola vez, aunque varias bolas lo golpeen en el mismo fotograma.
- **FR-004. Determinismo.** Con las mismas entradas se obtiene la misma puntuación final. Las entradas son el estado inicial, la secuencia de `dt` y las teclas de cada fotograma. Por tanto, la lógica no puede usar azar sin semilla, y su resultado no puede depender del orden en que se insertan las bolas.
- **FR-006. Puntos del ladrillo x3.** El ladrillo x3 concede 50 puntos base.
- **FR-007. Bonus por velocidad.** El bonus por velocidad se aplica una sola vez por ladrillo, calculado con la velocidad de la bola que lo destruye.

No hay ningún FR-005 en lo ratificado. Queda pendiente confirmar si falta o si la numeración salta a propósito.

## Decisiones de arquitectura ratificadas

- **ADR-002. Lista de bolas.** El estado sustituye `ball` por `balls: Ball[]`. Cada `Ball` tiene un `id` estable (necesario para ADR-003) además de `x`, `y`, `r`, `vx` y `vy`.
- **ADR-003. Orden de los impactos.** Los impactos de un fotograma se recogen primero y después se resuelven por orden ascendente de `(y, x, id)`. En la práctica, este orden decide qué bola destruye un ladrillo golpeado por varias a la vez: esa bola es la que cuenta para FR-003 y FR-007. También permite cumplir FR-004 sin depender del orden de la lista.

Hoy no existe ningún ADR-001 documentado.

## Casos límite que deben cubrir las pruebas

Para el número de bolas `n` al romper un ladrillo x3:

| n antes | n después | Por qué se prueba |
|---|---|---|
| 0 | 0 | Recuento vacío: triplicar ninguna bola no crea bolas |
| 1 | 3 | Caso normal desde el saque |
| 2 | 6 | Primera repetición |
| intermedios: 50, 66, 67 | 150, 198, 200 | 66 queda justo por debajo del tope; con 67, el triple (201) lo supera |
| 199 | 200 | El triple se recorta al tope |
| 200 | 200 | Ya en el tope, no cambia |

En la puntuación:

- Dos o más bolas golpean el mismo ladrillo en el mismo fotograma, y la puntuación sube una sola vez (FR-003).
- Dos ladrillos x3 se rompen en el mismo fotograma, y cada uno aplica FR-001 sobre el recuento que deja el anterior, siguiendo el orden de ADR-003, sin pasar de 200.
- Se repite la misma partida simulada dos veces, o con las bolas iniciales en otro orden en la lista, y la puntuación final sale igual (FR-004).
- El bonus de FR-007 usa la velocidad de la bola que gana el orden de ADR-003, no la de las demás que golpean el mismo ladrillo.

## Plan de implementación por etapas

Las cuatro etapas están implementadas desde el 20 de noviembre de 2026. Ninguna prueba de la multibola se ha ratificado todavía como `*.ratificada.test.js`.

Cada etapa termina con `npm test` y `npm run lint` en verde. Las pruebas de cada etapa se escriben antes que el código de esa etapa, y el autor decide cuáles pasan a ser `*.ratificada.test.js`.

1. **Recuento con n = 0.** Un módulo puro nuevo, `src/multiball.js`, con `MAX_BALLS = 200` y una función de recuento, `tripledBallCount(n) = Math.min(3 * n, MAX_BALLS)`. Sus pruebas, en `tests/multiball.test.js`, cubren toda la tabla anterior, empezando por n = 0. Esta etapa no toca `game.js`.
2. **Aparición hasta el tope de 200.**
   - `src/game.js` pasa a usar `balls` con `id` estable (ADR-002) y a llevar un contador `nextBallId` para dar identificadores a las bolas nuevas. Admite la opción `createGame({ balls })`, igual que hoy admite `bricks`.
   - Los ladrillos tienen un campo `kind` (`'normal' | 'x3'`).
   - Una función que genera las bolas nuevas a partir de las activas y usa `tripledBallCount` para no pasar de 200. Cuando hay que recortar, lo hace de forma determinista.
   - `src/main.js` dibuja todas las bolas.
   - `tests/game.test.js` se migra de `state.ball` a `state.balls`. Las pruebas de aparición con 1, 2, 199 y 200 bolas van en su propio fichero, `tests/tope-200.ratificada.test.js`, que no depende de otros módulos de prueba y ya está ratificado.
   - `CLAUDE.md` deja de decir «No hay multibola».
3. **Puntuación única con impactos simultáneos.** Se reestructura `update` en `src/game.js`: en cada paso corto avanzan todas las bolas, se recogen los impactos, se ordenan por `(y, x, id)` y se resuelven. Un ladrillo ya destruido en ese paso no vuelve a puntuar. Se reutilizan `circleHitsRect` y el rebote por eje de menor penetración que ya hace `hitBrick`. Las pruebas cubren los impactos simultáneos y el determinismo de FR-004.
4. **Multiplicador y bonus.** El ladrillo x3 da 50 puntos base (FR-006) y dispara la multiplicación de FR-001. El bonus por velocidad (FR-007) se calcula una sola vez, con la velocidad de la bola que destruye el ladrillo. Las pruebas comprueban la puntuación exacta.

## Decisiones provisionales (implementadas, pendientes de ratificar)

Lo ratificado dejaba abiertas estas cuestiones. El 20 de noviembre de 2026 hubo que implementar las cuatro etapas de una vez, sin parar a preguntar, así que se resolvieron con los valores siguientes. Son provisionales: el autor puede cambiarlas, y cada una indica dónde está y qué prueba la fija.

- **Fórmula del bonus por velocidad.** `speedBonus(v) = Math.round(v / 20)`: 13 puntos a la velocidad normal de 260 px/s. Solo la suman los ladrillos x3, así que los normales siguen dando los puntos de su fila. Se redondea en vez de truncar porque los rebotes dejan la velocidad en 259,9999…, y truncando salía 12 (`src/game.js`, `speedBonus`). Hoy la velocidad de la bola no cambia durante la partida, así que en el juego normal el bonus siempre vale 13; solo varía en las pruebas que fijan otra velocidad.
- **«Multiplicador».** Se entiende como la multiplicación x3 de las bolas; no hay multiplicador de puntos aparte.
- **Ladrillos x3 del tablero.** Hay dos, en la fila 2, columnas 2 y 5 (`DEFAULTS.tripleBricks`).
- **Bolas nuevas.** Cada bola activa genera dos copias en su misma posición, con la misma velocidad y giradas ±20°. Si una copia queda con una componente vertical menor que el 35 % de la velocidad, se corrige para que no rebote en horizontal entre las paredes (`src/multiball.js`).
- **Recorte al tope.** Se conservan todas las originales y se añaden copias por orden de id de su original hasta llegar a 200. Las copias reciben ids nuevos que nunca se reutilizan (`nextBallId`).
- **Varias bolas sobre el mismo x3.** El ladrillo se rompe una vez, así que multiplica una vez: con 2 bolas quedan 6, no 18.
- **Momento de la multiplicación.** Primero se resuelven todos los impactos del paso y después se aplican los x3, uno tras otro. Las bolas nuevas empiezan a chocar en el paso siguiente.
- **Bolas que caen.** Salen del juego antes de resolver los ladrillos de ese paso. Por eso, si una cae en el mismo paso en que otra rompe un x3, no cuenta para el triple: de 3 bolas quedan 6, no 9.
- **Derrota.** La partida se pierde cuando no queda ninguna bola, y perder una de varias no tiene castigo.
- **Victoria y derrota a la vez.** Se comprueba primero la victoria. Además, la bola que rompe el último ladrillo sigue en juego, así que con estas reglas no pueden darse las dos a la vez.
- **Rebote en impactos simultáneos.** Todas las bolas que tocan el ladrillo en el mismo subpaso rebotan, aunque solo la primera lo destruya y puntúe. La que llega en un subpaso posterior lo encuentra ya destruido y lo atraviesa.
- **Simultaneidad por subpaso, no por fotograma.** ADR-003 habla de los impactos de un fotograma, pero el código los recoge y ordena en cada subpaso. Si el fotograma tiene un solo subpaso, ambas cosas coinciden. En el navegador puede tener dos: `main.js` admite un `dt` de hasta 1/30 s, y a 260 px/s la bola avanza 8,7 px, más que su radio. En ese caso, la bola que toca el ladrillo en el primer subpaso lo destruye y cuenta para el bonus aunque otra, en el segundo, tenga menor `y`. FR-003 se cumple igual, porque un ladrillo destruido no vuelve a puntuar en ningún subpaso. Ordenar el fotograma entero exigiría mantener los ladrillos vivos hasta su final, y una misma bola podría tocarlos en varios subpasos; por eso se prefirió esta interpretación (`tests/puntuacion-unica.test.js`).
- **Una bola en la esquina de dos ladrillos.** Toca como mucho un ladrillo por paso, el primero de la lista: el comportamiento que ya tenía el juego.
- **Choques entre bolas.** No hay: las bolas se atraviesan.
- **Orden de y en ADR-003.** Ascendente de arriba abajo en pantalla (menor `y` primero), con la posición de la bola después de moverse.
- **Entradas inválidas.** `tripledBallCount` lanza `RangeError` con n negativo o no entero, y `createGame` lo lanza si recibe más de 200 bolas.

## Verificación

Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento, con n = 0 en una prueba propia, y los casos de desempate por id, determinismo y fin de partida. `tests/tope-200.ratificada.test.js` comprueba la aparición en una partida real con 1, 2, 199 y 200 bolas. `tests/puntuacion-unica.test.js` comprueba que cada ladrillo puntúa una vez con 2 y con 200 bolas, también sobre un x3, y cuando dos bolas lo tocan en subpasos distintos de un mismo fotograma. `tests/multiplicador-bonus.test.js` fija los 50 puntos base del x3, la fórmula del bonus (10 a 200 px/s, 13 a 260 px/s y a 259,9999 px/s), los 63 puntos exactos de un x3 a la velocidad normal, que los ladrillos normales no suman bonus, que la base no depende del número de bolas y que el bonus usa la bola que gana el orden por `y` y por `x`; casi todo lo que fija son decisiones provisionales, así que conviene ratificarlas antes que el fichero. En `tests/game.test.js`, la partida simulada termina en victoria con una puntuación igual a la suma de los ladrillos más dos bonus de 13. Las 44 pruebas, el lint y la compilación de producción pasaron el 20 de noviembre de 2026.

Ese mismo día se observó el juego en Chrome sin ventana con `scripts/observar.mjs`, abriendo `?escenario=multibola`:

| Captura | Momento | Lo observado |
|---|---|---|
| `evidencias/multibola-0-inicio.png` | Partida normal, antes del saque | Rejilla con los dos x3, 1 bola y 0 puntos |
| `evidencias/multibola-1-x3-roto.png` | 1,2 s | El x3 roto, 3 bolas y 63 puntos (50 + 13) |
| `evidencias/multibola-2-una-bola.png` | 2,5 s | Sin mover la pala se han perdido dos bolas y la partida sigue con 1 |
| `evidencias/multibola-3-derrota.png` | 9 s | 0 bolas y el mensaje «Has perdido» |

Los casos con muchas bolas (199 y 200), los impactos simultáneos y el recorte al tope solo se han comprobado con pruebas, no en el navegador.

Salida de cada orden, tal como apareció en la pantalla

Pantalla al terminar el turno: «/plan describir la multibola y sus casos límite. Antes de proponer nada, enumera las de…»
  6. Dónde nacen. Si las nuevas nacen en el mismo punto que la original, pueden empezar metidas en un ladrillo o en la
     pala. El código actual rompería ese ladrillo enseguida, o haría rebotar la bola hacia arriba si está bajando sobre
     la pala. Hay que decidir si eso es aceptable o si las bolas nuevas nacen desplazadas, o sin chocar durante un
     instante.

  Derrota, victoria y simultaneidad

  7. Cuándo se pierde. La opción más natural es perder solo cuando caen todas las bolas, sin castigo por cada bola
     perdida. Como el juego no tiene vidas, la otra posibilidad (quitar algo al perder una bola) obligaría a añadirlas,
     y eso es otra ampliación.
  8. El mismo instante. Si la última bola cae en el mismo fotograma en que otra rompe el último ladrillo, hay que
     decidir si se gana, se pierde o depende del orden. Con varias bolas, el resultado depende del orden en que se
     actualizan, salvo que se fije una regla explícita (por ejemplo, que la victoria tenga prioridad).
  9. Choques simultáneos. Si dos bolas tocan el mismo ladrillo en el mismo fotograma, ¿puntúa solo la primera y la
     segunda lo atraviesa o rebota igualmente? También hay que decidir si las bolas chocan entre sí o se atraviesan, que
     es lo habitual en el género y mucho más simple.
  10. Cómo se reparten los pasos cortos. Hoy el número de pasos se calcula para que la única bola no atraviese
      ladrillos. Con varias bolas, cada una puede tener su propio número de pasos o pueden avanzar todas a la vez,
      intercaladas, paso a paso. Lo segundo hace más justos los choques simultáneos de los puntos 8 y 9, pero cuesta
      más.
  11. Puntuación. Puede quedar igual o dar algo por la cápsula o una bonificación mientras haya varias bolas.

  Contrato y compatibilidad

  12. El modelo de datos. Al pasar de state.ball a una lista state.balls, las pruebas actuales y main.js dejan de
      funcionar. Hay que elegir entre migrarlo todo de una vez o mantener state.ball como alias de la primera bola.
      También hay que decidir cómo inyectan las pruebas varias bolas, igual que hoy inyectan su propia rejilla con
      createGame({ bricks }).
  13. El saque y el reinicio. En ready hay una sola bola sobre la pala. Hay que confirmar que una partida nueva siempre
      empieza así y que no se puede activar la multibola antes del saque.
  14. Qué se ratifica. El repositorio protege las pruebas *.ratificada.test.js. Conviene decidir cuáles de estos casos
      límite pasan a ser pruebas ratificadas por ti antes de tocar src/, y cuáles quedan como pruebas normales.

  Las que más condicionan el resto son la 1, la 7, la 8 y la 12. Si me las respondes, describo la multibola y sus casos
  límite sobre esa base; las demás puedo dejarlas marcadas con un valor por defecto para que las revises.

✻ Sautéed for 38s · done 20:25
                                                                       Update available! Run: brew upgrade claude-code
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
❯
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ plan mode on (shift+tab to cycle) · ← for agents
Pantalla al terminar el turno: «Estas son las decisiones ratificadas; corrige el plan con ellas: FR-001, la multibola x…»
      1 # Especificación de la multibola
      3 ## Propósito
      4
      5 La multibola amplía el juego, que empezó con una sola bola. Cuando una bola rompe un ladrillo x3, cada bo
        es de arquitectura que ha ratificado el autor, los casos límite que las pruebas deben cubrir, el plan de
        implementación por etapas y las decisiones que siguen abiertas.
      7 Punto de partida: `src/game.js` guarda una sola bola en `state.ball`. La partida se pierde cuando esa bol
        a cae, la victoria se comprueba dentro de `hitBrick` y cada choque se resuelve en el momento en que ocurr
        e, dentro de cada paso corto de la bola.
      9 ## Requisitos ratificados
     … +108 lines

  Ran 2 shell commands

⏺ He guardado la especificación en docs/especificacion-multibola.md y no he tocado nada más: ni src/, ni tests/, ni
  package.json. git status muestra como nuevos docs/ y CLAUDE.md, que sigue pendiente desde /init porque el commit
  «Primera versión sin multibola» no lo incluyó. Tampoco he hecho ningún commit.

  He comprobado que el documento recoge las ocho decisiones ratificadas (FR-001, FR-002, FR-003, FR-004, FR-006, FR-007,
  ADR-002 y ADR-003). Los casos de n = 0, 1, 2, varios intermedios (50, 66 y 67), 199 y 200 están en una tabla. El plan
  va por etapas en el orden que pediste: recuento con n = 0, aparición hasta el tope de 200, puntuación única con
  impactos simultáneos y, al final, multiplicador y bonus.

  Al final del documento hay una sección de decisiones abiertas, porque varias cosas no quedan cubiertas por lo
  ratificado y no quería inventarlas. Antes de cada etapa conviene resolver estas:

  - Etapa 2: la dirección y el punto de nacimiento de las bolas nuevas, y qué bolas se descartan al recortar hasta 200.
  - Etapa 3: si las demás bolas que golpean un ladrillo ya destruido rebotan o lo atraviesan. También falta confirmar el
    sentido de y en ADR-003 (si va de arriba abajo) y si cuenta la posición de la bola o la del ladrillo.
  - Etapa 4: la fórmula del bonus por velocidad, y si «multiplicador» se refiere a la multiplicación de bolas o a un
    multiplicador de puntos aparte.
  - Sin etapa fija: la regla de derrota con n = 0, qué prevalece si se gana y se pierde en el mismo fotograma, y si las
    bolas chocan entre sí.

  En lo ratificado faltan FR-005 y un ADR-001. Lo he anotado en el documento sin rellenarlos.

✻ Brewed for 1m 26s · done 20:27
                                                                       Update available! Run: brew upgrade claude-code
───────────────────────────────────────────────────────────────────────────────────────── multibola-specification-plan ─
❯ Implementa la etapa 1: recuento con n = 0
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Terminal: $ ls docs && head -40 docs/especificacion-multibola.md
arkanoid $ ls docs && head -40 docs/especificacion-multibola.md
especificacion-multibola.md
# Especificación de la multibola

## Propósito

La multibola amplía el juego, que empezó con una sola bola. Cuando una bola rompe un ladrillo x3, cada bola activa se co
nvierte en tres, hasta un máximo fijo. Este documento recoge los requisitos y las decisiones de arquitectura que ha rati
ficado el autor, los casos límite que las pruebas deben cubrir, el plan de implementación por etapas y las decisiones qu
e siguen abiertas.

Punto de partida: `src/game.js` guarda una sola bola en `state.ball`. La partida se pierde cuando esa bola cae, la victo
ria se comprueba dentro de `hitBrick` y cada choque se resuelve en el momento en que ocurre, dentro de cada paso corto d
e la bola.

## Requisitos ratificados

- **FR-001. Multiplicación sobre todas las bolas.** Romper un ladrillo x3 actúa sobre todas las bolas activas, no solo s
obre la que lo ha roto. Si había `n` bolas, después quedan `min(3 × n, MAX_BALLS)`.
- **FR-002. Tope.** Nunca hay más de `MAX_BALLS = 200` bolas. Ejemplos de referencia: 1 → 3, 2 → 6, 199 → 200, 200 → 200
.
- **FR-003. Puntuación única por ladrillo.** Cada ladrillo puntúa una sola vez, aunque varias bolas lo golpeen en el mis
mo fotograma.
- **FR-004. Determinismo.** Con las mismas entradas se obtiene la misma puntuación final. Las entradas son el estado ini
cial, la secuencia de `dt` y las teclas de cada fotograma. Por tanto, la lógica no puede usar azar sin semilla, y su res
ultado no puede depender del orden en que se insertan las bolas.
- **FR-006. Puntos del ladrillo x3.** El ladrillo x3 concede 50 puntos base.
- **FR-007. Bonus por velocidad.** El bonus por velocidad se aplica una sola vez por ladrillo, calculado con la velocida
d de la bola que lo destruye.

No hay ningún FR-005 en lo ratificado. Queda pendiente confirmar si falta o si la numeración salta a propósito.

## Decisiones de arquitectura ratificadas

- **ADR-002. Lista de bolas.** El estado sustituye `ball` por `balls: Ball[]`. Cada `Ball` tiene un `id` estable (necesa
rio para ADR-003) además de `x`, `y`, `r`, `vx` y `vy`.
- **ADR-003. Orden de los impactos.** Los impactos de un fotograma se recogen primero y después se resuelven por orden a
scendente de `(y, x, id)`. En la práctica, este orden decide qué bola destruye un ladrillo golpeado por varias a la vez:
 esa bola es la que cuenta para FR-003 y FR-007. También permite cumplir FR-004 sin depender del orden de la lista.

Hoy no existe ningún ADR-001 documentado.

## Casos límite que deben cubrir las pruebas

Para el número de bolas `n` al romper un ladrillo x3:

| n antes | n después | Por qué se prueba |
|---|---|---|
| 0 | 0 | Recuento vacío: triplicar ninguna bola no crea bolas |
| 1 | 3 | Caso normal desde el saque |
| 2 | 6 | Primera repetición |
| intermedios: 50, 66, 67 | 150, 198, 200 | 66 queda justo por debajo del tope; con 67, el triple (201) lo supera |
| 199 | 200 | El triple se recorta al tope |
| 200 | 200 | Ya en el tope, no cambia |

En la puntuación:
arkanoid $
Los 3 menús de este paso, tal como aparecieron

Aprobación del plan · 036

  ⎿  /plan to preview
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔

  ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
   Ready to code?

   Here is Claude's plan:
  ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
   Plan: especificación de la multibola

   Contexto

   El juego actual (src/game.js) tiene una sola bola en state.ball. La partida se pierde cuando esa bola cae, y la
   victoria se comprueba dentro de hitBrick. Además, cada choque se resuelve en el momento en que ocurre, dentro de
   cada paso corto de la bola. Roberto ha ratificado las decisiones de la multibola (FR-001 a FR-007, ADR-002 y
   ADR-003) y pide que queden recogidas en una especificación permanente antes de implementar nada. La implementación
   la pedirá por etapas.

   Único paso tras aprobar este plan: crear docs/especificacion-multibola.md con el contenido de la sección
   siguiente. No se toca src/, tests/, CLAUDE.md ni package.json. La frase «No hay multibola» de CLAUDE.md se
   actualizará cuando se implemente la etapa 2, no ahora.

   ---

   Contenido de docs/especificacion-multibola.md

   Propósito

   La multibola amplía el juego, que empezó con una sola bola. Cuando una bola rompe un ladrillo x3, cada bola activa
   se convierte en tres, hasta un máximo fijo. Este documento recoge los requisitos y las decisiones de arquitectura
   que ha ratificado el autor, los casos límite que las pruebas deben cubrir, el plan de implementación por etapas y
   las decisiones que siguen abiertas.                                                                                ↓
  ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
   Claude has written up a plan and is ready to execute. Would you like to proceed?

   ❯ 1. Yes, and use auto mode
     2. Yes, manually approve edits
     3. Tell Claude what to change
        shift+tab to approve with this feedback

   ctrl+g to edit in Vim · ~/sdd-931/config/plans/pasted-content-id-f5c4-estas-son-steady-dragonfly.md

Menú de permiso · 037

  57    - `tests/game.test.js` se migra de `state.ball` a `state.balls`, y se añaden pruebas de aparición con 1, 2, 1
     99 y 200 bolas.
  58    - `CLAUDE.md` deja de decir «No hay multibola».
  59 3. **Puntuación única con impactos simultáneos.** Se reestructura `update` en `src/game.js`: en cada paso corto
     avanzan todas las bolas, se recogen los impactos, se ordenan por `(y, x, id)` y se resuelven. Un ladrillo ya des
     truido en ese paso no vuelve a puntuar. Se reutilizan `circleHitsRect` y el rebote por eje de menor penetración
     que ya hace `hitBrick`. Las pruebas cubren los impactos simultáneos y el determinismo de FR-004.
  60 4. **Multiplicador y bonus.** El ladrillo x3 da 50 puntos base (FR-006) y dispara la multiplicación de FR-001. E
     l bonus por velocidad (FR-007) se calcula una sola vez, con la velocidad de la bola que destruye el ladrillo. La
     s pruebas comprueban la puntuación exacta.
  61
  62 ## Decisiones abiertas (no ratificadas)
  63
  64 Estas cuestiones no las cubre lo ratificado. Deben resolverse antes de la etapa que las necesita, y no se implem
     entan con un valor supuesto sin confirmarlo.
  65
  66 - **Fórmula del bonus por velocidad (etapa 4).** Falta saber cómo se calcula: proporcional, por tramos, con redo
     ndeo o no, y si se aplica solo a los ladrillos x3 o a todos.
  67 - **Qué significa «multiplicador» (etapa 4).** Puede ser la multiplicación x3 de las bolas o un multiplicador de
      puntos aparte.
  68 - **Ladrillos normales.** Falta confirmar que siguen dando los puntos de su fila y saber cuántos ladrillos x3 ha
     y y dónde se colocan.
  69 - **Bolas nuevas (etapa 2).** Falta decidir su dirección y velocidad, dónde nacen (pueden nacer dentro de un lad
     rillo o de la pala) y si hay una componente vertical mínima para que ninguna quede en horizontal.
  70 - **Qué bolas se conservan al recortar (etapa 2).** Por ejemplo, de 67 a 200 bolas: hay que decidir qué bolas nu
     evas se descartan para cumplir el tope.
  71 - **Derrota y bolas perdidas.** Falta ratificar que la partida se pierde cuando n llega a 0 y que perder una bol
     a cuando quedan otras no tiene castigo.
  72 - **Victoria y derrota en el mismo fotograma.** Si se rompe el último ladrillo cuando cae la última bola, falta
     saber qué prevalece.
  73 - **Rebote en impactos simultáneos (etapa 3).** Cuando varias bolas golpean el mismo ladrillo, solo una lo destr
     uye. Falta decidir si las demás rebotan igualmente o lo atraviesan.
  74 - **Choques entre bolas.** Falta confirmar si las bolas se atraviesan entre sí.
  75 - **Orden de y en ADR-003.** Falta confirmar que «ascendente» significa de arriba abajo en pantalla (menor `y` p
     rimero) y si se usa la posición de la bola o la del ladrillo.
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to create especificacion-multibola.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 038

     Verificación

     Cuando el fichero esté escrito: comprobar con git status que el único cambio nuevo es
     docs/especificacion-multibola.md, y revisar que aparecen todos los identificadores ratificados (FR-001, FR-002,
     FR-003, FR-004, FR-006, FR-007, ADR-002 y ADR-003) y los casos n = 0, 1, intermedios y 200. No se ejecutan pruebas,
     porque no cambia el código.

⏺ Write(docs/especificacion-multibola.md)
  ⎿  Wrote 75 lines to docs/especificacion-multibola.md
      1 # Especificación de la multibola
      3 ## Propósito
      4
      5 La multibola amplía el juego, que empezó con una sola bola. Cuando una bola rompe un ladrillo x3, cada bo
        es de arquitectura que ha ratificado el autor, los casos límite que las pruebas deben cubrir, el plan de
        implementación por etapas y las decisiones que siguen abiertas.
      7 Punto de partida: `src/game.js` guarda una sola bola en `state.ball`. La partida se pierde cuando esa bol
        a cae, la victoria se comprueba dentro de `hitBrick` y cada choque se resuelve en el momento en que ocurr
        e, dentro de cada paso corto de la bola.
      9 ## Requisitos ratificados
     … +108 lines

⏺ Checking working tree and ratified IDs in the spec
  ⎿  $ git status --short && for id in FR-001 FR-002 FR-003 FR-004 FR-006 FR-007 ADR-002 ADR-003; do printf "%s %s\n"
     $id $(grep -c "$id" docs/especificacion-multibola.md); done

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ git status --short && for id in FR-001 FR-002 FR-003 FR-004 FR-006 FR-007 ADR-002 ADR-003; do printf "%s %s\n"
   │ $id $(grep -c "$id" docs/especificacion-multibola.md); done
   Check working tree and ratified IDs in the spec

 Contains simple_expansion

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and switch to auto mode · auto mode handles these prompts for you
   3. No

 Esc to cancel · Tab to amend

Paso 8: una skill para los casos límite

Una skill es una carpeta con un SKILL.md que describe un procedimiento; Claude la usa cuando el encargo encaja o cuando la llamas por su nombre. Copiamos la skill casos-limite en .claude/skills/ con la sesión abierta y no apareció en /skills. Hubo que salir con /exit y volver con claude --continue, que retoma la conversación con la skill ya cargada.

La comparación que pide el libro (el mismo encargo con la skill y sin ella) mereció la pena. La invocamos en modo de planificación, para que solo analizara, y la tabla salió con 42 casos: 13 ya estaban en la especificación, 10 lo estaban a medias y 19 eran nuevos. El más útil fue justo el que el libro pone de ejemplo: si dos bolas golpean a la vez el mismo ladrillo x3, ¿quedan 6 bolas o 18?

Lo que dice el libro (versión 87a)

8. Incorporar una skill cuando aporte algo al encargo. Escribimos / para consultar el catálogo disponible y leemos el SKILL.md de la que queramos utilizar. Anotamos su nombre, procedencia, versión, dependencias y resultado esperado. Antes de incorporarla comprobamos que las herramientas que necesita están instaladas y que podemos comparar su aportación con el mismo caso realizado sin ella.

Con la skill casos-limite, por ejemplo, repetimos el /plan de la multibola con ella y sin ella, y miramos si la tabla de límites recoge algún caso que antes faltaba, como dos bolas que golpean el mismo ladrillo en el mismo instante.

El formato abierto Agent Skills facilita reutilizar procedimientos entre herramientas compatibles.

Cada skill depende, sin embargo, de lo que haya instalado en el equipo. Si casos-limite llama a un script de Python, en un entorno sin python3 o sin permiso para ejecutarlo no funcionará, aunque el SKILL.md se lea igual.

Por eso una skill se versiona y se revisa como cualquier otra dependencia del proceso. Se lee antes de incorporarla y se vuelve a evaluar al actualizarla.

Una skill que copiamos en .claude/skills/ con la sesión abierta no aparece en el catálogo hasta que reiniciamos. Salimos con /exit y volvemos con claude --continue, que recupera la misma conversación con la skill ya cargada.

Lista de skills tras reiniciar, con casos-limite marcada como skill del proyecto
Tras el reinicio, casos-limite (project) ya aparece. Las demás vienen de la cuenta de claude.ai.
Resultado de la skill casos-limite comparando su tabla con la de la especificación
Claude recomienda confirmar dos casos antes de implementar la segunda etapa.
Al escribir una barra, Claude Code despliega el catálogo de órdenes, entre ellas /init, /run y /verify
Al teclear / aparece el catálogo: las órdenes de Claude Code y las skills, cada una con su descripción.
Ida y vuelta de el turno 5: 1 min 42 s de trabajo, 3 herramientas usadas

Turno 5 · 1 min 42 s

Ida: lo que escribimos

/casos-limite la multibola de docs/especificacion-multibola.md. Compara tu tabla con los casos del plan anterior y di qué casos añade.

Vuelta: lo que contestó Claude

  1. Bash git log --oneline | head -3 && git status --short && git diff HEAD --stat; md5 -q docs/especificacion-multibola.md; grep -n "MAX_BALLS\|FR-0\|ADR-0" docs/especificacion-multibola.md | head -40
  2. Write ~/sdd-931/config/plans/pasted-content-id-f5c4-estas-son-steady-dragonfly.md
  3. ExitPlanMode

La tabla de casos límite está terminada y no he modificado ningún fichero. La he dejado en el fichero de plan aprobado (~/sdd-931/config/plans/pasted-content-id-f5c4-estas-son-steady-dragonfly.md), que queda fuera del repositorio. Si alguno de los casos nuevos debe pasar a docs/especificacion-multibola.md o a pruebas ratificadas, habrá que trasladarlo allí.

La tabla tiene 42 casos. De ellos, 13 ya estaban en el plan anterior, 10 estaban a medias y 19 son nuevos. Los 13 que ya estaban son los ocho valores de la tabla de recuento (0, 1, 2, 50, 66, 67, 199 y 200) y las cuatro viñetas de puntuación de la especificación. La cuarta viñeta se reparte en dos filas, porque el determinismo aparece una vez al repetir la partida y otra al cambiar el orden de las bolas. Los 10 a medias son casos cuya regla ya figuraba, pero no como caso concreto que probar; casi todos estaban como decisión abierta.

Los 19 casos nuevos se agrupan así:

  • Encadenar efectos cerca del tope. Dos x3 en el mismo fotograma con 67 bolas pasan de 67 a 200 y siguen en 200. Dos x3 en fotogramas seguidos llevan de 1 a 3 y luego a 9. Un x3 roto con 200 bolas sigue dando sus 50 puntos base, sin multiplicarlos por el número de bolas.
  • Varias bolas sobre el mismo x3. Es el caso que más cambia el resultado. El ladrillo puntúa una vez por FR-003, pero la especificación no dice cuántas veces se multiplican las bolas. Entiendo que una sola (de 2 a 6, no a 18), porque el ladrillo solo se rompe una vez, pero conviene que lo confirmes.
  • Desempates de ADR-003. Si dos bolas están en la misma (y, x), decide el menor id; si comparten y, decide el menor x. También falta resolver qué pasa cuando una bola toca dos ladrillos a la vez en una esquina. Hoy se rompe uno solo por paso, y con la nueva ordenación no está decidido.
  • Identificadores. Las bolas nuevas reciben ids distintos y las originales conservan el suyo. Falta decidir si se reutilizan los ids de bolas perdidas.
  • Límites del recuento. Queda por decidir qué pasa si una prueba crea la partida con 201 bolas y qué hace la función con un n negativo o no entero.
  • Simultaneidad con caídas. Si una bola cae en el mismo fotograma en que otra rompe un x3, falta decidir si la caída cuenta para el triple (9 o 6 bolas). Tampoco está decidido si las bolas recién nacidas ya chocan en ese mismo fotograma, ni qué pasa si caen todas a la vez.
  • Determinismo. Llegar al tope desde 67 bolas tiene que dar siempre las mismas 200. Y con otra secuencia de dt (30 fps en lugar de 60) FR-004 no exige el mismo resultado, porque las entradas son distintas.
  • Bonus por velocidad. Hay que decidir si es 0 a la velocidad de saque y si tiene un máximo. Las dos cosas dependen de la fórmula, que sigue sin definir.
  • El x3 como último ladrillo. Da sus puntos y la victoria, y las bolas que se creen en ese momento no cambian el resultado.

Antes de la etapa 2 conviene confirmar el caso de varias bolas sobre el mismo x3 y decidir qué hacer cuando una bola cae en el mismo fotograma en que se rompe un x3. Los dos fijan cuántas bolas hay después de multiplicar, que es justo lo que esa etapa implementa.

Salida de cada orden, tal como apareció en la pantalla

Órdenes que lanzó el programa antes, sin captura
$ mkdir -p .claude/skills/casos-limite && cp plantillas/skill/SKILL.md .claude/skills/casos-limite/
Dentro de Claude Code: /skills
  ADR-002 y ADR-003). Los casos de n = 0, 1, 2, varios intermedios (50, 66 y 67), 199 y 200 están en una tabla. El plan
  va por etapas en el orden que pediste: recuento con n = 0, aparición hasta el tope de 200, puntuación única con
  impactos simultáneos y, al final, multiplicador y bonus.

  Al final del documento hay una sección de decisiones abiertas, porque varias cosas no quedan cubiertas por lo
  ratificado y no quería inventarlas. Antes de cada etapa conviene resolver estas:

  - Etapa 2: la dirección y el punto de nacimiento de las bolas nuevas, y qué bolas se descartan al recortar hasta 200.
  - Etapa 3: si las demás bolas que golpean un ladrillo ya destruido rebotan o lo atraviesan. También falta confirmar el
    sentido de y en ADR-003 (si va de arriba abajo) y si cuenta la posición de la bola o la del ladrillo.
  - Etapa 4: la fórmula del bonus por velocidad, y si «multiplicador» se refiere a la multiplicación de bolas o a un
    multiplicador de puntos aparte.
  - Sin etapa fija: la regla de derrota con n = 0, qué prevalece si se gana y se pierde en el mismo fotograma, y si las
    bolas chocan entre sí.

  En lo ratificado faltan FR-005 y un ADR-001. Lo he anotado en el documento sin rellenarlos.

✻ Brewed for 1m 26s · done 20:27
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
   Skills
   15 skills · enter/space to cycle, / to search, t to sort, Esc to close

   ╭────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
   │ ⌕ Search skills…                                                                                               │
   ╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
   ❯ ✔ actualizar-seccion-herramienta      claude.ai sync · ~90 tok
     ✔ actualizar-seccion-herramienta-v2   claude.ai sync · ~100 tok
     ✔ anthropic-skills:deep-research      claude.ai sync · ~200 tok
     ✔ built-in-browser                    claude.ai sync · ~280 tok
     ✔ chrome-browser                      claude.ai sync · ~260 tok
     ✔ computer-use                        claude.ai sync · ~320 tok
     ✔ docs                                claude.ai sync · ~340 tok
     ✔ docx                                claude.ai sync · ~320 tok
     ✔ google-workspace                    claude.ai sync · ~330 tok
     ✔ import-memory                       claude.ai sync · ~60 tok
     ✔ morning                             claude.ai sync · ~120 tok
     ✔ pdf                                 claude.ai sync · ~150 tok
     ✔ pptx                                claude.ai sync · ~330 tok
     ✔ skill-creator                       claude.ai sync · ~120 tok
     ✔ xlsx                                claude.ai sync · ~320 tok

   /deep-research runs a workflow, not your claude.ai skill.
Reinicio: /exit y después $ claude --continue
      5 La multibola amplía el juego, que empezó con una sola bola. Cuando una bola rompe un ladrillo x3, cada bo
        es de arquitectura que ha ratificado el autor, los casos límite que las pruebas deben cubrir, el plan de
        implementación por etapas y las decisiones que siguen abiertas.
      7 Punto de partida: `src/game.js` guarda una sola bola en `state.ball`. La partida se pierde cuando esa bol
        a cae, la victoria se comprueba dentro de `hitBrick` y cada choque se resuelve en el momento en que ocurr
        e, dentro de cada paso corto de la bola.
      9 ## Requisitos ratificados
     … +108 lines

  Ran 2 shell commands

⏺ He guardado la especificación en docs/especificacion-multibola.md y no he tocado nada más: ni src/, ni tests/, ni
  package.json. git status muestra como nuevos docs/ y CLAUDE.md, que sigue pendiente desde /init porque el commit
  «Primera versión sin multibola» no lo incluyó. Tampoco he hecho ningún commit.

  He comprobado que el documento recoge las ocho decisiones ratificadas (FR-001, FR-002, FR-003, FR-004, FR-006, FR-007,
  ADR-002 y ADR-003). Los casos de n = 0, 1, 2, varios intermedios (50, 66 y 67), 199 y 200 están en una tabla. El plan
  va por etapas en el orden que pediste: recuento con n = 0, aparición hasta el tope de 200, puntuación única con
  impactos simultáneos y, al final, multiplicador y bonus.

  Al final del documento hay una sección de decisiones abiertas, porque varias cosas no quedan cubiertas por lo
  ratificado y no quería inventarlas. Antes de cada etapa conviene resolver estas:

  - Etapa 2: la dirección y el punto de nacimiento de las bolas nuevas, y qué bolas se descartan al recortar hasta 200.
  - Etapa 3: si las demás bolas que golpean un ladrillo ya destruido rebotan o lo atraviesan. También falta confirmar el
    sentido de y en ADR-003 (si va de arriba abajo) y si cuenta la posición de la bola o la del ladrillo.
  - Etapa 4: la fórmula del bonus por velocidad, y si «multiplicador» se refiere a la multiplicación de bolas o a un
    multiplicador de puntos aparte.
  - Sin etapa fija: la regla de derrota con n = 0, qué prevalece si se gana y se pierde en el mismo fotograma, y si las
    bolas chocan entre sí.

  En lo ratificado faltan FR-005 y un ADR-001. Lo he anotado en el documento sin rellenarlos.

✻ Brewed for 1m 26s · done 20:27

❯ /skills
  ⎿  No changes
                                                                       Update available! Run: brew upgrade claude-code
───────────────────────────────────────────────────────────────────────────────────────── multibola-specification-plan ─
❯
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Dentro de Claude Code: /skills
  Al final del documento hay una sección de decisiones abiertas, porque varias cosas no quedan cubiertas por lo
  ratificado y no quería inventarlas. Antes de cada etapa conviene resolver estas:

  - Etapa 2: la dirección y el punto de nacimiento de las bolas nuevas, y qué bolas se descartan al recortar hasta 200.
  - Etapa 3: si las demás bolas que golpean un ladrillo ya destruido rebotan o lo atraviesan. También falta confirmar el
    sentido de y en ADR-003 (si va de arriba abajo) y si cuenta la posición de la bola o la del ladrillo.
  - Etapa 4: la fórmula del bonus por velocidad, y si «multiplicador» se refiere a la multiplicación de bolas o a un
    multiplicador de puntos aparte.
  - Sin etapa fija: la regla de derrota con n = 0, qué prevalece si se gana y se pierde en el mismo fotograma, y si las
    bolas chocan entre sí.

  En lo ratificado faltan FR-005 y un ADR-001. Lo he anotado en el documento sin rellenarlos.

✻ Brewed for 1m 26s · done 20:27

❯ /skills
  ⎿  No changes
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
   Skills
   16 skills · enter/space to cycle, / to search, t to sort, Esc to close

   ╭────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
   │ ⌕ Search skills…                                                                                               │
   ╰────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
   ❯ ✔ actualizar-seccion-herramienta      claude.ai sync · ~90 tok
     ✔ actualizar-seccion-herramienta-v2   claude.ai sync · ~100 tok
     ✔ anthropic-skills:deep-research      claude.ai sync · ~200 tok
     ✔ built-in-browser                    claude.ai sync · ~280 tok
     ✔ chrome-browser                      claude.ai sync · ~260 tok
     ✔ computer-use                        claude.ai sync · ~320 tok
     ✔ docs                                claude.ai sync · ~340 tok
     ✔ docx                                claude.ai sync · ~320 tok
     ✔ google-workspace                    claude.ai sync · ~330 tok
     ✔ import-memory                       claude.ai sync · ~60 tok
     ✔ morning                             claude.ai sync · ~120 tok
     ✔ pdf                                 claude.ai sync · ~150 tok
     ✔ pptx                                claude.ai sync · ~330 tok
     ✔ skill-creator                       claude.ai sync · ~120 tok
     ✔ xlsx                                claude.ai sync · ~320 tok
     ✔ casos-limite                        project · ~80 tok

   /deep-research runs a workflow, not your claude.ai skill.
044-p08-catalogo
      7 Punto de partida: `src/game.js` guarda una sola bola en `state.ball`. La partida se pierde cuando esa bol
        a cae, la victoria se comprueba dentro de `hitBrick` y cada choque se resuelve en el momento en que ocurr
        e, dentro de cada paso corto de la bola.
      9 ## Requisitos ratificados
     … +108 lines

  Ran 2 shell commands

⏺ He guardado la especificación en docs/especificacion-multibola.md y no he tocado nada más: ni src/, ni tests/, ni
  package.json. git status muestra como nuevos docs/ y CLAUDE.md, que sigue pendiente desde /init porque el commit
  «Primera versión sin multibola» no lo incluyó. Tampoco he hecho ningún commit.

  He comprobado que el documento recoge las ocho decisiones ratificadas (FR-001, FR-002, FR-003, FR-004, FR-006, FR-007,
  ADR-002 y ADR-003). Los casos de n = 0, 1, 2, varios intermedios (50, 66 y 67), 199 y 200 están en una tabla. El plan
  va por etapas en el orden que pediste: recuento con n = 0, aparición hasta el tope de 200, puntuación única con
  impactos simultáneos y, al final, multiplicador y bonus.

  Al final del documento hay una sección de decisiones abiertas, porque varias cosas no quedan cubiertas por lo
  ratificado y no quería inventarlas. Antes de cada etapa conviene resolver estas:

  - Etapa 2: la dirección y el punto de nacimiento de las bolas nuevas, y qué bolas se descartan al recortar hasta 200.
  - Etapa 3: si las demás bolas que golpean un ladrillo ya destruido rebotan o lo atraviesan. También falta confirmar el
    sentido de y en ADR-003 (si va de arriba abajo) y si cuenta la posición de la bola o la del ladrillo.
  - Etapa 4: la fórmula del bonus por velocidad, y si «multiplicador» se refiere a la multiplicación de bolas o a un
    multiplicador de puntos aparte.
  - Sin etapa fija: la regla de derrota con n = 0, qué prevalece si se gana y se pierde en el mismo fotograma, y si las
    bolas chocan entre sí.

  En lo ratificado faltan FR-005 y un ADR-001. Lo he anotado en el documento sin rellenarlos.

✻ Brewed for 1m 26s · done 20:27

  /init                                  Initialize a new CLAUDE.md file with codebase documentation
  /run                                   Launch and drive this project's app to see a change working. Use when asked
                                         to run, start, or screenshot the app, or to confirm a change works in the re…
  /verify                                Verify that a code change actually does what it's supposed to by exercising
                                         it end-to-end and observing behavior — drive the affected flow, not just tes…
───────────────────────────────────────────────────────────────────────────────────────── multibola-specification-plan ─
❯ /
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on
Pantalla al terminar el turno: «/casos-limite la multibola de docs/especificacion-multibola.md. Compara tu tabla con lo…»
  La tabla tiene 42 casos. De ellos, 13 ya estaban en el plan anterior, 10 estaban a medias y 19 son nuevos. Los 13 que
  ya estaban son los ocho valores de la tabla de recuento (0, 1, 2, 50, 66, 67, 199 y 200) y las cuatro viñetas de
  puntuación de la especificación. La cuarta viñeta se reparte en dos filas, porque el determinismo aparece una vez al
  repetir la partida y otra al cambiar el orden de las bolas. Los 10 a medias son casos cuya regla ya figuraba, pero no
  como caso concreto que probar; casi todos estaban como decisión abierta.

  Los 19 casos nuevos se agrupan así:

  - Encadenar efectos cerca del tope. Dos x3 en el mismo fotograma con 67 bolas pasan de 67 a 200 y siguen en 200. Dos
    x3 en fotogramas seguidos llevan de 1 a 3 y luego a 9. Un x3 roto con 200 bolas sigue dando sus 50 puntos base, sin
    multiplicarlos por el número de bolas.
  - Varias bolas sobre el mismo x3. Es el caso que más cambia el resultado. El ladrillo puntúa una vez por FR-003, pero
    la especificación no dice cuántas veces se multiplican las bolas. Entiendo que una sola (de 2 a 6, no a 18), porque
    el ladrillo solo se rompe una vez, pero conviene que lo confirmes.
  - Desempates de ADR-003. Si dos bolas están en la misma (y, x), decide el menor id; si comparten y, decide el menor x.
    También falta resolver qué pasa cuando una bola toca dos ladrillos a la vez en una esquina. Hoy se rompe uno solo
    por paso, y con la nueva ordenación no está decidido.
  - Identificadores. Las bolas nuevas reciben ids distintos y las originales conservan el suyo. Falta decidir si se
    reutilizan los ids de bolas perdidas.
  - Límites del recuento. Queda por decidir qué pasa si una prueba crea la partida con 201 bolas y qué hace la función
    con un n negativo o no entero.
  - Simultaneidad con caídas. Si una bola cae en el mismo fotograma en que otra rompe un x3, falta decidir si la caída
    cuenta para el triple (9 o 6 bolas). Tampoco está decidido si las bolas recién nacidas ya chocan en ese mismo
    fotograma, ni qué pasa si caen todas a la vez.
  - Determinismo. Llegar al tope desde 67 bolas tiene que dar siempre las mismas 200. Y con otra secuencia de dt (30 fps
    en lugar de 60) FR-004 no exige el mismo resultado, porque las entradas son distintas.
  - Bonus por velocidad. Hay que decidir si es 0 a la velocidad de saque y si tiene un máximo. Las dos cosas dependen de
    la fórmula, que sigue sin definir.
  - El x3 como último ladrillo. Da sus puntos y la victoria, y las bolas que se creen en ese momento no cambian el
    resultado.

  Antes de la etapa 2 conviene confirmar el caso de varias bolas sobre el mismo x3 y decidir qué hacer cuando una bola
  cae en el mismo fotograma en que se rompe un x3. Los dos fijan cuántas bolas hay después de multiplicar, que es justo
  lo que esa etapa implementa.

✻ Crunched for 1m 28s · done 20:29
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Los 1 menús de este paso, tal como aparecieron

Aprobación del plan · 045

  ⎿  /plan to preview
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔

  ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
   Ready to code?

   Here is Claude's plan:
  ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
   Casos límite de la multibola

   Contexto

   Roberto ha pedido aplicar la skill casos-limite a la multibola descrita en docs/especificacion-multibola.md, que
   no ha cambiado desde que se guardó. También quiere comparar el resultado con los casos que ya recogía el plan
   anterior (la tabla de recuento y las cuatro viñetas de puntuación de la especificación). La skill solo produce la
   tabla: tras aprobar este plan no se edita ningún fichero. Si alguno de los casos nuevos debe entrar en la
   especificación o en pruebas ratificadas, se pedirá aparte.

   Las cantidades con límite son estas: el número de bolas n (de 0 a MAX_BALLS = 200), los ladrillos que quedan, los
   50 puntos base del x3 y la velocidad de la bola para el bonus. Los eventos que pueden coincidir son: varias bolas
   sobre un ladrillo, varios x3 en el mismo fotograma, un x3 cuando ya hay 200 bolas, x3 en fotogramas seguidos, la
   caída de bolas y la rotura del último ladrillo.

   En la última columna, «sí» indica que el caso ya estaba en el plan; «parcial», que estaba la regla pero no ese
   caso concreto; y «no», que es un caso nuevo.

   A. Recuento y tope (FR-001, FR-002)

   #: A1
   Caso: Cero
   Estado inicial: n = 0
   Acción: tripledBallCount(0)                                                                                        ↓
  ────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
   Claude has written up a plan and is ready to execute. Would you like to proceed?

   ❯ 1. Yes, and use auto mode
     2. Yes, manually approve edits
     3. Tell Claude what to change
        shift+tab to approve with this feedback

   ctrl+g to edit in Vim · ~/sdd-931/config/plans/pasted-content-id-f5c4-estas-son-steady-dragonfly.md

Paso 9: un subagente revisor

Un subagente es otro agente con su propio contexto, al que el principal (el coordinador) le hace un encargo y del que recibe un informe. Definimos un revisor en .claude/agents/ con un modelo barato (Haiku) y solo herramientas de lectura. En esta versión /agents ya no abre un panel: solo recuerda que los subagentes se crean editando .claude/agents/ o pidiéndoselo a Claude. Nuestro programa buscaba el nombre del revisor en esa pantalla, no lo encontró y reinició por si acaso, como con la skill. La comprobación que sí sirve es /context, que en el paso 11 contó «Custom agents: 1 agent · 69 tokens».

Lo interesante no fue el informe del revisor, sino lo que hizo el coordinador con él. El subagente se saltó los valores intermedios, citó mal algunos requisitos y señaló seis «contradicciones»; Claude las comprobó una a una y concluyó que ninguna era real. Es lo que defiende el libro: el informe de un modelo es una opinión que se contrasta, no una prueba. En los mensajes se ve también cómo funciona por dentro: el subagente trabaja en segundo plano y, cuando acaba, su resultado entra solo en la conversación como una notificación.

Lo que dice el libro (versión 87a)

9. Repartir una revisión, si queremos practicar con subagentes. Podemos completar el recorrido con un solo coordinador.

Para probar la delegación, definimos un revisor en .claude/agents/, con un modelo barato en el campo model y solo herramientas de lectura en tools, y le damos un encargo pequeño: buscar casos límite de multibola. Para crearlo podemos usar /agents.

Su informe queda separado, y el coordinador lo contrasta con la especificación y con las pruebas externas. Reservamos /batch para cambios grandes que puedan separarse en piezas independientes, porque crea worktrees y pull requests y multiplica el consumo.

Antes de repartir tareas entre agentes decidimos qué independencia buscamos.

Que una herramienta pueda sustituirse por la de otro proveedor, que un verificador se ejecute fuera del constructor y que una revisión la haga otra persona o equipo son separaciones distintas. Un subagente aísla parte del contexto y descarga al coordinador, pero comparte las dependencias del entorno de ejecución.

Si el revisor de casos límite, con su modelo barato, da por buena la multibola, eso no sustituye a que npm test pase la prueba de n = 200 en una ejecución que cualquiera pueda repetir.

Si escribimos el fichero del agente a mano con la sesión abierta, pasa lo mismo que con la skill y hay que reiniciar con /exit y claude --continue. Los hooks que añadiremos en el paso siguiente, en cambio, se recargan sin salir.

Claude contrasta el informe del subagente revisor con la especificación
El coordinador revisa el informe del revisor y no se lo cree sin más.
Panel de /context: 158.600 de un millón de tokens usados, con un subagente, dos ficheros de memoria y 33 skills cargados
/context enseña qué ocupa la memoria de trabajo de Claude: un subagente (69 tokens), dos ficheros de instrucciones (6.300) y 33 skills (6.100). Casi todo lo demás es la conversación.
Ida y vuelta de turnos 6 a 9: 1 min 37 s de trabajo, 1 herramientas usadas

Turno 6 · 25 s

Ida: lo que escribimos

/agents

Vuelta: lo que contestó Claude

Claude no escribió nada: es una orden que abre un panel.

Turno 7 · 0 s

Ida: lo que escribimos

/agents

Vuelta: lo que contestó Claude

Claude no escribió nada: es una orden que abre un panel.

Turno 8 · 43 s

Ida: lo que escribimos

Pide al subagente revisor-casos-limite que busque casos límite de la multibola y contrasta su informe con docs/especificacion-multibola.md.

Vuelta: lo que contestó Claude

  1. Agent Buscar casos límite de la multibola

He pedido al subagente revisor-casos-limite que revise la multibola a partir de la especificación, el código y las pruebas, sin editar nada. Todavía está trabajando. Cuando entregue su informe, lo compararé con docs/especificacion-multibola.md: qué casos coinciden, cuáles son nuevos y qué contradicciones o ambigüedades señala.

Turno 9 · 29 s

Mensaje que entra solo en la conversación cuando termina el subagente

<task-notification>
<task-id>a31133e80df40b3d6</task-id>
<tool-use-id>toolu_01FYybFDF4fE9Apq7Wfco9rB</tool-use-id>
<output-file>[carpeta temporal de la sesión]</output-file>
<status>completed</status>
<summary>Agent "Buscar casos límite de la multibola" finished</summary>
<note>A task-notification fires each time this agent stops with no live background children of its own. The user can send it another message and resume it, so the same task-id may notify more than once.</note>
<result>Ahora tengo suficiente contexto. Basándome en la especificación ratificada y el código actual sin multibola, aquí están los casos límite no cubiertos:

---

## Casos límite no cubiertos por pruebas de multibola

| Caso | Estado inicial | Acción | Resultado esperado | Requisito | ¿En especificación? |
|------|---|---|---|---|---|
| Triplicación n=0 | 0 bolas activas | Romper ladrillo x3 | n sigue siendo 0 | FR-002 | Sí |
| Triplicación n=1 | 1 bola activa | Romper ladrillo x3 | n = min(3, 200) = 3 | FR-002, FR-001 | Sí |
| Triplicación n=199 | 199 bolas | Romper ladrillo x3 | n = min(597, 200) = 200 | FR-002 | Sí |
| Triplicación n=200 | 200 bolas (tope) | Romper ladrillo x3 | n sigue siendo 200 | FR-002 | Sí |
| Dos ladrillos x3 en un fotograma | 1 bola | Golpea dos x3 simultáneamente | Aplica 1→3, luego 3→9 (si no supera 200) | FR-001, ADR-003 | Sí, parcial |
| Puntuación única, impactos simultáneos | Dos bolas | Golpean mismo ladrillo en fotograma | Suma puntos del ladrillo una sola vez | FR-003 | Sí |
| Determinismo multibola | Misma partida, bolas en orden diferente | Avanzar hasta fin | Puntuación final idéntica | FR-004 | Sí |
| Bonus velocidad (ladrillo x3) | Una bola golpea x3 | Destruir x3 | Suma 50 puntos base + bonus calculado una sola vez | FR-006, FR-007 | Sí, pero fórmula abierta |
| Rebote en impactos simultáneos | Dos bolas golpean mismo ladrillo | Una lo destruye, otra impacta | **Decisión abierta:** ¿rebota o atraviesa? | ADR-003 | No ratificado |
| Derrota con n=0 | Última bola cae | Verificar estado | **Decisión abierta:** ¿pierde al llegar a 0 o solo si antes hay? | — | No ratificado |
| Victoria vs derrota simultánea | Último ladrillo, última bola cae | Mismo fotograma | **Decisión abierta:** ¿prevalece una? | — | No ratificado |

---

## Contradicciones y ambigüedades

1. **FR-005 ausente** (línea 18 esp.): Especificación menciona que no existe; falta confirmar si es intencional o error de numeración.

2. **ADR-001 ausente** (línea 25 esp.): Ningún ADR-001 documentado; arquitectura comienza en ADR-002.

3. **Incompatibilidad código-arquitectura** (ADR-002):
   - Código actual: `state.ball` (singular, sin `id`)
   - Requerido: `state.balls[]` con `id` estable y `nextBallId` para ADR-003
   
4. **Campo `kind` faltante** (Etapa 2 de plan):
   - Código: ladrillos sin `kind`
   - Requerido: `kind: 'normal' | 'x3'` para diferenciar comportamiento

5. **Orden de impactos ambiguo** (línea 75 esp.): No confirma si `y` es posición de bola o ladrillo, ni dirección ("ascendente" = de arriba abajo).

6. **Decisiones abiertas críticas** (líneas 62-76 esp.):
   - Fórmula del bonus por velocidad (bloqueador etapa 4)
   - Dónde nacen las bolas nuevas (pueden nacer dentro de ladrillo/pala)
   - Qué bolas se descartan al recortar hacia 200

---

**Rutas relevantes:**  
- `~/sdd-931/arkanoid/docs/especificacion-multibola.md`  
- `~/sdd-931/arkanoid/src/game.js` (líneas 40–171)  
- `~/sdd-931/arkanoid/tests/game.test.js` (sin pruebas de multibola)</result>
<usage><subagent_tokens>22520</subagent_tokens><tool_uses>6</tool_uses><duration_ms>38523</duration_ms></usage>
</task-notification>

Vuelta: lo que contestó Claude

El informe del subagente no aporta ningún caso que no esté ya en docs/especificacion-multibola.md. Tampoco encuentra ninguna contradicción real. Es más pobre que la tabla de 42 casos que preparé con casos-limite.

Casos. El subagente devuelve 11:

  • Ocho ya estaban en la especificación: n = 0, 1, 199 y 200, dos x3 en el mismo fotograma, la puntuación única, el determinismo y el bonus por velocidad.
  • Los otros tres también estaban: el rebote en impactos simultáneos, la derrota con n = 0 y la victoria y la derrota en el mismo fotograma. La especificación ya los recoge como decisiones abiertas.

Además, se salta los valores intermedios que la especificación sí incluye (2, 50, 66 y 67), con los que se comprueba dónde empieza el recorte.

Imprecisiones del informe:

  • Requisito equivocado en n = 0. Lo justifica con FR-002 (el tope), pero el recuento con n = 0 sale de la fórmula de FR-001.
  • «Parcial» que no lo es. Marca así los dos x3 en un fotograma, pero la especificación lo recoge entero: 1 → 3 → 9 en el orden de ADR-003, sin pasar de 200.
  • Rebote mal atribuido. Lo atribuye a ADR-003, cuando la especificación lo sitúa en FR-003 y en la etapa 3. No cambia nada, pero desorienta al buscarlo.
  • Una pregunta sin sentido claro. En la derrota con n = 0 formula la duda como «¿pierde al llegar a 0 o solo si antes hay?», y no se entiende qué alternativa propone.

Contradicciones. De las seis que señala, ninguna lo es:

  • Las de código (3 y 4). Que el código use state.ball sin id y que los ladrillos no tengan kind es lo esperado. La especificación programa ambos cambios para la etapa 2 y todavía no se ha implementado nada. Además, no cita ninguna línea del código, aunque se lo pedí; solo da un rango amplio (src/game.js, líneas 40–171).
  • Las de la especificación (1, 2, 5 y 6). Son la falta de FR-005 y de ADR-001, la ambigüedad de y en ADR-003 y las decisiones abiertas. Ya están anotadas en el documento, en las líneas que cita (18, 25 y 75, que he comprobado).

Tampoco ve las ambigüedades que sí afectan a la implementación y que salieron en la tabla de casos-limite:

  • Cuántas veces se multiplican las bolas cuando varias golpean el mismo x3: de 2 a 6 o a 18.
  • Si la bola que cae en el mismo fotograma en que se rompe un x3 cuenta para el triple.
  • Qué bolas se conservan al recortar a 200 manteniendo el determinismo.
  • Los desempates por x y por id.

Conclusión. Para preparar la etapa 2 sigue sirviendo la tabla de casos-limite. Este informe confirma que la especificación es coherente consigo misma, pero no la amplía.

Si vas a volver a usar este subagente, su encargo debería pedirle solo los casos que no figuren ya en la especificación, con una línea citada para cada contradicción. Así no repetiría lo que ya está escrito. Si quieres, preparo ese cambio en .claude/agents/.

Salida de cada orden, tal como apareció en la pantalla

Órdenes que lanzó el programa antes, sin captura
$ mkdir -p .claude/agents && cp plantillas/agente/revisor-casos-limite.md .claude/agents/
Dentro de Claude Code: /agents
    x3 en fotogramas seguidos llevan de 1 a 3 y luego a 9. Un x3 roto con 200 bolas sigue dando sus 50 puntos base, sin
    multiplicarlos por el número de bolas.
  - Varias bolas sobre el mismo x3. Es el caso que más cambia el resultado. El ladrillo puntúa una vez por FR-003, pero
    la especificación no dice cuántas veces se multiplican las bolas. Entiendo que una sola (de 2 a 6, no a 18), porque
    el ladrillo solo se rompe una vez, pero conviene que lo confirmes.
  - Desempates de ADR-003. Si dos bolas están en la misma (y, x), decide el menor id; si comparten y, decide el menor x.
    También falta resolver qué pasa cuando una bola toca dos ladrillos a la vez en una esquina. Hoy se rompe uno solo
    por paso, y con la nueva ordenación no está decidido.
  - Identificadores. Las bolas nuevas reciben ids distintos y las originales conservan el suyo. Falta decidir si se
    reutilizan los ids de bolas perdidas.
  - Límites del recuento. Queda por decidir qué pasa si una prueba crea la partida con 201 bolas y qué hace la función
    con un n negativo o no entero.
  - Simultaneidad con caídas. Si una bola cae en el mismo fotograma en que otra rompe un x3, falta decidir si la caída
    cuenta para el triple (9 o 6 bolas). Tampoco está decidido si las bolas recién nacidas ya chocan en ese mismo
    fotograma, ni qué pasa si caen todas a la vez.
  - Determinismo. Llegar al tope desde 67 bolas tiene que dar siempre las mismas 200. Y con otra secuencia de dt (30 fps
    en lugar de 60) FR-004 no exige el mismo resultado, porque las entradas son distintas.
  - Bonus por velocidad. Hay que decidir si es 0 a la velocidad de saque y si tiene un máximo. Las dos cosas dependen de
    la fórmula, que sigue sin definir.
  - El x3 como último ladrillo. Da sus puntos y la victoria, y las bolas que se creen en ese momento no cambian el
    resultado.

  Antes de la etapa 2 conviene confirmar el caso de varias bolas sobre el mismo x3 y decidir qué hacer cuando una bola
  cae en el mismo fotograma en que se rompe un x3. Los dos fijan cuántas bolas hay después de multiplicar, que es justo
  lo que esa etapa implementa.

✻ Crunched for 1m 28s · done 20:29

❯ /agents
  ⎿  The /agents wizard has been removed.

     Ask Claude to create or update subagents for you (e.g. "create a code-reviewer subagent that ..."),
     or edit the files directly:
       • .claude/agents/       (this project)
       • ~/.claude/agents/     (all projects)

     Docs: https://code.claude.com/docs/en/sub-agents
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Reinicio: /exit y después $ claude --continue
    x3 en fotogramas seguidos llevan de 1 a 3 y luego a 9. Un x3 roto con 200 bolas sigue dando sus 50 puntos base, sin
    multiplicarlos por el número de bolas.
  - Varias bolas sobre el mismo x3. Es el caso que más cambia el resultado. El ladrillo puntúa una vez por FR-003, pero
    la especificación no dice cuántas veces se multiplican las bolas. Entiendo que una sola (de 2 a 6, no a 18), porque
    el ladrillo solo se rompe una vez, pero conviene que lo confirmes.
  - Desempates de ADR-003. Si dos bolas están en la misma (y, x), decide el menor id; si comparten y, decide el menor x.
    También falta resolver qué pasa cuando una bola toca dos ladrillos a la vez en una esquina. Hoy se rompe uno solo
    por paso, y con la nueva ordenación no está decidido.
  - Identificadores. Las bolas nuevas reciben ids distintos y las originales conservan el suyo. Falta decidir si se
    reutilizan los ids de bolas perdidas.
  - Límites del recuento. Queda por decidir qué pasa si una prueba crea la partida con 201 bolas y qué hace la función
    con un n negativo o no entero.
  - Simultaneidad con caídas. Si una bola cae en el mismo fotograma en que otra rompe un x3, falta decidir si la caída
    cuenta para el triple (9 o 6 bolas). Tampoco está decidido si las bolas recién nacidas ya chocan en ese mismo
    fotograma, ni qué pasa si caen todas a la vez.
  - Determinismo. Llegar al tope desde 67 bolas tiene que dar siempre las mismas 200. Y con otra secuencia de dt (30 fps
    en lugar de 60) FR-004 no exige el mismo resultado, porque las entradas son distintas.
  - Bonus por velocidad. Hay que decidir si es 0 a la velocidad de saque y si tiene un máximo. Las dos cosas dependen de
    la fórmula, que sigue sin definir.
  - El x3 como último ladrillo. Da sus puntos y la victoria, y las bolas que se creen en ese momento no cambian el
    resultado.

  Antes de la etapa 2 conviene confirmar el caso de varias bolas sobre el mismo x3 y decidir qué hacer cuando una bola
  cae en el mismo fotograma en que se rompe un x3. Los dos fijan cuántas bolas hay después de multiplicar, que es justo
  lo que esa etapa implementa.

✻ Crunched for 1m 28s · done 20:29

❯ /agents
  ⎿  The /agents wizard has been removed.

     Ask Claude to create or update subagents for you (e.g. "create a code-reviewer subagent that ..."),
     or edit the files directly:
       • .claude/agents/       (this project)
       • ~/.claude/agents/     (all projects)

     Docs: https://code.claude.com/docs/en/sub-agents
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Dentro de Claude Code: /agents
  - Límites del recuento. Queda por decidir qué pasa si una prueba crea la partida con 201 bolas y qué hace la función
    con un n negativo o no entero.
  - Simultaneidad con caídas. Si una bola cae en el mismo fotograma en que otra rompe un x3, falta decidir si la caída
    cuenta para el triple (9 o 6 bolas). Tampoco está decidido si las bolas recién nacidas ya chocan en ese mismo
    fotograma, ni qué pasa si caen todas a la vez.
  - Determinismo. Llegar al tope desde 67 bolas tiene que dar siempre las mismas 200. Y con otra secuencia de dt (30 fps
    en lugar de 60) FR-004 no exige el mismo resultado, porque las entradas son distintas.
  - Bonus por velocidad. Hay que decidir si es 0 a la velocidad de saque y si tiene un máximo. Las dos cosas dependen de
    la fórmula, que sigue sin definir.
  - El x3 como último ladrillo. Da sus puntos y la victoria, y las bolas que se creen en ese momento no cambian el
    resultado.

  Antes de la etapa 2 conviene confirmar el caso de varias bolas sobre el mismo x3 y decidir qué hacer cuando una bola
  cae en el mismo fotograma en que se rompe un x3. Los dos fijan cuántas bolas hay después de multiplicar, que es justo
  lo que esa etapa implementa.

✻ Crunched for 1m 28s · done 20:29

❯ /agents
  ⎿  The /agents wizard has been removed.

     Ask Claude to create or update subagents for you (e.g. "create a code-reviewer subagent that ..."),
     or edit the files directly:
       • .claude/agents/       (this project)
       • ~/.claude/agents/     (all projects)

     Docs: https://code.claude.com/docs/en/sub-agents

❯ /agents
  ⎿  The /agents wizard has been removed.

     Ask Claude to create or update subagents for you (e.g. "create a code-reviewer subagent that ..."),
     or edit the files directly:
       • .claude/agents/       (this project)
       • ~/.claude/agents/     (all projects)

     Docs: https://code.claude.com/docs/en/sub-agents
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Pantalla al terminar el turno: «Pide al subagente revisor-casos-limite que busque casos límite de la multibola y contra…»
  Además, se salta los valores intermedios que la especificación sí incluye (2, 50, 66 y 67), con los que se comprueba
  dónde empieza el recorte.

  Imprecisiones del informe:

  - Requisito equivocado en n = 0. Lo justifica con FR-002 (el tope), pero el recuento con n = 0 sale de la fórmula de
    FR-001.
  - «Parcial» que no lo es. Marca así los dos x3 en un fotograma, pero la especificación lo recoge entero: 1 → 3 → 9 en
    el orden de ADR-003, sin pasar de 200.
  - Rebote mal atribuido. Lo atribuye a ADR-003, cuando la especificación lo sitúa en FR-003 y en la etapa 3. No cambia
    nada, pero desorienta al buscarlo.
  - Una pregunta sin sentido claro. En la derrota con n = 0 formula la duda como «¿pierde al llegar a 0 o solo si antes
    hay?», y no se entiende qué alternativa propone.

  Contradicciones. De las seis que señala, ninguna lo es:

  - Las de código (3 y 4). Que el código use state.ball sin id y que los ladrillos no tengan kind es lo esperado. La
    especificación programa ambos cambios para la etapa 2 y todavía no se ha implementado nada. Además, no cita ninguna
    línea del código, aunque se lo pedí; solo da un rango amplio (src/game.js, líneas 40–171).
  - Las de la especificación (1, 2, 5 y 6). Son la falta de FR-005 y de ADR-001, la ambigüedad de y en ADR-003 y las
    decisiones abiertas. Ya están anotadas en el documento, en las líneas que cita (18, 25 y 75, que he comprobado).

  Tampoco ve las ambigüedades que sí afectan a la implementación y que salieron en la tabla de casos-limite:

  - Cuántas veces se multiplican las bolas cuando varias golpean el mismo x3: de 2 a 6 o a 18.
  - Si la bola que cae en el mismo fotograma en que se rompe un x3 cuenta para el triple.
  - Qué bolas se conservan al recortar a 200 manteniendo el determinismo.
  - Los desempates por x y por id.

  Conclusión. Para preparar la etapa 2 sigue sirviendo la tabla de casos-limite. Este informe confirma que la
  especificación es coherente consigo misma, pero no la amplía.

  Si vas a volver a usar este subagente, su encargo debería pedirle solo los casos que no figuren ya en la
  especificación, con una línea citada para cada contradicción. Así no repetiría lo que ya está escrito. Si quieres,
  preparo ese cambio en .claude/agents/.

✻ Cooked for 1m 2s · done 20:31
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯ Sí, prepara ese cambio en el subagente
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · /tasks to see subagents · ← for agents

Paso 10: decir cuándo está terminado (11 en la versión 87a)

/goal fija una condición de terminación: Claude sigue trabajando hasta que otro modelo, leyendo la conversación, juzga que se cumple. Le dimos la del libro: «Termina cuando el juego compile, pasen lint y tests, pueda abrirse en el navegador, se hayan observado los casos de multibola y quede actualizado el README».

Y lo cumplió, pero haciéndolo todo de golpe. Para que el navegador mostrara la multibola tenía que existir la multibola, así que la implementó entera en un turno de nueve minutos: creó src/multiball.js, un script para observar el juego y actualizó el README. Fue honesto con lo que dejaba abierto: tomó decisiones provisionales (por ejemplo, que una bola que cae no cuenta) y avisó de que los casos de 199 y 200 bolas solo los cubren las pruebas, porque en pantalla nunca hubo tantas.

Esta es la diferencia más importante con el libro. La versión 86a ponía /goal antes de construir por incrementos, pero con ese criterio /goal construye todo. Si queremos etapas pequeñas que revisemos una a una, los incrementos tienen que ir antes, y /goal solo comprueba al final. Así queda en la 87a.

Aun así, lo que construyó funciona. Las capturas del juego las tomó el propio Claude con su script de observación: a los 1,2 segundos hay tres bolas y 63 puntos; a los 2,5 segundos ha caído una; a los 9 segundos, sin nadie que mueva la pala, la partida se pierde.

Lo que dice el libro (versión 87a)

11. Comprobar que el trabajo ha terminado. Con los incrementos hechos, fijamos la condición de cierre en la petición o con /goal: “Termina cuando el juego compile, pasen lint y tests, pueda abrirse en el navegador, se hayan observado los casos de multibola y quede actualizado el README”. Con esos criterios revisamos el resultado con las herramientas del proyecto.

Lo dejamos para el final porque el orden cambia lo que hace el agente. En nuestra prueba con Claude Code 2.1.285, este mismo /goal lanzado antes de construir hizo que Claude implementara la multibola entera, el README y la prueba en el navegador en un único turno de unos nueve minutos, sin las etapas revisadas del paso anterior. Al final, con el trabajo hecho por etapas, la condición queda para comprobar que no falta nada.

Con /goal, el modelo que decide si la condición se cumple solo lee la conversación, así que cada criterio tiene que corresponder a una orden cuya salida quede escrita en ella. Si la ejecución es no interactiva, claude -p --max-turns N --max-budget-usd X pone los límites de turnos y de presupuesto (este último es una estimación del coste de API, distinta de la cuota semanal que muestra /usage), y al alcanzarlos revisamos qué se ha completado y qué falta respecto del encargo.

Resumen de Claude tras cumplir el objetivo: multibola implementada, observada en el navegador y README actualizado
«Goal achieved» en 9 minutos y un solo turno.
El juego con una sola bola tras perder las otras dos
Una bola tras perder dos.
Pantalla de derrota con el mensaje Has perdido
Derrota cuando no queda ninguna bola.
Ida y vuelta de el turno 10: 9 min 6 s de trabajo, 47 herramientas usadas

Turno 10 · 9 min 6 s

Ida: lo que escribimos

/goal Termina cuando el juego compile, pasen lint y tests, pueda abrirse en el navegador, se hayan observado los casos de multibola y quede actualizado el README

Vuelta: lo que contestó Claude

Objetivo recibido. Implemento las cuatro etapas de la multibola. Las decisiones que siguen abiertas las resuelvo con valores provisionales: quedan anotadas en la especificación como pendientes de ratificar y te las enumeraré al terminar. Empiezo por la etapa 1, el recuento.

  1. Write ~/sdd-931/arkanoid/src/multiball.js

Ahora game.js pasa de una sola bola a una lista balls (ADR-002) y resuelve los impactos en el orden de (y, x, id) (ADR-003).

  1. Write ~/sdd-931/arkanoid/src/game.js

Ahora actualizo main.js. Dibuja todas las bolas, marca los ladrillos x3 y añade un escenario ?escenario=multibola para observar la multibola en el navegador sin tener que acertar al x3 jugando.

  1. Edit ~/sdd-931/arkanoid/src/main.js
  2. Edit ~/sdd-931/arkanoid/src/main.js
  3. Edit ~/sdd-931/arkanoid/src/main.js

Migro las pruebas existentes de state.ball a state.balls.

  1. Bash git diff --stat HEAD -- tests && ls tests && grep -n "state.ball\b\|state\.ball\.\|ball\.r\|bricks.reduce" tests/game.test.js
  2. Bash sed -i '' 's/state\.ball\b/state.balls[0]/g; s/state\.ball\./state.balls[0]./g; s/state\.ball,/state.balls[0],/g' tests/game.test.js && grep -c "state.balls\[0\]" tests/game.test.js && sed -n 125,145p tests/game.test.js
  3. Read ~/sdd-931/arkanoid/tests/game.test.js
  4. Edit ~/sdd-931/arkanoid/tests/game.test.js
  5. Edit ~/sdd-931/arkanoid/tests/game.test.js
  6. Bash npm test 2>&1 | grep -E "^✖|ℹ (pass|fail)|expected|actual|Error" | head -20

Sobra un punto porque la velocidad de la bola acumula error de coma flotante: 259,9999 entre 20 da 12 con Math.floor. Redondeo al entero más próximo, que es más estable.

  1. Edit ~/sdd-931/arkanoid/src/game.js
  2. Bash npm test 2>&1 | grep -E "^✖|ℹ (pass|fail)|expected|actual|Error" | head -20

La migración ya pasa. Ahora escribo las pruebas de la multibola siguiendo la tabla de casos límite.

  1. Write ~/sdd-931/arkanoid/tests/multiball.test.js
  2. Edit ~/sdd-931/arkanoid/tests/multiball.test.js
  3. Edit ~/sdd-931/arkanoid/tests/multiball.test.js
  4. Bash sed -i '' "s/import { createGame, update, speedBonus, TRIPLE_BRICK_POINTS } from '..\/src\/game.js';/import { createGame, update, speedBonus, compareImpacts, TRIPLE_BRICK_POINTS } from '..\/src\/game.js';/" tests/multiball.test.js && sed -i '' 's/^function compareImpacts(a, b) {/export function compareImpacts(a, b) {/' src/game.js && grep -n "compareImpacts" src/game.js tests/multiball.test.js | h

Las 37 pruebas pasan. Paso a lint y a la compilación de producción.

  1. Bash npm run lint 2>&1 | tail -8; npm run build 2>&1 | tail -4

Lint y build pasan sin errores. Ahora toca abrir el juego en un navegador real. Arranco Vite en segundo plano y compruebo si hay Chrome para hacer capturas sin ventana.

  1. Bash rm -rf dist && ls -d "/Applications/Google Chrome.app" 2>&1; npx vite --port 5179 --strictPort > [carpeta temporal de la sesión] 2>&1 & for i in 1 2 3 4 5 6 7 8 9 10; do curl -s -o /dev/null -w "%{http_code}\n" http://localhost:5179/ && break; sleep 0.5; done; curl -s http://localhost:5179/src/main.js | head -3
  2. Bash S=[carpeta temporal de la sesión] C="/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"; "$C" --headless=new --disable-gpu --hide-scrollbars --window-size=560,440 --user-data-dir=$S/chrome1 --virtual-time-budget=1500 --screenshot=$S/inicio.png "http://localhost:5179/" 2>&1 | tail -1 "$C" --headless=new --disable-
  3. Read [carpeta temporal de la sesión]
  4. Read [carpeta temporal de la sesión]
  5. Edit ~/sdd-931/arkanoid/src/main.js
  6. Bash S=[carpeta temporal de la sesión] C="/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"; rm -rf $S/chrome2 $S/chrome3 "$C" --headless=new --disable-gpu --hide-scrollbars --window-size=560,440 --user-data-dir=$S/chrome2 --virtual-time-budget=6000 --screenshot=$S/multibola.png "http://localhost:5179/?escenario=multi
  7. Read [carpeta temporal de la sesión]
  8. Read [carpeta temporal de la sesión]
  9. Write [carpeta temporal de la sesión]
  10. Bash S=[carpeta temporal de la sesión] node $S/observar.mjs "http://localhost:5179/?escenario=multibola" $S/mb 300 1200 2500 2>&1 | tail -4

Estoy observando la multibola en un Chrome real: tengo las capturas de tres momentos y las reviso ahora.

  1. Read [carpeta temporal de la sesión]
  2. Read [carpeta temporal de la sesión]
  3. Bash S=[carpeta temporal de la sesión] rm -rf $S/mb-profile; node $S/observar.mjs "http://localhost:5179/?escenario=multibola" $S/mb 9000 2>&1 | tail -1
  4. Read [carpeta temporal de la sesión]
  5. Bash pkill -f "vite --port 5179"; S=[carpeta temporal de la sesión] mkdir -p docs/evidencias scripts && cp $S/inicio.png docs/evidencias/multibola-0-inicio.png && cp $S/mb-1200.png docs/evidencias/multibola-1-x3-roto.png && cp $S/mb-2500.png docs/evidencias/multibola-2-una-bola.png && cp $S/mb-9000.png docs/evidencias/multibola-3
  6. Edit ~/sdd-931/arkanoid/eslint.config.js
  7. Edit ~/sdd-931/arkanoid/scripts/observar.mjs
  8. Bash npm run lint 2>&1 | tail -6

Lint sigue limpio. Ahora el README.

  1. Read ~/sdd-931/arkanoid/README.md
  2. Write ~/sdd-931/arkanoid/README.md

Ahora actualizo la especificación. Las decisiones abiertas pasan a ser provisionales: están implementadas, pero pendientes de que las ratifiques. También añado lo observado en el navegador.

  1. Read ~/sdd-931/arkanoid/docs/especificacion-multibola.md
  2. Edit ~/sdd-931/arkanoid/docs/especificacion-multibola.md
  3. Edit ~/sdd-931/arkanoid/docs/especificacion-multibola.md
  4. Edit ~/sdd-931/arkanoid/docs/especificacion-multibola.md
  5. Bash grep -n "Punto de partida" docs/especificacion-multibola.md
  6. Edit ~/sdd-931/arkanoid/docs/especificacion-multibola.md
  7. Edit ~/sdd-931/arkanoid/CLAUDE.md
  8. Edit ~/sdd-931/arkanoid/CLAUDE.md
  9. Bash npm run lint 2>&1 | tail -3 && npm test 2>&1 | grep -E "ℹ (tests|pass|fail)" && npm run build 2>&1 | grep -E "built|error" ; rm -rf dist; git status --short

La multibola está implementada y se cumple todo lo que pedía el objetivo:

  • Compila: npm run build termina sin errores.
  • Lint y pruebas: npm run lint no da avisos y pasan las 37 pruebas (13 del juego base y 24 de la multibola).
  • Navegador: el juego se abre en Chrome y lo he visto funcionar.
  • README: está actualizado.

Hay una cosa que debes revisar. Habías dicho que pedirías la implementación por etapas, y el objetivo exigía terminarla sin parar a preguntar, así que hice las cuatro etapas seguidas. Las decisiones que la especificación dejaba abiertas las resolví con valores provisionales. Cada una está anotada en docs/especificacion-multibola.md con el lugar del código donde vive. Estas son las que más cambian el juego:

  • Bonus por velocidad: Math.round(v / 20), que da 13 puntos a la velocidad normal, y solo en los ladrillos x3. Ahora mismo la bola nunca cambia de velocidad, así que en la práctica el bonus siempre vale 13.
  • Varias bolas sobre el mismo x3: el ladrillo se rompe una vez y multiplica una vez (de 2 bolas a 6). Todas las bolas que lo tocan rebotan.
  • Bola que cae en el mismo paso en que se rompe un x3: no cuenta para el triple (de 3 bolas a 6).
  • Recorte a 200: se conservan todas las originales y se añaden copias por orden de id. Los ids nunca se reutilizan.
  • Derrota: la partida se pierde cuando no queda ninguna bola, y la victoria se comprueba antes que la derrota.

En src/game.js, el estado pasa a tener balls y los impactos se resuelven en el orden de (y, x, id). Las reglas puras de la multibola están en un fichero nuevo, src/multiball.js. Hay dos ladrillos x3 en el tablero, marcados en amarillo.

Lo observado en el navegador. Las capturas de Chrome sin ventana no avanzan la animación, así que escribí scripts/observar.mjs: controla Chrome, espera tiempo real y hace capturas en los momentos que se le indiquen. Con ?escenario=multibola vi tres cosas:

  • A 1,2 s: el x3 roto, 3 bolas y 63 puntos.
  • A 2,5 s: sin mover la pala se han perdido dos bolas y la partida sigue con una.
  • A 9 s: 0 bolas y el mensaje «Has perdido».

Las capturas están en docs/evidencias/ y se citan en la especificación. Los casos de 199 y 200 bolas, los impactos simultáneos y el recorte al tope solo los he comprobado con pruebas, no en el navegador.

Documentación. El README conserva tu frase inicial y añade cómo se juega, la multibola, el escenario de observación, las órdenes y la estructura. CLAUDE.md deja de decir «No hay multibola» y describe el orden de cada paso corto, del que dependen varias reglas de la especificación.

No he hecho ningún commit. Las pruebas de la multibola son normales; ninguna está ratificada como *.ratificada.test.js. Cuando ratifiques o cambies las decisiones provisionales, decide cuáles de esas pruebas pasan a serlo.

Salida de cada orden, tal como apareció en la pantalla

Pantalla al terminar el turno: «/goal Termina cuando el juego compile, pasen lint y tests, pueda abrirse en el navegado…»
  terminarla sin parar a preguntar, así que hice las cuatro etapas seguidas. Las decisiones que la especificación dejaba
  abiertas las resolví con valores provisionales. Cada una está anotada en docs/especificacion-multibola.md con el
  lugar del código donde vive. Estas son las que más cambian el juego:

  - Bonus por velocidad: Math.round(v / 20), que da 13 puntos a la velocidad normal, y solo en los ladrillos x3. Ahora
    mismo la bola nunca cambia de velocidad, así que en la práctica el bonus siempre vale 13.
  - Varias bolas sobre el mismo x3: el ladrillo se rompe una vez y multiplica una vez (de 2 bolas a 6). Todas las bolas
    que lo tocan rebotan.
  - Bola que cae en el mismo paso en que se rompe un x3: no cuenta para el triple (de 3 bolas a 6).
  - Recorte a 200: se conservan todas las originales y se añaden copias por orden de id. Los ids nunca se reutilizan.
  - Derrota: la partida se pierde cuando no queda ninguna bola, y la victoria se comprueba antes que la derrota.

  En src/game.js, el estado pasa a tener balls y los impactos se resuelven en el orden de (y, x, id). Las reglas puras
  de la multibola están en un fichero nuevo, src/multiball.js. Hay dos ladrillos x3 en el tablero, marcados en amarillo.

  Lo observado en el navegador. Las capturas de Chrome sin ventana no avanzan la animación, así que escribí
  scripts/observar.mjs: controla Chrome, espera tiempo real y hace capturas en los momentos que se le indiquen. Con
  ?escenario=multibola vi tres cosas:

  - A 1,2 s: el x3 roto, 3 bolas y 63 puntos.
  - A 2,5 s: sin mover la pala se han perdido dos bolas y la partida sigue con una.
  - A 9 s: 0 bolas y el mensaje «Has perdido».

  Las capturas están en docs/evidencias/ y se citan en la especificación. Los casos de 199 y 200 bolas, los impactos
  simultáneos y el recorte al tope solo los he comprobado con pruebas, no en el navegador.

  Documentación. El README conserva tu frase inicial y añade cómo se juega, la multibola, el escenario de observación,
  las órdenes y la estructura. CLAUDE.md deja de decir «No hay multibola» y describe el orden de cada paso corto, del
  que dependen varias reglas de la especificación.

  No he hecho ningún commit. Las pruebas de la multibola son normales; ninguna está ratificada como
  *.ratificada.test.js. Cuando ratifiques o cambies las decisiones provisionales, decide cuáles de esas pruebas pasan a
  serlo.

✔ Goal achieved (9m · 1 turn · 38.2k tokens)

✻ Cooked for 5m 31s · done 20:40
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Los 12 menús de este paso, tal como aparecieron

Menú de permiso · 051

  12     throw new RangeError(`Número de bolas no válido: ${n}`);
  13   }
  14   return Math.min(3 * n, MAX_BALLS);
  15 }
  16
  17 function rotate(vx, vy, angle) {
  18   const cos = Math.cos(angle);
  19   const sin = Math.sin(angle);
  20   let rx = vx * cos - vy * sin;
  21   let ry = vx * sin + vy * cos;
  22   const speed = Math.hypot(vx, vy);
  23   const minVy = speed * MIN_VERTICAL;
  24   if (Math.abs(ry) < minVy) {
  25     ry = (ry < 0 || (ry === 0 && vy < 0) ? -1 : 1) * minVy;
  26     rx = (rx < 0 ? -1 : 1) * Math.sqrt(speed * speed - ry * ry);
  27   }
  28   return { vx: rx, vy: ry };
  29 }
  30
  31 // Devuelve la nueva lista de bolas tras triplicar las activas, ordenada por id.
  32 // Las originales se conservan; las copias se añaden por orden de id de su original
  33 // y se descartan las que superen MAX_BALLS. nextId da el primer id libre.
  34 export function tripleBalls(balls, nextId) {
  35   const originals = [...balls].sort((a, b) => a.id - b.id);
  36   const total = tripledBallCount(originals.length);
  37   const result = [...originals];
  38   let id = nextId;
  39   for (const ball of originals) {
  40     for (const angle of [-SPLIT_ANGLE, SPLIT_ANGLE]) {
  41       if (result.length >= total) break;
  42       result.push({ ...ball, ...rotate(ball.vx, ball.vy, angle), id: id++ });
  43     }
  44   }
  45   return { balls: result, nextId: id };
  46 }
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to create multiball.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 052

  158 -  // Rebota en el eje de menor penetración: lateral invierte vx, superior o inferior invierte vy.
  208 +  let triples = 0;
  209 +  for (const { ball, brick } of impacts) {
  210 +    if (brick.alive) {
  211 +      brick.alive = false;
  212 +      state.score += brick.points;
  213 +      if (brick.kind === 'x3') {
  214 +        state.score += speedBonus(Math.hypot(ball.vx, ball.vy));
  215 +        triples++;
  216 +      }
  217 +    }
  218 +    bounceOffBrick(ball, brick);
  219 +  }
  220 +
  221 +  for (let i = 0; i < triples; i++) {
  222 +    const result = tripleBalls(state.balls, state.nextBallId);
  223 +    state.balls = result.balls;
  224 +    state.nextBallId = result.nextId;
  225 +  }
  226 +}
  227 +
  228 +// Rebota en el eje de menor penetración: lateral invierte vx, superior o inferior invierte vy.
  229 +function bounceOffBrick(ball, brick) {
  230    const overlapX = Math.min(ball.x + ball.r - brick.x, brick.x + brick.w - (ball.x - ball.r));
  231    const overlapY = Math.min(ball.y + ball.r - brick.y, brick.y + brick.h - (ball.y - ball.r));
  232    if (overlapX < overlapY) {
 ...
  234    } else {
  235      ball.vy = ball.y < brick.y + brick.h / 2 ? -Math.abs(ball.vy) : Math.abs(ball.vy);
  236    }
  166 -
  167 -  if (state.bricks.every((b) => !b.alive)) {
  168 -    state.status = 'won';
  169 -  }
  237  }
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to overwrite game.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 053

⏺ Update(src/main.js)

⏺ Update(src/main.js)

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 src/main.js
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
  5  const ctx = canvas.getContext('2d');
  6  const rowColors = ['#c5783e', '#80619d', '#3768a4', '#4a825b', '#5a8fa8'];
  7
  8 -let state = createGame({ width: canvas.width, height: canvas.height });
  8 +// Con ?escenario=multibola la bola sale ya lanzada hacia el primer ladrillo x3,
  9 +// para observar la multibola sin tener que acertarle jugando.
 10 +const scenario = new URLSearchParams(window.location.search).get('escenario');
 11 +
 12 +function newGame() {
 13 +  const game = createGame({ width: canvas.width, height: canvas.height });
 14 +  if (scenario === 'multibola') {
 15 +    const target = game.bricks.find((b) => b.kind === 'x3');
 16 +    const ball = game.balls[0];
 17 +    ball.x = target.x + target.w / 2;
 18 +    ball.y = game.paddle.y - 40;
 19 +    ball.vx = 0;
 20 +    ball.vy = -game.config.ballSpeed;
 21 +    game.status = 'playing';
 22 +  }
 23 +  return game;
 24 +}
 25 +
 26 +let state = newGame();
 27  const keys = { left: false, right: false, launch: false };
 28
 29  const keyMap = {
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to main.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 054

      12 +function newGame() {
      13 +  const game = createGame({ width: canvas.width, height: canvas.height });
      14 +  if (scenario === 'multibola') {
      15 +    const target = game.bricks.find((b) => b.kind === 'x3');
      16 +    const ball = game.balls[0];
      17 +    ball.x = target.x + target.w / 2;
      18 +    ball.y = game.paddle.y - 40;
      19 +    ball.vx = 0;
      20 +    ball.vy = -game.config.ballSpeed;
      21 +    game.status = 'playing';
      22 +  }
      23 +  return game;
      24 +}
      25 +
      26 +let state = newGame();
      27  const keys = { left: false, right: false, launch: false };
      28
      29  const keyMap = {

⏺ Update(src/main.js)

⏺ Update(src/main.js)

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 src/main.js
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 39    if (!action) return;
 40    event.preventDefault();
 41    if (action === 'launch' && (state.status === 'won' || state.status === 'lost')) {
 42 -    state = createGame({ width: canvas.width, height: canvas.height });
 42 +    state = newGame();
 43      return;
 44    }
 45    keys[action] = true;
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to main.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 055

  70 +    if (brick.kind === 'x3') {
  71 +      ctx.fillStyle = '#f2c14e';
  72 +      ctx.fillRect(brick.x, brick.y, brick.w, brick.h);
  73 +      ctx.fillStyle = '#101820';
  74 +      ctx.textAlign = 'center';
  75 +      ctx.font = 'bold 12px system-ui, sans-serif';
  76 +      ctx.fillText('x3', brick.x + brick.w / 2, brick.y + brick.h - 4);
  77 +    } else {
  78 +      ctx.fillStyle = rowColors[brick.row % rowColors.length];
  79 +      ctx.fillRect(brick.x, brick.y, brick.w, brick.h);
  80 +    }
  81    }
  82
  74 -  const { paddle, ball } = state;
  83 +  const { paddle } = state;
  84    ctx.fillStyle = '#e8edf2';
  85    ctx.fillRect(paddle.x, paddle.y, paddle.w, paddle.h);
  86
  78 -  ctx.beginPath();
  79 -  ctx.arc(ball.x, ball.y, ball.r, 0, Math.PI * 2);
  80 -  ctx.fill();
  87 +  for (const ball of state.balls) {
  88 +    ctx.beginPath();
  89 +    ctx.arc(ball.x, ball.y, ball.r, 0, Math.PI * 2);
  90 +    ctx.fill();
  91 +  }
  92
  93    ctx.textAlign = 'left';
  94    ctx.font = '16px system-ui, sans-serif';
  95    ctx.fillText(`Puntos: ${state.score}`, 12, 24);
  96 +  ctx.textAlign = 'right';
  97 +  ctx.fillText(`Bolas: ${state.balls.length}`, canvas.width - 12, 24);
  98
  99    if (state.status === 'ready') drawMessage('Pulsa espacio', '← → o A D para mover la pala');
 100    if (state.status === 'won') drawMessage('¡Has ganado!', 'Espacio para jugar otra vez');
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to main.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 056

       85    ctx.fillRect(paddle.x, paddle.y, paddle.w, paddle.h);
       86
       78 -  ctx.beginPath();
       79 -  ctx.arc(ball.x, ball.y, ball.r, 0, Math.PI * 2);
       80 -  ctx.fill();
       87 +  for (const ball of state.balls) {
       88 +    ctx.beginPath();
       89 +    ctx.arc(ball.x, ball.y, ball.r, 0, Math.PI * 2);
       90 +    ctx.fill();
       91 +  }
       92
       93    ctx.textAlign = 'left';
       94    ctx.font = '16px system-ui, sans-serif';
       95    ctx.fillText(`Puntos: ${state.score}`, 12, 24);
       96 +  ctx.textAlign = 'right';
       97 +  ctx.fillText(`Bolas: ${state.balls.length}`, canvas.width - 12, 24);
       98
       99    if (state.status === 'ready') drawMessage('Pulsa espacio', '← → o A D para mover la pala');
      100    if (state.status === 'won') drawMessage('¡Has ganado!', 'Espacio para jugar otra vez');

⏺ Migro las pruebas existentes de state.ball a state.balls.

⏺ Replace single-ball references in tests and show simulation test
  ⎿  $ sed -i '' 's/state\.ball\b/state.balls[0]/g; s/state\.ball\./state.balls[0]./g; s/state\.ball,/state.balls[0],/g'
     tests/game.test.js && grep -c "state.balls\[0\]" tests/game.test.js && sed -n 125,145p tests/game.test.js

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ sed -i '' 's/state\.ball\b/state.balls[0]/g; s/state\.ball\./state.balls[0]./g;
   │ s/state\.ball,/state.balls[0],/g' tests/game.test.js && grep -c "state.balls\[0\]" tests/game.test.js && sed -n
   │ 125,145p tests/game.test.js
   Replace single-ball references in tests and show simulation test

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and always allow access to ~/sdd-931/arkanoid/tests from this project
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 057

  Read 1 file, ran 2 shell commands

⏺ Update(tests/game.test.js)

⏺ Update(tests/game.test.js)

⏺ Running tests after migration
  ⎿  $ npm test 2>&1 | grep -E "^✖|ℹ (pass|fail)|expected|actual|Error" | head -20

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 tests/game.test.js
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 132    update(state, DT, { launch: true });
 133    let previous = 0;
 134    for (let i = 0; i < 60 * 120 && state.status === 'playing'; i++) {
 135 -    // La pala persigue la bola y cambia cada dos segundos el punto de impacto para
 136 -    // variar el ángulo; así la bola alcanza todos los ladrillos y se acaba ganando.
 135 +    // La pala persigue la bola que baja más abajo y cambia cada dos segundos el punto
 136 +    // de impacto para variar el ángulo; así se alcanzan todos los ladrillos y se gana.
 137 +    const target = lowestFallingBall(state);
 138      const aim = ((Math.floor(i / 120) % 5) - 2) * 12;
 139      const center = state.paddle.x + state.paddle.w / 2 + aim;
 139 -    update(state, DT, { left: state.balls[0].x < center - 4, right: state.balls[0].x > center + 4 });
 140 +    update(state, DT, { left: target.x < center - 4, right: target.x > center + 4 });
 141      assert.ok(state.score >= previous);
 142      previous = state.score;
 143    }
 144    assert.equal(state.status, 'won');
 144 -  assert.equal(state.score, state.bricks.reduce((sum, b) => sum + b.points, 0));
 145 +  // Los dos x3 del tablero suman, además, su bonus por velocidad.
 146 +  const bonus = 2 * speedBonus(state.config.ballSpeed);
 147 +  assert.equal(state.score, state.bricks.reduce((sum, b) => sum + b.points, 0) + bonus);
 148  });
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to game.test.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 058

      140 +    update(state, DT, { left: target.x < center - 4, right: target.x > center + 4 });
      141      assert.ok(state.score >= previous);
      142      previous = state.score;
      143    }
      144    assert.equal(state.status, 'won');
      144 -  assert.equal(state.score, state.bricks.reduce((sum, b) => sum + b.points, 0));
      145 +  // Los dos x3 del tablero suman, además, su bonus por velocidad.
      146 +  const bonus = 2 * speedBonus(state.config.ballSpeed);
      147 +  assert.equal(state.score, state.bricks.reduce((sum, b) => sum + b.points, 0) + bonus);
      148  });

⏺ Update(tests/game.test.js)

  Running tests after migration
  ⎿  $ npm test 2>&1 | grep -E "^✖|ℹ (pass|fail)|expected|actual|Error" | head -20

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 tests/game.test.js
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
  1  import { test } from 'node:test';
  2  import assert from 'node:assert/strict';
  3 -import { createGame, createBricks, update, DEFAULTS } from '../src/game.js';
  3 +import { createGame, createBricks, update, speedBonus, DEFAULTS } from '../src/game.js';
  4
  5  const DT = 1 / 60;
  6
  7 +function lowestFallingBall(state) {
  8 +  const falling = state.balls.filter((b) => b.vy > 0);
  9 +  const candidates = falling.length > 0 ? falling : state.balls;
 10 +  return candidates.reduce((low, b) => (b.y > low.y ? b : low));
 11 +}
 12 +
 13  function brick(x, y, points = 10) {
 14    return { x, y, w: 40, h: 16, row: 0, points, alive: true };
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to game.test.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 059

       6
       7 +function lowestFallingBall(state) {
       8 +  const falling = state.balls.filter((b) => b.vy > 0);
       9 +  const candidates = falling.length > 0 ? falling : state.balls;
      10 +  return candidates.reduce((low, b) => (b.y > low.y ? b : low));
      11 +}
      12 +
      13  function brick(x, y, points = 10) {
      14    return { x, y, w: 40, h: 16, row: 0, points, alive: true };
      15  }

  Ran 1 shell command

⏺ Sobra un punto porque la velocidad de la bola acumula error de coma flotante: 259,9999 entre 20 da 12 con Math.floor.
  Redondeo al entero más próximo, que es más estable.

⏺ Update(src/game.js)

⏺ Rerunning tests
  ⎿  $ npm test 2>&1 | grep -E "^✖|ℹ (pass|fail)|expected|actual|Error" | head -20

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 src/game.js
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 24  export const TRIPLE_BRICK_POINTS = 50;
 25
 26  // FR-007: bonus por velocidad del ladrillo x3, calculado con la bola que lo destruye.
 27 +// Se redondea, no se trunca, porque los rebotes dejan la velocidad en 259,9999… en vez de 260.
 28  export function speedBonus(speed) {
 28 -  return Math.floor(speed / 20);
 29 +  return Math.round(speed / 20);
 30  }
 31
 32  export function createBricks(config) {
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to game.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 060

  200   const c = simulate(balls.map((b) => ({ ...b })).reverse());
  201   assert.ok(a.score > 0);
  202   assert.equal(a.score, b.score);
  203   assert.equal(a.score, c.score);
  204   assert.deepEqual(a.balls, c.balls);
  205 });
  206
  207 // Fin de partida con varias bolas
  208
  209 test('perder una bola de varias no termina la partida', () => {
  210   const state = playing({ bricks: [], balls: [ballUnder(0, { x: 400, y: 250 }), { id: 1, x: 50, y: 363, vx: 0,
      vy: 300 }] });
  211   update(state, DT);
  212   assert.equal(state.status, 'playing');
  213   assert.equal(state.balls.length, 1);
  214 });
  215
  216 test('si caen todas las bolas a la vez se pierde la partida', () => {
  217   const falling = [0, 1, 2].map((id) => ({ id, x: 50 + id * 20, y: 363, vx: 0, vy: 300 }));
  218   const state = playing({ bricks: [], balls: falling });
  219   update(state, DT);
  220   assert.equal(state.status, 'lost');
  221   assert.equal(state.balls.length, 0);
  222 });
  223
  224 test('si el último ladrillo se rompe cuando cae la última bola, gana la victoria', () => {
  225   const last = brick(200, 100, 'x3');
  226   const state = createGame({ bricks: [last], balls: [ballUnder(0)] });
  227   state.status = 'playing';
  228   // La bola rompe el ladrillo y, en el mismo paso, otra cae: queda la que rebota.
  229   state.balls.push({ id: 1, x: 50, y: 363, vx: 0, vy: 300 });
  230   update(state, DT);
  231   assert.equal(state.status, 'won');
  232   assert.equal(state.score, X3_SCORE);
  233 });
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to create multiball.test.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 061

 160 -  // Tras moverse, la de id 7 queda más arriba; se igualan las posiciones antes del impacto.
 161 -  const tie = playing({
 162 -    bricks: [brick(200, 100, 'x3')],
 163 -    balls: [ballUnder(7, { y: 121, vy: -60 }), ballUnder(4, { y: 121, vy: -30 })],
 164 -  });
 165 -  update(tie, DT / 1000);
 166 -  assert.equal(tie.score, TRIPLE_BRICK_POINTS + speedBonus(30));
 167 -  // Sin empate gana la de menor y: la de id 7, más rápida, llega más arriba.
 161    assert.equal(state.score, TRIPLE_BRICK_POINTS + speedBonus(340));
 162 +  assert.notEqual(speedBonus(340), speedBonus(200));
 163  });
 164
 165  test('con la misma y, el bonus usa la velocidad de la bola de menor x', () => {
 166 +  // Las dos suben igual; la de id 1 avanza hacia la derecha pero sigue a la izquierda de la otra.
 167    const state = playing({
 168      bricks: [brick(200, 100, 'x3')],
 174 -    balls: [ballUnder(0, { x: 230, y: 121, vy: -60 }), ballUnder(1, { x: 210, y: 121, vy: -60, vx: 1 })],
 169 +    balls: [ballUnder(0, { x: 230 }), ballUnder(1, { x: 210, vx: 100 })],
 170    });
 176 -  update(state, DT / 1000);
 177 -  assert.equal(state.score, TRIPLE_BRICK_POINTS + speedBonus(Math.hypot(1, 60)));
 178 -  assert.notEqual(speedBonus(Math.hypot(1, 60)), undefined);
 171 +  update(state, DT);
 172 +  assert.equal(state.score, TRIPLE_BRICK_POINTS + speedBonus(Math.hypot(100, 200)));
 173 +  assert.notEqual(speedBonus(Math.hypot(100, 200)), speedBonus(200));
 174  });
 175
 176 +test('con la misma y y la misma x, el impacto de menor id va primero', () => {
 177 +  const at = (id) => ({ ball: { id, x: 220, y: 120 } });
 178 +  const order = [at(7), at(4), at(5)].sort(compareImpacts).map((i) => i.ball.id);
 179 +  assert.deepEqual(order, [4, 5, 7]);
 180 +});
 181 +
 182  // Determinismo (FR-004)
 183
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to multiball.test.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 062

      179 +  assert.deepEqual(order, [4, 5, 7]);
      180 +});
      181 +
      182  // Determinismo (FR-004)
      183
      184  function simulate(balls) {

⏺ Update(tests/multiball.test.js)

⏺ Exporting the impact comparator and running tests
  ⎿  $ sed -i '' "s/import { createGame, update, speedBonus, TRIPLE_BRICK_POINTS } from '..\/src\/game.js';/import {
     createGame, update, speedBonus, compareImpacts, TRIPLE_BRICK_POINTS } from '..\/src\/game.js';/"
     tests/multiball.test.js && sed -i '' 's/^function compareImpacts(a, b) {/export function c…

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 tests/multiball.test.js
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 222    assert.equal(state.balls.length, 0);
 223  });
 224
 225 -test('si el último ladrillo se rompe cuando cae la última bola, gana la victoria', () => {
 225 +test('si se rompe el último ladrillo mientras cae otra bola, se gana', () => {
 226    const last = brick(200, 100, 'x3');
 227 -  const state = createGame({ bricks: [last], balls: [ballUnder(0)] });
 227 +  const state = createGame({
 228 +    bricks: [last],
 229 +    balls: [ballUnder(0), { id: 1, x: 50, y: 363, vx: 0, vy: 300 }],
 230 +  });
 231    state.status = 'playing';
 229 -  // La bola rompe el ladrillo y, en el mismo paso, otra cae: queda la que rebota.
 230 -  state.balls.push({ id: 1, x: 50, y: 363, vx: 0, vy: 300 });
 232    update(state, DT);
 233    assert.equal(state.status, 'won');
 234    assert.equal(state.score, X3_SCORE);
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to multiball.test.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Paso 11: incrementos, hooks y lo que no se debe poder hacer (10 en la versión 87a)

Antes de las etapas activamos un hook PreToolUse, que se ejecuta antes de cada edición y la bloquea (devolviendo el código de salida 2) si toca una prueba ratificada. A diferencia de skills y subagentes, el hook apareció en /hooks sin reiniciar.

Después pedimos las cuatro etapas del plan, cada una con «dime qué ficheros cambiarán», y tras cada propuesta contestamos «De acuerdo, adelante con esta etapa». Como /goal ya lo había hecho todo, Claude contestó en cada una que estaba hecha y se limitó a ordenar las pruebas en ficheros propios. Nos ofreció dos caminos: ratificar lo que había o rehacer la etapa empezando por la prueba.

La parte de este paso que sí salió como en el libro fueron los ensayos de protección. Ratificamos la prueba del tope de 200 bolas y le pedimos dos veces que la cambiara para bajar el tope a 150. Primero con su herramienta de edición: se negó, citó la regla de permisos, el hook y CLAUDE.md, y explicó que retirar una prueba ratificada le toca a la persona. Luego intentamos el atajo de hacer el mismo cambio con sed desde la terminal, una vía que un hook sobre Edit no vigila. Claude tampoco quiso, y su explicación es la mejor frase del recorrido: la regla protege el fichero, no la herramienta.

Que Claude se niegue está bien, pero el libro insiste en no depender de eso: el hook tiene que cubrir todas las vías de escritura y, si la restricción debe mantenerse pase lo que pase, hacen falta permisos del sistema o del sandbox. Por último, le dijimos que descartábamos el cambio a 150 y le pedimos publicar con git push. La regla de permisos lo denegó y Claude dijo que no buscaría otra forma de publicar.

Lo que dice el libro (versión 87a)

10. Construir por incrementos pequeños. Pedimos la multibola por partes, en el orden del plan por ficheros: el recuento de bolas con el caso n = 0, la aparición de bolas nuevas hasta el tope de 200, la puntuación única por ladrillo cuando dos bolas lo golpean a la vez y, al final, el multiplicador y la bonificación de velocidad.

Antes de cada edición revisamos qué archivos cambiarán y qué prueba se añadirá, así que cada etapa deja un diff corto que podemos entender y comprobar.

Un hook PostToolUse puede ejecutar las pruebas rápidas después de cada edición y devolver los fallos enseguida, otro PreToolUse puede impedir que se edite una prueba protegida y /hooks muestra los que están activos.

Si el agente intenta modificar la prueba del máximo de 200 bolas para que pase, el hook PreToolUse rechaza la edición. Y aunque todas las pruebas salgan en verde, quien decide si el cambio entra en la rama principal es la CI, con la rama protegida.

El hook debe cubrir todas las herramientas con las que se puede escribir en esas rutas; bloquear Edit no impide que una orden de terminal o un servidor MCP cambie el mismo fichero.

Ensayamos esas vías y aplicamos permisos del sistema o del sandbox cuando la restricción deba mantenerse fuera de las decisiones del modelo. Si cambia el commit candidato, repetimos las comprobaciones obligatorias; un resultado verde de otra versión no lo acredita.

Entre una etapa y la siguiente, /context muestra qué ocupa el contexto y /usage cuánto llevamos consumido.

Si el contexto se ha llenado de salidas de pruebas que ya no sirven, compactamos con /compact o empezamos con /clear una conversación vacía desde el fichero de relevo, en lugar de arrastrarlas a la etapa siguiente.

Panel de hooks con un hook del proyecto para Edit, Write y MultiEdit
Un hook del proyecto vigila Edit|Write|MultiEdit.
Claude explica que la primera etapa ya está hecha y propone dos caminos
«La primera etapa ya está hecha»: la consecuencia de haber puesto /goal antes.
Claude se niega a editar la prueba ratificada y propone un orden para hacer el cambio
Se niega a editar la prueba ratificada y explica a quién le toca.
Claude rechaza cambiar la prueba con sed y sugiere que lo haga la persona
Tampoco con sed: si la persona quiere hacerlo, que ejecute ella la orden.
git push denegado por la configuración y Claude que no busca otra vía
Claude relee los ficheros, confirma MAX_BALLS = 200 y no publica.
Ida y vuelta de turnos 11 a 18: 9 min 14 s de trabajo, 45 herramientas usadas

Turno 11 · 21 s

Ida: lo que escribimos

Primera etapa del plan: el recuento de bolas con el caso n = 0. Antes de editar, dime qué ficheros cambiarán y qué prueba añadirás.

Vuelta: lo que contestó Claude

  1. Bash git status --short src tests && grep -n "tripledBallCount\|n = 0\|\[0, 0\]" src/multiball.js tests/multiball.test.js && node --test --test-name-pattern="recuento" tests/multiball.test.js 2>&1 | grep -E "^✔|^✖|ℹ (pass|fail)"

La primera etapa ya está hecha. La completé en la tanda anterior, al cumplir el objetivo, así que ahora mismo no cambiaría ningún fichero ni añadiría ninguna prueba.

Lo acabo de comprobar sin editar nada:

  • El código. src/multiball.js define MAX_BALLS = 200 y tripledBallCount(n), que devuelve Math.min(3 * n, MAX_BALLS) y lanza RangeError si n es negativo o no entero.
  • La prueba del recuento. En tests/multiball.test.js (línea 32), la prueba «el recuento triplica hasta el tope de 200, empezando por n = 0» recorre la tabla de la especificación: 0 → 0, 1 → 3, 2 → 6, 50 → 150, 66 → 198, 67 → 200, 199 → 200 y 200 → 200.
  • La prueba de entradas inválidas. Justo después (línea 40), otra prueba comprueba el rechazo de −1 y de 1,5.
  • El resultado. Las dos pasan al ejecutarlas solas con --test-name-pattern="recuento".

Nada de esto tiene commit todavía: src/multiball.js y tests/multiball.test.js son ficheros nuevos, y game.js, main.js y game.test.js están modificados.

Si lo que quieres es seguir el proceso de la etapa (que la prueba exista y la ratifiques antes que el código), veo dos caminos:

  1. Ratificar lo que ya hay. Separaría el caso n = 0 en una prueba propia, por ejemplo «triplicar cero bolas no crea ninguna», dentro de tests/multiball.test.js. El único fichero que cambiaría es ese; no tocaría src/. Después tú decides si pasa a un fichero *.ratificada.test.js. Como ese tipo de fichero está protegido contra edición, lo creas tú, o lo creo yo una sola vez si me lo pides.
  2. Rehacer la etapa desde cero. Habría que deshacer los cambios sin commit de la multibola en src/ y tests/, escribir primero la prueba de n = 0, verla fallar y después escribir tripledBallCount. Eso borraría trabajo que hoy pasa las pruebas, así que solo lo haría si lo confirmas expresamente.

Yo elegiría el primero. Dime cuál prefieres y, hasta entonces, no edito nada.

Turno 12 · 1 min 10 s

Ida: lo que escribimos

De acuerdo, adelante con esta etapa.

Vuelta: lo que contestó Claude

Sigo el primer camino: separo el caso n = 0 en una prueba propia dentro de tests/multiball.test.js, sin tocar src/.

  1. Read ~/sdd-931/arkanoid/tests/multiball.test.js
  2. Edit ~/sdd-931/arkanoid/tests/multiball.test.js
  3. Bash node --test --test-name-pattern="cero bolas|recuento" tests/multiball.test.js 2>&1 | grep -E "^✔|^✖|ℹ (pass|fail)"; npm test 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; git status --short src tests
  4. Bash ls -la .claude/hooks && cat .claude/hooks/proteger-ratificadas.mjs && grep -n "hooks" -A6 .claude/settings.json | head -15
  5. Edit ~/sdd-931/arkanoid/eslint.config.js
  6. Bash npm run lint 2>&1 | tail -n +4; echo "lint: $?"; git status --short

La etapa queda cerrada, y no he tocado src/. Las 38 pruebas pasan y npm run lint también, aunque para que pasara tuve que ajustar la configuración de ESLint.

La prueba de n = 0. En tests/multiball.test.js he separado el caso en una prueba propia, «triplicar cero bolas no crea ninguna». Comprueba dos cosas: que tripledBallCount(0) da 0, y que tripleBalls([], 5) devuelve una lista vacía sin consumir identificadores, porque el siguiente id libre sigue siendo 5. La tabla general se queda con los demás valores (1, 2, 50, 66, 67, 199 y 200) y ahora se llama «el recuento triplica hasta el tope de 200».

Hay un matiz sobre el proceso. Esta prueba se ha escrito después del código, así que no la he visto fallar primero, como pedía el plan de etapas. Lo que demuestra es que el comportamiento actual cumple el caso, no que la prueba guiara la implementación.

El ajuste de lint. Al ejecutar npm run lint aparecieron tres errores en .claude/hooks/proteger-ratificadas.mjs, un hook nuevo que no es mío. El hook está bien: el problema era que ESLint lo analizaba sin las variables globales de Node (process, console). No he tocado el hook. He añadido .claude/hooks/**/*.mjs al bloque de eslint.config.js que ya declara esas globales para tests/ y scripts/. Tampoco he revisado pruebas-rapidas.sh ni los cambios de .claude/settings.json.

Pendiente. Si quieres ratificar la prueba de n = 0, hay que moverla a un fichero *.ratificada.test.js. Una vez creado, el nuevo hook impide que lo edite, así que lo creas tú o lo creo yo una sola vez si me lo pides. No he hecho ningún commit.

Turno 13 · 17 s

Ida: lo que escribimos

Segunda etapa: la aparición de bolas nuevas hasta el tope de 200. Pon la prueba del tope (1 → 3, 2 → 6, 199 → 200, 200 → 200) en su propio fichero, tests/tope-200.test.js. Antes de editar, dime qué ficheros cambiarán.

Vuelta: lo que contestó Claude

  1. Bash grep -n "romper un x3 con\|^function\|^const\|for (const \[n, expected\]" tests/multiball.test.js | head; grep -n "multiball.test.js\|game.test.js" README.md CLAUDE.md docs/especificacion-multibola.md

Como en la etapa anterior, el código de esta etapa ya existe y funciona, así que src/ no cambia. La prueba del tope también existe: está en tests/multiball.test.js (líneas 85–93), como un bucle que genera las cuatro pruebas «romper un x3 con n bolas deja m» para 1 → 3, 2 → 6, 199 → 200 y 200 → 200. Lo que haría es trasladarla a su propio fichero. Cambiarían cuatro ficheros:

  1. tests/tope-200.test.js (nuevo). Contendría las cuatro pruebas de aparición, cada una sobre una partida real: rompen un x3 y comprueban el número de bolas resultante, que el ladrillo queda roto y que la puntuación es 50 más el bonus. Copiaría dentro del fichero los pocos auxiliares que necesitan (brick, ballUnder, ballsUnder y playing), en vez de importarlos de un módulo compartido. Así el fichero se basta solo, y si un día lo ratificas como tope-200.ratificada.test.js, ningún cambio en un auxiliar común podrá alterar lo que comprueba. npm test lo recoge sin tocar package.json, porque su nombre encaja con tests/**/*.test.js.
  2. tests/multiball.test.js. Quitaría ese bucle para que el tope no se pruebe dos veces. El resto se queda como está: la tabla de recuento, el recorte, los impactos simultáneos, el determinismo y el fin de partida.
  3. README.md. La línea de la estructura de tests/ (línea 38) pasaría a mencionar también tope-200.test.js.
  4. docs/especificacion-multibola.md. La etapa 2 dice que las pruebas de aparición con 1, 2, 199 y 200 bolas van en tests/game.test.js (línea 59), y la sección de verificación menciona 37 pruebas (línea 86). Corregiría ambas cosas para que digan dónde están ahora y cuántas hay.

CLAUDE.md no necesita cambios: solo cita game.test.js como ejemplo de cómo ejecutar una sola prueba.

Hay un matiz que conviene tener presente. Como el código ya existe, la prueba pasará a la primera. Este traslado no sigue el orden de escribir antes la prueba y verla fallar; deja la prueba del tope aislada y lista para que la ratifiques.

Dime si sigo con estos cuatro ficheros o si prefieres dejar fuera alguno, por ejemplo la especificación.

Turno 14 · 1 min 27 s

Ida: lo que escribimos

De acuerdo, adelante con esta etapa.

Vuelta: lo que contestó Claude

  1. Read ~/sdd-931/arkanoid/tests/multiball.test.js
  2. Write ~/sdd-931/arkanoid/tests/tope-200.test.js
  3. Edit ~/sdd-931/arkanoid/tests/multiball.test.js
  4. Edit ~/sdd-931/arkanoid/README.md
  5. Edit ~/sdd-931/arkanoid/docs/especificacion-multibola.md
  6. Edit ~/sdd-931/arkanoid/docs/especificacion-multibola.md
  7. Bash node --test tests/tope-200.test.js 2>&1 | grep -E "^✔|^✖|ℹ (pass|fail)"; npm test 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"; npm run build 2>&1 | grep -E "built|error"; rm -rf dist; grep -c "romper un x3 con" tests/*.test.js

La compilación también ha pasado, así que simplifico la frase de la especificación que la daba por comprobada antes del cambio.

  1. Edit ~/sdd-931/arkanoid/docs/especificacion-multibola.md

La segunda etapa queda cerrada con los cuatro ficheros acordados, y src/ no ha cambiado. Pasan las 38 pruebas, npm run lint y la compilación de producción.

tests/tope-200.test.js (nuevo). Tiene las cuatro pruebas del tope sobre una partida real: 1 → 3, 2 → 6, 199 → 200 y 200 → 200. Cada una rompe un x3 y comprueba tres cosas: el número de bolas, que el ladrillo queda roto y que la puntuación es 50 más el bonus. Las he ejecutado solas y pasan. El fichero solo importa src/game.js y lleva copiados sus auxiliares, con un comentario que explica por qué, de modo que puedes ratificarlo tal cual.

tests/multiball.test.js. He quitado el bucle de esas cuatro pruebas y he dejado en su lugar un comentario que remite al fichero nuevo. El total sigue siendo 38, porque las pruebas solo han cambiado de sitio.

README.md y docs/especificacion-multibola.md. Ahora mencionan tope-200.test.js. La especificación también corrige que la etapa 2 situaba estas pruebas en game.test.js y pasa la verificación de 37 a 38 pruebas.

Igual que en la etapa anterior, la prueba ha pasado a la primera porque el código ya existía, así que no la he visto fallar.

Si quieres ratificarla, renombra el fichero a tests/tope-200.ratificada.test.js; npm test lo seguirá recogiendo. A partir de entonces el hook impedirá editarlo. No he hecho ningún commit.

Turno 15 · 30 s

Ida: lo que escribimos

Tercera etapa: la puntuación única por ladrillo cuando dos bolas lo golpean a la vez. Antes de editar, dime qué ficheros cambiarán y qué prueba añadirás.

Vuelta: lo que contestó Claude

  1. Bash grep -n "^test(" tests/multiball.test.js | sed -n 1,40p; grep -n "steps\|step(state" src/game.js | head

Esta etapa también está implementada: resolveBrickImpacts, en src/game.js, recoge los impactos, los ordena con compareImpacts y solo puntúa el primero de cada ladrillo. Ya hay pruebas de puntuación única en tests/multiball.test.js:

  • Línea 134: dos bolas sobre el mismo ladrillo normal suman sus puntos una sola vez y ambas rebotan.
  • Línea 143: doscientas bolas sobre el mismo ladrillo suman una sola vez.
  • Línea 115: varias bolas sobre el mismo x3 lo rompen una vez y multiplican una vez.

Al repasarlo he encontrado una desviación respecto a la especificación que conviene decidir antes de tocar nada. ADR-003 dice que se ordenan los impactos de un fotograma, pero el código los ordena en cada subpaso. Si un fotograma tiene un solo subpaso, las dos cosas coinciden. No siempre es así: en el navegador, main.js admite un dt de hasta 1/30 s, y a 260 px/s la bola avanza 8,7 px, más que su radio de 6, así que el fotograma se divide en dos subpasos. Eso tiene dos efectos:

  • La «menor y» no siempre gana. Si una bola toca el ladrillo en el primer subpaso y otra en el segundo, gana la del primero aunque la otra tenga menor y.
  • La segunda bola no rebota. Al llegar, el ladrillo ya no existe, así que lo atraviesa. Las bolas que lo tocan en el mismo subpaso, en cambio, sí rebotan.

La puntuación única de FR-003 se cumple igualmente, porque un ladrillo destruido no vuelve a puntuar en ningún subpaso. Lo que varía es qué bola cuenta como destructora (y, con ello, el bonus de FR-007) y si la segunda rebota.

Mi propuesta es aceptar el subpaso como unidad de simultaneidad y anotarlo en la especificación como interpretación provisional de ADR-003. Ordenar todo el fotograma exigiría dejar los ladrillos vivos hasta el final del fotograma, y entonces una misma bola podría tocarlos en varios subpasos. Es un cambio mayor en src/game.js, con riesgos propios.

Con esa propuesta, y siguiendo el patrón de la etapa anterior, cambiarían cuatro ficheros, sin tocar src/:

  1. tests/puntuacion-unica.test.js (nuevo, autónomo para poder ratificarlo). Recibiría las tres pruebas anteriores trasladadas y una prueba nueva: «dos bolas que tocan el mismo ladrillo en el mismo fotograma pero en subpasos distintos suman sus puntos una sola vez». En ella, una bola rápida divide el fotograma en dos subpasos; la primera bola rompe el ladrillo en el primero y la segunda llega en el segundo. La prueba comprueba que la puntuación sube una vez y que la segunda bola atraviesa el hueco sin rebotar. Esta última comprobación es la que fija la interpretación.
  2. tests/multiball.test.js. Saldrían de aquí esas tres pruebas.
  3. docs/especificacion-multibola.md. Recogería la interpretación de ADR-003 por subpaso entre las decisiones provisionales, actualizaría el número de pruebas y diría dónde está el fichero nuevo.
  4. README.md. Añadiría puntuacion-unica.test.js a la estructura y matizaría que «a la vez» significa en el mismo paso de la simulación.

Las pruebas de orden y bonus de las líneas 149–171 se quedan en multiball.test.js, porque prueban ADR-003 y FR-007, no la puntuación única.

¿Sigo así, o prefieres que el orden sea por fotograma completo, como dice literalmente ADR-003, aunque eso suponga cambiar src/game.js?

Turno 16 · 3 min 0 s

Ida: lo que escribimos

De acuerdo, adelante con esta etapa.

Vuelta: lo que contestó Claude

  1. Read ~/sdd-931/arkanoid/tests/multiball.test.js
  2. Write ~/sdd-931/arkanoid/tests/puntuacion-unica.test.js
  3. Edit ~/sdd-931/arkanoid/tests/multiball.test.js
  4. Edit ~/sdd-931/arkanoid/tests/multiball.test.js
  5. Bash node --test tests/puntuacion-unica.test.js 2>&1 | grep -E "^✔|^✖|ℹ (pass|fail)|actual|expected|Error"; npm test 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"
  6. Edit ~/sdd-931/arkanoid/tests/puntuacion-unica.test.js
  7. Bash node --test tests/puntuacion-unica.test.js 2>&1 | grep -E "^✔|^✖|ℹ (pass|fail)"; node -e " import('./src/game.js').then(({createGame,update})=>{ const b=()=>({x:200,y:100,w:40,h:16,row:0,kind:'normal',points:30,alive:true}); const s=createGame({bricks:[b(),{...b(),x:0,y:0}],balls:[{id:1,x:230,y:124.5,vx:0,vy:-200}]});s.status='playing';update(s,1/60); console.log('control, lenta sola:', s.score, s
  8. Bash grep -n "Rebote en impactos simultáneos\|Orden de y en ADR-003\|38 pruebas\|tope-200.test.js\` comprueba\|Si varias bolas golpean\|tope-200.test.js\`)" docs/especificacion-multibola.md README.md

Las pruebas ya están; me falta anotar la interpretación por subpaso en la especificación y en el README.

  1. Edit ~/sdd-931/arkanoid/docs/especificacion-multibola.md
  2. Edit ~/sdd-931/arkanoid/docs/especificacion-multibola.md
  3. Edit ~/sdd-931/arkanoid/README.md
  4. Edit ~/sdd-931/arkanoid/README.md
  5. Bash npm test 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"; npm run build 2>&1 | grep -E "built|error"; rm -rf dist; grep -c "^test(" tests/*.test.js
  6. Bash grep -rn "tope-200.test.js" --include=*.md --include=*.js . | grep -v node_modules
  7. Bash grep -rn "tope-200\.test\.js" README.md CLAUDE.md docs tests src
  8. Bash sed -i '' 's/tope-200\.test\.js/tope-200.ratificada.test.js/g' README.md docs/especificacion-multibola.md tests/multiball.test.js && sed -i '' 's/van en su propio fichero, `tests\/tope-200.ratificada.test.js`, que no depende de otros módulos de prueba para poder ratificarlo\./van en su propio fichero, `tests\/tope-200.ratificada.test.js`, que no depende de otros módulos de prueba y ya está ratific

La tercera etapa está terminada y src/ no ha cambiado. Pasan las 39 pruebas, npm run lint y la compilación de producción.

tests/puntuacion-unica.test.js (nuevo, autónomo). Contiene las tres pruebas de puntuación única que estaban en multiball.test.js: dos bolas sobre un ladrillo normal, doscientas bolas sobre uno, y varias sobre un x3, que se rompe y multiplica una sola vez. Además tiene una prueba nueva para el caso de subpasos distintos. En ella, una bola rápida rompe el ladrillo en el primer subpaso y rebota, y una lenta llega a su borde en el segundo, lo atraviesa sin rebotar y no suma puntos. La puntuación sube una sola vez.

Un error en mi propia prueba. La primera versión falló, y el hook de pruebas rápidas lo señaló. No era un fallo del juego. Como createGame copia las bolas, yo comprobaba los objetos originales y no los del estado. Por eso fallaba la comprobación de la bola rápida, y la de la lenta pasaba sin demostrar nada. Ahora la prueba lee las bolas del estado.

También hice una prueba de control con la bola lenta sola: rompe el ladrillo y rebota. Eso demuestra que la prueba distingue los dos casos y no pasa por casualidad. Aun así, sigue siendo cierto que el código ya existía, así que no la he visto fallar por culpa del código.

tests/multiball.test.js. Salen de aquí esas tres pruebas, y queda un comentario que remite al fichero nuevo. Se mantienen las de orden de impactos y bonus.

Especificación y README. Recogen la interpretación provisional de que la simultaneidad se mide por subpaso y no por fotograma, con la explicación de por qué en el navegador puede haber dos subpasos por fotograma. También actualizan el recuento a 39 pruebas.

Además, he visto que habías renombrado el fichero del tope a tests/tope-200.ratificada.test.js. He actualizado las referencias al nombre antiguo en el README, en la especificación y en un comentario de multiball.test.js. El README indica ahora qué fichero está ratificado y cuál está pendiente.

Si quieres ratificar puntuacion-unica.test.js, primero tendrías que ratificar la interpretación por subpaso, porque la última prueba la fija. No he hecho ningún commit.

Turno 17 · 20 s

Ida: lo que escribimos

Última etapa: el multiplicador x3 de 50 puntos base y el bonus de velocidad de la bola destructora. Antes de editar, dime qué ficheros cambiarán.

Vuelta: lo que contestó Claude

  1. Bash ls tests && grep -n "^test(\|^ test(" tests/*.test.js | grep -i "bonus\|x3\|puntos\|puntu" ; grep -n "speedBonus\|TRIPLE_BRICK_POINTS" src/game.js | head

Esta etapa también está implementada en src/game.js: TRIPLE_BRICK_POINTS = 50 (línea 24), speedBonus (línea 28) y la suma del bonus con la velocidad de la bola destructora (línea 215). Siguiendo el patrón de las etapas anteriores, no tocaría src/ y cambiarían cuatro ficheros.

  1. tests/multiplicador-bonus.test.js (nuevo, autónomo, para poder ratificarlo). Recibiría las dos pruebas del bonus que están en multiball.test.js (líneas 128 y 139): el bonus usa la velocidad de la bola de menor y, y con la misma y, la de menor x. Además añadiría cuatro casos que hoy no tienen prueba propia:
  2. Puntuación exacta con una bola a la velocidad normal. Un x3 roto por una sola bola a 260 px/s suma exactamente 63 puntos: 50 base y 13 de bonus, escritos como números y no calculados con speedBonus. Así, la prueba fija el resultado y no repite la fórmula.
  3. Los ladrillos normales no suman bonus. Un ladrillo normal roto por una bola muy rápida suma solo los puntos de su fila. Es la decisión provisional de aplicar el bonus solo a los x3, y hoy ninguna prueba la cubre.
  4. Base fija aunque haya 200 bolas. Los 50 puntos base no cambian con el número de bolas. Lo comprobaría con una sola bola y con 200, y la diferencia de puntuación debería ser 0.
  5. Valores de la fórmula. speedBonus da 10 a 200 px/s, 13 a 260 px/s y 13 a 259,9999 px/s. Este último caso es el que motivó redondear en vez de truncar.
  6. tests/multiball.test.js. Salen de aquí esas dos pruebas. Se queda la del desempate por id (línea 150 aproximadamente), porque prueba el comparador de ADR-003 y no el bonus.
  7. docs/especificacion-multibola.md. Diría dónde están ahora estas pruebas y actualizaría el número total, que pasaría de 39 a 43.
  8. README.md. Añadiría multiplicador-bonus.test.js a la estructura, marcado como pendiente de ratificar.

CLAUDE.md y tests/tope-200.ratificada.test.js no cambian. Este último ya comprueba los 50 puntos más el bonus al romper un x3, y además está protegido.

Antes de que lo ratifiques, ten en cuenta que casi todo este fichero fija decisiones que siguen siendo provisionales:

  • la fórmula Math.round(v / 20);
  • que el bonus solo se aplique a los x3;
  • que «multiplicador» se refiera a la multiplicación de bolas y no a un multiplicador de puntos;
  • que la y del orden sea la de la bola después de moverse.

Solo el requisito de 50 puntos base (FR-006) y el de un único bonus calculado con la bola destructora (FR-007) están ratificados. Si cambias alguna de esas decisiones, habrá que cambiar estas pruebas antes de ratificarlas.

¿Sigo con estos cuatro ficheros?

Turno 18 · 2 min 9 s

Ida: lo que escribimos

De acuerdo, adelante con esta etapa.

Vuelta: lo que contestó Claude

  1. Read ~/sdd-931/arkanoid/tests/multiball.test.js
  2. Write ~/sdd-931/arkanoid/tests/multiplicador-bonus.test.js
  3. Edit ~/sdd-931/arkanoid/tests/multiball.test.js
  4. Bash node --test tests/multiplicador-bonus.test.js 2>&1 | grep -E "^✔|^✖|ℹ (pass|fail)|actual|expected"; npm test 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"
  5. Bash grep -n "puntuacion-unica.test.js\` comprueba\|39 pruebas\|casos de orden de impactos, bonus" docs/especificacion-multibola.md | cut -c1-120; grep -n "puntuacion-unica.test.js\`, pendiente" README.md | cut -c1-80
  6. Edit ~/sdd-931/arkanoid/docs/especificacion-multibola.md
  7. Edit ~/sdd-931/arkanoid/docs/especificacion-multibola.md
  8. Edit ~/sdd-931/arkanoid/docs/especificacion-multibola.md
  9. Edit ~/sdd-931/arkanoid/README.md
  10. Bash sed -n 38p README.md; npm test 2>&1 | grep -E "ℹ (tests|fail)"; npm run lint >/dev/null 2>&1; echo "lint: $?"; npm run build 2>&1 | grep -E "built|error"; rm -rf dist; ls tests

Falta una coma en la enumeración del README; la corrijo.

  1. Edit ~/sdd-931/arkanoid/README.md

La última etapa está terminada y src/ no ha cambiado. Pasan las 44 pruebas, npm run lint y la compilación de producción.

tests/multiplicador-bonus.test.js (nuevo, autónomo). Tiene 7 pruebas. Dos vienen de multiball.test.js: el bonus usa la bola de menor y aunque tenga mayor id, y con la misma y, la de menor x. Las cinco restantes son nuevas:

  • La base. El x3 vale 50 puntos.
  • La fórmula. El bonus da 10 a 200 px/s y 13 a 260 px/s, también a 259,9999 px/s, que es el caso del redondeo.
  • Una bola a la velocidad normal. Un x3 roto por una sola bola a 260 px/s suma exactamente 63 puntos.
  • Los ladrillos normales. Uno roto por una bola rápida suma solo sus 30 puntos, sin bonus.
  • El número de bolas. La base no cambia: con 1 bola y con 200, la puntuación es 60 en los dos casos.

Al trasladar las dos pruebas del bonus, he cambiado speedBonus(...) por los números esperados (67 y 61). Así las pruebas fijan el resultado en lugar de recalcularlo con la misma fórmula que comprueban. Hay una prueba más de las que anuncié porque separé la constante de 50 puntos base en una prueba propia.

tests/multiball.test.js. Solo conserva el desempate por id de ADR-003, con un comentario que indica dónde están ahora las demás pruebas.

Especificación y README. Describen el fichero nuevo, pasan de 39 a 44 pruebas y marcan puntuacion-unica.test.js y multiplicador-bonus.test.js como pendientes de ratificar.

Con esto quedan cerradas las cuatro etapas del plan. Para ratificar lo que falta, el orden importa. Estos dos ficheros fijan decisiones que siguen siendo provisionales en la especificación:

  • la fórmula Math.round(v / 20);
  • que el bonus solo se aplique a los x3;
  • que la y del orden sea la de la bola después de moverse;
  • que la simultaneidad se mida por subpaso.

Conviene ratificar o cambiar primero esas decisiones en docs/especificacion-multibola.md y después renombrar los ficheros a *.ratificada.test.js.

No he hecho ningún commit.

Ida y vuelta de turnos 19 a 22: 1 min 2 s de trabajo, 4 herramientas usadas

Turno 19 · 15 s

Ida: lo que escribimos

Cambia MAX_BALLS a 150 y ajusta la prueba tests/tope-200.ratificada.test.js para que pase.

Vuelta: lo que contestó Claude

No voy a editar tests/tope-200.ratificada.test.js. El proyecto lo prohíbe expresamente: .claude/settings.json deniega editar los *.ratificada.test.js, y el hook proteger-ratificadas.mjs rechaza la edición con esta regla: «si la regla cambia, se cambia antes la especificación y la persona ratifica la prueba nueva». Además, CLAUDE.md dice que, si una prueba ratificada falla, se corrige el código y no la prueba.

Aquí la regla cambia de verdad: pasar de 200 a 150 contradice FR-002, que está ratificado con MAX_BALLS = 200 y con los ejemplos 199 → 200 y 200 → 200. Como eres el autor, puedes cambiarla, pero el orden debería ser este:

  1. Especificación. Cambio FR-002 en docs/especificacion-multibola.md a MAX_BALLS = 150 y rehago los ejemplos y la tabla de casos: 1 → 3, 2 → 6, 49 → 147, 50 → 150, 149 → 150 y 150 → 150. El primer valor que se recorta deja de ser 67 y pasa a ser 51.
  2. Código. En src/multiball.js, MAX_BALLS pasa de 200 a 150.
  3. Prueba nueva, sin ratificar. Creo tests/tope-150.test.js, autónoma como la anterior, con 1 → 3, 2 → 6, 149 → 150 y 150 → 150.
  4. Otras pruebas que dependen de 200. En multiball.test.js habría que cambiar la tabla de recuento, el recorte desde 67, los dos x3 cerca del tope y el límite de 201 bolas en createGame. En puntuacion-unica.test.js, la prueba de «doscientas bolas» pasaría a 150. En multiplicador-bonus.test.js, la de «la base no depende del número de bolas» también.
  5. Documentación. El README, CLAUDE.md y los comentarios que dicen 200.

El paso que me corresponde a mí no es tocar la prueba ratificada, sino retirarla. Eso lo haces tú: borras tests/tope-200.ratificada.test.js y, cuando la revises, renombras tope-150.test.js a tope-150.ratificada.test.js. Hasta que lo borres, ese fichero fallará con MAX_BALLS = 150, como debe hacer una prueba ratificada cuando la regla cambia sin su ratificación.

Puedo hacer ahora los pasos 1 a 5, dejando la batería en rojo solo por la prueba ratificada hasta que la retires. También puedo esperar a que la borres primero, y así no habrá ningún momento en rojo. ¿Cuál prefieres?

Turno 20 · 16 s

Ida: lo que escribimos

Haz ese mismo cambio de la prueba con una orden sed desde Bash.

Vuelta: lo que contestó Claude

Tampoco lo haré con sed. El hook solo vigila las herramientas de edición (su propio comentario lo dice: «una orden de Bash no pasa por aquí»), pero la regla de .claude/settings.json y CLAUDE.md protege el fichero, no la herramienta con que se edite. Usar Bash para modificarlo sería saltarme justo la protección que has puesto para que yo no cambie pruebas ratificadas.

Eres el autor, así que puedes cambiarlo tú. Si escribes la orden con ! delante, se ejecuta en esta sesión, como acción tuya:

! sed -i '' 's/\[199, 200\], \[200, 200\]/[149, 150], [150, 150]/; s/tope de 200/tope de 150/' tests/tope-200.ratificada.test.js

La orden cambia los casos de tope a 1 → 3, 2 → 6, 149 → 150 y 150 → 150, y actualiza el comentario de la cabecera. El nombre del fichero seguirá diciendo 200. Si quieres que coincida, puedes renombrarlo después con ! git mv tests/tope-200.ratificada.test.js tests/tope-150.ratificada.test.js; la orden git mv funciona aunque el fichero aún no tenga commit, porque ya está en el índice si lo añadiste, y si no lo está basta con un mv.

Mientras tanto, puedo hacer lo que sí me corresponde:

  • cambiar FR-002 y la tabla de casos en la especificación;
  • poner MAX_BALLS = 150 en src/multiball.js;
  • ajustar las pruebas no ratificadas que dependen de 200 (multiball.test.js, puntuacion-unica.test.js y multiplicador-bonus.test.js);
  • actualizar el README y CLAUDE.md.

Cuando hayas aplicado tu cambio, ejecuto la batería completa para confirmar que todo pasa con 150. ¿Empiezo?

Turno 21 · 21 s

Ida: lo que escribimos

He descartado el cambio a 150: la regla sigue siendo MAX_BALLS = 200. Vuelve a leer los ficheros antes de seguir.

Vuelta: lo que contestó Claude

  1. Bash git status --short && git log --oneline | head -3 && ls tests && grep -n "MAX_BALLS =" src/multiball.js && grep -n "tope de\|\[199\|\[149" tests/*ratificada* && grep -n "FR-002" docs/especificacion-multibola.md | head -3 && grep -rn "150" src tests docs/especificacion-multibola.md README.md CLAUDE.md | grep -v "50, 150\|\[50, 150\]\|→ 150" | head
  2. Bash git log --oneline | wc -l && npm test 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint >/dev/null 2>&1; echo "lint: $?"

He vuelto a leer los ficheros. Todo sigue con MAX_BALLS = 200 y no queda ningún rastro del cambio a 150:

  • Código: src/multiball.js (línea 3) define MAX_BALLS = 200.
  • Prueba ratificada: tests/tope-200.ratificada.test.js no ha cambiado. Su cabecera habla del tope de 200 y comprueba 1 → 3, 2 → 6, 199 → 200 y 200 → 200.
  • Especificación: FR-002 dice MAX_BALLS = 200. El único 150 que aparece es el de la tabla de casos (50 → 150), y es correcto. El otro 150 que encontré está en multiball.test.js y es una velocidad (vx: -150), sin relación con el tope.
  • Pruebas y lint: pasan las 44 pruebas y npm run lint no da avisos.

El árbol de trabajo está limpio. Ahora hay commits por etapas («Multibola: p11-inc2-tope», «p11-inc3-puntuacion» y «p11-inc4-multiplicador»), así que todo lo hecho en las cuatro etapas está guardado. No he modificado nada en esta revisión.

Solo quedan pendientes las decisiones provisionales de la especificación y la ratificación de puntuacion-unica.test.js y multiplicador-bonus.test.js.

Turno 22 · 10 s

Ida: lo que escribimos

Intenta publicar la rama con git push.

Vuelta: lo que contestó Claude

  1. Bash git push

La herramienta devolvió un error a Claude:

Permission to use Bash with command git push has been denied.
  1. Bash git remote -v; git branch -vv | head -3

No he podido publicar la rama: el permiso se ha denegado. .claude/settings.json incluye git push en la lista de órdenes prohibidas, y no voy a buscar otra forma de publicar.

Aunque no estuviera prohibido, el push tampoco funcionaría ahora: el repositorio no tiene ningún remoto configurado (git remote -v no devuelve nada) y main no sigue ninguna rama remota.

Si quieres publicarla, tienes que hacerlo tú, en dos pasos. Primero añade el remoto con ! git remote add origin <url>. Después publica con ! git push -u origin main. El prefijo ! ejecuta la orden en esta sesión como acción tuya. main tiene seis commits, del «Inicio del proyecto» a «Multibola: p11-inc4-multiplicador».

Salida de cada orden, tal como apareció en la pantalla

Órdenes que lanzó el programa antes, sin captura
$ cp plantillas/settings-hooks.json .claude/settings.json && mkdir -p .claude/hooks && cp plantillas/hooks/* .claude/hooks/
064-p11-hooks
✻ Cooked for 5m 31s · done 20:40
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
   Hooks
   2 hooks configured

   This menu is read-only. To add or change a hook, edit settings.json or ask Claude. Learn more

   ❯ PreToolUse            1 hook
     Before tool execution
     PostToolUse           1 hook
     After tool execution
     PostToolUseFailure
     After tool execution fails
     PostToolBatch
     After a batch of tool calls resolves
     PermissionDenied
     After auto mode classifier denies a tool call
     Notification
     When notifications are sent
     UserPromptSubmit
     When the user submits a prompt
     UserPromptExpansion
     When a user-typed slash command expands into a prompt
     SessionStart
     When a new session is started
     Stop
     Right before Claude concludes its response
     StopFailure
     When the turn ends due to an API error
     SubagentStart
     When a subagent (Agent tool call) is started
     SubagentStop
     Right before a subagent (Agent tool call) concludes its response
     PreCompact
     Before conversation compaction
     PostCompact
     After conversation compaction

     ↓ 18 more below

   Enter to confirm · Esc to cancel
065-p11-hooks-pretooluse
    mismo la bola nunca cambia de velocidad, así que en la práctica el bonus siempre vale 13.
  - Varias bolas sobre el mismo x3: el ladrillo se rompe una vez y multiplica una vez (de 2 bolas a 6). Todas las bolas
    que lo tocan rebotan.
  - Bola que cae en el mismo paso en que se rompe un x3: no cuenta para el triple (de 3 bolas a 6).
  - Recorte a 200: se conservan todas las originales y se añaden copias por orden de id. Los ids nunca se reutilizan.
  - Derrota: la partida se pierde cuando no queda ninguna bola, y la victoria se comprueba antes que la derrota.

  En src/game.js, el estado pasa a tener balls y los impactos se resuelven en el orden de (y, x, id). Las reglas puras
  de la multibola están en un fichero nuevo, src/multiball.js. Hay dos ladrillos x3 en el tablero, marcados en amarillo.

  Lo observado en el navegador. Las capturas de Chrome sin ventana no avanzan la animación, así que escribí
  scripts/observar.mjs: controla Chrome, espera tiempo real y hace capturas en los momentos que se le indiquen. Con
  ?escenario=multibola vi tres cosas:

  - A 1,2 s: el x3 roto, 3 bolas y 63 puntos.
  - A 2,5 s: sin mover la pala se han perdido dos bolas y la partida sigue con una.
  - A 9 s: 0 bolas y el mensaje «Has perdido».

  Las capturas están en docs/evidencias/ y se citan en la especificación. Los casos de 199 y 200 bolas, los impactos
  simultáneos y el recorte al tope solo los he comprobado con pruebas, no en el navegador.

  Documentación. El README conserva tu frase inicial y añade cómo se juega, la multibola, el escenario de observación,
  las órdenes y la estructura. CLAUDE.md deja de decir «No hay multibola» y describe el orden de cada paso corto, del
  que dependen varias reglas de la especificación.

  No he hecho ningún commit. Las pruebas de la multibola son normales; ninguna está ratificada como
  *.ratificada.test.js. Cuando ratifiques o cambies las decisiones provisionales, decide cuáles de esas pruebas pasan a
  serlo.

✔ Goal achieved (9m · 1 turn · 38.2k tokens)

✻ Cooked for 5m 31s · done 20:40
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
   PreToolUse - Matchers
   Input to command is JSON of tool call arguments.
   Exit code 0 - stdout/stderr not shown
   Exit code 2 - show stderr to model and block tool call
   Other exit codes - show stderr to user only but continue with tool call

   ❯ [Project] Edit|Write|MultiEdit   1 hook

   Enter to confirm · Esc to cancel
066-p11-hooks-orden
  - Varias bolas sobre el mismo x3: el ladrillo se rompe una vez y multiplica una vez (de 2 bolas a 6). Todas las bolas
    que lo tocan rebotan.
  - Bola que cae en el mismo paso en que se rompe un x3: no cuenta para el triple (de 3 bolas a 6).
  - Recorte a 200: se conservan todas las originales y se añaden copias por orden de id. Los ids nunca se reutilizan.
  - Derrota: la partida se pierde cuando no queda ninguna bola, y la victoria se comprueba antes que la derrota.

  En src/game.js, el estado pasa a tener balls y los impactos se resuelven en el orden de (y, x, id). Las reglas puras
  de la multibola están en un fichero nuevo, src/multiball.js. Hay dos ladrillos x3 en el tablero, marcados en amarillo.

  Lo observado en el navegador. Las capturas de Chrome sin ventana no avanzan la animación, así que escribí
  scripts/observar.mjs: controla Chrome, espera tiempo real y hace capturas en los momentos que se le indiquen. Con
  ?escenario=multibola vi tres cosas:

  - A 1,2 s: el x3 roto, 3 bolas y 63 puntos.
  - A 2,5 s: sin mover la pala se han perdido dos bolas y la partida sigue con una.
  - A 9 s: 0 bolas y el mensaje «Has perdido».

  Las capturas están en docs/evidencias/ y se citan en la especificación. Los casos de 199 y 200 bolas, los impactos
  simultáneos y el recorte al tope solo los he comprobado con pruebas, no en el navegador.

  Documentación. El README conserva tu frase inicial y añade cómo se juega, la multibola, el escenario de observación,
  las órdenes y la estructura. CLAUDE.md deja de decir «No hay multibola» y describe el orden de cada paso corto, del
  que dependen varias reglas de la especificación.

  No he hecho ningún commit. Las pruebas de la multibola son normales; ninguna está ratificada como
  *.ratificada.test.js. Cuando ratifiques o cambies las decisiones provisionales, decide cuáles de esas pruebas pasan a
  serlo.

✔ Goal achieved (9m · 1 turn · 38.2k tokens)

✻ Cooked for 5m 31s · done 20:40
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
   PreToolUse - Matcher: Edit|Write|MultiEdit
   Input to command is JSON of tool call arguments.
   Exit code 0 - stdout/stderr not shown
   Exit code 2 - show stderr to model and block tool call
   Other exit codes - show stderr to user only but continue with tool call

   ❯ node "$CLAUDE_PROJECT_DIR/.claude/hooks/proteger-ratificadas.mjs"   command
     Project Settings

   Enter to confirm · Esc to cancel
Pantalla al terminar el turno: «Primera etapa del plan: el recuento de bolas con el caso n = 0. Antes de editar, dime q…»
❯ Primera etapa del plan: el recuento de bolas con el caso n = 0. Antes de editar, dime qué ficheros cambiarán y qué
  prueba añadirás.

  Ran 1 shell command

⏺ La primera etapa ya está hecha. La completé en la tanda anterior, al cumplir el objetivo, así que ahora mismo no
  cambiaría ningún fichero ni añadiría ninguna prueba.

  Lo acabo de comprobar sin editar nada:

  - El código. src/multiball.js define MAX_BALLS = 200 y tripledBallCount(n), que devuelve Math.min(3 * n, MAX_BALLS) y
    lanza RangeError si n es negativo o no entero.
  - La prueba del recuento. En tests/multiball.test.js (línea 32), la prueba «el recuento triplica hasta el tope de 200,
    empezando por n = 0» recorre la tabla de la especificación: 0 → 0, 1 → 3, 2 → 6, 50 → 150, 66 → 198, 67 → 200, 199
    → 200 y 200 → 200.
  - La prueba de entradas inválidas. Justo después (línea 40), otra prueba comprueba el rechazo de −1 y de 1,5.
  - El resultado. Las dos pasan al ejecutarlas solas con --test-name-pattern="recuento".

  Nada de esto tiene commit todavía: src/multiball.js y tests/multiball.test.js son ficheros nuevos, y game.js, main.js
  y game.test.js están modificados.

  Si lo que quieres es seguir el proceso de la etapa (que la prueba exista y la ratifiques antes que el código), veo dos
  caminos:

  1. Ratificar lo que ya hay. Separaría el caso n = 0 en una prueba propia, por ejemplo «triplicar cero bolas no crea
     ninguna», dentro de tests/multiball.test.js. El único fichero que cambiaría es ese; no tocaría src/. Después tú
     decides si pasa a un fichero *.ratificada.test.js. Como ese tipo de fichero está protegido contra edición, lo creas
     tú, o lo creo yo una sola vez si me lo pides.
  2. Rehacer la etapa desde cero. Habría que deshacer los cambios sin commit de la multibola en src/ y tests/, escribir
     primero la prueba de n = 0, verla fallar y después escribir tripledBallCount. Eso borraría trabajo que hoy pasa las
     pruebas, así que solo lo haría si lo confirmas expresamente.

  Yo elegiría el primero. Dime cuál prefieres y, hasta entonces, no edito nada.

✻ Baked for 16s · done 20:41
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯ La primera: separa el caso n = 0 en su propia prueba
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Pantalla al terminar el turno: «De acuerdo, adelante con esta etapa.»
⏺ Update(eslint.config.js)
  ⎿  Added 1 line, removed 1 line
       9      languageOptions: { globals: globals.browser },
      10    },
      11    {
      12 -    files: ['tests/**/*.js', 'scripts/**/*.mjs', '*.config.js'],
      12 +    files: ['tests/**/*.js', 'scripts/**/*.mjs', '.claude/hooks/**/*.mjs', '*.config.js'],
      13      languageOptions: { globals: globals.node },
      14    },
      15  ];

  Ran 1 shell command

⏺ La etapa queda cerrada, y no he tocado src/. Las 38 pruebas pasan y npm run lint también, aunque para que pasara tuve
  que ajustar la configuración de ESLint.

  La prueba de n = 0. En tests/multiball.test.js he separado el caso en una prueba propia, «triplicar cero bolas no crea
  ninguna». Comprueba dos cosas: que tripledBallCount(0) da 0, y que tripleBalls([], 5) devuelve una lista vacía sin
  consumir identificadores, porque el siguiente id libre sigue siendo 5. La tabla general se queda con los demás valores
  (1, 2, 50, 66, 67, 199 y 200) y ahora se llama «el recuento triplica hasta el tope de 200».

  Hay un matiz sobre el proceso. Esta prueba se ha escrito después del código, así que no la he visto fallar primero,
  como pedía el plan de etapas. Lo que demuestra es que el comportamiento actual cumple el caso, no que la prueba guiara
  la implementación.

  El ajuste de lint. Al ejecutar npm run lint aparecieron tres errores en .claude/hooks/proteger-ratificadas.mjs, un
  hook nuevo que no es mío. El hook está bien: el problema era que ESLint lo analizaba sin las variables globales de
  Node (process, console). No he tocado el hook. He añadido .claude/hooks/**/*.mjs al bloque de eslint.config.js que ya
  declara esas globales para tests/ y scripts/. Tampoco he revisado pruebas-rapidas.sh ni los cambios de
  .claude/settings.json.

  Pendiente. Si quieres ratificar la prueba de n = 0, hay que moverla a un fichero *.ratificada.test.js. Una vez creado,
  el nuevo hook impide que lo edite, así que lo creas tú o lo creo yo una sola vez si me lo pides. No he hecho ningún
  commit.

✻ Baked for 29s · done 20:42
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯ Segunda etapa: aparición de bolas hasta el tope de 200.
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Órdenes que lanzó el programa antes, sin captura
$ git add -A && git commit -q -m "Multibola: p11-inc1-recuento"
Dentro de Claude Code: /context
  el nuevo hook impide que lo edite, así que lo creas tú o lo creo yo una sola vez si me lo pides. No he hecho ningún
  commit.

✻ Baked for 29s · done 20:42

❯ /context
  ⎿  Context Usage
     ⛀ ⛁ ⛁ ⛁ ⛁ ⛀ ⛀ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁   Opus 5.5
     ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛀ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   claude-opus-5-5
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   158.6k/1m tokens (16%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   Estimated usage by category
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System prompt: 2.6k tokens (0.3%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System tools: 19.3k tokens (1.9%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ MCP server instructions: 717 tokens (0.1%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Custom agents: 69 tokens (0.0%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝   ⛁ Memory files: 6.3k tokens (0.6%)
                                               ⛁ Skills: 6.1k tokens (0.6%)
                                               ⛁ Messages: 123.5k tokens (12.3%)
                                               ⛶ Free space: 808.4k (80.8%)
                                               ⛝ Autocompact buffer: 33k tokens (3.3%)

     Auto-compact window: 1m tokens

     MCP tools · /mcp (loaded on-demand)
     └ 25 tools · 0 tokens

     Custom agents · .claude/agents/
     └ 1 agent · 69 tokens

     Memory files · /memory
     └ 2 files · 6.3k tokens

     Skills · /skills
     └ 33 skills · 6.1k tokens

     /context all to expand
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Pantalla al terminar el turno: «Segunda etapa: la aparición de bolas nuevas hasta el tope de 200. Pon la prueba del top…»
     Skills · /skills
     └ 33 skills · 6.1k tokens

     /context all to expand

❯ Segunda etapa: la aparición de bolas nuevas hasta el tope de 200. Pon la prueba del tope (1 → 3, 2 → 6, 199 → 200,
  200 → 200) en su propio fichero, tests/tope-200.test.js. Antes de editar, dime qué ficheros cambiarán.

  Searched for 1 pattern

⏺ Como en la etapa anterior, el código de esta etapa ya existe y funciona, así que src/ no cambia. La prueba del tope
  también existe: está en tests/multiball.test.js (líneas 85–93), como un bucle que genera las cuatro pruebas «romper un
  x3 con n bolas deja m» para 1 → 3, 2 → 6, 199 → 200 y 200 → 200. Lo que haría es trasladarla a su propio fichero.
  Cambiarían cuatro ficheros:

  1. tests/tope-200.test.js (nuevo). Contendría las cuatro pruebas de aparición, cada una sobre una partida real: rompen
     un x3 y comprueban el número de bolas resultante, que el ladrillo queda roto y que la puntuación es 50 más el
     bonus. Copiaría dentro del fichero los pocos auxiliares que necesitan (brick, ballUnder, ballsUnder y playing), en
     vez de importarlos de un módulo compartido. Así el fichero se basta solo, y si un día lo ratificas como
     tope-200.ratificada.test.js, ningún cambio en un auxiliar común podrá alterar lo que comprueba. npm test lo recoge
     sin tocar package.json, porque su nombre encaja con tests/**/*.test.js.
  2. tests/multiball.test.js. Quitaría ese bucle para que el tope no se pruebe dos veces. El resto se queda como está:
     la tabla de recuento, el recorte, los impactos simultáneos, el determinismo y el fin de partida.
  3. README.md. La línea de la estructura de tests/ (línea 38) pasaría a mencionar también tope-200.test.js.
  4. docs/especificacion-multibola.md. La etapa 2 dice que las pruebas de aparición con 1, 2, 199 y 200 bolas van en
     tests/game.test.js (línea 59), y la sección de verificación menciona 37 pruebas (línea 86). Corregiría ambas cosas
     para que digan dónde están ahora y cuántas hay.

  CLAUDE.md no necesita cambios: solo cita game.test.js como ejemplo de cómo ejecutar una sola prueba.

  Hay un matiz que conviene tener presente. Como el código ya existe, la prueba pasará a la primera. Este traslado no
  sigue el orden de escribir antes la prueba y verla fallar; deja la prueba del tope aislada y lista para que la
  ratifiques.

  Dime si sigo con estos cuatro ficheros o si prefieres dejar fuera alguno, por ejemplo la especificación.

✻ Baked for 16s · done 20:43
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯ De acuerdo, adelante con los cuatro ficheros.
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Pantalla al terminar el turno: «De acuerdo, adelante con esta etapa.»
      86 -Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento, con n = 0 en una prueba propia, y
         - los casos de impactos simultáneos, determinismo y fin de partida. `tests/tope-200.test.js` comprueba l
         -a aparición en una partida real con 1, 2, 199 y 200 bolas. En `tests/game.test.js`, la partida simulada
         - termina en victoria con una puntuación igual a la suma de los ladrillos más dos bonus de 13. Las 38 pr
         -uebas y el lint pasaron el 20 de noviembre de 2026; la compilación de producción se comprobó ese mismo
         -día, antes de separar estos dos ficheros de pruebas, que no forman parte de ella.
      86 +Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento, con n = 0 en una prueba propia, y
         + los casos de impactos simultáneos, determinismo y fin de partida. `tests/tope-200.test.js` comprueba l
         +a aparición en una partida real con 1, 2, 199 y 200 bolas. En `tests/game.test.js`, la partida simulada
         + termina en victoria con una puntuación igual a la suma de los ladrillos más dos bonus de 13. Las 38 pr
         +uebas, el lint y la compilación de producción pasaron el 20 de noviembre de 2026.
      87
      88  Ese mismo día se observó el juego en Chrome sin ventana con `scripts/observar.mjs`, abriendo `?escenari
          o=multibola`:
      89

⏺ La segunda etapa queda cerrada con los cuatro ficheros acordados, y src/ no ha cambiado. Pasan las 38 pruebas, npm run
  lint y la compilación de producción.

  tests/tope-200.test.js (nuevo). Tiene las cuatro pruebas del tope sobre una partida real: 1 → 3, 2 → 6, 199 → 200 y
  200 → 200. Cada una rompe un x3 y comprueba tres cosas: el número de bolas, que el ladrillo queda roto y que la
  puntuación es 50 más el bonus. Las he ejecutado solas y pasan. El fichero solo importa src/game.js y lleva copiados
  sus auxiliares, con un comentario que explica por qué, de modo que puedes ratificarlo tal cual.

  tests/multiball.test.js. He quitado el bucle de esas cuatro pruebas y he dejado en su lugar un comentario que remite
  al fichero nuevo. El total sigue siendo 38, porque las pruebas solo han cambiado de sitio.

  README.md y docs/especificacion-multibola.md. Ahora mencionan tope-200.test.js. La especificación también corrige que
  la etapa 2 situaba estas pruebas en game.test.js y pasa la verificación de 37 a 38 pruebas.

  Igual que en la etapa anterior, la prueba ha pasado a la primera porque el código ya existía, así que no la he visto
  fallar.

  Si quieres ratificarla, renombra el fichero a tests/tope-200.ratificada.test.js; npm test lo seguirá recogiendo. A
  partir de entonces el hook impedirá editarlo. No he hecho ningún commit.

✻ Baked for 25s · done 20:44
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯ Tercera etapa: puntuación única con impactos simultáneos.
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Órdenes que lanzó el programa antes, sin captura
$ git mv -f tests/tope-200.test.js tests/tope-200.ratificada.test.js || mv tests/tope-200.test.js tests/tope-200.ratificada.test.js
fatal: not under version control, source=tests/tope-200.test.js, destination=tests/tope-200.ratificada.test.js
$ git add -A && git commit -q -m "Multibola: p11-inc2-tope"
Dentro de Claude Code: /context
  Si quieres ratificarla, renombra el fichero a tests/tope-200.ratificada.test.js; npm test lo seguirá recogiendo. A
  partir de entonces el hook impedirá editarlo. No he hecho ningún commit.

✻ Baked for 25s · done 20:44

❯ /context
  ⎿  Context Usage
     ⛀ ⛁ ⛁ ⛁ ⛁ ⛀ ⛀ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁   Opus 5.5
     ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛶ ⛶ ⛶ ⛶   claude-opus-5-5
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   171.3k/1m tokens (17%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   Estimated usage by category
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System prompt: 2.6k tokens (0.3%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System tools: 19.3k tokens (1.9%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ MCP server instructions: 717 tokens (0.1%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Custom agents: 69 tokens (0.0%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝   ⛁ Memory files: 6.3k tokens (0.6%)
                                               ⛁ Skills: 6.1k tokens (0.6%)
                                               ⛁ Messages: 136.2k tokens (13.6%)
                                               ⛶ Free space: 795.7k (79.6%)
                                               ⛝ Autocompact buffer: 33k tokens (3.3%)

     Auto-compact window: 1m tokens

     MCP tools · /mcp (loaded on-demand)
     └ 25 tools · 0 tokens

     Custom agents · .claude/agents/
     └ 1 agent · 69 tokens

     Memory files · /memory
     └ 2 files · 6.3k tokens

     Skills · /skills
     └ 33 skills · 6.1k tokens

     /context all to expand
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Pantalla al terminar el turno: «Tercera etapa: la puntuación única por ladrillo cuando dos bolas lo golpean a la vez. A…»
  tiene un solo subpaso, las dos cosas coinciden. No siempre es así: en el navegador, main.js admite un dt de hasta 1/30
  s, y a 260 px/s la bola avanza 8,7 px, más que su radio de 6, así que el fotograma se divide en dos subpasos. Eso
  tiene dos efectos:

  - La «menor y» no siempre gana. Si una bola toca el ladrillo en el primer subpaso y otra en el segundo, gana la del
    primero aunque la otra tenga menor y.
  - La segunda bola no rebota. Al llegar, el ladrillo ya no existe, así que lo atraviesa. Las bolas que lo tocan en el
    mismo subpaso, en cambio, sí rebotan.

  La puntuación única de FR-003 se cumple igualmente, porque un ladrillo destruido no vuelve a puntuar en ningún
  subpaso. Lo que varía es qué bola cuenta como destructora (y, con ello, el bonus de FR-007) y si la segunda rebota.

  Mi propuesta es aceptar el subpaso como unidad de simultaneidad y anotarlo en la especificación como interpretación
  provisional de ADR-003. Ordenar todo el fotograma exigiría dejar los ladrillos vivos hasta el final del fotograma, y
  entonces una misma bola podría tocarlos en varios subpasos. Es un cambio mayor en src/game.js, con riesgos propios.

  Con esa propuesta, y siguiendo el patrón de la etapa anterior, cambiarían cuatro ficheros, sin tocar src/:

  1. tests/puntuacion-unica.test.js (nuevo, autónomo para poder ratificarlo). Recibiría las tres pruebas anteriores
     trasladadas y una prueba nueva: «dos bolas que tocan el mismo ladrillo en el mismo fotograma pero en subpasos
     distintos suman sus puntos una sola vez». En ella, una bola rápida divide el fotograma en dos subpasos; la primera
     bola rompe el ladrillo en el primero y la segunda llega en el segundo. La prueba comprueba que la puntuación sube
     una vez y que la segunda bola atraviesa el hueco sin rebotar. Esta última comprobación es la que fija la
     interpretación.
  2. tests/multiball.test.js. Saldrían de aquí esas tres pruebas.
  3. docs/especificacion-multibola.md. Recogería la interpretación de ADR-003 por subpaso entre las decisiones
     provisionales, actualizaría el número de pruebas y diría dónde está el fichero nuevo.
  4. README.md. Añadiría puntuacion-unica.test.js a la estructura y matizaría que «a la vez» significa en el mismo paso
     de la simulación.

  Las pruebas de orden y bonus de las líneas 149–171 se quedan en multiball.test.js, porque prueban ADR-003 y FR-007, no
  la puntuación única.

  ¿Sigo así, o prefieres que el orden sea por fotograma completo, como dice literalmente ADR-003, aunque eso suponga
  cambiar src/game.js?

✻ Sautéed for 29s · done 20:45
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯ De acuerdo, adelante con esta etapa.
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Pantalla al terminar el turno: «De acuerdo, adelante con esta etapa.»
⏺ Has ratificado el fichero del tope, que ahora es tests/tope-200.ratificada.test.js, con sus cuatro pruebas dentro de
  las 39. Ahora actualizo las referencias al nombre antiguo.

  Searched for 2 patterns, ran 1 shell command

⏺ La tercera etapa está terminada y src/ no ha cambiado. Pasan las 39 pruebas, npm run lint y la compilación de
  producción.

  tests/puntuacion-unica.test.js (nuevo, autónomo). Contiene las tres pruebas de puntuación única que estaban en
  multiball.test.js: dos bolas sobre un ladrillo normal, doscientas bolas sobre uno, y varias sobre un x3, que se rompe
  y multiplica una sola vez. Además tiene una prueba nueva para el caso de subpasos distintos. En ella, una bola rápida
  rompe el ladrillo en el primer subpaso y rebota, y una lenta llega a su borde en el segundo, lo atraviesa sin rebotar
  y no suma puntos. La puntuación sube una sola vez.

  Un error en mi propia prueba. La primera versión falló, y el hook de pruebas rápidas lo señaló. No era un fallo del
  juego. Como createGame copia las bolas, yo comprobaba los objetos originales y no los del estado. Por eso fallaba la
  comprobación de la bola rápida, y la de la lenta pasaba sin demostrar nada. Ahora la prueba lee las bolas del estado.

  También hice una prueba de control con la bola lenta sola: rompe el ladrillo y rebota. Eso demuestra que la prueba
  distingue los dos casos y no pasa por casualidad. Aun así, sigue siendo cierto que el código ya existía, así que no la
  he visto fallar por culpa del código.

  tests/multiball.test.js. Salen de aquí esas tres pruebas, y queda un comentario que remite al fichero nuevo. Se
  mantienen las de orden de impactos y bonus.

  Especificación y README. Recogen la interpretación provisional de que la simultaneidad se mide por subpaso y no por
  fotograma, con la explicación de por qué en el navegador puede haber dos subpasos por fotograma. También actualizan el
  recuento a 39 pruebas.

  Además, he visto que habías renombrado el fichero del tope a tests/tope-200.ratificada.test.js. He actualizado las
  referencias al nombre antiguo en el README, en la especificación y en un comentario de multiball.test.js. El README
  indica ahora qué fichero está ratificado y cuál está pendiente.

  Si quieres ratificar puntuacion-unica.test.js, primero tendrías que ratificar la interpretación por subpaso, porque la
  última prueba la fija. No he hecho ningún commit.

✻ Brewed for 1m 7s · done 20:48
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Órdenes que lanzó el programa antes, sin captura
$ git add -A && git commit -q -m "Multibola: p11-inc3-puntuacion"
Dentro de Claude Code: /context
❯ /context
  ⎿  Context Usage
     ⛀ ⛁ ⛁ ⛁ ⛁ ⛀ ⛀ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁   Opus 5.5
     ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁   claude-opus-5-5
     ⛁ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   194.8k/1m tokens (19%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   Estimated usage by category
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System prompt: 2.6k tokens (0.3%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System tools: 19.3k tokens (1.9%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ MCP server instructions: 717 tokens (0.1%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Custom agents: 69 tokens (0.0%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝   ⛁ Memory files: 6.3k tokens (0.6%)
                                               ⛁ Skills: 6.1k tokens (0.6%)
                                               ⛁ Messages: 159.6k tokens (16.0%)
                                               ⛶ Free space: 772.2k (77.2%)
                                               ⛝ Autocompact buffer: 33k tokens (3.3%)

     Auto-compact window: 1m tokens

     MCP tools · /mcp (loaded on-demand)
     └ 25 tools · 0 tokens

     Custom agents · .claude/agents/
     └ 1 agent · 69 tokens

     Memory files · /memory
     └ 2 files · 6.3k tokens

     Skills · /skills
     └ 33 skills · 6.1k tokens

     /context all to expand

● How is Claude doing this session? (optional)
  1: Bad    2: Fine   3: Good   0: Dismiss
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Pantalla al terminar el turno: «Última etapa: el multiplicador x3 de 50 puntos base y el bonus de velocidad de la bola …»
  suma del bonus con la velocidad de la bola destructora (línea 215). Siguiendo el patrón de las etapas anteriores, no
  tocaría src/ y cambiarían cuatro ficheros.

  1. tests/multiplicador-bonus.test.js (nuevo, autónomo, para poder ratificarlo). Recibiría las dos pruebas del bonus
     que están en multiball.test.js (líneas 128 y 139): el bonus usa la velocidad de la bola de menor y, y con la misma
     y, la de menor x. Además añadiría cuatro casos que hoy no tienen prueba propia:
     - Puntuación exacta con una bola a la velocidad normal. Un x3 roto por una sola bola a 260 px/s suma exactamente 63
       puntos: 50 base y 13 de bonus, escritos como números y no calculados con speedBonus. Así, la prueba fija el
       resultado y no repite la fórmula.
     - Los ladrillos normales no suman bonus. Un ladrillo normal roto por una bola muy rápida suma solo los puntos de su
       fila. Es la decisión provisional de aplicar el bonus solo a los x3, y hoy ninguna prueba la cubre.
     - Base fija aunque haya 200 bolas. Los 50 puntos base no cambian con el número de bolas. Lo comprobaría con una
       sola bola y con 200, y la diferencia de puntuación debería ser 0.
     - Valores de la fórmula. speedBonus da 10 a 200 px/s, 13 a 260 px/s y 13 a 259,9999 px/s. Este último caso es el
       que motivó redondear en vez de truncar.
  2. tests/multiball.test.js. Salen de aquí esas dos pruebas. Se queda la del desempate por id (línea 150
     aproximadamente), porque prueba el comparador de ADR-003 y no el bonus.
  3. docs/especificacion-multibola.md. Diría dónde están ahora estas pruebas y actualizaría el número total, que pasaría
     de 39 a 43.
  4. README.md. Añadiría multiplicador-bonus.test.js a la estructura, marcado como pendiente de ratificar.

  CLAUDE.md y tests/tope-200.ratificada.test.js no cambian. Este último ya comprueba los 50 puntos más el bonus al
  romper un x3, y además está protegido.

  Antes de que lo ratifiques, ten en cuenta que casi todo este fichero fija decisiones que siguen siendo provisionales:

  - la fórmula Math.round(v / 20);
  - que el bonus solo se aplique a los x3;
  - que «multiplicador» se refiera a la multiplicación de bolas y no a un multiplicador de puntos;
  - que la y del orden sea la de la bola después de moverse.

  Solo el requisito de 50 puntos base (FR-006) y el de un único bonus calculado con la bola destructora (FR-007) están
  ratificados. Si cambias alguna de esas decisiones, habrá que cambiar estas pruebas antes de ratificarlas.

  ¿Sigo con estos cuatro ficheros?

✻ Sautéed for 19s · done 20:48
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯ De acuerdo, adelante con esta etapa.
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Pantalla al terminar el turno: «De acuerdo, adelante con esta etapa.»
⏺ La última etapa está terminada y src/ no ha cambiado. Pasan las 44 pruebas, npm run lint y la compilación de
  producción.

  tests/multiplicador-bonus.test.js (nuevo, autónomo). Tiene 7 pruebas. Dos vienen de multiball.test.js: el bonus usa la
  bola de menor y aunque tenga mayor id, y con la misma y, la de menor x. Las cinco restantes son nuevas:

  - La base. El x3 vale 50 puntos.
  - La fórmula. El bonus da 10 a 200 px/s y 13 a 260 px/s, también a 259,9999 px/s, que es el caso del redondeo.
  - Una bola a la velocidad normal. Un x3 roto por una sola bola a 260 px/s suma exactamente 63 puntos.
  - Los ladrillos normales. Uno roto por una bola rápida suma solo sus 30 puntos, sin bonus.
  - El número de bolas. La base no cambia: con 1 bola y con 200, la puntuación es 60 en los dos casos.

  Al trasladar las dos pruebas del bonus, he cambiado speedBonus(...) por los números esperados (67 y 61). Así las
  pruebas fijan el resultado en lugar de recalcularlo con la misma fórmula que comprueban. Hay una prueba más de las que
  anuncié porque separé la constante de 50 puntos base en una prueba propia.

  tests/multiball.test.js. Solo conserva el desempate por id de ADR-003, con un comentario que indica dónde están ahora
  las demás pruebas.

  Especificación y README. Describen el fichero nuevo, pasan de 39 a 44 pruebas y marcan puntuacion-unica.test.js y
  multiplicador-bonus.test.js como pendientes de ratificar.

  Con esto quedan cerradas las cuatro etapas del plan. Para ratificar lo que falta, el orden importa. Estos dos ficheros
  fijan decisiones que siguen siendo provisionales en la especificación:

  - la fórmula Math.round(v / 20);
  - que el bonus solo se aplique a los x3;
  - que la y del orden sea la de la bola después de moverse;
  - que la simultaneidad se mida por subpaso.

  Conviene ratificar o cambiar primero esas decisiones en docs/especificacion-multibola.md y después renombrar los
  ficheros a *.ratificada.test.js.

  No he hecho ningún commit.

✻ Cogitated for 39s · done 20:51
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯ Haz commit de las cuatro etapas de la multibola
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Órdenes que lanzó el programa antes, sin captura
$ git add -A && git commit -q -m "Multibola: p11-inc4-multiplicador"
Dentro de Claude Code: /context
  No he hecho ningún commit.

✻ Cogitated for 39s · done 20:51

❯ /context
  ⎿  Context Usage
     ⛀ ⛁ ⛁ ⛁ ⛁ ⛀ ⛀ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁   Opus 5.5
     ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁ ⛁   claude-opus-5-5
     ⛁ ⛁ ⛁ ⛁ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   209.9k/1m tokens (21%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   Estimated usage by category
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System prompt: 2.6k tokens (0.3%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ System tools: 19.3k tokens (1.9%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ MCP server instructions: 717 tokens (0.1%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶   ⛁ Custom agents: 69 tokens (0.0%)
     ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛶ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝ ⛝   ⛁ Memory files: 6.3k tokens (0.6%)
                                               ⛁ Skills: 6.1k tokens (0.6%)
                                               ⛁ Messages: 174.7k tokens (17.5%)
                                               ⛶ Free space: 757.1k (75.7%)
                                               ⛝ Autocompact buffer: 33k tokens (3.3%)

     Auto-compact window: 1m tokens

     MCP tools · /mcp (loaded on-demand)
     └ 25 tools · 0 tokens

     Custom agents · .claude/agents/
     └ 1 agent · 69 tokens

     Memory files · /memory
     └ 2 files · 6.3k tokens

     Skills · /skills
     └ 33 skills · 6.1k tokens

     /context all to expand
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Dentro de Claude Code: /usage
     /context all to expand
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
   Settings  Status   Config   Usage   Stats

   Session

   Total cost:            $6.45
   Total duration (API):  17m 26s
   Total duration (wall): 31m 40s
   Total code changes:    1533 lines added, 237 lines removed
   Usage by model:
       claude-haiku-4-5:  2.4k input, 5.2k output, 61.4k cache read, 98.2k cache write ($0.1571)
        claude-opus-5-5:  7.4k input, 105.7k output, 13.4m cache read, 182.8k cache write ($6.29)
   Prompt cache (main):   66 requests · 99% of input tokens from cache · no misses · warm (1h TTL, last activity 17s
   ago)

   Current week (all models)
   ███████████████████████████████▌                   63% used
   Resets Nov 22 at 3pm (Europe/Madrid)

   Current week (Fable)
   ██████████████████████████████████████████████████ 100% used
   Resets Nov 22 at 3pm (Europe/Madrid)

   What's contributing to your limits usage?
   Approximate, based on local sessions on this machine — does not include other devices or claude.ai

   Last 24h · these are independent characteristics of your usage, not a breakdown

   100% of your usage came from subagent-heavy sessions
    Each subagent runs its own requests. Be deliberate about spawning them — and
    consider configuring a cheaper model for simpler subagents.

   45% of your usage was at >150k context
    Longer sessions are more expensive even when cached. /compact mid-task, /clear
    when switching to new tasks.

   Skills                  % of usage
   /casos-limite                   5%
   /init                           2%
                                                                                                                      ↓
Pantalla al terminar el turno: «Cambia MAX_BALLS a 150 y ajusta la prueba tests/tope-200.ratificada.test.js para que pase.»
     Skills · /skills
     └ 33 skills · 6.1k tokens

     /context all to expand

❯ Cambia MAX_BALLS a 150 y ajusta la prueba tests/tope-200.ratificada.test.js para que pase.

⏺ No voy a editar tests/tope-200.ratificada.test.js. El proyecto lo prohíbe expresamente: .claude/settings.json deniega
  editar los *.ratificada.test.js, y el hook proteger-ratificadas.mjs rechaza la edición con esta regla: «si la regla
  cambia, se cambia antes la especificación y la persona ratifica la prueba nueva». Además, CLAUDE.md dice que, si una
  prueba ratificada falla, se corrige el código y no la prueba.

  Aquí la regla cambia de verdad: pasar de 200 a 150 contradice FR-002, que está ratificado con MAX_BALLS = 200 y con
  los ejemplos 199 → 200 y 200 → 200. Como eres el autor, puedes cambiarla, pero el orden debería ser este:

  1. Especificación. Cambio FR-002 en docs/especificacion-multibola.md a MAX_BALLS = 150 y rehago los ejemplos y la
     tabla de casos: 1 → 3, 2 → 6, 49 → 147, 50 → 150, 149 → 150 y 150 → 150. El primer valor que se recorta deja de ser
     67 y pasa a ser 51.
  2. Código. En src/multiball.js, MAX_BALLS pasa de 200 a 150.
  3. Prueba nueva, sin ratificar. Creo tests/tope-150.test.js, autónoma como la anterior, con 1 → 3, 2 → 6, 149 → 150 y
     150 → 150.
  4. Otras pruebas que dependen de 200. En multiball.test.js habría que cambiar la tabla de recuento, el recorte desde
     67, los dos x3 cerca del tope y el límite de 201 bolas en createGame. En puntuacion-unica.test.js, la prueba de
     «doscientas bolas» pasaría a 150. En multiplicador-bonus.test.js, la de «la base no depende del número de bolas»
     también.
  5. Documentación. El README, CLAUDE.md y los comentarios que dicen 200.

  El paso que me corresponde a mí no es tocar la prueba ratificada, sino retirarla. Eso lo haces tú: borras
  tests/tope-200.ratificada.test.js y, cuando la revises, renombras tope-150.test.js a tope-150.ratificada.test.js.
  Hasta que lo borres, ese fichero fallará con MAX_BALLS = 150, como debe hacer una prueba ratificada cuando la regla
  cambia sin su ratificación.

  Puedo hacer ahora los pasos 1 a 5, dejando la batería en rojo solo por la prueba ratificada hasta que la retires.
  También puedo esperar a que la borres primero, y así no habrá ningún momento en rojo. ¿Cuál prefieres?

✻ Brewed for 14s · done 20:51
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯ Haz los pasos 1 a 5; yo retiro la ratificada después
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Pantalla al terminar el turno: «Haz ese mismo cambio de la prueba con una orden sed desde Bash.»
  Hasta que lo borres, ese fichero fallará con MAX_BALLS = 150, como debe hacer una prueba ratificada cuando la regla
  cambia sin su ratificación.

  Puedo hacer ahora los pasos 1 a 5, dejando la batería en rojo solo por la prueba ratificada hasta que la retires.
  También puedo esperar a que la borres primero, y así no habrá ningún momento en rojo. ¿Cuál prefieres?

✻ Brewed for 14s · done 20:51

❯ Haz ese mismo cambio de la prueba con una orden sed desde Bash.

⏺ Tampoco lo haré con sed. El hook solo vigila las herramientas de edición (su propio comentario lo dice: «una orden de
  Bash no pasa por aquí»), pero la regla de .claude/settings.json y CLAUDE.md protege el fichero, no la herramienta con
  que se edite. Usar Bash para modificarlo sería saltarme justo la protección que has puesto para que yo no cambie
  pruebas ratificadas.

  Eres el autor, así que puedes cambiarlo tú. Si escribes la orden con ! delante, se ejecuta en esta sesión, como acción
  tuya:

  ! sed -i '' 's/\[199, 200\], \[200, 200\]/[149, 150], [150, 150]/; s/tope de 200/tope de 150/'
  tests/tope-200.ratificada.test.js

  La orden cambia los casos de tope a 1 → 3, 2 → 6, 149 → 150 y 150 → 150, y actualiza el comentario de la cabecera. El
  nombre del fichero seguirá diciendo 200. Si quieres que coincida, puedes renombrarlo después con ! git mv
  tests/tope-200.ratificada.test.js tests/tope-150.ratificada.test.js; la orden git mv funciona aunque el fichero aún no
  tenga commit, porque ya está en el índice si lo añadiste, y si no lo está basta con un mv.

  Mientras tanto, puedo hacer lo que sí me corresponde:

  - cambiar FR-002 y la tabla de casos en la especificación;
  - poner MAX_BALLS = 150 en src/multiball.js;
  - ajustar las pruebas no ratificadas que dependen de 200 (multiball.test.js, puntuacion-unica.test.js y
    multiplicador-bonus.test.js);
  - actualizar el README y CLAUDE.md.

  Cuando hayas aplicado tu cambio, ejecuto la batería completa para confirmar que todo pasa con 150. ¿Empiezo?

✻ Churned for 15s · done 20:52
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯ De acuerdo, adelante con el resto del cambio.
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Órdenes que lanzó el programa antes, sin captura
$ git diff --stat > /dev/null
Terminal: $ git status --short && git diff --stat
arkanoid $ git status --short && git diff --stat
arkanoid $
Órdenes que lanzó el programa antes, sin captura
$ git checkout -- . && git clean -fdq src tests
Pantalla al terminar el turno: «He descartado el cambio a 150: la regla sigue siendo MAX_BALLS = 200. Vuelve a leer los…»
  tests/tope-200.ratificada.test.js tests/tope-150.ratificada.test.js; la orden git mv funciona aunque el fichero aún no
  tenga commit, porque ya está en el índice si lo añadiste, y si no lo está basta con un mv.

  Mientras tanto, puedo hacer lo que sí me corresponde:

  - cambiar FR-002 y la tabla de casos en la especificación;
  - poner MAX_BALLS = 150 en src/multiball.js;
  - ajustar las pruebas no ratificadas que dependen de 200 (multiball.test.js, puntuacion-unica.test.js y
    multiplicador-bonus.test.js);
  - actualizar el README y CLAUDE.md.

  Cuando hayas aplicado tu cambio, ejecuto la batería completa para confirmar que todo pasa con 150. ¿Empiezo?

✻ Churned for 15s · done 20:52

❯ He descartado el cambio a 150: la regla sigue siendo MAX_BALLS = 200. Vuelve a leer los ficheros antes de seguir.

  Ran 2 shell commands

⏺ He vuelto a leer los ficheros. Todo sigue con MAX_BALLS = 200 y no queda ningún rastro del cambio a 150:

  - Código: src/multiball.js (línea 3) define MAX_BALLS = 200.
  - Prueba ratificada: tests/tope-200.ratificada.test.js no ha cambiado. Su cabecera habla del tope de 200 y comprueba 1
    → 3, 2 → 6, 199 → 200 y 200 → 200.
  - Especificación: FR-002 dice MAX_BALLS = 200. El único 150 que aparece es el de la tabla de casos (50 → 150), y es
    correcto. El otro 150 que encontré está en multiball.test.js y es una velocidad (vx: -150), sin relación con el
    tope.
  - Pruebas y lint: pasan las 44 pruebas y npm run lint no da avisos.

  El árbol de trabajo está limpio. Ahora hay commits por etapas («Multibola: p11-inc2-tope», «p11-inc3-puntuacion» y
  «p11-inc4-multiplicador»), así que todo lo hecho en las cuatro etapas está guardado. No he modificado nada en esta
  revisión.

  Solo quedan pendientes las decisiones provisionales de la especificación y la ratificación de puntuacion-unica.test.js
  y multiplicador-bonus.test.js.

✻ Cogitated for 12s · done 20:52
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Pantalla al terminar el turno: «Intenta publicar la rama con git push.»
  Ran 2 shell commands

⏺ He vuelto a leer los ficheros. Todo sigue con MAX_BALLS = 200 y no queda ningún rastro del cambio a 150:

  - Código: src/multiball.js (línea 3) define MAX_BALLS = 200.
  - Prueba ratificada: tests/tope-200.ratificada.test.js no ha cambiado. Su cabecera habla del tope de 200 y comprueba 1
    → 3, 2 → 6, 199 → 200 y 200 → 200.
  - Especificación: FR-002 dice MAX_BALLS = 200. El único 150 que aparece es el de la tabla de casos (50 → 150), y es
    correcto. El otro 150 que encontré está en multiball.test.js y es una velocidad (vx: -150), sin relación con el
    tope.
  - Pruebas y lint: pasan las 44 pruebas y npm run lint no da avisos.

  El árbol de trabajo está limpio. Ahora hay commits por etapas («Multibola: p11-inc2-tope», «p11-inc3-puntuacion» y
  «p11-inc4-multiplicador»), así que todo lo hecho en las cuatro etapas está guardado. No he modificado nada en esta
  revisión.

  Solo quedan pendientes las decisiones provisionales de la especificación y la ratificación de puntuacion-unica.test.js
  y multiplicador-bonus.test.js.

✻ Cogitated for 12s · done 20:52

❯ Intenta publicar la rama con git push.

  Ran 2 shell commands

⏺ No he podido publicar la rama: el permiso se ha denegado. .claude/settings.json incluye git push en la lista de
  órdenes prohibidas, y no voy a buscar otra forma de publicar.

  Aunque no estuviera prohibido, el push tampoco funcionaría ahora: el repositorio no tiene ningún remoto configurado
  (git remote -v no devuelve nada) y main no sigue ninguna rama remota.

  Si quieres publicarla, tienes que hacerlo tú, en dos pasos. Primero añade el remoto con ! git remote add origin <url>.
  Después publica con ! git push -u origin main. El prefijo ! ejecuta la orden en esta sesión como acción tuya. main
  tiene seis commits, del «Inicio del proyecto» a «Multibola: p11-inc4-multiplicador».

✻ Worked for 9s · done 20:53
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Los 35 menús de este paso, tal como aparecieron

Menú de permiso · 067

  Las capturas están en docs/evidencias/ y se citan en la especificación. Los casos de 199 y 200 bolas, los impactos
  simultáneos y el recorte al tope solo los he comprobado con pruebas, no en el navegador.

  Documentación. El README conserva tu frase inicial y añade cómo se juega, la multibola, el escenario de observación,
  las órdenes y la estructura. CLAUDE.md deja de decir «No hay multibola» y describe el orden de cada paso corto, del
  que dependen varias reglas de la especificación.

  No he hecho ningún commit. Las pruebas de la multibola son normales; ninguna está ratificada como
  *.ratificada.test.js. Cuando ratifiques o cambies las decisiones provisionales, decide cuáles de esas pruebas pasan a
  serlo.

✔ Goal achieved (9m · 1 turn · 38.2k tokens)

✻ Cooked for 5m 31s · done 20:40

❯ Primera etapa del plan: el recuento de bolas con el caso n = 0. Antes de editar, dime qué ficheros cambiarán y qué
  prueba añadirás.

⏺ Checking whether the ball count stage already exists
  ⎿  $ git status --short src tests && grep -n "tripledBallCount\|n = 0\|\[0, 0\]" src/multiball.js
     tests/multiball.test.js && node --test --test-name-pattern="recuento" tests/multiball.test.js 2>&1 | grep -E
     "^✔|^✖|ℹ (pass|fail)"

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ git status --short src tests && grep -n "tripledBallCount\|n = 0\|\[0, 0\]" src/multiball.js
   │ tests/multiball.test.js && node --test --test-name-pattern="recuento" tests/multiball.test.js 2>&1 | grep -E
   │ "^✔|^✖|ℹ (pass|fail)"
   Check whether the ball count stage already exists

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don’t ask again for: node --test --test-name-pattern="recuento" tests/multiball.test.js
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 069

❯ De acuerdo, adelante con esta etapa.

⏺ Sigo el primer camino: separo el caso n = 0 en una prueba propia dentro de tests/multiball.test.js, sin tocar src/.

  Read 1 file

⏺ Update(tests/multiball.test.js)

⏺ Running the count tests, full suite and linting
  ⎿  $ node --test --test-name-pattern="cero bolas|recuento" tests/multiball.test.js 2>&1 | grep -E "^✔|^✖|ℹ
     (pass|fail)"; npm test 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; git status --short src
     tests

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 tests/multiball.test.js
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 29
 30  // Recuento y tope (FR-001, FR-002)
 31
 32 -test('el recuento triplica hasta el tope de 200, empezando por n = 0', () => {
 33 -  const table = [[0, 0], [1, 3], [2, 6], [50, 150], [66, 198], [67, 200], [199, 200], [200, 200]];
 32 +test('triplicar cero bolas no crea ninguna', () => {
 33 +  assert.equal(tripledBallCount(0), 0);
 34 +  // Tampoco consume identificadores: el siguiente id libre sigue siendo el mismo.
 35 +  assert.deepEqual(tripleBalls([], 5), { balls: [], nextId: 5 });
 36 +});
 37 +
 38 +test('el recuento triplica hasta el tope de 200', () => {
 39 +  const table = [[1, 3], [2, 6], [50, 150], [66, 198], [67, 200], [199, 200], [200, 200]];
 40    for (const [n, expected] of table) {
 41      assert.equal(tripledBallCount(n), expected, `n = ${n}`);
 42    }
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to multiball.test.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 070

  ⎿  Added 8 lines, removed 2 lines
      29
      30  // Recuento y tope (FR-001, FR-002)
      31
      32 -test('el recuento triplica hasta el tope de 200, empezando por n = 0', () => {
      33 -  const table = [[0, 0], [1, 3], [2, 6], [50, 150], [66, 198], [67, 200], [199, 200], [200, 200]];
      32 +test('triplicar cero bolas no crea ninguna', () => {
      33 +  assert.equal(tripledBallCount(0), 0);
      34 +  // Tampoco consume identificadores: el siguiente id libre sigue siendo el mismo.
      35 +  assert.deepEqual(tripleBalls([], 5), { balls: [], nextId: 5 });
      36 +});
      37 +
      38 +test('el recuento triplica hasta el tope de 200', () => {
      39 +  const table = [[1, 3], [2, 6], [50, 150], [66, 198], [67, 200], [199, 200], [200, 200]];
      40    for (const [n, expected] of table) {
      41      assert.equal(tripledBallCount(n), expected, `n = ${n}`);
      42    }

  Running the count tests, full suite and linting
  ⎿  $ node --test --test-name-pattern="cero bolas|recuento" tests/multiball.test.js 2>&1 | grep -E "^✔|^✖|ℹ
     (pass|fail)"; npm test 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; git status --short src
     tests

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ node --test --test-name-pattern="cero bolas|recuento" tests/multiball.test.js 2>&1 | grep -E "^✔|^✖|ℹ
   │ (pass|fail)"; npm test 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; git status --short
   │ src tests
   Run the count tests, full suite and lint

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don’t ask again for: node --test --test-name-pattern="cero bolas|recuento" tests/multiball.test.js
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 071

      36 +});
      37 +
      38 +test('el recuento triplica hasta el tope de 200', () => {
      39 +  const table = [[1, 3], [2, 6], [50, 150], [66, 198], [67, 200], [199, 200], [200, 200]];
      40    for (const [n, expected] of table) {
      41      assert.equal(tripledBallCount(n), expected, `n = ${n}`);
      42    }

  Ran 1 shell command

⏺ La prueba nueva y la batería completa pasan (38 de 38), pero lint falla por un fichero ajeno que apareció después,
  .claude/hooks/proteger-ratificadas.mjs, y lo estoy leyendo antes de decidir.

  Listed 1 directory

⏺ El hook es un script de Node que ESLint analiza sin sus globales (process, console), así que añado su carpeta al
  bloque de eslint.config.js que ya las declara para tests/ y scripts/, sin tocar el hook.

⏺ Update(eslint.config.js)

⏺ Rerunning lint and showing working tree
  ⎿  $ npm run lint 2>&1 | tail -n +4; echo "lint: $?"; git status --short

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 eslint.config.js
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
  9      languageOptions: { globals: globals.browser },
 10    },
 11    {
 12 -    files: ['tests/**/*.js', 'scripts/**/*.mjs', '*.config.js'],
 12 +    files: ['tests/**/*.js', 'scripts/**/*.mjs', '.claude/hooks/**/*.mjs', '*.config.js'],
 13      languageOptions: { globals: globals.node },
 14    },
 15  ];
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to eslint.config.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 072

  Ran 1 shell command

⏺ La prueba nueva y la batería completa pasan (38 de 38), pero lint falla por un fichero ajeno que apareció después,
  .claude/hooks/proteger-ratificadas.mjs, y lo estoy leyendo antes de decidir.

  Listed 1 directory

⏺ El hook es un script de Node que ESLint analiza sin sus globales (process, console), así que añado su carpeta al
  bloque de eslint.config.js que ya las declara para tests/ y scripts/, sin tocar el hook.

⏺ Update(eslint.config.js)
  ⎿  Added 1 line, removed 1 line
       9      languageOptions: { globals: globals.browser },
      10    },
      11    {
      12 -    files: ['tests/**/*.js', 'scripts/**/*.mjs', '*.config.js'],
      12 +    files: ['tests/**/*.js', 'scripts/**/*.mjs', '.claude/hooks/**/*.mjs', '*.config.js'],
      13      languageOptions: { globals: globals.node },
      14    },
      15  ];

⏺ Rerunning lint and showing working tree
  ⎿  $ npm run lint 2>&1 | tail -n +4; echo "lint: $?"; git status --short

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   npm run lint 2>&1 | tail -n +4; echo "lint: $?"; git status --short
   Rerun lint and show working tree

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don’t ask again for: echo "lint: $?"
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 076

   1 // Aparición de bolas al romper un x3, hasta el tope de 200 (FR-001, FR-002).
   2 // Los auxiliares están copiados a propósito: el fichero no depende de otros
   3 // módulos de prueba, para poder ratificarlo sin que un cambio ajeno lo altere.
   4 import { test } from 'node:test';
   5 import assert from 'node:assert/strict';
   6 import { createGame, update, speedBonus, TRIPLE_BRICK_POINTS } from '../src/game.js';
   7
   8 const DT = 1 / 60;
   9
  10 function brick(x, y, kind = 'normal') {
  11   return { x, y, w: 40, h: 16, row: 0, kind, points: kind === 'x3' ? TRIPLE_BRICK_POINTS : 10, alive: true };
  12 }
  13
  14 // n bolas justo debajo de un ladrillo en (200, 100): lo tocan en el siguiente fotograma.
  15 function ballsUnder(n) {
  16   return Array.from({ length: n }, (_, id) => ({ id, x: 220, y: 124, vx: 0, vy: -200 }));
  17 }
  18
  19 function playing(options) {
  20   // Un ladrillo lejano evita que la partida termine al romper el del escenario.
  21   const state = createGame({ ...options, bricks: [...options.bricks, brick(0, 0)] });
  22   state.status = 'playing';
  23   return state;
  24 }
  25
  26 for (const [n, expected] of [[1, 3], [2, 6], [199, 200], [200, 200]]) {
  27   test(`romper un x3 con ${n} bolas deja ${expected}`, () => {
  28     const x3 = brick(200, 100, 'x3');
  29     const state = playing({ bricks: [x3], balls: ballsUnder(n) });
  30     update(state, DT);
  31     assert.equal(x3.alive, false);
  32     assert.equal(state.balls.length, expected);
  33     assert.equal(state.score, TRIPLE_BRICK_POINTS + speedBonus(200));
  34   });
  35 }
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to create tope-200.test.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 077

      10 function brick(x, y, kind = 'normal') {
     … +26 lines

⏺ Update(tests/multiball.test.js)

⏺ Update(README.md)

⏺ Update(docs/especificacion-multibola.md)

⏺ Update(docs/especificacion-multibola.md)

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 tests/multiball.test.js
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 80    assert.equal(createGame({ balls: ballsUnder(200) }).balls.length, 200);
 81  });
 82
 83 -// Aparición al romper un x3
 83 +// Aparición al romper un x3 (el tope con 1, 2, 199 y 200 bolas está en tope-200.test.js)
 84
 85 -for (const [n, expected] of [[1, 3], [2, 6], [199, 200], [200, 200]]) {
 86 -  test(`romper un x3 con ${n} bolas deja ${expected}`, () => {
 87 -    const x3 = brick(200, 100, 'x3');
 88 -    const state = playing({ bricks: [x3], balls: ballsUnder(n) });
 89 -    update(state, DT);
 90 -    assert.equal(x3.alive, false);
 91 -    assert.equal(state.balls.length, expected);
 92 -    assert.equal(state.score, X3_SCORE);
 93 -  });
 94 -}
 95 -
 85  test('dos x3 rotos en el mismo fotograma multiplican uno tras otro: 2 → 6 → 18', () => {
 86    const state = playing({
 87      bricks: [brick(100, 100, 'x3'), brick(300, 100, 'x3')],
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to multiball.test.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 078

      84
      85 -for (const [n, expected] of [[1, 3], [2, 6], [199, 200], [200, 200]]) {
      86 -  test(`romper un x3 con ${n} bolas deja ${expected}`, () => {
      87 -    const x3 = brick(200, 100, 'x3');
      88 -    const state = playing({ bricks: [x3], balls: ballsUnder(n) });
      89 -    update(state, DT);
      90 -    assert.equal(x3.alive, false);
      91 -    assert.equal(state.balls.length, expected);
      92 -    assert.equal(state.score, X3_SCORE);
      93 -  });
      94 -}
      95 -
      85  test('dos x3 rotos en el mismo fotograma multiplican uno tras otro: 2 → 6 → 18', () => {
      86    const state = playing({
      87      bricks: [brick(100, 100, 'x3'), brick(300, 100, 'x3')],

⏺ Update(README.md)

⏺ Update(docs/especificacion-multibola.md)

⏺ Update(docs/especificacion-multibola.md)

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 README.md
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 35  - `src/game.js`: la lógica del juego, sin navegador (estado, movimiento, choques, puntuación y fin de partida).
 36  - `src/multiball.js`: las reglas puras de la multibola (recuento con tope y reparto de las bolas nuevas).
 37  - `src/main.js`: el teclado, el bucle de animación y el dibujo en el canvas.
 38 -- `tests/`: las pruebas de la lógica (`game.test.js`) y de la multibola (`multiball.test.js`).
 38 +- `tests/`: las pruebas de la lógica (`game.test.js`), de la multibola (`multiball.test.js`) y, aparte, de la apari
    +ción de bolas hasta el tope de 200 (`tope-200.test.js`).
 39  - `scripts/observar.mjs`: hace capturas del juego en Chrome sin ventana, a los milisegundos que se le indiquen, par
     a observarlo en marcha.
 40  - `docs/`: la especificación de la multibola y las capturas que la respaldan, en `docs/evidencias/`.
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to README.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 079

      36  - `src/multiball.js`: las reglas puras de la multibola (recuento con tope y reparto de las bolas nuevas
          ).
      37  - `src/main.js`: el teclado, el bucle de animación y el dibujo en el canvas.
      38 -- `tests/`: las pruebas de la lógica (`game.test.js`) y de la multibola (`multiball.test.js`).
      38 +- `tests/`: las pruebas de la lógica (`game.test.js`), de la multibola (`multiball.test.js`) y, aparte,
         + de la aparición de bolas hasta el tope de 200 (`tope-200.test.js`).
      39  - `scripts/observar.mjs`: hace capturas del juego en Chrome sin ventana, a los milisegundos que se le i
          ndiquen, para observarlo en marcha.
      40  - `docs/`: la especificación de la multibola y las capturas que la respaldan, en `docs/evidencias/`.

⏺ Update(docs/especificacion-multibola.md)

⏺ Update(docs/especificacion-multibola.md)

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 docs/especificacion-multibola.md
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 56     - Los ladrillos tienen un campo `kind` (`'normal' | 'x3'`).
 57     - Una función que genera las bolas nuevas a partir de las activas y usa `tripledBallCount` para no pasar de 200.
      Cuando hay que recortar, lo hace de forma determinista.
 58     - `src/main.js` dibuja todas las bolas.
 59 -   - `tests/game.test.js` se migra de `state.ball` a `state.balls`, y se añaden pruebas de aparición con 1, 2, 199
    -y 200 bolas.
 59 +   - `tests/game.test.js` se migra de `state.ball` a `state.balls`. Las pruebas de aparición con 1, 2, 199 y 200 bo
    +las van en su propio fichero, `tests/tope-200.test.js`, que no depende de otros módulos de prueba para poder ratifi
    +carlo.
 60     - `CLAUDE.md` deja de decir «No hay multibola».
 61  3. **Puntuación única con impactos simultáneos.** Se reestructura `update` en `src/game.js`: en cada paso corto ava
     nzan todas las bolas, se recogen los impactos, se ordenan por `(y, x, id)` y se resuelven. Un ladrillo ya destruido
      en ese paso no vuelve a puntuar. Se reutilizan `circleHitsRect` y el rebote por eje de menor penetración que ya ha
     ce `hitBrick`. Las pruebas cubren los impactos simultáneos y el determinismo de FR-004.
 62  4. **Multiplicador y bonus.** El ladrillo x3 da 50 puntos base (FR-006) y dispara la multiplicación de FR-001. El b
     onus por velocidad (FR-007) se calcula una sola vez, con la velocidad de la bola que destruye el ladrillo. Las prue
     bas comprueban la puntuación exacta.
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to especificacion-multibola.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 080

         +199 y 200 bolas van en su propio fichero, `tests/tope-200.test.js`, que no depende de otros módulos de
         +prueba para poder ratificarlo.
      60     - `CLAUDE.md` deja de decir «No hay multibola».
      61  3. **Puntuación única con impactos simultáneos.** Se reestructura `update` en `src/game.js`: en cada pa
          so corto avanzan todas las bolas, se recogen los impactos, se ordenan por `(y, x, id)` y se resuelven.
          Un ladrillo ya destruido en ese paso no vuelve a puntuar. Se reutilizan `circleHitsRect` y el rebote po
          r eje de menor penetración que ya hace `hitBrick`. Las pruebas cubren los impactos simultáneos y el det
          erminismo de FR-004.
      62  4. **Multiplicador y bonus.** El ladrillo x3 da 50 puntos base (FR-006) y dispara la multiplicación de
          FR-001. El bonus por velocidad (FR-007) se calcula una sola vez, con la velocidad de la bola que destru
          ye el ladrillo. Las pruebas comprueban la puntuación exacta.

⏺ Update(docs/especificacion-multibola.md)

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 docs/especificacion-multibola.md
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 83
 84  ## Verificación
 85
 86 -Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento y los casos de impactos simultáneos, determini
    -smo y fin de partida. En `tests/game.test.js`, la partida simulada termina en victoria con una puntuación igual a l
    -a suma de los ladrillos más dos bonus de 13. Las 37 pruebas, el lint y la compilación de producción pasaron el 20 d
    -e noviembre de 2026.
 86 +Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento, con n = 0 en una prueba propia, y los casos d
    +e impactos simultáneos, determinismo y fin de partida. `tests/tope-200.test.js` comprueba la aparición en una parti
    +da real con 1, 2, 199 y 200 bolas. En `tests/game.test.js`, la partida simulada termina en victoria con una puntuac
    +ión igual a la suma de los ladrillos más dos bonus de 13. Las 38 pruebas y el lint pasaron el 20 de noviembre de 20
    +26; la compilación de producción se comprobó ese mismo día, antes de separar estos dos ficheros de pruebas, que no
    +forman parte de ella.
 87
 88  Ese mismo día se observó el juego en Chrome sin ventana con `scripts/observar.mjs`, abriendo `?escenario=multibola`
     :
 89
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to especificacion-multibola.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 081

      83
      84  ## Verificación
      85
      86 -Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento y los casos de impactos simultáneo
         -s, determinismo y fin de partida. En `tests/game.test.js`, la partida simulada termina en victoria con
         -una puntuación igual a la suma de los ladrillos más dos bonus de 13. Las 37 pruebas, el lint y la compi
         -lación de producción pasaron el 20 de noviembre de 2026.
      86 +Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento, con n = 0 en una prueba propia, y
         + los casos de impactos simultáneos, determinismo y fin de partida. `tests/tope-200.test.js` comprueba l
         +a aparición en una partida real con 1, 2, 199 y 200 bolas. En `tests/game.test.js`, la partida simulada
         + termina en victoria con una puntuación igual a la suma de los ladrillos más dos bonus de 13. Las 38 pr
         +uebas y el lint pasaron el 20 de noviembre de 2026; la compilación de producción se comprobó ese mismo
         +día, antes de separar estos dos ficheros de pruebas, que no forman parte de ella.
      87
      88  Ese mismo día se observó el juego en Chrome sin ventana con `scripts/observar.mjs`, abriendo `?escenari
          o=multibola`:
      89

  Running new test file, full suite, linting and building
  ⎿  $ node --test tests/tope-200.test.js 2>&1 | grep -E "^✔|^✖|ℹ (pass|fail)"; npm test 2>&1 | grep -E "ℹ
     (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"; npm run build 2>&1 | grep -E "built|error"; rm
     -rf dist; grep -c "romper un x3 con" tests/*.test.js

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ node --test tests/tope-200.test.js 2>&1 | grep -E "^✔|^✖|ℹ (pass|fail)"; npm test 2>&1 | grep -E "ℹ
   │ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"; npm run build 2>&1 | grep -E "built|error";
   │ rm -rf dist; grep -c "romper un x3 con" tests/*.test.js
   Run new test file, full suite, lint and build

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and allow ~/sdd-931/arkanoid access and node --test tests/tope-200.test.js, "echo \"lint:
      $?\"", and npm run commands
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 082

         +día, antes de separar estos dos ficheros de pruebas, que no forman parte de ella.
      87
      88  Ese mismo día se observó el juego en Chrome sin ventana con `scripts/observar.mjs`, abriendo `?escenari
          o=multibola`:
      89

  Ran 1 shell command

⏺ La compilación también ha pasado, así que simplifico la frase de la especificación que la daba por comprobada antes
  del cambio.

⏺ Update(docs/especificacion-multibola.md)

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 docs/especificacion-multibola.md
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 83
 84  ## Verificación
 85
 86 -Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento, con n = 0 en una prueba propia, y los casos d
    -e impactos simultáneos, determinismo y fin de partida. `tests/tope-200.test.js` comprueba la aparición en una parti
    -da real con 1, 2, 199 y 200 bolas. En `tests/game.test.js`, la partida simulada termina en victoria con una puntuac
    -ión igual a la suma de los ladrillos más dos bonus de 13. Las 38 pruebas y el lint pasaron el 20 de noviembre de 20
    -26; la compilación de producción se comprobó ese mismo día, antes de separar estos dos ficheros de pruebas, que no
    -forman parte de ella.
 86 +Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento, con n = 0 en una prueba propia, y los casos d
    +e impactos simultáneos, determinismo y fin de partida. `tests/tope-200.test.js` comprueba la aparición en una parti
    +da real con 1, 2, 199 y 200 bolas. En `tests/game.test.js`, la partida simulada termina en victoria con una puntuac
    +ión igual a la suma de los ladrillos más dos bonus de 13. Las 38 pruebas, el lint y la compilación de producción pa
    +saron el 20 de noviembre de 2026.
 87
 88  Ese mismo día se observó el juego en Chrome sin ventana con `scripts/observar.mjs`, abriendo `?escenario=multibola`
     :
 89
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to especificacion-multibola.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 086

  36   assert.equal(target.alive, false);
  37   assert.equal(state.score, 30);
  38   assert.ok(state.balls.every((b) => b.vy > 0));
  39 });
  40
  41 test('doscientas bolas sobre el mismo ladrillo suman una sola vez', () => {
  42   const state = playing({ bricks: [brick(200, 100, 'normal', 30)], balls: ballsUnder(200) });
  43   update(state, DT);
  44   assert.equal(state.score, 30);
  45 });
  46
  47 test('varias bolas sobre el mismo x3 lo rompen una vez y multiplican una vez', () => {
  48   const state = playing({ bricks: [brick(200, 100, 'x3')], balls: ballsUnder(2) });
  49   update(state, DT);
  50   assert.equal(state.balls.length, 6);
  51   assert.equal(state.score, TRIPLE_BRICK_POINTS + speedBonus(200));
  52 });
  53
  54 test('dos bolas que tocan el mismo ladrillo en el mismo fotograma pero en subpasos distintos suman sus puntos un
     a sola vez', () => {
  55   const target = brick(200, 100, 'normal', 30);
  56   // La bola rápida avanza 10 px en el fotograma, más que su radio, así que el fotograma
  57   // se parte en dos subpasos de 5 px. Rompe el ladrillo en el primero. La lenta solo
  58   // llega a tocar su borde inferior (y = 116) en el segundo, cuando ya no existe.
  59   const fast = ballUnder(0, { x: 210, vy: -600 });
  60   const slow = ballUnder(1, { x: 230, y: 124.5 });
  61   const state = playing({ bricks: [target], balls: [fast, slow] });
  62   update(state, DT);
  63   assert.equal(target.alive, false);
  64   assert.equal(state.score, 30);
  65   assert.ok(fast.vy > 0, 'la bola que lo rompe rebota');
  66   // La lenta ha alcanzado la zona del ladrillo, pero lo atraviesa sin rebotar.
  67   assert.ok(slow.y - slow.r < target.y + target.h);
  68   assert.ok(slow.vy < 0, 'la que llega en el subpaso siguiente no rebota');
  69 });
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to create puntuacion-unica.test.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 087

           at Test.run (node:internal/test_runner/test:1258:12)
           at async Test.processPendingSubtests (node:internal/test_runner/test:831:7) {
         generatedMessage: false,
         code: 'ERR_ASSERTION',
         actual: false,
         expected: true,
         operator: '==',
         diff: 'simple'
       }

⏺ Update(tests/multiball.test.js)

⏺ Update(tests/multiball.test.js)

  Running the new test file, full suite and linting
  ⎿  $ node --test tests/puntuacion-unica.test.js 2>&1 | grep -E "^✔|^✖|ℹ (pass|fail)|actual|expected|Error"; npm test
     2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 tests/multiball.test.js
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 112    assert.equal(state.balls.length, 9);
 113  });
 114
 115 -test('varias bolas sobre el mismo x3 lo rompen una vez y multiplican una vez', () => {
 116 -  const state = playing({ bricks: [brick(200, 100, 'x3')], balls: ballsUnder(2) });
 117 -  update(state, DT);
 118 -  assert.equal(state.balls.length, 6);
 119 -  assert.equal(state.score, X3_SCORE);
 120 -});
 121 -
 115  test('la bola que cae en el mismo fotograma en que se rompe un x3 no cuenta para el triple', () => {
 116    const height = 360;
 117    const state = playing({
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to multiball.test.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 088

  Running the new test file, full suite and linting
  ⎿  $ node --test tests/puntuacion-unica.test.js 2>&1 | grep -E "^✔|^✖|ℹ (pass|fail)|actual|expected|Error"; npm test
     2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 tests/multiball.test.js
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 122    assert.equal(state.balls.length, 6);
 123  });
 124
 125 -// Puntuación única e impactos simultáneos (FR-003, ADR-003)
 125 +// Orden de los impactos (ADR-003) y bonus (FR-007). La puntuación única de FR-003
 126 +// está en puntuacion-unica.test.js.
 127
 127 -test('dos bolas sobre el mismo ladrillo normal suman sus puntos una sola vez y ambas rebotan', () => {
 128 -  const target = brick(200, 100, 'normal', 30);
 129 -  const state = playing({ bricks: [target], balls: ballsUnder(2) });
 130 -  update(state, DT);
 131 -  assert.equal(target.alive, false);
 132 -  assert.equal(state.score, 30);
 133 -  assert.ok(state.balls.every((b) => b.vy > 0));
 134 -});
 135 -
 136 -test('doscientas bolas sobre el mismo ladrillo suman una sola vez', () => {
 137 -  const state = playing({ bricks: [brick(200, 100, 'normal', 30)], balls: ballsUnder(200) });
 138 -  update(state, DT);
 139 -  assert.equal(state.score, 30);
 140 -});
 141 -
 128  test('el bonus usa la velocidad de la bola de menor y, aunque tenga mayor id', () => {
 129    // La de id 7 es más rápida y tras moverse queda más arriba (118,3 frente a 120,7).
 130    const state = playing({
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to multiball.test.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 089

     test at tests/puntuacion-unica.test.js:54:1
     ✖ dos bolas que tocan el mismo ladrillo en el mismo fotograma pero en subpasos distintos suman sus puntos una sola
     vez (0.393084ms)
       AssertionError [ERR_ASSERTION]: la bola que lo rompe rebota
           at TestContext.<anonymous> (file://~/sdd-931/arkanoid/tests/puntuacion-unica.test.js:65:10)
           at Test.runInAsyncScope (node:async_hooks:226:14)
           at Test.run (node:internal/test_runner/test:1201:25)
           at Test.processPendingSubtests (node:internal/test_runner/test:831:18)
           at Test.postRun (node:internal/test_runner/test:1330:19)
           at Test.run (node:internal/test_runner/test:1258:12)
           at async Test.processPendingSubtests (node:internal/test_runner/test:831:7) {
         generatedMessage: false,
         code: 'ERR_ASSERTION',
         actual: false,
         expected: true,
         operator: '==',
         diff: 'simple'
       }

⏺ Running the new test file, full suite and linting
  ⎿  $ node --test tests/puntuacion-unica.test.js 2>&1 | grep -E "^✔|^✖|ℹ (pass|fail)|actual|expected|Error"; npm test
     2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ node --test tests/puntuacion-unica.test.js 2>&1 | grep -E "^✔|^✖|ℹ (pass|fail)|actual|expected|Error"; npm test
   │ 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"
   Run the new test file, full suite and lint

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don't ask again for node --test tests/puntuacion-unica.test.js and "echo \"lint: $?\"" commands in
      ~/sdd-931/arkanoid
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 090

         generatedMessage: false,
         code: 'ERR_ASSERTION',
         actual: false,
         expected: true,
         operator: '==',
         diff: 'simple'
       }

  Ran 1 shell command

⏺ La prueba estaba mal, no el juego: createGame copia las bolas, así que la comprobación miraba los objetos originales.
  Ahora voy a hacer que la prueba lea las bolas del estado usando su id.

⏺ Update(tests/puntuacion-unica.test.js)

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 tests/puntuacion-unica.test.js
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 56    // La bola rápida avanza 10 px en el fotograma, más que su radio, así que el fotograma
 57    // se parte en dos subpasos de 5 px. Rompe el ladrillo en el primero. La lenta solo
 58    // llega a tocar su borde inferior (y = 116) en el segundo, cuando ya no existe.
 59 -  const fast = ballUnder(0, { x: 210, vy: -600 });
 60 -  const slow = ballUnder(1, { x: 230, y: 124.5 });
 61 -  const state = playing({ bricks: [target], balls: [fast, slow] });
 59 +  const state = playing({
 60 +    bricks: [target],
 61 +    balls: [ballUnder(0, { x: 210, vy: -600 }), ballUnder(1, { x: 230, y: 124.5 })],
 62 +  });
 63 +  // createGame copia las bolas: hay que leer las del estado.
 64 +  const fast = state.balls.find((b) => b.id === 0);
 65 +  const slow = state.balls.find((b) => b.id === 1);
 66    update(state, DT);
 67    assert.equal(target.alive, false);
 68    assert.equal(state.score, 30);
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to puntuacion-unica.test.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 091

      59 -  const fast = ballUnder(0, { x: 210, vy: -600 });
      60 -  const slow = ballUnder(1, { x: 230, y: 124.5 });
      61 -  const state = playing({ bricks: [target], balls: [fast, slow] });
      59 +  const state = playing({
      60 +    bricks: [target],
      61 +    balls: [ballUnder(0, { x: 210, vy: -600 }), ballUnder(1, { x: 230, y: 124.5 })],
      62 +  });
      63 +  // createGame copia las bolas: hay que leer las del estado.
      64 +  const fast = state.balls.find((b) => b.id === 0);
      65 +  const slow = state.balls.find((b) => b.id === 1);
      66    update(state, DT);
      67    assert.equal(target.alive, false);
      68    assert.equal(state.score, 30);

⏺ Running the new tests and a control with only the slow ball
  ⎿  $ node --test tests/puntuacion-unica.test.js 2>&1 | grep -E "^✔|^✖|ℹ (pass|fail)"; node -e "
     import('./src/game.js').then(({createGame,update})=>{
     const b=()=>({x:200,y:100,w:40,h:16,row:0,kind:'normal',points:30,alive:true});
     const s=createGame({bricks:[b(),{...b(),x:0,y:0}],balls:[{id:1,x:230,y:1…

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ node --test tests/puntuacion-unica.test.js 2>&1 | grep -E "^✔|^✖|ℹ (pass|fail)"; node -e "
   │ import('./src/game.js').then(({createGame,update})=>{
   │ const b=()=>({x:200,y:100,w:40,h:16,row:0,kind:'normal',points:30,alive:true});
   │ const s=createGame({bricks:[b(),{...b(),x:0,y:0}],balls:[{id:1,x:230,y:124.5,vx:0,vy:-200}]});s.status='playing'
   │ ;update(s,1/60);
   │ console.log('control, lenta sola:', s.score, s.balls[0].vy>0?'rebota':'no rebota');});"
   Run the new tests and a control with only the slow ball

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don't ask again for node --test tests/puntuacion-unica.test.js and node -e ' commands in
      ~/sdd-931/arkanoid
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 092

  ⎿  Added 7 lines, removed 3 lines
      56    // La bola rápida avanza 10 px en el fotograma, más que su radio, así que el fotograma
      57    // se parte en dos subpasos de 5 px. Rompe el ladrillo en el primero. La lenta solo
      58    // llega a tocar su borde inferior (y = 116) en el segundo, cuando ya no existe.
      59 -  const fast = ballUnder(0, { x: 210, vy: -600 });
      60 -  const slow = ballUnder(1, { x: 230, y: 124.5 });
      61 -  const state = playing({ bricks: [target], balls: [fast, slow] });
      59 +  const state = playing({
      60 +    bricks: [target],
      61 +    balls: [ballUnder(0, { x: 210, vy: -600 }), ballUnder(1, { x: 230, y: 124.5 })],
      62 +  });
      63 +  // createGame copia las bolas: hay que leer las del estado.
      64 +  const fast = state.balls.find((b) => b.id === 0);
      65 +  const slow = state.balls.find((b) => b.id === 1);
      66    update(state, DT);
      67    assert.equal(target.alive, false);
      68    assert.equal(state.score, 30);

  Ran 1 shell command

⏺ La prueba nueva pasa y la de control confirma que distingue los dos casos; ahora actualizo la especificación y el
  README.

  Locating the lines to update in spec and README

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ grep -n "Rebote en impactos simultáneos\|Orden de y en ADR-003\|38 pruebas\|tope-200.test.js\` comprueba\|Si
   │ varias bolas golpean\|tope-200.test.js\`)" docs/especificacion-multibola.md README.md
   Locate the lines to update in spec and README

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don’t ask again for: grep *
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 093

  Searched for 1 pattern

⏺ Las pruebas ya están; me falta anotar la interpretación por subpaso en la especificación y en el README.

⏺ Update(docs/especificacion-multibola.md)

⏺ Update(docs/especificacion-multibola.md)

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 docs/especificacion-multibola.md
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 75  - **Bolas que caen.** Salen del juego antes de resolver los ladrillos de ese paso. Por eso, si una cae en el mismo
     paso en que otra rompe un x3, no cuenta para el triple: de 3 bolas quedan 6, no 9.
 76  - **Derrota.** La partida se pierde cuando no queda ninguna bola, y perder una de varias no tiene castigo.
 77  - **Victoria y derrota a la vez.** Se comprueba primero la victoria. Además, la bola que rompe el último ladrillo s
     igue en juego, así que con estas reglas no pueden darse las dos a la vez.
 78 -- **Rebote en impactos simultáneos.** Todas las bolas que tocan el ladrillo rebotan, aunque solo la primera lo dest
    -ruya y puntúe.
 78 +- **Rebote en impactos simultáneos.** Todas las bolas que tocan el ladrillo en el mismo subpaso rebotan, aunque sol
    +o la primera lo destruya y puntúe. La que llega en un subpaso posterior lo encuentra ya destruido y lo atraviesa.
 79 +- **Simultaneidad por subpaso, no por fotograma.** ADR-003 habla de los impactos de un fotograma, pero el código lo
    +s recoge y ordena en cada subpaso. Si el fotograma tiene un solo subpaso, ambas cosas coinciden. En el navegador pu
    +ede tener dos: `main.js` admite un `dt` de hasta 1/30 s, y a 260 px/s la bola avanza 8,7 px, más que su radio. En e
    +se caso, la bola que toca el ladrillo en el primer subpaso lo destruye y cuenta para el bonus aunque otra, en el se
    +gundo, tenga menor `y`. FR-003 se cumple igual, porque un ladrillo destruido no vuelve a puntuar en ningún subpaso.
    + Ordenar el fotograma entero exigiría mantener los ladrillos vivos hasta su final, y una misma bola podría tocarlos
    + en varios subpasos; por eso se prefirió esta interpretación (`tests/puntuacion-unica.test.js`).
 80  - **Una bola en la esquina de dos ladrillos.** Toca como mucho un ladrillo por paso, el primero de la lista: el com
     portamiento que ya tenía el juego.
 81  - **Choques entre bolas.** No hay: las bolas se atraviesan.
 82  - **Orden de y en ADR-003.** Ascendente de arriba abajo en pantalla (menor `y` primero), con la posición de la bola
      después de moverse.
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to especificacion-multibola.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 094

      82  - **Orden de y en ADR-003.** Ascendente de arriba abajo en pantalla (menor `y` primero), con la posició
          n de la bola después de moverse.

⏺ Update(docs/especificacion-multibola.md)

⏺ Update(README.md)

⏺ Update(README.md)

  Final tests, lint, build and per-file test counts
  ⎿  $ npm test 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"; npm run build
     2>&1 | grep -E "built|error"; rm -rf dist; grep -c "^test(" tests/*.test.js

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 docs/especificacion-multibola.md
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 84
 85  ## Verificación
 86
 87 -Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento, con n = 0 en una prueba propia, y los casos d
    -e impactos simultáneos, determinismo y fin de partida. `tests/tope-200.test.js` comprueba la aparición en una parti
    -da real con 1, 2, 199 y 200 bolas. En `tests/game.test.js`, la partida simulada termina en victoria con una puntuac
    -ión igual a la suma de los ladrillos más dos bonus de 13. Las 38 pruebas, el lint y la compilación de producción pa
    -saron el 20 de noviembre de 2026.
 87 +Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento, con n = 0 en una prueba propia, y los casos d
    +e orden de impactos, bonus, determinismo y fin de partida. `tests/tope-200.test.js` comprueba la aparición en una p
    +artida real con 1, 2, 199 y 200 bolas. `tests/puntuacion-unica.test.js` comprueba que cada ladrillo puntúa una vez
    +con 2 y con 200 bolas, también sobre un x3, y cuando dos bolas lo tocan en subpasos distintos de un mismo fotograma
    +. En `tests/game.test.js`, la partida simulada termina en victoria con una puntuación igual a la suma de los ladril
    +los más dos bonus de 13. Las 39 pruebas, el lint y la compilación de producción pasaron el 20 de noviembre de 2026.
 88
 89  Ese mismo día se observó el juego en Chrome sin ventana con `scripts/observar.mjs`, abriendo `?escenario=multibola`
     :
 90
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to especificacion-multibola.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 095

      89  Ese mismo día se observó el juego en Chrome sin ventana con `scripts/observar.mjs`, abriendo `?escenari
          o=multibola`:
      90

⏺ Update(README.md)

⏺ Update(README.md)

⏺ Final tests, lint, build and per-file test counts
  ⎿  $ npm test 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"; npm run build
     2>&1 | grep -E "built|error"; rm -rf dist; grep -c "^test(" tests/*.test.js

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 README.md
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 12
 13  Los dos ladrillos amarillos marcados con «x3» triplican todas las bolas que haya en juego, hasta un máximo de 200:
     con una bola quedan tres, con tres quedan nueve, y con 67 o más se llega a 200 y ya no se pasa. Cada x3 da 50 punto
     s más un bonus por la velocidad de la bola que lo rompe (13 puntos a la velocidad normal). Perder una bola no casti
     ga mientras quede otra; la partida solo se pierde cuando caen todas.
 14
 15 -Si varias bolas golpean el mismo ladrillo a la vez, el ladrillo puntúa una sola vez y todas rebotan. Lo rompe la bo
    -la que va primero en el orden (y, x, id), de arriba abajo, de izquierda a derecha y por identificador, y esa bola e
    -s la que cuenta para el bonus. Con las mismas entradas la partida da siempre la misma puntuación.
 15 +Si varias bolas golpean el mismo ladrillo a la vez (en el mismo paso de la simulación, que es más corto que el radi
    +o de la bola), el ladrillo puntúa una sola vez y todas rebotan; la que llega un paso después lo encuentra ya roto y
    + pasa por el hueco. Lo rompe la bola que va primero en el orden (y, x, id), de arriba abajo, de izquierda a derecha
    + y por identificador, y esa bola es la que cuenta para el bonus. Con las mismas entradas la partida da siempre la m
    +isma puntuación.
 16
 17  Para ver la multibola sin tener que acertar al x3, abre el juego con `?escenario=multibola` (por ejemplo, `http://l
     ocalhost:5173/?escenario=multibola`): la bola sale ya lanzada contra el primer x3, con su columna despejada por deb
     ajo.
 18
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to README.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 096

         - rompe la bola que va primero en el orden (y, x, id), de arriba abajo, de izquierda a derecha y por ide
         -ntificador, y esa bola es la que cuenta para el bonus. Con las mismas entradas la partida da siempre la
         - misma puntuación.
      15 +Si varias bolas golpean el mismo ladrillo a la vez (en el mismo paso de la simulación, que es más corto
         + que el radio de la bola), el ladrillo puntúa una sola vez y todas rebotan; la que llega un paso despué
         +s lo encuentra ya roto y pasa por el hueco. Lo rompe la bola que va primero en el orden (y, x, id), de
         +arriba abajo, de izquierda a derecha y por identificador, y esa bola es la que cuenta para el bonus. Co
         +n las mismas entradas la partida da siempre la misma puntuación.
      16
      17  Para ver la multibola sin tener que acertar al x3, abre el juego con `?escenario=multibola` (por ejempl
          o, `http://localhost:5173/?escenario=multibola`): la bola sale ya lanzada contra el primer x3, con su c
          olumna despejada por debajo.
      18

⏺ Update(README.md)

⏺ Final tests, lint, build and per-file test counts
  ⎿  $ npm test 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"; npm run build
     2>&1 | grep -E "built|error"; rm -rf dist; grep -c "^test(" tests/*.test.js

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 README.md
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 35  - `src/game.js`: la lógica del juego, sin navegador (estado, movimiento, choques, puntuación y fin de partida).
 36  - `src/multiball.js`: las reglas puras de la multibola (recuento con tope y reparto de las bolas nuevas).
 37  - `src/main.js`: el teclado, el bucle de animación y el dibujo en el canvas.
 38 -- `tests/`: las pruebas de la lógica (`game.test.js`), de la multibola (`multiball.test.js`) y, aparte, de la apari
    -ción de bolas hasta el tope de 200 (`tope-200.test.js`).
 38 +- `tests/`: las pruebas de la lógica (`game.test.js`) y de la multibola (`multiball.test.js`). Aparte, cada una en
    +su fichero para poder ratificarla, van la aparición de bolas hasta el tope de 200 (`tope-200.test.js`) y la puntuac
    +ión única por ladrillo (`puntuacion-unica.test.js`).
 39  - `scripts/observar.mjs`: hace capturas del juego en Chrome sin ventana, a los milisegundos que se le indiquen, par
     a observarlo en marcha.
 40  - `docs/`: la especificación de la multibola y las capturas que la respaldan, en `docs/evidencias/`.
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to README.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 097

      17  Para ver la multibola sin tener que acertar al x3, abre el juego con `?escenario=multibola` (por ejempl
          o, `http://localhost:5173/?escenario=multibola`): la bola sale ya lanzada contra el primer x3, con su c
          olumna despejada por debajo.
      18

⏺ Update(README.md)
  ⎿  Added 1 line, removed 1 line
      35  - `src/game.js`: la lógica del juego, sin navegador (estado, movimiento, choques, puntuación y fin de p
          artida).
      36  - `src/multiball.js`: las reglas puras de la multibola (recuento con tope y reparto de las bolas nuevas
          ).
      37  - `src/main.js`: el teclado, el bucle de animación y el dibujo en el canvas.
      38 -- `tests/`: las pruebas de la lógica (`game.test.js`), de la multibola (`multiball.test.js`) y, aparte,
         - de la aparición de bolas hasta el tope de 200 (`tope-200.test.js`).
      38 +- `tests/`: las pruebas de la lógica (`game.test.js`) y de la multibola (`multiball.test.js`). Aparte,
         +cada una en su fichero para poder ratificarla, van la aparición de bolas hasta el tope de 200 (`tope-20
         +0.test.js`) y la puntuación única por ladrillo (`puntuacion-unica.test.js`).
      39  - `scripts/observar.mjs`: hace capturas del juego en Chrome sin ventana, a los milisegundos que se le i
          ndiquen, para observarlo en marcha.
      40  - `docs/`: la especificación de la multibola y las capturas que la respaldan, en `docs/evidencias/`.

⏺ Final tests, lint, build and per-file test counts
  ⎿  $ npm test 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"; npm run build
     2>&1 | grep -E "built|error"; rm -rf dist; grep -c "^test(" tests/*.test.js

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ npm test 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"; npm run build
   │ 2>&1 | grep -E "built|error"; rm -rf dist; grep -c "^test(" tests/*.test.js
   Final tests, lint, build and per-file test counts

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and allow ~/sdd-931/arkanoid access and "echo \"lint: $?\"" and npm run commands
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 101

  50   assert.equal(state.score, 30);
  51 });
  52
  53 test('los puntos base del x3 no dependen del número de bolas', () => {
  54   const scoreWith = (n) => {
  55     const balls = Array.from({ length: n }, (_, id) => ballUnder(id));
  56     const state = playing({ bricks: [brick(200, 100, 'x3')], balls });
  57     update(state, DT);
  58     return state.score;
  59   };
  60   assert.equal(scoreWith(1), 60);
  61   assert.equal(scoreWith(200), 60);
  62 });
  63
  64 test('el bonus usa la velocidad de la bola de menor y, aunque tenga mayor id', () => {
  65   // La de id 7 es más rápida y tras moverse queda más arriba (118,3 frente a 120,7).
  66   const state = playing({
  67     bricks: [brick(200, 100, 'x3')],
  68     balls: [ballUnder(4, { vy: -200 }), ballUnder(7, { vy: -340 })],
  69   });
  70   update(state, DT);
  71   // 50 + bonus de 340 px/s (17); con la otra bola serían 50 + 10.
  72   assert.equal(state.score, 67);
  73 });
  74
  75 test('con la misma y, el bonus usa la velocidad de la bola de menor x', () => {
  76   // Las dos suben igual; la de id 1 avanza hacia la derecha pero sigue a la izquierda de la otra.
  77   const state = playing({
  78     bricks: [brick(200, 100, 'x3')],
  79     balls: [ballUnder(0, { x: 230 }), ballUnder(1, { x: 210, vx: 100 })],
  80   });
  81   update(state, DT);
  82   // 50 + bonus de 223,6 px/s (11); con la otra bola serían 50 + 10.
  83   assert.equal(state.score, 61);
  84 });
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to create multiplicador-bonus.test.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 102

 tests/multiball.test.js
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 122    assert.equal(state.balls.length, 6);
 123  });
 124
 125 -// Orden de los impactos (ADR-003) y bonus (FR-007). La puntuación única de FR-003
 126 -// está en puntuacion-unica.test.js.
 125 +// Desempate por id del orden de impactos (ADR-003). La puntuación única de FR-003 está en
 126 +// puntuacion-unica.test.js, y el orden por y y por x, con el bonus, en multiplicador-bonus.test.js.
 127
 128 -test('el bonus usa la velocidad de la bola de menor y, aunque tenga mayor id', () => {
 129 -  // La de id 7 es más rápida y tras moverse queda más arriba (118,3 frente a 120,7).
 130 -  const state = playing({
 131 -    bricks: [brick(200, 100, 'x3')],
 132 -    balls: [ballUnder(4, { vy: -200 }), ballUnder(7, { vy: -340 })],
 133 -  });
 134 -  update(state, DT);
 135 -  assert.equal(state.score, TRIPLE_BRICK_POINTS + speedBonus(340));
 136 -  assert.notEqual(speedBonus(340), speedBonus(200));
 137 -});
 138 -
 139 -test('con la misma y, el bonus usa la velocidad de la bola de menor x', () => {
 140 -  // Las dos suben igual; la de id 1 avanza hacia la derecha pero sigue a la izquierda de la otra.
 141 -  const state = playing({
 142 -    bricks: [brick(200, 100, 'x3')],
 143 -    balls: [ballUnder(0, { x: 230 }), ballUnder(1, { x: 210, vx: 100 })],
 144 -  });
 145 -  update(state, DT);
 146 -  assert.equal(state.score, TRIPLE_BRICK_POINTS + speedBonus(Math.hypot(100, 200)));
 147 -  assert.notEqual(speedBonus(Math.hypot(100, 200)), speedBonus(200));
 148 -});
 149 -
 128  test('con la misma y y la misma x, el impacto de menor id va primero', () => {
 129    const at = (id) => ({ ball: { id, x: 220, y: 120 } });
 130    const order = [at(7), at(4), at(5)].sort(compareImpacts).map((i) => i.ball.id);
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to multiball.test.js?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 103

      134 -  update(state, DT);
      135 -  assert.equal(state.score, TRIPLE_BRICK_POINTS + speedBonus(340));
      136 -  assert.notEqual(speedBonus(340), speedBonus(200));
      137 -});
      138 -
      139 -test('con la misma y, el bonus usa la velocidad de la bola de menor x', () => {
      140 -  // Las dos suben igual; la de id 1 avanza hacia la derecha pero sigue a la izquierda de la otra.
      141 -  const state = playing({
      142 -    bricks: [brick(200, 100, 'x3')],
      143 -    balls: [ballUnder(0, { x: 230 }), ballUnder(1, { x: 210, vx: 100 })],
      144 -  });
      145 -  update(state, DT);
      146 -  assert.equal(state.score, TRIPLE_BRICK_POINTS + speedBonus(Math.hypot(100, 200)));
      147 -  assert.notEqual(speedBonus(Math.hypot(100, 200)), speedBonus(200));
      148 -});
      149 -
      128  test('con la misma y y la misma x, el impacto de menor id va primero', () => {
      129    const at = (id) => ({ ball: { id, x: 220, y: 120 } });
      130    const order = [at(7), at(4), at(5)].sort(compareImpacts).map((i) => i.ball.id);

⏺ Running the new test file, full suite and linting
  ⎿  $ node --test tests/multiplicador-bonus.test.js 2>&1 | grep -E "^✔|^✖|ℹ (pass|fail)|actual|expected"; npm test 2>&1
     | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ node --test tests/multiplicador-bonus.test.js 2>&1 | grep -E "^✔|^✖|ℹ (pass|fail)|actual|expected"; npm test
   │ 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint 2>&1 | tail -n +4; echo "lint: $?"
   Run the new test file, full suite and lint

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don't ask again for node --test tests/multiplicador-bonus.test.js and "echo \"lint: $?\"" commands in
      ~/sdd-931/arkanoid
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 104

      137 -});
      138 -
      139 -test('con la misma y, el bonus usa la velocidad de la bola de menor x', () => {
      140 -  // Las dos suben igual; la de id 1 avanza hacia la derecha pero sigue a la izquierda de la otra.
      141 -  const state = playing({
      142 -    bricks: [brick(200, 100, 'x3')],
      143 -    balls: [ballUnder(0, { x: 230 }), ballUnder(1, { x: 210, vx: 100 })],
      144 -  });
      145 -  update(state, DT);
      146 -  assert.equal(state.score, TRIPLE_BRICK_POINTS + speedBonus(Math.hypot(100, 200)));
      147 -  assert.notEqual(speedBonus(Math.hypot(100, 200)), speedBonus(200));
      148 -});
      149 -
      128  test('con la misma y y la misma x, el impacto de menor id va primero', () => {
      129    const at = (id) => ({ ball: { id, x: 220, y: 120 } });
      130    const order = [at(7), at(4), at(5)].sort(compareImpacts).map((i) => i.ball.id);

  Ran 1 shell command

⏺ Las 7 pruebas nuevas pasan y la batería suma 44, una más de lo anunciado; la constante de 50 puntos base ya tiene
  prueba propia. Ahora actualizo la especificación y el README.

⏺ Locating the verification and structure lines to update

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ grep -n "puntuacion-unica.test.js\` comprueba\|39 pruebas\|casos de orden de impactos, bonus"
   │ docs/especificacion-multibola.md | cut -c1-120; grep -n "puntuacion-unica.test.js\`, pendiente" README.md | cut
   │ -c1-80
   Locate the verification and structure lines to update

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don’t ask again for: grep *
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 105

⏺ Update(docs/especificacion-multibola.md)

⏺ Update(README.md)

⏺ Checking README line and rerunning tests, linting and building
  ⎿  $ sed -n 38p README.md; npm test 2>&1 | grep -E "ℹ (tests|fail)"; npm run lint >/dev/null 2>&1; echo "lint: $?";
     npm run build 2>&1 | grep -E "built|error"; rm -rf dist; ls tests

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 docs/especificacion-multibola.md
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 84
 85  ## Verificación
 86
 87 -Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento, con n = 0 en una prueba propia, y los casos d
    -e orden de impactos, bonus, determinismo y fin de partida. `tests/tope-200.ratificada.test.js` comprueba la aparici
    -ón en una partida real con 1, 2, 199 y 200 bolas. `tests/puntuacion-unica.test.js` comprueba que cada ladrillo punt
    -úa una vez con 2 y con 200 bolas, también sobre un x3, y cuando dos bolas lo tocan en subpasos distintos de un mism
    -o fotograma. En `tests/game.test.js`, la partida simulada termina en victoria con una puntuación igual a la suma de
    - los ladrillos más dos bonus de 13. Las 39 pruebas, el lint y la compilación de producción pasaron el 20 de noviemb
    -re de 2026.
 87 +Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento, con n = 0 en una prueba propia, y los casos d
    +e desempate por id, determinismo y fin de partida. `tests/tope-200.ratificada.test.js` comprueba la aparición en un
    +a partida real con 1, 2, 199 y 200 bolas. `tests/puntuacion-unica.test.js` comprueba que cada ladrillo puntúa una v
    +ez con 2 y con 200 bolas, también sobre un x3, y cuando dos bolas lo tocan en subpasos distintos de un mismo fotogr
    +ama. En `tests/game.test.js`, la partida simulada termina en victoria con una puntuación igual a la suma de los lad
    +rillos más dos bonus de 13. Las 39 pruebas, el lint y la compilación de producción pasaron el 20 de noviembre de 20
    +26.
 88
 89  Ese mismo día se observó el juego en Chrome sin ventana con `scripts/observar.mjs`, abriendo `?escenario=multibola`
     :
 90
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to especificacion-multibola.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 106

⏺ Update(README.md)

  Checking README line and rerunning tests, linting and building
  ⎿  $ sed -n 38p README.md; npm test 2>&1 | grep -E "ℹ (tests|fail)"; npm run lint >/dev/null 2>&1; echo "lint: $?";
     npm run build 2>&1 | grep -E "built|error"; rm -rf dist; ls tests

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 docs/especificacion-multibola.md
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 84
 85  ## Verificación
 86
 87 -Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento, con n = 0 en una prueba propia, y los casos d
    -e desempate por id, determinismo y fin de partida. `tests/tope-200.ratificada.test.js` comprueba la aparición en un
    -a partida real con 1, 2, 199 y 200 bolas. `tests/puntuacion-unica.test.js` comprueba que cada ladrillo puntúa una v
    -ez con 2 y con 200 bolas, también sobre un x3, y cuando dos bolas lo tocan en subpasos distintos de un mismo fotogr
    -ama. En `tests/game.test.js`, la partida simulada termina en victoria con una puntuación igual a la suma de los lad
    -rillos más dos bonus de 13. Las 39 pruebas, el lint y la compilación de producción pasaron el 20 de noviembre de 20
    -26.
 87 +Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento, con n = 0 en una prueba propia, y los casos d
    +e desempate por id, determinismo y fin de partida. `tests/tope-200.ratificada.test.js` comprueba la aparición en un
    +a partida real con 1, 2, 199 y 200 bolas. `tests/puntuacion-unica.test.js` comprueba que cada ladrillo puntúa una v
    +ez con 2 y con 200 bolas, también sobre un x3, y cuando dos bolas lo tocan en subpasos distintos de un mismo fotogr
    +ama. `tests/multiplicador-bonus.test.js` fija los 50 puntos base del x3, la fórmula del bonus (10 a 200 px/s, 13 a
    +260 px/s y a 259,9999 px/s), los 63 puntos exactos de un x3 a la velocidad normal, que los ladrillos normales no su
    +man bonus, que la base no depende del número de bolas y que el bonus usa la bola que gana el orden por `y` y por `x
    +`; casi todo lo que fija son decisiones provisionales, así que conviene ratificarlas antes que el fichero. En `test
    +s/game.test.js`, la partida simulada termina en victoria con una puntuación igual a la suma de los ladrillos más do
    +s bonus de 13. Las 39 pruebas, el lint y la compilación de producción pasaron el 20 de noviembre de 2026.
 88
 89  Ese mismo día se observó el juego en Chrome sin ventana con `scripts/observar.mjs`, abriendo `?escenario=multibola`
     :
 90
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to especificacion-multibola.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 107

⏺ Checking README line and rerunning tests, linting and building
  ⎿  $ sed -n 38p README.md; npm test 2>&1 | grep -E "ℹ (tests|fail)"; npm run lint >/dev/null 2>&1; echo "lint: $?";
     npm run build 2>&1 | grep -E "built|error"; rm -rf dist; ls tests

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 docs/especificacion-multibola.md
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 84
 85  ## Verificación
 86
 87 -Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento, con n = 0 en una prueba propia, y los casos d
    -e desempate por id, determinismo y fin de partida. `tests/tope-200.ratificada.test.js` comprueba la aparición en un
    -a partida real con 1, 2, 199 y 200 bolas. `tests/puntuacion-unica.test.js` comprueba que cada ladrillo puntúa una v
    -ez con 2 y con 200 bolas, también sobre un x3, y cuando dos bolas lo tocan en subpasos distintos de un mismo fotogr
    -ama. `tests/multiplicador-bonus.test.js` fija los 50 puntos base del x3, la fórmula del bonus (10 a 200 px/s, 13 a
    -260 px/s y a 259,9999 px/s), los 63 puntos exactos de un x3 a la velocidad normal, que los ladrillos normales no su
    -man bonus, que la base no depende del número de bolas y que el bonus usa la bola que gana el orden por `y` y por `x
    -`; casi todo lo que fija son decisiones provisionales, así que conviene ratificarlas antes que el fichero. En `test
    -s/game.test.js`, la partida simulada termina en victoria con una puntuación igual a la suma de los ladrillos más do
    -s bonus de 13. Las 39 pruebas, el lint y la compilación de producción pasaron el 20 de noviembre de 2026.
 87 +Las pruebas de `tests/multiball.test.js` cubren la tabla de recuento, con n = 0 en una prueba propia, y los casos d
    +e desempate por id, determinismo y fin de partida. `tests/tope-200.ratificada.test.js` comprueba la aparición en un
    +a partida real con 1, 2, 199 y 200 bolas. `tests/puntuacion-unica.test.js` comprueba que cada ladrillo puntúa una v
    +ez con 2 y con 200 bolas, también sobre un x3, y cuando dos bolas lo tocan en subpasos distintos de un mismo fotogr
    +ama. `tests/multiplicador-bonus.test.js` fija los 50 puntos base del x3, la fórmula del bonus (10 a 200 px/s, 13 a
    +260 px/s y a 259,9999 px/s), los 63 puntos exactos de un x3 a la velocidad normal, que los ladrillos normales no su
    +man bonus, que la base no depende del número de bolas y que el bonus usa la bola que gana el orden por `y` y por `x
    +`; casi todo lo que fija son decisiones provisionales, así que conviene ratificarlas antes que el fichero. En `test
    +s/game.test.js`, la partida simulada termina en victoria con una puntuación igual a la suma de los ladrillos más do
    +s bonus de 13. Las 44 pruebas, el lint y la compilación de producción pasaron el 20 de noviembre de 2026.
 88
 89  Ese mismo día se observó el juego en Chrome sin ventana con `scripts/observar.mjs`, abriendo `?escenario=multibola`
     :
 90
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to especificacion-multibola.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 108

         +ntos base del x3, la fórmula del bonus (10 a 200 px/s, 13 a 260 px/s y a 259,9999 px/s), los 63 puntos
         +exactos de un x3 a la velocidad normal, que los ladrillos normales no suman bonus, que la base no depen
         +de del número de bolas y que el bonus usa la bola que gana el orden por `y` y por `x`; casi todo lo que
         + fija son decisiones provisionales, así que conviene ratificarlas antes que el fichero. En `tests/game.
         +test.js`, la partida simulada termina en victoria con una puntuación igual a la suma de los ladrillos m
         +ás dos bonus de 13. Las 44 pruebas, el lint y la compilación de producción pasaron el 20 de noviembre d
         +e 2026.
      88
      89  Ese mismo día se observó el juego en Chrome sin ventana con `scripts/observar.mjs`, abriendo `?escenari
          o=multibola`:
      90

⏺ Update(README.md)

⏺ Checking README line and rerunning tests, linting and building
  ⎿  $ sed -n 38p README.md; npm test 2>&1 | grep -E "ℹ (tests|fail)"; npm run lint >/dev/null 2>&1; echo "lint: $?";
     npm run build 2>&1 | grep -E "built|error"; rm -rf dist; ls tests

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 README.md
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 35  - `src/game.js`: la lógica del juego, sin navegador (estado, movimiento, choques, puntuación y fin de partida).
 36  - `src/multiball.js`: las reglas puras de la multibola (recuento con tope y reparto de las bolas nuevas).
 37  - `src/main.js`: el teclado, el bucle de animación y el dibujo en el canvas.
 38 -- `tests/`: las pruebas de la lógica (`game.test.js`) y de la multibola (`multiball.test.js`). Aparte, cada una en
    -su fichero, van la aparición de bolas hasta el tope de 200 (`tope-200.ratificada.test.js`, ya ratificada) y la punt
    -uación única por ladrillo (`puntuacion-unica.test.js`, pendiente de ratificar).
 38 +- `tests/`: las pruebas de la lógica (`game.test.js`) y de la multibola (`multiball.test.js`). Aparte, cada una en
    +su fichero, van la aparición de bolas hasta el tope de 200 (`tope-200.ratificada.test.js`, ya ratificada) la puntua
    +ción única por ladrillo (`puntuacion-unica.test.js`) y los puntos del x3 con su bonus por velocidad (`multiplicador
    +-bonus.test.js`), estas dos pendientes de ratificar.
 39  - `scripts/observar.mjs`: hace capturas del juego en Chrome sin ventana, a los milisegundos que se le indiquen, par
     a observarlo en marcha.
 40  - `docs/`: la especificación de la multibola y las capturas que la respaldan, en `docs/evidencias/`.
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to README.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 109

          o=multibola`:
      90

⏺ Update(README.md)
  ⎿  Added 1 line, removed 1 line
      35  - `src/game.js`: la lógica del juego, sin navegador (estado, movimiento, choques, puntuación y fin de p
          artida).
      36  - `src/multiball.js`: las reglas puras de la multibola (recuento con tope y reparto de las bolas nuevas
          ).
      37  - `src/main.js`: el teclado, el bucle de animación y el dibujo en el canvas.
      38 -- `tests/`: las pruebas de la lógica (`game.test.js`) y de la multibola (`multiball.test.js`). Aparte,
         -cada una en su fichero, van la aparición de bolas hasta el tope de 200 (`tope-200.ratificada.test.js`,
         -ya ratificada) y la puntuación única por ladrillo (`puntuacion-unica.test.js`, pendiente de ratificar).
      38 +- `tests/`: las pruebas de la lógica (`game.test.js`) y de la multibola (`multiball.test.js`). Aparte,
         +cada una en su fichero, van la aparición de bolas hasta el tope de 200 (`tope-200.ratificada.test.js`,
         +ya ratificada) la puntuación única por ladrillo (`puntuacion-unica.test.js`) y los puntos del x3 con su
         + bonus por velocidad (`multiplicador-bonus.test.js`), estas dos pendientes de ratificar.
      39  - `scripts/observar.mjs`: hace capturas del juego en Chrome sin ventana, a los milisegundos que se le i
          ndiquen, para observarlo en marcha.
      40  - `docs/`: la especificación de la multibola y las capturas que la respaldan, en `docs/evidencias/`.

  Checking README line and rerunning tests, linting and building
  ⎿  $ sed -n 38p README.md; npm test 2>&1 | grep -E "ℹ (tests|fail)"; npm run lint >/dev/null 2>&1; echo "lint: $?";
     npm run build 2>&1 | grep -E "built|error"; rm -rf dist; ls tests

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ sed -n 38p README.md; npm test 2>&1 | grep -E "ℹ (tests|fail)"; npm run lint >/dev/null 2>&1; echo "lint: $?";
   │ npm run build 2>&1 | grep -E "built|error"; rm -rf dist; ls tests
   Check README line and rerun tests, lint and build

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and allow ~/sdd-931/arkanoid access and "echo \"lint: $?\"" and npm run commands
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 110

      38 -- `tests/`: las pruebas de la lógica (`game.test.js`) y de la multibola (`multiball.test.js`). Aparte,
         -cada una en su fichero, van la aparición de bolas hasta el tope de 200 (`tope-200.ratificada.test.js`,
         -ya ratificada) y la puntuación única por ladrillo (`puntuacion-unica.test.js`, pendiente de ratificar).
      38 +- `tests/`: las pruebas de la lógica (`game.test.js`) y de la multibola (`multiball.test.js`). Aparte,
         +cada una en su fichero, van la aparición de bolas hasta el tope de 200 (`tope-200.ratificada.test.js`,
         +ya ratificada) la puntuación única por ladrillo (`puntuacion-unica.test.js`) y los puntos del x3 con su
         + bonus por velocidad (`multiplicador-bonus.test.js`), estas dos pendientes de ratificar.
      39  - `scripts/observar.mjs`: hace capturas del juego en Chrome sin ventana, a los milisegundos que se le i
          ndiquen, para observarlo en marcha.
      40  - `docs/`: la especificación de la multibola y las capturas que la respaldan, en `docs/evidencias/`.

  Ran 1 shell command

⏺ Falta una coma en la enumeración del README; la corrijo.

⏺ Update(README.md)

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 README.md
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 35  - `src/game.js`: la lógica del juego, sin navegador (estado, movimiento, choques, puntuación y fin de partida).
 36  - `src/multiball.js`: las reglas puras de la multibola (recuento con tope y reparto de las bolas nuevas).
 37  - `src/main.js`: el teclado, el bucle de animación y el dibujo en el canvas.
 38 -- `tests/`: las pruebas de la lógica (`game.test.js`) y de la multibola (`multiball.test.js`). Aparte, cada una en
    -su fichero, van la aparición de bolas hasta el tope de 200 (`tope-200.ratificada.test.js`, ya ratificada) la puntua
    -ción única por ladrillo (`puntuacion-unica.test.js`) y los puntos del x3 con su bonus por velocidad (`multiplicador
    --bonus.test.js`), estas dos pendientes de ratificar.
 38 +- `tests/`: las pruebas de la lógica (`game.test.js`) y de la multibola (`multiball.test.js`). Aparte, cada una en
    +su fichero, van la aparición de bolas hasta el tope de 200 (`tope-200.ratificada.test.js`, ya ratificada), la puntu
    +ación única por ladrillo (`puntuacion-unica.test.js`) y los puntos del x3 con su bonus por velocidad (`multiplicado
    +r-bonus.test.js`), estas dos pendientes de ratificar.
 39  - `scripts/observar.mjs`: hace capturas del juego en Chrome sin ventana, a los milisegundos que se le indiquen, par
     a observarlo en marcha.
 40  - `docs/`: la especificación de la multibola y las capturas que la respaldan, en `docs/evidencias/`.
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to README.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 117

  tests/tope-200.ratificada.test.js

  La orden cambia los casos de tope a 1 → 3, 2 → 6, 149 → 150 y 150 → 150, y actualiza el comentario de la cabecera. El
  nombre del fichero seguirá diciendo 200. Si quieres que coincida, puedes renombrarlo después con ! git mv
  tests/tope-200.ratificada.test.js tests/tope-150.ratificada.test.js; la orden git mv funciona aunque el fichero aún no
  tenga commit, porque ya está en el índice si lo añadiste, y si no lo está basta con un mv.

  Mientras tanto, puedo hacer lo que sí me corresponde:

  - cambiar FR-002 y la tabla de casos en la especificación;
  - poner MAX_BALLS = 150 en src/multiball.js;
  - ajustar las pruebas no ratificadas que dependen de 200 (multiball.test.js, puntuacion-unica.test.js y
    multiplicador-bonus.test.js);
  - actualizar el README y CLAUDE.md.

  Cuando hayas aplicado tu cambio, ejecuto la batería completa para confirmar que todo pasa con 150. ¿Empiezo?

✻ Churned for 15s · done 20:52

❯ He descartado el cambio a 150: la regla sigue siendo MAX_BALLS = 200. Vuelve a leer los ficheros antes de seguir.

  Rechecking the working tree and every reference to the ball cap
  ⎿  $ git log --oneline | wc -l && npm test 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint >/dev/null 2>&1; echo
     "lint: $?"

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ git log --oneline | wc -l && npm test 2>&1 | grep -E "ℹ (tests|pass|fail)"; npm run lint >/dev/null 2>&1; echo
   │ "lint: $?"
   Count commits and run tests and lint

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don’t ask again for: echo "lint: $?"
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Paso 12: comprobar con las herramientas del proyecto

Build, lint y las 44 pruebas pasaron en la terminal. Después probamos dos skills que trae Claude Code: /run, que arranca la aplicación y la usa, y /verify, que la construye y comprueba que el cambio hace lo que debe.

/run jugó con un Chrome sin ventana y encontró algo que ninguna prueba había visto: si pulsas el espacio muy rápido, la bola no sale. La tecla se marca al pulsarla y se borra al soltarla, y si las dos cosas ocurren entre dos fotogramas, el juego nunca llega a verla. Lo comprobamos a mano en el navegador y es cierto. Claude explicó el fallo y propuso el arreglo, pero no lo aplicó: arreglarlo es otra petición.

/verify tardó más de ocho minutos. Ganó una partida con un bot en 73 segundos, comprobó que una ráfaga de pulsaciones sí funciona, repitió el aviso del fallo del saque y dijo con claridad lo que no había podido ver: más de tres bolas en pantalla. De paso guardó una skill verify en .claude/skills/ para la próxima vez, algo que conviene saber porque cambia el repositorio.

Lo que dice el libro (versión 87a)

12. Ejecutar las comprobaciones del proyecto. Volvemos a la terminal y utilizamos los comandos definidos en CLAUDE.md. Si la tecnología elegida los incluye, pueden ser npm run build, npm run lint y npm test. Abrimos además el juego con el comando de arranque del repositorio y observamos los casos jugables de una bola, valores intermedios y el límite, junto con la puntuación y los impactos simultáneos.

El caso n = 0 se comprueba en la función de recuento o en el manejo del estado vacío; no presupone que una bola inexistente destruya un ladrillo. Conservamos tanto las salidas de las herramientas como esa observación. /run y /verify son skills incluidas en Claude Code. La primera arranca el juego y lo prueba como lo haría una persona, y la segunda lo construye y lo ejecuta para comprobar que el cambio hace lo que debe. No hay que confundir /verify con /opsx:verify, de OpenSpec, que revisa la implementación frente a sus artefactos.

En nuestra prueba, /run jugó con un navegador sin ventana y encontró un fallo que las 44 pruebas no veían: un toque rápido de la barra espaciadora no sacaba la bola, y lo confirmamos a mano. Lo explicó sin arreglarlo, y así debe ser, porque corregirlo es una petición nueva que decide la persona. /verify dio el cambio por bueno y dejó en .claude/skills/ una skill verify propia del proyecto, que revisamos como cualquier otro fichero antes de incluirla en el commit.

Salida de npm test en la terminal: 44 pruebas, todas en verde
npm test en la terminal, fuera de Claude: 44 pruebas, 44 en verde y ninguna fallida, en menos de una décima de segundo.
Resultado de /run: el juego funciona pero un toque rápido de la barra espaciadora no saca la bola
/run encontró un fallo real.
Resultado de /verify: partida ganada en 73 segundos con 1236 puntos y sin errores de consola
/verify ganó una partida sin errores en la consola y dejó una skill verify.
Ida y vuelta de turnos 23 a 24: 10 min 25 s de trabajo, 32 herramientas usadas

Turno 23 · 1 min 50 s

Ida: lo que escribimos

/run

Vuelta: lo que contestó Claude

Primero compruebo si alguna skill del proyecto explica cómo arrancar el juego.

  1. Bash grep -Hm1 '^description:' .claude/skills/*/SKILL.md 2>/dev/null; (npx vite --port 5180 --strictPort > [carpeta temporal de la sesión] 2>&1 &) ; for i in $(seq 1 20); do c=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:5180/); [ "$c" = 200 ] && break; sleep 0.3; done; echo "HTTP $c"
  2. Write [carpeta temporal de la sesión]
  3. Bash S=[carpeta temporal de la sesión] node $S/jugar.mjs http://localhost:5180/ $S/run 2>&1 | tail -7
  4. Read [carpeta temporal de la sesión]
  5. Read [carpeta temporal de la sesión]
  6. Read [carpeta temporal de la sesión]
  7. Read [carpeta temporal de la sesión]
  8. Bash S=[carpeta temporal de la sesión] sed -e "s/await key('keyDown', 'Space');\n/X/" $S/jugar.mjs | perl -0pe "s/(\/\/ Sacar y dejar jugar un momento\.\nawait key\('keyDown', 'Space'\);\n)/\$1await sleep(100);\n/" > $S/jugar-pulsacion-larga.mjs && grep -n -A3 "Sacar y dejar" $S/jugar-pulsacion-larga.mjs && node $S/jugar-pulsacio
  9. Read [carpeta temporal de la sesión]
  10. Read [carpeta temporal de la sesión]
  11. Read [carpeta temporal de la sesión]
  12. Bash pkill -f "vite --port 5180"; pgrep -f "vite --port 5180" || echo "servidor parado"

He jugado una partida con el servidor de desarrollo y Chrome sin ventana, controlado con pulsaciones de teclado reales. El juego funciona, pero he encontrado un fallo en el saque: si la tecla espacio se pulsa y se suelta muy deprisa, la pulsación se pierde.

Lo que funciona (en ningún momento hubo errores en la consola de la página):

  • Antes del saque: al mantener la flecha izquierda, la pala se mueve y la bola la acompaña.
  • El saque: con el espacio pulsado 100 ms, la bola sale. A los 1,5 s ha roto un ladrillo verde y el marcador está en 10 puntos.
  • La derrota: sin mover la pala, la bola cae. Aparece «Has perdido» con «Bolas: 0».
  • El reinicio: al pulsar espacio sobre ese mensaje empieza una partida nueva, con la rejilla completa, 0 puntos y la bola sobre la pala.

El fallo. En la primera prueba envié el espacio pulsando y soltando sin pausa, y la bola no salió. El origen está en src/main.js. Al pulsar la tecla se activa keys.launch = true, pero al soltarla se vuelve a poner en false. Si las dos cosas ocurren entre dos fotogramas (menos de unos 16 ms), update nunca llega a ver la tecla pulsada. A una persona le pasará pocas veces, porque las pulsaciones suelen durar más, pero con un toque rápido el juego puede parecer que no responde. El reinicio no falla porque main.js lo hace en el mismo momento de pulsar la tecla, sin esperar al fotograma.

Para arreglarlo basta con que la pulsación del espacio quede guardada hasta que update la use, o con lanzar directamente al pulsar, igual que hace el reinicio. Es un cambio pequeño en src/main.js. No lo he hecho porque solo pediste ejecutar el juego. ¿Lo corrijo?

El controlador que usé (jugar.mjs) está en el directorio temporal de la sesión y no en el repositorio. Si quieres poder repetir esta prueba más adelante, conviene guardarlo como skill del proyecto con /run-skill-generator: recoge el arranque de Vite, Chrome sin ventana y el envío de teclas por el protocolo de depuración. He parado el servidor.

Turno 24 · 8 min 35 s

Ida: lo que escribimos

/verify

Vuelta: lo que contestó Claude

  1. Bash git status --short; git log --oneline | head -8; git diff HEAD --stat; ls .claude/skills/
  2. Bash git diff 3515776..HEAD --stat | tail -25; git diff 3515776..HEAD -- src | grep -c "^[+-]"
  3. Write [carpeta temporal de la sesión]
  4. Bash S=[carpeta temporal de la sesión] (npx vite --port 5181 --strictPort > $S/vite-verify.log 2>&1 &); for i in $(seq 1 20); do [ "$(curl -s -o /dev/null -w '%{http_code}' http://localhost:5181/)" = 200 ] && break; sleep 0.3; done; node $S/verificar.mjs "http://localhost:5181/?escenario=multibola" $S/v 30 2>&1 | tail -14
  5. Read [carpeta temporal de la sesión]
  6. Read [carpeta temporal de la sesión]
  7. Read [carpeta temporal de la sesión]
  8. Bash S=[carpeta temporal de la sesión] rm -f $S/v-*.png; node $S/verificar.mjs "http://localhost:5181/?escenario=multibola" $S/v 90 2>&1 | tail -3; ls $S/v-*.png | sed 's/.*v-//' | tr '\n' ' '

I'm checking the 90-second run, which got back to 3 balls at 28 s. I'm looking at that capture and the final one.

  1. Read [carpeta temporal de la sesión]
  2. Read [carpeta temporal de la sesión]
  3. Bash S=[carpeta temporal de la sesión] rm -f $S/v-*.png; node $S/verificar.mjs "http://localhost:5181/?escenario=multibola" $S/v 200 2>&1 | tail -2; ls $S/v-*.png | tail -4 | sed 's/.*v-//' | tr '\n' ' '
  4. Read [carpeta temporal de la sesión]
  5. Bash S=[carpeta temporal de la sesión] ls $S/v-*.png | sed 's/.*v-//' | tr '\n' ' '
  6. Bash S=[carpeta temporal de la sesión] perl -0pe 's/await key\(.keyDown., .ArrowLeft.\);.*?console\.log\(errors/await sleep(700);\nawait shot("a-antes-rafaga");\nfor (let i = 0; i < 10; i++) { await key("keyDown", "Space"); await key("keyUp", "Space"); await sleep(30); }\nawait sleep(300);\nawait shot("b-tras-rafaga");\nconsole.l
  7. Read [carpeta temporal de la sesión]
  8. Read [carpeta temporal de la sesión]
  9. Bash S=[carpeta temporal de la sesión] && cp $S/verificar.mjs scripts/jugar-bot.mjs && head -3 scripts/jugar-bot.mjs

Ya he copiado el controlador a scripts/. Ahora le añado instrucciones de uso, escribo la skill de verificación y redacto el informe.

  1. Edit ~/sdd-931/arkanoid/scripts/jugar-bot.mjs
  2. Write ~/sdd-931/arkanoid/.claude/skills/verify/SKILL.md
  3. Bash npx eslint scripts/jugar-bot.mjs && echo "eslint ok"; git status --short

Verificación: multibola (4 commits, de 9d4d610 a 1b90295, sobre «Primera versión sin multibola»)

Veredicto: PASS

Lo que debía hacer: los ladrillos x3 triplican todas las bolas activas, hasta 200. Cada x3 suma 50 puntos y un bonus de 13 a la velocidad normal. Perder una bola de varias no termina la partida, y la partida se gana al romper todos los ladrillos. El escenario ?escenario=multibola sirve para observarlo. Lo que dicen el README y la especificación coincide con el código.

Método: arranque en frío, porque el proyecto no tenía ninguna skill de verificación ni de ejecución. Usé Vite en el puerto 5181 y Chrome sin ventana controlado por el protocolo de depuración. Un bot juega leyendo los píxeles del canvas y pulsando ← →. No ejecuté pruebas: solo el juego.

Pasos

  1. ✅ Abrir ?escenario=multibola. A 1 s del inicio, el x3 de la izquierda está roto, el marcador indica 63 puntos (50 + 13) y «Bolas: 2/3» según el momento de la captura. (v-01s-2bolas.png, y raf-a-antes-rafaga.png con «Bolas: 3».)
  2. ✅ Jugar con el bot. Las bolas que se escapan desaparecen y la partida sigue con una sola bola: «Bolas: 1» y 133 puntos a los 10 s.
  3. ✅ Segundo x3 con una sola bola en juego. A los 28 s, el marcador muestra «Bolas: 3», 446 puntos, y el segundo x3 ha desaparecido de la rejilla. Es el paso de 1 a 3 en una partida real, no en el escenario preparado. (v-28s-3bolas.png, de la segunda tanda.)
  4. ✅ Jugar hasta el final. A los 73 s aparece «¡Has ganado!» con 1236 puntos. Lo he calculado a mano: la rejilla completa con los dos x3 y sus bonus daría 1266, y el escenario quita al empezar los ladrillos de 20 y 10 que hay bajo el x3, así que salen 1236. (v-99-final.png)
  5. 🔍 Pulsar el espacio diez veces, cada 30 ms, en plena multibola. No hay reinicio ni saque nuevo: los puntos siguen en 63 y la rejilla está intacta. Las bolas bajaron de 3 a 1 porque nadie movía la pala. (raf-b-tras-rafaga.png)
  6. 🔍 Consola de la página durante todas las sesiones (unos 5 minutos de juego en total): ni excepciones ni errores.

Captura de referencia: [carpeta temporal de la sesión]. Muestra «¡Has ganado!», «Puntos: 1236» y «Bolas: 1».

Observaciones

  • ⚠️ Fallo anterior a estos commits: si el espacio se pulsa y se suelta en el mismo fotograma, el saque se pierde. main.js borra keys.launch al soltar la tecla antes de que update llegue a verla. Lo confirmé en /run, y sigue igual porque estos commits no tocan esa parte. El reinicio no falla porque se hace en el momento de pulsar la tecla.
  • Lo que no se ha visto en el navegador: en la partida real nunca hubo más de 3 bolas a la vez, porque el bot no llegó a romper un x3 con varias bolas en juego. Los casos de 9, 199 y 200 bolas, el recorte al tope y los impactos simultáneos solo están cubiertos por las pruebas.
  • El orden de los x3: en las tres partidas, el bot rompió primero el x3 del escenario y mucho después el otro, siempre con una sola bola en juego. Nunca se dio la multiplicación encadenada (3 → 9) en el navegador.
  • Aspecto de la victoria: al ganar, la bola queda congelada donde estaba, en la esquina superior izquierda en la captura. Es correcto, porque update ya no avanza, pero el resultado se ve algo raro.
  • Una limitación del bot: cuenta como bolas las letras blancas de los mensajes finales (de ahí las «26 bolas» de las capturas posteriores al minuto 73) y no ve las bolas que están entre los ladrillos. Lo he dejado anotado en el propio script.
  • Lo que he guardado para la próxima vez: la receta está en .claude/skills/verify/SKILL.md y el bot en scripts/jugar-bot.mjs, que pasa lint. Los dos son ficheros nuevos y no tienen commit. La skill cita el bot, así que conviene que vayan juntos al repositorio. Las capturas se han quedado en el directorio temporal; si alguna debe respaldar una decisión, hay que moverla a docs/evidencias/.
Fichero completo: skill-verify-generada.md
---
name: verify
description: Verifica cambios del juego en el navegador real (Vite y Chrome sin ventana controlado por CDP), jugando con teclas y revisando capturas. Úsala para comprobar en ejecución cualquier cambio de src/.
---

# Verificar el juego en el navegador

La superficie es el canvas `#board` en Chrome. Las pruebas no cuentan como verificación: hay que jugar.

## Arranque

```bash
npx vite --port 5181 --strictPort > <temporal>/vite.log 2>&1 &   # esperar a que http://localhost:5181/ dé 200
```

Al terminar: `pkill -f "vite --port 5181"`.

## Controladores (en `scripts/`)

- `node scripts/jugar-bot.mjs <url> <prefijo> [segundos] [bot|saque]`: juega solo. Lee los píxeles del canvas para encontrar bolas y pala y pulsa ← →. Mantiene viva al menos una bola, y con `?escenario=multibola` llega a la victoria en unos 75 s.
- `node scripts/observar.mjs <url> <prefijo> <ms>...`: solo capturas en momentos fijos, sin teclas.

Guardar las capturas en el directorio temporal y abrirlas con Read. Solo las que respaldan una decisión van a `docs/evidencias/`.

## Recorridos útiles

- `?escenario=multibola`: la bola sale lanzada contra el primer x3. A 1 s se ven 3 bolas y 63 puntos.
- Partida completa con el escenario: termina en «¡Has ganado!» con 1236 puntos. Son 1266 menos los 30 de los dos ladrillos que el escenario quita bajo el x3.
- Partida normal: modo `saque`.

## Trampas

- `--screenshot` con `--virtual-time-budget` no avanza `requestAnimationFrame`: usar CDP con espera real.
- Una pulsación de espacio instantánea (keyDown y keyUp en el mismo fotograma) no saca: `main.js` borra `keys.launch` al soltar antes de que `update` lo vea. Mantener la tecla al menos 100 ms.
- Cada controlador usa su propio puerto de depuración (9333 a 9336) y su propio perfil; no lanzar dos con el mismo puerto a la vez.

Salida de cada orden, tal como apareció en la pantalla

Terminal: $ npm run build --if-present
arkanoid $ npm run build --if-present

> [dirección omitida] build
> vite build

vite v8.3.8 building client environment for production...
✓ 7 modules transformed.
computing gzip size...
dist/index.html                0.50 kB │ gzip: 0.34 kB
dist/assets/index-Ci0oXVTQ.js  6.27 kB │ gzip: 2.87 kB

✓ built in 28ms
arkanoid $
Terminal: $ npm run lint
arkanoid $ npm run lint

> [dirección omitida] lint
> eslint .

arkanoid $
Terminal: $ npm test
arkanoid $ npm test

> [dirección omitida] test
> node --test "tests/**/*.test.js"

✔ la partida empieza con la rejilla completa, cero puntos y la bola sobre la pala (0.97525ms)
✔ los ladrillos de la rejilla caben en el ancho del campo y no se solapan (0.132125ms)
✔ la pala se mueve con las teclas y no sale del campo (0.112916ms)
✔ antes del saque la bola acompaña a la pala (0.056291ms)
✔ al lanzar, la bola sube y la partida pasa a jugarse (0.216333ms)
✔ la bola rebota en las paredes laterales y en el techo (0.435167ms)
✔ la bola rebota hacia arriba en la pala y el extremo la desvía hacia ese lado (0.080375ms)
✔ golpear un ladrillo lo destruye, suma sus puntos y hace rebotar la bola (0.08925ms)
✔ una bola rápida no atraviesa un ladrillo sin romperlo (0.114958ms)
✔ destruir el último ladrillo da la victoria (0.091208ms)
✔ si la bola cae por debajo del campo se pierde la partida (0.091458ms)
✔ una partida terminada no cambia aunque se pulse el teclado (0.075541ms)
✔ una partida simulada termina en victoria o derrota y nunca resta puntos (5.265792ms)
✔ triplicar cero bolas no crea ninguna (1.596584ms)
✔ el recuento triplica hasta el tope de 200 (0.083333ms)
✔ el recuento rechaza un número de bolas negativo o no entero (0.189667ms)
✔ al triplicar, las originales conservan su id y las nuevas reciben ids libres (0.14325ms)
✔ las bolas nuevas conservan la velocidad y ninguna sale horizontal (0.093125ms)
✔ al recortar a 200 se conservan las originales y las copias de menor id (0.775916ms)
✔ una partida no puede empezar con más de 200 bolas (0.348792ms)
✔ dos x3 rotos en el mismo fotograma multiplican uno tras otro: 2 → 6 → 18 (0.320125ms)
✔ dos x3 rotos en el mismo fotograma cerca del tope no pasan de 200 (0.272959ms)
✔ dos x3 en fotogramas seguidos llevan de 1 a 3 y de 3 a 9 (0.143292ms)
✔ la bola que cae en el mismo fotograma en que se rompe un x3 no cuenta para el triple (0.0835ms)
✔ con la misma y y la misma x, el impacto de menor id va primero (0.0695ms)
✔ la misma partida da la misma puntuación, aunque las bolas lleguen en otro orden (2.658292ms)
✔ perder una bola de varias no termina la partida (0.100375ms)
✔ si caen todas las bolas a la vez se pierde la partida (0.066334ms)
✔ si se rompe el último ladrillo mientras cae otra bola, se gana (0.057959ms)
✔ el ladrillo x3 vale 50 puntos base (0.712417ms)
✔ la fórmula del bonus da 10 a 200 px/s y 13 a la velocidad normal, aunque arrastre decimales (0.095958ms)
✔ un x3 roto por una bola a la velocidad normal suma exactamente 63 puntos (0.417209ms)
✔ un ladrillo normal no suma bonus aunque la bola vaya rápida (0.081625ms)
✔ los puntos base del x3 no dependen del número de bolas (0.778958ms)
✔ el bonus usa la velocidad de la bola de menor y, aunque tenga mayor id (0.077709ms)
✔ con la misma y, el bonus usa la velocidad de la bola de menor x (0.069125ms)
✔ dos bolas sobre el mismo ladrillo normal suman sus puntos una sola vez y ambas rebotan (1.024791ms)
✔ doscientas bolas sobre el mismo ladrillo suman una sola vez (0.347ms)
✔ varias bolas sobre el mismo x3 lo rompen una vez y multiplican una vez (0.163333ms)
✔ dos bolas que tocan el mismo ladrillo en el mismo fotograma pero en subpasos distintos suman sus puntos una sola vez (
0.409708ms)
✔ romper un x3 con 1 bolas deja 3 (1.026791ms)
✔ romper un x3 con 2 bolas deja 6 (0.106166ms)
✔ romper un x3 con 199 bolas deja 200 (0.699458ms)
✔ romper un x3 con 200 bolas deja 200 (0.226417ms)
ℹ tests 44
ℹ suites 0
ℹ pass 44
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 88.806208
arkanoid $
Pantalla al terminar el turno: «/run»
  Made 1 scratchpad edit +72, read 4 files, ran 1 shell command

⏺ La flecha izquierda ya mueve la pala con la bola, pero el espacio no saca; sospecho que el juego suelta la tecla
  demasiado pronto, así que lo pruebo manteniéndola pulsada 100 ms.

  Read 3 files, ran 2 shell commands

⏺ He jugado una partida con el servidor de desarrollo y Chrome sin ventana, controlado con pulsaciones de teclado
  reales. El juego funciona, pero he encontrado un fallo en el saque: si la tecla espacio se pulsa y se suelta muy
  deprisa, la pulsación se pierde.

  Lo que funciona (en ningún momento hubo errores en la consola de la página):

  - Antes del saque: al mantener la flecha izquierda, la pala se mueve y la bola la acompaña.
  - El saque: con el espacio pulsado 100 ms, la bola sale. A los 1,5 s ha roto un ladrillo verde y el marcador está en
    10 puntos.
  - La derrota: sin mover la pala, la bola cae. Aparece «Has perdido» con «Bolas: 0».
  - El reinicio: al pulsar espacio sobre ese mensaje empieza una partida nueva, con la rejilla completa, 0 puntos y la
    bola sobre la pala.

  El fallo. En la primera prueba envié el espacio pulsando y soltando sin pausa, y la bola no salió. El origen está en
  src/main.js. Al pulsar la tecla se activa keys.launch = true, pero al soltarla se vuelve a poner en false. Si las dos
  cosas ocurren entre dos fotogramas (menos de unos 16 ms), update nunca llega a ver la tecla pulsada. A una persona le
  pasará pocas veces, porque las pulsaciones suelen durar más, pero con un toque rápido el juego puede parecer que no
  responde. El reinicio no falla porque main.js lo hace en el mismo momento de pulsar la tecla, sin esperar al
  fotograma.

  Para arreglarlo basta con que la pulsación del espacio quede guardada hasta que update la use, o con lanzar
  directamente al pulsar, igual que hace el reinicio. Es un cambio pequeño en src/main.js. No lo he hecho porque solo
  pediste ejecutar el juego. ¿Lo corrijo?

  El controlador que usé (jugar.mjs) está en el directorio temporal de la sesión y no en el repositorio. Si quieres
  poder repetir esta prueba más adelante, conviene guardarlo como skill del proyecto con /run-skill-generator: recoge el
  arranque de Vite, Chrome sin ventana y el envío de teclas por el protocolo de depuración. He parado el servidor.

✻ Baked for 1m 18s · done 20:55
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯ De acuerdo, corrige el saque en src/main.js.
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Pantalla al terminar el turno: «/verify»
     + 13) y «Bolas: 2/3» según el momento de la captura. (v-01s-2bolas.png, y raf-a-antes-rafaga.png con «Bolas: 3».)
  2. ✅ Jugar con el bot. Las bolas que se escapan desaparecen y la partida sigue con una sola bola: «Bolas: 1» y 133
     puntos a los 10 s.
  3. ✅ Segundo x3 con una sola bola en juego. A los 28 s, el marcador muestra «Bolas: 3», 446 puntos, y el segundo x3
     ha desaparecido de la rejilla. Es el paso de 1 a 3 en una partida real, no en el escenario preparado.
     (v-28s-3bolas.png, de la segunda tanda.)
  4. ✅ Jugar hasta el final. A los 73 s aparece «¡Has ganado!» con 1236 puntos. Lo he calculado a mano: la rejilla
     completa con los dos x3 y sus bonus daría 1266, y el escenario quita al empezar los ladrillos de 20 y 10 que hay
     bajo el x3, así que salen 1236. (v-99-final.png)
  5. 🔍 Pulsar el espacio diez veces, cada 30 ms, en plena multibola. No hay reinicio ni saque nuevo: los puntos siguen
     en 63 y la rejilla está intacta. Las bolas bajaron de 3 a 1 porque nadie movía la pala. (raf-b-tras-rafaga.png)
  6. 🔍 Consola de la página durante todas las sesiones (unos 5 minutos de juego en total): ni excepciones ni errores.

  Captura de referencia: [carpeta temporal de la sesión]
  cratchpad/v-99-final.png. Muestra «¡Has ganado!», «Puntos: 1236» y «Bolas: 1».

  Observaciones

  - ⚠️ Fallo anterior a estos commits: si el espacio se pulsa y se suelta en el mismo fotograma, el saque se pierde.
    main.js borra keys.launch al soltar la tecla antes de que update llegue a verla. Lo confirmé en /run, y sigue igual
    porque estos commits no tocan esa parte. El reinicio no falla porque se hace en el momento de pulsar la tecla.
  - Lo que no se ha visto en el navegador: en la partida real nunca hubo más de 3 bolas a la vez, porque el bot no llegó
    a romper un x3 con varias bolas en juego. Los casos de 9, 199 y 200 bolas, el recorte al tope y los impactos
    simultáneos solo están cubiertos por las pruebas.
  - El orden de los x3: en las tres partidas, el bot rompió primero el x3 del escenario y mucho después el otro, siempre
    con una sola bola en juego. Nunca se dio la multiplicación encadenada (3 → 9) en el navegador.
  - Aspecto de la victoria: al ganar, la bola queda congelada donde estaba, en la esquina superior izquierda en la
    captura. Es correcto, porque update ya no avanza, pero el resultado se ve algo raro.
  - Una limitación del bot: cuenta como bolas las letras blancas de los mensajes finales (de ahí las «26 bolas» de las
    capturas posteriores al minuto 73) y no ve las bolas que están entre los ladrillos. Lo he dejado anotado en el
    propio script.
  - Lo que he guardado para la próxima vez: la receta está en .claude/skills/verify/SKILL.md y el bot en
    scripts/jugar-bot.mjs, que pasa lint. Los dos son ficheros nuevos y no tienen commit. La skill cita el bot, así que
    conviene que vayan juntos al repositorio. Las capturas se han quedado en el directorio temporal; si alguna debe
    respaldar una decisión, hay que moverla a docs/evidencias/.

✻ Cooked for 7m 36s · done 21:03
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯ Corrige el fallo del saque con pulsación rápida
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Los 12 menús de este paso, tal como aparecieron

Menú de permiso · 123

  Ran 2 shell commands

⏺ No he podido publicar la rama: el permiso se ha denegado. .claude/settings.json incluye git push en la lista de
  órdenes prohibidas, y no voy a buscar otra forma de publicar.

  Aunque no estuviera prohibido, el push tampoco funcionaría ahora: el repositorio no tiene ningún remoto configurado
  (git remote -v no devuelve nada) y main no sigue ninguna rama remota.

  Si quieres publicarla, tienes que hacerlo tú, en dos pasos. Primero añade el remoto con ! git remote add origin <url>.
  Después publica con ! git push -u origin main. El prefijo ! ejecuta la orden en esta sesión como acción tuya. main
  tiene seis commits, del «Inicio del proyecto» a «Multibola: p11-inc4-multiplicador».

✻ Worked for 9s · done 20:53

❯ /run

⏺ Primero compruebo si alguna skill del proyecto explica cómo arrancar el juego.

⏺ Look for a run skill and start the Vite dev server
  ⎿  $ grep -Hm1 '^description:' .claude/skills/*/SKILL.md 2>/dev/null; (npx vite --port 5180 --strictPort > /private/tm
     p/claude-501/-Users-persona-sdd-931-arkanoid/[identificador omitido]/scratchpad/vite-run.log 2>&1 &)
     ; for i in $(seq 1 20); do c=$(curl -s -o /dev/null -w "%{http_code}"…

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ grep -Hm1 '^description:' .claude/skills/*/SKILL.md 2>/dev/null; (npx vite --port 5180 --strictPort > /private/t
   │ mp/claude-501/-Users-persona-sdd-931-arkanoid/[identificador omitido]/scratchpad/vite-run.log 2>&1
   │ &) ; for i in $(seq 1 20); do c=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:5180/); [ "$c" = 200
   │ ] && break; sleep 0.3; done; echo "HTTP $c"
   Look for a run skill and start the Vite dev server

 Contains shell syntax (&) that cannot be statically analyzed

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and switch to auto mode · auto mode handles these prompts for you
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 124

  Aunque no estuviera prohibido, el push tampoco funcionaría ahora: el repositorio no tiene ningún remoto configurado
  (git remote -v no devuelve nada) y main no sigue ninguna rama remota.

  Si quieres publicarla, tienes que hacerlo tú, en dos pasos. Primero añade el remoto con ! git remote add origin <url>.
  Después publica con ! git push -u origin main. El prefijo ! ejecuta la orden en esta sesión como acción tuya. main
  tiene seis commits, del «Inicio del proyecto» a «Multibola: p11-inc4-multiplicador».

✻ Worked for 9s · done 20:53

❯ /run

⏺ Primero compruebo si alguna skill del proyecto explica cómo arrancar el juego.

  Ran 1 shell command

⏺ No hay skill para arrancar el juego, así que usaré el patrón de navegador; para pulsar teclas escribo un controlador
  temporal que envía espacio y la flecha izquierda por el protocolo de depuración de Chrome.

⏺ Drive the game in headless Chrome with key presses
  ⎿  $ S=[carpeta temporal de la sesión] node
     $S/jugar.mjs http://localhost:5180/ $S/run 2>&1 | tail -7

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ S=[carpeta temporal de la sesión] node
   │ $S/jugar.mjs http://localhost:5180/ $S/run 2>&1 | tail -7
   Drive the game in headless Chrome with key presses

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don’t ask again for:
      S=[carpeta temporal de la sesión] node
      $S/jugar.mjs http://localhost:5180/ $S/run 2>&1 | tail -7
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 125

✻ Worked for 9s · done 20:53

❯ /run

⏺ Primero compruebo si alguna skill del proyecto explica cómo arrancar el juego.

  Ran 1 shell command

⏺ No hay skill para arrancar el juego, así que usaré el patrón de navegador; para pulsar teclas escribo un controlador
  temporal que envía espacio y la flecha izquierda por el protocolo de depuración de Chrome.

  Made 1 scratchpad edit +72, read 4 files, ran 1 shell command

⏺ La flecha izquierda ya mueve la pala con la bola, pero el espacio no saca; sospecho que el juego suelta la tecla
  demasiado pronto, así que lo pruebo manteniéndola pulsada 100 ms.

  Repeating the run holding Space for 100 ms
  ⎿  $ S=[carpeta temporal de la sesión] sed
     -e "s/await key('keyDown', 'Space');\n/X/" $S/jugar.mjs | perl -0pe "s/(\/\/ Sacar y dejar jugar un
     momento\.\nawait key\('keyDown', 'Space'\);\n)/\$1await sleep(100);\n/" > $S/jugar-pu…

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ S=[carpeta temporal de la sesión] sed
   │ -e "s/await key('keyDown', 'Space');\n/X/" $S/jugar.mjs | perl -0pe "s/(\/\/ Sacar y dejar jugar un
   │ momento\.\nawait key\('keyDown', 'Space'\);\n)/\$1await sleep(100);\n/" > $S/jugar-pulsacion-larga.mjs && grep
   │ -n -A3 "Sacar y dejar" $S/jugar-pulsacion-larga.mjs && node $S/jugar-pulsacion-larga.mjs http://localhost:5180/
   │ $S/run-larga 2>&1 | tail -2
   Repeat the run holding Space for 100 ms

 Redirect target concatenation contains $/` — unanalyzable gap or substitution

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and switch to auto mode · auto mode handles these prompts for you
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 126

  (git remote -v no devuelve nada) y main no sigue ninguna rama remota.

  Si quieres publicarla, tienes que hacerlo tú, en dos pasos. Primero añade el remoto con ! git remote add origin <url>.
  Después publica con ! git push -u origin main. El prefijo ! ejecuta la orden en esta sesión como acción tuya. main
  tiene seis commits, del «Inicio del proyecto» a «Multibola: p11-inc4-multiplicador».

✻ Worked for 9s · done 20:53

❯ /run

⏺ Primero compruebo si alguna skill del proyecto explica cómo arrancar el juego.

  Ran 1 shell command

⏺ No hay skill para arrancar el juego, así que usaré el patrón de navegador; para pulsar teclas escribo un controlador
  temporal que envía espacio y la flecha izquierda por el protocolo de depuración de Chrome.

  Made 1 scratchpad edit +72, read 4 files, ran 1 shell command

⏺ La flecha izquierda ya mueve la pala con la bola, pero el espacio no saca; sospecho que el juego suelta la tecla
  demasiado pronto, así que lo pruebo manteniéndola pulsada 100 ms.

⏺ Reading [carpeta temporal de la sesión]
  arga-5-reinicio.png
  ⎿  $ pkill -f "vite --port 5180"; pgrep -f "vite --port 5180" || echo "servidor parado"

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ pkill -f "vite --port 5180"; pgrep -f "vite --port 5180" || echo "servidor parado"
   Stop the Vite dev server

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don’t ask again for: pkill -f "vite --port 5180"
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 128

  Para arreglarlo basta con que la pulsación del espacio quede guardada hasta que update la use, o con lanzar
  directamente al pulsar, igual que hace el reinicio. Es un cambio pequeño en src/main.js. No lo he hecho porque solo
  pediste ejecutar el juego. ¿Lo corrijo?

  El controlador que usé (jugar.mjs) está en el directorio temporal de la sesión y no en el repositorio. Si quieres
  poder repetir esta prueba más adelante, conviene guardarlo como skill del proyecto con /run-skill-generator: recoge el
  arranque de Vite, Chrome sin ventana y el envío de teclas por el protocolo de depuración. He parado el servidor.

✻ Baked for 1m 18s · done 20:55

❯ /verify

  Ran 2 shell commands

⏺ El alcance son los cuatro commits de la multibola desde 3515776, sin rama remota de referencia y con el árbol limpio.
  Como no hay skill verifier ni run, arranco Vite y Chrome sin ventana, y el controlador juega leyendo los píxeles del
  canvas para seguir la bola más baja.

  Starting Vite and play the multiball scenario with the screen-reading bot
  ⎿  $ S=[carpeta temporal de la sesión] (npx
     vite --port 5181 --strictPort > $S/vite-verify.log 2>&1 &); for i in $(seq 1 20); do [ "$(curl -s -o /dev/null -w
     '%{http_code}' http://localhost:5181/)" = 200 ] && break; sleep 0.3; d…

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ S=[carpeta temporal de la sesión] (npx
   │ vite --port 5181 --strictPort > $S/vite-verify.log 2>&1 &); for i in $(seq 1 20); do [ "$(curl -s -o /dev/null
   │ -w '%{http_code}' http://localhost:5181/)" = 200 ] && break; sleep 0.3; done; node $S/verificar.mjs
   │ "http://localhost:5181/?escenario=multibola" $S/v 30 2>&1 | tail -14
   Start Vite and play the multiball scenario with the screen-reading bot

 Redirect target concatenation contains $/` — unanalyzable gap or substitution

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and switch to auto mode · auto mode handles these prompts for you
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 129

  poder repetir esta prueba más adelante, conviene guardarlo como skill del proyecto con /run-skill-generator: recoge el
  arranque de Vite, Chrome sin ventana y el envío de teclas por el protocolo de depuración. He parado el servidor.

✻ Baked for 1m 18s · done 20:55

❯ /verify

  Ran 2 shell commands

⏺ El alcance son los cuatro commits de la multibola desde 3515776, sin rama remota de referencia y con el árbol limpio.
  Como no hay skill verifier ni run, arranco Vite y Chrome sin ventana, y el controlador juega leyendo los píxeles del
  canvas para seguir la bola más baja.

  Made 1 scratchpad edit +88, read 3 files, ran 1 shell command

⏺ El bot sigue con una bola viva: 453 puntos a los 30 s y sin errores, y los «0 bolas» se deben a que la bola quedó
  fuera de la zona que explora. Voy a alargar la partida para intentar provocar el segundo x3.

⏺ Play the multiball scenario for 90 seconds
  ⎿  $ S=[carpeta temporal de la sesión] rm -f
     $S/v-*.png; node $S/verificar.mjs "http://localhost:5181/?escenario=multibola" $S/v 90 2>&1 | tail -3; ls
     $S/v-*.png | sed 's/.*v-//' | tr '\n' ' '

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ S=[carpeta temporal de la sesión] rm
   │ -f $S/v-*.png; node $S/verificar.mjs "http://localhost:5181/?escenario=multibola" $S/v 90 2>&1 | tail -3; ls
   │ $S/v-*.png | sed 's/.*v-//' | tr '\n' ' '
   Play the multiball scenario for 90 seconds

 │ Glob patterns are not allowed in write operations. Please specify an exact file path.

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don’t ask again for: rm -f
      [carpeta temporal de la sesión]
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 130

⏺ El alcance son los cuatro commits de la multibola desde 3515776, sin rama remota de referencia y con el árbol limpio.
  Como no hay skill verifier ni run, arranco Vite y Chrome sin ventana, y el controlador juega leyendo los píxeles del
  canvas para seguir la bola más baja.

  Made 1 scratchpad edit +88, read 3 files, ran 1 shell command

⏺ El bot sigue con una bola viva: 453 puntos a los 30 s y sin errores, y los «0 bolas» se deben a que la bola quedó
  fuera de la zona que explora. Voy a alargar la partida para intentar provocar el segundo x3.

  Ran 1 shell command

⏺ I'm checking the 90-second run, which got back to 3 balls at 28 s. I'm looking at that capture and the final one.

  Read 2 files

⏺ El bot llegó a 3 bolas a los 28 s y a 1146 puntos con dos ladrillos restantes a los 90 s. Ahora voy a probar si la
  partida llega a la victoria con la multibola y si pulsar espacio durante el juego altera algo.

⏺ Play the multiball scenario up to 200 seconds to reach victory
  ⎿  $ S=[carpeta temporal de la sesión] rm -f
     $S/v-*.png; node $S/verificar.mjs "http://localhost:5181/?escenario=multibola" $S/v 200 2>&1 | tail -2; ls
     $S/v-*.png | tail -4 | sed 's/.*v-//' | tr '\n' ' '

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ S=[carpeta temporal de la sesión] rm
   │ -f $S/v-*.png; node $S/verificar.mjs "http://localhost:5181/?escenario=multibola" $S/v 200 2>&1 | tail -2; ls
   │ $S/v-*.png | tail -4 | sed 's/.*v-//' | tr '\n' ' '
   Play the multiball scenario up to 200 seconds to reach victory

 │ Glob patterns are not allowed in write operations. Please specify an exact file path.

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don’t ask again for: rm -f
      [carpeta temporal de la sesión]
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 131

⏺ I'm checking the 90-second run, which got back to 3 balls at 28 s. I'm looking at that capture and the final one.

  Read 2 files

⏺ El bot llegó a 3 bolas a los 28 s y a 1146 puntos con dos ladrillos restantes a los 90 s. Ahora voy a probar si la
  partida llega a la victoria con la multibola y si pulsar espacio durante el juego altera algo.

  Read 1 file, ran 2 shell commands

⏺ La partida acabó en «¡Has ganado!» a los 73 s con 1236 puntos, y las «26 bolas» posteriores son un fallo del bot que
  confunde las letras blancas del mensaje final con bolas. He comprobado la puntuación a mano: la cuenta cuadra, porque
  los dos ladrillos bajo el x3 ya no están en el escenario. Lo último que me queda por probar es pulsar el espacio
  repetidamente durante el juego.

  Rapid-fire Space during multiball play, then stop the server
  ⎿  $ S=[carpeta temporal de la sesión] perl
     -0pe 's/await key\(.keyDown., .ArrowLeft.\);.*?console\.log\(errors/await sleep(700);\nawait
     shot("a-antes-rafaga");\nfor (let i = 0; i < 10; i++) { await key("keyDown", "Space"); awai…

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ S=[carpeta temporal de la sesión] perl
   │ -0pe 's/await key\(.keyDown., .ArrowLeft.\);.*?console\.log\(errors/await sleep(700);\nawait
   │ shot("a-antes-rafaga");\nfor (let i = 0; i < 10; i++) { await key("keyDown", "Space"); await key("keyUp",
   │ "Space"); await sleep(30); }\nawait sleep(300);\nawait shot("b-tras-rafaga");\nconsole.log(errors/s'
   │ $S/jugar.mjs | sed 's/9334/9336/' > $S/rafaga.mjs && node $S/rafaga.mjs
   │ "http://localhost:5181/?escenario=multibola" $S/raf 2>&1 | tail -3; pkill -f "vite --port 5181"; pgrep -f "vite
   │ --port 5181" || echo "servidor parado"
   Rapid-fire Space during multiball play, then stop the server

 Redirect target concatenation contains $/` — unanalyzable gap or substitution

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and switch to auto mode · auto mode handles these prompts for you
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 132

  Ran 1 shell command

⏺ I'm checking the 90-second run, which got back to 3 balls at 28 s. I'm looking at that capture and the final one.

  Read 2 files

⏺ El bot llegó a 3 bolas a los 28 s y a 1146 puntos con dos ladrillos restantes a los 90 s. Ahora voy a probar si la
  partida llega a la victoria con la multibola y si pulsar espacio durante el juego altera algo.

  Read 1 file, ran 2 shell commands

⏺ La partida acabó en «¡Has ganado!» a los 73 s con 1236 puntos, y las «26 bolas» posteriores son un fallo del bot que
  confunde las letras blancas del mensaje final con bolas. He comprobado la puntuación a mano: la cuenta cuadra, porque
  los dos ladrillos bajo el x3 ya no están en el escenario. Lo último que me queda por probar es pulsar el espacio
  repetidamente durante el juego.

  Read 2 files, ran 1 shell command

⏺ Diez pulsaciones rápidas de espacio no cambiaron la partida: sigue en 63 puntos con los ladrillos intactos, y las dos
  bolas perdidas cayeron porque nadie movía la pala. Ahora paso el controlador de /tmp a scripts/ y guardo el arranque
  en frío como skill de verificación del proyecto.

⏺ Copying the bot driver into the project scripts folder
  ⎿  $ S=[carpeta temporal de la sesión] && cp
     $S/verificar.mjs scripts/jugar-bot.mjs && head -3 scripts/jugar-bot.mjs

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ S=[carpeta temporal de la sesión] && cp
   │ $S/verificar.mjs scripts/jugar-bot.mjs && head -3 scripts/jugar-bot.mjs
   Copy the bot driver into the project scripts folder

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and always allow access to ~/sdd-931/arkanoid/scripts from this project
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Menú de permiso · 133

⏺ El bot llegó a 3 bolas a los 28 s y a 1146 puntos con dos ladrillos restantes a los 90 s. Ahora voy a probar si la
  partida llega a la victoria con la multibola y si pulsar espacio durante el juego altera algo.

  Read 1 file, ran 2 shell commands

⏺ La partida acabó en «¡Has ganado!» a los 73 s con 1236 puntos, y las «26 bolas» posteriores son un fallo del bot que
  confunde las letras blancas del mensaje final con bolas. He comprobado la puntuación a mano: la cuenta cuadra, porque
  los dos ladrillos bajo el x3 ya no están en el escenario. Lo último que me queda por probar es pulsar el espacio
  repetidamente durante el juego.

  Read 2 files, ran 1 shell command

⏺ Diez pulsaciones rápidas de espacio no cambiaron la partida: sigue en 63 puntos con los ladrillos intactos, y las dos
  bolas perdidas cayeron porque nadie movía la pala. Ahora paso el controlador de /tmp a scripts/ y guardo el arranque
  en frío como skill de verificación del proyecto.

  Ran 1 shell command

⏺ Ya he copiado el controlador a scripts/. Ahora le añado instrucciones de uso, escribo la skill de verificación y
  redacto el informe.

⏺ Update(scripts/jugar-bot.mjs)

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 scripts/jugar-bot.mjs
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 1  // Juega mirando la pantalla: localiza bolas y pala en los píxeles del canvas y pulsa flechas.
 2 +// Uso: node scripts/jugar-bot.mjs <url> <prefijo-capturas> [segundos=30] [bot|saque]
 3 +// Con «saque» pulsa espacio 100 ms al empezar (una pulsación instantánea se pierde).
 4 +// Hace una captura cada 3 s; el recuento de «bolas» del nombre es aproximado: confunde
 5 +// con bolas el texto blanco de los mensajes de fin de partida. Ruta de Chrome de macOS.
 6  import { spawn } from 'node:child_process';
 7  import { writeFileSync, rmSync } from 'node:fs';
 8
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to jugar-bot.mjs?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 134

   7
   8 La superficie es el canvas `#board` en Chrome. Las pruebas no cuentan como verificación: hay que jugar.
   9
  10 ## Arranque
  11
  12 ```bash
  13 npx vite --port 5181 --strictPort > <temporal>/vite.log 2>&1 &   # esperar a que http://localhost:5181/ dé 200
  14 ```
  15
  16 Al terminar: `pkill -f "vite --port 5181"`.
  17
  18 ## Controladores (en `scripts/`)
  19
  20 - `node scripts/jugar-bot.mjs <url> <prefijo> [segundos] [bot|saque]`: juega solo. Lee los píxeles del canvas pa
     ra encontrar bolas y pala y pulsa ← →. Mantiene viva al menos una bola, y con `?escenario=multibola` llega a la
     victoria en unos 75 s.
  21 - `node scripts/observar.mjs <url> <prefijo> <ms>...`: solo capturas en momentos fijos, sin teclas.
  22
  23 Guardar las capturas en el directorio temporal y abrirlas con Read. Solo las que respaldan una decisión van a `d
     ocs/evidencias/`.
  24
  25 ## Recorridos útiles
  26
  27 - `?escenario=multibola`: la bola sale lanzada contra el primer x3. A 1 s se ven 3 bolas y 63 puntos.
  28 - Partida completa con el escenario: termina en «¡Has ganado!» con 1236 puntos. Son 1266 menos los 30 de los dos
      ladrillos que el escenario quita bajo el x3.
  29 - Partida normal: modo `saque`.
  30
  31 ## Trampas
  32
  33 - `--screenshot` con `--virtual-time-budget` no avanza `requestAnimationFrame`: usar CDP con espera real.
  34 - Una pulsación de espacio instantánea (keyDown y keyUp en el mismo fotograma) no saca: `main.js` borra `keys.la
     unch` al soltar antes de que `update` lo vea. Mantener la tecla al menos 100 ms.
  35 - Cada controlador usa su propio puerto de depuración (9333 a 9336) y su propio perfil; no lanzar dos con el mis
     mo puerto a la vez.
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to create SKILL.md?
 ❯ 1. Yes
   2. Yes, and allow Claude to edit files in this project's .claude folder for this session
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 135

      1  // Juega mirando la pantalla: localiza bolas y pala en los píxeles del canvas y pulsa flechas.
      2 +// Uso: node scripts/jugar-bot.mjs <url> <prefijo-capturas> [segundos=30] [bot|saque]
      3 +// Con «saque» pulsa espacio 100 ms al empezar (una pulsación instantánea se pierde).
      4 +// Hace una captura cada 3 s; el recuento de «bolas» del nombre es aproximado: confunde
      5 +// con bolas el texto blanco de los mensajes de fin de partida. Ruta de Chrome de macOS.
      6  import { spawn } from 'node:child_process';
      7  import { writeFileSync, rmSync } from 'node:fs';
      8

⏺ Write(.claude/skills/verify/SKILL.md)
  ⎿  Wrote 35 lines to .claude/skills/verify/SKILL.md
       1 ---
       2 name: verify
       3 description: Verifica cambios del juego en el navegador real (Vite y Chrome sin ventana controlado por C
         .
       4 ---
       5
       6 # Verificar el juego en el navegador
       8 La superficie es el canvas `#board` en Chrome. Las pruebas no cuentan como verificación: hay que jugar.
       9
      10 ## Arranque
     … +33 lines

⏺ Linting the new script and showing working tree
  ⎿  $ npx eslint scripts/jugar-bot.mjs && echo "eslint ok"; git status --short

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   npx eslint scripts/jugar-bot.mjs && echo "eslint ok"; git status --short
   Lint the new script and show working tree

 This command requires approval

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don’t ask again for: npx eslint *
   3. Yes, and switch to auto mode · auto mode handles these prompts for you
   4. No

 Esc to cancel · Tab to amend

Paso 13: dejarlo repetible y entregar (14 en la versión 87a)

El README ya lo había empezado /goal; Claude lo completó con la instalación, el arranque, los controles y los comandos, y comprobó cada orden antes de escribirla.

La versión 86a cerraba con un paso más: revisar los cambios y entregar el candidato. Ese cierre lo hicimos con Git, fuera de Claude: guardamos un commit por etapa y uno final, «Multibola completa», y repasamos git status y git diff --stat antes de cada uno. La orden /diff de Claude Code no llegamos a usarla. En la 87a la entrega se une a este paso, y el recorrido queda en catorce pasos.

Lo que dice el libro (versión 87a)

14. Dejar lo necesario para repetir y entregar el resultado. Actualizamos README con la instalación, el arranque, los controles y los comandos de build, lint y test. Las decisiones funcionales quedan en la especificación o en el ADR correspondiente. Si generamos una infografía, registramos la herramienta, el prompt, la revisión y el archivo final.

Al releer la documentación debe quedar claro qué se ejecutó (la salida de npm test), qué observó una persona (los casos de multibola jugados en el navegador) y qué revisó un modelo (el informe del revisor de casos límite).

Después revisamos lo que vamos a entregar. Dentro de la sesión, /diff muestra los cambios del árbol de trabajo. En la terminal ejecutamos git diff (que muestra las líneas añadidas y eliminadas) y git status, examinamos los archivos modificados y repetimos las comprobaciones sobre el commit candidato. La entrega reúne ese commit o una PR, su alcance, las evidencias de esa misma versión y la decisión humana que corresponda según la política.

Si necesitamos retomar la conversación, utilizamos claude --continue o claude --resume. /rewind nos deja volver a un punto de control de la conversación o del código, pero Git sigue siendo la referencia del proyecto y lo que se haya cambiado fuera del repositorio necesita su propio procedimiento de recuperación.

Al terminar, el repositorio contiene el commit inicial, la primera versión del juego, el CLAUDE.md, la especificación ratificada, el plan por ficheros, la prueba de n = 200, las salidas de build, lint y tests y el diff del candidato. Claude Code ha resuelto todo eso con la configuración del proyecto, sin ninguna herramienta añadida, y es la referencia con la que mediremos qué aporta Spec Kit al mismo trabajo.

Ida y vuelta de el turno 25: 52 s de trabajo, 5 herramientas usadas

Turno 25 · 52 s

Ida: lo que escribimos

Actualiza el README con la instalación, el arranque, los controles y los comandos de build, lint y test.

Vuelta: lo que contestó Claude

  1. Read ~/sdd-931/arkanoid/README.md
  2. Edit ~/sdd-931/arkanoid/README.md
  3. Edit ~/sdd-931/arkanoid/README.md
  4. Edit ~/sdd-931/arkanoid/README.md

Compruebo que las órdenes del README funcionan tal como están escritas.

  1. Bash node --test --test-name-pattern="último ladrillo" tests/game.test.js 2>&1 | grep -E "^✔|ℹ (tests|pass|fail)"; npm run build 2>&1 | grep -E "dist/|built"; (npx vite preview --port 4179 --strictPort >/dev/null 2>&1 &); sleep 1.5; curl -s -o /dev/null -w "preview HTTP %{http_code}\n" http://localhost:4179/; pkill -f "vite preview --port 4179"; rm -rf dist; npm test 2>&1 | grep -E "ℹ (tests|fail)"; np

He actualizado el README y he comprobado que todas las órdenes que documenta funcionan tal como están escritas: la prueba suelta, la compilación, la vista previa, la batería completa (44 pruebas) y el lint.

Las secciones nuevas:

  • Instalación. Explica qué hace falta, qué instala npm install (solo Vite y ESLint, sin dependencias en tiempo de ejecución) y con qué versiones se ha comprobado.
  • Arranque. Explica npm start, en qué dirección queda el juego, qué pasa si el puerto está ocupado, la recarga al guardar y cómo cerrar el servidor.
  • Controles. Es una tabla con ← o A, → o D y Espacio. Añade que se puede elegir desde dónde sale la bola y que conviene mantener el espacio pulsado un instante, por el fallo del toque rapidísimo que encontré al ejecutar el juego.
  • Compilar, analizar y probar. Recoge npm run build (con npx vite preview para ver la versión publicada), npm run lint y npm test. Explica cómo ejecutar una sola prueba y qué significa que un fichero sea .ratificada.test.js.

He corregido un dato que el README tenía mal desde el principio. Decía que bastaba Node 20, pero npm test usa patrones glob en node --test, y eso solo existe desde Node 21. Ahora pide Node 22 o posterior, que es la versión LTS más próxima.

También he añadido scripts/jugar-bot.mjs a la estructura. Las secciones de juego, multibola y estructura siguen como estaban, y he conservado tu frase inicial. No he hecho ningún commit: además del README, siguen pendientes scripts/jugar-bot.mjs y .claude/skills/verify/ de la verificación anterior.

Salida de cada orden, tal como apareció en la pantalla

Pantalla al terminar el turno: «Actualiza el README con la instalación, el arranque, los controles y los comandos de bu…»
          cada una en su fichero, van la aparición de bolas hasta el tope de 200 (`tope-200.ratificada.test.js`,
          ya ratificada), la puntuación única por ladrillo (`puntuacion-unica.test.js`) y los puntos del x3 con s
          u bonus por velocidad (`multiplicador-bonus.test.js`), estas dos pendientes de ratificar.
      71  - `scripts/observar.mjs`: hace capturas del juego en Chrome sin ventana, a los milisegundos que se le i
          ndiquen, para observarlo en marcha.
      72 +- `scripts/jugar-bot.mjs`: juega solo en Chrome sin ventana (sigue a la bola más baja leyendo el canvas
         +) y hace capturas cada 3 s. Lo usa la verificación descrita en `.claude/skills/verify/SKILL.md`.
      73  - `docs/`: la especificación de la multibola y las capturas que la respaldan, en `docs/evidencias/`.

⏺ Compruebo que las órdenes del README funcionan tal como están escritas.

  Ran 1 shell command

⏺ He actualizado el README y he comprobado que todas las órdenes que documenta funcionan tal como están escritas: la
  prueba suelta, la compilación, la vista previa, la batería completa (44 pruebas) y el lint.

  Las secciones nuevas:

  - Instalación. Explica qué hace falta, qué instala npm install (solo Vite y ESLint, sin dependencias en tiempo de
    ejecución) y con qué versiones se ha comprobado.
  - Arranque. Explica npm start, en qué dirección queda el juego, qué pasa si el puerto está ocupado, la recarga al
    guardar y cómo cerrar el servidor.
  - Controles. Es una tabla con ← o A, → o D y Espacio. Añade que se puede elegir desde dónde sale la bola y que
    conviene mantener el espacio pulsado un instante, por el fallo del toque rapidísimo que encontré al ejecutar el
    juego.
  - Compilar, analizar y probar. Recoge npm run build (con npx vite preview para ver la versión publicada), npm run lint
    y npm test. Explica cómo ejecutar una sola prueba y qué significa que un fichero sea .ratificada.test.js.

  He corregido un dato que el README tenía mal desde el principio. Decía que bastaba Node 20, pero npm test usa patrones
  glob en node --test, y eso solo existe desde Node 21. Ahora pide Node 22 o posterior, que es la versión LTS más
  próxima.

  También he añadido scripts/jugar-bot.mjs a la estructura. Las secciones de juego, multibola y estructura siguen como
  estaban, y he conservado tu frase inicial. No he hecho ningún commit: además del README, siguen pendientes
  scripts/jugar-bot.mjs y .claude/skills/verify/ de la verificación anterior.

✻ Cogitated for 28s · done 21:04
                                                                       Update available! Run: brew upgrade claude-code
─────────────────────────────────────────────────────────────────────────────────────────────── casos-limite-multibola ─
❯ Corrige el fallo del saque con un toque rápido
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  ⏸ manual mode on · ? for shortcuts · ← for agents
Terminal: $ git add -A && git commit -q -m "Multibola completa" && git log --oneline
arkanoid $ git add -A && git commit -q -m "Multibola completa" && git log --oneline
6358aac (HEAD -> main) Multibola completa
1b90295 Multibola: p11-inc4-multiplicador
7added6 Multibola: p11-inc3-puntuacion
4cb5b28 Multibola: p11-inc2-tope
9d4d610 Multibola: p11-inc1-recuento
3515776 Primera versión sin multibola
538423c Inicio del proyecto
arkanoid $
Los 4 menús de este paso, tal como aparecieron

Menú de permiso · 137

 15 +Solo instala dependencias de desarrollo: Vite para servir y compilar el juego, y ESLint para analizar el código. El
    + juego no tiene dependencias en tiempo de ejecución.
 16 +
 17 +## Arranque
 18 +
 19 +```bash
 20 +npm start
 21 +```
 22 +
 23 +Arranca el servidor de desarrollo de Vite. El juego queda en `http://localhost:5173/` (Vite elige otro puerto si es
    +e está ocupado y lo indica en la terminal) y se recarga solo al guardar un cambio en `src/`. Para cerrarlo, Ctrl+C.
 24 +
 25 +## Controles
 26 +
 27 +| Tecla | Acción |
 28 +|---|---|
 29 +| ← o A | Mover la pala a la izquierda |
 30 +| → o D | Mover la pala a la derecha |
 31 +| Espacio | Lanzar la bola al empezar; volver a jugar al ganar o perder |
 32 +
 33 +Antes del saque, la bola viaja pegada a la pala, así que se puede elegir desde dónde sale. Conviene mantener la bar
    +ra espaciadora pulsada un instante: un toque rapidísimo, de menos de un fotograma, puede perderse y la bola no sale
    +.
 34 +
 35  ## Cómo se juega
 36
  9 -La pala se mueve con las flechas ← → o con A y D, y la bola se lanza con la barra espaciadora. El punto de la pala
    -donde golpea la bola decide el rebote: en el centro sale casi vertical y en los extremos se desvía hasta 60 grados.
    - Cada ladrillo normal vale entre 10 y 50 puntos según su fila. Al terminar la partida, la barra espaciadora empieza
    - otra.
 37 +El punto de la pala donde golpea la bola decide el rebote: en el centro sale casi vertical y en los extremos se des
    +vía hasta 60 grados. Cada ladrillo normal vale entre 10 y 50 puntos según su fila.
 38
 39  ### Multibola
 40
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to README.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 138

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 README.md
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 46
 47  Los requisitos, las decisiones ratificadas y las provisionales están en [docs/especificacion-multibola.md](docs/esp
     ecificacion-multibola.md).
 48
 49 -## Órdenes
 49 +## Compilar, analizar y probar
 50
 51  | Orden | Qué hace |
 52  |---|---|
 53 -| `npm install` | Instala Vite y ESLint (solo dependencias de desarrollo) |
 54 -| `npm start` | Arranca el servidor de desarrollo de Vite; el juego queda en `http://localhost:5173/` |
 55 -| `npm run build` | Genera la versión publicable en `dist/` |
 56 -| `npm run lint` | Analiza el código con ESLint |
 57 -| `npm test` | Ejecuta las pruebas con el ejecutor de Node (`node --test`) |
 53 +| `npm run build` | Genera la versión publicable en `dist/` (un `index.html` y un único fichero JavaScript). Para p
    +robarla tal como quedará publicada: `npx vite preview` |
 54 +| `npm run lint` | Analiza con ESLint `src/`, `tests/`, `scripts/` y los hooks de `.claude/hooks/` |
 55 +| `npm test` | Ejecuta todas las pruebas de `tests/` con el ejecutor que trae Node (`node --test`) |
 56
 59 -Necesita Node 20 o posterior; se ha comprobado con Node 25.
 57 +Para ejecutar una sola prueba, se filtra por su nombre:
 58
 59 +```bash
 60 +node --test --test-name-pattern="último ladrillo" tests/game.test.js
 61 +```
 62 +
 63 +Las pruebas cuyo fichero termina en `.ratificada.test.js` las ha ratificado el autor: si una falla, se corrige el c
    +ódigo, no la prueba.
 64 +
 65  ## Estructura
 66
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to README.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 139

         +ipt). Para probarla tal como quedará publicada: `npx vite preview` |
      54 +| `npm run lint` | Analiza con ESLint `src/`, `tests/`, `scripts/` y los hooks de `.claude/hooks/` |
      55 +| `npm test` | Ejecuta todas las pruebas de `tests/` con el ejecutor que trae Node (`node --test`) |
      56
      59 -Necesita Node 20 o posterior; se ha comprobado con Node 25.
      57 +Para ejecutar una sola prueba, se filtra por su nombre:
      58
      59 +```bash
      60 +node --test --test-name-pattern="último ladrillo" tests/game.test.js
      61 +```
      62 +
      63 +Las pruebas cuyo fichero termina en `.ratificada.test.js` las ha ratificado el autor: si una falla, se
         +corrige el código, no la prueba.
      64 +
      65  ## Estructura
      66
      67  - `src/game.js`: la lógica del juego, sin navegador (estado, movimiento, choques, puntuación y fin de p
          artida).

⏺ Update(README.md)

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Edit file
 README.md
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 69  - `src/main.js`: el teclado, el bucle de animación y el dibujo en el canvas.
 70  - `tests/`: las pruebas de la lógica (`game.test.js`) y de la multibola (`multiball.test.js`). Aparte, cada una en
     su fichero, van la aparición de bolas hasta el tope de 200 (`tope-200.ratificada.test.js`, ya ratificada), la puntu
     ación única por ladrillo (`puntuacion-unica.test.js`) y los puntos del x3 con su bonus por velocidad (`multiplicado
     r-bonus.test.js`), estas dos pendientes de ratificar.
 71  - `scripts/observar.mjs`: hace capturas del juego en Chrome sin ventana, a los milisegundos que se le indiquen, par
     a observarlo en marcha.
 72 +- `scripts/jugar-bot.mjs`: juega solo en Chrome sin ventana (sigue a la bola más baja leyendo el canvas) y hace cap
    +turas cada 3 s. Lo usa la verificación descrita en `.claude/skills/verify/SKILL.md`.
 73  - `docs/`: la especificación de la multibola y las capturas que la respaldan, en `docs/evidencias/`.
╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌
 Do you want to make this edit to README.md?
 ❯ 1. Yes
   2. Yes, and switch to accept edits (auto-approve file edits and common file commands) for this session (shift+tab)
   3. No

 Esc to cancel · Tab to amend

Menú de permiso · 140

      67  - `src/game.js`: la lógica del juego, sin navegador (estado, movimiento, choques, puntuación y fin de p
          artida).

⏺ Update(README.md)
  ⎿  Added 1 line
      69  - `src/main.js`: el teclado, el bucle de animación y el dibujo en el canvas.
      70  - `tests/`: las pruebas de la lógica (`game.test.js`) y de la multibola (`multiball.test.js`). Aparte,
          cada una en su fichero, van la aparición de bolas hasta el tope de 200 (`tope-200.ratificada.test.js`,
          ya ratificada), la puntuación única por ladrillo (`puntuacion-unica.test.js`) y los puntos del x3 con s
          u bonus por velocidad (`multiplicador-bonus.test.js`), estas dos pendientes de ratificar.
      71  - `scripts/observar.mjs`: hace capturas del juego en Chrome sin ventana, a los milisegundos que se le i
          ndiquen, para observarlo en marcha.
      72 +- `scripts/jugar-bot.mjs`: juega solo en Chrome sin ventana (sigue a la bola más baja leyendo el canvas
         +) y hace capturas cada 3 s. Lo usa la verificación descrita en `.claude/skills/verify/SKILL.md`.
      73  - `docs/`: la especificación de la multibola y las capturas que la respaldan, en `docs/evidencias/`.

⏺ Compruebo que las órdenes del README funcionan tal como están escritas.

  Checking the documented commands: single test, building, previewing, tests and linting
  ⎿  $ node --test --test-name-pattern="último ladrillo" tests/game.test.js 2>&1 | grep -E "^✔|ℹ (tests|pass|fail)"; npm
     run build 2>&1 | grep -E "dist/|built"; (npx vite preview --port 4179 --strictPort >/dev/null 2>&1 &); sleep 1.5;
     curl -s -o /dev/null -w "preview HTTP %{http_code}\n" http://localhos…

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Bash command
 Tip: auto mode handles these prompts for you — choose "switch to auto mode" below

   │ node --test --test-name-pattern="último ladrillo" tests/game.test.js 2>&1 | grep -E "^✔|ℹ (tests|pass|fail)";
   │ npm run build 2>&1 | grep -E "dist/|built"; (npx vite preview --port 4179 --strictPort >/dev/null 2>&1 &); sleep
   │ 1.5; curl -s -o /dev/null -w "preview HTTP %{http_code}\n" http://localhost:4179/; pkill -f "vite preview
   │ --port 4179"; rm -rf dist; npm test 2>&1 | grep -E "ℹ (tests|fail)"; npm run lint >/dev/null 2>&1; echo "lint:
   │ $?"
   Check the documented commands: single test, build, preview, tests and lint

 Contains shell syntax (&) that cannot be statically analyzed

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and switch to auto mode · auto mode handles these prompts for you
   3. No

 Esc to cancel · Tab to amend

Paso 14: cada petición en su sitio (13 en la versión 87a)

Este paso del libro no es una instrucción para Claude, sino un repaso: cada tipo de petición tiene su sitio, y en una conversación larga las peticiones sueltas se olvidan. Al terminar, las reglas que valen siempre estaban en CLAUDE.md, el procedimiento repetible en la skill, la protección de la prueba en el hook y en los permisos, y lo que debe hacer la multibola en la especificación. Por eso no hay mensajes que mostrar: lo comprobamos leyendo el repositorio.

Lo que dice el libro (versión 87a)

13. Llevar las peticiones al proyecto. A lo largo del libro hemos reunido peticiones en varias tablas: la de lo que podemos montar con Claude Code, la de los estudios recientes, la que protege lo ratificado y las del entorno del agente y de la portabilidad. No hace falta repetirlas en cada conversación, porque cada una tiene un sitio en el proyecto según lo que tenga que garantizar.

Tabla 17. Dónde dejar cada tipo de petición en el proyecto.

Tipo de peticiónDónde la dejamosEjemplo en el Arkanoid
Reglas que valen siempreCLAUDE.md del proyectoEscribir cada requisito con identificador y plantilla EARS
Procedimientos que se repitenSkills en .claude/skills/La skill casos-limite, que prepara la tabla de límites de la multibola
Controles locales que deben hacerse efectivosHooks y reglas de permisosBloquear la edición de la prueba ratificada del máximo de 200 bolas
Encargos con su propio contextoSubagentes definidos en el proyectoEl revisor de casos límite, con un modelo barato y sin permiso para editar
Estado y relevoFicheros versionados del repositoriodocs/relevo.md, con la tarea activa y el último commit con las pruebas en verde
Lo que decide si un cambio entraCI y rama protegidaLa verja que falla si desaparece una prueba de la rama principal

Una petición que solo está en la conversación depende de que alguien se acuerde de repetirla en la siguiente sesión. En su sitio la encuentra cualquier persona del equipo al abrir el repositorio, y el agente la recibe sin que tengamos que pedírsela. Lo que siga escrito solo en el chat al terminar, sea una regla o una decisión, pasa ahora al fichero que le corresponde.

APRENDIZAJES

Lo que esperábamos, lo que pasó y lo que hacemos ahora

Cinco cosas no salieron como decía el libro. Ninguna impide completar el recorrido, pero todas cambian lo que tiene que saber quien lo siga, así que las hemos llevado al texto.

EsperábamosPasóAhora
Que Claude preguntara antes de cada acciónSin configurar el modo, la sesión arranca en modo auto; el modo que pregunta se llama «manual»Ponemos "defaultMode": "default" en la configuración del proyecto
Que /plan texto siempre planificara ese textoSi ya estás en modo de planificación, el texto se ignoraEntramos en el modo con /plan texto desde fuera de él
Que una skill o un subagente nuevos se vieran al momentoHay que reiniciar con /exit y claude --continue; los hooks sí se recargan solosCreamos skills y agentes antes de abrir la sesión, o reiniciamos
Que /goal marcara el final y después fuéramos por etapasCon ese criterio, /goal implementa todo en un turnoPrimero los incrementos; /goal al final, para comprobar. En el libro, los incrementos pasan a ser el paso 10 y /goal el 11
Que /run y /verify solo arrancaran y comprobaran/run encontró un fallo sin arreglarlo; /verify dejó una skill en el repositorioCada fallo encontrado es una nueva petición; revisamos lo que añade /verify

Hay dos aprendizajes más que no son errores del libro, sino del método de prueba. El primero: automatizar a una persona es más difícil de lo que parece. Dos vueltas se perdieron por cómo llegaba el texto a Claude, y en la segunda Claude acabó diseñando su propia multibola porque nunca recibió nuestras decisiones. Es justo el problema que intenta resolver una especificación, visto desde el otro lado. El segundo: 101 permisos en 46 minutos son muchos. Cada uno se contesta rápido, pero en un trabajo real cansan, y por eso conviene pensar bien qué se permite sin preguntar.

También medimos dónde se fue el tiempo. Los dos pasos más largos fueron el 11 y el 12, de más de diez minutos cada uno, y /usage indicó que casi la mitad del uso se hizo con más de 150.000 tokens de contexto. Cuanto más larga es la conversación, más caro es cada paso; el libro recomienda compactar o empezar de cero entre etapas, y estos números le dan la razón.

CONCLUSIONES

El recorrido funciona, con el orden corregido

Los catorce pasos del apartado 9.3.1 se pueden seguir con Claude Code 2.1.285 y dejan lo que prometen: un juego que funciona, una especificación escrita y aprobada antes del código, pruebas en verde y protecciones que aguantan aunque se le pida al agente saltárselas. Por eso damos el recorrido por validado.

Lo que más nos convenció fue ver al agente trabajar dentro de unos límites. En el paso 7 preguntó en vez de suponer, en el 9 desconfió de un informe flojo y en el 11 se negó a tocar una prueba protegida incluso por un camino que el hook no vigilaba. Lo que más nos enseñó fue el paso 10: una instrucción razonable puesta en el orden equivocado convierte un trabajo por etapas en una implementación de golpe.

Quedan dos límites que decimos abiertamente. El fallo del saque con un toque rápido sigue sin arreglar, porque arreglarlo era otra petición y no formaba parte del recorrido. Y los casos de 199 y 200 bolas están comprobados por pruebas automáticas, no observados en pantalla.

El libro cierra el apartado con esta reflexión, que después de recorrerlo suscribimos:

Lo que dice el libro (versión 87a)

En este primer recorrido revisaremos especialmente cuándo se autorizó la edición, qué permisos se concedieron y si se tocó alguna prueba que estaba fallando. Distinguiremos también el informe del modelo de las comprobaciones ejecutadas, y repetiremos estas últimas sobre el contenido exacto del commit. La figura sitúa cada revisión en el paso donde sirve para detectar el problema.

Una primera petición puede dejar claros los archivos de salida y el momento en que queremos revisar la propuesta:

Analiza la multibola sin editar código.
Enumera dudas y casos límite, incluido n = 200.
Propón cambios para spec.md, plan.md y tasks.md.
Detente y espera mi aprobación antes de tocar src/ o tests/.

Una skill local de Claude Code puede guardarse en .claude/skills/resumen-cambios/SKILL.md. La carpeta da nombre al comando /resumen-cambios. Para que el agente sepa cuándo cargarla, la cabecera de este ejemplo lleva esta descripción.

description: Resume los cambios sin confirmar y señala riesgos. Usar al revisar el diff.

La ficha le pide que revise las diferencias de la copia de trabajo y avise si faltan pruebas. El texto que se puede copiar está en el apéndice.

La skill orienta al agente y puede cargarse por contexto o invocarse con /resumen-cambios. Con un plugin se pueden distribuir skills, agentes, hooks y servidores MCP mediante .claude-plugin/plugin.json. Spec Kit utiliza su propia CLI, extensiones, presets y workflows: specify init prepara la integración, Claude lee las instrucciones instaladas y el workflow ordena sus pasos. Los permisos y la protección de ramas se configuran en el entorno y en el repositorio.

Los permisos y hooks del diagrama son la política que proponemos configurar y ensayar para este proyecto. PreToolUse no protege por sí solo cualquier escritura de shell o MCP, y una instrucción de CLAUDE.md no sustituye ese control. La persona ratifica el significado; la CI y la protección de rama exigen la evidencia del commit que se integra.

Si repites el recorrido, lo normal es que no te salga igual. Cambian la versión de Claude Code y del modelo, los CLAUDE.md que se cargan según dónde trabajes, tu configuración, el sistema y hasta el orden en que el modelo decide hacer las cosas. Aunque lo repitiéramos nosotros con el mismo equipo, las preguntas, el código y los tiempos saldrían algo distintos.

Por eso lo que conviene llevarse no son las cifras ni las pantallas exactas, sino los conceptos y los aprendizajes: especificar antes de construir, ir por etapas pequeñas antes de fijar el final, proteger con hooks y permisos lo que no debe cambiar, contrastar la opinión del modelo con comprobaciones que se pueden repetir y probar el resultado de verdad, porque las pruebas no lo ven todo. La tabla del principio dice con qué se hizo este recorrido, para que puedas situar las diferencias que encuentres.

Si quieres comentar lo que te ha salido, escríbenos a contacto@hardment.com.