@elitedcs/ghl-mcp 3.55.0 → 3.57.0

package/skills/clone-site/scripts/substitute.mjs

@@ -0,0 +1,418 @@
+#!/usr/bin/env node
+/**
+ * substitute.mjs — rebrand by literal string substitution across HTML, CSS and
+ * JS bundles. The model builds the facts map; this script does the replacing,
+ * so no page content is ever regenerated from memory.
+ *
+ * Derives the tokens that naive clones leak (all live-proven failures):
+ *   - the BARE brand word ("Genesis" survived 41 times after "Genesis Red Light")
+ *   - every phone format, including tel: links
+ *   - the address as a UNIT (city-only replacement produced new city + old street)
+ *   - domain / www / bare-domain / email
+ *
+ * Asset filenames are PROTECTED: replacing "genesis" inside /genesis-logo.png
+ * would break a ref to a file that is on disk under its original name.
+ *
+ * Usage:
+ *   node substitute.mjs --dir <clone-dir> --facts facts.json            # dry run (default)
+ *   node substitute.mjs --dir <clone-dir> --facts facts.json --apply
+ *   node substitute.mjs --dir <clone-dir> --facts facts.json --emit tokens.json
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parseArgs, readJson, writeJson, walk, isTextFile, ext, nowIso, resolveRun } from "./lib.mjs";
+
+const args = parseArgs(process.argv.slice(2));
+if (!args.dir || !args.facts) {
+  console.error("usage: substitute.mjs --dir <clone-dir> --facts <facts.json> [--apply] [--emit tokens.json]");
+  process.exit(1);
+}
+const RUN = resolveRun(String(args.dir));
+const DIR = RUN.site;          // only the deployable site is ever rewritten
+const REPORTS = RUN.reports;   // tool artifacts live outside the deploy folder
+const APPLY = args.apply === true;
+const facts = readJson(path.resolve(String(args.facts)));
+
+const GENERIC_WORDS = new Set([
+  "the", "and", "for", "llc", "inc", "co", "company", "group", "clinic", "center", "centre",
+  "med", "spa", "wellness", "health", "care", "studio", "labs", "lab", "solutions", "services",
+]);
+
+const tokens = [];
+function push(label, oldVal, newVal, opts = {}) {
+  if (!oldVal || typeof oldVal !== "string") return;
+  const o = oldVal.trim();
+  if (!o) return;
+  const n = typeof newVal === "string" ? newVal : "";
+  tokens.push({ label, old: o, new: n, ...opts });
+}
+
+function phoneFormats(raw) {
+  const d = String(raw || "").replace(/\D/g, "");
+  const ten = d.length === 11 && d.startsWith("1") ? d.slice(1) : d;
+  if (ten.length !== 10) return [];
+  const [a, b, c] = [ten.slice(0, 3), ten.slice(3, 6), ten.slice(6)];
+  return [
+    `+1${ten}`, `+1 ${a} ${b} ${c}`, `1${ten}`, ten,
+    `(${a}) ${b}-${c}`, `(${a})${b}-${c}`, `(${a})-${b}-${c}`, `(${a}) ${b}.${c}`,
+    `${a}-${b}-${c}`, `${a}.${b}.${c}`, `${a} ${b} ${c}`,
+  ];
+}
+
+function addressUnit(addr) {
+  if (!addr || typeof addr !== "object") return [];
+  const { street, suite, city, state, zip } = addr;
+  const out = [];
+  const full = [street, suite, city, [state, zip].filter(Boolean).join(" ")].filter(Boolean).join(", ");
+  if (full) out.push({ v: full, k: "address (full unit)" });
+  if (street) out.push({ v: suite ? `${street} ${suite}` : street, k: "street" });
+  if (street) out.push({ v: street, k: "street (bare)" });
+  if (city && state) out.push({ v: `${city}, ${state}`, k: "city, state" });
+  if (city) out.push({ v: city, k: "city" });
+  if (zip) out.push({ v: String(zip), k: "zip" });
+  return out;
+}
+
+const oldF = facts.old || {};
+const newF = facts.new || {};
+
+// --- company + bare brand word ---------------------------------------------
+push("company", oldF.company, newF.company);
+if (oldF.company) {
+  const bare = String(oldF.company).split(/[\s,]+/)[0];
+  const newBare = String(newF.company || "").split(/[\s,]+/)[0];
+  if (facts.deriveBareWord !== false && bare.length >= 4 && !GENERIC_WORDS.has(bare.toLowerCase()) && bare !== oldF.company) {
+    push("company (bare word — the one that leaks)", bare, newBare, { bareWord: true });
+  }
+}
+for (const alias of oldF.aliases || []) push("company alias", alias, newF.company);
+
+// --- owner / staff names ----------------------------------------------------
+for (const [i, name] of (oldF.people || (oldF.owner ? [oldF.owner] : [])).entries()) {
+  const replacement = (newF.people || (newF.owner ? [newF.owner] : []))[i] || newF.owner || "";
+  push("person name", name, replacement, { review: !replacement });
+}
+
+// --- phone ------------------------------------------------------------------
+const oldPhones = oldF.phones || (oldF.phone ? [oldF.phone] : []);
+const newPhones = newF.phones || (newF.phone ? [newF.phone] : []);
+for (const [i, p] of oldPhones.entries()) {
+  const oldFmts = phoneFormats(p);
+  const newFmts = phoneFormats(newPhones[i] || newPhones[0] || "");
+  for (const [j, of_] of oldFmts.entries()) push("phone", of_, newFmts[j] || "");
+}
+
+// --- email / domain ---------------------------------------------------------
+for (const [i, e] of (oldF.emails || (oldF.email ? [oldF.email] : [])).entries()) {
+  push("email", e, (newF.emails || (newF.email ? [newF.email] : []))[i] || newF.email || "");
+}
+if (oldF.domain) {
+  const od = String(oldF.domain).replace(/^https?:\/\//, "").replace(/\/$/, "");
+  const nd = String(newF.domain || "").replace(/^https?:\/\//, "").replace(/\/$/, "");
+  push("domain (www)", `www.${od}`, nd ? `www.${nd}` : "");
+  push("domain", od, nd);
+}
+
+// --- address ----------------------------------------------------------------
+{
+  const oldParts = addressUnit(oldF.address);
+  const newParts = addressUnit(newF.address);
+  for (const [i, part] of oldParts.entries()) push(part.k, part.v, (newParts[i] || {}).v || "");
+}
+
+// --- explicit extras, colors, fonts ----------------------------------------
+for (const pair of facts.extra || []) push(pair.label || "extra", pair.old, pair.new);
+for (const [o, n] of Object.entries(facts.colors || {})) {
+  push("color", o, n);
+  push("color", o.toUpperCase(), n.toUpperCase());
+  push("color", o.toLowerCase(), n.toLowerCase());
+}
+for (const [o, n] of Object.entries(facts.fonts || {})) push("font", o, n);
+
+/**
+ * HTML-entity variants. A brand containing & " ' < > is stored encoded in the
+ * markup — `Arizona AC &amp; Heating` — so the plain token matches nothing and
+ * the brand survives untouched. Live-caught 2026-07-30 on a real HVAC site.
+ */
+function htmlEncode(v) {
+  return v.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+for (const t of [...tokens]) {
+  const encOld = htmlEncode(t.old);
+  if (encOld !== t.old) tokens.push({ ...t, old: encOld, new: htmlEncode(t.new), label: `${t.label} (HTML-encoded)` });
+}
+
+// Longest first so "Genesis Red Light" is consumed before bare "Genesis".
+tokens.sort((a, b) => b.old.length - a.old.length);
+const seen = new Set();
+const plan = tokens.filter((t) => {
+  const k = t.old;
+  if (seen.has(k)) return false;
+  seen.add(k);
+  return true;
+});
+
+// --- protected strings: never rewrite a path to a file on disk --------------
+const protectedStrings = new Set();
+const reportPath = path.join(REPORTS, "run-report.json");
+if (fs.existsSync(reportPath)) {
+  const rep = readJson(reportPath);
+  for (const a of rep.assets || []) {
+    protectedStrings.add("/" + a.local);
+    protectedStrings.add(a.local);
+    protectedStrings.add(path.posix.basename(a.local));
+  }
+}
+const protectedList = [...protectedStrings].filter(Boolean).sort((a, b) => b.length - a.length);
+
+function protect(text) {
+  const marks = [];
+  let out = text;
+  protectedList.forEach((p, i) => {
+    if (!out.includes(p)) return;
+    const mark = `__CLONE_PROTECT_${i}__`;
+    out = out.split(p).join(mark);
+    marks.push([mark, p]);
+  });
+  return { out, marks };
+}
+function unprotect(text, marks) {
+  let out = text;
+  for (const [mark, original] of marks) out = out.split(mark).join(original);
+  return out;
+}
+
+/**
+ * Rendered text of an HTML file, with every character mapped back to its offset
+ * in the source. A brand mark is very often split across a tag for two-tone
+ * styling — `GHL <span style="color:#D4AF37">Command</span>` reads as
+ * "GHL Command" on screen but contains no such string in the file, so literal
+ * replacement can never reach it and a naive zero-check reports a false clean.
+ * Live-caught 2026-07-30 on a real proof run against a production page.
+ *
+ * Counting occurrences before/after tag-stripping does NOT work: text inside
+ * attributes disappears when tags are stripped, cancelling out the split gain.
+ * The offset map makes the test exact.
+ */
+function renderedWithMap(html) {
+  // Blank script/style/comment bodies, preserving length so offsets stay true.
+  const blanked = html.replace(/<script[\s\S]*?<\/script>|<style[\s\S]*?<\/style>|<!--[\s\S]*?-->/gi, (m) =>
+    " ".repeat(m.length)
+  );
+  const chars = [];
+  const map = [];
+  let inTag = false;
+  for (let i = 0; i < blanked.length; i++) {
+    const c = blanked[i];
+    if (inTag) {
+      if (c === ">") inTag = false;
+      continue;
+    }
+    if (c === "<") {
+      inTag = true;
+      continue;
+    }
+    chars.push(c);
+    map.push(i);
+  }
+  return { text: chars.join(""), map };
+}
+
+/**
+ * Occurrences a visitor reads as `token` but which are NOT a contiguous literal
+ * run in the file — i.e. markup sits inside the brand name.
+ */
+function splitAcrossTags(html, token) {
+  const { text, map } = renderedWithMap(html);
+  const snippets = [];
+  let count = 0;
+  let idx = text.indexOf(token);
+  while (idx !== -1) {
+    const srcStart = map[idx];
+    const srcEnd = map[idx + token.length - 1];
+    if (srcEnd - srcStart + 1 !== token.length) {
+      count++;
+      if (snippets.length < 3) {
+        snippets.push(html.slice(srcStart, srcEnd + 1).replace(/\s+/g, " ").trim().slice(0, 150));
+      }
+    }
+    idx = text.indexOf(token, idx + token.length);
+  }
+  return count > 0 ? { extra: count, snippets } : null;
+}
+
+// --- scan / apply -----------------------------------------------------------
+const files = walk(DIR).filter((f) => isTextFile(f));
+const counts = new Map(plan.map((t) => [t.old, { token: t, total: 0, files: [] }]));
+
+let changedFiles = 0;
+const splitHits = [];
+for (const file of files) {
+  let text = fs.readFileSync(file, "utf8");
+  if ([".html", ".htm"].includes(ext(file))) {
+    for (const t of plan) {
+      if (!t.new) continue;
+      const split = splitAcrossTags(text, t.old);
+      if (split) splitHits.push({ file: path.relative(DIR, file), token: t, ...split });
+    }
+  }
+  const { out: guarded, marks } = protect(text);
+  let working = guarded;
+  let fileTouched = false;
+  for (const t of plan) {
+    const parts = working.split(t.old);
+    const hits = parts.length - 1;
+    if (hits === 0) continue;
+    const rec = counts.get(t.old);
+    rec.total += hits;
+    rec.files.push({ file: path.relative(DIR, file), hits });
+    if (APPLY && t.new) {
+      working = parts.join(t.new);
+      fileTouched = true;
+    }
+  }
+  if (APPLY && fileTouched) {
+    fs.writeFileSync(file, unprotect(working, marks));
+    changedFiles++;
+  }
+}
+
+// --- output -----------------------------------------------------------------
+const rows = [...counts.values()].filter((r) => r.total > 0);
+const zero = [...counts.values()].filter((r) => r.total === 0);
+const missingNew = rows.filter((r) => !r.token.new);
+
+const lines = [];
+lines.push("");
+lines.push(APPLY ? "SUBSTITUTION APPLIED" : "SUBSTITUTION DRY RUN (nothing written — add --apply to write)");
+lines.push(`  site dir: ${DIR}`);
+lines.push(`  text files scanned: ${files.length}   protected asset paths: ${protectedList.length}`);
+lines.push("");
+lines.push("  hits  label                                old  →  new");
+lines.push("  ----  -----------------------------------  ----------------------------------------");
+for (const r of rows.sort((a, b) => b.total - a.total)) {
+  const arrow = r.token.new ? `${r.token.old}  →  ${r.token.new}` : `${r.token.old}  →  ⚠ NO REPLACEMENT GIVEN`;
+  lines.push(`  ${String(r.total).padStart(4)}  ${r.token.label.padEnd(35).slice(0, 35)}  ${arrow}`);
+}
+const bareRows = rows.filter((r) => r.token.bareWord && r.total > 0);
+if (bareRows.length) {
+  lines.push("");
+  lines.push("  ⚠ BARE BRAND WORD — check this one before approving. It catches the occurrences a full-");
+  lines.push("    phrase list misses, but if the word is also a place or a common noun it will rewrite");
+  lines.push("    ordinary sentences (\"Arizona homeowners\" → \"Northgate homeowners\").");
+  for (const r of bareRows) lines.push(`      "${r.token.old}" → "${r.token.new}" — ${r.total} occurrence(s). Set "deriveBareWord": false in facts.json to skip it.`);
+}
+if (missingNew.length) {
+  lines.push("");
+  lines.push(`  ⚠ ${missingNew.length} token(s) present in the page with no replacement value.`);
+  lines.push("    They will be LEFT AS THE ORIGINAL OWNER'S — supply a value or accept them in the audit.");
+}
+// Near-miss check: a zero-hit token that DOES appear case-insensitively (or with
+// different whitespace/punctuation) means the fact is slightly wrong — the exact
+// way brands leak through a "complete" substitution list.
+const nearMisses = [];
+if (zero.length) {
+  const corpus = files.map((f) => protect(fs.readFileSync(f, "utf8")).out).join("\n");
+  const loose = (s) => s.toLowerCase().replace(/[\s,.'’-]+/g, " ").trim();
+  const looseCorpus = loose(corpus);
+  for (const z of zero) {
+    const needle = loose(z.token.old);
+    if (!needle) continue;
+    // Suppress the noise case: a shorter token whose loose form is already
+    // contained in a token that DID match exactly (e.g. "Elite DCs" inside
+    // "Elite DCS LLC") is covered, not leaking.
+    const coveredByMatched = rows.some((r) => loose(r.token.old).includes(needle));
+    if (coveredByMatched) continue;
+    const hits = looseCorpus.split(needle).length - 1;
+    if (hits > 0) nearMisses.push({ token: z.token, hits });
+  }
+}
+if (nearMisses.length) {
+  lines.push("");
+  lines.push(`  ⚠ NEAR MISS — ${nearMisses.length} token(s) do not match exactly but DO appear in the page`);
+  lines.push("    with different case, spacing or punctuation. Fix the fact or they will survive:");
+  for (const n of nearMisses) lines.push(`      ${n.token.label}: "${n.token.old}" — ${n.hits} loose match(es)`);
+}
+const trulyAbsent = zero.filter((z) => !nearMisses.some((n) => n.token.old === z.token.old));
+if (trulyAbsent.length) {
+  lines.push("");
+  lines.push(`  ${trulyAbsent.length} token(s) never appear in the page (fine — or the fact is wrong):`);
+  for (const z of trulyAbsent.slice(0, 12)) lines.push(`      ${z.token.label}: ${z.token.old}`);
+}
+if (splitHits.length) {
+  lines.push("");
+  lines.push("  ⚠ SPLIT ACROSS TAGS — these read as the old brand ON SCREEN but are broken up by");
+  lines.push("    markup in the file (a two-tone brand mark, usually). String replacement CANNOT");
+  lines.push("    reach them. Edit these by hand before deploying:");
+  for (const h of splitHits) {
+    lines.push(`      ${h.file}: "${h.token.old}" ×${h.extra} → should read "${h.token.new}"`);
+    for (const sn of h.snippets) lines.push(`         …${sn}…`);
+  }
+}
+if (APPLY) {
+  lines.push("");
+  lines.push(`  files rewritten: ${changedFiles}`);
+  // zero-check: any old token still present?
+  const residual = [];
+  for (const file of files) {
+    const text = fs.readFileSync(file, "utf8");
+    const { out: guarded } = protect(text);
+    for (const t of plan) {
+      if (!t.new) continue;
+      const hits = guarded.split(t.old).length - 1;
+      if (hits > 0) residual.push({ file: path.relative(DIR, file), token: t.old, hits });
+    }
+  }
+  // Re-check the RENDERED text too — a tag-split brand mark survives replacement
+  // and would otherwise pass a literal-only zero-check.
+  const residualSplit = [];
+  for (const file of files) {
+    if (![".html", ".htm"].includes(ext(file))) continue;
+    const text = fs.readFileSync(file, "utf8");
+    for (const t of plan) {
+      if (!t.new) continue;
+      const split = splitAcrossTags(text, t.old);
+      if (split) residualSplit.push({ file: path.relative(DIR, file), token: t.old, hits: split.extra });
+    }
+  }
+  const clean = residual.length === 0 && residualSplit.length === 0;
+  lines.push(
+    clean
+      ? "  ZERO-CHECK: no replaced token survives in the clone, in the file OR on screen. ✅"
+      : `  ZERO-CHECK FAILED: ${residual.length + residualSplit.length} residual occurrence(s) — investigate before deploying:`
+  );
+  for (const r of residual.slice(0, 15)) lines.push(`      ${r.file}: "${r.token}" ×${r.hits}`);
+  for (const r of residualSplit.slice(0, 15)) lines.push(`      ${r.file}: "${r.token}" ×${r.hits}  (SPLIT ACROSS TAGS — visible on screen, needs a hand edit)`);
+}
+lines.push("");
+lines.push("  NEXT: audit.mjs — the pre-launch REVIEW REQUIRED report (mandatory, never skipped).");
+lines.push("");
+console.log(lines.join("\n"));
+
+if (args.emit && args.emit !== true) {
+  writeJson(path.resolve(String(args.emit)), { generatedAt: nowIso(), applied: APPLY, tokens: plan, counts: rows });
+}
+// A re-run over already-substituted files finds zero hits. Never let that erase
+// the record of what WAS replaced — verify.mjs checks the live page against it.
+const reportFile = path.join(REPORTS, "substitution-report.json");
+let priorHits = [];
+try {
+  priorHits = readJson(reportFile).hits || [];
+} catch {}
+const freshHits = rows.map((r) => ({ label: r.token.label, old: r.token.old, new: r.token.new, total: r.total, files: r.files }));
+const mergedHits = [...freshHits];
+for (const prior of priorHits) {
+  if (!mergedHits.some((h) => h.old === prior.old)) mergedHits.push({ ...prior, fromEarlierRun: true });
+}
+
+writeJson(reportFile, {
+  generatedAt: nowIso(),
+  applied: APPLY,
+  dir: DIR,
+  tokens: plan,
+  hits: mergedHits,
+  splitAcrossTags: splitHits.map((h) => ({ file: h.file, old: h.token.old, new: h.token.new, count: h.extra, snippets: h.snippets })),
+  nearMisses: nearMisses.map((n) => ({ label: n.token.label, old: n.token.old, looseHits: n.hits })),
+  neverFound: trulyAbsent.map((z) => ({ label: z.token.label, old: z.token.old })),
+});

package/skills/clone-site/scripts/verify.mjs

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+/**
+ * verify.mjs — verify the DEPLOYED clone, not the local folder.
+ *
+ * Static hosts return 200 + the SPA shell for a missing asset, so a status code
+ * proves nothing (live-proven on Cloudflare Pages). Every asset is checked by
+ * CONTENT-TYPE. Old brand tokens must be gone; new ones must be present.
+ *
+ * Usage:
+ *   node verify.mjs --url https://<deployed> [--dir <clone-dir>] [--json out.json]
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+  parseArgs, fetchText, fetchRaw, mapLimit, ext, isAssetUrl, contentTypeMatches, readJson, writeJson, nowIso, resolveRun,
+} from "./lib.mjs";
+
+const args = parseArgs(process.argv.slice(2));
+if (!args.url) {
+  console.error("usage: verify.mjs --url <deployed-url> [--dir <clone-dir>] [--json out.json]");
+  process.exit(1);
+}
+const URL_ = String(args.url);
+const RUN = args.dir && args.dir !== true ? resolveRun(String(args.dir)) : null;
+const REPORTS = RUN ? RUN.reports : null;
+
+function refsFrom(text, kind) {
+  const refs = new Set();
+  if (kind === "html") {
+    for (const m of text.matchAll(/(?:src|href|poster)=["']([^"']+)["']/gi)) refs.add(m[1]);
+    for (const m of text.matchAll(/srcset=["']([^"']+)["']/gi))
+      for (const part of m[1].split(",")) { const u = part.trim().split(/\s+/)[0]; if (u) refs.add(u); }
+  }
+  for (const m of text.matchAll(/url\(([^)]+)\)/gi)) refs.add(m[1].trim().replace(/^['"]|['"]$/g, ""));
+  if (kind === "js") {
+    const mediaExt = "png|jpe?g|webp|gif|svg|avif|ico|mp4|webm|mov|mp3|woff2?|ttf|otf";
+    for (const m of text.matchAll(new RegExp(`["'\`](/[A-Za-z0-9._/-]+?\\.(?:${mediaExt}))["'\`]`, "gi"))) refs.add(m[1]);
+  }
+  return [...refs];
+}
+
+async function main() {
+  const base = new URL(URL_);
+  const page = await fetchText(URL_);
+  if (!page.ok || !page.text) {
+    console.error(`FAIL: could not fetch ${URL_} (status ${page.status})`);
+    process.exit(2);
+  }
+
+  // Collect refs from the deployed HTML, then from every deployed CSS/JS.
+  const candidates = new Map(); // absolute url -> where it came from
+  for (const r of refsFrom(page.text, "html")) {
+    if (!r || r.startsWith("data:") || r.startsWith("#") || r.startsWith("mailto:") || r.startsWith("tel:")) continue;
+    try {
+      const a = new URL(r, URL_).toString();
+      if (isAssetUrl(a)) candidates.set(a, "html");
+    } catch {}
+  }
+
+  const texts = [{ url: URL_, text: page.text }];
+  const codeUrls = [...candidates.keys()].filter((u) => [".css", ".js", ".mjs"].includes(ext(u)));
+  const codeBodies = await mapLimit(codeUrls, 6, async (u) => ({ u, r: await fetchText(u) }));
+  for (const { u, r } of codeBodies) {
+    if (!r.ok) continue;
+    texts.push({ url: u, text: r.text });
+    for (const ref of refsFrom(r.text, ext(u) === ".css" ? "css" : "js")) {
+      try {
+        const a = new URL(ref, ext(u) === ".css" ? u : base.origin + "/").toString();
+        if (isAssetUrl(a) && new URL(a).origin === base.origin) candidates.set(a, path.basename(u));
+      } catch {}
+    }
+  }
+
+  // Refs the SOURCE page was already serving badly — inherited, not caused by
+  // the clone. Reported, but they do not fail the run: redeploying cannot fix
+  // a file the original site does not have either.
+  const inheritedBad = new Set();
+  if (REPORTS) {
+    try {
+      const mirror = readJson(path.join(REPORTS, "run-report.json"));
+      for (const f of [...(mirror.failed || []), ...(mirror.skippedForeignOrMissing || [])]) {
+        try { inheritedBad.add(new URL(f.url).pathname); } catch {}
+      }
+    } catch {}
+  }
+
+  // Content-type check on every same-origin asset. A single transient answer
+  // (CDN rollout, a burst rate-limit) must not be reported as a broken asset —
+  // check twice before calling it, and keep concurrency modest.
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  const probe = async (u) => {
+    const res = await fetchRaw(u, 30000);
+    const e = ext(u);
+    return { res, ok: res.ok && contentTypeMatches(e, res.contentType) && res.buf.length > 0 };
+  };
+  const list = [...candidates.entries()].filter(([u]) => new URL(u).origin === base.origin);
+  const checked = await mapLimit(list, 4, async ([u, from]) => {
+    let attempt = await probe(u);
+    let retried = false;
+    if (!attempt.ok) {
+      retried = true;
+      await sleep(1200);
+      attempt = await probe(u);
+    }
+    const { res, ok } = attempt;
+    let inherited = false;
+    try { inherited = !ok && inheritedBad.has(new URL(u).pathname); } catch {}
+    return {
+      url: u, from, status: res.status, contentType: res.contentType,
+      bytes: res.buf.length, ok, retried, inherited,
+    };
+  });
+  const broken = checked.filter((c) => !c.ok && !c.inherited);
+  const inherited = checked.filter((c) => !c.ok && c.inherited);
+
+  // Token checks against the substitution report, if present.
+  const tokenRows = [];
+  if (REPORTS) {
+    let subs = null;
+    try { subs = readJson(path.join(REPORTS, "substitution-report.json")); } catch {}
+    if (subs) {
+      const allText = texts.map((t) => t.text).join("\n");
+      const assetPaths = new Set();
+      try {
+        const mirror = readJson(path.join(REPORTS, "run-report.json"));
+        for (const a of mirror.assets || []) assetPaths.add("/" + a.local);
+      } catch {}
+      let guarded = allText;
+      for (const p of [...assetPaths].sort((a, b) => b.length - a.length)) guarded = guarded.split(p).join(" ");
+      // Rendered text catches a brand mark split across tags — invisible to a
+      // literal search, plainly visible to a visitor.
+      const renderedAll = texts
+        .map((t) => t.text)
+        .join("\n")
+        .replace(/<script[\s\S]*?<\/script>/gi, " ")
+        .replace(/<style[\s\S]*?<\/style>/gi, " ")
+        .replace(/<[^>]+>/g, "");
+      for (const h of subs.hits || []) {
+        if (!h.new) continue;
+        const oldHits = guarded.split(h.old).length - 1;
+        const newHits = guarded.split(h.new).length - 1;
+        const renderedOld = renderedAll.split(h.old).length - 1;
+        tokenRows.push({
+          label: h.label, old: h.old, new: h.new, oldHits, newHits,
+          renderedOld,
+          ok: oldHits === 0 && renderedOld === 0 && newHits > 0,
+        });
+      }
+    }
+  }
+  const tokenFails = tokenRows.filter((t) => !t.ok);
+
+  const out = [];
+  out.push("");
+  out.push(`VERIFY  ${URL_}`);
+  out.push(`  assets checked (content-type, not status code): ${checked.length}`);
+  out.push(`  broken: ${broken.length}`);
+  for (const b of broken.slice(0, 20)) out.push(`      [${b.status} ${b.contentType || "no content-type"}] ${b.url}   (referenced by ${b.from})`);
+  if (inherited.length) {
+    out.push(`  inherited (the SOURCE page has the same broken reference — not caused by the clone): ${inherited.length}`);
+    for (const b of inherited.slice(0, 10)) out.push(`      ${b.url}`);
+  }
+  if (tokenRows.length) {
+    out.push("");
+    out.push("  brand tokens on the LIVE page:");
+    out.push("    old→0?  new>0?  token");
+    for (const t of tokenRows.slice(0, 30)) {
+      const flag = t.oldHits === 0 && t.renderedOld === 0 ? "  ok  " : ` ${String(t.oldHits || t.renderedOld).padStart(3)}✗ `;
+      const note = t.oldHits === 0 && t.renderedOld > 0 ? "  ← SPLIT ACROSS TAGS: visible on the live page" : "";
+      out.push(`    ${flag}  ${t.newHits > 0 ? `${String(t.newHits).padStart(3)}✓` : "  0✗"}   ${t.label}: "${t.old}" → "${t.new}"${note}`);
+    }
+    if (tokenFails.length) out.push(`  token failures: ${tokenFails.length}`);
+  }
+  out.push("");
+  const pass = broken.length === 0 && tokenFails.length === 0;
+  out.push(pass ? "  RESULT: PASS ✅" : "  RESULT: FAIL ❌ — fix and redeploy before showing anyone.");
+  out.push("");
+  out.push("  Content-type checking cannot see a broken RENDER. Also open the URL in a browser and");
+  out.push("  check every image reports naturalWidth > 0 and every video has no error.");
+  out.push("");
+  console.log(out.join("\n"));
+
+  if (args.json && args.json !== true) {
+    writeJson(path.resolve(String(args.json)), { generatedAt: nowIso(), url: URL_, checked, broken, inherited, tokenRows, pass });
+  }
+  process.exit(pass ? 0 : 5);
+}
+
+main().catch((e) => {
+  console.error("verify failed:", e);
+  process.exit(1);
+});