@thebattlearena/corner 0.10.0 → 0.10.1-beta.79

package/ring/scripts/rule-ids.mjs

@@ -0,0 +1,124 @@
+// The rules a bout runs on, read from its rulebooks and precedent files: the ids that exist (so a
+// finding cites a real one) and the one-line checklist every brief opens with. Zero-dependency.
+import { existsSync, readFileSync } from 'node:fs';
+
+/**
+ * `**R11. SRP, SOLID…**` → { id: 'R11', title }. The heading of every rule and precedent; a long
+ * heading wraps onto the next lines, so the bold runs across them until its closing `**`.
+ */
+const ENTRY = /^\*\*([A-Z]{1,2}\d+)\.\s+([\s\S]+?)\*\*/gm;
+
+/**
+ * What the human's reviews keep finding and line-by-line reviews let through (bout #1223 and the
+ * review Tapes of 11 nov 2026: optionals and ternaries dragged downstream, defensive code, code
+ * coupled to each channel, repositories off the host's standard, hand-written types, raw provider
+ * responses): every brief opens with these in one line each, before the full text. Ids a venue
+ * does not define are skipped.
+ */
+export const ARCHITECTURE_CHECKLIST = [
+  'R3',
+  'R6',
+  'R8',
+  'R11',
+  'R12',
+  'R15',
+  'R16',
+  'R17',
+  'R18',
+  'R19',
+  'R20',
+  'R21',
+  'R22',
+  'R23',
+  'R24',
+  'R25',
+  'R26',
+  'R27',
+  'U6',
+  'U7',
+  'P14',
+  'P16',
+];
+
+/** The id that marks a finding no rule covers; it becomes a proposal for the rulebook. */
+export const NO_RULE = 'X0';
+
+/** Every rule or precedent heading of a Markdown file. PURE. */
+export function ruleEntries(markdown) {
+  return [...String(markdown ?? '').matchAll(ENTRY)].map(([, id, title]) => ({
+    id,
+    title: title.replace(/\s+/g, ' ').replace(/\.$/, ''),
+  }));
+}
+
+/**
+ * The rule files of a venue, in the order a brief embeds them: the rulebook, the venue's
+ * rulebooks, the bundled precedents, the venue's precedents and the host's (HPn, which win).
+ */
+export function ruleFiles(config) {
+  return [
+    config.rulebookPath,
+    ...(config.venueRulebookPaths ?? []),
+    config.bundledPrecedentsPath,
+    ...(config.venuePrecedentsPaths ?? []),
+    config.precedentsPath,
+  ].filter((path) => path && existsSync(path));
+}
+
+/** The rule files with their text and the ids they define. */
+export function loadRules(config) {
+  const sources = ruleFiles(config).map((path) => ({
+    path,
+    text: readFileSync(path, 'utf8'),
+  }));
+  const entries = sources.flatMap((source) => ruleEntries(source.text));
+  return { sources, entries, ids: new Set(entries.map((entry) => entry.id)) };
+}
+
+/** The checklist as Markdown lines, from whichever of its ids the rules define. PURE. */
+export function checklistLines(entries, ids = ARCHITECTURE_CHECKLIST) {
+  const byId = new Map(entries.map((entry) => [entry.id, entry.title]));
+  return ids
+    .filter((id) => byId.has(id))
+    .map((id) => `- **${id}** ${byId.get(id)}`);
+}
+
+const ID = /\b[A-Z]{1,2}\d+\b/g;
+const FORMAT_LINE = /(?:^|\s—\s)format\s—\s|NO VERIFICADO/;
+
+/**
+ * The rule ids a finding line cites in its rule field: the second field of
+ * `<file:line> — <rule id> — <what> — <how>`, or of a table row `| file | rule | … |`. The field
+ * may carry a severity or a note around the ids (`BLOCKER (P16/PR11)`, `X0 (security)`); only the
+ * ids count. Null when the field names none. PURE.
+ */
+export function citedRules(line) {
+  const text = String(line).trim();
+  const fields = text.startsWith('|')
+    ? text
+        .split('|')
+        .map((field) => field.trim())
+        .filter(Boolean)
+    : text.split(/\s+—\s+/);
+  const field = (fields[1] ?? '').replace(/`/g, '').trim();
+  const ids = field.match(ID);
+  return ids ? [...new Set(ids)] : null;
+}
+
+/**
+ * The finding lines that do not cite a real rule, with why: no rule field, or ids no loaded rule
+ * defines. A format line and `X0` (no rule covers it) are valid. PURE.
+ */
+export function uncitedFindings(lines, ids) {
+  return lines
+    .map((line) => ({ line, cited: citedRules(line) }))
+    .filter(({ line }) => !FORMAT_LINE.test(line))
+    .map(({ line, cited }) => {
+      if (!cited) return { line, reason: 'no rule id in its second field' };
+      const unknown = cited.filter((id) => id !== NO_RULE && !ids.has(id));
+      return unknown.length
+        ? { line, reason: `no rule ${unknown.join(', ')} in this venue` }
+        : null;
+    })
+    .filter(Boolean);
+}

package/ring/skills/no-surrender/SKILL.md

@@ -43,6 +43,11 @@ theirs may be decided by you. It runs on top of an active bout: without one, say
 - **Keep the cycle**: every range reviewed by a cornerman at effort high, filtered against the
   base, one rebound package, round-bells opened as concepts close (they wait for the human; that
   is fine).
+- **A fresh wrestler per concept, and a relay every few**: a long night is where a wrestler's and a
+  referee's context grow stale. Close each approved concept with `judges-card.mjs concept`, brief
+  the next one to a new wrestler (`--mode resume`), and when `brief.mjs` says a relay is due,
+  rewrite the card's «How to resume» and run `judges-card.mjs relay` before going on. When the
+  session compacts, the SessionStart hook puts that section back: it is all you keep.
 - **Red gates are classified**, not silenced: code (rebound to the wrestler), environment (note it
   and retry once), harness (note it). A coverage gap is fixed with real tests, never with a test
   that only imports a file (T8). A flag decision and a PR over the host's size ceiling (how to

package/ring/skills/referee/SKILL.md

@@ -1,13 +1,14 @@
 ---
 name: referee
-description: Orchestrates a refactor or a large delivery on a backend, frontend or mobile PR as its referee, at the venue the PR belongs to. One long-lived wrestler (effort medium) writes in its own worktree; you (effort high) review each commit range with read-only cornermen against a numbered rulebook, send one rebound package at a time, open small do-not-merge round-bell PRs so the human reviews early, decide design doubts yourself from the rulebook and precedents (escalating only a short hard list), and keep a durable judges card so any new session can resume. Invoke with `/ring:referee start <pr>`, `/ring:referee resume [<pr>]`, `/ring:referee close`, "referee the refactor of #N", "resume the bout".
+description: Orchestrates a refactor or a large delivery on a backend, frontend or mobile PR as its referee, at the venue the PR belongs to. One wrestler (Sonnet, effort high by default) writes in its own worktree; you (effort high) review each commit range with read-only cornermen against a numbered rulebook, every brief generated by `brief.mjs` with the rules embedded, send one rebound package at a time, open small do-not-merge round-bell PRs so the human reviews early, decide design doubts yourself from the rulebook and precedents (escalating only a short hard list), and keep a durable judges card so any new session can resume. Invoke with `/ring:referee start <pr>`, `/ring:referee resume [<pr>]`, `/ring:referee close`, "referee the refactor of #N", "resume the bout".
 argument-hint: "start <pr> | start --from-sparring <slug> | resume [<pr>] | close"
 ---
 
 # referee
 
-You do not write production code. You write briefs, rebounds, round-bell bodies, escalations and
-the judges card. You are the only one who talks to the human. Under the default delegation you
+You do not write production code. You write rebounds, round-bell bodies, escalations and the
+judges card; the briefs of the wrestler and the cornermen are generated by `brief.mjs` from the
+templates, with the rules embedded in full, and you only give them your values. You are the only one who talks to the human. Under the default delegation you
 also decide every design doubt yourself, write down why, and keep the bout moving: only the hard
 list reaches the human.
 
@@ -41,7 +42,8 @@ list reaches the human.
 5. **State lives in `~/.claude/ring/<owner>/<repo>/<pr>/`** (`node "$RING/scripts/judges-card.mjs"
 path <pr>`; owner and repo lowercased, `local/<name>` for a repo without an origin remote;
    `RING_HOME` overrides the root), never in the session scratchpad: the scratchpad is wiped when
-   the session restarts. A bout in the old flat layout (`<owner>-<repo>/<pr>/`) is moved there the
+   the session restarts. Neither criteria nor notes live there either: what the human asks for
+   goes to `decisions.md` or the technical plan, and `brief.mjs` refuses a scratchpad path. A bout in the old flat layout (`<owner>-<repo>/<pr>/`) is moved there the
    first time a script resolves it; if both exist, the new one wins and the old one is reported on
    stderr, untouched.
 6. **The base is a remote ref.** In every git command and every brief, `<base>` means
@@ -50,9 +52,22 @@ path <pr>`; owner and repo lowercased, `local/<name>` for a repo without an orig
    thousands of files that are not the PR's. What the scripts store stays the branch name:
    `judges-card.mjs open --base <stack base>` (never `origin/…`), since round-bell adds `origin/`
    itself.
-7. **Effort on every Agent call.** Wrestler: `effort: "medium"`. Cornermen: `effort: "high"`.
-   Always explicit, even though the agent frontmatter sets it: never let a subagent inherit the
-   session's effort.
+7. **Every brief from `brief.mjs`, with its model and effort.** Before every Agent call to a
+   wrestler or a cornerman, write only your values to a JSON under `<bout dir>/tools/` and run
+   `node "$RING/scripts/brief.mjs" wrestler|cornerman <pr> --mode <mode> --vars <file>`: it fills
+   the template with the bout's state, the venue's gates and lenses, the commits of the range, the
+   decisions (every foul, the ones on those files, the last 20) and **the rules in full**, seals
+   it, logs it in `<bout dir>/briefs/index.jsonl`, and prints the file and the Agent call with the
+   role's model and effort (`config.agents`: the wrestler and the rudo on `sonnet` at `high`, the
+   cornerman on `opus` at `high`, unless the host's `.claude/ring.json` says otherwise). Launch
+   with `prompt: "ring-brief: <the file>"`, with that `model` and `effort` (PR16): the
+   `brief-guard` hook checks the seal (generated, untouched, on today's rules, of this bout and
+   role), puts the file's text in the prompt and sets the role's model and effort. A brief that
+   does not hold is reported to you (`briefGuard: "warn"`, the default) or refused (`"block"`).
+   Never write a brief by hand: a brief written from memory is what lost the rules in bout #1223.
+   `brief.mjs verify <file>` says whether a brief still holds (untouched, rules unchanged). After a
+   compaction, a SessionStart hook puts back the bout, its checklist, its fouls and the card's
+   «how to resume»: reread the card before acting.
 8. **Who decides** (`config.delegation`, rulebook "Who decides"):
    - **`referee`** (default): you decide design, pattern, layer, naming, style, scope inside the
      assignment, test strategy, and which option to take when a measurement shows a risk. Under
@@ -161,8 +176,10 @@ way out, and it refuses without a KO. Then the bout runs as always, with three i
    cornermen in **batch** mode in parallel, ≤20 files each (`templates/cornerman-batch.md`),
    `effort: "high"`. Decide their open questions yourself under `referee` (recorded as in §0.8);
    bring the human only the hard-list ones, or all of them under `human`.
-8. **Launch one wrestler**: `Agent{subagent_type: "ring:wrestler", effort: "medium",
-run_in_background: true, prompt: <templates/wrestler-brief.md filled>}`. The first concept is a
+8. **Launch one wrestler**: `brief.mjs wrestler <pr> --mode start --vars <file>` (your values:
+   `assignment`, `flowChange`, `concepts`, `frozen`, `waitingOnHuman`, and `comments` and
+   `referencePattern` when there are), then `Agent{subagent_type: "ring:wrestler", model, effort
+   (as printed), run_in_background: true, prompt: "ring-brief: <the file>"}`. The first concept is a
    **pilot**: one small concept as a sample for the human. Note the agent id in the judges card
    ("What I did"). If the harness exposes how the subagent ran, check it ran at medium.
    Give every Agent call a short `description` (its first three words label its chip in Ringside);
@@ -178,9 +195,21 @@ run_in_background: true, prompt: <templates/wrestler-brief.md filled>}`. The fir
    never in bulk**: a range is 2–3 commits or ~200 lines (`reviewEvery` in the host config, 3
    commits / 200 lines by default). `mask-guard` holds the wrestler's next commit once the
    unreviewed range reaches that cap, until you mark it (step 4).
-   - each new range: `templates/cornerman-range.md` (≤15 lines);
-   - when the wrestler closes a concept: `templates/cornerman-concept.md` (numbered behavior
-     invariants, tests on a `git archive` copy), over ranges already reviewed one by one.
+   - each new range: `brief.mjs cornerman <pr> --mode range --vars <file>` (≤15 lines; the range
+     is `lastReviewed..HEAD` unless you pass `--range`; your value: `claims`);
+   - when the wrestler closes a concept: `--mode concept` (your values: `invariants`, numbered,
+     and `claims`; `designReference` at a UI venue), over ranges already reviewed one by one. It
+     also reads the concept as one piece through the venue's lenses: what no single range shows;
+   - a design review: `--mode batch --files <f1,f2,…>`.
+   **A concept ends its wrestler.** When the concept review approves it, run
+   `judges-card.mjs concept <pr> "<concept>" --range <first>..<last>`: it records the concept and
+   retires the wrestlers that carried it (a long-lived wrestler drags the earlier concepts'
+   context and repeats their mistakes). The next concept goes to a fresh wrestler:
+   `brief.mjs wrestler <pr> --mode resume --vars <file>` with `nextConcept`; brief-guard warns
+   (or, under `briefGuard: "block"`, refuses) a SendMessage to a retired one. Every `relayEvery`
+   concepts (4 by default) you relay first: rewrite the card's «How to resume» (where the bout is,
+   what is next, what waits on the human) and run `judges-card.mjs relay <pr>`; until then
+   `brief.mjs` briefs no wrestler. That is what a compaction or a new session resumes from.
    If the wrestler claimed something ("does not change counter X"), hand the claim to the
    cornerman to verify against the base. The cornerman always checks the format of the range
    (`format-gate.mjs check`); an unclean file is a finding like any other, fixed by the wrestler
@@ -205,6 +234,16 @@ run_in_background: true, prompt: <templates/wrestler-brief.md filled>}`. The fir
    before anything else: `node "$RING/scripts/findings.mjs" add <pr> --source range --range
 <from>..<to> --file <report>` (one finding per line; `--source batch` without a range for a
    design review), or `findings.mjs clean <pr> --range <from>..<to>` when it found nothing.
+   **Every finding cites a rule**: `add` refuses a line whose second field is not a rule id of the
+   venue (`<file:line> — R11 — …`). Rebound the report to the cornerman ("cite the rule"), or take
+   the line as yours with `--rule <id>`, logged with you as its author. A finding no rule covers
+   carries `X0`: it lands by itself in "For the rulebook / precedents" of the judges card, since a
+   gap the rulebook does not name is a rule it lacks.
+   **The human's own reviews are findings too.** When the human reviews code on video (a Tape of
+   the Battle Arena QA sessions, `qa_session_overview <link>`) or in a message, each pending item
+   becomes a finding with `--source human`, the rule it falls under, `X0` when none does, and the
+   link in its text: it runs through the same states as a cornerman's, and the rule it breaks
+   goes on the architecture checklist of the next briefs.
    `lookout.mjs mark` refuses a range whose findings are not registered. Check every BLOCKER:
    `git -C <wt> show <base>:<path>`. An assertion in a test created in this branch is not a base
    assertion (T1). Never forward a report you have not read. Every finding ends in exactly one
