@xsft/panels 0.6.0 → 0.7.1

package/README.md

@@ -11,6 +11,8 @@ panels run <panel> [target...] [flags]
 --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
 
 exit 0  pass: every criterion scored 4
@@ -18,7 +20,7 @@ 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 with web fetch can send what it reads to a URL. 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, no sub-agents, 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
@@ -29,16 +31,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. Plain mode needs `--yolo`, because a background judge cannot answer a question; without it the command exits 2.
 
-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). One soft wave sweeps across the strip and lights the labels of the running judges as it passes; the same wave sweeps the running rows of the scores table. 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; 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 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 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.
+
+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.
@@ -29,7 +29,7 @@ const EXIT = { pass: 0, fail: 1, error: 2 };
 
 /** Runs the judges in the score table, and exits from report.json when the engineer quits. */
 async function runOnTerminal({ panel, runDir, harness, cwd, args }) {
-  await runTable({ panel, runDir, harness, cwd, target: args.target, brief: args.brief, sources: args.sources });
+  await runTable({ panel, runDir, harness, cwd, target: args.target, brief: args.brief, sources: args.sources, yolo: args.yolo });
   const reportPath = join(runDir, 'report.json');
   if (!existsSync(reportPath)) return 2;
   console.log(reportPath);
@@ -55,6 +55,11 @@ async function main() {
     console.error(`panels: harness missing: ${harness} is not on PATH`);
     return 2;
   }
+  // A judge without a terminal cannot answer a permission question.
+  if (!(process.stdout.isTTY && process.stdin.isTTY) && !args.yolo) {
+    console.error('panels: plain mode needs --yolo (judges cannot ask)');
+    return 2;
+  }
   const fetched = await fetchPanel(args.panel);
   if (fetched.error) {
     console.error(`panels: ${fetched.error}`);
@@ -62,27 +67,25 @@ 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,
+    yolo: true,
   }));
-  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/args.js

