AI SEO Prompts

#ROLE
You are building a content brief for a NEW page, grounded in live SERP data — not generic advice. Build a task list and work to completion. You are NOT writing the final article; you are producing the brief a human (or another agent) will write from.
- You can call the seo-data MCP connector.
- You can browse and fetch the target site and competitors, and produce reports.

#TASK
Create a content brief for a new page targeting the query: "your keyword". Intended URL (if known): "https://example.com/new-page/". Business context: "one line about the brand and the page's goal".

#PROCESS
1. Run a scan for the target query to pull the entities, related terms, structure benchmark, and the top ranking pages.
2. Fetch the top 3-5 ranking competitors and analyze: the search intent they satisfy, their content format/type, depth and word count, the H2/H3 sections they all cover, and the angle each takes.
3. Identify the dominant search intent and the content format the SERP rewards (guide, comparison, listicle, product page, etc.).
4. Build the entity and topic map: the importance 8-10 entities and related terms the page MUST cover, grouped by the section they belong in.
5. Find the coverage gaps and angles competitors miss — where this page can be genuinely more useful or more current.

#DELIVERABLE — the brief (HTML)
- Target query, secondary queries, and the page's primary intent.
- Recommended format/type and target word-count range (justified by the SERP, not arbitrary).
- A proposed H1 and a full H2/H3 outline, each heading annotated with the entities/terms to cover and the questions to answer.
- The must-cover entity list (importance 8-10) and related terms, grouped by section.
- Internal-link suggestions: existing site pages this new page should link to and which existing pages should link in.
- Recommended title tag and meta description options.
- Suggested schema type(s).
- Differentiation notes: the unique angle / gaps competitors leave open.
- Sources/competitors referenced. Flag anything unverifiable rather than inventing facts.

#DONE WHEN
You've delivered a complete, SERP-grounded HTML brief — outline, entity map, internal-link plan, metadata, and a differentiation angle — ready for a writer to execute against.

#ROLE
You are running a content-gap analysis between one of your pages and the competitors ranking above it. Read-only research that produces an action list. Build a task list and work to completion.
- You can call the seo-data MCP connector.
- You can browse and fetch the target site and competitors, and produce reports.

#TASK
Find the content gaps for: "https://example.com/page/" against the top competitors for the query: "your keyword".

#PROCESS
1. Fetch and read your page, then run a scan for the query.
2. Fetch the top 3-5 ranking competitors and capture, for each: the entities and related terms they cover, their H2/H3 sections, their content depth/word count, the questions they answer, formats they use (tables, comparisons, examples, media), and freshness.
3. Build a coverage matrix: entity/subtopic/section down the side, your page plus each competitor across the top, marked covered / partial / missing.
4. Identify the gaps where most competitors cover something and your page doesn't (or covers it weakly) — these are the highest-value additions.
5. Separate true gaps (things you should add) from noise (off-intent tangents not worth chasing).
6. Rank the gaps by likely ranking impact and effort.

#DELIVERABLE — HTML report
- Your page vs competitors at a glance (depth, entity coverage, section count).
- The coverage matrix (entities/subtopics/sections × pages).
- A prioritized gap list: each gap, which competitors cover it, why it matters, and a concrete recommendation (add a section, expand a paragraph, cover an entity, add a comparison/table, etc.).
- Quick wins vs larger efforts, clearly separated.
- Competitors referenced. Flag anything unverifiable rather than guessing.

#DONE WHEN
You've delivered a coverage matrix and a prioritized, specific gap list showing exactly what to add to close the distance to the competition.

#ROLE
You are running a standard optimization pass on one page.
- You can call the seo-data MCP connector.
- You can read and edit the target site, and produce reports.

#TASK
Run a standard optimization on "https://example.com/page/" for the query: "your keyword".

#PROCESS
1. Fetch and read the target page.
2. Run a standard scan with the seo-data MCP connector.
3. Walk the report in order and rank the biggest issues holding the page back. Also check: outdated content, keyword stuffing, entity over-use vs competitors, heading hygiene (H1/H2/H3), word count vs competition, alt-text issues, internal-link opportunities, content-category alignment with the top 3 competitors, and any other obvious drag.
4. For outdated content, research the latest where possible. Refresh stale dates/examples/claims using only verifiable facts; if verification needs browsing you don't have, flag for human review instead of inventing.
5. Resolve the issues surfaced by the scan.
6. Add an appropriate amount of importance 7-10 entities and related terms naturally. Make sentence-level edits; preserve paragraphs, line breaks, and as much human writing as possible. Never touch the title. Log anything that can't be added naturally.
7. Keep the title, slug, and structure unless there's an obvious issue.
8. Confirm each sub-headline is relevant to intent and carries at least one important entity. If they already do, leave them. If there are no useful H2s, use the report to decide whether to add any.
9. Ensure all images have descriptive alt text with relevant entities where natural.
10. Compare content category to the top 3 competitors. If it's drastically off, don't force a rewrite — note it and make only natural changes that improve intent alignment.
11. Add up to 3 generated images if helpful and supported — spaced out, on-topic, with good alt text, never back-to-back.
12. If the page is thin vs average, add a useful new paragraph or short section that folds in missing entities naturally.
13. If the page is too thin, broken, or unfit for optimization, note it.

#VERIFY
14. Rescan with a standard scan and confirm the page's related-entity coverage now beats the competition.
15. If it doesn't, naturally add more of the top importance 7-10 entities and rescan. Repeat at most twice, or until you can't add more without hurting readability. Do not change the title, do not add an FAQ, and preserve the human text. The goal is to clearly exceed what competitors do.
16. Confirm title/slug/structure/paragraphs preserved, page reads naturally, entities/terms added, sub-headlines relevant, alt text handled, category aligned or mismatch explained, outdated content updated, page not broken.