@@ -304,7 +343,7 @@ sha>`. When the cornerman **approved** it: `node "$RING/scripts/lookout.mjs" app
 9. **A concept that needs a new or changed endpoint, database model or native surface** goes
    contract first (§2b) before any implementation.
 
-If the wrestler is cut off (API error, limit), send it the cut-off variant of the brief. If the
+If the wrestler is cut off (API error, limit), send it `brief.mjs wrestler <pr> --mode cutoff`. If the
 whole session restarted, see §5.
 
 ## 2b · Contract first: the API and the database models are the judge's
@@ -474,8 +513,10 @@ and runs the fixes through this same cycle (§2).
    who, when), validation (SHA, command, result), what is not verified yet. Show it to the human;
    apply it with `gh pr edit <pr> --body-file …` only when they say so, then check it with
    `gh pr view <pr> --json title,body`.
-8. **Precedents**: show the human the proposals in "For the rulebook / precedents". For the ones
-   they accept, offer a small separate PR that appends them to the host precedents file
+8. **Precedents**: show the human the proposals in "For the rulebook / precedents" (the `X0`
+   findings land there too) and record each answer with
+   `judges-card.mjs proposal <pr> <n> accept|reject --why "<what they said>"`: `judges-card.mjs
+   close` refuses while one has no decision. For the ones they accept, offer a small separate PR that appends them to the host precedents file
    (`config.precedentsPath`, or a new `.claude/ring-precedents.md`) with the next HPn ids. Never
    commit that file on your own.
 9. **List, never close**: `node "$RING/scripts/round-bell.mjs" list <pr>`, `git worktree list`
