@digestseo/mcp-gsc 0.4.22 → 0.4.24

package/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.24] - 2026-09-23
+
+### Added
+- `indexing.remove` publishes Google's supported `URL_DELETED` notification for previously eligible Indexing API pages after a bounded preflight confirms the URL already returns HTTP 404/410 or exposes a robots `noindex` meta directive. A successful notification is reported only as receipt acknowledgment, never as proof that Google completed removal.
+
+### Changed
+- Search Analytics date inputs now explicitly state Google's Pacific Time calendar (`America/Los_Angeles`, UTC-8/UTC-7 depending on daylight saving time), matching the server's existing Pacific-Time default/date-range calculations and preventing agents from interpreting YYYY-MM-DD inputs in the caller's local timezone or UTC.
+
+## [0.4.23] - 2026-09-22
+
+### Fixed
+- The OAuth proxy now requires an explicit, CSRF-bound consent step that identifies the requesting MCP client and requested permissions before forwarding the browser to Google, preventing cached upstream Google consent from silently authorizing an untrusted MCP client. User or Google denial is returned to the validated MCP client as a terminal OAuth error instead of stranding the connection flow on a local error page.
+
 ## [0.4.22] - 2026-09-22
 
 ### Added

package/README.md

@@ -26,7 +26,7 @@ The npm launcher starts a loopback-only **Streamable HTTP** Worker on `127.0.0.1
 
 Local KV and Durable Object state, including the encrypted Google session, is stored in `~/.mcp-gsc/state` by default instead of inside the versioned npm cache. That keeps the local connection available across package upgrades and ordinary npm cache cleanup. Set `MCP_GSC_STATE_DIR` to use another directory; keep the same `TOKEN_ENCRYPTION_KEY` when reusing existing state because stored refresh tokens are encrypted with that key. The launcher prints the effective state directory at startup. The first release with this stable path may require one Google reconnect because older launcher releases stored local state under the npm package cache.
 
-The local launcher defaults to `GSC_ACCESS_MODE=readwrite`. For least-privilege analytics/reporting-only use, set `GSC_ACCESS_MODE=readonly` in the environment before running `npx`; the launcher forwards that value into the local Worker so OAuth requests only the read-only Search Console scope and the five mutation tools stay unregistered.
+The local launcher defaults to `GSC_ACCESS_MODE=readwrite`. For least-privilege analytics/reporting-only use, set `GSC_ACCESS_MODE=readonly` in the environment before running `npx`; the launcher forwards that value into the local Worker so OAuth requests only the read-only Search Console scope and the six mutation tools stay unregistered.
 
 For Google OAuth and Cloudflare deployment configuration, follow [SETUP.md](SETUP.md).
 
@@ -68,11 +68,11 @@ Start the npm launcher before using either install button. Complete its Google O
 
 A self-hostable [Model Context Protocol](https://modelcontextprotocol.io) (MCP) server for **Google Search Console**. Connect it to Claude.ai, Cursor, ChatGPT, or any MCP-compatible client and ask your AI assistant about your site's organic search performance — impressions, clicks, top queries, index status, and sitemap health — straight from your own Google account.
 
-It runs on [Cloudflare Workers](https://workers.cloudflare.com/) and ships with one-click Google OAuth onboarding: connect the server in your client, sign in with Google once, grant the requested Google Search Console permissions, and you're done. No API keys to copy around and no service-account JSON to manage.
+It runs on [Cloudflare Workers](https://workers.cloudflare.com/) and ships with Google OAuth onboarding: connect the server in your client, review the mcp-gsc consent page that identifies the requesting MCP client and permissions, then sign in with Google and grant the requested Google Search Console permissions. No API keys to copy around and no service-account JSON to manage.
 
 ## Tools
 
-By default (`GSC_ACCESS_MODE=readwrite`), this server exposes 22 tools. Read-only analytics and reporting tools are marked with MCP's `readOnlyHint`; the write tools below can change Search Console properties, sitemaps, or indexing state. Set `GSC_ACCESS_MODE=readonly` to request only the Search Console read-only scope and expose the 16 tools that do not require either write access or the separate Indexing API scope.
+By default (`GSC_ACCESS_MODE=readwrite`), this server exposes 23 tools. Read-only analytics and reporting tools are marked with MCP's `readOnlyHint`; the write tools below can change Search Console properties, sitemaps, or indexing state. Set `GSC_ACCESS_MODE=readonly` to request only the Search Console read-only scope and expose the 16 tools that do not require either write access or the separate Indexing API scope.
 
 | Tool | Access | What it does |
 |---|---|---|
@@ -91,14 +91,17 @@ By default (`GSC_ACCESS_MODE=readwrite`), this server exposes 22 tools. Read-onl
 | **`sitemaps.submit`** / **`sitemaps.delete`** | Write | Submit or remove a sitemap. |
 | **`indexing.status`** | Read | Read Google's latest successful Indexing API `URL_UPDATED` / `URL_DELETED` notification receipts for a previously submitted URL. This is notification metadata only, not index coverage, crawl status, indexing completion, or removal completion. It requires `GSC_ACCESS_MODE=readwrite` because Google's metadata endpoint uses the Indexing API OAuth scope. |
 | **`indexing.request`** | Write | Requests indexing through Google's Indexing API. Google currently restricts this API to pages containing `JobPosting` structured data or livestream pages containing `BroadcastEvent` inside `VideoObject`. It is not available for general webpage submission. Google's default 200 publish requests/day/project is onboarding/testing capacity rather than ongoing-use approval; additional approval is required for usage/resource provisioning, and submissions are spam-screened. |
+| **`indexing.remove`** | Write | Request a `URL_DELETED` notification for a previously eligible Indexing API page. Before removal, the URL must already return HTTP 404/410 or expose a robots `noindex` meta directive. Google's receipt does not prove removal completed; use URL Inspection for indexed-state evidence. |
+
+Search Analytics calendar dates (`start_date`, `end_date`, and comparison-period dates) use Google's Pacific Time calendar (`America/Los_Angeles`, UTC-8/UTC-7 depending on daylight saving time), not the caller's local timezone or UTC. This also governs the server's generated/default Search Analytics date ranges.
 
 > **Platform properties.** Search Console now supports platform properties for social/video accounts such as Instagram, TikTok, X, and YouTube in its UI. Google's current Search Console API documentation still defines `siteUrl` using URL-prefix and `sc-domain:` website-property forms and does not publish a platform-property API identifier contract. `sites.list` therefore preserves every identifier Google returns and marks whether it matches the documented API grammar; the other tools deliberately reject undocumented forms instead of inventing an identifier. Use the Search Console UI/export for a platform property until Google documents API support.
 
-Read-write mode requests the Google Search Console read-write and Indexing API scopes. Read-only mode requests only `https://www.googleapis.com/auth/webmasters.readonly` (plus `openid` and `email`) and does not register the five write tools or the read-only `indexing.status` lookup, because that lookup still requires Google's separate Indexing API scope. Read-write remains the default so existing deployments retain their current behavior; see [SETUP.md](SETUP.md) to select a mode before connecting users.
+Read-write mode requests the Google Search Console read-write and Indexing API scopes. Read-only mode requests only `https://www.googleapis.com/auth/webmasters.readonly` (plus `openid` and `email`) and does not register the six write tools or the read-only `indexing.status` lookup, because that lookup still requires Google's separate Indexing API scope. Read-write remains the default so existing deployments retain their current behavior; see [SETUP.md](SETUP.md) to select a mode before connecting users.
 
 Large analytics responses are bounded at the MCP boundary instead of being generated and then discarded by clients with structured-content limits. List-style tools expose `start_row` / `next_start_row` where applicable; ranked analytical tools expose `limit`, `start_row`, and `result_page` metadata including `has_more`, `truncated`, and `byte_limit_reached`. Continue paging while `has_more` is true rather than assuming one response is complete.
 
