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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thebattlearena/corner",
-  "version": "0.10.1-beta.84",
+  "version": "0.10.1-beta.85",
   "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/scripts/judges-card.mjs

@@ -872,11 +872,13 @@ export function readyForTitleDefense(pr, view) {
       reason: `could not tell whether PR #${pr} is a draft (${error.message}); title-defense does not start`,
     };
   }
-  if (answer?.isDraft === false) return { ok: true, reason: null };
+  if (answer?.isDraft === false)
+    return { ok: true, reason: null, nodeId: answer.id ?? null };
   if (answer?.isDraft === true)
     return {
       ok: false,
       draft: true,
+      nodeId: answer.id ?? null,
       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` };
@@ -1005,7 +1007,7 @@ function titleDefense([pr, ...argv]) {
   const gate = clear
     ? { ok: true }
     : readyForTitleDefense(pr, () =>
-        execFileSync('gh', ['pr', 'view', String(pr), '--json', 'isDraft'], {
+        execFileSync('gh', ['pr', 'view', String(pr), '--json', 'isDraft,id'], {
           cwd: state.worktree,
           encoding: 'utf8',
           stdio: ['ignore', 'pipe', 'pipe'],
@@ -1030,7 +1032,18 @@ function titleDefense([pr, ...argv]) {
     throw new Error(
       gate.draft ? `${gate.reason} (--keep-draft was passed)` : gate.reason,
     );
-  const next = withTitleDefense(state, clear ? null : Number(argv[index + 1]));
+  const flagged = withTitleDefense(
+    state,
+    clear ? null : Number(argv[index + 1]),
+  );
+  // The PR's GraphQL node id: mask-guard ties a requestReviewsByLogin (`-F id=<node>`) to this bout.
+  const next =
+    clear || !gate.nodeId
+      ? flagged
+      : {
+          ...flagged,
+          titleDefense: { ...flagged.titleDefense, nodeId: gate.nodeId },
+        };
   writeState(dir, next);
   console.log(
     clear

package/ring/scripts/mask-guard.mjs

@@ -13,6 +13,7 @@
 import { boutArchGate } from './arch-gate.mjs';
 import { boutFormatGate } from './format-gate.mjs';
 import { boutLeases, commitLeaseRefusal, wrestlerBlocks } from './lanes.mjs';
+import { reviewInputs, roundsAwaitingHuman } from './review-blocks.mjs';
 import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
@@ -955,6 +956,19 @@ const requestsCopilotByLogin = (gh) =>
   /\brequestReviewsByLogin\b/.test(graphqlText(gh)) &&
   /copilot-pull-request-reviewer/.test(graphqlText(gh));
 
+/**
+ * The PR node id a GraphQL mutation targets: `-F id=<node>` / `-f id=…` or a `pullRequestId:
+ * "<node>"` inside the query. PURE.
+ */
+export function graphqlNodeId(gh) {
+  const text = graphqlText(gh);
+  return (
+    /(?:^|\s)-[fF]\s+(?:id|pullRequestId)=(\S+)/.exec(text)?.[1] ??
+    /pullRequestId:\s*"([^"]+)"/.exec(text)?.[1] ??
+    null
+  );
+}
+
 /** `node <…>/judges-card.mjs close <pr>`: the PR it closes, else null. */
 function closesBout(words) {
   const closing =
@@ -980,9 +994,13 @@ function chronicleBehind(ctx, where, pr) {
   }
   const [first] = stale;
   if (!first) return null;
+  const unscoped =
+    pr === null
+      ? ` This command could not be tied to one bout, so every active bout of the repo was checked: #${first.pr} is the one behind, not necessarily the PR this command is for.`
+      : '';
   return {
     block: true,
-    reason: `The play-by-play is behind the bout (records changed after ${first.publishedAt ?? 'a publish that was never stamped'}). Run /ring:play-by-play ${first.pr} and publish to the same link first.`,
+    reason: `The play-by-play is behind the bout (records changed after ${first.publishedAt ?? 'a publish that was never stamped'}). Run /ring:play-by-play ${first.pr} and publish to the same link first.${unscoped}`,
   };
 }
 