@@ -492,11 +533,14 @@ and runs the fixes through this same cycle (§2).
 
 1. Without `<pr>`: `node "$RING/scripts/judges-card.mjs" list`; take the only active bout or ask.
 2. `node "$RING/scripts/judges-card.mjs" summary <pr>`: state (with the bout's venue),
-   unreviewed commits, open rebounds, decisions and the judges card. Read the rulebook and both precedent files in full again (§0.4).
+   unreviewed commits, open rebounds, decisions and the judges card, and, when Engram answers,
+   the repo's latest fouls, verdicts and precedents from earlier bouts (do not repeat those fouls;
+   they are context, never rules). Read the rulebook and both precedent files in full again (§0.4).
 3. Review the unreviewed commits first (§2.1–2.4).
 4. A new session cannot talk to the old wrestler: its agent id does not survive. Relaunch it
-   **without `isolation`**, on the existing worktree, with the resume variant of
-   `templates/wrestler-brief.md` and `effort: "medium"`.
+   **without `isolation`**, on the existing worktree, with
+   `brief.mjs wrestler <pr> --mode resume --vars <file>` (add `nextConcept` to your values) and
+   the model and effort it prints.
 5. Restart the lookout (§3) and carry on with the cycle.
 
 For unattended work (the human goes to sleep), use `/ring:no-surrender` on top of an active bout.

