@xsft/panels 0.7.1 → 0.8.0

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,22 +18,24 @@ 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, the verdict paragraph, and at the bottom the key line and a grey fact line with the judge number, the harness, the time, and the answer file. While a judge runs, its detail shows the Cross mark, a half disc in a square frame drawn in a halftone screen that breathes, centred in the pane, with the time under it. One soft wave sweeps across the running rows and the mark. 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.
 
-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.
+The second tab, `Panel`, holds the text of the panel: the criteria at the left with the same cursor as the overview, and at the right the description and the body of the cursor criterion as plain text. `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.
+
+A tab strip on the last three lines shows a hairline, the tabs (`Overview`, `Panel`, 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.
 
 ## Run folder
 
@@ -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

@@ -27,12 +27,11 @@ async function pool(items, size, fn) {
 
 const EXIT = { pass: 0, fail: 1, error: 2 };
 
-/** Runs the judges in the score table, and exits from report.json when the engineer quits. */
+/** 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;
-  console.log(reportPath);
   return EXIT[JSON.parse(readFileSync(reportPath, 'utf8')).status];
 }
 
@@ -78,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,41 @@ 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 Cross mark: a half disc inside a square frame, drawn in a halftone screen. Two sizes, rows by columns.
+const MARK_SIZES = [[11, 22], [7, 14]];
+const HALFTONE = [' ', '░', '▒', '▓'];
+const BREATH = 20;
+
+/**
+ * The lines of the Cross mark at frame: a square frame of box-drawing lines, grey, and inside it a half disc on
+ * the left, its flat side on the frame, made of halftone cells two columns per row. The screen breathes: its
+ * density pulses over BREATH frames, 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 renderMark({ frame = 0, start = 0, width = 80, size = MARK_SIZES[0] }) {
+  const [rows, cols] = size;
+  const inner = { rows: rows - 2, cols: cols - 2 };
+  const cy = (inner.rows - 1) / 2;
+  const radius = inner.rows / 2;
+  const pulse = Math.sin((2 * Math.PI * frame) / BREATH);
+  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 = Math.hypot((x + 0.5) / 2, y - cy) / radius;
+      cells += d > 1 ? ' ' : HALFTONE[Math.max(1, Math.min(3, Math.round(1.5 + (1 - d) * 1.5 + pulse)))];
+    }
+    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 mark 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 detail pane: a heading becomes a grey upper-case label, a list
+ * 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 +172,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 +186,58 @@ 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 { 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 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 number of lines of the text pane of the Panel tab that the scroll can hide. */
+export function panelScrollMax({ rows, cursor, width, height }) {
+  const { columnWidth } = layout(rows, width);
+  const window = paneHeight(width, height - 2) - 2;
+  return window < 1 ? 0 : Math.max(0, criterionText(rows[cursor], columnWidth).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, 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. 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. The detail of a running judge is the Cross mark, centred in the pane, with the time
+ * under it. Without a height, or when the content is taller than the height, the lines follow each other.
+ */
+export function renderOverview({ title, target, harness, elapsed, rows, cursor, width, height, frame = 0, version = VERSION }) {
   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,73 +262,109 @@ 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 detailHeader = `${BOLD}${name}${RESET}${' '.repeat(Math.max(1, columnWidth - name.length - level.length))}${GREY}${level}${RESET}`;
   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 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];
+  // The pane: the header, the content, then the bottom lines at the bottom. A running judge shows the mark centred.
+  const pane = (lines) => {
+    // The pane holds the header, a blank line, the content, a blank line, then the bottom lines.
+    const window = lines === undefined ? undefined : lines - 2 - 1 - bottom.length;
+    let content;
+    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 ? renderMark({ 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));
+      content = [...Array(above).fill(''), ...block];
+    } 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.`;
+      content = wrap(text, columnWidth);
+    }
+    const top = [detailHeader, '', ...content];
+    if (window === undefined || content.length > window) return [...top, '', ...bottom];
+    return [...top, ...Array(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: `${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 lines of the Panel tab: the same header, the criteria at the left (rank and name, the cursor row orange),
+ * and at the right the description and the body of the cursor 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 text.
+ */
+export function renderPanel({ title, target, harness, elapsed, rows, cursor, width, height, version = VERSION, focus = 'list', scroll = 0 }) {
+  const { leftWidth, columnWidth } = layout(rows, width);
+  const pad = leftWidth - 27;
+  const left = rows.map((r, i) => (i === cursor ? `${ORANGE}▸ ${String(r.rank).padStart(2)}  ${r.name.padEnd(pad)}${RESET}` : `  ${String(r.rank).padStart(2)}  ${r.name.padEnd(pad)}`));
+  const row = rows[cursor];
+  const name = `${row.rank}  ${row.name.toUpperCase()}`;
+  const header = `${focus === 'text' ? `${ORANGE}${BOLD}` : BOLD}${name}${RESET}`;
+  const text = criterionText(row, columnWidth);
+  const pane = (lines) => {
+    const window = lines === undefined ? text.length : lines - 2;
+    const from = Math.min(scroll, Math.max(0, text.length - window));
+    return [header, '', ...text.slice(from, from + Math.max(0, window))];
+  };
+  return page({
+    header: headerLine(title, target, harness, elapsed, width, version),
+    width,
+    height,
+    left: { rows, lines: left },
+    leftBottom: [],
+    pane,
+    edge: focus === 'text' ? `${ORANGE}▌${RESET}` : `${GREY}│${RESET}`,
+  });
 }
 
+// The pages: the overview (view 0) and the Panel tab (view 'panel'). The other views are judges.
+export const PANEL = 'panel';
+export const isPage = (view) => view === 0 || view === PANEL;
+
 /**
  * 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
+ * the elapsed time at the left and the keys of the focus at the right. The tabs are Overview, Panel, 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
+ * it), 'text' (the text pane of the Panel tab scrolls), or 'judge' (the active tab is bold ink, the keys go to
  * the judge). confirm replaces the progress with the quit question.
  */
 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 names = (level) => ['Overview', ...rows.map((r) => (level === 0 ? r.name : r.name.split(' ')[0]))];
+    : focus === 'text' ? '↑ ↓ scroll · enter list · ← → tabs · q q quit'
+      : view === 0 ? '↑ ↓ criterion · r restart · h harness · ← → tabs · q q quit'
+        : view === PANEL ? '↑ ↓ criterion · enter text · ← → tabs · q q quit' : '← → tabs · enter back · q quit';
+  const names = (level) => ['Overview', 'Panel', ...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 === 0 ? 0 : view === PANEL ? 1 : view + 1;
   let line = ' ';
   let col = 1;
   list.forEach((text, i) => {
     if (i) { line += `${GREY} │ ${RESET}`; col += 3; }
-    const active = i === view;
-    const row = rows[i - 1];
+    const active = i === activeIndex;
+    const row = rows[i - 2];
     const start = col;
     col += text.length;
     if (row?.state === 'running' && !row.trust) {
       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.
@@ -307,50 +376,51 @@ 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
- * 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.
+ * overview, PANEL for the Panel tab, or N for judge N. open holds the ranks of the judges that have started,
+ * count the number of criteria, maxScroll the lines the text 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, and q quits (a second q confirms while a judge runs). On the
+ * overview and the Panel tab, which take no text, up and down move the shared cursor; on the overview r
+ * restarts the judge of the cursor row and h flips its harness; on the Panel tab Enter moves the focus into
+ * the text pane, where up and down scroll one line, PgUp and PgDn a page, and Esc or Enter return the focus.
+ * On a judge tab, Enter, Esc, or ctrl-q give the focus to the judge.
  */
-export function press({ view, confirm, focus, cursor, scroll = 0 }, key, { open, running, count, maxScroll: limit = 0, page = 10 }) {
+export function press({ view, confirm, focus, cursor, scroll = 0 }, key, { open, running, count, maxScroll: limit = 0, page: step = 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 };
   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 (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 cycle = [0, PANEL, ...open];
+    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);
-      if (key === '\r' || key === '\x1b') return strip(0);
-      return detail(scroll);
+  if (isPage(view)) {
+    if (view === 0 && key === 'r') return open.includes(cursor + 1) ? { ...strip(0), restart: cursor + 1 } : strip(0);
+    if (view === 0 && key === 'h') return { ...strip(0), flip: cursor + 1 };
+    if (focus === 'text') {
+      const text = (s) => ({ view, confirm: false, focus: 'text', cursor, 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(view);
+      return text(scroll);
     }
-    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);
-    return strip(0);
+    if (UP.includes(key)) return { ...strip(view), cursor: Math.max(0, cursor - 1), scroll: 0 };
+    if (DOWN.includes(key)) return { ...strip(view), cursor: Math.min(count - 1, cursor + 1), scroll: 0 };
+    if (view === PANEL && key === '\r') return { view, confirm: false, focus: 'text', cursor, scroll: 0 };
+    return strip(view);
   }
   if (BACK.includes(key)) return { view, confirm: false, focus: 'judge', cursor, scroll };
   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 }));
   const judges = [];
@@ -395,7 +465,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 +511,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,7 +545,8 @@ 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 common = { 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 };
+    const lines = ui.view === PANEL ? renderPanel({ ...common, focus: ui.focus === 'text' ? 'text' : 'list', scroll: ui.scroll }) : renderOverview({ ...common, frame });
     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(''));
     drawStrip();
@@ -494,14 +565,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,7 +581,7 @@ 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 limit = rows.length ? panelScrollMax({ 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 };
       if (next.send) {
@@ -529,13 +600,13 @@ export function runTable({ panel, runDir, harness, cwd, target, brief, sources,
       } else if (next.flip) {
         harnesses[next.flip - 1] = harnesses[next.flip - 1] === 'claude' ? 'codex' : 'claude';
         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 +615,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.1",
+  "version": "0.8.0",
   "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."
 }