-> **`indexing.request` eligibility and provider approval.** Google's Indexing API is not a general-purpose page submission tool — as of this writing, Google's own documentation limits it to two content types: pages with `JobPosting` structured data, and livestream pages with `BroadcastEvent` structured data nested inside `VideoObject`. Before submitting, the server fetches the target URL and checks static JSON-LD, Microdata, and RDFa markup for one of those two types; if neither is present (or the page can't be fetched), it returns an error explaining why the URL is ineligible instead of calling the Indexing API. Structured data injected only after client-side JavaScript runs cannot be confirmed by this bounded preflight and therefore fails closed. Google's default 200 publish requests/day/project is for onboarding and submission testing; using the API beyond that onboarding/testing context requires Google's usage/resource-provisioning approval. Google also subjects every submission to spam detection and warns that abuse or attempts to exceed quotas through multiple accounts or other means can revoke access. A successful submission is only an acknowledgment that Google received the notification — it does not guarantee the URL will be indexed.
+> **Indexing API eligibility and provider approval.** Google's Indexing API is not a general-purpose page submission tool — as of this writing, Google's own documentation limits it to two content types: pages with `JobPosting` structured data, and livestream pages with `BroadcastEvent` structured data nested inside `VideoObject`. Before `indexing.request`, the server fetches the target URL and checks static JSON-LD, Microdata, and RDFa markup for one of those two types; if neither is present (or the page can't be fetched), it returns an error explaining why the URL is ineligible instead of calling the Indexing API. Structured data injected only after client-side JavaScript runs cannot be confirmed by this bounded preflight and therefore fails closed. Before `indexing.remove`, the server instead confirms Google's removal precondition: the URL must already return HTTP 404/410 or expose a robots `noindex` meta directive. Update and removal notifications share the same publish quota. Google's default 200 publish requests/day/project is for onboarding and submission testing; using the API beyond that onboarding/testing context requires Google's usage/resource-provisioning approval. Google also subjects every submission to spam detection and warns that abuse or attempts to exceed quotas through multiple accounts or other means can revoke access. A successful notification is only an acknowledgment that Google received it — it does not guarantee indexing or removal completed.
 
 ## What you can ask
 

package/SECURITY.md

@@ -32,9 +32,10 @@ Notes:
 - With `GSC_ACCESS_MODE=readonly`, the server requests only `openid`, `email`,
   and `https://www.googleapis.com/auth/webmasters.readonly`. It does not
   register `sites.add`, `sites.delete`, `sitemaps.submit`, `sitemaps.delete`,
-  or `indexing.request`; the remaining tool suite uses APIs that accept the
+  `indexing.request`, or `indexing.remove`; the remaining tool suite uses APIs that accept the
   read-only Search Console scope.
-- The Indexing API is requested only in read-write mode for `indexing.request`.
+- The Indexing API is requested only in read-write mode for `indexing.request`,
+  `indexing.remove`, and the otherwise read-only `indexing.status` lookup.
   Google restricts that API to `JobPosting` pages or livestream pages with a
   `BroadcastEvent` inside a `VideoObject`; it is not a general page-submission
   API.
@@ -60,7 +61,7 @@ delay and does not disclose another user's usage.
 | Search Analytics | `analytics.query`, `insights.quick_wins`, `insights.cannibalization`, `insights.content_decay`, `indexing.list_pages`, `analytics.compare` | 30 per user / 10 minutes |
 | URL inspection | `urls.inspect`, `urls.inspect_many` | 20 inspected URLs per user / 24 hours; batch requests reserve one unit per URL and run at most 3 inspections concurrently |
 | Search Console writes | `sites.add`, `sites.delete`, `sitemaps.submit`, `sitemaps.delete` | 10 per user / hour |
-| Indexing publish | `indexing.request` | 2 per user / 24 hours; 200 per deployment / 24 hours |
+| Indexing publish | `indexing.request`, `indexing.remove` | 2 per user / 24 hours; 200 per deployment / 24 hours |
 | Indexing metadata | `indexing.status` | 30 per user / minute; 180 per deployment / minute |
 | Weekly digest | `reports.weekly_digest` | 6 per user / hour |
 

package/SETUP.md

@@ -61,7 +61,7 @@ npx wrangler login
 
    `readwrite` preserves the full tool surface: it grants Search Console read-write access and the Indexing API scope required to manage sites, sitemaps, and request URL crawling. `readonly` requests only the Search Console read-only scope and omits the mutation tools.
 
-   Note that the Indexing API itself is narrow: Google currently restricts it to pages containing `JobPosting` structured data or livestream pages containing `BroadcastEvent` inside `VideoObject`. It is not available for general webpage submission — the `indexing.request` tool checks a page's structured data before submitting and returns an error for ineligible URLs. Google's default **200 publish requests/day/project** is explicitly for onboarding and submission testing; ongoing usage/resource provisioning requires additional Google approval. All submissions are subject to spam detection, and Google warns that abuse or attempts to exceed quotas through multiple accounts or other means can result in revoked access. The server's own lower safety limits do not constitute Google approval or increase provider quota.
+   Note that the Indexing API itself is narrow: Google currently restricts it to pages containing `JobPosting` structured data or livestream pages containing `BroadcastEvent` inside `VideoObject`. It is not available for general webpage submission - the `indexing.request` tool checks a page's structured data before submitting and returns an error for ineligible URLs. `indexing.remove` is for previously eligible pages and requires the URL to already return HTTP 404/410 or expose a robots `noindex` meta directive before it sends Google's `URL_DELETED` notification. Google's default **200 publish requests/day/project** is shared by update and removal notifications and is explicitly for onboarding and submission testing; ongoing usage/resource provisioning requires additional Google approval. All submissions are subject to spam detection, and Google warns that abuse or attempts to exceed quotas through multiple accounts or other means can result in revoked access. The server's own lower safety limits do not constitute Google approval or increase provider quota.
 5. Save the Data Access changes. In **Google Auth platform → Audience**, leave **Publishing status** as **Testing** for now — see [Step 7](#step-7--important-google-verification).
 
 ---
@@ -154,7 +154,7 @@ The template also sets `GSC_ACCESS_MODE` to `readwrite`, preserving the historic
 }
 ```
 
-Read-only deployments request `webmasters.readonly`, omit the Indexing API scope, and do not register `sites.add`, `sites.delete`, `sitemaps.submit`, `sitemaps.delete`, `indexing.request`, or the otherwise read-only `indexing.status` lookup. Changing modes affects OAuth grants for future connections; reconnect users after changing the mode so Google grants the matching scope set.
+Read-only deployments request `webmasters.readonly`, omit the Indexing API scope, and do not register `sites.add`, `sites.delete`, `sitemaps.submit`, `sitemaps.delete`, `indexing.request`, `indexing.remove`, or the otherwise read-only `indexing.status` lookup. Changing modes affects OAuth grants for future connections; reconnect users after changing the mode so Google grants the matching scope set.
 
 `wrangler.jsonc` is gitignored because it contains your account's namespace ids. The `wrangler.example.jsonc` template stays in git.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digestseo/mcp-gsc",
-  "version": "0.4.22",
+  "version": "0.4.24",
   "private": false,
   "main": "scripts/glama-start.mjs",
   "bin": {

package/src/access-mode.ts

@@ -23,6 +23,7 @@ export const WRITE_TOOL_NAMES = [
   'sitemaps.submit',
   'sitemaps.delete',
   'indexing.request',
+  'indexing.remove',
 ] as const;
 
 const INDEXING_SCOPE_READ_TOOL_NAMES = ['indexing.status'] as const;

package/src/date-validation.ts

@@ -1,7 +1,13 @@
 import { z } from 'zod';
 
 const YYYY_MM_DD = /^(\d{4})-(\d{2})-(\d{2})$/;
-const SEARCH_CONSOLE_TIME_ZONE = 'America/Los_Angeles';
+export const SEARCH_CONSOLE_TIME_ZONE = 'America/Los_Angeles';
+export const SEARCH_CONSOLE_DATE_TIME_ZONE_NOTE =
+  'Google Search Console interprets this calendar date in Pacific Time (America/Los_Angeles; UTC-8/UTC-7 depending on daylight saving time).';
+
+export function searchConsoleDateDescription(base: string): string {
+  return `${base} ${SEARCH_CONSOLE_DATE_TIME_ZONE_NOTE}`;
+}
 
 export function getSearchConsoleCalendarDate(now: Date = new Date()): string {
   const parts = new Intl.DateTimeFormat('en-US', {

package/src/google.ts

@@ -1458,15 +1458,124 @@ export async function checkIndexingEligibility(
   };
 }
 
-export async function requestIndexing(
-  accessToken: string,
+function hasRobotsNoindexMeta(html: string): boolean {
+  // HTML permits an omitted </head>, so stop at </head>, <body>, or EOF.
+  const head = /<head\b[^>]*>([\s\S]*?)(?:<\/head\s*>|<body\b|$)/i.exec(html)?.[1];
+  if (!head) return false;
+
+  const metaPattern = /<meta\b([^>]*)>/gi;
+  let match: RegExpExecArray | null;
+  while ((match = metaPattern.exec(head)) !== null) {
+    const name = htmlAttribute(match[1], 'name')?.trim().toLowerCase();
+    if (name !== 'robots') continue;
+    const content = htmlAttribute(match[1], 'content')?.trim().toLowerCase();
+    if (!content) continue;
+    const directives = content.split(/[\s,]+/).filter(Boolean);
+    if (directives.includes('noindex')) return true;
+  }
+
+  return false;
+}
+
+const INDEXING_REMOVAL_REQUIREMENT_MESSAGE =
+  'Before requesting removal, Google requires the URL to return HTTP 404 or 410, or the page to contain a robots noindex meta directive.';
+
+/**
+ * Verifies Google's documented precondition for an Indexing API URL_DELETED
+ * notification without requiring the page to keep its former structured data.
+ */
+export async function checkIndexingRemovalEligibility(
   url: string,
-): Promise<unknown> {
-  const eligibility = await checkIndexingEligibility(url);
-  if (!eligibility.eligible) {
-    throw new Error(eligibility.reason);
+  { timeoutMs = INDEXING_ELIGIBILITY_TIMEOUT_MS }: IndexingEligibilityOptions = {},
+): Promise<IndexingEligibility> {
+  if (!isHttpUrl(url)) {
+    return {
+      eligible: false,
+      reason: `${url} must be a valid HTTP or HTTPS URL. ${INDEXING_REMOVAL_REQUIREMENT_MESSAGE}`,
+    };
   }
 
+  const controller = new AbortController();
+  let timedOut = false;
+  const timeout = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs);
+
+  try {
+    const resp = await fetch(url, {
+      signal: controller.signal,
+      redirect: 'manual',
+      headers: {
+        'user-agent':
+          'Mozilla/5.0 (compatible; DigestSEO-GSC-MCP/1.0; +https://github.com/AKzar1el/mcp-gsc)',
+      },
+    });
+
+    if (resp.status === 404 || resp.status === 410) {
+      await cancelResponseBody(resp);
+      return { eligible: true };
+    }
+
+    if (!resp.ok) {
+      await cancelResponseBody(resp);
+      return {
+        eligible: false,
+        reason: `Could not confirm indexing-removal eligibility for ${url} (HTTP ${resp.status}). ${INDEXING_REMOVAL_REQUIREMENT_MESSAGE}`,
+      };
+    }
+
+    const contentType = resp.headers.get('content-type')?.split(';', 1)[0].trim().toLowerCase();
+    if (
+      contentType &&
+      contentType !== 'text/html' &&
+      contentType !== 'application/xhtml+xml'
+    ) {
+      await cancelResponseBody(resp);
+      return {
+        eligible: false,
+        reason: `Could not confirm indexing-removal eligibility for ${url} (expected HTML, received ${contentType}). ${INDEXING_REMOVAL_REQUIREMENT_MESSAGE}`,
+      };
+    }
+
+    const contentLength = Number(resp.headers.get('content-length'));
+    if (
+      Number.isFinite(contentLength) &&
+      contentLength > INDEXING_ELIGIBILITY_MAX_RESPONSE_BYTES
+    ) {
+      await cancelResponseBody(resp);
+      return {
+        eligible: false,
+        reason: `Could not confirm indexing-removal eligibility for ${url} (response exceeds the ${INDEXING_ELIGIBILITY_MAX_RESPONSE_BYTES}-byte limit). ${INDEXING_REMOVAL_REQUIREMENT_MESSAGE}`,
+      };
+    }
+
+    const html = await readBoundedResponseText(resp);
+    if (hasRobotsNoindexMeta(html)) return { eligible: true };
+
+    return {
+      eligible: false,
+      reason: `${url} does not currently return HTTP 404/410 and does not expose a robots noindex meta directive. ${INDEXING_REMOVAL_REQUIREMENT_MESSAGE}`,
+    };
+  } catch (err) {
+    const detail = timedOut
+      ? `timed out after ${timeoutMs}ms`
+      : (err as Error).message;
+    return {
+      eligible: false,
+      reason: `Could not confirm indexing-removal eligibility for ${url} (${detail}). ${INDEXING_REMOVAL_REQUIREMENT_MESSAGE}`,
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+async function publishIndexingNotification(
+  accessToken: string,
+  url: string,
+  type: 'URL_UPDATED' | 'URL_DELETED',
+  actionLabel: string,
+): Promise<unknown> {
   const resp = await fetch(
     'https://indexing.googleapis.com/v3/urlNotifications:publish',
     {
@@ -1475,10 +1584,7 @@ export async function requestIndexing(
         authorization: `Bearer ${accessToken}`,
         'content-type': 'application/json',
       },
-      body: JSON.stringify({
-        url,
-        type: 'URL_UPDATED',
-      }),
+      body: JSON.stringify({ url, type }),
     },
   );
   if (resp.status === 401) {
@@ -1486,11 +1592,38 @@ export async function requestIndexing(
   }
   if (!resp.ok) {
     const text = await resp.text();
-    throw new Error(`Request indexing failed: ${resp.status} ${text}`);
+    throw new Error(`${actionLabel} failed: ${resp.status} ${text}`);
   }
   return await resp.json();
 }
 
+export async function requestIndexing(
+  accessToken: string,
+  url: string,
+): Promise<unknown> {
+  const eligibility = await checkIndexingEligibility(url);
+  if (!eligibility.eligible) {
+    throw new Error(eligibility.reason);
+  }
+  return publishIndexingNotification(accessToken, url, 'URL_UPDATED', 'Request indexing');
+}
+
+export async function requestIndexingRemoval(
+  accessToken: string,
+  url: string,
+): Promise<unknown> {
+  const eligibility = await checkIndexingRemovalEligibility(url);
+  if (!eligibility.eligible) {
+    throw new Error(eligibility.reason);
+  }
+  return publishIndexingNotification(
+    accessToken,
+    url,
+    'URL_DELETED',
+    'Request indexing removal',
+  );
+}
+
 export interface IndexingNotification {
   url?: string;
   type?: 'URL_UPDATED' | 'URL_DELETED' | string;

package/src/index.ts

@@ -1,4 +1,4 @@
-import { OAuthProvider } from '@cloudflare/workers-oauth-provider';
+import { OAuthProvider, type AuthRequest } from '@cloudflare/workers-oauth-provider';
 import { DurableObject } from 'cloudflare:workers';
 import { createMcpHandler, getMcpAuthContext } from 'agents/mcp/server';
 import { McpServer } from '@modelcontextprotocol/server';
@@ -28,6 +28,7 @@ import {
   processCannibalization,
   processContentDecay,
   requestIndexing,
+  requestIndexingRemoval,
   getIndexingNotificationMetadata,
   processPerformanceComparison,
   type PaginatedSearchAnalyticsResult,
@@ -58,6 +59,7 @@ import {
   assertDateRange,
   getSearchConsoleCalendarDate,
   SEARCH_CONSOLE_DATE_SCHEMA,
+  searchConsoleDateDescription,
 } from './date-validation';
 import { CONTENT_DECAY_COMPARE_DAYS_SCHEMA } from './content-decay-schema';
 import { resolveIndexedPagesDateRange } from './indexed-pages-range';
@@ -71,6 +73,7 @@ import {
 import { WRITE_TOOL_ANNOTATIONS } from './write-tool-annotations';
 import {
   getToolCatalogForAccessMode,
+  getGoogleOAuthScopes,
   resolveGscAccessMode,
   type GscAccessMode,
 } from './access-mode';
@@ -472,6 +475,11 @@ const INDEXING_OUTPUT_SCHEMA = {
   provider_usage_note: z.string(),
 };
 
+const INDEXING_REMOVE_OUTPUT_SCHEMA = {
+  ...INDEXING_OUTPUT_SCHEMA,
+  removal_completion_proven: z.literal(false),
+};
+
 const INDEXING_NOTIFICATION_SCHEMA = z.object({
   url: z.string().optional(),
   type: z.string().optional(),
@@ -708,6 +716,11 @@ const TOOL_CATALOG = [
     description:
       'Request an eligible JobPosting or livestream URL update through Google\'s restricted Indexing API; this is not a general webpage submission tool. Google treats the default publish quota as onboarding/testing capacity, requires approval for ongoing usage/resource provisioning, and spam-screens submissions.',
   },
+  {
+    name: 'indexing.remove',
+    description:
+      "Request a URL_DELETED notification for a previously eligible JobPosting or livestream URL through Google's restricted Indexing API. The URL must already return HTTP 404/410 or expose a robots noindex meta directive; notification receipt does not prove removal completed.",
+  },
   {
     name: 'indexing.status',
     description:
@@ -1124,9 +1137,13 @@ class GscMcpRuntime {
         ].join('\n'),
         inputSchema: {
           site_url: SEARCH_CONSOLE_PROPERTY_SCHEMA,
-          start_date: SEARCH_CONSOLE_DATE_SCHEMA.describe('Start date (inclusive) in YYYY-MM-DD format.'),
+          start_date: SEARCH_CONSOLE_DATE_SCHEMA.describe(
+            searchConsoleDateDescription('Start date (inclusive) in YYYY-MM-DD format.'),
+          ),
           end_date: SEARCH_CONSOLE_DATE_SCHEMA.describe(
-            'End date (inclusive) in YYYY-MM-DD format. Recent dates are allowed: data_state all/hourly_all can include preliminary data, while final returns only finalized data.',
+            searchConsoleDateDescription(
+              'End date (inclusive) in YYYY-MM-DD format. Recent dates are allowed: data_state all/hourly_all can include preliminary data, while final returns only finalized data.',
+            ),
           ),
           dimensions: z
             .array(
@@ -1295,8 +1312,14 @@ class GscMcpRuntime {
         inputSchema: {
           site_url: SEARCH_CONSOLE_PROPERTY_SCHEMA,
           page_url: z.string().url().describe('Exact fully-qualified page URL to filter on, e.g. https://example.com/guides/seo/. Search Console exact page filters are case-sensitive.'),
-          start_date: SEARCH_CONSOLE_DATE_SCHEMA.describe('Start date (inclusive) in YYYY-MM-DD format.'),
-          end_date: SEARCH_CONSOLE_DATE_SCHEMA.describe('End date (inclusive) in YYYY-MM-DD format. Note the 2-3 day GSC data lag.'),
+          start_date: SEARCH_CONSOLE_DATE_SCHEMA.describe(
+            searchConsoleDateDescription('Start date (inclusive) in YYYY-MM-DD format.'),
+          ),
+          end_date: SEARCH_CONSOLE_DATE_SCHEMA.describe(
+            searchConsoleDateDescription(
+              'End date (inclusive) in YYYY-MM-DD format. Note the 2-3 day GSC data lag.',
+            ),
+          ),
           search_type: z
             .enum(['web', 'image', 'video', 'news'])
             .default('web')
@@ -1373,8 +1396,14 @@ class GscMcpRuntime {
         inputSchema: {
           site_url: SEARCH_CONSOLE_PROPERTY_SCHEMA,
           query: z.string().min(1).describe('Exact Search Console query text to filter on. Exact query filters are case-sensitive.'),
-          start_date: SEARCH_CONSOLE_DATE_SCHEMA.describe('Start date (inclusive) in YYYY-MM-DD format.'),
-          end_date: SEARCH_CONSOLE_DATE_SCHEMA.describe('End date (inclusive) in YYYY-MM-DD format. Note the 2-3 day GSC data lag.'),
+          start_date: SEARCH_CONSOLE_DATE_SCHEMA.describe(
+            searchConsoleDateDescription('Start date (inclusive) in YYYY-MM-DD format.'),
+          ),
+          end_date: SEARCH_CONSOLE_DATE_SCHEMA.describe(
+            searchConsoleDateDescription(
+              'End date (inclusive) in YYYY-MM-DD format. Note the 2-3 day GSC data lag.',
+            ),
+          ),
           search_type: z
             .enum(['web', 'image', 'video', 'news'])
             .default('web')
@@ -1607,8 +1636,14 @@ class GscMcpRuntime {
         description: 'Analyze query/page Search Analytics to find queries split across multiple pages. Candidates are ranked deterministically by the observed query/page impression sum, each candidate bounds its page list, and limit/start_row plus result_page provide safe pagination. total_clicks, total_impressions, and impression_share are calculated from observed query/page rows and are not true query-level property aggregates; multiple pages can make that row sum exceed the query-level Search Console total. Multiple ranking URLs can also reflect legitimate locale or intent differences, so treat candidates as evidence to investigate rather than proof of harmful cannibalization.',
         inputSchema: {
           site_url: SEARCH_CONSOLE_PROPERTY_SCHEMA,
-          start_date: SEARCH_CONSOLE_DATE_SCHEMA.describe('Start date (inclusive) in YYYY-MM-DD format.'),
-          end_date: SEARCH_CONSOLE_DATE_SCHEMA.describe('End date (inclusive) in YYYY-MM-DD format. Note the 2-3 day GSC data lag.'),
+          start_date: SEARCH_CONSOLE_DATE_SCHEMA.describe(
+            searchConsoleDateDescription('Start date (inclusive) in YYYY-MM-DD format.'),
+          ),
+          end_date: SEARCH_CONSOLE_DATE_SCHEMA.describe(
+            searchConsoleDateDescription(
+              'End date (inclusive) in YYYY-MM-DD format. Note the 2-3 day GSC data lag.',
+            ),
+          ),
           min_impressions: CANNIBALIZATION_MIN_IMPRESSIONS_SCHEMA,
           min_page_percentage: CANNIBALIZATION_MIN_PAGE_PERCENTAGE_SCHEMA,
           limit: ANALYSIS_RESULT_LIMIT_SCHEMA,
@@ -1817,6 +1852,48 @@ class GscMcpRuntime {
         return toolResponse(JSON.stringify(payload, null, 2), payload);
       },
       );
+
+      this.server.registerTool(
+      'indexing.remove',
+      {
+        title: 'Request Indexing API removal',
+        description: "Requests a URL_DELETED notification through Google's Indexing API for a URL within an owner-level Search Console property accessible to the connected Google account. Use only for pages that were eligible for the restricted Indexing API (JobPosting or livestream BroadcastEvent in VideoObject). Before removal Google requires the URL to return HTTP 404/410 or contain a robots noindex meta directive. A successful notification is only receipt acknowledgment and does not prove Google removed the URL from its index.",
+        inputSchema: {
+          site_url: SEARCH_CONSOLE_PROPERTY_SCHEMA.describe(`${SEARCH_CONSOLE_PROPERTY_DESCRIPTION} The connected Google account must be an owner of this property.`),
+          url: z.string().superRefine((value, ctx) => {
+            try {
+              assertIndexingRequestUrl(value);
+            } catch (error) {
+              ctx.addIssue({
+                code: 'custom',
+                message: (error as Error).message,
+              });
+            }
+          }).describe('The fully qualified HTTP/HTTPS URL to request removal for. It must fall within site_url, must have been eligible for the restricted Indexing API, and must currently return HTTP 404/410 or contain a robots noindex meta directive.'),
+        },
+        outputSchema: INDEXING_REMOVE_OUTPUT_SCHEMA,
+        annotations: WRITE_TOOL_ANNOTATIONS['indexing.remove'],
+      },
+      async ({ site_url, url }) => {
+        const googleId = this.requireGoogleId();
+        const rateLimitError = await this.rateLimitError(googleId, 'indexing.remove');
+        if (rateLimitError) return rateLimitError;
+        const accessToken = await this.getAccessToken(googleId);
+        const sites = await listSites(accessToken);
+        assertIndexingUrlAuthorized(url, site_url, sites);
+        const result = await requestIndexingRemoval(accessToken, url);
+        const payload = {
+          result,
+          note: "Google accepting this URL_DELETED notification only confirms receipt. It does not prove the URL was removed from Google's index; use URL Inspection for indexed-state evidence.",
+          provider_default_quota_for_testing_only: true as const,
+          provider_usage_approval_required: true as const,
+          provider_spam_detection_applies: true as const,
+          provider_usage_note: INDEXING_PROVIDER_USAGE_NOTE,
+          removal_completion_proven: false as const,
+        };
+        return toolResponse(JSON.stringify(payload, null, 2), payload);
+      },
+      );
     }
 
     this.server.registerTool(
@@ -1826,8 +1903,16 @@ class GscMcpRuntime {
         description: `${SEARCH_VISIBLE_PAGES_DESCRIPTION} When one date boundary is omitted, the server derives the other to target an inclusive 30-day range; generated end dates are capped at the latest complete date. Responses are bounded and pageable with row_limit/start_row.`,
         inputSchema: {
           site_url: SEARCH_CONSOLE_PROPERTY_SCHEMA,
-          start_date: SEARCH_CONSOLE_DATE_SCHEMA.optional().describe('Start date (inclusive) in YYYY-MM-DD format. If end_date is omitted, the generated end date is 29 days later, capped at the latest complete date.'),
-          end_date: SEARCH_CONSOLE_DATE_SCHEMA.optional().describe('End date (inclusive) in YYYY-MM-DD format. If start_date is omitted, the generated start date is 29 days earlier. Defaults to 3 days ago. Note the 2-3 day data lag.'),
+          start_date: SEARCH_CONSOLE_DATE_SCHEMA.optional().describe(
+            searchConsoleDateDescription(
+              'Start date (inclusive) in YYYY-MM-DD format. If end_date is omitted, the generated end date is 29 days later, capped at the latest complete date.',
+            ),
+          ),
+          end_date: SEARCH_CONSOLE_DATE_SCHEMA.optional().describe(
+            searchConsoleDateDescription(
+              'End date (inclusive) in YYYY-MM-DD format. If start_date is omitted, the generated start date is 29 days earlier. Defaults to 3 days ago. Note the 2-3 day data lag.',
+            ),
+          ),
           row_limit: z.number().int().min(1).max(25000).default(1000).describe(`Maximum pages requested for this logical response (1-25000). Output is safely bounded; continue with result_page.next_start_row while result_page.has_more is true.`),
           start_row: z.number().int().min(0).default(0).describe('Zero-based page-row offset for pagination.'),
         },
@@ -1886,10 +1971,18 @@ class GscMcpRuntime {
         description: 'Compare Search Console performance metrics (clicks, impressions, CTR, average position) between two distinct date ranges (Period A vs Period B) for a selected dimension (query, page, country, device). Only dimension keys returned in both Search Analytics period responses are compared; a key missing from one response is not treated as zero because Google does not guarantee every data row. Apply the same search type and optional dimension filters to both periods. Results are ranked by largest absolute click change, then impression change, and safely paged with limit/start_row. Percentage change is null when an explicitly returned baseline row has zero and the comparison value differs. Discover and Google News are intentionally unavailable because this comparison contract includes average position, which those reports do not support.',
         inputSchema: {
           site_url: SEARCH_CONSOLE_PROPERTY_SCHEMA,
-          start_date_a: SEARCH_CONSOLE_DATE_SCHEMA.describe('Start date of Period A (recent, YYYY-MM-DD)'),
-          end_date_a: SEARCH_CONSOLE_DATE_SCHEMA.describe('End date of Period A (recent, YYYY-MM-DD)'),
-          start_date_b: SEARCH_CONSOLE_DATE_SCHEMA.describe('Start date of Period B (previous, YYYY-MM-DD)'),
-          end_date_b: SEARCH_CONSOLE_DATE_SCHEMA.describe('End date of Period B (previous, YYYY-MM-DD)'),
+          start_date_a: SEARCH_CONSOLE_DATE_SCHEMA.describe(
+            searchConsoleDateDescription('Start date of Period A (recent, YYYY-MM-DD).'),
+          ),
+          end_date_a: SEARCH_CONSOLE_DATE_SCHEMA.describe(
+            searchConsoleDateDescription('End date of Period A (recent, YYYY-MM-DD).'),
+          ),
+          start_date_b: SEARCH_CONSOLE_DATE_SCHEMA.describe(
+            searchConsoleDateDescription('Start date of Period B (previous, YYYY-MM-DD).'),
+          ),
+          end_date_b: SEARCH_CONSOLE_DATE_SCHEMA.describe(
+            searchConsoleDateDescription('End date of Period B (previous, YYYY-MM-DD).'),
+          ),
           dimension: z.enum(['query', 'page', 'country', 'device']).default('query').describe('The dimension to compare performance for. Defaults to query.'),
           search_type: z
             .enum(['web', 'image', 'video', 'news'])
@@ -1996,7 +2089,11 @@ class GscMcpRuntime {
           site_url: SEARCH_CONSOLE_PROPERTY_SCHEMA,
           end_date: SEARCH_CONSOLE_DATE_SCHEMA
             .optional()
-            .describe('End date (inclusive) in YYYY-MM-DD format. Defaults to 3 days ago, which is usually the latest complete Search Console date. Pass a more recent date explicitly to include preliminary data.'),
+            .describe(
+              searchConsoleDateDescription(
+                'End date (inclusive) in YYYY-MM-DD format. Defaults to 3 days ago, which is usually the latest complete Search Console date. Pass a more recent date explicitly to include preliminary data.',
+              ),
+            ),
         },
         outputSchema: WEEKLY_DIGEST_OUTPUT_SCHEMA,
         annotations: READ_ONLY_ANNOTATIONS,
@@ -2134,6 +2231,154 @@ export class PendingAuthState extends DurableObject<Env> {
   }
 }
 
+const CONSENT_COOKIE_HTTPS = '__Host-MCP_GSC_CONSENT';
+const CONSENT_COOKIE_LOOPBACK = 'MCP_GSC_CONSENT';
+
+interface PendingConsentPayload {
+  kind: 'mcp-gsc-consent';
+  authRequest: AuthRequest;
+}
+
+function isLoopbackHttp(url: URL): boolean {
+  return (
+    url.protocol === 'http:' &&
+    (url.hostname === '127.0.0.1' ||
+      url.hostname === 'localhost' ||
+      url.hostname === '[::1]')
+  );
+}
+
+function consentCookieName(url: URL): string {
+  return isLoopbackHttp(url) ? CONSENT_COOKIE_LOOPBACK : CONSENT_COOKIE_HTTPS;
+}
+
+function consentCookie(url: URL, value: string, maxAgeSeconds = 600): string {
+  const secure = isLoopbackHttp(url) ? '' : '; Secure';
+  return `${consentCookieName(url)}=${encodeURIComponent(value)}; Path=/; HttpOnly; SameSite=Strict; Max-Age=${maxAgeSeconds}${secure}`;
+}
+
+function clearConsentCookie(url: URL): string {
+  return consentCookie(url, '', 0);
+}
+
+function getCookie(request: Request, name: string): string | null {
+  const cookie = request.headers.get('cookie');
+  if (!cookie) return null;
+  for (const entry of cookie.split(';')) {
+    const separator = entry.indexOf('=');
+    if (separator < 0) continue;
+    if (entry.slice(0, separator).trim() !== name) continue;
+    try {
+      return decodeURIComponent(entry.slice(separator + 1).trim());
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+async function constantTimeStringEqual(left: string, right: string): Promise<boolean> {
+  const encoder = new TextEncoder();
+  const [leftHash, rightHash] = await Promise.all([
+    crypto.subtle.digest('SHA-256', encoder.encode(left)),
+    crypto.subtle.digest('SHA-256', encoder.encode(right)),
+  ]);
+  const leftBytes = new Uint8Array(leftHash);
+  const rightBytes = new Uint8Array(rightHash);
+  let difference = 0;
+  for (let index = 0; index < leftBytes.length; index += 1) {
+    difference |= leftBytes[index] ^ rightBytes[index];
+  }
+  return difference === 0;
+}
+
+function escapeHtml(value: string): string {
+  return value
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#039;');
+}
+
+function isParsedAuthorizationRequest(value: unknown): value is AuthRequest {
+  if (!value || typeof value !== 'object') return false;
+  const candidate = value as Partial<AuthRequest>;
+  return (
+    typeof candidate.responseType === 'string' &&
+    typeof candidate.clientId === 'string' &&
+    typeof candidate.redirectUri === 'string' &&
+    Array.isArray(candidate.scope) &&
+    candidate.scope.every((scope) => typeof scope === 'string') &&
+    typeof candidate.state === 'string'
+  );
+}
+
+function isPendingConsentPayload(value: unknown): value is PendingConsentPayload {
+  if (!value || typeof value !== 'object') return false;
+  const candidate = value as Partial<PendingConsentPayload>;
+  return candidate.kind === 'mcp-gsc-consent' && isParsedAuthorizationRequest(candidate.authRequest);
+}
+
+function oauthErrorRedirect(
+  authRequest: AuthRequest,
+  code: 'access_denied' | 'server_error',
+  description?: string,
+): Response {
+  const redirect = new URL(authRequest.redirectUri);
+  redirect.searchParams.set('error', code);
+  if (description) redirect.searchParams.set('error_description', description);
+  redirect.searchParams.set('state', authRequest.state);
+  if (authRequest.issuer) redirect.searchParams.set('iss', authRequest.issuer);
+  return new Response(null, {
+    status: 302,
+    headers: { location: redirect.toString() },
+  });
+}
+
+function consentHtml(input: {
+  clientName: string;
+  clientId: string;
+  consentNonce: string;
+  mcpScopes: readonly string[];
+  googleScopes: readonly string[];
+  accessMode: GscAccessMode;
+}): string {
+  const list = (values: readonly string[]) =>
+    values.length > 0
+      ? values.map((value) => `<li><code>${escapeHtml(value)}</code></li>`).join('')
+      : '<li><em>No additional scopes requested</em></li>';
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Authorize Google Search Console MCP</title>
+<style>
+body{font-family:system-ui,sans-serif;max-width:760px;margin:3rem auto;padding:0 1rem;line-height:1.5;color:#111}main{border:1px solid #ddd;border-radius:12px;padding:1.5rem}code{overflow-wrap:anywhere}button{padding:.65rem 1rem;margin-right:.5rem;font:inherit}button[name="decision"][value="allow"]{font-weight:700}.muted{color:#555}
+</style>
+</head>
+<body>
+<main>
+<h1>Authorize Google Search Console access</h1>
+<p><strong>${escapeHtml(input.clientName)}</strong> is requesting access through mcp-gsc.</p>
+<p class="muted">Client ID: <code>${escapeHtml(input.clientId)}</code></p>
+<h2>MCP scopes requested</h2>
+<ul>${list(input.mcpScopes)}</ul>
+<h2>Google scopes mcp-gsc will request</h2>
+<p>Configured access mode: <strong>${escapeHtml(input.accessMode)}</strong></p>
+<ul>${list(input.googleScopes)}</ul>
+<p>Continue only if you recognize and trust the requesting MCP client.</p>
+<form method="post" action="/authorize">
+<input type="hidden" name="consent_nonce" value="${escapeHtml(input.consentNonce)}">
+<button type="submit" name="decision" value="allow">Allow and continue to Google</button>
+<button type="submit" name="decision" value="deny">Deny</button>
+</form>
+</main>
+</body>
+</html>`;
+}
+
 function googleRedirectUri(request: Request): string {
   return new URL('/google/callback', request.url).toString();
 }
@@ -2169,7 +2414,7 @@ export const defaultHandler = {
       });
     }
 
