@ainyc/canonry 1.27.2 → 1.28.0

package/dist/{chunk-727N35MW.js → chunk-QXLGOYDJ.js}

@@ -19,6 +19,15 @@ function normalizeGoogleConfig(config) {
     scopes: connection.scopes ?? []
   }));
 }
+function normalizeWordpressConfig(config) {
+  if (!config.wordpress) return;
+  config.wordpress.connections = (config.wordpress.connections ?? []).map((connection) => ({
+    ...connection,
+    url: connection.url.replace(/\/$/, ""),
+    stagingUrl: connection.stagingUrl?.replace(/\/$/, ""),
+    defaultEnv: connection.defaultEnv ?? "live"
+  }));
+}
 function getConfigDir() {
   const override = process.env.CANONRY_CONFIG_DIR?.trim();
   if (override) {
@@ -63,6 +72,7 @@ Do not write config.yaml by hand; use "canonry init", "canonry settings", or "ca
     };
   }
   normalizeGoogleConfig(parsed);
+  normalizeWordpressConfig(parsed);
   const portOverride = process.env.CANONRY_PORT?.trim();
   if (portOverride) {
     try {
@@ -125,6 +135,36 @@ function saveConfig(config) {
   const yaml = stringify(merged);
   fs.writeFileSync(configPath, yaml, { encoding: "utf-8", mode: 384 });
 }
+function saveConfigPatch(patch) {
+  const configDir = getConfigDir();
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  const configPath = getConfigPath();
+  let base = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      const raw = fs.readFileSync(configPath, "utf-8");
+      base = parse(raw) ?? {};
+    } catch {
+      base = {};
+    }
+  }
+  const merged = { ...base, ...patch };
+  if (base.database) merged.database = base.database;
+  if (base.apiKey) merged.apiKey = base.apiKey;
+  if (base.anonymousId) merged.anonymousId = base.anonymousId;
+  if (base.dashboardPasswordHash) merged.dashboardPasswordHash = base.dashboardPasswordHash;
+  if (base.providers && patch.providers) {
+    merged.providers = { ...base.providers };
+    for (const [key, patchEntry] of Object.entries(patch.providers)) {
+      const baseEntry = base.providers[key] ?? {};
+      merged.providers[key] = { ...baseEntry, ...patchEntry };
+    }
+  }
+  const yaml = stringify(merged);
+  fs.writeFileSync(configPath, yaml, { encoding: "utf-8", mode: 384 });
+}
 function configExists() {
   return fs.existsSync(getConfigPath());
 }
