@xsft/panels 0.7.2 → 0.8.1

package/README.md

@@ -5,12 +5,10 @@
 ```text
 panels run <panel> [target...] [flags]
 
-<panel>           owner/name, or owner/name/vN to pin version N
+<panel>           owner/name for the latest version, or owner/name@N to pin version N
 [target...]       free words, joined with single spaces into one target
 
 --harness <name>  claude | codex                     default: claude if installed, else codex
---brief <file>    the brief                          default: none
---sources <path>  a doc folder, a repository, or an app URL; repeat the flag for each
 --yolo            the judges skip every permission question (claude --dangerously-skip-permissions, codex --yolo).
                   Without it, a judge asks its own questions in its tab. Without a terminal, the flag is required.
 --                end of the flags; each later word joins the target
@@ -20,20 +18,22 @@ exit 1  fail: every judge answered, and one or more criteria scored below 4
 exit 2  error: bad flags, no target, panel not found, harness missing, or a judge failed
 ```
 
-CAUTION: A judge gets no tool block and no sandbox from the CLI. Without `--yolo`, the harness asks its own permission questions in the judge tab. With `--yolo`, nothing asks: the judge can read, write, run commands, and reach the network as you, and the system prompt (do not write or change files, no sub-agents, no forms, no posts) is the only guard. Do not run a panel on a repository that you do not trust.
+CAUTION: A judge gets no tool block and no sandbox from the CLI. Without `--yolo`, the harness asks its own permission questions in the judge tab. With `--yolo`, nothing asks: the judge can read, write, run commands, and reach the network as you, and the system prompt (do not write or change files of the target, no forms, no posts) is the only guard. Do not run a panel on a repository that you do not trust.
 
 ```sh
-npx @xsft/panels run xsft/marketing-site https://example.com --brief docs/brief.md --harness claude
-npx @xsft/panels run xsft/marketing-site/v6 . at http://localhost:4321 --sources docs --harness codex
+npx @xsft/panels run xsft/marketing-site https://example.com --harness claude --yolo
+npx @xsft/panels run xsft/marketing-site@8 . at http://localhost:4321 --harness codex
 ```
 
-Run the command in the folder of the product. Each judge starts in that folder, so `.`, a branch, and relative paths resolve there. The CLI does not test, fetch, or change the target. Four judges run at a time. A judge gets 20 minutes.
+Run the command in the folder of the product. Each judge starts in that folder, so `.`, a branch, and relative paths resolve there. The CLI does not test, fetch, or change the target. Four judges run at a time. A judge gets 20 minutes. The criteria of a panel say what to assess; the system prompt of the CLI (`prompts/judge-system-prompt.txt`) carries how to judge and the four levels: 4 Met, 3 Almost met, 2 Falls short, 1 Fails. Only 4 passes.
 
 ## Terminal mode
 
 On a terminal, `panels run` shows the overview, and each judge runs in its interactive harness in a pseudo-terminal inside the command. Each judge writes `judges/N/answer.json` and stays open. The overview writes the report when each judge has an answer or an error, and the command exits from `report.json` when you quit. Without a terminal, the judges run in the background (`claude -p`, `codex exec`), and stdout prints `N/4  name` and the verdict of each criterion, then the report path. Plain mode needs `--yolo`, because a background judge cannot answer a question; without it the command exits 2.
 
-The overview fills the terminal: a header line with the run (panel and target at the left, the version, the harness, and the elapsed time at the right edge) and two columns from 100 columns up (stacked below that). The left column lists the criteria: rank, name, score (4 green, 3 ink, 2 yellow, 1 red, a grey `·/4` until the score arrives), the time the judge has run, and the tokens it used, with a total row at the bottom under a hairline: the scores added as quarters over the number of criteria, the longest judge time, and the tokens added up. The right column shows the criterion under the cursor: its name, score, and level word, the verdict paragraph, the one-line description and the body of the criterion as plain text, and at the bottom the key line and a grey fact line with the judge number, the harness, the time, and the answer file. `enter` moves the focus into that pane (an orange bar marks it): `↑` and `↓` scroll one line, `PgUp` and `PgDn` a page, `esc` or `enter` return to the list. While a judge runs, its detail shows the word judging in big letters (figlet, ANSI Shadow) with the wave over it and the time under it. One soft wave sweeps across the running rows. On the overview, `↑` and `↓` move the cursor, `r` restarts the judge of the cursor row with its harness (its answer is dropped and the report is written again when it finishes), and `h` flips that harness between `claude` and `codex`. The page never says pass or fail; the total is the result.
+The overview fills the terminal: a header line with the run (panel and target at the left, the version, the harness, and the elapsed time at the right edge) and two columns from 100 columns up (stacked below that). The left column lists the criteria: rank, name, score (4 green, 3 ink, 2 yellow, 1 red, a grey `·/4` until the score arrives), the time the judge has run, and the tokens it used, with a total row at the bottom under a hairline: the scores added as quarters over the number of criteria, the longest judge time, and the tokens added up. The right column shows the criterion under the cursor: its name, score, and level word, then a sub tab bar, `Verdict │ Criterion`, and on the last row the key line. `tab` switches the sub tab: Verdict shows the verdict paragraph, Criterion the description and the body of the criterion as plain text. `enter` moves the focus into the pane (an orange bar marks it): `↑` and `↓` scroll one line, `PgUp` and `PgDn` a page, `esc` or `enter` return to the list. While a judge runs, the Verdict sub tab shows a piece of halftone art in a square frame, generated from a seed per criterion for the run (a half disc, a disc, a ring, a quarter disc, a band, or two discs), breathing, centred in the pane, with the time under it. One soft wave sweeps across the running rows and the art. On the overview, `↑` and `↓` move the cursor. The page never says pass or fail; the total is the result.
+
+`r` opens a small modal that asks before it restarts the judge of the cursor row (the current answer is discarded; `enter` on restart runs it, `esc` cancels). `h` opens a modal that picks the harness of that judge, `claude` or `codex`, for its next restart. While a modal is open, every other key is ignored.
 
 A tab strip on the last three lines shows a hairline, the tabs (`Overview`, then the name of each criterion, split by a grey `│`, cut to the first word when they do not fit), and a status line with the progress, the elapsed time, and the keys. The strip is the navigation area. With the focus on the strip, `←` and `→` move the active tab and switch the view, `1` to `9` jump to a started judge by list order, `0` to the overview, `enter` gives the focus to the judge, and `q` quits; while a judge still runs, the first `q` asks and a second `q` quits. With the focus on a judge, each key goes to the judge, and `ctrl-q` gives the focus back to the strip. The overview takes no text, so the strip keeps the focus there. A harness that has not seen the folder asks whether to trust it. The first judge starts alone; press `1`, answer, and the other judges start.
 
@@ -50,7 +50,7 @@ The last line on stdout is the path of `report.json`.
 ## Skipped
 
 - Run upload to cross.software, and `--no-upload`.
-- `--version`: `owner/name/vN` pins a version.
+- `--version`: `owner/name@N` pins a version. The CLI fetches the panel from the api on every run and never caches it.
 - `--out`: the run folder is fixed.
 - `--json`: stdout ends with the path of `report.json`.
 - `--concurrency`: fixed at 4.

package/bin/panels.js

@@ -29,7 +29,7 @@ const EXIT = { pass: 0, fail: 1, error: 2 };
 
 /** Runs the judges in the overview, and exits from report.json when the engineer quits. Prints nothing. */
 async function runOnTerminal({ panel, runDir, harness, cwd, args }) {
-  await runTable({ panel, runDir, harness, cwd, target: args.target, brief: args.brief, sources: args.sources, yolo: args.yolo });
+  await runTable({ panel, runDir, harness, cwd, target: args.target, yolo: args.yolo });
   const reportPath = join(runDir, 'report.json');
   if (!existsSync(reportPath)) return 2;
   return EXIT[JSON.parse(readFileSync(reportPath, 'utf8')).status];
@@ -77,8 +77,6 @@ async function main() {
     harness,
     cwd,
     target: args.target,
-    brief: args.brief,
-    sources: args.sources,
     yolo: true,
   }));
   const report = buildReport({ panel, target: args.target, outcomes });

package/lib/args.js

