How to Set Up Codex for Full-Site SEO Audits (Full SKILL.md Included)

---
name: codex-seo-audit
description: Use when the user asks for a full website audit, a whole-site SEO check, a health score for their site, or a consolidated report that combines every installed codex-seo-* skill. Composes the series skills into a weighted board, and withholds the health score when any category lacks a measured source.
---
# Full-Site Audit Composer

The finale skill: one URL in, one board out, every row traceable to the
scanner that produced it. An audit is not one score; it is a board of
category rows, each backed by its own measured source, plus a report that
names the rows it could not measure and why.

## Commands

```
python3 fullsite_audit.py <url> [--skills-dir DIR] [--json]
```

- `<url>`: the site to audit. The composer probes the homepage, robots.txt
  and sitemap itself, then runs every single-URL scanner it finds among
  installed `codex-seo-*` skills.
- `--skills-dir DIR`: where the skills live. Defaults to `~/.codex/skills`;
  point it at a test directory or a second machine's layout when auditing
  a setup you do not control.
- `--json`: prints the audit envelope (`audit-data.json` shape)
  machine-readable.

Run it again any time. An audit is a rerunnable board, not an event.

## The five phases

1. **Probe**: homepage (status, canonical, title/meta lengths, H1/H2
   counts, JSON-LD block count, security headers, image alt coverage),
   robots.txt (sitemap lines), sitemap discovery and URL counts, and
   business-type signals from the homepage text.
2. **Inventory**: scans the skills directory for `codex-seo-*/SKILL.md`,
   lists installed vs missing, and points the missing ones at the series
   post that installs them.
3. **Run**: executes the single-URL scanners (technical, page, content,
   schema, images, sitemap, geo, local, hreflang, plan, ready) as
   subprocesses with a 90-second cap, saves each full stdout to
   `findings/<skill>.txt`, and quotes each scanner's own verdict lines.
4. **Board**: the 7 weighted scorecard rows (below). Every row shows its
   status (OK / PENDING / NOT INSTALLED / TIMEOUT / ERROR), its source
   file, and its own verdict text.
5. **Artifacts**: writes `FULL-AUDIT-REPORT.md`, `ACTION-PLAN.md`,
   `audit-data.json` (the claude-seo envelope shape) and `findings/*.txt`
   under `{hostname}-audit/` in the current directory.

## Weighted board

| Category | Weight | Scanner source |
|----------|--------|----------------|
| Technical SEO | 22% | technical_scan.py + own probes |
| Content Quality | 23% | content_scan.py |
| On-Page SEO | 20% | page_scan.py + own probes |
| Schema / Structured Data | 10% | schema_scan.py |
| Performance (CWV) | 10% | PENDING by default - PSI/CrUX key (technical_scan --psi) or field CSV |
| AI Search Readiness | 10% | geo_scan.py |
| Images | 5% | image_scan.py |

## The honesty rule (the one thing that never bends)

- Each board row quotes the verdict of the scanner that produced it. The
  composer does not re-score, re-interpret, or synthesize numbers.
- Rows that need data the public web does not carry (GSC CSV, backlink
  export, SERP capture, CWV field data) are labeled PENDING with the
  missing input named, and they count as not-measured.
- If any of the 7 categories is not measured, the health score is
  withheld - the output prints "HEALTH SCORE: withheld" and says which
  rows and which inputs are missing. A score over partial evidence is the
  one thing this family of skills never prints.

## Output contract

- `FULL-AUDIT-REPORT.md`: board table + coverage + run date.
- `ACTION-PLAN.md`: Phase 1 (measured rows, week 1) and Phase 2
  (data-required rows, when data arrives). Items are tasks, not promises.
- `audit-data.json`: the envelope (summary, categories, action_plan,
  artifacts) that report generators and dashboards consume.
- `findings/`: per-scanner full stdout and stderr, saved verbatim.

## Error handling

