@tryvitris/website-harness 0.0.0-stage → 0.1.0-beta.6

package/bin/chunks/chunk-Z2UNY47A.js

@@ -0,0 +1,2418 @@
+import {
+  assetsOrigin,
+  publicAssetUrl,
+  putLocalR2,
+  putRemoteR2,
+  writeScratchFile
+} from "./chunk-XGTHGWPW.js";
+import {
+  assembleHarvestInventory,
+  capturedPathSet,
+  classifyMiss,
+  colorsFromComputedActions,
+  formatExclusion,
+  isErrorPage,
+  isPlaywrightLaunchFailure
+} from "./chunk-3CTBXY5K.js";
+import {
+  json,
+  save
+} from "./chunk-T6PE4KN4.js";
+
+// scripts/onboard/prompt.ts
+import * as readline from "node:readline/promises";
+
+// src/onboard/social.ts
+var PLATFORM_RE = [
+  { platform: "facebook", re: /(?:facebook\.com|fb\.com|fb\.me)\//i },
+  { platform: "instagram", re: /instagram\.com\//i },
+  { platform: "yelp", re: /yelp\.com\//i },
+  {
+    platform: "google",
+    re: /(?:maps\.app\.goo\.gl|goo\.gl\/maps|google\.com\/maps|business\.google\.com|g\.page)\//i
+  },
+  { platform: "tiktok", re: /tiktok\.com\/@/i },
+  { platform: "linkedin", re: /linkedin\.com\/(company|in)\//i },
+  { platform: "youtube", re: /(?:youtube\.com\/(channel|c|@|user)|youtu\.be)\//i },
+  { platform: "twitter", re: /(?:twitter\.com|x\.com)\//i }
+];
+function walkJsonLd(nodes) {
+  const flat = [];
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    const obj = node;
+    flat.push(obj);
+    if (obj["@graph"] && Array.isArray(obj["@graph"])) obj["@graph"].forEach(visit);
+  };
+  nodes.forEach(visit);
+  return flat;
+}
+function platformForUrl(url) {
+  for (const { platform, re } of PLATFORM_RE) {
+    if (re.test(url)) return platform;
+  }
+  return null;
+}
+function collectSocialLinks(opts) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (url, label) => {
+    const platform = platformForUrl(url);
+    if (!platform) return;
+    const key = url.replace(/\/+$/, "").toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push({ platform, url, label });
+  };
+  for (const link of opts.links) {
+    push(link.href, link.label || void 0);
+  }
+  for (const obj of walkJsonLd(opts.jsonLd)) {
+    const sameAs = obj.sameAs;
+    if (typeof sameAs === "string") push(sameAs);
+    else if (Array.isArray(sameAs)) {
+      for (const item of sameAs) {
+        if (typeof item === "string") push(item);
+      }
+    }
+  }
+  return out;
+}
+
+// src/onboard/extract.ts
+var SKIP_PATH = /\/(wp-admin|wp-login|cart|checkout|account|login|signup|register|cgi-bin|xmlrpc)(\/|$)/i;
+var SKIP_EXT = /\.(pdf|zip|docx?|xlsx?|pptx?|mp4|webm|mp3|ics)(\?|$)/i;
+var LOOP_QUERY = /^(page|paged|offset|start|utm_|fbclid|gclid|msclkid|mc_|ref|sort|order|filter|color|size|min|max|date|month|year|day|session|sid)/i;
+function shouldSkipPath(pathname) {
+  if (SKIP_PATH.test(pathname)) return true;
+  if (SKIP_EXT.test(pathname)) return true;
+  return false;
+}
+function shouldSkipQueryUrl(href) {
+  try {
+    const u = new URL(href);
+    if (![...u.searchParams.keys()].length) return false;
+    if ([...u.searchParams.keys()].length > 4) return true;
+    for (const key of u.searchParams.keys()) {
+      if (LOOP_QUERY.test(key)) return true;
+    }
+    return false;
+  } catch {
+    return true;
+  }
+}
+function stripNoise(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<noscript[\s\S]*?<\/noscript>/gi, " ").replace(/<!--[\s\S]*?-->/g, " ");
+}
+function decodeEntities(text) {
+  return text.replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;/g, "'").replace(/&#(\d+);/g, (_m, n) => String.fromCharCode(Number(n))).replace(/\s+/g, " ").trim();
+}
+function meta(html, name) {
+  const re = new RegExp(
+    `<meta[^>]+(?:name|property)=["']${name}["'][^>]+content=["']([^"']*)["']`,
+    "i"
+  );
+  const re2 = new RegExp(
+    `<meta[^>]+content=["']([^"']*)["'][^>]+(?:name|property)=["']${name}["']`,
+    "i"
+  );
+  return decodeEntities((html.match(re) || html.match(re2))?.[1] || "");
+}
+function tags(html, tag) {
+  const re = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)</${tag}>`, "gi");
+  const out = [];
+  for (const m of html.matchAll(re)) {
+    const text = decodeEntities(m[1].replace(/<[^>]+>/g, " "));
+    if (text) out.push(text);
+  }
+  return out;
+}
+function absolutize(href, base) {
+  try {
+    href = decodeEntities(href).trim().replace(/^["']+|["']+$/g, "");
+    const nested = href.match(/https?:\/\/[^\s"'<>]+/);
+    if (nested && href.indexOf(nested[0]) > 0) href = nested[0];
+    else if (/["']/.test(href)) href = href.split(/["']/)[0].trim();
+    href = href.replace(/&quot;|&#34;|&#39;/gi, "").trim();
+    if (!href) return null;
+    const u = new URL(href, base);
+    if (u.protocol !== "http:" && u.protocol !== "https:") return null;
+    u.hash = "";
+    return u.href;
+  } catch {
+    return null;
+  }
+}
+function documentBase(html, pageUrl) {
+  const m = html.match(/<base\b[^>]*href=["']([^"']+)["']/i);
+  if (!m) return pageUrl;
+  return absolutize(m[1], pageUrl) || pageUrl;
+}
+function isPathRelativeHref(href) {
+  const h = href.trim();
+  if (!h || h.startsWith("#") || h.startsWith("?") || h.startsWith("mailto:") || h.startsWith("tel:")) return false;
+  if (/^[a-z][a-z0-9+.-]*:/i.test(h)) return false;
+  if (h.startsWith("//") || h.startsWith("/")) return false;
+  return true;
+}
+function sameSite(a, b) {
+  try {
+    const ha = new URL(a).hostname.replace(/^www\./i, "").toLowerCase();
+    const hb = new URL(b).hostname.replace(/^www\./i, "").toLowerCase();
+    return ha === hb && ha.length > 0;
+  } catch {
+    return false;
+  }
+}
+function isLikelyTrackingImage(img) {
+  if (/sprite|pixel|tracking|1x1|favicon|logo-schema|emoji|gravatar|doubleclick|facebook\.com\/tr/i.test(img.src)) {
+    return true;
+  }
+  if (img.width && img.height && img.width < 64 && img.height < 64 && !img.fromJsonLdLogo && !img.inChrome) {
+    return true;
+  }
+  return false;
+}
+function dim(tag, name) {
+  const m = tag.match(new RegExp(`${name}=["']?(\\d+)`, "i"));
+  if (!m) return void 0;
+  const n = Number(m[1]);
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+function fromSrcset(srcset, pageUrl) {
+  const parts = srcset.split(",").map((s) => s.trim().split(/\s+/)[0]).filter((p) => Boolean(p));
+  const last = parts.at(-1);
+  return last ? absolutize(last, pageUrl) : null;
+}
+function allFromSrcset(srcset, pageUrl) {
+  return srcset.split(",").map((s) => s.trim().split(/\s+/)[0]).filter((p) => Boolean(p)).map((p) => absolutize(p, pageUrl)).filter((u) => Boolean(u));
+}
+function classifyHref(href, origin) {
+  if (href.startsWith("tel:")) return "tel";
+  if (href.startsWith("mailto:")) return "mailto";
+  try {
+    const u = new URL(href);
+    if (u.origin === origin) return "internal";
+    return "external";
+  } catch {
+    return "other";
+  }
+}
+var CTA_WORDS = /\b(book|schedule|appoint|call|contact|get a quote|request|order|reserve|sign up|get started|free estimate)\b/i;
+function extractPhones(text) {
+  const fromTel = [...text.matchAll(/tel:(\+?[\d().\s-]{7,})/gi)].map(
+    (m) => m[1].replace(/\s+/g, " ").trim()
+  );
+  const fromCopy = [...text.matchAll(/\+?1?[\s.-]?\(?\d{3}\)?[\s.-]\d{3}[\s.-]\d{4}/g)].map(
+    (m) => m[0].trim()
+  );
+  return [.../* @__PURE__ */ new Set([...fromTel, ...fromCopy])];
+}
+function extractEmails(text) {
+  const fromMailto = [...text.matchAll(/mailto:([^\s"'?>]+)/gi)].map(
+    (m) => decodeURIComponent(m[1].split("?")[0]).toLowerCase()
+  );
+  const fromCopy = [...text.matchAll(/[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}/gi)].map(
+    (m) => m[0].toLowerCase()
+  );
+  return [.../* @__PURE__ */ new Set([...fromMailto, ...fromCopy])].filter((e) => !e.endsWith(".png") && !e.endsWith(".jpg"));
+}
+function parseJsonLd(html) {
+  const blocks = [...html.matchAll(/<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi)];
+  const out = [];
+  for (const block of blocks) {
+    try {
+      const parsed = JSON.parse(block[1].trim());
+      if (Array.isArray(parsed)) out.push(...parsed);
+      else out.push(parsed);
+    } catch {
+    }
+  }
+  return out;
+}
+function walkJsonLd2(nodes) {
+  const flat = [];
+  const visit = (node) => {
+    if (!node || typeof node !== "object") return;
+    const obj = node;
+    flat.push(obj);
+    if (obj["@graph"] && Array.isArray(obj["@graph"])) obj["@graph"].forEach(visit);
+  };
+  nodes.forEach(visit);
+  return flat;
+}
+function businessFromJsonLd(nodes) {
+  const types = walkJsonLd2(nodes);
+  const biz = types.find((n) => {
+    const t = n["@type"];
+    const s = Array.isArray(t) ? t.join(" ") : String(t || "");
+    return /LocalBusiness|Organization|Restaurant|Store|Dentist|Physician|Attorney/i.test(s);
+  });
+  if (!biz) return {};
+  const addr = biz.address;
+  let address = "";
+  if (typeof addr === "string") address = addr;
+  else if (addr && typeof addr === "object") {
+    const a = addr;
+    address = [a.streetAddress, a.addressLocality, a.addressRegion, a.postalCode].filter(Boolean).map(String).join(", ");
+  }
+  const hours = biz.openingHours;
+  const specHours = hoursFromSpec(biz.openingHoursSpecification);
+  const listed = Array.isArray(hours) ? hours.map(String) : typeof hours === "string" ? [hours] : [];
+  let city = "";
+  if (addr && typeof addr === "object") {
+    const locality = addr.addressLocality;
+    if (typeof locality === "string") city = locality;
+  }
+  const phone = Array.isArray(biz.telephone) ? String(biz.telephone[0] || "") : typeof biz.telephone === "string" ? biz.telephone : void 0;
+  let logoUrl;
+  const logo = biz.logo;
+  if (typeof logo === "string") logoUrl = logo;
+  else if (logo && typeof logo === "object") {
+    const url = logo.url;
+    if (typeof url === "string") logoUrl = url;
+  }
+  return {
+    name: typeof biz.name === "string" ? biz.name : void 0,
+    phone: phone || void 0,
+    email: typeof biz.email === "string" ? biz.email : void 0,
+    address: address || void 0,
+    city: city || void 0,
+    hours: specHours.length ? specHours : listed.length ? listed : void 0,
+    url: typeof biz.url === "string" ? biz.url : void 0,
+    logoUrl
+  };
+}
+function hoursFromSpec(spec) {
+  if (!spec) return [];
+  const items = Array.isArray(spec) ? spec : [spec];
+  const out = [];
+  for (const item of items) {
+    if (!item || typeof item !== "object") continue;
+    const o = item;
+    const rawDays = o.dayOfWeek;
+    const day = Array.isArray(rawDays) ? rawDays.map((d) => String(d).replace(/^https?:\/\/schema\.org\//, "")).join(", ") : String(rawDays || "").replace(/^https?:\/\/schema\.org\//, "");
+    const opens = o.opens;
+    const closes = o.closes;
+    if (day && opens && closes) out.push(`${day}: ${opens}\u2013${closes}`);
+  }
+  return out;
+}
+function jsonLdServices(nodes) {
+  const out = [];
+  for (const obj of walkJsonLd2(nodes)) {
+    const t = obj["@type"];
+    const type = Array.isArray(t) ? t.join(" ") : String(t || "");
+    if (!/Service|Offer/i.test(type)) continue;
+    const name = typeof obj.name === "string" ? obj.name.trim() : "";
+    if (!name) continue;
+    const blurb = typeof obj.description === "string" && obj.description.trim() || typeof obj.price === "string" && obj.price || "";
+    out.push({ name, blurb: String(blurb).slice(0, 180) });
+  }
+  return out;
+}
+function extractLists(html) {
+  const out = [];
+  for (const m of html.matchAll(/<(ul|ol)\b[^>]*>([\s\S]*?)<\/\1>/gi)) {
+    const items = [...m[2].matchAll(/<li\b[^>]*>([\s\S]*?)<\/li>/gi)].map(
+      (li) => decodeEntities(li[1].replace(/<[^>]+>/g, " "))
+    );
+    const joined = items.filter(Boolean).join(" \xB7 ");
+    if (joined) out.push(joined);
+  }
+  return out;
+}
+function extractTestimonials(html) {
+  const out = [];
+  for (const m of html.matchAll(/<blockquote\b[^>]*>([\s\S]*?)<\/blockquote>/gi)) {
+    const inner = m[1];
+    const cite = inner.match(/<cite\b[^>]*>([\s\S]*?)<\/cite>/i)?.[1];
+    const footer = inner.match(/<footer\b[^>]*>([\s\S]*?)<\/footer>/i)?.[1];
+    const quote = decodeEntities(inner.replace(/<(cite|footer)[\s\S]*?<\/\1>/gi, " ").replace(/<[^>]+>/g, " "));
+    if (!quote || quote.length < 20) continue;
+    const attribution = decodeEntities((cite || footer || "").replace(/<[^>]+>/g, " ")) || void 0;
+    out.push({ quote, attribution });
+  }
+  return out;
+}
+function extractFaqs(html) {
+  const out = [];
+  for (const m of html.matchAll(/<dt\b[^>]*>([\s\S]*?)<\/dt>\s*<dd\b[^>]*>([\s\S]*?)<\/dd>/gi)) {
+    const question = decodeEntities(m[1].replace(/<[^>]+>/g, " "));
+    const answer = decodeEntities(m[2].replace(/<[^>]+>/g, " "));
+    if (question && answer) out.push({ question, answer });
+  }
+  for (const details of html.matchAll(/<details\b[^>]*>([\s\S]*?)<\/details>/gi)) {
+    const summary = details[1].match(/<summary\b[^>]*>([\s\S]*?)<\/summary>/i)?.[1];
+    if (!summary) continue;
+    const question = decodeEntities(summary.replace(/<[^>]+>/g, " "));
+    const answer = decodeEntities(
+      details[1].replace(/<summary[\s\S]*?<\/summary>/i, " ").replace(/<[^>]+>/g, " ")
+    );
+    if (question && answer) out.push({ question, answer });
+  }
+  return out;
+}
+function cssBackgroundUrls(html, pageUrl) {
+  const out = [];
+  for (const m of html.matchAll(/background(?:-image)?\s*:\s*[^;]*url\(\s*['"]?([^)'"]+)['"]?\s*\)/gi)) {
+    const abs = absolutize(m[1].trim(), pageUrl);
+    if (abs && !abs.startsWith("data:")) out.push(abs);
+  }
+  for (const m of html.matchAll(/style=["'][^"']*url\(\s*['"]?([^)'"]+)['"]?\s*\)[^"']*["']/gi)) {
+    const abs = absolutize(m[1].trim(), pageUrl);
+    if (abs && !abs.startsWith("data:")) out.push(abs);
+  }
+  return out;
+}
+function headingBefore(body, idx) {
+  const before = body.slice(0, idx);
+  const matches = [...before.matchAll(/<h[1-3][^>]*>([\s\S]*?)<\/h[1-3]>/gi)];
+  const last = matches.at(-1);
+  if (!last) return "";
+  return decodeEntities(last[1].replace(/<[^>]+>/g, " ")).slice(0, 80);
+}
+function isInChrome(tag, surrounding) {
+  if (/header|nav|navbar|site-header|masthead|\.logo|class=["'][^"']*logo/i.test(tag)) return true;
+  const lookback = surrounding.slice(Math.max(0, surrounding.length - 500));
+  return /<(header|nav)\b/i.test(lookback) && !/<\/(header|nav)>/i.test(lookback.split(/<(header|nav)\b/i).pop() || "");
+}
+function countUnlabeledInputs(html) {
+  const inputs = [...html.matchAll(/<(input|select|textarea)\b([^>]*)>/gi)];
+  let unlabeled = 0;
+  for (const m of inputs) {
+    const attrs = m[2] || "";
+    if (/type=["']hidden["']/i.test(attrs)) continue;
+    if (/aria-label=/i.test(attrs) || /aria-labelledby=/i.test(attrs)) continue;
+    const id = attrs.match(/\bid=["']([^"']+)["']/i)?.[1];
+    if (id && new RegExp(`<label[^>]+for=["']${id}["']`, "i").test(html)) continue;
+    if (!id) unlabeled += 1;
+  }
+  return unlabeled;
+}
+function extractNarrativeParagraphs(html) {
+  const clean = stripNoise(html);
+  const candidates = [];
+  for (const match of clean.matchAll(/<p\b[^>]*>([\s\S]*?)<\/p>/gi)) {
+    const value = decodeEntities(match[1].replace(/<[^>]+>/g, " "));
+    if (value) candidates.push({ index: match.index, text: value });
+  }
+  const prose = clean.replace(/<(nav|header|footer)\b[^>]*>[\s\S]*?<\/\1>/gi, (m) => " ".repeat(m.length));
+  for (const match of prose.matchAll(/<div\b([^>]*)>((?:(?!<\/?div\b)[\s\S])*?)<\/div>/gi)) {
+    if (/\b(?:hidden|aria-hidden\s*=\s*["']true["'])/i.test(match[1]) || /<(?:p|h[1-6]|ul|ol|li|button|input|select|textarea|nav)\b/i.test(match[2])) continue;
+    const value = decodeEntities(match[2].replace(/<[^>]+>/g, " "));
+    if (value.length >= 60 && value.split(/\s+/).length >= 8) candidates.push({ index: match.index, text: value });
+  }
+  return [...new Set(candidates.sort((a, b) => a.index - b.index).map((c) => c.text))];
+}
+function extractPage(html, pageUrl) {
+  const origin = new URL(pageUrl).origin;
+  const raw = html;
+  const base = documentBase(html, pageUrl);
+  const body = stripNoise(html);
+  const title = decodeEntities((body.match(/<title[^>]*>([\s\S]*?)<\/title>/i)?.[1] || "").replace(/<[^>]+>/g, " "));
+  const description = meta(body, "description") || meta(body, "og:description");
+  const h1 = tags(body, "h1");
+  const h2 = tags(body, "h2");
+  const h3 = tags(body, "h3");
+  const h4 = tags(body, "h4");
+  const headings = [...h2, ...h3, ...h4];
+  const paragraphs = extractNarrativeParagraphs(body);
+  const outline = [...h1, ...headings];
+  const lists = extractLists(body);
+  const testimonials = extractTestimonials(body);
+  const faqs = extractFaqs(body);
+  const lang = raw.match(/<html[^>]+lang=["']([^"']+)["']/i)?.[1];
+  const canonicalRaw = raw.match(/<link[^>]+rel=["']canonical["'][^>]+href=["']([^"']+)["']/i)?.[1] || raw.match(/<link[^>]+href=["']([^"']+)["'][^>]+rel=["']canonical["']/i)?.[1];
+  const canonical = canonicalRaw ? absolutize(canonicalRaw, base) || void 0 : void 0;
+  const linkTags = [...body.matchAll(/<a\b([^>]*)>([\s\S]*?)<\/a>/gi)];
+  const links = [];
+  const ctas = [];
+  for (const tag of linkTags) {
+    const hrefRaw = tag[1].match(/href=["']([^"']+)["']/i)?.[1];
+    if (!hrefRaw) continue;
+    const label = decodeEntities(tag[2].replace(/<[^>]+>/g, " "));
+    const relative = isPathRelativeHref(hrefRaw);
+    const abs = hrefRaw.startsWith("tel:") || hrefRaw.startsWith("mailto:") ? hrefRaw : absolutize(hrefRaw, base);
+    if (!abs && !hrefRaw.startsWith("tel:") && !hrefRaw.startsWith("mailto:")) continue;
+    const href = abs || hrefRaw;
+    links.push({ href, label, ...relative ? { relative: true } : {} });
+    const kind = classifyHref(href, origin);
+    if (kind === "tel" || kind === "mailto" || CTA_WORDS.test(label) || /btn|button/i.test(tag[1])) {
+      ctas.push({ href, label: label || kind, kind });
+    }
+  }
+  for (const btn of body.matchAll(/<button\b([^>]*)>([\s\S]*?)<\/button>/gi)) {
+    const label = decodeEntities(btn[2].replace(/<[^>]+>/g, " "));
+    if (label && CTA_WORDS.test(label)) {
+      ctas.push({ href: "", label, kind: "other" });
+    }
+  }
+  const images = [];
+  const pushImg = (img) => {
+    if (!img.src || img.src.startsWith("data:")) return;
+    images.push({ ...img, pageUrl: img.pageUrl || pageUrl });
+  };
+  for (const open of body.matchAll(/<img\b[^>]*>/gi)) {
+    const tag = open[0];
+    const idx = open.index ?? 0;
+    const surrounding = body.slice(Math.max(0, idx - 400), idx + tag.length);
+    const srcset = tag.match(/srcset=["']([^"']+)["']/i)?.[1];
+    const srcRaw = tag.match(/src=["']([^"']+)["']/i)?.[1] || tag.match(/data-src=["']([^"']+)["']/i)?.[1] || tag.match(/data-lazy-src=["']([^"']+)["']/i)?.[1] || tag.match(/data-original=["']([^"']+)["']/i)?.[1];
+    const best = srcset && fromSrcset(srcset, base) || (srcRaw && !srcRaw.startsWith("data:") ? absolutize(srcRaw, base) : null);
+    if (!best) continue;
+    const alt = decodeEntities(tag.match(/alt=["']([^"']*)["']/i)?.[1] || "");
+    const inChrome = isInChrome(tag, surrounding);
+    const nearbyHeading = headingBefore(body, idx);
+    pushImg({
+      src: best,
+      alt,
+      width: dim(tag, "width"),
+      height: dim(tag, "height"),
+      inChrome,
+      pageUrl,
+      nearbyHeading
+    });
+    if (srcset) {
+      for (const u of allFromSrcset(srcset, base)) {
+        if (u !== best) pushImg({ src: u, alt, inChrome, pageUrl, nearbyHeading });
+      }
+    }
+  }
+  for (const pic of body.matchAll(/<picture\b[^>]*>([\s\S]*?)<\/picture>/gi)) {
+    for (const srcset of pic[1].matchAll(/srcset=["']([^"']+)["']/gi)) {
+      for (const u of allFromSrcset(srcset[1], base)) {
+        pushImg({ src: u, alt: "" });
+      }
+    }
+  }
+  for (const bg of cssBackgroundUrls(raw, base)) {
+    pushImg({ src: bg, alt: "", aboveFold: false });
+  }
+  const og = meta(raw, "og:image");
+  if (og) {
+    const src = absolutize(og, base);
+    if (src) pushImg({ src, alt: title, fromOg: true, aboveFold: true });
+  }
+  const appleTouch = raw.match(
+    /<link[^>]+rel=["']apple-touch-icon["'][^>]+href=["']([^"']+)["']/i
+  )?.[1];
+  if (appleTouch) {
+    const src = absolutize(appleTouch, base);
+    if (src) pushImg({ src, alt: "apple-touch-icon", inChrome: true });
+  }
+  const jsonLd = parseJsonLd(raw);
+  const biz = businessFromJsonLd(jsonLd);
+  if (biz.logoUrl) {
+    const src = absolutize(biz.logoUrl, base);
+    if (src) pushImg({ src, alt: "logo", fromJsonLdLogo: true, inChrome: true });
+  }
+  for (const obj of walkJsonLd2(jsonLd)) {
+    const imgField = obj.image;
+    const urls = [];
+    if (typeof imgField === "string") urls.push(imgField);
+    else if (Array.isArray(imgField)) {
+      for (const item of imgField) {
+        if (typeof item === "string") urls.push(item);
+        else if (item && typeof item === "object" && typeof item.url === "string") {
+          urls.push(item.url);
+        }
+      }
+    } else if (imgField && typeof imgField === "object" && typeof imgField.url === "string") {
+      urls.push(imgField.url);
+    }
+    for (const u of urls) {
+      const src = absolutize(u, base);
+      if (src) pushImg({ src, alt: typeof obj.name === "string" ? obj.name : "" });
+    }
+  }
+  const social = collectSocialLinks({ links, jsonLd });
+  const textBlob = `${body} ${links.map((l) => l.href).join(" ")}`;
+  const dedupedImages = dedupeImages(images);
+  const missingAlts = dedupedImages.filter((i) => !i.alt.trim()).length;
+  return {
+    url: pageUrl,
+    title,
+    description,
+    canonical,
+    lang: lang || void 0,
+    h1,
+    headings,
+    outline,
+    paragraphs,
+    lists,
+    testimonials,
+    faqs,
+    links,
+    ctas: dedupeCtas(ctas),
+    images: dedupedImages,
+    phones: extractPhones(textBlob),
+    emails: extractEmails(textBlob),
+    social,
+    jsonLd,
+    audit: {
+      h1Count: h1.length,
+      missingAlts,
+      unlabeledInputs: countUnlabeledInputs(body),
+      hasCanonical: Boolean(canonical),
+      hasLang: Boolean(lang),
+      hasJsonLd: jsonLd.length > 0,
+      titleLength: title.length,
+      descriptionLength: description.length
+    }
+  };
+}
+function dedupeCtas(ctas) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const c of ctas) {
+    const key = `${c.kind}|${c.href}|${c.label.toLowerCase()}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(c);
+  }
+  return out;
+}
+function dedupeImages(images) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const img of images) {
+    if (seen.has(img.src)) {
+      const existing = out.find((i) => i.src === img.src);
+      if (existing) {
+        existing.inChrome = existing.inChrome || img.inChrome;
+        existing.fromJsonLdLogo = existing.fromJsonLdLogo || img.fromJsonLdLogo;
+        existing.fromOg = existing.fromOg || img.fromOg;
+        existing.aboveFold = existing.aboveFold || img.aboveFold;
+        if (!existing.alt && img.alt) existing.alt = img.alt;
+        if (!existing.nearbyHeading && img.nearbyHeading) existing.nearbyHeading = img.nearbyHeading;
+        if (!existing.pageUrl && img.pageUrl) existing.pageUrl = img.pageUrl;
+      }
+      continue;
+    }
+    if (isLikelyTrackingImage(img)) continue;
+    seen.add(img.src);
+    out.push({ ...img });
+  }
+  return out;
+}
+function parseSitemapLocs(xml) {
+  return [...xml.matchAll(/<loc>\s*([^<]+)\s*<\/loc>/gi)].map((m) => decodeEntities(m[1].trim()));
+}
+function inferPrimaryCta(ctas) {
+  const rank = (c) => {
+    if (c.kind === "tel") return 2;
+    if (/book|appoint|schedule|reserve/i.test(c.label)) return 0;
+    if (/quote|estimate|contact|call/i.test(c.label)) return 1;
+    if (c.kind === "mailto") return 3;
+    return 4;
+  };
+  return [...ctas].sort((a, b) => rank(a) - rank(b))[0];
+}
+function pageCopySlug(pageUrl, index) {
+  try {
+    const u = new URL(pageUrl);
+    let path = u.pathname.replace(/\/+$/, "") || "index";
+    path = path.replace(/^\//, "").replace(/[^\w./-]+/g, "-").replace(/\//g, "__");
+    if (!path || path === "-") path = "index";
+    return `${String(index).padStart(3, "0")}-${path}`.slice(0, 120);
+  } catch {
+    return `${String(index).padStart(3, "0")}-page`;
+  }
+}
+
+// src/onboard/brief.ts
+var GENERIC_HEADING = /^(home|about( us)?|contact|blog|news|privacy|terms|faq|hours|location|gallery|welcome|our story|get in touch|follow us|our services|what we offer|why (choose us|choose|us)|testimonials?|support|legal|social|how it works|what'?s included|featured( work)?|built for)$/i;
+var NOT_A_SERVICE = /agreement|policy|terms of service|privacy|cookie|contractor|universal terms|master services|^legal$|^support$|^social$|^about$|^home$|^shop$|^login$/i;
+var NUMBERED_CASE_STUDY = /^\d{1,2}[\.\)]?\s+\S/;
+var SERVICE_PATH = /\/(service|services|menu|offer|offers|treat|treatments)(\/|$)/i;
+var SERVICE_PAGE = /\/(service|services|menu|offer|offers|pricing|features|packages)(\/|$)/i;
+var COMPOSE_NOTE = "Follow the agent skill graph (agent/PROMPT.md). Keep facts (name, phone, email, address, hours, services, primary CTA, social). Keep the old site\u2019s media language: owner photos, illustrations, device mockups, portraits, and press marks \u2014 use interpret shortlist /media paths first. Invent new layout, copy, and chrome; do not clone the old grid 1:1. If the old home has a named visual chapter (How It Works, Featured work, Built for\u2026), restyle it on the new home instead of moving it to an inner route.";
+function emptyFacts() {
+  return {
+    name: "",
+    phone: "",
+    email: "",
+    address: "",
+    city: "",
+    hours: [],
+    primaryCta: { label: "", href: "" },
+    services: [],
+    social: []
+  };
+}
+function first(...vals) {
+  for (const v of vals) {
+    if (v && v.trim()) return v.trim();
+  }
+  return "";
+}
+function parseHoursFromText(text) {
+  const days = "Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday|Mon|Tue|Wed|Thu|Fri|Sat|Sun";
+  const re = new RegExp(`\\b(${days})\\b[:\\s\u2013-]+([^\\n<]{2,40})`, "gi");
+  const out = [];
+  for (const m of text.matchAll(re)) {
+    const hours = m[2].replace(/\s+/g, " ").trim();
+    if (/closed|by appointment|\d/i.test(hours)) out.push(`${m[1]}: ${hours}`);
+  }
+  return [...new Set(out)].slice(0, 7);
+}
+function isServiceHeading(heading, pageUrl) {
+  if (GENERIC_HEADING.test(heading) || NOT_A_SERVICE.test(heading) || heading.length > 48) return false;
+  try {
+    const path = new URL(pageUrl).pathname;
+    if (NUMBERED_CASE_STUDY.test(heading) && !SERVICE_PATH.test(path)) return false;
+  } catch {
+    if (NUMBERED_CASE_STUDY.test(heading)) return false;
+  }
+  return true;
+}
+function inferServices(pages) {
+  const fromLd = pages.flatMap((p) => jsonLdServices(p.jsonLd)).filter((s) => isServiceHeading(s.name, ""));
+  if (fromLd.length) return fromLd;
+  const servicePages = pages.filter((p) => {
+    try {
+      const path = new URL(p.url).pathname;
+      return SERVICE_PAGE.test(path) || /service|menu|offer|pricing|features/i.test(p.title);
+    } catch {
+      return false;
+    }
+  });
+  const pool = servicePages.length ? servicePages : pages.slice(0, 1);
+  const fromHeadings = [];
+  for (const page of pool) {
+    for (const heading of [...page.h1.slice(1), ...page.headings]) {
+      if (!isServiceHeading(heading, page.url)) continue;
+      if (fromHeadings.some((s) => s.name.toLowerCase() === heading.toLowerCase())) continue;
+      const blurb = page.paragraphs.find(
+        (p) => p.length > 40 && p.length < 220 && p.toLowerCase().includes(heading.toLowerCase().slice(0, Math.min(12, heading.length)))
+      ) || "";
+      fromHeadings.push({ name: heading, blurb });
+    }
+  }
+  return fromHeadings.slice(0, 12);
+}
+function collectCandidateImages(pages) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const page of pages) {
+    for (const img of page.images) {
+      if (seen.has(img.src)) {
+        const existing = out.find((i) => i.src === img.src);
+        if (existing) {
+          existing.inChrome = existing.inChrome || img.inChrome;
+          existing.fromJsonLdLogo = existing.fromJsonLdLogo || img.fromJsonLdLogo;
+          existing.fromOg = existing.fromOg || img.fromOg;
+          existing.aboveFold = existing.aboveFold || img.aboveFold;
+          if (!existing.alt && img.alt) existing.alt = img.alt;
+          if (!existing.nearbyHeading && img.nearbyHeading) existing.nearbyHeading = img.nearbyHeading;
+          if (!existing.pageUrl && img.pageUrl) existing.pageUrl = img.pageUrl;
+        }
+        continue;
+      }
+      seen.add(img.src);
+      out.push({ ...img });
+    }
+  }
+  return out;
+}
+function missingCritical(facts) {
+  const missing = [];
+  if (!facts.name) missing.push("name");
+  if (!facts.phone) missing.push("phone");
+  if (!facts.email) missing.push("email");
+  if (!facts.address && !facts.city) missing.push("address");
+  if (!facts.primaryCta.label && !facts.primaryCta.href) missing.push("primaryCta");
+  if (!facts.hours.length) missing.push("hours");
+  if (!facts.services.length) missing.push("services");
+  return missing;
+}
+function mergeFacts(pages, seed = {}) {
+  const facts = emptyFacts();
+  const ldList = pages.map((p) => businessFromJsonLd(p.jsonLd));
+  facts.name = first(seed.name, ...ldList.map((b) => b.name), pages[0]?.h1[0], pages[0]?.title);
+  facts.phone = first(seed.phone, ...ldList.map((b) => b.phone), ...pages.flatMap((p) => p.phones));
+  facts.email = first(seed.email, ...ldList.map((b) => b.email), ...pages.flatMap((p) => p.emails));
+  facts.address = first(seed.address, ...ldList.map((b) => b.address));
+  facts.city = first(seed.city, ...ldList.map((b) => b.city));
+  facts.hours = seed.hours?.length ? seed.hours : firstNonEmpty(
+    ldList.flatMap((b) => b.hours || []),
+    pages.flatMap((p) => parseHoursFromText([p.title, ...p.headings, ...p.paragraphs].join("\n")))
+  );
+  const ctas = pages.flatMap((p) => p.ctas);
+  const cta = inferPrimaryCta(ctas);
+  facts.primaryCta = seed.primaryCta && (seed.primaryCta.label || seed.primaryCta.href) ? seed.primaryCta : { label: cta?.label || "", href: cta?.href || "" };
+  facts.services = seed.services?.length ? seed.services : inferServices(pages);
+  if (facts.name.includes("|")) facts.name = facts.name.split("|")[0].trim();
+  if (seed.social?.length) {
+    facts.social = seed.social;
+  } else {
+    const seen = /* @__PURE__ */ new Set();
+    for (const page of pages) {
+      for (const s of page.social) {
+        const key = s.url.replace(/\/+$/, "").toLowerCase();
+        if (seen.has(key)) continue;
+        seen.add(key);
+        facts.social.push(s);
+      }
+    }
+    if (!facts.social.length) {
+      facts.social = collectSocialLinks({
+        links: pages.flatMap((p) => p.links),
+        jsonLd: pages.flatMap((p) => p.jsonLd)
+      });
+    }
+  }
+  return facts;
+}
+function firstNonEmpty(a, b) {
+  return a.length ? [...new Set(a)].slice(0, 8) : [...new Set(b)].slice(0, 8);
+}
+function assembleBrief(opts) {
+  const business = mergeFacts(opts.pages, opts.seed);
+  const pages = opts.pages.map((p) => ({
+    aliasOf: p.aliasOf,
+    url: p.url,
+    title: p.title,
+    description: p.description,
+    canonical: p.canonical,
+    outline: p.outline,
+    paragraphs: p.paragraphs,
+    lists: p.lists || [],
+    testimonials: p.testimonials || [],
+    faqs: p.faqs || [],
+    ctas: p.ctas,
+    copyFile: opts.copyFiles?.get(p.url),
+    audit: p.audit
+  }));
+  return {
+    version: 2,
+    sourceUrl: opts.sourceUrl,
+    crawledAt: opts.crawledAt || (/* @__PURE__ */ new Date()).toISOString(),
+    slug: opts.slug,
+    business,
+    missing: missingCritical(business),
+    pages,
+    images: opts.images || [],
+    warnings: opts.warnings || [],
+    compose: COMPOSE_NOTE,
+    visual: opts.visual || (opts.pages.length ? {
+      register: inferRegister(opts.pages, business),
+      signatureSections: inferSignatureSections(opts.pages),
+      hints: {},
+      stills: []
+    } : void 0)
+  };
+}
+var SIGNATURE_HEADING = /how it works|what'?s included|featured|portfolio|built for|meet the team|testimonial|industries|our work|case stud/i;
+function inferSignatureSections(pages) {
+  const home = pages[0];
+  if (!home) return [];
+  const out = [];
+  for (const heading of home.outline) {
+    if (SIGNATURE_HEADING.test(heading) && !out.some((h) => h.toLowerCase() === heading.toLowerCase())) {
+      out.push(heading);
+    }
+  }
+  return out.slice(0, 8);
+}
+function inferRegister(pages, business) {
+  const blob = [
+    business.name,
+    ...pages.slice(0, 6).flatMap((p) => [p.title, p.description, ...p.outline.slice(0, 12)])
+  ].join(" ").toLowerCase();
+  if (/salon|spa|beauty|lash|nail|barber|med spa/.test(blob)) return "beauty";
+  if (/platform|saas|software|demo|features|pricing|marketing agency|automations|digital marketing|website builder/.test(
+    blob
+  )) {
+    return "b2b";
+  }
+  return "trade";
+}
+function assembleAudit(opts) {
+  const pageRows = opts.pages.map((p) => ({
+    url: p.url,
+    title: p.title,
+    description: p.description,
+    canonical: p.canonical,
+    lang: p.lang,
+    ...p.audit
+  }));
+  return {
+    version: 1,
+    sourceUrl: opts.sourceUrl,
+    crawledAt: opts.crawledAt || (/* @__PURE__ */ new Date()).toISOString(),
+    pages: pageRows,
+    summary: {
+      pageCount: pageRows.length,
+      pagesMissingTitle: pageRows.filter((p) => !p.title).length,
+      pagesMissingDescription: pageRows.filter((p) => !p.description).length,
+      pagesMultipleH1: pageRows.filter((p) => p.h1Count > 1).length,
+      pagesZeroH1: pageRows.filter((p) => p.h1Count === 0).length,
+      totalMissingAlts: pageRows.reduce((n, p) => n + p.missingAlts, 0),
+      totalUnlabeledInputs: pageRows.reduce((n, p) => n + p.unlabeledInputs, 0)
+    },
+    webVitals: null
+  };
+}
+function emptyResearch(social = []) {
+  return {
+    version: 1,
+    reviews: { snippets: [], sourceUrls: [] },
+    social: [...social],
+    goals: {},
+    sources: [],
+    completed: false
+  };
+}
+
+// scripts/onboard/prompt.ts
+var input = process.stdin;
+var output = process.stdout;
+async function ask(rl, label, current = "") {
+  const suffix = current ? ` [${current}]` : "";
+  const answer = (await rl.question(`${label}${suffix}: `)).trim();
+  return answer || current;
+}
+async function promptMissingFacts(facts, opts) {
+  const missing = missingCritical(facts);
+  if (!missing.length || opts.noPrompt) return facts;
+  if (!input.isTTY) {
+    console.warn("Non-interactive terminal; pass flags or run without --no-prompt on a TTY to fill missing fields.");
+    return facts;
+  }
+  console.log("\nCrawl missed some critical fields. Fill them in (Enter skips):\n");
+  const rl = readline.createInterface({ input, output });
+  const next = {
+    ...facts,
+    primaryCta: { ...facts.primaryCta },
+    hours: [...facts.hours],
+    services: [...facts.services],
+    social: [...facts.social || []]
+  };
+  try {
+    const need = new Set(missing);
+    if (need.has("name")) next.name = await ask(rl, "Business name", next.name);
+    if (need.has("phone")) next.phone = await ask(rl, "Phone", next.phone);
+    if (need.has("email")) next.email = await ask(rl, "Email", next.email);
+    if (need.has("address")) {
+      next.address = await ask(rl, "Street address", next.address);
+      next.city = await ask(rl, "City", next.city);
+    }
+    if (need.has("primaryCta")) {
+      next.primaryCta.label = await ask(rl, "Primary CTA label (e.g. Book a chair)", next.primaryCta.label);
+      next.primaryCta.href = await ask(rl, "Primary CTA URL (tel:, mailto:, or /contact)", next.primaryCta.href);
+    }
+    if (need.has("hours")) {
+      const hours = await ask(rl, "Hours (e.g. Mon\u2013Fri 9am\u20135pm)", next.hours.join("; "));
+      if (hours) next.hours = hours.split(/;|\n/).map((h) => h.trim()).filter(Boolean);
+    }
+    if (need.has("services")) {
+      const services = await ask(rl, "Services (comma-separated)", next.services.map((s) => s.name).join(", "));
+      if (services) {
+        next.services = services.split(",").map((name) => ({ name: name.trim(), blurb: "" })).filter((s) => s.name);
+      }
+    }
+  } finally {
+    rl.close();
+  }
+  return next;
+}
+function normalizeSourceUrl(url) {
+  const trimmed = url.trim();
+  if (!trimmed) return "";
+  if (trimmed.startsWith("--")) {
+    throw new Error(`Invalid URL "${trimmed}". Pass --from https://existing-site.example`);
+  }
+  const withProto = /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+  const parsed = new URL(withProto);
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("Source URL must be http(s)");
+  }
+  return parsed.href;
+}
+async function promptSourceUrl(opts) {
+  if (opts.blank) return "";
+  if (opts.from) return normalizeSourceUrl(opts.from);
+  if (opts.noPrompt || !input.isTTY) {
+    throw new Error("Pass --from https://existing-site.example or --blank");
+  }
+  const rl = readline.createInterface({ input, output });
+  try {
+    const url = (await rl.question("Existing site URL to crawl (required unless this is a blank starter; Enter skips): ")).trim();
+    return url ? normalizeSourceUrl(url) : "";
+  } finally {
+    rl.close();
+  }
+}
+
+// scripts/onboard/run.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync, writeFileSync } from "node:fs";
+import { join as join3 } from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+
+// src/onboard/outline.ts
+function renderPageCopy(page) {
+  const lines = [];
+  lines.push(`# ${page.title || page.url}`);
+  lines.push("");
+  lines.push(`Source: ${page.url}`);
+  if (page.description) {
+    lines.push("");
+    lines.push(`> ${page.description}`);
+  }
+  if (page.outline.length) {
+    lines.push("");
+    lines.push("## Outline");
+    for (const h of page.outline) lines.push(`- ${h}`);
+  }
+  if (page.paragraphs.length) {
+    lines.push("");
+    lines.push("## Copy");
+    for (const p of page.paragraphs) {
+      lines.push("");
+      lines.push(p);
+    }
+  }
+  if (page.lists.length) {
+    lines.push("");
+    lines.push("## Lists");
+    for (const list of page.lists) {
+      lines.push("");
+      lines.push(`- ${list}`);
+    }
+  }
+  if (page.testimonials.length) {
+    lines.push("");
+    lines.push("## Testimonials");
+    for (const t of page.testimonials) {
+      lines.push("");
+      lines.push(`> ${t.quote}`);
+      if (t.attribution) lines.push(`> \u2014 ${t.attribution}`);
+    }
+  }
+  if (page.faqs.length) {
+    lines.push("");
+    lines.push("## FAQ");
+    for (const f of page.faqs) {
+      lines.push("");
+      lines.push(`**Q:** ${f.question}`);
+      lines.push(`**A:** ${f.answer}`);
+    }
+  }
+  if (page.ctas.length) {
+    lines.push("");
+    lines.push("## CTAs");
+    for (const c of page.ctas) {
+      lines.push(`- [${c.label}](${c.href || "#"}) (${c.kind})`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function buildCopyFiles(pages) {
+  const out = /* @__PURE__ */ new Map();
+  pages.forEach((page, i) => {
+    const slug = pageCopySlug(page.url, i);
+    out.set(page.url, { slug, markdown: renderPageCopy(page) });
+  });
+  return out;
+}
+function imageLine(img) {
+  const bits = [`**${img.role}**`, `kind=${img.kind}`];
+  if (img.mediaType) bits.push(`type=${img.mediaType}`);
+  if (img.alt) bits.push(`alt="${img.alt}"`);
+  if (img.nearbyHeading) bits.push(`near="${img.nearbyHeading}"`);
+  if (img.localPath) bits.push(`use=${img.localPath}`);
+  if (img.error) bits.push(`error=${img.error}`);
+  return `- ${bits.join(" \xB7 ")} \u2014 ${img.src || img.sourceUrl}`;
+}
+function renderMediaGuide(brief) {
+  const ok = brief.images.filter((i) => i.role !== "failed" && i.localPath);
+  const hintShortlist = brief.images.filter((i) => i.shortlist);
+  const lines = [];
+  lines.push(`# Media guide \u2014 ${brief.business.name || brief.slug}`);
+  lines.push("");
+  lines.push("All successful harvest images live under media/harvest/. The media node owns the complete asset inventory and dispositions. Do not hotlink the old origin.");
+  lines.push("");
+  if (brief.visual) {
+    lines.push(`- **Register (hint):** ${brief.visual.register} \u2014 the business and direction nodes reassess`);
+    if (brief.visual.signatureSections.length) {
+      lines.push(`- **Signature home chapters (hint):** ${brief.visual.signatureSections.join("; ")}`);
+    }
+    if (brief.visual.stills.length) {
+      lines.push(`- **Old-site stills:** ${brief.visual.stills.map((s) => `\`${s}\``).join(", ")}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Candidate hints \u2014 inspect before selecting");
+  lines.push("");
+  if (!hintShortlist.length) {
+    lines.push("- (pending inspection \u2014 account for the full harvest catalog)");
+  } else {
+    lines.push("_Heuristic hints from harvest (not authoritative):_");
+    lines.push("");
+    for (const img of hintShortlist) {
+      const dims = img.width && img.height ? `${img.width}\xD7${img.height}` : "";
+      lines.push(`- \`${img.localPath || img.src}\` \u2014 **${img.mediaType || img.role}** ${dims} ${img.caption || img.alt || ""}`.trim());
+      if (img.pageUrl) lines.push(`  - from ${img.pageUrl}`);
+    }
+  }
+  lines.push("");
+  lines.push("## Harvest catalog");
+  lines.push("");
+  if (!ok.length) {
+    lines.push("- (no images stored \u2014 stock fallback later if needed)");
+  } else {
+    for (const img of ok) {
+      lines.push(imageLine(img));
+    }
+  }
+  lines.push("");
+  lines.push("## Media treatment");
+  lines.push("");
+  lines.push('- One LCP still (`fetchpriority="high"`).');
+  lines.push("- Select media by narrative purpose and image quality; there is no count quota.");
+  lines.push("- Use actual people and project collections where they answer visitor questions.");
+  lines.push("- Record use, retain, duplicate, or exclude for every asset, and resolve missing source images.");
+  lines.push("");
+  return lines.join("\n");
+}
+function renderOutline(opts) {
+  const brief = opts.brief;
+  const biz = opts.business || brief.business;
+  const lines = [];
+  lines.push(`# Onboarding outline \u2014 ${biz.name || brief.slug}`);
+  lines.push("");
+  lines.push(`Source: ${brief.sourceUrl || "(blank)"}`);
+  lines.push(`Crawled: ${brief.crawledAt}`);
+  lines.push(`Slug: ${brief.slug}`);
+  lines.push("");
+  lines.push("## Business facts");
+  lines.push("");
+  lines.push(`- **Name:** ${biz.name || "(missing)"}`);
+  lines.push(`- **Phone:** ${biz.phone || "(missing)"}`);
+  lines.push(`- **Email:** ${biz.email || "(missing)"}`);
+  lines.push(`- **Address:** ${biz.address || "(missing)"}`);
+  lines.push(`- **City:** ${biz.city || "(missing)"}`);
+  lines.push(`- **Hours:** ${biz.hours.length ? biz.hours.join("; ") : "(missing)"}`);
+  lines.push(
+    `- **Primary CTA:** ${biz.primaryCta.label || "(missing)"} \u2192 ${biz.primaryCta.href || "(missing)"}`
+  );
+  if (biz.services.length) {
+    lines.push("- **Services:**");
+    for (const s of biz.services) {
+      lines.push(`  - ${s.name}${s.blurb ? ` \u2014 ${s.blurb}` : ""}`);
+    }
+  } else {
+    lines.push("- **Services:** (missing)");
+  }
+  if (biz.social.length) {
+    lines.push("- **Social (from site):**");
+    for (const s of biz.social) {
+      lines.push(`  - ${s.platform}: ${s.url}`);
+    }
+  } else {
+    lines.push("- **Social:** (none found on-site \u2014 complete in the research graph node)");
+  }
+  if (brief.visual) {
+    lines.push("");
+    lines.push("## Visual register");
+    lines.push("");
+    lines.push(`- **Register:** ${brief.visual.register} (trade = photo-led local shop; beauty = lifestyle stills; b2b = product/agency \u2014 illustrations, mockups, hover nav OK)`);
+    if (brief.visual.signatureSections.length) {
+      lines.push(`- **Signature chapters (keep on home, restyled):** ${brief.visual.signatureSections.join("; ")}`);
+    }
+    if (brief.visual.hints.fontDisplay) {
+      lines.push(`- **Display font (self-host if distinctive):** ${brief.visual.hints.fontDisplay}`);
+    }
+    if (brief.visual.hints.radius) {
+      lines.push(`- **Computed button radius:** ${brief.visual.hints.radius}`);
+    }
+  }
+  if (brief.missing.length) {
+    lines.push("");
+    lines.push("## Gaps");
+    lines.push("");
+    for (const m of brief.missing) lines.push(`- ${m}`);
+  }
+  lines.push("");
+  lines.push("## Sitemap");
+  lines.push("");
+  for (const page of brief.pages) {
+    const copy = page.copyFile ? ` \u2192 copy/${page.copyFile}` : "";
+    lines.push(`- [${page.title || page.url}](${page.url})${copy}`);
+  }
+  lines.push("");
+  lines.push("## Image inventory");
+  lines.push("");
+  const shortlist = brief.images.filter((i) => i.shortlist);
+  lines.push("### Must-use shortlist");
+  if (shortlist.length) for (const i of shortlist) lines.push(imageLine(i));
+  else lines.push("- (none \u2014 see full inventory below)");
+  lines.push("");
+  lines.push("Read **media.md** for captions and the homepage media budget. Prefer `/media/\u2026` paths.");
+  lines.push("");
+  const logo = brief.images.filter((i) => i.role === "logo");
+  const hero = brief.images.filter((i) => i.role === "hero");
+  const business = brief.images.filter((i) => i.kind === "business" && i.role !== "logo" && i.role !== "hero");
+  const stock = brief.images.filter((i) => i.kind === "stock");
+  const generic = brief.images.filter((i) => i.kind === "generic" || i.kind === "unknown");
+  const failed = brief.images.filter((i) => i.role === "failed");
+  lines.push("### Logo");
+  if (logo.length) for (const i of logo) lines.push(imageLine(i));
+  else lines.push("- (none classified)");
+  lines.push("");
+  lines.push("### Hero candidates");
+  if (hero.length) for (const i of hero) lines.push(imageLine(i));
+  else lines.push("- (none classified)");
+  lines.push("");
+  lines.push("### Business-specific photos");
+  if (business.length) for (const i of business) lines.push(imageLine(i));
+  else lines.push("- (none)");
+  lines.push("");
+  lines.push("### Stock");
+  if (stock.length) for (const i of stock) lines.push(imageLine(i));
+  else lines.push("- (none)");
+  lines.push("");
+  lines.push("### Generic / unknown");
+  if (generic.length) for (const i of generic) lines.push(imageLine(i));
+  else lines.push("- (none)");
+  if (failed.length) {
+    lines.push("");
+    lines.push("### Failed uploads");
+    for (const i of failed) lines.push(imageLine(i));
+  }
+  const testimonials = brief.pages.flatMap((p) => p.testimonials || []);
+  const faqs = brief.pages.flatMap((p) => p.faqs || []);
+  if (testimonials.length) {
+    lines.push("");
+    lines.push("## Testimonials found");
+    for (const t of testimonials) {
+      lines.push(`- \u201C${t.quote.slice(0, 160)}${t.quote.length > 160 ? "\u2026" : ""}\u201D${t.attribution ? ` \u2014 ${t.attribution}` : ""}`);
+    }
+  }
+  if (faqs.length) {
+    lines.push("");
+    lines.push("## FAQs found");
+    for (const f of faqs) {
+      lines.push(`- **${f.question}** \u2014 ${f.answer.slice(0, 120)}${f.answer.length > 120 ? "\u2026" : ""}`);
+    }
+  }
+  if (brief.warnings.length) {
+    lines.push("");
+    lines.push("## Crawl warnings");
+    for (const w of brief.warnings) lines.push(`- ${w}`);
+  }
+  lines.push("");
+  lines.push("## Next (operator / agent)");
+  lines.push("");
+  lines.push("1. Build and independently review the evidence-backed business interpretation.");
+  lines.push("2. Inspect and account for media, then develop and review coherent visual directions.");
+  lines.push("3. Follow the graph through storyboard, edited copy, representative pages, browser checks and final critics.");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// scripts/onboard/browser.ts
+import { createRequire } from "node:module";
+import { existsSync as existsSync2, mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+// src/onboard/crawl-order.ts
+function pathnameOf(url) {
+  try {
+    return new URL(url).pathname.toLowerCase() || "/";
+  } catch {
+    return "/";
+  }
+}
+function isHome(url, startUrl) {
+  try {
+    const a = new URL(url);
+    const b = new URL(startUrl);
+    const path = a.pathname.replace(/\/+$/, "") || "/";
+    return path === "/" || path === "/home" || path === "/index" || a.href === b.href;
+  } catch {
+    return false;
+  }
+}
+function crawlPriority(url, startUrl) {
+  if (isHome(url, startUrl)) return 0;
+  const path = pathnameOf(url);
+  if (/\/(about|team|meet-the-team|our-team)(\/|$)/.test(path)) return 1;
+  if (/\/(portfolio|work|our-work|projects|gallery)(\/|$)/.test(path)) return 2;
+  if (/\/(how-it-works|process)(\/|$)/.test(path)) return 3;
+  if (/\/(features|services|menu|offer)(\/|$)/.test(path)) return 4;
+  if (/\/(pricing|packages|plans)(\/|$)/.test(path)) return 5;
+  if (/\/(contact|schedule|book|demo)(\/|$)/.test(path)) return 6;
+  if (/\/(legal|privacy|terms|cookie|shop|cart|login|account)(\/|$)/.test(path)) return 90;
+  return 20;
+}
+function insertByCrawlPriority(queue, url, startUrl) {
+  const p = crawlPriority(url, startUrl);
+  let i = 0;
+  while (i < queue.length && crawlPriority(queue[i], startUrl) <= p) i += 1;
+  queue.splice(i, 0, url);
+}
+
+// src/onboard/visual-hints.ts
+var GENERIC_FACE = /* @__PURE__ */ new Set([
+  "ui-sans-serif",
+  "system-ui",
+  "sans-serif",
+  "serif",
+  "ui-serif",
+  "arial",
+  "helvetica",
+  "helvetica neue",
+  "times",
+  "times new roman",
+  "georgia",
+  "segoe ui",
+  "tahoma",
+  "verdana",
+  "roboto",
+  "-apple-system",
+  "blinkmacsystemfont",
+  "apple color emoji",
+  "segoe ui emoji",
+  "nimbus sans",
+  "liberation sans",
+  "dejavu sans"
+]);
+function firstFace(family) {
+  return (family.split(",")[0] || "").replace(/["']/g, "").trim();
+}
+function stackFromComputed(family, fallback) {
+  const face = firstFace(family);
+  if (!face || GENERIC_FACE.has(face.toLowerCase())) return void 0;
+  if (/^https?:/i.test(face) || face.includes("fonts.google")) return void 0;
+  return `"${face}", ${fallback}`;
+}
+function radiusFromComputed(raw) {
+  const token = (raw.split(/\s+/)[0] || "").trim();
+  if (!token || token === "0" || token === "0px") return {};
+  if (/%/.test(token) || parseFloat(token) >= 20) return { radiusPill: "999px" };
+  if (parseFloat(token) >= 2) return { radius: token };
+  return {};
+}
+function hintsFromComputed(input2) {
+  const hints = {};
+  const body = stackFromComputed(input2.fontBody || "", "ui-sans-serif, system-ui, sans-serif");
+  const display = stackFromComputed(input2.fontDisplay || "", "ui-serif, Georgia, serif");
+  if (body) hints.fontBody = body;
+  if (display) hints.fontDisplay = display;
+  Object.assign(hints, radiusFromComputed(input2.radius || ""));
+  return hints;
+}
+
+// scripts/onboard/crawl.ts
+import { existsSync } from "node:fs";
+var ua = "VitrisOnboard/0.1 (authorized site migration; https://vitris.local)";
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchDoc(url, accept) {
+  try {
+    const res = await fetch(url, {
+      headers: { "user-agent": ua, accept },
+      redirect: "follow",
+      signal: AbortSignal.timeout(12e3)
+    });
+    const contentType = res.headers.get("content-type") || "";
+    const body = await res.text();
+    if (!res.ok) return { ok: false, status: res.status, error: `HTTP ${res.status}` };
+    return { ok: true, url: res.url || url, body, contentType, status: res.status };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : "error" };
+  }
+}
+function normalizePageUrl(href) {
+  try {
+    const u = new URL(href);
+    if (u.protocol !== "http:" && u.protocol !== "https:") return null;
+    u.hash = "";
+    if (u.pathname.length > 1) u.pathname = u.pathname.replace(/\/+$/, "");
+    return u.href;
+  } catch {
+    return null;
+  }
+}
+function enqueue(queue, seen, href, startUrl, discovery, meta2) {
+  const url = normalizePageUrl(href);
+  if (!url) return;
+  if (!sameSite(url, startUrl)) return;
+  let path = "/";
+  try {
+    path = new URL(url).pathname;
+  } catch {
+    return;
+  }
+  if (shouldSkipPath(path)) return;
+  if (shouldSkipQueryUrl(url)) return;
+  if (seen.has(url)) return;
+  seen.add(url);
+  if (discovery && !discovery.has(url)) {
+    discovery.set(url, meta2 || { provenance: "in-body-relative" });
+  }
+  insertByCrawlPriority(queue, url, startUrl);
+}
+async function sitemapUrls(startUrl, warnings) {
+  const origin = new URL(startUrl).origin;
+  const candidates = [
+    `${origin}/sitemap.xml`,
+    `${origin}/sitemap_index.xml`,
+    `${origin}/wp-sitemap.xml`
+  ];
+  const robots = await fetchDoc(`${origin}/robots.txt`, "text/plain");
+  if (robots.ok) {
+    for (const m of robots.body.matchAll(/sitemap:\s*(\S+)/gi)) {
+      candidates.unshift(m[1]);
+    }
+  }
+  const locs = [];
+  const seenMaps = /* @__PURE__ */ new Set();
+  const mapQueue = [...candidates];
+  while (mapQueue.length) {
+    const mapUrl = mapQueue.shift();
+    if (seenMaps.has(mapUrl)) continue;
+    seenMaps.add(mapUrl);
+    const xml = await fetchDoc(mapUrl, "application/xml,text/xml,text/plain");
+    if (!xml.ok) continue;
+    const found = parseSitemapLocs(xml.body);
+    if (!found.length) continue;
+    if (/<sitemapindex/i.test(xml.body)) {
+      for (const child of found) {
+        if (!seenMaps.has(child)) mapQueue.push(child);
+      }
+    } else {
+      locs.push(...found);
+    }
+  }
+  if (!locs.length) warnings.push("No sitemap found; falling back to homepage links.");
+  return locs;
+}
+function persistCheckpoint(path, payload) {
+  if (!path) return;
+  try {
+    save(path, payload);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    payload.warnings.push(`Skipped (persistence error): checkpoint write failed \u2014 ${msg}`);
+    console.warn(`  persistence: ${msg}`);
+  }
+}
+function pageSignature(p) {
+  return JSON.stringify([p.title, p.description, p.headings, p.paragraphs]);
+}
+async function crawlSite(startUrl, maxPages, checkpointPath, fresh = false) {
+  const warnings = [];
+  const start = normalizePageUrl(startUrl) || startUrl;
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [];
+  const discovery = /* @__PURE__ */ new Map();
+  enqueue(queue, seen, start, start, discovery, { provenance: "start" });
+  const fromSitemap = await sitemapUrls(start, warnings);
+  const sitemapPaths = new Set(fromSitemap.map((loc) => {
+    try {
+      return new URL(loc).pathname.replace(/\/+$/, "") || "/";
+    } catch {
+      return loc;
+    }
+  }));
+  for (const loc of fromSitemap) enqueue(queue, seen, loc, start, discovery, { provenance: "sitemap" });
+  const pages = [];
+  const visited = /* @__PURE__ */ new Set();
+  const exclusions = [];
+  const misses = [];
+  const stills = [];
+  let hints;
+  if (checkpointPath && !fresh && existsSync(checkpointPath)) {
+    const checkpoint2 = json(checkpointPath);
+    if (checkpoint2.start === start) {
+      pages.push(...checkpoint2.pages.filter((p) => !isErrorPage(p)));
+      queue.splice(0, queue.length, ...checkpoint2.queue);
+      for (const p of checkpoint2.pages.filter(isErrorPage)) {
+        warnings.push(`Excluded error page from resumed capture: ${p.url}`);
+      }
+      for (const url of checkpoint2.visited) visited.add(url);
+      for (const url of checkpoint2.seen) seen.add(url);
+      for (const [url, meta2] of checkpoint2.discovery || []) discovery.set(url, meta2);
+      warnings.push(...checkpoint2.warnings.filter((w) => !checkpoint2.queue.length || !/browser error|empty document|unvisited|transient/i.test(w)));
+      stills.push(...checkpoint2.stills || []);
+      hints = checkpoint2.hints;
+      exclusions.push(...checkpoint2.exclusions || []);
+      console.log(`Resuming captured crawl: ${pages.length} pages, ${queue.length} URLs pending`);
+    }
+  }
+  const snapshot = () => ({
+    version: 2,
+    start,
+    pages,
+    queue,
+    visited: [...visited],
+    seen: [...seen],
+    warnings,
+    stills,
+    hints,
+    exclusions,
+    discovery: [...discovery]
+  });
+  const checkpoint = () => persistCheckpoint(checkpointPath, snapshot());
+  const retryUrls = [];
+  while (queue.length) {
+    if (maxPages !== void 0 && pages.length >= maxPages) {
+      warnings.push(`Emergency maxPages=${maxPages} reached; ${queue.length} URL(s) left unvisited.`);
+      break;
+    }
+    const url = queue.shift();
+    if (visited.has(url)) continue;
+    queue.unshift(url);
+    checkpoint();
+    queue.shift();
+    visited.add(url);
+    const res = await fetchDoc(url, "text/html,application/xhtml+xml");
+    if (!res.ok) {
+      const kind = res.status && res.status < 500 ? "http" : "transport";
+      misses.push({ url, status: res.status, error: res.error, kind });
+      if (kind === "transport") retryUrls.push(url);
+      checkpoint();
+      continue;
+    }
+    if (!sameSite(res.url, start)) {
+      misses.push({ url, error: `${url} \u2192 ${res.url}`, kind: "off-site" });
+      checkpoint();
+      continue;
+    }
+    if (!/html/i.test(res.contentType) && !res.body.trimStart().startsWith("<")) {
+      checkpoint();
+      continue;
+    }
+    const page = extractPage(res.body, res.url);
+    if (isErrorPage(page)) {
+      misses.push({ url, kind: "error-page", error: "Soft error page" });
+      checkpoint();
+      continue;
+    }
+    if (pages.some((p) => p.url === res.url)) {
+      checkpoint();
+      continue;
+    }
+    const duplicate = pages.find((p) => pageSignature(p) === pageSignature(page));
+    if (duplicate) {
+      page.aliasOf = duplicate.aliasOf || duplicate.url;
+      pages.push(page);
+      checkpoint();
+      continue;
+    }
+    pages.push(page);
+    for (const link of page.links) {
+      enqueue(queue, seen, link.href, start, discovery, {
+        provenance: link.relative ? "in-body-relative" : "nav",
+        discoveredFrom: res.url
+      });
+    }
+    await sleep(120);
+    checkpoint();
+  }
+  const captured = capturedPathSet(pages);
+  for (const miss of misses) {
+    const exclusion = classifyMiss({ ...miss, discovery: discovery.get(miss.url), captured, sitemapPaths });
+    exclusions.push(exclusion);
+    warnings.push(formatExclusion(exclusion));
+  }
+  if (!pages.length) warnings.push("Crawl returned no HTML pages.");
+  for (const url of retryUrls) {
+    visited.delete(url);
+    queue.push(url);
+  }
+  checkpoint();
+  return { startUrl: start, pages, warnings, engine: "fetch", exclusions, stills, hints, unvisited: [...queue] };
+}
+
+// scripts/onboard/browser.ts
+async function loadPlaywright(kernelRoot) {
+  try {
+    return await import("playwright");
+  } catch {
+    if (kernelRoot) {
+      try {
+        const require2 = createRequire(join(kernelRoot, "package.json"));
+        return require2("playwright");
+      } catch {
+      }
+    }
+    throw new Error(
+      "playwright package not installed. From the site repo: npm install && npx playwright install chromium"
+    );
+  }
+}
+async function scrollPage(page) {
+  await page.evaluate(async () => {
+    const w = globalThis;
+    await new Promise((resolve) => {
+      let total = 0;
+      const step = Math.max(400, Math.floor(w.innerHeight * 0.85));
+      const timer = setInterval(() => {
+        const { scrollHeight } = w.document.documentElement;
+        w.scrollBy(0, step);
+        total += step;
+        if (total >= scrollHeight || total > 5e4) {
+          clearInterval(timer);
+          w.scrollTo(0, 0);
+          resolve();
+        }
+      }, 120);
+    });
+  });
+  await page.waitForTimeout(400);
+}
+async function collectRenderedExtras(page) {
+  return await page.evaluate(() => {
+    const g = globalThis;
+    const imageUrls = [];
+    for (const node of Array.from(g.document.querySelectorAll("img"))) {
+      const img = node;
+      const src = img.currentSrc || img.src || img.getAttribute("data-src") || img.getAttribute("data-lazy-src") || "";
+      if (src && !src.startsWith("data:")) imageUrls.push(src);
+      const srcset = img.getAttribute("srcset") || img.getAttribute("data-srcset");
+      if (srcset) {
+        for (const part of srcset.split(",")) {
+          const u = part.trim().split(/\s+/)[0];
+          if (u && !u.startsWith("data:")) imageUrls.push(u);
+        }
+      }
+    }
+    for (const node of Array.from(g.document.querySelectorAll("picture source[srcset]"))) {
+      const source = node;
+      const srcset = source.getAttribute("srcset") || "";
+      for (const part of srcset.split(",")) {
+        const u = part.trim().split(/\s+/)[0];
+        if (u && !u.startsWith("data:")) imageUrls.push(u);
+      }
+    }
+    const bgUrls = [];
+    for (const el of Array.from(g.document.querySelectorAll("*"))) {
+      const bg = g.getComputedStyle(el).backgroundImage;
+      if (!bg || bg === "none") continue;
+      const re = /url\(\s*["']?([^"')]+)["']?\s*\)/g;
+      let m;
+      while (m = re.exec(bg)) {
+        const u = m[1];
+        if (u && !u.startsWith("data:")) bgUrls.push(u);
+      }
+    }
+    const hrefs = Array.from(g.document.querySelectorAll("a[href]")).map((a) => a.href).filter((h) => Boolean(h));
+    return { imageUrls, bgUrls, hrefs };
+  });
+}
+function mergeExtras(page, extras, pageUrl) {
+  const seen = new Set(page.images.map((i) => i.src));
+  const push = (raw, flags = {}) => {
+    try {
+      const abs = new URL(raw, pageUrl).href;
+      if (seen.has(abs) || abs.startsWith("data:")) return;
+      seen.add(abs);
+      page.images.push({ src: abs, alt: flags.alt || "", pageUrl, ...flags });
+    } catch {
+    }
+  };
+  for (const u of extras.imageUrls) push(u);
+  for (const u of extras.bgUrls) push(u);
+}
+async function captureHints(page) {
+  const raw = await page.evaluate(() => {
+    const g = globalThis;
+    const body = g.getComputedStyle(g.document.body);
+    const heading = g.document.querySelector("h1, h2");
+    const btn = g.document.querySelector("a[class*='btn'], button, [class*='cta']");
+    return {
+      fontBody: body.fontFamily,
+      fontDisplay: heading ? g.getComputedStyle(heading).fontFamily : body.fontFamily,
+      radius: btn ? g.getComputedStyle(btn).borderRadius : ""
+    };
+  });
+  const actionColors = await page.evaluate(() => {
+    const doc = globalThis.document;
+    const computed = globalThis.getComputedStyle;
+    return Array.from(doc.querySelectorAll('nav a, header a, button, a[class*="btn"], a[class*="cta"]')).slice(0, 40).flatMap((el) => {
+      const s = computed(el);
+      return [s.color, s.backgroundColor];
+    });
+  });
+  const brandColors = colorsFromComputedActions(actionColors, `${page.url()}: repeated computed navigation/action color (bounded 40 elements)`);
+  return { ...hintsFromComputed(raw), ...brandColors.length ? { brandColors } : {} };
+}
+async function captureStill(page, stillsDir, file, stills) {
+  mkdirSync(stillsDir, { recursive: true });
+  try {
+    await page.screenshot({ path: join(stillsDir, file), fullPage: false, type: "png" });
+    const rel = `onboarding/stills/${file}`;
+    if (!stills.includes(rel)) stills.push(rel);
+  } catch {
+  }
+}
+async function crawlSiteBrowser(startUrl, maxPages, kernelRoot, stillsDir, checkpointPath, fresh = false) {
+  const playwright = await loadPlaywright(kernelRoot);
+  const warnings = [];
+  const start = (() => {
+    try {
+      const u = new URL(startUrl);
+      u.hash = "";
+      if (u.pathname.length > 1) u.pathname = u.pathname.replace(/\/+$/, "");
+      return u.href;
+    } catch {
+      return startUrl;
+    }
+  })();
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [];
+  const discovery = /* @__PURE__ */ new Map();
+  enqueue(queue, seen, start, start, discovery, { provenance: "start" });
+  const fromSitemap = await sitemapUrls(start, warnings);
+  const sitemapPaths = new Set(fromSitemap.map((loc) => {
+    try {
+      return new URL(loc).pathname.replace(/\/+$/, "") || "/";
+    } catch {
+      return loc;
+    }
+  }));
+  for (const loc of fromSitemap) enqueue(queue, seen, loc, start, discovery, { provenance: "sitemap" });
+  const browser = await playwright.chromium.launch({ headless: true });
+  const context = await browser.newContext({
+    viewport: { width: 1440, height: 900 },
+    javaScriptEnabled: true
+  });
+  const pages = [];
+  const visited = /* @__PURE__ */ new Set();
+  const stills = [];
+  const exclusions = [];
+  const misses = [];
+  let hints;
+  if (checkpointPath && !fresh && existsSync2(checkpointPath)) {
+    const checkpoint2 = json(checkpointPath);
+    if (checkpoint2.start === start) {
+      pages.push(...checkpoint2.pages.filter((p) => !isErrorPage(p)));
+      queue.splice(0, queue.length, ...checkpoint2.queue);
+      for (const p of checkpoint2.pages.filter(isErrorPage)) warnings.push(`Excluded error page from resumed capture: ${p.url}`);
+      for (const url of checkpoint2.visited) visited.add(url);
+      for (const url of checkpoint2.seen) seen.add(url);
+      for (const [url, meta2] of checkpoint2.discovery || []) discovery.set(url, meta2);
+      warnings.push(...checkpoint2.warnings.filter((w) => !checkpoint2.queue.length || !/browser error|empty document|unvisited|transient/i.test(w)));
+      stills.push(...checkpoint2.stills);
+      hints = checkpoint2.hints;
+      exclusions.push(...checkpoint2.exclusions || []);
+      console.log(`Resuming captured crawl: ${pages.length} pages, ${queue.length} URLs pending`);
+    }
+  }
+  const snapshot = () => ({ version: 2, start, pages, queue, visited: [...visited], seen: [...seen], warnings, stills, hints, exclusions, discovery: [...discovery] });
+  const checkpoint = () => persistCheckpoint(checkpointPath, snapshot());
+  const retryUrls = [];
+  try {
+    while (queue.length) {
+      if (maxPages !== void 0 && pages.length >= maxPages) {
+        warnings.push(`Emergency maxPages=${maxPages} reached; ${queue.length} URL(s) left unvisited.`);
+        break;
+      }
+      const url = queue.shift();
+      if (visited.has(url)) continue;
+      queue.unshift(url);
+      checkpoint();
+      queue.shift();
+      visited.add(url);
+      const page = await context.newPage();
+      try {
+        const response = await page.goto(url, {
+          waitUntil: "domcontentloaded",
+          timeout: 3e4
+        });
+        if (response && !response.ok()) {
+          const status = response.status();
+          misses.push({
+            url,
+            status,
+            error: `HTTP ${status}`,
+            kind: status >= 500 ? "transport" : "http"
+          });
+          if (status >= 500) retryUrls.push(url);
+          continue;
+        }
+        const finalUrl = page.url();
+        if (!finalUrl.startsWith("http") || !sameSite(finalUrl, start)) {
+          misses.push({ url, error: finalUrl, kind: "non-http" });
+          continue;
+        }
+        await page.waitForTimeout(800);
+        try {
+          await page.waitForLoadState("networkidle", { timeout: 2e3 });
+        } catch {
+        }
+        await scrollPage(page);
+        const html = await page.content();
+        if (!html || html.length < 50) {
+          misses.push({ url, kind: "empty", error: "empty document" });
+          retryUrls.push(url);
+          continue;
+        }
+        const extracted = extractPage(html, finalUrl);
+        if (response && !response.ok() || isErrorPage(extracted)) {
+          misses.push({ url, kind: "error-page", error: "Soft error page" });
+          continue;
+        }
+        if (isErrorPage(extractPage(await page.content(), finalUrl))) {
+          misses.push({ url, kind: "error-page", error: "Soft error page" });
+          continue;
+        }
+        if (pages.some((p) => p.url === finalUrl)) continue;
+        const extras = await collectRenderedExtras(page);
+        mergeExtras(extracted, extras, finalUrl);
+        extracted.url = finalUrl;
+        const signature = (p) => JSON.stringify([p.title, p.description, p.headings, p.paragraphs]);
+        const duplicate = pages.find((p) => signature(p) === signature(extracted));
+        if (duplicate) {
+          extracted.aliasOf = duplicate.aliasOf || duplicate.url;
+          pages.push(extracted);
+          console.log(`  alias: ${finalUrl} \u2192 ${extracted.aliasOf}`);
+          continue;
+        }
+        pages.push(extracted);
+        console.log(`  page ${pages.length}: ${finalUrl} (${extracted.paragraphs.length} paras, ${extracted.images.length} images)`);
+        const priority = crawlPriority(finalUrl, start);
+        if (stillsDir && (priority === 0 || priority === 1)) {
+          await captureStill(page, stillsDir, priority === 0 ? "home.png" : "about.png", stills);
+        }
+        if (priority === 0 && !hints) {
+          try {
+            hints = await captureHints(page);
+          } catch {
+          }
+        }
+        for (const href of extras.hrefs) enqueue(queue, seen, href, start, discovery, { provenance: "nav", discoveredFrom: finalUrl });
+        for (const link of extracted.links) {
+          enqueue(queue, seen, link.href, start, discovery, {
+            provenance: link.relative ? "in-body-relative" : "nav",
+            discoveredFrom: finalUrl
+          });
+        }
+      } catch (err) {
+        retryUrls.push(url);
+        misses.push({ url, kind: "transport", error: err instanceof Error ? err.message : "error" });
+        console.warn(`  fail: ${url} \u2014 ${err instanceof Error ? err.message : "error"}`);
+      } finally {
+        await page.close().catch(() => void 0);
+        checkpoint();
+      }
+    }
+  } finally {
+    await context.close().catch(() => void 0);
+    await browser.close().catch(() => void 0);
+  }
+  if (!pages.length) warnings.push("Playwright crawl returned no HTML pages.");
+  const captured = capturedPathSet(pages);
+  for (const miss of misses) {
+    const exclusion = classifyMiss({ ...miss, discovery: discovery.get(miss.url), captured, sitemapPaths });
+    exclusions.push(exclusion);
+    warnings.push(formatExclusion(exclusion));
+  }
+  for (const url of retryUrls) {
+    visited.delete(url);
+    queue.push(url);
+  }
+  checkpoint();
+  for (const w of warnings) console.warn(`  warn: ${w}`);
+  return { startUrl: start, pages, warnings, engine: "playwright", hints, stills, exclusions, unvisited: [...queue] };
+}
+
+// scripts/onboard/images.ts
+import { createHash } from "node:crypto";
+import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "node:fs";
+import { basename, join as join2 } from "node:path";
+
+// src/onboard/classify.ts
+var STOCK_HOST = /unsplash\.com|images\.unsplash|pexels\.com|images\.pexels|pixabay\.com|cdn\.pixabay|shutterstock\.com|gettyimages|adobe\.stock|stock\.adobe|burst\.shopify|istockphoto|depositphotos|dreamstime|fotolia|smugmug\.com\/.*stock/i;
+var GENERIC_NAME = /handshake|laptop.?latte|coffee.?laptop|smiling.?team|diversity.?meeting|spa.?stones|marble.?texture|placeholder|spacer|dummy|default.?avatar|blank/i;
+var GENERIC_ALT = /^(alt.?text|image|photo|picture|img|untitled)$/i;
+var LOGO_HINT = /logo|brand.?mark|wordmark|logotype/i;
+var ICON_HINT = /icon|sprite|checkmark|arrow|chevron|social.?|facebook|instagram|twitter|linkedin|youtube|tiktok/i;
+var ILLUSTRATION_HINT = /illustrat|vector|isometric|cartoon|clipart|infographic|doodle|how-it-works|whats-included|what's included/i;
+var SCREENSHOT_HINT = /mockup|screenshot|device.?frame|laptop|browser|website of|responsive|portfolio/i;
+var PORTRAIT_HINT = /headshot|portrait|founder|team.?photo|staff|our team|meet the/i;
+var PRESS_HINT = /featured.?in|as.?seen|press.?logo|publication|badge/i;
+function isStockHost(src) {
+  try {
+    const host = new URL(src).hostname;
+    return STOCK_HOST.test(host) || STOCK_HOST.test(src);
+  } catch {
+    return STOCK_HOST.test(src);
+  }
+}
+function inferMediaType(img, role) {
+  if (role === "logo") return "logo";
+  if (role === "icon") return "icon";
+  const blob = `${img.src} ${img.alt} ${img.nearbyHeading || ""} ${img.pageUrl || ""}`;
+  if (PRESS_HINT.test(blob)) return "press";
+  if (PORTRAIT_HINT.test(blob) || /\/(about|team|meet)/i.test(img.pageUrl || "")) {
+    if (PORTRAIT_HINT.test(blob) || /headshot|portrait|founder|team/i.test(blob)) return "portrait";
+  }
+  if (SCREENSHOT_HINT.test(blob)) return "screenshot";
+  if (ILLUSTRATION_HINT.test(blob) || /\.svg(\?|$)/i.test(img.src)) return "illustration";
+  if (/\/(how-it-works|process)(\/|$)/i.test(img.pageUrl || "")) return "illustration";
+  if (PORTRAIT_HINT.test(blob)) return "portrait";
+  return "photo";
+}
+function classifyOne(img, opts = {}) {
+  const inChrome = Boolean(opts.inChrome ?? img.inChrome);
+  const fromJsonLdLogo = Boolean(opts.fromJsonLdLogo ?? img.fromJsonLdLogo);
+  const fromOg = Boolean(opts.fromOg ?? img.fromOg);
+  const aboveFold = Boolean(opts.aboveFold ?? img.aboveFold);
+  const srcAlt = `${img.src} ${img.alt}`;
+  const finish = (role, kind) => ({
+    ...img,
+    role,
+    kind,
+    mediaType: inferMediaType(img, role),
+    inChrome,
+    fromJsonLdLogo,
+    fromOg,
+    aboveFold
+  });
+  if (fromJsonLdLogo || LOGO_HINT.test(srcAlt) || inChrome && LOGO_HINT.test(img.alt || img.src)) {
+    return finish("logo", "business");
+  }
+  if (inChrome && (/\.svg(\?|$)/i.test(img.src) || img.width && img.height && img.width <= 400 && img.height <= 200)) {
+    if (!GENERIC_NAME.test(srcAlt)) return finish("logo", "business");
+  }
+  if (ICON_HINT.test(srcAlt) || img.width && img.height && img.width <= 96 && img.height <= 96) {
+    return finish("icon", "generic");
+  }
+  if (isStockHost(img.src) || GENERIC_NAME.test(srcAlt)) {
+    return finish(aboveFold || fromOg ? "hero" : "photo", isStockHost(img.src) ? "stock" : "generic");
+  }
+  const alt = img.alt.trim();
+  if (alt && (GENERIC_ALT.test(alt) || /^alt.?text$/i.test(alt))) {
+    return finish(aboveFold || fromOg ? "hero" : "photo", "generic");
+  }
+  return finish(aboveFold || fromOg ? "hero" : "photo", "business");
+}
+function classifyImages(images) {
+  const classified = images.map(
+    (img) => classifyOne(img, {
+      inChrome: img.inChrome,
+      fromJsonLdLogo: img.fromJsonLdLogo,
+      fromOg: img.fromOg,
+      aboveFold: img.aboveFold
+    })
+  );
+  const logos = classified.filter((c) => c.role === "logo");
+  if (logos.length > 1) {
+    const preferred = logos.find((l) => l.fromJsonLdLogo) || logos.find((l) => l.inChrome && LOGO_HINT.test(`${l.src} ${l.alt}`)) || logos[0];
+    for (const c of classified) {
+      if (c.role === "logo" && c.src !== preferred.src) {
+        c.role = "icon";
+        c.kind = c.kind === "business" ? "unknown" : c.kind;
+        c.mediaType = inferMediaType(c, "icon");
+      }
+    }
+  }
+  const heroes = classified.filter((c) => c.role === "hero");
+  if (heroes.length > 1) {
+    const preferred = heroes.find((h) => h.kind === "business" && (h.fromOg || h.aboveFold)) || heroes.find((h) => h.kind === "business") || heroes.find((h) => h.fromOg) || heroes[0];
+    for (const c of classified) {
+      if (c.role === "hero" && c.src !== preferred.src) {
+        c.role = "photo";
+        c.mediaType = inferMediaType(c, "photo");
+      }
+    }
+  } else if (heroes.length === 0) {
+    const candidate = classified.find((c) => c.kind === "business" && c.role === "photo" && (c.fromOg || c.aboveFold)) || classified.find((c) => c.kind === "business" && c.role === "photo") || classified.find((c) => c.role === "photo");
+    if (candidate) {
+      candidate.role = "hero";
+      candidate.mediaType = inferMediaType(candidate, "hero");
+    }
+  }
+  return classified;
+}
+
+// src/onboard/shortlist.ts
+var SHORTLIST_MIN = 8;
+var SHORTLIST_MAX = 20;
+var TYPE_CAPS = {
+  logo: 1,
+  screenshot: 4,
+  illustration: 4,
+  portrait: 3,
+  press: 2,
+  photo: 6,
+  icon: 2
+};
+function slugPart(raw) {
+  const s = raw.toLowerCase().replace(/['’]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+  return s || "asset";
+}
+function extFromImage(img) {
+  const fromKey = (img.r2Key || img.sourceUrl || img.src).match(/\.([a-z0-9]{3,4})(?:\?|$)/i);
+  const ext = (fromKey?.[1] || "png").toLowerCase();
+  return ext === "jpeg" ? "jpg" : ext;
+}
+function scoreShortlist(img) {
+  if (img.role === "failed" || img.error) return -1;
+  let n = 0;
+  if (img.role === "logo") n += 100;
+  if (img.role === "hero") n += 90;
+  if (img.mediaType === "screenshot") n += 40;
+  if (img.mediaType === "illustration") n += 38;
+  if (img.mediaType === "portrait") n += 36;
+  if (img.mediaType === "press") n += 28;
+  if (img.kind === "business") n += 20;
+  if (img.kind === "generic") n -= 8;
+  if (img.alt && !/^alt.?text$/i.test(img.alt)) n += 12;
+  if (img.nearbyHeading) n += 8;
+  if (img.aboveFold || img.fromOg) n += 10;
+  const w = img.width || 0;
+  const h = img.height || 0;
+  if (w >= 600 || h >= 400) n += 10;
+  if (img.mediaType === "icon") n -= 15;
+  return n;
+}
+function fileStemFor(img, used) {
+  const fromCaption = img.caption || img.nearbyHeading || img.alt;
+  let base = img.role === "logo" ? "logo" : img.role === "hero" ? "hero" : `${img.mediaType || "photo"}-${slugPart(fromCaption || img.r2Key.slice(-8) || "asset")}`;
+  if (used.has(base)) {
+    let i = 2;
+    while (used.has(`${base}-${i}`)) i += 1;
+    base = `${base}-${i}`;
+  }
+  used.add(base);
+  return base;
+}
+function selectShortlist(images) {
+  const ranked = images.filter((img) => scoreShortlist(img) >= 0).sort((a, b) => scoreShortlist(b) - scoreShortlist(a));
+  const picked = [];
+  const counts = {};
+  const take = (img) => {
+    const t = img.mediaType || img.role || "photo";
+    const cap = TYPE_CAPS[t] ?? 4;
+    counts[t] = (counts[t] || 0) + 1;
+    if (counts[t] > cap && picked.length >= SHORTLIST_MIN) return;
+    if (picked.includes(img)) return;
+    picked.push(img);
+  };
+  const logo = ranked.find((i) => i.role === "logo");
+  if (logo) take(logo);
+  const hero = ranked.find((i) => i.role === "hero" && i !== logo);
+  if (hero) take(hero);
+  for (const img of ranked) {
+    if (picked.length >= SHORTLIST_MAX) break;
+    take(img);
+  }
+  const used = /* @__PURE__ */ new Set();
+  for (const img of picked) {
+    img.shortlist = true;
+    const stem = fileStemFor(img, used);
+    img.thumbPath = `onboarding/thumbs/${stem}.${extFromImage(img)}`;
+    if (!img.caption) {
+      img.caption = [img.nearbyHeading, img.alt].filter(Boolean).join(" \u2014 ") || `${img.mediaType || img.role} from the old site (hint stem: ${stem})`;
+    }
+  }
+  return picked;
+}
+
+// scripts/onboard/images.ts
+var ua2 = "VitrisOnboard/0.1 (authorized site migration; https://vitris.local)";
+var MIN_BYTES = 4096;
+var MAX_BYTES = 8 * 1024 * 1024;
+function extFor(contentType, url) {
+  if (contentType.includes("png")) return "png";
+  if (contentType.includes("webp")) return "webp";
+  if (contentType.includes("gif")) return "gif";
+  if (contentType.includes("svg")) return "svg";
+  if (contentType.includes("jpeg") || contentType.includes("jpg")) return "jpg";
+  const fromUrl = url.match(/\.(jpe?g|png|webp|gif|svg)(\?|$)/i);
+  return (fromUrl?.[1] || "jpg").toLowerCase().replace("jpeg", "jpg");
+}
+async function download(url) {
+  try {
+    const res = await fetch(url, {
+      headers: { "user-agent": ua2, accept: "image/*,*/*;q=0.8" },
+      redirect: "follow",
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!res.ok) return null;
+    const contentType = (res.headers.get("content-type") || "").toLowerCase();
+    if (contentType && !contentType.startsWith("image/") && !contentType.includes("octet-stream")) {
+      return null;
+    }
+    const bytes = Buffer.from(await res.arrayBuffer());
+    return { bytes, contentType: contentType || "image/jpeg" };
+  } catch {
+    return null;
+  }
+}
+async function uploadImages(images, opts) {
+  const classified = classifyImages(images);
+  const out = [];
+  const seenHash = /* @__PURE__ */ new Map();
+  const cachePath = opts.captureKey ? join2(opts.kernelRoot, "scratch/onboard", opts.slug, `downloads-${opts.captureKey}.json`) : void 0;
+  const cached = cachePath && existsSync3(cachePath) ? json(cachePath) : [];
+  let remote = opts.remote;
+  if (opts.local === false && remote === false) {
+    console.log("Media is saved locally; no R2 publication requested.");
+  }
+  for (const img of classified) {
+    const previous = cached.find((c) => (c.sourceUrl === img.src || c.sourceUrls?.includes(img.src)) && c.scratchPath && existsSync3(c.scratchPath));
+    if (previous) {
+      if (!out.some((i) => i.scratchPath === previous.scratchPath)) out.push(previous);
+      continue;
+    }
+    const downloaded = await download(img.src);
+    if (!downloaded) {
+      out.push({
+        sourceUrl: img.src,
+        alt: img.alt,
+        r2Key: "",
+        src: img.src,
+        role: "failed",
+        kind: img.kind,
+        mediaType: img.mediaType,
+        pageUrl: img.pageUrl,
+        nearbyHeading: img.nearbyHeading,
+        width: img.width,
+        height: img.height,
+        error: "download failed"
+      });
+      continue;
+    }
+    if (downloaded.bytes.length > MAX_BYTES) {
+      out.push({
+        sourceUrl: img.src,
+        alt: img.alt,
+        r2Key: "",
+        src: img.src,
+        role: "failed",
+        kind: img.kind,
+        error: "file too large"
+      });
+      continue;
+    }
+    const isLogo = img.role === "logo" || img.fromJsonLdLogo;
+    if (downloaded.bytes.length < MIN_BYTES && !isLogo && !downloaded.contentType.includes("svg")) {
+      out.push({ sourceUrl: img.src, alt: img.alt, r2Key: "", src: img.src, role: "failed", kind: img.kind, error: "Small raster: inspect before inclusion" });
+      continue;
+    }
+    const hash = createHash("sha256").update(downloaded.bytes).digest("hex").slice(0, 16);
+    const duplicate = seenHash.get(hash);
+    if (duplicate) {
+      duplicate.sourceUrls = [.../* @__PURE__ */ new Set([...duplicate.sourceUrls || [duplicate.sourceUrl], img.src])];
+      continue;
+    }
+    const ext = extFor(downloaded.contentType, img.src);
+    const r2Key = `sites/${opts.slug}/media/${hash}.${ext}`;
+    const file = join2(opts.kernelRoot, "scratch", "onboard", opts.slug, `${hash}.${ext}`);
+    writeScratchFile(file, downloaded.bytes);
+    const contentType = downloaded.contentType.startsWith("image/") ? downloaded.contentType : `image/${ext === "jpg" ? "jpeg" : ext}`;
+    let uploaded = false;
+    if (opts.local) {
+      try {
+        putLocalR2(opts.kernelRoot, r2Key, file, contentType);
+        uploaded = true;
+      } catch (err) {
+        console.warn(`local R2 skipped for ${r2Key}: ${err instanceof Error ? err.message : "error"}`);
+      }
+    }
+    if (remote) {
+      try {
+        await putRemoteR2(r2Key, file, contentType);
+        uploaded = true;
+      } catch (err) {
+        console.warn(`remote R2 skipped for ${r2Key}: ${err instanceof Error ? err.message : "error"}`);
+        remote = false;
+      }
+    }
+    const brief = toBriefImage(img, {
+      r2Key: uploaded ? r2Key : "",
+      src: uploaded ? publicAssetUrl(r2Key) : img.src,
+      uploaded,
+      scratchPath: file,
+      hash,
+      ext
+    });
+    out.push(brief);
+    seenHash.set(hash, brief);
+    if (cachePath) save(cachePath, out.filter((i) => i.scratchPath));
+  }
+  promoteRoles(out);
+  const hints = selectShortlist(out);
+  console.log(`Harvest images: ${out.filter((i) => i.role !== "failed").length} stored; shortlist hint=${hints.length}`);
+  if (out.some((i) => i.role !== "failed" && i.r2Key) && assetsOrigin().includes("127.0.0.1")) {
+    console.warn(
+      "ASSETS_ORIGIN is local. All successful images are copied into media/harvest/; interpret picks the shortlist."
+    );
+  }
+  return out;
+}
+function toBriefImage(img, opts) {
+  const meta2 = {
+    mediaType: img.mediaType,
+    pageUrl: img.pageUrl,
+    nearbyHeading: img.nearbyHeading,
+    width: img.width,
+    height: img.height,
+    aboveFold: img.aboveFold,
+    fromOg: img.fromOg,
+    scratchPath: opts.scratchPath,
+    localPath: `/media/harvest/${opts.hash}.${opts.ext}`
+  };
+  return {
+    sourceUrl: img.src,
+    alt: img.alt,
+    r2Key: opts.r2Key,
+    src: opts.src,
+    role: img.role === "failed" ? "photo" : img.role,
+    kind: img.kind,
+    ...meta2
+  };
+}
+function copyHarvestToSite(siteRoot, images) {
+  const harvestDir = join2(siteRoot, "media", "harvest");
+  mkdirSync2(harvestDir, { recursive: true });
+  for (const img of images) {
+    if (img.role === "failed" || !img.scratchPath || !existsSync3(img.scratchPath)) continue;
+    const name = img.localPath ? basename(img.localPath) : basename(img.scratchPath);
+    const dest = join2(harvestDir, name);
+    copyFileSync(img.scratchPath, dest);
+    img.localPath = `/media/harvest/${name}`;
+    img.src = img.localPath;
+  }
+}
+function promoteRoles(images) {
+  const logos = images.filter((i) => i.role === "logo");
+  if (logos.length > 1) {
+    const keep = logos[0];
+    for (const img of images) {
+      if (img.role === "logo" && img.sourceUrl !== keep.sourceUrl) img.role = "icon";
+    }
+  }
+  const heroes = images.filter((i) => i.role === "hero");
+  if (heroes.length > 1) {
+    const keep = heroes.find((h) => h.kind === "business") || heroes[0];
+    for (const img of images) {
+      if (img.role === "hero" && img.sourceUrl !== keep.sourceUrl) img.role = "photo";
+    }
+  } else if (heroes.length === 0) {
+    const candidate = images.find((i) => i.kind === "business" && i.role === "photo") || images.find((i) => i.role === "photo");
+    if (candidate) candidate.role = "hero";
+  }
+}
+
+// scripts/onboard/run.ts
+function writeOnboardingArtifacts(dest, brief, extras) {
+  const dir = join3(dest, "onboarding");
+  mkdirSync3(dir, { recursive: true });
+  mkdirSync3(join3(dir, "copy"), { recursive: true });
+  writeFileSync(join3(dir, "brief.json"), `${JSON.stringify(briefForDisk(brief), null, 2)}
+`);
+  writeFileSync(join3(dir, "outline.md"), renderOutline({ brief }));
+  writeFileSync(join3(dir, "media.md"), renderMediaGuide(brief));
+  const audit = assembleAudit({
+    sourceUrl: brief.sourceUrl,
+    pages: extras?.pages || [],
+    crawledAt: brief.crawledAt
+  });
+  if (!extras?.pages?.length && brief.pages.length) {
+    audit.pages = brief.pages.map((p) => ({
+      url: p.url,
+      title: p.title,
+      description: p.description,
+      canonical: p.canonical,
+      lang: void 0,
+      h1Count: p.audit?.h1Count ?? 0,
+      missingAlts: p.audit?.missingAlts ?? 0,
+      unlabeledInputs: p.audit?.unlabeledInputs ?? 0,
+      hasCanonical: p.audit?.hasCanonical ?? false,
+      hasLang: p.audit?.hasLang ?? false,
+      hasJsonLd: p.audit?.hasJsonLd ?? false,
+      titleLength: p.audit?.titleLength ?? p.title.length,
+      descriptionLength: p.audit?.descriptionLength ?? p.description.length
+    }));
+    audit.summary = {
+      pageCount: audit.pages.length,
+      pagesMissingTitle: audit.pages.filter((p) => !p.title).length,
+      pagesMissingDescription: audit.pages.filter((p) => !p.description).length,
+      pagesMultipleH1: audit.pages.filter((p) => p.h1Count > 1).length,
+      pagesZeroH1: audit.pages.filter((p) => p.h1Count === 0).length,
+      totalMissingAlts: audit.pages.reduce((n, p) => n + p.missingAlts, 0),
+      totalUnlabeledInputs: audit.pages.reduce((n, p) => n + p.unlabeledInputs, 0)
+    };
+  }
+  writeFileSync(join3(dir, "audit.json"), `${JSON.stringify(audit, null, 2)}
+`);
+  const research = emptyResearch(brief.business.social || []);
+  writeFileSync(join3(dir, "research.json"), `${JSON.stringify(research, null, 2)}
+`);
+  writeFileSync(
+    join3(dir, "README.md"),
+    `# Onboarding harvest
+
+This folder is the crawl output for **${brief.business.name || brief.slug}**.
+
+| File | Purpose |
+|------|---------|
+| \`outline.md\` | Human-readable sitemap, facts, image catalog, gaps |
+| \`copy/*.md\` | Full visible copy per crawled URL |
+| \`brief.json\` | Machine index (facts, pages, images) |
+| \`audit.json\` | Crawl-time SEO/a11y inventory; \`webVitals\` filled by research node |
+| \`research.json\` | Reviews, social, goals \u2014 complete via the research graph node |
+| \`media.md\` | Harvest catalog + shortlist hints; the media node owns full asset disposition |
+| \`harvest-inventory.json\` | Kept pages, original-media files, failed downloads, classified exclusions |
+| \`harvest-scope.json\` | Optional operator bound (exclude classes / maxPages / notes) |
+
+## Next
+
+1. Build the evidence-backed business interpretation and review it.
+2. Inspect and account for all media, including acquisition failures.
+3. Follow the graph through direction, storyboard, copy, implementation, browser checks and independent reviews.
+
+All successful images live under \`media/harvest/\`. Theme tokens are established by the **direction** node (harvest only stores hints in brief.visual).
+
+See \`harvest-inventory.json\` for kept pages, original-media files, failed downloads, and an explicit class/reason for every exclusion (\`source-missing\`, \`crawler-invalid\`, \`off-site\`, \`error-page\`, \`transient\`). Operator bounds belong in \`harvest-scope.json\`.
+
+Source: ${brief.sourceUrl || "(blank starter)"}
+Engine note: see \`warnings\` in brief.json.
+`
+  );
+}
+function persistOnboard(dest, brief, extras) {
+  if (extras?.copyMarkdown) {
+    const copyDir = join3(dest, "onboarding", "copy");
+    mkdirSync3(copyDir, { recursive: true });
+    for (const { slug, markdown } of extras.copyMarkdown.values()) {
+      writeFileSync(join3(copyDir, `${slug}.md`), markdown.endsWith("\n") ? markdown : `${markdown}
+`);
+    }
+  }
+  copyHarvestToSite(dest, brief.images);
+  const rawDir = join3(dest, "onboarding", "raw");
+  mkdirSync3(rawDir, { recursive: true });
+  const capture = join3(rawDir, `${String(brief.crawledAt).replace(/[^a-zA-Z0-9-]/g, "-")}.json`);
+  if (!existsSync4(capture)) writeFileSync(capture, JSON.stringify(briefForDisk(brief), null, 2) + "\n");
+  if (brief.business.name) {
+    const sitePath = join3(dest, "site.json");
+    if (existsSync4(sitePath)) {
+      const site = JSON.parse(readFileSync(sitePath, "utf8"));
+      site.name = brief.business.name;
+      writeFileSync(sitePath, `${JSON.stringify(site, null, 2)}
+`);
+    }
+  }
+  writeOnboardingArtifacts(dest, brief, { pages: extras?.pages });
+  save(join3(dest, "onboarding", "harvest-inventory.json"), assembleHarvestInventory({
+    engine: extras?.engine || "playwright",
+    startUrl: brief.sourceUrl,
+    pages: extras?.pages || brief.pages,
+    exclusions: extras?.exclusions || [],
+    unvisited: extras?.unvisited || [],
+    siteRoot: dest,
+    images: brief.images
+  }));
+}
+function briefForDisk(brief) {
+  return {
+    ...brief,
+    images: brief.images.map(({ scratchPath: _drop, ...img }) => img)
+  };
+}
+async function crawlWithFallback(sourceUrl, maxPages, fetchOnly, kernelRoot, stillsDir, checkpointPath, fresh = false) {
+  if (fetchOnly) {
+    const crawl = await crawlSite(sourceUrl, maxPages, checkpointPath, fresh);
+    return crawl;
+  }
+  try {
+    console.log("Crawling with Playwright (rendered DOM)\u2026");
+    return await crawlSiteBrowser(sourceUrl, maxPages, kernelRoot, stillsDir, checkpointPath, fresh);
+  } catch (err) {
+    if (!isPlaywrightLaunchFailure(err)) throw err;
+    const msg = err instanceof Error ? err.message : String(err);
+    console.warn(`Playwright crawl unavailable (${msg}). Falling back to fetch HTML crawl.`);
+    const crawl = await crawlSite(sourceUrl, maxPages, checkpointPath, fresh);
+    crawl.warnings.unshift(`Playwright unavailable \u2014 used fetch fallback. ${msg}`);
+    return crawl;
+  }
+}
+async function gatherOnboard(opts) {
+  const crawl = await crawlWithFallback(
+    opts.sourceUrl,
+    opts.maxPages,
+    Boolean(opts.fetchOnly),
+    opts.kernelRoot,
+    join3(opts.siteRoot, "onboarding", "stills"),
+    join3(opts.siteRoot, "onboarding", "crawl-progress.json"),
+    Boolean(opts.fresh)
+  );
+  console.log(`Crawled ${crawl.pages.length} page(s) from ${crawl.startUrl} via ${crawl.engine}`);
+  if (crawl.warnings.length) {
+    for (const w of crawl.warnings) console.warn(`  warn: ${w}`);
+  }
+  const copyMarkdown = buildCopyFiles(crawl.pages);
+  const copyFiles = /* @__PURE__ */ new Map();
+  for (const [url, { slug }] of copyMarkdown) {
+    copyFiles.set(url, `${slug}.md`);
+  }
+  let images = [];
+  if (!opts.skipImages) {
+    const candidates = collectCandidateImages(crawl.pages);
+    const hasRemote = false;
+    console.log(`Downloading ${candidates.length} unique image candidate(s)\u2026`);
+    images = await uploadImages(candidates, {
+      kernelRoot: opts.kernelRoot,
+      slug: opts.slug,
+      local: false,
+      remote: hasRemote,
+      captureKey: createHash2("sha256").update(JSON.stringify(crawl.pages)).digest("hex").slice(0, 20)
+    });
+    const ok = images.filter((i) => i.scratchPath).length;
+    console.log(`Images: ${ok} downloaded locally, ${images.length - ok} skipped or failed`);
+  }
+  let brief = assembleBrief({
+    sourceUrl: crawl.startUrl,
+    slug: opts.slug,
+    pages: crawl.pages,
+    images,
+    warnings: crawl.warnings,
+    seed: opts.name ? { name: opts.name } : void 0,
+    copyFiles
+  });
+  if (brief.visual) {
+    brief.visual = {
+      ...brief.visual,
+      hints: crawl.hints || brief.visual.hints,
+      stills: crawl.stills?.length ? crawl.stills : brief.visual.stills
+    };
+  }
+  brief.business = await promptMissingFacts(brief.business, { noPrompt: opts.noPrompt });
+  brief.missing = missingCritical(brief.business);
+  if (brief.visual) {
+    brief.visual.register = inferRegister(crawl.pages, brief.business);
+  }
+  return { brief, pages: crawl.pages, copyMarkdown, crawl };
+}
+async function gatherBlankOnboard(opts) {
+  let brief = assembleBrief({
+    sourceUrl: "",
+    slug: opts.slug,
+    pages: [],
+    seed: { name: opts.name },
+    warnings: ["Blank starter \u2014 no existing URL crawled."]
+  });
+  brief.business = await promptMissingFacts(brief.business, { noPrompt: opts.noPrompt });
+  brief.missing = missingCritical(brief.business);
+  return { brief, pages: [], copyMarkdown: /* @__PURE__ */ new Map() };
+}
+
+export {
+  normalizeSourceUrl,
+  promptSourceUrl,
+  persistOnboard,
+  gatherOnboard,
+  gatherBlankOnboard
+};