@@ -155,7 +195,7 @@ function getOrCreateAnonymousId() {
     if (config.anonymousId) return config.anonymousId;
     const id = crypto.randomUUID();
     config.anonymousId = id;
-    saveConfig(config);
+    saveConfigPatch(config);
     return id;
   } catch {
     return void 0;
@@ -203,7 +243,7 @@ function trackEvent(event, properties) {
 
 // src/server.ts
 import { createRequire as createRequire2 } from "module";
-import crypto21 from "crypto";
+import crypto22 from "crypto";
 import fs5 from "fs";
 import path6 from "path";
 import { fileURLToPath } from "url";
@@ -439,6 +479,9 @@ function authRequired() {
 function authInvalid() {
   return new AppError("AUTH_INVALID", "Invalid API key", 401);
 }
+function providerError(message, details) {
+  return new AppError("PROVIDER_ERROR", message, 502, details);
+}
 function runInProgress(projectName) {
   return new AppError("RUN_IN_PROGRESS", `A run is already in progress for '${projectName}'`, 409);
 }
@@ -584,78 +627,179 @@ var bingSubmitResultDtoSchema = z6.object({
   error: z6.string().optional()
 });
 
-// ../contracts/src/run.ts
+// ../contracts/src/wordpress.ts
 import { z as z7 } from "zod";
-var runStatusSchema = z7.enum(["queued", "running", "completed", "partial", "failed", "cancelled"]);
-var runKindSchema = z7.enum(["answer-visibility", "site-audit", "gsc-sync", "inspect-sitemap"]);
-var runTriggerSchema = z7.enum(["manual", "scheduled", "config-apply"]);
-var citationStateSchema = z7.enum(["cited", "not-cited"]);
-var computedTransitionSchema = z7.enum(["new", "cited", "lost", "emerging", "not-cited"]);
-var runDtoSchema = z7.object({
-  id: z7.string(),
-  projectId: z7.string(),
+var wordpressEnvSchema = z7.enum(["live", "staging"]);
+var wordpressConnectionDtoSchema = z7.object({
+  projectName: z7.string(),
+  url: z7.string(),
+  stagingUrl: z7.string().optional(),
+  username: z7.string(),
+  defaultEnv: wordpressEnvSchema,
+  createdAt: z7.string(),
+  updatedAt: z7.string()
+});
+var wordpressSiteStatusDtoSchema = z7.object({
+  url: z7.string(),
+  reachable: z7.boolean(),
+  pageCount: z7.number().nullable().optional(),
+  version: z7.string().nullable().optional(),
+  error: z7.string().nullable().optional(),
+  plugins: z7.array(z7.string()).optional()
+});
+var wordpressStatusDtoSchema = z7.object({
+  connected: z7.boolean(),
+  projectName: z7.string(),
+  defaultEnv: wordpressEnvSchema,
+  live: wordpressSiteStatusDtoSchema.nullable(),
+  staging: wordpressSiteStatusDtoSchema.nullable(),
+  adminUrl: z7.string().nullable().optional()
+});
+var wordpressPageSummaryDtoSchema = z7.object({
+  id: z7.number(),
+  slug: z7.string(),
+  title: z7.string(),
+  status: z7.string(),
+  modifiedAt: z7.string().nullable().optional(),
+  link: z7.string().nullable().optional()
+});
+var wordpressSeoStateDtoSchema = z7.object({
+  title: z7.string().nullable(),
+  description: z7.string().nullable(),
+  noindex: z7.boolean().nullable(),
+  writable: z7.boolean().default(false),
+  writeTargets: z7.array(z7.string()).default([])
+});
+var wordpressSchemaBlockDtoSchema = z7.object({
+  type: z7.string(),
+  json: z7.record(z7.string(), z7.unknown())
+});
+var wordpressPageDetailDtoSchema = wordpressPageSummaryDtoSchema.extend({
+  env: wordpressEnvSchema,
+  content: z7.string(),
+  seo: wordpressSeoStateDtoSchema,
+  schemaBlocks: z7.array(wordpressSchemaBlockDtoSchema).default([])
+});
+var wordpressDiffPageDtoSchema = wordpressPageDetailDtoSchema.extend({
+  contentHash: z7.string(),
+  contentSnippet: z7.string()
+});
+var wordpressManualAssistDtoSchema = z7.object({
+  manualRequired: z7.literal(true),
+  targetUrl: z7.string(),
+  adminUrl: z7.string().nullable().optional(),
+  content: z7.string(),
+  nextSteps: z7.array(z7.string()).default([])
+});
+var wordpressAuditIssueDtoSchema = z7.object({
+  slug: z7.string(),
+  severity: z7.enum(["high", "medium", "low"]),
+  code: z7.enum([
+    "noindex",
+    "missing-seo-title",
+    "missing-meta-description",
+    "missing-schema",
+    "thin-content"
+  ]),
+  message: z7.string()
+});
+var wordpressAuditPageDtoSchema = z7.object({
+  slug: z7.string(),
+  title: z7.string(),
+  status: z7.string(),
+  wordCount: z7.number(),
+  seo: wordpressSeoStateDtoSchema,
+  schemaPresent: z7.boolean(),
+  issues: z7.array(wordpressAuditIssueDtoSchema).default([])
+});
+var wordpressDiffDtoSchema = z7.object({
+  slug: z7.string(),
+  live: wordpressDiffPageDtoSchema,
+  staging: wordpressDiffPageDtoSchema,
+  hasDifferences: z7.boolean(),
+  differences: z7.object({
+    title: z7.boolean(),
+    slug: z7.boolean(),
+    content: z7.boolean(),
+    seoTitle: z7.boolean(),
+    seoDescription: z7.boolean(),
+    noindex: z7.boolean(),
+    schema: z7.boolean()
+  })
+});
+
+// ../contracts/src/run.ts
+import { z as z8 } from "zod";
+var runStatusSchema = z8.enum(["queued", "running", "completed", "partial", "failed", "cancelled"]);
+var runKindSchema = z8.enum(["answer-visibility", "site-audit", "gsc-sync", "inspect-sitemap"]);
+var runTriggerSchema = z8.enum(["manual", "scheduled", "config-apply"]);
+var citationStateSchema = z8.enum(["cited", "not-cited"]);
+var computedTransitionSchema = z8.enum(["new", "cited", "lost", "emerging", "not-cited"]);
+var runDtoSchema = z8.object({
+  id: z8.string(),
+  projectId: z8.string(),
   kind: runKindSchema,
   status: runStatusSchema,
   trigger: runTriggerSchema.default("manual"),
-  location: z7.string().nullable().optional(),
-  startedAt: z7.string().nullable().optional(),
-  finishedAt: z7.string().nullable().optional(),
-  error: z7.string().nullable().optional(),
-  createdAt: z7.string()
+  location: z8.string().nullable().optional(),
+  startedAt: z8.string().nullable().optional(),
+  finishedAt: z8.string().nullable().optional(),
+  error: z8.string().nullable().optional(),
+  createdAt: z8.string()
 });
-var groundingSourceSchema = z7.object({
-  uri: z7.string(),
-  title: z7.string()
+var groundingSourceSchema = z8.object({
+  uri: z8.string(),
+  title: z8.string()
 });
-var querySnapshotDtoSchema = z7.object({
-  id: z7.string(),
-  runId: z7.string(),
-  keywordId: z7.string(),
-  keyword: z7.string().optional(),
+var querySnapshotDtoSchema = z8.object({
+  id: z8.string(),
+  runId: z8.string(),
+  keywordId: z8.string(),
+  keyword: z8.string().optional(),
   provider: providerNameSchema,
   citationState: citationStateSchema,
   transition: computedTransitionSchema.optional(),
-  answerText: z7.string().nullable().optional(),
-  citedDomains: z7.array(z7.string()).default([]),
-  competitorOverlap: z7.array(z7.string()).default([]),
-  groundingSources: z7.array(groundingSourceSchema).default([]),
-  searchQueries: z7.array(z7.string()).default([]),
-  model: z7.string().nullable().optional(),
-  location: z7.string().nullable().optional(),
-  createdAt: z7.string()
+  answerText: z8.string().nullable().optional(),
+  citedDomains: z8.array(z8.string()).default([]),
+  competitorOverlap: z8.array(z8.string()).default([]),
+  groundingSources: z8.array(groundingSourceSchema).default([]),
+  searchQueries: z8.array(z8.string()).default([]),
+  model: z8.string().nullable().optional(),
+  location: z8.string().nullable().optional(),
+  createdAt: z8.string()
 });
-var auditLogEntrySchema = z7.object({
-  id: z7.string(),
-  projectId: z7.string().nullable().optional(),
-  actor: z7.string(),
-  action: z7.string(),
-  entityType: z7.string(),
-  entityId: z7.string().nullable().optional(),
-  diff: z7.unknown().optional(),
-  createdAt: z7.string()
+var auditLogEntrySchema = z8.object({
+  id: z8.string(),
+  projectId: z8.string().nullable().optional(),
+  actor: z8.string(),
+  action: z8.string(),
+  entityType: z8.string(),
+  entityId: z8.string().nullable().optional(),
+  diff: z8.unknown().optional(),
+  createdAt: z8.string()
 });
 
 // ../contracts/src/schedule.ts
-import { z as z8 } from "zod";
-var scheduleDtoSchema = z8.object({
-  id: z8.string(),
-  projectId: z8.string(),
-  cronExpr: z8.string(),
-  preset: z8.string().nullable().optional(),
-  timezone: z8.string().default("UTC"),
-  enabled: z8.boolean().default(true),
-  providers: z8.array(providerNameSchema).default([]),
-  lastRunAt: z8.string().nullable().optional(),
-  nextRunAt: z8.string().nullable().optional(),
-  createdAt: z8.string(),
-  updatedAt: z8.string()
+import { z as z9 } from "zod";
+var scheduleDtoSchema = z9.object({
+  id: z9.string(),
+  projectId: z9.string(),
+  cronExpr: z9.string(),
+  preset: z9.string().nullable().optional(),
+  timezone: z9.string().default("UTC"),
+  enabled: z9.boolean().default(true),
+  providers: z9.array(providerNameSchema).default([]),
+  lastRunAt: z9.string().nullable().optional(),
+  nextRunAt: z9.string().nullable().optional(),
+  createdAt: z9.string(),
+  updatedAt: z9.string()
 });
-var scheduleUpsertRequestSchema = z8.object({
-  preset: z8.string().optional(),
-  cron: z8.string().optional(),
-  timezone: z8.string().optional().default("UTC"),
-  enabled: z8.boolean().optional().default(true),
-  providers: z8.array(providerNameSchema).optional().default([])
+var scheduleUpsertRequestSchema = z9.object({
+  preset: z9.string().optional(),
+  cron: z9.string().optional(),
+  timezone: z9.string().optional().default("UTC"),
+  enabled: z9.boolean().optional().default(true),
+  providers: z9.array(providerNameSchema).optional().default([])
 }).refine(
   (data) => data.preset && !data.cron || !data.preset && data.cron,
   { message: 'Exactly one of "preset" or "cron" must be provided' }
@@ -754,34 +898,34 @@ function categoryLabel(category) {
 }
 
 // ../contracts/src/ga.ts
-import { z as z9 } from "zod";
-var ga4ConnectionDtoSchema = z9.object({
-  id: z9.string(),
-  projectId: z9.string(),
-  propertyId: z9.string(),
-  clientEmail: z9.string(),
-  connected: z9.boolean(),
-  createdAt: z9.string(),
-  updatedAt: z9.string()
+import { z as z10 } from "zod";
+var ga4ConnectionDtoSchema = z10.object({
+  id: z10.string(),
+  projectId: z10.string(),
+  propertyId: z10.string(),
+  clientEmail: z10.string(),
+  connected: z10.boolean(),
+  createdAt: z10.string(),
+  updatedAt: z10.string()
 });
-var ga4TrafficSnapshotDtoSchema = z9.object({
-  date: z9.string(),
-  landingPage: z9.string(),
-  sessions: z9.number(),
-  organicSessions: z9.number(),
-  users: z9.number()
+var ga4TrafficSnapshotDtoSchema = z10.object({
+  date: z10.string(),
+  landingPage: z10.string(),
+  sessions: z10.number(),
+  organicSessions: z10.number(),
+  users: z10.number()
 });
-var ga4TrafficSummaryDtoSchema = z9.object({
-  totalSessions: z9.number(),
-  totalOrganicSessions: z9.number(),
-  totalUsers: z9.number(),
-  topPages: z9.array(z9.object({
-    landingPage: z9.string(),
-    sessions: z9.number(),
-    organicSessions: z9.number(),
-    users: z9.number()
+var ga4TrafficSummaryDtoSchema = z10.object({
+  totalSessions: z10.number(),
+  totalOrganicSessions: z10.number(),
+  totalUsers: z10.number(),
+  topPages: z10.array(z10.object({
+    landingPage: z10.string(),
+    sessions: z10.number(),
+    organicSessions: z10.number(),
+    users: z10.number()
   })),
-  lastSyncedAt: z9.string().nullable()
+  lastSyncedAt: z10.string().nullable()
 });
 
 // ../api-routes/src/auth.ts
@@ -3546,6 +3690,19 @@ var analyticsWindowParameter = {
   description: "Time window for analytics queries.",
   schema: { type: "string", enum: ["7d", "30d", "90d", "all"] }
 };
+var wordpressEnvQueryParameter = {
+  name: "env",
+  in: "query",
+  description: "WordPress environment to target.",
+  schema: { type: "string", enum: ["live", "staging"] }
+};
+var wordpressSlugQueryParameter = {
+  name: "slug",
+  in: "query",
+  required: true,
+  description: "WordPress page slug.",
+  schema: stringSchema
+};
 var routeCatalog = [
   {
     method: "get",
@@ -4897,6 +5054,301 @@ var routeCatalog = [
       404: { description: "Project not found." }
     }
   },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/wordpress/connect",
+    summary: "Connect WordPress REST access",
+    tags: ["wordpress"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["url", "username", "appPassword"],
+            properties: {
+              url: stringSchema,
+              stagingUrl: stringSchema,
+              username: stringSchema,
+              appPassword: stringSchema,
+              defaultEnv: { type: "string", enum: ["live", "staging"] }
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "WordPress connection status returned." },
+      400: { description: "Invalid WordPress connection request." },
+      404: { description: "Project not found." }
+    }
+  },
+  {
+    method: "delete",
+    path: "/api/v1/projects/{name}/wordpress/disconnect",
+    summary: "Disconnect WordPress",
+    tags: ["wordpress"],
+    parameters: [nameParameter],
+    responses: {
+      204: { description: "WordPress connection deleted." },
+      404: { description: "Project or connection not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/wordpress/status",
+    summary: "Get WordPress connection status",
+    tags: ["wordpress"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "WordPress status returned." },
+      404: { description: "Project not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/wordpress/pages",
+    summary: "List WordPress pages",
+    tags: ["wordpress"],
+    parameters: [nameParameter, wordpressEnvQueryParameter],
+    responses: {
+      200: { description: "WordPress pages returned." },
+      400: { description: "Invalid environment or missing connection." },
+      404: { description: "Project not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/wordpress/page",
+    summary: "Get a WordPress page by slug",
+    tags: ["wordpress"],
+    parameters: [nameParameter, wordpressSlugQueryParameter, wordpressEnvQueryParameter],
+    responses: {
+      200: { description: "WordPress page returned." },
+      400: { description: "Invalid slug or environment." },
+      404: { description: "Project, connection, or page not found." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/wordpress/pages",
+    summary: "Create a WordPress page",
+    tags: ["wordpress"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["title", "slug", "content"],
+            properties: {
+              title: stringSchema,
+              slug: stringSchema,
+              content: stringSchema,
+              status: stringSchema,
+              env: { type: "string", enum: ["live", "staging"] }
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "WordPress page created." },
+      400: { description: "Invalid page creation request." },
+      404: { description: "Project or connection not found." }
+    }
+  },
+  {
+    method: "put",
+    path: "/api/v1/projects/{name}/wordpress/page",
+    summary: "Update a WordPress page by slug",
+    tags: ["wordpress"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["currentSlug"],
+            properties: {
+              currentSlug: stringSchema,
+              title: stringSchema,
+              slug: stringSchema,
+              content: stringSchema,
+              status: stringSchema,
+              env: { type: "string", enum: ["live", "staging"] }
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "WordPress page updated." },
+      400: { description: "Invalid page update request." },
+      404: { description: "Project, connection, or page not found." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/wordpress/page/meta",
+    summary: "Update REST-exposed WordPress SEO meta",
+    tags: ["wordpress"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["slug"],
+            properties: {
+              slug: stringSchema,
+              title: stringSchema,
+              description: stringSchema,
+              noindex: booleanSchema,
+              env: { type: "string", enum: ["live", "staging"] }
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "WordPress SEO meta updated." },
+      400: { description: "SEO meta is unsupported or the request is invalid." },
+      404: { description: "Project, connection, or page not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/wordpress/schema",
+    summary: "Read rendered JSON-LD schema for a page",
+    tags: ["wordpress"],
+    parameters: [nameParameter, wordpressSlugQueryParameter, wordpressEnvQueryParameter],
+    responses: {
+      200: { description: "WordPress schema blocks returned." },
+      400: { description: "Invalid slug or environment." },
+      404: { description: "Project, connection, or page not found." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/wordpress/schema/manual",
+    summary: "Generate a manual schema update payload",
+    tags: ["wordpress"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["slug", "json"],
+            properties: {
+              slug: stringSchema,
+              type: stringSchema,
+              json: stringSchema,
+              env: { type: "string", enum: ["live", "staging"] }
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Manual schema instructions returned." },
+      400: { description: "Invalid schema request." },
+      404: { description: "Project, connection, or page not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/wordpress/llms-txt",
+    summary: "Read /llms.txt for a WordPress environment",
+    tags: ["wordpress"],
+    parameters: [nameParameter, wordpressEnvQueryParameter],
+    responses: {
+      200: { description: "llms.txt returned." },
+      400: { description: "Invalid environment or missing connection." },
+      404: { description: "Project not found." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/wordpress/llms-txt/manual",
+    summary: "Generate a manual llms.txt update payload",
+    tags: ["wordpress"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["content"],
+            properties: {
+              content: stringSchema,
+              env: { type: "string", enum: ["live", "staging"] }
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Manual llms.txt instructions returned." },
+      400: { description: "Invalid llms.txt request." },
+      404: { description: "Project or connection not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/wordpress/audit",
+    summary: "Audit WordPress pages for SEO and content issues",
+    tags: ["wordpress"],
+    parameters: [nameParameter, wordpressEnvQueryParameter],
+    responses: {
+      200: { description: "WordPress audit returned." },
+      400: { description: "Invalid environment or missing connection." },
+      404: { description: "Project not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/wordpress/diff",
+    summary: "Compare live and staging versions of a WordPress page",
+    tags: ["wordpress"],
+    parameters: [nameParameter, wordpressSlugQueryParameter],
+    responses: {
+      200: { description: "WordPress diff returned." },
+      400: { description: "Invalid slug or missing staging configuration." },
+      404: { description: "Project, connection, or page not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/wordpress/staging/status",
+    summary: "Get WordPress staging configuration status",
+    tags: ["wordpress"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "WordPress staging status returned." },
+      400: { description: "WordPress is not configured for this project." },
+      404: { description: "Project not found." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/wordpress/staging/push",
+    summary: "Generate a manual staging push handoff",
+    tags: ["wordpress"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "Manual staging push instructions returned." },
+      400: { description: "Missing staging configuration." },
+      404: { description: "Project or connection not found." }
+    }
+  },
   // GA4 routes
   {
     method: "post",
@@ -6086,17 +6538,22 @@ async function googleRoutes(app, opts) {
   app.get("/projects/:name/google/gsc/coverage", async (request) => {
     const project = resolveProject(app.db, request.params.name);
     const allInspections = app.db.select().from(gscUrlInspections).where(eq13(gscUrlInspections.projectId, project.id)).orderBy(desc4(gscUrlInspections.inspectedAt)).all();
+    const canonicalUrl = (url) => url.replace(/^http:\/\//, "https://");
     const latestByUrl = /* @__PURE__ */ new Map();
     const historyByUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
-      if (!latestByUrl.has(row.url)) {
-        latestByUrl.set(row.url, row);
-      }
-      const history = historyByUrl.get(row.url);
+      const key = canonicalUrl(row.url);
+      const existing = latestByUrl.get(key);
+      if (!existing) {
+        latestByUrl.set(key, row);
+      } else if (existing.url.startsWith("http://") && row.url.startsWith("https://")) {
+        latestByUrl.set(key, row);
+      }
+      const history = historyByUrl.get(key);
       if (history) {
         history.push(row);
       } else {
-        historyByUrl.set(row.url, [row]);
+        historyByUrl.set(key, [row]);
       }
     }
     const indexedUrls = [];
@@ -6636,10 +7093,22 @@ async function bingRoutes(app, opts) {
     if (!conn) return;
     const allInspections = app.db.select().from(bingUrlInspections).where(eq14(bingUrlInspections.projectId, project.id)).orderBy(desc5(bingUrlInspections.inspectedAt)).all();
     const latestByUrl = /* @__PURE__ */ new Map();
+    const definitiveByUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
       if (!latestByUrl.has(row.url)) {
         latestByUrl.set(row.url, row);
       }
+      if (!definitiveByUrl.has(row.url) && row.inIndex != null) {
+        definitiveByUrl.set(row.url, row);
+      }
+    }
+    for (const [url, latest] of latestByUrl) {
+      if (latest.inIndex == null) {
+        const definitive = definitiveByUrl.get(url);
+        if (definitive) {
+          latestByUrl.set(url, definitive);
+        }
+      }
     }
     const indexedUrls = [];
     const notIndexedUrls = [];
@@ -7569,22 +8038,1001 @@ async function ga4Routes(app, opts) {
   });
 }
 
-// ../api-routes/src/index.ts
-async function apiRoutes(app, opts) {
-  app.decorate("db", opts.db);
-  app.setErrorHandler((error, _request, reply) => {
-    if (error instanceof AppError) {
-      return reply.status(error.statusCode).send(error.toJSON());
-    }
-    const httpStatus = error.statusCode ?? error.status ?? 500;
-    if (httpStatus >= 400 && httpStatus < 500) {
-      return reply.status(httpStatus).send({
-        error: {
-          code: httpStatus === 401 ? "AUTH_INVALID" : httpStatus === 403 ? "FORBIDDEN" : httpStatus === 404 ? "NOT_FOUND" : httpStatus === 429 ? "QUOTA_EXCEEDED" : "VALIDATION_ERROR",
-          message: error.message
-        }
-      });
-    }
+// ../integration-wordpress/src/types.ts
+var WordpressApiError = class extends Error {
+  statusCode;
+  code;
+  constructor(code, message, statusCode) {
+    super(message);
+    this.name = "WordpressApiError";
+    this.code = code;
+    this.statusCode = statusCode;
+  }
+};
+
+// ../integration-wordpress/src/wordpress-client.ts
+import crypto17 from "crypto";
+var PAGE_FIELDS = "id,slug,status,link,modified,modified_gmt,title,content,meta";
+var PAGE_LIST_FIELDS = "id,slug,status,link,modified,modified_gmt,title";
+var VERIFY_PAGE_FIELDS = "id,status";
+var SEO_TARGETS = [
+  {
+    pluginHints: ["wordpress-seo", "yoast"],
+    titleKey: "_yoast_wpseo_title",
+    descriptionKey: "_yoast_wpseo_metadesc",
+    noindexKey: "_yoast_wpseo_meta-robots-noindex"
+  },
+  {
+    pluginHints: ["all-in-one-seo-pack", "aioseo"],
+    titleKey: "_aioseo_title",
+    descriptionKey: "_aioseo_description",
+    noindexKey: "_aioseo_noindex"
+  },
+  {
+    pluginHints: ["seo-by-rank-math", "rank-math"],
+    titleKey: "rank_math_title",
+    descriptionKey: "rank_math_description",
+    noindexKey: "rank_math_robots"
+  }
+];
+var THIN_CONTENT_WORD_COUNT = 250;
+function normalizeSiteUrl(url) {
+  return url.replace(/\/$/, "");
+}
+function encodeBasicAuth(username, appPassword) {
+  return Buffer.from(`${username}:${appPassword}`).toString("base64");
+}
+async function fetchJson(connection, siteUrl, path7, init) {
+  const res = await fetch(`${normalizeSiteUrl(siteUrl)}${path7}`, {
+    ...init,
+    headers: {
+      "Authorization": `Basic ${encodeBasicAuth(connection.username, connection.appPassword)}`,
+      ...init?.body != null ? { "Content-Type": "application/json" } : {},
+      ...init?.headers ?? {}
+    }
+  });
+  if (res.status === 401 || res.status === 403) {
+    throw new WordpressApiError("AUTH_INVALID", "WordPress credentials are invalid or lack permission for this action", res.status);
+  }
+  if (res.status === 404) {
+    throw new WordpressApiError("NOT_FOUND", "WordPress endpoint not found", 404);
+  }
+  if (!res.ok) {
+    const text2 = await res.text().catch(() => "");
+    throw new WordpressApiError("UPSTREAM_ERROR", `WordPress API error (${res.status}): ${text2 || res.statusText}`, res.status);
+  }
+  return {
+    body: await res.json(),
+    response: res
+  };
+}
+async function fetchPageCollectionSummary(connection, siteUrl, options) {
+  const params = new URLSearchParams({
+    per_page: "1",
+    _fields: VERIFY_PAGE_FIELDS
+  });
+  if (options?.context) {
+    params.set("context", options.context);
+  }
+  const { response } = await fetchJson(
+    connection,
+    siteUrl,
+    `/wp-json/wp/v2/pages?${params.toString()}`
+  );
+  return response;
+}
+async function fetchText(url) {
+  try {
+    const res = await fetch(url);
+    if (!res.ok) return null;
+    return await res.text();
+  } catch {
+    return null;
+  }
+}
+function stripHtml(input) {
+  return input.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&quot;/gi, '"').replace(/&#39;/gi, "'").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/\s+/g, " ").trim();
+}
+function extractMetaContent(html, name) {
+  const patterns = [
+    new RegExp(`<meta[^>]+name=["']${name}["'][^>]+content=["']([^"']*)["'][^>]*>`, "i"),
+    new RegExp(`<meta[^>]+content=["']([^"']*)["'][^>]+name=["']${name}["'][^>]*>`, "i")
+  ];
+  for (const pattern of patterns) {
+    const match = pattern.exec(html);
+    if (match?.[1] != null) return match[1].trim() || null;
+  }
+  return null;
+}
+function extractTitle(html) {
+  const match = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
+  return match?.[1] ? stripHtml(match[1]) || null : null;
+}
+function extractGeneratorVersion(html) {
+  const generator = extractMetaContent(html, "generator");
+  if (!generator) return null;
+  const match = /WordPress\s+([0-9][^ ]*)/i.exec(generator);
+  return match?.[1] ?? generator;
+}
+function extractSchemaBlocks(html) {
+  const blocks = [];
+  const regex = /<script[^>]+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+  let match;
+  while ((match = regex.exec(html)) !== null) {
+    const raw = match[1]?.trim();
+    if (!raw) continue;
+    try {
+      const parsed = JSON.parse(raw);
+      const items = Array.isArray(parsed) ? parsed : [parsed];
+      for (const item of items) {
+        const type = typeof item["@type"] === "string" ? String(item["@type"]) : Array.isArray(item["@type"]) ? String(item["@type"][0] ?? "Unknown") : "Unknown";
+        blocks.push({
+          type,
+          json: item
+        });
+      }
+    } catch {
+      continue;
+    }
+  }
+  return blocks;
+}
+function summarizeSeoFromHtml(html) {
+  const description = extractMetaContent(html, "description");
+  const robots = extractMetaContent(html, "robots");
+  return {
+    title: extractTitle(html),
+    description,
+    noindex: robots == null ? null : /\bnoindex\b/i.test(robots)
+  };
+}
+function computeWordCount(content) {
+  const clean = stripHtml(content);
+  if (!clean) return 0;
+  return clean.split(/\s+/).filter(Boolean).length;
+}
+function buildSnippet(content) {
+  const text2 = stripHtml(content);
+  if (text2.length <= 160) return text2;
+  return `${text2.slice(0, 157)}...`;
+}
+function contentHash(content) {
+  return crypto17.createHash("sha256").update(content).digest("hex");
+}
+function buildAmbiguousSlugMessage(slug, pages) {
+  const candidates = pages.map((page) => {
+    const title = stripHtml(page.title?.rendered ?? "") || "(untitled)";
+    return `#${page.id} "${title}"`;
+  }).join(", ");
+  return `Multiple pages matched slug "${slug}". Candidates: ${candidates}.`;
+}
+async function mapWithConcurrency(items, limit, iteratee) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  async function worker() {
+    while (nextIndex < items.length) {
+      const index2 = nextIndex;
+      nextIndex += 1;
+      results[index2] = await iteratee(items[index2], index2);
+    }
+  }
+  const workerCount = Math.max(1, Math.min(limit, items.length));
+  await Promise.all(Array.from({ length: workerCount }, () => worker()));
+  return results;
+}
+function resolveSeoWriteTargets(meta, plugins) {
+  if (!meta) return [];
+  const keys = new Set(Object.keys(meta));
+  const pluginList = plugins ?? [];
+  const targets = [];
+  for (const target of SEO_TARGETS) {
+    const hinted = target.pluginHints.some((hint) => pluginList.some((plugin) => plugin.includes(hint)));
+    if (!hinted && !keys.has(target.titleKey) && !keys.has(target.descriptionKey) && !keys.has(target.noindexKey)) {
+      continue;
+    }
+    if (keys.has(target.titleKey)) targets.push(target.titleKey);
+    if (keys.has(target.descriptionKey)) targets.push(target.descriptionKey);
+    if (keys.has(target.noindexKey)) targets.push(target.noindexKey);
+  }
+  return [...new Set(targets)];
+}
+function buildSeoState(page, html, plugins) {
+  const renderedSeo = html ? summarizeSeoFromHtml(html) : { title: null, description: null, noindex: null };
+  const writeTargets = resolveSeoWriteTargets(page.meta, plugins);
+  return {
+    title: renderedSeo.title,
+    description: renderedSeo.description,
+    noindex: renderedSeo.noindex,
+    writable: writeTargets.length > 0,
+    writeTargets
+  };
+}
+function resolveEnvironment(connection, requestedEnv) {
+  const env = requestedEnv ?? connection.defaultEnv;
+  if (env === "staging") {
+    if (!connection.stagingUrl) {
+      throw new WordpressApiError("VALIDATION_ERROR", "No staging URL configured for this project. Reconnect with --staging-url or use --live.", 400);
+    }
+    return { env, siteUrl: normalizeSiteUrl(connection.stagingUrl) };
+  }
+  return { env: "live", siteUrl: normalizeSiteUrl(connection.url) };
+}
+function getWpStagingAdminUrl(url) {
+  return `${normalizeSiteUrl(url)}/wp-admin/admin.php?page=wpstg_clone`;
+}
+async function verifyWordpressConnection(connection) {
+  const site = resolveEnvironment({ ...connection, defaultEnv: "live" }, "live");
+  const response = await fetchPageCollectionSummary(connection, site.siteUrl, { context: "view" });
+  const homeHtml = await fetchText(site.siteUrl);
+  return {
+    url: site.siteUrl,
+    reachable: true,
+    pageCount: Number.parseInt(response.headers.get("x-wp-total") ?? "0", 10) || 0,
+    version: homeHtml ? extractGeneratorVersion(homeHtml) : null,
+    plugins: []
+  };
+}
+async function getSiteStatus(connection, env) {
+  const site = resolveEnvironment(connection, env);
+  try {
+    const response = await fetchPageCollectionSummary(connection, site.siteUrl, { context: "view" });
+    const homeHtml = await fetchText(site.siteUrl);
+    const plugins = await listActivePlugins(connection, env);
+    return {
+      url: site.siteUrl,
+      reachable: true,
+      pageCount: Number.parseInt(response.headers.get("x-wp-total") ?? "0", 10) || 0,
+      version: homeHtml ? extractGeneratorVersion(homeHtml) : null,
+      plugins: plugins ?? []
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      url: site.siteUrl,
+      reachable: false,
+      pageCount: null,
+      version: null,
+      error: message,
+      plugins: []
+    };
+  }
+}
+async function listActivePlugins(connection, env) {
+  const site = resolveEnvironment(connection, env);
+  try {
+    const { body } = await fetchJson(
+      connection,
+      site.siteUrl,
+      "/wp-json/wp/v2/plugins?per_page=100&_fields=plugin,status"
+    );
+    return body.filter((plugin) => plugin.status === "active").map((plugin) => plugin.plugin).sort();
+  } catch (error) {
+    if (error instanceof WordpressApiError && (error.statusCode === 403 || error.statusCode === 404)) {
+      return null;
+    }
+    return null;
+  }
+}
+async function listPages(connection, env) {
+  const site = resolveEnvironment(connection, env);
+  const pages = [];
+  let page = 1;
+  let totalPages = 1;
+  while (page <= totalPages) {
+    const { body, response } = await fetchJson(
+      connection,
+      site.siteUrl,
+      `/wp-json/wp/v2/pages?per_page=100&page=${page}&context=edit&_fields=${PAGE_LIST_FIELDS}`
+    );
+    totalPages = Number.parseInt(response.headers.get("x-wp-totalpages") ?? "1", 10) || 1;
+    pages.push(...body.map((entry) => ({
+      id: entry.id,
+      slug: entry.slug,
+      title: stripHtml(entry.title?.rendered ?? ""),
+      status: entry.status,
+      modifiedAt: entry.modified ?? entry.modified_gmt ?? null,
+      link: entry.link ?? null
+    })));
+    page += 1;
+  }
+  return pages;
+}
+async function getPageBySlug(connection, slug, env) {
+  const site = resolveEnvironment(connection, env);
+  const { body } = await fetchJson(
+    connection,
+    site.siteUrl,
+    `/wp-json/wp/v2/pages?slug=${encodeURIComponent(slug)}&per_page=100&context=edit&_fields=${PAGE_FIELDS}`
+  );
+  if (body.length === 0) {
+    throw new WordpressApiError("NOT_FOUND", `No WordPress page found for slug "${slug}"`, 404);
+  }
+  const exact = body.filter((page) => page.slug === slug);
+  if (exact.length === 1) return exact[0];
+  if (exact.length > 1) {
+    throw new WordpressApiError("VALIDATION_ERROR", buildAmbiguousSlugMessage(slug, exact), 400);
+  }
+  if (body.length > 1) {
+    throw new WordpressApiError("VALIDATION_ERROR", buildAmbiguousSlugMessage(slug, body), 400);
+  }
+  return body[0];
+}
+async function fetchRenderedPage(link) {
+  if (!link) return null;
+  return fetchText(link);
+}
+async function getPageDetail(connection, slug, env, plugins) {
+  const site = resolveEnvironment(connection, env);
+  const resolvedPlugins = plugins === void 0 ? await listActivePlugins(connection, site.env) : plugins;
+  const page = await getPageBySlug(connection, slug, site.env);
+  const html = await fetchRenderedPage(page.link);
+  const schemaBlocks = html ? extractSchemaBlocks(html) : [];
+  const seo = buildSeoState(page, html, resolvedPlugins);
+  return {
+    id: page.id,
+    slug: page.slug,
+    title: stripHtml(page.title?.rendered ?? ""),
+    status: page.status,
+    modifiedAt: page.modified ?? page.modified_gmt ?? null,
+    link: page.link ?? null,
+    env: site.env,
+    content: page.content?.raw ?? page.content?.rendered ?? "",
+    seo,
+    schemaBlocks
+  };
+}
+async function createPage(connection, body, env) {
+  const site = resolveEnvironment(connection, env);
+  const { body: created } = await fetchJson(
+    connection,
+    site.siteUrl,
+    "/wp-json/wp/v2/pages",
+    {
+      method: "POST",
+      body: JSON.stringify({
+        title: body.title,
+        slug: body.slug,
+        content: body.content,
+        status: body.status ?? "draft"
+      })
+    }
+  );
+  return getPageDetail(connection, created.slug, site.env);
+}
+async function updatePageBySlug(connection, slug, body, env) {
+  const site = resolveEnvironment(connection, env);
+  const page = await getPageBySlug(connection, slug, site.env);
+  const { body: updated } = await fetchJson(
+    connection,
+    site.siteUrl,
+    `/wp-json/wp/v2/pages/${page.id}`,
+    {
+      method: "POST",
+      body: JSON.stringify(body)
+    }
+  );
+  return getPageDetail(connection, updated.slug, site.env);
+}
+function encodeNoindexValue(key, value) {
+  if (key === "rank_math_robots") {
+    return value ? ["noindex"] : ["index"];
+  }
+  return value ? "1" : "0";
+}
+async function setSeoMeta(connection, slug, body, env) {
+  const site = resolveEnvironment(connection, env);
+  const plugins = await listActivePlugins(connection, site.env);
+  const page = await getPageBySlug(connection, slug, site.env);
+  const writeTargets = resolveSeoWriteTargets(page.meta, plugins);
+  if (writeTargets.length === 0 || !page.meta) {
+    throw new WordpressApiError("UNSUPPORTED", "This WordPress site does not expose writable SEO meta fields through REST. Update the meta manually in WordPress.", 400);
+  }
+  const patch = {};
+  for (const target of SEO_TARGETS) {
+    if (body.title != null && writeTargets.includes(target.titleKey)) patch[target.titleKey] = body.title;
+    if (body.description != null && writeTargets.includes(target.descriptionKey)) patch[target.descriptionKey] = body.description;
+    if (body.noindex != null && writeTargets.includes(target.noindexKey)) {
+      patch[target.noindexKey] = encodeNoindexValue(target.noindexKey, body.noindex);
+    }
+  }
+  if (Object.keys(patch).length === 0) {
+    throw new WordpressApiError("UNSUPPORTED", "No writable REST-exposed SEO fields matched the requested update.", 400);
+  }
+  await fetchJson(
+    connection,
+    site.siteUrl,
+    `/wp-json/wp/v2/pages/${page.id}`,
+    {
+      method: "POST",
+      body: JSON.stringify({
+        meta: {
+          ...page.meta ?? {},
+          ...patch
+        }
+      })
+    }
+  );
+  return getPageDetail(connection, slug, site.env, plugins);
+}
+async function getLlmsTxt(connection, env) {
+  const site = resolveEnvironment(connection, env);
+  const url = `${site.siteUrl}/llms.txt`;
+  return {
+    env: site.env,
+    url,
+    content: await fetchText(url)
+  };
+}
+async function buildManualLlmsTxtUpdate(connection, content, env) {
+  const site = resolveEnvironment(connection, env);
+  return {
+    manualRequired: true,
+    targetUrl: `${site.siteUrl}/llms.txt`,
+    adminUrl: `${site.siteUrl}/wp-admin/`,
+    content,
+    nextSteps: [
+      `Open your hosting file manager or SSH session for ${site.siteUrl}.`,
+      "Create or update the file llms.txt at the site root.",
+      "Paste the generated content exactly as provided.",
+      "Reload /llms.txt in a browser to confirm the file is publicly reachable."
+    ]
+  };
+}
+async function getPageSchema(connection, slug, env) {
+  const detail = await getPageDetail(connection, slug, env);
+  return {
+    env: detail.env,
+    slug: detail.slug,
+    blocks: detail.schemaBlocks
+  };
+}
+async function buildManualSchemaUpdate(connection, slug, body, env) {
+  const site = resolveEnvironment(connection, env);
+  const page = await getPageBySlug(connection, slug, site.env);
+  return {
+    manualRequired: true,
+    targetUrl: page.link ?? `${site.siteUrl}/${slug}`,
+    adminUrl: `${site.siteUrl}/wp-admin/`,
+    content: body.json,
+    nextSteps: [
+      `Open the WordPress editor or theme/plugin settings for ${page.slug}.`,
+      `Add the ${body.type ?? "custom"} JSON-LD block to the page or the site-level schema tool you use.`,
+      "Publish/update the page and refresh the public URL to confirm the JSON-LD block is rendered."
+    ]
+  };
+}
+async function runAudit(connection, env) {
+  const site = resolveEnvironment(connection, env);
+  const pages = await listPages(connection, site.env);
+  const plugins = await listActivePlugins(connection, site.env);
+  const details = await mapWithConcurrency(
+    pages,
+    5,
+    async (page) => getPageDetail(connection, page.slug, site.env, plugins)
+  );
+  const auditPages = [];
+  const allIssues = [];
+  for (const page of details) {
+    const issues = [];
+    const wordCount = computeWordCount(page.content);
+    const schemaPresent = page.schemaBlocks.length > 0;
+    if (page.status === "publish" && page.seo.noindex === true) {
+      issues.push({
+        slug: page.slug,
+        severity: "high",
+        code: "noindex",
+        message: "Published page is marked noindex."
+      });
+    }
+    if (!page.seo.title) {
+      issues.push({
+        slug: page.slug,
+        severity: "medium",
+        code: "missing-seo-title",
+        message: "Rendered page title is missing."
+      });
+    }
+    if (!page.seo.description) {
+      issues.push({
+        slug: page.slug,
+        severity: "medium",
+        code: "missing-meta-description",
+        message: "Rendered meta description is missing."
+      });
+    }
+    if (!schemaPresent) {
+      issues.push({
+        slug: page.slug,
+        severity: "medium",
+        code: "missing-schema",
+        message: "No JSON-LD schema was detected on the rendered page."
+      });
+    }
+    if (wordCount < THIN_CONTENT_WORD_COUNT) {
+      issues.push({
+        slug: page.slug,
+        severity: "low",
+        code: "thin-content",
+        message: `Page content is thin (${wordCount} words; target at least ${THIN_CONTENT_WORD_COUNT}).`
+      });
+    }
+    auditPages.push({
+      slug: page.slug,
+      title: page.title,
+      status: page.status,
+      wordCount,
+      seo: page.seo,
+      schemaPresent,
+      issues
+    });
+    allIssues.push(...issues);
+  }
+  const severityWeight = { high: 0, medium: 1, low: 2 };
+  allIssues.sort((a, b) => {
+    return severityWeight[a.severity] - severityWeight[b.severity] || a.slug.localeCompare(b.slug);
+  });
+  return {
+    env: site.env,
+    pages: auditPages,
+    issues: allIssues
+  };
+}
+async function diffPageAcrossEnvironments(connection, slug) {
+  if (!connection.stagingUrl) {
+    throw new WordpressApiError("VALIDATION_ERROR", "No staging URL configured for this project. Reconnect with --staging-url before using diff.", 400);
+  }
+  const [livePlugins, stagingPlugins] = await Promise.all([
+    listActivePlugins(connection, "live"),
+    listActivePlugins(connection, "staging")
+  ]);
+  const live = await getPageDetail(connection, slug, "live", livePlugins);
+  const staging = await getPageDetail(connection, slug, "staging", stagingPlugins);
+  const liveContentHash = contentHash(live.content);
+  const stagingContentHash = contentHash(staging.content);
+  const liveDiff = {
+    ...live,
+    contentHash: liveContentHash,
+    contentSnippet: buildSnippet(live.content)
+  };
+  const stagingDiff = {
+    ...staging,
+    contentHash: stagingContentHash,
+    contentSnippet: buildSnippet(staging.content)
+  };
+  const differences = {
+    title: live.title !== staging.title,
+    slug: live.slug !== staging.slug,
+    content: liveContentHash !== stagingContentHash,
+    seoTitle: live.seo.title !== staging.seo.title,
+    seoDescription: live.seo.description !== staging.seo.description,
+    noindex: live.seo.noindex !== staging.seo.noindex,
+    schema: JSON.stringify(live.schemaBlocks) !== JSON.stringify(staging.schemaBlocks)
+  };
+  return {
+    slug,
+    live: liveDiff,
+    staging: stagingDiff,
+    hasDifferences: Object.values(differences).some(Boolean),
+    differences
+  };
+}
+async function buildManualStagingPush(connection) {
+  const liveStatus = await getSiteStatus(connection, "live");
+  const plugins = liveStatus.plugins ?? [];
+  const wpStagingActive = plugins.some((plugin) => plugin.includes("wp-staging"));
+  return {
+    manualRequired: true,
+    targetUrl: getWpStagingAdminUrl(connection.url),
+    adminUrl: getWpStagingAdminUrl(connection.url),
+    content: JSON.stringify({
+      liveUrl: connection.url,
+      stagingUrl: connection.stagingUrl ?? null,
+      wpStagingActive
+    }, null, 2),
+    nextSteps: [
+      "Open the WP STAGING admin page on the live site.",
+      wpStagingActive ? "Review the staging site snapshot you want to push and use the plugin UI to start the push-to-live workflow." : "Confirm the WP STAGING plugin is installed and active before attempting a push-to-live operation.",
+      "Complete the plugin confirmation steps in wp-admin and verify the live site after the push finishes."
+    ]
+  };
+}
+function parseEnv(value) {
+  if (typeof value !== "string") return void 0;
+  const parsed = wordpressEnvSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+
+// ../api-routes/src/wordpress.ts
+function parseEnvInput(value, fieldName = "env") {
+  const env = parseEnv(value);
+  if (!env && value != null) {
+    throw validationError(`${fieldName} must be "live" or "staging"`);
+  }
+  return env;
+}
+function sendWordpressError(reply, error) {
+  if (!(error instanceof WordpressApiError)) return false;
+  let appError;
+  switch (error.code) {
+    case "AUTH_INVALID":
+      appError = new AppError("AUTH_INVALID", error.message, error.statusCode);
+      break;
+    case "NOT_FOUND":
+      appError = new AppError("NOT_FOUND", error.message, error.statusCode);
+      break;
+    case "UPSTREAM_ERROR":
+      appError = providerError(error.message, { statusCode: error.statusCode });
+      break;
+    case "UNSUPPORTED":
+    case "VALIDATION_ERROR":
+      appError = validationError(error.message);
+      break;
+    default:
+      appError = providerError(error.message, { statusCode: error.statusCode });
+      break;
+  }
+  reply.status(appError.statusCode).send(appError.toJSON());
+  return true;
+}
+async function withWordpressErrorHandling(reply, handler) {
+  try {
+    return await handler();
+  } catch (error) {
+    if (sendWordpressError(reply, error)) return;
+    throw error;
+  }
+}
+async function wordpressRoutes(app, opts) {
+  function requireStore(reply) {
+    if (opts.wordpressConnectionStore) return opts.wordpressConnectionStore;
+    const err = validationError("WordPress connection storage is not configured for this deployment");
+    reply.status(err.statusCode).send(err.toJSON());
+    return null;
+  }
+  function requireConnection(store, projectName, reply) {
+    const connection = store.getConnection(projectName);
+    if (!connection) {
+      const err = validationError(`No WordPress connection found for project "${projectName}". Run "canonry wordpress connect ${projectName}" first.`);
+      reply.status(err.statusCode).send(err.toJSON());
+      return null;
+    }
+    return connection;
+  }
+  app.post("/projects/:name/wordpress/connect", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const { url, stagingUrl, username, appPassword } = request.body ?? {};
+      if (!url || !username || !appPassword) {
+        const err = validationError("url, username, and appPassword are required");
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      const defaultEnv = parseEnvInput(request.body?.defaultEnv, "defaultEnv") ?? (stagingUrl ? "staging" : "live");
+      if (defaultEnv === "staging" && !stagingUrl) {
+        const err = validationError('defaultEnv "staging" requires stagingUrl');
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const existing = store.getConnection(project.name);
+      const nextConnection = {
+        projectName: project.name,
+        url,
+        stagingUrl,
+        username,
+        appPassword,
+        defaultEnv,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now
+      };
+      await verifyWordpressConnection(nextConnection);
+      const connection = store.upsertConnection(nextConnection);
+      const live = await getSiteStatus(connection, "live");
+      const staging = connection.stagingUrl ? await getSiteStatus(connection, "staging") : null;
+      writeAuditLog(app.db, {
+        projectId: project.id,
+        actor: "api",
+        action: "wordpress.connected",
+        entityType: "wordpress_connection",
+        entityId: project.name
+      });
+      return {
+        connected: true,
+        projectName: project.name,
+        defaultEnv: connection.defaultEnv,
+        live,
+        staging,
+        adminUrl: getWpStagingAdminUrl(connection.url)
+      };
+    });
+  });
+  app.delete("/projects/:name/wordpress/disconnect", async (request, reply) => {
+    const store = requireStore(reply);
+    if (!store) return;
+    const project = resolveProject(app.db, request.params.name);
+    const deleted = store.deleteConnection(project.name);
+    if (!deleted) {
+      const err = notFound("WordPress connection", project.name);
+      return reply.status(err.statusCode).send(err.toJSON());
+    }
+    writeAuditLog(app.db, {
+      projectId: project.id,
+      actor: "api",
+      action: "wordpress.disconnected",
+      entityType: "wordpress_connection",
+      entityId: project.name
+    });
+    return reply.status(204).send();
+  });
+  app.get("/projects/:name/wordpress/status", async (request) => {
+    const project = resolveProject(app.db, request.params.name);
+    const connection = opts.wordpressConnectionStore?.getConnection(project.name);
+    if (!connection) {
+      return {
+        connected: false,
+        projectName: project.name,
+        defaultEnv: "live",
+        live: null,
+        staging: null,
+        adminUrl: null
+      };
+    }
+    const live = await getSiteStatus(connection, "live");
+    const staging = connection.stagingUrl ? await getSiteStatus(connection, "staging") : null;
+    return {
+      connected: true,
+      projectName: project.name,
+      defaultEnv: connection.defaultEnv,
+      live,
+      staging,
+      adminUrl: getWpStagingAdminUrl(connection.url)
+    };
+  });
+  app.get("/projects/:name/wordpress/pages", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const connection = requireConnection(store, project.name, reply);
+      if (!connection) return;
+      const env = parseEnvInput(request.query?.env);
+      return {
+        env: env ?? connection.defaultEnv,
+        pages: await listPages(connection, env)
+      };
+    });
+  });
+  app.get("/projects/:name/wordpress/page", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const connection = requireConnection(store, project.name, reply);
+      if (!connection) return;
+      const slug = request.query?.slug?.trim();
+      if (!slug) {
+        const err = validationError("slug is required");
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      const env = parseEnvInput(request.query?.env);
+      return getPageDetail(connection, slug, env);
+    });
+  });
+  app.post("/projects/:name/wordpress/pages", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const connection = requireConnection(store, project.name, reply);
+      if (!connection) return;
+      const { title, slug, content, status } = request.body ?? {};
+      const env = parseEnvInput(request.body?.env);
+      if (!title || !slug || !content) {
+        const err = validationError("title, slug, and content are required");
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      const created = await createPage(connection, { title, slug, content, status }, env);
+      writeAuditLog(app.db, {
+        projectId: project.id,
+        actor: "api",
+        action: "wordpress.page-created",
+        entityType: "wordpress_page",
+        entityId: created.slug
+      });
+      return created;
+    });
+  });
+  app.put("/projects/:name/wordpress/page", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const connection = requireConnection(store, project.name, reply);
+      if (!connection) return;
+      const currentSlug = request.body?.currentSlug?.trim();
+      if (!currentSlug) {
+        const err = validationError("currentSlug is required");
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      const env = parseEnvInput(request.body?.env);
+      const updated = await updatePageBySlug(connection, currentSlug, {
+        title: request.body?.title,
+        slug: request.body?.slug,
+        content: request.body?.content,
+        status: request.body?.status
+      }, env);
+      writeAuditLog(app.db, {
+        projectId: project.id,
+        actor: "api",
+        action: "wordpress.page-updated",
+        entityType: "wordpress_page",
+        entityId: currentSlug
+      });
+      return updated;
+    });
+  });
+  app.post("/projects/:name/wordpress/page/meta", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const connection = requireConnection(store, project.name, reply);
+      if (!connection) return;
+      const slug = request.body?.slug?.trim();
+      if (!slug) {
+        const err = validationError("slug is required");
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      const env = parseEnvInput(request.body?.env);
+      const updated = await setSeoMeta(connection, slug, {
+        title: request.body?.title,
+        description: request.body?.description,
+        noindex: request.body?.noindex
+      }, env);
+      writeAuditLog(app.db, {
+        projectId: project.id,
+        actor: "api",
+        action: "wordpress.page-meta-updated",
+        entityType: "wordpress_page",
+        entityId: slug
+      });
+      return updated;
+    });
+  });
+  app.get("/projects/:name/wordpress/schema", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const connection = requireConnection(store, project.name, reply);
+      if (!connection) return;
+      const slug = request.query?.slug?.trim();
+      if (!slug) {
+        const err = validationError("slug is required");
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      const env = parseEnvInput(request.query?.env);
+      return getPageSchema(connection, slug, env);
+    });
+  });
+  app.post("/projects/:name/wordpress/schema/manual", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const connection = requireConnection(store, project.name, reply);
+      if (!connection) return;
+      const slug = request.body?.slug?.trim();
+      const json = request.body?.json;
+      if (!slug || !json) {
+        const err = validationError("slug and json are required");
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      const env = parseEnvInput(request.body?.env);
+      return buildManualSchemaUpdate(connection, slug, { type: request.body?.type, json }, env);
+    });
+  });
+  app.get("/projects/:name/wordpress/llms-txt", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const connection = requireConnection(store, project.name, reply);
+      if (!connection) return;
+      const env = parseEnvInput(request.query?.env);
+      return getLlmsTxt(connection, env);
+    });
+  });
+  app.post("/projects/:name/wordpress/llms-txt/manual", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const connection = requireConnection(store, project.name, reply);
+      if (!connection) return;
+      const content = request.body?.content;
+      if (!content) {
+        const err = validationError("content is required");
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      const env = parseEnvInput(request.body?.env);
+      return buildManualLlmsTxtUpdate(connection, content, env);
+    });
+  });
+  app.get("/projects/:name/wordpress/audit", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const connection = requireConnection(store, project.name, reply);
+      if (!connection) return;
+      const env = parseEnvInput(request.query?.env);
+      return runAudit(connection, env);
+    });
+  });
+  app.get("/projects/:name/wordpress/diff", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const connection = requireConnection(store, project.name, reply);
+      if (!connection) return;
+      const slug = request.query?.slug?.trim();
+      if (!slug) {
+        const err = validationError("slug is required");
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      return diffPageAcrossEnvironments(connection, slug);
+    });
+  });
+  app.get("/projects/:name/wordpress/staging/status", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const connection = requireConnection(store, project.name, reply);
+      if (!connection) return;
+      const plugins = await listActivePlugins(connection, "live");
+      return {
+        stagingConfigured: Boolean(connection.stagingUrl),
+        stagingUrl: connection.stagingUrl ?? null,
+        wpStagingActive: Boolean(plugins?.some((plugin) => plugin.includes("wp-staging"))),
+        adminUrl: getWpStagingAdminUrl(connection.url)
+      };
+    });
+  });
+  app.post("/projects/:name/wordpress/staging/push", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const connection = requireConnection(store, project.name, reply);
+      if (!connection) return;
+      if (!connection.stagingUrl) {
+        const err = validationError("No staging URL configured for this project. Reconnect with --staging-url before using staging push.");
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      return buildManualStagingPush(connection);
+    });
+  });
+}
+
+// ../api-routes/src/index.ts
+async function apiRoutes(app, opts) {
+  app.decorate("db", opts.db);
+  app.setErrorHandler((error, _request, reply) => {
+    if (error instanceof AppError) {
+      return reply.status(error.statusCode).send(error.toJSON());
+    }
+    const httpStatus = error.statusCode ?? error.status ?? 500;
+    if (httpStatus >= 400 && httpStatus < 500) {
+      return reply.status(httpStatus).send({
+        error: {
+          code: httpStatus === 401 ? "AUTH_INVALID" : httpStatus === 403 ? "FORBIDDEN" : httpStatus === 404 ? "NOT_FOUND" : httpStatus === 429 ? "QUOTA_EXCEEDED" : "VALIDATION_ERROR",
+          message: error.message
+        }
+      });
+    }
     app.log.error(error);
     return reply.status(500).send({
       error: {
@@ -7655,6 +9103,9 @@ async function apiRoutes(app, opts) {
       onGscSyncRequested: opts.onGscSyncRequested,
       onInspectSitemapRequested: opts.onInspectSitemapRequested
     });
+    await api.register(wordpressRoutes, {
+      wordpressConnectionStore: opts.wordpressConnectionStore
+    });
     await api.register(cdpRoutes, {
       getCdpStatus: opts.getCdpStatus,
       onCdpScreenshot: opts.onCdpScreenshot,
@@ -7667,8 +9118,7 @@ async function apiRoutes(app, opts) {
 }
 
 // ../provider-gemini/src/normalize.ts
-import { GoogleGenerativeAI } from "@google/generative-ai";
-import { VertexAI } from "@google-cloud/vertexai";
+import { GoogleGenAI } from "@google/genai";
 var DEFAULT_MODEL = "gemini-3-flash";
 var VALIDATION_PATTERN = /^gemini-/;
 function isVertexConfig(config) {
@@ -7684,31 +9134,16 @@ function resolveModel(config) {
   );
   return DEFAULT_MODEL;
 }
-function wrapVertexResponse(response) {
-  return {
-    text: () => {
-      const parts = response.candidates?.[0]?.content?.parts;
-      return parts?.map((p) => p.text ?? "").join("") ?? "";
-    },
-    candidates: response.candidates?.map((c) => ({
-      content: c.content,
-      finishReason: c.finishReason,
-      groundingMetadata: c.groundingMetadata
-    })),
-    usageMetadata: response.usageMetadata
-  };
-}
-function createVertexModel(config, model, tools) {
-  const vertexOpts = {
-    project: config.vertexProject,
-    location: config.vertexRegion || "us-central1",
-    googleAuthOptions: config.vertexCredentials ? { keyFilename: config.vertexCredentials } : void 0
-  };
-  const vertexAI = new VertexAI(vertexOpts);
-  return vertexAI.getGenerativeModel({
-    model,
-    ...tools ? { tools } : {}
-  });
+function createClient2(config) {
+  if (isVertexConfig(config)) {
+    return new GoogleGenAI({
+      vertexai: true,
+      project: config.vertexProject,
+      location: config.vertexRegion || "us-central1",
+      ...config.vertexCredentials ? { googleAuthOptions: { keyFilename: config.vertexCredentials } } : {}
+    });
+  }
+  return new GoogleGenAI({ apiKey: config.apiKey });
 }
 function validateConfig(config) {
   if (isVertexConfig(config)) {
@@ -7737,28 +9172,19 @@ async function healthcheck(config) {
   if (!validation.ok) return validation;
   try {
     const model = resolveModel(config);
-    if (isVertexConfig(config)) {
-      const generativeModel = createVertexModel(config, model);
-      const result = await generativeModel.generateContent('Say "ok"');
-      const text2 = result.response.candidates?.[0]?.content?.parts?.map((p) => p.text ?? "").join("") ?? "";
-      return {
-        ok: text2.length > 0,
-        provider: "gemini",
-        message: text2.length > 0 ? "gemini vertex ai verified" : "empty response from gemini vertex ai",
-        model
-      };
-    } else {
-      const genAI = new GoogleGenerativeAI(config.apiKey);
-      const generativeModel = genAI.getGenerativeModel({ model });
-      const result = await generativeModel.generateContent('Say "ok"');
-      const text2 = result.response.text();
-      return {
-        ok: text2.length > 0,
-        provider: "gemini",
-        message: text2.length > 0 ? "gemini api key verified" : "empty response from gemini",
-        model
-      };
-    }
+    const client = createClient2(config);
+    const result = await client.models.generateContent({
+      model,
+      contents: 'Say "ok"'
+    });
+    const text2 = result.text ?? "";
+    const backend = isVertexConfig(config) ? "vertex ai" : "api key";
+    return {
+      ok: text2.length > 0,
+      provider: "gemini",
+      message: text2.length > 0 ? `gemini ${backend} verified` : `empty response from gemini ${backend}`,
+      model
+    };
   } catch (err) {
     return {
       ok: false,
@@ -7771,40 +9197,23 @@ async function healthcheck(config) {
 async function executeTrackedQuery(input) {
   const model = resolveModel(input.config);
   const prompt = buildPrompt(input.keyword, input.location);
-  if (isVertexConfig(input.config)) {
-    const vertexSearchTool = { googleSearchRetrieval: {} };
-    const generativeModel = createVertexModel(input.config, model, [vertexSearchTool]);
-    const result = await generativeModel.generateContent(prompt);
-    const response = result.response;
-    const unified = wrapVertexResponse(response);
-    const groundingMetadata = extractGroundingMetadataFromUnified(unified);
-    const searchQueries = extractSearchQueriesFromUnified(unified);
-    return {
-      provider: "gemini",
-      rawResponse: unifiedToRecord(unified),
-      model,
-      groundingSources: groundingMetadata,
-      searchQueries
-    };
-  } else {
-    const searchTool = { googleSearch: {} };
-    const genAI = new GoogleGenerativeAI(input.config.apiKey);
-    const generativeModel = genAI.getGenerativeModel({
-      model,
-      tools: [searchTool]
-    });
-    const result = await generativeModel.generateContent(prompt);
-    const response = result.response;
-    const groundingMetadata = extractGroundingMetadata(response);
-    const searchQueries = extractSearchQueries(response);
-    return {
-      provider: "gemini",
-      rawResponse: responseToRecord(response),
-      model,
-      groundingSources: groundingMetadata,
-      searchQueries
-    };
-  }
+  const client = createClient2(input.config);
+  const result = await client.models.generateContent({
+    model,
+    contents: prompt,
+    config: {
+      tools: [{ googleSearch: {} }]
+    }
+  });
+  const groundingSources = extractGroundingMetadata(result);
+  const searchQueries = extractSearchQueries(result);
+  return {
+    provider: "gemini",
+    rawResponse: responseToRecord(result),
+    model,
+    groundingSources,
+    searchQueries
+  };
 }
 function normalizeResult(raw) {
   const answerText = extractAnswerText(raw.rawResponse);
@@ -7850,22 +9259,6 @@ function extractGroundingMetadata(response) {
     return [];
   }
 }
-function extractGroundingMetadataFromUnified(response) {
-  try {
-    const candidate = response.candidates?.[0];
-    if (!candidate) return [];
-    const metadata = candidate.groundingMetadata;
-    if (!metadata) return [];
-    const chunks = metadata.groundingChunks;
-    if (!chunks) return [];
-    return chunks.filter((chunk) => chunk.web?.uri).map((chunk) => ({
-      uri: chunk.web.uri,
-      title: chunk.web?.title ?? ""
-    }));
-  } catch {
-    return [];
-  }
-}
 function extractSearchQueries(response) {
   try {
     const candidate = response.candidates?.[0];
@@ -7874,14 +9267,6 @@ function extractSearchQueries(response) {
     return [];
   }
 }
-function extractSearchQueriesFromUnified(response) {
-  try {
-    const candidate = response.candidates?.[0];
-    return candidate?.groundingMetadata?.webSearchQueries ?? [];
-  } catch {
-    return [];
-  }
-}
 function extractCitedDomains(raw) {
   const domains = /* @__PURE__ */ new Set();
   for (const source of raw.groundingSources) {
@@ -7929,16 +9314,12 @@ function extractDomainFromUri(uri) {
 }
 async function generateText(prompt, config) {
   const model = resolveModel(config);
-  if (isVertexConfig(config)) {
-    const generativeModel = createVertexModel(config, model);
-    const result = await generativeModel.generateContent(prompt);
-    return result.response.candidates?.[0]?.content?.parts?.map((p) => p.text ?? "").join("") ?? "";
-  } else {
-    const genAI = new GoogleGenerativeAI(config.apiKey);
-    const generativeModel = genAI.getGenerativeModel({ model });
-    const result = await generativeModel.generateContent(prompt);
-    return result.response.text();
-  }
+  const client = createClient2(config);
+  const result = await client.models.generateContent({
+    model,
+    contents: prompt
+  });
+  return result.text ?? "";
 }
 function responseToRecord(response) {
   try {
@@ -7958,24 +9339,6 @@ function responseToRecord(response) {
     return { error: "failed to serialize response" };
   }
 }
-function unifiedToRecord(response) {
-  try {
-    const candidates = response.candidates?.map((c) => ({
-      content: c.content,
-      finishReason: c.finishReason,
-      groundingMetadata: c.groundingMetadata ? {
-        webSearchQueries: c.groundingMetadata.webSearchQueries,
-        groundingChunks: c.groundingMetadata.groundingChunks
-      } : void 0
-    }));
-    return {
-      candidates: candidates ?? [],
-      usageMetadata: response.usageMetadata ?? null
-    };
-  } catch {
-    return { error: "failed to serialize response" };
-  }
-}
 
 // ../provider-gemini/src/adapter.ts
 function toGeminiConfig(config) {
@@ -9648,8 +11011,59 @@ function removeGa4Connection(config, projectName) {
   return true;
 }
 
+// src/wordpress-config.ts
+function ensureConnections3(config) {
+  if (!config.wordpress) config.wordpress = {};
+  if (!config.wordpress.connections) config.wordpress.connections = [];
+  return config.wordpress.connections;
+}
+function normalizeConnection(connection) {
+  return {
+    ...connection,
+    url: connection.url.replace(/\/$/, ""),
+    stagingUrl: connection.stagingUrl?.replace(/\/$/, ""),
+    defaultEnv: connection.defaultEnv ?? "live"
+  };
+}
+function getWordpressConnection(config, projectName) {
+  return (config.wordpress?.connections ?? []).find((connection) => connection.projectName === projectName);
+}
+function upsertWordpressConnection(config, connection) {
+  const connections = ensureConnections3(config);
+  const normalized = normalizeConnection(connection);
+  const index2 = connections.findIndex((entry) => entry.projectName === connection.projectName);
+  if (index2 === -1) {
+    connections.push(normalized);
+    return normalized;
+  }
+  connections[index2] = normalized;
+  return normalized;
+}
+function patchWordpressConnection(config, projectName, patch) {
+  const existing = getWordpressConnection(config, projectName);
+  if (!existing) return void 0;
+  return upsertWordpressConnection(config, {
+    ...existing,
+    ...patch,
+    stagingUrl: Object.prototype.hasOwnProperty.call(patch, "stagingUrl") ? patch.stagingUrl : existing.stagingUrl,
+    defaultEnv: patch.defaultEnv ?? existing.defaultEnv ?? "live"
+  });
+}
+function removeWordpressConnection(config, projectName) {
+  const connections = config.wordpress?.connections;
+  if (!connections?.length) return false;
+  const next = connections.filter((connection) => connection.projectName !== projectName);
+  if (next.length === connections.length) return false;
+  if (!config.wordpress) return false;
+  config.wordpress.connections = next;
+  if (next.length === 0) {
+    delete config.wordpress;
+  }
+  return true;
+}
+
 // src/job-runner.ts
-import crypto17 from "crypto";
+import crypto18 from "crypto";
 import fs4 from "fs";
 import path5 from "path";
 import os4 from "os";
@@ -9892,7 +11306,7 @@ var JobRunner = class {
             const overlap = computeCompetitorOverlap(normalized, competitorDomains);
             let screenshotRelPath = null;
             if (raw.screenshotPath && fs4.existsSync(raw.screenshotPath)) {
-              const snapshotId = crypto17.randomUUID();
+              const snapshotId = crypto18.randomUUID();
               const screenshotDir = path5.join(os4.homedir(), ".canonry", "screenshots", runId);
               if (!fs4.existsSync(screenshotDir)) fs4.mkdirSync(screenshotDir, { recursive: true });
               const destPath = path5.join(screenshotDir, `${snapshotId}.png`);
@@ -9920,7 +11334,7 @@ var JobRunner = class {
               }).run();
             } else {
               this.db.insert(querySnapshots).values({
-                id: crypto17.randomUUID(),
+                id: crypto18.randomUUID(),
                 runId,
                 keywordId: kw.id,
                 provider: providerName,
@@ -10029,7 +11443,7 @@ var JobRunner = class {
   incrementUsage(scope, metric, count) {
     const now = /* @__PURE__ */ new Date();
     const period = now.toISOString().slice(0, 10);
-    const id = crypto17.randomUUID();
+    const id = crypto18.randomUUID();
     const existing = this.db.select().from(usageCounters).where(eq17(usageCounters.scope, scope)).all().find((r) => r.period === period && r.metric === metric);
     if (existing) {
       this.db.update(usageCounters).set({ count: existing.count + count, updatedAt: now.toISOString() }).where(eq17(usageCounters.id, existing.id)).run();
@@ -10154,7 +11568,7 @@ function computeCompetitorOverlap(normalized, competitorDomains) {
 }
 
 // src/gsc-sync.ts
-import crypto18 from "crypto";
+import crypto19 from "crypto";
 import { eq as eq18, and as and8, sql as sql4 } from "drizzle-orm";
 var log2 = createLogger("GscSync");
 function formatDate2(d) {
@@ -10194,7 +11608,7 @@ async function executeGscSync(db, runId, projectId, opts) {
         tokenExpiresAt: new Date(Date.now() + tokens.expires_in * 1e3).toISOString(),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
-      saveConfig(opts.config);
+      saveConfigPatch(opts.config);
     }
     const lagOffset = GSC_DATA_LAG_DAYS;
     const endDate = formatDate2(daysAgo(lagOffset));
@@ -10220,7 +11634,7 @@ async function executeGscSync(db, runId, projectId, opts) {
       for (const row of batch) {
         const [query, page, country, device, date] = row.keys;
         db.insert(gscSearchData).values({
-          id: crypto18.randomUUID(),
+          id: crypto19.randomUUID(),
           projectId,
           syncRunId: runId,
           date: date ?? "",
@@ -10254,7 +11668,7 @@ async function executeGscSync(db, runId, projectId, opts) {
         const rich = ir.richResultsResult;
         const inspectedAt = (/* @__PURE__ */ new Date()).toISOString();
         db.insert(gscUrlInspections).values({
-          id: crypto18.randomUUID(),
+          id: crypto19.randomUUID(),
           projectId,
           syncRunId: runId,
           url: pageUrl,
@@ -10298,7 +11712,7 @@ async function executeGscSync(db, runId, projectId, opts) {
     const snapshotDate = formatDate2(/* @__PURE__ */ new Date());
     db.delete(gscCoverageSnapshots).where(and8(eq18(gscCoverageSnapshots.projectId, projectId), eq18(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
-      id: crypto18.randomUUID(),
+      id: crypto19.randomUUID(),
       projectId,
       syncRunId: runId,
       date: snapshotDate,
@@ -10318,7 +11732,7 @@ async function executeGscSync(db, runId, projectId, opts) {
 }
 
 // src/gsc-inspect-sitemap.ts
-import crypto19 from "crypto";
+import crypto20 from "crypto";
 import { eq as eq19, and as and9 } from "drizzle-orm";
 
 // src/sitemap-parser.ts
@@ -10415,7 +11829,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
         tokenExpiresAt: new Date(Date.now() + tokens.expires_in * 1e3).toISOString(),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
-      saveConfig(opts.config);
+      saveConfigPatch(opts.config);
     }
     const sitemapUrl = opts.sitemapUrl || conn.sitemapUrl || `https://${project.canonicalDomain}/sitemap.xml`;
     log3.info("sitemap.fetch", { runId, projectId, sitemapUrl });
@@ -10435,7 +11849,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
         const rich = ir.richResultsResult;
         const inspectedAt = (/* @__PURE__ */ new Date()).toISOString();
         db.insert(gscUrlInspections).values({
-          id: crypto19.randomUUID(),
+          id: crypto20.randomUUID(),
           projectId,
           syncRunId: runId,
           url: pageUrl,
@@ -10485,7 +11899,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
     const snapshotDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     db.delete(gscCoverageSnapshots).where(and9(eq19(gscCoverageSnapshots.projectId, projectId), eq19(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
-      id: crypto19.randomUUID(),
+      id: crypto20.randomUUID(),
       projectId,
       syncRunId: runId,
       date: snapshotDate,
@@ -10677,7 +12091,7 @@ var Scheduler = class {
 
 // src/notifier.ts
 import { eq as eq21, desc as desc7, and as and10, or as or2 } from "drizzle-orm";
-import crypto20 from "crypto";
+import crypto21 from "crypto";
 var log5 = createLogger("Notifier");
 var Notifier = class {
   db;
@@ -10817,7 +12231,7 @@ var Notifier = class {
   }
   logDelivery(projectId, notificationId, event, status, error) {
     this.db.insert(auditLog).values({
-      id: crypto20.randomUUID(),
+      id: crypto21.randomUUID(),
       projectId,
       actor: "scheduler",
       action: `notification.${status}`,
@@ -10915,14 +12329,14 @@ async function fetchSiteText(domain) {
       if (!redirectCheck.ok) return "";
       const redirectResult = await fetchWithPinnedAddress(redirectCheck.target);
       if (redirectResult.startsWith("REDIRECT:")) return "";
-      return stripHtml(redirectResult);
+      return stripHtml2(redirectResult);
     }
-    return stripHtml(result);
+    return stripHtml2(result);
   } catch {
     return "";
   }
 }
-function stripHtml(html) {
+function stripHtml2(html) {
   if (!html) return "";
   let text2 = html.replace(/<script[\s\S]*?<\/script>/gi, " ");
   text2 = text2.replace(/<style[\s\S]*?<\/style>/gi, " ");
@@ -10974,7 +12388,7 @@ function summarizeProviderConfig(provider, config) {
   };
 }
 function hashApiKey(key) {
-  return crypto21.createHash("sha256").update(key).digest("hex");
+  return crypto22.createHash("sha256").update(key).digest("hex");
 }
 function parseCookies2(header) {
   if (!header) return {};
@@ -11111,14 +12525,14 @@ async function createServer(opts) {
       } else {
         opts.config.bing.connections.push(connection);
       }
-      saveConfig(opts.config);
+      saveConfigPatch(opts.config);
       return connection;
     },
     updateConnection: (domain, patch) => {
       const conn = opts.config.bing?.connections?.find((c) => c.domain === domain);
       if (!conn) return void 0;
       Object.assign(conn, patch);
-      saveConfig(opts.config);
+      saveConfigPatch(opts.config);
       return conn;
     },
     deleteConnection: (domain) => {
@@ -11126,7 +12540,7 @@ async function createServer(opts) {
       const idx = opts.config.bing.connections.findIndex((c) => c.domain === domain);
       if (idx < 0) return false;
       opts.config.bing.connections.splice(idx, 1);
-      saveConfig(opts.config);
+      saveConfigPatch(opts.config);
       return true;
     }
   };
@@ -11136,32 +12550,52 @@ async function createServer(opts) {
     },
     upsertConnection: (connection) => {
       const updated = upsertGa4Connection(opts.config, connection);
-      saveConfig(opts.config);
+      saveConfigPatch(opts.config);
       return updated;
     },
     deleteConnection: (projectName) => {
       const removed = removeGa4Connection(opts.config, projectName);
-      if (removed) saveConfig(opts.config);
+      if (removed) saveConfigPatch(opts.config);
       return removed;
     }
   };
-  const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto21.randomBytes(32).toString("hex");
+  const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto22.randomBytes(32).toString("hex");
   const googleConnectionStore = {
     listConnections: (domain) => listGoogleConnections(opts.config, domain),
     getConnection: (domain, connectionType) => getGoogleConnection(opts.config, domain, connectionType),
     upsertConnection: (connection) => {
       const updated = upsertGoogleConnection(opts.config, connection);
-      saveConfig(opts.config);
+      saveConfigPatch(opts.config);
       return updated;
     },
     updateConnection: (domain, connectionType, patch) => {
       const updated = patchGoogleConnection(opts.config, domain, connectionType, patch);
-      if (updated) saveConfig(opts.config);
+      if (updated) saveConfigPatch(opts.config);
       return updated;
     },
     deleteConnection: (domain, connectionType) => {
       const removed = removeGoogleConnection(opts.config, domain, connectionType);
-      if (removed) saveConfig(opts.config);
+      if (removed) saveConfigPatch(opts.config);
+      return removed;
+    }
+  };
+  const wordpressConnectionStore = {
+    getConnection: (projectName) => {
+      return getWordpressConnection(opts.config, projectName);
+    },
+    upsertConnection: (connection) => {
+      const updated = upsertWordpressConnection(opts.config, connection);
+      saveConfigPatch(opts.config);
+      return updated;
+    },
+    updateConnection: (projectName, patch) => {
+      const updated = patchWordpressConnection(opts.config, projectName, patch);
+      if (updated) saveConfigPatch(opts.config);
+      return updated;
+    },
+    deleteConnection: (projectName) => {
+      const removed = removeWordpressConnection(opts.config, projectName);
+      if (removed) saveConfigPatch(opts.config);
       return removed;
     }
   };
@@ -11175,7 +12609,7 @@ async function createServer(opts) {
     if (!existing) {
       const prefix = opts.config.apiKey.slice(0, 12);
       opts.db.insert(apiKeys).values({
-        id: `key_${crypto21.randomBytes(8).toString("hex")}`,
+        id: `key_${crypto22.randomBytes(8).toString("hex")}`,
         name: "default",
         keyHash,
         keyPrefix: prefix,
@@ -11199,7 +12633,7 @@ async function createServer(opts) {
   };
   const createSession = (apiKeyId) => {
     pruneExpiredSessions();
-    const sessionId = crypto21.randomBytes(32).toString("hex");
+    const sessionId = crypto22.randomBytes(32).toString("hex");
     sessions.set(sessionId, {
       apiKeyId,
       expiresAt: Date.now() + SESSION_TTL_MS
@@ -11256,7 +12690,7 @@ async function createServer(opts) {
       return reply.status(err.statusCode).send(err.toJSON());
     }
     opts.config.dashboardPasswordHash = hashApiKey(password);
-    saveConfig(opts.config);
+    saveConfigPatch(opts.config);
     if (!createPasswordSession(reply)) {
       const err = authInvalid();
       return reply.status(err.statusCode).send(err.toJSON());
@@ -11362,6 +12796,7 @@ async function createServer(opts) {
     googleSettingsSummary,
     bingSettingsSummary,
     bingConnectionStore,
+    wordpressConnectionStore,
     ga4CredentialStore,
     onRunCreated: (runId, projectId, providers2, location) => {
       jobRunner.executeRun(runId, projectId, providers2, location).catch((err) => {
@@ -11387,7 +12822,7 @@ async function createServer(opts) {
         vertexCredentials: existing?.vertexCredentials
       };
       try {
-        saveConfig(opts.config);
+        saveConfigPatch(opts.config);
       } catch (err) {
         app.log.error({ err }, "Failed to save config");
         return null;
@@ -11429,7 +12864,7 @@ async function createServer(opts) {
         const targetProjectIds = affectedProjectIds.length > 0 ? affectedProjectIds : [null];
         const createdAt = (/* @__PURE__ */ new Date()).toISOString();
         opts.db.insert(auditLog).values(targetProjectIds.map((projectId) => ({
-          id: crypto21.randomUUID(),
+          id: crypto22.randomUUID(),
           projectId,
           actor: "api",
           action: existing ? "provider.updated" : "provider.created",
@@ -11449,7 +12884,7 @@ async function createServer(opts) {
     onGoogleSettingsUpdate: (clientId, clientSecret) => {
       try {
         setGoogleAuthConfig(opts.config, { clientId, clientSecret });
-        saveConfig(opts.config);
+        saveConfigPatch(opts.config);
         googleSettingsSummary.configured = true;
         return { ...googleSettingsSummary };
       } catch (err) {
@@ -11461,7 +12896,7 @@ async function createServer(opts) {
       try {
         if (!opts.config.bing) opts.config.bing = {};
         opts.config.bing.apiKey = apiKey;
-        saveConfig(opts.config);
+        saveConfigPatch(opts.config);
         bingSettingsSummary.configured = true;
         return { ...bingSettingsSummary };
       } catch (err) {
@@ -11488,7 +12923,7 @@ async function createServer(opts) {
     setTelemetryEnabled: (enabled) => {
       const config = loadConfig();
       config.telemetry = enabled;
-      saveConfig(config);
+      saveConfigPatch(config);
       opts.config.telemetry = enabled;
     },
     onCdpConfigure: async (host, port2) => {
@@ -11496,7 +12931,7 @@ async function createServer(opts) {
       opts.config.cdp.host = host;
       opts.config.cdp.port = port2;
       try {
-        saveConfig(opts.config);
+        saveConfigPatch(opts.config);
       } catch (err) {
         app.log.error({ err }, "Failed to save CDP config");
         throw err;
@@ -11673,6 +13108,7 @@ export {
   getConfigPath,
   loadConfig,
   saveConfig,
+  saveConfigPatch,
   configExists,
   isTelemetryEnabled,
   getOrCreateAnonymousId,