| Scenario | Action |
|----------|--------|
| URL unreachable / 403 / TLS | Probe prints the error and the Rule: an audit starts at the server. Do not guess content. |
| A scanner fails or times out | Row status shows TIMEOUT/ERROR with its exit reason; the run continues. |
| Skill not installed | Row says NOT INSTALLED and names the post that installs it. The board stays honest. |
| `--skills-dir` points at an empty dir | Inventory reports NONE; scanner runs all NOT INSTALLED; artifacts still write. |
| Only some categories measured | Health score withheld; the coverage line says which rows. Never fill a missing row from a different source than the mapping above. |
| site-audit artifacts already exist | 90-second overwrite? No - `{hostname}-audit/` files are overwritten silently by re-run, since the audit is rerunnable by design. |
| Skill scripts fail on Windows | The subprocess runs with `sys.executable`; use the same paste-and-run path as the post for each skill. |

#!/usr/bin/env python3
"""Full-site audit composer for the Codex SEO Skills series.

One URL in, one board out: probes the site, inventories installed
codex-seo-* skills, runs the single-URL scanners among them, quotes each
scanner's own verdict, writes the claude-seo audit envelope
(FULL-AUDIT-REPORT.md / ACTION-PLAN.md / audit-data.json / findings/*.md),
and only prints a health score when every category has a measured source.

Standard library only. Usage:
  python3 fullsite_audit.py <url> [--skills-dir DIR] [--json]
"""
import gzip
import json
import os
import re
import subprocess
import sys
import time
import urllib.request
from urllib.parse import urlparse

UA = ("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 "
      "(KHTML, like Gecko) Chrome/126.0 Safari/537.36")
TIMEOUT = 25
CAP = 6 * 1024 * 1024
TODAY = __import__("datetime").date.today().isoformat()

CATEGORY_WEIGHTS = [  # weights from the original claude-seo audit scorecard
    ("Technical SEO", 22, "technical"),
    ("Content Quality", 23, "content"),
    ("On-Page SEO", 20, "page"),
    ("Schema / Structured Data", 10, "schema"),
    ("Performance (CWV)", 10, "performance"),
    ("AI Search Readiness", 10, "geo"),
    ("Images", 5, "images"),
]

# Registry: series skill -> (script basename, args template, runs-on-bare-url?)
# args: "%url%" replaced with the audit URL; None means the skill is PENDING
# (needs an extra input file/join that only the user can provide).
SKILL_RUNS = [
    ("ready", "check_env.py", [], None),
    ("technical", "technical_scan.py", ["%url%"], None),
    ("page", "page_scan.py", ["%url%"], None),
    ("content", "content_scan.py", ["%url%"], None),
    ("schema", "schema_scan.py", ["%url%"], None),
    ("images", "image_scan.py", ["%url%"], None),
    ("sitemap", "sitemap_check.py", ["%url%"], None),
    ("geo", "geo_scan.py", ["%url%"], None),
    ("local", "local_scan.py", ["%url%"], None),
    ("hreflang", "hreflang_check.py", ["%url%"], None),
    ("plan", "plan_recon.py", ["%url%"], None),
    ("google", "gsc_csv.py", None, "needs a GSC performance CSV export (see the google-data post)"),
    ("backlinks", "backlinks_audit.py", None, "needs a links CSV or --gsc-export (see the backlinks post)"),
    ("cluster", "serp_cluster.py", None, "needs a SERP TSV capture (see the cluster post)"),
    ("sxo", "sx_scan.py", None, "needs a SERP capture (see the SXO post)"),
    ("hreflang-parity", "hreflang_parity.py", None, "needs locales.tsv (see the hreflang post)"),
    ("programmatic", "pp_scan.py", None, "needs a sitemap URL and pattern decision (see the programmatic post)"),
    ("competitor-pages", "competitor_facts.py", None, "needs competitor URLs (see the competitor-pages post)"),
]


def fetch(url, _retried=False):
    req = urllib.request.Request(url, headers={
        "User-Agent": UA, "Accept": "text/html,application/xhtml+xml,*/*;q=0.8",
        "Accept-Encoding": "gzip", "Accept-Language": "en-US,en;q=0.9",
    })
    try:
        with urllib.request.urlopen(req, timeout=TIMEOUT) as r:
            body = r.read(CAP + 1)
            if len(body) > CAP:
                return None, None, "body too large (over 6MB)"
            if body[:2] == b"\x1f\x8b" or r.headers.get("Content-Encoding", "").lower() == "gzip":
                body = gzip.decompress(body)
            hdr = dict((k.lower(), v) for k, v in r.headers.items())
            return body.decode("utf-8", "replace"), hdr, None
    except urllib.error.HTTPError as e:
        return None, None, f"HTTP {e.code}"
    except urllib.error.URLError as e:
        err = re.sub(r"\s+", " ", str(e.reason).strip("<> "))[:60]
        if not _retried and re.search(r"(?i)EOF|ssl|connect|reset|timeout", err):
            return fetch(url, _retried=True)
        return None, None, err
    except Exception as e:
        err = f"{type(e).__name__}: {e}"[:60]
        if not _retried and re.search(r"(?i)EOF|ssl|connect|reset|timeout", err):
            return fetch(url, _retried=True)
        return None, None, err