@@ -2,12 +2,10 @@ import { parseArgs } from 'node:util';
 
 export const SYNOPSIS = `panels run <panel> [target...] [flags]
 
-<panel>           owner/name, or owner/name/vN to pin version N
+<panel>           owner/name for the latest version, or owner/name@N to pin version N
 [target...]       free words, joined with single spaces into one target
 
 --harness <name>  claude | codex                     default: claude if installed, else codex
---brief <file>    the brief                          default: none
---sources <path>  a doc folder, a repository, or an app URL; repeat the flag for each
 --yolo            the judges skip every permission question (claude --dangerously-skip-permissions, codex --yolo).
                   Without it, a judge asks its own questions in its tab. Without a terminal, the flag is required.
 --                end of the flags; each later word joins the target
@@ -18,13 +16,11 @@ exit 2  error: bad flags, no target, panel not found, harness missing, or a judg
 
 const options = {
   harness: { type: 'string' },
-  brief: { type: 'string' },
-  sources: { type: 'string', multiple: true },
   yolo: { type: 'boolean' },
   help: { type: 'boolean' },
 };
 
-const PANEL = /^([a-z0-9-]+)\/([a-z0-9-]+)(?:\/v([1-9]\d*))?$/;
+const PANEL = /^([a-z0-9-]+)\/([a-z0-9-]+)(?:@([1-9]\d*))?$/;
 
 /** Returns the run options, { help: true }, { usage: true }, or { error } with a one-line message. */
 export function parse(argv) {
@@ -38,15 +34,13 @@ export function parse(argv) {
   const [command, panel, ...words] = positionals;
   if (command !== 'run' || panel === undefined) return { usage: true };
   const match = PANEL.exec(panel);
-  if (!match) return { error: `bad panel ${panel}: use owner/name or owner/name/vN` };
+  if (!match) return { error: `bad panel ${panel}: use owner/name or owner/name@N` };
   if (words.length === 0) return { error: 'no target: type what the panel reviews after the panel name, such as a URL, a path, or a branch' };
   if (values.harness !== undefined && !['claude', 'codex'].includes(values.harness)) return { error: `--harness needs claude or codex, not ${values.harness}` };
   return {
     panel: { owner: match[1], name: match[2], version: match[3] && Number(match[3]) },
     target: words.join(' '),
     harness: values.harness,
-    brief: values.brief,
-    sources: values.sources ?? [],
     yolo: Boolean(values.yolo),
   };
 }

package/lib/judge.js

@@ -1,26 +1,24 @@
 import { spawn } from 'node:child_process';
 import { closeSync, mkdirSync, openSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join, relative, resolve, sep } from 'node:path';
+import { join } from 'node:path';
 
 const { criterion: CRITERION } = JSON.parse(readFileSync(new URL('../schema/report.json', import.meta.url), 'utf8')).$defs;
 const SYSTEM_PROMPT = readFileSync(new URL('../prompts/judge-system-prompt.txt', import.meta.url), 'utf8');
 export const MINUTES_PER_CRITERION = 20;
 // A judge gets no tool list, no permission mode, and no sandbox flag: the harness defaults, and its own questions
 // in its tab. With --yolo, the judge skips every question: no sandbox, nothing is denied, nothing asks. The system
-// prompt holds the rules on writing files, sub-agents, forms, and messages. exec resume takes no sandbox flag,
+// prompt holds the rules on writing files, forms, and messages. exec resume takes no sandbox flag,
 // so it gets the same setting as config values.
 // codex --yolo is the alias of --dangerously-bypass-approvals-and-sandbox.
 const yoloFlags = (yolo, harness) => (!yolo ? [] : harness === 'claude' ? ['--dangerously-skip-permissions'] : ['--yolo']);
 const CODEX_RESUME_YOLO = ['-c', 'sandbox_mode="danger-full-access"', '-c', 'approval_policy="never"'];
 
 /**
- * The user message of a judge. criterion is { rank, name, description, body }. Each part sits in a tag,
- * because a body is markdown with headings of its own.
+ * The user message of a judge: the criterion and the target. criterion is { rank, name, description, body }.
+ * Each part sits in a tag, because a body is markdown with headings of its own.
  */
-export function userMessage(criterion, { target, brief, sources }) {
-  const parts = [`<criterion rank="${criterion.rank}" name="${criterion.name}">\nDescription: ${criterion.description}\n\n${criterion.body}\n</criterion>`];
-  parts.push(`<target>\n${target}\n</target>`, `<brief>\n${brief ?? 'none supplied'}\n</brief>`, `<sources>\n${sources.length ? sources.join('\n') : 'none'}\n</sources>`);
-  return `${parts.join('\n\n')}\n`;
+export function userMessage(criterion, { target }) {
+  return `<criterion rank="${criterion.rank}" name="${criterion.name}">\nDescription: ${criterion.description}\n\n${criterion.body}\n</criterion>\n\n<target>\n${target}\n</target>\n`;
 }
 
 /** The output schema of a judge: one criterion object { name, score, verdict }, with the name fixed. */
@@ -41,12 +39,6 @@ export function check(answer, criterion) {
   return errors;
 }
 
-/** The folders of the brief and the path sources that are outside cwd. A Claude judge cannot read them without --add-dir. */
-export function addDirs(cwd, brief, sources) {
-  const paths = [brief && dirname(resolve(cwd, brief)), ...sources.filter((s) => !/^https?:\/\//.test(s)).map((s) => resolve(cwd, s))];
-  return [...new Set(paths.filter(Boolean))].filter((p) => relative(cwd, p).split(sep)[0] === '..');
-}
-
 function exec(command, args, { cwd, stdin, timeout }) {
   return new Promise((done) => {
     const child = spawn(command, args, { cwd, timeout, stdio: [stdin, 'pipe', 'pipe'] });
@@ -65,7 +57,6 @@ function exec(command, args, { cwd, stdin, timeout }) {
 async function askClaude(j, prompt, session) {
   const args = [
     '-p', ...yoloFlags(j.yolo, 'claude'),
-    ...j.addDirs.flatMap((d) => ['--add-dir', d]),
     '--system-prompt', SYSTEM_PROMPT,
     '--json-schema', JSON.stringify(j.schema),
     '--output-format', 'json',
@@ -109,13 +100,13 @@ export function parseAnswer(text) {
  * Runs one judge to the end: the first answer, and one re-ask when check() rejects it.
  * Returns { answer } or { error }. command is the harness binary; the tests pass a stub.
  */
-export async function runJudge({ dir, criterion, harness, cwd, target, brief, sources, yolo = false }, command = harness) {
+export async function runJudge({ dir, criterion, harness, cwd, target, yolo = false }, command = harness) {
   mkdirSync(dir, { recursive: true });
-  const prompt = userMessage(criterion, { target, brief, sources });
+  const prompt = userMessage(criterion, { target });
   const schema = judgeSchema(criterion);
   writeFileSync(join(dir, 'prompt.md'), prompt);
   writeFileSync(join(dir, 'schema.json'), JSON.stringify(schema, null, 2));
-  const j = { dir, cwd, schema, command, yolo, addDirs: addDirs(cwd, brief, sources), timeout: MINUTES_PER_CRITERION * 60_000 };
+  const j = { dir, cwd, schema, command, yolo, timeout: MINUTES_PER_CRITERION * 60_000 };
   const ask = harness === 'claude' ? askClaude : askCodex;
   let reply = await ask(j, prompt);
   if (reply.error) return reply;
@@ -137,17 +128,19 @@ export const tomlString = (s) => `"${s.replace(/["\\\x00-\x1f\x7f]/g, (c) => TOM
  * Writes prompt.md and schema.json of one judge of the terminal mode, and returns the command and the
  * arguments that start the judge in its interactive harness.
  */
-export function writeJudge({ dir, criterion, harness, cwd, target, brief, sources, yolo = false }) {
+export function writeJudge({ dir, criterion, harness, cwd, target, yolo = false }) {
   mkdirSync(dir, { recursive: true });
-  const closing = `The engineer ran the command in ${cwd}. As your last step, write your answer, one JSON object { name, score, verdict } that matches the schema in ${join(dir, 'schema.json')}, to ${join(dir, 'answer.json')}. Write that file yourself with a tool, and do not start sub-agents: the JSON in your reply does not count. Then stop. These two files are the only exceptions to the rules on writing files and on the .panels folder.\n`;
-  const prompt = `${userMessage(criterion, { target, brief, sources })}\n${closing}`;
+  // The answer file rule sits at the end of the user prompt and in the system prompt, so a judge that hands the
+  // work to a sub-agent still leaves the file at the exact path.
+  const closing = `The engineer ran the command in ${cwd}. Your answer counts only as the file ${join(dir, 'answer.json')}: write it with that exact absolute path, as one JSON object { name, score, verdict } that matches ${join(dir, 'schema.json')}. JSON in your reply does not count. Whoever does the work, that file must exist at that path when you stop. These two files are the only exceptions to the rules on writing files and on the .panels folder.\n`;
+  const prompt = `${userMessage(criterion, { target })}\n${closing}`;
+  const system = `${SYSTEM_PROMPT}\n${closing}`;
   writeFileSync(join(dir, 'prompt.md'), prompt);
   writeFileSync(join(dir, 'schema.json'), JSON.stringify(judgeSchema(criterion), null, 2));
   if (harness === 'codex') {
     // Codex ranks the developer instructions above the prompt, and the system prompt says to return the JSON and to
     // write no files. Without the closing in the developer instructions, the judge prints the JSON and writes no answer.json.
-    return ['codex', '-C', dir, ...yoloFlags(yolo, 'codex'), '-c', `developer_instructions=${tomlString(`${SYSTEM_PROMPT}\n${closing}`)}`, prompt];
+    return ['codex', '-C', dir, ...yoloFlags(yolo, 'codex'), '-c', `developer_instructions=${tomlString(system)}`, prompt];
   }
-  const add = addDirs(cwd, brief, sources).flatMap((d) => ['--add-dir', d]);
-  return ['claude', ...yoloFlags(yolo, 'claude'), '--system-prompt', SYSTEM_PROMPT, ...add, prompt];
+  return ['claude', ...yoloFlags(yolo, 'claude'), '--system-prompt', system, prompt];
 }

package/lib/panel.js

@@ -1,8 +1,12 @@
 const API = 'https://cross.software/panels/api/panels';
 
-/** Reads a panel from the public api. An unpublished panel also answers 404. */
+/**
+ * Reads a panel from the public api on every run, the latest version unless one is pinned, and never from a
+ * cache: the api answers no-store, and the fetch asks for no store too, so a proxy cannot keep a copy.
+ * An unpublished panel also answers 404.
+ */
 export async function fetchPanel({ owner, name, version }) {
-  const res = await fetch(`${API}/${owner}/${name}${version ? `/v/${version}` : ''}`);
+  const res = await fetch(`${API}/${owner}/${name}${version ? `/v/${version}` : ''}`, { cache: 'no-store' });
   if (res.status === 404) return { error: 'panel not found' };
   if (!res.ok) return { error: `panel fetch failed: ${res.status}` };
   return { panel: await res.json() };

package/lib/report.js

@@ -18,7 +18,11 @@ export function buildReport({ panel, target, outcomes }) {
   return { panel: `${panel.owner}/${panel.name}@${panel.version}`, target, status, criteria };
 }
 
-/** The lines that the plain mode prints: the run and the version, then "N/4  name" and the verdict under it, for each criterion. */
+/**
+ * The lines that the plain mode prints: the run (panel and its version, the target, the CLI version), then
+ * "N/4  name" and the verdict under it, for each criterion.
+ */
 export function renderPlain(report) {
-  return [`panels ${VERSION}  ${report.panel}  ${report.target}`, '', ...report.criteria.flatMap((c) => [`${c.score === null ? 'err' : `${c.score}/4`}  ${c.name}`, `    ${c.verdict}`, ''])];
+  const [name, version] = report.panel.split('@');
+  return [`panels run  ${name} v${version}   ${report.target}   ${VERSION}`, '', ...report.criteria.flatMap((c) => [`${c.score === null ? 'err' : `${c.score}/4`}  ${c.name}`, `    ${c.verdict}`, ''])];
 }

package/lib/table.js

@@ -5,7 +5,6 @@ import { join } from 'node:path';
 import pty from '@homebridge/node-pty-prebuilt-multiarch';
 import { SerializeAddon } from '@xterm/addon-serialize';
 import xterm from '@xterm/headless';
-import figlet from 'figlet';
 import { check, MINUTES_PER_CRITERION, parseAnswer, writeJudge } from './judge.js';
 import { buildReport, VERSION } from './report.js';
 
@@ -76,18 +75,9 @@ export function tokensOnScreen(text) {
   return best;
 }
 
-let artLines;
-/** The word "judging" as big letters, in the ANSI Shadow font (Standard when that font is missing). Rendered once. */
-export function art() {
-  if (!artLines) {
-    const font = figlet.fontsSync().includes('ANSI Shadow') ? 'ANSI Shadow' : 'Standard';
-    artLines = figlet.textSync('judging', { font }).split('\n').filter((l) => l.trim());
-  }
-  return artLines;
-}
-
 const plainLength = (s) => s.replace(/\x1b\[[0-9;]*m/g, '').length;
 const padTo = (s, width) => s + ' '.repeat(Math.max(0, width - plainLength(s)));
+const centre = (s, width) => ' '.repeat(Math.max(0, Math.floor((width - plainLength(s)) / 2))) + s;
 
 /** The first width visible characters of a styled line, with every escape sequence kept, so the line never wraps. */
 export function clip(line, width) {
@@ -117,8 +107,77 @@ export function wrap(text, width) {
 /** The scores added as quarters: 1/4 + 1/4 + 2/4 is "1". No trailing zeros. */
 const quarters = (sum) => String(Math.round((sum / 4) * 100) / 100);
 
+// The art of a running judge: a halftone piece inside a square frame, generated from a seed. Two sizes, rows by columns.
+const MARK_SIZES = [[11, 22], [7, 14]];
+const HALFTONE = [' ', '░', '▒', '▓'];
+const SHAPES = ['half-left', 'half-right', 'half-top', 'half-bottom', 'disc', 'ring', 'quarter-tl', 'quarter-tr', 'quarter-bl', 'quarter-br', 'band', 'twin'];
+
+/** A small seeded random generator (mulberry32): the same seed gives the same sequence. */
+export function mulberry32(seed) {
+  let a = seed | 0;
+  return () => {
+    a = (a + 0x6D2B79F5) | 0;
+    let t = Math.imul(a ^ (a >>> 15), 1 | a);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
 /**
- * The body of a criterion as plain lines for the detail pane: a heading becomes a grey upper-case label, a list
+ * The lines of the art of a judge at frame: a grey square frame of box-drawing lines, and inside it a shape in a
+ * halftone screen, two cells per row unit so it looks round. The seed picks the shape (a half disc on one side,
+ * a disc, a ring, a quarter disc in a corner, a diagonal band, or two discs), its size and place, the grain of
+ * the screen, and the phase and the speed of its pulse. The screen breathes, and the glimmer wave runs across the
+ * cells by screen column, where start is the screen column of the frame. size is [rows, columns].
+ */
+export function renderArt({ seed = 0, frame = 0, start = 0, width = 80, size = MARK_SIZES[0] }) {
+  const rng = mulberry32(seed);
+  const shape = SHAPES[Math.floor(rng() * SHAPES.length)];
+  const scale = 0.65 + rng() * 0.35;
+  const dx = (rng() - 0.5) * 0.3;
+  const dy = (rng() - 0.5) * 0.3;
+  const phase = rng() * Math.PI * 2;
+  const period = 14 + rng() * 12;
+  const grain = 0.4 + rng() * 0.6;
+  const [rows, cols] = size;
+  const inner = { rows: rows - 2, cols: cols - 2 };
+  const w = inner.cols / 2;
+  const h = inner.rows;
+  const r = (scale * h) / 2;
+  const centres = {
+    'half-left': [0, h / 2], 'half-right': [w, h / 2], 'half-top': [w / 2, 0], 'half-bottom': [w / 2, h],
+    'quarter-tl': [0, 0], 'quarter-tr': [w, 0], 'quarter-bl': [0, h], 'quarter-br': [w, h],
+  };
+  const [cx, cy] = centres[shape] ?? [w / 2 + dx * w, h / 2 + dy * h];
+  // The distance of a cell from the shape, 0 at the heart and 1 at the edge; past 1 the cell is empty.
+  const distance = (u, v) => {
+    const d = Math.hypot(u - cx, v - cy);
+    if (shape === 'ring') { const t = Math.abs(d - r * 0.75) / (r * 0.3); return t; }
+    if (shape === 'band') return Math.abs((u - cx) - (v - cy)) / (r * 0.6);
+    if (shape === 'twin') return Math.min(Math.hypot(u - (cx - r * 0.5), v - cy), Math.hypot(u - (cx + r * 0.5), v - cy)) / (r * 0.75);
+    if (shape.startsWith('quarter')) return d / (r * 1.5);
+    return d / r;
+  };
+  const pulse = Math.sin((2 * Math.PI * frame) / period + phase);
+  const lines = [`${GREY}┌${'─'.repeat(inner.cols)}┐${RESET}`];
+  for (let y = 0; y < inner.rows; y++) {
+    let cells = '';
+    for (let x = 0; x < inner.cols; x++) {
+      const d = distance((x + 0.5) / 2, y + 0.5);
+      const noise = mulberry32(seed * 7919 + y * 1021 + x * 31)() - 0.5;
+      cells += d > 1 ? ' ' : HALFTONE[Math.max(1, Math.min(3, Math.round(1.5 + (1 - d) * 1.5 + pulse + noise * grain)))];
+    }
+    lines.push(`${GREY}│${RESET}${glimmer(cells, frame, start + 1, width)}${GREY}│${RESET}`);
+  }
+  lines.push(`${GREY}└${'─'.repeat(inner.cols)}┘${RESET}`);
+  return lines;
+}
+
+/** The size of the art that fits a pane of columnWidth by lines, or null when only the one-line form fits. */
+export const markSize = (columnWidth, lines) => MARK_SIZES.find(([r, c]) => r + 2 <= lines && c <= columnWidth) ?? null;
+
+/**
+ * The body of a criterion as plain lines for the text pane: a heading becomes a grey upper-case label, a list
  * item keeps its dash, a fenced block is indented four spaces as it is, a table line stays as it is, and the
  * other text is wrapped to width with the emphasis, code, and link marks removed.
  */
@@ -149,23 +208,10 @@ export function plainMarkdown(markdown, width) {
   return lines;
 }
 
-/** The lines of the detail pane under its header: the verdict or the judging art, then the criterion text. */
-function detailContent(row, columnWidth, start, width, frame) {
-  const lines = [''];
-  if (row.state === 'running' && !row.trust) {
-    // The judge works: the word judging in big letters with the wave over it, or in one line in a narrow pane.
-    const letters = art();
-    lines.push(...(letters[0].length <= columnWidth ? letters : ['judging']).map((l) => glimmer(l, frame, start, width)));
-    const since = row.restarted !== null ? `restarted with ${row.harness} · ` : '';
-    lines.push(`${GREY}${since}${clock(row.time ?? 0)} · ${row.rank} to watch${RESET}`);
-  } else {
-    const text = row.state === 'done' ? row.result.verdict
-      : row.state === 'error' ? row.error
-        : row.state === 'queued' ? 'The judge has not started.'
-          : `Press ${row.rank} and answer the trust prompt.`;
-    lines.push(...wrap(text, columnWidth));
-  }
-  if (row.description) lines.push('', ...wrap(row.description, columnWidth));
+/** The lines of the body of a criterion in the Panel tab. */
+function criterionText(row, columnWidth) {
+  const lines = [];
+  if (row.description) lines.push(...wrap(row.description, columnWidth));
   if (row.body) lines.push('', ...plainMarkdown(row.body, columnWidth));
   return lines;
 }
@@ -176,35 +222,81 @@ const layout = (rows, width) => {
   return width >= TWO_COLUMNS ? { leftWidth, columnWidth: width - leftWidth - 3, start: leftWidth + 3 } : { leftWidth, columnWidth: width - 2, start: 2 };
 };
 
-/** The number of lines of the detail pane that the scroll can hide: the content past the window of the pane. */
-export function maxScroll({ rows, cursor, width, height }) {
+const headerLine = (title, target, harness, elapsed, width, version) => {
+  const run = ` panels run  ${title}   ${target}`;
+  const meta = `${version} · ${harness} · ${clock(elapsed)} `;
+  return ` ${BOLD}panels run${RESET}  ${title}${GREY}   ${target}${' '.repeat(Math.max(2, width - run.length - meta.length))}${meta}${RESET}`;
+};
+
+const paneHeight = (width, body) => (width >= TWO_COLUMNS ? body : body - Math.floor(body / 2) - 1);
+
+// The detail pane holds the header, the sub tab bar, its hairline, the content, then the key line on its last row.
+const PANE_FRAME = 4;
+
+/** The lines of the detail pane under its sub tab bar: the verdict (or the mark while running), or the criterion text. */
+function detailContent(row, sub, columnWidth, start, width, frame, window) {
+  if (sub === 'criterion') return criterionText(row, columnWidth);
+  if (row.state === 'running' && !row.trust) {
+    const since = row.restarted !== null ? `restarted with ${row.harness} · ` : '';
+    const line = `${GREY}${since}${clock(row.time ?? 0)} · ${row.rank} to watch${RESET}`;
+    const size = markSize(columnWidth, window ?? MARK_SIZES[0][0] + 2);
+    const art = size ? renderArt({ seed: row.seed ?? 0, frame, start: start + Math.floor((columnWidth - size[1]) / 2), width, size }) : [glimmer('judging', frame, start + Math.floor((columnWidth - 7) / 2), width)];
+    const block = [...art, '', line].map((l) => centre(l, columnWidth));
+    const above = window === undefined ? 0 : Math.max(0, Math.floor((window - block.length) / 2));
+    return [...Array(above).fill(''), ...block];
+  }
+  const text = row.state === 'done' ? row.result.verdict : row.state === 'error' ? row.error : row.state === 'queued' ? 'The judge has not started.' : `Press ${row.rank} and answer the trust prompt.`;
+  return wrap(text, columnWidth);
+}
+
+/** The number of lines of the detail pane of the overview that the scroll can hide, for the sub tab sub. */
+export function overviewScrollMax({ rows, cursor, sub = 'verdict', width, height }) {
   const { columnWidth, start } = layout(rows, width);
-  const content = detailContent(rows[cursor], columnWidth, start, width, 0);
-  const body = height - 2;
-  const paneHeight = width >= TWO_COLUMNS ? body : body - Math.floor(body / 2) - 1;
-  // The pane holds the header, the content window, a blank line, and the three bottom lines.
-  const window = paneHeight - 5;
-  return window < 1 ? 0 : Math.max(0, content.length - window);
+  const window = paneHeight(width, height - 2) - PANE_FRAME;
+  return window < 1 ? 0 : Math.max(0, detailContent(rows[cursor], sub, columnWidth, start, width, 0, window).length - window);
 }
 
 /**
- * The lines of the overview. rows hold { rank, name, description, body, state, result, error, trust, time, tokens,
- * harness, restarted }, and state is queued, running, done, or error. time is the seconds the judge has run,
- * tokens the count it used (null for none), harness the one its next restart uses, restarted the seconds since
- * a restart (null for none). cursor is the index of the row whose detail shows at the right; focus is 'list'
- * or 'detail' (the detail pane shows an orange bar and its header turns orange); scroll hides that many lines
- * of the detail content under its header. The header line holds the run: panel and target at the left, the
- * version, the harness, and the elapsed time at the right edge. Two columns from TWO_COLUMNS wide, the list
- * above the detail below that. height is the number of lines the overview may fill: the column divider runs
- * the whole height, the rows and the detail header stay at the top, and the total row and the key and fact
- * lines sit at the bottom. Without a height, or when the content is taller than the height, the lines follow
- * each other and nothing scrolls.
+ * Lays a page out: the header and the hairline, then the list at the left and a pane at the right from
+ * TWO_COLUMNS wide, or the list above the pane below that. pane(lines) gives the lines of the pane for a height,
+ * or for undefined when there is no height. edge is the divider character between the columns.
  */
-export function renderOverview({ title, target, harness, elapsed, rows, cursor, width, height, frame = 0, version = VERSION, focus = 'list', scroll = 0 }) {
-  const run = ` panels run  ${title}   ${target}`;
-  const meta = `${version} · ${harness} · ${clock(elapsed)} `;
-  const header = ` ${BOLD}panels run${RESET}  ${title}${GREY}   ${target}${' '.repeat(Math.max(2, width - run.length - meta.length))}${meta}${RESET}`;
-  const rule = `${GREY}${'─'.repeat(width)}${RESET}`;
+function page({ header, width, height, left, leftBottom, pane, edge }) {
+  const { leftWidth } = layout(left.rows, width);
+  const fill = (top, bottom, lines) => {
+    const n = lines === undefined || lines < top.length + bottom.length ? 0 : lines - top.length - bottom.length;
+    return [...top, ...Array(n).fill(''), ...bottom];
+  };
+  const lines = [header, `${GREY}${'─'.repeat(width)}${RESET}`];
+  const body = height === undefined ? undefined : height - 2;
+  if (width >= TWO_COLUMNS) {
+    const leftLines = fill(left.lines, leftBottom, body);
+    const rightLines = pane(body);
+    for (let i = 0; i < Math.max(leftLines.length, rightLines.length); i++) lines.push(`${padTo(leftLines[i] ?? '', leftWidth)} ${edge} ${rightLines[i] ?? ''}`);
+  } else {
+    const half = body === undefined ? undefined : Math.floor(body / 2);
+    const list = fill(left.lines, leftBottom, half);
+    lines.push(...list, '', ...pane(body === undefined ? undefined : body - list.length - 1).map((l) => `${edge === `${GREY}│${RESET}` ? ' ' : edge} ${l}`));
+  }
+  return lines.map((l) => clip(l, width));
+}
+
+/**
+ * The lines of the overview. rows hold { rank, name, seed, state, result, error, trust, time, tokens, harness, restarted },
+ * and state is queued, running, done, or error. time is the seconds the judge has run, tokens the count it used
+ * (null for none), harness the one its next restart uses, restarted the seconds since a restart (null for none),
+ * seed the seed of the art of the criterion.
+ * cursor is the index of the row whose detail shows at the right. The header line holds the run: panel and target
+ * at the left, the version, the harness, and the elapsed time at the right edge. Two columns from TWO_COLUMNS wide,
+ * the list above the detail below that. height is the number of lines the overview may fill: the column divider
+ * runs the whole height, the rows and the detail header stay at the top, and the total row and the key
+ * line sits at the bottom. Under the detail header a sub tab bar picks the content: sub 'verdict' shows the
+ * verdict, or the Cross mark centred in the pane with the time under it while the judge runs; sub 'criterion'
+ * shows the description and the body of the criterion as plain text. focus 'text' marks the pane with an orange
+ * edge and an orange header, and scroll hides that many lines of the content. Without a height, or when the
+ * content is taller than the height, the lines follow each other and nothing scrolls.
+ */
+export function renderOverview({ title, target, harness, elapsed, rows, cursor, width, height, frame = 0, version = VERSION, sub = 'verdict', focus = 'list', scroll = 0 }) {
   const { leftWidth, columnWidth, start } = layout(rows, width);
   const pad = leftWidth - 27;
   const cells = (score, time, tokens) => `   ${score.padStart(3)}  ${time.padStart(5)}  ${tokens.padStart(6)}`;
@@ -229,65 +321,94 @@ export function renderOverview({ title, target, harness, elapsed, rows, cursor,
   const sum = done.length ? `${quarters(done.reduce((n, r) => n + r.result.score, 0))}/${rows.length}` : `·/${rows.length}`;
   const total = cells(sum, clock(Math.max(0, ...rows.map((r) => r.time ?? 0))), tokensText(rows.some((r) => r.tokens !== null) ? rows.reduce((n, r) => n + (r.tokens ?? 0), 0) : null));
   const totalLine = `${padTo('      total', leftWidth - total.length)}${done.length ? total : total.replace(sum, `${GREY}${sum}${RESET}`)}`;
-  const leftBottom = [`${GREY}${'─'.repeat(leftWidth)}${RESET}`, totalLine];
 
   const row = rows[cursor];
   const level = row.state === 'done' ? `${row.result.score}/4  ${LEVELS[row.result.score]}` : row.state === 'error' ? 'error' : row.state;
   const name = `${row.rank}  ${row.name.toUpperCase()}`;
-  const detailHeader = `${focus === 'detail' ? `${ORANGE}${BOLD}` : BOLD}${name}${RESET}${' '.repeat(Math.max(1, columnWidth - name.length - level.length))}${GREY}${level}${RESET}`;
-  const content = detailContent(row, columnWidth, start, width, frame);
-  const facts = [`judge ${row.rank}`, row.harness, ...(row.time === null ? [] : [clock(row.time)]), ...(row.state === 'done' || row.state === 'error' ? [`judges/${row.rank}/answer.json`] : [])];
-  const bottom = [`${ORANGE}r${RESET} restart   ${ORANGE}h${RESET} harness ${row.harness}   ${ORANGE}${row.rank}${RESET} watch`, '', `${GREY}${facts.join(' · ')}${RESET}`];
-
-  // top, gap blank lines, then bottom; with a height that holds them, the blank lines grow so bottom ends at the height.
-  const pane = (top, bottomLines, lines, gap) => {
-    const fill = lines === undefined || lines < top.length + gap + bottomLines.length ? gap : lines - top.length - bottomLines.length;
-    return [...top, ...Array(fill).fill(''), ...bottomLines];
-  };
-  // The detail pane: the header, a window of the content that the scroll moves, a blank line, then the bottom lines.
-  const detailPane = (lines) => {
-    const window = lines === undefined ? 0 : lines - 5;
-    if (window < 1) return pane([detailHeader, ...content], bottom, lines, 1);
+  const detailHeader = `${focus === 'text' ? `${ORANGE}${BOLD}` : BOLD}${name}${RESET}${' '.repeat(Math.max(1, columnWidth - name.length - level.length))}${GREY}${level}${RESET}`;
+  const subTab = (label, key) => `${sub === key ? BOLD : GREY}${label}${RESET}`;
+  const subBar = [`${subTab('Verdict', 'verdict')}${GREY} │ ${RESET}${subTab('Criterion', 'criterion')}`, `${GREY}${'─'.repeat(columnWidth)}${RESET}`];
+  const bottom = [`${ORANGE}r${RESET} restart   ${ORANGE}h${RESET} harness ${row.harness}   ${ORANGE}${row.rank}${RESET} watch`];
+  // The pane: the header, the sub tab bar and its hairline, a window of the content that the scroll moves, then
+  // the key line on the last row.
+  const pane = (lines) => {
+    const window = lines === undefined ? undefined : lines - PANE_FRAME;
+    const content = detailContent(row, sub, columnWidth, start, width, frame, window);
+    const top = [detailHeader, ...subBar];
+    if (window === undefined || window < 1) return [...top, ...content, ...bottom];
     const from = Math.min(scroll, Math.max(0, content.length - window));
-    return [detailHeader, ...content.slice(from, from + window), ...Array(Math.max(0, window - content.length)).fill(''), '', ...bottom];
+    return [...top, ...content.slice(from, from + window), ...Array(Math.max(0, window - content.length)).fill(''), ...bottom];
   };
-  const edge = focus === 'detail' ? `${ORANGE}▌${RESET}` : `${GREY}│${RESET}`;
+  return page({
+    header: headerLine(title, target, harness, elapsed, width, version),
+    width,
+    height,
+    left: { rows, lines: left },
+    leftBottom: [`${GREY}${'─'.repeat(leftWidth)}${RESET}`, totalLine],
+    pane,
+    edge: focus === 'text' ? `${ORANGE}▌${RESET}` : `${GREY}│${RESET}`,
+  });
+}
 
-  const lines = [header, rule];
-  const body = height === undefined ? undefined : height - 2;
-  if (width >= TWO_COLUMNS) {
-    const leftLines = pane(left, leftBottom, body, 0);
-    const rightLines = detailPane(body);
-    for (let i = 0; i < Math.max(leftLines.length, rightLines.length); i++) lines.push(`${padTo(leftLines[i] ?? '', leftWidth)} ${edge} ${rightLines[i] ?? ''}`);
-  } else {
-    const half = body === undefined ? undefined : Math.floor(body / 2);
-    const list = pane(left, leftBottom, half, 0);
-    lines.push(...list, '', ...detailPane(body === undefined ? undefined : body - list.length - 1).map((l) => `${focus === 'detail' ? `${ORANGE}▌${RESET}` : ' '} ${l}`));
-  }
-  return lines.map((l) => clip(l, width));
+// The overview is view 0. The other views are judges.
+export const isPage = (view) => view === 0;
+
+const HARNESSES = ['claude', 'codex'];
+
+/**
+ * The modal states: { kind: 'harness', rank, options, cursor } picks the harness of judge rank; { kind: 'restart',
+ * rank, options, cursor } asks before a restart. options are the rows, cursor the index of the orange row.
+ */
+export const harnessModal = (rank, current) => ({ kind: 'harness', rank, options: HARNESSES, cursor: Math.max(0, HARNESSES.indexOf(current)) });
+export const restartModal = (rank) => ({ kind: 'restart', rank, options: ['restart', 'cancel'], cursor: 1 });
+
+/**
+ * The lines of a modal and where they go: { top, left, lines }, centred on a screen width by height. A grey
+ * box-drawing frame, a bold title, a grey note when there is one, then one row per option, the cursor row orange
+ * with ▸. current is the harness the judge uses now, marked in the harness picker.
+ */
+export function renderModal({ modal, current, width, height }) {
+  const title = modal.kind === 'harness' ? `Harness for judge ${modal.rank}` : `Restart judge ${modal.rank}?`;
+  const note = modal.kind === 'restart' ? `with ${current} · the current answer is discarded` : null;
+  const rows = modal.options.map((o) => (modal.kind === 'harness' && o === current ? `${o}  (current)` : o));
+  const inner = Math.max(title.length, note?.length ?? 0, ...rows.map((r) => r.length + 2)) + 2;
+  const line = (text) => `${GREY}│${RESET} ${padTo(text, inner - 2)} ${GREY}│${RESET}`;
+  const lines = [`${GREY}┌${'─'.repeat(inner)}┐${RESET}`, line(`${BOLD}${title}${RESET}`)];
+  if (note) lines.push(line(`${GREY}${note}${RESET}`));
+  lines.push(line(''));
+  rows.forEach((r, i) => lines.push(line(i === modal.cursor ? `${ORANGE}▸ ${r}${RESET}` : `  ${r}`)));
+  lines.push(`${GREY}└${'─'.repeat(inner)}┘${RESET}`);
+  return { top: Math.max(0, Math.floor((height - lines.length) / 2)), left: Math.max(0, Math.floor((width - inner - 2) / 2)), lines };
 }
 
 /**
  * The three lines of the tab strip: a grey hairline, the tabs, then a grey status line with the progress and
- * the elapsed time at the left and the keys of the focus at the right. The first tab is Overview, then the
- * name of each criterion, with a grey │ between the tabs. A running tab glimmers. The names step down to the
- * first word when they do not fit the width. focus is 'strip' (the active tab is bold orange, the arrows move
- * it), 'detail' (the detail pane of the overview scrolls), or 'judge' (the active tab is bold ink, the keys go to
- * the judge). confirm replaces the progress with the quit question.
+ * the elapsed time at the left and the keys of the focus at the right. The tabs are Overview, then the name of
+ * each criterion, with a grey │ between the tabs. A running tab glimmers. The names step down to the first word
+ * when they do not fit the width. focus is 'strip' (the active tab is bold orange, the arrows move it), 'text'
+ * (the detail pane of the overview scrolls), or 'judge' (the active tab is bold ink, the keys go to the judge).
+ * confirm replaces the progress with the quit question; focus 'modal' shows the keys of the open modal. The keys
+ * of the overview drop their last words when they do not fit beside the progress.
  */
 export function renderStrip({ rows, view, frame = 0, width, focus = 'strip', elapsed = 0, confirm = false }) {
   const finished = rows.filter((r) => r.state === 'done' || r.state === 'error').length;
-  const keys = focus === 'judge' ? 'ctrl-q tabs'
-    : focus === 'detail' ? '↑ ↓ scroll · enter list · ← → tabs · q q quit'
-      : view === 0 ? '↑ ↓ criterion · r restart · h harness · ← → tabs · q q quit' : '← → tabs · enter back · q quit';
+  const progress = confirm ? 'judges still run. q again quits, another key stays' : `${finished} of ${rows.length} done · ${clock(elapsed)}`;
+  const full = focus === 'judge' ? 'ctrl-q tabs'
+    : focus === 'modal' ? '↑ ↓ · enter pick · esc close'
+      : focus === 'text' ? '↑ ↓ scroll · enter list · ← → tabs · q q quit'
+      : view === 0 ? '↑ ↓ criterion · tab verdict/criterion · enter scroll · r restart · h harness · ← → tabs · q q quit' : '← → tabs · enter back · q quit';
+  const parts = full.split(' · ');
+  while (parts.length > 1 && progress.length + 2 + parts.join(' · ').length + 2 > width) parts.pop();
+  const keys = parts.join(' · ');
   const names = (level) => ['Overview', ...rows.map((r) => (level === 0 ? r.name : r.name.split(' ')[0]))];
   const used = (list) => 1 + list.reduce((n, t) => n + t.length, 0) + 3 * (list.length - 1);
   const list = [0, 1].map(names).find((l) => used(l) <= width) ?? names(1);
+  const activeIndex = view;
   let line = ' ';
   let col = 1;
   list.forEach((text, i) => {
     if (i) { line += `${GREY} │ ${RESET}`; col += 3; }
-    const active = i === view;
+    const active = i === activeIndex;
     const row = rows[i - 1];
     const start = col;
     col += text.length;
@@ -295,9 +416,8 @@ export function renderStrip({ rows, view, frame = 0, width, focus = 'strip', ela
       line += glimmer(text, frame, start, width, active && focus === 'strip' ? GLIMMER_ORANGE : GLIMMER, active ? BOLD : '');
       return;
     }
-    line += `${active ? (focus === 'strip' ? `${ORANGE}${BOLD}` : BOLD) : GREY}${text}${RESET}`;
+    line += `${active ? (focus === 'judge' ? BOLD : `${ORANGE}${BOLD}`) : GREY}${text}${RESET}`;
   });
-  const progress = confirm ? 'judges still run. q again quits, another key stays' : `${finished} of ${rows.length} done · ${clock(elapsed)}`;
   // A narrow terminal drops the keys before the progress, and then the end of the progress.
   const gap = width - progress.length - keys.length - 2;
   const status = gap >= 2 ? ` ${progress}${' '.repeat(gap)}${keys}` : ` ${progress}`;
@@ -305,60 +425,79 @@ export function renderStrip({ rows, view, frame = 0, width, focus = 'strip', ela
 }
 
 /**
- * The next { view, confirm, focus, cursor, scroll } after one key, plus send: true when the key goes to the judge,
- * quit: true, restart: N to restart judge N, or flip: N to flip the harness of judge N. view is 0 for the
+ * The next { view, confirm, focus, cursor, sub, scroll } after one key, plus send: true when the key goes to the
+ * judge, quit: true, restart: N to restart judge N, or flip: N to flip the harness of judge N. view is 0 for the
  * overview, or N for judge N. open holds the ranks of the judges that have started, count the number of
  * criteria, maxScroll the lines the detail pane can hide, page the lines one PgUp or PgDn moves. With the
  * focus on a judge, every key but ctrl-q goes to the judge, and ctrl-q moves the focus to the strip. With the
  * focus on the strip, the arrows left and right move the active tab and switch the view, 1-9 jump to a started
- * judge, 0 to the overview, Enter, Esc, or ctrl-q give the focus back to the judge, and q quits (a second q
- * confirms while a judge runs). On the overview, which takes no text, up and down move the cursor, r restarts
- * the judge of the cursor row, h flips its harness, and Enter moves the focus into the detail pane: there up
- * and down scroll one line, PgUp and PgDn a page, and Esc or Enter return the focus to the list.
+ * judge, 0 to the overview, and q quits (a second q confirms while a judge runs). On the overview, which takes
+ * no text, up and down move the cursor, Tab switches the sub tab of the detail pane (verdict or criterion),
+ * r opens the restart modal of the judge of the cursor row, h the harness picker, and Enter moves the focus into
+ * the pane: there up and down scroll one line, PgUp and PgDn a page, and Esc or Enter return the focus. A modal
+ * (state.modal) takes every key until Enter or Esc. On a judge tab, Enter, Esc, or ctrl-q give the focus to the
+ * judge. The result carries harness: { rank, value } when the picker picked one.
  */
-export function press({ view, confirm, focus, cursor, scroll = 0 }, key, { open, running, count, maxScroll: limit = 0, page = 10 }) {
-  const strip = (v) => ({ view: v, confirm: false, focus: 'strip', cursor, scroll });
-  if (focus === 'judge') return TOGGLE.includes(key) ? strip(view) : { view, confirm, focus, cursor, scroll, send: true };
+export function press({ view, confirm, focus, cursor, sub = 'verdict', scroll = 0, modal = null }, key, { open, running, count, maxScroll: limit = 0, page: step = 10, harnesses = [] }) {
+  const strip = (v) => ({ view: v, confirm: false, focus: 'strip', cursor, sub, scroll, modal: null });
+  if (modal) {
+    // The modal takes every key: up and down move its cursor, Enter picks the row, Esc closes it, the rest is ignored.
+    const same = { view, confirm, focus, cursor, sub, scroll, modal };
+    if (UP.includes(key)) return { ...same, modal: { ...modal, cursor: Math.max(0, modal.cursor - 1) } };
+    if (DOWN.includes(key)) return { ...same, modal: { ...modal, cursor: Math.min(modal.options.length - 1, modal.cursor + 1) } };
+    if (key === '\x1b') return strip(0);
+    if (key === '\r') {
+      const pick = modal.options[modal.cursor];
+      if (modal.kind === 'harness') return { ...strip(0), harness: { rank: modal.rank, value: pick } };
+      return pick === 'restart' ? { ...strip(0), restart: modal.rank } : strip(0);
+    }
+    return same;
+  }
+  if (focus === 'judge') return TOGGLE.includes(key) ? strip(view) : { view, confirm, focus, cursor, sub, scroll, modal: null, send: true };
   if (confirm) return { ...strip(0), quit: key === 'q' };
-  if (key === 'q') return running ? { view: 0, confirm: true, focus: 'strip', cursor, scroll } : { ...strip(0), quit: true };
+  if (key === 'q') return running ? { view: 0, confirm: true, focus: 'strip', cursor, sub, scroll, modal: null } : { ...strip(0), quit: true };
   if (RIGHT.includes(key) || LEFT.includes(key)) {
     const cycle = [0, ...open];
-    const step = RIGHT.includes(key) ? 1 : -1;
-    return strip(cycle[(cycle.indexOf(view) + step + cycle.length) % cycle.length]);
+    const dir = RIGHT.includes(key) ? 1 : -1;
+    return strip(cycle[(cycle.indexOf(view) + dir + cycle.length) % cycle.length]);
   }
   if (/^[1-9]$/.test(key)) return open.includes(Number(key)) ? strip(Number(key)) : { ...strip(view), focus };
   if (key === '0') return strip(0);
   if (view === 0) {
-    const detail = (s) => ({ view: 0, confirm: false, focus: 'detail', cursor, scroll: Math.max(0, Math.min(limit, s)) });
-    if (key === 'r') return open.includes(cursor + 1) ? { ...strip(0), focus, restart: cursor + 1 } : { ...strip(0), focus };
-    if (key === 'h') return { ...strip(0), focus, flip: cursor + 1 };
-    if (focus === 'detail') {
-      if (UP.includes(key)) return detail(scroll - 1);
-      if (DOWN.includes(key)) return detail(scroll + 1);
-      if (key === '\x1b[5~') return detail(scroll - page);
-      if (key === '\x1b[6~') return detail(scroll + page);
+    const keep = { ...strip(0), focus };
+    if (key === 'r') return open.includes(cursor + 1) ? { ...keep, focus: 'modal', modal: restartModal(cursor + 1) } : keep;
+    if (key === 'h') return { ...keep, focus: 'modal', modal: harnessModal(cursor + 1, harnesses[cursor]) };
+    if (key === '\t') return { ...keep, sub: sub === 'verdict' ? 'criterion' : 'verdict', scroll: 0 };
+    if (focus === 'text') {
+      const text = (s) => ({ ...keep, scroll: Math.max(0, Math.min(limit, s)) });
+      if (UP.includes(key)) return text(scroll - 1);
+      if (DOWN.includes(key)) return text(scroll + 1);
+      if (key === '\x1b[5~') return text(scroll - step);
+      if (key === '\x1b[6~') return text(scroll + step);
       if (key === '\r' || key === '\x1b') return strip(0);
-      return detail(scroll);
+      return keep;
     }
     if (UP.includes(key)) return { ...strip(0), cursor: Math.max(0, cursor - 1), scroll: 0 };
     if (DOWN.includes(key)) return { ...strip(0), cursor: Math.min(count - 1, cursor + 1), scroll: 0 };
-    if (key === '\r') return detail(0);
+    if (key === '\r') return { ...strip(0), focus: 'text', scroll: 0 };
     return strip(0);
   }
-  if (BACK.includes(key)) return { view, confirm: false, focus: 'judge', cursor, scroll };
+  if (BACK.includes(key)) return { view, confirm: false, focus: 'judge', cursor, sub, scroll, modal: null };
   return strip(view);
 }
 
 /** Runs the judges, shows the overview, and writes the report. Resolves when the engineer quits. */
-export function runTable({ panel, runDir, harness, cwd, target, brief, sources, yolo = false }) {
+export function runTable({ panel, runDir, harness, cwd, target, yolo = false }) {
   const out = process.stdout;
-  const criteria = panel.criteria.map((c, i) => ({ rank: i + 1, ...c }));
+  // One random seed per run; each criterion keeps its own art for the whole run, through restarts.
+  const runSeed = Math.floor(Math.random() * 2 ** 31);
+  const criteria = panel.criteria.map((c, i) => ({ rank: i + 1, seed: runSeed + i + 1, ...c }));
   const judges = [];
   // The harness of each judge: the run harness, until h flips it.
   const harnesses = criteria.map(() => harness);
   let rows = [];
   let final = null;
-  let ui = { view: 0, confirm: false, focus: 'strip', cursor: 0, scroll: 0 };
+  let ui = { view: 0, confirm: false, focus: 'strip', cursor: 0, sub: 'verdict', scroll: 0, modal: null };
   let stripTimer;
   let lastData = 0;
   const started = Date.now();
@@ -395,7 +534,7 @@ export function runTable({ panel, runDir, harness, cwd, target, brief, sources,
   }
 
   function start(rank, restartedAt = null) {
-    const [command, ...argv] = writeJudge({ dir: judgeDir(rank), criterion: criteria[rank - 1], harness: harnesses[rank - 1], cwd, target, brief, sources, yolo });
+    const [command, ...argv] = writeJudge({ dir: judgeDir(rank), criterion: criteria[rank - 1], harness: harnesses[rank - 1], cwd, target, yolo });
     const { cols, rows: lines } = size();
     const term = new xterm.Terminal({ cols, rows: lines, allowProposedApi: true });
     const serializer = new SerializeAddon();
@@ -441,7 +580,7 @@ export function runTable({ panel, runDir, harness, cwd, target, brief, sources,
     const lines = renderStrip({ rows, view: ui.view, frame, width: out.columns, focus: ui.focus, elapsed: seconds(started), confirm: ui.confirm });
     const top = out.rows - STRIP_ROWS + 1;
     const strip = lines.map((l, i) => `\x1b[${top + i};1H${l}\x1b[K`).join('');
-    if (!ui.view) return void out.write(`${RESET}${strip}`);
+    if (isPage(ui.view)) return void out.write(`${RESET}${strip}`);
     const j = judges[ui.view - 1];
     const { cursorX, cursorY } = j.term.buffer.active;
     if (cursorX >= out.columns) return;
@@ -475,9 +614,14 @@ export function runTable({ panel, runDir, harness, cwd, target, brief, sources,
 
   let frame = 0;
   function draw() {
-    const lines = renderOverview({ title: `${panel.owner}/${panel.name} v${panel.version}`, target, harness, elapsed: seconds(started), rows, cursor: ui.cursor, width: out.columns, height: out.rows - STRIP_ROWS, frame, focus: ui.focus === 'detail' ? 'detail' : 'list', scroll: ui.scroll });
+    const lines = renderOverview({ title: `${panel.owner}/${panel.name} v${panel.version}`, target, harness, elapsed: seconds(started), rows, cursor: ui.cursor, width: out.columns, height: out.rows - STRIP_ROWS, frame, sub: ui.sub, focus: ui.focus === 'text' ? 'text' : 'list', scroll: ui.scroll });
     while (lines.length < out.rows - STRIP_ROWS) lines.push('');
     out.write(lines.slice(0, out.rows - STRIP_ROWS).map((l, i) => `\x1b[${i + 1};1H${l}\x1b[K`).join(''));
+    // The modal sits over the overview; the next draw without it shows the overview again.
+    if (ui.modal) {
+      const { top, left, lines: box } = renderModal({ modal: ui.modal, current: harnesses[ui.modal.rank - 1], width: out.columns, height: out.rows - STRIP_ROWS });
+      out.write(box.map((l, i) => `\x1b[${top + i + 1};${left + 1}H${l}`).join(''));
+    }
     drawStrip();
   }
 
@@ -494,14 +638,14 @@ export function runTable({ panel, runDir, harness, cwd, target, brief, sources,
       }
       if (rows.every((r) => r.state === 'done' || r.state === 'error')) finish();
     }
-    if (!ui.view) draw();
+    if (isPage(ui.view)) draw();
   }
 
   return new Promise((done) => {
     const timer = setInterval(tick, 1000);
     const spinner = setInterval(() => {
       frame += 1;
-      if (!ui.view) draw();
+      if (isPage(ui.view)) draw();
       else if (Date.now() - lastData > 60) drawStrip();
     }, 100);
     out.write('\x1b[?1049h\x1b[?25l');
@@ -510,9 +654,9 @@ export function runTable({ panel, runDir, harness, cwd, target, brief, sources,
       const key = data.toString();
       const from = ui.view;
       const height = out.rows - STRIP_ROWS;
-      const limit = rows.length ? maxScroll({ rows, cursor: ui.cursor, width: out.columns, height }) : 0;
-      const next = press(ui, key, { open: judges.flatMap((j, i) => (j ? [i + 1] : [])), running: rows.some((r) => r.state === 'running'), count: criteria.length, maxScroll: limit, page: Math.max(1, height - 7) });
-      ui = { view: next.view, confirm: next.confirm, focus: next.focus, cursor: next.cursor, scroll: next.scroll };
+      const limit = rows.length ? overviewScrollMax({ rows, cursor: ui.cursor, sub: ui.sub, width: out.columns, height }) : 0;
+      const next = press(ui, key, { open: judges.flatMap((j, i) => (j ? [i + 1] : [])), running: rows.some((r) => r.state === 'running'), count: criteria.length, maxScroll: limit, page: Math.max(1, height - PANE_FRAME), harnesses });
+      ui = { view: next.view, confirm: next.confirm, focus: next.focus, cursor: next.cursor, sub: next.sub, scroll: next.scroll, modal: next.modal };
       if (next.send) {
         judges[from - 1].proc.write(key);
       } else if (next.quit) {
@@ -526,16 +670,16 @@ export function runTable({ panel, runDir, harness, cwd, target, brief, sources,
       } else if (next.restart) {
         restart(next.restart);
         tick();
-      } else if (next.flip) {
-        harnesses[next.flip - 1] = harnesses[next.flip - 1] === 'claude' ? 'codex' : 'claude';
+      } else if (next.harness) {
+        harnesses[next.harness.rank - 1] = next.harness.value;
         tick();
-      } else if (ui.view && ui.view === from) {
+      } else if (!isPage(ui.view) && ui.view === from) {
         drawStrip();
       } else {
         // A judge can leave its modes on (mouse, bracketed paste, the kitty keyboard). The next view starts clean.
-        if (from) out.write(TABLE_MODES);
-        if (ui.view) showJudge(ui.view);
-        else draw();
+        if (!isPage(from)) out.write(TABLE_MODES);
+        if (isPage(ui.view)) draw();
+        else showJudge(ui.view);
       }
     });
     out.on('resize', () => {
@@ -544,8 +688,8 @@ export function runTable({ panel, runDir, harness, cwd, target, brief, sources,
         if (j && !j.exited) j.proc.resize(cols, lines);
         j?.term.resize(cols, lines);
       }
-      if (ui.view) showJudge(ui.view);
-      else draw();
+      if (isPage(ui.view)) draw();
+      else showJudge(ui.view);
     });
     tick();
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xsft/panels",
-  "version": "0.7.2",
+  "version": "0.8.1",
   "private": false,
   "description": "Run a panel of AI judges from cross.software/panels against a target.",
   "type": "module",
@@ -24,7 +24,6 @@
   "dependencies": {
     "@homebridge/node-pty-prebuilt-multiarch": "0.14.1",
     "@xterm/addon-serialize": "0.14.0",
-    "@xterm/headless": "6.0.0",
-    "figlet": "1.12.0"
+    "@xterm/headless": "6.0.0"
   }
 }

package/prompts/judge-system-prompt.txt

@@ -3,44 +3,42 @@ You are one judge in a run of a panel. A panel is a named list of criteria. You
 YOUR INPUTS
 
 The user message gives you:
-- Your criterion: its rank, its name, its one-line description, and its body. Follow the body as written.
+- Your criterion: its rank, its name, its one-line description, and its body. They define what to assess, not how. This prompt holds the method.
 - The target: the text that the engineer typed after the panel name, unchanged. It can be a URL, a path, a branch, a pull request, or a sentence.
-- The brief: a file path, or "none supplied".
-- The sources: paths or URLs, or "none".
 
 Your working directory is the folder where the engineer ran the command.
 
-THE TARGET
+HOW TO JUDGE
 
-Find out what the target names, and reach it with your tools: read files, run git read commands, open URLs. When you cannot reach the target, or cannot do a test of the body with your tools, name the test at the end of your verdict after "Not checked:" with the reason. Then score as the body says for that case. Never score what you did not see.
+- Look at the target itself: open it, read it, and run it when it is code. Reach it with your tools: read files, run commands, open URLs.
+- Collect evidence for every claim you make: a URL, a file and line, a quote, or a command and its output. The engineer must be able to check each one.
+- Give no credit for intent. A comment or a doc is not done work.
+- When you cannot reach the target, or cannot check a part of the criterion with your tools, say so at the end of your verdict after "Not checked:" with the reason. Never score what you did not see.
+- Keep any notes or tables for yourself; they do not go in the answer.
 
-ORDER
+SCORE
 
-Before you read the brief or the sources, do every step that the body puts before them. Keep the records and tables that the body asks for in your own notes; they do not go in the answer.
+The score is a whole number from 1 to 4. Only 4 passes.
 
-HOW TO SCORE
+4  Met. The criterion holds across the whole target, every claim has evidence, and a real look found no material flaw.
+3  Almost met. The criterion holds in the main. Material flaws remain, and each one is named with its evidence.
+2  Falls short. Parts hold, but the flaws outweigh them, or a core part is missing.
+1  Fails. The criterion does not hold, or the target cannot be assessed for it, or a claim is invented.
 
-1. Follow the body to a level from 1 to 4: 4 Met, 3 Almost met, 2 Falls short, 1 Fails. The level is the score.
-2. Apply each cap of the body, such as "cannot support a score above 3". When two caps apply, use the lower cap.
-3. When the evidence fits two levels, use the lower level.
-4. A criterion passes only at score 4.
-
-EVIDENCE
-
-- Each claim needs evidence that the engineer can check: a URL, a file and line, a quote, or a command and its output. Put the place in brackets inside the verdict, such as (index.html:90).
-- Give no credit for intent. A promise in a comment, a doc, or the brief is not done work.
+Rules:
+- When the evidence fits two levels, use the lower level.
 - No evidence for a level means the lower level.
+- Anything you did not check cannot support a 4. List it at the end of the verdict after "Not checked:".
 
 THE VERDICT
 
-One paragraph: what holds, then what is wrong and where, each place in brackets, then "Not checked:" and the tests you could not do, when there are any. Judge; do not propose fixes. The fixes are the job of the engineer.
+One paragraph: what holds, then what is wrong and where, each place in brackets such as (index.html:90), then "Not checked:" and the parts you could not check, when there are any. Judge; do not propose fixes. The fixes are the job of the engineer.
 
 PROHIBITIONS
 
-- Do not change the body, the levels, or the caps.
-- Do not score a fault that the body gives to another criterion.
-- Do not write or change files, except the answer file when the user message names one.
-- Do not start sub-agents.
+- Do not change the criterion or the levels.
+- Do not score a fault that another criterion of the panel covers.
+- Do not write or change files of the target. The answer file, when the user message names one, is the only file you write.
 - Do not submit forms, send messages, or post data.
 - Do not read the .panels folder. It holds earlier reports.
 
@@ -59,5 +57,5 @@ Example:
 {
   "name": "Original design assets",
   "score": 2,
-  "verdict": "The hero shows the real app, and the cutaway hotel and the team scenes are original and share one idea (public/assets/hotel-world). Every content icon is a generic Lucide symbol (src/components/Features.tsx:3), which caps the band at 6. Not checked: a reverse image search of hero.webp, the target is on localhost."
+  "verdict": "The hero shows the real app, and the cutaway hotel and the team scenes are original and share one idea (public/assets/hotel-world). Every content icon is a generic Lucide symbol (src/components/Features.tsx:3), so the icon set is not original. Not checked: a reverse image search of hero.webp, the target is on localhost."
 }