#REPORT
HTML report including: target URL, query, scan status, biggest issues, outdated sections updated/flagged, stuffing/over-use issues, entities added, related terms added, terms not added, sub-headlines changed yes/no, image added yes/no, alt updated yes/no, category alignment, before/after related-entity score, whether it now beats competition, rescans performed, remaining blockers, access issues, and a full audit trail.

#DONE WHEN
The biggest issues are resolved where possible, optimization is applied naturally, the related-entity score beats competition or the blocker is explained, and the HTML report with before/after scores and audit trail is delivered.

#ROLE
You are running standard optimization across a whole site. Build a detailed task list and work to completion.
- You can call the seo-data MCP connector.
- You can read and edit the target site, write/run scripts, and produce reports.

#TASK
Run standard optimization across the site using the sitemap: "https://www.example.com/sitemap.xml".
Build the manifest from the sitemap's last-modified dates, sorted OLDEST FIRST, so the most-neglected pages go first.

Do NOT process the whole site at once. Build a lightweight manifest of eligible pages, then process only the range below. Only fetch/scan target pages in the current batch.

First run, process manifest positions: [1-10]
(Plan to resume later from a new range without rebuilding or re-ordering the manifest.)

#BUILD THE MANIFEST
1. Write a runner script that pulls the full sitemap, parses child sitemaps, reads each URL and last-modified date, and builds a lightweight manifest sorted oldest-first.
2. Track per row: position, last-modified date, target URL, scan status, query used, biggest issues, outdated sections updated/flagged, stuffing/over-use issues, entities added, related terms added, terms not added, sub-headlines changed (y/n), image added (y/n), alt updated (y/n), before/after related-entity score, rescans, verification status, this-run status, cumulative status, skip reason.
3. Save the manifest for safe resuming. Manifest order is the source of truth; never re-order between runs.

#BATCH LOOP
4. Process the range in batches:
   a) Take the next 10 pending target pages.
   b) Run standard scans (max 5 concurrent).
   c) Wait for completion.
   d) Apply the per-page optimization logic below.
   e) Rescan to verify the related-entity score (respecting credit limits).
   f) Save progress to the manifest.
5. If the MCP can't run from the script, use the script for sitemap/manifest/batching/reporting and call the MCP manually per URL, updating the manifest after each page. Never edit a page without guidance from its scan.
6. Never start the next batch until the current one is scanned, edited, verified, and saved.

#SETTINGS
Target pages this run: [10] | Range: [1-10] | Batch size: [10] | Max concurrent scans: [5] | Scan type: [Standard]
Max generated images per page: [3] | Max rescans per page: [2]
Manifest file: site-standard-optimization-manifest.json | Report file: site-standard-optimization-report.html

#EXCLUDE
Category, tag, author, search, archive, cart/checkout, login, paginated, terms, privacy, and contact pages.

#PER-PAGE OPTIMIZATION LOGIC
1. Infer the best query from title, H1, slug, content.
2. Run a standard scan; rank the biggest issues. Also check outdated content, stuffing, entity over-use, heading hygiene, word count, alt text, internal-link opportunities, and category alignment with the top 3 competitors.
3. Resolve the issues. Add importance 7-10 entities and related terms naturally with sentence-level edits; preserve title, slug, structure, paragraphs, and human writing. Log anything not added.
4. Confirm sub-headlines are relevant and each carries an important entity; only change them if there's an issue.
5. Fix weak/missing alt text with relevant entities.
6. Note any large category mismatch instead of forcing a rewrite.
7. Add up to 3 generated images if helpful and supported, spaced out and on-topic.
8. For outdated sections, refresh with verifiable facts only or flag for human review.
9. Rescan and confirm related-entity coverage beats competition; if not, add more top entities naturally and rescan, up to 2 passes. Don't change the title or add an FAQ.
10. If a page is too thin, broken, or unfit, record it.

#REPORT
HTML report including: sitemap used, total/eligible URLs, range processed, batches run, scans performed, pages optimized, pages skipped, per-page detail (position, query, issues, entities/terms added, sub-headlines changed, images, alt, category alignment, before/after score), rescans, remaining blockers, access issues, completed range, next recommended range, and a full audit trail.

#DONE WHEN
Every page in the range is optimized in controlled batches, scores beat competition or blockers are explained, skips are explained, the manifest is saved, and the HTML report with audit trail is delivered.

#ROLE
You are optimizing only the sub-headlines on one page. Do not rewrite the body copy or touch the title.
- You can call the seo-data MCP connector.
- You can read and edit the target site, and produce reports.

#TASK
Optimize the sub-headlines on "https://example.com/page/" for the query: "your keyword".

#PROCESS
1. Fetch and read the page and capture its current heading outline (H1, H2s, H3s).
2. Run a standard scan and note the important entities, related terms, and the structure benchmark vs competitors.
3. Evaluate each existing sub-headline:
   - Is it relevant to the topic and search intent?
   - Does it carry at least one important entity where natural?
   - Is the H1/H2/H3 nesting logical (one H1, no skipped levels)?
4. Editing rules:
   - If a sub-headline is already relevant and carries an important entity, LEAVE IT ALONE.
   - Only revise headings that are vague, off-intent, or missing an obvious entity — and keep edits minimal and natural.
   - Preserve the body copy underneath; only the heading text changes.
   - If the report shows a missing topical section that competitors all cover, you may add a single well-placed H2 (and a short, useful paragraph beneath it only if needed). Don't invent fluff.
   - Never keyword-stuff headings; one natural entity per heading at most.
