@xsft/panels 0.5.2 → 0.7.0

package/README.md

@@ -29,16 +29,18 @@ Run the command in the folder of the product. Each judge starts in that folder,
 
 ## Terminal mode
 
-On a terminal, `panels run` shows the score table, 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 table 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`).
+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.
 
-A tab strip on the last three lines shows a hairline, a tab per view, and a status line with the progress, the elapsed time, and the keys. The tabs are the scores, then each judge with its number, name, and mark (score, ✗ for an error, · while queued, ! while the harness asks whether to trust the folder). The label of a running judge glimmers. 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, `0` to the scores, `enter` gives the focus to the judge, and `q` quits and asks `y` while a judge still runs. With the focus on a judge, each key goes to the judge, and `ctrl-q` gives the focus back to the strip. The scores take no input, 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 overview has a header line with the run (panel, target, harness, elapsed time) 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), the time the judge has run, and the tokens it used, with a total row 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 key line, and a grey fact line with the judge number, the harness, the time, and the answer file. 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.
+
+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.
 
 ## Run folder
 
 Each run writes to `.panels/<owner>-<name>/<UTC time>/`:
 
 - `panel.json`: the panel as the api gave it.
-- `report.md` and `report.json`: the scores, the evidence, the fixes, and the errors. `schema/report.json` is the schema of `report.json`.
+- `report.json`: `{ panel: "owner/name@version", target, status, criteria: [{ name, score, verdict }] }`, in panel order. `schema/report.json` is its schema, and its `criterion` definition is the shape of the answer of a judge.
 - `judges/<k>/`: the prompt, the output schema, and the raw answer of judge k. In terminal mode, `answer.json` takes the place of the raw answer.
 
 The last line on stdout is the path of `report.json`.

package/bin/panels.js

@@ -4,7 +4,7 @@ import { delimiter, join } from 'node:path';
 import { parse, SYNOPSIS } from '../lib/args.js';
 import { runJudge } from '../lib/judge.js';
 import { fetchPanel } from '../lib/panel.js';
-import { buildReport, renderMarkdown } from '../lib/report.js';
+import { buildReport, renderPlain } from '../lib/report.js';
 import { runTable } from '../lib/table.js';
 
 // More parallel sessions on one account get 429 answers from the model api.
@@ -62,27 +62,24 @@ async function main() {
   }
   const { panel } = fetched;
   const cwd = process.cwd();
-  const judges = panel.criteria.map((_, i) => [i]);
   const time = new Date().toISOString().replaceAll(':', '-');
   const runDir = join(cwd, '.panels', `${panel.owner}-${panel.name}`, time);
   mkdirSync(runDir, { recursive: true });
   writeFileSync(join(runDir, 'panel.json'), JSON.stringify(panel, null, 2));
   if (process.stdout.isTTY && process.stdin.isTTY) return runOnTerminal({ panel, runDir, harness, cwd, args });
-  const outcomes = await pool(judges, PARALLEL_JUDGES, (indexes, j) => runJudge({
-    dir: join(runDir, 'judges', String(j + 1)),
-    criteria: indexes.map((i) => ({ rank: i + 1, ...panel.criteria[i] })),
+  const outcomes = await pool(panel.criteria, PARALLEL_JUDGES, (c, i) => runJudge({
+    dir: join(runDir, 'judges', String(i + 1)),
+    criterion: { rank: i + 1, ...c },
     harness,
     cwd,
     target: args.target,
     brief: args.brief,
     sources: args.sources,
   }));
-  const report = buildReport({ panel, target: args.target, cwd, harness, judges, outcomes });
-  const markdown = renderMarkdown(report);
+  const report = buildReport({ panel, target: args.target, outcomes });
   const reportPath = join(runDir, 'report.json');
-  writeFileSync(join(runDir, 'report.md'), markdown);
   writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`);
-  console.log(markdown);
+  console.log(renderPlain(report).join('\n'));
   console.log(reportPath);
   return EXIT[report.status];
 }

package/lib/judge.js

@@ -2,54 +2,41 @@ import { spawn } from 'node:child_process';
 import { closeSync, mkdirSync, openSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative, resolve, sep } from 'node:path';
 
-const { judgeResult } = JSON.parse(readFileSync(new URL('../schema/report.json', import.meta.url), 'utf8')).$defs;
+const { criterion: CRITERION } = JSON.parse(readFileSync(new URL('../schema/report.json', import.meta.url), 'utf8')).$defs;
+const VERDICT_LENGTH = CRITERION.properties.verdict.maxLength;
 const SYSTEM_PROMPT = readFileSync(new URL('../prompts/judge-system-prompt.txt', import.meta.url), 'utf8');
 export const MINUTES_PER_CRITERION = 20;
 const TOOLS = 'Read,Glob,Grep,Bash,WebFetch,WebSearch';
 // With --permission-mode dontAsk, Claude refuses every tool call that this list does not allow, so Bash runs git reads only.
 const ALLOWED_TOOLS = 'Read,Glob,Grep,WebFetch,WebSearch,Bash(git log:*),Bash(git show:*),Bash(git diff:*),Bash(git status:*),Bash(git ls-files:*),Bash(git rev-parse:*),Bash(git branch --list:*)';
 