package/ring/skills/referee/references/rulebook.md

@@ -106,7 +106,35 @@ https://refactoring.guru/design-patterns), citing the measured `file:line`. A pa
 when it is simpler than the conditional it removes; a discarded pattern is written down with its
 reason so it is not proposed again. Example: five chained `if`s assigning a number, with the
 exclusivity rule repeated in three files, become one `AssignmentRule` per rule, reused by the
-backfill.
+backfill. The same for code that names each channel, provider or flavor it serves (`if chat … if
+voice … if whatsapp`): the core does not know which ones exist; each one is a strategy it delegates
+to, and effects between them travel as events (publish and subscribe).
+
+**R23. A ternary that fills a gap means the gap should not exist.** `x ? x : []`, `x ?? []` repeated
+downstream or a `map` guarded against `undefined` say the value was born optional when it has a
+default: the default lives where the value is born (an empty list, not an optional list), and the
+code downstream stops asking. Every ternary that stays names its two business cases; one that
+cannot is replaced by a named function or a strategy (R22).
+
+**R24. Types come from their source.** A shape the SDK, the API spec or a validation schema already
+defines is imported or derived from it (generated types, the schema's inferred type, the SDK's own
+enums), never rewritten by hand, so it follows the source when the source changes. Closed sets of
+strings (statuses, operations, channels) are those constants or value objects (R6), never loose
+literals compared in an `if`.
+
+**R25. What a provider returns crosses an anti-corruption layer.** A provider's response is
+validated and transformed at the edge, by a schema, into our own model; neither the domain nor the
+client ever receives the raw response. An optional field of the provider is optional only with the
+evidence of when it does not arrive (the provider's docs, a captured response), never by
+assumption.
+
+**R26. Business metrics are not monitoring.** Product analytics records business events, each one
+naming the business question it answers; errors go to the monitoring tool (error tracking,
+alarms, F4). A failed operation is not a business event, and an error is never tracked as one.
+
+**R27. A cross-cutting precondition is checked once, where it is born.** The selected workspace,
+the session, the tenant: validated at one global point (a guard, a provider, a resolver), not in
+every component, hook or handler that uses it (R8).
 
 ## T · Tests as a contract
 
@@ -221,8 +249,10 @@ decides it and records why, or, for the hard list or under `delegation: "human"`
 human with two options, their cost and a recommendation. Meanwhile the author does not touch that
 part and works on something else.
 
-**P10. Effort by role**: whoever writes runs at medium; whoever orchestrates, reviews or gives
-feedback runs at high. Set it explicitly on every launch; never let it be inherited.
+**P10. Model and effort by role**: whoever writes runs on the cheaper model at high effort (the
+wrestler and the rudo on Sonnet); whoever orchestrates, reviews or gives feedback runs on the
+strongest model at high effort. The host can change either per role (`agents` in
+`.claude/ring.json`). Set both explicitly on every launch; never let them be inherited.
 
 **P11. When the host forbids them (`forbidAiTrailers`, the default), commits carry no AI
 attribution trailers**; human co-authors are always fine. Stage by explicit paths.

package/ring/skills/referee/templates/cornerman-batch.md

@@ -1,15 +1,21 @@
-<!-- Agent{subagent_type: "ring:cornerman", effort: "high"}, several in parallel, before code is
-     touched or when the human asks for a design pass. At most 20 files each. -->
-
-Mode: **batch**. Read only. Worktree `<absolute path>` at its live HEAD; the tree may change while
-you read: cite the lines of the moment. Rulebook `<absolute rulebook path>`.
+Mode: **batch**. Read only. Worktree `{{worktree}}` at its live HEAD; the tree may change while
+you read: cite the lines of the moment. The decisions taken are near the end of this brief and the
+rules after them, at its end (the architecture checklist first). Ring scripts `{{ring}}/scripts`
+(the format gate is `format-gate.mjs` there).
 
 Files (≤20):
-- <path>
+{{files}}
+
+Review in two passes and report both together.
 
-Each file through the lenses of the bout's venue (`config.lenses` from
-`config.mjs show --venue <venue>`): <lenses, one per line>.
+1. **Sweep.** Read each file whole, then go through it lens by lens, every lens of this venue:
+   {{lenses}}. Report everything wrong you find, production risk and behavior as much as design.
+   There is no cap on findings, and a problem no rule fits is still a finding.
+2. **Checklist.** Go over the architecture checklist at the end of this brief against each file
+   and add what the sweep missed.
 
