AI SEO Change Kit

Copy-ready toolkit for multi-client SEO + AI SEO audits, staged implementation, and central Google Sheet change logging.

Quick Setup

Use one central template and one Apps Script webhook for all clients.

Click Open Template and make a central copy.
Add client columns at the start of the Change Log if they are not already present: client_id, client_name, site_url, environment.
In the copied sheet: Extensions > Apps Script > Deploy as Web App.
Set access to Anyone, then deploy one shared /exec webhook.
Use client_id and environment on every row to filter work by client and staging/live state.
Copy the webhook test prompt below and send it to AI with your copied PHP snippet.

Multi-Client Mode

Use the same Google Sheet and webhook for every client. Client separation happens through required payload fields, not separate webhook URLs.

Every audit, change, and promotion row must include client_id, client_name, site_url, and environment.
Use stable machine-readable IDs such as northshore-roof-repairs; do not rely on client names for matching.
Use a unique batch_id per client run, such as northshore-roof-repairs-2026-05-p2.
The Apps Script webhook should update an existing row when change_id matches, or fall back to matching from_url + to_url.
The webhook response should be checked for action: insert or action: update after each log attempt.

Human Actions Checklist

Set up one central Google Sheet and Apps Script Web App webhook (or redeploy if script code changed).
Confirm the Sheet headings start with client_id, client_name, site_url, and environment.
Paste the latest Web App /exec webhook URL into the WordPress PHP snippet for the target site, or keep it in a local environment variable for CLI logging.
Fill in the Client / Project Context before copying prompts.
Run Prompt 1 (Audit Only) and review findings by priority.
Approve the exact change list before any implementation work starts.
Run Prompt 2 (Implementation) on staging only.
For each attempted change, verify the result and record evidence.
Ensure a Google Sheet row is inserted or updated after every attempt.
If validation fails, roll back immediately and record rollback details.
Only mark rows live-ready after staging verification is complete.
Promote only approved and verified rows to live, then update live_status.

Assigned operator (human) is responsible for approvals, validation, and promotion decisions.

Client / Project Context

Complete this for each client run. These values should appear in every Google Sheet row and copied prompt.

Client ID

Client Name

Website URL

Environment

Batch ID

Priority Pages

Client Config

Notes

Install Skills

Single-line install commands. Copy and run in terminal.

WordPress PHP Webhook Logger

Run this combined prompt to add the snippet and test the central webhook in one pass:

Webhook URL (/exec)

Use tools: novamira mcp
Use skill: ai-seo
Add the following PHP snippet to the website (Fluent Snippets / Easy Code Manager), then run a webhook test on [STAGING_URL].
Use the supplied client config. Return status code, response body summary, webhook action (insert or update), and whether a row was written to Google Sheet.

PHP snippet:
{{PHP_SNIPPET}}

