@thebattlearena/corner 0.8.0 → 0.9.1-beta.70

package/plugin/tests/ring-pane.test.tsx

@@ -163,6 +163,10 @@ type Setup = {
   remote?: string;
   /** Aquí se anotan los `argv` de cada `process.run`. */
   runs?: string[][];
+  /** Sparrings en `<RING_HOME>/sparrings/<slug>/`: su `sparring.json` y su feed. */
+  sparrings?: Record<string, { state: object; live: object[] }>;
+  /** El id de la sesión (`$.session.id()`). */
+  sessionId?: string;
 };
 
 const engine = (on: On, setup: Setup = {}) => {
@@ -179,6 +183,8 @@ const engine = (on: On, setup: Setup = {}) => {
     termProgram,
     remote = 'git@github.com:julio-supervisor/agents-studio-be.git\n',
     runs = [],
+    sparrings = {},
+    sessionId = 'sesion-1',
   } = setup;
   const files: Record<string, string> = {
     '/Users/test/.claude/battle-arena/config.json': JSON.stringify({
@@ -196,6 +202,15 @@ const engine = (on: On, setup: Setup = {}) => {
     [`${BOUT}/live.jsonl`]: live.map((e) => JSON.stringify(e)).join('\n'),
     [`${BOUT}/title-defense.md`]: CATALOGUE,
     [`${ROOT}/.claude/ring.json`]: JSON.stringify({ monitors }),
+    ...Object.fromEntries(
+      Object.entries(sparrings).flatMap(([slug, { state, live: feed }]) => [
+        [`${HOME}/sparrings/${slug}/sparring.json`, JSON.stringify(state)],
+        [
+          `${HOME}/sparrings/${slug}/live.jsonl`,
+          feed.map((e) => JSON.stringify(e)).join('\n'),
+        ],
+      ]),
+    ),
   };
   const dirs: Record<string, string[]> = {
     [HOME]: ['julio-supervisor'],
@@ -210,6 +225,13 @@ const engine = (on: On, setup: Setup = {}) => {
       'round-15-b.md',
       'round6-since.txt',
     ],
+    [`${HOME}/sparrings`]: Object.keys(sparrings),
+    ...Object.fromEntries(
+      Object.keys(sparrings).map((slug) => [
+        `${HOME}/sparrings/${slug}`,
+        ['sparring.json', 'live.jsonl', 'card.md'],
+      ]),
+    ),
   };
   on('session.start', (_, e) => ({ cwd: e.cwd }));
   on('clock.now', () => ({ value: NOW }));
@@ -252,6 +274,7 @@ const engine = (on: On, setup: Setup = {}) => {
   on('ui.open', () => ({ value: { isPlaced: true } }));
   on('ui.toast', () => ({ value: undefined }));
   on('session.root', () => ({ value: ROOT }));
+  on('session.id', () => ({ value: sessionId }));
   on('env.get', (_, e) => {
     if (e.name === 'TERM_PROGRAM') return { value: termProgram };
     return { value: e.name === 'RING_HOME' ? HOME : '/Users/test' };
@@ -1346,3 +1369,134 @@ for (const termProgram of [undefined, 'Apple_Terminal'])
     expect((await ui.find({ key: 'ring-chip-bateria' }))?.text).toContain('⚠');
     await ui.unmount();
   });
+
+const SPARRING = {
+  slug: 'tira-morada',
+  verdict: { call: 'rematch', note: 'oculta los totales', at: ago(7200) },
+  history: [{ call: 'rematch' }],
+  repos: [
+    {
+      repo: 'acme/api',
+      worktree: '/wt/api-sparring',
+      pr: 7,
+      url: 'https://github.com/acme/api/pull/7',
+    },
+    { repo: 'acme/web', worktree: '/wt/web-sparring', pr: null, url: null },
+  ],
+  sessions: [{ id: 'sesion-1', role: 'referee' }],
+};
+
+const SPARRING_LIVE = [
+  {
+    at: ago(900),
+    actor: 'arbitro',
+    state: 'done',
+    label: 'abrió el PR',
+    id: 'p',
+  },
+  {
+    at: ago(240),
+    actor: 'rudo',
+    state: 'active',
+    label: 'tira-morada acme/web',
+    id: 'r1',
+    detail: 'tira-morada acme/web',
+  },
+];
+
+test('sparring: su sección con la ronda, el veredicto, sus repos y el rudo trabajando', async ($, on) => {
+  engine(on, {
+    sparrings: { 'tira-morada': { state: SPARRING, live: SPARRING_LIVE } },
+  });
+  await start($);
+  const ui = await $.ui.mount({ ...PANE, surface: 'terminal' });
+  const row = 'sparring-tira-morada-row';
+  expect(await ui.find({ key: row })).toBeTruthy();
+  expect(
+    await ui.find({ type: 'Text', text: 'Sparring tira-morada' }),
+  ).toBeTruthy();
+  // Va tras los puntos del plan, como un combate sin punto anfitrión.
+  const tree = await texts(ui);
+  expect(tree.indexOf('Programar lotes desde el panel')).toBeLessThan(
+    tree.indexOf('Sparring tira-morada'),
+  );
+  expect(await ui.find({ key: 'sparring-tira-morada-chip-rudo' })).toBeFalsy();
+  await ui.press({ key: row });
+  expect(await ui.find({ type: 'Text', text: 'ronda 2' })).toBeTruthy();
+  expect(
+    await ui.find({ type: 'Text', text: 'último veredicto: rematch' }),
+  ).toBeTruthy();
+  expect(
+    await ui.find({ key: 'sparring-tira-morada-repo-acme/api', text: /#7/ }),
+  ).toBeTruthy();
+  expect(
+    await ui.find({
+      key: 'sparring-tira-morada-repo-acme/web',
+      text: /sin PR/,
+    }),
+  ).toBeTruthy();
+  // La tira: árbitro, rudo y juez; el rudo trabaja (su barrita), el combate sigue con la suya.
+  for (const id of ['arbitro', 'rudo', 'juez'])
+    expect(
+      await ui.find({ key: `sparring-tira-morada-chip-${id}` }),
+    ).toBeTruthy();
+  expect(
+    await ui.find({ key: 'sparring-tira-morada-chip-luchador' }),
+  ).toBeFalsy();
+  expect(
+    await ui.find({
+      key: 'sparring-tira-morada-chip-rudo',
+      text: /[▰▱]{4}/,
+    }),
+  ).toBeTruthy();
+  expect(
+    await ui.find({ type: 'Text', text: 'tira-morada acme/web' }),
+  ).toBeTruthy();
+  // Abrir la ficha del rudo no abre ninguna del combate.
+  await ui.press({ key: 'sparring-tira-morada-chip-rudo' });
+  expect(await ui.find({ key: 'sparring-tira-morada-field-en' })).toBeTruthy();
+  expect(await ui.find({ key: 'ring-field-en' })).toBeFalsy();
+  await ui.unmount();
+});
+
+test('sparring: una pregunta abierta enciende al juez; uno con ko o de otra sesión no se pinta', async ($, on) => {
+  engine(on, {
+    sparrings: {
+      'tira-morada': {
+        state: SPARRING,
+        live: [
+          ...SPARRING_LIVE,
+          {
+            at: ago(30),
+            actor: 'juez',
+            state: 'waiting',
+            label: 'te toca decidir',
+            id: 'q1',
+          },
+        ],
+      },
+      ganada: {
+        state: {
+          ...SPARRING,
+          slug: 'ganada',
+          verdict: { call: 'ko', note: 'x' },
+        },
+        live: [],
+      },
+      ajena: {
+        state: { ...SPARRING, slug: 'ajena', sessions: [{ id: 'otra' }] },
+        live: [],
+      },
+    },
+  });
+  await start($);
+  const ui = await $.ui.mount({ ...PANE, surface: 'terminal' });
+  expect(await ui.find({ key: 'sparring-ganada-row' })).toBeFalsy();
+  expect(await ui.find({ key: 'sparring-ajena-row' })).toBeFalsy();
+  await ui.press({ key: 'sparring-tira-morada-row' });
+  expect(
+    await ui.find({ key: 'sparring-tira-morada-chip-juez', text: 'tú' }),
+  ).toBeTruthy();
+  expect(await ui.find({ type: 'Text', text: /TE TOCA DECIDIR/ })).toBeTruthy();
+  await ui.unmount();
+});

package/plugin/tests/ring.test.ts

@@ -416,13 +416,15 @@ test('paleta: cada actor con su color; un monitor pide uno de la paleta o va en
     e2e: 'pink',
     mal: 'green',
   });
-  expect(Object.keys(ACTOR_COLOR)).toHaveLength(6);
-  expect(new Set(Object.values(ACTOR_COLOR)).size).toBe(6);
+  // El rudo (sparring) no va en la tira de un combate, pero tiene su color: el rosa.
+  expect(ACTOR_COLOR.rudo).toBe('pink');
+  expect(Object.keys(ACTOR_COLOR)).toHaveLength(7);
+  expect(new Set(Object.values(ACTOR_COLOR)).size).toBe(7);
   expect(Object.keys(PALETTE)).toContain('green');
 });
 
-test('los íconos salen de la fuente: los 58, con su glifo, sus letras y sus PNG', () => {
-  expect(Object.keys(ICONS)).toHaveLength(58);
+test('los íconos salen de la fuente: los 59, con su glifo, sus letras y sus PNG', () => {
+  expect(Object.keys(ICONS)).toHaveLength(59);
   expect(ICONS.trofeo).toEqual({
     glyph: String.fromCodePoint(0xfba57),
     alt: 'TR',
@@ -431,6 +433,13 @@ test('los íconos salen de la fuente: los 58, con su glifo, sus letras y sus PNG
     cells: 1,
   });
   expect(ICONS.luchador.tints).toEqual(['blue', 'red', 'amber']);
+  expect(ICONS.rudo).toEqual({
+    glyph: String.fromCodePoint(0xfba16),
+    alt: 'RU',
+    png: 'rudo',
+    tints: ['pink', 'red', 'amber'],
+    cells: 1,
+  });
   expect(
     monitorsOf({ monitors: [{ id: 'copa', label: 'Copa', icon: 'trofeo' }] }),
   ).toEqual([{ id: 'copa', label: 'Copa', icon: 'trofeo' }]);

package/plugin/tests/sparring.test.ts

@@ -0,0 +1,204 @@
+import { expect, test } from 'claude-code/testing';
+
+import type { RingEvent } from '../types';
+import type { SparringFile } from '../hooks/sparring';
+import { deriveRing, monitorsOf, parseEvents } from '../hooks/ring';
+import {
+  deriveSparring,
+  isActiveSparring,
+  roundOf,
+  SPARRING_FRESH_MS,
+  sparringOf,
+  sparringsFor,
+} from '../hooks/sparring';
+
+const NOW = Date.parse('2026-10-24T20:00:00Z');
+const ago = (seconds: number) => new Date(NOW - seconds * 1000).toISOString();
+const HOUR = 3_600_000;
+
+const file = (slug: string, extra: Partial<SparringFile> = {}) => ({
+  slug,
+  verdict: null,
+  repos: [
+    {
+      repo: 'acme/web',
+      worktree: `/wt/web-sparring-${slug}`,
+      pr: null,
+      url: null,
+    },
+  ],
+  sessions: [{ id: 's1' }],
+  ...extra,
+});
+
+test('activo: sin veredicto final (un rematch sigue) y tocado en las últimas 12 h', () => {
+  expect(isActiveSparring(file('a'), NOW - HOUR, NOW)).toBe(true);
+  expect(
+    isActiveSparring(
+      file('a', { verdict: { call: 'rematch', note: 'x' } }),
+      NOW,
+      NOW,
+    ),
+  ).toBe(true);
+  expect(
+    isActiveSparring(
+      file('a', { verdict: { call: 'ko', note: 'x' } }),
+      NOW,
+      NOW,
+    ),
+  ).toBe(false);
+  expect(
+    isActiveSparring(
+      file('a', { verdict: { call: 'discard', note: 'x' } }),
+      NOW,
+      NOW,
+    ),
+  ).toBe(false);
+  expect(isActiveSparring(file('a'), NOW - SPARRING_FRESH_MS, NOW)).toBe(false);
+  expect(isActiveSparring({ slug: 3 }, NOW, NOW)).toBe(false);
+});
+
+test('qué sparrings muestra la sesión: los que registró; sin ninguno, los de su carpeta', () => {
+  const found = [
+    { state: file('vieja'), touched: NOW - 2 * HOUR },
+    { state: file('nueva'), touched: NOW - HOUR },
+    { state: file('ajena', { sessions: [{ id: 's2' }] }), touched: NOW },
+    {
+      state: file('ganada', { verdict: { call: 'ko', note: 'x' } }),
+      touched: NOW,
+    },
+  ];
+  const slugs = (list: typeof found) => list.map((s) => s.state.slug);
+  expect(
+    slugs(sparringsFor(found, { sessionId: 's1', root: '/repo', now: NOW })),
+  ).toEqual(['nueva', 'vieja']);
+  // Otra sesión que no registró ninguno: los que trabajan en su carpeta (o debajo de ella).
+  expect(
+    slugs(
+      sparringsFor(found, {
+        sessionId: 's9',
+        root: '/wt/web-sparring-ajena/src',
+        now: NOW,
+      }),
+    ),
+  ).toEqual(['ajena']);
+  expect(
+    slugs(
+      sparringsFor(found, {
+        sessionId: null,
+        root: '/wt/web-sparring-ganada',
+        now: NOW,
+      }),
+    ),
+  ).toEqual([]);
+  // `/wt/web-sparring-nuevas` no es la carpeta de `nueva`.
+  expect(
+    slugs(
+      sparringsFor(found, {
+        sessionId: null,
+        root: '/wt/web-sparring-nuevas',
+        now: NOW,
+      }),
+    ),
+  ).toEqual([]);
+});
+
+test('la ronda: veredictos de history + 1; los de antes de history, por su veredicto', () => {
+  expect(roundOf(file('a'))).toBe(1);
+  expect(
+    roundOf(
+      file('a', {
+        verdict: { call: 'rematch', note: 'x' },
+        history: [{}, {}],
+      }),
+    ),
+  ).toBe(3);
+  expect(roundOf(file('a', { verdict: { call: 'rematch', note: 'x' } }))).toBe(
+    2,
+  );
+});
+
+test('el sparring: sus repos con su PR, la ronda, el último veredicto y su tira (árbitro, rudo, juez)', () => {
+  const events = parseEvents(
+    [
+      {
+        at: ago(900),
+        actor: 'arbitro',
+        state: 'done',
+        label: 'abrió el PR',
+        pr: 12,
+      },
+      {
+        at: ago(300),
+        actor: 'rudo',
+        state: 'active',
+        label: 'tira-morada acme/web',
+        id: 'r1',
+      },
+      {
+        at: ago(60),
+        actor: 'juez',
+        state: 'waiting',
+        label: 'te toca decidir',
+        id: 'q1',
+      },
+    ]
+      .map((e) => JSON.stringify(e))
+      .join('\n'),
+    [],
+  );
+  expect(events).toHaveLength(3);
+  const sparring = sparringOf(
+    file('tira-morada', {
+      verdict: { call: 'rematch', note: 'oculta los totales' },
+      history: [{}],
+      repos: [
+        { repo: 'acme/api', pr: 7, url: 'https://github.com/acme/api/pull/7' },
+        { repo: 'acme/web' },
+      ],
+    }),
+    events,
+  );
+  expect(sparring).toMatchObject({
+    slug: 'tira-morada',
+    round: 2,
+    verdict: { call: 'rematch', note: 'oculta los totales' },
+    repos: [
+      { repo: 'acme/api', pr: 7, url: 'https://github.com/acme/api/pull/7' },
+      { repo: 'acme/web', pr: null, url: null },
+    ],
+  });
+  const view = deriveSparring(sparring, NOW);
+  expect(view.chips.map((c) => [c.id, c.color, c.mode])).toEqual([
+    ['arbitro', 'slate', 'done'],
+    ['rudo', 'pink', 'active'],
+    ['juez', 'orange', 'waiting'],
+  ]);
+  expect(view.running).toBe(true);
+  expect(view.waiting).toBe(true);
+  expect(view.live?.id).toBe('juez');
+});
+
+test('el rudo no entra a la tira de un combate, y ningún monitor puede llamarse rudo', () => {
+  const rudo: RingEvent = {
+    at: ago(10),
+    actor: 'rudo',
+    state: 'active',
+    label: 'x',
+  };
+  const view = deriveRing(
+    {
+      slug: 'acme/api',
+      pr: 1,
+      playByPlayUrl: null,
+      defense: null,
+      bells: 0,
+      events: [rudo],
+      monitors: [],
+      commands: [],
+    },
+    NOW,
+  );
+  expect(view.chips.map((c) => c.id)).not.toContain('rudo');
+  expect(monitorsOf({ monitors: [{ id: 'rudo', label: 'Rudo' }] })).toEqual([]);
+});

package/plugin/types/index.d.ts

@@ -247,7 +247,8 @@ export type RingActorId =
   | 'esquinero'
   | 'campana'
   | 'copilot'
-  | 'juez';
+  | 'juez'
+  | 'rudo';
 
 export type RingEventState = 'active' | 'waiting' | 'done' | 'failed';
 
@@ -314,6 +315,27 @@ export type RingBout = {
   commands: string[];
 };
 
+/** Un repo de un sparring: su PR (borrador) cuando ya se abrió. */
+export type RingSparringRepo = {
+  repo: string;
+  pr: number | null;
+  url: string | null;
+};
+
+/**
+ * Un sparring activo, leído de `~/.claude/ring/sparrings/<slug>/` (`sparring.json` y su
+ * `live.jsonl`): no es un combate, pero se pinta como uno, con su propia tira (árbitro, rudo, juez).
+ */
+export type RingSparring = {
+  slug: string;
+  repos: RingSparringRepo[];
+  /** La que se pelea: veredictos de `history` + 1. */
+  round: number;
+  /** El último veredicto (un `rematch`, si sigue activo); `null` mientras el juez no dicta. */
+  verdict: { call: string; note: string } | null;
+  events: RingEvent[];
+};
+
 /** Si la terminal dibuja las imágenes de las fichas (`null` sin probar) y por qué no. */
 export type RingImages = { draws: boolean | null; reason: string | null };
 
@@ -327,6 +349,8 @@ export type IconsDiag = {
 
 export type RingSnapshot = {
   bout: RingBout | null;
+  /** Los sparrings activos de esta sesión (o de su carpeta); vacío sin ninguno. */
+  sparrings?: RingSparring[];
   readAt: number;
   /** `iconFont: true` en la config: la fuente Battle Arena Icons está instalada. */
   iconFont?: boolean;

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

@@ -1,7 +1,7 @@
 {
   "name": "ring",
   "version": "0.1.0",
-  "description": "A way of working for backend, frontend and mobile repos, each at its own venue: a referee session at high effort, one long-lived wrestler at medium, read-only cornermen at high, small do-not-merge review PRs, rebounds, a numbered rulebook and a durable judges card.",
+  "description": "A way of working for backend, frontend and mobile repos, each at its own venue: a referee session at high effort, one long-lived wrestler at medium, read-only cornermen at high, small do-not-merge review PRs, rebounds, a numbered rulebook and a durable judges card, plus sparring drafts (a rudo at medium) that prove a feature is worth building before it is built well.",
   "author": {
     "name": "Battle Arena"
   }

package/ring/agents/rudo.md

@@ -0,0 +1,95 @@
+---
+name: rudo
+description: The ring's sparring executor. Builds a quick, deliberately low-quality draft of a feature in its own worktree, only to prove whether it is worth building; never merged. Launched and directed by the ring referee from `/ring:sparring`; takes every doubt to the referee (never to the human), works inside a timebox and lists every shortcut it took. Suspends the style and test rules, never the live-operation ones.
+tools: Read, Grep, Glob, Edit, Write, Bash
+effort: medium
+---
+
+You are the rudo: in lucha libre the rudo wins however he can, the técnico wins clean. You are
+the first one in. Your job is to make the feature **work well enough for the judge to try it, in
+the whole experience it lives in**, inside the timebox, and to say honestly which corners you cut. If the judge calls it a KO, a ring
+bout refactors your branch later; nobody expects clean code from you.
+
+## What you may skip
+
+- The rulebook's style and design rules (R): layers, patterns, specifications, mappers, file
+  size, naming polish. Inline what is faster.
+- The test rules (T): no coverage needed. Only the typecheck gate must pass.
+- Cornermen, rebounds and round-bells: there are none in a sparring.
+- Contract first: the API or model change is a draft too, reviewed later in the bout.
+
+## What you never skip
+
+- **Live operation (rule F):** no real money, messages, calls or customer events. Sandbox or test
+  modes only. The one exception, when your brief grants it: a real send to the judge's own
+  destinations, read from `SPARRING_ALLOWED_<KIND>` in `.env.sparring` (comma-separated, filled by
+  the judge). Closed by default: an empty list sends nothing; any other destination is recorded
+  with `{ sent: false, reason: "not_allowlisted" }`. Never write a destination in code, a fixture,
+  a commit or a log; log only whether it was sent.
+- **Secrets:** credentials are names in your brief; their values live in
+  `<worktree>/.env.sparring`, filled by the judge. Never commit, print, echo, log or paste a
+  value, nor put one in code, a fixture or a commit message. `mask-guard` blocks committing
+  `.env.sparring`.
+- **Database:** additive only (new tables or columns, English names), never against production.
+  Never drop or alter what exists.
+- Customer data and PII stay out of fixtures and seeds.
+- **Never write to a shared database** (dev, staging). When the proof needs seeded data, prepare
+  it in `<sparring dir>/tools/`: synthetic rows marked with the slug, values that reach nobody
+  (unassigned phone prefixes, `example.invalid` emails), a dry run, and a cleanup that deletes only
+  the marked rows. Report the commands; the judge runs them. If a write is blocked, do not retry it
+  another way.
+- Stage by explicit paths (never `git add -A` or `.`); no `--no-verify`; when the brief's
+  `forbidAiTrailers` is true (the default), no AI attribution trailers.
+- Push only to `sparring/<slug>`, never force. No ready PRs, merges or base changes: `mask-guard`
+  blocks them on a sparring branch, bout or not.
+- Write only inside your worktree; a helper goes in the sparring dir's `tools/`, never in the repo.
+- One heavy command at a time, through `node "<ring>/scripts/one-at-a-time.mjs" run -- <command>`.
+- **Background processes by PID only.** Note the PID of every server, watcher or `tail`/`cat` you
+  leave running (`echo $!` right after starting it) and stop it with `kill <pid>` before you
+  report. Never `pkill`, `killall` or `kill $(pgrep …)`: other sessions on the machine run
+  processes with the same name. Whatever you leave running for the judge to try (the server
+  of the proof), list it in your report with its PID.
+
+## How you work
+
+1. `git -C <worktree> status` must be clean before you start. Every git command is
+   `git -C <worktree> …`.
+2. Build the **full screen or flow** of your brief, the way the design draws it, **working**: the
+   judge must see the whole experience and every visible control must do something (search,
+   filters, tabs, loaders, pagination or infinite scroll, actions and the alert when they fail).
+   Data comes from the back, built quick and dirty; a mock is only for what cannot be had yet.
+   Never a placeholder that says "comes later", never a button that does nothing. Speed comes
+   from the quality you skip, not from the scope or the depth you cut. Before you report, click
+   every control in a browser and list any that still does nothing.
+   - **Designs** in the brief are followed as closely as the timebox allows. A `.pen` file is read
+     only through the pencil MCP tools, never with Read or Grep (it is encrypted).
+   - **Other repos of the sparring:** when you produce what another repo consumes (an SDK, an
+     endpoint), leave it in `<sparring dir>/tools/` (an SDK as an `npm pack` tarball) and report its
+     path, your port and one `curl` that proves it. When you consume, install it from there, never
+     from a registry the sparring published to; until it arrives, a mock behind an env var is a
+     shortcut to list. Locally, accept requests from any `http://localhost:<port>` origin (CORS),
+     never one fixed port, and list it as a shortcut.
+3. Keep a running list of **shortcuts** as you take them ("hardcoded the workspace id", "no
+   pagination", "mapping inline in the repository"): it becomes the first rebound of the bout.
+4. Commit often, conventional messages in the language of the branch's previous commits. Push to
+   `sparring/<slug>` when something is worth trying.
+5. When the timebox runs out, stop where you are, push what works and report.
+6. Every doubt goes to the referee in your report, with two options each. Never to the human.
+
+## What you return (every time you push or stop)
+
+```
+Sparring: <slug> · tip <sha> (pushed to sparring/<slug>)
+Proof of value: reachable ✓ | partial: <what is missing> | not reached: <why>
+How to try it: <how to start it, its port, env vars, sample input>
+Dead controls: none | <control — why> (from your click-through)
+Judge opens: <exact URL of each screen> · enters as <user / workspace / account>
+Left running: none | <process, PID, port> (only what the judge needs to try it)
+Hand-off: none | <path in tools/, port, curl> (producer) | <what you installed from tools/> (consumer)
+Shortcuts: <one line each>
+Credentials used (names only): <NAME, … | none>
+Schema changes: none | <additive change, tables/columns>
+Gate: typecheck ✓/✗ (exact command)
+Questions for the referee: <numbered, 2 options each>
+Time used: <h:mm> of <timebox>
+```

package/ring/scripts/chronicle.mjs

@@ -21,6 +21,20 @@
 //   gh events     ready_for_review → juez; review_requested to Copilot → campana (closes a round)
 //   round-bells   a round-bell PR opened → dado
 //   --extra       any of the types, as given, marked provided
+//
+// A fight that starts at a sparring (sparring-chronicle.mjs, fight.mjs) uses the same eight types,
+// no new one. Its sources, classified:
+//   sparring.json  openedAt → arbitro (the referee opened it); each verdict of history[] → juez
+//                  (a KO closes the first fall); each repo's last preview look → bateria
+//   milestones     (`sparring.mjs mark`) vestidor → bateria (the host gates passed; `sparring.mjs
+//                  vestidor` stamps it); defense → juez (the judge opens it to the team, the note
+//                  holds the hours to the bell); bell → campana; mask-kept / mask-lost → juez;
+//                  no-team → juez («sin equipo»: no second fall, the third starts there);
+//                  referee → arbitro (handed to the bout; `judges-card open --from-sparring` marks it)
+//   blows-round-<n>.md  each Tape it cites → juez (the judge's attack) at the time written next to
+//                  it; its blows (D/B/F/Q/R with their Tape minute) go to `catalogs`, not events
+//   live.jsonl     the referee's own lines: repo added → arbitro; PR opened → dado; preview → bateria
+//   gh / git       each sparring PR opened → dado; test/fix commits in each worktree → dado
 
 export const TYPES = [
   'reclamo',
@@ -418,6 +432,16 @@ export function localTime(at, timeZone) {
   }).format(new Date(at));
 }
 
+/** YYYY-MM-DD in a time zone: a fight that spans days says which day each beat is. */
+export function localDay(at, timeZone) {
+  return new Intl.DateTimeFormat('en-CA', {
+    timeZone,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+  }).format(new Date(at));
+}
+
 /** Did Copilot review the PR's head? Says it plainly for a merge or a close. PURE. */
 export function copilotOnHead(pr, reviews) {
   const copilot = reviews