-Return per file the findings with rule ids, one finding per line (the referee registers each line
-with `findings.mjs add --source batch --file`). Then the **open design questions**, numbered, each
-with two options, their cost and your recommendation.
+Return per file the findings, one per line, as `<file:line> — <rule id> — <what is wrong> — <how
+it must be>`. The rule id is one from the rules at the end of this brief, or `X0` when none covers
+it: never drop a finding because no rule fits (the referee registers each line with
+`findings.mjs add --source batch --file`, which refuses a line without a valid id). Then the
+**open design questions**, numbered, each with two options, their cost and your recommendation.

package/ring/skills/referee/templates/cornerman-concept.md

@@ -1,44 +1,42 @@
-<!-- Agent{subagent_type: "ring:cornerman", effort: "high"}. When a concept closes. -->
-
 Mode: **concept**. You are the high-effort reviewer. Read only: no edits, no commits, no index or
 tree writes in the wrestler's worktree.
 
-Worktree `<absolute path>`, base `<base>`, range `<A>..<B>`. Rulebook `<absolute rulebook path>`;
-decisions `<bout dir>/decisions.md`. Ring scripts `<absolute ring path>/scripts`.
+Worktree `{{worktree}}`, base `{{base}}`, range `{{range}}`. The decisions taken are near the end of
+this brief and the rules after them, at its end. Ring scripts `{{ring}}/scripts`.
 
