@ainyc/canonry 1.29.0 → 1.30.0

package/dist/{chunk-IWUQVYU3.js → chunk-LMSO32GF.js}

@@ -716,6 +716,49 @@ var wordpressAuditPageDtoSchema = z7.object({
   schemaPresent: z7.boolean(),
   issues: z7.array(wordpressAuditIssueDtoSchema).default([])
 });
+var wordpressBulkMetaEntryResultDtoSchema = z7.object({
+  slug: z7.string(),
+  status: z7.enum(["applied", "skipped", "manual"]),
+  error: z7.string().optional(),
+  manualAssist: wordpressManualAssistDtoSchema.optional()
+});
+var wordpressBulkMetaResultDtoSchema = z7.object({
+  env: wordpressEnvSchema,
+  strategy: z7.enum(["plugin", "manual"]),
+  results: z7.array(wordpressBulkMetaEntryResultDtoSchema)
+});
+var wordpressSchemaDeployEntryResultDtoSchema = z7.object({
+  slug: z7.string(),
+  status: z7.enum(["deployed", "stripped", "skipped", "failed"]),
+  schemasInjected: z7.array(z7.string()).optional(),
+  manualAssist: wordpressManualAssistDtoSchema.optional(),
+  error: z7.string().optional()
+});
+var wordpressSchemaDeployResultDtoSchema = z7.object({
+  env: wordpressEnvSchema,
+  results: z7.array(wordpressSchemaDeployEntryResultDtoSchema)
+});
+var wordpressSchemaStatusPageDtoSchema = z7.object({
+  slug: z7.string(),
+  title: z7.string(),
+  canonrySchemas: z7.array(z7.string()),
+  thirdPartySchemas: z7.array(z7.string()),
+  hasCanonrySchema: z7.boolean()
+});
+var wordpressSchemaStatusResultDtoSchema = z7.object({
+  env: wordpressEnvSchema,
+  pages: z7.array(wordpressSchemaStatusPageDtoSchema)
+});
+var wordpressOnboardStepDtoSchema = z7.object({
+  name: z7.string(),
+  status: z7.enum(["completed", "skipped", "failed"]),
+  summary: z7.string().optional(),
+  error: z7.string().optional()
+});
+var wordpressOnboardResultDtoSchema = z7.object({
+  projectName: z7.string(),
+  steps: z7.array(wordpressOnboardStepDtoSchema)
+});
 var wordpressDiffDtoSchema = z7.object({
   slug: z7.string(),
   live: wordpressDiffPageDtoSchema,
@@ -766,6 +809,7 @@ var querySnapshotDtoSchema = z8.object({
   answerText: z8.string().nullable().optional(),
   citedDomains: z8.array(z8.string()).default([]),
   competitorOverlap: z8.array(z8.string()).default([]),
+  recommendedCompetitors: z8.array(z8.string()).default([]),
   groundingSources: z8.array(groundingSourceSchema).default([]),
   searchQueries: z8.array(z8.string()).default([]),
   model: z8.string().nullable().optional(),
@@ -1004,6 +1048,12 @@ var ga4TrafficSnapshotDtoSchema = z11.object({
   organicSessions: z11.number(),
   users: z11.number()
 });
+var ga4AiReferralDtoSchema = z11.object({
+  source: z11.string(),
+  medium: z11.string(),
+  sessions: z11.number(),
+  users: z11.number()
+});
 var ga4TrafficSummaryDtoSchema = z11.object({
   totalSessions: z11.number(),
   totalOrganicSessions: z11.number(),
@@ -1014,6 +1064,7 @@ var ga4TrafficSummaryDtoSchema = z11.object({
     organicSessions: z11.number(),
     users: z11.number()
   })),
+  aiReferrals: z11.array(ga4AiReferralDtoSchema),
   lastSyncedAt: z11.string().nullable()
 });
 
@@ -1036,6 +1087,7 @@ __export(schema_exports, {
   bingKeywordStats: () => bingKeywordStats,
   bingUrlInspections: () => bingUrlInspections,
   competitors: () => competitors,
+  gaAiReferrals: () => gaAiReferrals,
   gaConnections: () => gaConnections,
   gaTrafficSnapshots: () => gaTrafficSnapshots,
   gaTrafficSummaries: () => gaTrafficSummaries,
@@ -1113,6 +1165,7 @@ var querySnapshots = sqliteTable("query_snapshots", {
   answerText: text("answer_text"),
   citedDomains: text("cited_domains").notNull().default("[]"),
   competitorOverlap: text("competitor_overlap").notNull().default("[]"),
+  recommendedCompetitors: text("recommended_competitors").notNull().default("[]"),
   location: text("location"),
   screenshotPath: text("screenshot_path"),
   rawResponse: text("raw_response"),
@@ -1306,6 +1359,20 @@ var gaTrafficSnapshots = sqliteTable("ga_traffic_snapshots", {
   index("idx_ga_traffic_project_date").on(table.projectId, table.date),
   index("idx_ga_traffic_page").on(table.landingPage)
 ]);
+var gaAiReferrals = sqliteTable("ga_ai_referrals", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+  date: text("date").notNull(),
+  source: text("source").notNull(),
+  medium: text("medium").notNull(),
+  sessions: integer("sessions").notNull().default(0),
+  users: integer("users").notNull().default(0),
+  syncedAt: text("synced_at").notNull()
+}, (table) => [
+  index("idx_ga_ai_ref_project_date").on(table.projectId, table.date),
+  index("idx_ga_ai_ref_source").on(table.source),
+  uniqueIndex("idx_ga_ai_ref_unique").on(table.projectId, table.date, table.source, table.medium)
+]);
 var gaTrafficSummaries = sqliteTable("ga_traffic_summaries", {
   id: text("id").primaryKey(),
   projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
@@ -1635,7 +1702,23 @@ var MIGRATIONS = [
   // v15: Bing URL inspections — document_size, anchor_count, discovery_date columns
   `ALTER TABLE bing_url_inspections ADD COLUMN document_size INTEGER`,
   `ALTER TABLE bing_url_inspections ADD COLUMN anchor_count INTEGER`,
-  `ALTER TABLE bing_url_inspections ADD COLUMN discovery_date TEXT`
+  `ALTER TABLE bing_url_inspections ADD COLUMN discovery_date TEXT`,
+  // v16: Recommended competitor names extracted from run answers
+  `ALTER TABLE query_snapshots ADD COLUMN recommended_competitors TEXT NOT NULL DEFAULT '[]'`,
+  // v17: GA4 AI referral tracking — ga_ai_referrals table
+  `CREATE TABLE IF NOT EXISTS ga_ai_referrals (
+    id          TEXT PRIMARY KEY,
+    project_id  TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    date        TEXT NOT NULL,
+    source      TEXT NOT NULL,
+    medium      TEXT NOT NULL,
+    sessions    INTEGER NOT NULL DEFAULT 0,
+    users       INTEGER NOT NULL DEFAULT 0,
+    synced_at   TEXT NOT NULL
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_ga_ai_ref_project_date ON ga_ai_referrals(project_id, date)`,
+  `CREATE INDEX IF NOT EXISTS idx_ga_ai_ref_source ON ga_ai_referrals(source)`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS idx_ga_ai_ref_unique ON ga_ai_referrals(project_id, date, source, medium)`
 ];
 function migrate(db) {
   const statements = MIGRATION_SQL.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
@@ -2544,6 +2627,7 @@ async function runRoutes(app, opts) {
       answerText: querySnapshots.answerText,
       citedDomains: querySnapshots.citedDomains,
       competitorOverlap: querySnapshots.competitorOverlap,
+      recommendedCompetitors: querySnapshots.recommendedCompetitors,
       location: querySnapshots.location,
       rawResponse: querySnapshots.rawResponse,
       createdAt: querySnapshots.createdAt
@@ -2562,6 +2646,7 @@ async function runRoutes(app, opts) {
           answerText: s.answerText,
           citedDomains: tryParseJson(s.citedDomains, []),
           competitorOverlap: tryParseJson(s.competitorOverlap, []),
+          recommendedCompetitors: tryParseJson(s.recommendedCompetitors, []),
           model: s.model ?? rawParsed.model,
           location: s.location,
           groundingSources: rawParsed.groundingSources,
@@ -3174,6 +3259,7 @@ async function historyRoutes(app) {
       answerText: querySnapshots.answerText,
       citedDomains: querySnapshots.citedDomains,
       competitorOverlap: querySnapshots.competitorOverlap,
+      recommendedCompetitors: querySnapshots.recommendedCompetitors,
       location: querySnapshots.location,
       createdAt: querySnapshots.createdAt
     }).from(querySnapshots).leftJoin(keywords, eq9(querySnapshots.keywordId, keywords.id)).where(inArray(querySnapshots.runId, projectRuns.map((r) => r.id))).orderBy(desc2(querySnapshots.createdAt)).all();
@@ -3193,6 +3279,7 @@ async function historyRoutes(app) {
         answerText: s.answerText,
         citedDomains: tryParseJson2(s.citedDomains, []),
         competitorOverlap: tryParseJson2(s.competitorOverlap, []),
+        recommendedCompetitors: tryParseJson2(s.recommendedCompetitors, []),
         location: s.location,
         createdAt: s.createdAt
       })),
@@ -5338,6 +5425,45 @@ var routeCatalog = [
       404: { description: "Project, connection, or page not found." }
     }
   },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/wordpress/pages/meta/bulk",
+    summary: "Bulk update SEO meta for multiple pages",
+    tags: ["wordpress"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["entries"],
+            properties: {
+              entries: {
+                type: "array",
+                items: {
+                  type: "object",
+                  required: ["slug"],
+                  properties: {
+                    slug: stringSchema,
+                    title: stringSchema,
+                    description: stringSchema,
+                    noindex: booleanSchema
+                  }
+                }
+              },
+              env: { type: "string", enum: ["live", "staging"] }
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Bulk SEO meta update results returned." },
+      400: { description: "Invalid entries or environment." },
+      404: { description: "Project or connection not found." }
+    }
+  },
   {
     method: "get",
     path: "/api/v1/projects/{name}/wordpress/schema",
@@ -5379,6 +5505,48 @@ var routeCatalog = [
       404: { description: "Project, connection, or page not found." }
     }
   },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/wordpress/schema/deploy",
+    summary: "Deploy JSON-LD schema to WordPress pages",
+    tags: ["wordpress"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["profile"],
+            properties: {
+              profile: {
+                type: "object",
+                description: "Business profile and per-slug schema mapping"
+              },
+              env: { type: "string", enum: ["live", "staging"] }
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Schema deployment results returned." },
+      400: { description: "Invalid profile or environment." },
+      404: { description: "Project or connection not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/wordpress/schema/status",
+    summary: "Get JSON-LD schema status for all pages",
+    tags: ["wordpress"],
+    parameters: [nameParameter, wordpressEnvQueryParameter],
+    responses: {
+      200: { description: "Schema status per page returned." },
+      400: { description: "Invalid environment." },
+      404: { description: "Project or connection not found." }
+    }
+  },
   {
     method: "get",
     path: "/api/v1/projects/{name}/wordpress/llms-txt",
@@ -5466,6 +5634,39 @@ var routeCatalog = [
       404: { description: "Project or connection not found." }
     }
   },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/wordpress/onboard",
+    summary: "Full WordPress onboarding workflow",
+    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"] },
+              profile: objectSchema,
+              skipSchema: booleanSchema,
+              skipSubmit: booleanSchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Onboarding result with step-by-step status." },
+      400: { description: "Invalid onboarding request." },
+      404: { description: "Project not found." }
+    }
+  },
   // GA4 routes
   {
     method: "post",
@@ -5519,7 +5720,7 @@ var routeCatalog = [
   {
     method: "post",
     path: "/api/v1/projects/{name}/ga/sync",
-    summary: "Sync GA4 traffic data",
+    summary: "Sync GA4 traffic and AI referral data",
     tags: ["ga4"],
     parameters: [nameParameter],
     requestBody: {
@@ -5544,7 +5745,7 @@ var routeCatalog = [
   {
     method: "get",
     path: "/api/v1/projects/{name}/ga/traffic",
-    summary: "Get GA4 landing page traffic",
+    summary: "Get GA4 landing page traffic and AI referral sources",
     tags: ["ga4"],
     parameters: [nameParameter, limitQueryParameter],
     responses: {
@@ -7809,6 +8010,15 @@ async function batchRunReports(accessToken, propertyId, requests) {
 function formatDate(d) {
   return d.toISOString().split("T")[0];
 }
+var AI_REFERRAL_SOURCE_FILTERS = [
+  { matchType: "CONTAINS", value: "perplexity" },
+  { matchType: "CONTAINS", value: "gemini" },
+  { matchType: "CONTAINS", value: "chatgpt" },
+  { matchType: "CONTAINS", value: "openai" },
+  { matchType: "CONTAINS", value: "claude" },
+  { matchType: "CONTAINS", value: "anthropic" },
+  { matchType: "CONTAINS", value: "copilot" }
+];
 async function fetchTrafficByLandingPage(accessToken, propertyId, days) {
   const syncDays = Math.min(Math.max(1, days ?? GA4_DEFAULT_SYNC_DAYS), GA4_MAX_SYNC_DAYS);
   const endDate = /* @__PURE__ */ new Date();
@@ -7935,6 +8145,61 @@ async function fetchAggregateSummary(accessToken, propertyId, days) {
   ga4Log("info", "fetch-aggregate.done", { propertyId, ...summary });
   return summary;
 }
+async function fetchAiReferrals(accessToken, propertyId, days) {
+  const syncDays = Math.min(Math.max(1, days ?? GA4_DEFAULT_SYNC_DAYS), GA4_MAX_SYNC_DAYS);
+  const endDate = /* @__PURE__ */ new Date();
+  const startDate = /* @__PURE__ */ new Date();
+  startDate.setDate(startDate.getDate() - syncDays);
+  ga4Log("info", "fetch-ai-referrals.start", { propertyId, days: syncDays });
+  const PAGE_SIZE = 1e3;
+  const rows = [];
+  let offset = 0;
+  while (true) {
+    const request = {
+      dateRanges: [{ startDate: formatDate(startDate), endDate: formatDate(endDate) }],
+      dimensions: [
+        { name: "date" },
+        { name: "sessionSource" },
+        { name: "sessionMedium" }
+      ],
+      metrics: [
+        { name: "sessions" },
+        { name: "totalUsers" }
+      ],
+      dimensionFilter: {
+        orGroup: {
+          expressions: AI_REFERRAL_SOURCE_FILTERS.map(({ matchType, value }) => ({
+            filter: {
+              fieldName: "sessionSource",
+              stringFilter: { matchType, value }
+            }
+          }))
+        }
+      },
+      limit: PAGE_SIZE,
+      offset
+    };
+    const response = await runReport(accessToken, propertyId, request);
+    const pageRows = (response.rows ?? []).map((row) => ({
+      date: row.dimensionValues[0].value,
+      source: row.dimensionValues[1].value,
+      medium: row.dimensionValues[2].value,
+      sessions: parseInt(row.metricValues[0].value, 10) || 0,
+      users: parseInt(row.metricValues[1].value, 10) || 0
+    }));
+    rows.push(...pageRows);
+    const totalRows = response.rowCount ?? 0;
+    offset += pageRows.length;
+    if (pageRows.length < PAGE_SIZE || offset >= totalRows) break;
+  }
+  for (const row of rows) {
+    if (row.date.length === 8 && !row.date.includes("-")) {
+      row.date = `${row.date.slice(0, 4)}-${row.date.slice(4, 6)}-${row.date.slice(6, 8)}`;
+    }
+  }
+  ga4Log("info", "fetch-ai-referrals.done", { propertyId, rowCount: rows.length });
+  return rows;
+}
 
 // ../api-routes/src/ga.ts
 function gaLog(level, action, ctx) {
@@ -8020,6 +8285,7 @@ async function ga4Routes(app, opts) {
     }
     app.db.delete(gaTrafficSnapshots).where(eq16(gaTrafficSnapshots.projectId, project.id)).run();
     app.db.delete(gaTrafficSummaries).where(eq16(gaTrafficSummaries.projectId, project.id)).run();
+    app.db.delete(gaAiReferrals).where(eq16(gaAiReferrals.projectId, project.id)).run();
     store.deleteConnection(project.name);
     writeAuditLog(app.db, {
       projectId: project.id,
@@ -8038,7 +8304,7 @@ async function ga4Routes(app, opts) {
     if (!conn) {
       return { connected: false, propertyId: null, clientEmail: null, lastSyncedAt: null };
     }
-    const latestSync = app.db.select({ syncedAt: gaTrafficSnapshots.syncedAt }).from(gaTrafficSnapshots).where(eq16(gaTrafficSnapshots.projectId, project.id)).orderBy(desc6(gaTrafficSnapshots.syncedAt)).limit(1).get();
+    const latestSync = app.db.select({ syncedAt: gaTrafficSummaries.syncedAt }).from(gaTrafficSummaries).where(eq16(gaTrafficSummaries.projectId, project.id)).orderBy(desc6(gaTrafficSummaries.syncedAt)).limit(1).get();
     return {
       connected: true,
       propertyId: conn.propertyId,
@@ -8069,11 +8335,13 @@ async function ga4Routes(app, opts) {
     }
     let rows;
     let summary;
+    let aiReferrals;
     try {
       ;
-      [rows, summary] = await Promise.all([
+      [rows, summary, aiReferrals] = await Promise.all([
         fetchTrafficByLandingPage(accessToken, conn.propertyId, days),
-        fetchAggregateSummary(accessToken, conn.propertyId, days)
+        fetchAggregateSummary(accessToken, conn.propertyId, days),
+        fetchAiReferrals(accessToken, conn.propertyId, days)
       ]);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
@@ -8082,17 +8350,14 @@ async function ga4Routes(app, opts) {
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.transaction((tx) => {
+      tx.delete(gaTrafficSnapshots).where(
+        and6(
+          eq16(gaTrafficSnapshots.projectId, project.id),
+          sql3`${gaTrafficSnapshots.date} >= ${summary.periodStart}`,
+          sql3`${gaTrafficSnapshots.date} <= ${summary.periodEnd}`
+        )
+      ).run();
       if (rows.length > 0) {
-        const dates = rows.map((r) => r.date);
-        const minDate = dates.reduce((a, b) => a < b ? a : b);
-        const maxDate = dates.reduce((a, b) => a > b ? a : b);
-        tx.delete(gaTrafficSnapshots).where(
-          and6(
-            eq16(gaTrafficSnapshots.projectId, project.id),
-            sql3`${gaTrafficSnapshots.date} >= ${minDate}`,
-            sql3`${gaTrafficSnapshots.date} <= ${maxDate}`
-          )
-        ).run();
         for (const row of rows) {
           tx.insert(gaTrafficSnapshots).values({
             id: crypto16.randomUUID(),
@@ -8106,6 +8371,27 @@ async function ga4Routes(app, opts) {
           }).run();
         }
       }
+      tx.delete(gaAiReferrals).where(
+        and6(
+          eq16(gaAiReferrals.projectId, project.id),
+          sql3`${gaAiReferrals.date} >= ${summary.periodStart}`,
+          sql3`${gaAiReferrals.date} <= ${summary.periodEnd}`
+        )
+      ).run();
+      if (aiReferrals.length > 0) {
+        for (const row of aiReferrals) {
+          tx.insert(gaAiReferrals).values({
+            id: crypto16.randomUUID(),
+            projectId: project.id,
+            date: row.date,
+            source: row.source,
+            medium: row.medium,
+            sessions: row.sessions,
+            users: row.users,
+            syncedAt: now
+          }).run();
+        }
+      }
       tx.delete(gaTrafficSummaries).where(eq16(gaTrafficSummaries.projectId, project.id)).run();
       tx.insert(gaTrafficSummaries).values({
         id: crypto16.randomUUID(),
@@ -8118,10 +8404,17 @@ async function ga4Routes(app, opts) {
         syncedAt: now
       }).run();
     });
-    gaLog("info", "sync.complete", { projectId: project.id, rowCount: rows.length, days, totalUsers: summary.totalUsers });
+    gaLog("info", "sync.complete", {
+      projectId: project.id,
+      rowCount: rows.length,
+      aiReferralCount: aiReferrals.length,
+      days,
+      totalUsers: summary.totalUsers
+    });
     return {
       synced: true,
       rowCount: rows.length,
+      aiReferralCount: aiReferrals.length,
       days,
       syncedAt: now
     };
@@ -8147,7 +8440,13 @@ async function ga4Routes(app, opts) {
       organicSessions: sql3`SUM(${gaTrafficSnapshots.organicSessions})`,
       users: sql3`SUM(${gaTrafficSnapshots.users})`
     }).from(gaTrafficSnapshots).where(eq16(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql3`SUM(${gaTrafficSnapshots.sessions}) DESC`).limit(limit).all();
-    const latestSync = app.db.select({ syncedAt: gaTrafficSnapshots.syncedAt }).from(gaTrafficSnapshots).where(eq16(gaTrafficSnapshots.projectId, project.id)).orderBy(desc6(gaTrafficSnapshots.syncedAt)).limit(1).get();
+    const aiReferrals = app.db.select({
+      source: gaAiReferrals.source,
+      medium: gaAiReferrals.medium,
+      sessions: sql3`SUM(${gaAiReferrals.sessions})`,
+      users: sql3`SUM(${gaAiReferrals.users})`
+    }).from(gaAiReferrals).where(eq16(gaAiReferrals.projectId, project.id)).groupBy(gaAiReferrals.source, gaAiReferrals.medium).orderBy(sql3`SUM(${gaAiReferrals.sessions}) DESC`).all();
+    const latestSync = app.db.select({ syncedAt: gaTrafficSummaries.syncedAt }).from(gaTrafficSummaries).where(eq16(gaTrafficSummaries.projectId, project.id)).orderBy(desc6(gaTrafficSummaries.syncedAt)).limit(1).get();
     return {
       totalSessions: summary?.totalSessions ?? 0,
       totalOrganicSessions: summary?.totalOrganicSessions ?? 0,
@@ -8158,6 +8457,12 @@ async function ga4Routes(app, opts) {
         organicSessions: r.organicSessions ?? 0,
         users: r.users ?? 0
       })),
+      aiReferrals: aiReferrals.map((r) => ({
+        source: r.source,
+        medium: r.medium,
+        sessions: r.sessions ?? 0,
+        users: r.users ?? 0
+      })),
       lastSyncedAt: latestSync?.syncedAt ?? null
     };
   });
@@ -8199,6 +8504,115 @@ var WordpressApiError = class extends Error {
   }
 };
 
+// ../integration-wordpress/src/schema-templates.ts
+var SUPPORTED_TYPES = /* @__PURE__ */ new Set([
+  "LocalBusiness",
+  "Organization",
+  "FAQPage",
+  "Service",
+  "WebPage"
+]);
+function isSupportedSchemaType(type) {
+  return SUPPORTED_TYPES.has(type);
+}
+function buildAddress(address) {
+  return {
+    "@type": "PostalAddress",
+    ...address.street ? { streetAddress: address.street } : {},
+    ...address.city ? { addressLocality: address.city } : {},
+    ...address.state ? { addressRegion: address.state } : {},
+    ...address.zip ? { postalCode: address.zip } : {},
+    ...address.country ? { addressCountry: address.country } : {}
+  };
+}
+function generateLocalBusiness(profile) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "LocalBusiness",
+    name: profile.name
+  };
+  if (profile.url) schema.url = profile.url;
+  if (profile.description) schema.description = profile.description;
+  if (profile.phone) schema.telephone = profile.phone;
+  if (profile.email) schema.email = profile.email;
+  if (profile.address) schema.address = buildAddress(profile.address);
+  return schema;
+}
+function generateOrganization(profile) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "Organization",
+    name: profile.name
+  };
+  if (profile.url) schema.url = profile.url;
+  if (profile.description) schema.description = profile.description;
+  if (profile.phone) schema.telephone = profile.phone;
+  if (profile.email) schema.email = profile.email;
+  if (profile.address) schema.address = buildAddress(profile.address);
+  return schema;
+}
+function generateFAQPage(profile, faqs) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "FAQPage",
+    name: profile.name
+  };
+  if (faqs && faqs.length > 0) {
+    schema.mainEntity = faqs.map((faq) => ({
+      "@type": "Question",
+      name: faq.q,
+      acceptedAnswer: {
+        "@type": "Answer",
+        text: faq.a
+      }
+    }));
+  }
+  return schema;
+}
+function generateService(profile) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "Service",
+    name: profile.name
+  };
+  if (profile.url) schema.url = profile.url;
+  if (profile.description) schema.description = profile.description;
+  if (profile.address) schema.areaServed = buildAddress(profile.address);
+  return schema;
+}
+function generateWebPage(profile) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "WebPage",
+    name: profile.name
+  };
+  if (profile.url) schema.url = profile.url;
+  if (profile.description) schema.description = profile.description;
+  return schema;
+}
+function generateSchema(type, profile, overrides) {
+  switch (type) {
+    case "LocalBusiness":
+      return generateLocalBusiness(profile);
+    case "Organization":
+      return generateOrganization(profile);
+    case "FAQPage":
+      return generateFAQPage(profile, overrides?.faqs);
+    case "Service":
+      return generateService(profile);
+    case "WebPage":
+      return generateWebPage(profile);
+    default:
+      throw new Error(`Unsupported schema type: ${type}`);
+  }
+}
+function parseSchemaPageEntry(entry) {
+  if (typeof entry === "string") {
+    return { type: entry };
+  }
+  return { type: entry.type, faqs: entry.faqs };
+}
+
 // ../integration-wordpress/src/wordpress-client.ts
 import crypto17 from "crypto";
 var PAGE_FIELDS = "id,slug,status,link,modified,modified_gmt,title,content,meta";
@@ -8635,6 +9049,271 @@ async function setSeoMeta(connection, slug, body, env) {
   );
   return getPageDetail(connection, slug, site.env, plugins);
 }
+async function detectSeoWriteStrategy(connection, env) {
+  const site = resolveEnvironment(connection, env);
+  const plugins = await listActivePlugins(connection, site.env);
+  const pages = await listPages(connection, site.env);
+  if (pages.length === 0) {
+    return { strategy: "manual", plugins };
+  }
+  const samplePage = await getPageBySlug(connection, pages[0].slug, site.env);
+  const writeTargets = resolveSeoWriteTargets(samplePage.meta, plugins);
+  return {
+    strategy: writeTargets.length > 0 ? "plugin" : "manual",
+    plugins
+  };
+}
+function buildManualMetaAssist(siteUrl, slug, link, meta) {
+  const fields = [];
+  if (meta.title != null) fields.push(`Title: ${meta.title}`);
+  if (meta.description != null) fields.push(`Description: ${meta.description}`);
+  if (meta.noindex != null) fields.push(`Noindex: ${meta.noindex}`);
+  return {
+    manualRequired: true,
+    targetUrl: link ?? `${siteUrl}/${slug}`,
+    adminUrl: `${siteUrl}/wp-admin/`,
+    content: fields.join("\n"),
+    nextSteps: [
+      `Open the WordPress editor for page "${slug}".`,
+      "Install an SEO plugin (Yoast SEO, Rank Math, or AIOSEO) to manage meta fields via REST, or set the values manually in the page editor.",
+      "Apply the meta values listed above.",
+      "Publish/update the page."
+    ]
+  };
+}
+async function bulkSetSeoMeta(connection, entries, env) {
+  const site = resolveEnvironment(connection, env);
+  const { strategy, plugins } = await detectSeoWriteStrategy(connection, site.env);
+  const results = await mapWithConcurrency(
+    entries,
+    3,
+    async (entry) => {
+      try {
+        const page = await getPageBySlug(connection, entry.slug, site.env);
+        if (strategy === "manual") {
+          return {
+            slug: entry.slug,
+            status: "manual",
+            manualAssist: buildManualMetaAssist(
+              site.siteUrl,
+              entry.slug,
+              page.link,
+              entry
+            )
+          };
+        }
+        const writeTargets = resolveSeoWriteTargets(page.meta, plugins);
+        if (writeTargets.length === 0 || !page.meta) {
+          return {
+            slug: entry.slug,
+            status: "manual",
+            manualAssist: buildManualMetaAssist(
+              site.siteUrl,
+              entry.slug,
+              page.link,
+              entry
+            )
+          };
+        }
+        const patch = {};
+        for (const target of SEO_TARGETS) {
+          if (entry.title != null && writeTargets.includes(target.titleKey)) patch[target.titleKey] = entry.title;
+          if (entry.description != null && writeTargets.includes(target.descriptionKey)) patch[target.descriptionKey] = entry.description;
+          if (entry.noindex != null && writeTargets.includes(target.noindexKey)) {
+            patch[target.noindexKey] = encodeNoindexValue(target.noindexKey, entry.noindex);
+          }
+        }
+        if (Object.keys(patch).length === 0) {
+          return {
+            slug: entry.slug,
+            status: "manual",
+            manualAssist: buildManualMetaAssist(
+              site.siteUrl,
+              entry.slug,
+              page.link,
+              entry
+            )
+          };
+        }
+        await fetchJson(
+          connection,
+          site.siteUrl,
+          `/wp-json/wp/v2/pages/${page.id}`,
+          {
+            method: "POST",
+            body: JSON.stringify({
+              meta: { ...page.meta ?? {}, ...patch }
+            })
+          }
+        );
+        return { slug: entry.slug, status: "applied" };
+      } catch (error) {
+        if (error instanceof WordpressApiError && error.code === "NOT_FOUND") {
+          return { slug: entry.slug, status: "skipped", error: `Page "${entry.slug}" not found` };
+        }
+        return {
+          slug: entry.slug,
+          status: "skipped",
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    }
+  );
+  return { env: site.env, strategy, results };
+}
+var CANONRY_SCHEMA_START = "<!-- canonry:schema:start -->";
+var CANONRY_SCHEMA_END = "<!-- canonry:schema:end -->";
+function stripCanonrySchema(content) {
+  const regex = new RegExp(
+    `${escapeRegExp(CANONRY_SCHEMA_START)}[\\s\\S]*?${escapeRegExp(CANONRY_SCHEMA_END)}`,
+    "g"
+  );
+  return content.replace(regex, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function injectCanonrySchema(content, schemas) {
+  if (schemas.length === 0) return content;
+  const blocks = schemas.map((schema) => `<script type="application/ld+json">${JSON.stringify(schema).replace(/<\//g, "<\\/")}</script>`).join("\n");
+  const injection = `
+
+${CANONRY_SCHEMA_START}
+${blocks}
+${CANONRY_SCHEMA_END}`;
+  const stripped = stripCanonrySchema(content);
+  return stripped + injection;
+}
+async function verifySchemaInjection(connection, slug, env) {
+  const page = await getPageBySlug(connection, slug, env);
+  const raw = page.content?.raw ?? page.content?.rendered ?? "";
+  return raw.includes(CANONRY_SCHEMA_START);
+}
+async function deploySchema(connection, slug, schemas, env) {
+  const site = resolveEnvironment(connection, env);
+  try {
+    const page = await getPageBySlug(connection, slug, site.env);
+    const currentContent = page.content?.raw ?? page.content?.rendered ?? "";
+    const updatedContent = injectCanonrySchema(currentContent, schemas);
+    await fetchJson(
+      connection,
+      site.siteUrl,
+      `/wp-json/wp/v2/pages/${page.id}`,
+      {
+        method: "POST",
+        body: JSON.stringify({ content: updatedContent })
+      }
+    );
+    const persisted = await verifySchemaInjection(connection, slug, site.env);
+    if (!persisted) {
+      return {
+        slug,
+        status: "stripped",
+        schemasInjected: schemas.map((s) => String(s["@type"] ?? "Unknown")),
+        manualAssist: {
+          manualRequired: true,
+          targetUrl: page.link ?? `${site.siteUrl}/${slug}`,
+          adminUrl: `${site.siteUrl}/wp-admin/`,
+          content: schemas.map((s) => JSON.stringify(s, null, 2)).join("\n\n"),
+          nextSteps: [
+            `WordPress stripped the schema <script> tags for page "${slug}". The connected user likely lacks the unfiltered_html capability.`,
+            "Grant the user Administrator or Super Admin role, or add the schema manually in the page editor or via a schema plugin.",
+            "Paste the JSON-LD blocks provided above."
+          ]
+        }
+      };
+    }
+    return {
+      slug,
+      status: "deployed",
+      schemasInjected: schemas.map((s) => String(s["@type"] ?? "Unknown"))
+    };
+  } catch (error) {
+    if (error instanceof WordpressApiError && error.code === "NOT_FOUND") {
+      return { slug, status: "skipped", error: `Page "${slug}" not found` };
+    }
+    return {
+      slug,
+      status: "failed",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function deploySchemaFromProfile(connection, profile, env) {
+  const site = resolveEnvironment(connection, env);
+  const slugEntries = Object.entries(profile.pages);
+  const results = await mapWithConcurrency(
+    slugEntries,
+    3,
+    async ([slug, entries]) => {
+      const parsed = entries.map(parseSchemaPageEntry);
+      const unsupported = parsed.filter((p) => !isSupportedSchemaType(p.type));
+      if (unsupported.length > 0) {
+        return {
+          slug,
+          status: "failed",
+          error: `Unsupported schema type(s): ${unsupported.map((u) => u.type).join(", ")}`
+        };
+      }
+      const schemas = parsed.map((p) => generateSchema(p.type, profile.business, { faqs: p.faqs }));
+      return deploySchema(connection, slug, schemas, site.env);
+    }
+  );
+  return { env: site.env, results };
+}
+async function getSchemaStatus(connection, env) {
+  const site = resolveEnvironment(connection, env);
+  const pages = await listPages(connection, site.env);
+  const details = await mapWithConcurrency(
+    pages,
+    5,
+    async (page) => getPageDetail(connection, page.slug, site.env)
+  );
+  const statusPages = details.map((page) => {
+    const rawContent = page.content;
+    const hasCanonryMarker = rawContent.includes(CANONRY_SCHEMA_START);
+    const allSchemaTypes = page.schemaBlocks.map((b) => b.type);
+    const canonrySchemas = [];
+    const thirdPartySchemas = [];
+    if (hasCanonryMarker) {
+      const markerRegex = new RegExp(
+        `${escapeRegExp(CANONRY_SCHEMA_START)}([\\s\\S]*?)${escapeRegExp(CANONRY_SCHEMA_END)}`
+      );
+      const match = markerRegex.exec(rawContent);
+      if (match?.[1]) {
+        const jsonLdRegex = /<script[^>]+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+        let jsonMatch;
+        while ((jsonMatch = jsonLdRegex.exec(match[1])) !== null) {
+          try {
+            const parsed = JSON.parse(jsonMatch[1].trim());
+            canonrySchemas.push(String(parsed["@type"] ?? "Unknown"));
+          } catch {
+          }
+        }
+      }
+    }
+    const canonryCounts = /* @__PURE__ */ new Map();
+    for (const t of canonrySchemas) {
+      canonryCounts.set(t, (canonryCounts.get(t) ?? 0) + 1);
+    }
+    for (const schemaType of allSchemaTypes) {
+      const remaining = canonryCounts.get(schemaType) ?? 0;
+      if (remaining > 0) {
+        canonryCounts.set(schemaType, remaining - 1);
+      } else {
+        thirdPartySchemas.push(schemaType);
+      }
+    }
+    return {
+      slug: page.slug,
+      title: page.title,
+      canonrySchemas,
+      thirdPartySchemas,
+      hasCanonrySchema: hasCanonryMarker
+    };
+  });
+  return { env: site.env, pages: statusPages };
+}
 async function getLlmsTxt(connection, env) {
   const site = resolveEnvironment(connection, env);
   const url = `${site.siteUrl}/llms.txt`;
@@ -9080,6 +9759,39 @@ async function wordpressRoutes(app, opts) {
       return updated;
     });
   });
+  app.post("/projects/:name/wordpress/pages/meta/bulk", 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 entries = request.body?.entries;
+      if (!Array.isArray(entries) || entries.length === 0) {
+        const err = validationError("entries array is required and must not be empty");
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      for (const entry of entries) {
+        if (!entry.slug?.trim()) {
+          const err = validationError("each entry must have a slug");
+          return reply.status(err.statusCode).send(err.toJSON());
+        }
+      }
+      const env = parseEnvInput(request.body?.env);
+      const result = await bulkSetSeoMeta(connection, entries, env);
+      const applied = result.results.filter((r) => r.status === "applied");
+      if (applied.length > 0) {
+        writeAuditLog(app.db, {
+          projectId: project.id,
+          actor: "api",
+          action: "wordpress.page-meta-updated",
+          entityType: "wordpress_page",
+          entityId: `bulk(${applied.map((r) => r.slug).join(",")})`
+        });
+      }
+      return result;
+    });
+  });
   app.get("/projects/:name/wordpress/schema", async (request, reply) => {
     return withWordpressErrorHandling(reply, async () => {
       const store = requireStore(reply);
@@ -9113,6 +9825,33 @@ async function wordpressRoutes(app, opts) {
       return buildManualSchemaUpdate(connection, slug, { type: request.body?.type, json }, env);
     });
   });
+  app.post("/projects/:name/wordpress/schema/deploy", 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 profile = request.body?.profile;
+      if (!profile?.business?.name || !profile?.pages || Object.keys(profile.pages).length === 0) {
+        const err = validationError("profile with business.name and non-empty pages is required");
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
+      const env = parseEnvInput(request.body?.env);
+      return deploySchemaFromProfile(connection, profile, env);
+    });
+  });
+  app.get("/projects/:name/wordpress/schema/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 env = parseEnvInput(request.query?.env);
+      return getSchemaStatus(connection, env);
+    });
+  });
   app.get("/projects/:name/wordpress/llms-txt", async (request, reply) => {
     return withWordpressErrorHandling(reply, async () => {
       const store = requireStore(reply);
@@ -9196,6 +9935,201 @@ async function wordpressRoutes(app, opts) {
       return buildManualStagingPush(connection);
     });
   });
+  app.post("/projects/:name/wordpress/onboard", async (request, reply) => {
+    return withWordpressErrorHandling(reply, async () => {
+      const store = requireStore(reply);
+      if (!store) return;
+      const project = resolveProject(app.db, request.params.name);
+      const { url, username, appPassword, stagingUrl, profile, skipSchema, skipSubmit } = 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 steps = [];
+      let connection = null;
+      let pageUrls = [];
+      try {
+        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);
+        connection = store.upsertConnection(nextConnection);
+        writeAuditLog(app.db, {
+          projectId: project.id,
+          actor: "api",
+          action: "wordpress.connected",
+          entityType: "wordpress_connection",
+          entityId: project.name
+        });
+        steps.push({ name: "connect", status: "completed", summary: `Connected to ${url}` });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        steps.push({ name: "connect", status: "failed", error: msg });
+        return { projectName: project.name, steps };
+      }
+      let auditIssues = [];
+      let auditPages = [];
+      try {
+        const audit = await runAudit(connection);
+        const issueCount = audit.issues?.length ?? 0;
+        const pageCount = audit.pages?.length ?? 0;
+        auditIssues = audit.issues;
+        auditPages = audit.pages;
+        const pageSummaries = await listPages(connection);
+        pageUrls = pageSummaries.map((p) => p.link).filter((link) => typeof link === "string" && link.length > 0);
+        steps.push({ name: "audit", status: "completed", summary: `${pageCount} pages audited, ${issueCount} issues` });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        steps.push({ name: "audit", status: "failed", error: msg });
+        return { projectName: project.name, steps };
+      }
+      try {
+        const metaEntries = [];
+        for (const issue of auditIssues) {
+          if (issue.code === "missing-meta-description" || issue.code === "missing-seo-title") {
+            const existing = metaEntries.find((e) => e.slug === issue.slug);
+            const page = auditPages.find((p) => p.slug === issue.slug);
+            if (!existing) {
+              metaEntries.push({
+                slug: issue.slug,
+                title: issue.code === "missing-seo-title" ? page?.title ?? issue.slug : void 0,
+                description: issue.code === "missing-meta-description" ? page?.title ?? issue.slug : void 0
+              });
+            } else {
+              if (issue.code === "missing-seo-title" && !existing.title) {
+                existing.title = page?.title ?? issue.slug;
+              }
+              if (issue.code === "missing-meta-description" && !existing.description) {
+                existing.description = page?.title ?? issue.slug;
+              }
+            }
+          }
+        }
+        if (metaEntries.length === 0) {
+          steps.push({ name: "set-meta", status: "skipped", summary: "No pages with missing meta found" });
+        } else {
+          const result = await bulkSetSeoMeta(connection, metaEntries);
+          const applied = result.results.filter((r) => r.status === "applied").length;
+          const manual = result.results.filter((r) => r.status === "manual").length;
+          const skipped = result.results.filter((r) => r.status === "skipped").length;
+          steps.push({
+            name: "set-meta",
+            status: "completed",
+            summary: `${applied} applied, ${manual} manual-assist, ${skipped} skipped`
+          });
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        steps.push({ name: "set-meta", status: "failed", error: msg });
+        return { projectName: project.name, steps };
+      }
+      if (skipSchema || !profile) {
+        steps.push({
+          name: "schema-deploy",
+          status: "skipped",
+          summary: skipSchema ? "Skipped via --skip-schema" : "No --profile provided"
+        });
+      } else {
+        try {
+          if (!profile.business?.name || !profile.pages || Object.keys(profile.pages).length === 0) {
+            steps.push({ name: "schema-deploy", status: "skipped", summary: "Profile missing business.name or pages" });
+          } else {
+            const result = await deploySchemaFromProfile(connection, profile);
+            const deployed = result.results.filter((r) => r.status === "deployed").length;
+            const stripped = result.results.filter((r) => r.status === "stripped").length;
+            const skipped = result.results.filter((r) => r.status === "skipped").length;
+            steps.push({
+              name: "schema-deploy",
+              status: "completed",
+              summary: `${deployed} deployed, ${stripped} stripped (manual-assist), ${skipped} skipped`
+            });
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          steps.push({ name: "schema-deploy", status: "failed", error: msg });
+          return { projectName: project.name, steps };
+        }
+      }
+      if (skipSubmit || pageUrls.length === 0) {
+        const reason = skipSubmit ? "Skipped via --skip-submit" : "No page URLs to submit";
+        steps.push({ name: "google-submit", status: "skipped", summary: reason });
+        steps.push({ name: "bing-submit", status: "skipped", summary: reason });
+      } else {
+        try {
+          const authHeader = request.headers.authorization;
+          const googleRes = await app.inject({
+            method: "POST",
+            url: `${opts.routePrefix ?? "/api/v1"}/projects/${encodeURIComponent(project.name)}/google/indexing/request`,
+            payload: { urls: pageUrls },
+            headers: authHeader ? { authorization: authHeader } : {}
+          });
+          if (googleRes.statusCode === 200) {
+            const body = JSON.parse(googleRes.body);
+            const succeeded = body.results?.filter((r) => r.status === "success").length ?? 0;
+            steps.push({ name: "google-submit", status: "completed", summary: `${succeeded}/${pageUrls.length} URLs submitted` });
+          } else {
+            const body = JSON.parse(googleRes.body);
+            const msg = body.message || body.error || `HTTP ${googleRes.statusCode}`;
+            if (googleRes.statusCode === 400 || googleRes.statusCode === 404) {
+              steps.push({ name: "google-submit", status: "skipped", summary: msg });
+            } else {
+              steps.push({ name: "google-submit", status: "failed", error: msg });
+            }
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          steps.push({ name: "google-submit", status: "skipped", summary: `Google not available: ${msg}` });
+        }
+        try {
+          const authHeader = request.headers.authorization;
+          const bingRes = await app.inject({
+            method: "POST",
+            url: `${opts.routePrefix ?? "/api/v1"}/projects/${encodeURIComponent(project.name)}/bing/request-indexing`,
+            payload: { urls: pageUrls },
+            headers: authHeader ? { authorization: authHeader } : {}
+          });
+          if (bingRes.statusCode === 200) {
+            const body = JSON.parse(bingRes.body);
+            const succeeded = body.results?.filter((r) => r.status === "success").length ?? 0;
+            steps.push({ name: "bing-submit", status: "completed", summary: `${succeeded}/${pageUrls.length} URLs submitted` });
+          } else {
+            const body = JSON.parse(bingRes.body);
+            const msg = body.message || body.error || `HTTP ${bingRes.statusCode}`;
+            if (bingRes.statusCode === 400 || bingRes.statusCode === 404) {
+              steps.push({ name: "bing-submit", status: "skipped", summary: msg });
+            } else {
+              steps.push({ name: "bing-submit", status: "failed", error: msg });
+            }
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          steps.push({ name: "bing-submit", status: "skipped", summary: `Bing not available: ${msg}` });
+        }
+      }
+      writeAuditLog(app.db, {
+        projectId: project.id,
+        actor: "api",
+        action: "wordpress.onboarded",
+        entityType: "wordpress_connection",
+        entityId: project.name
+      });
+      return { projectName: project.name, steps };
+    });
+  });
 }
 
 // ../api-routes/src/index.ts
@@ -9288,7 +10222,8 @@ async function apiRoutes(app, opts) {
       onInspectSitemapRequested: opts.onInspectSitemapRequested
     });
     await api.register(wordpressRoutes, {
-      wordpressConnectionStore: opts.wordpressConnectionStore
+      wordpressConnectionStore: opts.wordpressConnectionStore,
+      routePrefix: opts.routePrefix ?? "/api/v1"
     });
     await api.register(cdpRoutes, {
       getCdpStatus: opts.getCdpStatus,
@@ -11488,6 +12423,12 @@ var JobRunner = class {
             log.info("query.result", { runId, provider: providerName, keyword: kw.keyword, citedDomains: normalized.citedDomains, groundingSources: normalized.groundingSources.map((s) => s.uri), matchDomains: allDomains });
             const citationState = determineCitationState(normalized, allDomains);
             const overlap = computeCompetitorOverlap(normalized, competitorDomains);
+            const extractedCompetitors = extractRecommendedCompetitors(
+              normalized.answerText,
+              allDomains,
+              normalized.citedDomains,
+              overlap
+            );
             let screenshotRelPath = null;
             if (raw.screenshotPath && fs4.existsSync(raw.screenshotPath)) {
               const snapshotId = crypto18.randomUUID();
@@ -11506,6 +12447,7 @@ var JobRunner = class {
                 answerText: normalized.answerText,
                 citedDomains: JSON.stringify(normalized.citedDomains),
                 competitorOverlap: JSON.stringify(overlap),
+                recommendedCompetitors: JSON.stringify(extractedCompetitors),
                 location: runLocation?.label ?? null,
                 screenshotPath: screenshotRelPath,
                 rawResponse: JSON.stringify({
@@ -11527,6 +12469,7 @@ var JobRunner = class {
                 answerText: normalized.answerText,
                 citedDomains: JSON.stringify(normalized.citedDomains),
                 competitorOverlap: JSON.stringify(overlap),
+                recommendedCompetitors: JSON.stringify(extractedCompetitors),
                 location: runLocation?.label ?? null,
                 rawResponse: JSON.stringify({
                   model: raw.model,
@@ -11750,6 +12693,97 @@ function computeCompetitorOverlap(normalized, competitorDomains) {
   }
   return [...overlapSet];
 }
+function extractRecommendedCompetitors(answerText, ownDomains, citedDomains, competitorDomains) {
+  if (!answerText || answerText.length < 20) return [];
+  const ownBrandKeys = new Set(
+    ownDomains.flatMap((domain) => collectBrandKeysFromDomain(domain))
+  );
+  const knownCompetitorKeys = new Set(
+    [...citedDomains, ...competitorDomains].flatMap((domain) => collectBrandKeysFromDomain(domain)).filter((key) => !ownBrandKeys.has(key))
+  );
+  if (knownCompetitorKeys.size === 0) return [];
+  const candidatePatterns = [
+    /^\s*(?:[-*]|\d+\.)\s+(?:\*\*)?([A-Z0-9][A-Za-z0-9][\w\s.&',/()-]{1,50}?)(?:\*\*)?\s*[:\u2014\u2013–-]/gm,
+    /\*\*([A-Z0-9][A-Za-z0-9][\w\s.&',/()-]{1,50}?)\*\*/g,
+    /^#{1,4}\s+(?:\d+\.\s+)?(?:\*\*)?([A-Z0-9][A-Za-z0-9][\w\s.&',/()-]{1,50}?)(?:\*\*)?$/gm,
+    /\[([A-Z0-9][A-Za-z0-9][\w\s.&',/()-]{1,50}?)\]\(https?:\/\/[^\s)]+\)/g
+  ];
+  const genericKeys = /* @__PURE__ */ new Set([
+    "additional",
+    "best",
+    "benefits",
+    "bottomline",
+    "comparison",
+    "conclusion",
+    "directorylisting",
+    "example",
+    "expertise",
+    "features",
+    "finalthoughts",
+    "howitworks",
+    "important",
+    "keybenefits",
+    "keyfeatures",
+    "major",
+    "note",
+    "notable",
+    "option",
+    "other",
+    "overview",
+    "pricing",
+    "pros",
+    "reviews",
+    "step",
+    "summary",
+    "top",
+    "verdict",
+    "whattolookfor",
+    "whyitmatters",
+    "whyitstandsout",
+    "whywechoseit"
+  ]);
+  const seen = /* @__PURE__ */ new Map();
+  for (const pattern of candidatePatterns) {
+    let match;
+    while ((match = pattern.exec(answerText)) !== null) {
+      const candidate = cleanCandidateName(match[1] ?? "");
+      const candidateKey = brandKeyFromText(candidate);
+      if (!candidateKey) continue;
+      if (genericKeys.has(candidateKey)) continue;
+      if (candidate.split(/\s+/).length > 6) continue;
+      if (matchesBrandKey(candidateKey, ownBrandKeys)) continue;
+      if (!matchesBrandKey(candidateKey, knownCompetitorKeys)) continue;
+      if (!seen.has(candidateKey)) seen.set(candidateKey, candidate);
+    }
+  }
+  return [...seen.values()].slice(0, 10);
+}
+function cleanCandidateName(candidate) {
+  return candidate.replace(/^[\s"'`]+|[\s"'`.,:;!?]+$/g, "").replace(/\s+/g, " ").trim();
+}
+function brandKeyFromText(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function collectBrandKeysFromDomain(domain) {
+  const hostname = normalizeProjectDomain(domain).split("/")[0] ?? "";
+  const labels = hostname.split(".").filter(Boolean);
+  const keys = /* @__PURE__ */ new Set();
+  const hostnameKey = hostname.replace(/[^a-z0-9]/gi, "").toLowerCase();
+  if (hostnameKey.length >= 4) keys.add(hostnameKey);
+  for (const label of labels) {
+    const key = label.replace(/[^a-z0-9]/gi, "").toLowerCase();
+    if (key.length >= 4) keys.add(key);
+  }
+  return [...keys];
+}
+function matchesBrandKey(candidateKey, brandKeys) {
+  for (const brandKey of brandKeys) {
+    if (candidateKey === brandKey) return true;
+    if (candidateKey.startsWith(brandKey) || candidateKey.endsWith(brandKey)) return true;
+    if (brandKey.startsWith(candidateKey) || brandKey.endsWith(candidateKey)) return true;
+  }
+  return false;
+}
 
 // src/gsc-sync.ts
 import crypto19 from "crypto";
@@ -12825,7 +13859,7 @@ var SnapshotService = class {
         heuristicCompetitors: result.recommendedCompetitors,
         citedDomains: result.citedDomains,
         groundingSources: result.groundingSources.map((source) => source.uri),
-        answerText: clipText(result.answerText, 420)
+        answerText: clipText(result.answerText, 2e3)
       }))
     );
     if (responses.length === 0) {
@@ -12853,7 +13887,7 @@ var SnapshotService = class {
             accuracyNotes: assessment.accuracyNotes ?? null,
             incorrectClaims: uniqueStrings(assessment.incorrectClaims ?? []).slice(0, 5),
             ...hasReviewedCompetitors ? {
-              recommendedCompetitors: uniqueStrings(assessment.recommendedCompetitors ?? []).slice(0, 6)
+              recommendedCompetitors: uniqueStrings(assessment.recommendedCompetitors ?? []).slice(0, 10)
             } : {}
           };
         }),
@@ -12906,7 +13940,13 @@ function buildBatchAnalysisPrompt(ctx) {
     "Return strict JSON with keys: assessments, whatThisMeans, recommendedActions.",
     "Each assessment must include: phrase, provider, mentioned, describedAccurately, accuracyNotes, incorrectClaims, recommendedCompetitors.",
     "describedAccurately must be one of: yes, no, unknown, not-mentioned.",
-    "recommendedCompetitors should list actual competitor brands or domains named in the answer, not generic directories unless that is the only thing recommended.",
+    "",
+    "CRITICAL \u2014 recommendedCompetitors extraction:",
+    "For each response, extract EVERY specific company/brand/product name that the AI recommended or listed as an alternative.",
+    'Include the company name exactly as it appears in the response (e.g. "Accenture", "Deloitte", "C3.ai").',
+    'Do NOT include generic terms like "consulting firms" or directories like "G2" or "Clutch".',
+    "Do NOT include the target company itself.",
+    "This is the most important field \u2014 it shows the prospect who AI recommends INSTEAD of them.",
     "",
     `Target company: ${ctx.companyName}`,
     `Target domain: ${ctx.domain}`,
@@ -13042,7 +14082,7 @@ function mentionsTargetCompany(answerText, companyName, domain) {
   if (targetTokens.length === 0) return false;
   let matches = 0;
   for (const token of targetTokens) {
-    if (new RegExp(`\\b${escapeRegExp(token)}\\b`, "i").test(answerText)) {
+    if (new RegExp(`\\b${escapeRegExp2(token)}\\b`, "i").test(answerText)) {
       matches++;
     }
   }
@@ -13128,7 +14168,10 @@ function normalizeStringList(values) {
   );
 }
 function uniqueStrings(values) {
-  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+  if (!Array.isArray(values)) return [];
+  return [...new Set(
+    values.filter((value) => typeof value === "string").map((value) => value.trim()).filter(Boolean)
+  )];
 }
 function normalizeDomain(value) {
   const trimmed = value.trim();
@@ -13159,7 +14202,7 @@ function clipText(value, length) {
   if (value.length <= length) return value;
   return `${value.slice(0, length - 3)}...`;
 }
-function escapeRegExp(value) {
+function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }