@thebattlearena/corner 0.9.1-beta.70 → 0.10.1-beta.78

package/ring/scripts/bout-stats.mjs

@@ -0,0 +1,360 @@
+#!/usr/bin/env node
+// The numbers of a bout for the final edition of its chronicle: what the lines are made of, the
+// rhythm of the commits (by day, by hour, by conventional type) and the referee's book (decisions,
+// rebounds, findings, contracts, fouls, round-bells). Read-only: git in the wrestler's worktree and
+// the bout dir. The pure parts are exported and tested; the CLI prints JSON or, with --html, the
+// "El cierre en números" block ready for the chronicle template. Zero-dependency.
+//
+//   node bout-stats.mjs <pr> [--tz <Area/City>] [--repo <owner/name>] [--html] [--lang es|en]
+//                            [--moments <json|file>]
+//
+// --moments takes an array of { at, title, tag } (tag: one of the chronicle's event types); the
+// skill picks them from the play-by-play JSON. Every time comes from the records, never invented.
+import { execFileSync } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+
+import { renderStats } from './bout-stats-render.mjs';
+import {
+  classifyDecision,
+  foulTarget,
+  parseDecisionLine,
+  parseReboundLine,
+} from './chronicle.mjs';
+import {
+  boutDir,
+  isMain,
+  projectDir,
+  readState,
+  repoSlug,
+  slugFromRemote,
+} from './config.mjs';
+import { counts, readLedger } from './findings.mjs';
+
+const LOCKFILES = [
+  'package-lock.json',
+  'yarn.lock',
+  'pnpm-lock.yaml',
+  'bun.lockb',
+  'npm-shrinkwrap.json',
+  'Cargo.lock',
+  'go.sum',
+  'poetry.lock',
+  'Pipfile.lock',
+  'Gemfile.lock',
+  'composer.lock',
+];
+const TEST_PATH = /(^|\/)(__tests__|__mocks__|__fixtures__|tests?|spec)\//;
+const TEST_FILE =
+  /\.(test|spec|e2e-spec)\.[cm]?[jt]sx?$|_test\.(go|py)$|(^|\/)test_[^/]+\.py$/;
+const CODE_FILE =
+  /\.([cm]?[jt]sx?|py|go|rb|java|kt|kts|swift|rs|cs|php|vue|svelte|scala|ex|exs|dart|m|mm|c|cc|cpp|h|hpp|sql)$/;
+
+/** Which part of the bout a changed path belongs to: tests, lockfile, code or other. PURE. */
+export function lineBucket(path) {
+  const file = String(path);
+  if (LOCKFILES.includes(basename(file))) return 'lockfile';
+  if (TEST_PATH.test(file) || TEST_FILE.test(file)) return 'tests';
+  if (CODE_FILE.test(file)) return 'code';
+  return 'other';
+}
+
+/**
+ * Totals of `git diff --numstat` output, split by bucket. A binary file ("-" counts) counts as a
+ * file with no lines. A rename (`a => b`, `{a => b}`) is bucketed by its new path. PURE.
+ */
+export function numstatTotals(text) {
+  const empty = () => ({ added: 0, deleted: 0, files: 0 });
+  const buckets = {
+    code: empty(),
+    tests: empty(),
+    lockfile: empty(),
+    other: empty(),
+  };
+  const total = empty();
+  for (const line of String(text).split('\n').filter(Boolean)) {
+    const [added, deleted, ...rest] = line.split('\t');
+    const path = rest
+      .join('\t')
+      .replace(/\{[^{}]* => ([^{}]*)\}/g, '$1')
+      .replace(/^.* => /, '');
+    const bucket = buckets[lineBucket(path)];
+    const plus = Number(added) || 0;
+    const minus = Number(deleted) || 0;
+    for (const target of [bucket, total]) {
+      target.added += plus;
+      target.deleted += minus;
+      target.files += 1;
+    }
+  }
+  return { ...total, buckets };
+}
+
+const TYPE_ORDER = [
+  'feat',
+  'fix',
+  'refactor',
+  'test',
+  'docs',
+  'perf',
+  'style',
+  'build',
+  'ci',
+  'chore',
+];
+
+/** The conventional type of a commit subject (`feat(mobile): …` → feat), or "other". PURE. */
+export function commitType(subject) {
+  const type = /^([a-z]+)(\([^)]*\))?!?:/i
+    .exec(String(subject).trim())?.[1]
+    ?.toLowerCase();
+  return TYPE_ORDER.includes(type) ? type : 'other';
+}
+
+const dayKey = (at, timeZone) =>
+  new Intl.DateTimeFormat('en-CA', {
+    timeZone,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+  }).format(new Date(at));
+const hourOf = (at, timeZone) =>
+  Number(
+    new Intl.DateTimeFormat('en-GB', {
+      timeZone,
+      hour: '2-digit',
+      hour12: false,
+    })
+      .format(new Date(at))
+      .replace('24', '00'),
+  );
+
+/** Days between two YYYY-MM-DD keys, both included, so a quiet day still shows as zero. PURE. */
+function daysBetween(first, last) {
+  const days = [];
+  for (
+    let at = Date.parse(`${first}T12:00:00Z`);
+    at <= Date.parse(`${last}T12:00:00Z`);
+    at += 86_400_000
+  )
+    days.push(new Date(at).toISOString().slice(0, 10));
+  return days;
+}
+
+/**
+ * The rhythm of `git log --format=%cI%x09%s` lines in a time zone: commits per local day (quiet
+ * days included), per local hour (24 slots) and per conventional type (fixed order, "other" last).
+ * PURE.
+ */
+export function commitRhythm(log, timeZone) {
+  const commits = String(log)
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => {
+      const [at, ...subject] = line.split('\t');
+      return { at, subject: subject.join('\t') };
+    })
+    .filter((commit) => !Number.isNaN(Date.parse(commit.at)));
+  const byHour = Array.from({ length: 24 }, () => 0);
+  const perDay = new Map();
+  const perType = new Map();
+  for (const commit of commits) {
+    byHour[hourOf(commit.at, timeZone)] += 1;
+    const day = dayKey(commit.at, timeZone);
+    perDay.set(day, (perDay.get(day) ?? 0) + 1);
+    const type = commitType(commit.subject);
+    perType.set(type, (perType.get(type) ?? 0) + 1);
+  }
+  const keys = [...perDay.keys()].sort();
+  const byDay = keys.length
+    ? daysBetween(keys[0], keys.at(-1)).map((day) => ({
+        day,
+        n: perDay.get(day) ?? 0,
+      }))
+    : [];
+  const byType = [...TYPE_ORDER, 'other']
+    .filter((type) => perType.has(type))
+    .map((type) => ({ type, n: perType.get(type) }));
+  return { total: commits.length, byDay, byHour, byType };
+}
+
+/**
+ * The referee's book from the ledgers: decisions (distinct ids, the judge's among them), contracts
+ * the judge approved, fouls, rebounds (closed and open), first and last recorded time. PURE.
+ */
+export function ledgerCounts(decisionsText, reboundsText) {
+  const decisions = String(decisionsText)
+    .split('\n')
+    .map(parseDecisionLine)
+    .filter((entry) => entry?.id);
+  const rebounds = String(reboundsText)
+    .split('\n')
+    .map(parseReboundLine)
+    .filter(Boolean);
+  const ids = (list) => new Set(list.map((entry) => entry.id)).size;
+  const fouls = decisions.filter(
+    (entry) => classifyDecision(entry) === 'falta',
+  );
+  // As applyFoulReferences in the chronicle: a line marking an earlier decision of the ledger
+  // counts as that decision's foul, so two marks of the same D<n> are one foul.
+  const logged = new Set(decisions.map((entry) => entry.id));
+  const foulOf = (entry) => {
+    const target = foulTarget(entry.text);
+    return target && target !== entry.id && logged.has(target)
+      ? target
+      : entry.id;
+  };
+  // ISO times with different offsets do not sort as strings: sort by the instant.
+  const times = [...decisions, ...rebounds]
+    .map((entry) => entry.at)
+    .filter((at) => at && !Number.isNaN(Date.parse(at)))
+    .sort((a, b) => Date.parse(a) - Date.parse(b));
+  return {
+    decisions: ids(decisions.filter((entry) => /^D\d+$/.test(entry.id))),
+    judgeDecisions: ids(
+      decisions.filter((entry) => classifyDecision(entry) === 'juez'),
+    ),
+    contracts: ids(
+      decisions.filter((entry) => /contract approved/i.test(entry.text)),
+    ),
+    fouls: new Set(fouls.map(foulOf)).size,
+    rebounds: {
+      total: rebounds.length,
+      closed: rebounds.filter((entry) => entry.closed).length,
+    },
+    first: times[0] ?? null,
+    last: times.at(-1) ?? null,
+  };
+}
+
+/** Round numbers from the bout dir's `round-<n>-<slug>.md` files (one per round-bell). PURE. */
+export function roundBells(files) {
+  return new Set(
+    files.map((file) => /^round-(\d+)-/.exec(file)?.[1]).filter(Boolean),
+  ).size;
+}
+
+/** "134 h 54" between two ISO times. PURE. */
+export function durationLabel(first, last) {
+  if (!first || !last) return null;
+  const minutes = Math.max(
+    0,
+    Math.floor((Date.parse(last) - Date.parse(first)) / 60_000),
+  );
+  return `${Math.floor(minutes / 60)} h ${String(minutes % 60).padStart(2, '0')}`;
+}
+
+/** Moments for the highlight reel: { at, title, tag } sorted by time, the time checked. PURE. */
+export function readMoments(items) {
+  if (!Array.isArray(items))
+    throw new Error('--moments: expected a JSON array');
+  return items
+    .map((item) => {
+      if (Number.isNaN(Date.parse(item?.at)))
+        throw new Error(`--moments: "${item?.title}" has no valid time`);
+      return {
+        at: item.at,
+        title: String(item.title ?? ''),
+        tag: String(item.tag ?? 'campana'),
+      };
+    })
+    .sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+}
+
+const run = (args, cwd) =>
+  execFileSync('git', ['-C', cwd, ...args], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    maxBuffer: 64 * 1024 * 1024,
+  });
+
+/** Everything above for one bout, read from git and its dir. */
+export function collectStats(dir, timeZone) {
+  const state = readState(dir);
+  const read = (name) =>
+    existsSync(join(dir, name)) ? readFileSync(join(dir, name), 'utf8') : '';
+  const notes = [];
+  const book = ledgerCounts(read('decisions.md'), read('rebounds.md'));
+  const worktreeOk = Boolean(state.worktree && existsSync(state.worktree));
+  if (!worktreeOk)
+    notes.push(
+      `git: the wrestler's worktree ${state.worktree} is gone; lines and commits are missing`,
+    );
+  const base = `origin/${state.base}`;
+  const lines = worktreeOk
+    ? numstatTotals(
+        run(['diff', '--numstat', `${base}...HEAD`], state.worktree),
+      )
+    : null;
+  const rhythm = worktreeOk
+    ? commitRhythm(
+        run(
+          ['log', '--no-merges', '--format=%cI%x09%s', `${base}..HEAD`],
+          state.worktree,
+        ),
+        timeZone,
+      )
+    : null;
+  return {
+    pr: state.pr ?? null,
+    timezone: timeZone,
+    head: worktreeOk
+      ? run(['rev-parse', '--short=9', 'HEAD'], state.worktree).trim()
+      : null,
+    duration: {
+      first: book.first,
+      last: book.last,
+      label: durationLabel(book.first, book.last),
+    },
+    lines,
+    rhythm,
+    book: {
+      ...book,
+      findings: counts(readLedger(dir)),
+      roundBells: roundBells(readdirSync(dir)),
+    },
+    notes,
+  };
+}
+
+function option(argv, name) {
+  const index = argv.indexOf(`--${name}`);
+  return index === -1 ? null : argv[index + 1];
+}
+
+function main([pr, ...argv]) {
+  if (!pr)
+    throw new Error(
+      'usage: bout-stats.mjs <pr> [--tz <zone>] [--repo <owner/name>] [--html] [--lang es|en] [--moments <json|file>]',
+    );
+  const repo = option(argv, 'repo');
+  const timeZone =
+    option(argv, 'tz') ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const dir = boutDir(repo ? slugFromRemote(repo) : repoSlug(projectDir()), pr);
+  if (!existsSync(join(dir, 'state.json')))
+    throw new Error(`no bout for #${pr} in ${dir}`);
+  const stats = collectStats(dir, timeZone);
+  if (!argv.includes('--html')) return JSON.stringify(stats, null, 2);
+  const momentsValue = option(argv, 'moments');
+  const moments = momentsValue
+    ? readMoments(
+        JSON.parse(
+          /^\s*\[/.test(momentsValue)
+            ? momentsValue
+            : readFileSync(momentsValue, 'utf8'),
+        ),
+      )
+    : [];
+  return renderStats(stats, { lang: option(argv, 'lang') ?? 'es', moments });
+}
+
+if (isMain(import.meta.url)) {
+  try {
+    console.log(main(process.argv.slice(2)));
+  } catch (error) {
+    console.error(
+      `bout-stats: ${String(error.stderr || error.message).trim()}`,
+    );
+    process.exit(1);
+  }
+}

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);
+  });
+}