@canonry/canonry 4.136.0 → 4.136.1

package/dist/{chunk-PAR6P5H6.js → chunk-OESGFFUO.js}

@@ -42,7 +42,7 @@ import {
   trafficConnectWordpressRequestSchema,
   trafficEventKindSchema,
   trafficSeriesGranularitySchema
-} from "./chunk-PXEEWJRV.js";
+} from "./chunk-PIMWEIJ3.js";
 
 // src/config.ts
 import fs from "fs";
@@ -1087,6 +1087,22 @@ var createClient = (config = {}) => {
 var client = createClient(createConfig());
 
 // ../api-client-generated/src/generated/sdk.gen.ts
+var postApiV1ProjectsByNameGoogleGscSitemapsSubmit = (options) => {
+  return (options.client ?? client).post({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v1/projects/{name}/google/gsc/sitemaps/submit",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+};
 var deleteApiV1ProjectsByName = (options) => {
   return (options.client ?? client).delete({
     security: [
@@ -5181,9 +5197,22 @@ var ApiClient = class {
       })
     );
   }
-  async gscSitemaps(project) {
+  async gscSitemaps(project, params) {
+    return this.invoke(
+      () => getApiV1ProjectsByNameGoogleGscSitemaps({
+        client: this.heyClient,
+        path: { name: project },
+        query: { sitemapIndex: params?.sitemapIndex }
+      })
+    );
+  }
+  async gscSubmitSitemaps(project, body) {
     return this.invoke(
-      () => getApiV1ProjectsByNameGoogleGscSitemaps({ client: this.heyClient, path: { name: project } })
+      () => postApiV1ProjectsByNameGoogleGscSitemapsSubmit({
+        client: this.heyClient,
+        path: { name: project },
+        body
+      })
     );
   }
   async gscDiscoverSitemaps(project) {
@@ -6149,6 +6178,92 @@ var gscCoverageHistoryInputSchema = z2.object({
   project: projectNameSchema,
   limit: z2.number().int().positive().max(500).optional()
 });
+var gscSitemapsInputSchema = z2.object({
+  project: projectNameSchema,
+  sitemapIndex: z2.string().url().optional()
+});
+var gscSitemapsSubmitInputSchema = z2.union([
+  z2.object({
+    project: projectNameSchema,
+    sitemapUrls: z2.array(z2.string().url()).min(1).max(50)
+  }).strict(),
+  z2.object({
+    project: projectNameSchema,
+    mode: z2.enum(["indexes", "all-files"])
+  }).strict()
+]);
+async function submitGscSitemapsFromMcp(client2, input) {
+  let sitemapUrls;
+  if ("sitemapUrls" in input) {
+    sitemapUrls = uniqueStrings(input.sitemapUrls);
+  } else {
+    const topLevel = await client2.gscSitemaps(input.project);
+    if (input.mode === "indexes") {
+      sitemapUrls = uniqueStrings(
+        topLevel.preferredSubmissionUrls.length > 0 ? topLevel.preferredSubmissionUrls : topLevel.sitemaps.map((sitemap) => sitemap.path)
+      );
+    } else {
+      const indexes = topLevel.sitemaps.filter((sitemap) => sitemap.isSitemapsIndex).map((sitemap) => sitemap.path);
+      const expandedIndexUrls = [];
+      for (let offset = 0; offset < indexes.length; offset += 4) {
+        const children = await Promise.all(
+          indexes.slice(offset, offset + 4).map(
+            (sitemapIndex) => client2.gscSitemaps(input.project, { sitemapIndex })
+          )
+        );
+        children.forEach((result, index) => {
+          const sitemapIndex = indexes[offset + index];
+          expandedIndexUrls.push(...result.sitemaps.length > 0 ? result.sitemaps.map((sitemap) => sitemap.path) : [sitemapIndex]);
+        });
+      }
+      sitemapUrls = uniqueStrings([
+        ...topLevel.sitemaps.filter((sitemap) => !sitemap.isSitemapsIndex).map((sitemap) => sitemap.path),
+        ...expandedIndexUrls
+      ]);
+    }
+  }
+  if (sitemapUrls.length === 0) {
+    throw new Error("No GSC sitemaps found. Submit an explicit sitemap URL first.");
+  }
+  const aggregate = {
+    summary: { total: 0, accepted: 0, failed: 0 },
+    results: []
+  };
+  for (let offset = 0; offset < sitemapUrls.length; offset += 50) {
+    const batchSitemapUrls = sitemapUrls.slice(offset, offset + 50);
+    try {
+      const result = await client2.gscSubmitSitemaps(input.project, {
+        sitemapUrls: batchSitemapUrls
+      });
+      aggregate.summary.total += result.summary.total;
+      aggregate.summary.accepted += result.summary.accepted;
+      aggregate.summary.failed += result.summary.failed;
+      aggregate.results.push(...result.results);
+    } catch (cause) {
+      if (offset === 0) throw cause;
+      const attempted = aggregate.summary.total + batchSitemapUrls.length;
+      const remaining = sitemapUrls.length - attempted;
+      throw new CliError({
+        code: "GOOGLE_SITEMAP_SUBMISSION_PARTIAL",
+        message: `Sitemap submission stopped after ${aggregate.summary.total} completed results; ${batchSitemapUrls.length} are unconfirmed and ${remaining} were not attempted.`,
+        exitCode: cause instanceof CliError && cause.exitCode === 1 ? 1 : EXIT_SYSTEM_ERROR,
+        details: {
+          project: input.project,
+          accepted: aggregate.summary.accepted,
+          failed: aggregate.summary.failed,
+          completed: aggregate.summary.total,
+          attempted,
+          unconfirmed: batchSitemapUrls.length,
+          remaining,
+          unconfirmedBatch: { index: Math.floor(offset / 50) + 1, sitemapUrls: batchSitemapUrls },
+          partialResult: aggregate,
+          cause: cause instanceof CliError ? { code: cause.code, message: cause.message, details: cause.details } : { message: cause instanceof Error ? cause.message : String(cause) }
+        }
+      });
+    }
+  }
+  return aggregate;
+}
 var gaWindowInputSchema = z2.object({
   project: projectNameSchema,
   window: analyticsWindowSchema.optional()
@@ -6486,7 +6601,7 @@ var canonryMcpTools = [
     description: "Get a Canonry project by name.",
     access: "read",
     tier: "core",
-    inputSchema: projectInputSchema,
+    inputSchema: gscSitemapsInputSchema,
     annotations: readAnnotations(),
     openApiOperations: ["GET /api/v1/projects/{name}"],
     handler: (client2, input) => client2.getProject(input.project)
@@ -7048,10 +7163,21 @@ var canonryMcpTools = [
     description: "Get sitemap data from Google Search Console for a Canonry project.",
     access: "read",
     tier: "gsc",
-    inputSchema: projectInputSchema,
+    inputSchema: gscSitemapsInputSchema,
     annotations: readAnnotations(true),
     openApiOperations: ["GET /api/v1/projects/{name}/google/gsc/sitemaps"],
-    handler: (client2, input) => client2.gscSitemaps(input.project)
+    handler: (client2, input) => client2.gscSitemaps(input.project, { sitemapIndex: input.sitemapIndex })
+  }),
+  defineTool({
+    name: "canonry_gsc_sitemaps_submit",
+    title: "Submit GSC sitemaps",
+    description: "Submit up to 50 explicit sitemap URLs, preferred sitemap indexes, or every standalone top-level file plus index child to Google Search Console for refetching. Parent indexes are not redundantly submitted in all-files mode. Google acceptance does not guarantee indexing.",
+    access: "write",
+    tier: "gsc",
+    inputSchema: gscSitemapsSubmitInputSchema,
+    annotations: writeAnnotations({ idempotentHint: false, openWorldHint: true }),
+    openApiOperations: ["POST /api/v1/projects/{name}/google/gsc/sitemaps/submit"],
+    handler: submitGscSitemapsFromMcp
   }),
   defineTool({
     name: "canonry_ga_status",

package/dist/{chunk-PXEEWJRV.js → chunk-PIMWEIJ3.js}

@@ -1493,10 +1493,13 @@ var gscSiteListResponseDtoSchema = z9.object({
 var gscSitemapContentDtoSchema = z9.object({
   type: z9.string(),
   submitted: z9.string(),
-  indexed: z9.string()
+  // Google still returns this for existing sitemap reads, but it is not a
+  // reliable submission outcome. Retained only for response compatibility.
+  indexed: z9.string().optional().describe("Deprecated compatibility field.")
 });
 var gscSitemapDtoSchema = z9.object({
   path: z9.string(),
+  parentSitemapUrl: z9.string().optional(),
   lastSubmitted: z9.string().optional(),
   isPending: z9.boolean().optional(),
   isSitemapsIndex: z9.boolean().optional(),
@@ -1507,7 +1510,50 @@ var gscSitemapDtoSchema = z9.object({
   contents: z9.array(gscSitemapContentDtoSchema).optional()
 });
 var gscSitemapListResponseDtoSchema = z9.object({
-  sitemaps: z9.array(gscSitemapDtoSchema).default([])
+  sitemaps: z9.array(gscSitemapDtoSchema).default([]),
+  summary: z9.object({
+    total: z9.number().int().nonnegative(),
+    indexes: z9.number().int().nonnegative(),
+    files: z9.number().int().nonnegative()
+  }),
+  preferredSubmissionUrls: z9.array(z9.string()).default([])
+});
+var gscSubmitSitemapsRequestDtoSchema = z9.object({
+  sitemapUrls: z9.array(
+    z9.string().url().refine(
+      (value) => {
+        const protocol = new URL(value).protocol;
+        return protocol === "http:" || protocol === "https:";
+      },
+      { message: "Sitemap URL must use http or https." }
+    )
+  ).min(1).max(50)
+});
+var gscSubmitSitemapResultDtoSchema = z9.object({
+  sitemapUrl: z9.string(),
+  status: z9.enum(["accepted", "error"]),
+  submittedAt: z9.string().optional(),
+  error: z9.string().optional()
+});
+var gscSubmitSitemapsResponseDtoSchema = z9.object({
+  summary: z9.object({
+    total: z9.number().int().nonnegative(),
+    accepted: z9.number().int().nonnegative(),
+    failed: z9.number().int().nonnegative()
+  }),
+  results: z9.array(gscSubmitSitemapResultDtoSchema)
+});
+var gscDiscoverSitemapsResponseDtoSchema = z9.object({
+  sitemaps: z9.array(gscSitemapDtoSchema),
+  primarySitemapUrl: z9.string(),
+  run: z9.object({
+    id: z9.string(),
+    projectId: z9.string(),
+    kind: z9.string(),
+    status: z9.string(),
+    trigger: z9.string(),
+    createdAt: z9.string()
+  }).nullable()
 });
 
 // ../contracts/src/gbp.ts
@@ -7882,6 +7928,9 @@ export {
   gscCoverageSnapshotDtoSchema,
   gscSiteListResponseDtoSchema,
   gscSitemapListResponseDtoSchema,
+  gscSubmitSitemapsRequestDtoSchema,
+  gscSubmitSitemapsResponseDtoSchema,
+  gscDiscoverSitemapsResponseDtoSchema,
   gbpAccountListResponseSchema,
   gbpLocationDtoSchema,
   gbpLocationListResponseSchema,

package/dist/{chunk-3PFRVEWP.js → chunk-YMF35LN5.js}

@@ -10,7 +10,7 @@ import {
   loadConfig,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-PAR6P5H6.js";
+} from "./chunk-OESGFFUO.js";
 import {
   CC_CACHE_DIR,
   DUCKDB_SPEC,
@@ -119,7 +119,7 @@ import {
   siteAuditPages,
   siteAuditSnapshots,
   usageCounters
-} from "./chunk-TPVMHYHD.js";
+} from "./chunk-YQ2RXMU2.js";
 import {
   AGENT_MEMORY_VALUE_MAX_BYTES,
   AGENT_PROVIDER_IDS,
@@ -194,7 +194,7 @@ import {
   validationError,
   winnabilityClassLabel,
   withRetry
-} from "./chunk-PXEEWJRV.js";
+} from "./chunk-PIMWEIJ3.js";
 
 // src/telemetry.ts
 import crypto from "crypto";
@@ -7066,7 +7066,7 @@ function readStoredGroundingSources(rawResponse) {
   return result;
 }
 async function backfillInsightsCommand(project, opts) {
-  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-BMEJ5GFZ.js");
+  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-BKLR57RQ.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);

package/dist/{chunk-TPVMHYHD.js → chunk-YQ2RXMU2.js}

@@ -238,10 +238,13 @@ import {
   gscCoverageSnapshotDtoSchema,
   gscCoverageSummaryDtoSchema,
   gscDeindexedRowSchema,
+  gscDiscoverSitemapsResponseDtoSchema,
   gscPerformanceDailyDtoSchema,
   gscSearchDataDtoSchema,
   gscSiteListResponseDtoSchema,
   gscSitemapListResponseDtoSchema,
+  gscSubmitSitemapsRequestDtoSchema,
+  gscSubmitSitemapsResponseDtoSchema,
   gscUrlInspectionDtoSchema,
   hasLocationLabel,
   healthSnapshotDtoSchema,
@@ -365,7 +368,7 @@ import {
   wordpressSchemaDeployResultDtoSchema,
   wordpressSchemaStatusResultDtoSchema,
   wordpressStatusDtoSchema
-} from "./chunk-PXEEWJRV.js";
+} from "./chunk-PIMWEIJ3.js";
 
 // src/intelligence-service.ts
 import { eq as eq44, desc as desc21, asc as asc9, and as and35, ne as ne6, or as or10, inArray as inArray15, gte as gte12, lte as lte8 } from "drizzle-orm";
@@ -17487,7 +17490,9 @@ var SCHEMA_TABLE = {
   GscDeindexedRowDto: gscDeindexedRowSchema,
   GscPerformanceDailyDto: gscPerformanceDailyDtoSchema,
   GscSearchDataDto: gscSearchDataDtoSchema,
+  GscDiscoverSitemapsResponseDto: gscDiscoverSitemapsResponseDtoSchema,
   GscSiteListResponseDto: gscSiteListResponseDtoSchema,
+  GscSubmitSitemapsResponseDto: gscSubmitSitemapsResponseDtoSchema,
   GscSitemapListResponseDto: gscSitemapListResponseDtoSchema,
   GscUrlInspectionDto: gscUrlInspectionDtoSchema,
   HealthSnapshotDto: healthSnapshotDtoSchema,
@@ -17910,6 +17915,34 @@ var routeCatalog = [
       200: rawJsonResponse("OpenAPI document.", looseObjectSchema)
     }
   },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/google/gsc/sitemaps/submit",
+    summary: "Submit GSC sitemaps",
+    description: "Submits sitemap URLs to Google Search Console sequentially. An accepted result means Google accepted the submit/refetch request; it does not indicate indexing.",
+    tags: ["google"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["sitemapUrls"],
+            additionalProperties: false,
+            properties: {
+              sitemapUrls: { type: "array", minItems: 1, maxItems: 50, items: { type: "string", format: "uri", pattern: "^https?://" } }
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: jsonResponse("Per-sitemap submission results returned.", "GscSubmitSitemapsResponseDto"),
+      400: errorResponse("Invalid sitemap request, property ownership, or OAuth scope."),
+      404: errorResponse("Project or connection not found.")
+    }
+  },
   {
     method: "put",
     path: "/api/v1/projects/{name}",
@@ -19487,7 +19520,15 @@ var routeCatalog = [
     path: "/api/v1/projects/{name}/google/gsc/sitemaps",
     summary: "List GSC sitemaps",
     tags: ["google"],
-    parameters: [nameParameter],
+    parameters: [
+      nameParameter,
+      {
+        name: "sitemapIndex",
+        in: "query",
+        description: "Optional owned sitemap-index URL. When present, returns that index's child entries.",
+        schema: { type: "string", format: "uri", pattern: "^https?://" }
+      }
+    ],
     responses: {
       200: jsonResponse("GSC sitemaps returned.", "GscSitemapListResponseDto"),
       400: errorResponse("Invalid sitemap request."),
@@ -19501,8 +19542,7 @@ var routeCatalog = [
     tags: ["google"],
     parameters: [nameParameter],
     responses: {
-      // TODO: Add `DiscoverSitemapsResponse` Zod schema in contracts.
-      200: rawJsonResponse("Discovered sitemaps and queued run returned.", looseObjectSchema),
+      200: jsonResponse("Discovered sitemaps and queued run returned.", "GscDiscoverSitemapsResponseDto"),
       400: errorResponse("Invalid sitemap discovery request."),
       404: errorResponse("Project or connection not found.")
     }
@@ -23230,7 +23270,8 @@ function buildGbpSummary(input) {
 // ../integration-google/src/constants.ts
 var GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
 var GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
-var GSC_SCOPE = "https://www.googleapis.com/auth/webmasters.readonly";
+var GSC_SCOPE = "https://www.googleapis.com/auth/webmasters";
+var GSC_READONLY_SCOPE = "https://www.googleapis.com/auth/webmasters.readonly";
 var INDEXING_SCOPE = "https://www.googleapis.com/auth/indexing";
 var GSC_API_BASE = "https://www.googleapis.com/webmasters/v3";
 var URL_INSPECTION_API = "https://searchconsole.googleapis.com/v1/urlInspection/index:inspect";
@@ -23480,7 +23521,7 @@ function gscClientLog(level, action, ctx) {
   const stream = level === "error" ? process.stderr : process.stdout;
   stream.write(JSON.stringify(entry) + "\n");
 }
-async function gscFetch(accessToken, url, opts) {
+async function gscFetchResponse(accessToken, url, opts) {
   const method = opts?.method ?? "GET";
   const headers = {
     Authorization: `Bearer ${accessToken}`,
@@ -23506,26 +23547,50 @@ async function gscFetch(accessToken, url, opts) {
     const detail = body.length <= 500 ? body : `${body.slice(0, 500)}... [truncated]`;
     throw new GoogleApiError(`GSC API error (${res.status}): ${detail}`, res.status);
   }
-  return await res.json();
+  return res;
+}
+async function gscFetchJson(accessToken, url, opts) {
+  const res = await gscFetchResponse(accessToken, url, opts);
+  const text2 = await res.text();
+  if (!text2) {
+    throw new GoogleApiError("GSC API returned an empty response where JSON was expected", res.status);
+  }
+  try {
+    return JSON.parse(text2);
+  } catch {
+    throw new GoogleApiError("GSC API returned invalid JSON", res.status);
+  }
 }
 async function listSites(accessToken) {
   validateAccessToken(accessToken);
-  const data = await gscFetch(
+  const data = await gscFetchJson(
     accessToken,
     `${GSC_API_BASE}/sites`
   );
   return data.siteEntry ?? [];
 }
-async function listSitemaps(accessToken, siteUrl) {
+async function listSitemaps(accessToken, siteUrl, sitemapIndex) {
   validateAccessToken(accessToken);
   validateSiteUrl(siteUrl);
+  if (sitemapIndex != null) validateUrl(sitemapIndex);
   const encodedSiteUrl = encodeURIComponent(siteUrl);
-  const data = await gscFetch(
+  const sitemapIndexQuery = sitemapIndex == null ? "" : `?sitemapIndex=${encodeURIComponent(sitemapIndex)}`;
+  const data = await gscFetchJson(
     accessToken,
-    `${GSC_API_BASE}/sites/${encodedSiteUrl}/sitemaps`
+    `${GSC_API_BASE}/sites/${encodedSiteUrl}/sitemaps${sitemapIndexQuery}`
   );
   return data.sitemap ?? [];
 }
+async function submitSitemap(accessToken, siteUrl, sitemapUrl) {
+  validateAccessToken(accessToken);
+  validateSiteUrl(siteUrl);
+  validateUrl(sitemapUrl);
+  await gscFetchResponse(
+    accessToken,
+    `${GSC_API_BASE}/sites/${encodeURIComponent(siteUrl)}/sitemaps/${encodeURIComponent(sitemapUrl)}`,
+    { method: "PUT" }
+  );
+}
 async function fetchSearchAnalytics(accessToken, siteUrl, opts) {
   validateAccessToken(accessToken);
   validateSiteUrl(siteUrl);
@@ -23555,7 +23620,7 @@ async function fetchSearchAnalytics(accessToken, siteUrl, opts) {
       requestBody.dimensionFilterGroups = filters;
     }
     const encodedSiteUrl = encodeURIComponent(siteUrl);
-    const data = await gscFetch(
+    const data = await gscFetchJson(
       accessToken,
       `${GSC_API_BASE}/sites/${encodedSiteUrl}/searchAnalytics/query`,
       { method: "POST", body: requestBody }
@@ -23572,7 +23637,7 @@ async function fetchSearchAnalytics(accessToken, siteUrl, opts) {
 async function publishUrlNotification(accessToken, url, type = "URL_UPDATED") {
   validateAccessToken(accessToken);
   validateUrl(url);
-  return gscFetch(
+  return gscFetchJson(
     accessToken,
     `${INDEXING_API_BASE}/urlNotifications:publish`,
     {
@@ -23585,7 +23650,7 @@ async function inspectUrl(accessToken, inspectionUrl, siteUrl) {
   validateAccessToken(accessToken);
   validateUrl(inspectionUrl);
   validateSiteUrl(siteUrl);
-  return gscFetch(
+  return gscFetchJson(
     accessToken,
     URL_INSPECTION_API,
     {
@@ -24795,6 +24860,33 @@ function scopesForConnectionType(type) {
       return [GBP_SCOPE];
   }
 }
+function isSitemapOwnedByProperty(sitemapUrl, propertyId, canonicalDomain) {
+  let sitemap;
+  try {
+    sitemap = new URL(sitemapUrl);
+  } catch {
+    return false;
+  }
+  if (sitemap.protocol !== "http:" && sitemap.protocol !== "https:") return false;
+  if (/^sc-domain:/i.test(propertyId)) {
+    const domain = propertyId.slice("sc-domain:".length).toLowerCase();
+    const host = sitemap.hostname.toLowerCase();
+    return host === domain || host.endsWith(`.${domain}`);
+  }
+  if (/^\d+$/.test(propertyId)) {
+    const domain = normalizeProjectDomain(canonicalDomain);
+    return sitemap.hostname.toLowerCase().replace(/^www\./, "") === domain;
+  }
+  try {
+    const property = new URL(propertyId);
+    if (property.protocol !== "http:" && property.protocol !== "https:") return false;
+    if (sitemap.origin !== property.origin) return false;
+    const prefix = property.pathname.endsWith("/") ? property.pathname : `${property.pathname}/`;
+    return sitemap.pathname === property.pathname || sitemap.pathname.startsWith(prefix);
+  } catch {
+    return false;
+  }
+}
 function signState(payload, secret) {
   return crypto19.createHmac("sha256", secret).update(payload).digest("hex");
 }
@@ -25454,17 +25546,83 @@ async function googleRoutes(app, opts) {
     }
     const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
+    const conn = store.getConnection(project.canonicalDomain, "gsc");
+    if (!conn?.propertyId) {
+      throw validationError('No GSC property configured for this connection. Set one with "canonry google set-property".');
+    }
+    const sitemapIndex = request.query.sitemapIndex;
+    if (sitemapIndex && !isSitemapOwnedByProperty(sitemapIndex, conn.propertyId, project.canonicalDomain)) {
+      throw validationError(`sitemapIndex must belong to the configured GSC property "${conn.propertyId}".`);
+    }
     try {
       const { accessToken, propertyId } = await getValidToken(store, project.canonicalDomain, "gsc", googleClientId, googleClientSecret);
       if (!propertyId) {
         throw validationError('No GSC property configured for this connection. Set one with "canonry google set-property".');
       }
-      const sitemaps = await listSitemaps(accessToken, propertyId);
-      return { sitemaps };
+      const entries = await listSitemaps(accessToken, propertyId, sitemapIndex);
+      const sitemaps = sitemapIndex ? entries.map((sitemap) => ({ ...sitemap, parentSitemapUrl: sitemapIndex })) : entries;
+      const indexes = sitemaps.filter((sitemap) => sitemap.isSitemapsIndex).length;
+      return {
+        sitemaps,
+        summary: { total: sitemaps.length, indexes, files: sitemaps.length - indexes },
+        preferredSubmissionUrls: indexes > 0 ? sitemaps.filter((sitemap) => sitemap.isSitemapsIndex).map((sitemap) => sitemap.path) : sitemaps.map((sitemap) => sitemap.path)
+      };
     } catch (err) {
       throw gscErrorToAppError(err, "Failed to list Search Console sitemaps");
     }
   });
+  app.post("/projects/:name/google/gsc/sitemaps/submit", async (request) => {
+    const parsed = gscSubmitSitemapsRequestDtoSchema.safeParse(request.body ?? {});
+    if (!parsed.success) {
+      throw validationError("sitemapUrls must contain between 1 and 50 valid sitemap URLs");
+    }
+    const sitemapUrls = [...new Set(parsed.data.sitemapUrls)];
+    const project = resolveProject(app.db, request.params.name);
+    const store = requireConnectionStore();
+    const conn = store.getConnection(project.canonicalDomain, "gsc");
+    if (!conn) {
+      throw validationError('No GSC connection found for this domain. Run "canonry google connect" first.');
+    }
+    if (!conn.propertyId) {
+      throw validationError('No GSC property configured for this connection. Set one with "canonry google set-property".');
+    }
+    const invalidUrls = sitemapUrls.filter((url) => !isSitemapOwnedByProperty(url, conn.propertyId, project.canonicalDomain));
+    if (invalidUrls.length > 0) {
+      throw validationError(`Sitemap URLs must belong to the configured GSC property "${conn.propertyId}". Invalid: ${invalidUrls.slice(0, 5).join(", ")}`);
+    }
+    if (!(conn.scopes ?? []).includes(GSC_SCOPE)) {
+      throw validationError('This GSC connection has the read-only webmasters scope and cannot submit sitemaps. Reconnect with "canonry google connect" to grant the full webmasters scope.');
+    }
+    const { clientId: googleClientId, clientSecret: googleClientSecret } = getAuthConfig();
+    if (!googleClientId || !googleClientSecret) {
+      throw validationError("Google OAuth is not configured");
+    }
+    let accessToken;
+    try {
+      ({ accessToken } = await getValidToken(store, project.canonicalDomain, "gsc", googleClientId, googleClientSecret));
+    } catch (err) {
+      throw gscErrorToAppError(err, "Failed to authorize Search Console sitemap submission");
+    }
+    const results = [];
+    for (const sitemapUrl of sitemapUrls) {
+      try {
+        await submitSitemap(accessToken, conn.propertyId, sitemapUrl);
+        const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+        writeAuditLog(app.db, {
+          projectId: project.id,
+          actor: "api",
+          action: "google.sitemap.submitted",
+          entityType: "sitemap",
+          entityId: sitemapUrl
+        });
+        results.push({ sitemapUrl, status: "accepted", submittedAt });
+      } catch (err) {
+        results.push({ sitemapUrl, status: "error", error: err instanceof Error ? err.message : String(err) });
+      }
+    }
+    const accepted = results.filter((result) => result.status === "accepted").length;
+    return { summary: { total: results.length, accepted, failed: results.length - accepted }, results };
+  });
   app.post("/projects/:name/google/gsc/discover-sitemaps", async (request) => {
     const { clientId: googleClientId, clientSecret: googleClientSecret } = getAuthConfig();
     if (!googleClientId || !googleClientSecret) {
@@ -25487,9 +25645,11 @@ async function googleRoutes(app, opts) {
       throw gscErrorToAppError(err, "Failed to discover Search Console sitemaps");
     }
     if (sitemaps.length === 0) {
-      throw validationError("No sitemaps found for this GSC property. Submit a sitemap in Google Search Console first.");
+      throw validationError(
+        `No sitemaps found for this GSC property. Submit one with "canonry google submit-sitemap ${request.params.name} <url>" first.`
+      );
     }
-    const primary = sitemaps.find((s) => !s.isSitemapsIndex) ?? sitemaps[0];
+    const primary = sitemaps.find((s) => s.isSitemapsIndex) ?? sitemaps[0];
     const sitemapUrl = primary.path;
     store.updateConnection(project.canonicalDomain, "gsc", {
       sitemapUrl,
@@ -42064,7 +42224,6 @@ var PLACES_CHECK_BY_ID = Object.fromEntries(
 );
 
 // ../api-routes/src/doctor/checks/google-auth.ts
-var REQUIRED_GSC_SCOPES = [GSC_SCOPE, INDEXING_SCOPE];
 async function resolveAccessToken(ctx) {
   if (!ctx.project) {
     return { ok: false, output: skippedNoProject4() };
@@ -42339,8 +42498,19 @@ var scopesCheck2 = {
       };
     }
     const granted = new Set(conn.scopes ?? []);
-    const missing = REQUIRED_GSC_SCOPES.filter((scope) => !granted.has(scope));
-    if (missing.length === 0) {
+    const hasFullGscScope = granted.has(GSC_SCOPE);
+    const hasReadOnlyGscScope = granted.has(GSC_READONLY_SCOPE);
+    const hasIndexingScope = granted.has(INDEXING_SCOPE);
+    if (!hasFullGscScope && !hasReadOnlyGscScope) {
+      return {
+        status: CheckStatuses.fail,
+        code: "google.auth.required-scope-missing",
+        summary: "Neither the full nor read-only Search Console scope is granted, so GSC reads will fail.",
+        remediation: `Reconnect to grant a Search Console scope: \`canonry google connect ${ctx.project.name} --type gsc\`.`,
+        details: { granted: [...granted], missing: [GSC_SCOPE, GSC_READONLY_SCOPE] }
+      };
+    }
+    if (hasFullGscScope && hasIndexingScope) {
       return {
         status: CheckStatuses.ok,
         code: "google.auth.scopes-ok",
@@ -42349,14 +42519,22 @@ var scopesCheck2 = {
         details: { granted: [...granted] }
       };
     }
-    const gscMissing = missing.includes(GSC_SCOPE);
-    const indexingOnlyMissing = !gscMissing && missing.includes(INDEXING_SCOPE) && missing.length === 1;
+    if (!hasFullGscScope) {
+      const missing = [GSC_SCOPE, ...hasIndexingScope ? [] : [INDEXING_SCOPE]];
+      return {
+        status: CheckStatuses.warn,
+        code: "google.auth.sitemap-write-scope-missing",
+        summary: hasIndexingScope ? "The read-only Search Console scope supports existing GSC reads, but sitemap submission is unavailable." : "The read-only Search Console scope supports existing GSC reads, but sitemap submission and the Indexing API are unavailable.",
+        remediation: `Reconnect to grant the full Search Console webmasters scope: \`canonry google connect ${ctx.project.name} --type gsc\`.`,
+        details: { granted: [...granted], missing }
+      };
+    }
     return {
-      status: indexingOnlyMissing ? CheckStatuses.warn : CheckStatuses.fail,
-      code: indexingOnlyMissing ? "google.auth.indexing-scope-missing" : "google.auth.required-scope-missing",
-      summary: indexingOnlyMissing ? "Indexing API scope is not granted \u2014 `canonry google request-indexing` will fail." : `Missing required scopes: ${missing.join(", ")}.`,
+      status: CheckStatuses.warn,
+      code: "google.auth.indexing-scope-missing",
+      summary: "Indexing API scope is not granted \u2014 `canonry google request-indexing` will fail.",
       remediation: `Reconnect to grant missing scopes: \`canonry google connect ${ctx.project.name} --type gsc\`.`,
-      details: { granted: [...granted], missing }
+      details: { granted: [...granted], missing: [INDEXING_SCOPE] }
     };
   }
 };