@@ -1376,8 +1394,19 @@ function judgeSegment(segment, words, cwd, ctx) {
   const bell = gh && requestsCopilotByLogin(gh);
   const where = { git, gh, dir: cwd };
   if ((bell || closing !== null) && ctx.anyBout() && ctx.boutActive(where)) {
-    const behind = chronicleBehind(ctx, where, bell ? prNumberOf(gh) : closing);
+    // A GraphQL re-request names its PR by node id: title-defense stored it when it set the flag.
+    const bellPr = bell
+      ? (prNumberOf(gh) ?? ctx.prOfNode?.(where, graphqlNodeId(gh)) ?? null)
+      : null;
+    const behind = chronicleBehind(ctx, where, bell ? bellPr : closing);
     if (behind) return behind;
+    // Copilot gets no new round until the human validated the last one (its plan block).
+    const unreviewed = bell ? ctx.roundsAwaitingHuman?.(where, bellPr) : [];
+    if (unreviewed?.length)
+      return {
+        block: true,
+        reason: `The human has not validated ${unreviewed.join(', ')} yet: Copilot gets the next round only after the human signs that round in PR Review Lab (a pass). Wait for the verdict (the lookout wakes you), apply it with judges-card.mjs summary <pr>, then re-request.`,
+      };
   }
   const ambiguous =
     git?.sub === 'commit' &&
@@ -1721,6 +1750,26 @@ function realContext(cwd, agentId = null) {
         .filter((bout) => bout.stale)
         .map(({ pr: stalePr, publishedAt }) => ({ pr: stalePr, publishedAt }));
     },
+    // The Copilot round blocks the human has not validated, of the bout of `pr` (every bout when null).
+    roundsAwaitingHuman: (where, pr) => {
+      const slug = slugWhere(where);
+      if (!slug) return [];
+      return boutsOf(slug)
+        .filter(({ state }) => pr === null || state.pr === pr)
+        .flatMap(({ dir }) => {
+          const { plan, log, verdicts } = reviewInputs(dir);
+          return roundsAwaitingHuman(plan, log, verdicts);
+        });
+    },
+    // The bout whose title-defense flag carries this PR node id, or null.
+    prOfNode: (where, nodeId) => {
+      const slug = slugWhere(where);
+      if (!slug || !nodeId) return null;
+      return (
+        boutsOf(slug).find(({ state }) => state.titleDefense?.nodeId === nodeId)
+          ?.state.pr ?? null
+      );
+    },
     titleDefenseFlags: (where) => {
       const slug = slugWhere(where);
       if (!slug) return [];

package/ring/scripts/review-blocks.mjs

@@ -287,6 +287,19 @@ export function lookaheadRefusal({ globs, waitingFiles, running }) {
   return null;
 }
 
+/**
+ * The Copilot rounds of title-defense the human has not validated yet: a block «Copilot R<k>…»
+ * still «en curso», or waiting on the judge with no later verdict. Copilot is not asked for another
+ * round until they are empty. PURE.
+ */
+export function roundsAwaitingHuman(plan, log, verdicts) {
+  const isRound = (item) => /^Copilot R\d+/i.test(item.title);
+  const waiting = blocksAwaitingReview(plan, log, verdicts).filter(isRound);
+  return [...runningBlocks(plan).filter(isRound), ...waiting].map(
+    (item) => `B${item.n} «${item.title}»`,
+  );
+}
+
 /** The blocks «en curso» right now. PURE. */
 export const runningBlocks = (plan) =>
   parsePlan(plan)

package/ring/skills/title-defense/SKILL.md

@@ -94,7 +94,15 @@ list, judges card, `decisions.md` and `rebounds.md`, and the same `mask-guard` r
    result is a new rebound; a fix is not done until the reproduction says so (PR26). If it cannot
    run (environment down, scenario missing), the thread stays open and is listed for the human in
    the judges card: never resolve it on unit tests alone.
-6. **A round-bell for the fixes** (§2.6), one per concept.
+6. **A round-bell for the fixes** (§2.6), one per concept. **The round is a block of the plan**,
+   so the human reviews it in PR Review Lab like any other: before the wrestler starts, `judges-card.mjs
+   plan <pr> add "Defensa del título" "Copilot R<k>: <one line of what it fixes>"`, then `plan <pr>
+   <n> "en curso" --minutes <m> --priority 1` (with `--files` when blocks run side by side), and
+   `plan <pr> <n> "espera al juez"` once its range is approved. The human's verdict applies as for
+   any block: a fail comes back as the rebound of the next round. A round with nothing to fix adds
+   no block. **Copilot gets the next round only after the human passed this one**: mask-guard
+   refuses the re-request while a «Copilot R<k>» block is running or waits on the judge; the lookout
+   wakes you when the verdict lands.
 7. **CI red**: diagnose before touching code: `gh run view <id> --log-failed`. Tell a PR failure
    from a gate failure (coverage of an untested file; a size ceiling, which goes to the human).
    Never "fix" a gate by weakening it. A PR failure goes through steps 3 to 6 like a finding.