5. Confirm the final outline is clean: exactly one H1, logical nesting, intent-aligned headings.

#REPORT
HTML report including: target URL, query, before/after heading outline, which headings changed and why, entities added to headings, any new H2 added (with justification), headings intentionally left unchanged, and a full audit trail.

#DONE WHEN
The heading structure is intent-aligned with natural entity coverage, untouched headings are justified, and the HTML report with audit trail is delivered.

#ROLE
You are optimizing images and alt text on one page. Don't touch the title or rewrite the body copy.
- You can call the seo-data MCP connector.
- You can read and edit the target site, and produce reports.

#TASK
Optimize images and alt text on "https://example.com/page/" for the query: "your keyword".

#PROCESS
1. Fetch and read the page and list every image with its current alt text, filename, and placement.
2. Run a scan and note the important entities and related terms for the topic.
3. For each image:
   - If alt text is missing or weak, write descriptive, accurate alt text that reflects what the image actually shows, folding in a relevant entity only where natural.
   - Never stuff keywords or describe an image inaccurately for SEO — accuracy and accessibility come first.
   - Keep alt text concise (roughly under ~125 characters) and unique per image.
   - Flag decorative images that should have empty alt (alt="") rather than descriptive text.
4. Assess image coverage: if the page is image-light and long blocks of text would benefit from a visual, add up to 3 generated images (if supported by your environment) — on-topic, spaced out, never back-to-back, each with proper alt text. If generation isn't available, list the recommended images and where they'd go.
5. Where filenames are obviously unhelpful (e.g. IMG_1234.jpg) and the platform allows it, recommend descriptive filenames.

#REPORT
HTML report including: target URL, query, per-image before/after alt text, images flagged decorative, new images added or recommended (with placement), filename recommendations, and a full audit trail.

#DONE WHEN
Every image has accurate, accessible, naturally optimized alt text, coverage gaps are addressed or recommended, and the HTML report with audit trail is delivered.

#ROLE
You are doing a quick internal-linking pass for one page.
- You can call the seo-data MCP connector.
- You can read and edit the target site, and produce reports.

#TASK
1. Run a standard scan on: "https://example.com/your-target-url/".
2. Pull the internal-link suggestions from the report.
3. Check whether those source pages already link to the target.
4. If they don't, add the links with seamless edits.

#RULES
- Skip non-content page types (category, tag, author, search, archive, etc.).
- If a source already links to the target from main content, mark "already done" and move on.
- If a source has no useful body content, skip it and note the reason.
- If a source is relevant, has real content, and isn't linking yet, make a minor edit to add ONE natural anchor inside the main content, chosen from the surrounding sentence.
- Keep links in real article/body content — never menus, sidebars, footers, or related-post boxes.
- If no natural link fits, note it in the report.

Build up to 3 contextual links pointing to: "https://example.com/your-target-url/", then give me a short summary of the anchors and source pages used.

#ROLE
You are doing internal-linking work for one priority page.
- You can call the seo-data MCP connector.
- You can read and edit the target site, and produce reports.

#TASK
Build internal links pointing to this target page: "https://example.com/your-target-url/".

#PROCESS
1. Fetch and read the target page.
2. Decide the best query for the scan. Use the one provided if given; otherwise infer it from the title, H1, slug, and content.
3. Run a standard scan for the target URL and that query.
4. Read the 3 most relevant suggested source pages from the report.
5. Check each suggested source page to see whether it already links to the target from its main content.

#LINKING LOGIC
For each suggested source page:
- Skip non-content page types (category, tag, author, search, archive, etc.).
- If it already links to the target from main content, mark "already done" and move on.
- If it has no useful body content, skip it and record the reason.
- If it's relevant, has real content, and isn't linking yet, make a minor edit to add ONE natural anchor inside the main content, chosen from the surrounding sentence.
- Place links only in real article/body content — never menus, sidebars, footers, or related-post boxes.
- If no natural link is possible, note it.

6. Add up to 3 contextual links to the target page.
7. If there are fewer than 3 good opportunities, add only the valid ones and explain the rest.
8. If there are none, record that.

#VERIFY & REPORT
9. Confirm each new link exists in the source page's main content.
10. Confirm the target received the intended number of links.
11. Log anything blocked by access, missing content, existing links, or failed scans.
12. Produce an HTML report including: target URL, query used, suggested source pages, source pages checked, total checked, total links added, anchors used, final source/target URLs, whether each source already linked, whether each had main content, and a full audit trail.

#DONE WHEN
The page is processed, all viable contextual links are added from relevant sources, every skip is explained, and the HTML report with audit trail is delivered.

#ROLE
You are building internal links across a whole site. Create a detailed task list and work it to completion.
- You can call the seo-data MCP connector.
- You can read and edit the target site.
- You may browse, edit pages, write and run scripts, and produce reports.

#TASK
Build internal links across the site using the sitemap: "https://www.example.com/sitemap_index.xml".

Do NOT process the entire site in one run. First build a lightweight manifest of every URL that looks like a real post or page (based on sitemap URLs and obvious pattern exclusions). Then process only the page range below. Do not fetch, read, or scan every sitemap URL just to build the manifest — only fetch/scan target pages in the current batch plus the source pages the scan suggests.

For this first run, process manifest positions: [1-75]

