@elitedcs/ghl-mcp 3.56.0 → 3.57.0

package/CHANGELOG.md

@@ -1,5 +1,103 @@
 # Changelog
 
+## 3.57.0 — Clone Site: copy a live page for a client, with the guardrails built in
+
+A second bundled skill. Point Claude at any live URL and get a working,
+rebranded copy for a client — same layout, images, video and CSS, with the
+new business's details in place of the original's. It installs itself like
+Blueprint; there is nothing to download and no new tools to learn.
+
+Cloning normally fails because the model *regenerates* the page instead of
+copying it, and you get a worse version of what you pointed at. This skill
+runs real scripts: they download the bytes, swap the strings, and verify the
+result. Nothing is retyped from memory.
+
+- **The rights question is step 0 and cannot be skipped.** Before anything is
+  copied, the skill asks who owns the page — you, your client (authorized),
+  written permission, or none — and records the answer in the run report and
+  in the final report header. It does not verify ownership; the declaration is
+  yours to make. The mirror script refuses to run without it.
+- **"None" gets a real lane, not a refusal.** It extracts the page's actual
+  design system — palette, CSS variables, font stack and type scale, spacing
+  rhythm, radii, shadows, breakpoints, and the section skeleton as shape — so
+  the rebuild starts from the real design instead of a from-memory redraw. No
+  bytes, images, video or copy are copied in that lane.
+- **Substitution that doesn't leak the old brand.** Derives the bare brand word,
+  every phone format, the address as a unit (not just the city), and domain and
+  email variants; runs across JS bundles as well as HTML and CSS, because
+  compiled sites keep contact details only in the bundle. Asset filenames are
+  protected from rewriting. Dry-run counts first, a zero-check after, and a
+  NEAR MISS warning when one of your facts is *almost* right.
+- **Catches the leak a string search cannot see.** A brand mark is usually
+  two-tone — `GHL <span style="color:#D4AF37;">Command</span>` — which reads as
+  the old brand on screen while that string appears nowhere in the file. Every
+  literal check calls it clean. Clone Site renders the page to text while
+  keeping a map back to source offsets, so it reports exactly which occurrences
+  are split by markup, shows the markup, and fails the zero-check until they are
+  hand-edited. Found on a real page, in the header and the footer, after a
+  file-level rebrand had already "passed."
+- **Asset capture from all four places** — HTML, CSS `url()`, CDN URLs in JS
+  bundles, and root-relative paths inside JS bundles (the one that silently
+  breaks images). Oversized files are reported for object storage, never
+  hot-linked back to the original owner's CDN.
+- **A mandatory pre-launch REVIEW REQUIRED report** on every run: form endpoints,
+  webhooks, payment links and publishable keys, booking embeds, analytics and ad
+  pixels (MUST REPOINT); names, addresses, testimonials and likenesses; and
+  inherited claims with regulated health/efficacy language flagged separately.
+  Nothing is auto-deleted — findings go to a human.
+- **Verification by content-type, not status code**, because static hosts answer
+  200 with the page shell for assets that don't exist. It retries once before
+  calling anything broken (a CDN rollout can answer a single request with HTML),
+  and separates references the *source* page was already serving badly from
+  breakage the clone caused.
+- Reports are written outside the deployable folder, so a rights declaration and
+  a liability list can never be published with the site.
+
+Everything below was found by running the tool against real production sites
+rather than test fixtures, and every one of them shipped a fix:
+
+- **Whole-site cloning.** A one-page mirror inherits the original's entire
+  navigation, so every menu item 404s the moment a client clicks it.
+  `--crawl --depth N --max-pages N` follows the site's own navigation, writes
+  each page at its own path, and rewrites links between your pages as
+  root-relative so the nav works locally and after deploy — while canonical and
+  og:url keep their host so the rebrand can point them at the client's domain.
+  The skill asks how deep to go rather than assuming. Real numbers: a 36-page
+  contractor site came to 2,104 files and 935 MB at depth 2.
+- **Assets that only exist at runtime.** Page-builders publish an asset base
+  path and concatenate chunk filenames onto it in JavaScript, so those files
+  appear in no attribute, stylesheet or string literal. Six missing Elementor
+  chunks meant no section background was painted at all: the hero rendered blank
+  and its white headline was invisible on white, while every file-level check
+  reported success. New `repair.mjs` plus a mandatory render-and-repair loop
+  fetches whatever the running page asks for and cannot find.
+- **Media hidden in escaped JSON.** Background slideshows and galleries store
+  image URLs inside entity-encoded, backslash-escaped JSON attributes. Those are
+  now extracted and localised, escaping preserved.
+- **Brand marks split across tags.** `GHL <span style="color:#D4AF37">Command</span>`
+  reads as the old brand on screen while that string exists nowhere in the file.
+  Detected exactly via a rendered-text-to-source offset map; the zero-check now
+  fails until they are hand-edited instead of reporting a false clean.
+- **HTML-entity brand forms.** A brand containing `&` is stored as `&amp;`. On
+  one page the plain token matched twice and the encoded form 56 times.
+- **Brand baked into image pixels.** Logos and graphics carrying the old phone
+  number or web address are flagged — substitution cannot edit artwork, and the
+  logo is the most visible way a clone gives itself away.
+- **New audit rules from real pages:** contractor and professional licence
+  numbers (the highest-severity item on any trades or medical clone), consumer
+  financing links, review widgets that load the original's reviews at runtime,
+  and internal links with no page in the clone.
+- **Bare-word derivation is now cautioned**, because a brand beginning with a
+  place name ("Arizona AC & Heating") would otherwise rewrite ordinary sentences.
+- **Style lane returns the brand's palette, not the framework's.** Plugin CSS
+  repeats neutral greys hundreds of times while the real brand colours appear
+  twice; vendor stylesheets are now separated, accents are attributed to their
+  source file, declared colour tokens are surfaced first, and CSS variables are
+  resolved so the type scale comes back as real pixel values.
+- **The style lane's deliverable is a page, not a document.** Its rebuild is now
+  five explicit steps, including a media step and a leak check against the
+  original page.
+
 ## 3.56.0 — Security off-switches: any tool can be disabled; sub-account create/delete is opt-in
 
 Shaped directly by subscriber feedback: some teams keep account-level