if (!function_exists('log_url_change_to_google_sheets')) {
    function log_url_change_to_google_sheets($old_url, $new_url, $type = 'slug update', $notes = '', $meta = array()) {
        $webhook_url = 'https://script.google.com/macros/s/REPLACE_WITH_YOUR_DEPLOYMENT_ID/exec';

        $current_user = wp_get_current_user();
        $user_name = !empty($current_user->display_name) ? $current_user->display_name : 'System';
        $change_id = !empty($meta['change_id']) ? (string) $meta['change_id'] : 'CHG-' . strtoupper(wp_generate_password(6, false, false));

        $payload = array(
            'client_id'             => !empty($meta['client_id']) ? (string) $meta['client_id'] : '',
            'client_name'           => !empty($meta['client_name']) ? (string) $meta['client_name'] : '',
            'site_url'              => !empty($meta['site_url']) ? (string) $meta['site_url'] : home_url(),
            'environment'           => !empty($meta['environment']) ? (string) $meta['environment'] : 'staging',
            'date_modified'         => current_time('mysql'),
            'change_id'             => $change_id,
            'batch_id'              => !empty($meta['batch_id']) ? (string) $meta['batch_id'] : '',
            'change_type'           => (string) $type,
            'object_type'           => !empty($meta['object_type']) ? (string) $meta['object_type'] : 'redirect_rule',
            'object_identifier'     => !empty($meta['object_identifier']) ? (string) $meta['object_identifier'] : '',
            'from_url'              => (string) $old_url,
            'to_url'                => (string) $new_url,
            'http_code'             => isset($meta['http_code']) ? (string) $meta['http_code'] : '301',
            'match_type'            => !empty($meta['match_type']) ? (string) $meta['match_type'] : 'exact',
            'current_state'         => !empty($meta['current_state']) ? (string) $meta['current_state'] : '',
            'desired_state'         => !empty($meta['desired_state']) ? (string) $meta['desired_state'] : '',
            'implementation_method' => !empty($meta['implementation_method']) ? (string) $meta['implementation_method'] : '',
            'staging_status'        => !empty($meta['staging_status']) ? (string) $meta['staging_status'] : 'planned',
            'staging_verified_at'   => !empty($meta['staging_verified_at']) ? (string) $meta['staging_verified_at'] : '',
            'live_status'           => !empty($meta['live_status']) ? (string) $meta['live_status'] : 'pending',
            'live_verified_at'      => !empty($meta['live_verified_at']) ? (string) $meta['live_verified_at'] : '',
            'validation_steps'      => !empty($meta['validation_steps']) ? (string) $meta['validation_steps'] : '',
            'rollback_steps'        => !empty($meta['rollback_steps']) ? (string) $meta['rollback_steps'] : '',
            'owner'                 => !empty($meta['owner']) ? (string) $meta['owner'] : $user_name,
            'notes'                 => (string) $notes,
            'actionable'            => !empty($meta['actionable']) ? (string) $meta['actionable'] : ''
        );

        $request_args = array(
            'body' => wp_json_encode($payload),
            'headers' => array('Content-Type' => 'application/json; charset=utf-8'),
            'timeout' => 15,
            'blocking' => true,
            'data_format' => 'body',
            'redirection' => 0,
        );

        $response = wp_remote_post($webhook_url, $request_args);

        if (is_wp_error($response)) {
            error_log('Google Sheets Webhook Error: ' . $response->get_error_message());
            return false;
        }

        $status_code = (int) wp_remote_retrieve_response_code($response);
        $response_body = wp_remote_retrieve_body($response);

        if ($status_code >= 300 && $status_code < 400) {
            $redirect_url = wp_remote_retrieve_header($response, 'location');
            if (empty($redirect_url)) {
                error_log('Google Sheets Webhook Redirect Error: Missing redirect location. Response: ' . $response_body);
                return false;
            }

            $redirect_response = wp_remote_get($redirect_url, array(
                'timeout' => 15,
                'blocking' => true,
                'redirection' => 0,
            ));

            if (is_wp_error($redirect_response)) {
                error_log('Google Sheets Webhook Redirect Error: ' . $redirect_response->get_error_message());
                return false;
            }

            $status_code = (int) wp_remote_retrieve_response_code($redirect_response);
            $response_body = wp_remote_retrieve_body($redirect_response);
        }

        if ($status_code < 200 || $status_code >= 300) {
            error_log('Google Sheets Webhook HTTP Error: ' . $status_code . ' Response: ' . $response_body);
            return false;
        }

        $decoded_response = json_decode($response_body, true);
        if (is_array($decoded_response) && isset($decoded_response['status']) && strtolower((string) $decoded_response['status']) === 'error') {
            error_log('Google Sheets Webhook App Error: ' . $response_body);
            return false;
        }

        return is_array($decoded_response) ? $decoded_response : array(
            'status' => 'success',
            'action' => 'unknown',
            'status_code' => $status_code,
            'body' => $response_body,
        );
    }
}

Prompt 1: Audit Only (No Changes)

Write rows to Google SheetAdds seo-audit-sheet-poster and changes Prompt 1 output requirements. novamira-cornerstoneAdds direction to use cornerstone-novamira for Cornerstone/Pro edits.

Use skill: seo-audit
Run a full SEO + AI SEO audit on [STAGING_URL].

Client config:
- client_id: [CLIENT_ID]
- client_name: [CLIENT_NAME]
- site_url: [SITE_URL]
- environment: audit
- priority_pages: [PRIORITY_PAGES]

Use the client config as the source of truth for URLs and scope.

Scope:
- Indexability and crawl directives
- Canonicals and environment consistency
- Sitemap coverage and URL status health
- Metadata quality and schema coverage
- Internal linking quality
- AI extractability (question-style headings + concise answer blocks)
- E-E-A-T signals (author/reviewer, credentials, updates, citations)
- llms.txt quality and noise cleanup opportunities
- Redirect gap opportunities for common intent variants

Output requirements:
1) Return findings grouped by priority (P1-P3).
2) For each finding include URL, issue, impact, fix, and validation steps.
3) Include Top Findings and Recommended Actions.
4) Do not make any changes yet.
5) Do not write rows to Google Sheet in this phase.

Recommendation Intake (If You Already Have Findings)

Use this when you already have audit findings and want to write them to the Google Sheet before any implementation work starts.

Paste the audit findings and the client config into the prompt below.
Require one Google Sheet row per distinct finding and URL group.
Use change_type = audit_finding and staging_status = planned.
Do not edit the website during this intake step.
After rows are logged, use Prompt 3 only for findings that have been approved for implementation.

Prompt 2: Log Audit Findings to Sheet

Audit Findings

Use skill: ai-seo
Convert the pasted SEO / AI SEO audit findings into Google Sheet change-log rows using the existing central webhook.

Client config:
[CLIENT_CONFIG]

Webhook URL:
[GOOGLE_SHEET_WEBHOOK_URL]

Post method:
POST JSON to the webhook URL with Content-Type: application/json.

Webhook payload fields:
Send every payload with these keys. Use blank strings for fields that do not apply. Do not omit keys.
- client_id
- client_name
- site_url
- environment
- date_modified
- change_id
- batch_id
- change_type
- object_type
- object_identifier
- from_url
- to_url
- http_code
- match_type
- current_state
- desired_state
- implementation_method
- staging_status
- staging_verified_at
- live_status
- live_verified_at
- validation_steps
- rollback_steps
- owner
- notes
- actionable