-export const bandToScore = (band) => (band <= 3 ? 1 : band <= 6 ? 2 : band <= 8 ? 3 : 4);
-
 /**
- * The user message of a judge. criteria items are { 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. 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(criteria, { target, brief, sources }) {
-  const parts = criteria.map((c) => `<criterion rank="${c.rank}" name="${c.name}">\nDescription: ${c.description}\n\n${c.body}\n</criterion>`);
+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`;
 }
 
-/** The output schema of a judge: { results }, one judgeResult for each of its criteria, with rank and name fixed. */
-export function judgeSchema(criteria) {
-  const items = criteria.map((c) => ({
-    ...judgeResult,
-    properties: { ...judgeResult.properties, rank: { type: 'integer', const: c.rank }, criterion: { type: 'string', const: c.name } },
-  }));
-  return {
-    type: 'object',
-    additionalProperties: false,
-    required: ['results'],
-    properties: { results: { type: 'array', minItems: items.length, maxItems: items.length, items: items.length === 1 ? items[0] : { anyOf: items } } },
-  };
+/** The output schema of a judge: one criterion object { name, score, verdict }, with the name fixed. */
+export function judgeSchema(criterion) {
+  const { description, ...schema } = CRITERION;
+  return { ...schema, properties: { ...schema.properties, name: { type: 'string', const: criterion.name } } };
 }
 
 /** Returns the reasons the answer of a judge is not valid, or an empty array. */
-export function check(answer, criteria) {
-  if (!Array.isArray(answer?.results)) return ['The answer must be a JSON object with a results array.'];
-  if (answer.results.length !== criteria.length) return [`results must hold ${criteria.length} items, one for each criterion, in rank order.`];
-  return criteria.flatMap((c, i) => {
-    const r = answer.results[i];
-    const missing = judgeResult.required.filter((key) => !(key in Object(r)));
-    if (missing.length) return [`Item ${i + 1} lacks ${missing.join(', ')}.`];
-    const errors = [];
-    if (r.rank !== c.rank || r.criterion !== c.name) errors.push(`Item ${i + 1} must have rank ${c.rank} and criterion "${c.name}".`);
-    if (!Number.isInteger(r.band) || r.band < 1 || r.band > 10) errors.push(`Rank ${c.rank}: band must be a whole number from 1 to 10.`);
-    else if (r.score !== bandToScore(r.band)) errors.push(`Rank ${c.rank}: band ${r.band} maps to score ${bandToScore(r.band)}, not ${r.score}.`);
-    if (r.score < 4 && !(Array.isArray(r.fixes) && r.fixes.length)) errors.push(`Rank ${c.rank}: score ${r.score} is below 4, so fixes must list each fix that score 4 needs.`);
-    return errors;
-  });
+export function check(answer, criterion) {
+  if (answer === null || typeof answer !== 'object' || Array.isArray(answer)) return ['The answer must be one JSON object with name, score, and verdict.'];
+  const missing = CRITERION.required.filter((key) => !(key in answer));
+  if (missing.length) return [`The answer lacks ${missing.join(', ')}.`];
+  const errors = [];
+  if (answer.name !== criterion.name) errors.push(`name must be "${criterion.name}".`);
+  if (!Number.isInteger(answer.score) || answer.score < 1 || answer.score > 4) errors.push('score must be a whole number from 1 to 4.');
+  if (typeof answer.verdict !== 'string' || !answer.verdict.trim()) errors.push('verdict must be one paragraph of text.');
+  else if (answer.verdict.length > VERDICT_LENGTH) errors.push(`verdict must be ${VERDICT_LENGTH} characters at most; it has ${answer.verdict.length}.`);
+  return errors;
 }
 
 /** The folders of the brief and the path sources that are outside cwd. A Claude judge cannot read them without --add-dir. */
@@ -123,25 +110,25 @@ export function parseAnswer(text) {
 
 /**
  * Runs one judge to the end: the first answer, and one re-ask when check() rejects it.
- * Returns { results } or { error }. command is the harness binary; the tests pass a stub.
+ * Returns { answer } or { error }. command is the harness binary; the tests pass a stub.
  */
-export async function runJudge({ dir, criteria, harness, cwd, target, brief, sources }, command = harness) {
+export async function runJudge({ dir, criterion, harness, cwd, target, brief, sources }, command = harness) {
   mkdirSync(dir, { recursive: true });
-  const prompt = userMessage(criteria, { target, brief, sources });
-  const schema = judgeSchema(criteria);
+  const prompt = userMessage(criterion, { target, brief, sources });
+  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, addDirs: addDirs(cwd, brief, sources), timeout: criteria.length * MINUTES_PER_CRITERION * 60_000 };
+  const j = { dir, cwd, schema, command, addDirs: addDirs(cwd, brief, sources), timeout: MINUTES_PER_CRITERION * 60_000 };
   const ask = harness === 'claude' ? askClaude : askCodex;
   let reply = await ask(j, prompt);
   if (reply.error) return reply;
-  let errors = check(reply.answer, criteria);
+  let errors = check(reply.answer, criterion);
   if (errors.length) {
     reply = await ask(j, `Your answer failed these checks. Return the whole JSON object again, with each one fixed:\n${errors.map((e) => `- ${e}`).join('\n')}`, reply.session);
     if (reply.error) return reply;
-    errors = check(reply.answer, criteria);
+    errors = check(reply.answer, criterion);
   }
-  return errors.length ? { error: `invalid answer after one re-ask: ${errors.join(' ')}` } : { results: reply.answer.results };
+  return errors.length ? { error: `invalid answer after one re-ask: ${errors.join(' ')}` } : { answer: reply.answer };
 }
 
 const TOML_ESCAPES = { '"': '\\"', '\\': '\\\\', '\n': '\\n' };
@@ -153,12 +140,12 @@ 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, criteria, harness, cwd, target, brief, sources }) {
+export function writeJudge({ dir, criterion, harness, cwd, target, brief, sources }) {
   mkdirSync(dir, { recursive: true });
-  const closing = `The engineer ran the command in ${cwd}. As your last step, write your answer JSON, which 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(criteria, { target, brief, sources })}\n${closing}`;
+  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}`;
   writeFileSync(join(dir, 'prompt.md'), prompt);
-  writeFileSync(join(dir, 'schema.json'), JSON.stringify(judgeSchema(criteria), null, 2));
+  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.

package/lib/report.js

@@ -1,43 +1,19 @@
 /**
- * Builds report.json. judges holds the criterion indexes of each judge, and outcomes the
- * { results } or { error } of each judge, in the same order. The lowest score of a criterion
- * counts, and a criterion of a failed judge gets score null.
+ * Builds report.json: { panel: "owner/name@version", target, status, criteria }. outcomes holds the
+ * { answer } or { error } of the judge of each criterion, in panel order. A criterion whose judge failed
+ * gets score null and the error as its verdict, and the run status is error. The panel passes only when
+ * every criterion scores 4.
  */
-export function buildReport({ panel, target, cwd, harness, judges, outcomes }) {
-  const errors = outcomes.flatMap((o, j) => (o.error ? [{ judge: j + 1, message: o.error }] : []));
-  const failed = new Set(errors.flatMap((e) => judges[e.judge - 1]));
-  const answers = judges.flatMap((indexes, j) => (outcomes[j].results ?? []).map((result, x) => ({ i: indexes[x], judge: j + 1, result })));
+export function buildReport({ panel, target, outcomes }) {
   const criteria = panel.criteria.map((c, i) => {
-    const mine = answers.filter((a) => a.i === i).map(({ judge, result }) => ({ judge, result }));
-    return { rank: i + 1, name: c.name, score: failed.has(i) ? null : Math.min(...mine.map((a) => a.result.score)), judges: mine };
+    const { answer, error } = outcomes[i];
+    return answer ? { name: c.name, score: answer.score, verdict: answer.verdict } : { name: c.name, score: null, verdict: `error: ${error}` };
   });
   const status = criteria.some((c) => c.score === null) ? 'error' : criteria.every((c) => c.score === 4) ? 'pass' : 'fail';
-  return { status, panel: { owner: panel.owner, name: panel.name, version: panel.version }, target, cwd, harness, size: judges.length, criteria, errors };
+  return { panel: `${panel.owner}/${panel.name}@${panel.version}`, target, status, criteria };
 }
 
-const cell = (text) => text.replaceAll('|', '\\|').replaceAll('\n', ' ');
-
-export function renderMarkdown(report) {
-  const { status, panel, target, criteria, errors } = report;
-  const lines = [
-    `${status.toUpperCase()}  ${panel.owner}/${panel.name} v${panel.version} on ${JSON.stringify(target)}  (${criteria.filter((c) => c.score === 4).length} of ${criteria.length} criteria at 4)`,
-    '',
-    '| # | Criterion | Score | Verdict |',
-    '|---|---|---|---|',
-  ];
-  for (const c of criteria) {
-    const lowest = c.judges.find((a) => a.result.score === c.score);
-    lines.push(`| ${c.rank} | ${cell(c.name)} | ${c.score ?? 'error'} | ${cell(lowest?.result.verdict ?? '')} |`);
-  }
-  const list = (title, items) => items.length && lines.push(title, ...items.map((item) => `- ${item}`));
-  for (const c of criteria) {
-    for (const { result } of c.judges) {
-      lines.push('', `## ${c.rank}. ${c.name}: ${result.score} (band ${result.band})`);
-      list('Evidence', result.evidence.map((e) => `${e.where}: ${e.quote ?? e.claim}`));
-      list('Fixes', result.fixes.map((f) => `${f.problem} ${f.change} (${f.where})`));
-      list('Not checked', result.notChecked.map((n) => `${n.test}: ${n.reason}`));
-    }
-  }
-  if (errors.length) lines.push('', '## Errors', ...errors.map((e) => `- judge ${e.judge}: ${e.message}`));
-  return `${lines.join('\n')}\n`;
+/** The lines that the plain mode prints: "N/4  name" and the verdict under it, for each criterion. */
+export function renderPlain(report) {
+  return report.criteria.flatMap((c) => [`${c.score === null ? 'err' : `${c.score}/4`}  ${c.name}`, `    ${c.verdict}`, '']);
 }