@@ -8,6 +8,8 @@ export const SYNOPSIS = `panels run <panel> [target...] [flags]
 --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
 
 exit 0  pass: every criterion scored 4
@@ -18,6 +20,7 @@ const options = {
   harness: { type: 'string' },
   brief: { type: 'string' },
   sources: { type: 'string', multiple: true },
+  yolo: { type: 'boolean' },
   help: { type: 'boolean' },
 };
 
@@ -29,7 +32,7 @@ export function parse(argv) {
   const { values, positionals, tokens } = parseArgs({ args: argv, options, strict: false, allowPositionals: true, tokens: true });
   for (const token of tokens.filter((t) => t.kind === 'option')) {
     if (!Object.hasOwn(options, token.name)) return { error: `unknown flag ${token.rawName}` };
-    if (token.name !== 'help' && token.value === undefined) return { error: `${token.rawName} needs a value` };
+    if (options[token.name].type === 'string' && token.value === undefined) return { error: `${token.rawName} needs a value` };
   }
   if (values.help) return { help: true };
   const [command, panel, ...words] = positionals;
@@ -44,5 +47,6 @@ export function parse(argv) {
     harness: values.harness,
     brief: values.brief,
     sources: values.sources ?? [],
+    yolo: Boolean(values.yolo),
   };
 }

package/lib/judge.js

@@ -2,51 +2,43 @@ 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 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:*)';
+// 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,
+// 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. 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.score) || r.score < 1 || r.score > 4) errors.push(`Rank ${c.rank}: score must be a whole number from 1 to 4.`);
-    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.');
+  return errors;
 }
 
 /** The folders of the brief and the path sources that are outside cwd. A Claude judge cannot read them without --add-dir. */
@@ -72,10 +64,7 @@ function exec(command, args, { cwd, stdin, timeout }) {
 
 async function askClaude(j, prompt, session) {
   const args = [
-    '-p', '--safe-mode',
-    '--tools', TOOLS,
-    '--allowedTools', ALLOWED_TOOLS,
-    '--permission-mode', 'dontAsk', '--permission-prompts', 'none',
+    '-p', ...yoloFlags(j.yolo, 'claude'),
     ...j.addDirs.flatMap((d) => ['--add-dir', d]),
     '--system-prompt', SYSTEM_PROMPT,
     '--json-schema', JSON.stringify(j.schema),
@@ -92,15 +81,13 @@ async function askClaude(j, prompt, session) {
   return { answer: result.structured_output, session: result.session_id };
 }
 
-// --disable apps: the apps feature gives Codex the connectors of the ChatGPT account, and some of them write
-// (chatgpt_space_create_page, chatgpt_space_trash_page). --ignore-user-config does not turn them off.
 async function askCodex(j, prompt, thread) {
   const raw = join(j.dir, 'raw.json');
   const instructions = `developer_instructions=${JSON.stringify(SYSTEM_PROMPT)}`;
   const output = ['--output-schema', join(j.dir, 'schema.json'), '-o', raw, '--json'];
   const args = thread
-    ? ['exec', 'resume', thread, prompt, '--skip-git-repo-check', '--ignore-user-config', '-c', 'sandbox_mode="read-only"', '--disable', 'multi_agent', '--disable', 'apps', '-c', instructions, ...output]
-    : ['exec', '-', '-C', j.cwd, '--skip-git-repo-check', '--ignore-user-config', '-s', 'read-only', '--disable', 'multi_agent', '--disable', 'apps', '-c', instructions, ...output];
+    ? ['exec', 'resume', thread, prompt, '--skip-git-repo-check', '--ignore-user-config', ...(j.yolo ? CODEX_RESUME_YOLO : []), '-c', instructions, ...output]
+    : ['exec', '-', '-C', j.cwd, '--skip-git-repo-check', '--ignore-user-config', ...yoloFlags(j.yolo, 'codex'), '-c', instructions, ...output];
   const stdin = thread ? 'ignore' : openSync(join(j.dir, 'prompt.md'));
   const run = await exec(j.command, args, { cwd: j.cwd, stdin, timeout: j.timeout });
   if (!thread) closeSync(stdin);
@@ -120,25 +107,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, yolo = false }, 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, yolo, 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' };
@@ -150,19 +137,17 @@ 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, yolo = false }) {
   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.
-    return ['codex', '-C', dir, '-s', 'workspace-write', '--disable', 'multi_agent', '--disable', 'apps', '-c', `developer_instructions=${tomlString(`${SYSTEM_PROMPT}\n${closing}`)}`, prompt];
+    return ['codex', '-C', dir, ...yoloFlags(yolo, 'codex'), '-c', `developer_instructions=${tomlString(`${SYSTEM_PROMPT}\n${closing}`)}`, prompt];
   }
-  // Claude matches file paths only in Edit rules, which cover Write too; // starts an absolute path.
-  const allowed = `${ALLOWED_TOOLS},Edit(/${join(dir, 'answer.json')})`;
   const add = addDirs(cwd, brief, sources).flatMap((d) => ['--add-dir', d]);
-  return ['claude', '--safe-mode', '--system-prompt', SYSTEM_PROMPT, '--tools', `${TOOLS},Write`, ...add, '--allowedTools', allowed, '--permission-mode', 'dontAsk', prompt];
+  return ['claude', ...yoloFlags(yolo, 'claude'), '--system-prompt', SYSTEM_PROMPT, ...add, prompt];
 }

package/lib/report.js

@@ -1,45 +1,24 @@
+import { readFileSync } from 'node:fs';
+
+/** The version of this package, from package.json. */
+export const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+
 /**
- * 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 LEVELS = { 1: 'Fails', 2: 'Falls short', 3: 'Almost met', 4: 'Met' };
-
-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}/4 ${LEVELS[result.score]}`);
-      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: the run and the 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}`, ''])];
 }