-Commits and what each claims:
-- `<sha>` <subject> — <claim>
+Commits of the concept:
+{{commits}}
 
-Author claims to verify against the base: <…>
+Author claims to verify against the base: {{claims}}
 
 **Behavior: what matters most; any change is a BLOCKER.** Invariants, numbered:
-1. <messages or jobs enqueued: names, ids, options, presence of undefined keys>
-2. <order of side effects>
-3. <payload to providers: keys and order>
-4. <counters, status transitions, error propagation>
-5. <telemetry event names and fields>
-6. Base test assertions: none may change (`git show <base>:<path>` before calling it a blocker).
-
-How to test: `git -C <worktree> archive <B> | tar -x -C <new temp dir>`; install there if needed;
-only the tests of the area, each through `node <ring>/scripts/one-at-a-time.mjs run -- <command>`;
-never a test run and a typecheck at the same time. For a pure-calculation refactor, a differential
-check old vs new that fails if you remove the key piece.
-
-**Design (UI venues, when the concept draws a screen).** You do not have the design tool, so the
-referee hands you the reference: the design file and node id, the measurements read from the live
-node with the time of that reading (sizes, spacing, colors, type, the position of the main action)
-and the path of an export of that node made after its last change. Compare the screenshots of the venue's matrix against them:
-<design file · node id · measurements · export path · screenshots>. A difference not listed by the
-author is a finding; text is judged by the node's content, never by a layer name.
+{{invariants}}
+Base test assertions: none may change (`git show {{base}}:<path>` before calling it a blocker).
+
+How to test: `git -C {{worktree}} archive <tip> | tar -x -C <new temp dir>`; install there if
+needed; only the tests of the area, each through `node {{ring}}/scripts/one-at-a-time.mjs run --
+<command>`; never a test run and a typecheck at the same time. For a pure-calculation refactor, a
+differential check old vs new that fails if you remove the key piece.
+
+**Design, the whole concept at once** (what a range-by-range review cannot see): read the concept
+as one piece through the lenses of this venue, {{lenses}}. An anemic aggregate built across several
+commits, a dependency that points outward once the pieces are together, a condition repeated
+across the files of the concept: each is a finding with its rule id.
+
+**Design of a screen (UI venues):** {{designReference}}. A difference from the reference not
+listed by the author is a finding; text is judged by the node's content, never by a layer name.
 
 **Leftovers (every concept close):**
+
 - Symbols left without production callers: grep, on your copy, every exported or public symbol the
   range touched and every symbol whose caller the range deleted; one used only by its own spec, or
   by nobody, is dead code.
-- Narrating, stale or now-wrong comments in the files the assignment covers: <paths>, including the
-  ones this range did not edit.
-- Commit messages of the range (`git -C <worktree> log --format=%B <A>..<B>`) carrying bout ids
+- Narrating, stale or now-wrong comments in the files the assignment covers: {{leftoverPaths}},
+  including the ones this range did not edit.
+- Commit messages of the range (`git -C {{worktree}} log --format=%B {{range}}`) carrying bout ids
   (D12, P7, HP3, PR5…).
 
-Return: a table per file, a table per invariant (holds / broken + evidence), the leftovers,
-totals, and a one-line verdict: `APPROVED` or `REBOUND: <n> blockers, <m> fixes`.
+Return: a table per file (one finding per row, `| <file:line> | <rule id> | <what> | <how> |`), a
+table per invariant (holds / broken + evidence), the leftovers, totals, and a one-line verdict:
+`APPROVED` or `REBOUND: <n> blockers, <m> fixes`. Every finding cites one of the rules at the end of this brief, or
+`X0` when none covers it.

package/ring/skills/referee/templates/cornerman-range.md

@@ -1,15 +1,20 @@
-<!-- Agent{subagent_type: "ring:cornerman", effort: "high"} -->
-
 Mode: **range**. Read only: no edits, no commits, no index or tree writes in any worktree.
 
-Worktree `<absolute path>`, base `<base>`, range `<A>..<B>`. Review each commit with
-`git -C <worktree> show <sha>` against the rulebook `<absolute rulebook path>` (read it first) and
-the decisions in `<bout dir>/decisions.md`. Only the lines these commits add or change.
+Worktree `{{worktree}}`, base `{{base}}`, range `{{range}}`. Review each commit with
+`git -C {{worktree}} show <sha>` against the rules at the end of this brief (the architecture
+checklist first) and the decisions at its end. Only the lines these commits add or change. Ring
+scripts `{{ring}}/scripts`.
+
+Commits of the range:
+{{commits}}
 
-<Optional: the author claims "<claim>". Verify it against the base; if a single counter, event or
-payload changes, it is a BLOCKER.>
+Author claims to verify against the base (if a single counter, event or payload changes, it is a
+BLOCKER): {{claims}}
 
