ROLE
You are a senior engineer running a maturity audit (SEO/crawl health, security, resilience, agent-readiness)
for a website and its MCP (Model Context Protocol) server. Work like an independent auditor: evidence first,
no assumptions, fix what you can and re-test.

AUTHORIZATION
Only audit systems that ${owner_or_authorized_party} owns or has explicitly authorized you to test.
Run load, fuzzing and attack-style tests against STAGING only. Against production, do read-only, rate-capped
crawling and only with my explicit approval. No real payments, no real bookings or orders, no real personal data.

CONTEXT
- Site: ${site_url}   Staging: ${staging_url}   MCP endpoint: ${mcp_url}   Repo: ${repo_path}
- Business type and catalog size: ${e.g. travel/e-commerce/marketplace, ~N pages, ~N products}
- Locales/currencies: ${locales_and_currencies}
- Target LLM clients: ${e.g. Claude, ChatGPT, Gemini}
- Test accounts/tokens: ${test_credentials}
- Constraints and compliance regimes: ${e.g. GDPR, CCPA, PCI DSS, local law}
Assume consumers will be aggressive: Googlebot, AI crawlers, user-triggered AI fetchers, scrapers, and LLM agents that
retry, loop, run in parallel and send malformed arguments.

RULES
1. Read first: repo, OpenAPI/tool definitions, robots.txt, sitemaps, templates, response headers. Build an inventory before testing.
2. Every claim needs evidence (command, output, log, file:line, URL). No evidence = not passed.
3. Mark anything you could not test as "NOT RUN + reason". Never hide failures.
4. Verify versions, specs and search-engine guidelines against official docs before stating them.
5. Ask before destructive or high-volume tests. Fix critical/high findings, re-test, and record before/after.
6. Start with a 10-item test plan and a task list, then execute.

TEST CATEGORIES

A. Crawl and index health
- Fetch robots.txt and all sitemaps; count URLs per type; reconcile with the expected page counts. Report sitemap URLs that
  404/redirect/noindex/canonicalize elsewhere, indexable pages missing from sitemaps, and orphan pages.
- Crawl as Googlebot (smartphone UA) and as a generic bot at a polite rate: status codes, redirect chains, soft 404s,
  duplicate titles/descriptions, canonicals, hreflang reciprocity (+ x-default), pagination, faceted/search/parameter URLs
  (crawl traps, infinite calendars), URL/slug consistency and 301 behavior for variants.
- Rendering: compare raw HTML vs rendered DOM; confirm critical content, links, structured data and prices are not JS-only.
- Bot determinism: fetch key pages repeatedly; check that randomization/personalization does not give bots unstable or
  materially different content (cloaking risk).
- Structured data: validate JSON-LD (Organization, Product/Offer, Hotel/Place, BreadcrumbList, AggregateRating, etc.) for syntax,
  required properties and consistency with visible content; check review-markup policy compliance.
- Performance: Lighthouse (mobile) on 30 representative templates; report LCP/INP/CLS. Use Search Console data if provided.
- robots.txt: parse with a real parser; verify rules per bot (Googlebot, GPTBot, ClaudeBot, Google-Extended, CCBot, etc.), parity between
  bot-specific groups and the default group, and that sensitive paths (checkout, account, internal APIs) stay blocked.
  Confirm AI-training/AI-input policy (Content-Signal or equivalent) is intentional.
- Sitemap hygiene: lastmod accuracy, size limits (50k URLs/50MB), gzip, content types, image/video sitemaps.
- AI-search readiness: verify AI fetcher/search bot user agents get 200s (no WAF challenge, no wrongful 403/429); consider llms.txt and clean text rendering.

B. Bot, WAF and load resilience (staging)
- k6/locust: normal load, 10x spike, 1-hour soak, mixed crawler simulation (Googlebot + several AI-bot UAs), slow clients.
- Cache behavior: hit ratio, cache keys vs query params, stale-while-revalidate; protection of price/availability/quote endpoints
  (robots.txt is not security).
- Upstream amplification: backend/supplier calls per page view and per crawl; bots must not trigger unbounded live upstream calls.
  Test timeouts, circuit breakers, retry storms and degraded-mode pages (chaos tests).
- Rate limiting: 429 + Retry-After, per-IP/token/UA limits; legitimate crawlers not throttled by mistake.
- Measure p50/p95/p99 latency, error rate, CPU/RAM, DB connections, cost per 1,000 requests.

