@palate/cli 0.0.0-stage → 0.0.1

package/src/loop/rules.mjs

@@ -0,0 +1,939 @@
+// The user's rules: what palate has learned this user won't accept, written as short, testable rules in
+// ~/.palate/taste/rules.json. The taste profile says what the user likes; rules say what must hold. Every brief
+// opens with the rules for its kind of screen ("Your rules (must pass)") and the failures for that kind, every
+// `palate shoot` checks the measurable ones, the judge penalises variants that fail one, and the rules that
+// can't be measured become questions in the judge's rubric.
+//   rule:   { id, rule, kinds: ["landing"] | ["all"], where?: { route?, component?, project? }, status, source, check, added,
+//             also?: [more sources], evidence?: [what it was learned from] }
+//   status: "active" (enforced; a rule without one is active) or "proposed" (waiting for the user's OK, never enforced)
+//   check:  { type: "metric", metric, op: "<=" | ">=" | "=", value }  a fact measured in the page (page-rules.js)
+//           { type: "dom", selector, min?, max?, visible?, before?: "demo" }  a count of matching elements
+//           { type: "judge", question }  asked of the judge, per variant
+// The user's own words are rules at once (`palate rule add`, notes on their references). What palate infers
+// (agreed critique findings, failures, repeated point requests: `palate taste learn`, `palate fail`) is only
+// proposed, with the scopes its evidence supports; it applies nowhere until the user keeps it (`palate rule
+// review`, `ok`, `no`). A discarded proposal is remembered (`rejected` in the file) and not proposed again from
+// the same evidence.
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { PALATE_HOME } from "../catalog/store.mjs";
+import { loopOfRoute } from "./timeline.mjs";
+import { growthProposals } from "./growth.mjs";
+import { researchProposals } from "./research-learn.mjs";
+
+const TASTE = path.join(PALATE_HOME, "taste");
+export const RULES_FILE = path.join(TASTE, "rules.json");
+export const FAIL_DIR = path.join(PALATE_HOME, "failures");
+export const FAILS_LOG = path.join(FAIL_DIR, "failures.jsonl");
+const STATE = path.join(TASTE, "state.json");
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const script = (f) => fs.readFileSync(path.join(here, "..", f), "utf8").trim().replace(/;\s*$/, "");
+const slash = (p) => String(p).replace(/\\/g, "/");
+const readJson = (f, fb) => {
+  try {
+    return JSON.parse(fs.readFileSync(f, "utf8"));
+  } catch {
+    return fb;
+  }
+};
+export const readLines = (f) => (fs.existsSync(f) ? fs.readFileSync(f, "utf8").split("\n").filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean) : []);
+
+// ---- the facts a metric check can read (page-rules.js), with how to say them
+export const METRICS = {
+  framedScreenshots: "framed static screenshots",
+  staticScreenshots: "static screenshots",
+  kickerSections: "sections with a kicker label",
+  repeatedDevices: "devices repeated in 3+ sections",
+  minLogoMarkPx: "smallest logo mark (px)",
+  monochromeLogoRows: "logo rows in one grey",
+  stepBarsBeforeDemo: "step bars before the demo",
+  stepBars: "step bars",
+  frameworkLogosBeforeDemo: "framework logos before the demo",
+  blackPrimaryButtons: "black primary buttons",
+  distinctRadii: "distinct corner radii",
+  movingElements: "things that move on load or scroll",
+  blackAccents: "black chips, buttons and labels",
+  buttonInsideInputBar: "submit buttons inside the input's bordered bar",
+  dotGrids: "dotted grid backdrops",
+  demoMissingControls: "demo controls missing (Skip, Replay)",
+  gradientButtons: "buttons with a gradient fill",
+  // Measured by `palate states` (the latest run for the route), not by the page as it loads.
+  listsWithoutEmptyState: "lists with no empty state",
+  missingLoadingStates: "async parts with no loading state",
+  errorsSwallowed: "failures nothing on screen reports",
+  doubleSubmits: "actions sent twice by a double press",
+  brokenImages: "parts showing a broken-image icon",
+  textOverflows: "places long text or 320px breaks",
+};
+export const STATE_METRICS = new Set(["listsWithoutEmptyState", "missingLoadingStates", "errorsSwallowed", "doubleSubmits", "brokenImages", "textOverflows"]);
+
+// The state facts from the latest `palate states` run for a route (.palate/states/<slug>/<stamp>/findings.json).
+export function statesFactsFor(dir, route) {
+  const base = path.join(dir, ".palate", "states", (route ?? "/").replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "") || "home");
+  if (!fs.existsSync(base)) return null;
+  const last = fs.readdirSync(base).filter((s) => fs.existsSync(path.join(base, s, "findings.json"))).sort().at(-1);
+  const f = last ? readJson(path.join(base, last, "findings.json"), null) : null;
+  return f?.facts ? { ...f.facts, statesRun: last } : null;
+}
+// Facts that only mean something with motion on (the judge renders with reduced motion).
+const NEEDS_MOTION = new Set(["movingElements"]);
+
+// ---- kinds of screen. A rule applies when one of its kinds is in the screen's tags (or it says "all").
+export const KINDS = ["all", "landing", "marketing", "hero", "demo", "logo cloud", "features", "pricing", "cta", "app", "table", "dashboard", "team", "settings", "onboarding", "auth", "docs"];
+const KIND_RE = [
+  ["landing", /\b(landing|home|homepage|waitlist|marketing page)\b/],
+  ["hero", /\bhero\b/],
+  ["demo", /\b(demo|showcase|mockup|live product)\b/],
+  ["logo cloud", /\blogo[s ]*(cloud|row|wall|strip)|works with|any stack|integrations?\b/],
+  ["features", /\bfeatures?\b|bento/],
+  ["pricing", /\b(pricing|plans?)\b/],
+  ["cta", /\b(cta|signup|sign up|newsletter|call to action)\b/],
+  ["table", /\b(table|list|records|pipeline|companies)\b/],
+  ["dashboard", /\b(dashboard|overview|analytics)\b/],
+  ["team", /\b(team|members?)\b/],
+  ["settings", /\bsettings?\b/],
+  ["onboarding", /\b(onboarding|setup|welcome)\b/],
+  ["auth", /\b(login|sign in)\b/],
+  ["docs", /\b(docs|documentation|blog|article)\b/],
+];
+
+// The tags for a screen, from what palate knows about it: its loop's screen and kind, its route, a section's
+// kind, any words. "/" is a site's landing page; landing, hero, demo, features, pricing and logo clouds are marketing.
+export function kindTags({ screen, kind, route, section, words } = {}) {
+  const tags = new Set();
+  if (screen && screen !== "other") tags.add(screen);
+  if (kind) tags.add(kind);
+  if (route === "/") tags.add("landing");
+  const t = `${section ?? ""} ${words ?? ""} ${route && route !== "/" ? route.replace(/[^a-z]+/gi, " ") : ""}`.toLowerCase();
+  for (const [k, re] of KIND_RE) if (re.test(t)) tags.add(k);
+  if (["landing", "hero", "demo", "logo cloud", "features", "pricing", "cta"].some((k) => tags.has(k))) tags.add("marketing");
+  if (["table", "dashboard", "team", "settings", "onboarding"].some((k) => tags.has(k))) tags.add("app");
+  return [...tags];
+}
+
+// The tags for a route: its loop's screen and kind (a variant), the page a vary loop copied, or the route.
+export function routeTags(dir, route, { title = "", sections = [] } = {}) {
+  const loop = loopOfRoute(dir, route);
+  const meta = loop ? readJson(path.join(dir, ".palate", "variants", loop, "loop.json"), {}) : {};
+  if (meta.vary) return kindTags({ route: meta.vary.route, kind: "marketing", section: meta.kind, words: meta.vary.section });
+  if (loop) return kindTags({ screen: meta.screen, kind: meta.kind, words: `${loop} ${meta.job ?? ""}`.slice(0, 400) });
+  return kindTags({ route, words: `${title} ${route === "/" ? "" : sections.slice(0, 3).map((s) => s.name).join(" ")}` });
+}
+
+// ---- the rules file
+const readFile = () => readJson(RULES_FILE, { rules: [] });
+export function loadRules() {
+  return readFile().rules ?? [];
+}
+// Proposals the user discarded: { id, rule, tpl?, check?, keys: [evidence], at, since?: [newer evidence] }.
+export const rejectedRules = () => readFile().rejected ?? [];
+function saveRules(rules, rejected = rejectedRules()) {
+  fs.mkdirSync(TASTE, { recursive: true });
+  fs.writeFileSync(RULES_FILE, JSON.stringify({ note: "Your rules: palate puts the active ones at the top of every brief and checks them on every shoot. Proposed rules wait for your OK (palate rule review). Edit with palate rule add | ok | no | edit | rm.", rules, ...(rejected.length ? { rejected } : {}) }, null, 1));
+}
+export const isActive = (r) => (r.status ?? "active") === "active";
+export const isProposed = (r) => r.status === "proposed";
+export const proposedRules = () => loadRules().filter(isProposed);
+
+// A rule for one component can't be measured (a check reads the whole page), so the judge asks it about that
+// component; the measured check is kept and comes back if the rule is widened.
+function enforced(r) {
+  const c = r.where?.component;
+  if (!c) return r;
+  const q = r.check?.type === "judge" && r.check.question ? r.check.question : `Does it follow this rule: "${r.rule}"?`;
+  return { ...r, check: { type: "judge", question: `Only for <${c}>: ${q}` }, measured: r.check };
+}
+// What palate enforces: the rules the user wrote or kept, never proposals. Every brief, shoot and judge reads these.
+export const activeRules = () => loadRules().filter(isActive).map(enforced);
+
+const normRoute = (r) => (r ? `/${String(r).trim().replace(/^\/+|\/+$/g, "")}` : null);
+// A rule for /team holds on /team and below it (/team/42).
+export const onRoute = (scope, route) => {
+  const [a, b] = [normRoute(scope), normRoute(route)];
+  return Boolean(a && b) && (a === b || (a !== "/" && b.startsWith(`${a}/`)));
+};
+// A rule applies when one of its kinds is in the screen's tags (or it says "all"), and, if it is for one route,
+// only on that route (route unknown: not applied), and, if it is for one project, only in that project (project
+// unknown: not applied, so a new project never inherits another one's look).
+export const projectOf = (dir) => path.basename(path.resolve(dir));
+const sameProject = (a, b) => Boolean(a && b) && String(a).toLowerCase() === String(b).toLowerCase();
+export const appliesTo = (r, tags, { route, project } = {}) =>
+  (r.kinds.includes("all") || r.kinds.some((k) => tags.includes(k))) && (!r.where?.route || onRoute(r.where.route, route)) && (!r.where?.project || sameProject(r.where.project, project));
+export const rulesFor = (tags, { route, project } = {}) => activeRules().filter((r) => appliesTo(r, tags, { route, project }));
+
+// ---- scope: where a rule applies, in words
+const KIND_NAMES = { landing: "landing pages", marketing: "marketing pages", hero: "heroes", demo: "demos", "logo cloud": "logo clouds", features: "feature sections", pricing: "pricing pages", cta: "calls to action", app: "app screens", table: "tables and lists", dashboard: "dashboards", team: "team pages", settings: "settings pages", onboarding: "onboarding screens", auth: "sign-in screens", docs: "docs pages" };
+const UMBRELLA = new Set(["all", "app", "marketing"]);
+const cap = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+// "Team and settings pages", "Landing pages, heroes and demos"; with a project: "Only in palate-site",
+// "Landing pages, only in palate-site".
+export function kindsLabel(kinds, { project } = {}) {
+  if (project) return !kinds?.length || kinds.includes("all") ? `Only in ${project}` : `${kindsLabel(kinds)}, only in ${project}`;
+  if (!kinds?.length || kinds.includes("all")) return "Everywhere";
+  const names = kinds.map((k) => KIND_NAMES[k] ?? `${k} screens`);
+  const pages = names.every((n) => n.endsWith(" pages"));
+  const parts = pages ? names.map((n) => n.replace(/ pages$/, "")) : names;
+  const list = parts.length > 1 ? `${parts.slice(0, -1).join(", ")} and ${parts.at(-1)}` : parts[0];
+  return cap(`${list}${pages ? " pages" : ""}`);
+}
+const inProject = (p) => (p ? ` in ${p}` : "");
+export const scopeLabel = (r) => (r.where?.component ? `Only <${r.where.component}>${inProject(r.where.project)}` : r.where?.route ? `Only ${r.where.route}${inProject(r.where.project)}` : kindsLabel(r.kinds, { project: r.where?.project }));
+
+// ---- whose taste a rule is. palate decides, not the user: a rule tied to one product's identity (a colour, a font,
+// the brand's name, "our", what the page says, its agents and demos) stays in that project; a judgement about
+// design (clarity, hierarchy, density, motion, states, licensing) is general taste. Simple signals, so the reason
+// can be said in one line. Evidence from two or more projects is always general.
+const COLOURS = /\b(cream|beige|stone|sand|ivory|navy|blue|teal|cyan|green|emerald|mint|lime|olive|yellow|amber|gold|orange|coral|red|crimson|pink|rose|magenta|purple|violet|lilac|lavender|brown|pastels?|neon)\b/i;
+const FONTS = /\b(inter|geist|fraunces|helvetica|arial|roboto|s[öo]hne|satoshi|manrope|garamond|georgia|playfair|ibm plex|jetbrains mono|space grotesk|dm sans|poppins|montserrat|lato|figtree)\b/i;
+const FAMILY = /\b[A-Z][a-z]+ (Sans|Serif|Mono|Grotesk)\b/;
+const NEGATED = /\b(no|never|not|avoid|without|don'?t|nor)\b/i;
+const OURS = /\b(our|ours|we|palate)\b/i;
+const SAYS = /\b(says?|tells?|mentions?) (that|it|the)\b/i;
+const PRODUCT = /\b(agents?|subagents?|logos?|demos?)\b/gi;
+const JUDGEMENT = /\b(clear|clarity|hierarch\w*|restrain\w*|calm|dens\w*|spacing|align\w*|sizes?|small|large|tiny|legible|readable|read|contrast|motion|animat\w*|states?|empty|loading|errors?|licen[cs]\w*|public domain|cc0|credited|focal|consistent|scale)\b|px\b/gi;
+const GENERIC = new Set(["site", "app", "web", "www", "demo", "landing", "home", "page", "pages", "frontend", "client", "ui", "my", "the", "new", "test", "main", "project"]);
+// The brand's own words: the project folder's name and its package name, without words like "site" or "app".
+function brandWords(project, dir) {
+  let pkg = "";
+  try {
+    if (dir) pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8")).name ?? "";
+  } catch {}
+  return [...new Set(`${project ?? ""} ${pkg}`.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length >= 3 && !GENERIC.has(w)))];
+}
+// { project: the project it's tied to, or null for general taste; signals; why: the reason in a few words }.
+export function classifyScope(text, { project, evidence = [], dir } = {}) {
+  const t = String(text ?? "");
+  const spread = [...new Set(evidence.map((e) => e.project).filter(Boolean))];
+  const judged = [...new Set((t.match(JUDGEMENT) ?? []).map((w) => w.toLowerCase()))];
+  const general = (why) => ({ project: null, signals: [], why });
+  if (spread.length > 1) return general(`seen in ${spread.length} projects`);
+  project ??= spread[0] ?? null;
+  const signals = [];
+  const hex = t.match(/#[0-9a-f]{3,8}\b/i);
+  const colour = t.split(/[.;,:()—]/).find((c) => COLOURS.test(c) && !NEGATED.test(c));
+  if (hex || colour) signals.push(`colour (${hex?.[0] ?? colour.match(COLOURS)[0].toLowerCase()})`);
+  const font = t.match(FONTS) ?? t.match(FAMILY);
+  if (font) signals.push(`font (${font[0]})`);
+  const brand = brandWords(project, dir).find((w) => new RegExp(`\\b${w}\\b`, "i").test(t)) ?? t.match(OURS)?.[0].toLowerCase();
+  if (brand) signals.push(`brand (${brand})`);
+  if (SAYS.test(t)) signals.push("what the page says");
+  // Agents, logos and demos only count when the rule is about them (twice or more) more than about a judgement.
+  const product = (t.match(PRODUCT) ?? []).map((w) => w.toLowerCase());
+  if (!signals.length && product.length >= 2 && product.length > judged.length) signals.push(`product content (${[...new Set(product)].join(", ")})`);
+  if (!signals.length) return general(judged.length ? `a judgement about design (${judged.slice(0, 3).join(", ")})` : "nothing ties it to one product");
+  return { project, signals, why: signals.join(" and ") };
+}
+
+// The scopes a proposal's evidence supports, narrowest first, and the one to suggest: the narrowest that holds
+// across all of it (one component → that component; tied to one product's identity → that project; one route →
+// that route; routes of one kind → that kind; evidence across kinds → everywhere), with why, in one line.
+export function scopeOptions(r) {
+  const ev = r.evidence ?? [];
+  const options = [];
+  const add = (o) => options.some((x) => x.id === o.id) || options.push(o);
+  const comps = [...new Set(ev.map((e) => e.component).filter(Boolean))];
+  const routes = [...new Set(ev.map((e) => normRoute(e.route)).filter(Boolean))];
+  for (const c of comps.slice(0, 2)) add({ id: `component:${c}`, label: `Only <${c}>`, kinds: ["all"], where: { component: c } });
+  for (const rt of routes.slice(0, 2)) add({ id: `route:${rt}`, label: `Only ${rt}`, kinds: ["all"], where: { route: rt } });
+  // Evidence from one project can stay in it. Not when it all names one component: that already lives in one codebase.
+  const projects = [...new Set(ev.map((e) => e.project ?? null))];
+  const oneComponent = comps.length === 1 && ev.every((e) => e.component === comps[0]);
+  if (projects.length === 1 && projects[0] && !oneComponent) add({ id: `project:${projects[0]}`, label: `Only in ${projects[0]}`, kinds: ["all"], where: { project: projects[0] } });
+  const tagsOf = ev.map((e) => (e.kinds?.length ? e.kinds : e.route ? kindTags({ route: e.route }) : [])).filter((t) => t.length);
+  const shared = (pick) => (tagsOf.length ? tagsOf.map((t) => t.filter(pick)).reduce((a, b) => a.filter((k) => b.includes(k))) : []);
+  const union = (pick) => [...new Set(tagsOf.flatMap((t) => t.filter(pick)))];
+  const specific = (k) => !UMBRELLA.has(k);
+  const umbrella = (k) => k !== "all" && UMBRELLA.has(k);
+  const kindsOpt = (ks) => ks.length && add({ id: `kinds:${ks.join(",")}`, label: kindsLabel(ks), kinds: ks });
+  const [sSpec, sUmb] = [shared(specific), shared(umbrella)];
+  kindsOpt(sSpec.length ? sSpec : union(specific));
+  kindsOpt(sUmb.length ? sUmb : union(umbrella));
+  if (!ev.length && !r.kinds.includes("all")) kindsOpt(r.kinds);
+  add({ id: "all", label: "Everywhere", kinds: ["all"] });
+  const taste = classifyScope(r.rule, { evidence: ev });
+  let suggest = "all";
+  if (oneComponent) suggest = `component:${comps[0]}`;
+  else if (taste.project && options.some((o) => o.id === `project:${taste.project}`)) suggest = `project:${taste.project}`;
+  else if (routes.length === 1 && ev.every((e) => normRoute(e.route) === routes[0])) suggest = `route:${routes[0]}`;
+  else if (sSpec.length) suggest = `kinds:${sSpec.join(",")}`;
+  else if (sUmb.length) suggest = `kinds:${sUmb.join(",")}`;
+  else if (!ev.length && !r.kinds.includes("all")) suggest = `kinds:${r.kinds.join(",")}`;
+  const label = options.find((o) => o.id === suggest)?.label ?? "Everywhere";
+  // The reason matches the suggestion: the narrowest scope the evidence supports, said plainly.
+  const why = suggest.startsWith("component:") ? `all of it on ${label.replace(/^Only /, "")}: ${label.toLowerCase()}` : suggest.startsWith("project:") ? `${taste.why}: ${label.toLowerCase()}` : suggest.startsWith("route:") ? `all the evidence is from ${suggest.slice(6)}, so ${label.toLowerCase()} for now; it reads as general taste, so keep it wider if it holds elsewhere` : `general taste, ${taste.why}: ${label.toLowerCase()}`;
+  return { options, suggest, why };
+}
+
+// A scope from what the user chose: an option id, its number (1…), its label, "suggested", "everywhere",
+// or { component } / { route } / { kinds } / { project } (a project narrows any of the others: { project, kinds }).
+export function resolveScope(r, choice) {
+  const { options, suggest } = scopeOptions(r);
+  const byId = (id) => options.find((o) => o.id === id);
+  if (choice == null || choice === "" || choice === "suggested") return byId(suggest);
+  if (typeof choice === "object" && choice.project) {
+    const p = String(choice.project).trim();
+    const { project, scope, ...rest } = choice;
+    const base = scope != null ? resolveScope(r, scope) : Object.values(rest).some((v) => v != null && v !== "" && !(Array.isArray(v) && !v.length)) ? resolveScope(r, rest) : byId("all");
+    const s = { ...base, where: { ...(base.where ?? {}), project: p } };
+    return { ...s, id: `${base.id === "all" ? "" : `${base.id}@`}project:${p}`, label: scopeLabel(s) };
+  }
+  if (typeof choice === "object") {
+    if (choice.component) {
+      const c = String(choice.component).trim().replace(/^<|\/?>$/g, "");
+      return { id: `component:${c}`, label: `Only <${c}>`, kinds: ["all"], where: { component: c } };
+    }
+    if (choice.route) return { id: `route:${normRoute(choice.route)}`, label: `Only ${normRoute(choice.route)}`, kinds: ["all"], where: { route: normRoute(choice.route) } };
+    if (choice.kinds?.length) {
+      const ks = [...new Set(choice.kinds.map((k) => String(k).trim().toLowerCase()).filter(Boolean))];
+      return ks.includes("all") ? byId("all") : { id: `kinds:${ks.join(",")}`, label: kindsLabel(ks), kinds: ks };
+    }
+    return byId(suggest);
+  }
+  const c = String(choice).trim();
+  if (/^(all|everywhere|global)$/i.test(c)) return byId("all");
+  if (/^\d+$/.test(c) && options[Number(c) - 1]) return options[Number(c) - 1];
+  const hit = byId(c) ?? options.find((o) => o.label.toLowerCase() === c.toLowerCase());
+  if (hit) return hit;
+  if (/^component:/.test(c)) return resolveScope(r, { component: c.slice(10) });
+  if (/^route:/.test(c)) return resolveScope(r, { route: c.slice(6) });
+  if (/^kinds?:/.test(c)) return resolveScope(r, { kinds: c.replace(/^kinds?:/, "").split(",") });
+  if (/^project:/.test(c)) return resolveScope(r, { project: c.slice(8) });
+  if (c.startsWith("/")) return resolveScope(r, { route: c });
+  throw new Error(`No scope "${c}". Choose one of: ${options.map((o, i) => `${i + 1} ${o.id} (${o.label})`).join(", ")}; or --only <Component>, --route /x, --kind team, --project <name>.`);
+}
+
+const WORDS = (s) => new Set((s.toLowerCase().match(/[a-z]{3,}/g) ?? []).filter((w) => !["the", "and", "not", "never", "with", "only", "one", "its", "for", "every", "page", "section"].includes(w)));
+function similar(a, b) {
+  const [x, y] = [WORDS(a), WORDS(b)];
+  const both = [...x].filter((w) => y.has(w)).length;
+  return both / Math.max(1, Math.min(x.size, y.size));
+}
+const sameCheck = (a, b) => a && b && a.type !== "judge" && a.type === b.type && (a.metric ?? a.selector) === (b.metric ?? b.selector);
+const alike = (r, { rule, check, tpl }) => (tpl && r.tpl === tpl) || sameCheck(r.check, check) || similar(r.rule, rule) >= 0.7;
+// Does an active rule's scope already hold where this evidence came from? (Then the evidence only strengthens it.)
+const covers = (r, evidence = []) =>
+  evidence.every((e) => {
+    if (r.where?.project && !sameProject(r.where.project, e.project)) return false;
+    if (r.where?.component) return e.component === r.where.component;
+    if (r.where?.route) return onRoute(r.where.route, e.route);
+    const ks = e.kinds?.length ? e.kinds : e.route ? kindTags({ route: e.route }) : [];
+    return r.kinds.includes("all") || !ks.length || r.kinds.some((k) => ks.includes(k));
+  });
+const mergeEvidence = (a = [], b = []) => [...new Map([...a, ...b].map((e) => [e.key, e])).values()];
+const nextId = (rules, rejected) => `R${[...rules, ...rejected].reduce((m, r) => Math.max(m, Number(String(r.id).slice(1)) || 0), 0) + 1}`;
+const gain = (r, source) => {
+  if (source && r.source !== source && !(r.also ?? []).includes(source)) r.also = [...(r.also ?? []), source];
+};
+
+// Adds a rule unless one like it exists (the same template, the same measured check, or nearly the same
+// words); then the existing rule gains the new source instead. Returns { rule, added, proposed?, discarded? }.
+// status "active": the user's own words, enforced at once (a proposal like it becomes theirs).
+// status "proposed": inferred by palate, with evidence. An active rule whose scope holds the evidence is only
+// strengthened; a proposal like it gains the evidence; one the user discarded stays discarded until clearly new
+// evidence arrives (more new pieces than the rejection was based on).
+// where: the user's own narrower scope ({ component } or { route }, and/or { project }), for an active rule.
+// A project alone keeps the kinds (landing pages in that project); a component or route holds on any kind.
+export function addRule({ rule, kinds = ["all"], source, check, tpl, status = "active", evidence = [], where } = {}) {
+  if (!rule?.trim()) throw new Error('Usage: palate rule add "<the rule, in the user\'s words>" [--kind landing] [--only <Component> | --route /x]');
+  const rules = loadRules();
+  const rejected = rejectedRules();
+  kinds = [...new Set(kinds.map((k) => k.trim().toLowerCase()).filter(Boolean))];
+  if (!kinds.length || where?.component || where?.route) kinds = ["all"];
+  const likes = rules.filter((r) => alike(r, { rule, check, tpl }));
+  let id;
+  const sameWhere = (r) => (r.where?.component ?? null) === (where?.component ?? null) && normRoute(r.where?.route) === normRoute(where?.route) && (r.where?.project ?? null) === (where?.project ?? null);
+  if (status === "active") {
+    // A rule that already holds everywhere covers a narrower one; two different narrow scopes are two rules.
+    const twin = where ? likes.find((r) => isProposed(r) || !r.where || sameWhere(r)) : likes.find(isActive) ?? likes[0];
+    if (twin) {
+      gain(twin, source);
+      // The user said it themselves: a proposal like it is now theirs, with their scope.
+      const promoted = isProposed(twin);
+      if (promoted || (twin.where && !sameWhere(twin))) {
+        twin.status = "active";
+        twin.kinds = kinds;
+        if (where) twin.where = where;
+        else delete twin.where;
+        if (promoted) twin.approved = new Date().toISOString();
+      } else if (!where) for (const k of kinds) if (!twin.kinds.includes(k) && !twin.kinds.includes("all")) twin.kinds.push(k);
+      saveRules(rules, rejected);
+      return { rule: twin, added: promoted };
+    }
+  } else {
+    const strong = likes.find((r) => isActive(r) && covers(r, evidence));
+    if (strong) {
+      gain(strong, source);
+      saveRules(rules, rejected);
+      return { rule: strong, added: false };
+    }
+    const twin = likes.find(isProposed);
+    if (twin) {
+      gain(twin, source);
+      twin.evidence = mergeEvidence(twin.evidence, evidence);
+      for (const k of kinds) if (!twin.kinds.includes(k) && !twin.kinds.includes("all")) twin.kinds.push(k);
+      saveRules(rules, rejected);
+      return { rule: twin, added: false, proposed: true };
+    }
+    const no = rejected.find((x) => alike(x, { rule, check, tpl }));
+    if (no) {
+      // Only evidence the rejection didn't see counts, and it adds up across learns.
+      const fresh = mergeEvidence((no.since ?? []).map((key) => ({ key })), evidence.filter((e) => !no.keys.includes(e.key)));
+      if (fresh.length <= no.keys.length) {
+        no.since = fresh.map((e) => e.key);
+        saveRules(rules, rejected);
+        return { rule: null, added: false, discarded: no, needs: no.keys.length + 1 - fresh.length };
+      }
+      // Proposed again, under a new id (the discarded one stays retired).
+      id = nextId(rules, rejected);
+      rejected.splice(rejected.indexOf(no), 1);
+      evidence = evidence.map((e) => ({ ...e, afterNo: no.at }));
+    }
+  }
+  const r = { id: id ?? nextId(rules, rejected), rule: rule.trim(), kinds, status, source: source ?? "user", check: check ?? { type: "judge", question: `Does it follow this rule: "${rule.trim()}"?` }, added: new Date().toISOString(), ...(where && status === "active" ? { where } : {}), ...(tpl ? { tpl } : {}), ...(status === "proposed" ? { evidence } : {}) };
+  rules.push(r);
+  saveRules(rules, rejected);
+  return { rule: r, added: true, proposed: status === "proposed" };
+}
+
+const findRule = (rules, id) => rules.find((x) => x.id.toLowerCase() === String(id).trim().toLowerCase().replace(/^(\d)/, "r$1"));
+const setText = (r, text) => {
+  r.rule = text.trim();
+  if (r.check?.type === "judge") r.check.question = `Does it follow this rule: "${r.rule}"?`;
+  delete r.inTheirWords;
+};
+
+// The user keeps a proposal: it becomes active with the scope they chose (default: the suggested one), in
+// their words if they gave new ones. When an active rule like it had a narrower scope, that rule takes the
+// wider scope instead (no twin rules); otherwise the kept rule stands on its own.
+export function approveRule(id, { scope, text } = {}) {
+  const rules = loadRules();
+  const r = findRule(rules, id);
+  if (!r) throw new Error(`No rule ${id}. palate rule list shows them.`);
+  if (!isProposed(r)) throw new Error(`${r.id} is already one of your rules (palate rule edit ${r.id} changes it).`);
+  const s = resolveScope(r, scope);
+  if (text?.trim() && text.trim() !== r.rule) setText(r, text);
+  r.kinds = s.kinds;
+  if (s.where) r.where = s.where;
+  else delete r.where;
+  r.status = "active";
+  r.approved = new Date().toISOString();
+  const twin = rules.find((x) => x !== r && isActive(x) && alike(x, r));
+  if (twin && !s.where && (twin.where || !twin.kinds.includes("all"))) {
+    if (twin.where) {
+      delete twin.where;
+      twin.kinds = s.kinds;
+    } else twin.kinds = s.kinds.includes("all") ? ["all"] : [...new Set([...twin.kinds, ...s.kinds])];
+    for (const src of [r.source, ...(r.also ?? [])]) gain(twin, src);
+    if (text?.trim()) setText(twin, r.rule);
+    rules.splice(rules.indexOf(r), 1);
+    saveRules(rules);
+    return { rule: twin, scope: { ...s, label: scopeLabel(twin) }, mergedFrom: r.id };
+  }
+  saveRules(rules);
+  return { rule: r, scope: s };
+}
+
+// The user discards a proposal: it goes, and is remembered with its evidence, so the same evidence never
+// proposes it again.
+export function rejectRule(id) {
+  const rules = loadRules();
+  const r = findRule(rules, id);
+  if (!r) throw new Error(`No rule ${id}. palate rule list shows them.`);
+  if (!isProposed(r)) throw new Error(`${r.id} is one of your rules, not a proposal. To remove it: palate rule rm ${r.id}`);
+  rules.splice(rules.indexOf(r), 1);
+  const rejected = rejectedRules();
+  rejected.push({ id: r.id, rule: r.rule, ...(r.tpl ? { tpl: r.tpl } : {}), ...(r.check?.type !== "judge" ? { check: r.check } : {}), keys: (r.evidence ?? []).map((e) => e.key), at: new Date().toISOString() });
+  saveRules(rules, rejected.slice(-300));
+  return r;
+}
+
+// project: keep the rule to one project ("" or "all": every project again). New kinds drop a route or component
+// scope but keep the project.
+export function editRule(id, { rule, kinds, project } = {}) {
+  const rules = loadRules();
+  const r = findRule(rules, id);
+  if (!r) throw new Error(`No rule ${id}. palate rule list shows them.`);
+  if (rule) setText(r, rule);
+  if (kinds?.length) {
+    r.kinds = kinds;
+    r.where = r.where?.project ? { project: r.where.project } : undefined;
+  }
+  if (project != null) {
+    const p = String(project).trim();
+    r.where = { ...(r.where ?? {}), project: /^(|all|everywhere|any)$/i.test(p) ? undefined : p };
+  }
+  if (r.where) for (const k of Object.keys(r.where)) if (r.where[k] == null) delete r.where[k];
+  if (!r.where || !Object.keys(r.where).length) delete r.where;
+  saveRules(rules);
+  return r;
+}
+
+export function removeRule(id) {
+  const rules = loadRules();
+  const r = findRule(rules, id);
+  if (!r) throw new Error(`No rule ${id}.`);
+  rules.splice(rules.indexOf(r), 1);
+  saveRules(rules);
+  return r;
+}
+
+// ---- evidence: what a proposal was learned from, in plain words
+const pinNo = (id) => String(id ?? "").match(/-(\d+)$/)?.[1] ?? "";
+export const pinEvidence = (p, said) => ({ key: `pin:${p.id}`, type: "pin", pin: pinNo(p.id), said: said ?? p.prompt ?? (p.chips ?? []).join(", "), typed: Boolean(p.prompt), project: p.project, route: p.route, component: p.component ?? null, kinds: kindTags({ route: p.route }), crop: p.crop ?? p.before ?? null, at: p.at });
+const placeOf = (e) => (e.component ? `<${e.component}>${e.route ? ` in ${e.route}` : ""}` : e.route ?? "");
+const one = (e) =>
+  e.type === "pin"
+    ? `pin${e.pin ? ` ${e.pin}` : ""} “${short(e.said ?? "", 60)}” on ${placeOf(e)}`
+    : e.type === "failure"
+      ? `you called ${e.route ?? "a screen"} bad: “${short(e.said ?? "", 80)}”`
+      : e.type === "critique"
+        ? `a critique finding you agreed with on ${e.route ?? "a page"}: “${short(e.said ?? "", 80)}”`
+        : `“${short(e.said ?? "", 80)}”`;
+// "from pin 3 “make this calmer” on <RoleBadge> in /team, and 2 more asks like it": the newest evidence in the
+// user's own words first, then a count of the rest.
+export function evidenceText(r) {
+  const ev = [...(r.evidence ?? [])].sort((a, b) => Number(Boolean(b.typed)) - Number(Boolean(a.typed)) || String(b.at ?? "").localeCompare(String(a.at ?? "")));
+  if (!ev.length) return `from ${[r.source, ...(r.also ?? [])].join(", ")}`;
+  const rest = ev.slice(1);
+  const pins = rest.every((e) => e.type === "pin");
+  const more = rest.length ? `, and ${rest.length} more ${pins ? (rest.length === 1 ? "ask" : "asks") : rest.length === 1 ? "one" : "ones"} like it` : "";
+  const no = ev.find((e) => e.afterNo)?.afterNo;
+  return `from ${one(ev[0])}${more}${no ? ` (you discarded it on ${no.slice(0, 10)}; it has come up again since)` : ""}`;
+}
+// "asked 3 times", "2 failures", "1 agreed critique finding"
+export function evidenceCount(r) {
+  const ev = r.evidence ?? [];
+  const n = (t) => ev.filter((e) => e.type === t).length;
+  return [n("pin") && `asked ${n("pin")} time${n("pin") > 1 ? "s" : ""}`, n("failure") && `${n("failure")} failure${n("failure") > 1 ? "s" : ""}`, n("critique") && `${n("critique")} agreed critique finding${n("critique") > 1 ? "s" : ""}`].filter(Boolean).join(", ") || "1 source";
+}
+// How a rule is checked, in words (a rule for one component is asked of the judge).
+export const checkWords = (r) => {
+  const c = enforced(r).check;
+  return c?.type === "metric" ? `measured on every shoot: ${METRICS[c.metric] ?? c.metric} ${c.op} ${c.value}` : c?.type === "dom" ? `measured on every shoot: ${c.selector}` : "the judge asks";
+};
+
+// ---- templates: the general form of what the user keeps rejecting, with a check. Evidence in any words
+// ("logos too small", a critique finding, a failure's why) is matched to one, so it becomes the same rule
+// with the same check instead of a new note. Order matters: specific before general.
+const metric = (m, op, value) => ({ type: "metric", metric: m, op, value });
+// The user asking for a demo without controls ("no skip button", "loop on its own", "automatic, without a button").
+const NO_CONTROLS = /\b(no|without|never|instead of)\b[^.]{0,40}\b(skip|replay|button)\b|loops? on its own|automatic(ally)?\b[^.]{0,30}\bloop|\bloop[^.]{0,30}\bautomatic/i;
+
+export const TEMPLATES = [
+  // States, measured by `palate states` (every screen; n/a where a state can't happen, e.g. static data).
+  { tpl: "states-empty", re: /empty states?|no (items|results|records|members) (message|state)|blank list|nothing to show/i, kinds: ["all"], rule: "Every list, table and grid has an empty state: what is empty, and the next action as a button.", check: metric("listsWithoutEmptyState", "<=", 0) },
+  { tpl: "states-loading", re: /loading (state|indicator|spinner)|skeletons?\b|blank while (it )?loads|while (it'?s )?loading/i, kinds: ["all"], rule: "Everything that loads shows it is loading (a skeleton shaped like the content), never a blank or a false empty state.", check: metric("missingLoadingStates", "<=", 0) },
+  { tpl: "states-error", re: /error (states?|messages?)|swallow|fails? silently|errors? (are |is )?(hidden|ignored)|nothing happens when it fails/i, kinds: ["all"], rule: "Every failure is shown: what happened and what to do, with Try again; never a silent fail or a fall-through to the empty state.", check: metric("errorsSwallowed", "<=", 0) },
+  { tpl: "states-double-submit", re: /double.?(submit|click|press)|(sent|submitted|pressed|clicked) twice/i, kinds: ["all"], rule: "A second press while an action runs does nothing: the button shows it is pending and the request goes once.", check: metric("doubleSubmits", "<=", 0) },
+  { tpl: "states-images", re: /broken (images?|avatars?)|image fallback|avatar fallback|missing (images?|avatars?)/i, kinds: ["all"], rule: "Images and avatars fall back gracefully when they fail; never the browser's broken-image icon.", check: metric("brokenImages", "<=", 0) },
+  { tpl: "states-long-text", re: /long (names?|text|emails?|words?|titles?)|text overflows?|overflowing text|clipped text/i, kinds: ["all"], rule: "Long names, emails and titles wrap or truncate with a way to read them; nothing spills, clips or scrolls the page sideways at 320px.", check: metric("textOverflows", "<=", 0) },
+  { tpl: "signup-button-outside", re: /button.{0,60}(outside|inside|beside).{0,40}(input|field|bar)|inside one bordered bar/i, kinds: ["landing", "cta"], rule: "The primary signup button sits outside the input bar, as its own button beside the field group, not inside one bordered bar.", check: metric("buttonInsideInputBar", "<=", 0) },
+  { tpl: "no-black-accents", re: /pure.black|no black|black (ui )?(chips?|accents?|labels?)/i, kinds: ["landing", "marketing"], rule: "No pure-black UI accents (chips, buttons, labels): use the brand colour or refined neutrals.", check: metric("blackAccents", "<=", 0) },
+  { tpl: "cards-autoplay", re: /animate by themselves|auto.?play|play on their own|static demo card/i, kinds: ["landing", "marketing", "features"], rule: "Feature cards animate by themselves and show the feature working (auto-play when in view); a static demo card loses.", check: { type: "judge", question: "Does every feature card play by itself when in view, showing the feature working (no static demo cards)?" } },
+  { tpl: "pastel-stages", re: /pastel|dotted (grey |gray )?grids?|dots? (background|grid)|instead of dots/i, kinds: ["landing", "marketing", "features"], rule: "Card stages use soft pastel backgrounds, never dotted grey grids.", check: metric("dotGrids", "<=", 0) },
+  { tpl: "no-gradient-buttons", re: /gradient (buttons?|ctas?|fills?)|gradients? on (the )?(buttons?|ctas?)|buttons? with (a )?gradients?/i, kinds: ["all"], rule: "No gradient fills on buttons: a solid brand colour or a refined neutral.", check: metric("gradientButtons", "<=", 0) },
+  { tpl: "real-agent-ui", re: /agent (ui|interface)|prompt box|tool.call/i, kinds: ["landing", "demo"], rule: "An agent UI in a demo looks like a real best-in-class agent interface: a real prompt box, tool-call and step components.", check: { type: "judge", question: "Does the agent UI in the demo look like a real best-in-class agent interface (a real prompt box, tool calls, steps)?" } },
+  { tpl: "one-company-agents", re: /rival|one company'?s agents|mixed in one build|subagents/i, kinds: ["landing", "demo"], rule: "Demos stay realistic: one company's agents build together (e.g. Claude Code subagents), never rival companies' agents mixed in one build.", check: { type: "judge", question: "Is the demo realistic: one company's agents working together, no rival agents mixed in one build?" } },
+  // Said with a "no"/"without", the controls flip meaning: the user wants the demo to loop on its own.
+  { tpl: "demo-loops", re: NO_CONTROLS, kinds: ["landing", "demo"], rule: "A demo on a landing page loops on its own, with no Skip or Replay button: it finishes its story in about 15 seconds, holds the result, then plays again, pausing while the visitor hovers or focuses inside it.", check: { type: "judge", question: "Does the demo loop on its own (no Skip or Replay button), finish its story in about 15 seconds, and pause while the visitor hovers or focuses inside it?" } },
+  { tpl: "demo-15s", re: /\b15 ?s\b|skip and replay|finishes its story/i, unless: NO_CONTROLS, kinds: ["landing", "demo"], rule: "A demo on a landing page finishes its story in about 15 seconds, with Skip and Replay.", check: metric("demoMissingControls", "<=", 0) },
+  { tpl: "framework-logos-placement", re: /framework logos?|frameworks?.{0,50}(own|logo.cloud|section|further down)|only (the )?(coding[- ])?agent(s'?)? logos|logos in the wrong place/i, kinds: ["landing"], rule: "Before the product demo, only the logos of the agents it runs in. Framework and other integration logos go in their own logo-cloud section further down.", check: metric("frameworkLogosBeforeDemo", "<=", 0) },
+  { tpl: "no-step-bars", re: /step ?bars?|progress (bar|line)|✓ ?plan|decorative (step|progress)|bar (with|that has) no purpose/i, kinds: ["landing", "marketing"], rule: "No decorative step or progress bars (\"✓ Plan — Build — Choose…\") that do nothing; let the product show its steps.", check: metric("stepBarsBeforeDemo", "<=", 0) },
+  { tpl: "demo-premium", re: /demo.{0,80}(premium|dashboard of panels|at its best|isn'?t the product)|dashboard of panels/i, kinds: ["landing", "demo"], rule: "The product demo is the most premium thing on the page: the product visibly working, in detail; never a small dashboard of panels.", check: { type: "judge", question: "Is the product demo the most premium thing on the page, the product visibly working in detail (not a small dashboard of panels)?" } },
+  { tpl: "no-framed-screenshots", re: /screenshots?|static (pictures?|images?)|only (ever )?(shown )?as pictures|framed|instead of the product working/i, kinds: ["landing"], rule: "Never show the product only as framed screenshots on a landing page: show it working, built in code (one plain still at most).", check: metric("framedScreenshots", "<=", 0) },
+  { tpl: "kicker-once", re: /kicker|eyebrow|section numbers?|same label|label on every|mono "?0\d/i, kinds: ["landing", "marketing"], rule: "A kicker label or section number on one section at most; let sections open differently.", check: metric("kickerSections", "<=", 1) },
+  { tpl: "no-repeated-device", re: /same (opening )?device|device (on|in) every|every section (the same|opens)/i, kinds: ["landing", "marketing"], rule: "No device on every section (frames, rules, two-column heads, backdrops, dark bands): a device used everywhere means nothing.", check: metric("repeatedDevices", "<=", 0) },
+  { tpl: "logo-size", re: /logos?.{0,50}(too )?(small|tiny|faint|unreadable|can'?t see|16px)|marks?.{0,30}(small|tiny|faint)|small logos?/i, kinds: ["landing", "marketing", "logo cloud"], rule: "Logo marks at least 24px tall, at a size you can read; never logos as faint texture.", check: metric("minLogoMarkPx", ">=", 24) },
+  { tpl: "logo-colour", re: /logos?.{0,50}(grey|gray|one colou?r|monochrome|brand colou?rs?)|official (brand )?colou?rs/i, kinds: ["landing", "marketing", "logo cloud"], rule: "Brand logos in their official colours, not painted one grey.", check: metric("monochromeLogoRows", "<=", 0) },
+  { tpl: "logo-cloud-presence", re: /logo.?cloud/i, kinds: ["logo cloud"], rule: "A logo cloud has presence: brand-colour marks at 32–40px with their names, one deliberate rhythm, under a real heading (never a 16px label alone), and a reason to be on the page.", check: { type: "judge", question: "Does the logo cloud have presence: brand-colour marks at 32–40px with names, one rhythm, a real heading, a reason to exist?" } },
+  { tpl: "motion", re: /nothing moves|no motion|feels dead|static apart|doesn'?t move|purposeful (motion|animation)/i, kinds: ["landing", "marketing"], rule: "The page moves with purpose: a short entrance, the product playing, state changes animated; reduced motion respected and nothing hidden without JavaScript.", check: metric("movingElements", ">=", 1) },
+  { tpl: "radius-scale", re: /radi(us|i)|corner/i, kinds: ["all"], rule: "One radius scale (three or four values, nested concentrically) and one black.", check: metric("distinctRadii", "<=", 4) },
+  { tpl: "social-meta", re: /og:image|social (image|card)|twitter:card|apple-touch/i, kinds: ["landing"], rule: "A page people will share has an og:image, a twitter card and an apple-touch-icon.", check: { type: "dom", selector: 'meta[property="og:image"], meta[name="og:image"]', min: 1 } },
+  { tpl: "brand-primary", re: /not black|black (button|primary)|brand colou?r.{0,30}primary|primary.{0,30}brand colou?r/i, kinds: ["landing"], rule: "Primary actions use the brand colour, not black.", check: metric("blackPrimaryButtons", "<=", 0) },
+  { tpl: "documentation-row", re: /documentation|how it works|seven-column|process row|step list|explains? the loop/i, kinds: ["landing", "marketing"], rule: "No row of process steps that explains how it works like documentation; show the process happening.", check: { type: "judge", question: "Is there a row or list of process steps that explains the product like documentation, instead of showing it happen? (yes fails)" } },
+  { tpl: "readable-thumbnails", re: /tiny (screenshots|thumbnails)|wall of|unreadable/i, kinds: ["all"], rule: "Every preview or thumbnail is large enough to read; no wall of tiny screenshots.", check: { type: "judge", question: "Is every preview or thumbnail large enough to read at 100% (no wall of tiny screenshots)?" } },
+  { tpl: "one-focal-number", re: /compete|one (big|lead) number|several (numbers|figures)|at the heading'?s size/i, kinds: ["all"], rule: "One focal point per band: one lead number or line; other figures a step smaller.", check: { type: "judge", question: "Does each band have one focal point (one lead number or line, the rest a step smaller)?" } },
+  { tpl: "closing-cta", re: /closing (signup|cta|call)|repeats the hero/i, kinds: ["landing"], rule: "The closing call to action gives something new (the result, a reward), not a repeat of the hero form.", check: { type: "judge", question: "Does the closing call to action add something new instead of repeating the hero form?" } },
+  { tpl: "show-not-tell", re: /tells you|never shows|without showing|toggle .{0,30}(screenshot|too small)|change is too small to see/i, kinds: ["landing", "marketing"], rule: "Show every claim happening (learning, polish, the pick) in live UI; don't just state it or flip a toggle over a picture.", check: { type: "judge", question: "Is every claim the page makes shown happening in live UI, rather than stated or shown as a toggle over a picture?" } },
+  { tpl: "premium", re: /premium|apple.level|best.designed|merely correct|still not there|won'?t believe an ai/i, kinds: ["landing", "marketing", "hero"], rule: "Premium, not merely correct: the finish of the best product pages. Would a designer believe an AI built this?", check: { type: "judge", question: "Is it premium, not merely correct: would a designer believe an AI built this? (correct and clean but forgettable fails)" } },
+  { tpl: "clarity-over-spectacle", re: /spectacle|theatre|theater|clever.concept/i, kinds: ["all"], rule: "Clarity before spectacle: a new idea must be at least as clear as what it replaces.", check: { type: "judge", question: "Is it at least as clear as the current version, with any spectacle serving that clarity?" } },
+  { tpl: "all-at-once", re: /one at a time|behind (tabs?|interaction|steps)|hidden behind|configure before/i, kinds: ["all"], rule: "Show everything the job needs at once; never hide content behind tabs, steps or one card at a time.", check: { type: "judge", question: "Is all the content this job needs visible at once (not behind tabs, steps or one card at a time)?" } },
+  { tpl: "no-props", re: /\bprops\b|stamps?|tickets?|tear-off|clutter/i, kinds: ["all"], rule: "Density of content, never of chrome: one crafted touch at most, and no props (stamps, tickets, slips, folders).", check: { type: "judge", question: "Is the density content rather than chrome, with one crafted touch at most and no props?" } },
+];
+export const matchTemplate = (text) => TEMPLATES.find((t) => t.re.test(text)) ?? null;
+export const matchTemplates = (text) => TEMPLATES.filter((t) => t.re.test(text) && !t.unless?.test(text));
+const kindsWith = (t, kinds) => (t.kinds.includes("all") || !kinds?.length ? t.kinds : [...new Set([...t.kinds, ...kinds])]);
+const fromTemplate = (t, { kinds, source, status, evidence, where } = {}) => addRule({ rule: t.rule, kinds: kindsWith(t, kinds), source, check: t.check, tpl: t.tpl, status, evidence, where });
+
+// Point chips the user can tap, as the rule a repeated tap means.
+const CHIP_RULES = {
+  "Make it premium": "premium",
+  "Add motion": "motion",
+  "Fix spacing": { rule: "Spacing on one scale, the same between like parts.", kinds: ["all"] },
+  "Fix alignment": { rule: "Shared edges: every block aligns to the layout's grid.", kinds: ["all"] },
+  "Type hierarchy": { rule: "One clear type hierarchy: one focal size per screen and few sizes in all.", kinds: ["all"] },
+  "Real content & avatars": { rule: "Real content and real faces (or generated avatars); never placeholders or initials.", kinds: ["all"] },
+};
+
+// Evidence in any words → rules: the general form of every template it matches, else the words themselves.
+// status "proposed" (with evidence) when palate inferred it; the user's own words are active.
+export function ruleFrom(text, { kinds, source, status, evidence, where } = {}) {
+  const ts = matchTemplates(text);
+  if (ts.length) return ts.map((t) => fromTemplate(t, { kinds, source, status, evidence, where }));
+  return [addRule({ rule: text, kinds, source, status, evidence, where })];
+}
+
+// A note on one of the user's references (`palate refs add <src> --like "…" --dislike "…"`) → rules tied to it
+// (source "ref:<id>"). A like is a judge rule naming that reference; a dislike takes the general form of every
+// template it matches (measured when palate can measure it), else becomes a judge rule naming the reference.
+export function ruleFromRefNote(ref, kind, text, { kinds = ["all"] } = {}) {
+  const note = String(text ?? "").trim().replace(/[.\s]+$/, "");
+  if (!note) return [];
+  const where = ref.kind === "url" ? ref.source.replace(/^https?:\/\/(www\.)?/, "").replace(/\/$/, "") : path.basename(ref.source);
+  const source = `ref:${ref.id}`;
+  if (kind === "like") return [addRule({ rule: `Like your reference ${where}: ${note}.`, kinds, source, check: { type: "judge", question: `Does it have what the user likes about their reference ${where}: "${note}"?` }, tpl: `ref-like:${ref.id}:${note.toLowerCase()}` })];
+  const ts = matchTemplates(note);
+  if (ts.length) return ts.map((t) => fromTemplate(t, { kinds: kinds.includes("all") ? undefined : kinds, source }));
+  return [addRule({ rule: `Avoid ${note} (you disliked it in ${where}).`, kinds, source, check: { type: "judge", question: `Is it free of what the user dislikes in their reference ${where}: "${note}"? (present fails)` }, tpl: `ref-dislike:${ref.id}:${note.toLowerCase()}` })];
+}
+
+// Forgets a source (a removed reference): rules that came only from it go; rules it only strengthened lose it.
+export function dropSource(source) {
+  const rules = loadRules();
+  const kept = [];
+  const removed = [];
+  for (const r of rules) {
+    if (r.source === source) {
+      if (!r.also?.length) {
+        removed.push(r);
+        continue;
+      }
+      r.source = r.also.shift();
+      if (!r.also.length) delete r.also;
+    } else if (r.also?.includes(source)) {
+      r.also = r.also.filter((s) => s !== source);
+      if (!r.also.length) delete r.also;
+    }
+    kept.push(r);
+  }
+  saveRules(kept);
+  return removed;
+}
+
+// ---- checking
+const OPS = { "<=": (a, b) => a <= b, ">=": (a, b) => a >= b, "=": (a, b) => a === b, "<": (a, b) => a < b, ">": (a, b) => a > b };
+const domChecks = (rules) => rules.filter((r) => r.check?.type === "dom").map((r) => ({ id: r.id, selector: r.check.selector, visible: Boolean(r.check.visible), before: r.check.before }));
+
+// Measures the facts the rules read, in an open page (scrolled through first, so lazy parts are there).
+export async function measureRules(page, rules = activeRules()) {
+  const sections = await page.evaluate(`(${script("page-sections.js")})()`);
+  const devices = await page.evaluate(`(${script("page-devices.js")})(${JSON.stringify(sections)})`);
+  const facts = await page.evaluate(`(${script("page-rules.js")})(${JSON.stringify(sections)}, ${JSON.stringify(devices)}, ${JSON.stringify(domChecks(rules))})`);
+  return { facts, sections };
+}
+
+// Each rule against the facts: pass, fail, n/a (nothing to measure, e.g. no logos) or judge (not measurable).
+export function checkRules(rules, facts, { motion = true } = {}) {
+  return rules.map((r) => {
+    const c = r.check ?? { type: "judge" };
+    if (c.type === "judge") return { id: r.id, rule: r.rule, status: "judge", question: c.question };
+    if (!facts) return { id: r.id, rule: r.rule, status: "na", why: "not measured" };
+    if (c.type === "dom") {
+      const n = facts.dom?.[r.id];
+      if (n == null) return { id: r.id, rule: r.rule, status: "na", why: "not measured in this render" };
+      const ok = (c.min == null || n >= c.min) && (c.max == null || n <= c.max);
+      return { id: r.id, rule: r.rule, status: ok ? "pass" : "fail", value: n, want: [c.min != null && `≥ ${c.min}`, c.max != null && `≤ ${c.max}`].filter(Boolean).join(" and "), label: `elements matching ${c.selector}` };
+    }
+    if (NEEDS_MOTION.has(c.metric) && !motion) return { id: r.id, rule: r.rule, status: "na", why: "rendered with reduced motion" };
+    const v = facts[c.metric];
+    if (v == null && STATE_METRICS.has(c.metric)) return { id: r.id, rule: r.rule, status: "na", why: facts.statesRun ? `can't happen on this screen (palate states ${facts.statesRun})` : "measured by palate states; run it on this route" };
+    if (v == null) return { id: r.id, rule: r.rule, status: "na", why: `no ${METRICS[c.metric] ?? c.metric} on the page` };
+    const ok = (OPS[c.op] ?? OPS["<="])(v, c.value);
+    return { id: r.id, rule: r.rule, status: ok ? "pass" : "fail", value: v, want: `${c.op} ${c.value}`, label: METRICS[c.metric] ?? c.metric, detail: STATE_METRICS.has(c.metric) ? `palate states ${facts.statesRun}` : detailOf(c.metric, facts) };
+  });
+}
+const detailOf = (m, f) =>
+  ({
+    repeatedDevices: f.repeatedList?.join("; "),
+    blackAccents: f.blackAccentTexts?.map((t) => `"${t}"`).join(", "),
+    demoMissingControls: f.demoMissingList?.length ? `missing: ${f.demoMissingList.join(", ")}` : null,
+    minLogoMarkPx: f.logoRowList?.join("; "),
+    monochromeLogoRows: f.logoRowList?.filter((l) => /one colour/.test(l)).join("; "),
+    stepBarsBeforeDemo: f.stepBarTexts?.map((t) => `"${t}"`).join(", "),
+    distinctRadii: f.radiiList?.length ? `${f.radiiList.join(", ")}px` : null,
+    frameworkLogosBeforeDemo: `${(f.frameworksBeforeDemo ?? []).join(", ")}${f.demo ? ` before the demo (section ${f.demo.section}, "${f.demo.name}")` : " on the first screen (no demo found)"}`,
+  })[m] ?? null;
+
+const short = (s, n = 90) => (s.length > n ? `${s.slice(0, n - 1).replace(/\s+\S*$/, "")}…` : s);
+const measuredAs = (r) => (r.status === "fail" || r.status === "pass" ? `${r.label}: ${r.value}, must be ${r.want}${r.status === "fail" && r.detail ? `; ${r.detail}` : ""}` : "");
+
+// "Rules: 7 pass, 1 fail: R3 …" and one line per measured rule.
+export function rulesSummary(results) {
+  const pass = results.filter((r) => r.status === "pass");
+  const fail = results.filter((r) => r.status === "fail");
+  const judged = results.filter((r) => r.status === "judge").length;
+  const head = `Rules: ${pass.length} pass, ${fail.length} fail${fail.length ? `: ${fail.map((r) => `${r.id} (${short(r.rule, 60)})`).join("; ")}` : ""}${judged ? ` · ${judged} more for the judge` : ""}`;
+  return { head, pass, fail, judged };
+}
+export function rulesReport(results) {
+  if (!results.length) return [];
+  const { head } = rulesSummary(results);
+  return [
+    `## Your rules`,
+    `- ${head}`,
+    ...results.filter((r) => r.status === "fail").map((r) => `- ⚠ Rule ${r.id} fails: ${r.rule} (${measuredAs(r)})`),
+    ...results.filter((r) => r.status === "pass").map((r) => `- ✓ ${r.id} ${short(r.rule, 70)} (${measuredAs(r)})`),
+    ...results.filter((r) => r.status === "na").map((r) => `- · ${r.id} ${short(r.rule, 70)} (n/a: ${r.why})`),
+    ...(results.some((r) => r.status === "judge") ? [`- Not measurable, judge them yourself on the screenshot: ${results.filter((r) => r.status === "judge").map((r) => (/^Only for </.test(r.question ?? "") ? `${r.id} (${r.question.match(/^Only for (<[^>]+>)/)[1]} only)` : r.id)).join(", ")}`] : []),
+  ];
+}
+
+// ---- failures: what the user called bad, with a screenshot, in ~/.palate/failures
+export function failuresFor(tags, n = 4) {
+  return readLines(FAILS_LOG).filter((f) => !f.kinds?.length || f.kinds.includes("all") || f.kinds.some((k) => tags.includes(k))).slice(-n).reverse();
+}
+
+export function recordFailure({ project, route, why, kinds, shots = [], at } = {}) {
+  fs.mkdirSync(FAIL_DIR, { recursive: true });
+  const id = `${(at ?? new Date().toISOString()).slice(0, 10)}-${project}-${(route ?? "/").replace(/[^a-z0-9]+/gi, "-").replace(/^-|-$/g, "") || "home"}-${Math.random().toString(36).slice(2, 6)}`;
+  const kept = shots.filter((f) => f && fs.existsSync(f)).map((f, i) => {
+    const dest = path.join(FAIL_DIR, `${id}${shots.length > 1 ? `-${i + 1}` : ""}${path.extname(f) || ".png"}`);
+    fs.copyFileSync(f, dest);
+    return slash(dest);
+  });
+  const rec = { id, at: at ?? new Date().toISOString(), project, route, why, kinds, shots: kept };
+  fs.appendFileSync(FAILS_LOG, JSON.stringify(rec) + "\n");
+  return { failure: rec, learned: dedupe(learnFromFailure(rec)) };
+}
+
+// Each sentence of the why that matches a template proposes (or strengthens) a rule; else the whole why does.
+// Proposed, not active: the user said this screen is bad, not where else it holds; they choose the scope.
+export const failEvidence = (f, said) => ({ key: `failure:${f.id}`, type: "failure", said: said ?? f.why, project: f.project, route: f.route, component: null, kinds: f.kinds ?? [], crop: f.shots?.[0] ?? null, at: f.at });
+function learnFromFailure(f, { onlyTemplates = false } = {}) {
+  const learned = [];
+  const opts = (said) => ({ kinds: f.kinds, source: `failure:${f.id}`, status: "proposed", evidence: [failEvidence(f, said)] });
+  const parts = f.why.split(/(?<=[.;!?])\s+|\n+/).map((s) => s.trim()).filter((s) => s.length > 6);
+  for (const p of parts) if (matchTemplate(p)) learned.push(...ruleFrom(p, opts(p)));
+  if (!learned.length && !onlyTemplates) learned.push(...ruleFrom(f.why, opts()));
+  return learned;
+}
+
+// One entry per rule; "added" if any of its matches added it. A discarded proposal that came up again is kept once.
+export function dedupe(list) {
+  const by = new Map();
+  for (const l of list) {
+    if (!l.rule) by.set(`no:${l.discarded?.id}`, l);
+    else by.set(l.rule.id, { ...l, added: Boolean(by.get(l.rule.id)?.added || l.added) });
+  }
+  return [...by.values()];
+}
+
+// ---- the brief block
+// Picks as clicks: one grid click writes a record per loser, all within the same second.
+export function pickCount() {
+  return new Set(readLines(path.join(TASTE, "picks.jsonl")).map((p) => `${p.project}/${p.loop}/${String(p.at).slice(0, 19)}`)).size;
+}
+
+// The line that opens every brief, and the "Your rules (must pass)" block for this kind of screen with the
+// failures for it ("don't do this"). results: this page's current rule results, to mark what fails now.
+// route: the route the brief is for (rules kept for one route apply only there); project: the project folder's
+// name (rules kept for one project apply only there; unknown: not applied). Proposals never appear here.
+export function rulesBlock(tags, { results, failures = true, route, project } = {}) {
+  const rules = rulesFor(tags, { route, project });
+  const picks = pickCount();
+  // Which rules hold as general taste, which only here, and which another project kept for itself (skipped).
+  const general = rules.filter((r) => !r.where?.project).length;
+  const own = rules.length - general;
+  const skipped = {};
+  for (const r of activeRules()) if (r.where?.project && !appliesTo(r, tags, { route, project }) && appliesTo({ ...r, where: { ...r.where, project: undefined } }, tags, { route })) skipped[r.where.project] = (skipped[r.where.project] ?? 0) + 1;
+  const others = Object.entries(skipped).map(([p, n]) => `${n} only for ${p} skipped`);
+  const split = own || others.length ? `${general} general rule${general === 1 ? "" : "s"}${own ? `, ${own} only for ${project}` : ""}${others.length ? `; ${others.join("; ")}` : ""}` : "";
+  const line = `Built from ${rules.length} of your rules and ${picks} past picks${split ? ` (${split})` : ""}.`;
+  if (!rules.length) return { line, lines: [], rules, split };
+  const now = Object.fromEntries((results ?? []).map((r) => [r.id, r]));
+  const how = (r) => (r.check?.type === "metric" ? `measured: ${METRICS[r.check.metric] ?? r.check.metric} ${r.check.op} ${r.check.value}` : r.check?.type === "dom" ? `measured: ${r.check.selector}${r.check.min != null ? ` ≥ ${r.check.min}` : ""}${r.check.max != null ? ` ≤ ${r.check.max}` : ""}` : "the judge asks");
+  const where = (r) => (r.where?.component ? `Only for <${r.where.component}>: ` : r.where?.route ? `Only on ${r.where.route}: ` : "") + (r.where?.project ? `Only in ${r.where.project}: ` : "");
+  const fails = failures ? failuresFor(tags) : [];
+  const lines = [
+    "## Your rules (must pass)",
+    `What this user has said no to, as rules for ${tags.filter((t) => t !== "all").join(", ") || "every screen"}. They beat references, directions and your own ideas. palate shoot measures the [measured] ones on every shot ("Rules: n pass, n fail"), and the judge ranks down any variant that fails one.`,
+    ...(split ? [`Here: ${split}. General rules are this user's taste; rules another project kept for its own look don't apply.`] : []),
+    ...rules.map((r) => `- ${now[r.id]?.status === "fail" ? "✗ FAILS NOW: " : ""}**${r.id}** ${where(r)}${r.rule} [${how(r)}]`),
+    "",
+    ...(fails.length
+      ? [
+          "### Don't do this (what this user called bad before, for this kind of screen)",
+          ...fails.map((f) => `- ${f.at.slice(0, 10)} ${f.project} ${f.route}: ${short(f.why.replace(/\s+/g, " "), 480)}${f.shots?.length ? ` Screenshot${f.shots.length > 1 ? "s" : ""}: ${f.shots.join(", ")}` : ""}`),
+          "",
+        ]
+      : []),
+  ];
+  return { line, lines, rules, split };
+}
+
+// ---- learning: new evidence → proposed rules, de-duplicated. One pin is a one-off fix; a pattern (the same ask
+// twice, an agreed critique finding, a failure) becomes a proposal with the scopes its evidence supports, and
+// applies nowhere until the user keeps it.
+export function learnRules({ all = false } = {}) {
+  const state = readJson(STATE, {});
+  const since = all ? "" : state.rulesLearnedAt ?? "";
+  const out = [];
+  const take = (res, evidence) => out.push({ ...res, evidence });
+  const proposed = (evidence) => ({ status: "proposed", evidence });
+  // Critique findings the user agreed with, in general form.
+  for (const c of readLines(path.join(TASTE, "critiques.jsonl")).filter((c) => c.at > since && c.verdict === "agree")) {
+    // The finding's own words first (its fix can name other things); the fix only when they match nothing.
+    const text = `${c.what} ${c.note ?? ""}`;
+    const ts = matchTemplates(text).length ? matchTemplates(text) : matchTemplates(c.fix ?? "").slice(0, 1);
+    const kinds = kindTags({ route: c.route, words: c.kind });
+    const source = `critique:${c.project}${c.route}#${c.id}`;
+    const ev = [{ key: `critique:${c.project}${c.route}#${c.id}@${c.at}`, type: "critique", said: c.note || c.what, project: c.project, route: c.route, component: null, kinds, crop: null, at: c.at }];
+    if (ts.length) for (const t of ts) take(fromTemplate(t, { source, ...proposed(ev) }), `agreed critique ${c.id}: ${short(c.what, 80)}`);
+    else if (c.note) take(addRule({ rule: c.note, kinds, source, ...proposed(ev) }), `agreed critique ${c.id}, their note`);
+    else if (c.severity !== "low") {
+      const res = addRule({ rule: `Avoid: ${short(c.what, 160)}`, kinds, source, ...proposed(ev) });
+      if (res.added && res.rule) {
+        editFlag(res.rule.id);
+        res.rule.inTheirWords = true;
+      }
+      take(res, `agreed critique ${c.id} (in the critique's words: say it generally when you keep it)`);
+    }
+  }
+  // Failures recorded since (palate fail already proposed from them; this keeps them in sync if added by hand).
+  for (const f of readLines(FAILS_LOG).filter((f) => f.at > since)) for (const res of learnFromFailure(f, { onlyTemplates: true })) take(res, `failure ${f.id}`);
+  // Point requests: the same chip or the same kind of complaint twice is a proposal; once is a one-off fix.
+  const points = [...new Map(readLines(path.join(TASTE, "point.jsonl")).filter((x) => x.at > since && x.kind !== "point-cancel").map((x) => [x.id, x])).values()];
+  const chips = {};
+  for (const p of points) for (const c of p.chips ?? []) (chips[c] ??= []).push(p);
+  for (const [c, list] of Object.entries(chips)) {
+    const m = CHIP_RULES[c];
+    if (list.length < 2 || !m) continue;
+    const t = typeof m === "string" ? TEMPLATES.find((x) => x.tpl === m) : null;
+    const ev = proposed(list.map((p) => pinEvidence(p, p.prompt || c)));
+    take(t ? addRule({ rule: t.rule, kinds: t.kinds, source: `point:${c} ×${list.length}`, check: t.check, tpl: t.tpl, ...ev }) : addRule({ ...m, source: `point:${c} ×${list.length}`, ...ev }), `"${c}" asked ${list.length} times`);
+  }
+  const byTpl = {};
+  for (const p of points.filter((p) => p.prompt)) {
+    const t = matchTemplate(p.prompt);
+    if (t) (byTpl[t.tpl] ??= []).push(p);
+  }
+  for (const [tpl, list] of Object.entries(byTpl)) {
+    if (list.length < 2) continue;
+    const t = TEMPLATES.find((x) => x.tpl === tpl);
+    take(addRule({ rule: t.rule, kinds: t.kinds, source: `point:"${short(list[0].prompt, 40)}" ×${list.length}`, check: t.check, tpl, ...proposed(list.map((p) => pinEvidence(p))) }), `asked ${list.length} times in their words`);
+  }
+  // palate ambition and the similarity gate: an upgrade move the user kept or undid twice, and another
+  // project's look the gate keeps catching. Proposals only, like everything above.
+  for (const g of growthProposals(since)) {
+    // "feature grids section" → features (marketing only when nothing narrower fits).
+    const tags = g.section ? kindTags({ section: g.section }) : ["all"];
+    const kinds = tags.length > 1 ? tags.filter((k) => k !== "marketing") : tags;
+    take(addRule({ rule: g.rule, kinds: kinds.length ? kinds : ["all"], source: g.source, ...proposed(g.evidence) }), g.evidence.length > 1 ? `${g.evidence.length} times: ${g.evidence[0].said}` : g.evidence[0]?.said ?? g.source);
+  }
+  // palate research: the same trait liked or disliked in two research references (research-learn.mjs).
+  for (const p of researchProposals(since)) take(addRule({ rule: p.rule, kinds: p.kinds, source: p.source, check: p.check, tpl: p.tpl, ...proposed(p.evidence) }), `${p.evidence.length} research references: ${p.evidence.map((e) => e.said).join("; ")}`);
+  fs.mkdirSync(TASTE, { recursive: true });
+  if (!all) fs.writeFileSync(STATE, JSON.stringify({ ...readJson(STATE, {}), rulesLearnedAt: new Date().toISOString() }));
+  return out;
+}
+function editFlag(id) {
+  const rules = loadRules();
+  const r = rules.find((x) => x.id === id);
+  if (r) r.inTheirWords = true;
+  saveRules(rules);
+}
+
+// How to answer proposals, for the agent and the CLI.
+export const reviewHint = (ids = []) =>
+  `Nothing carries into later builds until the user keeps it. Show them each rule with its scope: palate rule review opens a board in their browser (MCP: palate_rule with action "review_start"). Or in chat: palate rule ok ${ids[0] ?? "<id>"} [--only <Component> | --route /x | --kind team | --scope all] [--text "…"], or palate rule no ${ids[0] ?? "<id>"}.`;
+
+// A proposal in a few lines: the rule, its suggested scope, how it's checked, and what it came from.
+export function proposalLine(r) {
+  const { options, suggest, why } = scopeOptions(r);
+  return `- ${r.id} ${r.rule}\n    suggested scope: ${options.find((o) => o.id === suggest)?.label ?? "Everywhere"}, because ${why} (or: ${options.filter((o) => o.id !== suggest).map((o) => o.label).join(", ")}) · ${checkWords(r)}\n    ${cap(evidenceText(r))} (${evidenceCount(r)})`;
+}
+
+export function learnedLines(list) {
+  const first = new Map();
+  for (const l of list.filter((l) => l.rule)) if (!first.has(l.rule.id) || (l.added && !first.get(l.rule.id).added)) first.set(l.rule.id, l);
+  // The rule as it is now (a later match may have added evidence to it).
+  const now = new Map(loadRules().map((r) => [r.id, r]));
+  const entries = [...first.values()].map((l) => ({ ...l, rule: now.get(l.rule.id) ?? l.rule }));
+  const proposals = entries.filter((l) => isProposed(l.rule));
+  const known = entries.filter((l) => !isProposed(l.rule) && !l.added);
+  const mine = entries.filter((l) => !isProposed(l.rule) && l.added);
+  const still = [...new Map(list.filter((l) => !l.rule && l.discarded).map((l) => [l.discarded.id, l])).values()];
+  if (!entries.length && !still.length) return ["No new rules: one pin is a one-off fix. A rule needs a pattern: the same ask twice, a critique finding the user agreed with, or a failure."];
+  return [
+    proposals.length ? `Proposed rules, waiting for your OK (${proposals.length}):` : "No new proposals.",
+    ...proposals.map((l) => `${proposalLine(l.rule)}${l.rule.inTheirWords ? "\n    (in the critique's words: say it generally when you keep it)" : ""}`),
+    ...(mine.length ? [`New rules in your words: ${mine.map((l) => `${l.rule.id} ${l.rule.rule}`).join("; ")}`] : []),
+    ...(known.length ? [`Strengthened (already one of your rules): ${[...new Set(known.map((l) => l.rule.id))].join(", ")}`] : []),
+    ...(still.length ? [`Still discarded (you said no before): ${still.map((l) => `"${short(l.discarded.rule, 60)}" (back only after ${l.needs} more new ask${l.needs > 1 ? "s" : ""})`).join(", ")}`] : []),
+    ...(proposals.length ? [reviewHint(proposals.map((l) => l.rule.id))] : []),
+  ];
+}
+
+// ---- how palate is doing: rules, picks, and how often its top-ranked variant was the user's pick
+export function learnedSummary(dir) {
+  const rules = loadRules().filter(isActive);
+  const byKind = {};
+  for (const r of rules) for (const k of r.kinds) byKind[k] = (byKind[k] ?? 0) + 1;
+  const measured = rules.filter((r) => r.check && r.check.type !== "judge").length;
+  const picks = readLines(path.join(TASTE, "picks.jsonl"));
+  const loops = [...new Map(picks.map((p) => [`${p.project}/${p.loop}`, p])).values()];
+  // For each loop, find its session: the record's dir, this project, or a sibling folder named like the project.
+  const sessionOf = (p) => {
+    const cands = [p.dir, dir && path.basename(path.resolve(dir)) === p.project ? dir : null, dir ? path.join(path.dirname(path.resolve(dir)), p.project) : null].filter(Boolean);
+    for (const d of cands) {
+      const s = path.join(d, ".palate", "variants", p.loop);
+      if (fs.existsSync(path.join(s, "result.json"))) return s;
+    }
+    return null;
+  };
+  let judged = 0;
+  let hits = 0;
+  let led = 0;
+  let ledHits = 0;
+  const misses = [];
+  for (const p of loops) {
+    const s = sessionOf(p);
+    if (!s) continue;
+    const result = readJson(path.join(s, "result.json"), null);
+    const winner = result?.ranking?.[0]?.wins ? result.ranking[0].route : null;
+    if (!winner) continue;
+    const judge = readJson(path.join(s, "judge.json"), null);
+    if (judge?.keep?.length) {
+      judged++;
+      if (judge.keep[0] === winner) hits++;
+      else misses.push(`${p.project}/${p.loop}: judge ranked ${judge.keep[0]} first, the user picked ${winner}`);
+    }
+    // Direction a is the one palate leads with (what has won for this user, or their reference).
+    const meta = readJson(path.join(s, "loop.json"), {});
+    if (!meta.vary && meta.directions?.length > 1) {
+      led++;
+      if (/-a\d+$/.test(winner)) ledHits++;
+    }
+  }
+  return { rules, proposed: proposedRules(), byKind, measured, picks: pickCount(), loops: loops.length, judged, hits, misses, led, ledHits, failures: readLines(FAILS_LOG).length };
+}
+
+export function learnedText(dir) {
+  const s = learnedSummary(dir);
+  const pct = (a, b) => (b ? `${Math.round((a / b) * 100)}%` : "n/a");
+  const newest = [...s.rules].sort((a, b) => (a.added < b.added ? 1 : -1)).slice(0, 5);
+  return [
+    "# What palate has learned about you",
+    "",
+    `- ${s.rules.length} rules (${s.measured} measured on every shoot, ${s.rules.length - s.measured} asked by the judge), from ${s.picks} picks in ${s.loops} loops and ${s.failures} failures. File: ${slash(RULES_FILE)}`,
+    `- Rules by kind of screen: ${Object.entries(s.byKind).sort((a, b) => b[1] - a[1]).map(([k, n]) => `${k} ${n}`).join(" · ") || "none yet"}`,
+    `- First-choice hit rate: palate's top-ranked variant was your pick in ${s.hits} of ${s.judged} judged loops (${pct(s.hits, s.judged)})${s.led ? `; its lead direction (a) won ${s.ledHits} of ${s.led} loops (${pct(s.ledHits, s.led)})` : ""}.`,
+    ...s.misses.slice(-3).map((m) => `  - missed: ${m}`),
+    newest.length ? "- Newest rules:" : "- No rules yet. Yours come from `palate rule add \"…\"` and notes on your references; palate proposes more from critique findings you agree with, `palate fail` and repeated asks, for your OK.",
+    ...newest.map((r) => `  - ${r.id} [${scopeLabel(r)}] ${r.rule}`),
+    ...(s.proposed.length ? [`- ${s.proposed.length} proposed rule${s.proposed.length > 1 ? "s" : ""} waiting for your OK (not applied yet): ${s.proposed.map((r) => r.id).join(", ")}. palate rule review`] : []),
+    "",
+  ].join("\n");
+}