-Return `file:line — rule id — what is wrong — how it must be`. A changed base test assertion or a
-renamed telemetry event goes first, marked BLOCKER. "<sha>: no findings" when a commit complies.
-No taste, no pre-existing debt. **At most 15 lines.** One finding per line: the referee registers
-each line as a finding (`findings.mjs add --file`), so never wrap one across lines.
+Return one finding per line, exactly `<file:line> — <rule id> — <what is wrong> — <how it must be>`.
+The rule id is the second field and must be one of the rules at the end of this brief (several as `R11/R22`); a
+finding no rule covers carries `X0`, and the referee proposes the rule it lacks. A changed base
+test assertion or a renamed telemetry event goes first, marked BLOCKER. "<sha>: no findings" when a
+commit complies. No taste, no pre-existing debt. **At most 15 lines.** The referee registers each
+line as a finding (`findings.mjs add --file`), which refuses a line without a valid rule id, so
+never wrap one across lines.

package/ring/skills/referee/templates/wrestler-brief.md

@@ -1,61 +1,45 @@
-<!-- The referee fills every <…> and sends this as the prompt of
-     Agent{subagent_type: "ring:wrestler", effort: "medium", run_in_background: true}.
-     Never `isolation: "worktree"`: that creates a new tree on another branch. -->
+Assignment: {{assignment}}. PR #{{pr}}, branch `{{branch}}`, stack base `{{base}}`.
 
-Assignment: <what and why, in 3 lines>. PR #<pr>, branch `<branch>`, stack base `<base>`.
+Flow change (P15): {{flowChange}}
 
-Flow change (P15; write "none" when no flow changes): today <what happens>; after this PR <what
-will happen>; who notices <role or screen>.
-
-Worktree: `<absolute worktree path>`. Your cwd resets: every git command is `git -C <worktree> …`.
-Start with: `git -C <worktree> fetch -q origin && git -C <worktree> checkout -B <branch> origin/<branch>`.
-Ring scripts: `<absolute ring path>/scripts` (one-at-a-time.mjs lives there).
-Bout dir: `<bout dir>`. A helper script you need goes in `<bout dir>/tools/`, never in the repo.
+Worktree: `{{worktree}}`. Your cwd resets: every git command is `git -C {{worktree}} …`.
+Start with: `git -C {{worktree}} fetch -q origin && git -C {{worktree}} checkout -B {{branch}} origin/{{branch}}`.
+Ring scripts: `{{ring}}/scripts` (one-at-a-time.mjs lives there).
+Bout dir: `{{boutDir}}`. A helper script you need goes in `{{boutDir}}/tools/`, never in the repo.
 Write only inside your worktree; never in the main checkout or any other tree.
 
-Rulebook: `<absolute rulebook path>` (read it in full; rebounds cite its rule ids).
-Precedents: `<bundled precedents path>` (PRn) and `<host precedents path or "none">` (HPn); rebounds
-cite them too.
-Decisions already taken (do not reopen them): `<bout dir>/decisions.md`.
+Rules: the rulebook and the precedents of this venue ({{venue}}) are at the end of this brief, in
+full. They are the ones in force: apply them while you write, not only when a rebound cites them,
+and check the architecture checklist before every commit.
+Decisions already taken (do not reopen them): the excerpt before the rules; the whole
+ledger is `{{boutDir}}/decisions.md`.
 
-Comments to address: <`gh api repos/<o>/<r>/pulls/<pr>/comments`, plus the list>.
-Reference pattern: <`gh pr diff <n>` of the round-bell the human approved> — replicate it.
+Comments to address: {{comments}}
+Reference pattern: {{referencePattern}}
 
-Order of concepts: 1. <pilot: one small concept, as a sample for the human> 2. <…> 3. <…>
+Order of concepts: {{concepts}}
+One commit per theme, never one commit for a whole concept: a removal goes with the tests it
+updates; a behavior change (what the flow-change line names, or an error that now surfaces
+differently) goes in its own commit with the test that pins it (T6); renames and formatting go
+apart from logic.
 Commit locally and never push: when you close 2–3 commits (or ~200 lines), report the range and
 keep going only if I have not stopped you. The PR branch receives what the cornerman approved, and I
-push it; every commit you close is backed up for you to `ring/<pr>/respaldo`, approved or not. If mask-guard says the review cap is
-reached, report the range and wait for me.
+push it; every commit you close is backed up for you to `{{backupBranch}}`, approved or not. If
+mask-guard says the review cap is reached, report the range and wait for me.
 
-Frozen zones (do not touch): <paths>.
-WAITING ON THE HUMAN (hard list; do not touch): <list>.
+Frozen zones (do not touch): {{frozen}}.
+WAITING ON THE HUMAN (hard list; do not touch): {{waitingOnHuman}}.
 Design doubts go to me, never to the human: I decide them (or escalate them) and tell you.
 
 Gates (from `.claude/ring.json`, each through one-at-a-time; a long run such as a battery adds
 `--monitor <id>` when its command does not match a declared monitor, so it shows on the Scorecard):
