@koda-sl/baker-cli 0.567.0 → 0.569.0

package/dist/critique-62QFBC33.js

@@ -0,0 +1,1451 @@
+import {
+  landingGraphFiles
+} from "./chunk-Z3ENMCFE.js";
+import {
+  brandCommitsAiHue,
+  brandCommitsCream,
+  brandCommitsFont,
+  brandCommitsGradient,
+  hasChroma,
+  isCreamColor,
+  isNeutralAuthoredColor,
+  loadBrandTokens,
+  parseColor
+} from "./chunk-EIDHLGQM.js";
+import "./chunk-KDAINT54.js";
+import {
+  STACCATO_MAX_WORDS,
+  STACCATO_RUN,
+  TELL_QUESTIONS,
+  copySentences,
+  rawSentences,
+  tellQuestionsFor,
+  wordCount
+} from "./chunk-4NZ47VXO.js";
+import {
+  rememberedJev
+} from "./chunk-4H6XLX7E.js";
+import {
+  holdUnbilledSpend
+} from "./chunk-Y5PNLB24.js";
+import "./chunk-N3PASNUA.js";
+import "./chunk-DLM5OSHM.js";
+import "./chunk-MCJ5I5LR.js";
+import "./chunk-E56V3RFO.js";
+import {
+  sha256Hex
+} from "./chunk-EL3TDR5S.js";
+import "./chunk-G6U45QD3.js";
+import "./chunk-X6U3B6YK.js";
+import "./chunk-2Q7K4F4H.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-R7XDGNZD.js";
+import "./chunk-XHWHBGKX.js";
+import "./chunk-JXTNP3B5.js";
+import "./chunk-45D6WRCJ.js";
+import {
+  registerSchema
+} from "./chunk-CCYZJMZ7.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/landing/critique.ts
+import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "fs/promises";
+import path3 from "path";
+import { defineCommand } from "citty";
+
+// src/engine/landing/lib/constants.ts
+var OVERUSED_FONTS = /* @__PURE__ */ new Set([
+  // Older monoculture (still ubiquitous):
+  "inter",
+  "roboto",
+  "open sans",
+  "lato",
+  "montserrat",
+  "arial",
+  "helvetica",
+  // Newer monoculture (the Anthropic-skill / Vercel / GitHub default wave):
+  "fraunces",
+  "instrument sans",
+  "instrument serif",
+  "geist",
+  "geist sans",
+  "geist mono",
+  "mona sans",
+  "plus jakarta sans",
+  "space grotesk",
+  "space mono",
+  "recoleta",
+  "dm sans",
+  "dm serif display",
+  "dm serif text",
+  "outfit",
+  "syne",
+  "cormorant",
+  "playfair display",
+  "lora",
+  "crimson",
+  "newsreader",
+  "ibm plex",
+  "ibm plex sans",
+  "ibm plex serif"
+]);
+function isOverusedFont(family) {
+  if (OVERUSED_FONTS.has(family)) return true;
+  for (const entry of OVERUSED_FONTS) if (family.startsWith(`${entry} `)) return true;
+  return false;
+}
+var GENERIC_FONTS = /* @__PURE__ */ new Set([
+  "serif",
+  "sans-serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "ui-serif",
+  "ui-sans-serif",
+  "ui-monospace",
+  "ui-rounded",
+  "-apple-system",
+  "blinkmacsystemfont",
+  "segoe ui",
+  "inherit",
+  "initial",
+  "unset",
+  "revert"
+]);
+var EM_DASH_FLOOR = 8;
+var EM_DASH_CHARS_PER_DASH = 500;
+var TAILWIND_TEXT_PX = {
+  "text-xs": 12,
+  "text-sm": 14,
+  "text-base": 16,
+  "text-lg": 18,
+  "text-xl": 20,
+  "text-2xl": 24,
+  "text-3xl": 30,
+  "text-4xl": 36,
+  "text-5xl": 48,
+  "text-6xl": 60,
+  "text-7xl": 72,
+  "text-8xl": 96,
+  "text-9xl": 128
+};
+var COPY_TELL_GATES = {
+  "chat-artifact": { minCount: 1, severity: "warn" },
+  "rhetorical-opener": { minCount: 2, severity: "warn" },
+  "negation-pivot": { minCount: 2, severity: "warn" },
+  "vague-attribution": { minCount: 2, severity: "warn" },
+  "participle-tail": { minCount: 2, severity: "advisory" },
+  "copula-avoidance": { minCount: 2, severity: "advisory" },
+  "authority-trope": { minCount: 2, severity: "advisory" },
+  signposting: { minCount: 2, severity: "advisory" },
+  "hollow-conclusion": { minCount: 2, severity: "advisory" },
+  "filler-phrase": { minCount: 2, severity: "advisory" },
+  "aphorism-formula": { minCount: 2, severity: "advisory" },
+  "false-range": { minCount: 2, severity: "advisory" },
+  "staccato-drama": { minCount: 2, severity: "advisory" },
+  "title-case-heading": { minCount: 2, severity: "advisory" },
+  "inline-header-list": { minCount: 3, severity: "advisory" },
+  emoji: { minCount: 3, severity: "advisory" }
+};
+var AI_PURPLE_HEXES = /* @__PURE__ */ new Set([
+  "#7c3aed",
+  "#8b5cf6",
+  "#a855f7",
+  "#9333ea",
+  "#7e22ce",
+  "#6d28d9",
+  "#6366f1",
+  "#764ba2",
+  "#667eea"
+]);
+var CREAM_TAILWIND_BG = /* @__PURE__ */ new Set([
+  "bg-amber-50",
+  "bg-amber-100",
+  "bg-orange-50",
+  "bg-orange-100",
+  "bg-yellow-50",
+  "bg-stone-50",
+  "bg-stone-100",
+  "bg-stone-200"
+]);
+var RULE_META = {
+  "gradient-text": {
+    family: "color",
+    severity: "block",
+    note: "Gradient text is a top AI tell. Emphasis comes from weight or size, not a clipped gradient fill.",
+    brandAware: "gradient"
+  },
+  "broken-image": {
+    family: "integrity",
+    severity: "block",
+    note: "An <img> with an empty or placeholder src ships a broken image. Source a real asset via `baker images`."
+  },
+  "competitor-named-in-comparison": {
+    family: "integrity",
+    severity: "warn",
+    note: "A competitor from the vault is named in a comparative sentence outside a comparison table. Naming a rival on paid traffic sells their brand and is the client's decision, not yours \u2014 cite the capability, not the company."
+  },
+  "side-tab": {
+    family: "borders_depth",
+    severity: "warn",
+    note: "A thick colored border on one edge is the 'side-tab' AI tell. Use full borders, a background, or spacing instead."
+  },
+  "border-accent-on-rounded": {
+    family: "borders_depth",
+    severity: "warn",
+    note: "A colored top/bottom accent bar on a rounded card is an AI tell. Let the card's own surface carry the accent."
+  },
+  "overused-font": {
+    family: "typography",
+    severity: "warn",
+    brandAware: "font",
+    note: "This face is a training-data default. Pick a face with a point of view \u2014 unless BRAND.md commits it."
+  },
+  "single-font": {
+    family: "typography",
+    severity: "advisory",
+    note: "Only one face across the page flattens hierarchy. A display/body pair usually reads richer."
+  },
+  "flat-type-hierarchy": {
+    family: "typography",
+    severity: "warn",
+    note: "Type steps are too close (<2\xD7 span). Widen the scale so the primary, secondary, and body are obvious at a glance."
+  },
+  "ai-color-palette": {
+    family: "color",
+    severity: "warn",
+    brandAware: "color",
+    note: "Purple/indigo-on-heading or purple\u2192cyan gradients are the AI palette cluster. Commit to the brand's own hues."
+  },
+  "cream-palette": {
+    family: "color",
+    severity: "warn",
+    brandAware: "color",
+    note: "Cream/parchment ground is the 'measured rendition' AI default. Rework from the brand's saturated materials."
+  },
+  "gray-on-color": {
+    family: "color",
+    severity: "warn",
+    note: "Gray text on a colored surface reads muddy. Tint secondary text from the surface hue, never neutral gray."
+  },
+  "bounce-easing": {
+    family: "motion",
+    severity: "warn",
+    note: "Bounce/elastic easing feels dated. Use natural deceleration (e.g. cubic-bezier(0.16, 1, 0.3, 1))."
+  },
+  "layout-transition": {
+    family: "motion",
+    severity: "advisory",
+    note: "Transitioning width/height/padding/margin janks. Animate transform/opacity, or clip-path/max-height with care."
+  },
+  "monotonous-spacing": {
+    family: "spacing",
+    severity: "warn",
+    note: "One spacing value dominates. Create rhythm \u2014 tight groups, generous separation, more space above a heading than below."
+  },
+  "marketing-buzzword": {
+    family: "copy",
+    severity: "warn",
+    note: "SaaS filler ('supercharge your\u2026') is generic. Name names, use numbers, say the specific thing only this product proves."
+  },
+  "agent-washing": {
+    family: "copy",
+    severity: "warn",
+    note: "The page claims autonomy but never says what the buyer controls. Name what it does on its own, what waits for approval, and what happens when it's wrong."
+  },
+  "em-dash-overuse": {
+    family: "copy",
+    severity: "warn",
+    note: "Dense em-dashes are an AI cadence tell (and brand copy bans them). Recast with commas, colons, or full stops."
+  },
+  "chat-artifact": {
+    family: "copy",
+    severity: "warn",
+    note: "Chatbot framing ('Here is an overview\u2026', 'av\xEDsame si') leaked into the page. Delete it and state the claim directly."
+  },
+  "rhetorical-opener": {
+    family: "copy",
+    severity: "warn",
+    note: "Fake-candid openers ('Honestly?', 'La verdad es que') manufacture intimacy before an ordinary claim. Just say the thing."
+  },
+  "negation-pivot": {
+    family: "copy",
+    severity: "warn",
+    note: "'It's not just X, it's Y' / 'no se trata solo de' is now a louder AI tell than any single word. Cut the setup, keep the claim."
+  },
+  "vague-attribution": {
+    family: "copy",
+    severity: "warn",
+    note: "'Experts agree' / 'los estudios demuestran' attributes to nobody. Name the source and the year, or drop the claim."
+  },
+  "participle-tail": {
+    family: "copy",
+    severity: "advisory",
+    note: "Participles hung off a comma (', ensuring\u2026', ', permitiendo\u2026') fake depth. End the sentence, or make it a real clause."
+  },
+  "copula-avoidance": {
+    family: "copy",
+    severity: "advisory",
+    note: "'serves as' / 'cuenta con' dodges plain 'is' and 'has'. Use the simple verb \u2014 it reads as confidence, not flatness."
+  },
+  "authority-trope": {
+    family: "copy",
+    severity: "advisory",
+    note: "'At its core' / 'en el fondo' pretends to reach a deeper truth before restating an ordinary point. Make the point once."
+  },
+  signposting: {
+    family: "copy",
+    severity: "advisory",
+    note: "Announcing the writing ('Let's dive in', 'vamos a ver') instead of doing it. Delete the announcement, keep the content."
+  },
+  "hollow-conclusion": {
+    family: "copy",
+    severity: "advisory",
+    note: "'The future looks bright' / 'las posibilidades son infinitas' asserts nothing. End on a concrete next step or a number."
+  },
+  "filler-phrase": {
+    family: "copy",
+    severity: "advisory",
+    note: "Filler ('in order to', 'cabe destacar que') costs words and says nothing. Cut to the verb."
+  },
+  "aphorism-formula": {
+    family: "copy",
+    severity: "advisory",
+    note: "'X is the currency of Y' sounds profound without adding precision. Replace it with the concrete claim it gestures at."
+  },
+  "false-range": {
+    family: "copy",
+    severity: "advisory",
+    note: "'From onboarding to retention' pairs ends that aren't on a scale. List what you actually cover."
+  },
+  "staccato-drama": {
+    family: "copy",
+    severity: "advisory",
+    note: "A run of very short sentences manufactures drama. One clipped line lands; three in a row read as engineered."
+  },
+  "title-case-heading": {
+    family: "copy",
+    severity: "advisory",
+    note: "Title Case headings are an AI tell \u2014 and in Spanish the convention doesn't exist at all. Use sentence case."
+  },
+  "inline-header-list": {
+    family: "copy",
+    severity: "advisory",
+    note: "'**Speed:** it is fast' bullets are AI list shape. Write the sentence, or let the bullet carry the content directly."
+  },
+  emoji: {
+    family: "copy",
+    severity: "advisory",
+    note: "Emoji-decorated copy is a chatbot habit. Let the words and the layout carry the emphasis."
+  },
+  "dark-glow": {
+    family: "borders_depth",
+    severity: "warn",
+    note: "A zero-offset colored glow is decoration, not depth. Shadows carry an offset and a soft blur."
+  },
+  marquee: {
+    family: "motion",
+    severity: "warn",
+    note: "Auto-scrolling marquees are a dated tell. Let the visitor control the pace, or drop the motion."
+  }
+};
+var SEVERITY_WEIGHT = {
+  block: 0.5,
+  warn: 0.2,
+  advisory: 0.05
+};
+
+// src/engine/landing/lib/copy-questions.ts
+var ANY_LANGUAGE = "The page may be in any language.";
+var BUZZWORD_QUESTION = `Does \`sentence\` lean on generic marketing buzzwords that could describe any company, such as "supercharge your workflow", "revolutionize", "seamless", "best-in-class", "cutting-edge", "unleash the power", "lleva tu negocio al siguiente nivel", instead of saying something specific? ${ANY_LANGUAGE}`;
+var BUZZWORD_HELD = 0.8;
+function comparisonQuestion(competitor) {
+  return `\`sentence\` is copy on a company's own sales page, and it names ${JSON.stringify(competitor)}, another company. Does it compare the two (better, worse, versus, cheaper than, an alternative to, switching from)? Naming it as something the product connects to, works with or imports from is not a comparison. ${ANY_LANGUAGE}`;
+}
+var COMPARISON_HELD = 0.5;
+var AUTONOMY_QUESTION = `Does \`sentence\` claim the product does the work by itself, with no person involved: fully autonomous agents, it runs while you sleep, set it and forget it, no human input needed? ${ANY_LANGUAGE}`;
+var AUTONOMY_HELD = 0.3;
+var CONTROL_QUESTION = `Does \`page\` tell the buyer how they stay in control of what the product does on its own: what waits for their approval, what they review before it happens, what they can override, undo or roll back, an audit log of what ran, or when it escalates to a person? Privacy or security statements (GDPR, encryption, "your data is safe") and accuracy figures do not count. ${ANY_LANGUAGE}`;
+var CONTROL_HELD = 0.3;
+function sentenceQuestion(question, sentence) {
+  return { instructions: { sentence, question } };
+}
+function pageQuestion(question, page) {
+  return { instructions: { page, question } };
+}
+
+// src/engine/copy-tells/detect.ts
+var SAMPLE_MAX = 60;
+function sample(text) {
+  const clean = text.replace(/\s+/g, " ").trim();
+  return clean.length <= SAMPLE_MAX ? clean : `${clean.slice(0, SAMPLE_MAX)}\u2026`;
+}
+function countStaccato(text) {
+  const prose = text.split("\n").filter((line) => !/^\s{0,3}#{1,6}\s/.test(line)).join(" ");
+  const sentences = rawSentences(prose);
+  let run = 0;
+  let count = 0;
+  let first = "";
+  let runStart = 0;
+  for (const [i, s] of sentences.entries()) {
+    const words = wordCount(s);
+    if (words > 0 && words <= STACCATO_MAX_WORDS) {
+      if (run === 0) runStart = i;
+      run++;
+      if (run === STACCATO_RUN) {
+        count++;
+        if (!first) first = sentences.slice(runStart, i + 1).join(" ");
+      }
+    } else {
+      run = 0;
+    }
+  }
+  return { count, first };
+}
+function countTitleCaseHeadings(text) {
+  let count = 0;
+  let first = "";
+  for (const m of text.matchAll(/^\s{0,3}#{1,6}\s+(.+)$/gm)) {
+    const heading = (m[1] ?? "").trim();
+    const words = heading.split(/\s+/).filter((w) => new RegExp("\\p{L}", "u").test(w));
+    if (words.length < 4) continue;
+    const capitalized = words.filter((w) => new RegExp("^\\p{Lu}", "u").test(w)).length;
+    if (capitalized / words.length < 0.8) continue;
+    count++;
+    if (!first) first = heading;
+  }
+  return { count, first };
+}
+function countInlineHeaderList(text) {
+  const matches = [...text.matchAll(/^\s*(?:[-*+]|\d+\.)\s+\*\*[^*\n]{2,40}:?\*\*:?\s/gm)];
+  if (matches.length < 3) return { count: 0, first: "" };
+  return { count: matches.length, first: (matches[0]?.[0] ?? "").trim() };
+}
+var EMOJI = /[\u{1F300}-\u{1FAFF}]|[\u{2600}-\u{27BF}]|[\u{1F000}-\u{1F2FF}]|\u{FE0F}/gu;
+var CURLY = /[‘’“”]/g;
+function countPattern(text, re) {
+  const matches = text.match(re) ?? [];
+  return { count: matches.length, first: matches.join("") };
+}
+function structuralCopyTells(text) {
+  if (!text.trim()) return [];
+  const results = [
+    ["staccato-drama", countStaccato(text)],
+    ["title-case-heading", countTitleCaseHeadings(text)],
+    ["inline-header-list", countInlineHeaderList(text)],
+    ["curly-quote", countPattern(text, CURLY)],
+    ["emoji", countPattern(text, EMOJI)]
+  ];
+  return results.filter(([, result]) => result.count > 0).map(([id, result]) => ({ id, count: result.count, sample: sample(result.first) }));
+}
+
+// src/engine/landing/lib/rules.ts
+var cap = (m, i) => m[i] ?? "";
+var num = (m, i) => Number(m[i] ?? 0);
+var hasRounded = (line) => /\brounded(?:-\w+)?\b/.test(line) || /border-radius/i.test(line);
+var isSafeElement = (line) => /<(?:blockquote|nav[\s>]|pre[\s>]|code[\s>]|a\s|input[\s>]|span[\s>])/i.test(line);
+var hasNeutralTailwindBorder = (line) => /\bborder-(?:gray|slate|zinc|neutral|stone|white|black|transparent|current|inherit)\b|\bborder-(?:gray|slate|zinc|neutral|stone)-\d+\b/.test(
+  line
+);
+function isNeutralBorderColor(str) {
+  const m = str.match(/solid\s+((?:rgba?|hsla?|oklch|oklab|lab|lch|hwb|color)\([^)]*\)|#[0-9a-f]{3,8}\b|[a-z]+)/i);
+  if (!m) return false;
+  return isNeutralAuthoredColor(m[1] ?? "");
+}
+var LINE_MATCHERS = [
+  // ── Side-tab: a thick colored border on one edge ──────────────────────────
+  {
+    id: "side-tab",
+    regex: /\bborder-[lrse]-(\d+)\b/g,
+    test: (m, line) => {
+      if (isSafeElement(line) || hasNeutralTailwindBorder(line)) return false;
+      return hasRounded(line) ? num(m, 1) >= 2 : num(m, 1) >= 4;
+    },
+    fmt: (m) => cap(m, 0)
+  },
+  {
+    id: "side-tab",
+    regex: /border-(?:left|right)\s*:\s*(\d+)px\s+solid[^;]*/gi,
+    test: (m, line) => {
+      if (isSafeElement(line)) return false;
+      if (isNeutralBorderColor(cap(m, 0))) return false;
+      return hasRounded(line) ? num(m, 1) >= 2 : num(m, 1) >= 3;
+    },
+    fmt: (m) => cap(m, 0).replace(/\s*;?\s*$/, "")
+  },
+  {
+    id: "side-tab",
+    regex: /border-(?:left|right)-width\s*:\s*(\d+)px/gi,
+    test: (m, line) => !isSafeElement(line) && num(m, 1) >= 3,
+    fmt: (m) => cap(m, 0)
+  },
+  {
+    id: "side-tab",
+    regex: /border-inline-(?:start|end)(?:-width)?\s*:\s*(\d+)px/gi,
+    test: (m, line) => !isSafeElement(line) && num(m, 1) >= 3,
+    fmt: (m) => cap(m, 0)
+  },
+  // ── Border accent on a rounded card (top/bottom colored bar) ──────────────
+  {
+    id: "border-accent-on-rounded",
+    regex: /\bborder-[tb]-(\d+)\b/g,
+    test: (m, line) => hasRounded(line) && num(m, 1) >= 1 && !hasNeutralTailwindBorder(line),
+    fmt: (m) => cap(m, 0)
+  },
+  {
+    id: "border-accent-on-rounded",
+    regex: /border-(?:top|bottom)\s*:\s*(\d+)px\s+solid/gi,
+    test: (m, line) => num(m, 1) >= 3 && hasRounded(line),
+    fmt: (m) => cap(m, 0)
+  },
+  // ── Gradient text (Tailwind class form; authored-CSS form is the window
+  // analyzer below, so a multi-line rule block is still caught) ──────────────
+  {
+    id: "gradient-text",
+    regex: /\bbg-clip-text\b/g,
+    test: (_m, line) => (
+      // v3 `bg-gradient-to-*`, v4 `bg-linear-to-*` / `bg-radial*` / `bg-conic*`,
+      // and arbitrary-value `bg-[linear-gradient(…)]` spellings.
+      /\bbg-gradient-to-|\bbg-linear-to-|\bbg-(?:radial|conic)\b|\bbg-\[(?:linear|radial|conic)-gradient/i.test(line)
+    ),
+    // The stops ride in the snippet so the brand allowlist can read them.
+    fmt: (_m, line) => {
+      const stops = line.match(/\b(?:from|via|to)-\[[^\]\s]+\]|\bbg-\[(?:linear|radial|conic)-gradient[^\]\s]*\]/g);
+      return stops ? `bg-clip-text + ${stops.join(" ")}` : "bg-clip-text + gradient";
+    }
+  },
+  // ── Gray text on a colored background (Tailwind). Shade ≥ 300 only: a pale
+  // tint panel (bg-blue-50 info box) is a normal light ground, not "on color". ──
+  {
+    id: "gray-on-color",
+    regex: /\btext-(?:gray|slate|zinc|neutral|stone)-(\d+)\b/g,
+    test: (_m, line) => {
+      const bg = line.match(
+        /\bbg-(?:red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-(\d+)\b/
+      );
+      return bg !== null && Number(bg[1] ?? 0) >= 300;
+    },
+    fmt: (m, line) => {
+      const bg = line.match(
+        /\bbg-(?:red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose)-\d+\b/
+      );
+      return `${cap(m, 0)} on ${bg?.[0] || "?"}`;
+    }
+  },
+  // ── AI color palette (Tailwind purple/indigo + banned hero hexes) ─────────
+  {
+    id: "ai-color-palette",
+    regex: /\btext-(?:purple|violet|indigo)-(\d+)\b/g,
+    test: (_m, line) => /\btext-(?:[2-9]xl)\b|<h[1-3]/i.test(line),
+    fmt: (m) => `${cap(m, 0)} on heading`
+  },
+  {
+    id: "ai-color-palette",
+    regex: /\bfrom-(?:purple|violet|indigo)-(\d+)\b/g,
+    test: (_m, line) => /\bto-(?:purple|violet|indigo|blue|cyan|pink|fuchsia)-\d+\b/.test(line),
+    fmt: (m) => `${cap(m, 0)} gradient`
+  },
+  {
+    id: "ai-color-palette",
+    regex: /#[0-9a-f]{6}\b/gi,
+    test: (m) => AI_PURPLE_HEXES.has(cap(m, 0).toLowerCase()),
+    fmt: (m) => `${cap(m, 0)} (AI-cluster purple)`
+  },
+  // ── Cream/parchment ground (Tailwind + authored background hex) ───────────
+  {
+    id: "cream-palette",
+    regex: /\bbg-(?:amber|orange|yellow|stone)-(?:50|100|200)\b/g,
+    test: (m) => CREAM_TAILWIND_BG.has(cap(m, 0)),
+    fmt: (m) => `${cap(m, 0)} (cream ground)`
+  },
+  {
+    id: "cream-palette",
+    regex: /background(?:-color)?\s*:\s*(#[0-9a-f]{6}\b|rgba?\([^)]+\))/gi,
+    test: (m) => {
+      const c = parseColor(cap(m, 1));
+      return c !== null && isCreamColor(c);
+    },
+    fmt: (m) => `${cap(m, 1)} (cream ground)`
+  },
+  // ── Bounce / elastic easing ───────────────────────────────────────────────
+  {
+    id: "bounce-easing",
+    regex: /\banimate-bounce\b/g,
+    test: () => true,
+    fmt: () => "animate-bounce (Tailwind)"
+  },
+  {
+    id: "bounce-easing",
+    regex: /animation(?:-name)?\s*:\s*([^;{}]*(?:bounce|elastic|wobble|jiggle|spring)[^;{}]*)/gi,
+    test: () => true,
+    fmt: (m) => `animation: ${cap(m, 1).trim()}`
+  },
+  {
+    id: "bounce-easing",
+    regex: /cubic-bezier\(\s*([\d.-]+)\s*,\s*([\d.-]+)\s*,\s*([\d.-]+)\s*,\s*([\d.-]+)\s*\)/g,
+    test: (m) => {
+      const y1 = Number.parseFloat(cap(m, 2));
+      const y2 = Number.parseFloat(cap(m, 4));
+      return y1 < -0.1 || y1 > 1.1 || y2 < -0.1 || y2 > 1.1;
+    },
+    fmt: (m) => `cubic-bezier(${cap(m, 1)}, ${cap(m, 2)}, ${cap(m, 3)}, ${cap(m, 4)})`
+  },
+  // ── Transitioning layout properties (jank) ────────────────────────────────
+  {
+    id: "layout-transition",
+    // The lookahead skips Astro's view-transition directives (transition:name=,
+    // transition:animate=, transition:persist) — markup idiom, not CSS.
+    regex: /transition(?:-property)?\s*:\s*(?!name\s*=|animate\s*=|persist\b)([^;{}]+)/gi,
+    test: (m) => {
+      const val = cap(m, 1).toLowerCase();
+      if (/\ball\b/.test(val)) return false;
+      return /\b(?:(?:max|min)-)?(?:width|height)\b|\bpadding\b|\bmargin\b/.test(val);
+    },
+    fmt: (m) => {
+      const found = cap(m, 1).match(
+        /\b(?:(?:max|min)-)?(?:width|height)\b|\bpadding(?:-(?:top|right|bottom|left))?\b|\bmargin(?:-(?:top|right|bottom|left))?\b/gi
+      );
+      return `transition: ${found ? found.join(", ") : cap(m, 1).trim()}`;
+    }
+  },
+  // ── Broken image ──────────────────────────────────────────────────────────
+  {
+    id: "broken-image",
+    regex: /<img\b[^>]*?\bsrc\s*=\s*(?:""|''|"\s+"|'\s+'|"#"|'#')/gi,
+    test: () => true,
+    fmt: (m) => cap(m, 0).slice(0, 100)
+  },
+  {
+    id: "broken-image",
+    regex: /<img\b(?:(?!\bsrc\s*=)[^>])*>/gi,
+    test: (m) => !/\bsrc\s*=/i.test(cap(m, 0)),
+    fmt: (m) => cap(m, 0).slice(0, 100)
+  }
+];
+function foldForCopy(text) {
+  return text.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+function stripHtmlToText(html) {
+  return html.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ").replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ").replace(/<!--[\s\S]*?-->/g, " ").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ");
+}
+function stripHtmlPreservingHeadings(html) {
+  return html.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ").replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ").replace(/<!--[\s\S]*?-->/g, " ").replace(
+    /<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi,
+    (_all, _lvl, inner) => `
+## ${String(inner).replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim()}
+`
+  ).replace(/<\/(?:p|div|section|li|tr|br)>|<br\s*\/?>/gi, "\n").replace(/<[^>]+>/g, " ").replace(/[ \t]+/g, " ").replace(/\n{3,}/g, "\n\n");
+}
+function isProseLiteral(value) {
+  const text = value.trim();
+  if (text.length < 12) return false;
+  if (/^(?:https?:\/\/|\/|\.{1,2}\/|#|@|[a-z]+:)/i.test(text)) return false;
+  if (!new RegExp("\\p{L}", "u").test(text)) return false;
+  const words = text.split(/\s+/).filter(Boolean);
+  if (words.length < 4) return false;
+  const classy = words.filter((w) => /^-?[a-z][a-z0-9]*(?:[-.:/][a-z0-9.[\]%-]+)+$/.test(w)).length;
+  if (classy >= 3 && classy / words.length > 0.5) return false;
+  return true;
+}
+function blankAstroFrontmatter(text) {
+  const cut = frontmatterLength(text);
+  if (cut === 0) return text;
+  const head = text.slice(0, cut);
+  const kept = head.split("").map((ch) => ch === "\n" ? "\n" : " ");
+  for (const literal of stringLiterals(head)) {
+    if (!isProseLiteral(literal.value)) continue;
+    for (let i = 0; i < literal.value.length; i++) {
+      const at = literal.start + i;
+      if (head[at] !== "\n") kept[at] = head[at] ?? " ";
+    }
+  }
+  return kept.join("") + text.slice(cut);
+}
+function blankUnrenderedSource(text) {
+  return blankTemplateComments(blankAstroFrontmatter(text));
+}
+function blankTemplateComments(text) {
+  const out = text.split("");
+  const pattern = /\{\s*\/\*[\s\S]*?\*\/\s*\}|<!--[\s\S]*?-->/g;
+  for (const m of text.matchAll(pattern)) {
+    const start = m.index ?? 0;
+    for (let i = start; i < start + m[0].length && i < out.length; i++) {
+      if (out[i] !== "\n") out[i] = " ";
+    }
+  }
+  return out.join("");
+}
+function frontmatterLength(text) {
+  if (!text.startsWith("---")) return 0;
+  const lines = text.split("\n");
+  if (!/^---\s*$/.test(lines[0] ?? "")) return 0;
+  const end = lines.findIndex((line, i) => i > 0 && /^---\s*$/.test(line));
+  return end === -1 ? 0 : lines.slice(0, end + 1).join("\n").length;
+}
+function stringLiterals(source) {
+  const out = [];
+  for (let i = 0; i < source.length; i++) {
+    const commentEnd = skipComment(source, i);
+    if (commentEnd !== -1) {
+      i = commentEnd;
+      continue;
+    }
+    const quote = source[i];
+    if (quote !== '"' && quote !== "'" && quote !== "`") continue;
+    const close = closingQuote(source, i + 1, quote);
+    if (close === -1) break;
+    out.push({ start: i + 1, value: source.slice(i + 1, close) });
+    i = close;
+  }
+  return out;
+}
+function skipComment(source, i) {
+  if (source[i] !== "/") return -1;
+  if (source[i + 1] === "/") {
+    const nl = source.indexOf("\n", i);
+    return nl === -1 ? source.length : nl;
+  }
+  if (source[i + 1] === "*") {
+    const close = source.indexOf("*/", i + 2);
+    return close === -1 ? source.length : close + 1;
+  }
+  return -1;
+}
+function closingQuote(source, from, quote) {
+  for (let j = from; j < source.length; j++) {
+    if (source[j] === "\\") {
+      j++;
+      continue;
+    }
+    if (source[j] === quote) return j;
+  }
+  return -1;
+}
+var ANALYZERS = [
+  // Overused primary font (font-family declarations + Google Fonts URLs). Fires
+  // at ≥1 and carries a line number → per file.
+  {
+    scope: "file",
+    run: (text, file) => {
+      const out = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const m of text.matchAll(/font-family\s*:\s*([^;}{]+)/gi)) {
+        const first = firstFamily(cap(m, 1));
+        if (first && !GENERIC_FONTS.has(first) && isOverusedFont(first) && !seen.has(first)) {
+          seen.add(first);
+          out.push({ id: "overused-font", snippet: `font-family: ${first}`, file, line: lineOf(text, m.index ?? 0) });
+        }
+      }
+      for (const m of text.matchAll(/fonts\.googleapis\.com\/css2?\?[^"'\s)<>]*/gi)) {
+        for (const fam of googleFontFamilies(cap(m, 0))) {
+          if (isOverusedFont(fam) && !seen.has(fam)) {
+            seen.add(fam);
+            out.push({ id: "overused-font", snippet: `Google Fonts: ${fam}`, file, line: lineOf(text, m.index ?? 0) });
+          }
+        }
+      }
+      return out;
+    }
+  },
+  // Single font across a substantial page — needs the whole page's font set.
+  // Counts only the FIRST family of each stack (like overused-font): fallbacks
+  // aren't choices, so `'Inter', 'Helvetica Neue'` everywhere is still one font.
+  {
+    scope: "page",
+    run: (text, file) => {
+      const fonts = /* @__PURE__ */ new Set();
+      for (const m of text.matchAll(/font-family\s*:\s*([^;}{]+)/gi)) {
+        const first = firstFamily(cap(m, 1));
+        if (first && !GENERIC_FONTS.has(first)) fonts.add(first);
+      }
+      for (const f of allGoogleFontFamilies(text)) fonts.add(f);
+      if (fonts.size !== 1 || text.split("\n").length < 20) return [];
+      const only = [...fonts][0] ?? "";
+      return [{ id: "single-font", snippet: `only font used across the page is ${only}`, file }];
+    }
+  },
+  // Flat type hierarchy (all sizes span <2×) — needs every size on the page.
+  {
+    scope: "page",
+    run: (text, file) => {
+      const sizes = /* @__PURE__ */ new Set();
+      const REM = 16;
+      for (const m of text.matchAll(/font-size\s*:\s*([\d.]+)(px|rem|em)\b/gi)) {
+        const px = cap(m, 2) === "px" ? num(m, 1) : num(m, 1) * REM;
+        if (px > 0 && px < 200) sizes.add(Math.round(px * 10) / 10);
+      }
+      for (const [cls, px] of Object.entries(TAILWIND_TEXT_PX)) {
+        if (new RegExp(`\\b${cls}\\b`).test(text)) sizes.add(px);
+      }
+      if (sizes.size < 3) return [];
+      const sorted = [...sizes].sort((a, b) => a - b);
+      const min = sorted[0] ?? 1;
+      const max = sorted[sorted.length - 1] ?? 1;
+      const ratio = max / min;
+      if (ratio >= 2) return [];
+      return [
+        {
+          id: "flat-type-hierarchy",
+          snippet: `sizes ${sorted.map((s) => `${s}px`).join(", ")} (ratio ${ratio.toFixed(1)}:1)`,
+          file
+        }
+      ];
+    }
+  },
+  // Monotonous spacing (one value dominates) — needs every spacing value.
+  {
+    scope: "page",
+    run: (text, file) => {
+      const rounded = collectSpacingPx(text).map((v) => Math.round(v / 4) * 4);
+      if (rounded.length < 10) return [];
+      const counts = {};
+      for (const v of rounded) counts[v] = (counts[v] || 0) + 1;
+      const maxCount = Math.max(...Object.values(counts));
+      const pct = maxCount / rounded.length;
+      const unique = [...new Set(rounded)].filter((v) => v > 0);
+      if (pct <= 0.6 || unique.length > 3) return [];
+      const dominant = Object.entries(counts).sort((a, b) => b[1] - a[1])[0]?.[0] ?? "?";
+      return [
+        {
+          id: "monotonous-spacing",
+          snippet: `~${dominant}px used ${maxCount}/${rounded.length} times (${Math.round(pct * 100)}%)`,
+          file
+        }
+      ];
+    }
+  },
+  // Em-dash overuse (density-gated) — density is measured over the page's copy.
+  {
+    scope: "page",
+    run: (text, file) => {
+      const body = stripHtmlToText(text).replace(/&mdash;|&#0*8212;|&#x0*2014;/gi, "\u2014");
+      const count = (body.match(/[—]|(?<!-)--(?!-)(?=\S)/g) ?? []).length;
+      if (count < EM_DASH_FLOOR) return [];
+      if (body.length > count * EM_DASH_CHARS_PER_DASH) return [];
+      return [{ id: "em-dash-overuse", snippet: `${count} em-dashes in body copy`, file }];
+    }
+  },
+  // The AI copy tells that are a shape, not a reading (engine/copy-tells):
+  // the ones that read the words are asked of the decision model in
+  // `copy-judgments.ts`. Page-scope: every gate here is a count threshold, and
+  // a landing is always split across small components, so measuring per file
+  // would dilute a page-wide habit into nothing.
+  {
+    scope: "page",
+    run: (text, file) => {
+      const body = stripHtmlPreservingHeadings(text);
+      const out = [];
+      for (const tell of structuralCopyTells(body)) {
+        const gate = COPY_TELL_GATES[tell.id];
+        if (!gate || tell.count < gate.minCount) continue;
+        out.push({ id: tell.id, snippet: `${tell.count}\xD7 \u2014 "${tell.sample}"`, file });
+      }
+      return out;
+    }
+  },
+  // Gradient text in authored CSS. A rule block spans lines, so this scans a
+  // ±6-line window around each `background-clip: text` instead of one line
+  // (the Tailwind class form stays a line matcher above).
+  {
+    scope: "file",
+    run: (text, file) => {
+      const out = [];
+      const lines = text.split("\n");
+      for (const m of text.matchAll(/(?:-webkit-)?background-clip\s*:\s*text/gi)) {
+        const line = lineOf(text, m.index ?? 0);
+        const window = lines.slice(Math.max(0, line - 7), Math.min(lines.length, line + 6)).join("\n");
+        const gradient = window.match(/(?:repeating-)?(?:linear|radial|conic)-gradient\((?:[^()]|\([^()]*\))*\)/i);
+        if (gradient) {
+          out.push({ id: "gradient-text", snippet: `background-clip: text + ${gradient[0]}`, file, line });
+        }
+      }
+      return out;
+    }
+  },
+  // Dark glow: a zero-offset chromatic shadow used as decoration. Line-attributed
+  // → per file.
+  {
+    scope: "file",
+    run: (text, file) => {
+      const out = [];
+      for (const m of text.matchAll(/(?:box|text)-shadow\s*:\s*([^;{}]+)/gi)) {
+        if (shadowIsGlow(cap(m, 1))) {
+          out.push({
+            id: "dark-glow",
+            snippet: `shadow: ${cap(m, 1).trim().slice(0, 60)}`,
+            file,
+            line: lineOf(text, m.index ?? 0)
+          });
+        }
+      }
+      return out;
+    }
+  },
+  // Marquee (<marquee> element). Fires at ≥1 → per file.
+  {
+    scope: "file",
+    run: (text, file) => /<marquee\b/i.test(text) ? [{ id: "marquee", snippet: "<marquee> element", file }] : []
+  }
+];
+function collectSpacingPx(text) {
+  const vals = [];
+  const push = (v) => {
+    if (v > 0 && v < 200) vals.push(v);
+  };
+  for (const m of text.matchAll(/(?:padding|margin)(?:-(?:top|right|bottom|left))?\s*:\s*(\d+)px/gi)) push(num(m, 1));
+  for (const m of text.matchAll(/(?:padding|margin)(?:-(?:top|right|bottom|left))?\s*:\s*([\d.]+)rem/gi))
+    push(Math.round(Number.parseFloat(cap(m, 1)) * 16));
+  for (const m of text.matchAll(/\b(?:p|px|py|pt|pb|pl|pr|m|mx|my|mt|mb|ml|mr|gap(?:-[xy])?|space-[xy])-([\d.]+)\b/g))
+    push(Number.parseFloat(cap(m, 1)) * 4);
+  return vals;
+}
+function shadowIsGlow(value) {
+  const first = (value.split(/,(?![^(]*\))/)[0] ?? "").trim();
+  const colorMatch = first.match(/#[0-9a-f]{3,8}\b|rgba?\([^)]+\)|hsla?\([^)]+\)/i);
+  if (!colorMatch) return false;
+  const lengthsPart = first.replace(colorMatch[0], " ").replace(/\binset\b/gi, " ");
+  const offsets = lengthsPart.match(/-?\d*\.?\d+(?:px|rem|em)?/g);
+  if (!offsets || offsets.length < 3) return false;
+  const x = Number.parseFloat(offsets[0] ?? "0");
+  const y = Number.parseFloat(offsets[1] ?? "0");
+  const blur = Number.parseFloat(offsets[2] ?? "0");
+  if (!(x === 0 && y === 0 && blur > 4)) return false;
+  const c = parseColor(colorMatch[0]);
+  return c !== null && hasChroma(c, 30);
+}
+function firstFamily(decl) {
+  return (decl.split(",")[0] ?? "").trim().replace(/^['"]|['"]$/g, "").toLowerCase();
+}
+function googleFontFamilies(url) {
+  const q = url.indexOf("?");
+  if (q === -1) return [];
+  const params = new URLSearchParams(url.slice(q + 1).replace(/&amp;/g, "&"));
+  const out = [];
+  for (const value of params.getAll("family")) {
+    for (const part of value.split("|")) out.push((part.split(":")[0] ?? "").trim().toLowerCase());
+  }
+  return out.filter(Boolean);
+}
+function allGoogleFontFamilies(text) {
+  const out = [];
+  for (const m of text.matchAll(/fonts\.googleapis\.com\/css2?\?[^"'\s)<>]*/gi))
+    out.push(...googleFontFamilies(cap(m, 0)));
+  return out;
+}
+function lineOf(text, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < text.length; i++) if (text[i] === "\n") line++;
+  return line;
+}
+function tableRanges(text) {
+  const out = [];
+  for (const m of text.matchAll(/<table\b[\s\S]*?<\/table>/gi)) {
+    const start = m.index ?? 0;
+    out.push([start, start + m[0].length]);
+  }
+  return out;
+}
+function distinctCompetitorNames(competitors) {
+  const byFold = /* @__PURE__ */ new Map();
+  for (const raw of competitors) {
+    if (typeof raw !== "string") continue;
+    const name = raw.trim();
+    if (name.length < 4) continue;
+    const key = foldForCopy(name);
+    if (!byFold.has(key) || new RegExp("\\p{Lu}", "u").test(name)) byFold.set(key, name);
+  }
+  return [...byFold.values()];
+}
+var INLINE_TAGS = /^<\/?(?:a|abbr|b|bdi|bdo|cite|code|data|dfn|em|i|kbd|mark|q|s|samp|small|span|strong|sub|sup|time|u|var|wbr)\b/i;
+function visibleCopyKeepingOffsets(text) {
+  const out = text.split("");
+  const pattern = /<script\b[^>]*>[\s\S]*?<\/script>|<style\b[^>]*>[\s\S]*?<\/style>|<!--[\s\S]*?-->|<[^>]+>/gi;
+  for (const m of text.matchAll(pattern)) {
+    const start = m.index ?? 0;
+    for (let i = start; i < start + m[0].length && i < out.length; i++) {
+      if (out[i] !== "\n") out[i] = " ";
+    }
+    if (!INLINE_TAGS.test(m[0])) out[start] = "\n";
+  }
+  return out.join("");
+}
+function landingCopy(sources, competitors = []) {
+  const names = distinctCompetitorNames(competitors).map((name) => ({
+    name,
+    pattern: new RegExp(`(?<![\\p{L}\\p{N}])${escapeRegExp(name)}(?![\\p{L}\\p{N}])`, "iu")
+  }));
+  const sentences = sources.flatMap(sourceSentences);
+  const mentions = sentences.flatMap(
+    (s) => s.inTable ? [] : names.filter(({ pattern }) => pattern.test(s.text)).map(({ name }) => ({ file: s.file, line: s.line, sentence: s.text, competitor: name }))
+  );
+  return { sentences, mentions };
+}
+function sourceSentences(source) {
+  const text = blankUnrenderedSource(source.text);
+  const tables = tableRanges(text);
+  return copySentences(visibleCopyKeepingOffsets(text)).map((s) => ({
+    file: source.path,
+    line: lineOf(text, s.start),
+    text: s.text,
+    ...s.before ? { before: s.before } : {},
+    inTable: tables.some(([from, to]) => s.start >= from && s.start < to)
+  }));
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function detectSource(source) {
+  const file = source.path;
+  const text = blankUnrenderedSource(source.text);
+  const findings = [];
+  const lines = text.split("\n");
+  for (const matcher of LINE_MATCHERS) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i] ?? "";
+      for (const m of line.matchAll(matcher.regex)) {
+        if (matcher.test(m, line)) findings.push({ id: matcher.id, snippet: matcher.fmt(m, line), file, line: i + 1 });
+      }
+    }
+  }
+  for (const analyzer of ANALYZERS) {
+    if (analyzer.scope === "file") findings.push(...analyzer.run(text, file));
+  }
+  return dedupe(findings);
+}
+function detectPage(sources) {
+  if (sources.length === 0) return [];
+  const combined = sources.map((s) => blankUnrenderedSource(s.text)).join("\n");
+  const pageFile2 = sources.find((s) => s.path === "index.astro" || s.path.endsWith("/index.astro"))?.path ?? sources[0]?.path ?? "index.astro";
+  const findings = [];
+  for (const analyzer of ANALYZERS) {
+    if (analyzer.scope === "page") findings.push(...analyzer.run(combined, pageFile2));
+  }
+  return dedupe(findings);
+}
+function dedupe(findings) {
+  const out = [];
+  for (const f of findings) {
+    const dupe = out.some(
+      (d) => d.id === f.id && d.snippet === f.snippet && Math.abs((d.line ?? 0) - (f.line ?? 0)) <= 2
+    );
+    if (!dupe) out.push(f);
+  }
+  return out;
+}
+
+// src/engine/landing/lib/copy-judgments.ts
+var PAGE_CHARS = 6e4;
+var SNIPPET_CHARS = 70;
+var PER_SENTENCE = ["buzzword", "autonomy", ...TELL_QUESTIONS.map((t) => t.id)];
+function questionsFor(sentence) {
+  return [
+    sentenceQuestion(BUZZWORD_QUESTION, sentence.text),
+    sentenceQuestion(AUTONOMY_QUESTION, sentence.text),
+    ...tellQuestionsFor({ text: sentence.text, ...sentence.before ? { before: sentence.before } : {} })
+  ];
+}
+var snippet = (text) => `"${text.slice(0, SNIPPET_CHARS)}"`;
+function pageFile(sources) {
+  return sources.find((s) => s.path === "index.astro" || s.path.endsWith("/index.astro"))?.path ?? sources[0]?.path ?? "index.astro";
+}
+function sentenceFindings(sentences, said) {
+  return [...new Set(sentences.map((s) => s.file))].flatMap((file) => {
+    const buzz = sentences.filter((s) => s.file === file && !s.inTable && said(s, "buzzword", BUZZWORD_HELD));
+    const first = buzz[0];
+    if (!first) return [];
+    return [
+      {
+        id: "marketing-buzzword",
+        snippet: `${buzz.length} buzzword sentence${buzz.length === 1 ? "" : "s"}: ${snippet(first.text)}`,
+        file,
+        line: first.line
+      }
+    ];
+  });
+}
+function pageFindings(sentences, said, controlled, file) {
+  const out = [];
+  const claim = sentences.find((s) => said(s, "autonomy", AUTONOMY_HELD));
+  if (claim && !controlled) {
+    out.push({
+      id: "agent-washing",
+      snippet: `${snippet(claim.text)} with no control or oversight signal on the page`,
+      file
+    });
+  }
+  for (const tell of TELL_QUESTIONS) {
+    const hits = sentences.filter((s) => !s.inTable && said(s, tell.id, tell.threshold));
+    const gate = COPY_TELL_GATES[tell.id];
+    if (!gate || hits.length < gate.minCount) continue;
+    out.push({ id: tell.id, snippet: `${hits.length}\xD7 \u2014 ${snippet(hits[0]?.text ?? "")}`, file });
+  }
+  return out;
+}
+async function judgeLandingCopy(input, ask) {
+  const { sentences, mentions } = landingCopy(input.sources, input.competitors ?? []);
+  if (sentences.length === 0) return { findings: [], judged: true };
+  const keyOf = (s) => `${s.before ?? ""}\0${s.text}`;
+  const distinct = [...new Map(sentences.map((s) => [keyOf(s), s])).values()];
+  const page = [...new Set(sentences.map((s) => s.text))].join("\n").slice(0, PAGE_CHARS);
+  const answers = await ask([
+    ...distinct.flatMap(questionsFor),
+    ...mentions.map((m) => sentenceQuestion(comparisonQuestion(m.competitor), m.sentence)),
+    pageQuestion(CONTROL_QUESTION, page)
+  ]);
+  if (answers === null) return { findings: [], judged: false };
+  const answerOf = new Map(
+    distinct.map((s, i) => [
+      keyOf(s),
+      Object.fromEntries(PER_SENTENCE.map((id, q) => [id, answers[i * PER_SENTENCE.length + q] ?? 0]))
+    ])
+  );
+  const said = (s, id, held) => (answerOf.get(keyOf(s))?.[id] ?? 0) >= held;
+  const comparedAt = distinct.length * PER_SENTENCE.length;
+  const comparisons = mentions.filter((_, i) => (answers[comparedAt + i] ?? 0) >= COMPARISON_HELD).map((m) => ({
+    id: "competitor-named-in-comparison",
+    snippet: `${snippet(m.sentence)} names ${m.competitor}`,
+    file: m.file,
+    line: m.line
+  }));
+  const controlled = (answers[comparedAt + mentions.length] ?? 0) >= CONTROL_HELD;
+  return {
+    findings: dedupe([
+      ...sentenceFindings(sentences, said),
+      ...comparisons,
+      ...pageFindings(sentences, said, controlled, pageFile(input.sources))
+    ]),
+    judged: true
+  };
+}
+
+// src/engine/landing/lib/critique.ts
+var FAMILIES = ["typography", "color", "borders_depth", "motion", "spacing", "copy", "integrity"];
+function round(n) {
+  return Math.round(n * 100) / 100;
+}
+function clamp01(n) {
+  return Math.max(0, Math.min(1, n));
+}
+function applyBrand(id, snippet2, severity, brand) {
+  const meta = RULE_META[id];
+  if (!meta?.brandAware || !brand.hasTokens) return { severity, brandDrift: false };
+  const matched = meta.brandAware === "font" && brandCommitsFont(brand, snippet2) || meta.brandAware === "color" && id === "ai-color-palette" && brandCommitsAiHue(brand) || meta.brandAware === "color" && id === "cream-palette" && brandCommitsCream(brand) || meta.brandAware === "gradient" && brandCommitsGradient(brand, snippet2);
+  return matched ? { severity: "advisory", brandDrift: true } : { severity, brandDrift: false };
+}
+async function critiqueLanding(input) {
+  const sources = Array.isArray(input.sources) ? input.sources : [];
+  const findings = [];
+  const raws = [];
+  for (const source of sources) raws.push(...detectSource(source));
+  raws.push(...detectPage(sources));
+  const copy = input.ask ? await judgeLandingCopy({ sources, competitors: input.competitors ?? [] }, input.ask) : { findings: [], judged: false };
+  raws.push(...copy.findings);
+  for (const raw of raws) {
+    const meta = RULE_META[raw.id];
+    if (!meta) continue;
+    const { severity, brandDrift } = applyBrand(raw.id, raw.snippet, meta.severity, input.brand);
+    findings.push({
+      id: raw.id,
+      severity,
+      family: meta.family,
+      snippet: raw.snippet,
+      file: raw.file,
+      line: raw.line,
+      note: meta.note,
+      ...brandDrift ? { brandDrift: true } : {}
+    });
+  }
+  const dimensions = FAMILIES.map((family) => {
+    const fam = findings.filter((f) => f.family === family);
+    const penalty = fam.reduce((s, f) => s + SEVERITY_WEIGHT[f.severity], 0);
+    const score = round(clamp01(1 - penalty));
+    const note = fam.length === 0 ? "clean" : `${fam.length} finding(s): ${describeCounts(fam)}`;
+    return { dimension: family, score, note };
+  });
+  const overall = round(dimensions.reduce((s, d) => s + d.score, 0) / dimensions.length);
+  const counts = {
+    block: findings.filter((f) => f.severity === "block").length,
+    warn: findings.filter((f) => f.severity === "warn").length,
+    advisory: findings.filter((f) => f.severity === "advisory").length
+  };
+  return { advisory: true, overall, dimensions, findings, counts, copyChecked: copy.judged };
+}
+function describeCounts(findings) {
+  const b = findings.filter((f) => f.severity === "block").length;
+  const w = findings.filter((f) => f.severity === "warn").length;
+  const a = findings.filter((f) => f.severity === "advisory").length;
+  return [b ? `${b} block` : "", w ? `${w} warn` : "", a ? `${a} advisory` : ""].filter(Boolean).join(", ");
+}
+
+// src/commands/landing/snapshot.ts
+import { mkdir, rename, writeFile } from "fs/promises";
+import path from "path";
+var CRITIC_VERSION = "6";
+function critiqueCacheDir(projectRoot) {
+  return path.join(projectRoot, ".cache", "landing-critique");
+}
+function snapshotPath(projectRoot, slug) {
+  return path.join(critiqueCacheDir(projectRoot), `${slug}.json`);
+}
+async function writeCritiqueSnapshot(projectRoot, snapshot) {
+  await mkdir(critiqueCacheDir(projectRoot), { recursive: true });
+  const dest = snapshotPath(projectRoot, snapshot.slug);
+  const tmp = `${dest}.tmp`;
+  await writeFile(tmp, `${JSON.stringify(snapshot, null, 2)}
+`, "utf8");
+  await rename(tmp, dest);
+}
+
+// src/commands/landing/source-version.ts
+import { readdir, readFile, stat } from "fs/promises";
+import path2 from "path";
+var CRITIQUED_ROOTS = ["src/pages/", "src/components/"];
+async function landingSourceRelPaths(root, slug) {
+  const files = await landingGraphFiles(root, slug);
+  return [...files].filter((rel) => rel.endsWith(".astro") && CRITIQUED_ROOTS.some((r) => rel.startsWith(r))).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+async function readLandingSources(root, slug) {
+  const rel = await landingSourceRelPaths(root, slug);
+  const out = [];
+  for (const r of rel) out.push({ path: r, text: await readFile(path2.join(root, r), "utf8") });
+  return out;
+}
+async function computeLandingSourceSha(root, slug) {
+  const rel = await landingSourceRelPaths(root, slug);
+  const parts = [];
+  for (const r of rel) {
+    let bytes;
+    try {
+      bytes = await readFile(path2.join(root, r));
+    } catch {
+      bytes = Buffer.alloc(0);
+    }
+    parts.push(Buffer.from(`${r}\0${bytes.length}\0`), bytes);
+  }
+  return sha256Hex(Buffer.concat(parts));
+}
+async function computeLegacyLandingSourceSha(landingDir) {
+  const rel = [];
+  if (await isFile(path2.join(landingDir, "index.astro"))) rel.push("index.astro");
+  for (const abs of await walkAstro(path2.join(landingDir, "_components"))) {
+    rel.push(path2.relative(landingDir, abs).split(path2.sep).join("/"));
+  }
+  rel.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const parts = [];
+  for (const r of rel) {
+    let bytes;
+    try {
+      bytes = await readFile(path2.join(landingDir, r));
+    } catch {
+      bytes = Buffer.alloc(0);
+    }
+    parts.push(Buffer.from(`${r}\0${bytes.length}\0`), bytes);
+  }
+  return sha256Hex(Buffer.concat(parts));
+}
+async function isFile(p) {
+  try {
+    return (await stat(p)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function walkAstro(dir) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const entry of entries) {
+    const abs = path2.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...await walkAstro(abs));
+    else if (entry.isFile() && entry.name.endsWith(".astro")) out.push(abs);
+  }
+  return out;
+}
+
+// src/commands/landing/critique.ts
+registerSchema({
+  command: "landing.critique",
+  description: "Start here: `baker landing critique my-landing` after building or editing a landing. Design-quality critic (ADVISORY \u2014 findings never fail it). Flags the known AI 'slop' tells (gradient text, overused fonts, side-tab borders, cream palettes, broken images\u2026) in code, and reads the copy in any language for buzzwords, AI copy tells and a rival named in a comparison, tiered block/warn/advisory, and records the critique the publish quality gate requires.",
+  args: {
+    slug: {
+      type: "string",
+      description: "Landing slug (folder under src/pages/). Pass several, space-separated, to critique them in one call.",
+      required: true
+    },
+    full: {
+      type: "boolean",
+      description: "Also print advisory-tier findings (default: block + warn only)",
+      required: false
+    }
+  }
+});
+var SLUG_RE = /^[a-z0-9][a-z0-9._-]*$/i;
+function parseCritiqueSlugs(args) {
+  const rest = Array.isArray(args._) ? args._ : [];
+  const all = [args.slug, ...rest].filter((s) => typeof s === "string" && s.length > 0);
+  return [...new Set(all.map(String))];
+}
+function fail(code, message, fix) {
+  process.stderr.write(
+    `${JSON.stringify({ ok: false, error: { code, message, ...fix ? { fix } : {} } }, null, 2)}
+`
+  );
+  process.exit(2);
+}
+var critiqueCommand = defineCommand({
+  meta: {
+    name: "critique",
+    description: "Start here: `baker landing critique <slug>` after building or editing a landing. Design-quality critic (ADVISORY \u2014 findings never fail it). Flags the known AI design tells (gradient text, overused fonts, side-tab borders, cream palettes, broken images) and reads the copy in any language for buzzwords, AI copy tells and a rival named in a comparison, tiered block/warn/advisory, respecting the client's brand as the allowlist. Also records the critique that publishing requires \u2014 run it before finishing a landing."
+  },
+  args: {
+    slug: {
+      type: "positional",
+      required: true,
+      description: "Landing slug (folder under src/pages/). Space-separate several to critique them in one call."
+    },
+    full: { type: "boolean", description: "Also print advisory-tier findings", default: false }
+  },
+  async run({ args }) {
+    const slugs = parseCritiqueSlugs(args);
+    const projectRoot = process.cwd();
+    for (const slug of slugs) {
+      if (!SLUG_RE.test(slug) || slug.includes("..")) {
+        fail(
+          "INVALID_SLUG",
+          `"${slug}" is not a landing slug \u2014 use the folder name directly under src/pages/ (letters, digits, dashes; not a path, not a _-private folder).`,
+          { availableSlugs: await listLandingSlugs(projectRoot) }
+        );
+      }
+      if (!await isDir(path3.resolve(projectRoot, "src", "pages", slug))) {
+        fail("NOT_FOUND", `No landing at src/pages/${slug}/`, {
+          availableSlugs: await listLandingSlugs(projectRoot)
+        });
+      }
+    }
+    const spent = [];
+    const onSpend = (u) => spent.push(u);
+    const brand = await loadBrandTokens(projectRoot, { onSpend });
+    const competitors = await readCompetitorNames(projectRoot);
+    const ask = rememberedJev(path3.join(critiqueCacheDir(projectRoot), ".copy-answers.json"), onSpend);
+    const results = await Promise.all(slugs.map((slug) => critiqueOne(projectRoot, slug, brand, competitors, ask)));
+    await holdUnbilledSpend(path3.join(projectRoot, "canvas", ".cache"), spent).catch(() => void 0);
+    const landings = results.map(({ slug, report }) => ({
+      slug,
+      overall: report.overall,
+      copyChecked: report.copyChecked,
+      counts: report.counts,
+      dimensions: report.dimensions,
+      findings: report.findings.filter((f) => args.full ? true : f.severity !== "advisory").map(present)
+    }));
+    const blocked = results.filter((r) => r.report.counts.block > 0).map((r) => r.slug);
+    const snapshotFailures = results.filter((r) => r.snapshotFailed).map((r) => r.slug);
+    const copyUnchecked = results.filter((r) => !r.report.copyChecked).map((r) => r.slug);
+    const hints = [
+      blocked.length > 0 ? `Block-tier tells are held at publish \u2014 fix them (${blocked.join(", ")}). Warn/advisory are guidance. Scores are 0\u20131 (higher is better).` : copyUnchecked.length > 0 ? "No block-tier tells in what was checked." : "No block-tier tells. Warn/advisory findings are guidance, not gates. Re-run after edits so the publish gate stays fresh.",
+      ...copyUnchecked.length > 0 ? [
+        `The copy of ${copyUnchecked.join(", ")} could not be checked just now (rivals named, buzzwords and AI copy tells are unchecked, so none is reported), and this critique was not recorded for publishing. Run \`baker landing critique ${copyUnchecked.join(" ")}\` again before publishing.`
+      ] : [],
+      ...snapshotFailures.length > 0 ? [
+        `Could not record the critique snapshot for ${snapshotFailures.join(", ")} (.cache/ not writable?) \u2014 the publish quality gate will still report ${snapshotFailures.length === 1 ? "this landing" : "these landings"} as un-critiqued.`
+      ] : []
+    ];
+    const single = landings.length === 1 ? landings[0] : null;
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          ok: true,
+          data: { advisory: true, ...single ?? {}, landings },
+          hints
+        },
+        null,
+        2
+      )}
+`
+    );
+  }
+});
+async function critiqueOne(projectRoot, slug, brand, competitors, ask) {
+  const [sources, compositionSha, sourceSha] = await Promise.all([
+    readLandingSources(projectRoot, slug),
+    computeLandingSourceSha(projectRoot, slug),
+    computeLegacyLandingSourceSha(path3.resolve(projectRoot, "src", "pages", slug))
+  ]);
+  const report = await critiqueLanding({ slug, sources, brand, competitors, ask });
+  if (!report.copyChecked) return { slug, report, snapshotFailed: false };
+  let snapshotFailed = false;
+  try {
+    await writeCritiqueSnapshot(projectRoot, {
+      slug,
+      compositionSha,
+      sourceSha,
+      criticVersion: CRITIC_VERSION,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      blockCount: report.counts.block,
+      warnCount: report.counts.warn
+    });
+  } catch {
+    snapshotFailed = true;
+  }
+  return { slug, report, snapshotFailed };
+}
+async function readCompetitorNames(projectRoot) {
+  const dir = path3.join(projectRoot, "src", "content", "competitors");
+  let entries;
+  try {
+    entries = (await readdir2(dir)).filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+  const names = [];
+  for (const entry of entries) {
+    names.push(path3.basename(entry, ".md").replace(/[-_]+/g, " "));
+    try {
+      const head = (await readFile2(path3.join(dir, entry), "utf8")).slice(0, 2e3);
+      const titled = /^\s*(?:title|name)\s*:\s*["']?([^"'\n]+)["']?\s*$/im.exec(head);
+      if (titled?.[1]) names.push(titled[1].trim());
+    } catch {
+    }
+  }
+  return names;
+}
+async function listLandingSlugs(projectRoot) {
+  try {
+    const entries = await readdir2(path3.join(projectRoot, "src", "pages"), { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith(".")).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+}
+function present(f) {
+  return {
+    id: f.id,
+    severity: f.severity,
+    family: f.family,
+    where: f.line ? `${f.file}:${f.line}` : f.file,
+    snippet: f.snippet,
+    note: f.note,
+    ...f.brandDrift ? { brandDrift: true } : {}
+  };
+}
+async function isDir(p) {
+  try {
+    return (await stat2(p)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+export {
+  critiqueCommand,
+  critiqueOne,
+  parseCritiqueSlugs
+};
+//# sourceMappingURL=critique-62QFBC33.js.map