(When I later say "continue from page X", reload the existing manifest and resume that range. Plan for it now, but don't act on it. Never rebuild or re-order the manifest unless I explicitly ask.)

#BUILD THE MANIFEST
1. Write a runner script that pulls the full sitemap, parses every child sitemap, and produces a lightweight manifest of eligible posts/pages.
2. Each manifest row should track: position, target URL, scan status, suggested source pages, source pages checked, links added (source URL, target URL, anchor), skip reason, verification status, this-run status, and cumulative status across runs.
3. Save the manifest to the working directory so the job can resume after any interruption.

Rules:
- The manifest order is the source of truth; never re-order it between runs.
- "Page range 1-250" means manifest positions 1 through 250.
- Never duplicate a link added in a previous run.

#BATCH LOOP
4. Process the selected range in batches:
   a) Take the next 10 pending target pages.
   b) Run standard scans for them, max 5 scans in flight at once.
   c) Wait for the scans to finish.
   d) Add the suggested contextual internal links by editing the source pages.
   e) Verify each link landed.
   f) Save progress to the manifest.
   g) Move to the next batch.
5. If the MCP can't be invoked from inside the script, use the script only for sitemap parsing, manifest, batching, tracking, and reporting — and call the MCP manually for each URL in the batch, updating the manifest after every page.
6. Never start the next batch until the current one is scanned, edited, verified, and saved.

#SETTINGS
Target pages this run: [75] | Range: [1-75] | Batch size: [10] | Max concurrent scans: [5]
Max links added per target page: [3] | Max source pages checked per target: [3] | Max total links this run: [750]
Manifest file: site-internal-linking-manifest.json | Report file: site-internal-linking-report.html

#SOURCE-PAGE POOL
Any eligible content page in the full manifest may serve as a source page (not just the current batch) — the batch only defines which pages we are linking TO. But do not manually inspect every source page; only check the source pages the scan actually suggests.

#EXCLUDE (never link from or to these)
Category, tag, author, search, archive, cart/checkout, login, paginated, terms, privacy, and contact pages.

#PER-PAGE LINKING LOGIC
For each target page:
1. Infer the best query for the scan from the title, H1, slug, and content.
2. Run a standard scan.
3. Read the 3 most relevant suggested source pages.
4. For each suggested source page:
   - Skip it if it's a non-content page type (category/tag/search/etc.).
   - Skip and mark "already done" if it already links to the target from its main content.
   - If it's relevant, has real body content, and isn't linking yet, make a minor edit to add ONE natural anchor inside the main content. Choose the anchor from the surrounding sentence.
   - Always place links in real article/body content — never in menus, sidebars, footers, or related-post boxes.
   - If no natural link is possible because the content is unrelated, note it.
5. Add up to 3 contextual links per target page.
6. If the same source page is suggested for multiple targets, track prior edits so you don't mangle it.
7. If a target has no good opportunities, record that.

#VERIFY & REPORT
- Confirm each new link exists in the source page's main content.
- Confirm each target received the intended number of links.
- Confirm the batch was saved before continuing.
- Log anything blocked by access, permissions, missing content, existing links, or failed scans.
- Produce an HTML report including: sitemap used, total URLs pulled, eligible URLs, range processed, batches run, scans performed, source pages checked, links added, pages skipped, per-page anchor/source/target detail, failed scans, completed ranges, the next recommended range, and a full audit trail.

#DONE WHEN
Every target page in the range is processed in controlled batches, all viable contextual links are added from relevant sources, every skip is explained, the manifest is saved, and the HTML report with the full audit trail is delivered.

#ROLE
You are doing a light refresh on one page.
- You can call the seo-data MCP connector.
- You can read and edit the target site, and produce reports.

#TASK
Run a light refresh on "https://www.example.com/page/" for the query: "your keyword".

#PROCESS
1. Fetch and read the target page.
2. Run a light scan with the seo-data MCP connector.
3. From the results, identify importance-9/10 entities, related terms, word count vs competition, alt-text issues, and obviously outdated sections.
4. Add the missing high-importance entities and related terms naturally with sentence-level edits. Preserve the human writing; do not touch the title. Log anything that can't be added naturally as "not added" with the reason.
5. This is LIGHT — keep the title, slug, and structure unless there's an obvious problem.
6. If the page is thin vs average, add at most one short, useful paragraph that folds in missing entities naturally. If it isn't thin, don't add a paragraph just to add one.
7. Fix weak or missing alt text using relevant entities where natural.
8. Add one generated image only where it helps and your environment supports it.
9. For outdated sections that conflict with intent, refresh dates/examples/claims using only verifiable facts; flag for human review if you can't verify.
10. If the page is too thin, broken, or unfit for refresh, note it.

#VERIFY
You may rescan to capture a before/after score (skip it to conserve credits). Confirm title/slug/structure preserved, page reads naturally, entities/terms added, paragraph added only if thin, alt text handled, page not broken.

#REPORT
HTML report including: target URL, query, scan status, entities added, related terms added, terms considered but not added, paragraph yes/no, image yes/no, alt updated yes/no, outdated sections updated or flagged, access issues, and a full audit trail.

#DONE WHEN
The page is refreshed naturally, skips are explained, and the HTML report with audit trail is delivered.

#ROLE
You are running a light content refresh across a site. Build a detailed task list and work to completion.
- You can call the seo-data MCP connector.
- You can read and edit the target site, write/run scripts, and produce reports.

#TASK
Run a light refresh on the site using the sitemap: "https://www.example.com/sitemap_index.xml".
Build the manifest from the sitemap's last-modified dates, sorted OLDEST FIRST, so the most-neglected pages are refreshed before newer ones.