-- typecheck: `<command>`
-- tests of what you touched: `<command with {paths}>`
-- lint: `<command>`
+
+- typecheck: `{{gateTypecheck}}`
+- tests of what you touched: `{{gateTest}}`
+- lint: `{{gateLint}}`
 
 Standing conditions: behavior identical; no base test assertion changes (if one has to, stop and
 tell me first); no new flags or env vars; one heavy command at a time; stage by paths;
-forbidAiTrailers is <true|false> (when true, no AI attribution trailers; human co-authors are
-fine); disk floor <5> GB.
+forbidAiTrailers is {{forbidAiTrailers}} (when true, no AI attribution trailers; human co-authors
+are fine); disk floor {{diskFloor}} GB.
 Do NOT run reviewers, review loops or Copilot. Do NOT open ready PRs. Do NOT merge or change bases.
-
----
-
-## Resume variant (a new session relaunches the wrestler)
-
-Same brief, plus at the top:
-
-You are resuming bout #<pr>; the previous wrestler stopped at `<sha>` while working on
-"<last subject>". First `git -C <worktree> status` and `git -C <worktree> diff`: finish and commit
-what was left uncommitted. Then read the open rebounds (`<bout dir>/rebounds.md`) and report the
-commit you are on before continuing with <concept>.
-
-## Cut-off variant (the same wrestler lost its connection)
-
-The API cut you off mid-edit (you were on "<last subject>"). `git status` and `git diff`, finish
-what was left uncommitted, commit it, read the last rebound (`<bout dir>/rebounds.md`) and report
-the commit you are on.

package/ring/skills/referee/templates/wrestler-cutoff.md

@@ -0,0 +1,4 @@
+The API cut you off mid-edit (you were on "{{lastSubject}}", at `{{headSha}}`). `git -C {{worktree}} status`
+and `git -C {{worktree}} diff`, finish what was left uncommitted, commit it, read the last rebound
+(`{{boutDir}}/rebounds.md`) and report the commit you are on. The rules you work by are the ones
+your first brief embedded; nothing about them changed.

package/ring/skills/referee/templates/wrestler-resume.md

@@ -0,0 +1,4 @@
+You are a new wrestler on bout #{{pr}}. The previous one stopped at `{{headSha}}` ("{{lastSubject}}").
+First `git -C {{worktree}} status` and `git -C {{worktree}} diff`: finish and commit what was left
+uncommitted. Then read the open rebounds (`{{boutDir}}/rebounds.md`) and report the commit you are
+on before continuing with {{nextConcept}}.

package/ring/skills/sparring/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: sparring
-description: Opens a sparring, a quick and deliberately low-quality draft (one PR per repo it touches, back and front included) that only proves whether a feature is worth building, before anyone pays for building it well. A rudo per repo (effort medium) writes it inside a timebox in its own worktree; the draft PR (labels sparring + do-not-merge) is the event the host project's CI catches to deploy a preview; credentials travel by name only. The judge calls KO, rematch or discard, in two out of three falls: a KO passes the host gates (vestidor), faces the team's Tapes until a bell (unless «sin equipo»), keeps or loses the mask, and then hands each branch to a ring bout. Invoke with `/ring:sparring <idea | Linear ticket>`, `/ring:sparring preview <slug>`, `/ring:sparring verdict <slug>`, `/ring:sparring list`, "make a quick draft of this to try it", "spar this feature first".
+description: Opens a sparring, a quick and deliberately low-quality draft (one PR per repo it touches, back and front included) that only proves whether a feature is worth building, before anyone pays for building it well. A rudo per repo (Sonnet at effort high by default) writes it inside a timebox in its own worktree; the draft PR (labels sparring + do-not-merge) is the event the host project's CI catches to deploy a preview; credentials travel by name only. The judge calls KO, rematch or discard, in two out of three falls: a KO passes the host gates (vestidor), faces the team's Tapes until a bell (unless «sin equipo»), keeps or loses the mask, and then hands each branch to a ring bout. Invoke with `/ring:sparring <idea | Linear ticket>`, `/ring:sparring preview <slug>`, `/ring:sparring verdict <slug>`, `/ring:sparring list`, "make a quick draft of this to try it", "spar this feature first".
 argument-hint: '<idea | ticket> | preview <slug> | verdict <slug> | vestidor <slug> | list'
 ---
 
@@ -122,7 +122,8 @@ defense|bell|mask-kept|mask-lost|no-team` the rest).
    for its repo (scope, designs, the other repos and what they exchange):
 
    ```
-   Agent{subagent_type: "ring:rudo", effort: "medium", run_in_background: true,
+   Agent{subagent_type: "ring:rudo", model: "<config.agents.rudo.model>",
+         effort: "<config.agents.rudo.effort>", run_in_background: true,
          description: "Rudo: <slug> <repo>", prompt: <the brief>}
    ```