-    if (url.pathname === '/authorize') {
+    if (url.pathname === '/authorize' && request.method === 'GET') {
       let claudeAuthRequest;
       try {
         claudeAuthRequest = await env.OAUTH_PROVIDER.parseAuthRequest(request);
@@ -2185,6 +2430,9 @@ export const defaultHandler = {
           },
         );
       }
+      if (!isParsedAuthorizationRequest(claudeAuthRequest)) {
+        return new Response('Invalid OAuth authorization request.', { status: 400 });
+      }
       let accessMode: GscAccessMode;
       try {
         accessMode = resolveGscAccessMode(env.GSC_ACCESS_MODE);
@@ -2194,16 +2442,106 @@ export const defaultHandler = {
           { status: 500 },
         );
       }
-      const nonce = crypto.randomUUID();
-      await stashPendingAuth(env, nonce, claudeAuthRequest);
-      const redirectUri = googleRedirectUri(request);
+      let client;
+      try {
+        client = await env.OAUTH_PROVIDER.lookupClient(claudeAuthRequest.clientId);
+      } catch (err) {
+        console.warn('OAuth client lookup failed', {
+          message: (err as Error).message,
+        });
+        return new Response('Could not verify the requesting OAuth client.', { status: 400 });
+      }
+      if (!client) {
+        return new Response('Unknown OAuth client.', { status: 400 });
+      }
+
+      const consentNonce = crypto.randomUUID();
+      const pendingConsent: PendingConsentPayload = {
+        kind: 'mcp-gsc-consent',
+        authRequest: claudeAuthRequest,
+      };
+      await stashPendingAuth(env, consentNonce, pendingConsent);
+      return new Response(
+        consentHtml({
+          clientName: client.clientName ?? claudeAuthRequest.clientId,
+          clientId: claudeAuthRequest.clientId,
+          consentNonce,
+          mcpScopes: claudeAuthRequest.scope,
+          googleScopes: getGoogleOAuthScopes(accessMode),
+          accessMode,
+        }),
+        {
+          headers: {
+            'content-type': 'text/html; charset=utf-8',
+            'cache-control': 'no-store',
+            'content-security-policy': "default-src 'none'; style-src 'unsafe-inline'; form-action 'self'; base-uri 'none'; frame-ancestors 'none'",
+            'referrer-policy': 'no-referrer',
+            'x-content-type-options': 'nosniff',
+            'x-frame-options': 'DENY',
+            'set-cookie': consentCookie(url, consentNonce),
+          },
+        },
+      );
+    }
+
+    if (url.pathname === '/authorize' && request.method === 'POST') {
+      const contentType = request.headers.get('content-type')?.toLowerCase() ?? '';
+      if (!contentType.startsWith('application/x-www-form-urlencoded')) {
+        return new Response('Unsupported Media Type', { status: 415 });
+      }
+      const contentLength = Number(request.headers.get('content-length') ?? '0');
+      if (Number.isFinite(contentLength) && contentLength > 4096) {
+        return new Response('Authorization response too large', { status: 413 });
+      }
+      const body = await request.formData();
+      const consentNonceValue = body.get('consent_nonce');
+      const decisionValue = body.get('decision');
+      const consentNonce =
+        typeof consentNonceValue === 'string' ? consentNonceValue : null;
+      const decision = typeof decisionValue === 'string' ? decisionValue : null;
+      const cookieNonce = getCookie(request, consentCookieName(url));
+      if (!consentNonce || !cookieNonce || !(await constantTimeStringEqual(consentNonce, cookieNonce))) {
+        return new Response('Invalid or expired authorization consent.', { status: 400 });
+      }
+
+      const pending = await consumePendingAuth(env, consentNonce);
+      if (!pending || !isPendingConsentPayload(pending.claudeAuthRequest)) {
+        return new Response('Authorization consent expired or invalid.', { status: 400 });
+      }
+      const authRequest = pending.claudeAuthRequest.authRequest;
+      if (decision === 'deny') {
+        const denied = oauthErrorRedirect(authRequest, 'access_denied', 'The user denied access.');
+        denied.headers.append('set-cookie', clearConsentCookie(url));
+        return denied;
+      }
+      if (decision !== 'allow') {
+        return new Response('Invalid authorization decision.', { status: 400 });
+      }
+
+      let accessMode: GscAccessMode;
+      try {
+        accessMode = resolveGscAccessMode(env.GSC_ACCESS_MODE);
+      } catch {
+        return new Response(
+          'Server configuration error: GSC_ACCESS_MODE must be "readonly" or "readwrite".',
+          { status: 500 },
+        );
+      }
+      const googleNonce = crypto.randomUUID();
+      await stashPendingAuth(env, googleNonce, authRequest);
       const googleUrl = buildAuthUrl(
         env.GOOGLE_CLIENT_ID,
-        redirectUri,
-        nonce,
+        googleRedirectUri(request),
+        googleNonce,
         accessMode,
       );
-      return Response.redirect(googleUrl, 302);
+      return new Response(null, {
+        status: 302,
+        headers: {
+          location: googleUrl,
+          'set-cookie': clearConsentCookie(url),
+        },
+      });
     }
 
     if (url.pathname === '/google/callback') {
@@ -2211,14 +2549,7 @@ export const defaultHandler = {
       const state = url.searchParams.get('state');
       const googleError = url.searchParams.get('error');
 
-      if (googleError) {
-        console.error('Google OAuth returned error', { error: googleError });
-        return new Response(`Google OAuth error: ${googleError}`, {
-          status: 400,
-        });
-      }
-
-      if (!code || !state) {
+      if (!state || (!code && !googleError)) {
         console.error('Missing code or state on /google/callback', {
           has_code: !!code,
           has_state: !!state,
@@ -2232,6 +2563,27 @@ export const defaultHandler = {
         return new Response('Auth request expired or invalid', { status: 400 });
       }
 
+      const claudeAuthReq = pending.claudeAuthRequest;
+      if (!isParsedAuthorizationRequest(claudeAuthReq)) {
+        console.error('Pending auth had an invalid shape');
+        return new Response('Auth request expired or invalid', { status: 400 });
+      }
+
+      if (googleError) {
+        console.warn('Google OAuth returned error', { error: googleError });
+        return oauthErrorRedirect(
+          claudeAuthReq,
+          googleError === 'access_denied' ? 'access_denied' : 'server_error',
+          googleError === 'access_denied'
+            ? 'Google authorization was denied.'
+            : 'Google authorization failed.',
+        );
+      }
+
+      if (!code) {
+        return new Response('Missing authorization code', { status: 400 });
+      }
+
       const redirectUri = googleRedirectUri(request);
 
       let tokens;
@@ -2269,7 +2621,6 @@ export const defaultHandler = {
         return new Response('Save user failed', { status: 500 });
       }
 
-      const claudeAuthReq = pending.claudeAuthRequest as any;
       let redirectTo: string;
       try {
         ({ redirectTo } = await env.OAUTH_PROVIDER.completeAuthorization({

package/src/quick-wins-schema.ts

@@ -1,5 +1,8 @@
 import { z } from 'zod';
-import { SEARCH_CONSOLE_DATE_SCHEMA } from './date-validation';
+import {
+  SEARCH_CONSOLE_DATE_SCHEMA,
+  searchConsoleDateDescription,
+} from './date-validation';
 import { SEARCH_CONSOLE_PROPERTY_SCHEMA } from './search-console-property-schema';
 import {
   DEFAULT_ANALYSIS_RESULT_LIMIT,
@@ -21,8 +24,14 @@ export function createQuickWinsInputSchema() {
   return z
     .object({
       site_url: SEARCH_CONSOLE_PROPERTY_SCHEMA,
-      start_date: SEARCH_CONSOLE_DATE_SCHEMA.describe('Start date (inclusive) in YYYY-MM-DD format.'),
-      end_date: SEARCH_CONSOLE_DATE_SCHEMA.describe('End date (inclusive) in YYYY-MM-DD format. Note the 2-3 day GSC data lag.'),
+      start_date: SEARCH_CONSOLE_DATE_SCHEMA.describe(
+        searchConsoleDateDescription('Start date (inclusive) in YYYY-MM-DD format.'),
+      ),
+      end_date: SEARCH_CONSOLE_DATE_SCHEMA.describe(
+        searchConsoleDateDescription(
+          'End date (inclusive) in YYYY-MM-DD format. Note the 2-3 day GSC data lag.',
+        ),
+      ),
       ...QUICK_WINS_THRESHOLDS_SHAPE,
       limit: z
         .number()

package/src/tool-rate-limit.ts

@@ -59,7 +59,7 @@ export const TOOL_RATE_LIMIT_POLICIES = {
   },
   indexing_request: {
     category: 'indexing-request',
-    tools: ['indexing.request'],
+    tools: ['indexing.request', 'indexing.remove'],
     // Google's 200 publish/day default is onboarding/testing quota and does
     // not itself authorize ongoing use. Mirror that number only as a local
     // safety ceiling; two per user reserves it for up to 100 users.

package/src/write-tool-annotations.ts

@@ -4,10 +4,10 @@
  * MCP defines destructiveHint=false for non-read-only tools that perform only
  * additive updates. Search Console's site addition and sitemap submission are
  * additive PUT operations; the corresponding DELETE operations remain
- * destructive. Indexing publishes a URL_UPDATED notification with POST; each
- * call can consume quota and change Google's indexing state, so it remains
- * conservative (destructive + non-idempotent). Tool annotations are client
- * hints, not an enforcement or confirmation mechanism.
+ * destructive. Indexing update/removal notifications use POST; each call can
+ * consume quota and change Google's indexing state, so both remain conservative
+ * (destructive + non-idempotent). Tool annotations are client hints, not an
+ * enforcement or confirmation mechanism.
  */
 export const WRITE_TOOL_ANNOTATIONS = {
   'sites.add': {
@@ -35,7 +35,12 @@ export const WRITE_TOOL_ANNOTATIONS = {
     openWorldHint: true,
   },
   'indexing.request': {
-    // The implementation only publishes URL_UPDATED, never URL_DELETED.
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: true,
+  },
+  'indexing.remove': {
     readOnlyHint: false,
     destructiveHint: true,
     idempotentHint: false,