@xsft/panels 0.7.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,11 +31,11 @@ Run the command in the folder of the product. Each judge starts in that folder,
 
 ## 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.
+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 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.
+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.
+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
 

package/bin/panels.js

@@ -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}`);
@@ -75,6 +80,7 @@ async function main() {
     target: args.target,
     brief: args.brief,
     sources: args.sources,
+    yolo: true,
   }));
   const report = buildReport({ panel, target: args.target, outcomes });
   const reportPath = join(runDir, 'report.json');

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

@@ -3,12 +3,15 @@ import { closeSync, mkdirSync, openSync, readFileSync, writeFileSync } from 'nod
 import { dirname, join, relative, resolve, sep } from 'node:path';
 
 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:*)';
+// 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. criterion is { rank, name, description, body }. Each part sits in a tag,
@@ -35,7 +38,6 @@ export function check(answer, criterion) {
   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;
 }
 
@@ -62,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),
@@ -82,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);
@@ -112,13 +109,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 }, command = harness) {
+export async function runJudge({ dir, criterion, harness, cwd, target, brief, sources, yolo = false }, command = harness) {
   mkdirSync(dir, { recursive: true });
   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: 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;
@@ -140,7 +137,7 @@ 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 }) {
+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, 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}`;
@@ -149,10 +146,8 @@ export function writeJudge({ dir, criterion, harness, cwd, target, brief, source
   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,3 +1,8 @@
+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: { 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
@@ -13,7 +18,7 @@ export function buildReport({ panel, target, outcomes }) {
   return { panel: `${panel.owner}/${panel.name}@${panel.version}`, target, status, criteria };
 }
 
-/** The lines that the plain mode prints: "N/4  name" and the verdict under it, for each criterion. */
+/** 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 report.criteria.flatMap((c) => [`${c.score === null ? 'err' : `${c.score}/4`}  ${c.name}`, `    ${c.verdict}`, '']);
+  return [`panels ${VERSION}  ${report.panel}  ${report.target}`, '', ...report.criteria.flatMap((c) => [`${c.score === null ? 'err' : `${c.score}/4`}  ${c.name}`, `    ${c.verdict}`, ''])];
 }

package/lib/table.js

@@ -5,8 +5,9 @@ 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 } from './report.js';
+import { buildReport, VERSION } 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,
@@ -75,6 +76,16 @@ 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)));
 
@@ -107,17 +118,95 @@ export function wrap(text, width) {
 const quarters = (sum) => String(Math.round((sum / 4) * 100) / 100);
 
 /**
- * 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.
+ * The body of a criterion as plain lines for the detail 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.
+ */
+export function plainMarkdown(markdown, width) {
+  const inline = (t) => t.replace(/\*\*(.+?)\*\*/g, '$1').replace(/__(.+?)__/g, '$1').replace(/`([^`]+)`/g, '$1').replace(/\*(\S[^*]*?)\*/g, '$1').replace(/\[([^\]]+)\]\([^)]*\)/g, '$1');
+  const lines = [];
+  let paragraph = [];
+  let fence = false;
+  const flush = () => {
+    if (paragraph.length) lines.push(...wrap(inline(paragraph.join(' ')), width));
+    paragraph = [];
+  };
+  for (const raw of markdown.split('\n')) {
+    const line = raw.trimEnd();
+    if (/^\s*```/.test(line)) { flush(); fence = !fence; continue; }
+    if (fence) { lines.push(`    ${line}`); continue; }
+    if (!line.trim()) { flush(); if (lines.at(-1) !== '') lines.push(''); continue; }
+    const heading = /^#{1,6}\s+(.*)$/.exec(line);
+    if (heading) { flush(); if (lines.length && lines.at(-1) !== '') lines.push(''); lines.push(`${GREY}${inline(heading[1]).toUpperCase()}${RESET}`); continue; }
+    const item = /^\s*(?:[-*+]|\d+\.)\s+(.*)$/.exec(line);
+    if (item) { flush(); const [first, ...rest] = wrap(inline(item[1]), width - 2); lines.push(`- ${first ?? ''}`, ...rest.map((l) => `  ${l}`)); continue; }
+    if (/^\s*\|/.test(line)) { flush(); lines.push(inline(line)); continue; }
+    paragraph.push(line.trim());
+  }
+  flush();
+  while (lines.at(-1) === '') lines.pop();
+  while (lines[0] === '') lines.shift();
+  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));
+  if (row.body) lines.push('', ...plainMarkdown(row.body, columnWidth));
+  return lines;
+}
+
+const layout = (rows, width) => {
+  // The name column is as wide as the longest name, and at least as wide as the word total under it.
+  const leftWidth = Math.max(5, ...rows.map((r) => r.name.length)) + 27;
+  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);
+}
+
+/**
+ * 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.
  */