def metal(html, needle):
    for pat in (r'<meta[^>]+(?:name|property)=["\']' + needle + r'["\'][^>]*content=["\']([^"\']+)',
                r'<meta[^>]+content=["\']([^"\']+)["\'][^>]*(?:name|property)=["\']' + needle +
                r'["\']'):
        m = re.search(pat, html, re.I)
        if m:
            return m.group(1)
    return None


def read_xml_locs(body):
    return re.findall(r"<loc>(.*?)</loc>", body, re.S)


def probe_site(url):
    """Own measurements: homepage health + robots + sitemap + business signals."""
    out = {"url": url, "status": "unreachable"}
    html, hdr, err = fetch(url)
    if err or html is None:
        out["errors"] = [err or "no page"]
        return out
    out["status"] = 200
    txt = re.sub(r"<script.*?</script>|<style.*?</style>", " ", html, flags=re.I | re.S)
    txt = re.sub(r"<[^>]+>", " ", txt)
    txt = re.sub(r"\s+", " ", txt).lower()
    ti = re.search(r"<title[^>]*>(.*?)</title>", html, re.I | re.S)
    out["title_chars"] = len(ti.group(1).strip()) if ti else 0
    md = metal(html, "(?:description|og:description)")
    out["meta_desc"] = len(md) if md else 0
    out["h1"] = len(re.findall(r"<h1[^>]*>", html, re.I))
    out["h2"] = len(re.findall(r"<h2[^>]*>", html, re.I))
    imgs = re.findall(r"<img[^>]*>", html, re.I)
    alt = [i for i in imgs if re.search(r'alt=["\'][^"\']+', i, re.I)]
    out["images"] = {"total": len(imgs), "with_alt": len(alt)}
    out["jsonld_blocks"] = len(re.findall(r'<script[^>]*type=["\']application/ld\+json["\']', html, re.I))
    out["security_headers"] = [k for k in ("strict-transport-security", "x-content-type-options",
                                           "content-security-policy", "referrer-policy")
                               if hdr and k in hdr]
    out["final_url"] = url
    # business-type signals (per the original orchestrator's detection table)
    signals = {
        "SaaS": bool(re.search(r"pricing|/features|/integrations|/docs|free trial|sign up", txt)),
        "Local service": bool(re.search(r"phone|address|serving [a-z]{3,}|map embed|google maps", txt)),
        "E-commerce": bool(re.search(r"/products|/collections|/cart|add to cart", txt)),
        "Publisher": bool(re.search(r"/blog|/articles|/topics", txt)),
        "Agency": bool(re.search(r"case-stud|portfolio|/industries|our work|client logo", txt)),
    }
    out["business_signals"] = {k: v for k, v in signals.items() if v} or {"none": True}
    # robots + sitemap
    base = url.split("//")[0] + "//" + url.split("//")[1].split("/", 1)[0] if "//" in url else url
    out["base"] = base
    rb, _, rerr = fetch(base + "/robots.txt")
    sm_url = None
    out["robot_sitemap_lines"] = 0
    if rb is not None and "<html" not in rb.lower()[:400]:
        lines = [l.strip().split(None, 1)[-1] for l in rb.splitlines()
                 if re.match(r"(?i)^sitemap\b", l) and ":" in l]
        out["robot_sitemap_lines"] = len(lines)
        sm_url = lines[0] if lines else None
    if not sm_url:
        sm_url = base + "/sitemap.xml"
    sb, _, serr = fetch(sm_url)
    out["sitemap"] = {"file": sm_url, "found": sb is not None}
    if sb is not None:
        locs = read_xml_locs(sb)
        out["sitemap"]["urls_declared"] = len(locs)
        out["sitemap"]["kind"] = "index" if "<sitemap>" in sb else "single"
        if out["sitemap"]["kind"] == "index":
            total = 0
            for c in locs[:8]:
                cb, _, _ = fetch(c)
                if cb is not None:
                    total += len(read_xml_locs(cb))
            out["sitemap"]["urls_children_total"] = total
        out["sitemap"]["robots_hint"] = "yes" if out["robot_sitemap_lines"] else "no (default path)" \
            if out["sitemap"]["found"] else "no"
    else:
        out["sitemap"]["error"] = serr or "not found"
    return out


