@thebattlearena/corner 0.8.0 → 0.9.0

package/ring/scripts/config.mjs

@@ -64,6 +64,22 @@ export const BUNDLED_PRECEDENTS = join(
 export const HOST_CONFIG = join('.claude', 'ring.json');
 export const HOST_PRECEDENTS = join('.claude', 'ring-precedents.md');
 
+/** The label of every temporary PR the ring opens (round-bells, sparrings): never merged. */
+export const DO_NOT_MERGE = 'do-not-merge';
+
+/**
+ * Sparring drafts live on `sparring/<slug>`; local (`origin/`) and full refs count too, and so
+ * does the `owner:` prefix gh takes for a head on a fork (`--head owner:sparring/<slug>`); a git
+ * branch can never hold a `:`, so stripping it never mistakes a real branch. PURE.
+ */
+export const SPARRING_PREFIX = 'sparring/';
+export const isSparringBranch = (branch) =>
+  String(branch ?? '')
+    .replace(/^[^/:\s]+:/, '')
+    .replace(/^refs\/heads\//, '')
+    .replace(/^(refs\/remotes\/)?origin\//, '')
+    .startsWith(SPARRING_PREFIX);
+
 /** Who decides design doubts: the referee (default) or, as before, the human. */
 export const DELEGATION_LEVELS = ['referee', 'human'];
 
@@ -111,9 +127,23 @@ export const DEFAULTS = Object.freeze({
   // Cornerman findings a round-bell or a push tolerates: open ones from ranges inside it, and ones
   // the referee settled alone that the human has not seen (null: no gate). See findings.mjs.
   findingsGate: Object.freeze({ open: 0, unshown: 3 }),
+  // Sparring drafts (/ring:sparring): the label of their PRs, the GitHub deployment environment the
+  // host's CI publishes the preview to (null: the host has none), how long to wait for it, and after
+  // how many days without a verdict a sparring shows as stale.
+  sparring: Object.freeze({
+    label: 'sparring',
+    previewEnvironment: null,
+    previewTimeoutMin: 20,
+    staleDays: 7,
+  }),
 });
 
 const GATES = ['typecheck', 'test', 'lint'];
+/**
+ * Gates detected when the repo has them, never reported missing: `build` is the sparring vestidor's
+ * (the host's real build before the team sees a KO), not a bout gate, so mask-guard leaves it out.
+ */
+export const OPTIONAL_GATES = ['build'];
 
 const VENUES = bundledVenues();
 export const VENUE_NAMES = Object.keys(VENUES);
@@ -158,6 +188,11 @@ function detectNode(read, exists) {
       command: `${pm.exec} tsc --noEmit`,
       from: 'typescript + tsconfig.json',
     };
+  if (scripts.build)
+    found.build = {
+      command: `${pm.run} build`,
+      from: 'package.json script "build"',
+    };
   if (scripts.lint)
     found.lint = {
       command: `${pm.run} lint`,
@@ -223,6 +258,7 @@ function detectGo(read, exists) {
       command: 'go test {paths}',
       from: 'go.mod (paths are packages, e.g. ./pkg/x/...)',
     },
+    build: { command: 'go build ./...', from: 'go.mod' },
   };
   if (['.golangci.yml', '.golangci.yaml', '.golangci.toml'].some(exists))
     found.lint = { command: 'golangci-lint run', from: '.golangci config' };
@@ -245,6 +281,8 @@ function detectMake(read) {
     };
   if (targets.has('lint'))
     found.lint = { command: 'make lint', from: 'Makefile target "lint"' };
+  if (targets.has('build'))
+    found.build = { command: 'make build', from: 'Makefile target "build"' };
   if (targets.has('test'))
     found.test = {
       command: 'make test',
@@ -256,7 +294,8 @@ function detectMake(read) {
 /**
  * Detects the gates of a host repo from its manifests. PURE: `read(name)` returns the file text or
  * null, `exists(name)` a boolean. Language manifests win over the Makefile, which fills the gaps.
- * Returns the gates, where each came from, and the ones nobody could detect.
+ * Returns the gates, where each came from, and the ones nobody could detect (an optional gate is
+ * there only when detected, and never missing).
  */
 export function detectGates(read, exists) {
   const layers = [
@@ -272,6 +311,12 @@ export function detectGates(read, exists) {
     gates[gate] = hit ? hit.command : null;
     if (hit) detectedFrom[gate] = hit.from;
   }
+  for (const gate of OPTIONAL_GATES) {
+    const hit = layers.map((layer) => layer[gate]).find(Boolean);
+    if (!hit) continue;
+    gates[gate] = hit.command;
+    detectedFrom[gate] = hit.from;
+  }
   const missing = GATES.filter((gate) => !gates[gate]);
   return { gates, detectedFrom, missing };
 }
@@ -303,6 +348,7 @@ export function mergeConfig(detected, host) {
       own.findingsGate === null
         ? null
         : { ...DEFAULTS.findingsGate, ...(own.findingsGate ?? {}) },
+    sparring: { ...DEFAULTS.sparring, ...(own.sparring ?? {}) },
   };
 }
 

package/ring/scripts/fight.mjs

@@ -0,0 +1,238 @@
+// A fight that starts at a sparring: one chronicle from the sparring's opening to the end of every
+// referee bout opened `--from-sparring` it (two out of three falls), one page and one link for all
+// of it. This module reads and writes the sparring's side (`sparring.json`: the chronicle's link and
+// the fight's milestones) and collects the whole fight; the pure rules are sparring-chronicle.mjs.
+// Zero-dependency. It never rewrites the sparring's card: neither the link nor the milestones are
+// on it.
+import { execFileSync } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { commitEvents, localDay, localTime, score } from './chronicle.mjs';
+import { repoBouts, slugFromRemote } from './config.mjs';
+import { LIVE_LOG, SPARRING_FILE, sparringsHome } from './live.mjs';
+import {
+  dedupe,
+  feedEvents,
+  parseBlows,
+  prOpenedEvents,
+  sliceFight,
+  stateEvents,
+  tapeEvents,
+  verdictsOf,
+  withChronicleUrl,
+  withMilestone,
+} from './sparring-chronicle.mjs';
+
+const SLUG = /^[a-z0-9][a-z0-9-]{0,39}$/;
+
+/** `<ring home>/sparrings/<slug>`, refusing anything that is not a sparring slug. */
+export function sparringDirOf(slug, env = process.env) {
+  if (!SLUG.test(slug ?? ''))
+    throw new Error(`"${slug}" is not a sparring slug`);
+  return join(sparringsHome(env), slug);
+}
+
+export function readSparringState(slug, env = process.env) {
+  const file = join(sparringDirOf(slug, env), SPARRING_FILE);
+  if (!existsSync(file))
+    throw new Error(
+      `no sparring "${slug}" (${file}); \`sparring.mjs list\` merges one recorded per repo`,
+    );
+  return JSON.parse(readFileSync(file, 'utf8'));
+}
+
+function writeSparringState(state, env) {
+  writeFileSync(
+    join(sparringDirOf(state.slug, env), SPARRING_FILE),
+    JSON.stringify(state, null, 2) + '\n',
+  );
+}
+
+/** Records (or re-stamps) the fight's chronicle link on the sparring. Returns the new state. */
+export function recordSparringChronicle(
+  slug,
+  url,
+  publishedAt,
+  env = process.env,
+) {
+  const next = withChronicleUrl(
+    readSparringState(slug, env),
+    url,
+    publishedAt,
+    'this fight',
+  );
+  writeSparringState(next, env);
+  return next;
+}
+
+/** Marks a milestone of the fight on the sparring, at this moment. Returns the new state. */
+export function markSparring(slug, kind, note, env = process.env) {
+  const next = withMilestone(readSparringState(slug, env), kind, note);
+  writeSparringState(next, env);
+  return next;
+}
+
+const run = (bin, args, cwd) =>
+  execFileSync(bin, args, {
+    cwd,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    maxBuffer: 64 * 1024 * 1024,
+  });
+
+function option(argv, name) {
+  const index = argv.indexOf(`--${name}`);
+  return index === -1 ? null : argv[index + 1];
+}
+
+/** Every bout opened `--from-sparring` this sparring, in the sparring's repos. */
+export function boutsOfSparring(state, env = process.env) {
+  return (state.repos ?? []).flatMap((entry) =>
+    repoBouts(slugFromRemote(entry.repo), env)
+      .filter((bout) => bout.state.fromSparring === state.slug)
+      .map((bout) => ({ repo: entry.repo, ...bout })),
+  );
+}
+
+/** The sparring's own events: its state, feed, catalogs, git and GitHub. */
+function sparringEvents(dir, state, argv, timeZone, notes) {
+  const read = (name) =>
+    existsSync(join(dir, name)) ? readFileSync(join(dir, name), 'utf8') : '';
+  const catalogs = readdirSync(dir)
+    .filter((name) => /^blows-round-\d+\.md$/.test(name))
+    .sort((a, b) => parseInt(a.slice(12), 10) - parseInt(b.slice(12), 10))
+    .map((name) => parseBlows(read(name), name));
+  const tapes = tapeEvents(catalogs, {
+    openedAt: state.openedAt,
+    timeZone,
+  });
+  const events = [
+    ...stateEvents(state),
+    ...feedEvents(read(LIVE_LOG)),
+    ...tapes.events,
+  ];
+  if (!read(LIVE_LOG))
+    notes.push(
+      'live.jsonl: no feed; repos added and preview looks come only from sparring.json (the last look per repo)',
+    );
+  const lastRound = catalogs.at(-1)?.round ?? 0;
+  if (lastRound > verdictsOf(state).length + 1)
+    notes.push(
+      `sparring.json records ${verdictsOf(state).length} verdict(s) but blows-round-${lastRound}.md exists: the earlier rounds have no recorded verdict`,
+    );
+  for (const entry of state.repos ?? []) {
+    if (!entry.worktree || !existsSync(entry.worktree)) {
+      notes.push(
+        `git: the worktree of ${entry.repo} is gone; its commits are not in the chronicle`,
+      );
+      continue;
+    }
+    events.push(
+      ...commitEvents(
+        run('git', [
+          '-C',
+          entry.worktree,
+          'log',
+          '--no-merges',
+          `--since=${state.openedAt}`,
+          '--format=%H%x09%cI%x09%s',
+          'HEAD',
+        ]),
+      ).map((event) => ({
+        ...event,
+        detail: `${entry.repo} · ${event.detail}`,
+      })),
+    );
+  }
+  const prs = (state.repos ?? []).filter((entry) => entry.pr);
+  if (argv.includes('--no-gh'))
+    notes.push('gh: not consulted; the PRs are dated only by the live feed');
+  if (!argv.includes('--no-gh'))
+    events.push(
+      ...prOpenedEvents(
+        prs.map((entry) => ({
+          repo: entry.repo,
+          number: entry.pr,
+          ...JSON.parse(
+            run('gh', [
+              'pr',
+              'view',
+              String(entry.pr),
+              '-R',
+              entry.repo,
+              '--json',
+              'createdAt,url',
+            ]),
+          ),
+        })),
+      ),
+    );
+  return { events: dedupe(events), gaps: tapes.gaps, catalogs };
+}
+
+/**
+ * The whole fight from a sparring: its first and second falls and, as the third, every bout opened
+ * `--from-sparring` it. `collectBout` and `readExtra` come from play-by-play.mjs.
+ */
+export function collectFight(slug, argv, { collectBout, readExtra }) {
+  const timezone =
+    option(argv, 'tz') ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const dir = sparringDirOf(slug);
+  const state = readSparringState(slug);
+  const notes = [
+    `tapes: the time next to each Tape is read in ${timezone} (the judge's)`,
+  ];
+  const own = sparringEvents(dir, state, argv, timezone, notes);
+  const gaps = [...own.gaps];
+  const extraValue = option(argv, 'extra');
+  const extra = extraValue ? readExtra(extraValue) : { events: [], gaps: [] };
+  gaps.push(...extra.gaps);
+  const bouts = boutsOfSparring(state).map(({ repo, state: bout }) => {
+    const passed = ['--repo', repo, '--tz', timezone];
+    if (argv.includes('--no-gh')) passed.push('--no-gh');
+    return { repo, ...collectBout([String(bout.pr), ...passed]) };
+  });
+  for (const bout of bouts) {
+    gaps.push(...bout.gaps.map((gap) => ({ ...gap, pr: bout.pr })));
+    notes.push(...bout.notes.map((note) => `#${bout.pr}: ${note}`));
+  }
+  const boutEvents = bouts.flatMap((bout) =>
+    bout.events.map((event) => ({ ...event, fall: 3, pr: bout.pr })),
+  );
+  const sliced = sliceFight(
+    [...own.events, ...extra.events, ...boutEvents],
+    bouts.map((bout) => ({ pr: bout.pr, rounds: bout.rounds })),
+  );
+  const events = sliced.events.map((event) => ({
+    ...event,
+    local: localTime(event.at, timezone),
+    day: localDay(event.at, timezone),
+  }));
+  return {
+    sparring: slug,
+    sparringDir: dir,
+    page: join(dir, 'play-by-play.html'),
+    playByPlayUrl: state.playByPlayUrl ?? null,
+    generatedAt: new Date().toISOString(),
+    timezone,
+    hypothesis: state.hypothesis,
+    proof: state.proof,
+    verdict: state.verdict ?? null,
+    repos: (state.repos ?? []).map(({ repo, pr, url }) => ({ repo, pr, url })),
+    bouts: bouts.map((bout) => ({
+      repo: bout.repo,
+      pr: bout.pr,
+      boutDir: bout.boutDir,
+      opened: bout.opened,
+      copilotOnHead: bout.copilotOnHead,
+    })),
+    falls: sliced.falls,
+    rounds: sliced.rounds,
+    events,
+    score: score(events, sliced.rounds),
+    catalogs: own.catalogs,
+    gaps,
+    notes,
+  };
+}

package/ring/scripts/judges-card.mjs

@@ -2,6 +2,10 @@
 // The durable state of a bout and its judges card (logbook and hand-off). Zero-dependency.
 //
 //   node judges-card.mjs open --pr <n> --worktree <abs> --branch <b> --base <base> [--venue <name>]
+//                              [--from-sparring <slug>]   the bout of a sparring's KO: records
+//                              `fromSparring` and marks the hand-off on the sparring (third fall);
+//                              refuses anything but a KO, warns when neither the vestidor nor
+//                              «sin equipo» (no-team) was marked
 //   node judges-card.mjs summary <pr>        everything a new session needs to resume
 //   node judges-card.mjs log <pr> decision|rebound <text>
 //   node judges-card.mjs did <pr> <text>    a "What I did" line in the judges card, stamped by the clock
@@ -14,7 +18,8 @@
 //                                            the contract files, so mask-guard lets that commit land
 //   node judges-card.mjs play-by-play-url <pr> <url>
 //                                            after every publish: records the chronicle's stable
-//                                            Artifact link once and stamps playByPlay.publishedAt
+//                                            Artifact link once and stamps playByPlay.publishedAt;
+//                                            a bout from a sparring shares the fight's one link
 //   node judges-card.mjs title-defense <pr> --until-round <k> | --clear
 //                                            lets mask-guard allow Copilot re-requests and thread
 //                                            replies/resolution for this PR while title-defense runs;
@@ -54,7 +59,13 @@ import {
   unshown,
   withSectionLine,
 } from './findings.mjs';
+import {
+  markSparring,
+  readSparringState,
+  recordSparringChronicle,
+} from './fight.mjs';
 import { record } from './live.mjs';
+import { handOffWarning, withChronicleUrl } from './sparring-chronicle.mjs';
 import { DEFAULT_VENUE } from './venues.mjs';
 
 export const TEMPLATES = join(RING_ROOT, 'skills', 'referee', 'templates');
@@ -137,11 +148,13 @@ function open(argv) {
     branch,
     base,
     venue = DEFAULT_VENUE,
+    'from-sparring': fromSparring,
   } = options(argv.filter((arg) => arg !== '--allow-empty-contract'));
   if (!pr || !worktree || !branch || !base)
     throw new Error(
-      'usage: open --pr <n> --worktree <abs path> --branch <head branch> --base <stack base> [--venue <name>] [--allow-empty-contract]',
+      'usage: open --pr <n> --worktree <abs path> --branch <head branch> --base <stack base> [--venue <name>] [--from-sparring <slug>] [--allow-empty-contract]',
     );
+  if (fromSparring) checkKo(fromSparring);
   if (!isAbsolute(worktree))
     throw new Error('--worktree must be an absolute path');
   if (!VENUE_NAMES.includes(venue))
@@ -162,8 +175,11 @@ function open(argv) {
     lastReviewed: git(worktree, ['rev-parse', 'HEAD']),
     active: true,
     venue,
+    ...(fromSparring ? { fromSparring } : {}),
   };
   writeState(dir, state);
+  if (fromSparring)
+    markSparring(fromSparring, 'referee', `#${pr} ${repoSlug(worktree)}`);
   writeFileSync(
     join(dir, 'decisions.md'),
     `# Decisions for #${pr}\n\nOne line each: id · date · who · decision · what it affects.\n\n`,
@@ -465,27 +481,55 @@ function titleDefense([pr, ...argv]) {
 
 /**
  * Records the play-by-play page's link, and stamps `playByPlay.publishedAt` on every publish to it.
- * The same link again is a republish; a different one is refused. PURE.
+ * The same link again is a republish; a different one is refused. A bout from a sparring
+ * (`fightUrl`, the sparring's link) shares the fight's one link. PURE.
  */
 export function withPlayByPlayUrl(
   state,
   url,
   publishedAt = new Date().toISOString(),
+  fightUrl = null,
 ) {
-  if (!/^https:\/\/claude\.ai\//.test(String(url)))
-    throw new Error('the play-by-play link must be a claude.ai artifact URL');
-  if (state.playByPlayUrl && state.playByPlayUrl !== url)
+  const seeded = state.playByPlayUrl ?? fightUrl;
+  return withChronicleUrl(
+    seeded ? { ...state, playByPlayUrl: seeded } : state,
+    url,
+    publishedAt,
+    state.playByPlayUrl ? 'this bout' : 'this fight',
+  );
+}
+
+/**
+ * A bout opens from a sparring only once the judge called it KO. It warns, without refusing, when
+ * the KO skipped both the vestidor and «sin equipo».
+ */
+function checkKo(slug) {
+  const state = readSparringState(slug);
+  const call = state.verdict?.call ?? 'no verdict';
+  if (call !== 'ko')
     throw new Error(
-      `this bout already has its chronicle at ${state.playByPlayUrl}; republish to that link instead of creating another`,
+      `sparring "${slug}" is not a KO (${call}): only a KO hands its branch to a bout`,
     );
-  return { ...state, playByPlayUrl: url, playByPlay: { publishedAt } };
+  const warning = handOffWarning(state);
+  if (warning) console.error(`warning: ${warning}`);
 }
 
 function playByPlayUrl([pr, url]) {
   if (!pr || !url) throw new Error('usage: play-by-play-url <pr> <url>');
   const dir = currentDir(pr);
-  const next = withPlayByPlayUrl(readState(dir), url);
+  const state = readState(dir);
+  const fight = state.fromSparring
+    ? readSparringState(state.fromSparring)
+    : null;
+  const next = withPlayByPlayUrl(
+    state,
+    url,
+    undefined,
+    fight?.playByPlayUrl ?? null,
+  );
   writeState(dir, next);
+  if (fight)
+    recordSparringChronicle(fight.slug, url, next.playByPlay.publishedAt);
   record(dir, {
     actor: 'arbitro',
     state: 'done',

package/ring/scripts/live-hook.mjs

@@ -2,10 +2,10 @@
 // Hook on PreToolUse / PostToolUse / PostToolUseFailure (Agent, AskUserQuestion, Bash) and
 // SubagentStop: feeds the bout's live.jsonl so Ringside shows who is acting. Zero-dependency.
 //
-// - Agent: a subagent of type ring:wrestler or ring:cornerman, or whose description starts with
-//   "Wrestler:" / "Cornerman:" (also "Luchador:" / "Esquinero:"), marks the luchador or the
-//   esquinero active, labelled with the first three words of the description. A background agent
-//   stays active until its SubagentStop.
+// - Agent: a subagent of type ring:wrestler, ring:cornerman or ring:rudo, or whose description
+//   starts with "Wrestler:" / "Cornerman:" / "Rudo:" (also "Luchador:" / "Esquinero:"), marks the
+//   luchador, the esquinero or the rudo active, labelled with the first three words of the
+//   description. A background agent stays active until its SubagentStop.
 // - AskUserQuestion: the juez waits on the human until the question is answered.
 // - Bash: a command that EXECUTES what a declared monitor matches (`.claude/ring.json` → monitors;
 //   heredoc bodies and quoted text don't count) marks it active until the command ends, labelled
@@ -21,6 +21,11 @@
 // so a session that only looks at a bout never shows up as its referee. Subagents share their parent's session_id, so the wrestler and the cornermen of a
 // registered referee count too. Any other session working in the same repo is ignored.
 //
+// A session with no bout of its own feeds the open sparring it registered instead
+// (`sparrings/<slug>/live.jsonl`; `sparring.mjs` registers the session that runs it, except `list`):
+// only actor events (rudo, juez), never a repo's monitors. A sparring script never registers the
+// session in a bout.
+//
 // It ALWAYS exits 0 and prints nothing: the feed is decoration and must never block or slow a tool.
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
@@ -28,6 +33,7 @@ import { join } from 'node:path';
 import { isMain, loadConfig, projectDir } from './config.mjs';
 import {
   findBout,
+  findSparring,
   LIVE_LOG,
   record,
   registerSession,
@@ -42,14 +48,21 @@ import {
 } from './monitors.mjs';
 
 const AGENT_TOOLS = ['Agent', 'Task'];
-const TYPES = { 'ring:wrestler': 'luchador', 'ring:cornerman': 'esquinero' };
-const PREFIX = /^\s*(wrestler|luchador|cornerman|esquinero)\s*[:·—-]\s*/i;
+const TYPES = {
+  'ring:wrestler': 'luchador',
+  'ring:cornerman': 'esquinero',
+  'ring:rudo': 'rudo',
+};
+const PREFIX = /^\s*(wrestler|luchador|cornerman|esquinero|rudo)\s*[:·—-]\s*/i;
 const PREFIX_ACTOR = {
   wrestler: 'luchador',
   luchador: 'luchador',
   cornerman: 'esquinero',
   esquinero: 'esquinero',
+  rudo: 'rudo',
 };
+/** The actors an Agent call marks: what a SubagentStop may close. */
+const AGENT_ACTORS = Object.values(PREFIX_ACTOR);
 
 /** The ring actor of an Agent call, or null when it is not one of the ring's. PURE. */
 export function classifyAgent(input) {
@@ -162,7 +175,7 @@ export function stoppedAgent(lines, agentId, agentType) {
   for (const line of lines) {
     try {
       const event = JSON.parse(line);
-      if (event.id && ['luchador', 'esquinero'].includes(event.actor))
+      if (event.id && AGENT_ACTORS.includes(event.actor))
         latest.set(event.id, event);
     } catch {
       // A torn line is skipped.
@@ -245,9 +258,10 @@ function eventsFor(input) {
 }
 
 // Only a segment that runs node acts: naming a ring script (`git add …/scripts/x.mjs`, `cat`) does not.
+// A sparring script acts on a sparring, never on a bout: it registers itself there.
 const RUNS_NODE = /(?:^|\s)node(?:\s|$)/;
 const READS_ONLY =
-  /\/scripts\/(?:config\.mjs|judges-card\.mjs["']?\s+(?:list|path)(?![\w-]))/;
+  /\/scripts\/(?:config\.mjs|sparring\.mjs|judges-card\.mjs["']?\s+(?:list|path)(?![\w-]))/;
 
 /** Does a command run a ring script that acts on the bout, not one that only reads it? PURE. */
 export const actsOnBout = (command) =>
@@ -266,17 +280,30 @@ const registersSession = (input) =>
   input.hook_event_name === 'PreToolUse' &&
   actsOnBout(input.tool_input?.command);
 
+/**
+ * Where this session's events go: its bout when it is one of the bout's sessions, else the open
+ * sparring it registered. Null when it has neither.
+ */
+function feedOf(input, registering) {
+  const hint = input.tool_input?.description;
+  const bout = findBout({ cwd: input.cwd, hint });
+  if (bout && registering)
+    registerSession(bout, input.session_id, input.agent_type ?? 'referee');
+  if (bout && sessionRegistered(bout, input.session_id))
+    return { dir: bout, isBout: true };
+  const sparring = findSparring({ sessionId: input.session_id, hint });
+  return sparring ? { dir: sparring, isBout: false } : null;
+}
+
 export function handle(input) {
   const registering = registersSession(input);
   const make = eventsFor(input);
   if (!make && !registering) return;
-  const dir = findBout({ cwd: input.cwd, hint: input.tool_input?.description });
-  if (!dir) return;
-  if (registering)
-    registerSession(dir, input.session_id, input.agent_type ?? 'referee');
-  if (!make || !sessionRegistered(dir, input.session_id)) return;
-  for (const event of make(dir))
-    record(dir, { ...event, session: input.session_id });
+  const feed = feedOf(input, registering);
+  if (!make || !feed) return;
+  // A sparring carries actors only: monitors belong to a repo, not to a sparring.
+  for (const event of make(feed.dir).filter((e) => feed.isBout || e.actor))
+    record(feed.dir, { ...event, session: input.session_id });
 }
 
 if (isMain(import.meta.url)) {