-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}`;
+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}`;
-  const pad = Math.max(...rows.map((r) => r.name.length));
-  const leftWidth = pad + 27;
+  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)}`;
   const left = rows.map((r, i) => {
     const current = i === cursor;
@@ -127,59 +216,71 @@ export function renderOverview({ title, target, harness, elapsed, rows, cursor,
     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}`;
+      return `${mark}${current ? ORANGE : ''}${rank}${RESET}${name}${current ? ORANGE : GREY}${cells('·/4', 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] : '';
+    // A row without a score yet holds the place of the score with ·/4.
+    const score = r.state === 'done' ? `${r.result.score}/4` : r.state === 'error' ? '✗' : '·/4';
+    const colour = current ? ORANGE : r.state === 'done' ? SCORE_COLOUR[r.result.score] : r.state === 'error' ? SCORE_COLOUR[1] : GREY;
     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 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 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 level = row.state === 'done' ? `${row.result.score}/4  ${LEVELS[row.result.score]}` : row.state === 'error' ? 'error' : row.state;
+  const name = `${row.rank}  ${row.name.toUpperCase()}`;
+  const detailHeader = `${focus === 'detail' ? `${ORANGE}${BOLD}` : BOLD}${name}${RESET}${' '.repeat(Math.max(1, columnWidth - name.length - level.length))}${GREY}${level}${RESET}`;
+  const content = detailContent(row, columnWidth, start, width, frame);
+  const facts = [`judge ${row.rank}`, row.harness, ...(row.time === null ? [] : [clock(row.time)]), ...(row.state === 'done' || row.state === 'error' ? [`judges/${row.rank}/answer.json`] : [])];
+  const bottom = [`${ORANGE}r${RESET} restart   ${ORANGE}h${RESET} harness ${row.harness}   ${ORANGE}${row.rank}${RESET} watch`, '', `${GREY}${facts.join(' · ')}${RESET}`];
+
+  // top, gap blank lines, then bottom; with a height that holds them, the blank lines grow so bottom ends at the height.
+  const pane = (top, bottomLines, lines, gap) => {
+    const fill = lines === undefined || lines < top.length + gap + bottomLines.length ? gap : lines - top.length - bottomLines.length;
+    return [...top, ...Array(fill).fill(''), ...bottomLines];
+  };
+  // The detail pane: the header, a window of the content that the scroll moves, a blank line, then the bottom lines.
+  const detailPane = (lines) => {
+    const window = lines === undefined ? 0 : lines - 5;
+    if (window < 1) return pane([detailHeader, ...content], bottom, lines, 1);
+    const 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];
   };
+  const edge = focus === 'detail' ? `${ORANGE}▌${RESET}` : `${GREY}│${RESET}`;
 
   const lines = [header, rule];
+  const body = height === undefined ? undefined : height - 2;
   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] ?? ''}`);
+    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 {
-    detail(width - 2);
-    lines.push(...left, '', ...right.map((l) => `  ${l}`));
+    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 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
+ * the elapsed time at the left and the keys of the focus at the right. The first tab is Overview, then the
  * name of each criterion, with a grey │ between the tabs. A running tab glimmers. The names step down to the
  * first word when they do not fit the width. focus is 'strip' (the active tab is bold orange, the arrows move
- * it) or 'judge' (the active tab is bold ink, the keys go to the judge). confirm replaces the progress with
- * the quit question.
+ * it), 'detail' (the detail pane of the overview scrolls), or 'judge' (the active tab is bold ink, the keys go to
+ * the judge). confirm replaces the progress with the quit question.
  */
 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' : 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 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]))];
   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 = ' ';
