@digestseo/mcp-gsc 0.4.16 → 0.4.18

package/CHANGELOG.md

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.18] - 2026-09-22
+
+### Fixed
+- The published npm launcher now keeps `GOOGLE_CLIENT_SECRET` and `TOKEN_ENCRYPTION_KEY` out of Wrangler `--var` command-line arguments; Wrangler loads those declared local secrets directly from the child process environment instead.
+- `server.capabilities` now distinguishes stored local Google credentials from live provider authorization, exposing the credential-state basis and explicitly reporting that the discovery call does not probe Google before claiming a connection is usable.
+
+## [0.4.17] - 2026-09-22
+
+### Added
+- `indexing.status` reads Google's latest successful Indexing API update/remove notification receipts for a previously submitted URL while explicitly distinguishing notification receipt from crawl, index coverage, indexing completion, or removal completion.
+
+### Fixed
+- `sites.delete` now describes and reports Google's actual account-scoped effect: it removes the property from the connected user's Search Console site set rather than implying that the website itself or a global Search Console property is deleted.
+
 ## [0.4.16] - 2026-09-22
 
 ### Fixed

package/README.md

@@ -22,7 +22,7 @@ The self-hosting launcher is available as [`@digestseo/mcp-gsc`](https://www.npm
 npx -y @digestseo/mcp-gsc
 ```
 
-The npm launcher starts a loopback-only **Streamable HTTP** Worker on `127.0.0.1` (port `8080` by default); it is not a stdio MCP process. You can run the `npx` command from any directory because the launcher resolves its bundled Worker configuration from the installed package. Clients that launch the package should connect to `http://127.0.0.1:8080/mcp` after supplying the Google OAuth and token-encryption environment variables described in [SETUP.md](SETUP.md). Before the first OAuth sign-in, authorize the exact callback `http://127.0.0.1:8080/google/callback` in Google Cloud (or use the same custom `PORT` you launch with); the launcher prints both URLs at startup.
+The npm launcher starts a loopback-only **Streamable HTTP** Worker on `127.0.0.1` (port `8080` by default); it is not a stdio MCP process. You can run the `npx` command from any directory because the launcher resolves its bundled Worker configuration from the installed package. Clients that launch the package should connect to `http://127.0.0.1:8080/mcp` after supplying the Google OAuth and token-encryption environment variables described in [SETUP.md](SETUP.md). The launcher keeps `GOOGLE_CLIENT_SECRET` and `TOKEN_ENCRYPTION_KEY` in the child process environment and Wrangler loads them through declared local secrets; their values are not copied into Wrangler `--var` command-line arguments. Before the first OAuth sign-in, authorize the exact callback `http://127.0.0.1:8080/google/callback` in Google Cloud (or use the same custom `PORT` you launch with); the launcher prints both URLs at startup.
 
 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.
 
@@ -72,11 +72,11 @@ It runs on [Cloudflare Workers](https://workers.cloudflare.com/) and ships with
 
 ## Tools
 
-By default (`GSC_ACCESS_MODE=readwrite`), this server exposes 21 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 read-only 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.
 
 | Tool | Access | What it does |
 |---|---|---|
-| **`server.capabilities`** | Read | List every tool this server exposes and report whether your Google connection is currently authenticated (`connected` / `not_connected`). Takes no arguments — a good first call for discovery. |
+| **`server.capabilities`** | Read | List every tool this server exposes and report local Google credential state. `connected` means a stored refresh credential is present; the response also exposes `auth_status_basis` and `provider_auth_live_verified: false` because this discovery call does not probe Google. A later Google tool call can still require reconnection if the credential expired or was revoked. Takes no arguments. |
 | **`sites.list`** | Read | List the Search Console properties the connected Google account can access (`siteUrl`, `permissionLevel`). |
 | **`sites.get`** | Read | Retrieve one exact Search Console property and the connected account's permission level for it. |
 | **`analytics.query`** | Read | Impressions, clicks, CTR, and average position over a date range, with dimensions, filters, safe pagination, and selectable search type. Pass `dimensions: []` for true site totals; Google's aggregate row may omit `keys`. Search Analytics does not guarantee every data row and can return only top rows, so exhausting local pagination is not proof that the provider dataset is exhaustive. `data_state: "all"` can include fresh preliminary data, while `final` returns only finalized data; responses echo `data_state` plus `preliminary_data_possible`, and date/hour groupings preserve Google's incomplete-data boundary metadata when returned. Search appearance discovery is a two-step workflow: group by `searchAppearance` alone to discover the exact values Google returns for the property, then filter to one returned value in a separate query when grouping by page/query/country/device/date/hour. For `search_type: "discover"` or `"googleNews"`, `position_supported` is `false`; those reports expose clicks, impressions, and CTR but not average position, and query grouping/filtering is unavailable. Search Console's dedicated Generative AI performance reports are not exposed by the current documented Search Analytics API as a dedicated search type or filter selector; `generative_ai_report_isolatable` is therefore `false`. |
@@ -87,13 +87,14 @@ By default (`GSC_ACCESS_MODE=readwrite`), this server exposes 21 tools. Read-onl
 | **`insights.quick_wins`** / **`insights.cannibalization`** / **`insights.content_decay`** | Read | Surface average-position opportunity rows, query/page overlap, and evidence-ranked click declines. Quick-win candidates are observed query/page rows selected by aggregate Search Console average position, not proof of a stable current rank, and CTR is context rather than an eligibility filter. Cannibalization candidate totals/shares are scoped to observed query/page rows rather than true query-level property totals; content-decay results compare only pages returned in both periods and do not turn one-sided row absence into zero traffic. |
 | **`indexing.list_pages`** / **`analytics.compare`** | Read | Analyze pages receiving Search Console impressions and compare two periods, optionally using the same search type and query/page/country/device/search-appearance filters for both periods. `analytics.compare` compares only dimension keys returned in both period responses; a key absent from one non-exhaustive Search Analytics response is not assumed to have zero metrics. Because its comparison contract includes average position, it excludes Discover and Google News. `indexing.list_pages` is performance data, not index coverage: a missing URL may still be indexed; use `urls.inspect` / `urls.inspect_many` for URL-level index status. |
 | **`reports.weekly_digest`** | Read | Generate a plain-language seven-day performance report with movers, top pages, and one recommended action. Query movers compare only rows returned in both weekly Search Analytics result sets; a query missing from one bounded response is not treated as zero because Google does not guarantee every data row. |
-| **`sites.add`** / **`sites.delete`** | Write | Add or remove a Search Console property. `sites.add` only adds the property to the connected account's Search Console site set; it returns `ownership_verification_performed: false` because ownership verification is a separate Google Site Verification/Search Console workflow. |
+| **`sites.add`** / **`sites.delete`** | Write | Add or remove a property from the connected account's Search Console site set. `sites.add` returns `ownership_verification_performed: false` because ownership verification is a separate Google Site Verification/Search Console workflow. `sites.delete` removes the property from that account's Search Console site set; it does not delete the website itself. |
 | **`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. |
 
 > **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. 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 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.
 
 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.
 

package/SECURITY.md

@@ -51,8 +51,8 @@ Notes:
 ## Tool rate limits
 
 The server enforces the following fixed-window limits before making upstream
-requests. They are per authenticated user and tool category; `indexing.request`
-also has a deployment-wide project guard. A rejected invocation returns a retry
+requests. They are per authenticated user and tool category; the Indexing API
+publish and metadata-read categories also have deployment-wide project guards. A rejected invocation returns a retry
 delay and does not disclose another user's usage.
 
 | Category | Tools | Limit |
@@ -61,9 +61,11 @@ delay and does not disclose another user's usage.
 | 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 metadata | `indexing.status` | 30 per user / minute; 180 per deployment / minute |
 | Weekly digest | `reports.weekly_digest` | 6 per user / hour |
 
-The Indexing API's default publish quota is 200 requests per project per day.
+The Indexing API's default publish quota is 200 requests per project per day,
+and its default metadata-read quota is 180 requests per project per minute.
 Search Analytics and URL Inspection have separate load and per-site quotas, so
 these limits are intentionally conservative rather than a replacement for
 monitoring the Google Cloud project quota.

package/SETUP.md

@@ -112,7 +112,7 @@ openssl rand -base64 32
 
 Paste that value when prompted. Keep it safe — if you lose it, the refresh tokens already in KV become undecryptable and every user has to reconnect.
 
-For **local development**, put the same three values in `.dev.vars` instead — copy `.dev.vars.example` to `.dev.vars` (it's gitignored):
+For **local development**, put the same three values in `.dev.vars` instead — copy `.dev.vars.example` to `.dev.vars` (it's gitignored). The published npm launcher can also read them from the process environment; its bundled Wrangler config declares `GOOGLE_CLIENT_SECRET` and `TOKEN_ENCRYPTION_KEY` as required local secrets so those sensitive values do not need to be serialized into `--var` command-line arguments:
 
 ```
 GOOGLE_CLIENT_ID=...
@@ -155,7 +155,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`, or `indexing.request`. 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`, 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.16",
+  "version": "0.4.18",
   "private": false,
   "main": "scripts/glama-start.mjs",
   "bin": {

package/scripts/glama-start.mjs

@@ -16,8 +16,6 @@ const stateDir = process.env.MCP_GSC_STATE_DIR
   : resolve(homedir(), '.mcp-gsc', 'state');
 const forwardedVariables = [
   'GOOGLE_CLIENT_ID',
-  'GOOGLE_CLIENT_SECRET',
-  'TOKEN_ENCRYPTION_KEY',
   'GSC_ACCESS_MODE',
   'GLAMA_INSPECTION_MODE',
 ];

package/src/access-mode.ts

@@ -25,6 +25,13 @@ export const WRITE_TOOL_NAMES = [
   'indexing.request',
 ] as const;
 
+const INDEXING_SCOPE_READ_TOOL_NAMES = ['indexing.status'] as const;
+
+const READWRITE_ONLY_TOOL_NAMES = [
+  ...WRITE_TOOL_NAMES,
+  ...INDEXING_SCOPE_READ_TOOL_NAMES,
+] as const;
+
 export function resolveGscAccessMode(value: string | undefined): GscAccessMode {
   if (value === undefined || value === '') {
     return DEFAULT_GSC_ACCESS_MODE;
@@ -54,6 +61,6 @@ export function getToolCatalogForAccessMode<T extends { name: string }>(
   }
 
   return tools.filter(
-    (tool) => !(WRITE_TOOL_NAMES as readonly string[]).includes(tool.name),
+    (tool) => !(READWRITE_ONLY_TOOL_NAMES as readonly string[]).includes(tool.name),
   );
 }

package/src/google.ts

@@ -1475,6 +1475,42 @@ export async function requestIndexing(
   return await resp.json();
 }
 
+export interface IndexingNotification {
+  url?: string;
+  type?: 'URL_UPDATED' | 'URL_DELETED' | string;
+  notifyTime?: string;
+}
+
+export interface IndexingNotificationMetadata {
+  url?: string;
+  latestUpdate?: IndexingNotification;
+  latestRemove?: IndexingNotification;
+}
+
+export async function getIndexingNotificationMetadata(
+  accessToken: string,
+  url: string,
+): Promise<IndexingNotificationMetadata> {
+  const endpoint = new URL(
+    'https://indexing.googleapis.com/v3/urlNotifications/metadata',
+  );
+  endpoint.searchParams.set('url', url);
+
+  const resp = await fetchGoogleRead(endpoint.toString(), {
+    headers: { authorization: `Bearer ${accessToken}` },
+  });
+  if (resp.status === 401) {
+    throw new Error(GSC_ACCESS_REVOKED_MESSAGE);
+  }
+  if (!resp.ok) {
+    const text = await resp.text();
+    throw new Error(
+      `Get indexing notification status failed: ${resp.status} ${text}`,
+    );
+  }
+  return (await resp.json()) as IndexingNotificationMetadata;
+}
+
 export interface PerformanceComparisonRow {
   key: string;
   period_a: { clicks: number; impressions: number; ctr: number; position: number };

package/src/index.ts

@@ -28,6 +28,7 @@ import {
   processCannibalization,
   processContentDecay,
   requestIndexing,
+  getIndexingNotificationMetadata,
   processPerformanceComparison,
   type PaginatedSearchAnalyticsResult,
 } from './google';
@@ -190,7 +191,18 @@ const CAPABILITIES_OUTPUT_SCHEMA = {
   server: z.string(),
   version: z.string(),
   access_mode: z.enum(['readonly', 'readwrite']),
-  auth_status: z.enum(['connected', 'not_connected', 'unknown']),
+  auth_status: z.enum(['connected', 'not_connected', 'unknown']).describe(
+    "Local credential state: 'connected' means a stored Google refresh credential is present; it does not live-verify that Google still accepts it.",
+  ),
+  auth_status_basis: z.enum([
+    'stored_refresh_token',
+    'no_stored_refresh_token',
+    'local_state_unavailable',
+  ]),
+  provider_auth_live_verified: z.literal(false).describe(
+    'Always false because server.capabilities does not make a Google token or API request merely to probe authorization.',
+  ),
+  auth_note: z.string(),
   tools: z.array(
     z.object({
       name: z.string(),
@@ -301,6 +313,13 @@ const SITE_ADD_OUTPUT_SCHEMA = {
   ownership_verification_note: z.string(),
 };
 
+const SITE_DELETE_OUTPUT_SCHEMA = {
+  message: z.string(),
+  removed_from_connected_account_site_set: z.literal(true),
+  website_content_deleted: z.literal(false),
+  provider_scope_note: z.string(),
+};
+
 const SEARCH_ANALYTICS_PAGINATION_OUTPUT_SCHEMA = z.object({
   rows_fetched: z.number().int().nonnegative(),
   pages_fetched: z.number().int().positive(),
@@ -453,6 +472,24 @@ const INDEXING_OUTPUT_SCHEMA = {
   provider_usage_note: z.string(),
 };
 
+const INDEXING_NOTIFICATION_SCHEMA = z.object({
+  url: z.string().optional(),
+  type: z.string().optional(),
+  notifyTime: z.string().optional(),
+});
+
+const INDEXING_STATUS_OUTPUT_SCHEMA = {
+  notification_metadata: z.object({
+    url: z.string().optional(),
+    latestUpdate: INDEXING_NOTIFICATION_SCHEMA.optional(),
+    latestRemove: INDEXING_NOTIFICATION_SCHEMA.optional(),
+  }),
+  notification_receipt_only: z.literal(true),
+  index_coverage_report: z.literal(false),
+  indexing_or_removal_completion_proven: z.literal(false),
+  note: z.string(),
+};
+
 const INDEXED_PAGES_OUTPUT_SCHEMA = {
   pages: z.array(z.object({ page: z.string(), ...METRIC_OUTPUT_SCHEMA })),
   note: z.string(),
@@ -604,7 +641,7 @@ const TOOL_CATALOG = [
   {
     name: 'sites.delete',
     description:
-      'Remove an existing website property from your Google Search Console account.',
+      "Remove an existing website property from the connected Google account's Search Console site set. This changes that account's Search Console membership for the property; it does not delete the website itself.",
   },
   {
     name: 'analytics.query',
@@ -671,6 +708,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.status',
+    description:
+      'Read the latest successful Indexing API update/remove notifications Google received for a previously submitted URL. This reports notification receipt only, not crawl, index coverage, indexing completion, or removal completion.',
+  },
   {
     name: 'indexing.list_pages',
     description: SEARCH_VISIBLE_PAGES_DESCRIPTION,
@@ -688,7 +730,7 @@ const TOOL_CATALOG = [
   {
     name: 'server.capabilities',
     description:
-      "List every tool this server exposes and report whether the user's Google Search Console connection is currently authenticated.",
+      "List every tool this server exposes and report local Google credential state. A connected status means a stored refresh credential is present; it is not a live Google authorization check.",
   },
 ] as const;
 
@@ -745,32 +787,49 @@ class GscMcpRuntime {
       {
         title: 'Get server capabilities and auth status',
         description:
-          "List every tool this server exposes, its configured access mode, and whether the user's Google Search Console connection is currently authenticated. Call this first if you're unsure what tools are available, whether the deployment is read-only, or whether the user is connected. Returns the tool catalog plus an access mode and auth status. Takes no arguments.",
+          "List every tool this server exposes, its configured access mode, and local Google credential state. Call this first if you're unsure what tools are available, whether the deployment is read-only, or whether stored Google credentials are configured. auth_status='connected' means a stored refresh credential is present; this tool does not make a Google token/API request and therefore does not live-verify that Google still accepts it. Takes no arguments.",
         inputSchema: {},
         outputSchema: CAPABILITIES_OUTPUT_SCHEMA,
         annotations: READ_ONLY_ANNOTATIONS,
       },
       async () => {
         let authStatus: 'connected' | 'not_connected' | 'unknown';
+        let authStatusBasis:
+          | 'stored_refresh_token'
+          | 'no_stored_refresh_token'
+          | 'local_state_unavailable';
         try {
           const googleId = this.props?.google_id;
           if (!googleId) {
             authStatus = 'not_connected';
+            authStatusBasis = 'no_stored_refresh_token';
           } else {
             const refreshToken = await getDecryptedRefreshToken(
               this.env,
               googleId,
             );
             authStatus = refreshToken ? 'connected' : 'not_connected';
+            authStatusBasis = refreshToken
+              ? 'stored_refresh_token'
+              : 'no_stored_refresh_token';
           }
         } catch {
           authStatus = 'unknown';
+          authStatusBasis = 'local_state_unavailable';
         }
+        const authNote = authStatus === 'connected'
+          ? "Stored Google refresh credentials are present, but server.capabilities does not live-verify them with Google. Refresh tokens can expire or be revoked; a Google tool call may still require reconnection."
+          : authStatus === 'not_connected'
+            ? 'No stored Google refresh credential is available. Reconnect this server in your MCP client to sign in with Google.'
+            : 'Local Google credential state could not be read. Provider authorization was not checked.';
         const capabilities = {
           server: SERVER_NAME,
           version: SERVER_VERSION,
           access_mode: accessMode,
           auth_status: authStatus,
+          auth_status_basis: authStatusBasis,
+          provider_auth_live_verified: false as const,
+          auth_note: authNote,
           tools: getToolCatalogForAccessMode(TOOL_CATALOG, accessMode),
           provider_limits: {
             generative_ai_performance_report: {
@@ -778,7 +837,9 @@ class GscMcpRuntime {
               note: GENERATIVE_AI_REPORT_API_NOTE,
             },
           },
-          hint: "If auth_status is not 'connected', the user should reconnect this server in their MCP client to sign in with Google.",
+          hint: authStatus === 'connected'
+            ? 'Stored Google credentials are configured. If a Google tool later reports revoked access, reconnect this server in your MCP client.'
+            : 'Reconnect this server in your MCP client to sign in with Google.',
         };
         return toolResponse(JSON.stringify(capabilities, null, 2), capabilities);
       },
@@ -1413,12 +1474,12 @@ class GscMcpRuntime {
       this.server.registerTool(
       'sites.delete',
       {
-        title: 'Delete Search Console property',
-        description: 'Remove an existing website property from your Google Search Console account.',
+        title: 'Remove Search Console property from account',
+        description: "Remove an existing website property from the connected Google account's Search Console site set. Google documents this operation as removing the site from the user's Search Console sites; it does not delete website content.",
         inputSchema: {
           site_url: SEARCH_CONSOLE_PROPERTY_SCHEMA,
         },
-        outputSchema: MESSAGE_OUTPUT_SCHEMA,
+        outputSchema: SITE_DELETE_OUTPUT_SCHEMA,
         annotations: WRITE_TOOL_ANNOTATIONS['sites.delete'],
       },
       async ({ site_url }) => {
@@ -1427,8 +1488,14 @@ class GscMcpRuntime {
         if (rateLimitError) return rateLimitError;
         const accessToken = await this.getAccessToken(googleId);
         await deleteSite(accessToken, site_url);
-        const message = `Successfully deleted site property: ${site_url}`;
-        return toolResponse(message, { message });
+        const message = `Successfully removed site property from the connected account's Search Console site set: ${site_url}`;
+        const payload = {
+          message,
+          removed_from_connected_account_site_set: true as const,
+          website_content_deleted: false as const,
+          provider_scope_note: "Google's Sites.delete method removes the property from the connected user's Search Console site set. It does not delete the website itself.",
+        };
+        return toolResponse(`${message}\n\n${payload.provider_scope_note}`, payload);
       },
     );
 
@@ -1667,6 +1734,49 @@ class GscMcpRuntime {
     );
 
     if (accessMode === 'readwrite') {
+      this.server.registerTool(
+      'indexing.status',
+      {
+        title: 'Get Indexing API notification status',
+        description: "Read the latest successful Indexing API URL_UPDATED and URL_DELETED notifications Google received for a previously submitted URL within an owner-level Search Console property accessible to the connected Google account. This is a read-only notification-receipt lookup, not an index-coverage report and not proof that Google crawled, indexed, or removed the URL. It is available only in readwrite access mode because Google's metadata endpoint requires the Indexing API OAuth scope.",
+        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('A fully qualified HTTP/HTTPS URL previously submitted successfully through the Google Indexing API. It must fall within site_url.'),
+        },
+        outputSchema: INDEXING_STATUS_OUTPUT_SCHEMA,
+        annotations: READ_ONLY_ANNOTATIONS,
+      },
+      async ({ site_url, url }) => {
+        const googleId = this.requireGoogleId();
+        const rateLimitError = await this.rateLimitError(googleId, 'indexing.status');
+        if (rateLimitError) return rateLimitError;
+        const accessToken = await this.getAccessToken(googleId);
+        const sites = await listSites(accessToken);
+        assertIndexingUrlAuthorized(url, site_url, sites);
+        const notificationMetadata = await getIndexingNotificationMetadata(
+          accessToken,
+          url,
+        );
+        const payload = {
+          notification_metadata: notificationMetadata,
+          notification_receipt_only: true as const,
+          index_coverage_report: false as const,
+          indexing_or_removal_completion_proven: false as const,
+          note: "This reports the latest successful Indexing API notification receipt(s) Google recorded for the URL. It does not report whether Google crawled, indexed, or removed the URL; use URL Inspection for indexed-state evidence.",
+        };
+        return toolResponse(JSON.stringify(payload, null, 2), payload);
+      },
+      );
+
       this.server.registerTool(
       'indexing.request',
       {

package/src/tool-rate-limit.ts

@@ -67,6 +67,15 @@ export const TOOL_RATE_LIMIT_POLICIES = {
     userLimit: 2,
     projectLimit: 200,
   },
+  indexing_metadata: {
+    category: 'indexing-metadata',
+    tools: ['indexing.status'],
+    // Google publishes a default metadata-read quota of 180 requests per
+    // minute per project. Keep per-user headroom inside that shared ceiling.
+    windowMs: MINUTE_MS,
+    userLimit: 30,
+    projectLimit: 180,
+  },
   weekly_digest: {
     category: 'weekly-digest',
     tools: ['reports.weekly_digest'],

package/wrangler.example.jsonc

@@ -8,6 +8,9 @@
   "compatibility_date": "2026-05-19",
   "compatibility_flags": ["nodejs_compat", "global_fetch_strictly_public"],
   "observability": { "enabled": true },
+  "secrets": {
+    "required": ["GOOGLE_CLIENT_SECRET", "TOKEN_ENCRYPTION_KEY"]
+  },
   "vars": {
     "GSC_ACCESS_MODE": "readwrite"
   },