package/lib/table.js

@@ -1,12 +1,12 @@
-// The terminal mode of `panels run`: the score table, and a view of each judge. Each judge runs its interactive
+// The terminal mode of `panels run`: the overview, and a view of each judge. Each judge runs its interactive
 // harness in a pseudo-terminal, and a headless terminal keeps its screen for the switch to its view.
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join, relative } from 'node:path';
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+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 { check, MINUTES_PER_CRITERION, parseAnswer, writeJudge } from './judge.js';
-import { buildReport, renderMarkdown } from './report.js';
+import { buildReport } from './report.js';
 
 const LIVE_JUDGES = 10;
 // A harness asks this in a folder it has not seen. Only the first judge starts until its screen no longer asks,
@@ -17,117 +17,207 @@ const ORANGE = '\x1b[38;2;255;106;61m';
 const GREY = '\x1b[90m';
 const BOLD = '\x1b[1m';
 const RESET = '\x1b[0m';
+// The colour of a score, from the 16-colour palette: 4 green, 3 the default ink, 2 yellow, 1 red.
+const SCORE_COLOUR = { 4: '\x1b[32m', 3: '', 2: '\x1b[33m', 1: '\x1b[31m' };
+const LEVELS = { 1: 'Fails', 2: 'Falls short', 3: 'Almost met', 4: 'Met' };
 // ctrl-q moves the focus between a judge and the tab strip. A terminal in the kitty keyboard mode sends it as CSI 113;5u.
 const TOGGLE = ['\x11', '\x1b[113;5u'];
 const RIGHT = ['\x1b[C', '\x1bOC'];
 const LEFT = ['\x1b[D', '\x1bOD'];
+const UP = ['\x1b[A', '\x1bOA'];
+const DOWN = ['\x1b[B', '\x1bOB'];
 // Enter, Esc, or ctrl-q give the focus back to the judge of the active tab.
 const BACK = ['\r', '\x1b', ...TOGGLE];
-// Turns off each mode that the screen of a judge can turn on, so the table gets the keys and the screen as before.
+// Turns off each mode that the screen of a judge can turn on, so the overview gets the keys and the screen as before.
 const TABLE_MODES = '\x1b[?1049h\x1b[r\x1b[0m\x1b[4l\x1b[?6l\x1b[?7h\x1b[?1l\x1b>\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1004l\x1b[?2004l\x1b[<u\x1b[?25l\x1b[2J';
+// The glimmer on the text of the running judges: grey text, and one soft wave three columns wide that moves one
+// column per frame from the left edge of the screen to the right edge and starts over. A running label lights
+// up only where the wave passes over its own columns, so every running label lights at the same columns.
+const GLIMMER = { base: '\x1b[38;5;244m', mid: '\x1b[38;5;247m', high: '\x1b[38;5;250m' };
+const GLIMMER_ORANGE = { base: ORANGE, mid: '\x1b[38;2;255;140;100m', high: '\x1b[38;2;255;175;145m' };
+const WAVE = 3;
+// The tab strip takes the last three lines of the terminal: a hairline, the tabs, then the status and the keys.
+const STRIP_ROWS = 3;
+// The overview shows two columns from this width up, and the list above the detail below it.
+const TWO_COLUMNS = 100;
 
 /**
- * The lines of the table. rows hold { rank, name, state, result, trust }, and state is queued, running, done, or error.
- * trust is true while the harness of a running judge asks whether to trust the folder.
- * final is null until the report exists, then { status, path }. confirm is true while q waits for y.
+ * text with the glimmer at frame, where the text starts at the screen column start (0-based) on a screen width
+ * columns wide. colours is { base, mid, high }; prefix (such as bold) goes before each piece.
  */