def inventory(skills_dir):
    expected = {name for name, _, args, note in SKILL_RUNS}
    found = {}
    if os.path.isdir(skills_dir):
        for d in sorted(os.listdir(skills_dir)):
            p = os.path.join(skills_dir, d)
            if os.path.isfile(os.path.join(p, "SKILL.md")):
                key = d[10:] if d.startswith("codex-seo-") else d
                found[key] = p
    rows = []
    for name in sorted(expected):
        rows.append({
            "skill": name,
            "installed": name in found,
            "scripts_dir": os.path.join(found[name], "scripts") if name in found else None,
            "expected": True,
        })
    return rows, found


def find_script(found, skill, basename):
    d = found.get(skill)
    if not d:
        return None
    path = os.path.join(d, "scripts", basename)
    return path if os.path.isfile(path) else None


def run_scanner(outdir, skill, script_path, args):
    started = time.time()
    redirs = {"%url%": args["url"]}
    cmd = [sys.executable, script_path] + [a.replace("%url%", redirs["%url%"]) for a in args["argv"]]
    try:
        r = subprocess.run(cmd, capture_output=True, text=True, timeout=90)
        rc, out, errout = r.returncode, r.stdout or "", r.stderr or ""
    except subprocess.TimeoutExpired:
        return {"skill": skill, "status": "TIMEOUT (>90s)", "source": "subprocess",
                "files": [], "elapsed": round(time.time() - started, 1)}
    except Exception as e:
        return {"skill": skill, "status": "ERROR", "source": "subprocess",
                "error": f"{type(e).__name__}: {e}", "elapsed": round(time.time() - started, 1)}
    # save full output
    os.makedirs(os.path.join(outdir, "findings"), exist_ok=True)
    fn = os.path.join(outdir, "findings", skill + ".txt")
    with open(fn, "w", encoding="utf-8") as f:
        f.write("$ " + " ".join(cmd) + "\n" + (out or "") + (("\n--- stderr ---\n" + errout) if errout else ""))
    verdict_lines = [l for l in (out.splitlines() or [])[-25:]
                     if re.search(r"(?i)score|verdict|pass|fail|warn|flag|health|not publicly|no local|not a product", l)]
    verdict = verdict_lines[-6:] if verdict_lines else (
        out.splitlines()[-3:] if out else (errout.splitlines()[-3:] or ["(no output)"]))
    return {"skill": skill, "status": "OK" if rc == 0 else f"EXIT {rc}", "source": "subprocess",
            "verdict_excerpt": "\n".join(verdict)[:900], "file": "findings/" + skill + ".txt",
            "elapsed": round(time.time() - started, 1)}


def row_from_scanner(run, cat_name, weight):
    return {"category": cat_name, "weight": weight, "status": run["status"],
            "source": run.get("file") or run.get("error") or run["status"],
            "verdict": run.get("verdict_excerpt", "")}