package/README.md

@@ -12,7 +12,7 @@ Works with **both the Claude Desktop App and Claude Code terminal** — your cho
 
 **How this differs from HighLevel's official MCP.** HighLevel ships an official Anthropic MCP that reads and writes your CRM (contacts, conversations, calendars, opportunities, payments, social) over the public API — it's free and it's good; use it for that. What it *cannot* do, because the public API doesn't expose it: **build or edit workflows, build funnels/landing pages, or build forms.** That's exactly what GHL Command does — the programmatic Workflow Builder, funnel/page builder, form builder, deep workflow cloning, the silent-failure `audit_workflows`, and Blueprint (build a whole client account from one intake — ships as a guided skill that **installs itself automatically** with this package; nothing to download), all on GHL's internal APIs. **Official MCP = read/write your CRM. GHL Command = build and fix it.** They stack fine together.
 
-**Bundled skills (install automatically).** The package ships guided skills that teach Claude complete multi-step workflows on top of the raw tools. On every start the server installs/updates them into your `~/.claude/skills/` (never overwriting files you've edited — your version wins and is reported). Current skills: **Blueprint** — turn one client intake into a complete reviewed GHL account build. Verify or repair any time by asking Claude to `run install_skills`, then fully restart Claude so new skills load.
+**Bundled skills (install automatically).** The package ships guided skills that teach Claude complete multi-step workflows on top of the raw tools. On every start the server installs/updates them into your `~/.claude/skills/` (never overwriting files you've edited — your version wins and is reported). Current skills: **Blueprint** — turn one client intake into a complete reviewed GHL account build; **Clone Site** — point at a live URL and get a rebranded, deploy-ready copy for a client, with a recorded rights declaration, a style-only lane when you have no rights, and a mandatory pre-launch report of every lead/booking/payment destination, borrowed testimonial and inherited claim still belonging to the original owner. Verify or repair any time by asking Claude to `run install_skills`, then fully restart Claude so new skills load.
 
 Built by [Elite DCs, LLC](https://elitedcs.com).
 

package/dist/index.js

@@ -2102,7 +2102,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@elitedcs/ghl-mcp",
-      version: "3.56.0",
+      version: "3.57.0",
       mcpName: "io.github.drjerryrelth/ghl-command",
       description: "GoHighLevel MCP Server for Claude. 233 tools \u2014 full CRM, automation, marketing control, account-wide workflow audit, live funnel-capture verification, and the only programmatic GHL workflow builder, now multi-tenant across client accounts.",
       main: "dist/index.js",
@@ -17956,7 +17956,7 @@ function summarizeInstall(r) {
 function registerSkillsTool(server2, packageVersion, baseDir) {
   server2.tool(
     "install_skills",
-    "Install (or repair) the guided skills bundled with GHL Command \u2014 currently the Blueprint skill (build a whole client account from one intake) \u2014 into your ~/.claude/skills/ so Claude can use them. Runs automatically on startup; call this to verify what is installed, or to re-install after deleting a skill. NEVER overwrites files you have edited (your version is kept and reported). Restart Claude after install for new skills to load.",
+    "Install (or repair) the guided skills bundled with GHL Command \u2014 Blueprint (build a whole client account from one intake) and Clone Site (clone and rebrand a live web page for a client, with a rights declaration and a pre-launch liability report) \u2014 into your ~/.claude/skills/ so Claude can use them. Runs automatically on startup; call this to verify what is installed, or to re-install after deleting a skill. NEVER overwrites files you have edited (your version is kept and reported). Restart Claude after install for new skills to load.",
     {
       targetDir: import_zod57.z.string().optional().describe("Override the install directory. Default: ~/.claude/skills")
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elitedcs/ghl-mcp",
-  "version": "3.56.0",
+  "version": "3.57.0",
   "mcpName": "io.github.drjerryrelth/ghl-command",
   "description": "GoHighLevel MCP Server for Claude. 233 tools — full CRM, automation, marketing control, account-wide workflow audit, live funnel-capture verification, and the only programmatic GHL workflow builder, now multi-tenant across client accounts.",
   "main": "dist/index.js",

package/skills/clone-site/README.md

@@ -0,0 +1,42 @@
+# Clone Site
+
+Point Claude at a live web page and get a working copy, rebranded for a new client — same layout, same images and video, same CSS, with your client's name, phone, address, domain and colors in place of the original's.
+
+The reason this works when "clone this page" normally doesn't: cloning is a **copy** job, and models paraphrase. This skill runs real scripts that download the bytes and swap the strings, so nothing gets re-typed from memory and quietly turned into a worse version of the page.
+
+## Install
+
+Nothing to download. It installs itself with GHL Command into `~/.claude/skills/clone-site/`. Fully restart Claude after an update so it loads, then say **"clone this page for my client"** with a URL.
+
+## What it asks you first
+
+One question, before it copies anything:
+
+> Who owns this page, or what permission do you have to copy it?
+> **I own it** · **My client owns it and authorized this** · **I have written permission** · **None of these**
+
+Your answer is recorded in the run report. It isn't verified and it isn't argued with — but it does decide how the page gets built:
+
+- **You have rights** → a true byte-for-byte clone, rebranded.
+- **You don't** → it extracts the page's actual design system (exact palette, fonts, type scale, spacing, section structure) and rebuilds on that with your own copy and images. Not a from-memory redraw — that's what makes those rebuilds look cheap.
+
+## What you get back
+
+- A deploy-ready site folder (and the deploy itself, if you want it on Cloudflare Pages, Vercel or Netlify).
+- A substitution table showing exactly how many times each old detail was found and replaced, plus a warning when one of your facts is *almost* right — the usual reason the old brand survives.
+- A live verification: every asset checked by content-type, not status code, because static hosts return "200 OK" for files that don't exist.
+- A **REVIEW REQUIRED** report.
+
+## The REVIEW REQUIRED report
+
+The part that protects you. Every clone run ends with it, listing:
+
+- **Must repoint** — form endpoints, webhooks, payment links, booking calendars, analytics and ad pixels still pointing at the original owner. Leave one and your client's leads, bookings or money go to a stranger.
+- **Other people's content** — names, street address, testimonials, before/after photos, staff headshots.
+- **Inherited and regulated claims** — FDA and medical language, "clinically proven," star ratings, client counts, years in business, awards, pricing. All of it was true (or not) for a different business.
+
+Nothing is deleted for you. It's flagged, and you decide.
+
+## Where the clone can live
+
+Cloudflare Pages (default), Vercel, Netlify, a folder you host yourself — or **inside GoHighLevel**, in which case it hands off to Page Studio and builds the page in your sub-account.

package/skills/clone-site/SKILL.md

@@ -0,0 +1,247 @@
+---
+name: clone-site
+description: Clone an existing live website or landing page from its URL and rebrand it for a new client — same layout, images, video and CSS, with new company name, contact details, colors and copy. Starts by asking what rights you have to the page and records your answer; with rights it makes a true byte-for-byte clone, without them it extracts the page's real design system and rebuilds on that. Every run ends with a REVIEW REQUIRED report of everything still belonging to the original owner — lead, booking and payment destinations, other people's names and testimonials, and inherited regulated claims. Triggers on clone this site, clone this page, copy this website, duplicate this funnel, rebuild this landing page for, make this site for my client, mirror this URL, clone URL, copy this landing page, steal this layout, make me one like this.
+compatibility: Claude Code, Claude Cowork, Claude.ai
+---
+
+# Clone Site
+
+A clone is a **copy** operation, never a generation operation. You never retype a page from your understanding of it — the scripts in `scripts/` copy the bytes, you build the substitution map, and you verify the result. That distinction is the whole skill: models paraphrase, and a paraphrased clone is the thing that comes back "not even close."
+
+One run = **rights → acquire → inventory → rebrand → host → verify → REVIEW REQUIRED report.**
+
+**The scripts live at `~/.claude/skills/clone-site/scripts/`** (installed with GHL Command). Call them with that path — dependency-free Node, nothing to install. Work in a run directory outside the user's repo unless they name one.
+
+## Hard rules
+
+1. **Ask for rights first, record the answer, then proceed.** Step 0 below. You are not a rights verifier; the user's declaration is the user's responsibility, and recording it makes that explicit.
+2. **Coach, never block.** "No rights" routes to the style lane — never to a refusal, and never to a from-memory redraw.
+3. **Copy, never regenerate.** If a fetch fails, say so. Do not reconstruct a page you could not download.
+4. **Never silently fix ownership content.** Names, addresses, testimonials, likenesses and claims belonging to the original owner go into the report for a human decision. Flag and propose; never quietly delete or invent replacements.
+5. **No credentials or payment identifiers are ever carried into a live clone.** `pk_live_*`, payment links, form endpoints and webhook URLs are MUST REPOINT findings.
+6. **Verify by content-type and by rendering, never by status code.** Static hosts serve 200 + HTML for a missing asset.
+7. **Never deploy the `reports/` folder.** It contains the user's rights declaration and a list of the original owner's liabilities. Deploy `site/` only.
+
+## STEP 0 — Rights (before any bytes are copied)
+
+Ask this first, in these words, before fetching anything:
+
+> **Before I copy this page — who owns it, or what permission do you have to copy it?**
+> 1. **I own it**
+> 2. **My client owns it and authorized the migration**
+> 3. **I have written permission from the owner**
+> 4. **None of these** — I found the page and want something like it
+>
+> I'm not checking this, and I'm not going to argue with your answer — it goes in the run report so it's on the record, and it decides which of two ways I build this.
+
+Map the answer to `own` / `client-authorized` / `written-permission` / `none` and carry it as `--rights`. `mirror.mjs` refuses to run without it, so this step cannot be skipped by accident.
+
+Do not lecture. Do not repeat the rights topic later in the run — it is asked once, recorded once, and the audit at the end carries the practical consequences.
+
+| Answer | Lane |
+|---|---|
+| own / client-authorized / written-permission | **Full clone** — byte-for-byte mirror + rebrand |
+| none | **Style clone** — extract the real design system, rebuild with original copy and licensed media |
+
+If the user has no rights but insists on a byte-for-byte copy, tell them once, plainly, what that exposes them to (copyright in the layout and copy, other people's testimonials and likenesses, trademark, and inherited advertising claims), and that you'll do the style lane instead — which in practice looks closer to the original than a redraw does. Read `references/rights-and-lanes.md` for the full wording and the edge cases.
+
+---
+
+# LANE A — Full clone (rights declared)
+
+## STEP 1 — Scope and ask (one message, defaults offered)
+
+1. **Source URL — and how much of the site?** Ask this outright; never assume a default:
+   > *"Just this one page, or the whole site? If it's the whole site, how deep should I follow the navigation — one level (the main menu), two levels (menu plus the pages those link to), or everything I can find?"*
+
+   A one-page mirror inherits the original's entire menu, so every nav item 404s. For a real client migration the answer is almost always the whole site. Give them the trade-off in their terms: a 36-page contractor site at depth 2 came to **2,104 files and 935 MB**, and the audit then listed **1,598 images with the old brand baked into the artwork**. Run the crawl, then show them the discovered page list and the size before going further.
+2. **New client facts** — company name, phone, email, address, domain, owner/staff names.
+3. **Host** — default **Cloudflare Pages**; also Vercel, Netlify, GHL-native (→ Page Studio), or "just give me the folder."
+4. **Brand changes** — keep the original colors/fonts, or new hex/font values?
+5. **Media** — re-host everything (default and recommended) or keep hot-links (fragile, and it bills the original owner's bandwidth).
+
+If they give a URL and nothing else, run step 2 first and show them the inventory — the substitution questions are much easier to answer once they can see what is actually in the page.
+
+## STEP 2 — Mirror (deterministic)
+
+```bash
+# one page
+node scripts/mirror.mjs --url "<URL>" --out <run-dir> --rights <declaration> --declared "<their words>"
+
+# the whole site — follows the site's own navigation
+node scripts/mirror.mjs --url "<URL>" --out <run-dir> --rights <declaration> \
+  --crawl --depth 2 --max-pages 40
+```
+
+**Answer the single-page-or-whole-site question with `--crawl`, not with a caveat.** A one-page mirror keeps the original's full navigation, so every menu item 404s the moment the client clicks it — the first thing they will do. Crawling writes each page at its own path (`/contact/` → `contact/index.html`) and rewrites `<a>` links to your own pages as root-relative so the nav works locally and after deploy. `<link rel=canonical>` and `og:url` keep their host on purpose, so the rebrand can point them at the client's real domain.
+
+Depth 2 with a 40-page cap covered a 36-page contractor site in one pass. Assets are shared across pages, so the marginal cost per page is small — but the total is not: that site came to 2,104 files and 935 MB.
+
+Creates `<run-dir>/site/` (deployable) and `<run-dir>/reports/run-report.json`. It collects assets from **four** places — miss any one and images break:
+
+1. HTML `src` / `href` / `poster` / `srcset`
+2. `url(...)` inside every downloaded stylesheet
+3. Full CDN URLs baked into JS bundles
+4. **Root-relative paths inside JS bundles** (`"/logo.png"`) — the one everyone misses; it caused 6 broken images in the proving run
+
+It also does two things that decide whether the clone renders at all:
+
+- **URLs inside escaped JSON attributes** (`data-settings="{&quot;url&quot;:&quot;https:\/\/host\/hero.jpg&quot;}"`) are found and localised. Page-builder background slideshows and galleries live here and are invisible to a src/href scan.
+- **Same-origin asset URLs are made root-relative**, including inside inline JS config. A page-builder publishes an asset base path and concatenates chunk filenames onto it at runtime; left absolute, the rebrand points every runtime-built URL at a domain that does not exist.
+
+External **media** is re-hosted locally; third-party **scripts** (analytics, chat, payment SDKs) are deliberately left external so the audit can see and flag them. Files over 25 MB are recorded, not downloaded — route those to object storage (`references/hosting-verify-and-audit.md`).
+
+Show the user the inventory before rebranding: file count, size, breakdown by type, anything excluded, anything oversized.
+
+## STEP 3 — Rebrand (substitution, not rewriting)
+
+Write a `facts.json` (schema in `references/facts-and-substitution.md`), then **dry run first**:
+
+```bash
+node scripts/substitute.mjs --dir <run-dir> --facts facts.json          # counts only
+node scripts/substitute.mjs --dir <run-dir> --facts facts.json --apply  # after they approve
+```
+
+The script derives the tokens that leak in practice — the bare brand word, every phone format, the address as a unit, domain/www/email variants — protects asset filenames from being rewritten, and after `--apply` runs a zero-check that no replaced token survives.
+
+Two warnings decide whether the rebrand is actually finished:
+
+- **NEAR MISS** — a token that never matches exactly but appears loosely (different case, spacing or punctuation). The user's fact is slightly wrong. Fix it and re-run the dry run. This is how the old brand survives a "complete" list.
+- **SPLIT ACROSS TAGS** — the old brand is visible on screen but broken up by markup in the file, almost always a two-tone brand mark like `GHL <span style="color:#D4AF37;">Command</span>`. **No string replacement can reach these.** You must edit them by hand, keeping the styling and changing only the words. The script prints the exact markup. The zero-check counts them, so `--apply` reports FAILED until they are fixed — a literal-only check would have said "clean" while the live page still showed the original brand in the header and the footer.
+
+Never edit page copy to "improve" it during a clone. That is a different request; offer it afterwards.
+
+## STEP 3b — Render and repair (never skip; a clone that does not render is not a clone)
+
+Static scanning cannot see a URL that JavaScript builds at runtime. Webpack lazy chunks are the usual case: the filename exists in no attribute, stylesheet or literal string, so it is never mirrored.
+
+Serve the clone locally and load it in a browser:
+
+```bash
+python3 -m http.server 8899 --bind 127.0.0.1   # from <run-dir>/site
+```
+
+In the page, list every same-origin resource that failed:
+
+```js
+const bad=[];
+for (const e of performance.getEntriesByType('resource')) {
+  if (!e.name.startsWith(location.origin)) continue;
+  const r = await fetch(e.name, {method:'HEAD'});
+  if (!r.ok) bad.push(e.name.replace(location.origin,''));
+}
+bad
+```
+
+Then fetch those from the original and re-render:
+
+```bash
+node scripts/repair.mjs --dir <run-dir> --origin "<original-site-url>" --urls failed.txt
+```
+
+**Repeat until nothing fails** — one repair pass often reveals the next, because code that was missing then runs and asks for more.
+
+Why this is mandatory: on a real page six missing Elementor chunks meant `section-frontend-handlers` never loaded, so no section background was painted. The hero rendered blank, white headline text sat on white, and the clone looked nothing like the original — while every file-level check reported clean.
+
+## STEP 4 — Pre-launch audit (mandatory, never skipped)
+
+```bash
+node scripts/audit.mjs --dir <run-dir>
+```
+
+Writes `reports/REVIEW-REQUIRED.md`: MUST REPOINT (leads/bookings/money), other people's content, inherited and regulated claims, plus everything excluded. **Show it to the user before deploying**, lead with the MUST REPOINT list and the regulated-claims flag, and never auto-delete a finding. `references/hosting-verify-and-audit.md` explains how to walk them through it.
+
+## STEP 5 — Host
+
+Deploy **`<run-dir>/site`** — never the run directory itself.
+
+```bash
+wrangler pages deploy <run-dir>/site --project-name=<slug>   # Cloudflare Pages (default)
+```
+
+Create/confirm the project first (Pages fails opaquely if it doesn't exist), and add a `_redirects` 404 rule so missing assets stop returning 200. Host table, per-file caps and the R2 commands for oversized media: `references/hosting-verify-and-audit.md`.
+
+**GHL-native seam:** if the clone should live *inside* GHL, stop after step 3 and hand the content plus the asset manifest to Page Studio (`compose_page` / `compose_website`). Do not write a second GHL page writer here.
+
+## STEP 6 — Verify the deployed URL
+
+```bash
+node scripts/verify.mjs --url "<deployed-url>" --dir <run-dir>
+```
+
+Checks every asset by content-type (not status code), retries once before calling anything broken (a single transient answer during a CDN rollout is not a broken asset), separates references the **source page was already serving badly** from ones the clone caused, and confirms old brand tokens are at zero — in the file *and* in the rendered text — with the new ones present.
+
+Then open the URL in a browser and check three things, because no fetch-based check can see them:
+
+```js
+// Lazy images report naturalWidth 0 until they load — force them first, or you
+// will report broken images that are perfectly fine (live-caught 2026-07-30).
+document.querySelectorAll('img[loading="lazy"]').forEach(i => { i.loading = 'eager'; });
+document.querySelectorAll('img[data-src]').forEach(i => { if (!i.src) i.src = i.dataset.src; });
+window.scrollTo(0, document.body.scrollHeight);
+await new Promise(r => setTimeout(r, 4000));
+window.scrollTo(0, 0);
+
+[...document.querySelectorAll('img')].filter(i => i.complete && i.naturalWidth === 0)  // must be empty
+[...document.querySelectorAll('video')].filter(v => v.error)                           // must be empty
+document.body.innerText.match(/<old brand>/g)                                          // must be null
+```
+
+That last one is not redundant. Rendered text is where a tag-split brand mark shows up, and it is the only check that sees text injected at runtime by third-party widgets. Report the numbers, not an impression.
+
+Finish with: the live URL, the verification table, and the REVIEW REQUIRED report.
+
+---
+
+# LANE B — Style clone (no rights, or "I just want the look")
+
+The failure this lane exists to prevent: refusing the copy, then redrawing the page from memory and producing something drastically worse. Do not do that. Extract the actual design system:
+
+```bash
+node scripts/extract-design.mjs --url "<URL>" --out <dir>
+```
+
+Produces `DESIGN-SYSTEM.md` + `design-tokens.json`: palette ranked by frequency, the author's own CSS variables, font families and the real type scale, spacing rhythm, radii, shadows, breakpoints, container widths, and the section skeleton as **shape** (role, heading word counts, media and CTA counts) — deliberately never the words.
+
+**Extraction is step 1 of 5. The deliverable is a working page, never a markdown file.** Do not stop here — a design-system document is not something the user can look at next to the original.
+
+### B1 — Read the extracted artefacts, not your instincts
+
+Open `design-tokens.json`. Use `declaredPalette` first when it exists (the site names its own colours — no guessing), then `brandAccents` with their source files. Take the type scale, spacing, radii, container width and grid **verbatim**.
+
+### B2 — Lay the page out from `structure.sections`
+
+The skeleton gives you section order, role, heading levels **with word counts**, and image/button/list counts. Build that. If it says the hero is `h1:3w · h5:17w · h2:5w · h6:25w` centred, build exactly that shape — matching the rhythm is what makes it read like the same designer's work. Do not substitute your own preferred layout; that is the from-memory redraw this lane exists to prevent.
+
+If `spaShell` is true the structure is client-rendered and absent from the source; open the page in a browser and record the section order by eye first.
+
+### B3 — Write original copy
+
+Every headline, paragraph and CTA fresh. Match length and function, never wording. Filling a "17-word subhead" slot by pasting the original's 17-word subhead is copying — it will be caught in B5.
+
+### B4 — Supply real media (this step is not optional)
+
+A style-lane page with no imagery reads as a downgrade no matter how good the tokens are. Three legitimate sources: the client's own photographs, licensed stock, or **generated originals**. Never the source site's files. Label any slot you cannot fill yet, and say plainly in the handover that placeholders must be replaced before launch.
+
+### B5 — Leak check, then audit
+
+```bash
+# compare against the ORIGINAL page, never against a rebranded clone
+```
+
+Fetch the original's rendered text and confirm **zero shared 5-, 6- and 8-word sequences** with your rebuild, and zero shared image filenames. Comparing against a rebranded clone is meaningless — the new brand name shows up as "shared" and hides real leaks.
+
+Then run `audit.mjs` on the finished page. A fresh build can still inherit a regulated claim you typed from memory.
+
+---
+
+## Anti-patterns
+
+- Rewriting page copy "to make it better" mid-clone.
+- Trusting HTTP 200 as proof an asset exists.
+- Scanning only the HTML for assets.
+- Replacing a city without the street address.
+- Auto-deleting testimonials — it destroys the layout and hides the liability instead of surfacing it.
+- Deploying with the original owner's CDN still serving the media.
+- Shipping `reports/` to the live host.
+- Repeating the rights warning after step 0. Ask once, record, move on.

package/skills/clone-site/references/facts-and-substitution.md

@@ -0,0 +1,96 @@
+# facts.json and how substitution works
+
+## The file
+
+```json
+{
+  "old": {
+    "company": "Genesis Red Light",
+    "aliases": ["Genesis Red Light Therapy", "GRL"],
+    "domain": "genesisredlight.com",
+    "emails": ["info@genesisredlight.com"],
+    "phones": ["+15123992074"],
+    "people": ["Serenity Harris"],
+    "address": { "street": "103 N Bell Blvd", "suite": "Ste A2", "city": "Cedar Park", "state": "TX", "zip": "78613" }
+  },
+  "new": {
+    "company": "Northgate Wellness",
+    "domain": "northgatewellness.com",
+    "emails": ["hello@northgatewellness.com"],
+    "phones": ["(512) 555-0147"],
+    "people": ["Dana Whitfield"],
+    "address": { "street": "2200 Palm Valley Blvd", "suite": "Ste 300", "city": "Round Rock", "state": "TX", "zip": "78665" }
+  },
+  "colors": { "#c9a227": "#1f6feb" },
+  "fonts": { "Playfair Display": "Fraunces" },
+  "extra": [{ "label": "tagline", "old": "Light. Restored.", "new": "Recover Faster." }]
+}
+```
+
+`old` and `new` are positional: `old.people[0]` is replaced by `new.people[0]`, `old.phones[1]` by `new.phones[1]`. Singular keys (`phone`, `email`, `owner`) work too.
+
+Leave a `new` value out and the token is still **counted and reported** — it just isn't replaced, and it lands in the audit under "present with no replacement value." That is deliberate: an unanswered fact should be visible, not silently kept.
+
+## What gets derived automatically
+
+| Input | Derived |
+|---|---|
+| `company: "Genesis Red Light"` | the full phrase **and the bare word `Genesis`** — the bare token survived 41 times in the proving run after the full phrase was replaced |
+| `phones: ["+15123992074"]` | `+15123992074`, `1512...`, `5123992074`, `(512) 399-2074`, `(512)399-2074`, `512-399-2074`, `512.399.2074`, `512 399 2074` — all of which appear in real pages, including inside `tel:` links |
+| `address` | the full unit (street + suite + city + state + zip), street with suite, bare street, "city, state", city alone, zip. Ordered longest-first so the **unit** is replaced before the city — replacing only the city produced "new city, old street" in the proving run |
+| `domain` | `www.domain`, bare `domain` |
+| `colors` | the hex in original, upper and lower case |
+
+Tokens are applied longest-first, so `Genesis Red Light` is consumed before bare `Genesis`.
+
+Generic bare words are not derived (`The`, `Med`, `Spa`, `Wellness`, `Clinic`, `Center`, `Health`, `Group`, `LLC`, …) — replacing `Spa` across a page does far more harm than good.
+
+## Protected strings
+
+Every asset path from `run-report.json` — full path, relative path and basename — is masked before substitution and restored after. Without this, replacing `genesis` → `northgate` rewrites `/genesis-logo.png` in the HTML while the file on disk is still `genesis-logo.png`, and the image 404s. Renaming asset files is not worth the risk; keep the source filenames, including hashes.
+
+## Where substitution runs
+
+HTML, CSS **and JS bundles**. Minified JS is plain text and safe for literal replacement, and on compiled SPAs the contact details exist *only* in the bundle — HTML-only substitution leaves the original owner's phone number live on the page.
+
+Only files under `<run-dir>/site/` are touched. The tool's own reports live in `<run-dir>/reports/` and are never scanned or rewritten.
+
+## Brand marks split across tags
+
+The one failure literal substitution cannot fix by itself, and the reason the zero-check looks at rendered text as well as file text.
+
+A styled brand mark is normally two elements:
+
+```html
+<p>GHL <span style="color:#D4AF37;">Command</span></p>
+```
+
+A visitor reads "GHL Command". The file contains no such string, so every literal search — including the zero-check — reports clean while the header and footer still carry the original brand. Live-caught on a real proof run 2026-07-30, on a page whose file-level substitution had already passed.
+
+`substitute.mjs` detects these exactly: it renders the HTML to text while keeping a map back to source offsets, finds the token in the rendered text, and checks whether that span is contiguous in the file. Counting occurrences before and after tag-stripping does **not** work — text inside attributes disappears when tags are stripped, which cancels out the split gain and hides the problem.
+
+Fix them by hand, preserving the styling:
+
+```html
+<p>Beacon <span style="color:#D4AF37;">Ops</span></p>
+```
+
+Then re-run `--apply`; the zero-check reads `in the file OR on screen` when it is genuinely clean.
+
+## The two warnings that matter
+
+**NEAR MISS** — a token that matched zero times exactly, but does appear with different case, spacing or punctuation. This is the single most common cause of a leaked brand: `Elite DCs` in your facts, `Elite DCS LLC` on the page. Fix the fact and re-run the dry run.
+
+**ZERO-CHECK** (after `--apply`) — re-scans every file for every replaced token, as a literal string *and* in the rendered text. It must read `no replaced token survives in the clone, in the file OR on screen`. If it doesn't, stop; do not deploy.
+
+Re-running `substitute.mjs` over already-substituted files finds zero hits by design. The report preserves the earlier run's record rather than erasing it, because `verify.mjs` checks the live page against exactly that list.
+
+## Order of operations
+
+1. Dry run. Show the user the hit table.
+2. Fix near-misses and missing `new` values.
+3. Dry run again if anything changed.
+4. `--apply`, confirm the zero-check.
+5. Audit. Then deploy.
+
+Never apply before the user has seen the counts.

package/skills/clone-site/references/hosting-verify-and-audit.md

@@ -0,0 +1,101 @@
+# Hosting, verification, and the REVIEW REQUIRED report
+
+## Run directory layout
+
+```
+<run-dir>/
+  site/        ← the deployable folder. Deploy THIS path, never its parent.
+    index.html
+    assets/    css/js exactly as the source named them — do not rename
+    media/     re-hosted external media, grouped by source host
+  reports/     ← run-report.json, substitution-report.json, REVIEW-REQUIRED.md
+```
+
+`reports/` must never reach a public host: it contains the user's rights declaration and an itemized list of the original owner's liabilities. Deploying the run directory instead of `site/` publishes both.
+
+New client media goes in `site/img/brand/` with descriptive kebab-case names (`owner-headshot.jpg`), never `IMG_4821.jpg`. Re-hosted media keeps its source filename, hashes included.
+
+## Host profiles
+
+| Host | Deploy | Per-file cap | Oversized media | 404 behavior |
+|---|---|---|---|---|
+| **Cloudflare Pages** (default) | `wrangler pages deploy <run-dir>/site --project-name=<slug>` | **25 MB** | R2 or Stream | serves 200 + HTML unless `_redirects` has `/* /404.html 404` — **add it** |
+| **Vercel** | `vercel deploy --prod` (from `site/`) | ~100 MB, plan-dependent | Vercel Blob | configure in `vercel.json` |
+| **Netlify** | `netlify deploy --prod --dir=<run-dir>/site` | ~100 MB | Netlify LFS / external | `_redirects`, same syntax as Cloudflare |
+| **GHL-native** | hand off to Page Studio (`compose_page` / `compose_website`) | GHL media library | GHL media library | GHL-managed |
+| **Folder only** | zip `site/` and hand it over | n/a | advise per their host | n/a |
+
+Create or confirm the project **before** deploying — Cloudflare Pages fails opaquely when the project doesn't exist.
+
+## Oversized media
+
+`mirror.mjs` records anything over the cap in `run-report.json` under `oversized` and does **not** download it. Route those files explicitly:
+
+```bash
+wrangler r2 bucket create <client-slug>-media
+wrangler r2 object put <client-slug>-media/<file> --file ./<file>
+# then bind media.<clientdomain> to the bucket and rewrite the refs to that host
+```
+
+Never leave oversized media hot-linked to the original owner's CDN in a delivered clone. It breaks the day they delete the file, and until then the original owner pays for the bandwidth.
+
+## Verification
+
+```bash
+node scripts/verify.mjs --url "<deployed-url>" --dir <run-dir>
+```
+
+1. **Content-type, not status code.** Static hosts return 200 with the page shell for a missing asset. An asset is present only if the served content-type matches its extension. (Proof: requesting `/reports/REVIEW-REQUIRED.md` on a correctly-deployed clone returns `200 text/html` — the file is not there at all.)
+2. **One retry before calling anything broken.** A CDN rollout or a burst rate-limit can answer one request with HTML. Verified live: an unretried pass reported 9 broken assets, a clean re-run reported 2, and the truth was 0. A flaky verifier is worse than a strict one.
+3. **Inherited breakage is separated out.** A reference the *source* page was already serving badly is reported but does not fail the run — redeploying cannot fix a file the original site does not have either.
+4. **Old tokens at zero, new tokens above zero**, checked against `substitution-report.json`, with asset paths masked so a filename never counts as a brand hit — and checked in the **rendered** text too, which is where a tag-split brand mark hides.
+5. Exit code 0 = pass, 5 = fail. A failing verify means fix and redeploy — do not show the user the URL first.
+
+Then the part no script can do: open the deployed URL in a browser and confirm every `<img>` reports `naturalWidth > 0`, no `<video>` has an error, and `document.body.innerText` contains **zero** occurrences of the old brand. Report counts. "Looks right" is not a verification.
+
+**Force lazy images to load before you measure.** A page with `loading="lazy"` images reports `naturalWidth === 0` for everything below the fold, and you will report a pile of broken images that are perfectly fine. Set `loading = 'eager'`, fill any `data-src`, scroll to the bottom, wait, and only count images where `img.complete` is true. Live-caught 2026-07-30 on a WordPress/Elementor page with 43 lazy images: the "broken" list was entirely lazy-loading, and every file served 200 with the right content-type.
+
+The rendered-text check earns its place twice over: it catches tag-split brand marks, and it is the only way to see text a third-party widget injects at runtime. A cloned page keeps the original owner's chat widget live until you repoint it — it loads their business identity from their account, and nothing in the files can be edited to change that.
+
+## Walking the user through REVIEW REQUIRED
+
+Lead with consequences, in this order:
+
+1. **MUST REPOINT first.** Every item here routes something real — a lead, a booking, a payment, an ad conversion — to the original owner. Read out the form endpoints, payment links, booking embeds and pixel IDs by name and ask what each should become. A cloned page that still posts to someone else's CRM is the worst failure mode this skill has.
+2. **The regulated-claims flag next.** FDA/medical/efficacy language, "clinically proven," "board certified." These were substantiated (or not) by a different business, and the exposure follows whoever publishes them. Ask directly whether the new business can stand behind each one.
+3. **Other people's content.** Names, street addresses, testimonials, before/after photos, staff headshots. Never delete these silently — deleting a testimonial block breaks the layout and hides the problem. Propose replacements and let the user decide.
+4. **Ratings, counts, tenure, awards, pricing.** Numbers that describe the original business. Each needs a true number for the new one or it comes out.
+5. **Excluded and unresolved.** Oversized files, assets the origin didn't actually serve, third-party scripts left external, and any token with no replacement value.
+
+The report is deliberately over-inclusive — a quoted line of marketing copy shows up alongside a real customer testimonial. Say so. Over-flagging costs a minute of reading; under-flagging ships someone else's customer's face on a page selling a health service.
+
+Close with the report's own line: *everything in it describes the original business, not the client, and each item needs replacing or removing before the page takes real traffic.*
+
+## Runtime-loaded assets (the render→repair loop)
+
+A file-level check cannot see a URL that JavaScript constructs. The pattern that bites hardest:
+
+1. A page-builder publishes an asset base path in inline config.
+2. At runtime it concatenates chunk filenames onto that base.
+3. Those filenames appear in no attribute, stylesheet or string literal, so the mirror never fetches them.
+4. The rebrand rewrites the base path's host, so every runtime URL resolves against a domain that does not exist.
+
+The result is a page that passes every static check and renders wrong. Live-caught 2026-07-30: six Elementor handler chunks failed, `section-frontend-handlers` among them, so no section background was painted — the hero was blank and its white headline invisible on white.
+
+`mirror.mjs` now prevents step 4 by making same-origin asset URLs root-relative. Step 3 still needs the loop:
+
+```
+render the clone → collect failed same-origin requests → repair.mjs → render again
+```
+
+Repeat until nothing fails. One pass commonly reveals the next, because code restored in pass one runs in pass two and asks for its own dependencies.
+
+## What "done" means
+
+A clone run is done when all of these are true, and not before:
+
+- the render→repair loop has run to zero failed requests
+- the deployed URL is live and `verify.mjs` exits 0
+- a browser check confirms zero broken images and zero video errors
+- `REVIEW-REQUIRED.md` has been shown to the user and the MUST REPOINT items have been answered
+- `reports/` is not on the live host