Audit finding defaults:
- change_type = audit_finding
- implementation_method = proposed
- staging_status = planned
- live_status = pending
- date_modified = current timestamp if available, otherwise blank
- staging_verified_at = blank
- live_verified_at = blank
- rollback_steps = blank unless supplied

Webhook / logging rules:
- Use the supplied webhook URL only. Do not ask for another webhook URL.
- Do not edit the website.
- Do not implement any fixes.
- Write one row per distinct finding. If one finding lists multiple example URLs but the issue and fix are the same, keep it as one row and put all URLs in object_identifier or notes. If the URLs require different fixes, split them into separate rows.
- If a finding has a priority heading such as P1, P2, or P3, preserve that priority in notes.
- Set change_type to audit_finding.
- Set object_type to the most specific useful type, such as page, template, schema, metadata, llms_txt, redirect, internal_linking, or eeat.
- Set object_identifier to the primary URL, template group, or URL list from the finding.
- Set from_url to the affected URL when there is one clear source URL; otherwise leave it blank.
- Set to_url blank unless the finding is specifically a redirect recommendation.
- Set http_code blank unless the finding is about redirects or URL status.
- Set match_type blank unless the finding is about redirects.
- Set current_state from the Issue field.
- Set desired_state from the Fix field.
- Set implementation_method to proposed.
- Set staging_status to planned.
- Set live_status to pending.
- Set validation_steps from the Validation field.
- Set rollback_steps blank unless the audit includes rollback details.
- Set owner to the supplied operator or blank.
- Set actionable to the exact future implementation artifact when obvious; otherwise write a concise implementation instruction, not a summary.
- Include client_id, client_name, site_url, environment, and batch_id in every payload.
- Generate stable change_id values using client_id + priority + finding number, for example northshore-roof-repairs-P2-004. Use the audit numbering when present.
- Because the Apps Script updates by change_id, rerunning the same intake should update the same rows, not create duplicates.
- After each webhook call, check the response action field and record whether it was insert or update.

Output requirements:
1) Show the parsed rows before posting if the user has not explicitly approved posting.
2) If the user explicitly approved posting, post each row and return a table with change_id, object_identifier, priority, webhook action, and status.
3) Report any skipped findings and why.

Audit findings to convert:
[PASTE_AUDIT_FINDINGS_HERE]

Prompt 3: Implement Approved Changes (Easy Version)

Use skill: ai-seo
Apply approved SEO + AI SEO changes on [STAGING_URL] only.

Client config:
- client_id: [CLIENT_ID]
- client_name: [CLIENT_NAME]
- site_url: [SITE_URL]
- environment: staging
- batch_id: [BATCH_ID]
- priority_pages: [PRIORITY_PAGES]

Important:
- This workflow uses one central Google Sheet webhook for all clients.
- Webhook logging is already available through the installed WordPress PHP logger snippet.
- Do not request another webhook URL or alternate logging mechanism.
- Call log_url_change_to_google_sheets(...) after each attempted change using the existing PHP logger path.
- Every payload must include client_id, client_name, site_url, environment, and batch_id.
- The webhook may insert a new row or update an existing row by change_id, with fallback matching on from_url + to_url.
- Check the webhook response and record whether action is insert or update.

Rules:
1) At start of each run, read existing Google Sheet rows for this client_id and batch_id first.
2) Use the approved change list as source of truth.
3) If input is high-level recommendations, first convert them into a URL-by-URL action list with exact edits and validation steps.
4) Process a maximum of 10 URL-level changes per run, then stop and return results.
5) For each URL/change: verify current state, apply desired state, run validation.
6) Immediately after each change attempt, write a Google Sheet row via the existing webhook logger.
7) Log both success and failure attempts.
8) If validation fails, roll back immediately and include rollback details in the row.
9) Do not add unapproved changes.
10) Never mix client IDs, site URLs, or environments across clients.

Logging requirements per attempt:
- client_id, client_name, site_url, environment
- change_id, batch_id, from_url, to_url, change_type
- staging_status (verified or failed)
- validation_steps summary
- rollback_steps when applicable
- notes with evidence summary and webhook action (insert or update)
- actionable must be runnable/pasteable where possible (exact redirect rule, exact regex rule, exact command, exact code block, or exact CMS field/value update)

Actionable format rule:
- Do not write natural-language summaries in actionable.
- Write the exact execution artifact required to apply the change.

Final output:
- Applied
- Skipped (with reason)
- Failed (with reason)
- Rolled back
- Webhook rows inserted or updated
- Verified rows ready for production promotion

When You Are Ready for Live

Use the Google Sheet as the source of truth for production rollout.

Filter rows by the active client_id, then staging_status = verified and approved for promotion.
Copy only those verified rows into a live-promotion AI prompt.
Instruct AI to apply only the listed rows on live (no extra inferred changes).
After each live change, validate and update live_status + live_verified_at through the same webhook.
Check the webhook response for action: update when promoting existing rows.
Add evidence/notes for each promoted row.

This keeps live rollout controlled and prevents re-auditing from scratch.

Ready.