@thebattlearena/corner 0.10.0 → 0.10.1-beta.78

package/README.md

@@ -123,28 +123,28 @@ El detalle (esquema, íconos y colores válidos) está en «Monitores del repo»
 Con la fuente Battle Arena Icons instalada (la pone `install`), estos símbolos se dibujan con sus
 glifos; sin ella, con el carácter de la tabla.
 
-| Ícono | Dónde | Significa |
-| --- | --- | --- |
-| ✓ | punto, banda | entregado |
-| ↻ | punto, banda | en curso: tiene tiempo hoy |
-| ↷ | punto, banda | desplazado por un emergente |
-| ○ | punto, banda | por hacer: sin tiempo todavía |
-| ● | punto, en el cierre | avanzó pero no se entregó |
-| ⚠ | banda, riesgos | riesgo abierto; en una ficha, «va con avisos» |
-| ✗ | ficha | un paso falló |
-| ✎ | emergente, banda | falta responder el motivo |
-| ✋ | riesgo | levantar la mano: avisa a tu líder |
-| 👍 👎 | riesgo | si el aviso de riesgo acertó o no (ajusta la detección) |
-| 📅 | punto | reunión ligada |
-| 💡 | punto, complemento | tiempo en cabina |
-| 🧪 | punto, complemento | sesión de Tape |
-| ▸ ▾ ▴ | filas | desplegar, contraer, cerrar el detalle |
-| ↗ | ligas | abrir en la web |
-| ♪ ▶ ⏸ ▲ | radio | la canción, escuchar, dejar de escuchar, votar |
-| spinner | ring | alguien del combate está trabajando |
-| ■ (ámbar) | ring | te toca decidir |
-| 👊N (rojo) | ring | Copilot dejó N hilos |
-| ◣ | ficha de Copilot | en la esquina: Copilot está revisando |
+| Ícono      | Dónde               | Significa                                               |
+| ---------- | ------------------- | ------------------------------------------------------- |
+| ✓          | punto, banda        | entregado                                               |
+| ↻          | punto, banda        | en curso: tiene tiempo hoy                              |
+| ↷          | punto, banda        | desplazado por un emergente                             |
+| ○          | punto, banda        | por hacer: sin tiempo todavía                           |
+| ●          | punto, en el cierre | avanzó pero no se entregó                               |
+| ⚠          | banda, riesgos      | riesgo abierto; en una ficha, «va con avisos»           |
+| ✗          | ficha               | un paso falló                                           |
+| ✎          | emergente, banda    | falta responder el motivo                               |
+| ✋         | riesgo              | levantar la mano: avisa a tu líder                      |
+| 👍 👎      | riesgo              | si el aviso de riesgo acertó o no (ajusta la detección) |
+| 📅         | punto               | reunión ligada                                          |
+| 💡         | punto, complemento  | tiempo en cabina                                        |
+| 🧪         | punto, complemento  | sesión de Tape                                          |
+| ▸ ▾ ▴      | filas               | desplegar, contraer, cerrar el detalle                  |
+| ↗          | ligas               | abrir en la web                                         |
+| ♪ ▶ ⏸ ▲    | radio               | la canción, escuchar, dejar de escuchar, votar          |
+| spinner    | ring                | alguien del combate está trabajando                     |
+| ■ (ámbar)  | ring                | te toca decidir                                         |
+| 👊N (rojo) | ring                | Copilot dejó N hilos                                    |
+| ◣          | ficha de Copilot    | en la esquina: Copilot está revisando                   |
 
 Las fichas del ring son el **árbitro**, el **luchador**, el **esquinero**, la **campana** (round-bell),
 **Copilot** y el **juez** (tú). Su borde dice el estado: gris quieta, azul trabajando, morada en la