@@ -204,40 +305,52 @@ export function renderStrip({ rows, view, frame = 0, width, focus = 'strip', ela
 }
 
 /**
- * The next { view, confirm, focus, cursor } after one key, plus send: true when the key goes to the judge,
+ * 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. 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.
+ * 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.
  */
-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 };
+export function press({ view, confirm, focus, cursor, scroll = 0 }, key, { open, running, count, maxScroll: limit = 0, page = 10 }) {
+  const strip = (v) => ({ view: v, confirm: false, focus: 'strip', cursor, scroll });
+  if (focus === 'judge') return TOGGLE.includes(key) ? strip(view) : { view, confirm, focus, cursor, scroll, send: true };
   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 (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]);
   }
-  if (/^[1-9]$/.test(key)) return open.includes(Number(key)) ? strip(Number(key)) : strip(view);
+  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) {
-    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 };
+    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 (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 (BACK.includes(key)) return { view, confirm: false, focus: 'judge', cursor };
+  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 }) {
+export function runTable({ panel, runDir, harness, cwd, target, brief, sources, yolo = false }) {
   const out = process.stdout;
   const criteria = panel.criteria.map((c, i) => ({ rank: i + 1, ...c }));
   const judges = [];
@@ -245,7 +358,7 @@ export function runTable({ panel, runDir, harness, cwd, target, brief, sources }
   const harnesses = criteria.map(() => harness);
   let rows = [];
   let final = null;
-  let ui = { view: 0, confirm: false, focus: 'strip', cursor: 0 };
+  let ui = { view: 0, confirm: false, focus: 'strip', cursor: 0, scroll: 0 };
   let stripTimer;
   let lastData = 0;
   const started = Date.now();
@@ -282,7 +395,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 });
+    const [command, ...argv] = writeJudge({ dir: judgeDir(rank), criterion: criteria[rank - 1], harness: harnesses[rank - 1], cwd, target, brief, sources, yolo });
     const { cols, rows: lines } = size();
     const term = new xterm.Terminal({ cols, rows: lines, allowProposedApi: true });
     const serializer = new SerializeAddon();
@@ -362,7 +475,7 @@ 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, frame });
+    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 });
     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();
@@ -396,8 +509,10 @@ 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'), count: criteria.length });
-      ui = { view: next.view, confirm: next.confirm, focus: next.focus, cursor: next.cursor };
+      const height = out.rows - STRIP_ROWS;
+      const limit = rows.length ? maxScroll({ rows, cursor: ui.cursor, width: out.columns, height }) : 0;
+      const next = press(ui, key, { open: judges.flatMap((j, i) => (j ? [i + 1] : [])), running: rows.some((r) => r.state === 'running'), count: criteria.length, maxScroll: limit, page: Math.max(1, height - 7) });
+      ui = { view: next.view, confirm: next.confirm, focus: next.focus, cursor: next.cursor, scroll: next.scroll };
       if (next.send) {
         judges[from - 1].proc.write(key);
       } else if (next.quit) {

package/package.json

@@ -1,17 +1,30 @@
 {
   "name": "@xsft/panels",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "private": false,
   "description": "Run a panel of AI judges from cross.software/panels against a target.",
   "type": "module",
-  "bin": { "panels": "bin/panels.js" },
-  "files": ["bin", "lib", "prompts", "schema", "README.md"],
+  "bin": {
+    "panels": "bin/panels.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "prompts",
+    "schema",
+    "README.md"
+  ],
   "license": "UNLICENSED",
-  "engines": { "node": ">=20" },
-  "scripts": { "test": "node --test test/*.test.js" },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
   "dependencies": {
     "@homebridge/node-pty-prebuilt-multiarch": "0.14.1",
     "@xterm/addon-serialize": "0.14.0",
-    "@xterm/headless": "6.0.0"
+    "@xterm/headless": "6.0.0",
+    "figlet": "1.12.0"
   }
 }

package/prompts/judge-system-prompt.txt

@@ -33,7 +33,7 @@ EVIDENCE
 
 THE VERDICT
 
-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.
+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.
 
 PROHIBITIONS
 
@@ -51,7 +51,7 @@ Return one JSON object and nothing else:
 {
   "name": string, the name of your criterion,
   "score": integer 1 to 4,
-  "verdict": string, one paragraph, 600 characters at most
+  "verdict": string, one paragraph
 }
 
 Example:

package/schema/report.json

@@ -31,7 +31,7 @@
       "properties": {
         "name": { "type": "string" },
         "score": { "type": "integer", "minimum": 1, "maximum": 4 },
-        "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." }
+        "verdict": { "type": "string", "minLength": 1, "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." }
       }
     }
   }