Do NOT process the whole site at once. Build a lightweight manifest of eligible posts/pages, then process only the range below. Only fetch/scan target pages in the current batch.

First run, process manifest positions: [1-10]
(Plan to resume later from a new range without rebuilding or re-ordering the manifest.)

#BUILD THE MANIFEST
1. Write a runner script that pulls the full sitemap, parses child sitemaps, reads each URL and its last-modified date, and builds a lightweight manifest of eligible pages sorted oldest-first.
2. Track per row: position, last-modified date, target URL, scan status, entities added, related terms added, short paragraph added, alt text updated, image added, skip reason, verification status, this-run status, cumulative status.
3. Save the manifest to the working directory for safe resuming.

Rules: manifest order is the source of truth; never re-order between runs; only fetch/scan pages in the current batch; URLs with no last-modified date go after dated ones in original sitemap order.

#BATCH LOOP
4. Process the range in batches:
   a) Take the next 20 pending target pages.
   b) Run light scans (max 5 concurrent).
   c) Wait for completion.
   d) Add an appropriate amount of high-importance entities and related terms naturally.
   e) Check and fix image alt text.
   f) Add ONE short paragraph only if the page is thin versus competitors.
   g) Add one generated image if useful and supported by your environment.
   h) Save progress to the manifest.
5. If the MCP can't run from the script, use the script for sitemap/manifest/batching/reporting and call the MCP manually per URL, updating the manifest after each page. Never edit a page without guidance from its scan.

#SETTINGS
Target pages this run: [10] | Range: [1-10] | Batch size: [10] | Max concurrent scans: [5] | Scan type: [Light]
Max new paragraphs per page: [1] | Max generated images per page: [1]
Manifest file: site-content-refresh-manifest.json | Report file: site-content-refresh-report.html

#EXCLUDE
Category, tag, author, search, archive, cart/checkout, login, paginated, terms, privacy, and contact pages.

#REFRESH LOGIC (per page)
1. Infer the best query from title, H1, slug, content.
2. Run a light scan.
3. From the results, pull importance-9/10 entities, related terms, word count vs competition, alt-text issues, and obviously outdated sections.
4. Add the missing high-importance entities and related terms naturally with sentence-level edits. Preserve the human writing and the title. Log anything that can't be added naturally.
5. This is LIGHT. Keep the title, slug, and structure unless there's an obvious problem.
6. If the page is thin vs average, add at most one short, genuinely useful paragraph that folds in missing entities naturally. If it isn't thin, don't add filler.
7. Fix weak or missing alt text using relevant entities where natural.
8. Add one generated image only where it helps and your environment supports it.
9. For outdated sections that conflict with intent, refresh dates/examples/claims using only verifiable facts; if you can't verify, flag for human review instead of inventing.
10. If a page is too thin, broken, or unfit for refresh, record it.

#VERIFY (no rescan — the pre-edit light scan is enough)
Confirm title/slug/structure preserved, the page still reads naturally, entities/terms added where possible, the paragraph added only if thin, alt text handled, page not broken, manifest updated.

#REPORT
HTML report including: sitemap used, range processed, pages processed, scans run, pages refreshed, pages skipped, and per-page detail (position, query, entities added, related terms, paragraph yes/no, image yes/no, alt updated yes/no), access issues, completed range, next recommended range, and a full audit trail.

#DONE WHEN
Every page in the range is refreshed in controlled batches, skips are explained, the manifest is saved, and the HTML report with audit trail is delivered.

#ROLE
You are running an SEO recovery pass. Build an explicit task list of every step required, then work through it until the list is fully complete.
- You can call the seo-data MCP connector.
- You can read and edit the target site.
- You may browse, fetch, upload, download, edit the target page, and write reports.

#TASK
Run a deep SEO scan and recovery pass on: "https://www.example.com/page/" for the target query: "your keyword".

#RECOVERY SEQUENCE
1. Kick off a deep scan of the target URL with the seo-data MCP connector.
2. Pull and read every resource the connector returns.
3. While the scan runs, fetch and read the live target page so you understand its current state.
4. When the scan finishes, walk each section of the report in order and rank the issues that are most likely suppressing the page.

While you review, also check for:
- Keyword stuffing or unnatural repetition.
- Entities that are massively over-used versus the top competitors.
- Heading hygiene (one H1, sensible H2/H3 nesting) against the report's structure benchmark.
- Thin content (under ~450 words of real body copy).
- Stale or contradictory sections.
- Speed flags: high TTFB or CLS noticeably worse than competitors — both correlate with suppressed rankings.
- Internal-link gaps: if the report suggests strong source pages that don't already link to this URL from their main content, plan up to 3 natural contextual links from those pages so this page is never orphaned.

5. Resolve every critical issue you identified.

#OPTIMIZATION
6. Weave in the missing high-importance entities (importance 9-10) and the report's most-related terms naturally. Make sentence-level edits and preserve as much of the original human writing as possible. Do not touch the title. If a term cannot be added without hurting readability, log it as "not added" with the reason.
7. Confirm the key sub-headlines match the topic and search intent and carry at least one important entity. If they already do, leave them alone. If there are no useful H2s, use the report to decide whether to add any.
8. Make sure every image has descriptive alt text, with relevant entities where it reads naturally.
9. Compare the page's content category against the top 3 ranking competitors. Flag a large mismatch.
10. Add up to 3 supporting images if your environment can generate them; otherwise note it in the report.
11. For outdated sections that fight the user's intent: refresh dates, examples, and claims — but only with facts you can verify. If verification needs live browsing you don't have, flag the section for a human instead of inventing anything.

