@palate/cli 0.0.0-stage → 0.0.1

package/src/loop/judge-api.mjs

@@ -0,0 +1,245 @@
+// The judge fallback for `palate gate`: when the agent has no subagents (Codex, Cursor), it would have to judge
+// its own build, and a builder grades its own work too kindly. With an API key set, palate runs the judge packets
+// itself, with a model from a different family than the builder where it can (Gemini first, then OpenAI, then
+// Anthropic: the same family as a Claude builder, so last).
+//
+// A packet is the Markdown gate.mjs writes: absolute image paths, questions, and one line
+// "Write <path> as {...}". palate sends the packet with its images, asks for the JSON only, checks it has the
+// key the packet asked for (retrying once), and writes it where the packet said.
+//
+// No SDKs: plain fetch. Keys never leave the request headers: never logged, never in a URL, never in an error.
+import fs from "node:fs";
+import path from "node:path";
+
+export const PROVIDERS = {
+  gemini: { label: "Gemini", family: "google", model: "gemini-4-argon", keys: ["GEMINI_API_KEY", "GOOGLE_API_KEY"] },
+  openai: { label: "OpenAI", family: "openai", model: "gpt-6-astra", keys: ["OPENAI_API_KEY"] },
+  anthropic: { label: "Anthropic", family: "anthropic", model: "claude-opus-5-5", keys: ["ANTHROPIC_API_KEY"] },
+};
+// A different family than a Claude builder first.
+export const DEFAULT_ORDER = ["gemini", "openai", "anthropic"];
+export const MAX_IMAGES = 24;
+// Anthropic applies a stricter per-image size (2000 px) to every image once a request has more than 20.
+const PROVIDER_MAX_IMAGES = { anthropic: 20 };
+const INLINE_WARN_BYTES = 18e6; // Gemini caps a whole inline request at 20 MB.
+
+const slash = (p) => String(p).replace(/\\/g, "/");
+
+// Which provider judges: PALATE_JUDGE is "off", or a preference list ("openai" or "openai,gemini"); empty or
+// "auto" is the default order. The first listed provider with a key wins. PALATE_JUDGE_MODEL overrides the model.
+// The key is on the result but not enumerable, so printing or serialising the provider never shows it.
+export function judgeProvider(env = process.env) {
+  const pref = String(env.PALATE_JUDGE ?? "").trim().toLowerCase();
+  if (/^(off|none|no|false|0)$/.test(pref)) return null;
+  const listed = pref && pref !== "auto" ? pref.split(/[\s,]+/).filter((p) => PROVIDERS[p]) : [];
+  const order = listed.length ? listed : DEFAULT_ORDER;
+  for (const name of order) {
+    const p = PROVIDERS[name];
+    const envKey = p.keys.find((k) => String(env[k] ?? "").trim());
+    if (!envKey) continue;
+    const model = String(env.PALATE_JUDGE_MODEL ?? "").trim() || p.model;
+    const out = { name, label: p.label, family: p.family, model, keyFrom: envKey };
+    Object.defineProperty(out, "key", { value: String(env[envKey]).trim(), enumerable: false });
+    return out;
+  }
+  return null;
+}
+
+// What the packet asks for, from its "Write <path> as {...}" line.
+export function packetSpec(text) {
+  const m = /^Write (.+?\.json) as (.*)$/m.exec(text);
+  if (!m) throw new Error('The packet has no "Write <path>.json as {...}" line.');
+  const shape = m[2];
+  const kind = /"comparisons"/.test(shape) ? "pair" : /"winner"/.test(shape) ? "duel" : /"sections"/.test(shape) ? "checklist" : "unknown";
+  return { out: path.resolve(m[1].trim()), kind, shape };
+}
+
+// Every absolute png/jpg path the packet names, in order, once each. Windows paths can't hold ":" after the
+// drive, so a route like "(/pricing): C:/..." doesn't swallow the path after it.
+export function packetImages(text) {
+  const re = /(?:[A-Za-z]:[\\/]|\/)[^\n:*?"<>|]*?\.(?:png|jpe?g)(?!\w|\.\w)/gi;
+  const seen = new Set();
+  const out = [];
+  for (const m of text.matchAll(re)) {
+    const p = m[0].trim();
+    if (!seen.has(p)) {
+      seen.add(p);
+      out.push(p);
+    }
+  }
+  return out;
+}
+
+// The JSON in a reply: fenced or bare, with stray prose around it tolerated.
+export function parseJudgeJson(reply) {
+  let s = String(reply ?? "").trim();
+  const fence = /```(?:json)?\s*([\s\S]*?)```/i.exec(s);
+  if (fence) s = fence[1].trim();
+  try {
+    return JSON.parse(s);
+  } catch {}
+  const a = s.indexOf("{");
+  const b = s.lastIndexOf("}");
+  if (a >= 0 && b > a) {
+    try {
+      return JSON.parse(s.slice(a, b + 1));
+    } catch {}
+  }
+  return null;
+}
+
+// Null when the answer has what the gate reads; otherwise what's missing.
+export function answerProblem(kind, obj) {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return "the reply was not a JSON object";
+  if (kind === "checklist") {
+    if (!Array.isArray(obj.sections)) return 'it needs a "sections" array';
+    if (!obj.page || typeof obj.page !== "object") return 'it needs a "page" object';
+  } else if (kind === "pair") {
+    if (!Array.isArray(obj.comparisons)) return 'it needs a "comparisons" array';
+  } else if (kind === "duel") {
+    if (typeof obj.winner !== "string") return 'it needs a "winner" string';
+  }
+  return null;
+}
+
+const PREAMBLE = [
+  "You are judging a design review packet. The images it names are attached, each labelled with the exact path the packet uses: where the packet says to open an image, look at the attached image with that path.",
+  "Where the packet says to write a JSON file, don't write a file: reply with that JSON object only, with no prose and no code fences. palate writes the file.",
+].join("\n");
+const CLOSING = "Reply with the JSON object only.";
+
+const mimeOf = (f) => (/\.png$/i.test(f) ? "image/png" : "image/jpeg");
+
+// Provider request bodies. `parts` is [{text} | {image: {mime, data}}] in order.
+const BUILD = {
+  gemini(p, parts) {
+    return {
+      url: `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(p.model)}:generateContent`,
+      headers: { "content-type": "application/json", "x-goog-api-key": p.key },
+      body: {
+        contents: [{ role: "user", parts: parts.map((x) => (x.image ? { inline_data: { mime_type: x.image.mime, data: x.image.data } } : { text: x.text })) }],
+        generationConfig: { response_mime_type: "application/json" },
+      },
+    };
+  },
+  openai(p, parts) {
+    return {
+      url: "https://api.openai.com/v1/responses",
+      headers: { "content-type": "application/json", authorization: `Bearer ${p.key}` },
+      body: {
+        model: p.model,
+        input: [{ role: "user", content: parts.map((x) => (x.image ? { type: "input_image", image_url: `data:${x.image.mime};base64,${x.image.data}`, detail: "high" } : { type: "input_text", text: x.text })) }],
+        text: { format: { type: "json_object" } },
+      },
+    };
+  },
+  anthropic(p, parts) {
+    return {
+      url: "https://api.anthropic.com/v1/messages",
+      headers: { "content-type": "application/json", "x-api-key": p.key, "anthropic-version": "2023-06-01" },
+      body: {
+        model: p.model,
+        max_tokens: 8000,
+        messages: [{ role: "user", content: parts.map((x) => (x.image ? { type: "image", source: { type: "base64", media_type: x.image.mime, data: x.image.data } } : { type: "text", text: x.text })) }],
+      },
+    };
+  },
+};
+
+// The reply text from each provider's response body.
+const READ = {
+  gemini: (d) => (d?.candidates?.[0]?.content?.parts ?? []).filter((x) => typeof x.text === "string" && !x.thought).map((x) => x.text).join(""),
+  openai: (d) =>
+    typeof d?.output_text === "string" && d.output_text
+      ? d.output_text
+      : (d?.output ?? [])
+          .filter((o) => o.type === "message")
+          .flatMap((o) => o.content ?? [])
+          .filter((c) => c.type === "output_text")
+          .map((c) => c.text)
+          .join(""),
+  anthropic: (d) => (d?.content ?? []).filter((c) => c.type === "text").map((c) => c.text).join(""),
+};
+
+async function ask(provider, parts, { fetchImpl, timeoutMs }) {
+  const req = BUILD[provider.name](provider, parts);
+  let res;
+  try {
+    res = await fetchImpl(req.url, { method: "POST", headers: req.headers, body: JSON.stringify(req.body), signal: AbortSignal.timeout(timeoutMs) });
+  } catch (e) {
+    throw new Error(`${provider.label} judge request failed (${e?.name === "TimeoutError" ? "timed out" : e?.code ?? e?.name ?? "network error"})`);
+  }
+  if (!res.ok) throw new Error(`${provider.label} judge request failed: HTTP ${res.status}`);
+  let data;
+  try {
+    data = await res.json();
+  } catch {
+    throw new Error(`${provider.label} judge returned an unreadable response (HTTP ${res.status})`);
+  }
+  return READ[provider.name](data);
+}
+
+// Runs one packet through the API and writes its answer file. Returns { out, provider, model, ms, images, retried }.
+export async function runPacket(packetFile, { provider, fetchImpl = globalThis.fetch, env = process.env, onWarn = (m) => console.warn(m), maxImages, timeoutMs = 300_000 } = {}) {
+  const p = provider ?? judgeProvider(env);
+  if (!p) throw new Error("No judge API key: set GEMINI_API_KEY (or GOOGLE_API_KEY), OPENAI_API_KEY or ANTHROPIC_API_KEY, or PALATE_JUDGE is off.");
+  if (!BUILD[p.name]) throw new Error(`Unknown judge provider: ${p.name}`);
+  if (!p.key) throw new Error(`${p.label ?? p.name} judge has no key.`);
+  const started = Date.now();
+  const text = fs.readFileSync(packetFile, "utf8");
+  const spec = packetSpec(text);
+  const cap = Math.min(maxImages ?? MAX_IMAGES, PROVIDER_MAX_IMAGES[p.name] ?? Infinity);
+  const found = packetImages(text);
+  const present = found.filter((f) => fs.existsSync(f));
+  const missing = found.length - present.length;
+  if (missing) onWarn(`palate judge: ${missing} image(s) named in ${path.basename(packetFile)} don't exist; judging without them.`);
+  const images = present.slice(0, cap);
+  if (present.length > cap) onWarn(`palate judge: ${path.basename(packetFile)} names ${present.length} images; ${p.label} gets the first ${cap}.`);
+  const parts = [{ text: PREAMBLE }];
+  let bytes = 0;
+  for (const f of images) {
+    const data = fs.readFileSync(f).toString("base64");
+    bytes += data.length;
+    parts.push({ text: `Image: ${slash(f)}` }, { image: { mime: mimeOf(f), data } });
+  }
+  if (bytes > INLINE_WARN_BYTES) onWarn(`palate judge: ${Math.round(bytes / 1e6)} MB of images in one request; ${p.label} may refuse it.`);
+  parts.push({ text }, { text: CLOSING });
+  let reply = await ask(p, parts, { fetchImpl, timeoutMs });
+  let obj = parseJudgeJson(reply);
+  let problem = answerProblem(spec.kind, obj);
+  let retried = false;
+  if (problem) {
+    retried = true;
+    const again = [...parts, { text: `A previous reply was not usable (${problem}). Reply again with only the JSON object the packet asks for, shaped exactly as: ${spec.shape}` }];
+    reply = await ask(p, again, { fetchImpl, timeoutMs });
+    obj = parseJudgeJson(reply);
+    problem = answerProblem(spec.kind, obj);
+    if (problem) throw new Error(`${p.label} judge gave no usable answer for ${path.basename(packetFile)} after a retry (${problem}).`);
+  }
+  fs.mkdirSync(path.dirname(spec.out), { recursive: true });
+  fs.writeFileSync(spec.out, JSON.stringify(obj, null, 1));
+  return { out: spec.out, provider: p.name, model: p.model, ms: Date.now() - started, images: images.length, retried };
+}
+
+// Runs packets in parallel (3 at a time). `files` are packet paths or gate's { file, out } entries. Never throws
+// for one packet: each result is { file, ok, ...runPacket result } or { file, ok: false, error }.
+export async function runPackets(files, opts = {}) {
+  const list = (files ?? []).map((f) => (typeof f === "string" ? f : f.file));
+  const provider = opts.provider ?? judgeProvider(opts.env ?? process.env);
+  if (!provider) throw new Error("No judge API key: set GEMINI_API_KEY (or GOOGLE_API_KEY), OPENAI_API_KEY or ANTHROPIC_API_KEY, or PALATE_JUDGE is off.");
+  const limit = Math.max(1, opts.limit ?? 3);
+  const results = new Array(list.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < list.length) {
+      const i = next++;
+      try {
+        results[i] = { file: list[i], ok: true, ...(await runPacket(list[i], { ...opts, provider })) };
+      } catch (e) {
+        results[i] = { file: list[i], ok: false, error: e.message };
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, list.length) }, worker));
+  return results;
+}