@@ -167,8 +167,8 @@ Se invocan escribiendo el comando o pidiéndolo con tus palabras («arma mi plan
 
 ### Comandos
 
-| Comando      | Para qué sirve                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Comando     | Para qué sirve                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `/ringside` | Abre **Ringside**: la pelea de tu día junto al chat. Tu plan con el avance y el tiempo de cada punto contra lo comprometido (semáforo verde · amarillo · rojo), los emergentes (clic para ver su motivo), los riesgos siempre visibles con ✋ Levantar la mano y 👍/👎, y el pie con Plan · Reuniones · Fuera · Total. Pestaña **Semana** con tus hábitos. Sin datos, te dice el **siguiente paso** (instalar, armar el plan, entrar a la daily). `/scorecard`, su nombre anterior, lo sigue abriendo con un aviso. |
 
 Arriba del prompt sale además una **banda** compacta de Ringside (`LER-640   ✓ 1   ↻ 1   ↷ 1   ⚠ 1   Abrir`, cada contador con su color).
@@ -374,8 +374,28 @@ rama. El contrato para el proyecto está en `ring/skills/sparring/references/hos
 **Config del repo** (`.claude/ring.json`, opcional): `gates` (typecheck, tests por ruta con
 `{paths}`, lint), `validateCommand`, `rulebook` (por defecto el genérico del plugin),
 `protectedBranches`, `forbidAiTrailers` (por defecto `true`), `heavyCommands`, `delegation`,
-`precedents` y `monitors` (ver «Monitores del repo»). Sin el archivo, `ring` usa los gates que detecta en `package.json`, `pyproject.toml`,
-`go.mod` y el `Makefile`.
+`precedents`, `monitors` (ver «Monitores del repo»), `briefGuard` (`warn`, `block` u `off`) y `agents` (modelo y esfuerzo por rol; por
+defecto el luchador y el rudo en `sonnet` con esfuerzo `high` y el esquinero en `opus` con `high`,
+p. ej. `"agents": { "wrestler": { "model": "opus" } }`). Sin el archivo, `ring` usa los gates que
+detecta en `package.json`, `pyproject.toml`, `go.mod` y el `Makefile`.
+
+**Briefs generados, no escritos**: el árbitro no le escribe a mano las instrucciones al luchador
+ni al esquinero. `ring/scripts/brief.mjs` las arma desde los templates con el reglamento y los
+precedentes embebidos completos (abriendo con un checklist de arquitectura: lo que más se escapa en
+una revisión línea por línea), las decisiones que importan (todas las faltas, las de esos archivos
+y las últimas 20) y los commits del rango; las sella y las registra en
+`<combate>/briefs/index.jsonl`. El árbitro sólo pone sus valores (el encargo, las invariantes…).
+Todo hallazgo de un esquinero o de una revisión tuya cita una regla del reglamento
+(`<archivo:línea> — R11 — …`): `findings.mjs add` rechaza el que no la trae, y uno que ninguna regla
+cubre lleva `X0` y queda como propuesta para el reglamento.
+El árbitro lanza al luchador y al esquinero con `prompt: "ring-brief: <archivo>"`: el hook
+`brief-guard` revisa el sello (generado por `brief.mjs`, sin editar, con las reglas de hoy, de este
+combate y de ese rol), pone el texto del archivo como instrucción y el modelo y esfuerzo del rol.
+Con `briefGuard: "warn"` (el default en `.claude/ring.json`) un brief que no cumple pasa y el árbitro
+recibe el aviso; con `"block"` se rechaza con el comando que lo genera; `"off"` lo apaga. Cada
+decisión queda en `<combate>/brief-guard.jsonl`. Y cuando la sesión del árbitro se compacta, el hook
+`compact-hook` le devuelve (en menos de 10 000 caracteres) el combate, el checklist, sus faltas y el
+«cómo reanudar» de la tarjeta.
 
 **Delegación y precedentes**: con `delegation: "referee"` (el default) el árbitro decide él mismo
 las dudas de diseño con el reglamento y los precedentes, anota por qué en `decisions.md` y sigue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thebattlearena/corner",
-  "version": "0.10.0",
+  "version": "0.10.1-beta.78",
   "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

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

package/ring/agents/rudo.md

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

package/ring/agents/wrestler.md

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

package/ring/hooks/hooks.json

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

package/ring/scripts/brief-build.mjs

@@ -0,0 +1,130 @@
+// The pure rules of a generated brief (brief.mjs is its CLI): the rules block, the excerpt of
+// decisions, the filling of a template with no placeholder left, the seal that proves the brief
+// came from the script with the rules in force, and the paths a brief may point to. Zero-dependency.
+import { createHash } from 'node:crypto';
+import { basename, isAbsolute, sep } from 'node:path';
+
+import { parseDecisionLine } from './chronicle.mjs';
+import { checklistLines } from './rule-ids.mjs';
+
+export const BRIEF_VERSION = 'v1';
+const SEAL = /^<!-- ring-brief (v\d+) (.*) -->$/;
+
+export const sha256 = (text) =>
+  `sha256:${createHash('sha256').update(text).digest('hex')}`;
+
+/**
+ * The rules every brief carries, in full and before anything else (the same text for every brief
+ * of a venue, so a model can reuse it): the architecture checklist, then each rule file. PURE.
+ */
+export function rulesBlock({ sources, entries }) {
+  const files = sources.map(
+    ({ path, text }) =>
+      `<rules file="${basename(path)}">\n${text.trim()}\n</rules>`,
+  );
+  return [
+    '# The rules in force for this bout',
+    '',
+    'Embedded in full by `brief.mjs`: these are the rules you apply and cite by id. Nothing you',
+    'remember from another bout replaces them.',
+    '',
+    '## Architecture checklist (what slips past a line-by-line review; check it first)',
+    '',
+    ...checklistLines(entries),
+    '',
+    ...files,
+  ].join('\n');
+}
+
+/**
+ * The decisions a brief carries: every foul (what must not be repeated), the ones whose text names
+ * a file of the range, and the last `last`; in ledger order, each once. PURE.
+ */
+export function decisionsExcerpt(
+  decisionsText,
+  files = [],
+  { last = 20 } = {},
+) {
+  const lines = String(decisionsText ?? '')
+    .split('\n')
+    .filter((line) => parseDecisionLine(line)?.id);
+  const names = files.map((file) => basename(file)).filter(Boolean);
+  const tail = new Set(lines.slice(-last));
+  const kept = lines.filter(
+    (line) =>
+      tail.has(line) ||
+      /\bFOUL\b/.test(line) ||
+      names.some((name) => line.includes(name)),
+  );
+  return kept.length ? kept.join('\n') : '(no decisions yet)';
+}
+
+/** The template with every `{{name}}` filled; throws naming each one left empty. PURE. */
+export function fill(template, vars) {
+  const missing = new Set();
+  const text = template.replace(/\{\{(\w+)\}\}/g, (whole, name) => {
+    const value = vars[name];
+    if (value === undefined || value === null || String(value).trim() === '') {
+      missing.add(name);
+      return whole;
+    }
+    return String(value);
+  });
+  if (missing.size)
+    throw new Error(`the brief is missing: ${[...missing].join(', ')}`);
+  return text;
+}
+
+/** The last line of a brief: what it is and the hashes that prove it. PURE. */
+export function seal(body, meta) {
+  const fields = Object.entries({ ...meta, body: sha256(body) })
+    .map(([key, value]) => `${key}=${value}`)
+    .join(' ');
+  return `${body}\n<!-- ring-brief ${BRIEF_VERSION} ${fields} -->\n`;
+}
+
+/** The seal of a brief, its body and whether the body is the one sealed; null without a seal. PURE. */
+export function readSeal(text) {
+  const lines = String(text).replace(/\n$/, '').split('\n');
+  const match = SEAL.exec(lines.at(-1) ?? '');
+  if (!match) return null;
+  const meta = Object.fromEntries(
+    match[2].split(' ').map((pair) => pair.split('=')),
+  );
+  const body = lines.slice(0, -1).join('\n');
+  return { version: match[1], meta, body, intact: sha256(body) === meta.body };
+}
+
+/**
+ * Whether a sealed brief still holds: its body untouched and its rules the ones in force now
+ * (`rulesHash`). The reason when it does not. PURE.
+ */
+export function briefStatus(text, rulesHash) {
+  const sealed = readSeal(text);
+  if (!sealed)
+    return { ok: false, reason: 'not generated by brief.mjs (no seal)' };
+  if (!sealed.intact)
+    return { ok: false, reason: 'edited by hand after it was generated' };
+  if (sealed.meta.rules && sealed.meta.rules !== rulesHash)
+    return { ok: false, reason: 'the rules changed since; generate it again' };
+  return { ok: true, meta: sealed.meta };
+}
+
+const ABSOLUTE_PATH = /(?:^|[\s`'"(])(\/[^\s`'"()]+)/g;
+
+/**
+ * The absolute paths in the referee's values that point outside the places a brief may send an
+ * agent (the repo, the worktree, the bout dir, the ring): a session scratchpad is wiped on restart,
+ * so nothing the human asked for may live there. PURE.
+ */
+export function strayPaths(vars, roots) {
+  const inside = (path) =>
+    roots.some((root) => path === root || path.startsWith(root + sep));
+  return Object.entries(vars).flatMap(([name, value]) =>
+    [...String(value ?? '').matchAll(ABSOLUTE_PATH)]
+      .map((match) => match[1].replace(/[.,;:]+$/, ''))
+      .filter((path) => isAbsolute(path))
+      .filter((path) => !inside(path))
+      .map((path) => ({ name, path })),
+  );
+}

package/ring/scripts/brief-guard.mjs

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+// Hook on PreToolUse (Agent|Task). In a session registered in a bout, a wrestler or a cornerman is
+// launched with a brief brief.mjs generated, never one written by hand. Zero-dependency.
+//
+// - The referee launches with `prompt: "ring-brief: <path>"`: the guard reads the file, checks its
+//   seal (generated, unedited, on today's rules, of this bout and of this role) and replaces the
+//   prompt with the file's text, with the model and effort `.claude/ring.json` sets for the role.
+// - A prompt that is the brief itself is checked the same way and only gets the model and effort.
+// - A brief that does not hold: `briefGuard: "warn"` (the default) lets the launch through and tells
+//   the referee why; `"block"` refuses it with the command that generates one; `"off"` does nothing.
+// Every decision goes to `<bout dir>/brief-guard.jsonl`.
+//
+// Sessions that are not the bout's, agents that are not the ring's and the rudo are left alone.
+// It never fails a tool call by accident: any error of its own ends in exit 0 with no output.
+import { appendFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { checkBrief } from './brief.mjs';
+import { isMain, loadConfig, projectDir, readState } from './config.mjs';
+import { classifyAgent } from './live-hook.mjs';
+import { findBout, sessionRegistered } from './live.mjs';
+
+export const GUARD_LOG = 'brief-guard.jsonl';
+const AGENT_TOOLS = ['Agent', 'Task'];
+const ROLE = { luchador: 'wrestler', esquinero: 'cornerman' };
+const REFERENCE = /^ring-brief:\s*(\S+)$/;
+
+/** The brief a prompt carries: the file of a `ring-brief: <path>` reference, or the prompt itself. */
+export function briefOf(
+  prompt,
+  readFile = (path) => readFileSync(path, 'utf8'),
+) {
+  const text = String(prompt ?? '').trim();
+  const path = REFERENCE.exec(text)?.[1] ?? null;
+  if (!path) return { text, path: null };
+  try {
+    return { text: readFile(path), path };
+  } catch {
+    return { text: null, path };
+  }
+}
+
+/** Why a brief does not hold for this launch, or null when it holds. PURE given `check`. */
+export function problemOf({ text, path, check, role, pr }) {
+  if (text === null) return `there is no brief at ${path}`;
+  if (!check.ok) return check.reason;
+  if (check.meta.kind !== role)
+    return `it is a ${check.meta.kind} brief, launched as the ${role}`;
+  if (String(check.meta.pr) !== String(pr))
+    return `it is the brief of #${check.meta.pr}, not of this bout (#${pr})`;
+  return null;
+}
+
+const howToFix = (role, pr) =>
+  `generate it with \`node <ring>/scripts/brief.mjs ${role} ${pr} --mode <mode> --vars <file.json>\` and launch with \`prompt: "ring-brief: <the path it prints>"\``;
+
+/**
+ * The hook's answer for one launch: the JSON to print, or null to print nothing. PURE.
+ * `brief` is briefOf's result, `problem` problemOf's, `launch` the role's {model, effort}.
+ */
+export function answer({ input, brief, problem, mode, role, pr, launch }) {
+  if (problem && mode === 'block')
+    return {
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason: `brief-guard: the ${role} brief does not hold (${problem}); ${howToFix(role, pr)}.`,
+      },
+    };
+  if (problem)
+    return {
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        additionalContext: `brief-guard (warn): this ${role} was launched with a brief that does not hold (${problem}). It runs without the rules and decisions brief.mjs embeds; next time ${howToFix(role, pr)}.`,
+      },
+    };
+  const updated = {
+    ...input,
+    prompt: brief.text,
+    ...(launch?.model ? { model: launch.model } : {}),
+    ...(launch?.effort ? { effort: launch.effort } : {}),
+  };
+  const same = ['prompt', 'model', 'effort'].every(
+    (key) => updated[key] === input[key],
+  );
+  if (same) return null;
+  return {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: 'allow',
+      permissionDecisionReason: `brief-guard: ${brief.path ? `brief ${brief.path} expanded` : 'brief holds'}, ${role} on ${launch?.model ?? input.model} / ${launch?.effort ?? input.effort}`,
+      updatedInput: updated,
+    },
+  };
+}
+
+/** The guard on one hook input; returns what to print (null for nothing). */
+export function guard(input) {
+  if (input?.hook_event_name !== 'PreToolUse') return null;
+  if (!AGENT_TOOLS.includes(input.tool_name)) return null;
+  const role = ROLE[classifyAgent(input.tool_input)];
+  if (!role) return null;
+  const bout = findBout({
+    cwd: input.cwd,
+    hint: input.tool_input?.description,
+  });
+  if (!bout || !sessionRegistered(bout, input.session_id)) return null;
+  const state = readState(bout);
+  const { config } = loadConfig(projectDir(process.env, input.cwd), {
+    contract: false,
+    venue: state.venue ?? 'backend',
+  });
+  const mode = config.briefGuard ?? 'warn';
+  if (mode === 'off') return null;
+  const brief = briefOf(input.tool_input?.prompt);
+  let check = { ok: false, reason: 'no seal', meta: null };
+  if (brief.text !== null) {
+    try {
+      check = checkBrief(brief.text);
+    } catch (error) {
+      check = { ok: false, reason: error.message, meta: null };
+    }
+  }
+  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`,
+  );
+  return answer({
+    input: input.tool_input,
+    brief,
+    problem,
+    mode,
+    role,
+    pr: state.pr,
+    launch: config.agents?.[role],
+  });
+}
+
+if (isMain(import.meta.url)) {
+  let raw = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk) => (raw += chunk));
+  process.stdin.on('end', () => {
+    let out = null;
+    try {
+      out = guard(JSON.parse(raw));
+    } catch {
+      out = null;
+    }
+    if (out) process.stdout.write(JSON.stringify(out));
+    process.exit(0);
+  });
+}