def main():
    args = [a for a in sys.argv[1:]]
    json_mode = "--json" in args
    rest = [a for a in args if not a.startswith("--")]
    skills_dir = "~/.codex/skills"
    if "--skills-dir" in args:
        i = args.index("--skills-dir")
        skills_dir = args[i + 1]
    skills_dir = os.path.expanduser(skills_dir)
    if not rest:
        print("usage: fullsite_audit.py <url> [--skills-dir DIR] [--json]", file=sys.stderr)
        return 2
    url = rest[0]

    board = []
    print("FULL-SITE AUDIT: " + url)
    print("=" * 50)
    print("Phase 1 - site probes")
    p = probe_site(url)
    if p["status"] != 200:
        print("SITE UNREACHABLE: " + "; ".join(p.get("errors", [])))
        print("Rule: a full-site audit of an unreachable site starts at the server, not at the categories.")
        board.append({"category": "Site", "weight": 0, "status": "UNREACHABLE",
                      "source": p.get("errors"), "verdict": "fix the server first"})
    else:
        print("status 200 | final URL: " + str(p.get("final_url")))
        print("title chars: %s  meta desc: %s  h1: %s  h2: %s" %
              (p["title_chars"], p["meta_desc"], p["h1"], p["h2"]))
        im = "images: %s total, %s with alt" % (p["images"]["total"], p["images"]["with_alt"])
        print(im)
        print("jsonld blocks: %s  security headers: %s" % (p["jsonld_blocks"],
              ", ".join(p["security_headers"]) or "NONE"))
        print("business signals: " + ", ".join(p["business_signals"].keys()))
        sm = p["sitemap"]
        line = "sitemap %s (%s): %s" % (sm["file"], sm.get("kind"), sm.get("urls_declared"))
        if sm.get("urls_children_total") is not None:
            line += " (children: " + str(sm["urls_children_total"]) + ")"
        if sm.get("error"):
            line += " ERROR " + str(sm["error"])
        else:
            line += "  robots hint: " + str(sm.get("robots_hint"))
        print(line)
        board.append({"category": "Site probes", "weight": 0, "status": "MEASURED",
                      "source": "own probe", "verdict": "ok"})

    print("\nPhase 2 - skill inventory (" + skills_dir + ")")
    inv, found = inventory(skills_dir)
    installed = [r["skill"] for r in inv if r["installed"]]
    print("installed skills: " + (", ".join(installed) or "NONE"))
    missing = [r["skill"] for r in inv if not r["installed"]]
    if missing:
        print("missing (see the matching series post to install): " + ", ".join(missing))

    parsed = urlparse(url)
    domain = re.sub(r"^www\.", "", (parsed.netloc or parsed.path.split("/")[0]).lower())
    outdir = os.path.join(os.getcwd(), domain + "-audit")
    os.makedirs(outdir, exist_ok=True)

    print("\nPhase 3 - scanner runs (each verdict is the scanner's own)")
    runs = []
    for name, base, argv, note in SKILL_RUNS:
        if argv is None:
            runs.append({"skill": name, "status": "PENDING", "note": note})
            continue
        script_path = find_script(found, name, base)
        if not script_path:
            runs.append({"skill": name, "status": "NOT INSTALLED"})
            continue
        rr = run_scanner(outdir, name, script_path, {"url": url, "argv": argv})
        runs.append(rr)
        st = rr["status"]
        line_tail = " ".join(rr.get("verdict_excerpt", "").replace("\n", " | ")[:140].split())
        if rr.get("error"):
            line_tail = rr["error"]
        print("%-14s %-9s %s%s" % (name, st, line_tail,
                                   ("  " + str(rr.get("elapsed")) + "s") if "elapsed" in rr else ""))

    print("\nPhase 4 - weighted board (the audited scorecard)")
    cat_rows = []
    for cat_name, weight, skill_key in CATEGORY_WEIGHTS:
        run = next((r for r in runs if r["skill"] == skill_key), None)
        if skill_key == "performance" and run is None:
            run = {"skill": "performance", "status": "PENDING",
                   "note": "no scanner by default - PSI key (technical_scan --psi) or field CSV"}
        if run is None or run["status"] in ("PENDING", "NOT INSTALLED"):
            status = run["status"] if run else "MISSING"
            note = run.get("note", "") if run else "no scanner"
            cat_rows.append({"category": cat_name, "weight": weight, "status": status,
                             "source": note or "no scanner", "verdict": ""})
            print("%-24s %-13s (weight %s%%)  %s" % (cat_name, status, weight, note))
        else:
            cat_rows.append(row_from_scanner(run, cat_name, weight))
            verdict = " ".join(cat_rows[-1]["verdict"].replace("\n", " | ").split())[:150]
            print("%-24s %-13s (weight %s%%)  %s" % (cat_name, cat_rows[-1]["status"], weight, verdict))
    measured = [r for r in cat_rows if r["status"] == "OK"]
    pending = [r for r in cat_rows if r["status"] != "OK"]
    print("\ncoverage: %d of 7 categories measured" % len(measured))
    if pending:
        print("PENDING rows (fix with data): " + "; ".join(r["category"] + " - " + str(r.get("source", ""))
                                                           for r in pending))
        print("HEALTH SCORE: withheld - not every category has a measured source. "
              "A score over partial evidence is the one thing this family of skills never prints.")
    else:
        # only score when all measured: quote the scanner verdicts, no invented maths
        print("HEALTH SCORE: consistent (all 7 rows have a measured source; "
              "open findings/*.txt and the board above for the per-category verdicts).")

    print("\nPhase 5 - artifacts written")
    for art in (outdir + "/FULL-AUDIT-REPORT.md", outdir + "/ACTION-PLAN.md",
                outdir + "/audit-data.json", outdir + "/findings/"):
        print(art)
    print("audit run: " + TODAY + " | source URLs are public pages of the target site")

    # write artifacts
    categories = []
    for row in cat_rows:
        categories.append({"name": row["category"], "weight": row["weight"],
                           "status": row["status"], "source": row["source"],
                           "verdict": row["verdict"]})
    envelope = {
        "summary": {
            "health_score": None if pending else "consistent",
            "url": url, "business_signals": p.get("business_signals"),
            "coverage": "%d/7" % len(measured), "audited_on": TODAY,
            "note": "health score withheld when a category has no measured source",
        },
        "categories": categories,
        "action_plan": {"phases": [
            {"name": "Phase 1: Critical Fixes", "timeframe": "Week 1",
             "items": [c for c in categories if c["status"] == "OK"]},
            {"name": "Phase 2: Data-Required Rows", "timeframe": "When data arrives",
             "items": [c for c in categories if c["status"] != "OK"]}]},
        "artifacts": {"findings_dir": "findings/", "screenshots_dir": "n/a (no browser runtime)"},
    }
    with open(os.path.join(outdir, "audit-data.json"), "w", encoding="utf-8") as f:
        json.dump(envelope, f, indent=1)
    lines = ["# FULL AUDIT REPORT - %s" % url, "", "Audited: " + TODAY, "",
             "| Category | Status | Source |", "|---|---|---|"]
    for c in categories:
        lines.append("| %s | %s | %s |" % (c["name"], c["status"], c["source"]))
    with open(os.path.join(outdir, "FULL-AUDIT-REPORT.md"), "w", encoding="utf-8") as f:
        f.write("\n".join(lines) + "\n")
    plan = ["# ACTION PLAN - %s" % url, ""]
    for ph in envelope["action_plan"]["phases"]:
        plan.append("## " + ph["name"] + " (" + ph["timeframe"] + ")")
        for c in ph["items"]:
            plan.append("- [ ] " + c["name"] + " - " + c["source"])
        plan.append("")
    with open(os.path.join(outdir, "ACTION-PLAN.md"), "w", encoding="utf-8") as f:
        f.write("\n".join(plan) + "\n")

    if json_mode:
        print(json.dumps(envelope, indent=1))
    return 0