package/src/loop/judge.mjs

@@ -0,0 +1,167 @@
+// `palate judge --name <loop>`: drops the weakest variants before the user sees them. A judge that
+// reads the screen and knows the job measures a few job-relative qualities; in tests on the founder's
+// picks, "clarity for this job" alone agreed with him 63% overall and 70–82% on app screens, while a
+// pixel-only model was below chance. So the judge filters; the user still chooses.
+// Before any scoring, the variants are compared with each other and with everything palate has made for
+// this user (the layout memory): near-duplicates are found here, and the scoring step keeps only one of each.
+//   palate judge --name pricing                 renders the variants and writes the rubric for a judge
+//   palate judge --name pricing --scores f.json keeps the best (default 4) for palate pick
+import fs from "node:fs";
+import path from "node:path";
+import { readJson, render, screenKind, sessionDir, variantRoutes, waitReady } from "./common.mjs";
+import { mark } from "./timeline.mjs";
+import { DUPLICATE, SIMILAR, originality, recordRender, whereOf } from "./layouts.mjs";
+import { activeRules, checkRules, projectOf, routeTags, rulesFor, rulesSummary } from "./rules.mjs";
+
+const ATTRS = {
+  clarity: "hierarchy and readability; obvious what this is and what to do first",
+  content_at_glance: "how much of the content this job needs is visible at once, without tabs, steps, one-at-a-time cards or calculators",
+  main_object_dominance: "the main object of this job (the table, the plans, the list, the product proof) is clearly the hero",
+  chrome_clutter: "decoration, props and chrome around the content (stamps, tickets, extra frames and panels); 10 = very cluttered",
+};
+// Quality this close (in judge points) counts as a tie, and the more original of two near-duplicates stays.
+const CLOSE = 1.5;
+// A variant that repeats something already made elsewhere loses this much.
+const REPEAT_PENALTY = 1;
+// The user's rules: a variant that fails a measured rule is ranked below every variant that passes them all
+// (it reaches the user only when too few pass) and loses this much; a rule the judge answers "no" to costs less.
+const RULE_PENALTY = 2;
+const JUDGED_RULE_PENALTY = 1;
+
+const pct = (v) => `${Math.round(v * 100)}%`;
+
+// The originality report, from similarity.json.
+function originalityLines(sim) {
+  const out = [];
+  const dups = sim.pairs.filter((p) => p.total >= DUPLICATE);
+  const close = sim.pairs.filter((p) => p.total >= SIMILAR && p.total < DUPLICATE);
+  for (const p of dups) out.push(`- Near-duplicates: ${p.a} and ${p.b} (${pct(p.total)}: structure ${pct(p.structure)}, picture ${p.visual == null ? "?" : pct(p.visual)}). Only one of them reaches the user.`);
+  for (const p of close) out.push(`- Similar: ${p.a} and ${p.b} (${pct(p.total)}).`);
+  // The two routes of one direction were asked to differ in structure.
+  const dir = (r) => r.match(/-([a-z])\d+$/)?.[1];
+  for (const p of sim.pairs.filter((x) => x.total < SIMILAR && x.structure >= 0.8 && dir(x.a) && dir(x.a) === dir(x.b))) out.push(`- ${p.a} and ${p.b} (one direction) share a structure (${pct(p.structure)}); they differ in skin only.`);
+  for (const [route, m] of Object.entries(sim.history)) {
+    if (m && m.total >= DUPLICATE) out.push(`- ${route} repeats ${whereOf(m)} made ${m.at.slice(0, 10)} (${pct(m.total)}); it is ranked down.`);
+    else if (m && m.total >= SIMILAR) out.push(`- ${route} is close to ${whereOf(m)} made ${m.at.slice(0, 10)} (${pct(m.total)}).`);
+  }
+  return out.length ? out : ["- No near-duplicates in this loop and no repeat of anything made before."];
+}
+
+// watch: wait until `ready` variants (default: the loop's own number, at most 4) are built, and judge those;
+// variants that land later join at the pick only if fewer than 4 survive.
+export async function judge(dir, name, { scores, keep = 4, url, watch = false, ready } = {}) {
+  const session = sessionDir(dir, name);
+  const meta = readJson(path.join(session, "loop.json"), {});
+  if (!scores) {
+    const routes = watch || ready ? await waitReady(dir, name, ready ?? meta.ready ?? Math.min(4, meta.planned ?? 4), { url }) : variantRoutes(dir, name);
+    mark(dir, name, "build_done");
+    const { full } = screenKind(name, meta.job);
+    const shots = await render(dir, routes, path.join(session, "judge"), { full, url, rules: true });
+    mark(dir, name, "judge_rendered");
+    const ok = shots.filter((s) => s.file);
+    const labels = ok.map((s, i) => ({ label: `V${i + 1}`, route: s.route, file: s.file.replace(/\\/g, "/") }));
+    fs.writeFileSync(path.join(session, "judge-key.json"), JSON.stringify(labels, null, 1));
+    // Originality first: compare before anyone scores, and remember every variant in the layout memory.
+    const recs = recordRender(dir, name, ok);
+    const sim = originality(dir, recs, { run: meta.created });
+    fs.writeFileSync(path.join(session, "similarity.json"), JSON.stringify(sim, null, 1));
+    // The user's rules: measured on each render (reduced motion, so motion rules wait for the winner's shoot);
+    // the ones that can't be measured become questions for the judge.
+    const tags = labels.length ? routeTags(dir, labels[0].route) : [];
+    const mine = rulesFor(tags, { route: meta.route, project: projectOf(dir) });
+    const ruleResults = Object.fromEntries(labels.map((l) => [l.route, checkRules(mine, readJson(l.file.replace(/\.png$/, ".facts.json"), {}).facts ?? null, { motion: false })]));
+    fs.writeFileSync(path.join(session, "rules.json"), JSON.stringify({ tags, results: ruleResults }, null, 1));
+    const questions = mine.filter((r) => r.check?.type === "judge");
+    const rulesPart = mine.length
+      ? [
+          "## The user's rules (must pass)",
+          "Measured by palate on each render (a variant that fails one is ranked below every variant that passes):",
+          ...labels.map((l) => `- ${l.label}: ${rulesSummary(ruleResults[l.route]).head}`),
+          ...(questions.length
+            ? ["", "Not measurable, so you answer them: for each design, true if it follows the rule, false if it doesn't. Be strict: this user has rejected these before.", ...questions.map((r) => `- ${r.id}: ${r.check.question ?? r.rule}`)]
+            : []),
+          "",
+        ]
+      : [];
+    const rulesExample = questions.length ? `, "rules": {${questions.slice(0, 2).map((r, i) => `"${r.id}": ${i ? "false" : "true"}`).join(", ")}${questions.length > 2 ? ", …" : ""}}` : "";
+    const rubric = [
+      `# Judge: ${meta.job ?? name}`,
+      "",
+      "You measure; you do not pick a favourite or judge taste. Open every screenshot with your image tool and score each design from 1 to 10 on each quality, relative to this job, using the full range across the set:",
+      ...Object.entries(ATTRS).map(([k, v]) => `- ${k}: ${v}`),
+      "",
+      "Designs:",
+      ...labels.map((l) => `- ${l.label}: ${l.file}`),
+      "",
+      ...rulesPart,
+      `Write JSON to ${path.join(session, "scores.json").replace(/\\/g, "/")} as {"scores": [{"label": "V1", "clarity": 7, "content_at_glance": 6, "main_object_dominance": 8, "chrome_clutter": 3${rulesExample}}, …]}`,
+      `then run: palate judge --name ${name} --scores ${path.join(session, "scores.json").replace(/\\/g, "/")}`,
+    ].join("\n");
+    fs.writeFileSync(path.join(session, "rubric.md"), rubric);
+    const broken = shots.filter((s) => s.error);
+    return [
+      `Rendered ${ok.length} variants${broken.length ? ` (did not build: ${broken.map((b) => b.route).join(", ")})` : ""}.`,
+      "",
+      ...(mine.length ? ["## Your rules (measured on each variant)", ...labels.map((l) => `- ${l.route}: ${rulesSummary(ruleResults[l.route]).head}`), ""] : []),
+      "## Originality (measured before scoring)",
+      ...originalityLines(sim),
+      "",
+      `Judge them with a fresh subagent if you can (a judge should not grade its own work): "Read ${path.join(session, "rubric.md").replace(/\\/g, "/")} and follow it." Otherwise follow the rubric yourself.`,
+    ].join("\n");
+  }
+
+  const key = readJson(path.join(session, "judge-key.json"), []);
+  const raw = readJson(path.resolve(scores), null);
+  if (!raw?.scores?.length) throw new Error(`No scores in ${scores}`);
+  const kind = screenKind(name, meta.job).kind;
+  const sim = readJson(path.join(session, "similarity.json"), { pairs: [], history: {}, originality: {} });
+  const rows = raw.scores.map((s) => ({ ...s, route: key.find((k) => k.label === s.label)?.route })).filter((s) => s.route);
+  const ruleFile = readJson(path.join(session, "rules.json"), { results: {} });
+  const judgeRules = new Set(activeRules().filter((r) => r.check?.type === "judge").map((r) => r.id));
+  // Clarity leads; for app screens, content at a glance and main-object dominance help and clutter hurts.
+  for (const r of rows) {
+    r.score = r.clarity + (kind === "app" ? 0.5 * (r.content_at_glance + r.main_object_dominance - r.chrome_clutter) : 0.25 * (r.content_at_glance - r.chrome_clutter));
+    const h = sim.history[r.route];
+    if (h && h.total >= DUPLICATE) {
+      r.score -= REPEAT_PENALTY;
+      r.note = `repeats ${whereOf(h)} (${pct(h.total)})`;
+    }
+    r.originality = sim.originality[r.route] ?? null;
+    // The user's rules: what palate measured failing, then what the judge said it breaks.
+    r.measuredFails = (ruleFile.results?.[r.route] ?? []).filter((x) => x.status === "fail").map((x) => x.id);
+    r.judgedFails = Object.entries(r.rules ?? {}).filter(([id, ok]) => ok === false && judgeRules.has(id)).map(([id]) => id);
+    r.score -= RULE_PENALTY * r.measuredFails.length + JUDGED_RULE_PENALTY * r.judgedFails.length;
+    const broke = [...r.measuredFails, ...r.judgedFails];
+    if (broke.length) r.note = [r.note, `fails your rule${broke.length > 1 ? "s" : ""} ${broke.join(", ")}`].filter(Boolean).join("; ");
+  }
+  // Variants that pass every measured rule first, then by score; equal scores: the more original first.
+  rows.sort((a, b) => Number(a.measuredFails.length > 0) - Number(b.measuredFails.length > 0) || b.score - a.score || (b.originality ?? 0) - (a.originality ?? 0));
+  // How original a variant is apart from its twin: its closest match among the rest of the loop and history.
+  const apart = (route, twin) => 1 - Math.max(sim.history[route]?.total ?? 0, ...sim.pairs.filter((p) => (p.a === route || p.b === route) && p.a !== twin && p.b !== twin).map((p) => p.total));
+  // Near-duplicates: only one of each pair goes on. Quality decides unless it's close; then the more original
+  // one (further from everything else in the loop and from history) stays.
+  const dropped = new Map();
+  const byRoute = Object.fromEntries(rows.map((r) => [r.route, r]));
+  for (const p of sim.pairs.filter((x) => x.total >= DUPLICATE)) {
+    const [a, b] = [byRoute[p.a], byRoute[p.b]];
+    if (!a || !b || dropped.has(a.route) || dropped.has(b.route)) continue;
+    const close = Math.abs(a.score - b.score) <= CLOSE;
+    const [win, lose] = close ? (apart(a.route, b.route) >= apart(b.route, a.route) ? [a, b] : [b, a]) : a.score >= b.score ? [a, b] : [b, a];
+    dropped.set(lose.route, `near-duplicate of ${win.route} (${pct(p.total)}); ${close ? "quality was close, kept the more original one" : "kept the better one"}`);
+  }
+  // Never fewer than two for the user.
+  const pool = rows.filter((r) => !dropped.has(r.route));
+  for (const r of rows) if (pool.length < Math.min(2, rows.length) && dropped.has(r.route)) pool.push(r);
+  const kept = pool.slice(0, Math.min(keep, pool.length)).map((r) => r.route);
+  fs.writeFileSync(path.join(session, "judge.json"), JSON.stringify({ keep: kept, rows, dropped: Object.fromEntries(dropped) }, null, 2));
+  mark(dir, name, "judge_scored");
+  return [
+    `# ${name}: judged`,
+    ...rows.map((r) => `${kept.includes(r.route) ? "keep" : "drop"}  ${r.route.padEnd(18)} score ${r.score.toFixed(1)}  (clarity ${r.clarity}, at a glance ${r.content_at_glance}, main object ${r.main_object_dominance}, clutter ${r.chrome_clutter}${r.originality != null ? `, originality ${pct(r.originality)}` : ""})${dropped.has(r.route) && !kept.includes(r.route) ? `  ← ${dropped.get(r.route)}` : ""}${r.note ? `  ← ${r.note}` : ""}`),
+    "",
+    "## Originality",
+    ...originalityLines(sim),
+    "",
+    `Next: palate pick --name ${name}   (the user chooses among the ${kept.length} kept, blind)`,
+  ].join("\n");
+}