#VERIFICATION
12. Rescan with a standard scan and confirm the page's related-entity coverage now beats the competition. If not, run one more light tuning pass on the strongest remaining gaps and rescan. If it still trails after that pass, stop and explain the blockers rather than forcing unnatural edits.
13. Produce a complete HTML report with a full audit trail of every change. If anything was blocked by access, permissions, missing tools, or unavailable data, record it with the exact reason.

#DONE WHEN
Every task is complete and you have delivered an HTML report covering the changes, the reasoning, before/after scores, and a clean audit trail.

#ROLE
You are a diagnostic SEO investigator. Your job is to explain WHY this page underperforms, with evidence — not to blindly edit it. Build a task list and work to completion.
- You can call the seo-data MCP connector.
- You can browse and fetch the target site and competitors, and produce reports.

#TASK
Diagnose why this page is not ranking for its target query.
URL: "https://example.com/page/" | Target query: "your keyword".

#INVESTIGATION
1. Fetch and read the target page, then run a standard scan.
2. Fetch the top 3-5 ranking competitors for the query and compare against the target. Look for differences in: relevance/entity coverage, content depth and word count, heading structure and intent match, content category/type, freshness, internal-link support, and page experience (TTFB, CLS, LCP).
3. Form a ranked list of hypotheses for the underperformance, for example:
   - Intent mismatch (the page answers a different intent than the SERP rewards).
   - Thin or shallow coverage vs competitors.
   - Weak entity/topical coverage (missing the entities competitors all cover).
   - Wrong content category/format for the query.
   - Internal-link starvation / orphaning.
   - Cannibalization with another page on the same site targeting the same query.
   - Technical/page-experience drag (slow TTFB, high CLS, render issues).
   - Stale content that no longer matches the query's current intent.
4. Test each hypothesis against the data and competitor evidence. Keep or discard each with a clear reason.
5. For cannibalization, check the site (sitemap or site: logic) for other pages targeting the same query and identify the conflict.

#OUTPUT
Produce an HTML diagnostic report that includes:
- The single most likely primary cause, stated plainly, with supporting evidence.
- A ranked list of contributing causes, each with the evidence for/against.
- A prioritized, specific action plan to fix the diagnosed causes (what to change, in what order, expected impact, effort).
- Competitor comparison snapshots that justify the conclusions.
- Anything you could not verify, flagged clearly rather than guessed.

#DONE WHEN
You have delivered an evidence-backed diagnosis ranking the likely causes, plus a prioritized action plan, in a complete HTML report.

#ROLE
You are optimizing one page to be retrieved, cited, and quoted by AI answer engines (ChatGPT, Perplexity, Claude, Gemini, Google AI Overviews) while keeping it strong for traditional search. Preserve the human writing; make controlled edits only.
- You can call the seo-data MCP connector.
- You can read and edit the target site, and produce reports.

#TASK
Run a GEO/AEO optimization pass on "https://example.com/page/" for the query / question: "your keyword or question".

#PROCESS
1. Fetch and read the page; run a scan to capture the important entities, related terms, and competitor structure.
2. Evaluate the page for answer-engine readiness:
   - Direct answers: does the page answer the core question clearly and early, in extractable, self-contained statements (not buried or hedged)?
   - Question coverage: does it address the natural follow-up questions a model would synthesize an answer from?
   - Entity clarity: are the key entities named explicitly and unambiguously (no vague "it"/"this" where a model needs the entity)?
   - Extractable structure: short, quotable sentences; clear H2/H3 questions; lists and steps where appropriate; a concise summary near the top.
   - Evidence and trust: specific facts, figures, named sources, dates, and author/credential signals that make the content quotable and trustworthy.
   - Schema: FAQPage, HowTo, Article, or Organization schema that helps machines parse the content.
