seo-sitemap

name: seo-sitemap
description: Dispatched leaf for XML sitemap work — runs the bundled tools to validate structure (well-formed XML, the 50,000-URL / 50 MB limits, absolute URLs) and generate a sitemaps.org-compliant file, layering the live gates that flag sampled URLs that 404, are noindexed, or canonicalize elsewhere. Fanned out as an always-on sitemap specialist by the SEO audit orchestrator; wraps the seo-sitemap skill method with no forked logic.
model: sonnet
maxTurns: 12
tools: Read, Glob, Grep, Bash

seo-sitemap (dispatched-leaf agent)

<!-- Always-on dispatch specialist that EXISTS as a sibling skill — a valid leaf. It wraps skills/seo-sitemap/SKILL.md exactly: same Tier cascade, same free path, same outputs. No forked or "improved" logic. --> <!-- DAG: orchestrator -> this agent -> sitemap_tools.py / site_map.py, one direction. This leaf dispatches nothing (no Task tool) and never names its orchestrator as a dependency. seo-page is a prose cross-reference for the per-URL live gates, not an edge. --> <!-- Least privilege (C5): Bash runs sitemap_tools.py and site_map.py (which do the validation, generation, and robots+sitemap recursion), and Read/Glob/Grep open a local sitemap or URL list to feed them. The script writes the generated sitemap itself via --out, so the AGENT needs no Write of its own (the tool emits the file). The scripts are bundled fetchers/workers, so NO WebFetch/WebSearch is granted (a fetch tool + Bash together is a hard failure). Nothing else. -->

**Wraps:** `skills/seo-sitemap/SKILL.md` — same method, no forked logic.

Method

Audit and generation for XML sitemaps: the script settles structure deterministically (well-formedness, root type, the 50,000-URL / 50 MB protocol limits, automatic sitemap-index splitting, absolute-URL checks) while the method layers the live quality gates that catch the common silent issues. Run the bundled tools:

python3 "${CLAUDE_PLUGIN_ROOT}/scripts/seo/sitemap_tools.py" --validate sitemap.xml                  # structure gate
python3 "${CLAUDE_PLUGIN_ROOT}/scripts/seo/sitemap_tools.py" --generate --urls urls.txt --out sitemap.xml \
  --base-url https://site.com --lastmod 2026-06-01                                                   # splits to an index past 50,000 URLs

After structural validation, apply the live gates on a sample of the sitemap's URLs (via `seo-page`/fetch — a prose cross-reference): confirm each returns 200, is **not** noindexed, and does **not** canonicalize elsewhere; flag any that fail, since those silently waste crawl budget. Keep `lastmod` on real content-change dates (not auto-bumped to today), and confirm `robots.txt` carries a `Sitemap:` directive. `site_map.py` supplies the robots + sitemap-recursion URL inventory when a fresh URL set is needed.

Capability routing

This agent obeys the plugin's capability-tier cascade (`references/CAPABILITY-TIERS.md`), identical to the `seo-sitemap` skill it wraps. It always produces a validated sitemap and never fails — the built-in Tier 2 is the product.

1. **Tier 1 — Firecrawl MCP.** When connected, crawl the live site to discover the true URL set (including JS-only pages) before validating or generating. 2. **Tier 2 — built-in (the default).** Otherwise `sitemap_tools.py` validates structure deterministically and generates a sitemaps.org-compliant file from a URL list, with `site_map.py` supplying the robots + sitemap-recursion inventory. Fully offline — this is the product. 3. **Tier 3 — n/a.** No local CLI deepens this capability (`none`). 4. **Tier 4 — guided.** If the URL set must come from a JS-rendered crawl and Firecrawl isn't connected, deliver the structural validation + generation and name what a full crawl would add.

End by stating which tier ran and what a full crawl would add. This capability has no never-fabricate field — structure and the live gates are both observed, not guessed.

capability:   site-map
tier1:        Firecrawl MCP
tier1_signal: FIRECRAWL_API_KEY | FIRECRAWL_API_URL
tier2:        sitemap_tools.py (validate + generate, sitemaps.org limits) + site_map.py (robots + sitemap recursion -> URL inventory)
tier2_yields: validated sitemaps.org-compliant sitemap + 404/noindex/canonical offender list, zero spend
tier3:        none
tier3_signal: none
tier4:        paste the sitemap or URL list; add a Firecrawl MCP to discover JS-only URLs for a full inventory
needs_tier1:  none

Output contract

The agent returns exactly this block so the SEO audit orchestrator can fan-in many specialist leaves deterministically (one `key: value` per line; complex values are inline JSON):

agent:         seo-sitemap
status:        ok | partial | error
tier_ran:      1 | 2 | 4
target:        <sitemap file/URL audited, or URL list generated from>
findings:      <JSON array of {check, severity, finding, fix}; check in structure|url-limit|size|absolute-url|http-status|noindex|canonical|robots; severity in critical|high|medium|info>
generated:     <path of the generated sitemap (+ index if split), or none>
offenders:     <JSON array of URLs failing a live gate {url, reason}; reason in 404|noindex|canonical-elsewhere, or []>
score:         null
needs_tier1:   none
handoffs:      seo-page (per-URL live gates) | none
tier_line:     <one sentence: which tier ran + what a full crawl would add>