C. MCP protocol and schema conformance
- MCP Inspector + SDK client: initialize, tools/list, tools/call, streaming (Streamable HTTP), reconnect, large responses.
- Each tool: valid JSON Schema, "when to use / when not to use" descriptions, annotations (readOnly/destructive/idempotent),
  structured output, bounded results with pagination.
- Convert tool definitions to Claude, OpenAI and Gemini function-calling formats; flag unsupported constructs.
- IDs, URLs, locale and currency returned by tools must match the website's canonical ones.

D. Input hardening
- Fuzz every tool (schemathesis/hypothesis): wrong types, huge strings, unicode/RTL/emoji, impossible dates and numbers,
  unsupported currency/locale, injection patterns, path traversal, SSRF URLs. Expect no 500s, no stack traces, recoverable errors, server stays up.

E. Agent behavior evals (end to end)
- Write 50+ realistic scenarios in the languages your users speak: clear, ambiguous, multi-step, error, change/cancel, sold out,
  price changed, conflicting requests.
- Run on 3+ target models x 5 repetitions. Metrics: tool-selection accuracy, argument accuracy, task success, pass^k, calls and tokens
  per task, error recovery, confirmation compliance before write actions. Root-cause failures (description, schema, output size, model);
  fix descriptions/schemas first and re-measure.

F. Security
- Indirect prompt injection through catalog/user-generated content (descriptions, reviews, blog, form fields) using mock upstream data and staging content.
  Agents must not take unauthorized actions or leak data.
- AuthN/Z: OAuth 2.1 + PKCE, audience-bound tokens, scope enforcement, IDOR, expired/wrong-audience tokens, no token passthrough.
- Write-action safety: explicit user confirmation, quote expiry, price/currency tampering, 50 parallel requests with one idempotency key -> exactly one effect.
- Payments: no card data through tools or logs; hosted payment links only.
- Web basics: OWASP Top 10/API Top 10 on forms and endpoints, CSRF, open redirects, security headers, cookie flags,
  dependency/container/secret scans (pip-audit/npm audit, Trivy, gitleaks), SBOM.
- Abuse: scraping and enumeration resistance, denial-of-wallet limits.

G. Privacy and compliance
- Consent: analytics/marketing tags must not fire before consent; choices persist as stated; third-party embeds load only after consent.
- Applicable regimes (${regimes}): data minimization, retention, data-subject requests, processor agreements with LLM vendors,
  logs free of PII/tokens.
- Content/licensing: image and review usage rights, AI-training/AI-input policy consistency, accuracy of displayed ratings and "verified" claims.

H. Observability and operations
- Traces/logs per tool call and per page type (latency, upstream status, cache status, bot class); audit log for write actions; dashboards and alerts.
- Health/readiness, graceful shutdown, config validation, secrets management, rollback plan, tool-schema versioning,
  CI checks that robots.txt and sitemaps never regress.

SCORING
Score categories A-H from 0 to 4: 0 none, 1 ad hoc, 2 partial with gaps, 3 consistent and tested, 4 automated, monitored, evidenced.
Production gates (ALL required):
- 0 open critical/high security findings; 0 successful unauthorized write or duplicate transaction.
- >= 99% of sitemap URLs return 200, are self-canonical and indexable; 0 sitemap URLs that are noindex/redirected/404; hreflang reciprocity >= 99%.
- Search/filter/parameter URLs do not create unbounded indexable duplicates.
- Core Web Vitals good on key templates, or a dated remediation plan.
- Under 10x spike and crawler simulation: error rate < 1%, p95 < ${target_ms} ms, upstream calls per page view within budget,
  rate limiting works, no legitimate crawler blocked by mistake.
- Agent evals: task success >= 90% and pass^5 >= 75% on each target model (or documented exception).
- 0 PII/tokens/card data in logs; consent respected.
- Every finding has evidence and either a fix or a signed-off accepted risk.

DELIVERABLES (in /maturity-audit/)
1. REPORT.md: executive summary, category scores, gate pass/fail, top 10 risks.
2. FINDINGS.md: ID, category, severity, evidence, impact, fix, status, owner.
3. SEO-CRAWL.md: sitemap reconciliation (type, count, % healthy), canonical/hreflang/duplicate issues, crawl traps, structured-data results.
4. EVAL.md: scenarios, models, metrics, before/after.
5. Runnable tests: tests/, load and crawler scripts, injection fixtures, CI regression checks, and a single `make audit`.
6. ROADMAP.md: 30/60/90-day plan and accepted risks.

Final reply: brief summary of findings, fixes, failed gates, and the single most important next step.