-// The glimmer on the text of a running judge: grey text, and a bright highlight three characters wide that
-// sweeps from left to right one character per frame and wraps.
-const GLIMMER = { base: '\x1b[38;5;244m', mid: '\x1b[38;5;250m', high: '\x1b[38;5;255m' };
-const GLIMMER_ORANGE = { base: ORANGE, mid: '\x1b[38;2;255;170;140m', high: '\x1b[38;5;255m' };
-
-/** text with the glimmer at frame. colours is { base, mid, high }; prefix (such as bold) goes before each piece. */
-export function glimmer(text, frame, colours = GLIMMER, prefix = '') {
-  const centre = frame % text.length;
+export function glimmer(text, frame, start, width, colours = GLIMMER, prefix = '') {
+  const centre = (frame % (width + WAVE)) - 1;
   return [...text].map((c, i) => {
-    const d = Math.min(Math.abs(i - centre), text.length - Math.abs(i - centre));
+    const d = Math.abs(start + i - centre);
     return `${prefix}${d === 0 ? colours.high : d === 1 ? colours.mid : colours.base}${c}`;
   }).join('') + RESET;
 }
-// The tab strip takes the last three lines of the terminal: a hairline, the tabs, then the status and the keys.
-const STRIP_ROWS = 3;
 
-export function render({ title, rows, final, confirm, width, frame = 0 }) {
-  const rule = `${GREY}${'─'.repeat(width)}${RESET}`;
-  const pad = Math.max(...rows.map((r) => r.name.length)) + 2;
-  const lines = [` ${BOLD}panels run${RESET}  ${title}`, rule];
-  for (const r of rows) {
-    const head = `${String(r.rank).padStart(3)}  ${r.name.padEnd(pad)}`;
-    if (r.state === 'running' && r.trust) lines.push(`${ORANGE}${head}press ${r.rank} and answer the trust prompt${RESET}`);
-    else if (r.state === 'running') lines.push(`${String(r.rank).padStart(3)}  ${glimmer(r.name, frame)}`);
-    else if (r.state === 'queued') lines.push(`${head}${GREY}queued${RESET}`);
-    else if (r.state === 'error') lines.push(`${head}error`);
-    else lines.push(`${head}${r.result.score}/4`);
+/** m:ss for a number of seconds. */
+export const clock = (seconds) => `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, '0')}`;
+
+/** "12.4k" for 12400 tokens, "0.3k" for 300, "1.2M" from a million, and "" for none. */
+export function tokensText(n) {
+  if (n === null || n === undefined) return '';
+  return n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : `${(n / 1000).toFixed(1)}k`;
+}
+
+/**
+ * The largest token count on the screen of a judge, or null. Claude shows "↓ 354 tokens" and a context count
+ * such as "12532 tokens"; Codex shows its count with a k or M suffix. The largest number before "tokens" wins.
+ */
+export function tokensOnScreen(text) {
+  let best = null;
+  for (const m of text.matchAll(/(\d[\d,]*(?:\.\d+)?)\s*([kKmM])?\s*tokens/g)) {
+    const n = Number(m[1].replaceAll(',', '')) * (m[2] ? { k: 1e3, m: 1e6 }[m[2].toLowerCase()] : 1);
+    if (best === null || n > best) best = n;
   }
-  lines.push(rule);
-  if (final) {
-    const at4 = rows.filter((r) => r.state === 'done' && r.result.score === 4).length;
-    lines.push(` ${BOLD}${final.status.toUpperCase()}${RESET}  ${at4} of ${rows.length} at 4`, ` report ${final.path}`);
+  return best;
+}
+
+const plainLength = (s) => s.replace(/\x1b\[[0-9;]*m/g, '').length;
+const padTo = (s, width) => s + ' '.repeat(Math.max(0, width - plainLength(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) {
+  let seen = 0;
+  let out = '';
+  for (const part of line.split(/(\x1b\[[0-9;]*m)/)) {
+    if (part.startsWith('\x1b')) { out += part; continue; }
+    const room = Math.max(0, width - seen);
+    out += [...part].slice(0, room).join('');
+    seen += Math.min([...part].length, room);
+  }
+  return out;
+}
+
+/** The words of text in lines of at most width characters. */
+export function wrap(text, width) {
+  const lines = [];
+  let line = '';
+  for (const word of text.split(/\s+/).filter(Boolean)) {
+    if (line && line.length + 1 + word.length > width) { lines.push(line); line = word; }
+    else line = line ? `${line} ${word}` : word;
   }
-  if (confirm) lines.push(' judges still run. y quits, another key stays');
+  if (line) lines.push(line);
   return lines;
 }
 
+/** 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 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 the scores; each judge
- * tab reads "N name mark". A running judge has no mark and its label glimmers. The mark is the score (bold at
- * 4), ✗ for an error, · while queued, or ! while the harness asks whether to trust the folder. The names step
- * down to fit the width: the whole name, the first word, or no name. focus is 'strip' (the active tab is bold
- * orange, the arrows move it) or 'judge' (the active tab is bold ink, the keys go to the judge).
+ * 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, target,
+ * harness, elapsed. Two columns from TWO_COLUMNS wide, the list above the detail below that.
  */
-export function renderStrip({ rows, view, final, frame = 0, width, focus = 'strip', elapsed = 0 }) {
-  const mark = (r) => {
-    if (r.state === 'running') return r.trust ? '!' : '';
-    if (r.state === 'queued') return '·';
-    if (r.state === 'error') return '✗';
-    return `${r.result.score}/4`;
+export function renderOverview({ title, target, harness, elapsed, rows, cursor, width, frame = 0 }) {
+  const header = ` ${BOLD}panels run${RESET}  ${title}${GREY}        ${target}   ${harness}   ${clock(elapsed)}${RESET}`;
+  const rule = `${GREY}${'─'.repeat(width)}${RESET}`;
+  const pad = Math.max(...rows.map((r) => r.name.length));
+  const leftWidth = pad + 27;
+  const cells = (score, time, tokens) => `   ${score.padStart(3)}  ${time.padStart(5)}  ${tokens.padStart(6)}`;
+  const left = rows.map((r, i) => {
+    const current = i === cursor;
+    const mark = current ? `${ORANGE}▸${RESET} ` : '  ';
+    const rank = `${String(r.rank).padStart(2)}  `;
+    const time = r.time === null ? '' : clock(r.time);
+    const tokens = tokensText(r.tokens);
+    if (r.state === 'running' && !r.trust) {
+      const name = glimmer(r.name.padEnd(pad), frame, 6, width, current ? GLIMMER_ORANGE : GLIMMER);
+      return `${mark}${current ? ORANGE : ''}${rank}${RESET}${name}${current ? ORANGE : GREY}${cells('', time, tokens)}${RESET}`;
+    }
+    const score = r.state === 'done' ? `${r.result.score}/4` : r.state === 'error' ? '✗' : '';
+    const colour = current ? ORANGE : r.state === 'done' ? SCORE_COLOUR[r.result.score] : r.state === 'error' ? SCORE_COLOUR[1] : '';
+    const name = current ? `${ORANGE}${r.name.padEnd(pad)}${RESET}` : r.state === 'queued' ? `${GREY}${r.name.padEnd(pad)}${RESET}` : r.name.padEnd(pad);
+    const rest = r.state === 'running' ? `${ORANGE}press ${r.rank} and answer the trust prompt${RESET}` : `${colour}${cells(score, time, tokens)}${RESET}`;
+    return `${mark}${current ? ORANGE : ''}${rank}${RESET}${name}${rest}`;
+  });
+  const done = rows.filter((r) => r.state === 'done');
+  const total = cells(`${quarters(done.reduce((n, r) => n + r.result.score, 0))}/${rows.length}`, 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));
+  left.push(`${GREY}${'─'.repeat(leftWidth)}${RESET}`, `${padTo('      total', leftWidth - total.length)}${total}`);
+
+  const row = rows[cursor];
+  const right = [];
+  const detail = (columnWidth) => {
+    right.length = 0;
+    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()}`;
+    right.push(`${BOLD}${name}${RESET}${' '.repeat(Math.max(1, columnWidth - name.length - level.length))}${GREY}${level}${RESET}`, '');
+    const text = row.state === 'done' ? row.result.verdict
+      : row.state === 'error' ? row.error
+        : row.state === 'queued' ? 'The judge has not started.'
+          : row.restarted !== null ? `Restarted with ${row.harness} ${clock(row.restarted)} ago. Press ${row.rank} to watch it.`
+            : `The judge has run for ${clock(row.time ?? 0)}. Press ${row.rank} to watch it.`;
+    right.push(...wrap(text, columnWidth), '');
+    right.push(`${ORANGE}r${RESET} restart   ${ORANGE}h${RESET} harness ${row.harness}   ${ORANGE}${row.rank}${RESET} watch`, '');
+    const facts = [`judge ${row.rank}`, row.harness, ...(row.time === null ? [] : [clock(row.time)]), ...(row.state === 'done' || row.state === 'error' ? [`judges/${row.rank}/answer.json`] : [])];
+    right.push(`${GREY}${facts.join(' · ')}${RESET}`);
   };
+
+  const lines = [header, rule];
+  if (width >= TWO_COLUMNS) {
+    detail(width - leftWidth - 3);
+    for (let i = 0; i < Math.max(left.length, right.length); i++) lines.push(`${padTo(left[i] ?? '', leftWidth)}${GREY} │ ${RESET}${right[i] ?? ''}`);
+  } else {
+    detail(width - 2);
+    lines.push(...left, '', ...right.map((l) => `  ${l}`));
+  }
+  return lines.map((l) => clip(l, width));
+}
+
+/**
+ * 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 the 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) 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 clock = `${Math.floor(elapsed / 60)}:${String(elapsed % 60).padStart(2, '0')}`;
-  const keys = focus === 'strip' ? '← → tabs · enter back · q quit' : 'ctrl-q tabs';
-  const tabs = (level) => [
-    { rank: '', name: final ? `scores ${final.status.toUpperCase()}` : 'scores', mark: '' },
-    ...rows.map((r) => ({ rank: String(r.rank), name: level === 0 ? r.name : level === 1 ? r.name.split(' ')[0] : '', mark: mark(r) })),
-  ];
-  const plain = (t) => [t.rank, t.name, t.mark].filter(Boolean).join(' ');
-  const used = (list) => 1 + list.reduce((n, t) => n + plain(t).length, 0) + 2 * (list.length - 1);
-  const list = [0, 1, 2].map(tabs).find((l) => used(l) <= width) ?? tabs(2);
+  const keys = focus === 'judge' ? 'ctrl-q tabs' : 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]))];
+  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);
   let line = ' ';
-  list.forEach((t, i) => {
-    if (i) line += '  ';
+  let col = 1;
+  list.forEach((text, i) => {
+    if (i) { line += `${GREY} │ ${RESET}`; col += 3; }
     const active = i === view;
-    const base = active ? (focus === 'strip' ? `${ORANGE}${BOLD}` : BOLD) : GREY;
-    const text = plain(t);
     const row = rows[i - 1];
+    const start = col;
+    col += text.length;
     if (row?.state === 'running' && !row.trust) {
-      line += glimmer(text, frame, active && focus === 'strip' ? GLIMMER_ORANGE : GLIMMER, active ? BOLD : '');
+      line += glimmer(text, frame, start, width, active && focus === 'strip' ? GLIMMER_ORANGE : GLIMMER, active ? BOLD : '');
       return;
     }
-    const pieces = [];
-    if (t.rank) pieces.push(`${base}${t.rank}${RESET}`);
-    if (t.name) pieces.push(`${base}${t.name}${RESET}`);
-    if (t.mark) pieces.push(`${row.state === 'done' && row.result.score === 4 ? `${base}${BOLD}` : base}${t.mark}${RESET}`);
-    line += pieces.join(' ');
+    line += `${active ? (focus === 'strip' ? `${ORANGE}${BOLD}` : BOLD) : GREY}${text}${RESET}`;
   });
-  const progress = `${finished} of ${rows.length} done · ${clock}`;
-  const status = ` ${progress}${' '.repeat(Math.max(2, width - progress.length - keys.length - 2))}${keys}`;
-  return [`${GREY}${'─'.repeat(width)}${RESET}`, line, `${GREY}${status}${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}`;
+  return [`${GREY}${'─'.repeat(width)}${RESET}`, clip(line, width), `${GREY}${clip(status, width)}${RESET}`];
 }
 
 /**
- * The next { view, confirm, focus } after one key, plus send: true when the key goes to the judge, or quit: true.
- * view is 0 for the scores, or N for judge N. open holds the ranks of the judges that have started. 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 move the active tab and switch the view, 1-9 jump to a started judge, 0 to the
- * scores, Enter, Esc, or ctrl-q give the focus back to the judge, and q quits (y confirms while a judge runs).
- * The scores take no input, so the strip keeps the focus there.
+ * The next { view, confirm, focus, cursor } 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. 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, and h flips its harness.
  */
-export function press({ view, confirm, focus }, key, { open, running }) {
-  const strip = (v) => ({ view: v, confirm: false, focus: 'strip' });
-  if (focus === 'judge') return TOGGLE.includes(key) ? strip(view) : { view, confirm, focus, send: true };
-  if (confirm) return { ...strip(0), quit: key === 'y' };
-  if (key === 'q') return running ? { view: 0, confirm: true, focus: 'strip' } : { ...strip(0), quit: true };
+export function press({ view, confirm, focus, cursor }, key, { open, running, count }) {
+  const strip = (v) => ({ view: v, confirm: false, focus: 'strip', cursor });
+  if (focus === 'judge') return TOGGLE.includes(key) ? strip(view) : { view, confirm, focus, cursor, send: true };
+  if (confirm) return { ...strip(0), quit: key === 'q' };
+  if (key === 'q') return running ? { view: 0, confirm: true, focus: 'strip', cursor } : { ...strip(0), quit: true };
   if (RIGHT.includes(key) || LEFT.includes(key)) {
     const cycle = [0, ...open];
     const step = RIGHT.includes(key) ? 1 : -1;
@@ -135,18 +225,27 @@ export function press({ view, confirm, focus }, key, { open, running }) {
   }
   if (/^[1-9]$/.test(key)) return open.includes(Number(key)) ? strip(Number(key)) : strip(view);
   if (key === '0') return strip(0);
-  if (BACK.includes(key) && view) return { view, confirm: false, focus: 'judge' };
+  if (view === 0) {
+    if (UP.includes(key)) return { ...strip(0), cursor: Math.max(0, cursor - 1) };
+    if (DOWN.includes(key)) return { ...strip(0), cursor: Math.min(count - 1, cursor + 1) };
+    if (key === 'r') return open.includes(cursor + 1) ? { ...strip(0), restart: cursor + 1 } : strip(0);
+    if (key === 'h') return { ...strip(0), flip: cursor + 1 };
+    return strip(0);
+  }
+  if (BACK.includes(key)) return { view, confirm: false, focus: 'judge', cursor };
   return strip(view);
 }
 
-/** Runs the judges, shows the table, and writes the report. Resolves when the engineer quits. */
+/** 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 }) {
   const out = process.stdout;
   const criteria = panel.criteria.map((c, i) => ({ rank: 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' };
+  let ui = { view: 0, confirm: false, focus: 'strip', cursor: 0 };
   let stripTimer;
   let lastData = 0;
   const started = Date.now();
@@ -154,37 +253,45 @@ export function runTable({ panel, runDir, harness, cwd, target, brief, sources }
   const judgeDir = (rank) => join(runDir, 'judges', String(rank));
   // A judge gets the lines above the tab strip.
   const size = () => ({ cols: out.columns, rows: out.rows - STRIP_ROWS });
+  const seconds = (from, to = Date.now()) => Math.floor((to - from) / 1000);
+
+  function screenText(j) {
+    const buffer = j.term.buffer.active;
+    const lines = [];
+    for (let y = 0; y < buffer.length; y++) lines.push(buffer.getLine(y).translateToString(true));
+    return lines.join(' ');
+  }
 
   function state(c, i) {
+    const j = judges[i];
+    const facts = { harness: harnesses[i], time: j ? seconds(j.started, j.finished) : null, tokens: j?.tokens ?? null, restarted: j?.restartedAt ? seconds(j.restartedAt) : null };
     const file = join(judgeDir(c.rank), 'answer.json');
     if (existsSync(file)) {
+      if (j && !j.finished) j.finished = Date.now();
+      facts.time = j ? seconds(j.started, j.finished) : null;
       const answer = parseAnswer(readFileSync(file, 'utf8'));
-      const errors = check(answer, [c]);
-      return errors.length ? { state: 'error', error: `invalid answer: ${errors.join(' ')}` } : { state: 'done', result: answer.results[0] };
+      const errors = check(answer, c);
+      return errors.length ? { ...facts, state: 'error', error: `invalid answer: ${errors.join(' ')}` } : { ...facts, state: 'done', result: answer };
     }
-    if (judges[i] === undefined) return { state: 'queued' };
-    if (Date.now() - judges[i].started > MINUTES_PER_CRITERION * 60_000) return { state: 'error', error: `no answer.json after ${MINUTES_PER_CRITERION} minutes` };
-    return { state: 'running', trust: asksTrust(judges[i]) };
+    if (j === undefined) return { ...facts, state: 'queued' };
+    if (Date.now() - j.started > MINUTES_PER_CRITERION * 60_000) return { ...facts, state: 'error', error: `no answer.json after ${MINUTES_PER_CRITERION} minutes` };
+    const screen = screenText(j);
+    const tokens = tokensOnScreen(screen);
+    if (tokens !== null) j.tokens = tokens;
+    return { ...facts, tokens: j.tokens ?? null, state: 'running', trust: TRUST_PROMPT.test(screen) };
   }
 
-  function asksTrust(j) {
-    const buffer = j.term.buffer.active;
-    const lines = [];
-    for (let y = 0; y < buffer.length; y++) lines.push(buffer.getLine(y).translateToString(true));
-    return TRUST_PROMPT.test(lines.join(' '));
-  }
-
-  function start(rank) {
-    const [command, ...argv] = writeJudge({ dir: judgeDir(rank), criteria: [criteria[rank - 1]], 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 });
     const { cols, rows: lines } = size();
     const term = new xterm.Terminal({ cols, rows: lines, allowProposedApi: true });
     const serializer = new SerializeAddon();
     term.loadAddon(serializer);
     const proc = pty.spawn(command, argv, { name: 'xterm-256color', cols, rows: lines, cwd, env: process.env });
-    const j = { started: Date.now(), term, serializer, proc, modes: { 25: 'h', 1006: 'l' }, exited: false };
+    const j = { started: Date.now(), finished: undefined, restartedAt, tokens: null, term, serializer, proc, modes: { 25: 'h', 1006: 'l' }, exited: false };
     // The write callback keeps the order of the live output and of the screen that showJudge writes.
     proc.onData((data) => term.write(data, () => {
-      if (ui.view !== rank) return;
+      if (ui.view !== rank || judges[rank - 1] !== j) return;
       out.write(data);
       lastData = Date.now();
       stripSoon();
@@ -202,10 +309,23 @@ export function runTable({ panel, runDir, harness, cwd, target, brief, sources }
     judges[rank - 1] = j;
   }
 
+  // The harness on PATH can be a shell script that runs the real binary as a child and waits for it, so
+  // SIGHUP goes to the process group of the judge. The pty makes each judge the leader of its own group.
+  const stop = (j) => { if (j && !j.exited) process.kill(-j.proc.pid, 'SIGHUP'); };
+
+  /** Stops judge rank, drops its answer, and starts it again with its harness. The report is written again later. */
+  function restart(rank) {
+    stop(judges[rank - 1]);
+    const file = join(judgeDir(rank), 'answer.json');
+    if (existsSync(file)) unlinkSync(file);
+    start(rank, Date.now());
+    final = null;
+  }
+
   // In a judge, the strip hides the cursor while it draws and then puts it back where the judge had it. A cursor
   // past the last column waits for the next character to wrap; a move there would lose that, so the strip waits.
   function drawStrip() {
-    const lines = renderStrip({ rows, view: ui.view, final, frame, width: out.columns, focus: ui.focus, elapsed: Math.floor((Date.now() - started) / 1000) });
+    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}`);
@@ -225,7 +345,7 @@ export function runTable({ panel, runDir, harness, cwd, target, brief, sources }
     const j = judges[rank - 1];
     j.term.write('', () => {
       if (ui.view !== rank) return;
-      // The table already holds the alternate screen, so a judge on its alternate screen gets a clear after
+      // The overview already holds the alternate screen, so a judge on its alternate screen gets a clear after
       // the normal screen, which the serializer writes first. The scroll region keeps the judge above the strip.
       const screen = j.serializer.serialize({ scrollback: 0 }).replace('\x1b[?1049h\x1b[H', '$&\x1b[2J');
       out.write(`${RESET}\x1b[H\x1b[2J\x1b[1;${out.rows - STRIP_ROWS}r${screen}${Object.entries(j.modes).map(([mode, final]) => `\x1b[?${mode}${final}`).join('')}`);
@@ -234,25 +354,23 @@ export function runTable({ panel, runDir, harness, cwd, target, brief, sources }
   }
 
   function finish() {
-    const outcomes = rows.map((r) => (r.state === 'done' ? { results: [r.result] } : { error: r.error }));
-    const report = buildReport({ panel, target, cwd, harness, judges: rows.map((_, i) => [i]), outcomes });
-    const reportPath = join(runDir, 'report.json');
-    writeFileSync(join(runDir, 'report.md'), renderMarkdown(report));
-    writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`);
-    final = { status: report.status, path: relative(cwd, reportPath) };
+    const outcomes = rows.map((r) => (r.state === 'done' ? { answer: r.result } : { error: r.error }));
+    const report = buildReport({ panel, target, outcomes });
+    writeFileSync(join(runDir, 'report.json'), `${JSON.stringify(report, null, 2)}\n`);
+    final = { status: report.status };
   }
 
   let frame = 0;
   function draw() {
-    const lines = render({ title: `${panel.owner}/${panel.name} v${panel.version}`, rows, final, confirm: ui.confirm, width: Math.min(out.columns, 100), frame });
+    const lines = renderOverview({ title: `${panel.owner}/${panel.name} v${panel.version}`, target, harness, elapsed: seconds(started), rows, cursor: ui.cursor, width: out.columns, 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();
   }
 
   function tick() {
+    rows = criteria.map((c, i) => ({ ...c, ...state(c, i) }));
     if (!final) {
-      rows = criteria.map((c, i) => ({ ...c, ...state(c, i) }));
       const live = rows.filter((r) => r.state === 'running').length;
       const first = judges[0];
       const hold = first && !first.exited && (Date.now() - first.started < FIRST_JUDGE_HEAD_START || rows[0].trust);
@@ -270,7 +388,6 @@ export function runTable({ panel, runDir, harness, cwd, target, brief, sources }
     const timer = setInterval(tick, 1000);
     const spinner = setInterval(() => {
       frame += 1;
-      if (final) return;
       if (!ui.view) draw();
       else if (Date.now() - lastData > 60) drawStrip();
     }, 100);
@@ -279,20 +396,24 @@ export function runTable({ panel, runDir, harness, cwd, target, brief, sources }
     process.stdin.on('data', (data) => {
       const key = data.toString();
       const from = ui.view;
-      const next = press(ui, key, { open: judges.flatMap((j, i) => (j ? [i + 1] : [])), running: rows.some((r) => r.state === 'running') });
-      ui = { view: next.view, confirm: next.confirm, focus: next.focus };
+      const next = press(ui, key, { open: judges.flatMap((j, i) => (j ? [i + 1] : [])), running: rows.some((r) => r.state === 'running'), count: criteria.length });
+      ui = { view: next.view, confirm: next.confirm, focus: next.focus, cursor: next.cursor };
       if (next.send) {
         judges[from - 1].proc.write(key);
       } else if (next.quit) {
         clearInterval(timer);
         clearInterval(spinner);
-        // The harness on PATH can be a shell script that runs the real binary as a child and waits for it, so
-        // SIGHUP goes to the process group of the judge. The pty makes each judge the leader of its own group.
-        for (const j of judges) if (j && !j.exited) process.kill(-j.proc.pid, 'SIGHUP');
+        for (const j of judges) stop(j);
         out.write(`${TABLE_MODES}\x1b[?25h\x1b[?1049l`);
         process.stdin.setRawMode(false);
         process.stdin.pause();
         done();
+      } else if (next.restart) {
+        restart(next.restart);
+        tick();
+      } else if (next.flip) {
+        harnesses[next.flip - 1] = harnesses[next.flip - 1] === 'claude' ? 'codex' : 'claude';
+        tick();
       } else if (ui.view && ui.view === from) {
         drawStrip();
       } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xsft/panels",
-  "version": "0.5.2",
+  "version": "0.7.0",
   "private": false,
   "description": "Run a panel of AI judges from cross.software/panels against a target.",
   "type": "module",

package/prompts/judge-system-prompt.txt

@@ -1,9 +1,9 @@
-You are one judge in a run of a panel. A panel is a named list of criteria. You score one or more criteria against a target, and you name the fixes for each criterion that does not pass.
+You are one judge in a run of a panel. A panel is a named list of criteria. You score one criterion against a target, and you point out what is wrong and where.
 
 YOUR INPUTS
 
 The user message gives you:
-- Each 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. Follow the body as written.
 - 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".
@@ -12,80 +12,52 @@ Your working directory is the folder where the engineer ran the command.
 
 THE TARGET
 
-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, add the test to notChecked with the reason. Then score as the body says for that case. Never score what you did not see.
+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.
 
 ORDER
 
-Score your criteria one at a time, in rank order. Before you read the brief or the sources, do every step that one of your bodies puts before them.
+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.
 
 HOW TO SCORE
 
-1. Follow the body to a level from 1 to 10. The body calls this level a score. Here it is the band.
-2. Apply each cap of the body, such as "cannot support a score above 8". When two caps apply, use the lower cap.
-3. When the evidence fits two bands, use the lower band.
-4. Convert the band to the score with this map:
-   band 1 to 3  = score 1
-   band 4 to 6  = score 2
-   band 7 or 8  = score 3
-   band 9 or 10 = score 4
-5. A criterion passes only at score 4.
+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.
+- 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.
-- No evidence for a band means the lower band.
-- At band 9, name the one specific gap of the body in the evidence.
+- No evidence for a level means the lower level.
 
-RECORDS AND FIXES
+THE VERDICT
 
-- Put each record and table that the body tells you to write in records, with the columns of the body.
-- Below score 4, list each fix that score 4 needs: the problem, the change, and the place.
+One paragraph of 600 characters at most: 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.
 
 PROHIBITIONS
 
-- Do not change the body, the bands, the caps, or the map.
+- 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. Name each fix, and do not make it.
+- Do not write or change files, except the answer file when the user message names one.
+- Do not start sub-agents.
 - Do not submit forms, send messages, or post data.
 - Do not read the .panels folder. It holds earlier reports.
 
 OUTPUT
 
-Return one JSON object and nothing else. Give one item in results for each of your criteria, in rank order.
+Return one JSON object and nothing else:
 
 {
-  "results": [{
-    "rank": integer,
-    "criterion": string,
-    "band": integer 1 to 10,
-    "score": integer 1 to 4,
-    "verdict": string, one sentence of 30 words or less,
-    "records": [{ "name": string, "columns": [string], "rows": [[string]] }],
-    "evidence": [{ "claim": string, "where": string, "quote": string or null }],
-    "notChecked": [{ "test": string, "reason": string }],
-    "fixes": [{ "problem": string, "change": string, "where": string }]
-  }]
+  "name": string, the name of your criterion,
+  "score": integer 1 to 4,
+  "verdict": string, one paragraph, 600 characters at most
 }
 
-Example of one item:
+Example:
 
 {
-  "rank": 5,
-  "criterion": "Original design assets",
-  "band": 5,
+  "name": "Original design assets",
   "score": 2,
-  "verdict": "The hero shows the real app, and the six feature icons are Lucide icons.",
-  "records": [{
-    "name": "asset table",
-    "columns": ["asset", "provenance", "product test", "verdict"],
-    "rows": [["feature icons (6)", "class \"lucide\"", "generic symbols", "generic"]]
-  }],
-  "evidence": [{ "claim": "The icons come from Lucide.", "where": "src/components/Features.tsx:3", "quote": "import { Zap } from \"lucide-react\"" }],
-  "notChecked": [{ "test": "reverse image search of hero.webp", "reason": "the target is on localhost" }],
-  "fixes": [{
-    "problem": "Library icons carry the feature grid.",
-    "change": "Draw each icon as an object of this product.",
-    "where": "src/components/Features.tsx, home section #features"
-  }]
+  "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."
 }

package/schema/report.json

@@ -2,123 +2,36 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "additionalProperties": false,
-  "required": ["status", "panel", "target", "cwd", "harness", "size", "criteria", "errors"],
+  "required": ["panel", "target", "status", "criteria"],
   "properties": {
-    "status": { "enum": ["pass", "fail", "error"] },
-    "panel": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["owner", "name", "version"],
-      "properties": {
-        "owner": { "type": "string" },
-        "name": { "type": "string" },
-        "version": { "type": "integer" }
-      }
-    },
+    "panel": { "type": "string", "description": "owner/name@version" },
     "target": { "type": "string" },
-    "cwd": { "type": "string" },
-    "harness": { "enum": ["claude", "codex"] },
-    "size": { "type": "integer", "minimum": 1 },
+    "status": { "enum": ["pass", "fail", "error"] },
     "criteria": {
       "type": "array",
+      "description": "One item per criterion of the panel, in panel order. A criterion whose judge failed has score null and the error as its verdict.",
       "items": {
         "type": "object",
         "additionalProperties": false,
-        "required": ["rank", "name", "score", "judges"],
+        "required": ["name", "score", "verdict"],
         "properties": {
-          "rank": { "type": "integer" },
           "name": { "type": "string" },
           "score": { "type": ["integer", "null"], "minimum": 1, "maximum": 4 },
-          "judges": {
-            "type": "array",
-            "items": {
-              "type": "object",
-              "additionalProperties": false,
-              "required": ["judge", "result"],
-              "properties": {
-                "judge": { "type": "integer" },
-                "result": { "$ref": "#/$defs/judgeResult" }
-              }
-            }
-          }
-        }
-      }
-    },
-    "errors": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "additionalProperties": false,
-        "required": ["judge", "message"],
-        "properties": {
-          "judge": { "type": "integer" },
-          "message": { "type": "string" }
+          "verdict": { "type": "string" }
         }
       }
     }
   },
   "$defs": {
-    "judgeResult": {
+    "criterion": {
+      "description": "The answer of one judge: one criterion object. The name is fixed to the criterion of the judge.",
       "type": "object",
       "additionalProperties": false,
-      "required": ["rank", "criterion", "band", "score", "verdict", "records", "evidence", "notChecked", "fixes"],
+      "required": ["name", "score", "verdict"],
       "properties": {
-        "rank": { "type": "integer" },
-        "criterion": { "type": "string" },
-        "band": { "type": "integer", "minimum": 1, "maximum": 10 },
+        "name": { "type": "string" },
         "score": { "type": "integer", "minimum": 1, "maximum": 4 },
-        "verdict": { "type": "string" },
-        "records": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "additionalProperties": false,
-            "required": ["name", "columns", "rows"],
-            "properties": {
-              "name": { "type": "string" },
-              "columns": { "type": "array", "items": { "type": "string" } },
-              "rows": { "type": "array", "items": { "type": "array", "items": { "type": "string" } } }
-            }
-          }
-        },
-        "evidence": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "additionalProperties": false,
-            "required": ["claim", "where", "quote"],
-            "properties": {
-              "claim": { "type": "string" },
-              "where": { "type": "string" },
-              "quote": { "type": ["string", "null"] }
-            }
-          }
-        },
-        "notChecked": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "additionalProperties": false,
-            "required": ["test", "reason"],
-            "properties": {
-              "test": { "type": "string" },
-              "reason": { "type": "string" }
-            }
-          }
-        },
-        "fixes": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "additionalProperties": false,
-            "required": ["problem", "change", "where"],
-            "properties": {
-              "problem": { "type": "string" },
-              "change": { "type": "string" },
-              "where": { "type": "string" }
-            }
-          }
-        }
+        "verdict": { "type": "string", "minLength": 1, "maxLength": 600, "description": "One paragraph: what holds, what is wrong and where (the place in brackets), and \"Not checked: ...\" at the end when something was not checked." }
       }
     }
   }