@thebattlearena/corner 0.10.1-beta.82 → 0.10.1-beta.84

package/README.md

@@ -444,7 +444,12 @@ y al pasar a «espera al juez» el fin y el rango (`--range A..B` lo fija a mano
 `plan.jsonl`, que es lo que lee el modo «Pelea del ring» de PR Review Lab. Cuando `humanReviewEvery`
 bloques (2 por default, `null` lo apaga) esperan al juez, suena la campana en PR Review Lab y
 `brief.mjs` no le arma instrucciones al siguiente luchador hasta que el humano revise ese corte en un
-solo diff y firme un veredicto con Tape. PR Review Lab lo escribe en `<combate>/review-verdicts.jsonl`
+solo diff y firme un veredicto con Tape. Con `parallelBlocks: 2` (el default) dos bloques corren a la vez **en el mismo
+worktree** mientras nada espere la revisión del humano (con algo esperando, uno a la vez), cada luchador sobre los archivos que su bloque declaró (`--files "<globs>"` al estimar o
+arrancar): el script no deja arrancar un bloque con archivos de otro en curso, `mask-guard` rechaza un
+commit con archivos de otro bloque (los de `generatedPaths`, como los docs que regenera un pre-commit,
+no son de nadie: el árbitro los regenera al cerrar la oleada), y `concept … --block <n>` retira solo al
+luchador de ese bloque. Los tests corren al terminar el bloque, sobre lo que tocó. Y mientras el humano revisa un corte, un luchador puede adelantar UN bloque más cuyos archivos no toque el corte: `brief.mjs wrestler … --lookahead "<globs>"`. PR Review Lab lo escribe en `<combate>/review-verdicts.jsonl`
 y el ring lo lee en el siguiente brief o `summary`: si pasa, los bloques quedan en «hecho»; si no
 pasa, vuelven a «en curso» con el feedback y el Tape como rebote, que el brief del siguiente luchador
 trae al principio. Cada veredicto queda en `decisions.md` como decisión del juez (y en Engram).

package/package.json

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

package/ring/agents/cornerman.md

@@ -79,6 +79,11 @@ numbered list of behavior invariants.
      outside tests. One used only by its own spec, or by nobody, is a finding (dead code).
    - **Comments.** Narrating, stale or now-wrong comments in every file the assignment covers,
      **including files the range did not edit** when the brief names them.
+   - **The same question asked again (PR31).** Grep the concept for the same condition (a null
+     check, an optional, a `?.`, a status test) asked for the same reason in several places: three
+     or more is a finding, with where it should be settled once.
+   - **Guards against a provider's events (P16).** A guard against an event a provider's SDK sends
+     cites the SDK code that can send it (`node_modules/<sdk>/…:line`); without it, it is a finding.
    - **Commit messages.** Each message in the range (`git -C <wt> log --format=%B <A>..<B>`) must
      not carry bout-internal ids (D12, P7, HP3, PR5…): they mean nothing in the repo's history.
 5. Return: a table per file (findings with rule ids), a table per invariant (holds / broken, with

package/ring/scripts/brief-build.mjs

@@ -37,7 +37,7 @@ export function rulesBlock({ sources, entries }) {
 }
 
 /**
- * The decisions a brief carries: every foul (what must not be repeated), the ones whose text names
+ * The decisions a brief carries: every foul (what must not be repeated), every ruling of the judge, the ones whose text names
  * a file of the range, and the last `last`; in ledger order, each once. PURE.
  */
 export function decisionsExcerpt(
@@ -54,6 +54,8 @@ export function decisionsExcerpt(
     (line) =>
       tail.has(line) ||
       /\bFOUL\b/.test(line) ||
+      // What the human ruled stays in every brief of the bout, like a foul.
+      / · judge · /.test(line) ||
       names.some((name) => line.includes(name)),
   );
   return kept.length ? kept.join('\n') : '(no decisions yet)';

package/ring/scripts/brief-guard.mjs

@@ -168,7 +168,7 @@ export function guard(input) {
   const problem = problemOf({ ...brief, check, role, pr: state.pr });
   appendFileSync(
     join(bout, GUARD_LOG),
-    `${JSON.stringify({ at: new Date().toISOString(), role, mode, path: brief.path, ok: !problem, problem })}\n`,
+    `${JSON.stringify({ at: new Date().toISOString(), role, mode, path: brief.path, toolUseId: input.tool_use_id ?? null, ok: !problem, problem })}\n`,
   );
   return answer({
     input: input.tool_input,

package/ring/scripts/brief.mjs

@@ -44,7 +44,13 @@ import {
 } from './config.mjs';
 import { recallSection } from './engram.mjs';
 import { conceptsSinceRelay, relayDue } from './relay.mjs';
-import { reviewTurn } from './review-blocks.mjs';
+import { boutLeases } from './lanes.mjs';
+import {
+  lookaheadRefusal,
+  reviewInputs,
+  reviewTurn,
+  runningBlocks,
+} from './review-blocks.mjs';
 import { setPlanState } from './tech-plan-log.mjs';
 import { loadRules } from './rule-ids.mjs';
 
@@ -166,6 +172,85 @@ function boutVars({ dir, state, config }, values) {
   };
 }
 
+/**
+ * The wrestler's block and the files it holds, next to the files other running blocks hold (none:
+ * one block at a time, nothing to add). With parallelBlocks > 1 and another block running, the
+ * brief names its block (--block <n>).
+ */
+function laneSection(bout, block) {
+  const running = boutLeases(bout.dir);
+  if (!block) {
+    if ((bout.config.parallelBlocks ?? 1) > 1 && running.length > 1)
+      throw new Error(
+        `${running.length} blocks are running (${running.map((lease) => `B${lease.n}`).join(', ')}): name this wrestler's block with --block <n>`,
+      );
+    return [];
+  }
+  const mine = running.find((lease) => lease.n === Number(block));
+  if (!mine)
+    throw new Error(
+      `B${block} is not «en curso»: start it with judges-card.mjs plan <pr> ${block} "en curso" --files "<globs>" first`,
+    );
+  const others = running.filter((lease) => lease.n !== mine.n);
+  const list = (files) =>
+    files.length
+      ? files.map((glob) => `\`${glob}\``).join(', ')
+      : '(none declared)';
+  return [
+    `## Your block: B${mine.n} «${mine.title}»`,
+    [
+      `You touch only files matching ${list(mine.files)}.`,
+      others.length
+        ? `Other wrestlers work in this same worktree right now: ${others.map((lease) => `B${lease.n} holds ${list(lease.files)}`).join('; ')}. Never edit, stage or commit their files; mask-guard refuses such a commit. If you need one of them, stop and tell me: I move it between blocks.`
+        : 'No other block is running now.',
+      `Stage by explicit paths only, never \`git add -A\`, \`git stash\`, \`checkout\`, \`reset\` or \`rebase\` (they move the other wrestler's work too).`,
+      `Gates once, when the block is done, not after each edit: the tests of the files you touched, and the typecheck reading only the errors in your files (another block's work in progress may not compile yet).${(bout.config.generatedPaths ?? []).length ? ` Generated files (${list(bout.config.generatedPaths)}) are nobody's: leave them unstaged; I regenerate them when the wave closes.` : ''}`,
+    ].join('\n\n'),
+  ];
+}
+
+/**
+ * While the human reviews a cut, one wrestler may work ahead on a block whose declared files the
+ * cut does not touch (`--lookahead "<globs>"`). Without it, or when it overlaps or another block is
+ * running, the pause holds. Returns the brief's section that bounds the work ahead.
+ */
+function workAhead(bout, lookahead, turn, block) {
+  if (!lookahead)
+    throw new Error(
+      `${turn.due}. Or work ahead on one block whose files the cut does not touch: --lookahead "<glob>,<glob>"`,
+    );
+  const globs = String(lookahead)
+    .split(',')
+    .map((glob) => glob.trim())
+    .filter(Boolean);
+  const { plan, log } = reviewInputs(bout.dir);
+  const waitingFiles = [
+    ...new Set(
+      turn.waiting.flatMap((item) => {
+        const range = log
+          .filter((line) => line.n === item.n && line.range)
+          .at(-1)?.range;
+        return range
+          ? git(bout.state.worktree, ['diff', '--name-only', range])
+              .split('\n')
+              .filter(Boolean)
+          : [];
+      }),
+    ),
+  ];
+  const refusal = lookaheadRefusal({
+    globs,
+    waitingFiles,
+    // The block this brief is for may already be «en curso»: it is not another block ahead.
+    running: runningBlocks(plan).filter((item) => item.n !== Number(block)),
+  });
+  if (refusal) throw new Error(`${turn.due}. ${refusal}`);
+  return [
+    '## Working ahead of the human review (the cut under review must not move)',
+    `The human is reviewing ${turn.waiting.map((item) => `B${item.n}`).join(' + ')}. You work ahead on one block and touch only files matching: ${globs.map((glob) => `\`${glob}\``).join(', ')}. Never edit a file of the cut under review (${waitingFiles.map((file) => `\`${file}\``).join(', ') || 'none'}); if you need one, stop and tell me. If the verdict sends the cut back, its rebound goes first.`,
+  ].join('\n\n');
+}
+
 /** The open rebounds the human's review sent back, as a section of the brief (none: nothing). */
 function humanReview(dir) {
   const path = join(dir, 'rebounds.md');
@@ -180,6 +265,20 @@ function humanReview(dir) {
     : [];
 }
 
+/**
+ * The files the bout changed so far (merge base with its base..head): what Engram searches on when
+ * the brief's own range is empty, as a wrestler starting a new concept has no commit yet.
+ */
+function boutFiles({ worktree, base }) {
+  try {
+    return git(worktree, ['diff', '--name-only', `origin/${base}...HEAD`])
+      .split('\n')
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
 const real = (path) => (existsSync(path) ? realpathSync(path) : path);
 
 async function generate(kind, [pr, ...argv]) {
@@ -194,16 +293,18 @@ async function generate(kind, [pr, ...argv]) {
     throw new Error(
       `a relay is due (${conceptsSinceRelay(bout.state)} concepts since the last one): rewrite the card's «How to resume», run judges-card.mjs relay ${pr}, then brief the next wrestler`,
     );
+  let ahead = null;
   if (kind === 'wrestler') {
     // The human's verdicts from PR Review Lab first: a fail comes back as a rebound for this brief.
     const turn = reviewTurn(
       bout.dir,
       bout.config.humanReviewEvery,
       (n, to, ref) => setPlanState(bout.dir, n, to, ref),
+      bout.config.parallelBlocks ?? 1,
     );
     if (turn.applied.length)
       console.error(`human review applied: ${turn.applied.join(' · ')}`);
-    if (turn.due) throw new Error(turn.due);
+    if (turn.due) ahead = workAhead(bout, values.lookahead, turn, values.block);
   }
   const own = values.vars ? JSON.parse(readFileSync(values.vars, 'utf8')) : {};
   const roots = [
@@ -237,17 +338,19 @@ async function generate(kind, [pr, ...argv]) {
     ? await recallSection(bout.config, {
         slug: repoSlug(projectDir()),
         pr,
-        files,
+        files: files.length ? files : boutFiles(bout.state),
       })
     : null;
   // The task goes first and the rules last, as the reference: a brief that opens with the rules
   // reads as a checklist, and a 2026-11 lab on #1212 found fewer real problems that way.
   const body = [
     text.trim(),
-    '## Decisions already taken (excerpt: every foul, the ones on these files, the last 20)',
+    '## Decisions already taken (excerpt: every foul, every ruling of the judge, the ones on these files, the last 20)',
     decisions,
     `The whole ledger: \`${decisionsPath}\`.`,
     ...humanReview(bout.dir),
+    ...(ahead ? [ahead] : []),
+    ...(kind === 'wrestler' ? laneSection(bout, values.block) : []),
     ...(learned ? [learned] : []),
     ...(shape.rules ? ['---', rules.block] : []),
   ].join('\n\n');
@@ -262,6 +365,9 @@ async function generate(kind, [pr, ...argv]) {
     mode: values.mode,
     pr,
     n,
+    ...(kind === 'wrestler' && values.block
+      ? { block: Number(values.block) }
+      : {}),
     rules: shape.rules ? rules.hash : 'none',
   };
   const file = join(briefs, `${kind}-${values.mode}-${n}.md`);

package/ring/scripts/compact-hook.mjs

@@ -16,6 +16,7 @@ import {
   RING_ROOT,
 } from './config.mjs';
 import { findBout, sessionRegistered } from './live.mjs';
+import { openHumanReturns, TAPE_HINT } from './review-blocks.mjs';
 import { checklistLines, loadRules } from './rule-ids.mjs';
 
 /** Claude Code's cap for SessionStart output, with room to spare. */
@@ -55,10 +56,25 @@ export function foulLines(decisions, max = 3000) {
 }
 
 /** The text a compacted referee gets back. PURE. */
-export function compactContext({ pr, dir, checklist, fouls, resume }) {
+export function compactContext({
+  pr,
+  dir,
+  checklist,
+  fouls,
+  resume,
+  returned = [],
+}) {
   const text = [
     `# Ring: you referee bout #${pr} (context restored after a compaction)`,
     '',
+    ...(returned.length
+      ? [
+          '## RETURNED BY THE HUMAN (rebound still open: this goes first)',
+          ...returned,
+          TAPE_HINT,
+          '',
+        ]
+      : []),
     `Reread before acting: the judges card \`${join(dir, 'judges-card.md')}\` and the ledger \`${join(dir, 'decisions.md')}\`. Every wrestler and cornerman is launched with a brief from \`node ${RING_ROOT}/scripts/brief.mjs\` and \`prompt: "ring-brief: <path>"\`; never a brief written by hand. Every finding cites its rule id (or X0).`,
     '',
     '## Architecture checklist (the full rules go in every brief)',
@@ -90,6 +106,7 @@ export function restore(input) {
     checklist: checklistLines(loadRules(config).entries).join('\n'),
     fouls: foulLines(read(join(dir, 'decisions.md'))),
     resume: resumeSection(read(join(dir, 'judges-card.md'))),
+    returned: openHumanReturns(dir),
   });
 }
 

package/ring/scripts/config.mjs

@@ -160,6 +160,13 @@ export const DEFAULTS = Object.freeze({
   // blocks of the plan (points with a reviewed range) wait on the judge, brief.mjs briefs no
   // wrestler until the human signs a verdict on that cut. null: no pause.
   humanReviewEvery: 2,
+  // Blocks that may run at once in the bout's worktree, each wrestler on the files its block
+  // declared (lanes.mjs). A second block starts only while nothing waits on the human's review and
+  // its files do not touch the running one's. 1: one at a time.
+  parallelBlocks: 2,
+  // Files the host regenerates on its own (a pre-commit that writes docs): no block holds them, and
+  // the referee regenerates them when a wave of parallel blocks closes. Globs.
+  generatedPaths: [],
   // Engram (github.com/Gentleman-Programming/engram), the memory of what earlier bouts learned:
   // fouls, the judge's verdicts, accepted precedents, X0 findings and each bout's status. Never the
   // rules. The scripts sync and read it when something answers at this URL (null: off). The

package/ring/scripts/findings.mjs

@@ -553,7 +553,7 @@ function settleAlone(pr, argv, kind) {
   for (const finding of settled)
     appendFileSync(
       join(dir, 'decisions.md'),
-      `- ${at} · ${values.id ?? finding.id} · ${judge ? 'judge' : 'referee'} · cornerman finding ${finding.id} ${verb}: ${reason}${judge ? ` (the human: ${judge})` : ''} · «${finding.text}»\n`,
+      `- ${at} · ${finding.id} · ${judge ? 'judge' : 'referee'} · cornerman finding ${finding.id} ${verb}${values.id ? ` per ${values.id}` : ''}: ${reason}${judge ? ` (the human: ${judge})` : ''} · «${finding.text}»\n`,
     );
   const cardPath = join(dir, 'judges-card.md');
   if (existsSync(cardPath)) {
@@ -643,6 +643,20 @@ const COMMANDS = {
   audit,
 };
 
+/** Each subcommand's usage, printed with its error. */
+const USAGE = {
+  add: 'add <pr> --source range|concept|batch|preferences --range <A>..<B> --file <report> [--up-to <sha>] [--rule <id>]',
+  clean: 'clean <pr> --range <from>..<to>',
+  applied: 'applied <pr> F<n>[,…] --sha <commit>',
+  discard:
+    'discard <pr> F<n>[,…] --id D<k> --reason "<why>" [--judge "<what the human said>"]',
+  ticket:
+    'ticket <pr> F<n>[,…] --ticket <id|"to file"> --reason "<why>" [--judge "<what the human said>"]',
+  escalate: 'escalate <pr> F<n>[,…] --reason "<why>"',
+  shown: 'shown <pr> F<n>[,…] --in "<where the human saw it>"',
+  audit: 'audit <pr> [--full]',
+};
+
 if (isMain(import.meta.url)) {
   const [command, ...rest] = process.argv.slice(2);
   const run = COMMANDS[command];
@@ -658,6 +672,8 @@ if (isMain(import.meta.url)) {
     if (command !== 'audit') await syncAfter(rest[0]);
   } catch (error) {
     console.error(`findings: ${error.message}`);
+    if (USAGE[command])
+      console.error(`usage: node findings.mjs ${USAGE[command]}`);
     process.exit(1);
   }
 }

package/ring/scripts/judges-card.mjs

@@ -59,6 +59,7 @@ import {
   withConceptClosed,
   withProposalDecision,
   wrestlerIds,
+  wrestlerLines,
 } from './relay.mjs';
 import { resumeSection } from './compact-hook.mjs';
 import { boutFormatGate } from './format-gate.mjs';
@@ -115,7 +116,13 @@ import {
 } from './preparation.mjs';
 import { handOffWarning, withChronicleUrl } from './sparring-chronicle.mjs';
 import { refereeRecall, syncAfter } from './engram.mjs';
-import { estimateFacts, reviewTurn } from './review-blocks.mjs';
+import { parseGlobs, wrestlerBlocks } from './lanes.mjs';
+import {
+  estimateFacts,
+  openHumanReturns,
+  reviewTurn,
+  TAPE_HINT,
+} from './review-blocks.mjs';
 import { parsePlan, PLAN, planItem } from './tech-plan.mjs';
 import { addPlanItem, setPlanState } from './tech-plan-log.mjs';
 import { logPageVerdicts } from './verdicts-log.mjs';
@@ -314,13 +321,24 @@ async function summary([pr]) {
     contract: false,
     venue: state.venue ?? DEFAULT_VENUE,
   });
-  const review = reviewTurn(dir, config.humanReviewEvery, (n, to, ref) =>
-    setPlanState(dir, n, to, ref),
+  const review = reviewTurn(
+    dir,
+    config.humanReviewEvery,
+    (n, to, ref) => setPlanState(dir, n, to, ref),
+    config.parallelBlocks ?? 1,
   );
+  const returned = openHumanReturns(dir);
   console.log(
     [
       '',
       '## Human review by blocks (PR Review Lab, bout mode)',
+      ...(returned.length
+        ? [
+            `RETURNED BY THE HUMAN, rebound still open (${returned.length}):`,
+            ...returned,
+            TAPE_HINT,
+          ]
+        : []),
       review.applied.length
         ? `verdicts applied now: ${review.applied.join(' · ')}`
         : 'no new verdicts',
@@ -330,6 +348,23 @@ async function summary([pr]) {
       review.due ?? '',
     ].join('\n'),
   );
+  const points = existsSync(join(dir, PLAN))
+    ? parsePlan(readFileSync(join(dir, PLAN), 'utf8')).groups.flatMap(
+        (group) => group.items,
+      )
+    : [];
+  if (
+    points.length &&
+    points.every((item) => item.state === 'hecho') &&
+    titleDefenseRefusal(readState(dir), null)
+  )
+    console.log(
+      [
+        '',
+        '## Next in the bout’s life (the plan is complete)',
+        'The judge tests it in the sandbox → the human marks the PR ready → /ring:title-defense → judges-card.mjs close. Do not close before the defense unless the judge waives it (--without-title-defense "<what they said>").',
+      ].join('\n'),
+    );
   const learned = await refereeRecall(config, {
     slug: repoSlug(projectDir()),
     pr,
@@ -601,6 +636,7 @@ function plan([pr, target, ...rest]) {
       estimate: estimateFacts({
         priority: value('--priority'),
         minutes: value('--minutes'),
+        files: parseGlobs(value('--files')),
       }),
     });
     return void console.log(
@@ -616,17 +652,24 @@ function plan([pr, target, ...rest]) {
     contract: false,
     venue: readState(dir).venue ?? DEFAULT_VENUE,
   });
-  const inline = [value('--minutes'), value('--priority')].some(
-    (given) => given != null,
-  );
+  const inline = [
+    value('--minutes'),
+    value('--priority'),
+    value('--files'),
+  ].some((given) => given != null);
   const changed = setPlanState(dir, target, state, value('--ref'), undefined, {
     range: value('--range'),
     estimate: inline
       ? estimateFacts({
           priority: value('--priority'),
           minutes: value('--minutes'),
+          files: parseGlobs(value('--files')),
         })
       : null,
+    lanes: {
+      parallel: config.parallelBlocks,
+      generated: config.generatedPaths,
+    },
     // Under the human review by blocks a block starts with its estimate and priority.
     requireEstimate: Boolean(config.humanReviewEvery),
   });
@@ -635,7 +678,8 @@ function plan([pr, target, ...rest]) {
   );
 }
 
-function log([pr, kind, ...words]) {
+function log([pr, kind, ...rest]) {
+  let words = rest;
   if (
     ['escalation', 'escalation-context', 'answer'].includes(kind) &&
     words.length
@@ -649,6 +693,26 @@ function log([pr, kind, ...words]) {
   const stamp = new Date().toISOString();
   const box = kind === 'rebound' ? '[ ] ' : '';
   const dir = currentDir(pr);
+  if (kind === 'decision') {
+    const path = join(dir, 'decisions.md');
+    const taken = new Set(
+      [
+        ...(existsSync(path) ? readFileSync(path, 'utf8') : '').matchAll(
+          / · (D\d+) · /g,
+        ),
+      ].map((m) => m[1]),
+    );
+    const fixed = withFreeDecisionId(
+      words.join(' '),
+      taken,
+      nextDecisionId(dir),
+    );
+    if (fixed.renumbered)
+      console.error(
+        `${fixed.renumbered[0]} is taken in decisions.md: logged as ${fixed.renumbered[1]}`,
+      );
+    words = [fixed.text];
+  }
   appendFileSync(
     join(dir, files[kind]),
     `- ${box}${stamp} · ${words.join(' ')}\n`,
@@ -694,8 +758,20 @@ function list() {
   console.log(rows.join('\n') || 'no bouts for this repo');
 }
 
-function close([pr]) {
+/**
+ * Why a bout may not close for its title defense yet, or null: the bout ends after the human's tests
+ * in the sandbox, the PR marked ready and title-defense against Copilot, unless the judge waives it
+ * (`--without-title-defense "<what the human said>"`, which goes to decisions.md). PURE.
+ */
+export function titleDefenseRefusal(state, waiver) {
+  if (state.titleDefense || state.titleDefenseStarted || waiver?.trim())
+    return null;
+  return 'it never defended its title. The bout ends with: plan complete → the judge tests it in the sandbox → the human marks the PR ready → /ring:title-defense → close. If the judge does not want the defense, close with --without-title-defense "<what the human said>"';
+}
+
+function close([pr, ...argv]) {
   const dir = currentDir(pr);
+  const waiver = options(argv)['without-title-defense'];
   const blocked = auditBlocks(readLedger(dir), { closing: true });
   if (blocked) throw new Error(`bout #${pr} does not close yet: ${blocked}`);
   const proposals = undecidedProposals(
@@ -710,10 +786,56 @@ function close([pr]) {
     if (format.refusal)
       throw new Error(`bout #${pr} does not close yet: ${format.refusal}`);
   }
+  const defense = titleDefenseRefusal(state, waiver);
+  if (defense) throw new Error(`bout #${pr} does not close yet: ${defense}`);
+  if (waiver?.trim())
+    appendFileSync(
+      join(dir, 'decisions.md'),
+      `- ${new Date().toISOString()} · ${nextDecisionId(dir)} · judge · closed without title-defense: ${waiver.trim()}\n`,
+    );
   writeState(dir, { ...state, active: false });
   console.log(`bout #${pr} closed; its files stay in ${dir} as the record.`);
 }
 
+/** The next free D<n> of the bout's decisions.md. */
+function nextDecisionId(dir) {
+  const path = join(dir, 'decisions.md');
+  const ids = existsSync(path)
+    ? [...readFileSync(path, 'utf8').matchAll(/ · D(\d+) · /g)].map((m) =>
+        Number(m[1]),
+      )
+    : [];
+  return `D${Math.max(0, ...ids) + 1}`;
+}
+
+/**
+ * The decision line as the referee wrote it, with its D<n> made unique: a D<n> already taken in
+ * the ledger (a judge's verdict wrote it meanwhile) becomes the next free one. PURE.
+ */
+export function withFreeDecisionId(text, taken, next) {
+  const id = /^(D\d+)(\s*·)/.exec(text)?.[1];
+  if (!id || !taken.has(id)) return { text, renumbered: null };
+  return { text: text.replace(id, next), renumbered: [id, next] };
+}
+
+/** A closed bout back to work, with the judge's reason in decisions.md. */
+function reopen([pr, ...argv]) {
+  const { why } = options(argv);
+  if (!why?.trim())
+    throw new Error('usage: reopen <pr> --why "<what the human said>"');
+  const dir = currentDir(pr);
+  const state = readState(dir);
+  if (state.active) throw new Error(`bout #${pr} is already active`);
+  appendFileSync(
+    join(dir, 'decisions.md'),
+    `- ${new Date().toISOString()} · ${nextDecisionId(dir)} · judge · bout reopened: ${why.trim()}\n`,
+  );
+  writeState(dir, { ...state, active: true });
+  console.log(
+    `bout #${pr} reopened; resume it with /ring:referee resume ${pr}.`,
+  );
+}
+
 /**
  * The title-defense flag in a bout state, set or cleared. `setAt` starts its count: mask-guard
  * allows at most `untilRound` Copilot review requests after it. PURE.
@@ -727,7 +849,12 @@ export function withTitleDefense(
   if (untilRound === null) return rest;
   if (!Number.isInteger(untilRound) || untilRound < 1)
     throw new Error('--until-round must be a positive integer');
-  return { ...rest, titleDefense: { pr: state.pr, untilRound, setAt } };
+  // titleDefenseStarted outlives the flag: close asks whether the PR ever defended its title.
+  return {
+    ...rest,
+    titleDefense: { pr: state.pr, untilRound, setAt },
+    titleDefenseStarted: rest.titleDefenseStarted ?? setAt,
+  };
 }
 
 /**
@@ -749,6 +876,7 @@ export function readyForTitleDefense(pr, view) {
   if (answer?.isDraft === true)
     return {
       ok: false,
+      draft: true,
       reason: `PR #${pr} is still a draft; title-defense starts when you mark it ready for review`,
     };
   return { ok: false, reason: `gh did not say whether PR #${pr} is a draft` };
@@ -865,7 +993,9 @@ function titleDefense([pr, ...argv]) {
   const clear = argv.includes('--clear');
   const index = argv.indexOf('--until-round');
   if (!pr || (!clear && index === -1))
-    throw new Error('usage: title-defense <pr> --until-round <k> | --clear');
+    throw new Error(
+      'usage: title-defense <pr> --until-round <k> [--keep-draft] | --clear',
+    );
   const dir = currentDir(pr);
   const state = readState(dir);
   if (state.active !== true)
@@ -881,7 +1011,25 @@ function titleDefense([pr, ...argv]) {
           stdio: ['ignore', 'pipe', 'pipe'],
         }),
       );
-  if (!gate.ok) throw new Error(gate.reason);
+  // Invoking title-defense is the judge's yes to take the PR out of draft (--keep-draft: not yet).
+  // The script runs gh itself, so mask-guard still refuses `gh pr ready` anywhere else.
+  if (!gate.ok && gate.draft && !argv.includes('--keep-draft')) {
+    execFileSync('gh', ['pr', 'ready', String(pr)], {
+      cwd: state.worktree,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    appendFileSync(
+      join(dir, 'decisions.md'),
+      `- ${new Date().toISOString()} · ${nextDecisionId(dir)} · judge · the judge invoked title-defense: PR #${pr} is out of draft\n`,
+    );
+    console.log(
+      `PR #${pr} marked ready for review (the judge invoked title-defense)`,
+    );
+  } else if (!gate.ok)
+    throw new Error(
+      gate.draft ? `${gate.reason} (--keep-draft was passed)` : gate.reason,
+    );
   const next = withTitleDefense(state, clear ? null : Number(argv[index + 1]));
   writeState(dir, next);
   console.log(
@@ -958,14 +1106,19 @@ function playByPlayUrl([pr, url]) {
  * concept goes to a fresh wrestler; every `relayEvery` concepts the referee relays first.
  */
 function concept([pr, name, ...argv]) {
-  const { range } = options(argv);
+  const { range, block } = options(argv);
   const dir = currentDir(pr);
   const state = readState(dir);
   const next = withConceptClosed(state, {
     name,
     range,
     at: new Date().toISOString(),
-    wrestlers: wrestlerIds(liveLines(dir)),
+    // With --block only that block's wrestlers retire: another block may still be running.
+    wrestlers: block
+      ? [...wrestlerBlocks(dir)]
+          .filter(([, n]) => n === Number(block))
+          .map(([agent]) => agent)
+      : wrestlerIds(wrestlerLines(dir)),
   });
   writeState(dir, next);
   const { config } = loadConfig(projectDir(), {
@@ -1043,6 +1196,7 @@ function proposal([pr, n, verdict, ...argv]) {
 
 const COMMANDS = {
   open,
+  reopen,
   concept,
   relay,
   proposal,
@@ -1065,7 +1219,7 @@ if (isMain(import.meta.url)) {
   const run = COMMANDS[command];
   if (!run) {
     console.error(
-      'Usage: node judges-card.mjs open|summary|log|did|list|path|close|concept|relay|proposal|approve-contract|title-defense|play-by-play-url|page-answers|page-verdicts|plan …',
+      'Usage: node judges-card.mjs open|reopen|summary|log|did|list|path|close|concept|relay|proposal|approve-contract|title-defense|play-by-play-url|page-answers|page-verdicts|plan …',
     );
     process.exit(1);
   }