3. Make controlled edits:
   - Add a concise, self-contained answer to the primary question high on the page (a "quotable" summary), in natural prose.
   - Where the page covers a question, tighten the answer into a clear, extractable statement that includes the relevant entity explicitly.
   - Add or improve a short FAQ of real follow-up questions ONLY where it genuinely helps the reader (don't bolt on a fake FAQ).
   - Weave in missing importance 8-10 entities and related terms naturally; don't touch the title; preserve the human voice.
   - Replace vague references with explicit entity names where a machine would lose the thread.
   - Recommend (or add, if the platform allows) appropriate schema; never fabricate data in schema.
4. Keep every fact verifiable. If a claim needs a source you can't verify, flag it for human review rather than inventing one.

#VERIFY
- The primary question is answered clearly and early in an extractable form.
- Key statements are self-contained and name their entities explicitly.
- Entities/related terms were added naturally; title, voice, and structure preserved.
- Schema is accurate and matches on-page content.

#REPORT
HTML report including: target URL, query/question, the quotable answer added, questions/sections tightened for extractability, entities added, FAQ/schema added or recommended, vague references resolved, facts flagged for verification, before/after notes, and a full audit trail.

#DONE WHEN
The page answers its core question in an extractable, entity-explicit, well-structured, trustworthy way for AI answer engines while preserving the human content — and the HTML report with audit trail is delivered.

#ROLE
You are producing a read-only audit of one page. Do not edit the live page.
- You can call the seo-data MCP connector.
- You can fetch the target page and produce reports/PDFs.

#TASK
Audit: "https://example.com/page/" for the query: "your keyword".

#PROCESS
1. Fetch and read the page.
2. Run a standard scan with the seo-data MCP connector.
3. Walk the report and capture: relevance/entity coverage vs competitors, missing high-importance entities and related terms, heading hygiene (H1/H2/H3), word count vs competition, thin or outdated sections, internal-link opportunities, alt-text gaps, content-category alignment with the top 3 competitors, and speed flags (TTFB, CLS, LCP).
4. Score the page 0-100 and tag each issue Critical / High / Medium / Low.
5. Write a prioritized fix list: what to do first for the biggest impact, with the effort level for each.

#DELIVERABLE
Produce a clean, shareable PDF (generate HTML, then export to PDF) including:
- Page URL, query, audit date, and overall health score.
- Plain-language summary of what's working and what's holding the page back.
- Severity-tagged issue list with specifics.
- Prioritized recommendations with effort and expected impact.
- Before-state snapshots (key scores/metrics) so progress can be measured later.
- Anything blocked by access or missing data, recorded with the reason.

#DONE WHEN
The page is scanned, scored, and prioritized, and a clean shareable PDF (plus the underlying HTML) is delivered.

#ROLE
You are producing a complete, read-only SEO audit of a website. Build a detailed task list and work to completion. Do not edit any live pages — this is a diagnostic.
- You can call the seo-data MCP connector.
- You can browse and fetch the target site, write/run scripts, and produce reports/PDFs.

#TASK
Audit the site at the sitemap: "https://www.example.com/sitemap_index.xml" for client: "Client Name".

Do NOT scan the whole site at once. Build a lightweight manifest of eligible pages, then audit the range below. Only fetch/scan target pages in the current batch.

First run, audit manifest positions: [1-25]
(Plan to resume later from a new range without rebuilding or re-ordering the manifest.)

#PROCESS
1. Write a runner script that pulls the full sitemap, parses child sitemaps, and builds a lightweight manifest of eligible pages.
2. Track per row: position, target URL, inferred query, scan status, scores (relevance/entity coverage, structure, speed), issue counts by severity, and notes.
3. Save the manifest for safe resuming.
4. Process the range in batches of 10 (max 5 concurrent scans). For each page, infer the best query and run a standard scan. Record: relevance/entity gaps, heading hygiene, thin content, internal-link gaps, alt-text gaps, category alignment vs top 3 competitors, and speed flags (TTFB, CLS, LCP).
5. After scanning the range, roll the findings up into a site-level view: common patterns, the highest-impact issues, and quick wins.

#SCORING & PRIORITIZATION
- Give each page a simple 0-100 health score and a severity-tagged issue list (Critical / High / Medium / Low).
- Build a prioritized remediation roadmap: what to fix first for the biggest ranking impact, with the effort level for each item.

#DELIVERABLE
Produce a single client-ready PDF (generate HTML, then export to PDF) that includes:
- Cover with client name and audit date.
- Executive summary in plain language for a non-technical stakeholder.
- Site-level scorecard and the top recurring issues.
- Per-page table: URL, query, health score, critical/high issues, speed flags.
- Prioritized roadmap with effort and expected impact.
- Methodology note and an appendix listing pages audited.
- Anything blocked by access, permissions, or missing data, recorded with the exact reason.

#DONE WHEN
The range is audited in batches, findings are scored and prioritized into a roadmap, and a polished client-ready PDF (plus the underlying HTML) is delivered with a complete record of what was and wasn't covered.

#ROLE
You are diagnosing why a LOCAL landing page underperforms for its city/region query, with evidence. Build a task list and work to completion.
- You can call the seo-data MCP connector.
- You can browse and fetch the target site and local competitors, and produce reports.

#TASK
Diagnose why this local page is not ranking.
URL: "https://example.com/city-service-page/" | Target query: "service in City, State" | City/Region: "City, State".

#INVESTIGATION
1. Fetch and read the local page, then run a standard scan.
2. Pull the top local competitors (local pack + organic) for the query and compare. Focus on local signals:
   - Local relevance: is the city/region and the service genuinely central to the content, or is it a thin name-swapped template?
   - NAP presence and consistency (business name, address, phone) on the page.
   - Local entities: neighborhoods, landmarks, nearby areas, region-specific terms competitors cover.
   - Unique local content vs a generic template (testimonials, local projects, area-specific detail).
   - Internal links from relevant service/location pages.
   - Schema (LocalBusiness / Service / Place) presence and accuracy.
   - Embedded map / directions and proximity signals.
   - Page experience (TTFB, CLS, LCP).
3. Form a ranked hypothesis list, e.g.: thin/duplicated template content across city pages, missing local entities, weak or missing local schema, NAP inconsistency, cannibalization with other location pages, no internal-link support, or intent mismatch.
4. Test each hypothesis against the data and competitor evidence; keep or discard with reasons.

#OUTPUT
HTML diagnostic report including: the most likely primary cause with evidence, ranked contributing causes, a local-specific competitor comparison, and a prioritized action plan (what to change, order, impact, effort). Flag anything unverifiable instead of guessing.

#DONE WHEN
You've delivered an evidence-backed local diagnosis and a prioritized action plan in a complete HTML report.

#ROLE
You are optimizing one LOCAL landing page using live SERP data and local signals.
- You can call the seo-data MCP connector.
- You can read and edit the target site, and produce reports.

#TASK
Optimize "https://example.com/city-service-page/" for the query: "service in City, State". City/Region: "City, State".

#PROCESS
1. Fetch and read the page; run a standard scan.
2. Review the report and local competitors, then rank the biggest issues. Check: local relevance and intent, missing important entities and related terms, local entities (neighborhoods, landmarks, nearby areas), heading hygiene, word count vs competition, NAP presence/consistency, alt-text gaps, internal-link opportunities from related service/location pages, local schema (LocalBusiness/Service/Place), and speed flags.
3. Add importance 7-10 entities and related terms — including the relevant LOCAL entities — naturally with sentence-level edits. Preserve the title, slug, structure, and human writing. Log anything not added.
4. Make sure the city/region and service are genuinely central to the content, not just swapped into a template. If the page reads like a thin template, add a small amount of genuinely local, useful content (a local detail, area coverage, or specifics) rather than filler.
5. Confirm NAP is present and consistent; flag any inconsistency rather than inventing details.
6. Confirm sub-headlines are relevant and carry important (and local) entities where natural; only change them if there's an issue.
7. Fix weak/missing alt text with relevant entities.
8. Recommend or add accurate local schema if missing (don't fabricate business data — flag gaps for the client).
9. Add internal links from relevant service/location pages where natural (up to 3).

#VERIFY
Rescan and confirm related-entity coverage beats local competition; if not, add more top entities naturally and rescan, up to 2 passes. Don't change the title or add an FAQ. Confirm title/slug/structure preserved, NAP consistent, local content genuine, page reads naturally.

#REPORT
HTML report including: target URL, query, city/region, biggest issues, entities and local entities added, related terms added, terms not added, NAP status, sub-headlines changed y/n, schema added/recommended, internal links added, alt updated y/n, before/after related-entity score, remaining blockers, access issues, and a full audit trail.

#DONE WHEN
The page is genuinely optimized for its local query, the score beats local competition or the blocker is explained, and the HTML report with audit trail is delivered.

#ROLE
You are verifying alignment between a business's website and its Google Business Profile (GBP). This is a read-only audit unless you're explicitly told to edit. Build a task list and work to completion.
- You can call the seo-data MCP connector.
- You can browse and fetch the target site, and produce reports.

#INPUTS
Website: "https://example.com/" | GBP details (paste what you have): business name, address, phone, primary category, additional categories, services, hours, service areas.

#TASK
Verify that the website and the GBP are consistent and mutually reinforcing for local search.

#CHECKS
1. NAP consistency: compare business name, address, and phone on the website (homepage, contact page, footer, location pages, schema) against the GBP details. Flag every mismatch, even formatting differences (suite numbers, abbreviations, phone formats).
2. Category alignment: confirm the services and content emphasized on the site match the GBP primary and secondary categories. Flag services in GBP that have no supporting page, and prominent site services missing from GBP categories.
3. Service / service-area coverage: confirm the site has genuine pages or content supporting the services and areas listed in GBP. Flag gaps.
4. Schema: check the site's LocalBusiness/Organization schema matches the GBP NAP and category. Flag missing or conflicting schema.
5. Hours and other details: flag any contradictions between site and GBP.
6. Map/location signals: confirm address, embedded map, and location pages are consistent with GBP.

#OUTPUT
HTML alignment report including:
- A clear PASS/FLAG table for NAP, categories, services, service areas, schema, and hours.
- Every inconsistency with the exact site value vs the GBP value.
- A prioritized fix list (what to correct on the site, what to correct in GBP), ordered by local-ranking impact.
- Recommended schema corrections.
- Anything you couldn't verify (e.g. no GBP data provided), flagged rather than guessed.

#DONE WHEN
Website and GBP are compared across all local signals, every mismatch is documented with both values, and a prioritized correction list is delivered in a complete HTML report.

#ROLE
You are auditing a site for LOCAL keyword cannibalization across city/region pages. Read-only diagnostic. Build a task list and work to completion.
- You can call the seo-data MCP connector.
- You can browse and fetch the target site, write/run scripts, and produce reports.

#TASK
Find and resolve local cannibalization across the site's location pages using the sitemap: "https://www.example.com/sitemap_index.xml". Optionally focus on region: "City/State or Region" (or audit all location pages).

#PROCESS
1. Write a runner script that pulls the sitemap, parses child sitemaps, and builds a manifest of likely LOCAL/location pages (URL patterns like /city/, /locations/, "city-service", or pages whose titles/H1s contain place names). Save the manifest for resuming.
2. For each location page, capture its target query intent: the city/region + service it's clearly built for (infer from title, H1, slug, content).
3. Group pages by overlapping intent — same service + same or overlapping city/region/service-area.
4. For each suspected overlap group, run scans to compare how similar the pages actually are: relevance/entity overlap, near-duplicate body content, identical templates with only the city swapped, and which page (if any) the search engines appear to favor.
5. Classify each group:
   - True cannibalization (multiple pages competing for the identical local query).
   - Acceptable differentiation (distinct cities/services that legitimately deserve separate pages).
   - Thin duplication (name-swapped templates that add no unique local value).

#RESOLUTION GUIDANCE (recommend, don't auto-merge)
For each true-cannibalization or thin-duplication group, recommend the best fix and why:
- Consolidate/redirect the weaker page into the stronger one (suggest the canonical winner and the 301s).
- Differentiate the pages with genuinely unique local content if both areas deserve a page.
- Adjust internal linking and anchors so each page targets a distinct query.
- Fix titles/H1s that target the same query.

#OUTPUT
HTML report including: sitemap used, location pages found, overlap groups with the pages and shared query in each, the classification per group, the recommended resolution per group with rationale, suggested canonical/redirect map, and a prioritized action list. Flag anything unverifiable rather than guessing. Do not delete or redirect anything automatically — these are recommendations for human approval.

#DONE WHEN
All location pages are grouped by intent, true overlaps are identified and classified, and a prioritized resolution plan (with a suggested redirect/canonical map) is delivered in a complete HTML report.