if __name__ == "__main__":
    sys.exit(main())

# 1) create the skill directory
mkdir -p ~/.codex/skills/codex-seo-audit/scripts

# 2) save the SKILL.md (paste the first code block above into the file below)
nano ~/.codex/skills/codex-seo-audit/SKILL.md

# 3) save the script (paste the second code block above)
nano ~/.codex/skills/codex-seo-audit/scripts/fullsite_audit.py

# 4) smoke test - one command, default skills directory
python3 ~/.codex/skills/codex-seo-audit/scripts/fullsite_audit.py https://your-site.com

FULL-SITE AUDIT: https://auspia.ai
==================================================
Phase 1 - site probes
status 200 | final URL: https://auspia.ai
title chars: 46  meta desc: 80  h1: 1  h2: 9
images: 15 total, 6 with alt
jsonld blocks: 2  security headers: strict-transport-security
business signals: SaaS
sitemap https://auspia.ai/sitemap.xml (single): 1037  robots hint: yes

Phase 2 - skill inventory (skills)
installed skills: backlinks, cluster, competitor-pages, content, geo, google, hreflang, images, local, page, plan, programmatic, ready, schema, sitemap, sxo, technical
missing (see the matching series post to install): hreflang-parity

Phase 3 - scanner runs (each verdict is the scanner's own)
ready          OK        - codex-seo-competitor-pages planned | - codex-seo-plan planned | - codex-seo-audit planned  0.7s
technical      OK        - Warn: missing X-Content-Type-Options  4.1s
page           OK        - Warn: no H1 on page  2.1s
content        OK        links: 134 internal (105.3/1000w), 2 external | media: img 15 video 0 toc True | date None | author - | trust: privacy_policy, contact  1.6s
schema         OK        types: Organization, WebSite | block 1 [Organization]: ok | block 2 [WebSite, Organization]: ok  1.4s
images         OK        13. https://auspia.ai/logo.svg 11.3kb missing-alt; no-dimensions(CLS); no-loading-hint; no  10.3s
sitemap        OK        sitemap https://auspia.ai/blog/blog-index.xml status 200 | xml ok: True tag: sitemapindex urls: 3 size: 0.0MB | index file with  19.1s
geo            OK        top fixes: | - move your best answer block into the first 30% of the page | - add publication date (and ideally last modified)  2.9s
local          OK        result: NO LOCAL SIGNALS  1.4s
hreflang       OK        WARN no hreflang tags found on https://auspia.ai  1.6s
plan           OK        link inventory (codex-seo-backlinks). | NOT PUBLISHABLE from this recon: any KPI row not mapped above. Leave it as a manual row until a r  2.7s

Phase 4 - weighted board (the audited scorecard)
Technical SEO            OK            (weight 22%)  - Warn: missing X-Content-Type-Options
Content Quality          OK            (weight 23%)  links: 134 internal (105.3/1000w), 2 external | media: img 15 video 0 toc True | date None | author - | trust: privacy_policy, contact
On-Page SEO              OK            (weight 20%)  - Warn: no H1 on page
Schema / Structured Data OK            (weight 10%)  types: Organization, WebSite | block 1 [Organization]: ok | block 2 [WebSite, Organization]: ok
Performance (CWV)        PENDING       (weight 10%)  no scanner by default - PSI key (technical_scan --psi) or field CSV
AI Search Readiness      OK            (weight 10%)  top fixes: | - move your best answer block into the first 30% of the page | - add publication date (and ideally last modified)
Images                   OK            (weight 5%)  13. https://auspia.ai/logo.svg 11.3kb missing-alt; no-dimensions(CLS); no-loading-hint; no-fetchpriority | 14. https://auspia.ai/logo.svg?dpl=dpl_7yYV

coverage: 6 of 7 categories measured
PENDING rows (fix with data): Performance (CWV) - no scanner by default - PSI key (technical_scan --psi) or field CSV
HEALTH SCORE: withheld - not every category has a measured source. A score over partial evidence is the one thing this family of skills never prints.

Phase 5 - artifacts written
/Users/charles/claude-felo-workspace/codex-seo-series/auspia.ai-audit/FULL-AUDIT-REPORT.md
/Users/charles/claude-felo-workspace/codex-seo-series/auspia.ai-audit/ACTION-PLAN.md
/Users/charles/claude-felo-workspace/codex-seo-series/auspia.ai-audit/audit-data.json
/Users/charles/claude-felo-workspace/codex-seo-series/auspia.ai-audit/findings/
audit run: 2026-09-01 | source URLs are public pages of the target site

coverage: 6 of 7 categories measured
HEALTH SCORE: withheld - not every category has a measured source

<PASTE_TO_CODEX>
You will install a Codex skill. Read the two code blocks in the page you were pasted from: the block that starts with the YAML frontmatter `name: codex-seo-audit` and the block that starts with `#!/usr/bin/env python3` (which contains the string `fullsite_audit.py`).

1. Create the directory ~/.codex/skills/codex-seo-audit/scripts.
2. Save the YAML block to ~/.codex/skills/codex-seo-audit/SKILL.md (only the frontmatter and body; do not include the fence lines).
3. Save the Python block to ~/.codex/skills/codex-seo-audit/scripts/fullsite_audit.py (keep the shebang and everything after it).
4. Run: python3 ~/.codex/skills/codex-seo-audit/scripts/fullsite_audit.py https://example.com
5. If example.com fails to fetch, try the user's real site when they provide its URL.
6. Report back: how many series skills were found inline, how many of the 7 board categories are measured, and whether the health score was withheld.

Do not modify any existing skill directories. Do not touch ~/.codex/skills/ outside the codex-seo-audit directory. Timebox the smoke test to one run unless the user asks for more.
</PASTE_TO_CODEX>