@palate/cli 0.0.0-stage → 0.0.2

package/src/loop/gate.mjs

@@ -0,0 +1,1053 @@
+// `palate gate <route>`: the quality floor, judged by someone who didn't build the page.
+//
+// Three layers, cheapest first (research: reports/AI design quality floor.md):
+// 1. The floor checks palate measures itself (floor.mjs): dead space, half-empty sections, one template
+//    repeated, one flat colour with no material, monospace used as decoration, placeholder text, clipped text,
+//    a phone section that stacks into an endless list, a system that drifts between sections, a void inside a
+//    tile, a photo shown twice; at 1440, 1024, 768 and 390. Two-sided: too empty fails like too busy.
+// 2. A checklist judge: yes/no questions per section (from each section's archetype in kb/sections and a few
+//    that hold for every section), answered from screenshots by a fresh judge.
+// 3. A pairwise judge against strong real sites of the same category (the research captures), in both orders,
+//    by judges who never saw the build. A page fails only when it is clearly worse in both orders; a split
+//    verdict is a tie. Pairwise judging agrees with people far more than 1–10 scores (~70–90% vs 50–64%), and
+//    a builder grading its own work skews high (Kiln: 6.7 self-graded, about 5 to a person).
+//
+// palate makes no model calls: it writes the judge packets (blind: "Page A / Page B", no file names that say
+// which is ours) and the calling agent runs each with a fresh subagent; `--answers` reads what they wrote. When
+// the gate fails, palate writes one repair brief for one section (one target per round: fixing everything at
+// once breaks what already worked), snapshots the source first, and after the repair compares the round with
+// the best one so far; a round that got worse is rolled back (`--restore`). Two repair rounds at most, then it
+// says honestly where the page is still below the bar.
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { cropSections, findSections, openPage, shootFull, slugOf, stamp, withBrowser } from "../look.mjs";
+import { normalizeRoute } from "../shoot.mjs";
+import { readJson, TASTE_DIR } from "./common.mjs";
+import { loadBlueprint } from "./blueprint.mjs";
+import { readResearch } from "./similar.mjs";
+import { activeMinutes, buildDurations, buildTookLine, loopTimeline, mark, minutes } from "./timeline.mjs";
+import { MATCHED_NOTE, matchedRoute } from "./matched.mjs";
+
+// The build-mode loop a route belongs to (blueprint.mjs and build.mjs name it the same way).
+const loopName = (route) => (route === "/" ? "home" : String(route).replace(/^\//, "").replace(/[^a-z0-9]+/gi, "-"));
+
+const Floor = await import("./floor.mjs").catch(() => null);
+const Sections = await import("../sections.mjs").catch(() => null);
+// The house-look check (lookvec.mjs): a page whose look repeats palate's recent pages in other projects fails.
+const LookVec = await import("./lookvec.mjs").catch(() => null);
+const FINGERPRINT = (() => {
+  try {
+    return fs.readFileSync(new URL("../page-fingerprint.js", import.meta.url), "utf8").trim().replace(/;\s*$/, "");
+  } catch {
+    return null;
+  }
+})();
+
+// The similarity gate palate shoot runs (other projects, and the research's references), as floor checks: a page
+// could pass the quality gate and then fail palate shoot (Tracewell drifted from 40% to 43% like axiom.co during its
+// repairs). Nothing is recorded here; palate shoot records the page.
+export async function similarityChecks(dir, route, fp) {
+  if (!fp?.skeleton?.length) return [];
+  try {
+    const { shotRecord } = await import("../novelty.mjs");
+    const { similarityGate } = await import("./similar.mjs");
+    const g = similarityGate(dir, route, shotRecord(dir, route, fp));
+    return [...g.hits, ...g.refHits].map((h) => ({
+      id: "SIMILAR",
+      width: 1440,
+      section: null,
+      severity: "fail",
+      what: `${Math.round(h.total * 100)}% like ${h.where}${h.parts?.length ? ` (${h.parts.filter((x) => x.score >= 0.6).slice(0, 3).map((x) => x.label).join(", ") || h.parts[0].label})` : ""}: over palate's similarity gate`,
+      fix: `Change what palate shoot ${route} names under "Similarity gate": the skeleton, the first screen's shape or the section archetypes, not the colour`,
+    }));
+  } catch {
+    return [];
+  }
+}
+
+const slash = (p) => String(p).replace(/\\/g, "/");
+export const MAX_ROUNDS = 2;
+const POINT_LOG = path.join(TASTE_DIR, "point.jsonl");
+export const GATE_LOG = path.join(TASTE_DIR, "gates.jsonl");
+
+// Questions every section answers, whatever its archetype. YES is good.
+export const SECTION_QUESTIONS = [
+  { id: "finished", q: "Does this section look finished and deliberately designed, at the level of a strong product site (not a template or a first draft)?", must: true },
+  { id: "space", q: "Is every empty area clearly intentional (no dead band, no empty half beside the content, no columns that are mostly blank)?" },
+  { id: "focus", q: "Is there one clear focal point, with the rest a step quieter?" },
+  { id: "real", q: "Is the content real and specific to this product (no placeholder text, no generic filler, no fake logos or stats)?" },
+];
+// Questions about the whole page. must: a NO fails the page.
+export const PAGE_QUESTIONS = [
+  { id: "subject", q: "Does the page feel like its subject, so you could tell what kind of product or place it is with the words blurred?", must: true },
+  { id: "material", q: "Does the page have real imagery or material (photography, illustration, texture or a rich product object), not only UI cards on flat colour?", must: true },
+  { id: "variety", q: "Is each section built differently enough that the page doesn't feel like one template repeated?" },
+  { id: "phone", q: "Does the phone version hold up (no endless stacked lists, nothing clipped, comfortable tap targets, a way to reach the navigation)?", must: true },
+  { id: "tablet", q: "Do the tablet views (1024 first screen, 768 whole page) hold up: no photo blown up behind the text, no squeezed or orphaned columns, nothing clipped?" },
+  { id: "finish", q: "Is the finish consistent (one radius family, one shadow style, considered buttons, no default-looking controls)?" },
+];
+
+const yes = (v) => v === true || /^(y|yes|true|pass)$/i.test(String(v ?? "").trim());
+const no = (v) => v === false || /^(n|no|false|fail)$/i.test(String(v ?? "").trim());
+
+function rootFor(dir, route) {
+  return path.join(dir, ".palate", "quality", slugOf(route));
+}
+const roundsFile = (dir, route) => path.join(rootFor(dir, route), "rounds.json");
+export function readRounds(dir, route) {
+  return readJson(roundsFile(dir, route), { rounds: [], best: null });
+}
+function writeRounds(dir, route, r) {
+  fs.mkdirSync(rootFor(dir, route), { recursive: true });
+  fs.writeFileSync(roundsFile(dir, route), JSON.stringify(r, null, 1));
+}
+
+// The strongest references to judge against: the research captures for this project (kept order is palate's
+// ranking), each with its first screen and full page.
+export function exemplars(dir, { limit = 2 } = {}) {
+  const r = readResearch(dir);
+  // No research for this project (build mode went straight to a build): the user's own saved references are the
+  // bar, so the page is still judged beside strong real sites (a Moveday hero got no comparison at all).
+  if (!r) return userBar(dir, { limit });
+  // The bar is the best of the category: the strongest competitor and the strongest craft reference by
+  // palate's craft score (research.json), then the rest in palate's order.
+  const raw = readJson(r.file, {});
+  const meta = new Map((raw.kept ?? []).map((k) => [k.url, k]));
+  const all = r.refs.map((x) => ({ name: x.name, url: x.url, fold: x.fold, full: x.shots.find((f) => /full/i.test(f)) ?? null, craft: meta.get(x.url)?.craft ?? 0, role: meta.get(x.url)?.role ?? null })).filter((x) => x.fold && x.full);
+  const byCraft = (a, b) => b.craft - a.craft;
+  // The bar is the category's best: references the project named (a benchmark brief's), then competitors by craft;
+  // a craft site from another category only when the category has too few (a bakery judged against a mail app
+  // tells nobody much).
+  const host = (u) => String(u ?? "").replace(/^https?:\/\/(www\.)?/, "").split("/")[0];
+  const named = new Set((readJson(path.join(dir, ".palate", "bench.json"), {})?.references ?? []).map((r) => host(r.url ?? r)));
+  // Then the strongest remaining reference of any kind, so a niche category's weak sites aren't the only bar.
+  const picked = all.filter((x) => named.has(host(x.url))).sort(byCraft).slice(0, limit);
+  const comp = all.filter((x) => x.role === "competitor" && !picked.includes(x)).sort(byCraft)[0];
+  if (comp && picked.length < limit) picked.push(comp);
+  for (const x of [...all].sort(byCraft)) if (picked.length < limit && !picked.includes(x)) picked.push(x);
+  return picked;
+}
+
+// The user's saved references (palate refs add) with a first screen and a full page, as the bar: the ones they
+// noted as strong first ("best product storytelling sections"), the project's own site never. They may be from
+// another category, and the pair packet says so: judge the craft, not the category.
+export function userBar(dir, { limit = 2, list } = {}) {
+  let refs = list;
+  if (!refs) {
+    try {
+      refs = readJson(path.join(TASTE_DIR, "..", "refs", "refs.json"), []);
+    } catch {
+      refs = [];
+    }
+  }
+  const host = (u) => String(u ?? "").replace(/^https?:\/\/(www\.)?/, "").split("/")[0].toLowerCase();
+  const own = new Set([host(readJson(path.join(dir, "package.json"), {})?.homepage), path.basename(dir).toLowerCase()].filter(Boolean));
+  return (Array.isArray(refs) ? refs : [])
+    .map((x) => ({ x, fold: (x.files ?? []).find((f) => /fold\.(png|jpe?g)$/i.test(f)), full: (x.files ?? []).find((f) => /full\.(png|jpe?g)$/i.test(f)) }))
+    .filter(({ x, fold, full }) => fold && full && fs.existsSync(fold) && fs.existsSync(full) && !own.has(host(x.source)) && !own.has(host(x.source).split(".")[0]))
+    .map(({ x, fold, full }) => ({ name: host(x.source) || x.id, url: /^https?:/.test(x.source ?? "") ? x.source : null, fold, full, craft: (x.note ? 2 : 0) + ((x.likes ?? []).length ? 1 : 0), role: "your reference", added: x.added ?? "" }))
+    .sort((a, b) => b.craft - a.craft || String(b.added).localeCompare(String(a.added)))
+    .slice(0, limit);
+}
+
+// This user's own recent corrections from palate point (what they asked for, before and after), so the judge
+// looks with their eye. Only pairs whose images still exist.
+export function corrections(limit = 3) {
+  if (!fs.existsSync(POINT_LOG)) return [];
+  const rows = fs
+    .readFileSync(POINT_LOG, "utf8")
+    .split("\n")
+    .filter(Boolean)
+    .map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    })
+    .filter((x) => x?.kind === "point-done" && x.prompt && x.before && x.after && fs.existsSync(x.before) && fs.existsSync(x.after));
+  return rows.slice(-limit).reverse();
+}
+
+// Snapshot of the project's source (src/, app/, components/, styles), so a repair that makes things worse can be
+// rolled back. Small projects only: skipped above 8 MB.
+const SRC_DIRS = ["src", "app", "components", "styles", "pages", "lib"];
+export function snapshot(dir, into) {
+  let bytes = 0;
+  const files = [];
+  const walk = (d) => {
+    if (!fs.existsSync(d)) return;
+    for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      if (/^(node_modules|\.next|dist|build|\.palate|\.git)$/.test(e.name)) continue;
+      const p = path.join(d, e.name);
+      if (e.isDirectory()) walk(p);
+      else {
+        bytes += fs.statSync(p).size;
+        files.push(p);
+      }
+    }
+  };
+  for (const s of SRC_DIRS) walk(path.join(dir, s));
+  if (bytes > 8e6) return { ok: false, why: `source is ${Math.round(bytes / 1e6)} MB; no snapshot` };
+  // public/ too (a repair swaps photos there), under its own budget: a page's photos can run to tens of MB.
+  const code = files.length;
+  const codeBytes = bytes;
+  walk(path.join(dir, "public"));
+  if (bytes - codeBytes > 60e6) files.length = code;
+  for (const f of files) {
+    const to = path.join(into, path.relative(dir, f));
+    fs.mkdirSync(path.dirname(to), { recursive: true });
+    fs.copyFileSync(f, to);
+  }
+  return { ok: true, files: files.length };
+}
+export function restore(dir, route, round) {
+  const rr = readRounds(dir, route);
+  const r = rr.rounds.find((x) => x.n === Number(round)) ?? null;
+  if (!r?.snapshot) throw new Error(`No snapshot for round ${round} of ${route}.`);
+  const from = r.snapshot;
+  let n = 0;
+  const walk = (d) => {
+    for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      const p = path.join(d, e.name);
+      if (e.isDirectory()) walk(p);
+      else {
+        const to = path.join(dir, path.relative(from, p));
+        fs.mkdirSync(path.dirname(to), { recursive: true });
+        fs.copyFileSync(p, to);
+        n++;
+      }
+    }
+  };
+  walk(from);
+  // The restored round's verdict is the page's verdict again: palate check and bench record read it, not the
+  // rolled-back round's.
+  try {
+    const v = readJson(path.join(r.at, "verdict.json"), null);
+    const st = readJson(path.join(r.at, "state.json"), null);
+    if (v && st) {
+      const prev = readJson(path.join(dir, ".palate", "quality.json"), {})[route];
+      saveQuality(dir, route, v, st, { final: Boolean(prev?.final) });
+    }
+    rr.best = r.n;
+    fs.writeFileSync(roundsFile(dir, route), JSON.stringify(rr, null, 1));
+  } catch {}
+  return `Restored ${n} files (source and public/) from round ${round} (${slash(from)}); round ${round}'s verdict is the page's verdict again. Files added since then are still there: delete them if they belong only to the reverted repair.`;
+}
+
+// A full-page screenshot cut into screen-sized parts (at most `max`, from the top), so a judge sees a long page
+// at a legible size instead of shrunk to a strip (a judge saw Missive's full page at a fifth of its size).
+export async function sliceTall(file, { height = 1600, max = 4, width = 1440 } = {}) {
+  const { acquireBrowser } = await import("../pool.mjs");
+  const { browser, release } = await acquireBrowser();
+  try {
+    const page = await browser.newPage();
+    try {
+      const type = /\.jpe?g$/i.test(file) ? "image/jpeg" : "image/png";
+      const parts = await page.evaluate(
+        async ([src, h, n, w]) => {
+          const img = new Image();
+          img.src = src;
+          await img.decode();
+          const scale = Math.min(1, w / img.naturalWidth);
+          const sh = h / scale;
+          const res = [];
+          for (let y = 0, i = 0; y < img.naturalHeight && i < n; y += sh, i++) {
+            const c = document.createElement("canvas");
+            const take = Math.min(sh, img.naturalHeight - y);
+            c.width = Math.round(img.naturalWidth * scale);
+            c.height = Math.round(take * scale);
+            c.getContext("2d").drawImage(img, 0, y, img.naturalWidth, take, 0, 0, c.width, c.height);
+            res.push(c.toDataURL("image/jpeg", 0.85));
+          }
+          return res;
+        },
+        [`data:${type};base64,${fs.readFileSync(file).toString("base64")}`, height, max, width],
+      );
+      return parts.map((d) => Buffer.from(d.split(",")[1], "base64"));
+    } finally {
+      await page.close();
+    }
+  } finally {
+    await release();
+  }
+}
+
+const JSON_RULE = "Answer only from what you see in the images. Be strict: a strong human designer is the bar, not other AI output. Write the JSON file exactly as specified and nothing else.";
+
+// The project's own facts (its README), for the judges: a quote, a name or a price the project gave is real, and a
+// section that shows only what the facts give is honest, not thin. Without this, judges called a README's own quote
+// "invented" and failed honest sections for lacking a photo or organisation the project never had.
+export function projectFacts(dir, { max = 3000 } = {}) {
+  for (const f of ["README.md", "readme.md", "README", "BRIEF.md"]) {
+    try {
+      const t = fs.readFileSync(path.join(dir, f), "utf8").replace(/\r\n/g, "\n").trim();
+      if (t) return t.length > max ? `${t.slice(0, max)}\n…` : t;
+    } catch {}
+  }
+  return null;
+}
+
+export const FACTS_RULE = "Content that appears in these facts is the project's own: never call it invented, fake or unsourced. When a question asks for a detail the facts don't give (a photo of the person, an organisation, a source link, opening hours), answer YES if the section shows only what the facts give and invents nothing; answer NO if it fills the gap with something made up (an invented surname, a stock face, a fake source).";
+
+function checklistPacket({ route, job, sections, phone, firstScreen, questions, page, out, mine, bar = [], tablet = {}, facts = null }) {
+  return [
+    "# Design review: section checklist",
+    "",
+    "You are an independent design reviewer. You did not make this page and you have no stake in it. Open every image with your image tool before answering.",
+    job ? `The page is the ${route} page for: ${job}` : null,
+    "",
+    `- The first screen at 1440: ${slash(firstScreen)}`,
+    `- The whole page on a phone (390): ${slash(phone)}`,
+    tablet.fold ? `- The first screen on a tablet, landscape (1024): ${slash(tablet.fold)}` : null,
+    tablet.full ? `- The whole page on a tablet, portrait (768): ${slash(tablet.full)}` : null,
+    "",
+    ...(facts ? ["## The project's facts (from its README)", "```", facts, "```", FACTS_RULE, ""] : []),
+    ...(bar.length
+      ? [
+          "## The bar",
+          "Strong real sites in the same category, for calibration only (they are not being reviewed). A section answers YES to \"finished\" only if it would hold up next to these:",
+          ...bar.map((b, i) => `- Site ${i + 1}, full page: ${slash(b)}`),
+          "",
+        ]
+      : []),
+    ...(mine.length
+      ? [
+          "## How this user judges (their own recent corrections: what they asked for, then before → after)",
+          ...mine.map((m) => `- "${m.prompt}" (${m.route}): ${slash(m.before)} → ${slash(m.after)}`),
+          "Hold the page to the standard these corrections show.",
+          "",
+        ]
+      : []),
+    "## Each section",
+    "Answer every question YES or NO (YES = good), and give each section a `worst` line: the one thing most below the bar, in under 20 words.",
+    ...sections.map((s) => [`### Section ${s.n}: ${s.name}${s.archetype ? ` (meant to be: ${s.archetype})` : ""}`, `Image: ${slash(s.file)}`, ...questions(s).map((q) => `- ${q.id}: ${q.q}`)].join("\n")),
+    "",
+    "## The whole page",
+    ...page.map((q) => `- ${q.id}: ${q.q}`),
+    "",
+    JSON_RULE,
+    `Write ${slash(out)} as {"sections": [{"n": 1, "answers": {"finished": true, ...}, "worst": "..."}, ...], "page": {"subject": true, ...}, "summary": "two sentences"}`,
+  ]
+    .filter((l) => l != null)
+    .join("\n");
+}
+
+function pairPacket({ comparisons, out, sameCategory = true }) {
+  return [
+    "# Design review: which page is better designed?",
+    "",
+    sameCategory
+      ? "You are an independent design reviewer comparing landing pages for different products in the same category. You made none of them. Open every image with your image tool before answering. Judge the design, not the product or the brand's fame."
+      : "You are an independent design reviewer comparing product landing pages. The products may be in different categories: judge the design craft, not the category, the product or the brand's fame. You made none of them. Open every image with your image tool before answering.",
+    "For each comparison, look at both first screens and both full pages, top to bottom. Weigh: the first impression and hierarchy; the finish (type, spacing, surfaces, buttons, details); imagery and material; whether every section is considered and different (not one template repeated); and whether the lower sections hold up as well as the first screen.",
+    "",
+    ...comparisons.map((c) => {
+      const full = (p, who) => (Array.isArray(p.parts) && p.parts.length ? p.parts.map((f, i) => `- Page ${who}, part ${i + 1} of ${p.parts.length} (top to bottom): ${slash(f)}`) : [`- Page ${who} full page: ${slash(p.full)}`]);
+      return [`## ${c.id}`, `- Page A first screen: ${slash(c.a.fold)}`, ...full(c.a, "A"), `- Page B first screen: ${slash(c.b.fold)}`, ...full(c.b, "B")].join("\n");
+    }),
+    "",
+    "For each: `winner` A, B or tie; `margin` clearly or slightly (omit for a tie); `weakestA` and `weakestB`: each page's single weakest section and why, in under 25 words, whoever wins.",
+    JSON_RULE,
+    `Write ${slash(out)} as {"comparisons": [{"id": "${comparisons[0]?.id ?? "c1"}", "winner": "A", "margin": "clearly", "weakestA": {"section": "...", "why": "..."}, "weakestB": {"section": "...", "why": "..."}}, ...]}`,
+  ].join("\n");
+}
+
+// The blueprint section each crop shows (or null). By the blueprint id first (the element's id, a word of its name,
+// heading or selector); the page's own header and nav are chrome unless the blueprint plans a section with that id;
+// the rest in order, but only when what's left lines up one to one. A crop palate can't place gets the generic
+// questions: asking a pre-order form the day-of-the-place questions (a header counted as section 1 shifted every
+// archetype by one) failed a good page.
+export function matchCrops(crops, plan) {
+  const low = (v) => String(v ?? "").toLowerCase();
+  const words = (v) => low(v).split(/[^a-z0-9]+/).filter(Boolean);
+  const idOf = (s) => low(s.id);
+  const hit = (c, s) => Boolean(idOf(s)) && (low(c.id) === idOf(s) || [c.id, c.selector].some((v) => words(v).includes(idOf(s)) || low(v).includes(`#${idOf(s)}`)) || words(c.name).join("-") === idOf(s) || words(c.heading).join("-") === idOf(s));
+  const used = new Set();
+  const out = crops.map((c) => {
+    const s = plan.find((p) => !used.has(p) && hit(c, p));
+    if (s) used.add(s);
+    return s ?? null;
+  });
+  const chrome = (c) => ["header", "nav"].includes(low(c.tag)) || ["header", "navigation"].includes(low(c.name));
+  const open = crops.map((c, i) => i).filter((i) => !out[i] && !chrome(crops[i]));
+  const left = plan.filter((p) => !used.has(p) && !["header", "nav", "navigation"].includes(idOf(p)));
+  if (open.length === left.length) open.forEach((i, k) => (out[i] = left[k]));
+  return out;
+}
+
+// Renders the page, runs the floor checks, crops every section and writes the judge packets.
+async function prepare(dir, route, { url, job } = {}) {
+  const rounds = readRounds(dir, route);
+  const n = rounds.rounds.length;
+  const at = path.join(rootFor(dir, route), `round-${n}-${stamp()}`);
+  fs.mkdirSync(at, { recursive: true });
+  // The tablet views come from the floor's own renders at 1024 and 768 (no extra page loads).
+  const tablet = { fold: path.join(at, "page-1024-fold.png"), full: path.join(at, "page-768.png") };
+  const floorShots = { 1024: [{ path: tablet.fold }], 768: [{ path: tablet.full, full: true }] };
+  const floor = Floor?.runFloor ? await Floor.runFloor(dir, route, { url, shots: floorShots }).catch((e) => ({ pass: true, checks: [], error: e.message })) : { pass: true, checks: [], error: "floor checks not installed" };
+  for (const k of Object.keys(tablet)) if (!fs.existsSync(tablet[k])) delete tablet[k];
+  // A route built from the user's own design (palate match) isn't held to palate's house look.
+  const userDesign = Boolean(matchedRoute(dir, route));
+  if (LookVec?.houseLookCheck && !userDesign) await LookVec.houseLookCheck(dir, route, floor, { url });
+  const bp = loadBlueprint(dir, { route });
+  const shots = await withBrowser(dir, { url }, async ({ base, browser }) => {
+    const { page, ctx } = await openPage(browser, base, route, { width: 1440, reducedMotion: true });
+    try {
+      const fold = path.join(at, "page-fold.png");
+      await page.screenshot({ path: fold });
+      const fp = FINGERPRINT ? await page.evaluate(`(${FINGERPRINT})()`).catch(() => null) : null;
+      const full = path.join(at, "page-full.png");
+      const image = await shootFull(page, full);
+      const sections = await findSections(page);
+      // The crops are cut from that same capture, so they match it.
+      const crops = await cropSections(page, sections, path.join(at, "sections"), "w1440", { image });
+      // The copy lock: every string the page showed before an existing-page change, checked against now.
+      const strings = bp?.before?.strings && fs.existsSync(bp.before.strings) ? await page.evaluate(() => {
+        const out = new Set();
+        const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
+        for (let n = walker.nextNode(); n; n = walker.nextNode()) {
+          const el = n.parentElement;
+          if (!el || el.closest("script,style,noscript,template,[aria-hidden=true]")) continue;
+          const cs = getComputedStyle(el);
+          if (cs.display === "none" || cs.visibility === "hidden") continue;
+          const t = n.textContent.replace(/\s+/g, " ").trim();
+          if (t.length >= 2) out.add(t);
+        }
+        for (const el of document.querySelectorAll("[alt],[aria-label],[placeholder],[title]")) for (const a of ["alt", "aria-label", "placeholder", "title"]) { const v = (el.getAttribute(a) ?? "").trim(); if (v.length >= 2) out.add(v); }
+        return [...out];
+      }).catch(() => null) : null;
+      const p = await openPage(browser, base, route, { width: 390, reducedMotion: true });
+      const phone = path.join(at, "page-390.png");
+      try {
+        await shootFull(p.page, phone);
+      } finally {
+        await p.ctx.close();
+      }
+      return { fold, full, phone, crops, strings, fp };
+    } finally {
+      await ctx.close();
+    }
+  });
+  for (const c of userDesign ? [] : await similarityChecks(dir, route, shots.fp)) {
+    floor.checks = [...(floor.checks ?? []), c];
+    floor.pass = false;
+  }
+  // Match crops to the blueprint's sections by order (the page's sections, header and footer included, are
+  // matched to the blueprint where the counts allow).
+  const plan = bp?.sections ?? [];
+  const matched = matchCrops(shots.crops, plan);
+  const sections = shots.crops.map((c, i) => {
+    const b = matched[i];
+    return { n: i + 1, name: c.heading || c.name || `section ${i + 1}`, file: c.file, archetype: b?.archetype ?? null, id: b?.id ?? null };
+  });
+  const questions = (s) => [...SECTION_QUESTIONS, ...(s.archetype && Sections?.floorChecks ? Sections.floorChecks(s.archetype).map((q, k) => ({ id: `a${k + 1}`, q })) : [])];
+  const mine = corrections();
+  const packets = [];
+  const checklistOut = path.join(at, "answers-checklist.json");
+  // Pairwise, both orders, each order with a different judge: packet 1 has ours as A for ref 1 and as B for
+  // ref 2; packet 2 the reverse.
+  const refs = exemplars(dir);
+  // An existing page's change is also judged against the page as it was (blueprint.mjs saved it): it may not get worse.
+  if (bp?.before?.full && fs.existsSync(bp.before.full) && fs.existsSync(bp.before.fold)) refs.unshift({ name: "the page before this change", url: null, fold: bp.before.fold, full: bp.before.full, before: true });
+  // Blind: every image in a comparison gets a random neutral name, so no file name says which page is ours or
+  // whose site a reference is (the first judges read "ours-fold.png" and knew).
+  const blindDir = path.join(at, "blind");
+  fs.mkdirSync(blindDir, { recursive: true });
+  const blind = (file) => {
+    const to = path.join(blindDir, `${crypto.randomBytes(5).toString("hex")}${path.extname(file)}`);
+    fs.copyFileSync(file, to);
+    return to;
+  };
+  const parts = async (file) => {
+    const bufs = await sliceTall(file).catch(() => []);
+    return bufs.map((b) => {
+      const to = path.join(blindDir, `${crypto.randomBytes(5).toString("hex")}.jpg`);
+      fs.writeFileSync(to, b);
+      return to;
+    });
+  };
+  const ours = { fold: blind(shots.fold), full: blind(shots.full), parts: await parts(shots.full) };
+  const refViews = [];
+  for (const ref of refs) refViews.push({ fold: blind(ref.fold), full: blind(ref.full), parts: await parts(ref.full) });
+  fs.writeFileSync(path.join(at, "packet-checklist.md"), checklistPacket({ route, job, sections, phone: shots.phone, firstScreen: shots.fold, questions, page: PAGE_QUESTIONS, out: checklistOut, mine, bar: refViews.flatMap((v) => (v.parts.length ? v.parts.slice(0, 2) : [v.full])), tablet, facts: projectFacts(dir) }));
+  packets.push({ file: path.join(at, "packet-checklist.md"), out: checklistOut });
+  const key = [];
+  if (refs.length) {
+    const order = [[], []];
+    refs.forEach((ref, i) => {
+      const r = refViews[i];
+      const id = `c${i + 1}`;
+      const oursFirst = { id, a: ours, b: r };
+      const refFirst = { id, a: r, b: ours };
+      order[0].push(i % 2 === 0 ? oursFirst : refFirst);
+      order[1].push(i % 2 === 0 ? refFirst : oursFirst);
+      key.push({ id, ref: ref.name, url: ref.url, before: Boolean(ref.before), oursIs: [i % 2 === 0 ? "A" : "B", i % 2 === 0 ? "B" : "A"] });
+    });
+    order.forEach((comparisons, k) => {
+      const out = path.join(at, `answers-pair-${k + 1}.json`);
+      const file = path.join(at, `packet-pair-${k + 1}.md`);
+      fs.writeFileSync(file, pairPacket({ comparisons, out, sameCategory: !refs.some((x) => x.role === "your reference") }));
+      packets.push({ file, out });
+    });
+  }
+  mark(dir, loopName(route), "gate_first");
+  mark(dir, loopName(route), "gate_round", { round: n });
+  const copy = shots.strings && bp?.before?.strings ? copyDiff(readJson(bp.before.strings, []), shots.strings, { locked: bp.copy !== "edit" }) : null;
+  delete shots.strings;
+  const state = { route, job, at, n, floor, shots, sections, refs, key, packets, copy, blueprint: bp?.file ?? null, created: new Date().toISOString() };
+  fs.writeFileSync(path.join(at, "state.json"), JSON.stringify(state, null, 1));
+  return state;
+}
+
+// The copy lock: what an existing page showed before that it doesn't now (and what's new). Whitespace and case of
+// spacing are ignored; a string counts as kept when it appears whole inside a longer one now (a sentence merged
+// into a paragraph). locked: the blueprint didn't say copy: "edit".
+export function copyDiff(before, after, { locked = true } = {}) {
+  const norm = (x) => String(x).replace(/\s+/g, " ").trim();
+  const now = after.map(norm);
+  const joined = now.join(" \u0001 ");
+  const prev = before.map(norm);
+  const missing = prev.filter((x) => x.length >= 2 && !now.includes(x) && !joined.includes(x));
+  const was = new Set(prev);
+  const was2 = prev.join(" \u0001 ");
+  const added = now.filter((x) => !was.has(x) && !was2.includes(x));
+  return { locked, kept: prev.length - missing.length, total: prev.length, missing, added };
+}
+
+// The verdict from the floor checks and the judges' answers.
+export function verdict(state, answers) {
+  const fails = [];
+  const warns = [];
+  for (const c of state.floor?.checks ?? []) (c.severity === "fail" ? fails : warns).push({ layer: "floor", id: c.id, section: c.section ?? null, what: c.what, fix: c.fix });
+  // The copy lock (an existing page): strings the page showed before and doesn't now.
+  if (state.copy?.missing?.length) (state.copy.locked ? fails : warns).push({ layer: "floor", id: "COPY_LOST", section: null, what: `${state.copy.missing.length} string${state.copy.missing.length > 1 ? "s" : ""} the page showed before ${state.copy.missing.length > 1 ? "are" : "is"} gone: ${state.copy.missing.slice(0, 6).map((x) => `"${x.slice(0, 60)}"`).join(", ")}${state.copy.missing.length > 6 ? ` and ${state.copy.missing.length - 6} more` : ""}`, fix: state.copy.locked ? "Put them back word for word (the copy is locked unless the blueprint says copy: edit)" : "Check each was meant to go" });
+  if (state.copy?.added?.length) warns.push({ layer: "floor", id: "COPY_NEW", section: null, what: `${state.copy.added.length} new string${state.copy.added.length > 1 ? "s" : ""} (list them in the hand-off): ${state.copy.added.slice(0, 6).map((x) => `"${x.slice(0, 40)}"`).join(", ")}` });
+  const cl = answers.checklist;
+  const weakVotes = {};
+  if (cl) {
+    for (const s of cl.sections ?? []) {
+      const sec = state.sections.find((x) => x.n === Number(s.n));
+      const entries = Object.entries(s.answers ?? {});
+      const nos = entries.filter(([, v]) => no(v)).map(([k]) => k);
+      const mustFail = SECTION_QUESTIONS.filter((q) => q.must).some((q) => no(s.answers?.[q.id]));
+      if (mustFail || nos.length >= 2) fails.push({ layer: "checklist", id: "SECTION_BELOW_BAR", section: { n: Number(s.n), name: sec?.name }, what: `section ${s.n} (${sec?.name ?? "?"}) answered NO to ${nos.join(", ")}${s.worst ? `: ${s.worst}` : ""}`, fix: s.worst ?? null });
+      else if (nos.length) warns.push({ layer: "checklist", id: "SECTION_NO", section: { n: Number(s.n), name: sec?.name }, what: `section ${s.n} (${sec?.name ?? "?"}): NO to ${nos.join(", ")}${s.worst ? `: ${s.worst}` : ""}` });
+      if (s.worst) weakVotes[s.n] = (weakVotes[s.n] ?? 0) + (nos.length ? 1 : 0);
+    }
+    for (const q of PAGE_QUESTIONS) {
+      if (!no(cl.page?.[q.id])) continue;
+      (q.must ? fails : warns).push({ layer: "checklist", id: `PAGE_${q.id.toUpperCase()}`, section: null, what: `the page: NO to "${q.q}"` });
+    }
+  }
+  // Pairwise: per reference, ours in each order.
+  const pairs = [];
+  for (const k of state.key ?? []) {
+    const res = [answers.pair1, answers.pair2].map((p, idx) => {
+      const c = p?.comparisons?.find((x) => x.id === k.id);
+      if (!c) return null;
+      const oursSide = k.oursIs[idx];
+      const w = String(c.winner ?? "").trim().toUpperCase();
+      const outcome = w === "TIE" || !w ? "tie" : w === oursSide ? "win" : "lose";
+      const mineW = c[`weakest${oursSide}`] ?? (c.weakest && String(c.weakest.page ?? "").toUpperCase() === oursSide ? c.weakest : null);
+      return { outcome, margin: outcome === "tie" ? null : String(c.margin ?? "slightly").toLowerCase(), oursWeakest: mineW ?? null };
+    });
+    const [a, b] = res;
+    let result = "incomplete";
+    if (a && b) {
+      if (a.outcome === b.outcome) result = a.outcome === "lose" && a.margin === "clearly" && b.margin === "clearly" ? "clearly worse" : a.outcome === "lose" ? "worse" : a.outcome === "win" ? "better" : "tie";
+      else result = "tie (the two orders disagree)";
+    }
+    pairs.push({ ref: k.ref, url: k.url, result, orders: res });
+    for (const o of res) if (o?.oursWeakest) weakVotes[o.oursWeakest.section] = (weakVotes[o.oursWeakest.section] ?? 0) + 1;
+    if (k.before) {
+      if (/worse/.test(result)) fails.push({ layer: "pairwise", id: "WORSE_THAN_BEFORE", section: null, what: `${result} than the page before this change, in both orders: the change made it worse${res.find((o) => o?.oursWeakest) ? `; weakest now: ${res.find((o) => o?.oursWeakest).oursWeakest.section}: ${res.find((o) => o?.oursWeakest).oursWeakest.why}` : ""}` });
+      else if (/^tie/.test(result)) warns.push({ layer: "pairwise", id: "NO_BETTER", section: null, what: `no better than the page before this change (${result})` });
+      continue;
+    }
+    if (result === "clearly worse") fails.push({ layer: "pairwise", id: "CLEARLY_WORSE", section: null, what: `clearly worse than ${k.ref} in both orders${res.find((o) => o?.oursWeakest) ? `; weakest: ${res.find((o) => o?.oursWeakest).oursWeakest.section}: ${res.find((o) => o?.oursWeakest).oursWeakest.why}` : ""}` });
+    else if (result === "worse") warns.push({ layer: "pairwise", id: "BEHIND", section: null, what: `behind ${k.ref} in both orders (slightly)` });
+  }
+  const pass = !fails.length;
+  // A round's standing, for "keep the best round": fewer fails, then fewer pairwise losses, then fewer warns.
+  const losses = pairs.filter((p) => /worse/.test(p.result)).length;
+  const score = fails.length * 100 + losses * 10 + warns.length;
+  return { pass, fails, warns, pairs, score, weakVotes };
+}
+
+// The one thing to repair this round: a failing section first (floor fails before judge fails), else the section
+// the judges named weakest most often.
+export function repairTarget(state, v) {
+  const bySection = {};
+  for (const f of v.fails) {
+    const n = f.section?.n ?? f.section?.index ?? null;
+    if (n == null) continue;
+    (bySection[n] ??= []).push(f);
+  }
+  const worst = Object.entries(bySection).sort((a, b) => b[1].length - a[1].length || (b[1].some((x) => x.layer === "floor") ? 1 : 0) - (a[1].some((x) => x.layer === "floor") ? 1 : 0))[0];
+  if (worst) return { n: Number(worst[0]), why: worst[1] };
+  const voted = Object.entries(v.weakVotes ?? {}).sort((a, b) => b[1] - a[1])[0];
+  if (voted) {
+    const n = Number(voted[0]);
+    const sec = Number.isFinite(n) ? state.sections.find((s) => s.n === n) : state.sections.find((s) => s.name.toLowerCase().includes(String(voted[0]).toLowerCase()));
+    if (sec) return { n: sec.n, why: v.fails.filter((f) => !f.section) };
+  }
+  const pageFail = v.fails.find((f) => !f.section);
+  return pageFail ? { n: null, why: [pageFail] } : null;
+}
+
+// Every section below the bar this round (up to max), each with its own findings; page-wide findings go with the
+// first. Each is repaired by its own builder in parallel: they touch different sections, so they don't undo each
+// other, and one round replaces what used to be two (the benchmark spent ~15 minutes in serial repair rounds).
+export function repairTargets(state, v, { max = 3 } = {}) {
+  const bySection = {};
+  for (const f of v.fails) {
+    const n = f.section?.n ?? f.section?.index ?? null;
+    if (n == null) continue;
+    (bySection[n] ??= []).push(f);
+  }
+  const ranked = Object.entries(bySection).sort((a, b) => b[1].length - a[1].length || (b[1].some((x) => x.layer === "floor") ? 1 : 0) - (a[1].some((x) => x.layer === "floor") ? 1 : 0));
+  const out = ranked.slice(0, max).map(([n, why]) => ({ n: Number(n), why }));
+  const page = v.fails.filter((f) => !f.section);
+  if (!out.length) {
+    const t = repairTarget(state, v);
+    return t ? [t] : [];
+  }
+  if (page.length) out[0].why = [...out[0].why, ...page];
+  return out;
+}
+
+// What this job may change. The gate judges the whole page, so on a page still being built ("add the pricing section")
+// the judges say the page "just stops, no footer": a repair then built a closing section the user never asked for.
+// On an existing page the blueprint's add/upgrade sections are the scope; the rest is a suggestion for the user.
+export function scopeLines(bp) {
+  if (bp?.mode !== "existing") return [];
+  const ids = (bp.sections ?? []).filter((s) => ["add", "upgrade"].includes(s.action)).map((s) => s.id);
+  if (!ids.length) return [];
+  return [
+    "## This job's scope",
+    `${bp.job ? `The user asked: "${String(bp.job).slice(0, 240)}". ` : ""}This build adds or changes only: ${ids.join(", ")}. Fix what's below the bar inside those (and the tokens they use).`,
+    "If the judges say something outside them is missing or weak (an ending, a footer, a section the page doesn't have yet, another section's look), don't build or change it: tell the user in one line as a suggestion and leave it for them to ask.",
+    "",
+  ];
+}
+
+function repairBrief(dir, state, v, target, { round, of = 1 }) {
+  const sec = target?.n ? state.sections.find((s) => s.n === target.n) : null;
+  const bp = loadBlueprint(dir, { route: state.route });
+  const planned = sec?.id ? bp?.sections?.find((s) => s.id === sec.id) : null;
+  const arche = sec?.archetype && Sections?.sectionBrief ? Sections.sectionBrief(sec.archetype) : null;
+  return [
+    `# Repair round ${round} of ${MAX_ROUNDS}: ${sec ? `section ${sec.n}, ${sec.name}` : "the page"}`,
+    "",
+    of > 1 ? `One of ${of} sections repaired in parallel this round, each by its own builder. Change only this section's own files (and nothing another section uses); palate snapshotted the source before this round.` : "One target this round. Change only this section (and the tokens it needs). palate snapshotted the source before this round.",
+    sec ? `- Its crop now: ${slash(sec.file)}` : null,
+    planned ? `- Its job in the blueprint: ${planned.job}. Content: ${planned.content ?? "-"}. Surface: ${planned.surface}. Imagery: ${planned.imagery}.` : null,
+    "",
+    ...scopeLines(bp),
+    "## What's below the bar",
+    ...(target?.why?.length ? target.why : v.fails).map((f) => `- [${f.layer}] ${f.what}${f.fix ? ` → ${f.fix}` : ""}`),
+    ...v.pairs.filter((p) => p.orders.some((o) => o?.oursWeakest)).map((p) => `- Judges comparing with ${p.ref}: ${p.orders.filter((o) => o?.oursWeakest).map((o) => `${o.oursWeakest.section}: ${o.oursWeakest.why}`).join("; ")}`),
+    "",
+    ...(arche ? ["## The archetype this section follows (rebuild it to this, completely)", arche, ""] : []),
+    "Facts come only from the project (its README and existing copy): where the archetype asks for something the project doesn't have (a photo of the person, an organisation, a source, opening hours), leave it out and make the section strong without it. Never invent a surname, a face, a source or a number.",
+    Sections?.finishStandard ? `The shared finish: kb/sections/_finish.md.` : null,
+    "",
+    `Then: \`palate gate ${state.route}\` again (it renders, re-checks and writes new judge packets; run them with fresh subagents, then --answers). If the round got worse, palate says so and rolls it back with --restore.`,
+  ]
+    .filter((l) => l != null)
+    .join("\n");
+}
+
+function logGate(dir, state, v) {
+  try {
+    fs.mkdirSync(TASTE_DIR, { recursive: true });
+    fs.appendFileSync(GATE_LOG, JSON.stringify({ project: path.basename(path.resolve(dir)), route: state.route, round: state.n, pass: v.pass, fails: v.fails.map((f) => f.id), pairs: v.pairs.map((p) => ({ ref: p.ref, result: p.result })), at: new Date().toISOString() }) + "\n");
+  } catch {}
+}
+
+// Saves the route's latest quality verdict (palate check reads it).
+function saveQuality(dir, route, v, state, { final = false } = {}) {
+  const f = path.join(dir, ".palate", "quality.json");
+  const all = readJson(f, {});
+  all[route] = { pass: v.pass, final, at: new Date().toISOString(), round: state.n, fails: v.fails.map((x) => x.what), pairs: v.pairs.map((p) => `${p.result} vs ${p.ref}`) };
+  fs.mkdirSync(path.dirname(f), { recursive: true });
+  fs.writeFileSync(f, JSON.stringify(all, null, 1));
+}
+
+function readAnswers(state, given) {
+  const pick = (re) => {
+    const cands = [...(given ?? []), ...state.packets.map((p) => p.out)].filter((f) => re.test(path.basename(f)) && fs.existsSync(f));
+    return cands.length ? readJson(cands[0], null) : null;
+  };
+  return { checklist: pick(/checklist/i), pair1: pick(/pair-?1/i), pair2: pick(/pair-?2/i) };
+}
+
+// judge: "subagent" (default: the agent runs each packet with a fresh subagent), "api" (palate runs the packets
+// itself with a model API from judge-api.mjs, for agents without subagents: Codex, Cursor), or "self" (no
+// subagents and no key: the builder answers, and the verdict says so; a builder grades its own work too kindly).
+export async function gate(dir, rawRoute, { url, answers, job, restore: restoreRound, judge = "subagent" } = {}) {
+  const route = normalizeRoute(rawRoute);
+  if (restoreRound != null) return restore(dir, route, restoreRound);
+  // The user's own design is the spec there: fidelity is checked by palate match, not palate's taste.
+  if (matchedRoute(dir, route) && !answers) return [`# Quality gate ${route}: not for this route`, "", MATCHED_NOTE(route), "That check renders the build beside the design and keeps contrast and clipping as warnings; it never changes the design."].join("\n");
+  const rr = readRounds(dir, route);
+  if (!answers && judge === "api") {
+    const J = await import("./judge-api.mjs");
+    const provider = J.judgeProvider();
+    if (!provider) return "No judge API key (GEMINI_API_KEY or GOOGLE_API_KEY, OPENAI_API_KEY, ANTHROPIC_API_KEY), or PALATE_JUDGE=off. Run the packets with fresh subagents instead, or --judge self (marked as self-judged).";
+    const meta = loadBlueprint(dir, { route });
+    const state = await prepare(dir, route, { url, job: job ?? meta?.job });
+    const res = await J.runPackets(state.packets, { provider });
+    state.judge = { mode: "api", provider: provider.name, model: provider.model };
+    fs.writeFileSync(path.join(state.at, "state.json"), JSON.stringify(state, null, 1));
+    const failed = res.filter((x) => !x.ok);
+    if (failed.length) return [`# Quality gate ${route}: the API judge failed on ${failed.length} packet(s)`, ...failed.map((f) => `- ${slash(f.file?.file ?? f.file)}: ${f.error}`), "", `Run those packets with fresh subagents, then palate gate ${route} --answers ${slash(state.at)}.`].join("\n");
+    return gate(dir, rawRoute, { url, answers: [state.at], job });
+  }
+  if (!answers) {
+    const meta = loadBlueprint(dir, { route });
+    const state = await prepare(dir, route, { url, job: job ?? meta?.job });
+    if (judge === "self") {
+      state.judge = { mode: "self" };
+      fs.writeFileSync(path.join(state.at, "state.json"), JSON.stringify(state, null, 1));
+    }
+    const lines = [
+      `# Quality gate ${route}: round ${state.n}`,
+      "",
+      `## Floor checks (palate measured): ${state.floor.pass ? "pass" : "FAIL"}${state.floor.error ? ` (${state.floor.error})` : ""}`,
+      ...(Floor?.floorLines ? [].concat(Floor.floorLines(state.floor)) : (state.floor.checks ?? []).map((c) => `- ${c.severity === "fail" ? "✗" : "!"} ${c.id}: ${c.what}`)),
+      "",
+      "## The judges (independent: never the agent that built the page)",
+      ...state.packets.map((p, i) => `${i + 1}. ${slash(p.file)}`),
+      state.refs.length ? `Compared with: ${state.refs.map((r) => r.name).join(", ")} (each in both orders, by different judges).` : "No research captures to compare with: only the checklist judge runs. Run palate research for this page to add the comparison.",
+      "",
+      `Run each packet with its own fresh subagent, in parallel: "Read <packet> and follow it exactly." Don't judge them yourself (a builder grades its own work too kindly), and don't tell the judges which page is ours. Then: \`palate gate ${route} --answers ${slash(state.at)}\`.`,
+    ];
+    return lines.join("\n");
+  }
+  // --answers: the latest prepared round (or the directory given).
+  const dirGiven = answers.length === 1 && fs.existsSync(answers[0]) && fs.statSync(answers[0]).isDirectory() ? answers[0] : null;
+  const latest = dirGiven ?? fs.readdirSync(rootFor(dir, route)).filter((n) => n.startsWith("round-")).map((n) => path.join(rootFor(dir, route), n)).sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs)[0];
+  const state = readJson(path.join(latest, "state.json"), null);
+  if (!state) throw new Error(`No prepared gate round for ${route}. Run palate gate ${route} first.`);
+  const files = dirGiven ? fs.readdirSync(dirGiven).map((f) => path.join(dirGiven, f)) : answers;
+  const ans = readAnswers(state, files);
+  if (!ans.checklist) throw new Error(`No checklist answers yet: ${slash(state.packets[0].out)}`);
+  const v = verdict(state, ans);
+  v.judge = state.judge ?? { mode: "subagent" };
+  // A page that gained sections since the last round is a new build (Moveday's features under the hero): its rounds
+  // start again, so it isn't "final" on arrival and is never rolled back to a round without those sections. The old
+  // series is kept beside it.
+  const last = rr.rounds.at(-1);
+  const lastState = last ? readJson(path.join(last.at, "state.json"), null) : null;
+  const key = (s) => String(s.id ?? s.name ?? "").toLowerCase().trim();
+  if (lastState?.sections && state.sections.some((s) => key(s) && !lastState.sections.some((p) => key(p) === key(s)))) {
+    const old = path.join(rootFor(dir, route), `rounds-before-${stamp()}.json`);
+    fs.writeFileSync(old, JSON.stringify(rr, null, 1));
+    rr.rounds = [];
+    rr.best = null;
+  }
+  // Rounds: record this one; compare with the best so far.
+  const prevBest = rr.best != null ? rr.rounds.find((x) => x.n === rr.best) : null;
+  // Worse means more fails: not a warning more, and not a "slightly behind" against a reference, which flips with
+  // judge noise (the benchmark rolled back rounds that had fixed their target over 413 vs 406 and 317 vs 304). With
+  // as many fails, the newer round wins: it carries the repairs.
+  const worse = prevBest && v.fails.length > prevBest.fails;
+  const snap = path.join(state.at, "source");
+  const snapped = v.pass ? { ok: false } : snapshot(dir, snap);
+  const entry = { n: state.n, at: state.at, pass: v.pass, score: v.score, fails: v.fails.length, snapshot: snapped.ok ? snap : null };
+  rr.rounds = [...rr.rounds.filter((x) => x.n !== state.n), entry];
+  if (!prevBest || !worse) rr.best = state.n;
+  writeRounds(dir, route, rr);
+  saveQuality(dir, route, v, state, { final: rr.rounds.length - 1 >= MAX_ROUNDS });
+  logGate(dir, state, v);
+  fs.writeFileSync(path.join(state.at, "verdict.json"), JSON.stringify(v, null, 1));
+  const repairs = rr.rounds.length - 1;
+  const head = [
+    `# Quality gate ${route}, round ${state.n}: ${v.pass ? "PASS" : "below the bar"}${v.judge.mode === "self" ? " (self-judged: weaker; a builder grades its own work too kindly)" : ""}`,
+    "",
+    ...(v.judge.mode === "api" ? [`Judged by ${v.judge.provider} (${v.judge.model}) through its API${v.judge.provider === "anthropic" ? ": the same model family as a Claude builder" : ""}.`, ""] : []),
+    ...v.pairs.map((p) => `- Against ${p.ref}: ${p.result}`),
+    ...v.fails.map((f) => `- ✗ [${f.layer}] ${f.what}`),
+    ...v.warns.slice(0, 8).map((w) => `- ! [${w.layer}] ${w.what}`),
+    "",
+  ];
+  mark(dir, loopName(route), "gate_verdict", { round: state.n, pass: v.pass });
+  let took = buildTookLine(loopTimeline(dir, loopName(route)));
+  const active = activeMinutes(dir, loopName(route));
+  const wall = buildDurations(loopTimeline(dir, loopName(route)))?.total;
+  // Long pauses (a stall, a break) aren't build time: say the active minutes when they differ.
+  if (took && active != null && wall && wall - active > 10 * 60_000) took = took.replace(/^This build took [\d.]+ min/, `This build took ${minutes(active)} min of active work (${minutes(wall)} min on the clock, with pauses)`);
+  if (took) head.push(took, "");
+  if (v.pass) return [...head, "The page clears the floor. Finish with palate states, details and animate, then offer palate point."].join("\n");
+  if (worse && prevBest?.snapshot) {
+    return [...head, `This round is worse than round ${prevBest.n} (score ${v.score} vs ${prevBest.score}). Roll it back: \`palate gate ${route} --restore ${prevBest.n}\`, then try a different repair of the same target, or stop if this was the last round.`].join("\n");
+  }
+  if (repairs >= MAX_ROUNDS) {
+    return [...head, `That was the last repair round (${MAX_ROUNDS}). Tell the user honestly where the page is still below the bar (the lines above) and offer palate point so they can direct the fix. Best round: ${rr.best}.`].join("\n");
+  }
+  const targets = repairTargets(state, v);
+  const briefs = targets.map((t, i) => {
+    const file = path.join(state.at, targets.length > 1 ? `repair-${i + 1}.md` : "repair.md");
+    fs.writeFileSync(file, repairBrief(dir, state, v, t, { round: repairs + 1, of: targets.length }));
+    return file;
+  });
+  return [
+    ...head,
+    targets.length > 1 ? `Repair briefs (${targets.length} sections, in parallel):` : "Repair brief (one section):",
+    ...briefs.map((f) => `- ${slash(f)}`),
+    targets.length > 1 ? `Run each with its own fresh subagent at the same time: "Read <brief> and follow it exactly." Then palate gate ${route} again.` : `Do it yourself or with one subagent: "Read ${slash(briefs[0])} and follow it exactly." Then palate gate ${route} again.`,
+  ].join("\n");
+}
+
+// What palate check reports: routes whose latest quality gate is below the bar.
+export function qualityBlockers(dir) {
+  const all = readJson(path.join(dir, ".palate", "quality.json"), {});
+  return Object.entries(all)
+    .filter(([, v]) => !v.pass)
+    .map(([route, v]) => ({ route, what: `below the quality bar (round ${v.round}): ${v.fails.slice(0, 2).join("; ")}` }));
+}
+
+// A benchmark row from the latest gate round of this project (palate bench record).
+export function benchResultFrom(dir, { from } = {}) {
+  const q = path.join(dir, ".palate", "quality");
+  let at = from ? path.resolve(from) : null;
+  if (!at && fs.existsSync(q)) {
+    const rounds = fs.readdirSync(q).flatMap((slug) => (fs.statSync(path.join(q, slug)).isDirectory() ? fs.readdirSync(path.join(q, slug)).filter((n) => n.startsWith("round-")).map((n) => path.join(q, slug, n)) : []));
+    const judged = rounds.filter((r) => fs.existsSync(path.join(r, "verdict.json")));
+    // The round the source is at: after a --restore that's the best round, not the latest one judged.
+    const best = judged.map((r) => ({ r, rr: readJson(path.join(path.dirname(r), "rounds.json"), null) })).find(({ r, rr }) => rr?.best != null && path.basename(r).startsWith(`round-${rr.best}-`));
+    at = best?.r ?? judged.sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs)[0] ?? null;
+  }
+  const v = at ? readJson(path.join(at, "verdict.json"), null) : null;
+  if (!v) throw new Error("No judged gate round yet: run palate gate <route> and --answers first.");
+  const count = (re) => v.pairs.filter((p) => re.test(p.result)).length;
+  return {
+    floor: { pass: v.pass, fails: v.fails.map((f) => f.id) },
+    vsRefs: { wins: count(/^better/), ties: count(/^tie$/), losses: count(/worse/), inconsistent: count(/disagree/) },
+    gate: slash(at),
+  };
+}
+
+// ---- best of two: the hero (or any section) built two ways, judged blind in both orders.
+// The page renders option B when the URL carries ?palate-alt=<section> (the builder wires that switch). The judges
+// see two first screens labelled A and B; the user decides only when the two orders disagree.
+export async function duel(dir, rawRoute, { section = "hero", url, answers } = {}) {
+  const route = normalizeRoute(rawRoute);
+  const root = path.join(rootFor(dir, route), `duel-${section}`);
+  if (!answers) {
+    fs.mkdirSync(root, { recursive: true });
+    const shots = await withBrowser(dir, { url }, async ({ base, browser }) => {
+      const out = {};
+      for (const [k, q] of [["one", ""], ["two", `?palate-alt=${encodeURIComponent(section)}`]]) {
+        for (const width of [1440, 390]) {
+          const { page, ctx } = await openPage(browser, base, route + q, { width, reducedMotion: true });
+          try {
+            const f = path.join(root, `${k}-${width}.png`);
+            await page.screenshot({ path: f, fullPage: width === 390 ? false : false });
+            out[`${k}${width}`] = f;
+          } finally {
+            await ctx.close();
+          }
+        }
+      }
+      return out;
+    });
+    const packet = (first, second, k) => {
+      const out = path.join(root, `answers-${k}.json`);
+      const file = path.join(root, `packet-${k}.md`);
+      fs.writeFileSync(
+        file,
+        [
+          `# Design review: two versions of a ${section}`,
+          "",
+          "You are an independent design reviewer; you made neither. Open every image with your image tool. Same page, same product, two versions of its first screen.",
+          `- Version A at 1440: ${slash(shots[`${first}1440`])} · on a phone: ${slash(shots[`${first}390`])}`,
+          `- Version B at 1440: ${slash(shots[`${second}1440`])} · on a phone: ${slash(shots[`${second}390`])}`,
+          "",
+          "Which is better designed: clearer, more distinctive, better finished, and truer to what the product is? Judge both widths.",
+          JSON_RULE,
+          `Write ${slash(out)} as {"winner": "A" | "B" | "tie", "margin": "clearly" | "slightly", "why": "under 25 words"}`,
+        ].join("\n"),
+      );
+      return { file, out };
+    };
+    const p = [packet("one", "two", 1), packet("two", "one", 2)];
+    fs.writeFileSync(path.join(root, "duel.json"), JSON.stringify({ route, section, packets: p }, null, 1));
+    return [
+      `# Best of two: the ${section} of ${route}`,
+      "",
+      ...p.map((x, i) => `${i + 1}. ${slash(x.file)}`),
+      "",
+      `Run each packet with its own fresh subagent, in parallel, then: palate gate ${route} --duel ${section} --answers ${slash(root)}`,
+    ].join("\n");
+  }
+  const d = readJson(path.join(root, "duel.json"), null);
+  if (!d) throw new Error(`No duel for ${section} on ${route}: run palate gate ${route} --duel ${section} first.`);
+  const [a, b] = d.packets.map((p) => readJson(p.out, null));
+  if (!a || !b) throw new Error("Both judges' answers are needed.");
+  // Packet 1: A = current, B = alternative. Packet 2 the reverse.
+  const pick = (ans, flip) => {
+    const w = String(ans.winner ?? "").toUpperCase();
+    if (w !== "A" && w !== "B") return "tie";
+    return (w === "A") !== flip ? "current" : "alternative";
+  };
+  const [r1, r2] = [pick(a, false), pick(b, true)];
+  const verdictLine = r1 === r2 && r1 !== "tie" ? `The ${r1} version wins in both orders (${a.why ?? ""}${b.why ? `; ${b.why}` : ""}).` : `The judges split (${r1} vs ${r2}): a matter of taste.`;
+  const next =
+    r1 === r2 && r1 === "alternative"
+      ? `Make the alternative the ${section} (move it into place, delete the current one and the ?palate-alt switch).`
+      : r1 === r2 && r1 === "current"
+        ? `Keep the current ${section}; delete the alternative and the ?palate-alt switch.`
+        : `Ask the user in one line which they prefer, showing both 1440 shots (${slash(path.join(root, "one-1440.png"))}, ${slash(path.join(root, "two-1440.png"))}); their answer is taste palate learns from.`;
+  try {
+    fs.mkdirSync(TASTE_DIR, { recursive: true });
+    fs.appendFileSync(GATE_LOG, JSON.stringify({ kind: "duel", project: path.basename(path.resolve(dir)), route, section, result: [r1, r2], at: new Date().toISOString() }) + "\n");
+  } catch {}
+  return [`# Best of two: the ${section} of ${route}`, "", verdictLine, next].join("\n");
+}
+
+// ---- `palate section <route> <name>`: a section builder's own check, in seconds. One section cropped at 1440
+// and 390 and palate's floor checks for that section only, instead of a full-page shoot per builder (on Kiln v2
+// six builders each ran full shoots: about 15 minutes each). Also at 768: tablet is where a hero photo gets
+// blown up behind its text.
+const SECTION_WIDTHS = [1440, 768, 390];
+export async function sectionCheck(dir, rawRoute, query, { url, judge = false } = {}) {
+  const route = normalizeRoute(rawRoute);
+  if (!query) throw new Error("Usage: palate section <route> <section id, name or selector>");
+  try {
+    mark(dir, loopName(route), "section_check", { id: String(query) });
+  } catch {}
+  const { matchSection } = await import("../look.mjs");
+  const out = path.join(rootFor(dir, route), "sections-check", String(query).toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 40));
+  fs.mkdirSync(out, { recursive: true });
+  const found = await withBrowser(dir, { url }, async ({ base, browser }) => {
+    const res = {};
+    // The three widths side by side, each measured on the page it already loaded (no second load for the floor).
+    await Promise.all(SECTION_WIDTHS.map(async (width) => {
+      const { page, ctx, errors } = await openPage(browser, base, route, { width, reducedMotion: true });
+      try {
+        const sections = await findSections(page).catch(() => []);
+        // A page that didn't render (a build error in another builder's file, a crash) isn't "section not found".
+        const text = await page.evaluate(() => document.body?.innerText?.trim().length ?? 0).catch(() => 0);
+        const overlay = await page.evaluate(() => document.querySelector("vite-error-overlay")?.shadowRoot?.querySelector(".message")?.textContent ?? null).catch(() => null);
+        if (overlay || (!sections.length && text < 20)) {
+          res[width] = { failed: true, why: overlay?.trim().slice(0, 300) ?? errors?.[0] ?? "the page rendered nothing" };
+          return;
+        }
+        // By the blueprint id (the section's component carries it in its name, id or heading), else by words.
+        const s = (await matchSection(page, sections, String(query))) ?? sections.find((x) => String(x.selector ?? "").toLowerCase().includes(String(query).toLowerCase())) ?? null;
+        if (!s) {
+          res[width] = { missing: true, names: sections.map((x) => x.name) };
+          return;
+        }
+        const [crop] = await cropSections(page, [s], out, `w${width}`, { maxHeight: 6000 });
+        const checks = Floor?.floorOnPage ? await Floor.floorOnPage(page, { width, sections }).catch(() => []) : [];
+        res[width] = { index: s.index, name: s.name, file: crop?.file ?? null, height: s.box.height, checks };
+      } finally {
+        await ctx.close();
+      }
+    }));
+    return res;
+  });
+  if (found[1440]?.failed) return [`# Section check ${route}: the page didn't render`, `- ${found[1440].why}`, "Another section's file may be mid-edit or broken. Wait a moment and check again; if the error names your file, fix it first."].join("\n");
+  const floor = { checks: SECTION_WIDTHS.flatMap((w) => (found[w]?.checks ?? []).map((c) => ({ ...c, width: c.width ?? w }))) };
+  // Same-template checks compare neighbours, which other builders may still be writing: left to the whole-page gate.
+  const mine = (floor?.checks ?? []).filter((c) => c.id !== "SAME_TEMPLATE").filter((c) => {
+    const w = found[c.width ?? 1440];
+    return w && !w.missing && !w.failed && (c.section?.index === w.index || (c.section?.heading && w.name && w.name.startsWith(String(c.section.heading).slice(0, 20))));
+  });
+  if (found[1440]?.missing) return [`# Section check ${route}: "${query}" not found`, `Sections on the page: ${found[1440].names.join(" · ")}`, "Give the section's component an id or heading that names it, or pass one of these names."].join("\n");
+  const packet = judge ? earlyPacket(dir, route, String(query), out, found) : null;
+  return [
+    `# Section check ${route}: ${found[1440].name}`,
+    "",
+    `- At 1440: ${slash(found[1440].file)} (${found[1440].height}px tall)`,
+    found[768]?.file ? `- At 768 (tablet): ${slash(found[768].file)} (${found[768].height}px tall)` : "- At 768: not found",
+    found[390]?.file ? `- At 390: ${slash(found[390].file)} (${found[390].height}px tall${found[390].height > 1900 ? ": over two phone screens, check it isn't one long stacked list" : ""})` : "- At 390: not found",
+    "",
+    mine.length ? "## palate's floor checks for this section" : "## palate's floor checks: nothing wrong in this section",
+    ...mine.map((c) => `- ${c.severity === "fail" ? "✗" : "!"} ${c.id} @${c.width}: ${c.what}${c.fix ? ` → ${c.fix}` : ""}`),
+    "",
+    "Open the crops and compare them with the brief's \"Done when\" questions. Fix once, check again, then report done.",
+    ...(packet
+      ? [
+          "",
+          "## The early judge",
+          `Packet for a fresh judge (not the builder): ${slash(packet.file)}. Put this line in your report: the main build runs the judge as soon as you're done, then \`palate section ${route} ${query} --verdict\`.`,
+        ]
+      : []),
+  ].join("\n");
+}
+
+// ---- The early judge: one section judged by a fresh subagent as soon as its builder is done, on the same
+// questions the gate asks (the section questions plus its archetype's checks), so a section below the bar is fixed
+// while the others are still being built instead of in a repair round after the whole page (on a benchmark page the
+// two repair rounds cost 16 minutes). The final gate still judges the whole page; this only means it finds less.
+function earlyPacket(dir, route, id, out, found) {
+  const bp = loadBlueprint(dir, { route });
+  const planned = (bp?.sections ?? []).find((x) => String(x.id).toLowerCase() === id.toLowerCase());
+  const checks = planned?.archetype && Sections?.floorChecks ? Sections.floorChecks(planned.archetype) : [];
+  const questions = [...SECTION_QUESTIONS, ...checks.map((q, k) => ({ id: `a${k + 1}`, q }))];
+  const answers = path.join(out, "judge-answers.json");
+  fs.rmSync(answers, { force: true });
+  const facts = projectFacts(dir);
+  const file = path.join(out, "judge-packet.md");
+  fs.writeFileSync(
+    file,
+    [
+      "# Design review: one section",
+      "",
+      "You are an independent design reviewer. You did not make this section and you have no stake in it. Open every image with your image tool before answering.",
+      `It is one section (${found[1440].name}${planned?.archetype ? `, meant to be: ${planned.archetype}` : ""}) of the ${route} page${planned?.job ? `; its job: ${planned.job}` : ""}.`,
+      "",
+      `- At 1440: ${slash(found[1440].file)}`,
+      found[768]?.file ? `- At 768 (tablet): ${slash(found[768].file)}` : null,
+      found[390]?.file ? `- At 390 (phone): ${slash(found[390].file)}` : null,
+      "",
+      ...(facts ? ["## The project's facts (from its README)", "```", facts, "```", FACTS_RULE, ""] : []),
+      "## Questions",
+      "Answer every question YES or NO (YES = good), and a `worst` line: the one thing most below the bar, in under 20 words. Then `fix`: up to three concrete changes that would turn each NO into YES.",
+      ...questions.map((q) => `- ${q.id}: ${q.q}`),
+      "",
+      JSON_RULE,
+      `Write ${slash(answers)} as {"answers": {"finished": true, ...}, "worst": "...", "fix": ["...", "..."]}`,
+    ]
+      .filter((l) => l != null)
+      .join("\n"),
+  );
+  fs.writeFileSync(path.join(out, "judge-state.json"), JSON.stringify({ route, id, questions: questions.map(({ id: q, q: text, must }) => ({ id: q, q: text, must: Boolean(must) })), at: new Date().toISOString() }, null, 1));
+  return { file, answers };
+}
+
+// `palate section <route> <id> --verdict`: the early judge's answers, by the gate's own rule (the "finished" question
+// NO, or two NOs, is below the bar). Recorded per section in the route's quality folder.
+export function sectionVerdict(dir, rawRoute, id) {
+  const route = normalizeRoute(rawRoute);
+  const out = path.join(rootFor(dir, route), "sections-check", String(id).toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 40));
+  const st = readJson(path.join(out, "judge-state.json"), null);
+  if (!st) return `No early-judge packet for "${id}" on ${route} yet: run palate section ${route} ${id} --early first.`;
+  const a = readJson(path.join(out, "judge-answers.json"), null);
+  if (!a?.answers) return `The judge hasn't written ${slash(path.join(out, "judge-answers.json"))} yet: give a fresh subagent ${slash(path.join(out, "judge-packet.md"))}.`;
+  const nos = Object.entries(a.answers).filter(([, v]) => no(v)).map(([k]) => k);
+  const mustFail = st.questions.some((q) => q.must && no(a.answers[q.id]));
+  const pass = !mustFail && nos.length < 2;
+  const file = path.join(rootFor(dir, route), "early.json");
+  const all = readJson(file, {});
+  all[id] = { pass, nos, worst: a.worst ?? null, at: new Date().toISOString() };
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(all, null, 1));
+  try {
+    mark(dir, loopName(route), "section_verdict", { id, pass });
+  } catch {}
+  const q = (k) => st.questions.find((x) => x.id === k)?.q ?? k;
+  if (pass) return `Section ${id} passes the early judge${nos.length ? ` (one NO, a warning: ${q(nos[0])})` : ""}. Leave it; the final gate judges the whole page.`;
+  return [
+    `Section ${id} is below the bar (NO to ${nos.join(", ")})${a.worst ? `: ${a.worst}` : ""}.`,
+    ...nos.map((k) => `- ${k}: ${q(k)}`),
+    ...(Array.isArray(a.fix) && a.fix.length ? ["Fix:", ...a.fix.slice(0, 3).map((f) => `- ${f}`)] : []),
+    `Send this back to the section's builder (or a fresh one with its brief) now, while the other sections build: fix it once, palate section ${route} ${id}, done. One repair here; the final gate judges again anyway.`,
+  ].join("\n");
+}